def setup(self): parser = sample_cli.build_arg_parser() parser.add_argument('-n', '--vm_name', action='store', help='Name of the testing vm') parser.add_argument('-clustername', '--clustername', help='The name of the cluster to be used.') parser.add_argument('-libitemname', '--libitemname', help='The name of the library item to deploy.' 'The library item should contain an OVF package.') args = sample_util.process_cli_args(parser.parse_args()) self.lib_item_name = args.libitemname self.cluster_name = args.clustername self.vm_name = args.vm_name self.servicemanager = ServiceManager(args.server, args.username, args.password, args.skipverification) self.servicemanager.connect() atexit.register(self.servicemanager.disconnect) self.client = ClsApiClient(self.servicemanager) self.helper = ClsApiHelper(self.client, args.skipverification) # Default VM name self.vm_name = 'vm-' + str(generate_random_uuid())
class ListVM(object): """ Demonstrates getting list of VMs present in vCenter Sample Prerequisites: vCenter/ESX """ def __init__(self): self.service_manager = None def setup(self): parser = sample_cli.build_arg_parser() args = sample_util.process_cli_args(parser.parse_args()) self.service_manager = ServiceManager(args.server, args.username, args.password, args.skipverification) self.service_manager.connect() atexit.register(self.service_manager.disconnect) 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 setup(self): parser = sample_cli.build_arg_parser() args = sample_util.process_cli_args(parser.parse_args()) self.service_manager = ServiceManager(args.server, args.username, args.password, args.skipverification) self.service_manager.connect() atexit.register(self.service_manager.disconnect)
class Sample(object): """ TODO: Sample description and prerequisites. e.g. Demonstrates getting list of VMs present in vCenter Sample Prerequisites: - vCenter """ def __init__(self): self.service_manager = None self.vm_name = None self.cleardata = None def setup(self): # 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('-n', '--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()) self.vm_name = args.vm_name self.cleardata = args.cleardata # Connect to both Vim and vAPI services self.service_manager = ServiceManager(args.server, args.username, args.password, args.skipverification) self.service_manager.connect() atexit.register(self.service_manager.disconnect) 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 cleanup(self): if self.cleardata: # TODO add cleanup code pass
def setup(self): # Create argument parser for standard inputs: # server, username, password, cleanup and skipverification parser = sample_cli.build_arg_parser() args = sample_util.process_cli_args(parser.parse_args()) self.service_manager = ServiceManager(args.server, args.username, args.password, args.skipverification) self.service_manager.connect() atexit.register(self.service_manager.disconnect)
def setup(self): parser = sample_cli.build_arg_parser() parser.add_argument('-n', '--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()) self.vm_name = args.vm_name self.service_manager = ServiceManager(args.server, args.username, args.password, args.skipverification) self.service_manager.connect() atexit.register(self.service_manager.disconnect)
class DeleteVM(object): """ Demonstrates Deleting User specified Virtual Machine (VM) Sample Prerequisites: vCenter/ESX """ def __init__(self): self.service_manager = None self.vm_name = None def setup(self): parser = sample_cli.build_arg_parser() parser.add_argument('-n', '--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()) self.vm_name = args.vm_name self.service_manager = ServiceManager(args.server, args.username, args.password, args.skipverification) self.service_manager.connect() atexit.register(self.service_manager.disconnect) 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 setup(self): parser = sample_cli.build_arg_parser() parser.add_argument('-n', '--vm_name', action='store', help='Name of the testing vm') args = sample_util.process_cli_args(parser.parse_args()) if args.vm_name: self.vm_name = args.vm_name self.cleardata = args.cleardata self.service_manager = ServiceManager(args.server, args.username, args.password, args.skipverification) self.service_manager.connect() atexit.register(self.service_manager.disconnect) self.stub_config = self.service_manager.stub_config
def setup(self): # Create argument parser for standard inputs: # server, username, password, cleanup and skipverification parser = sample_cli.build_arg_parser() parser.add_argument( '-o', '--operation', action='store', default='status', choices=['status', 'start', 'pause', 'resume', 'cancel'], help='Operation to execute') args = sample_util.process_cli_args(parser.parse_args()) self.operation = args.operation self.service_manager = ServiceManager(args.server, args.username, args.password, args.skipverification) self.service_manager.connect() atexit.register(self.service_manager.disconnect)
def setup(self): # 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('-n', '--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()) self.vm_name = args.vm_name self.cleardata = args.cleardata # Connect to both Vim and vAPI services self.service_manager = ServiceManager(args.server, args.username, args.password, args.skipverification) self.service_manager.connect() atexit.register(self.service_manager.disconnect)
def setup(self): parser = sample_cli.build_arg_parser() parser.add_argument('-n', '--vm_name', action='store', help='Name of the testing vm') parser.add_argument('-resourcepoolname', '--resourcepoolname', help='The name of the resource pool to be used.') parser.add_argument('-libitemname', '--libitemname', help='The name of the library item to deploy.' 'The library item should contain an OVF package.') parser.add_argument( '-vm_count', '--vm_count', help='Number of VMs to be created. By default is 1', type=int, default=1) args = sample_util.process_cli_args(parser.parse_args()) self.lib_item_name = args.libitemname self.resource_pool_name = args.resourcepoolname self.vm_name = args.vm_name self.vm_count = args.vm_count self.servicemanager = ServiceManager(args.server, args.username, args.password, args.skipverification) self.servicemanager.connect() atexit.register(self.servicemanager.disconnect) self.client = ClsApiClient(self.servicemanager) self.helper = ClsApiHelper(self.client, args.skipverification) # Default VM name if not self.vm_name: self.vm_name = 'vm-' + str(generate_random_uuid())
def get_service_manager(cls, server, username, password, skip_verification): cls.service_manager = ServiceManager(server, username, password, skip_verification) cls.service_manager.connect() return cls.service_manager
from pyVmomi import vim from samples.vsphere.common.service_manager import ServiceManager from samples.vsphere.contentlibrary.lib.cls_api_client import ClsApiClient from samples.vsphere.common.vim.helpers.vim_utils import get_obj from com.vmware.content.library_client import Item from com.vmware.vcenter.ovf_client import LibraryItem vm_name = '' rp_name = '' template_name = '' esx_host = '' api_host = '' api_user = '' api_pass = '' service_manager = ServiceManager(api_host, api_user, api_pass, True) service_manager.connect() client = ClsApiClient(service_manager) find_spec = Item.FindSpec(name=template_name) ovf_template_id = client.library_item_service.find(find_spec)[0] target = get_obj(service_manager.content, [vim.HostSystem], esx_host) rp = get_obj(service_manager.content, [vim.ResourcePool], rp_name) deployment_target = LibraryItem.DeploymentTarget( host_id=target._GetMoId(), resource_pool_id=rp._GetMoId()) deployment_spec = LibraryItem.ResourcePoolDeploymentSpec(name=template_name + '_deployed', accept_all_eula=True) client.ovf_lib_item_service.deploy(ovf_template_id, deployment_target, deployment_spec)
class DeployOvfTemplate: """ Demonstrates the workflow to deploy an OVF library item to a resource pool. Note: the sample needs an existing library item with an OVF template and an existing cluster with resources for deploying the VM. """ def __init__(self): self.servicemanager = None self.client = None self.helper = None self.resource_pool_name = None self.lib_item_name = None self.vm_obj = None self.vm_name = None self.vm_count = None def setup(self): parser = sample_cli.build_arg_parser() parser.add_argument('-n', '--vm_name', action='store', help='Name of the testing vm') parser.add_argument('-resourcepoolname', '--resourcepoolname', help='The name of the resource pool to be used.') parser.add_argument('-libitemname', '--libitemname', help='The name of the library item to deploy.' 'The library item should contain an OVF package.') parser.add_argument( '-vm_count', '--vm_count', help='Number of VMs to be created. By default is 1', type=int, default=1) args = sample_util.process_cli_args(parser.parse_args()) self.lib_item_name = args.libitemname self.resource_pool_name = args.resourcepoolname self.vm_name = args.vm_name self.vm_count = args.vm_count self.servicemanager = ServiceManager(args.server, args.username, args.password, args.skipverification) self.servicemanager.connect() atexit.register(self.servicemanager.disconnect) self.client = ClsApiClient(self.servicemanager) self.helper = ClsApiHelper(self.client, args.skipverification) # Default VM name if not self.vm_name: self.vm_name = 'vm-' + str(generate_random_uuid()) def execute(self): # Find the resource pool's moid resource_pool_obj = get_obj(self.servicemanager.content, [vim.ResourcePool], self.resource_pool_name) assert resource_pool_obj is not None print("Resource Pool Moref: {0}".format(resource_pool_obj)) deployment_target = LibraryItem.DeploymentTarget( resource_pool_id=resource_pool_obj._GetMoId()) lib_item_id = self.helper.get_item_id_by_name(self.lib_item_name) assert lib_item_id ovf_summary = self.client.ovf_lib_item_service.filter( ovf_library_item_id=lib_item_id, target=deployment_target) print('Found an OVF template :{0} to deploy.'.format(ovf_summary.name)) # Deploy the ovf template self.deploy_ovf_template(lib_item_id, ovf_summary, deployment_target) def deploy_ovf_template(self, lib_item_id, ovf_summary, deployment_target): # Build the deployment spec deployment_spec = LibraryItem.ResourcePoolDeploymentSpec( name=self.vm_name, annotation=ovf_summary.annotation, accept_all_eula=True, network_mappings=None, storage_mappings=None, storage_provisioning=None, storage_profile_id=None, locale=None, flags=None, additional_parameters=None, default_datastore_id=None) # Deploy the ovf template result = self.client.ovf_lib_item_service.deploy( lib_item_id, deployment_target, deployment_spec, client_token=generate_random_uuid()) # The type and ID of the target deployment is available in the deployment result. if result.succeeded: print( 'Deployment successful. Result resource: {0}, ID: {1}'.format( result.resource_id.type, result.resource_id.id)) self.vm_id = result.resource_id.id error = result.error if error is not None: for warning in error.warnings: print('OVF warning: {}'.format(warning.message)) # Power on the VM and wait for the power on operation to be completed self.vm_obj = get_obj_by_moId(self.servicemanager.content, [vim.VirtualMachine], self.vm_id) assert self.vm_obj is not None poweron_vm(self.servicemanager.content, self.vm_obj) else: print('Deployment failed.') for error in result.error.errors: print('OVF error: {}'.format(error.message)) def cleanup(self): if self.vm_obj is not None: # Power off the VM and wait for the power off operation to complete poweroff_vm(self.servicemanager.content, self.vm_obj) # Delete the VM delete_object(self.servicemanager.content, self.vm_obj)
class ImportHistorySampleCli(object): """ Sample demonstrating how the API for the upgrade's Defer History Data Import feature can be used. To use this feature you need to have an appliance upgrade or migrated to the 6.7 or later version, using the option for transferring historical data after upgrade. """ def __init__(self): self.service_manager = None self.operation = None def setup(self): # Create argument parser for standard inputs: # server, username, password, cleanup and skipverification parser = sample_cli.build_arg_parser() parser.add_argument( '-o', '--operation', action='store', default='status', choices=['status', 'start', 'pause', 'resume', 'cancel'], help='Operation to execute') args = sample_util.process_cli_args(parser.parse_args()) self.operation = args.operation self.service_manager = ServiceManager(args.server, args.username, args.password, args.skipverification) self.service_manager.connect() atexit.register(self.service_manager.disconnect) def run(self): """ Runs the requested operation """ # Using REST API service import_history = ImportHistory(self.service_manager.stub_config) if self.operation == 'status': get_defer_history_import_status(import_history) return try: operations = { 'start': import_history.start, 'pause': import_history.pause, 'resume': import_history.resume, 'cancel': import_history.cancel } print('Executing operation "{0}"'.format(self.operation)) if self.operation in operations: operations[self.operation]() print('Executing operation "{0}" was successful'.format( self.operation)) else: print('Unknown operation {0}'.format(self.operation)) except AlreadyInDesiredState: print('The Defer History Data Import is already in the ' 'desired state.') except Error as error: print('Request "{0}" returned error.'.format(self.operation)) for err in error.messages: print('Error: {0}'.format(get_message_as_text(err))) def cleanup(self): # Nothing to clean up pass
class CreateDefaultVM(object): """ Demonstrates how to create a VM with system provided defaults Sample Prerequisites: - datacenter - vm folder - datastore """ def __init__(self, stub_config=None, placement_spec=None): self.context = None self.service_manager = None self.stub_config = stub_config self.placement_spec = placement_spec self.vm_name = testbed.config['VM_NAME_DEFAULT'] self.cleardata = None def setup(self): parser = sample_cli.build_arg_parser() parser.add_argument('-n', '--vm_name', action='store', help='Name of the testing vm') args = sample_util.process_cli_args(parser.parse_args()) if args.vm_name: self.vm_name = args.vm_name self.cleardata = args.cleardata self.service_manager = ServiceManager(args.server, args.username, args.password, args.skipverification) self.service_manager.connect() atexit.register(self.service_manager.disconnect) self.stub_config = self.service_manager.stub_config 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 cleanup(self): vm = get_vm(self.stub_config, self.vm_name) if vm: power_svc = Power(self.stub_config) vm_svc = VM(self.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(self.vm_name, vm)) vm_svc.delete(vm)
class CreateExhaustiveVM(object): """ Demonstrates how to create a exhaustive VM with the below configuration: 3 disks, 2 nics, 2 vcpu, 2 GB, memory, boot=BIOS, 1 cdrom, 1 serial port, 1 parallel port, 1 floppy, boot_device=[CDROM, DISK, ETHERNET]) Sample Prerequisites: - datacenter - vm folder - resource pool - datastore - standard switch network - distributed switch network - An iso file on the datastore mentioned above """ def __init__(self, stub_config=None, placement_spec=None, standard_network=None, distributed_network=None): self.context = None self.service_manager = None self.stub_config = stub_config self.placement_spec = placement_spec self.standard_network = standard_network self.distributed_network = distributed_network self.vm_name = testbed.config['VM_NAME_EXHAUSTIVE'] self.cleardata = None def setup(self): parser = sample_cli.build_arg_parser() parser.add_argument('-n', '--vm_name', action='store', help='Name of the testing vm') args = sample_util.process_cli_args(parser.parse_args()) if args.vm_name: self.vm_name = args.vm_name self.cleardata = args.cleardata self.service_manager = ServiceManager(args.server, args.username, args.password, args.skipverification) self.service_manager.connect() atexit.register(self.service_manager.disconnect) self.stub_config = self.service_manager.stub_config 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.stub_config, datacenter_name, vm_folder_name, datastore_name) # Get a standard network backing if not self.standard_network: self.standard_network = network_helper.get_standard_network_backing( self.stub_config, std_portgroup_name, datacenter_name) # Get a distributed network backing if not self.distributed_network: self.distributed_network = network_helper.get_distributed_network_backing( self.stub_config, dv_portgroup_name, datacenter_name) """ 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_svc = VM(self.stub_config) vm = vm_svc.create(vm_create_spec) print("create_exhaustive_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 cleanup(self): vm = get_vm(self.stub_config, self.vm_name) if vm: power_svc = Power(self.stub_config) vm_svc = VM(self.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(self.vm_name, vm)) vm_svc.delete(vm)
class CreateBasicVM(object): """ Demonstrates how to create a basic VM with following configuration: 2 disks, 1 nic Sample Prerequisites: - datacenter - vm folder - datastore - standard switch network """ def __init__(self, stub_config=None, placement_spec=None): self.context = None self.service_manager = None self.stub_config = stub_config self.placement_spec = placement_spec self.vm_name = testbed.config['VM_NAME_BASIC'] self.cleardata = None def setup(self): parser = sample_cli.build_arg_parser() parser.add_argument('-n', '--vm_name', action='store', help='Name of the testing vm') args = sample_util.process_cli_args(parser.parse_args()) if args.vm_name: self.vm_name = args.vm_name self.cleardata = args.cleardata self.service_manager = ServiceManager(args.server, args.username, args.password, args.skipverification) self.service_manager.connect() atexit.register(self.service_manager.disconnect) self.stub_config = self.service_manager.stub_config 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 cleanup(self): vm = get_vm(self.stub_config, self.vm_name) if vm: power_svc = Power(self.stub_config) vm_svc = VM(self.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(self.vm_name, vm)) vm_svc.delete(vm)
class ImportHistorySample(object): """ Sample demonstrating how one can change the state of the Defer History Data Import using its vAPI. To use this feature you need to have an appliance upgrade or migrated to the 6.7 or later version, using the option for transferring historical data after upgrade. """ def __init__(self): self.service_manager = None def setup(self): # Create argument parser for standard inputs: # server, username, password, cleanup and skipverification parser = sample_cli.build_arg_parser() args = sample_util.process_cli_args(parser.parse_args()) self.service_manager = ServiceManager(args.server, args.username, args.password, args.skipverification) self.service_manager.connect() atexit.register(self.service_manager.disconnect) def run(self): """ Runs the sample's operations """ try: # Using REST API service import_history = ImportHistory(self.service_manager.stub_config) # Change the status - either pause or resume it start_status = get_defer_history_import_status(import_history) if start_status == Status.RUNNING: print('Pausing Defer History Data Import.') import_history.pause() expected_status = Status.PAUSED revert_operation = import_history.resume elif start_status == Status.PAUSED: print('Resuming Defer History Data Import.') import_history.resume() expected_status = Status.RUNNING revert_operation = import_history.pause else: print('Sample can only work if the status of Defer History ' 'Data Import is paused or running, current status ' 'is: {0}'.format(start_status)) return after_ops_status = get_defer_history_import_status(import_history) if after_ops_status == expected_status: print('Operation finished successfully.') else: print('Executed operation did not bring the process in ' 'desired state. Current status is "{0}". ' 'Aborting'.format(after_ops_status)) return # revert to the original status print('Reverting to original state.') revert_operation() get_defer_history_import_status(import_history) except AlreadyInDesiredState: print('The Defer History Data Import is already in the ' 'desired state.') except Error as error: for err in error.messages: print('Error: {0}'.format(get_message_as_text(err))) def cleanup(self): # Nothing to clean up pass