def run(self): # Get a placement spec datacenter_name = testbed.config['VM_DATACENTER_NAME'] vm_folder_name = testbed.config['VM_FOLDER2_NAME'] datastore_name = testbed.config['VM_DATASTORE_NAME'] if not self.placement_spec: self.placement_spec = vm_placement_helper.get_placement_spec_for_resource_pool( self.stub_config, datacenter_name, vm_folder_name, datastore_name) """ Create a default VM. Using the provided PlacementSpec, create a VM with a selected Guest OS and provided name. Use all the guest and system provided defaults. """ guest_os = testbed.config['VM_GUESTOS'] vm_create_spec = VM.CreateSpec(name=self.vm_name, guest_os=guest_os, placement=self.placement_spec) print( '\n# Example: create_default_vm: Creating a VM using spec\n-----') print(pp(vm_create_spec)) print('-----') vm_svc = VM(self.stub_config) vm = vm_svc.create(vm_create_spec) print("create_default_vm: Created VM '{}' ({})".format( self.vm_name, vm)) vm_info = vm_svc.get(vm) print('vm.get({}) -> {}'.format(vm, pp(vm_info))) return vm
def get_vms(stub_config, vm_names): """Return identifiers of a list of vms""" vm_svc = VM(stub_config) vms = vm_svc.list(VM.FilterSpec(names=vm_names)) if len(vms) == 0: print('No vm found') return None print("Found VMs '{}' ({})".format(vm_names, vms)) return vms
def run(self): """ List VMs present in server """ vm_svc = VM(self.service_manager.stub_config) list_of_vms = vm_svc.list() print("----------------------------") print("List Of VMs") print("----------------------------") pprint(list_of_vms) print("----------------------------")
def run(self): # TODO add your sample code here # Using REST API service vm_service = VM(self.service_manager.stub_config) filter_spec = VM.FilterSpec(names=set([self.vm_name])) vms = vm_service.list(filter_spec) print(vms) # Using Vim API service (pyVmomi) current_time = self.service_manager.si.CurrentTime() print(current_time)
def run(): """ List VMs present in server """ vm_svc = VM(stub_config) list_of_vms = vm_svc.list() print("----------------------------") print("List Of VMs") print("----------------------------") for vm in list_of_vms: print('{}'.format(vm)) print("----------------------------")
def create_basic_vm(stub_config, placement_spec, standard_network): """ Create a basic VM. Using the provided PlacementSpec, create a VM with a selected Guest OS and provided name. Create a VM with the following configuration: * Create 2 disks and specify one of them on scsi0:0 since it's the boot disk * Specify 1 ethernet adapter using a Standard Portgroup backing * Setup for PXE install by selecting network as first boot device Use guest and system provided defaults for most configuration settings. """ guest_os = testbed.config['VM_GUESTOS'] boot_disk = Disk.CreateSpec(type=Disk.HostBusAdapterType.SCSI, scsi=ScsiAddressSpec(bus=0, unit=0), new_vmdk=Disk.VmdkCreateSpec()) data_disk = Disk.CreateSpec(new_vmdk=Disk.VmdkCreateSpec()) nic = Ethernet.CreateSpec(start_connected=True, backing=Ethernet.BackingSpec( type=Ethernet.BackingType.STANDARD_PORTGROUP, network=standard_network)) # TODO Should DISK be put before ETHERNET? Does the BIOS automatically try # the next device if the DISK is empty? boot_device_order = [ BootDevice.EntryCreateSpec(BootDevice.Type.ETHERNET), BootDevice.EntryCreateSpec(BootDevice.Type.DISK) ] vm_create_spec = VM.CreateSpec(name=vm_name, guest_os=guest_os, placement=placement_spec, disks=[boot_disk, data_disk], nics=[nic], boot_devices=boot_device_order) print('\n# Example: create_basic_vm: Creating a VM using spec\n-----') print(pp(vm_create_spec)) print('-----') vm_svc = VM(stub_config) vm = vm_svc.create(vm_create_spec) print("create_basic_vm: Created VM '{}' ({})".format(vm_name, vm)) vm_info = vm_svc.get(vm) print('vm.get({}) -> {}'.format(vm, pp(vm_info))) return vm
def cleanup(): vm = get_vm(stub_config, vm_name) if vm: power_svc = Power(stub_config) vm_svc = VM(stub_config) state = power_svc.get(vm) if state == Power.Info(state=Power.State.POWERED_ON): power_svc.stop(vm) elif state == Power.Info(state=Power.State.SUSPENDED): power_svc.start(vm) power_svc.stop(vm) print("Deleting VM '{}' ({})".format(vm_name, vm)) vm_svc.delete(vm)
def get_details(allnames, filename='serverlist.yaml', debugoutput=True): """Get the details""" import sys from com.vmware.vcenter_client import VM from com.vmware.cis.tagging_client import TagAssociation from com.vmware.vapi import std_client vsphere_client = connect_vsphere() names_chunks = chunks(allnames, 100) results = [] for names in names_chunks: names = set(names) vms = vsphere_client.vcenter.VM.list(VM.FilterSpec(names=names)) if debugoutput: sys.stdout.write('-') sys.stdout.flush() for vmserver in vms: if debugoutput: sys.stdout.write('.') sys.stdout.flush() result = {} taglist = TagAssociation(connect_cis()) taglist = taglist.list_attached_tags( std_client.DynamicID(type="VirtualMachine", id=vmserver.vm) ) name = names.pop() result[name] = {} result[name] = taglist write_dict_to_file(result, filename) results.append(result) return results
def get_vm(stub_config, vm_name): """ Return the identifier of a vm Note: The method assumes that there is only one vm with the mentioned name. """ vm_svc = VM(stub_config) names = set([vm_name]) vms = vm_svc.list(VM.FilterSpec(names=names)) if len(vms) == 0: print("VM with name ({}) not found".format(vm_name)) return None vm = vms[0].vm print("Found VM '{}' ({})".format(vm_name, vm)) return vm
def get_placement_spec_for_resource_pool(stub_config, datacenter_name, vm_folder_name, datastore_name): """ Returns a VM placement spec for a resourcepool. Ensures that the vm folder and datastore are all in the same datacenter which is specified. """ resource_pool = resource_pool_helper.get_resource_pool(stub_config, datacenter_name) folder = folder_helper.get_folder(stub_config, datacenter_name, vm_folder_name) datastore = datastore_helper.get_datastore(stub_config, datacenter_name, datastore_name) # Create the vm placement spec with the datastore, resource pool and vm # folder placement_spec = VM.PlacementSpec(folder=folder, resource_pool=resource_pool, datastore=datastore) print("get_placement_spec_for_resource_pool: Result is '{}'". format(placement_spec)) return placement_spec
def __init__(self, service_manager): # Client for all the services on a management node. self.service_manager = service_manager # Returns the service which provides support for generic functionality # which can be applied equally to all types of libraries self.library_service = Library(self.service_manager.stub_config) # Returns the service for managing local libraries self.local_library_service = LocalLibrary(self.service_manager.stub_config) # Returns the service for managing subscribed libraries self.subscribed_library_service = SubscribedLibrary(self.service_manager.stub_config) # Returns the service for managing library items self.library_item_service = Item(self.service_manager.stub_config) # Returns the service for managing sessions to update or delete content self.upload_service = UpdateSession(self.service_manager.stub_config) # Returns the service for managing files within an update session self.upload_file_service = UpdateSessionFile(self.service_manager.stub_config) # Returns the service for managing sessions to download content self.download_service = DownloadSession(self.service_manager.stub_config) # Returns the service for managing files within a download session self.download_file_service = DownloadSessionFile(self.service_manager.stub_config) # Returns the service for deploying virtual machines from OVF library items self.ovf_lib_item_service = LibraryItem(self.service_manager.stub_config) # Returns the service for mount and unmount of an iso file on a VM self.iso_service = Image(self.service_manager.stub_config) # Returns the service for managing subscribed library items self.subscribed_item_service = SubscribedItem(self.service_manager.stub_config) # Returns the service for managing library items containing virtual # machine templates self.vmtx_service = VmtxLibraryItem(self.service_manager.stub_config) # Returns the service for managing subscription information of # the subscribers of a published library. self.subscriptions = Subscriptions(self.service_manager.stub_config) # Creates the service that communicates with virtual machines self.vm_service = VM(self.service_manager.stub_config) # Returns the service for managing checkouts of a library item containing # a virtual machine template self.check_outs_service = CheckOuts(self.service_manager.stub_config) # Returns the service for managing the live versions of the virtual machine # templates contained in a library item self.versions_service = Versions(self.service_manager.stub_config) # Returns the service for managing the history of content changes made # to a library item self.changes_service = Changes(self.service_manager.stub_config)
def run(self): # TODO add your sample code here # Using REST API service filter_spec = VM.FilterSpec(names=set([self.vm_name])) vms = self.client.vcenter.VM.list(filter_spec) print(vms)
def get_vms(client, vm_names): """Return identifiers of a list of vms""" vms = client.vcenter.VM.list(VM.FilterSpec(names=vm_names)) if len(vms) == 0: print('No vm found') return None print("Found VMs '{}' ({})".format(vm_names, vms)) return vms
def run(self): """ Delete User specified VM from Server """ vm_svc = VM(self.service_manager.stub_config) power_svc = Power(self.service_manager.stub_config) vm = get_vm(self.service_manager.stub_config, self.vm_name) if not vm: raise Exception('Sample requires an existing vm with name ({}).' 'Please create the vm first.'.format(vm_name)) print("Deleting VM -- '{}-({})')".format(self.vm_name, vm)) state = power_svc.get(vm) if state == Power.Info(state=Power.State.POWERED_ON): power_svc.stop(vm) elif state == Power.Info(state=Power.State.SUSPENDED): power_svc.start(vm) power_svc.stop(vm) vm_svc.delete(vm) print("Deleted VM -- '{}-({})".format(self.vm_name, vm))
def create_default_vm(stub_config, placement_spec): """ Create a default VM. Using the provided PlacementSpec, create a VM with a selected Guest OS and provided name. Use all the guest and system provided defaults. """ guest_os = testbed.config['VM_GUESTOS'] vm_create_spec = VM.CreateSpec(name=vm_name, guest_os=guest_os, placement=placement_spec) print('\n# Example: create_default_vm: Creating a VM using spec\n-----') print(pp(vm_create_spec)) print('-----') vm_svc = VM(stub_config) vm = vm_svc.create(vm_create_spec) print("create_default_vm: Created VM '{}' ({})".format(vm_name, vm)) vm_info = vm_svc.get(vm) print('vm.get({}) -> {}'.format(vm, pp(vm_info))) return vm
def __init__(self, service_manager): # Client for all the services on a management node. self.service_manager = service_manager # Returns the service which provides support for generic functionality # which can be applied equally to all types of libraries self.library_service = Library(self.service_manager.stub_config) # Returns the service for managing local libraries self.local_library_service = LocalLibrary( self.service_manager.stub_config) # Returns the service for managing subscribed libraries self.subscribed_library_service = SubscribedLibrary( self.service_manager.stub_config) # Returns the service for managing library items self.library_item_service = Item(self.service_manager.stub_config) # Returns the service for managing sessions to update or delete content self.upload_service = UpdateSession(self.service_manager.stub_config) # Returns the service for managing files within an update session self.upload_file_service = UpdateSessionFile( self.service_manager.stub_config) # Returns the service for managing sessions to download content self.download_service = DownloadSession( self.service_manager.stub_config) # Returns the service for managing files within a download session self.download_file_service = DownloadSessionFile( self.service_manager.stub_config) # Returns the service for deploying virtual machines from OVF library items self.ovf_lib_item_service = LibraryItem( self.service_manager.stub_config) # Returns the service for mount and unmount of an iso file on a VM self.iso_service = Image(self.service_manager.stub_config) # Returns the service for managing subscribed library items self.subscribed_item_service = SubscribedItem( self.service_manager.stub_config) # Returns the service for managing library items containing virtual # machine templates self.vmtx_service = VmtxLibraryItem(self.service_manager.stub_config) # Creates the service that communicates with virtual machines self.vm_service = VM(self.service_manager.stub_config)
def create_vm_api(request): datacenter_name = 'BlueKing' vm_folder_name = 'test' datastore_name = 'esxi-1-hdd' # session = get_unverified_session() session = requests.session() session.verify = False urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) client = create_vsphere_client(server='10.12.33.9', username='******', password='******', session=session) # client = create_vsphere_client(server='10.12.0.3', # username=r'*****@*****.**', # password=r'p@ssw0rd', # session=session) placement_spec = get_placement_spec_for_resource_pool( client, datacenter_name, vm_folder_name, datastore_name) rec_data = json.loads(request.body.decode('utf-8'), strict=False) guest_os = "WINDOWS_9" vm_name = rec_data['name'] memory = Memory.UpdateSpec(size_mib=int(rec_data['memory']) * 1024) disk = Disk.CreateSpec(new_vmdk=Disk.VmdkCreateSpec( capacity=int(rec_data['disk']) * 1024 * 1024 * 1024)) vm_create_spec = VM.CreateSpec(name=vm_name, guest_os=guest_os, memory=memory, disks=[disk], placement=placement_spec) vm = client.vcenter.VM.create(vm_create_spec) print("create_default_vm: Created VM '{}' ({})".format(vm_name, vm)) vm_info = client.vcenter.VM.get(vm) if (vm_info): return JsonResponse({ 'code': 200, 'data': "create_default_vm: Created VM '{}' ({})".format(vm_name, vm) }) else: return JsonResponse({'code': 500, 'message': "error"})
def run(self): # Get a placement spec datacenter_name = 'Datacenter' # testbed.config['VM_DATACENTER_NAME'] # vm_folder_name = 'kong111_166' #testbed.config['VM_FOLDER2_NAME'] datastore_name = 'datastore-717' # testbed.config['VM_DATASTORE_NAME'] std_portgroup_name = 'VM Network' # testbed.config['STDPORTGROUP_NAME'] host = 'host-716' diskprovisioningtpye = DiskProvisioningType('eagerZeroedThick') if not self.placement_spec: # self.placement_spec = vm_placement_helper.get_placement_spec_for_resource_pool( # self.client, # datacenter_name, # vm_folder_name, # datastore_name) self.placement_spec = VM.PlacementSpec(host=host, datastore=datastore_name, folder='group-v3') # Get a standard network backing standard_network = network_helper.get_network_backing( self.client, std_portgroup_name, datacenter_name, Network.Type.STANDARD_PORTGROUP) """ Create a basic VM. Using the provided PlacementSpec, create a VM with a selected Guest OS and provided name. Create a VM with the following configuration: * Create 2 disks and specify one of them on scsi0:0 since it's the boot disk * Specify 1 ethernet adapter using a Standard Portgroup backing * Setup for PXE install by selecting network as first boot device Use guest and system provided defaults for most configuration settings. """ guest_os = 'CENTOS_6_64' # testbed.config['VM_GUESTOS'] hardware = '' # boot_disk = Disk.CreateSpec(type=Disk.HostBusAdapterType.SCSI, # scsi=ScsiAddressSpec(bus=0, unit=0), # new_vmdk=Disk.VmdkCreateSpec()) data_disk = Disk.CreateSpec(new_vmdk=Disk.VmdkCreateSpec( capacity=self.cap)) nic = Ethernet.CreateSpec( start_connected=True, backing=Ethernet.BackingSpec( type=Ethernet.BackingType.STANDARD_PORTGROUP, network=standard_network)) sata_adapt = Sata.CreateSpec() cpu = Cpu.UpdateSpec(count=self.cpu, cores_per_socket=1, hot_add_enabled=True, hot_remove_enabled=True) memory = Memory.UpdateSpec(size_mib=self.memory, hot_add_enabled=True) # boot_device_order = [ # BootDevice.EntryCreateSpec(BootDevice.Type.ETHERNET), # BootDevice.EntryCreateSpec(BootDevice.Type.DISK)] # host1=Host.list() # print (host1) placement = VM.PlacementSpec(host=host, datastore=datastore_name, folder='group-v3') vm_create_spec = VM.CreateSpec(name=self.vm_name, guest_os=guest_os, cpu=cpu, memory=memory, placement=placement, disks=[data_disk], nics=[nic], sata_adapters=[sata_adapt]) print('\n# Example: create_basic_vm: Creating a VM using spec\n-----') print(pp(vm_create_spec)) print('-----') vm = self.client.vcenter.VM.create(vm_create_spec) print("create_basic_vm: Created VM '{}' ({})".format(self.vm_name, vm)) vm_info = self.client.vcenter.VM.get(vm) print('vm.get({}) -> {}'.format(vm, pp(vm_info))) self.client.vcenter.vm.Power.start(vm) return vm
session = requests.session() # Disable cert verification for demo purpose. # This is not recommended in a production environment. session.verify = False # Disable the secure connection warning for demo purpose. # This is not recommended in a production environment. urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) # Connect to a vCenter Server using username and password config = VsCreadential.load('.credentials.yaml') client = create_vsphere_client(server=config.hostname, username=config.username, password=config.password, session=session) vm = 'TESTVM' vm = client.vcenter.VM.list(VM.FilterSpec(names=set(['TESTVM'])))[0] vm_info = client.vcenter.VM.get(vm.vm) print('vm.get({}) -> {}'.format(vm, vm_info)) state = client.vcenter.vm.Power.get(vm.vm) if state == Power.Info(state=Power.State.POWERED_ON): client.vcenter.vm.Power.stop(vm.vm) elif state == Power.Info(state=Power.State.SUSPENDED): client.vcenter.vm.Power.start(vm.vm) client.vcenter.vm.Power.stop(vm.vm) client.vcenter.VM.delete(vm.vm) print("Deleted VM -- '{}-({})".format('TESTVM', vm.vm))
def run(self): # Get a placement spec datacenter_name = testbed.config['VM_DATACENTER_NAME'] vm_folder_name = testbed.config['VM_FOLDER2_NAME'] datastore_name = testbed.config['VM_DATASTORE_NAME'] std_portgroup_name = testbed.config['STDPORTGROUP_NAME'] dv_portgroup_name = testbed.config['VDPORTGROUP1_NAME'] if not self.placement_spec: self.placement_spec = vm_placement_helper.get_placement_spec_for_resource_pool( self.client, datacenter_name, vm_folder_name, datastore_name) # Get a standard network backing if not self.standard_network: self.standard_network = network_helper.get_network_backing( self.client, std_portgroup_name, datacenter_name, Network.Type.STANDARD_PORTGROUP) # Get a distributed network backing if not self.distributed_network: self.distributed_network = network_helper.get_network_backing( self.client, dv_portgroup_name, datacenter_name, Network.Type.DISTRIBUTED_PORTGROUP) """ Create an exhaustive VM. Using the provided PlacementSpec, create a VM with a selected Guest OS and provided name. Create a VM with the following configuration: * Hardware Version = VMX_11 (for 6.0) * CPU (count = 2, coresPerSocket = 2, hotAddEnabled = false, hotRemoveEnabled = false) * Memory (size_mib = 2 GB, hotAddEnabled = false) * 3 Disks and specify each of the HBAs and the unit numbers * (capacity=40 GB, name=<some value>, spaceEfficient=true) * Specify 2 ethernet adapters, one using a Standard Portgroup backing and the other using a DISTRIBUTED_PORTGROUP networking backing. * nic1: Specify Ethernet (macType=MANUAL, macAddress=<some value>) * nic2: Specify Ethernet (macType=GENERATED) * 1 CDROM (type=ISO_FILE, file="os.iso", startConnected=true) * 1 Serial Port (type=NETWORK_SERVER, file="tcp://localhost/16000", startConnected=true) * 1 Parallel Port (type=HOST_DEVICE, startConnected=false) * 1 Floppy Drive (type=CLIENT_DEVICE) * Boot, type=BIOS * BootDevice order: CDROM, DISK, ETHERNET Use guest and system provided defaults for remaining configuration settings. """ guest_os = testbed.config['VM_GUESTOS'] iso_datastore_path = testbed.config['ISO_DATASTORE_PATH'] serial_port_network_location = \ testbed.config['SERIAL_PORT_NETWORK_SERVER_LOCATION'] GiB = 1024 * 1024 * 1024 GiBMemory = 1024 vm_create_spec = VM.CreateSpec( guest_os=guest_os, name=self.vm_name, placement=self.placement_spec, hardware_version=Hardware.Version.VMX_11, cpu=Cpu.UpdateSpec(count=2, cores_per_socket=1, hot_add_enabled=False, hot_remove_enabled=False), memory=Memory.UpdateSpec(size_mib=2 * GiBMemory, hot_add_enabled=False), disks=[ Disk.CreateSpec(type=Disk.HostBusAdapterType.SCSI, scsi=ScsiAddressSpec(bus=0, unit=0), new_vmdk=Disk.VmdkCreateSpec(name='boot', capacity=40 * GiB)), Disk.CreateSpec(new_vmdk=Disk.VmdkCreateSpec( name='data1', capacity=10 * GiB)), Disk.CreateSpec(new_vmdk=Disk.VmdkCreateSpec( name='data2', capacity=10 * GiB)) ], nics=[ Ethernet.CreateSpec( start_connected=True, mac_type=Ethernet.MacAddressType.MANUAL, mac_address='11:23:58:13:21:34', backing=Ethernet.BackingSpec( type=Ethernet.BackingType.STANDARD_PORTGROUP, network=self.standard_network)), Ethernet.CreateSpec( start_connected=True, mac_type=Ethernet.MacAddressType.GENERATED, backing=Ethernet.BackingSpec( type=Ethernet.BackingType.DISTRIBUTED_PORTGROUP, network=self.distributed_network)), ], cdroms=[ Cdrom.CreateSpec(start_connected=True, backing=Cdrom.BackingSpec( type=Cdrom.BackingType.ISO_FILE, iso_file=iso_datastore_path)) ], serial_ports=[ Serial.CreateSpec( start_connected=False, backing=Serial.BackingSpec( type=Serial.BackingType.NETWORK_SERVER, network_location=serial_port_network_location)) ], parallel_ports=[ Parallel.CreateSpec(start_connected=False, backing=Parallel.BackingSpec( type=Parallel.BackingType.HOST_DEVICE)) ], floppies=[ Floppy.CreateSpec(backing=Floppy.BackingSpec( type=Floppy.BackingType.CLIENT_DEVICE)) ], boot=Boot.CreateSpec(type=Boot.Type.BIOS, delay=0, enter_setup_mode=False), # TODO Should DISK be put before CDROM and ETHERNET? Does the BIOS # automatically try the next device if the DISK is empty? boot_devices=[ BootDevice.EntryCreateSpec(BootDevice.Type.CDROM), BootDevice.EntryCreateSpec(BootDevice.Type.DISK), BootDevice.EntryCreateSpec(BootDevice.Type.ETHERNET) ]) print( '# Example: create_exhaustive_vm: Creating a VM using spec\n-----') print(pp(vm_create_spec)) print('-----') vm = self.client.vcenter.VM.create(vm_create_spec) print("create_exhaustive_vm: Created VM '{}' ({})".format( self.vm_name, vm)) vm_info = self.client.vcenter.VM.get(vm) print('vm.get({}) -> {}'.format(vm, pp(vm_info))) return vm
def get_placement_spec_for_resource_pool(context): # Select a ResourcePool meeting our requirements datacenter_name = context.testbed.config['DATACENTER2_NAME'] datacenter = context.testbed.entities['DATACENTER_IDS'][datacenter_name] filter = ResourcePool.FilterSpec(datacenters=set([datacenter])) resource_pool_summaries = context.client.vcenter.ResourcePool.list( filter=filter) if len(resource_pool_summaries) > 0: resource_pool = resource_pool_summaries[0].resource_pool print('Selecting ResourcePool ({})'.format(resource_pool)) else: print("ResourcePool not found in Datacenter '{}'".format( datacenter_name)) return None # Select a Folder meeting our requirements. # # Must be in the same Datacenter as the ResourcePool that was chosen. datacenter_name = context.testbed.config['DATACENTER2_NAME'] datacenter = context.testbed.entities['DATACENTER_IDS'][datacenter_name] folder_name = context.testbed.config['VM_FOLDER2_NAME'] filter = Folder.FilterSpec(names=set([folder_name]), datacenters=set([datacenter])) folder_summaries = context.client.vcenter.Folder.list(filter=filter) if len(folder_summaries) > 0: folder = folder_summaries[0].folder print("Selecting Folder '{}' ({})".format(folder_name, folder)) else: print("Folder '{}' not found".format(folder_name)) return None # Select a Datastore meeting our requirements. # # Must be in the same Datacenter as the ResourcePool that was chosen. datacenter_name = context.testbed.config['DATACENTER2_NAME'] datacenter = context.testbed.entities['DATACENTER_IDS'][datacenter_name] # TODO Parameterize based on NFS or VMFS datastore_name = context.testbed.config['NFS_DATASTORE_NAME'] filter = Datastore.FilterSpec(names=set([datastore_name]), datacenters=set([datacenter])) datastore_summaries = context.client.vcenter.Datastore.list(filter=filter) if len(datastore_summaries) > 0: datastore = datastore_summaries[0].datastore print("Selecting Datastore '{}' ({})".format(datastore_name, datastore)) else: print("Datastore '{}' not found".format(datastore_name)) return None placement_spec = VM.PlacementSpec(folder=folder, resource_pool=resource_pool, datastore=datastore) print("get_placement_spec_for_resourcepool: Result is '{}'".format( placement_spec)) return placement_spec
def _get_vm_filter_spec(self): vm_filter_spec = VM.FilterSpec() datacenters = self.get_option('datacenters') if datacenters: temp_dcs = [] for datacenter_name in datacenters: dc_filter_spec = Datacenter.FilterSpec( names=set([datacenter_name])) datacenter_summaries = self.pyv.rest_content.vcenter.Datacenter.list( dc_filter_spec) if len(datacenter_summaries) > 0: temp_dcs.append(datacenter_summaries[0].datacenter) else: self._handle_error(message="Unable to find datacenter %s" % datacenter_name) vm_filter_spec.datacenters = set(temp_dcs) clusters = self.get_option('clusters') if clusters: temp_clusters = [] for cluster_name in clusters: ccr_filter_spec = Cluster.FilterSpec(names=set([cluster_name])) cluster_summaries = self.pyv.rest_content.vcenter.Cluster.list( ccr_filter_spec) if len(cluster_summaries) > 0: temp_clusters.append(cluster_summaries[0].cluster) else: self._handle_error(message="Unable to find cluster %s" % cluster_name) vm_filter_spec.clusters = set(temp_clusters) folders = self.get_option('folders') if folders: temp_folders = [] for folder_name in folders: folder_filter_spec = Folder.FilterSpec( names=set([folder_name])) folder_summaries = self.pyv.rest_content.vcenter.Folder.list( folder_filter_spec) if len(folder_summaries) > 0: temp_folders.append(folder_summaries[0].folder) else: self._handle_error(message="Unable to find folder %s" % folder_name) vm_filter_spec.folders = set(temp_folders) esxi_hosts = self.get_option('esxi_hostsystems') if esxi_hosts: temp_hosts = [] for esxi_name in esxi_hosts: esxi_filter_spec = Host.FilterSpec(names=set([esxi_name])) esxi_summaries = self.pyv.rest_content.vcenter.Host.list( esxi_filter_spec) if len(esxi_summaries) > 0: temp_hosts.append(esxi_summaries[0].host) else: self._handle_error( message="Unable to find esxi hostsystem %s" % esxi_name) vm_filter_spec.folders = set(temp_hosts) resource_pools = self.get_option('resource_pools') if resource_pools: temp_rps = [] for rp_name in resource_pools: rp_filter_spec = ResourcePool.FilterSpec(names=set([rp_name])) rp_summaries = self.pyv.rest_content.vcenter.ResourcePool.list( rp_filter_spec) if len(rp_summaries) > 0: temp_rps.append(rp_summaries[0].resourcepool) else: self._handle_error( message="Unable to find resource pool %s" % rp_name) vm_filter_spec.folders = set(temp_rps) return vm_filter_spec
client.vcenter.Host.list() # Display VMs client.vcenter.VM.list() # Display Datastores client.vcenter.Datastore.list() # Display Single Datastore client.vcenter.Datastore.get('datastore-13') # Create Basic VM from com.vmware.vcenter_client import VM # Create VM Specification vmSpec = VM.CreateSpec() vmSpec vmSpec.guest_os = 'WINDOWS_9_64' vmSpec.name = 'CODE2219U' # Create VM Placement Specification placementSpec = VM.PlacementSpec() #placementSpec placementSpec.resource_pool = 'resgroup-8' placementSpec.datastore = 'datastore-13' placementSpec.folder = 'group-v9' # Add Placement Specification to VM Specification vmSpec.placement = placementSpec
def run(self): # Get a placement spec datacenter_name = testbed.config['VM_DATACENTER_NAME'] vm_folder_name = testbed.config['VM_FOLDER2_NAME'] datastore_name = testbed.config['VM_DATASTORE_NAME'] std_portgroup_name = testbed.config['STDPORTGROUP_NAME'] if not self.placement_spec: self.placement_spec = vm_placement_helper.get_placement_spec_for_resource_pool( self.stub_config, datacenter_name, vm_folder_name, datastore_name) # Get a standard network backing standard_network = network_helper.get_standard_network_backing( self.stub_config, std_portgroup_name, datacenter_name) """ Create a basic VM. Using the provided PlacementSpec, create a VM with a selected Guest OS and provided name. Create a VM with the following configuration: * Create 2 disks and specify one of them on scsi0:0 since it's the boot disk * Specify 1 ethernet adapter using a Standard Portgroup backing * Setup for PXE install by selecting network as first boot device Use guest and system provided defaults for most configuration settings. """ guest_os = testbed.config['VM_GUESTOS'] boot_disk = Disk.CreateSpec(type=Disk.HostBusAdapterType.SCSI, scsi=ScsiAddressSpec(bus=0, unit=0), new_vmdk=Disk.VmdkCreateSpec()) data_disk = Disk.CreateSpec(new_vmdk=Disk.VmdkCreateSpec()) nic = Ethernet.CreateSpec( start_connected=True, backing=Ethernet.BackingSpec( type=Ethernet.BackingType.STANDARD_PORTGROUP, network=standard_network)) boot_device_order = [ BootDevice.EntryCreateSpec(BootDevice.Type.ETHERNET), BootDevice.EntryCreateSpec(BootDevice.Type.DISK) ] vm_create_spec = VM.CreateSpec(name=self.vm_name, guest_os=guest_os, placement=self.placement_spec, disks=[boot_disk, data_disk], nics=[nic], boot_devices=boot_device_order) print('\n# Example: create_basic_vm: Creating a VM using spec\n-----') print(pp(vm_create_spec)) print('-----') vm_svc = VM(self.stub_config) vm = vm_svc.create(vm_create_spec) print("create_basic_vm: Created VM '{}' ({})".format(self.vm_name, vm)) vm_info = vm_svc.get(vm) print('vm.get({}) -> {}'.format(vm, pp(vm_info))) return vm
def get_placement_spec_for_cluster(context): """ Cluster names are not guaranteed to be unique within a vCenter instance, so we qualify our search using the Datacenter. If Folders are used, the search must be qualified using Folders since a Cluster name is not guaranteed to be unique across different Folders within a Datacenter. """ # Select a Cluster meeting our requirements datacenter_name = context.testbed.config['DATACENTER2_NAME'] datacenter = context.testbed.entities['DATACENTER_IDS'][datacenter_name] cluster_name = context.testbed.config['CLUSTER1_NAME'] filter = Cluster.FilterSpec(names=set([cluster_name]), datacenters=set([datacenter])) cluster_summaries = context.client.vcenter.Cluster.list(filter=filter) if len(cluster_summaries) > 0: cluster = cluster_summaries[0].cluster print("Selecting Cluster '{}' ({})".format(cluster_name, cluster)) else: print("Cluster '{}' not found".format(cluster_name)) return None # Select a Folder meeting our requirements. # # Must be in the same Datacenter as the Cluster that was chosen. datacenter_name = context.testbed.config['DATACENTER2_NAME'] datacenter = context.testbed.entities['DATACENTER_IDS'][datacenter_name] folder_name = context.testbed.config['VM_FOLDER2_NAME'] filter = Folder.FilterSpec(names=set([folder_name]), datacenters=set([datacenter])) folder_summaries = context.client.vcenter.Folder.list(filter=filter) if len(folder_summaries) > 0: folder = folder_summaries[0].folder print("Selecting Folder '{}' ({})".format(folder_name, folder)) else: print("Folder '{}' not found".format(folder_name)) return None # Select a Datastore meeting our requirements. # # Must be in the same Datacenter as the Cluster that was chosen. # TODO No way to validate that Cluster is connected to Datastore datacenter_name = context.testbed.config['DATACENTER2_NAME'] datacenter = context.testbed.entities['DATACENTER_IDS'][datacenter_name] # TODO Parameterize based on NFS or VMFS datastore_name = context.testbed.config['NFS_DATASTORE_NAME'] filter = Datastore.FilterSpec(names=set([datastore_name]), datacenters=set([datacenter])) datastore_summaries = context.client.vcenter.Datastore.list(filter=filter) if len(datastore_summaries) > 0: datastore = datastore_summaries[0].datastore print("Selecting Datastore '{}' ({})".format(datastore_name, datastore)) else: print("Datastore '{}' not found".format(datastore_name)) return None placement_spec = VM.PlacementSpec(folder=folder, cluster=cluster, datastore=datastore) print("get_placement_spec_for_cluster: Result is '{}'".format( placement_spec)) return placement_spec
def run(self): # Using vAPI to find VM. filter_spec = VM.FilterSpec(names=set([self.vm_name])) vms = self.client.vcenter.VM.list(filter_spec) if len(vms) != 1: raise Exception('Could not locate the required VM with name ' + self.vm_name + '. Please create the vm first.') if vms[0].power_state != 'POWERED_ON': raise Exception('VM is not powered on: ' + vms[0].power_state) vm_id = vms[0].vm # Check that vmtools svc (non-interactive user) is running. info = self.client.vcenter.vm.guest.Operations.get(vm_id) if info.guest_operations_ready is not True: raise Exception( 'VMware Tools/open-vm-tools is not running as required.') # Establish the user credentials that will be needed for all Guest Ops # APIs. creds = Credentials(interactive_session=False, user_name=self.root_user, password=self.root_passwd, type=Credentials.Type.USERNAME_PASSWORD) # Step 2 - Create a temporary directory from which to run the command # and capture any output tempDir = self.client.vcenter.vm.guest.filesystem.Directories.create_temporary( vm_id, creds, '', '', parent_path=None) # Step 3 - Create temproary files to reveive stdout and stderr # as needed. stdout = self.client.vcenter.vm.guest.filesystem.Files.create_temporary( vm_id, creds, '', '.stdout', parent_path=tempDir) stderr = self.client.vcenter.vm.guest.filesystem.Files.create_temporary( vm_id, creds, '', '.stderr', parent_path=tempDir) # Step 4 - (Optional) copy in the script to be run. # While optional, using this step to demo tranfer of a # file to a guest. scriptPath = self.client.vcenter.vm.guest.filesystem.Files.create_temporary( vm_id, creds, '', '.sh', tempDir) # Create script contents and transfer to the guest. # TODO: Need generic pick up of script content baseFN = os.path.basename(scriptPath) script = ('#! /bin/bash\n' '# ' + baseFN + '\n' '\n' 'sleep 5 # Adding a little length to the process.\n' 'ps -ef\n' 'echo\n' 'rpm -qa | sort\n' '\n') print(script) attr = self._fileAttributeCreateSpec_Linux(size=len(script), overwrite=True, permissions='0755') spec = self._create_transfer_spec(path=scriptPath, attributes=attr) toURL = self.client.vcenter.vm.guest.filesystem.Transfers.create( vm_id, creds, spec) res = self._upload(toURL, script) # Check that the uploaded file size is correct. info = self.client.vcenter.vm.guest.filesystem.Files.get( vm_id, creds, scriptPath) if info.size != len(script): raise Exception('Uploaded file size not as epected.') # Step 5 - Start the program on the guest, capturing stdout and stderr # in the separate temp files obtained earlier. options = (" > " + stdout + " 2> " + stderr) spec = self._process_create_spec(scriptPath, args=options, dir=tempDir) pid = self.client.vcenter.vm.guest.Processes.create(vm_id, creds, spec) print('process created with pid: %s\n' % pid) # Step 6 # Need a loop to wait for the process to finish to handle longer # running processes. while True: time.sleep(1.0) try: # List the single process for pid. result = self.client.vcenter.vm.guest.Processes.get( vm_id, creds, pid) if result.exit_code is not None: print('Command: ' + result.command) print('Exit code: %s\n' % result.exit_code) break if result.finished is None: print('Process with pid %s is still running.' % pid) continue except Exception as e: raise e # Step 7 Copy out the results (stdout). spec = self._create_transfer_spec(path=stdout) # create the download URL fromURL = self.client.vcenter.vm.guest.filesystem.Transfers.create( vm_id, creds, spec) body = self._download(fromURL, expectedLen=info.size) print("----------- stdout ------------------") print(body) print("---------------------------------------") # Optionally the contents of "stderr" could be downloaded. # And finally, clean up the temporary files and directories on the # Linux guest. Deleting the temporary diretory and its contents. self.client.vcenter.vm.guest.filesystem.Directories.delete( vm_id, creds, tempDir, recursive=True)
session = requests.session() # Disable cert verification for demo purpose. # This is not recommended in a production environment. session.verify = False # Disable the secure connection warning for demo purpose. # This is not recommended in a production environment. urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) # Connect to a vCenter Server using username and password config = VsCreadential.load('.credentials.yaml') client = create_vsphere_client(server=config.hostname, username=config.username, password=config.password, session=session) rac1_vm = client.vcenter.VM.list(VM.FilterSpec(names=set(['RAC1'])))[0] rac1_vm_info = client.vcenter.VM.get(rac1_vm.vm) print(rac1_vm_info) scsi_summaries = client.vcenter.vm.hardware.adapter.Scsi.list(vm=rac1_vm.vm) for s in scsi_summaries: x = client.vcenter.vm.hardware.adapter.Scsi.get(vm=rac1_vm.vm, adapter=s.adapter) print(x) GiB = 1024 * 1024 * 1024 GiBMemory = 1024 def pp(value): """ Utility method used to print the data nicely. """ output = cStringIO() PrettyPrinter(stream=output).pprint(value)
Sample Prerequisites: - vCenter """ # Create argument parser for standard inputs: # server, username, password, cleanup and skipverification parser = sample_cli.build_arg_parser() # Add your custom input arguments parser.add_argument('--vm_name', action='store', default='Sample_Default_VM_for_Simple_Testbed', help='Name of the testing vm') args = sample_util.process_cli_args(parser.parse_args()) # Skip server cert verification if needed. # This is not recommended in production code. session = get_unverified_session() if args.skipverification else None # Connect to vSphere client client = create_vsphere_client(server=args.server, username=args.username, password=args.password, session=session) # List VMs filter_spec = VM.FilterSpec(names=set([args.vm_name])) vms = client.vcenter.VM.list(filter_spec) print(vms)