def main(): """ Sample for adding a vm NIC to a Distributed Virtual Switch """ parser = cli.Parser() parser.add_required_arguments(cli.Argument.VM_NAME, cli.Argument.PORT_GROUP, cli.Argument.VM_MAC) args = parser.get_args() si = service_instance.connect(args) content = si.RetrieveContent() print("Search VDS PortGroup by Name ...") portgroup = pchelper.get_obj(content, [vim.dvs.DistributedVirtualPortgroup], args.port_group) if portgroup is None: print("Portgroup not Found in DVS ...") sys.exit(0) print("Search Available(Unused) port for VM...") dvs = portgroup.config.distributedVirtualSwitch port_key = search_port(dvs, portgroup.key) port = port_find(dvs, port_key) print("Search VM by Name ...") vm = None vm = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name) if vm: print("Find Vm , Add Nic Card ...") add_nic(vm, args.vm_mac, port) else: print("Vm not Found ...")
def main(): """ Let this thing fly """ parser = cli.Parser() parser.add_required_arguments(cli.Argument.VM_NAME, cli.Argument.TEMPLATE) # if no locationis provided, thefirst available datacenter, datastore, etc. will be used parser.add_optional_arguments( cli.Argument.DATACENTER_NAME, cli.Argument.VMFOLDER, cli.Argument.DATASTORE_NAME, cli.Argument.DATASTORECLUSTER_NAME, cli.Argument.CLUSTER_NAME, cli.Argument.RESOURCE_POOL, cli.Argument.POWER_ON, cli.Argument.OPAQUE_NETWORK_NAME) args = parser.get_args() si = service_instance.connect(args) content = si.RetrieveContent() template = pchelper.get_obj(content, [vim.VirtualMachine], args.template) if template: clone_vm(content, template, args.vm_name, args.datacenter_name, args.vm_folder, args.datastore_name, args.cluster_name, args.resource_pool, args.power_on, args.datastorecluster_name) if args.opaque_network_name: vm = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name) add_nic(si, vm, args.opaque_network_name) else: print("template not found")
def main(): """ Sample for adding a raw disk to vm """ parser = cli.Parser() parser.add_required_arguments(cli.Argument.DEVICE_NAME) parser.add_optional_arguments(cli.Argument.VM_NAME, cli.Argument.UUID, cli.Argument.DISK_MODE, cli.Argument.COMPATIBILITY_MODE) args = parser.get_args() si = service_instance.connect(args) vm = None if args.uuid: search_index = si.content.searchIndex vm = search_index.FindByUuid(None, args.uuid, True) elif args.vm_name: content = si.RetrieveContent() vm = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name) if vm: add_raw_disk(vm, si, args.device_name, args.disk_mode, args.disk_compatibility_mode) else: print("VM not found")
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 main(): parser = cli.Parser() parser.add_required_arguments(cli.Argument.VM_NAME) parser.add_custom_argument('--unitnumber', required=True, help='HDD number to delete.', type=int) parser.add_custom_argument('--yes', help='Confirm disk deletion.', action='store_true') parser.add_custom_argument('--language', default='English', help='Language your vcenter used.') args = parser.get_args() si = service_instance.connect(args) content = si.RetrieveContent() print('Searching for VM {}'.format(args.vm_name)) vm_obj = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name) if vm_obj: if not args.yes: cli.prompt_y_n_question("Are you sure you want " "to delete HDD " "{}?".format(args.unitnumber), default='no') delete_virtual_disk(si, vm_obj, args.unitnumber, args.language) print('VM HDD "{}" successfully deleted.'.format(args.unitnumber)) else: print('VM not found')
def main(): """ Upgrades the hardware version of a Virtual Machine. """ parser = cli.Parser() parser.add_required_arguments(cli.Argument.VM_NAME) parser.add_custom_argument( '--release', required=False, action='store', default=None, help='Version/release number of the Virtual machine hardware') args = parser.get_args() si = service_instance.connect(args) content = si.RetrieveContent() vm = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name) if not vm: print("Could not find VM %s" % args.vm_name) else: print("Upgrading VM %s" % args.vm_name) # Set the hardware version to use if specified if args.release is not None: print("New version will be %s" % args.release) version = "vmx-{:02d}".format(args.release) else: version = None # Upgrade the VM try: task.WaitForTask(task=vm.UpgradeVM_Task(version), si=si) print("Upgrade complete") except vim.fault.AlreadyUpgraded: print("VM is already upgraded")
def main(): """ Simple command-line program for creating a snapshot of a first class disk. """ parser = cli.Parser() parser.add_required_arguments(cli.Argument.DATASTORE_NAME, cli.Argument.FIRST_CLASS_DISK_NAME, cli.Argument.SNAPSHOT_NAME) args = parser.get_args() si = service_instance.connect(args) try: content = si.RetrieveContent() # Retrieve Datastore Object datastore = pchelper.get_obj(content, [vim.Datastore], args.datastore_name) # Retrieve FCD Object vdisk = disk.retrieve_fcd(content, datastore, args.fcd_name) # Create FCD Snapshot storage = content.vStorageObjectManager task = storage.VStorageObjectCreateSnapshot_Task( vdisk.config.id, datastore, args.snapshot_name) tasks.wait_for_tasks(si, [task]) print("FCD snapshot created!") except vmodl.MethodFault as error: print("Caught vmodl fault : " + error.msg) return -1 return 0
def main(): """ Simple command-line program for listing all snapshots of a fcd """ parser = cli.Parser() parser.add_required_arguments(cli.Argument.DATASTORE_NAME, cli.Argument.FIRST_CLASS_DISK_NAME) args = parser.get_args() si = service_instance.connect(args) try: content = si.RetrieveContent() # Retrieve Datastore Object datastore = pchelper.get_obj(content, [vim.Datastore], args.datastore_name) # Retrieve FCD Object vdisk = disk.retrieve_fcd(content, datastore, args.fcd_name) # Retrieve all Snapshots list_fcd_snapshots(content, vdisk) except vmodl.MethodFault as error: print("Caught vmodl fault : " + error.msg) return -1 return 0
def reconfigureVM(self, uuid, portGroup): self.check_connectivity() _content = self.service_instance.RetrieveContent() target_vm = _content.searchIndex.FindByUuid(None, uuid, True) device_change = [] for device in target_vm.config.hardware.device: if isinstance(device, vim.vm.device.VirtualEthernetCard): nicspec = vim.vm.device.VirtualDeviceSpec() nicspec.operation = \ vim.vm.device.VirtualDeviceSpec.Operation.edit nicspec.device = device nicspec.device.wakeOnLanEnabled = True if True: nicspec.device.backing = \ vim.vm.device.VirtualEthernetCard.NetworkBackingInfo() nicspec.device.backing.network = \ pchelper.get_obj(_content, [vim.Network], portGroup) nicspec.device.backing.deviceName = portGroup else: network = pchelper.get_obj( _content, [vim.dvs.DistributedVirtualPortgroup], portGroup) dvs_port_connection = vim.dvs.PortConnection() dvs_port_connection.portgroupKey = network.key dvs_port_connection.switchUuid = \ network.config.distributedVirtualSwitch.uuid nicspec.device.backing = \ vim.vm.device.VirtualEthernetCard. \ DistributedVirtualPortBackingInfo() nicspec.device.backing.port = dvs_port_connection nicspec.device.connectable = \ vim.vm.device.VirtualDevice.ConnectInfo() nicspec.device.connectable.startConnected = True nicspec.device.connectable.allowGuestControl = True device_change.append(nicspec) break config_spec = vim.vm.ConfigSpec(deviceChange=device_change) task = target_vm.ReconfigVM_Task(config_spec) retval = tasks.wait_for_tasks(self.service_instance, [task]) print("reconfigure result ", retval) return retval
def configure_dvs_pg(si, dvs_name, dv_pg_name): """ Configures the distributed port group :param si: Vcenter service instance :param dvs_name: Name of the distributed virtual switch :param dv_pg_name: Name of distributed virtual port group """ # Retrieve the content content = si.RetrieveContent() # get distributed Switch and its port group objects dvs = pchelper.get_obj(content, [vim.DistributedVirtualSwitch], dvs_name) dv_pg = pchelper.get_obj(content, [vim.dvs.DistributedVirtualPortgroup], dv_pg_name) print("The distributed virtual Switch is {0}" .format(dvs)) print("The distributed port group is {0}".format(dv_pg)) # construct selection sets selection_sets = [] dv_pg_ss = vim.dvs.DistributedVirtualPortgroupSelection() dv_pg_ss.dvsUuid = dvs.uuid dv_pg_ss.portgroupKey.append(dv_pg.key) selection_sets.append(dv_pg_ss) print("The selected port group configurations are {0}" .format(selection_sets)) # Backup/Export the configuration entity_backup_config = si.content\ .dvSwitchManager\ .DVSManagerExportEntity_Task(selection_sets) export_result = entity_backup_config.info.result print("The result of export configuration are {0}".format(export_result)) # Destroy the port group configuration dv_pg.Destroy_Task() # Restore/Import port group configuration entity_restore_config = si.content\ .dvSwitchManager\ .DVSManagerImportEntity_Task(export_result, 'createEntityWithOriginalIdentifier') print("The result of restore configuration is {0}" .format(entity_restore_config.info.result))
def main(): """ Simple command-line program for attaching a first class disk to a vm. """ parser = cli.Parser() parser.add_required_arguments(cli.Argument.DATASTORE_NAME, cli.Argument.FIRST_CLASS_DISK_NAME) parser.add_optional_arguments(cli.Argument.VM_NAME, cli.Argument.UUID) args = parser.get_args() si = service_instance.connect(args) try: content = si.RetrieveContent() # Retrieve Datastore Object datastore = pchelper.get_obj(content, [vim.Datastore], args.datastore_name) # Retrieve FCD Object vdisk = disk.retrieve_fcd(content, datastore, args.fcd_name) # Retrieve VM vm = None if args.uuid: search_index = content.searchIndex vm = search_index.FindByUuid(None, args.uuid, True) elif args.vm_name: vm = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name) # Attaching FCD to VM if vm: task = attach_fcd_to_vm(vm, vdisk) tasks.wait_for_tasks(si, [task]) else: raise RuntimeError("VM not found.") except vmodl.MethodFault as error: print("Caught vmodl fault : " + error.msg) return -1 return 0
def main(): parser = cli.Parser() parser.add_required_arguments(cli.Argument.DATACENTER_NAME) parser.add_custom_argument('--dvswitch-name', required=False, help='name of the dvswitch', default='all') args = parser.get_args() si = service_instance.connect(args) content = si.RetrieveContent() datacenter = pchelper.get_obj(content, [vim.Datacenter], args.datacenter_name) if datacenter is None: print("Failed to find the datacenter %s" % args.datacenter_name) return 0 if args.dvswitch_name == 'all': dvs_lists = pchelper.get_all_obj(content, [vim.DistributedVirtualSwitch], folder=datacenter.networkFolder) else: dvsn = pchelper.search_for_obj(content, [vim.DistributedVirtualSwitch], args.dvswitch_name) if dvsn is None: print("Failed to find the dvswitch %s" % args.dvswitch_name) return 0 dvs_lists = [dvsn] print('Datacenter Name'.ljust(40) + ' :', args.datacenter_name) for dvs in dvs_lists: print(40 * '#') print('Dvswitch Name'.ljust(40) + ' :', dvs.name) print(40 * '#') for dvs_pg in dvs.portgroup: vlan_info = dvs_pg.config.defaultPortConfig.vlan vlan_spec = vim.dvs.VmwareDistributedVirtualSwitch.TrunkVlanSpec if isinstance(vlan_info, vlan_spec): vlanlist = [] for item in vlan_info.vlanId: if item.start == item.end: vlanlist.append(str(item.start)) else: vlanlist.append(str(item.start) + '-' + str(item.end)) vlan_id = " | Trunk | vlan id: " + ','.join(vlanlist) else: vlan_id = " | vlan id: " + str(vlan_info.vlanId) print(dvs_pg.name.ljust(40) + vlan_id) return 0
def main(): """ Simple command-line program for deleting a snapshot of a first class disk. """ parser = cli.Parser() parser.add_required_arguments(cli.Argument.DATASTORE_NAME, cli.Argument.FIRST_CLASS_DISK_NAME, cli.Argument.SNAPSHOT_NAME) parser.add_custom_argument('--yes', action='store_true', help='Confirm disk deletion.') args = parser.get_args() si = service_instance.connect(args) try: content = si.RetrieveContent() # Retrieve Datastore Object datastore = pchelper.get_obj(content, [vim.Datastore], args.datastore_name) # Retrieve FCD Object vdisk = disk.retrieve_fcd(content, datastore, args.fcd_name) # Retrieve Snapshot Object snapshot = disk.retrieve_fcd_snapshot( content, datastore, vdisk, args.snapshot_name) # Confirming Snapshot deletion if not args.yes: response = cli.prompt_y_n_question("Are you sure you want to " "delete snapshot '" + args.snapshot_name + "'?", default='no') if not response: print("Exiting script. User chose not to delete snapshot.") sys.exit() # Delete FCD Snapshot storage = content.vStorageObjectManager task = storage.DeleteSnapshot_Task( vdisk.config.id, datastore, snapshot) tasks.wait_for_tasks(si, [task]) print("FCD snapshot deleted!") except vmodl.MethodFault as error: print("Caught vmodl fault : " + error.msg) return -1 return 0
def main(): parser = cli.Parser() parser.add_required_arguments(cli.Argument.VM_NAME, cli.Argument.DISK_MODE) parser.add_custom_argument('--disk-number', required=True, help='Disk number to change mode.') args = parser.get_args() si = service_instance.connect(args) content = si.RetrieveContent() print('Searching for VM {}'.format(args.vm_name)) vm_obj = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name) if vm_obj: change_disk_mode(si, vm_obj, args.disk_number, args.disk_mode) print('VM Disk {} successfully changed to mode {}.'.format(args.disk_number, args.disk_mode)) else: print("VM not found.")
def add_nic(si, vm, network_name): """ :param si: Service Instance :param vm: Virtual Machine Object :param network_name: Name of the Virtual Network """ spec = vim.vm.ConfigSpec() nic_changes = [] nic_spec = vim.vm.device.VirtualDeviceSpec() nic_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add nic_spec.device = vim.vm.device.VirtualE1000() nic_spec.device.deviceInfo = vim.Description() nic_spec.device.deviceInfo.summary = 'vCenter API test' content = si.RetrieveContent() network = pchelper.get_obj(content, [vim.Network], network_name) if isinstance(network, vim.OpaqueNetwork): nic_spec.device.backing = \ vim.vm.device.VirtualEthernetCard.OpaqueNetworkBackingInfo() nic_spec.device.backing.opaqueNetworkType = \ network.summary.opaqueNetworkType nic_spec.device.backing.opaqueNetworkId = \ network.summary.opaqueNetworkId else: nic_spec.device.backing = \ vim.vm.device.VirtualEthernetCard.NetworkBackingInfo() nic_spec.device.backing.useAutoDetect = False nic_spec.device.backing.deviceName = network_name nic_spec.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo() nic_spec.device.connectable.startConnected = True nic_spec.device.connectable.allowGuestControl = True nic_spec.device.connectable.connected = False nic_spec.device.connectable.status = 'untried' nic_spec.device.wakeOnLanEnabled = True nic_spec.device.addressType = 'assigned' nic_changes.append(nic_spec) spec.deviceChange = nic_changes vm.ReconfigVM_Task(spec=spec) print("NIC CARD ADDED")
def main(): """ Simple command-line program demonstrating how to update ESXi Advanced Settings """ parser = cli.Parser() parser.add_required_arguments(cli.Argument.CLUSTER_NAME) parser.add_custom_argument('--key', required=True, action='store', help='Name of ESXi Advanced Setting to update') parser.add_custom_argument( '--value', required=True, action='store', help='Value of the ESXi Advanced Setting to update') args = parser.get_args() try: si = service_instance.connect(args) content = si.RetrieveContent() cluster = pchelper.get_obj(content, [vim.ClusterComputeResource], args.cluster_name) hosts = cluster.host for host in hosts: option_manager = host.configManager.advancedOption option = vim.option.OptionValue(key=args.key, value=int(args.value)) print("Updating %s on ESXi host %s " "with value of %s" % (args.key, host.name, args.value)) if option_manager.UpdateOptions(changedValue=[option]): print("Settings updated!") except vmodl.MethodFault as ex: print("Caught vmodl fault : " + ex.msg) return -1 except Exception as ex: print("Caught exception : " + str(ex)) return -1 return 0
def main(): parser = cli.Parser() parser.add_required_arguments(cli.Argument.VM_NAME, cli.Argument.NIC_STATE) parser.add_custom_argument('--unitnumber', required=True, help='NIC number.', type=int) args = parser.get_args() si = service_instance.connect(args) content = si.RetrieveContent() print('Searching for VM {}'.format(args.vm_name)) vm_obj = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name) if vm_obj: update_virtual_nic_state(si, vm_obj, args.unitnumber, args.nic_state) print('VM NIC {} successfully state changed to {}'.format( args.unitnumber, args.nic_state)) else: print("VM not found")
def main(): parser = cli.Parser() parser.add_optional_arguments(cli.Argument.VM_NAME) args = parser.get_args() si = service_instance.connect(args) content = si.RetrieveContent() if args.vm_name: print('Searching for VM {}'.format(args.vm_name)) vm_obj = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name) if vm_obj: print(_columns_four.format('Name', 'Status', 'Version', 'Version Status')) print_vmwareware_tools_status(vm_obj) else: print("VM not found") else: print(_columns_four.format('Name', 'Status', 'Version', 'Version Status')) for vm_obj in get_vms(content): print_vmwareware_tools_status(vm_obj)
def main(): """ Sample for adding a NIC to vm """ parser = cli.Parser() parser.add_required_arguments(cli.Argument.PORT_GROUP) parser.add_optional_arguments(cli.Argument.VM_NAME, cli.Argument.UUID) args = parser.get_args() si = service_instance.connect(args) vm = None if args.uuid: search_index = si.content.searchIndex vm = search_index.FindByUuid(None, args.uuid, True) elif args.vm_name: content = si.RetrieveContent() vm = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name) if vm: add_nic(si, vm, args.port_group) else: print("VM not found")
def main(): """ Sample for adding a disk to vm """ parser = cli.Parser() parser.add_optional_arguments(cli.Argument.VM_NAME, cli.Argument.UUID, cli.Argument.DISK_TYPE, cli.Argument.DISK_SIZE) args = parser.get_args() si = service_instance.connect(args) vm = None if args.uuid: search_index = si.content.searchIndex vm = search_index.FindByUuid(None, args.uuid, True) elif args.vm_name: content = si.RetrieveContent() vm = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name) if vm: add_disk(vm, args.disk_size, args.disk_type) else: print("VM not found")
def main(): parser = cli.Parser() parser.add_optional_arguments(cli.Argument.UUID, cli.Argument.VM_NAME) parser.add_custom_argument('--unit-number', required=True, action='store', help='unit number') args = parser.get_args() si = service_instance.connect(args) vm = None if args.uuid: search_index = si.content.searchIndex vm = search_index.FindByUuid(None, args.uuid, True) elif args.vm_name: content = si.RetrieveContent() vm = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name) if vm: if del_nic(si, vm, int(args.unit_number)): print("Successfully deleted NIC CARD") else: print("VM not found")
def main(): """ Simple command-line program for creating host and VM folders in a datacenter. """ parser = cli.Parser() parser.add_required_arguments(cli.Argument.DATACENTER_NAME, cli.Argument.FOLDER_NAME) args = parser.get_args() si = service_instance.connect(args) content = si.RetrieveContent() datacenter = pchelper.get_obj(content, [vim.Datacenter], args.datacenter_name) if pchelper.search_for_obj(content, [vim.Folder], args.folder_name): print("Folder '%s' already exists", args.folder_name) return 0 create_folder(datacenter.hostFolder, args.folder_name) print("Successfully created the host folder '%s'" % args.folder_name) create_folder(datacenter.vmFolder, args.folder_name) print("Successfully created the VM folder '%s'" % args.folder_name) return 0
def main(): """ Simple command-line program for retrieving a port group """ parser = cli.Parser() parser.add_required_arguments(cli.Argument.PORT_GROUP) args = parser.get_args() si = service_instance.connect(args) try: content = si.RetrieveContent() # searching for port group port_group = pchelper.get_obj(content, [vim.Network], args.port_group) print(port_group) except vmodl.MethodFault as error: print("Caught vmodl fault : {0}".format(error.msg)) return -1 return 0
def main(): """ Simple command-line program for detaching a disk from a virtual machine. """ parser = cli.Parser() parser.add_optional_arguments(cli.Argument.VM_NAME, cli.Argument.UUID, cli.Argument.LANGUAGE) parser.add_custom_argument('--disk-number', required=True, help='HDD number to detach.') args = parser.get_args() si = service_instance.connect(args) try: content = si.RetrieveContent() # Retrieve VM vm = None if args.uuid: search_index = content.searchIndex vm = search_index.FindByUuid(None, args.uuid, True) elif args.vm_name: vm = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name) # Detaching Disk from VM if vm: task = detach_disk_from_vm(vm, args.disk_number, args.language) tasks.wait_for_tasks(si, [task]) else: raise RuntimeError("VM not found.") except vmodl.MethodFault as error: print("Caught vmodl fault : " + error.msg) return -1 return 0
def main(): parser = cli.Parser() parser.add_required_arguments(cli.Argument.VM_NAME) # Full path to iso. i.e. "[ds1] folder/Ubuntu.iso" # If not provided, backend will set to RemotePassThrough parser.add_optional_arguments(cli.Argument.ISO) parser.add_custom_argument('--unitnumber', required=True, help='CD/DVD unit number.', type=int) args = parser.get_args() si = service_instance.connect(args) content = si.RetrieveContent() print('Searching for VM {}'.format(args.vm_name)) vm_obj = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name) if vm_obj: update_virtual_cd_backend_by_obj(si, vm_obj, args.unitnumber, args.iso) device_change = args.iso if args.iso else 'Client Device' print('VM CD/DVD {} successfully state changed to {}'.format( args.unitnumber, device_change)) else: print("VM not found")
def main(): """ Simple command-line program for creating Dummy VM based on Marvel character names """ parser = cli.Parser() parser.add_required_arguments(cli.Argument.DATASTORE_NAME, cli.Argument.FOLDER_NAME, cli.Argument.RESOURCE_POOL, cli.Argument.OPAQUE_NETWORK_NAME) parser.add_custom_argument('--count', type=int, required=True, action='store', help='Number of VMs to create') # NOTE (hartsock): as a matter of good security practice, never ever # save a credential of any kind in the source code of a file. As a # matter of policy we want to show people good programming practice in # these samples so that we don't encourage security audit problems for # people in the future. parser.add_custom_argument( '--public_key_file', required=False, action='store', help='Name of the file holding your marvel public key,' ' the key should be the first only of the file. ' 'Set one up at developer.marvel.com/account') parser.add_custom_argument( '--private_key_file', required=False, action='store', help='Name of the file holding your marvel private ' 'key, the key should be the only line of the ' 'file. ' 'Set one up at developer.marvel.com/account') args = parser.get_args() si = service_instance.connect(args) if args.public_key_file: with open(args.public_key_file) as key_file: marvel_public_key = key_file.readline().strip() else: marvel_public_key = input('Marvel public key: ').strip() if args.private_key_file: with open(args.private_key_file) as key_file: marvel_private_key = key_file.readline().strip() else: marvel_private_key = input('Marvel private key: ').strip() content = si.RetrieveContent() vmfolder = pchelper.get_obj(content, [vim.Folder], args.folder_name) resource_pool = pchelper.get_obj(content, [vim.ResourcePool], args.resource_pool) print("Connecting to Marvel API and retrieving " + str(args.count) + " random character(s) ...") characters = get_marvel_characters(args.count, marvel_public_key, marvel_private_key) for name in characters: vm_name = 'MARVEL-' + name create_dummy_vm(vm_name, si, vmfolder, resource_pool, args.datastore_name) if args.opaque_network_name: vm = pchelper.get_obj(content, [vim.VirtualMachine], vm_name) add_nic(si, vm, args.opaque_network_name) return 0
def main(): """ Simple command-line program for executing a process in the VM without the network requirement to actually access it. """ parser = cli.Parser() parser.add_optional_arguments(cli.Argument.VM_NAME, cli.Argument.UUID, cli.Argument.VM_USER, cli.Argument.VM_PASS) parser.add_custom_argument( '--path_to_program', required=False, action='store', help='Path inside VM to the program. e.g. "/bin/cat"') parser.add_custom_argument('--program_arguments', required=False, action='store', help='Program command line options. ' 'e.g. "/etc/network/interfaces > /tmp/plop"') args = parser.get_args() si = service_instance.connect(args) try: content = si.RetrieveContent() vm = None if args.uuid: # if instanceUuid(last argument) is false it will search for VM BIOS UUID instead vm = content.searchIndex.FindByUuid(None, args.uuid, True) elif args.vm_name: vm = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name) if not vm: raise SystemExit("Unable to locate the virtual machine.") tools_status = vm.guest.toolsStatus if tools_status in ('toolsNotInstalled', 'toolsNotRunning'): raise SystemExit( "VMwareTools is either not running or not installed. " "Rerun the script after verifying that VMwareTools " "is running") creds = vim.vm.guest.NamePasswordAuthentication(username=args.vm_user, password=args.vm_pwd) try: profile_manager = content.guestOperationsManager.processManager if args.program_arguments: program_spec = vim.vm.guest.ProcessManager.ProgramSpec( programPath=args.path_to_program, arguments=args.program_arguments) else: program_spec = vim.vm.guest.ProcessManager.ProgramSpec( programPath=args.path_to_program) res = profile_manager.StartProgramInGuest(vm, creds, program_spec) if res > 0: print("Program submitted, PID is %d" % res) pid_exitcode = \ profile_manager.ListProcessesInGuest(vm, creds, [res]).pop().exitCode # If its not a numeric result code, it says None on submit while re.match('[^0-9]+', str(pid_exitcode)): print("Program running, PID is %d" % res) time.sleep(5) pid_exitcode = \ profile_manager.ListProcessesInGuest(vm, creds, [res]).pop().exitCode if pid_exitcode == 0: print("Program %d completed with success" % res) break # Look for non-zero code to fail elif re.match('[1-9]+', str(pid_exitcode)): print("ERROR: Program %d completed with Failute" % res) print(" tip: Try running this on guest %r to debug" % vm.summary.guest.ipAddress) print("ERROR: More info on process") print( profile_manager.ListProcessesInGuest( vm, creds, [res])) break except IOError as ex: print(ex) except vmodl.MethodFault as error: print("Caught vmodl fault : " + error.msg) return -1 return 0
def main(): """ Simple command-line program for Uploading a file from host to guest """ parser = cli.Parser() parser.add_required_arguments(cli.Argument.VM_USER, cli.Argument.VM_PASS, cli.Argument.REMOTE_FILE_PATH, cli.Argument.LOCAL_FILE_PATH) parser.add_optional_arguments(cli.Argument.VM_NAME, cli.Argument.UUID) args = parser.get_args() vm_path = args.remote_file_path try: si = service_instance.connect(args) content = si.RetrieveContent() vm = None if args.uuid: search_index = si.content.searchIndex vm = search_index.FindByUuid(None, args.uuid, True) elif args.vm_name: content = si.RetrieveContent() vm = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name) if not vm: raise SystemExit("Unable to locate VirtualMachine.") print("Found: {0}".format(vm.name)) tools_status = vm.guest.toolsStatus if (tools_status == 'toolsNotInstalled' or tools_status == 'toolsNotRunning'): raise SystemExit( "VMwareTools is either not running or not installed. " "Rerun the script after verifying that VMWareTools " "is running") creds = vim.vm.guest.NamePasswordAuthentication(username=args.vm_user, password=args.vm_pwd) with open(args.local_file_path, 'rb') as myfile: data_to_send = myfile.read() try: file_attribute = vim.vm.guest.FileManager.FileAttributes() url = content.guestOperationsManager.fileManager. \ InitiateFileTransferToGuest(vm, creds, vm_path, file_attribute, len(data_to_send), True) # When : host argument becomes https://*:443/guestFile? # Ref: https://github.com/vmware/pyvmomi/blob/master/docs/ \ # vim/vm/guest/FileManager.rst # Script fails in that case, saying URL has an invalid label. # By having hostname in place will take take care of this. url = re.sub(r"^https://\*:", "https://" + str(args.host) + ":", url) resp = requests.put(url, data=data_to_send, verify=False) if not resp.status_code == 200: print("Error while uploading file") else: print("Successfully uploaded file") except IOError as ex: print(ex) except vmodl.MethodFault as error: print("Caught vmodl fault : " + error.msg) return -1 return 0
# Example script to reboot a VirtualMachine from tools import cli, service_instance, tasks, pchelper from pyVmomi import vim parser = cli.Parser() parser.add_optional_arguments(cli.Argument.VM_NAME, cli.Argument.DNS_NAME, cli.Argument.UUID, cli.Argument.VM_IP) args = parser.get_args() si = service_instance.connect(args) VM = None if args.uuid: VM = si.content.searchIndex.FindByUuid(None, args.uuid, True, True) elif args.dns_name: VM = si.content.searchIndex.FindByDnsName(None, args.dns_name, True) elif args.vm_ip: VM = si.content.searchIndex.FindByIp(None, args.vm_ip, True) elif args.vm_name: content = si.RetrieveContent() VM = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name) if VM is None: raise SystemExit("Unable to locate VirtualMachine.") print("Found: {0}".format(VM.name)) print("The current powerState is: {0}".format(VM.runtime.powerState)) TASK = VM.ResetVM_Task() tasks.wait_for_tasks(si, [TASK]) print("its done.")
def clone_vm(content, template, vm_name, datacenter_name, vm_folder, datastore_name, cluster_name, resource_pool, power_on, datastorecluster_name): """ Clone a VM from a template/VM, datacenter_name, vm_folder, datastore_name cluster_name, resource_pool, and power_on are all optional. """ # if none git the first one datacenter = pchelper.get_obj(content, [vim.Datacenter], datacenter_name) if vm_folder: destfolder = pchelper.search_for_obj(content, [vim.Folder], vm_folder) else: destfolder = datacenter.vmFolder if datastore_name: datastore = pchelper.search_for_obj(content, [vim.Datastore], datastore_name) else: datastore = pchelper.get_obj(content, [vim.Datastore], template.datastore[0].info.name) # if None, get the first one cluster = pchelper.search_for_obj(content, [vim.ClusterComputeResource], cluster_name) if not cluster: clusters = pchelper.get_all_obj(content, [vim.ResourcePool]) cluster = list(clusters)[0] if resource_pool: resource_pool = pchelper.search_for_obj(content, [vim.ResourcePool], resource_pool) else: resource_pool = cluster.resourcePool vmconf = vim.vm.ConfigSpec() if datastorecluster_name: podsel = vim.storageDrs.PodSelectionSpec() pod = pchelper.get_obj(content, [vim.StoragePod], datastorecluster_name) podsel.storagePod = pod storagespec = vim.storageDrs.StoragePlacementSpec() storagespec.podSelectionSpec = podsel storagespec.type = 'create' storagespec.folder = destfolder storagespec.resourcePool = resource_pool storagespec.configSpec = vmconf try: rec = content.storageResourceManager.RecommendDatastores( storageSpec=storagespec) rec_action = rec.recommendations[0].action[0] real_datastore_name = rec_action.destination.name except Exception: real_datastore_name = template.datastore[0].info.name datastore = pchelper.get_obj(content, [vim.Datastore], real_datastore_name) # set relospec relospec = vim.vm.RelocateSpec() relospec.datastore = datastore relospec.pool = resource_pool clonespec = vim.vm.CloneSpec() clonespec.location = relospec clonespec.powerOn = power_on print("cloning VM...") task = template.Clone(folder=destfolder, name=vm_name, spec=clonespec) wait_for_task(task) print("VM cloned.")