← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/govmomi/govc/vm/create.go

  • Committer: Nicholas Skaggs
  • Date: 2016-10-24 20:56:05 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161024205605-z8lta0uvuhtxwzwl
Initi with beta15

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/govmomi/govc/vm/create.go
 
1
/*
 
2
Copyright (c) 2014 VMware, Inc. All Rights Reserved.
 
3
 
 
4
Licensed under the Apache License, Version 2.0 (the "License");
 
5
you may not use this file except in compliance with the License.
 
6
You may obtain a copy of the License at
 
7
 
 
8
    http://www.apache.org/licenses/LICENSE-2.0
 
9
 
 
10
Unless required by applicable law or agreed to in writing, software
 
11
distributed under the License is distributed on an "AS IS" BASIS,
 
12
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 
13
See the License for the specific language governing permissions and
 
14
limitations under the License.
 
15
*/
 
16
 
 
17
package vm
 
18
 
 
19
import (
 
20
        "flag"
 
21
        "fmt"
 
22
 
 
23
        "github.com/juju/govmomi/govc/cli"
 
24
        "github.com/juju/govmomi/govc/flags"
 
25
        "github.com/juju/govmomi/object"
 
26
        "github.com/juju/govmomi/vim25"
 
27
        "github.com/juju/govmomi/vim25/types"
 
28
        "golang.org/x/net/context"
 
29
)
 
30
 
 
31
type create struct {
 
32
        *flags.ClientFlag
 
33
        *flags.DatacenterFlag
 
34
        *flags.DatastoreFlag
 
35
        *flags.ResourcePoolFlag
 
36
        *flags.HostSystemFlag
 
37
        *flags.NetworkFlag
 
38
 
 
39
        memory     int
 
40
        cpus       int
 
41
        guestID    string
 
42
        link       bool
 
43
        on         bool
 
44
        force      bool
 
45
        iso        string
 
46
        disk       string
 
47
        controller string
 
48
 
 
49
        Client       *vim25.Client
 
50
        Datacenter   *object.Datacenter
 
51
        Datastore    *object.Datastore
 
52
        ResourcePool *object.ResourcePool
 
53
        HostSystem   *object.HostSystem
 
54
}
 
55
 
 
56
func init() {
 
57
        cli.Register("vm.create", &create{})
 
58
}
 
59
 
 
60
func (cmd *create) Register(f *flag.FlagSet) {
 
61
        f.IntVar(&cmd.memory, "m", 1024, "Size in MB of memory")
 
62
        f.IntVar(&cmd.cpus, "c", 1, "Number of CPUs")
 
63
        f.StringVar(&cmd.guestID, "g", "otherGuest", "Guest OS")
 
64
        f.BoolVar(&cmd.link, "link", true, "Link specified disk")
 
65
        f.BoolVar(&cmd.on, "on", true, "Power on VM. Default is true if -disk argument is given.")
 
66
        f.BoolVar(&cmd.force, "force", false, "Create VM if vmx already exists")
 
67
        f.StringVar(&cmd.iso, "iso", "", "Path to ISO")
 
68
        f.StringVar(&cmd.controller, "disk.controller", "scsi", "Disk controller type")
 
69
        f.StringVar(&cmd.disk, "disk", "", "Disk path name")
 
70
}
 
71
 
 
72
func (cmd *create) Process() error { return nil }
 
73
 
 
74
func (cmd *create) Run(f *flag.FlagSet) error {
 
75
        var err error
 
76
 
 
77
        if len(f.Args()) != 1 {
 
78
                return flag.ErrHelp
 
79
        }
 
80
 
 
81
        cmd.Client, err = cmd.ClientFlag.Client()
 
82
        if err != nil {
 
83
                return err
 
84
        }
 
85
 
 
86
        cmd.Datacenter, err = cmd.DatacenterFlag.Datacenter()
 
87
        if err != nil {
 
88
                return err
 
89
        }
 
90
 
 
91
        cmd.Datastore, err = cmd.DatastoreFlag.Datastore()
 
92
        if err != nil {
 
93
                return err
 
94
        }
 
95
 
 
96
        cmd.HostSystem, err = cmd.HostSystemFlag.HostSystemIfSpecified()
 
97
        if err != nil {
 
98
                return err
 
99
        }
 
100
 
 
101
        if cmd.HostSystem != nil {
 
102
                if cmd.ResourcePool, err = cmd.HostSystem.ResourcePool(context.TODO()); err != nil {
 
103
                        return err
 
104
                }
 
105
        } else {
 
106
                // -host is optional
 
107
                if cmd.ResourcePool, err = cmd.ResourcePoolFlag.ResourcePool(); err != nil {
 
108
                        return err
 
109
                }
 
110
        }
 
111
 
 
112
        for _, file := range []*string{&cmd.iso, &cmd.disk} {
 
113
                if *file != "" {
 
114
                        _, err = cmd.Stat(*file)
 
115
                        if err != nil {
 
116
                                return err
 
117
                        }
 
118
                }
 
119
        }
 
120
 
 
121
        task, err := cmd.createVM(f.Arg(0))
 
122
        if err != nil {
 
123
                return err
 
124
        }
 
125
 
 
126
        info, err := task.WaitForResult(context.TODO(), nil)
 
127
        if err != nil {
 
128
                return err
 
129
        }
 
130
 
 
131
        vm := object.NewVirtualMachine(cmd.Client, info.Result.(types.ManagedObjectReference))
 
132
 
 
133
        if err := cmd.addDevices(vm); err != nil {
 
134
                return err
 
135
        }
 
136
 
 
137
        if cmd.on {
 
138
                task, err := vm.PowerOn(context.TODO())
 
139
                if err != nil {
 
140
                        return err
 
141
                }
 
142
 
 
143
                _, err = task.WaitForResult(context.TODO(), nil)
 
144
                if err != nil {
 
145
                        return err
 
146
                }
 
147
        }
 
148
 
 
149
        return nil
 
150
}
 
151
 
 
152
func (cmd *create) addDevices(vm *object.VirtualMachine) error {
 
153
        devices, err := vm.Device(context.TODO())
 
154
        if err != nil {
 
155
                return err
 
156
        }
 
157
 
 
158
        var add []types.BaseVirtualDevice
 
159
 
 
160
        if cmd.disk != "" {
 
161
                controller, err := devices.FindDiskController(cmd.controller)
 
162
                if err != nil {
 
163
                        return err
 
164
                }
 
165
 
 
166
                disk := devices.CreateDisk(controller, cmd.Datastore.Path(cmd.disk))
 
167
 
 
168
                if cmd.link {
 
169
                        disk = devices.ChildDisk(disk)
 
170
                }
 
171
 
 
172
                add = append(add, disk)
 
173
        }
 
174
 
 
175
        if cmd.iso != "" {
 
176
                ide, err := devices.FindIDEController("")
 
177
                if err != nil {
 
178
                        return err
 
179
                }
 
180
 
 
181
                cdrom, err := devices.CreateCdrom(ide)
 
182
                if err != nil {
 
183
                        return err
 
184
                }
 
185
 
 
186
                add = append(add, devices.InsertIso(cdrom, cmd.Datastore.Path(cmd.iso)))
 
187
        }
 
188
 
 
189
        netdev, err := cmd.NetworkFlag.Device()
 
190
        if err != nil {
 
191
                return err
 
192
        }
 
193
 
 
194
        add = append(add, netdev)
 
195
 
 
196
        return vm.AddDevice(context.TODO(), add...)
 
197
}
 
198
 
 
199
func (cmd *create) createVM(name string) (*object.Task, error) {
 
200
        spec := types.VirtualMachineConfigSpec{
 
201
                Name:     name,
 
202
                GuestId:  cmd.guestID,
 
203
                Files:    &types.VirtualMachineFileInfo{VmPathName: fmt.Sprintf("[%s]", cmd.Datastore.Name())},
 
204
                NumCPUs:  cmd.cpus,
 
205
                MemoryMB: int64(cmd.memory),
 
206
        }
 
207
 
 
208
        if !cmd.force {
 
209
                vmxPath := fmt.Sprintf("%s/%s.vmx", name, name)
 
210
 
 
211
                _, err := cmd.Stat(vmxPath)
 
212
                if err == nil {
 
213
                        dsPath := cmd.Datastore.Path(vmxPath)
 
214
                        return nil, fmt.Errorf("File %s already exists", dsPath)
 
215
                }
 
216
        }
 
217
 
 
218
        if cmd.controller != "ide" {
 
219
                scsi, err := object.SCSIControllerTypes().CreateSCSIController(cmd.controller)
 
220
                if err != nil {
 
221
                        return nil, err
 
222
                }
 
223
 
 
224
                spec.DeviceChange = append(spec.DeviceChange, &types.VirtualDeviceConfigSpec{
 
225
                        Operation: types.VirtualDeviceConfigSpecOperationAdd,
 
226
                        Device:    scsi,
 
227
                })
 
228
        }
 
229
 
 
230
        folders, err := cmd.Datacenter.Folders(context.TODO())
 
231
        if err != nil {
 
232
                return nil, err
 
233
        }
 
234
 
 
235
        return folders.VmFolder.CreateVM(context.TODO(), spec, cmd.ResourcePool, cmd.HostSystem)
 
236
}