def revert(vmname): context = None if inputs['ignore_ssl'] and hasattr(ssl, "_create_unverified_context"): context = ssl._create_unverified_context() si = connect.Connect(inputs['vcenter_ip'], 443, inputs['vcenter_user'], inputs['vcenter_password'], sslContext=context) atexit.register(Disconnect, si) content = si.RetrieveContent() vm_name = vmname vm = get_obj(content, [vim.VirtualMachine], vm_name) if not vm: raise Exception("Virtual Machine %s doesn't exists" % vm_name) snapshot_name = inputs['snapshot_name'] snap_obj = get_snapshots_by_name_recursively( vm.snapshot.rootSnapshotList, snapshot_name) if len(snap_obj) == 1: snap_obj = snap_obj[0].snapshot WaitForTask(snap_obj.RevertToSnapshot_Task()) WaitForTask(vm.PowerOn()) else: raise Exception(("No snapshots found with name: %s on VM: %s" % (snapshot_name, vm.name))) return
def main(): supportedArgs = [(["s:", "host="], "localhost", "host name", "host"), (["u:", "user="******"root", "User name", "user"), (["p:", "pwd="], "", "Password", "pwd")] supportedToggles = [(["usage", "help"], False, "Show usage information", "usage")] args = Arguments(sys.argv, supportedArgs, supportedToggles) if args.GetKeyValue("usage"): args.Usage() sys.exit(0) si = SmartConnect(host=args.GetKeyValue('host'), user=args.GetKeyValue('user'), pwd=args.GetKeyValue('pwd')) vm = CreateQuickDummy('vm-for-hostlog', numScsiDisks=1) try: disk = CheckDevice(vm.config, vim.vm.device.VirtualDisk)[0] diskName = disk.backing.fileName for dsUrl in vm.config.datastoreUrl: diskName = diskName.replace('[%s] ' % dsUrl.name, dsUrl.url + '/') hostlogOption = vim.option.OptionValue(key='migrate.hostlog', value=diskName) spec = vim.vm.ConfigSpec(extraConfig=[hostlogOption]) WaitForTask(vm.Reconfigure(spec)) except vmodl.fault.InvalidArgument as e: print("Hit %s as expected" % e) else: raise Exception("Failed to hit Reconfigure error changing hostlog") finally: WaitForTask(vm.Destroy())
def TestNegVMCIDevice(vm1, isVMCIDefault): if not isVMCIDefault: devices = vmconfig.CheckDevice(vm1.GetConfig(), Vim.Vm.Device.VirtualVMCIDevice) if len(devices) != 0: raise Exception("VMCI device found by default in VM") return failure = False Log("Adding new VMCI device to a VM") try: cspec = Vim.Vm.ConfigSpec() cpsec = vmconfig.AddVMCI(cspec) task = vm1.Reconfigure(cspec) WaitForTask(task) except Exception as e: Log("Verified request was rejected as expected.") failure = True if not failure: raise Exception("Adding VMCI device to VM was allowed!") Log("Attempt to remove VMCI device from VM") devices = vmconfig.CheckDevice(vm1.GetConfig(), Vim.Vm.Device.VirtualVMCIDevice) cspec = Vim.Vm.ConfigSpec() cpsec = vmconfig.RemoveDeviceFromSpec(cspec, devices[0]) try: task = vm1.Reconfigure(cspec) WaitForTask(task) except Exception as e: Log("Verified request was rejected as expected.") return raise Exception("Did not hit an exception as expected")
def CreateMultipleSoundCards(vm1): ## Test 6. Create two sound cards and verify the operation fails success = False cspec = Vim.Vm.ConfigSpec() cspec = vmconfig.AddSoundCard(cspec, autodetect=False, type="ensoniq") cspec = vmconfig.AddSoundCard(cspec, autodetect=False, type="sb16") try: task = vm1.Reconfigure(cspec) WaitForTask(task) except Vim.Fault.TooManyDevices as e: success = True if success == True: success = False cspec = Vim.Vm.ConfigSpec() cspec = vmconfig.AddSoundCard(cspec, autodetect=False, type="ensoniq") try: task = vm1.Reconfigure(cspec) WaitForTask(task) except Vim.Fault.TooManyDevices as e: success = True devices = vmconfig.CheckDevice(vm1.GetConfig(), Vim.Vm.Device.VirtualSoundCard) if len(devices) != 0: raise "Found sound card though operation should have failed!!" if (success == True): print("Successful failing to create 2 sound devices") else: print("Apparently didnt see expected exceptions")
def ModifyVmfs(vmfs, mount): if mount: bt = time.time() task = storageSystem.MountVmfsVolumeEx([mnt.volume.uuid for mnt in vmfs]) WaitForTask(task) print("Mount" + " " + str(len(vmfs)) + " volumes in " + str(time.time() - bt) + " sec") return task.info.result else: bt = time.time() task = storageSystem.UnmountVmfsVolumeEx([mnt.volume.uuid for mnt in vmfs]) WaitForTask(task) print("Unmount" + " " + str(len(vmfs)) + " volumes in " + str(time.time() - bt) + " sec") return task.info.result
def TestMove(self): pathA = self.CreateSingle("MoveTest") pathB = self.MakeDsPath("MoveTest_move") Log(" Moving: " + pathA + " -> " + pathB) task = self._vdm.MoveVirtualDisk(pathA, self._dc, pathB, self._dc, True) WaitForTask(task, True) Log(" Moving back: " + pathB + " -> " + pathA) task = self._vdm.MoveVirtualDisk(pathB, self._dc, pathA, self._dc, True) WaitForTask(task, True) self.DeleteSingle(pathA)
def EditExistingEnsoniqToSetAndUnsetAutodetect(vm1): # Test 9. Edit an ensoniq device and toggle the device autodetect setting cspec = Vim.Vm.ConfigSpec() cspec = vmconfig.AddSoundCard(cspec, autodetect=True, type="ensoniq") task = vm1.Reconfigure(cspec) WaitForTask(task) devices = vmconfig.CheckDevice(vm1.GetConfig(), Vim.Vm.Device.VirtualEnsoniq1371, {"backing.useAutoDetect": True}) if len(devices) != 1: raise "Failed to find added sound card" cspec = Vim.Vm.ConfigSpec() dev = devices[0] backing = dev.GetBacking() backing.SetUseAutoDetect(False) backing.SetDeviceName( vmconfig.GetDeviceName(None, vmconfig.GetCfgTarget(None).GetSound)) dev.SetBacking(backing) vmconfig.AddDeviceToSpec(cspec, dev, Vim.Vm.Device.VirtualDeviceSpec.Operation.edit) task = vm1.Reconfigure(cspec) WaitForTask(task) devices = vmconfig.CheckDevice(vm1.GetConfig(), Vim.Vm.Device.VirtualEnsoniq1371, {"backing.useAutoDetect": False}) if len(devices) != 1: raise "Failed to find added sound card" cspec = Vim.Vm.ConfigSpec() dev = devices[0] backing = dev.GetBacking() backing.SetUseAutoDetect(True) dev.SetBacking(backing) vmconfig.AddDeviceToSpec(cspec, dev, Vim.Vm.Device.VirtualDeviceSpec.Operation.edit) task = vm1.Reconfigure(cspec) WaitForTask(task) devices = vmconfig.CheckDevice(vm1.GetConfig(), Vim.Vm.Device.VirtualEnsoniq1371, {"backing.useAutoDetect": True}) if len(devices) != 1: raise "Failed to find added sound card" print("Toggling soundcard autodetect works!")
def EditFloppySetAndUnsetAutodetect(vm1): # Test 9. Edit a floppy device and toggle the device autodetect setting cspec = Vim.Vm.ConfigSpec() cspec = vmconfig.AddFloppy(cspec, autodetect=True) task = vm1.Reconfigure(cspec) WaitForTask(task) devices = vmconfig.CheckDevice(vm1.GetConfig(), Vim.Vm.Device.VirtualFloppy, {"backing.useAutoDetect": True}) if len(devices) != 1: raise "Failed to find added floppy" cspec = Vim.Vm.ConfigSpec() dev = devices[0] backing = dev.GetBacking() backing.SetUseAutoDetect(False) backing.SetDeviceName( vmconfig.GetDeviceName(None, vmconfig.GetCfgTarget(None).GetFloppy)) dev.SetBacking(backing) vmconfig.AddDeviceToSpec(cspec, dev, Vim.Vm.Device.VirtualDeviceSpec.Operation.edit) task = vm1.Reconfigure(cspec) WaitForTask(task) devices = vmconfig.CheckDevice(vm1.GetConfig(), Vim.Vm.Device.VirtualFloppy, {"backing.useAutoDetect": False}) if len(devices) != 1: raise "Failed to find added floppy" cspec = Vim.Vm.ConfigSpec() dev = devices[0] backing = dev.GetBacking() backing.SetUseAutoDetect(True) dev.SetBacking(backing) vmconfig.AddDeviceToSpec(cspec, dev, Vim.Vm.Device.VirtualDeviceSpec.Operation.edit) task = vm1.Reconfigure(cspec) WaitForTask(task) devices = vmconfig.CheckDevice(vm1.GetConfig(), Vim.Vm.Device.VirtualFloppy, {"backing.useAutoDetect": True}) if len(devices) != 1: raise "Failed to find added floppy" print("Toggling floppy autodetect works!")
def clone_vm(self): """ Clone VM from a previously created template, template_name == vm_name without last 3 digits """ log.subtask("clone virtual machine") log.info("- source: {0}".format(self.template_name)) log.info("- destination: {0}".format(self.name)) template_vm = self.get_vm(isTemplate=True) if template_vm: self._check_media() vm_clone_spec = vim.vm.CloneSpec(location=vim.vm.RelocateSpec( datastore=self.datastore, pool=self.resource_pool), powerOn=False, template=False) task = template_vm.CloneVM_Task(folder=self.datacenter.vmFolder, name=self.name, spec=vm_clone_spec) try: log.info("cloning...") WaitForTask(task) self.vm_obj = self.get_vm(isTemplate=False) log.info("cloning succeeded") except Exception as e: quit("cloning failed: {0}".format(e)) else: quit("template not found: {0}".format(self.template_name))
def create_vm(si, vm_name, datacenter_name, host_ip, datastore_name=None): content = si.RetrieveContent() destination_host = pchelper.get_obj(content, [vim.HostSystem], host_ip) source_pool = destination_host.parent.resourcePool if datastore_name is None: datastore_name = destination_host.datastore[0].name config = create_config_spec(datastore_name=datastore_name, name=vm_name) for child in content.rootFolder.childEntity: if child.name == datacenter_name: vm_folder = child.vmFolder # child is a datacenter break else: print("Datacenter %s not found!" % datacenter_name) sys.exit(1) try: WaitForTask( vm_folder.CreateVm(config, pool=source_pool, host=destination_host)) print("VM created: %s" % vm_name) except vim.fault.DuplicateName: print("VM duplicate name: %s" % vm_name, file=sys.stderr) except vim.fault.AlreadyExists: print("VM name %s already exists." % vm_name, file=sys.stderr)
def add_pci_device(self, vm, pci_device): """ Attaches PCI device to VM Args: vm (vim.VirtualMachine): VM instance pci_device (vim.vm.PciPassthroughInfo): PCI device to add """ host = vm.runtime.host.name logger.info( f"Adding PCI device with ID:{pci_device.pciDevice.id} on host {host} to {vm.name}" ) deviceId = hex(pci_device.pciDevice.deviceId % 2**16).lstrip("0x") backing = vim.VirtualPCIPassthroughDeviceBackingInfo( deviceId=deviceId, id=pci_device.pciDevice.id, systemId=pci_device.systemId, vendorId=pci_device.pciDevice.vendorId, deviceName=pci_device.pciDevice.deviceName, ) hba_object = vim.VirtualPCIPassthrough(key=-100, backing=backing) new_device_config = vim.VirtualDeviceConfigSpec(device=hba_object) new_device_config.operation = "add" vmConfigSpec = vim.vm.ConfigSpec() vmConfigSpec.memoryReservationLockedToMax = True vmConfigSpec.deviceChange = [new_device_config] WaitForTask(vm.ReconfigVM_Task(spec=vmConfigSpec))
def main(): args = get_args() # connect to vc si = SmartConnect(host=args.params['hostname'], user=args.params['username'], pwd=args.params['password'], port=args.params['port']) # disconnect vc atexit.register(Disconnect, si) content = si.RetrieveContent() print('Searching for VM {}').format(args.params['name']) vm = get_obj(content, [vim.VirtualMachine], args.params['name']) cdrom = get_vm_cdrom_device(vm) if cdrom is not None: # Remove it deviceSpec = vim.vm.device.VirtualDeviceSpec() deviceSpec.device = cdrom deviceSpec.operation = vim.vm.device.VirtualDeviceSpec.Operation.remove configSpec = vim.vm.ConfigSpec(deviceChange=[deviceSpec]) WaitForTask(vm.Reconfigure(configSpec)) msg = ('CDROM successfully') args.exit_json(msg=msg, changed=True) else: msg = ("CDROM not found") args.fail_json(msg=msg, changed=False)
def main(): args = get_args() si = SmartConnect(host=args.params['hostname'], user=args.params['username'], pwd=args.params['password'], port=args.params['port']) if args.params['datacenter']: dc = get_dc(si, args.params['datacenter']) else: dc = si.content.rootFolder.childEntity[0] dc = si.content.rootFolder.childEntity[0] # first datacenter searchIndex = si.content.searchIndex vm = searchIndex.FindChild(dc.vmFolder, args.params['name']) # vm = si.content.searchIndex.FindChild(dc.vmFolder, args.params['name']) #cdrom = get_vm_cdrom_device(vm_obj=vm) cdroms = find_device(vm, vim.vm.device.VirtualCdrom) op = vim.vm.device.VirtualDeviceSpec.Operation if cdrom is not None: # Remove it deviceSpec = vim.vm.device.VirtualDeviceSpec() deviceSpec.device = cdrom deviceSpec.operation = op.remove configSpec = vim.vm.ConfigSpec(deviceChange=[deviceSpec]) WaitForTask(vm.Reconfigure(configSpec))
def ShowDiskInfo(self, path, includeParents=True): Log("VirtualDiskManager: show query disk info") Log("Query disk info for " + path) task = self._vdm.QueryVirtualDiskInfo(path, self._dc, includeParents) WaitForTask(task, True) diskInfos = task.info.result Log("Result = \n" + `diskInfos`)
def UnmountVolumes(): sw = StopWatch() task = storageSystem.UnmountVmfsVolumeEx(volumeUUIDs) WaitForTask(task) sw.finish(" unmount VMFS volumes") #TODO add str(len(volumeUUIDs)) time.sleep( 60) # rest a bit, in case un-expected things happens to do next op
def TestEagerZero(self): Log("VirtualDiskManager: Eagerzero test") path = self.CreateSingle("EagerZeroTest", "preallocated") Log(" EagerZeroing: " + path) task = self._vdm.EagerZeroVirtualDisk(path) WaitForTask(task, True) self.DeleteSingle(path)
def resetVM(self, vm): try: t = vm.ResetVM_Task() WaitForTask(t) #self.wait(t.info) except Exception as e: print str(e)
def create(content, snapShot, descript, dumpMemory, quiesce): """ Creates snapshot of VM after finding context for it. Important: when called set dumpMemory and quiesce to False. """ vm = getVM(content, [vim.VirtualMachine], "johnson") WaitForTask(vm.CreateSnapshot("helloworld", descript, dumpMemory, quiesce))
def TestVQATDestroyVM(vm): """ Destroy a VM. """ Log("Destroying VM") task = vm.Destroy() WaitForTask(task)
def add_hosts_to_vc(dc,cluster,esx_hosts,esx_user,esx_pwd): host_objects = [] folder = dc.hostFolder for ip in esx_hosts: # Get ESXi SSL thumbprints sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.settimeout(1) wrappedSocket = ssl.wrap_socket(sock) wrappedSocket.connect((ip, 443)) der_cert_bin = wrappedSocket.getpeercert(True) thumb_sha1 = hashlib.sha1(der_cert_bin).hexdigest() thumb = ':'.join(a + b for a, b in zip(thumb_sha1[::2], thumb_sha1[1::2])) print("Host thumbprint is ", thumb) connect_spec = vim.host.ConnectSpec(hostName=ip, userName=esx_user, password=esx_pwd, sslThumbprint=thumb, force=False) print("Adding Host ({}) to vCenter".format(ip)) task = folder.AddStandaloneHost(connect_spec, vim.ComputeResource.ConfigSpec(), True) # Get host from task result WaitForTask(task) host_mo = task.info.result.host[0] #print("Created Host '{}' ({})".format(mo._moId, ip)) print("Added Host '{}' ({} to vCenter)".format(host_mo._moId, host_mo.name)) host_objects.append(host_mo) return host_objects
def delete(self, snapshot, removeChildren=False): try: log.info("delete snapshot") WaitForTask(snapshot.snapshot.RemoveSnapshot_Task(removeChildren)) except: log.debug("Error irreconosible") raise
def TestWithSnapshot(vm1): """ Verify that it is not possible to extend delta disk by changing capacityInBytes. """ cspec = Vim.Vm.ConfigSpec() vmconfig.AddScsiDisk(cspec, cfgInfo = vm1.config) vm.Reconfigure(vm1, cspec) devices = vmconfig.CheckDevice(vm1.config, Vim.Vm.Device.VirtualDisk) if len(devices) != 1: raise Exception("Failed to find new disk!") # attempt to extend a disk with a parent Log("Creating a snapshot on the VM for negative disk extend test.") vm.CreateSnapshot(vm1, "dummy snapshot", "dummy desc", False, False) Log("Attempting to extend disk size of delta disk.") disk = vmconfig.CheckDevice(vm1.config, Vim.Vm.Device.VirtualDisk)[0] cspec = Vim.Vm.ConfigSpec() disk.capacityInBytes = disk.capacityInBytes + 1024 vmconfig.AddDeviceToSpec(cspec, disk, Vim.Vm.Device.VirtualDeviceSpec.Operation.edit) task = vm1.Reconfigure(cspec) try: WaitForTask(task) except Exception as e: Log("Hit an exception extending delta disk as expected" + str(e)) else: raise Exception("Error: Extending delta disk was allowed!") Log("Removing all snapshots on the VM.") vm.RemoveAllSnapshots(vm1)
def TestCreateFileBackedWeirdPaths(self, cleanup=True): Log("VirtualDiskManager: Create file-backed tests with weird paths") spec = Vim.VirtualDiskManager.FileBackedVirtualDiskSpec() weirdNames = [ # directory-looking path without vmdk extension handled like disks [True, "path without vmdk extension" , "novmdkext"], # created but disklib errored on reading disk info IIRC [False, "path with quotes and stuff", "\"\",.-.vmdk"], [False, "path with special characters", "~!@#$%^&*-_=+[]\\{}|;:\",./<>?-.vmdk"], [False, "path with single quote not liked by vmfs", "\"xxxquote.vmdk"], [False, "nonexistent directory path with trailing slash disallowed", "withslash/"] ] for allow,desc,name in weirdNames: # @todo exercise disallowed ones too, but catch/match exceptions if allow: spec.SetDiskType("preallocated") spec.SetAdapterType("busLogic") spec.SetCapacityKb(long(50000)) path = "[" + self._dsName + "] " + name Log(" Creating " + desc + " (" + path + ")") task = self._vdm.CreateVirtualDisk(path, None, spec) WaitForTask(task) Log(" Creating " + desc + " (" + path + ") Done.") if cleanup: task = self._vdm.DeleteVirtualDisk(path, None) Log(" Deleting " + desc + " (" + path + ") Done.")
def main(): supportedArgs = [ (["h:", "host="], "localhost", "Host name", "host"), (["u:", "user="******"root", "User name", "user"), (["p:", "pwd="], "", "Password", "pwd"), (["v:", "vmname="], "SATATest", "Name of the virtual machine", "vmname") ] supportedToggles = [ (["usage", "help"], False, "Show usage information", "usage"), (["runall", "r"], True, "Run all the tests", "runall"), (["nodelete"], False, "Dont delete vm on completion", "nodelete") ] args = arguments.Arguments(sys.argv, supportedArgs, supportedToggles) if args.GetKeyValue("usage") == True: args.Usage() sys.exit(0) # Connect si = SmartConnect(host=args.GetKeyValue("host"), user=args.GetKeyValue("user"), pwd=args.GetKeyValue("pwd")) atexit.register(Disconnect, si) # Process command line vmname = args.GetKeyValue("vmname") runall = args.GetKeyValue("runall") noDelete = args.GetKeyValue("nodelete") status = "PASS" vm1 = None try: Log("Cleaning up VMs from previous runs...") vm.Delete(vmname, True) ## Positive tests on a hwVersion 10 VM Log("Creating Hw10 VM..") vm1 = vm.CreateQuickDummy(vmname, vmxVersion = "vmx-10", memory = 4, guest = "otherGuest") # Test add of SATA controller TestSataCtlrReconfig(vm1) # Mess with SATA disks TestEditSataDisk(vm1) # Mess with SATA cdroms TestEditSataCdrom(vm1) Log("Tests completed.") except Exception as e: status = "FAIL" Log("Caught exception : " + str(e)) finally: # Delete the vm as cleanup if noDelete == False: if vm1 != None: task = vm1.Destroy() WaitForTask(task) vm1 = None Log("TEST RUN COMPLETE: " + status)
def revertCurrentSnapshotVM(self, vm): try: t = vm.RevertToCurrentSnapshot_Task() WaitForTask(t) #self.wait(t.info) except Exception as e: print str(e)
def remove_snapshot_by_id(self, snapshot_id, vm_obj=None, vm_name=None, remove_children=True, raise_not_found=False): """ Remove a vm's snapshot by the snapshot ID The snapshot ID should be saved when creating a snapshot if you need to use it in this function. A snapshot obj in pyvmomi is like 'vim.vm.Snapshot:snapshot-1474', the snapshot ID is 'snapshot-1474' :param snapshot_id: a snapshot ID :param vm_obj: a vsphere vm object :param vm_name: a vm's name :param remove_children: whether to remove snapshot's children snapshots :param raise_not_found: whether to raise exception if snapshot_id not found """ snap = self.find_snapshot_by_id(snapshot_id) if not snap: if raise_not_found: raise VSphereSnapNotFound(vm_obj.name, snapshot_id) else: logging.debug('Not found snapshot_id %s for VM %s', snapshot_id, vm_obj.name) return logging.debug('Remove snapshot %s for VM %s', snap, vm_obj.name) WaitForTask(snap.Remove(removeChildren=remove_children))
def TestInflate(self): Log("VirtualDiskManager: Inflate test") path = self.CreateSingle("InflateTest", "thin") Log(" Inflating: " + path) task = self._vdm.InflateVirtualDisk(path) WaitForTask(task, True) self.DeleteSingle(path)
def change_vm_disk(self, disk_label, new_disk_size, vm_moId): si = self._connect_vc() content = si.RetrieveContent() vm_obj = self._get_obj_bymoId(content, [vim.VirtualMachine], vm_moId) try: virtual_disk_device = None if not vm_obj.rootSnapshot: for dev in vm_obj.config.hardware.device: if isinstance(dev, vim.vm.device.VirtualDisk ) and dev.deviceInfo.label == disk_label: virtual_disk_device = dev if not virtual_disk_device: return RuntimeError( 'Virtual {} could not be found.'.format(disk_label)) virtual_disk_spec = vim.vm.device.VirtualDeviceSpec() virtual_disk_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.edit virtual_disk_spec.device = virtual_disk_device virtual_disk_spec.device.capacityInKB = int( new_disk_size) * 1024 * 1024 dev_changes = [] dev_changes.append(virtual_disk_spec) spec = vim.vm.ConfigSpec() spec.deviceChange = dev_changes task = vm_obj.ReconfigVM_Task(spec=spec) # tasks.wait_for_tasks(si, [task]) WaitForTask(task) return {'result': True} except Exception, e: error_msg = e.message if e.message else str(e) return {"result": False, "data": error_msg}
def add_disk(self, vm, size, disk_type="thin"): """ Attaches disk to VM Args: vm (vim.VirtualMachine): VM instance size (int) : size of disk in GB disk_type (str) : disk type """ logger.info(f"Adding disk to {vm.config.name}") spec = vim.vm.ConfigSpec() controller = self.get_controller_for_adding_disk(vm) unit_number = self.get_unit_number(vm) logger.info(f"Unit number for new disk: {unit_number}") device_changes = [] new_disk_kb = int(size) * GB2KB disk_spec = vim.vm.device.VirtualDeviceSpec() disk_spec.fileOperation = "create" disk_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add disk_spec.device = vim.vm.device.VirtualDisk() disk_spec.device.backing = vim.vm.device.VirtualDisk.FlatVer2BackingInfo( ) if disk_type == VM_DISK_TYPE: disk_spec.device.backing.thinProvisioned = True disk_spec.device.backing.diskMode = VM_DISK_MODE disk_spec.device.unitNumber = unit_number disk_spec.device.capacityInKB = new_disk_kb disk_spec.device.controllerKey = controller.key device_changes.append(disk_spec) spec.deviceChange = device_changes WaitForTask(vm.ReconfigVM_Task(spec=spec)) logger.info(f"{size}GB disk added successfully to {vm.config.name}")
def change_vcpu(vm, vcpu_nu): vcpu_nu = int(vcpu_nu) cspec = vim.vm.ConfigSpec() cspec.numCPUs = vcpu_nu cspec.numCoresPerSocket = 1 WaitForTask(vm.Reconfigure(cspec)) print("number of vCPU changed to %s" % vcpu_nu)