func (m *Manager) Attach(op trace.Operation, disk *types.VirtualDisk) error {
deviceList := object.VirtualDeviceList{}
deviceList = append(deviceList, disk)
changeSpec, err := deviceList.ConfigSpec(types.VirtualDeviceConfigSpecOperationAdd)
if err != nil {
return err
}
machineSpec := types.VirtualMachineConfigSpec{}
machineSpec.DeviceChange = append(machineSpec.DeviceChange, changeSpec...)
m.reconfig.Lock()
_, err = m.vm.WaitForResult(op, func(ctx context.Context) (tasks.Task, error) {
t, er := m.vm.Reconfigure(ctx, machineSpec)
op.Debugf("Attach reconfigure task=%s", t.Reference())
return t, er
})
m.reconfig.Unlock()
if err != nil {
op.Errorf("vmdk storage driver failed to attach disk: %s", errors.ErrorStack(err))
return errors.Trace(err)
}
return nil
}
func (d *Dispatcher) configIso(conf *metadata.VirtualContainerHostConfigSpec, vm *vm.VirtualMachine) (object.VirtualDeviceList, error) {
defer trace.End(trace.Begin(""))
var devices object.VirtualDeviceList
var err error
vmDevices, err := vm.Device(d.ctx)
if err != nil {
log.Errorf("Failed to get vm devices for appliance: %s", err)
return nil, err
}
ide, err := vmDevices.FindIDEController("")
if err != nil {
log.Errorf("Failed to find IDE controller for appliance: %s", err)
return nil, err
}
cdrom, err := devices.CreateCdrom(ide)
if err != nil {
log.Errorf("Failed to create Cdrom device for appliance: %s", err)
return nil, err
}
cdrom = devices.InsertIso(cdrom, fmt.Sprintf("[%s] %s/appliance.iso", conf.ImageStores[0].Host, d.vmPathName))
devices = append(devices, cdrom)
return devices, nil
}
func (s *VirtualMachineConfigSpec) FindNICs(ctx context.Context, network object.NetworkReference) ([]types.BaseVirtualDeviceConfigSpec, error) {
if network == nil {
return nil, fmt.Errorf("no network provided")
}
backing, err := network.EthernetCardBackingInfo(ctx)
if err != nil {
return nil, err
}
var dcs []types.BaseVirtualDeviceConfigSpec
for _, d := range s.DeviceChange {
dev := d.GetVirtualDeviceConfigSpec().Device
if _, ok := dev.(types.BaseVirtualEthernetCard); ok {
var dl object.VirtualDeviceList
dl = append(dl, dev)
dl = dl.SelectByBackingInfo(backing)
if len(dl) > 0 {
dcs = append(dcs, d)
}
}
}
return dcs, nil
}
func (d *Dispatcher) reconfigureApplianceSpec(vm *vm.VirtualMachine, conf *metadata.VirtualContainerHostConfigSpec) (*types.VirtualMachineConfigSpec, error) {
defer trace.End(trace.Begin(""))
var devices object.VirtualDeviceList
var err error
spec := &types.VirtualMachineConfigSpec{
Name: conf.Name,
GuestId: "other3xLinux64Guest",
Files: &types.VirtualMachineFileInfo{VmPathName: fmt.Sprintf("[%s]", conf.ImageStores[0].Host)},
}
if devices, err = d.configIso(conf, vm); err != nil {
return nil, err
}
deviceChange, err := devices.ConfigSpec(types.VirtualDeviceConfigSpecOperationAdd)
if err != nil {
log.Errorf("Failed to create config spec for appliance: %s", err)
return nil, err
}
spec.DeviceChange = deviceChange
cfg := make(map[string]string)
extraconfig.Encode(extraconfig.MapSink(cfg), conf)
spec.ExtraConfig = append(spec.ExtraConfig, extraconfig.OptionValueFromMap(cfg)...)
return spec, nil
}
func (cmd *create) createVM(ctx context.Context) (*object.Task, error) {
var devices object.VirtualDeviceList
var err error
spec := &types.VirtualMachineConfigSpec{
Name: cmd.name,
GuestId: cmd.guestID,
NumCPUs: int32(cmd.cpus),
MemoryMB: int64(cmd.memory),
}
devices, err = cmd.addStorage(nil)
if err != nil {
return nil, err
}
devices, err = cmd.addNetwork(devices)
if err != nil {
return nil, err
}
deviceChange, err := devices.ConfigSpec(types.VirtualDeviceConfigSpecOperationAdd)
if err != nil {
return nil, err
}
spec.DeviceChange = deviceChange
var datastore *object.Datastore
// If storage pod is specified, collect placement recommendations
if cmd.StoragePod != nil {
datastore, err = cmd.recommendDatastore(ctx, spec)
if err != nil {
return nil, err
}
} else {
datastore = cmd.Datastore
}
if !cmd.force {
vmxPath := fmt.Sprintf("%s/%s.vmx", cmd.name, cmd.name)
_, err := datastore.Stat(ctx, vmxPath)
if err == nil {
dsPath := cmd.Datastore.Path(vmxPath)
return nil, fmt.Errorf("File %s already exists", dsPath)
}
}
folder := cmd.Folder
spec.Files = &types.VirtualMachineFileInfo{
VmPathName: fmt.Sprintf("[%s]", datastore.Name()),
}
return folder.CreateVM(ctx, *spec, cmd.ResourcePool, cmd.HostSystem)
}
func (d *Dispatcher) addNetworkDevices(conf *metadata.VirtualContainerHostConfigSpec, cspec *spec.VirtualMachineConfigSpec, devices object.VirtualDeviceList) (object.VirtualDeviceList, error) {
defer trace.End(trace.Begin(""))
// network name:alias, to avoid create multiple devices for same network
slots := make(map[int32]bool)
nets := make(map[string]*metadata.NetworkEndpoint)
for name, endpoint := range conf.ExecutorConfig.Networks {
if pnic, ok := nets[endpoint.Network.Common.ID]; ok {
// there's already a NIC on this network
endpoint.Common.ID = pnic.Common.ID
log.Infof("Network role %s is sharing NIC with %s", name, pnic.Network.Common.Name)
continue
}
moref := new(types.ManagedObjectReference)
if ok := moref.FromString(endpoint.Network.ID); !ok {
return nil, fmt.Errorf("serialized managed object reference in unexpected format: %s", endpoint.Network.ID)
}
obj, err := d.session.Finder.ObjectReference(d.ctx, *moref)
if err != nil {
return nil, fmt.Errorf("unable to reacquire reference for network %s from serialized form: %s", endpoint.Network.Name, endpoint.Network.ID)
}
network, ok := obj.(object.NetworkReference)
if !ok {
return nil, fmt.Errorf("reacquired reference for network %s, from serialized form %s, was not a network: %T", endpoint.Network.Name, endpoint.Network.ID, obj)
}
backing, err := network.EthernetCardBackingInfo(d.ctx)
if err != nil {
err = errors.Errorf("Failed to get network backing info for %s: %s", network, err)
return nil, err
}
nic, err := devices.CreateEthernetCard("vmxnet3", backing)
if err != nil {
err = errors.Errorf("Failed to create Ethernet Card spec for %s", err)
return nil, err
}
slot := cspec.AssignSlotNumber(nic, slots)
if slot == spec.NilSlot {
err = errors.Errorf("Failed to assign stable PCI slot for %s network card", name)
}
endpoint.Common.ID = strconv.Itoa(int(slot))
slots[slot] = true
log.Debugf("Setting %s to slot %d", name, slot)
devices = append(devices, nic)
nets[endpoint.Network.Common.ID] = endpoint
}
return devices, nil
}
// Returns key of the controller.
// Key is unique id that distinguishes one device from other devices in the same virtual machine.
func getControllerKey(scsiType string, vmDevices object.VirtualDeviceList, dc *object.Datacenter, client *govmomi.Client) (int32, error) {
for _, device := range vmDevices {
devType := vmDevices.Type(device)
if devType == scsiType {
if c, ok := device.(types.BaseVirtualController); ok {
return c.GetVirtualController().Key, nil
}
}
}
return -1, ErrNoDevicesFound
}
func (d *Dispatcher) addIDEController(devices object.VirtualDeviceList) (object.VirtualDeviceList, error) {
defer trace.End(trace.Begin(""))
// IDE controller
scsi, err := devices.CreateIDEController()
if err != nil {
return nil, err
}
devices = append(devices, scsi)
return devices, nil
}
func (d *Dispatcher) addParaVirtualSCSIController(devices object.VirtualDeviceList) (object.VirtualDeviceList, error) {
defer trace.End(trace.Begin(""))
// para virtual SCSI controller
scsi, err := devices.CreateSCSIController("pvscsi")
if err != nil {
return nil, err
}
devices = append(devices, scsi)
return devices, nil
}
func getSCSIController(vmDevices object.VirtualDeviceList, scsiType string) *types.VirtualController {
// get virtual scsi controller of passed argument type
for _, device := range vmDevices {
devType := vmDevices.Type(device)
if devType == scsiType {
if c, ok := device.(types.BaseVirtualController); ok {
return c.GetVirtualController()
}
}
}
return nil
}
// Removes SCSI controller which is latest attached to VM.
func cleanUpController(newSCSIController types.BaseVirtualDevice, vmDevices object.VirtualDeviceList, vm *object.VirtualMachine, ctx context.Context) error {
ctls := vmDevices.SelectByType(newSCSIController)
if len(ctls) < 1 {
return ErrNoDevicesFound
}
newScsi := ctls[len(ctls)-1]
err := vm.RemoveDevice(ctx, true, newScsi)
if err != nil {
return err
}
return nil
}
func getSCSIControllersOfType(vmDevices object.VirtualDeviceList, scsiType string) []*types.VirtualController {
// get virtual scsi controllers of passed argument type
var scsiControllers []*types.VirtualController
for _, device := range vmDevices {
devType := vmDevices.Type(device)
if devType == scsiType {
if c, ok := device.(types.BaseVirtualController); ok {
scsiControllers = append(scsiControllers, c.GetVirtualController())
}
}
}
return scsiControllers
}
func getSCSIControllers(vmDevices object.VirtualDeviceList) []*types.VirtualController {
// get all virtual scsi controllers
var scsiControllers []*types.VirtualController
for _, device := range vmDevices {
devType := vmDevices.Type(device)
switch devType {
case SCSIControllerType, strings.ToLower(LSILogicControllerType), strings.ToLower(BusLogicControllerType), PVSCSIControllerType, strings.ToLower(LSILogicSASControllerType):
if c, ok := device.(types.BaseVirtualController); ok {
scsiControllers = append(scsiControllers, c.GetVirtualController())
}
}
}
return scsiControllers
}
func getVirtualDiskID(volPath string, vmDevices object.VirtualDeviceList) (string, error) {
// filter vm devices to retrieve disk ID for the given vmdk file
for _, device := range vmDevices {
if vmDevices.TypeName(device) == "VirtualDisk" {
d := device.GetVirtualDevice()
if b, ok := d.Backing.(types.BaseVirtualDeviceFileBackingInfo); ok {
fileName := b.GetVirtualDeviceFileBackingInfo().FileName
if fileName == volPath {
return vmDevices.Name(device), nil
}
}
}
}
return "", ErrNoDiskIDFound
}
func (cmd *create) createVM(ctx context.Context) (*object.Task, error) {
var devices object.VirtualDeviceList
var err error
spec := types.VirtualMachineConfigSpec{
Name: cmd.name,
GuestId: cmd.guestID,
Files: &types.VirtualMachineFileInfo{VmPathName: fmt.Sprintf("[%s]", cmd.Datastore.Name())},
NumCPUs: cmd.cpus,
MemoryMB: int64(cmd.memory),
}
devices, err = cmd.addStorage(nil)
if err != nil {
return nil, err
}
devices, err = cmd.addNetwork(devices)
if err != nil {
return nil, err
}
deviceChange, err := devices.ConfigSpec(types.VirtualDeviceConfigSpecOperationAdd)
if err != nil {
return nil, err
}
spec.DeviceChange = deviceChange
if !cmd.force {
vmxPath := fmt.Sprintf("%s/%s.vmx", cmd.name, cmd.name)
_, err := cmd.Datastore.Stat(ctx, vmxPath)
if err == nil {
dsPath := cmd.Datastore.Path(vmxPath)
return nil, fmt.Errorf("File %s already exists", dsPath)
}
}
folders, err := cmd.Datacenter.Folders(ctx)
if err != nil {
return nil, err
}
return folders.VmFolder.CreateVM(ctx, spec, cmd.ResourcePool, cmd.HostSystem)
}
func (d *Dispatcher) createApplianceSpec(conf *config.VirtualContainerHostConfigSpec, vConf *data.InstallerData) (*types.VirtualMachineConfigSpec, error) {
defer trace.End(trace.Begin(""))
var devices object.VirtualDeviceList
var err error
cfg, err := d.encodeConfig(conf)
if err != nil {
return nil, err
}
spec := &spec.VirtualMachineConfigSpec{
VirtualMachineConfigSpec: &types.VirtualMachineConfigSpec{
Name: conf.Name,
GuestId: "other3xLinux64Guest",
Files: &types.VirtualMachineFileInfo{VmPathName: fmt.Sprintf("[%s]", conf.ImageStores[0].Host)},
NumCPUs: int32(vConf.ApplianceSize.CPU.Limit),
MemoryMB: vConf.ApplianceSize.Memory.Limit,
// Encode the config both here and after the VMs created so that it can be identified as a VCH appliance as soon as
// creation is complete.
ExtraConfig: vmomi.OptionValueFromMap(cfg),
},
}
if devices, err = d.addIDEController(devices); err != nil {
return nil, err
}
if devices, err = d.addParaVirtualSCSIController(devices); err != nil {
return nil, err
}
if devices, err = d.addNetworkDevices(conf, spec, devices); err != nil {
return nil, err
}
deviceChange, err := devices.ConfigSpec(types.VirtualDeviceConfigSpecOperationAdd)
if err != nil {
return nil, err
}
spec.DeviceChange = deviceChange
return spec.VirtualMachineConfigSpec, nil
}
// Returns a device id which is internal vSphere API identifier for the attached virtual disk.
func getVirtualDiskID(volPath string, vmDevices object.VirtualDeviceList, dc *object.Datacenter, client *govmomi.Client) (string, error) {
volumeUUID, err := getVirtualDiskUUIDByPath(volPath, dc, client)
if err != nil {
glog.Warningf("disk uuid not found for %v ", volPath)
return "", err
}
// filter vm devices to retrieve disk ID for the given vmdk file
for _, device := range vmDevices {
if vmDevices.TypeName(device) == "VirtualDisk" {
diskUUID, _ := getVirtualDiskUUID(device)
if diskUUID == volumeUUID {
return vmDevices.Name(device), nil
}
}
}
return "", ErrNoDiskIDFound
}
// Returns the object key that denotes the controller object to which vmdk is attached.
func getVirtualDiskControllerKey(volPath string, vmDevices object.VirtualDeviceList, dc *object.Datacenter, client *govmomi.Client) (int32, error) {
volumeUUID, err := getVirtualDiskUUIDByPath(volPath, dc, client)
if err != nil {
glog.Errorf("disk uuid not found for %v. err: %s", volPath, err)
return -1, err
}
// filter vm devices to retrieve disk ID for the given vmdk file
for _, device := range vmDevices {
if vmDevices.TypeName(device) == "VirtualDisk" {
diskUUID, _ := getVirtualDiskUUID(device)
if diskUUID == volumeUUID {
return device.GetVirtualDevice().ControllerKey, nil
}
}
}
return -1, ErrNoDevicesFound
}
func (cmd *info) match(p string, devices object.VirtualDeviceList) object.VirtualDeviceList {
var matches object.VirtualDeviceList
match := func(name string) bool {
matched, _ := filepath.Match(p, name)
return matched
}
for _, device := range devices {
name := devices.Name(device)
eq := name == p
if eq || match(name) {
matches = append(matches, device)
}
if eq {
break
}
}
return matches
}
func (d *Dispatcher) switchISO(filePath string) ([]types.BaseVirtualDeviceConfigSpec, error) {
defer trace.End(trace.Begin(filePath))
var devices object.VirtualDeviceList
var err error
log.Infof("Switching appliance iso to %s", filePath)
devices, err = d.appliance.Device(d.ctx)
if err != nil {
log.Errorf("Failed to get vm devices for appliance: %s", err)
return nil, err
}
// find the single cdrom
cd, err := devices.FindCdrom("")
if err != nil {
log.Errorf("Failed to get CD rom device from appliance: %s", err)
return nil, err
}
oldApplianceISO := cd.Backing.(*types.VirtualCdromIsoBackingInfo).FileName
if oldApplianceISO == filePath {
log.Debugf("Target file name %q is same to old one, no need to change.")
return nil, nil
}
cd = devices.InsertIso(cd, filePath)
changedDevices := object.VirtualDeviceList([]types.BaseVirtualDevice{cd})
deviceChange, err := changedDevices.ConfigSpec(types.VirtualDeviceConfigSpecOperationEdit)
if err != nil {
log.Errorf("Failed to create config spec for appliance: %s", err)
return nil, err
}
d.oldApplianceISO = oldApplianceISO
return deviceChange, nil
}
func (c *configSpec) AddDisk(ds *object.Datastore, path string) {
var devices object.VirtualDeviceList
controller, err := devices.CreateSCSIController("")
if err != nil {
panic(err)
}
devices = append(devices, controller)
disk := devices.CreateDisk(controller.(types.BaseVirtualController), ds.Reference(), ds.Path(path))
devices = append(devices, disk)
spec, err := devices.ConfigSpec(types.VirtualDeviceConfigSpecOperationAdd)
if err != nil {
panic(err)
}
c.DeviceChange = append(c.DeviceChange, spec...)
}
for _, a := range aliases {
delete(c.containers, a)
}
// long id
delete(c.containers, con.ID().String())
// short id
delete(c.containers, con.ID().Truncate().String())
// name
delete(c.containers, con.Name())
return endpoints, nil
}
var addEthernetCard = func(h *exec.Handle, s *Scope) (types.BaseVirtualDevice, error) {
var devices object.VirtualDeviceList
var d types.BaseVirtualDevice
var dc types.BaseVirtualDeviceConfigSpec
ctx := context.Background()
dcs, err := h.Spec.FindNICs(ctx, s.Network())
if err != nil {
return nil, err
}
for _, ds := range dcs {
if ds.GetVirtualDeviceConfigSpec().Operation == types.VirtualDeviceConfigSpecOperationAdd {
d = ds.GetVirtualDeviceConfigSpec().Device
dc = ds
break
}
func TestContextAddContainer(t *testing.T) {
ctx, err := NewContext(net.IPNet{IP: net.IPv4(172, 16, 0, 0), Mask: net.CIDRMask(12, 32)}, net.CIDRMask(16, 32))
if err != nil {
t.Fatalf("NewContext() => (nil, %s), want (ctx, nil)", err)
return
}
h := exec.NewContainer("foo")
var devices object.VirtualDeviceList
backing, _ := ctx.DefaultScope().Network().EthernetCardBackingInfo(context.TODO())
specWithEthCard := &spec.VirtualMachineConfigSpec{
VirtualMachineConfigSpec: &types.VirtualMachineConfigSpec{},
}
var d types.BaseVirtualDevice
if d, err = devices.CreateEthernetCard("vmxnet3", backing); err == nil {
d.GetVirtualDevice().SlotInfo = &types.VirtualDevicePciBusSlotInfo{
PciSlotNumber: 1111,
}
devices = append(devices, d)
var cs []types.BaseVirtualDeviceConfigSpec
if cs, err = devices.ConfigSpec(types.VirtualDeviceConfigSpecOperationAdd); err == nil {
specWithEthCard.DeviceChange = cs
}
}
if err != nil {
t.Fatalf(err.Error())
}
aecErr := func(_ *exec.Handle, _ *Scope) (types.BaseVirtualDevice, error) {
return nil, fmt.Errorf("error")
}
otherScope, err := ctx.NewScope(BridgeScopeType, "other", nil, net.IPv4(0, 0, 0, 0), nil, nil)
if err != nil {
t.Fatalf("failed to add scope")
}
hBar := exec.NewContainer(uid.New())
var tests = []struct {
aec func(h *exec.Handle, s *Scope) (types.BaseVirtualDevice, error)
h *exec.Handle
s *spec.VirtualMachineConfigSpec
scope string
ip *net.IP
err error
}{
// nil handle
{nil, nil, nil, "", nil, fmt.Errorf("")},
// scope not found
{nil, h, nil, "foo", nil, ResourceNotFoundError{}},
// addEthernetCard returns error
{aecErr, h, nil, "default", nil, fmt.Errorf("")},
// add a container
{nil, h, nil, "default", nil, nil},
// container already added
{nil, h, nil, "default", nil, nil},
{nil, hBar, specWithEthCard, "default", nil, nil},
{nil, hBar, nil, otherScope.Name(), nil, nil},
}
origAEC := addEthernetCard
defer func() { addEthernetCard = origAEC }()
for i, te := range tests {
// setup
addEthernetCard = origAEC
scopy := &spec.VirtualMachineConfigSpec{}
if te.h != nil {
te.h.SetSpec(te.s)
if te.h.Spec != nil {
*scopy = *te.h.Spec
}
}
if te.aec != nil {
addEthernetCard = te.aec
}
options := &AddContainerOptions{
Scope: te.scope,
IP: te.ip,
}
err := ctx.AddContainer(te.h, options)
if te.err != nil {
// expect an error
if err == nil {
t.Fatalf("case %d: ctx.AddContainer(%v, %s, %s) => nil want err", i, te.h, te.scope, te.ip)
}
if reflect.TypeOf(err) != reflect.TypeOf(te.err) {
t.Fatalf("case %d: ctx.AddContainer(%v, %s, %s) => (%v, %v) want (%v, %v)", i, te.h, te.scope, te.ip, err, te.err, err, te.err)
}
if _, ok := te.err.(DuplicateResourceError); ok {
continue
}
// verify no device changes in the spec
if te.s != nil {
if len(scopy.DeviceChange) != len(h.Spec.DeviceChange) {
t.Fatalf("case %d: ctx.AddContainer(%v, %s, %s) added device", i, te.h, te.scope, te.ip)
}
}
continue
}
if err != nil {
t.Fatalf("case %d: ctx.AddContainer(%v, %s, %s) => %s want nil", i, te.h, te.scope, te.ip, err)
}
// verify the container was not added to the scope
s, _ := ctx.resolveScope(te.scope)
if s != nil && te.h != nil {
c := s.Container(uid.Parse(te.h.Container.ExecConfig.ID))
if c != nil {
t.Fatalf("case %d: ctx.AddContainer(%v, %s, %s) added container", i, te.h, te.scope, te.ip)
}
}
// spec should have a nic attached to the scope's network
var dev types.BaseVirtualDevice
dcs, err := te.h.Spec.FindNICs(context.TODO(), s.Network())
if len(dcs) != 1 {
t.Fatalf("case %d: ctx.AddContainer(%v, %s, %s) more than one NIC added for scope %s", i, te.h, te.scope, te.ip, s.Network())
}
dev = dcs[0].GetVirtualDeviceConfigSpec().Device
if spec.VirtualDeviceSlotNumber(dev) == spec.NilSlot {
t.Fatalf("case %d: ctx.AddContainer(%v, %s, %s) NIC added has nil pci slot", i, te.h, te.scope, te.ip)
}
// spec metadata should be updated with endpoint info
ne, ok := te.h.ExecConfig.Networks[s.Name()]
if !ok {
t.Fatalf("case %d: ctx.AddContainer(%v, %s, %s) no network endpoint info added", i, te.h, te.scope, te.ip)
}
if spec.VirtualDeviceSlotNumber(dev) != atoiOrZero(ne.ID) {
t.Fatalf("case %d; ctx.AddContainer(%v, %s, %s) => ne.ID == %d, want %d", i, te.h, te.scope, te.ip, atoiOrZero(ne.ID), spec.VirtualDeviceSlotNumber(dev))
}
if ne.Network.Name != s.Name() {
t.Fatalf("case %d; ctx.AddContainer(%v, %s, %s) => ne.NetworkName == %s, want %s", i, te.h, te.scope, te.ip, ne.Network.Name, s.Name())
}
if te.ip != nil && !te.ip.Equal(ne.Static.IP) {
t.Fatalf("case %d; ctx.AddContainer(%v, %s, %s) => ne.Static.IP == %s, want %s", i, te.h, te.scope, te.ip, ne.Static.IP, te.ip)
}
if te.ip == nil && ne.Static != nil {
t.Fatalf("case %d; ctx.AddContainer(%v, %s, %s) => ne.Static.IP == %s, want %s", i, te.h, te.scope, te.ip, ne.Static.IP, net.IPv4zero)
}
}
}
func (cmd *create) addStorage(devices object.VirtualDeviceList) (object.VirtualDeviceList, error) {
if cmd.controller != "ide" {
scsi, err := devices.CreateSCSIController(cmd.controller)
if err != nil {
return nil, err
}
devices = append(devices, scsi)
cmd.controller = devices.Name(scsi)
}
// If controller is specified to be IDE or if an ISO is specified, add IDE controller.
if cmd.controller == "ide" || cmd.iso != "" {
ide, err := devices.CreateIDEController()
if err != nil {
return nil, err
}
devices = append(devices, ide)
}
if cmd.diskByteSize != 0 {
controller, err := devices.FindDiskController(cmd.controller)
if err != nil {
return nil, err
}
disk := &types.VirtualDisk{
VirtualDevice: types.VirtualDevice{
Key: devices.NewKey(),
Backing: &types.VirtualDiskFlatVer2BackingInfo{
DiskMode: string(types.VirtualDiskModePersistent),
ThinProvisioned: types.NewBool(true),
},
},
CapacityInKB: cmd.diskByteSize / 1024,
}
devices.AssignController(disk, controller)
devices = append(devices, disk)
} else if cmd.disk != "" {
controller, err := devices.FindDiskController(cmd.controller)
if err != nil {
return nil, err
}
ds := cmd.diskDatastore.Reference()
path := cmd.diskDatastore.Path(cmd.disk)
disk := devices.CreateDisk(controller, ds, path)
if cmd.link {
disk = devices.ChildDisk(disk)
}
devices = append(devices, disk)
}
if cmd.iso != "" {
ide, err := devices.FindIDEController("")
if err != nil {
return nil, err
}
cdrom, err := devices.CreateCdrom(ide)
if err != nil {
return nil, err
}
cdrom = devices.InsertIso(cdrom, cmd.isoDatastore.Path(cmd.iso))
devices = append(devices, cdrom)
}
return devices, nil
}
func (cmd *create) addStorage(devices object.VirtualDeviceList) (object.VirtualDeviceList, error) {
if cmd.controller != "ide" {
scsi, err := devices.CreateSCSIController(cmd.controller)
if err != nil {
return nil, err
}
devices = append(devices, scsi)
}
// If controller is specified to be IDE or if an ISO is specified, add IDE controller.
if cmd.controller == "ide" || cmd.iso != "" {
ide, err := devices.CreateIDEController()
if err != nil {
return nil, err
}
devices = append(devices, ide)
}
if cmd.disk != "" {
controller, err := devices.FindDiskController(cmd.controller)
if err != nil {
return nil, err
}
ds := cmd.diskDatastore.Reference()
path := cmd.diskDatastore.Path(cmd.disk)
disk := devices.CreateDisk(controller, ds, path)
if cmd.link {
disk = devices.ChildDisk(disk)
}
devices = append(devices, disk)
}
if cmd.iso != "" {
ide, err := devices.FindIDEController("")
if err != nil {
return nil, err
}
cdrom, err := devices.CreateCdrom(ide)
if err != nil {
return nil, err
}
cdrom = devices.InsertIso(cdrom, cmd.isoDatastore.Path(cmd.iso))
devices = append(devices, cdrom)
}
return devices, nil
}
func (c *Context) RemoveContainer(h *exec.Handle, scope string) error {
defer trace.End(trace.Begin(""))
c.Lock()
defer c.Unlock()
if h == nil {
return fmt.Errorf("handle is required")
}
if con, _ := c.container(h); con != nil {
return fmt.Errorf("container is bound")
}
var err error
s, err := c.resolveScope(scope)
if err != nil {
return err
}
var ne *executor.NetworkEndpoint
ne, ok := h.ExecConfig.Networks[s.Name()]
if !ok {
return fmt.Errorf("container %s not part of network %s", h.ExecConfig.ID, s.Name())
}
// figure out if any other networks are using the NIC
removeNIC := true
for _, ne2 := range h.ExecConfig.Networks {
if ne2 == ne {
continue
}
if ne2.ID == ne.ID {
removeNIC = false
break
}
}
if removeNIC {
var devices object.VirtualDeviceList
backing, err := s.network.EthernetCardBackingInfo(context.Background())
if err != nil {
return err
}
d, err := devices.CreateEthernetCard("vmxnet3", backing)
if err != nil {
return err
}
devices = append(devices, d)
spec, err := devices.ConfigSpec(types.VirtualDeviceConfigSpecOperationRemove)
if err != nil {
return err
}
h.Spec.DeviceChange = append(h.Spec.DeviceChange, spec...)
}
delete(h.ExecConfig.Networks, s.Name())
return nil
}