func toggle(handle *exec.Handle, connected bool) (*exec.Handle, error) {
// get the virtual device list
devices := object.VirtualDeviceList(handle.Config.Hardware.Device)
// select the virtual serial ports
serials := devices.SelectByBackingInfo((*types.VirtualSerialPortURIBackingInfo)(nil))
if len(serials) == 0 {
return nil, fmt.Errorf("Unable to bind a device with desired backing")
}
if len(serials) > 1 {
return nil, fmt.Errorf("Multiple matches found with desired backing")
}
serial := serials[0]
ip, err := lookupVCHIP()
if err != nil {
return nil, err
}
log.Debugf("Found a device with desired backing: %#v", serial)
c := serial.GetVirtualDevice().Connectable
b := serial.GetVirtualDevice().Backing.(*types.VirtualSerialPortURIBackingInfo)
serviceURI := fmt.Sprintf("tcp://%s:%d", ip, constants.SerialOverLANPort)
if b.ServiceURI == serviceURI && c.Connected == connected {
log.Debugf("Already in the desired state (connected: %t, serviceURI: %s)", connected, serviceURI)
return handle, nil
}
// set the values
log.Debugf("Setting Connected to %t", connected)
c.Connected = connected
if connected && handle.ExecConfig.Sessions[handle.ExecConfig.ID].Attach {
log.Debugf("Setting the start connected state to %t", connected)
c.StartConnected = handle.ExecConfig.Sessions[handle.ExecConfig.ID].Attach
}
log.Debugf("Setting ServiceURI to %s", serviceURI)
b.ServiceURI = serviceURI
config := &types.VirtualDeviceConfigSpec{
Device: serial,
Operation: types.VirtualDeviceConfigSpecOperationEdit,
}
handle.Spec.DeviceChange = append(handle.Spec.DeviceChange, config)
// iterate over Sessions and set their RunBlock property to connected
// if attach happens before start then this property will be persist in the vmx
// if attash happens after start then this propery will be thrown away by commit (one simply cannot change ExtraConfig if the vm is powered on)
for _, session := range handle.ExecConfig.Sessions {
session.RunBlock = connected
}
return handle, nil
}
func NewVirtualMachine(spec *types.VirtualMachineConfigSpec) (*VirtualMachine, types.BaseMethodFault) {
vm := &VirtualMachine{}
if spec.Name == "" {
return nil, &types.InvalidVmConfig{Property: "configSpec.name"}
}
if spec.Files == nil || spec.Files.VmPathName == "" {
return nil, &types.InvalidVmConfig{Property: "configSpec.files.vmPathName"}
}
vm.Config = &types.VirtualMachineConfigInfo{}
vm.Summary.Guest = &types.VirtualMachineGuestSummary{}
vm.Summary.Storage = &types.VirtualMachineStorageSummary{}
// Add the default devices
devices, _ := object.VirtualDeviceList(esx.VirtualDevice).ConfigSpec(types.VirtualDeviceConfigSpecOperationAdd)
if !strings.HasSuffix(spec.Files.VmPathName, ".vmx") {
spec.Files.VmPathName = path.Join(spec.Files.VmPathName, spec.Name+".vmx")
}
dsPath := path.Dir(spec.Files.VmPathName)
defaults := types.VirtualMachineConfigSpec{
NumCPUs: 1,
NumCoresPerSocket: 1,
MemoryMB: 32,
Uuid: uuid.New().String(),
Version: "vmx-11",
Files: &types.VirtualMachineFileInfo{
SnapshotDirectory: dsPath,
SuspendDirectory: dsPath,
LogDirectory: dsPath,
},
DeviceChange: devices,
}
err := vm.configure(&defaults)
if err != nil {
return nil, err
}
vm.Runtime.PowerState = types.VirtualMachinePowerStatePoweredOff
vm.Summary.Runtime = vm.Runtime
err = vm.configure(spec)
if err != nil {
return nil, err
}
return vm, nil
}
func (vm *VirtualMachine) configureDevices(spec *types.VirtualMachineConfigSpec) types.BaseMethodFault {
devices := object.VirtualDeviceList(vm.Config.Hardware.Device)
for i, change := range spec.DeviceChange {
dspec := change.GetVirtualDeviceConfigSpec()
device := dspec.Device.GetVirtualDevice()
invalid := &types.InvalidDeviceSpec{DeviceIndex: int32(i)}
switch dspec.Operation {
case types.VirtualDeviceConfigSpecOperationAdd:
if devices.FindByKey(device.Key) != nil {
return invalid
}
devices = append(devices, device)
}
}
vm.Config.Hardware.Device = []types.BaseVirtualDevice(devices)
return nil
}
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
}