def test_0002_modify_memory(self): logged_in_org = self.client.get_org() org = Org(self.client, resource=logged_in_org) vdc_resource = org.get_vdc(self.config['vcd']['vdc']) vdc = VDC(self.client, resource=vdc_resource) assert self.config['vcd']['vdc'] == vdc.get_resource().get('name') vapp_resource = vdc.get_vapp(self.config['vcd']['vapp']) vapp = VApp(self.client, resource=vapp_resource) vm_resource = vapp.get_vm(self.config['vcd']['vm']) vm = VM(self.client, resource=vm_resource) task = vm.modify_memory(self.config['vcd']['memory']) task = self.client.get_task_monitor().wait_for_status( task=task, timeout=60, poll_frequency=2, fail_on_statuses=None, expected_target_statuses=[ TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR, TaskStatus.CANCELED], callback=None) assert task.get('status') == TaskStatus.SUCCESS.value vm.reload() assert vm.get_memory() == self.config['vcd']['memory']
def node_rollback(self, node_list): """Implements rollback for node creation failure :param list node_list: faulty nodes to be deleted """ LOGGER.info('About to rollback nodes from cluster with name: %s' % self.cluster_name) LOGGER.info('Node list to be deleted:%s' % node_list) vapp = VApp(self.client_tenant, href=self.cluster['vapp_href']) template = self.get_template() try: delete_nodes_from_cluster(self.config, vapp, template, node_list, force=True) except Exception: LOGGER.warning("Couldn't delete node %s from cluster:%s" % (node_list, self.cluster_name)) for vm_name in node_list: vm = VM(self.client_tenant, resource=vapp.get_vm(vm_name)) try: vm.undeploy() except Exception: LOGGER.warning("Couldn't undeploy VM %s" % vm_name) vapp.delete_vms(node_list) LOGGER.info('Successfully deleted nodes: %s' % node_list)
def delete_nodes_thread(self): LOGGER.debug(f"About to delete nodes from cluster with name: " f"{self.cluster_name}") try: vapp = VApp(self.tenant_client, href=self.cluster['vapp_href']) template = self._get_template() self._update_task( TaskStatus.RUNNING, message=f"Deleting " f"{len(self.req_spec.get(RequestKey.NODE_NAMES_LIST))}" f" node(s) from " f"{self.cluster_name}({self.cluster_id})") try: server_config = get_server_runtime_config() delete_nodes_from_cluster( server_config, vapp, template, self.req_spec.get(RequestKey.NODE_NAMES_LIST), self.req_spec.get(RequestKey.FORCE_DELETE)) except Exception: LOGGER.error(f"Couldn't delete node " f"{self.req_spec.get(RequestKey.NODE_NAMES_LIST)}" f" from cluster:{self.cluster_name}") self._update_task( TaskStatus.RUNNING, message=f"Undeploying " f"{len(self.req_spec.get(RequestKey.NODE_NAMES_LIST))}" f" node(s) for {self.cluster_name}({self.cluster_id})") for vm_name in self.req_spec.get(RequestKey.NODE_NAMES_LIST): vm = VM(self.tenant_client, resource=vapp.get_vm(vm_name)) try: task = vm.undeploy() self.tenant_client.get_task_monitor().wait_for_status(task) except Exception: LOGGER.warning(f"Couldn't undeploy VM {vm_name}") self._update_task( TaskStatus.RUNNING, message=f"Deleting " f"{len(self.req_spec.get(RequestKey.NODE_NAMES_LIST))}" f" VM(s) for {self.cluster_name}({self.cluster_id})") task = vapp.delete_vms(self.req_spec.get(RequestKey.NODE_NAMES_LIST)) # noqa: E501 self.tenant_client.get_task_monitor().wait_for_status(task) self._update_task( TaskStatus.SUCCESS, message=f"Deleted " f"{len(self.req_spec.get(RequestKey.NODE_NAMES_LIST))}" f" node(s) to cluster " f"{self.cluster_name}({self.cluster_id})") except Exception as e: LOGGER.error(traceback.format_exc()) error_obj = error_to_json(e) stack_trace = \ ''.join(error_obj[ERROR_MESSAGE_KEY][ERROR_STACKTRACE_KEY]) self._update_task( TaskStatus.ERROR, error_message=error_obj[ERROR_MESSAGE_KEY][ERROR_DESCRIPTION_KEY], # noqa: E501 stack_trace=stack_trace) finally: self._disconnect_sys_admin()
def test_0000_setup(self): self._config = Environment.get_config() TestVappNat._logger = Environment.get_default_logger() TestVappNat._client = Environment.get_sys_admin_client() TestVappNat._runner = CliRunner() default_org = self._config['vcd']['default_org_name'] self._login() TestVappNat._runner.invoke(org, ['use', default_org]) vapp = Environment.get_test_vapp_with_network(TestVappNat._client) vapp.reload() task = vapp.connect_vapp_network_to_ovdc_network( network_name=TestVappNat._vapp_network_name, orgvdc_network_name=TestVappNat._org_vdc_network_name) result = TestVappNat._client.get_task_monitor().wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value) vm_resource = vapp.get_vm(TestVappNat._vm_name) vm = VM(TestVappNat._client, resource=vm_resource) task = vm.add_nic(NetworkAdapterType.E1000.value, True, True, TestVappNat._vapp_network_name, IpAddressMode.MANUAL.value, TestVappNat._allocate_ip_address) result = TestVappNat._client.get_task_monitor().wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value) list_vm_interface = vapp.list_vm_interface( TestVappNat._vapp_network_name) for vm_interface in list_vm_interface: TestVappNat._vm_id = str(vm_interface['Local_id']) TestVappNat._vm_nic_id = str(vm_interface['VmNicId'])
def StopVMs(parameters, client): """ Shutdown Virtual Machines """ try: for virtual_machine in parameters['VIRTUAL_MACHINES']: vapp = GetvAppObj(parameters, client, virtual_machine) vm_resource = vapp.get_vm(virtual_machine) vm = VM(client, resource=vm_resource) state = vm.get_power_state() if state == 8: print("INFO: VM '" + virtual_machine + "' Already Powered Off") elif state == 4: print("INFO: Shutting Down VM: '" + virtual_machine + "'") vm.shutdown() else: print("INFO: VM '" + virtual_machine + "' In Unknown State, No Action Taken") except Exception as e: print("ERROR: Failed To Shutdown VM: '" + virtual_machine + "'") print(e) exit(1)
def node_rollback(self, node_list): """Rollback for node creation failure. :param list node_list: faulty nodes to be deleted """ LOGGER.info(f"About to rollback nodes from cluster with name: " "{self.cluster_name}") LOGGER.info(f"Node list to be deleted:{node_list}") vapp = VApp(self.tenant_client, href=self.cluster['vapp_href']) template = self._get_template() try: server_config = get_server_runtime_config() delete_nodes_from_cluster(server_config, vapp, template, node_list, force=True) except Exception: LOGGER.warning("Couldn't delete node {node_list} from cluster:" "{self.cluster_name}") for vm_name in node_list: vm = VM(self.tenant_client, resource=vapp.get_vm(vm_name)) try: vm.undeploy() except Exception: LOGGER.warning(f"Couldn't undeploy VM {vm_name}") vapp.delete_vms(node_list) LOGGER.info(f"Successfully deleted nodes: {node_list}")
def create_vm(vms, source_vapp_resource, vm_cfg, master_name, master=False): try: global lastMasterIp vm = vapp.get_vm(vm_cfg['name']) vm_obj = VM(client, resource=vm) ip = vm_obj.list_nics()[0]['ip_address'].ljust(20) if master: #gen_key(vm_cfg['name'],os.environ['SSH_USERNAME'],os.environ['SSH_PASSWORD'], ip) lastMasterIp = ip if vm_obj.is_powered_on() == True: print(" VM '{0}' ... OK".format(vm_cfg['name'])) else: print(" VM '{0}' ... DOWN -> starting ...\r".format( vm_cfg['name']), end='') result = vm_obj.power_on() handle_task(client, result) print(" VM '{0}' ... UP {1}".format(vm_cfg['name'], "".ljust(20))) except EntityNotFoundException: print(" VM '{0}' ... NONE -> marked for creation ...".format( vm_cfg['name'])) spec = { 'source_vm_name': vm_cfg['source_vm_name'], 'vapp': source_vapp_resource } spec['target_vm_name'] = vm_cfg['name'] spec['hostname'] = vm_cfg['hostname'] vms.append(spec)
def test_0450_enable_nested_hypervisor(self): vapp = VApp(TestVM._client, href=TestVM._test_vapp_href) self._power_off_and_undeploy(vapp=vapp) vm = VM(TestVM._sys_admin_client, href=TestVM._test_vapp_first_vm_href) task = vm.enable_nested_hypervisor() result = TestVM._client.get_task_monitor().wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def test_1002_deploy_vm(self): logged_in_org = self.client.get_org() org = Org(self.client, resource=logged_in_org) v = org.get_vdc(self.config['vcd']['vdc']) vdc = VDC(self.client, href=v.get('href')) assert self.config['vcd']['vdc'] == vdc.get_resource().get('name') vapp_resource = vdc.get_vapp(self.config['vcd']['vapp']) assert vapp_resource.get('name') == self.config['vcd']['vapp'] vapp = VApp(self.client, resource=vapp_resource) vm_resource = vapp.get_vm(self.config['vcd']['vm']) vm = VM(self.client, resource=vm_resource) result = vm.deploy() # result = vm.shutdown() task = self.client.get_task_monitor().wait_for_status( task=result, timeout=60, poll_frequency=2, fail_on_statuses=None, expected_target_statuses=[ TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR, TaskStatus.CANCELED], callback=None) assert task.get('status') == TaskStatus.SUCCESS.value
def test_1006_snapshot_create(self): logged_in_org = self.client.get_org() org = Org(self.client, resource=logged_in_org) vdc_resource = org.get_vdc(self.config['vcd']['vdc']) vdc = VDC(self.client, resource=vdc_resource) assert self.config['vcd']['vdc'] == vdc.get_resource().get('name') vapp_resource = vdc.get_vapp(self.config['vcd']['vapp']) assert vapp_resource.get('name') == self.config['vcd']['vapp'] vapp = VApp(self.client, resource=vapp_resource) vm_resource = vapp.get_vm(self.config['vcd']['vm']) assert vm_resource.get('name') == self.config['vcd']['vm'] vm = VM(self.client, resource=vm_resource) task = vm.snapshot_create(memory=False, quiesce=False) task = self.client.get_task_monitor().wait_for_status( task=task, timeout=120, poll_frequency=2, fail_on_statuses=None, expected_target_statuses=[ TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR, TaskStatus.CANCELED], callback=None) assert task.get('status') == TaskStatus.SUCCESS.value
def get_all_host(host, org, user, password, vdc): #Linux guest hosts linux_os_list = ['CentOS 7 (64-bit)', 'Ubuntu Linux (64-bit)', 'CentOS 8 (64-bit)'] #Windows guest hosts win_os_list = ['Microsoft Windows Server 2016 or later (64-bit)', 'Microsoft Windows Server 2019 (64-bit)'] #Host list of all Vapps host_list = {} client = Client(host, verify_ssl_certs=True,#SSL log_requests=False, log_headers=False, log_bodies=False) client.set_highest_supported_version() client.set_credentials(BasicLoginCredentials(user, org, password)) org_resource = client.get_org() org = Org(client, resource=org_resource) vdc_resource = org.get_vdc(vdc) vdc = VDC(client, resource=vdc_resource) vapps = vdc.list_resources() win_list = [] linux_list = [] other_os_list = [] hostvars = {} for vapp in vapps: if vapp["type"] == "application/vnd.vmware.vcloud.vApp+xml": currentHref = vdc.get_vapp_href(vapp["name"]) currentVapp = VApp(client, href=currentHref) for vm in currentVapp.get_all_vms(): vmName = vm.get('name') vmOs = VM(client, resource=vm) vOs = vmOs.get_operating_system_section() try: vmIp = currentVapp.get_primary_ip(vmName) except: pass if vmOs.is_powered_on(): if vOs.Description in win_os_list: win_list.append(vmName) hostvars.update({vmName:{'ansible_host':vmIp}}) elif vOs.Description in linux_os_list: linux_list.append(vmName) hostvars.update({vmName:{'ansible_host':vmIp}}) else: other_os_list.append(vmName) hostvars.update({vmName:{'ansible_host':vmIp}}) host_list.update({'windows':{'hosts':win_list}}) host_list.update({'linux':{'hosts':linux_list}}) host_list.update({'others':{'hosts':other_os_list}}) host_list.update({'_meta':{'hostvars':hostvars}}) return host_list
def test_0330_update_vm_capabilities(self): vm = VM(TestVM._sys_admin_client, href=TestVM._test_vapp_vmtools_vm_href) task = vm.update_vm_capabilities_section(memory_hot_add_enabled=False) result = TestVM._client.get_task_monitor().wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value) vm_capabilities_section = vm.get_vm_capabilities_section() self.assertFalse(vm_capabilities_section.MemoryHotAddEnabled)
def test_0410_list_screen_ticket(self): vm = VM(TestVM._sys_admin_client, href=TestVM._test_vapp_vmtools_vm_href) if vm.is_powered_off(): task = vm.deploy(power_on=True) TestVM._client.get_task_monitor().wait_for_success(task) dict = vm.list_screen_ticket() self.assertTrue(len(dict) > 0)
def test_0370_set_meadata(self): vm = VM(TestVM._sys_admin_client, href=TestVM._test_vapp_first_vm_href) task = vm.set_metadata(domain=MetadataDomain.GENERAL.value, visibility=MetadataVisibility.READ_WRITE, key=TestVM._metadata_key, value=TestVM._metadata_value) result = TestVM._client.get_task_monitor().wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def test_0350_update_boot_options(self): vm = VM(TestVM._sys_admin_client, href=TestVM._test_vapp_vmtools_vm_href) task = vm.update_boot_options(enter_bios_setup=False) result = TestVM._client.get_task_monitor().wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value) boot_options = vm.get_boot_options() self.assertFalse(boot_options.EnterBIOSSetup)
def test_0300_update_gc_section(self): vm = VM(TestVM._sys_admin_client, href=TestVM._test_vapp_vmtools_vm_href) task = vm.update_guest_customization_section(enabled=True) result = TestVM._client.get_task_monitor().wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value) gc_section = vm.get_guest_customization_section() self.assertTrue(gc_section.Enabled)
def test_0260_relocate(self): vm = VM(TestVM._sys_admin_client, href=TestVM._test_vapp_first_vm_href) datastore_id = TestVM._datastore_id id = datastore_id.split(':')[3] task = vm.relocate(datastore_id=id) result = TestVM._sys_admin_client. \ get_task_monitor().wait_for_success(task=task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def test_0200_get_gc_status(self): """Test the method related to get_guest_customization_status in vm.py. This test passes if it gives guest customization status. """ vm = VM(TestVM._sys_admin_client, href=TestVM._test_vapp_vmtools_vm_href) status = vm.get_guest_customization_status() self.assertEqual(status, 'GC_PENDING')
def test_0040_get_vc(self): """Test the method VM.get_vc(). This test passes if the retrieved vc name matches with the expected vc name. """ vm = VM(TestVM._sys_admin_client, href=TestVM._test_vapp_first_vm_href) retrieved_vc_name = vm.get_vc() expected_vc_name = Environment.get_config()['vc']['vcenter_host_name'] self.assertEqual(retrieved_vc_name, expected_vc_name)
def _allocate_vm_ip(self, vapp): vm_resource = vapp.get_vm(TestVApp._customized_vapp_vm_name) href = vm_resource.get('href') vm = VM(TestVApp._client, href=href) task = vm.add_nic(NetworkAdapterType.E1000.value, True, True, TestVApp._vapp_network_name, IpAddressMode.MANUAL.value, TestVApp._allocate_ip_address) result = TestVApp._client.get_task_monitor().wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def deploy_local_key(vms, source_vapp_resource, vm_cfg, master_name): try: vm = vapp.get_vm(vm_cfg['name']) vm_obj = VM(client, resource=vm) ip = vm_obj.list_nics()[0]['ip_address'].ljust(20) push_local_key(os.environ['SSH_USERNAME'], os.environ['SSH_PASSWORD'], ip, master_name) except EntityNotFoundException: print(" Cannot deploy certificate on VM '{0}'".format( vm_cfg['name']))
def test_0070_vm_snapshot_operations(self): """Test the method related to snapshot operations in vm.py. This test passes if all the snapshot operations are successful. """ logger = Environment.get_default_logger() vm_name = TestVM._test_vapp_first_vm_name vm = VM(TestVM._client, href=TestVM._test_vapp_first_vm_href) # VM.snapshot_create() logger.debug('Creating snapshot of vm ' + vm_name) task = vm.snapshot_create(memory=False, quiesce=False) result = TestVM._client.get_task_monitor().wait_for_success(task=task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value) # VM.snapshot_revert_to_current logger.debug('Reverting vm ' + vm_name + ' to it\'s snapshot.') vm.reload() task = vm.snapshot_revert_to_current() result = TestVM._client.get_task_monitor().wait_for_success(task=task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value) # VM.snapshot_remove_all() logger.debug('Removing all snapshots of vm ' + vm_name) vm.reload() task = vm.snapshot_remove_all() result = TestVM._client.get_task_monitor().wait_for_success(task=task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def test_0180_update_general_setting(self): """Test the method related to update general setting in vm.py. This test passes if general setting update successful. """ vm_name = TestVM._test_vapp_first_vm_name vm = VM(TestVM._sys_admin_client, href=TestVM._test_vapp_first_vm_href) vm.reload() # Updating general setting of vm task = vm.update_general_setting( name=TestVM._vm_name_update, description=TestVM._description_update, computer_name=TestVM._computer_name_update, boot_delay=TestVM._boot_delay_update, enter_bios_setup=TestVM._enter_bios_setup_update) result = TestVM._sys_admin_client.\ get_task_monitor().wait_for_success(task=task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value) vm.reload() result = vm.general_setting_detail() self.assertEqual(result['Name'], TestVM._vm_name_update) self.assertEqual(result['Description'], TestVM._description_update) self.assertEqual(result['Computer Name'], TestVM._computer_name_update) self.assertEqual(result['Boot Delay'], TestVM._boot_delay_update) self.assertEqual(result['Enter BIOS Setup'], TestVM._enter_bios_setup_update) # Reverting back general setting of vm task = vm.update_general_setting( name=TestVM._test_vapp_first_vm_name, description=TestVM._description, computer_name=TestVM._computer_name, boot_delay=TestVM._boot_delay, enter_bios_setup=TestVM._enter_bios_setup) result = TestVM._sys_admin_client.\ get_task_monitor().wait_for_success(task=task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def test_0061_install_vmware_tools(self): """Test the method related to install vmware tools in vm.py. This test passes if install vmware tools operation is successful. """ logger = Environment.get_default_logger() vm_name = TestVM._test_vapp_first_vm_name vm = VM(TestVM._client, href=TestVM._test_vapp_first_vm_href) logger.debug('Installing Vmware Tools in VM: ' + vm_name) task = vm.install_vmware_tools() result = TestVM._client.get_task_monitor().wait_for_success(task=task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def test_0390_update_metadata(self): # update metadata value as org admin vm = VM(TestVM._sys_admin_client, href=TestVM._test_vapp_first_vm_href) task = vm.set_metadata(domain=MetadataDomain.GENERAL.value, visibility=MetadataVisibility.READ_WRITE, key=TestVM._metadata_key, value=TestVM._metadata_new_value) TestVM._client.get_task_monitor().wait_for_success(task) entries = metadata_to_dict(vm.get_metadata()) self.assertEqual(TestVM._metadata_new_value, entries[TestVM._metadata_key])
def test_0074_delete_vm(self): """Test the method related to delete VM. This test passes if delete VM operation is successful. """ vapp = VApp(TestVM._client, href=TestVM._test_vapp_href) vm_resource = vapp.get_vm(TestVM._target_vm_name) TestVM._target_vm_href = vm_resource.get('href') vm = VM(TestVM._client, href=TestVM._target_vm_href) task = vm.delete() result = TestVM._client.get_task_monitor().wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def test_0063_eject_cd(self): """Test the method related to eject CD in vm.py. This test passes if eject CD operation is successful. """ logger = Environment.get_default_logger() vm_name = TestVM._test_vapp_first_vm_name vm = VM(TestVM._client, href=TestVM._test_vapp_first_vm_href) media_href = TestVM._media_resource.Entity.get('href') logger.debug('Ejecting CD from VM: ' + vm_name) task = vm.eject_cd(media_href) result = TestVM._client.get_task_monitor().wait_for_success(task=task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def test_0080_vm_nic_operations(self): """Test the method add_nic vm.py. This test passes if a nic is created successfully. """ vm = VM(TestVM._client, href=TestVM._test_vapp_first_vm_href) task = vm.add_nic(NetworkAdapterType.E1000.value, True, True, 'none', IpAddressMode.NONE.value, None) result = TestVM._client.get_task_monitor().wait_for_success(task=task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value) vm.reload() self.assertTrue(len(vm.list_nics()) == 2)
def generate_key(vms, source_vapp_resource, vm_cfg): try: global lastMasterIp vm = vapp.get_vm(vm_cfg['name']) vm_obj = VM(client, resource=vm) ip = vm_obj.list_nics()[0]['ip_address'].ljust(20) lastMasterIp = ip gen_key(vm_cfg['name'], os.environ['SSH_USERNAME'], os.environ['SSH_PASSWORD'], ip) except EntityNotFoundException: print(" Cannot generate certificate on VM '{0}'".format( vm_cfg['name']))
def modify_cpu(self, request): logging.info("__INIT__modify_cpu[VappVm]") res = vapp_vm_pb2.ModifyVappVmCPUResult() res.modified = False org_resource = self.client.get_org() org = Org(self.client, resource=org_resource) try: vdc_resource = org.get_vdc(request.target_vdc) vdc = VDC(self.client, name=request.target_vdc, resource=vdc_resource) vapp_resource = vdc.get_vapp(request.target_vapp) vapp = VApp(self.client, name=request.target_vapp, resource=vapp_resource) vapp_vm_resource = vapp.get_vm(request.target_vm_name) vm = VM(self.client, resource=vapp_vm_resource) self.undeploy(request) modify_cpu_response = vm.modify_cpu( request.virtual_cpus, request.cores_per_socket) task = self.client.get_task_monitor().wait_for_status( task=modify_cpu_response, timeout=60, poll_frequency=2, fail_on_statuses=None, expected_target_statuses=[ TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR, TaskStatus.CANCELED ], callback=None) st = task.get('status') if st != TaskStatus.SUCCESS.value: raise errors.VappVmModifyCPUError( etree.tostring(task, pretty_print=True)) message = 'status : {0} '.format(st) logging.info(message) self.power_on(request) res.modified = True except Exception as e: errmsg = '__ERROR_modify_cpu[VappVm] failed for VappVm {0}. __ErrorMessage__ {1}' logging.warn(errmsg.format(request.target_vm_name, str(e))) self.context.set_code(grpc.StatusCode.INVALID_ARGUMENT) self.context.set_details(errmsg) logging.info("__DONE__modify_cpu[VappVm]") return res
def modify_cpu(self, request): logging.info("__INIT__modify_cpu[VappVm]") res = vapp_vm_pb2.ModifyVappVmCPUResult() res.modified = False org_resource = self.client.get_org() org = Org(self.client, resource=org_resource) try: vdc_resource = org.get_vdc(request.target_vdc) vdc = VDC( self.client, name=request.target_vdc, resource=vdc_resource) vapp_resource = vdc.get_vapp(request.target_vapp) vapp = VApp( self.client, name=request.target_vapp, resource=vapp_resource) vapp_vm_resource = vapp.get_vm(request.target_vm_name) vm = VM(self.client, resource=vapp_vm_resource) self.undeploy(request) modify_cpu_response = vm.modify_cpu(request.virtual_cpus, request.cores_per_socket) task = self.client.get_task_monitor().wait_for_status( task=modify_cpu_response, timeout=60, poll_frequency=2, fail_on_statuses=None, expected_target_statuses=[ TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR, TaskStatus.CANCELED ], callback=None) st = task.get('status') if st != TaskStatus.SUCCESS.value: raise errors.VappVmModifyCPUError( etree.tostring(task, pretty_print=True)) message = 'status : {0} '.format(st) logging.info(message) self.power_on(request) res.modified = True except Exception as e: errmsg = '__ERROR_modify_cpu[VappVm] failed for VappVm {0}. __ErrorMessage__ {1}' logging.warn(errmsg.format(request.target_vm_name, str(e))) self.context.set_code(grpc.StatusCode.INVALID_ARGUMENT) self.context.set_details(errmsg) logging.info("__DONE__modify_cpu[VappVm]") return res
def deploy_tool(vms, source_vapp_resource, vm_cfg, master_name): try: vm = vapp.get_vm(vm_cfg['name']) vm_obj = VM(client, resource=vm) ip = vm_obj.list_nics()[0]['ip_address'].ljust(20) upgrade_os(os.environ['SSH_USERNAME'], os.environ['SSH_PASSWORD'], ip, master_name) install_sshpass(os.environ['SSH_USERNAME'], os.environ['SSH_PASSWORD'], ip, master_name) install_git(os.environ['SSH_USERNAME'], os.environ['SSH_PASSWORD'], ip, master_name) except EntityNotFoundException: print(" Cannot deploy tool on VM '{0}'".format(vm_cfg['name']))
def test_0006_undeploy(self): logged_in_org = self.client.get_org() org = Org(self.client, resource=logged_in_org) vdc_resource = org.get_vdc(self.config['vcd']['vdc']) vdc = VDC(self.client, resource=vdc_resource) assert self.config['vcd']['vdc'] == vdc.get_resource().get('name') vapp_resource = vdc.get_vapp(self.config['vcd']['vapp']) vapp = VApp(self.client, resource=vapp_resource) vm_resource = vapp.get_vm(self.config['vcd']['vm']) vm = VM(self.client, resource=vm_resource) task = vm.undeploy() task = self.client.get_task_monitor().wait_for_status(task) assert task.get('status') == TaskStatus.SUCCESS.value
def test_0160_check_compliance(self): """Test the method related to check_compliance in vm.py. This test passes if check compliance operation is successful. """ logger = Environment.get_default_logger() vm_name = TestVM._test_vapp_first_vm_name vm = VM(TestVM._sys_admin_client, href=TestVM._test_vapp_first_vm_href) vm.reload() logger.debug('Checking compliance of VM: ' + vm_name) task = vm.check_compliance() result = TestVM._sys_admin_client.\ get_task_monitor().wait_for_success(task=task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def test_0150_reload_from_vc(self): """Test the method related to reload_from_vc in vm.py. This test passes if reload from VC operation is successful. """ logger = Environment.get_default_logger() vm_name = TestVM._test_vapp_first_vm_name vm = VM(TestVM._sys_admin_client, href=TestVM._test_vapp_first_vm_href) vm.reload() logger.debug('Reloading VM: ' + vm_name + ' from VC.') task = vm.reload_from_vc() result = TestVM._sys_admin_client.\ get_task_monitor().wait_for_success(task=task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def test_0072_copy_to(self): """Test the method related to copy VM from one vapp to another. This test passes if copy VM operation is successful. """ target_vapp_name = TestVM._empty_vapp_name source_vapp_name = TestVM._test_vapp_name target_vm_name = TestVM._target_vm_name vm = VM(TestVM._client, href=TestVM._test_vapp_first_vm_href) task = vm.copy_to(source_vapp_name=source_vapp_name, target_vapp_name=target_vapp_name, target_vm_name=target_vm_name) result = TestVM._client.get_task_monitor().wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def power_off(self, request): logging.info("__INIT__power_off[VappVm]") res = vapp_vm_pb2.PowerOffVappVmResult() res.powered_off = False org_resource = self.client.get_org() org = Org(self.client, resource=org_resource) try: vdc_resource = org.get_vdc(request.target_vdc) vdc = VDC( self.client, name=request.target_vdc, resource=vdc_resource) vapp_resource = vdc.get_vapp(request.target_vapp) vapp = VApp( self.client, name=request.target_vapp, resource=vapp_resource) vapp_vm_resource = vapp.get_vm(request.target_vm_name) vm = VM(self.client, resource=vapp_vm_resource) power_off_response = vm.undeploy() task = self.client.get_task_monitor().wait_for_status( task=power_off_response, timeout=60, poll_frequency=2, fail_on_statuses=None, expected_target_statuses=[ TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR, TaskStatus.CANCELED ], callback=None) st = task.get('status') if st != TaskStatus.SUCCESS.value: raise errors.VappVmCreateError( etree.tostring(task, pretty_print=True)) message = 'status : {0} '.format(st) logging.info(message) powered_off = True except Exception as e: errmsg = '__ERROR_power_off[VappVm] failed for VappVm {0}. __ErrorMessage__ {1}' logging.warn(errmsg.format(request.target_vm_name, str(e))) logging.info("__DONE__power_off[VappVm]") return powered_off
def reset(ctx, name, vm_names): try: restore_session(ctx, vdc_required=True) client = ctx.obj['client'] vdc_href = ctx.obj['profiles'].get('vdc_href') vdc = VDC(client, href=vdc_href) vapp_resource = vdc.get_vapp(name) vapp = VApp(client, resource=vapp_resource) if len(vm_names) == 0: task = vapp.power_reset() stdout(task, ctx) else: for vm_name in vm_names: vm = VM(client, resource=vapp.get_vm(vm_name)) task = vm.power_reset() stdout(task, ctx) except Exception as e: stderr(e, ctx)
def power_off(client, target_vdc, target_vapp, target_vm_name): logging.info("__INIT__delete[VappVm]") powered_off = False org_resource = client.get_org() org = Org(client, resource=org_resource) try: vdc_resource = org.get_vdc(target_vdc) vdc = VDC(slef.client, name=target_vdc, resource=vdc_resource) vapp_resource = vdc.get_vapp(target_vapp) vapp = VApp(client, name=target_vapp, resource=vapp_resource) vapp_vm_resource = vapp.get_vm(target_vm_name) vm = VM(client, resource=vapp_vm_resource) vm.power_off() powered_off = True except Exception as e: error_message = '__ERROR_power_off[VappVm] failed for VappVm {0}. __ErrorMessage__ {1}'.format( target_vm_name, str(e)) logging.warn(error_message) return powered_off
def deploy(ctx, name, vm_names, power_on, force_customization): try: restore_session(ctx, vdc_required=True) client = ctx.obj['client'] vdc_href = ctx.obj['profiles'].get('vdc_href') vdc = VDC(client, href=vdc_href) vapp_resource = vdc.get_vapp(name) vapp = VApp(client, resource=vapp_resource) if power_on is not None: power_on = False if force_customization is not None: force_customization = True if len(vm_names) == 0: task = vapp.deploy(power_on=power_on) stdout(task, ctx) else: for vm_name in vm_names: vm = VM(client, href=vapp.get_vm(vm_name).get('href')) vm.reload() task = vm.deploy( power_on=power_on, force_customization=force_customization) stdout(task, ctx) except Exception as e: stderr(e, ctx)
def test_0071_consolidate(self): """Test the method related to consolidate in vm.py. This test passes if consolidate operation is successful. """ logger = Environment.get_default_logger() vm_name = TestVM._test_vapp_first_vm_name vm = VM(TestVM._sys_admin_client, href=TestVM._test_vapp_first_vm_href) vm.reload() if vm.is_powered_on(): task = vm.power_off() result = TestVM._sys_admin_client.\ get_task_monitor().wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value) vm.reload() logger.debug('Consolidating VM: ' + vm_name) task = vm.consolidate() result = TestVM._sys_admin_client.\ get_task_monitor().wait_for_success(task=task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def test_0090_vm_nic_delete(self): """Test the method delete_nic in vm.py This test passes if a nic is deleted successfully. """ vm = VM(TestVM._client, href=TestVM._test_vapp_first_vm_href) nics = vm.list_nics() self.assertTrue(len(nics) == 2) nic_to_delete = next(i[VmNicProperties.INDEX.value] for i in nics if i[VmNicProperties.PRIMARY.value]) task = vm.delete_nic(int(nic_to_delete)) result = TestVM._client.get_task_monitor().wait_for_success(task=task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value) vm.reload() self.assertTrue(len(vm.list_nics()) == 1)
def test_0050_customize_vm(self): """Test the methods to update and retrieve memory and cpu of a vm. The test passes if the update operations are successful and the values retrieved thereafter matches the expected values. """ logger = Environment.get_default_logger() vm_name = TestVM._test_vapp_first_vm_name vm = VM(TestVM._client, href=TestVM._test_vapp_first_vm_href) old_num_cpu_data = vm.get_cpus() self.assertEqual(old_num_cpu_data['num_cpus'], TestVM._test_vapp_first_vm_num_cpu) old_memory_size = vm.get_memory() self.assertEqual(old_memory_size, TestVM._test_vapp_first_vm_memory_size) # vm can be updated only when it's powered off if not vm.is_powered_off(): task = vm.power_off() TestVM._client.get_task_monitor().wait_for_success(task) vm.reload() logger.debug('Updating number of cpus of vm ' + vm_name + ' to ' + str(TestVM._test_vapp_first_vm_new_num_cpu)) task = vm.modify_cpu( virtual_quantity=TestVM._test_vapp_first_vm_new_num_cpu) result = TestVM._client.get_task_monitor().wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value) vm.reload() new_num_cpu_data = vm.get_cpus() self.assertEqual(new_num_cpu_data['num_cpus'], TestVM._test_vapp_first_vm_new_num_cpu) logger.debug('Updating memory size of vm ' + vm_name + ' to ' + str(TestVM._test_vapp_first_vm_new_memory_size)) task = vm.modify_memory(TestVM._test_vapp_first_vm_new_memory_size) result = TestVM._client.get_task_monitor().wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value) vm.reload() new_memory_size = vm.get_memory() self.assertEqual(new_memory_size, TestVM._test_vapp_first_vm_new_memory_size) # power the vm back on task = vm.power_on() TestVM._client.get_task_monitor().wait_for_success(task)
def test_0060_vm_power_operations(self): """Test the method related to power operations in vm.py. This test passes if all the power operations are successful. """ logger = Environment.get_default_logger() vm_name = TestVM._test_vapp_first_vm_name vm = VM(client=TestVM._client, href=TestVM._test_vapp_first_vm_href) # make sure the vm is powered on before running tests logger.debug('Making sure vm ' + vm_name + ' is powered on.') if vm.is_suspended(): task = vm.deploy() TestVM._client.get_task_monitor().wait_for_success(task=task) vm.reload() if not vm.is_powered_on(): task = vm.power_on() TestVM._client.get_task_monitor().wait_for_success(task=task) vm.reload() logger.debug('Un-deploying vm ' + vm_name) task = vm.undeploy() result = TestVM._client.get_task_monitor().wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value) logger.debug('Deploying vm ' + vm_name) vm.reload() task = vm.deploy(power_on=False) result = TestVM._client.get_task_monitor().wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value) logger.debug('Powering on vm ' + vm_name) vm.reload() task = vm.power_on() result = TestVM._client.get_task_monitor().wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value) logger.debug('Reseting (power) vm ' + vm_name) vm.reload() task = vm.power_reset() result = TestVM._client.get_task_monitor().wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value) logger.debug('Powering off vm ' + vm_name) vm.reload() task = vm.power_off() result = TestVM._client.get_task_monitor().wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value) logger.debug('Powering back on vm ' + vm_name) vm.reload() task = vm.power_on() result = TestVM._client.get_task_monitor().wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value) logger.debug('Suspend a vm ' + vm_name) vm.reload() task = vm.suspend() result = TestVM._client.get_task_monitor().wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value) logger.debug('Discard suspended state of a vm ' + vm_name) vm.reload() if vm.is_suspended(): task = vm.discard_suspended_state() result = TestVM._client.get_task_monitor().wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value) logger.debug('Powering back on vm ' + vm_name) vm.reload() if not vm.is_powered_on(): task = vm.power_on() result = TestVM._client.get_task_monitor().wait_for_success(task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
print("Fetching Org...") org_resource = client.get_org() org = Org(client, resource=org_resource) print("Fetching VDC...") vdc_resource = org.get_vdc(vdc) vdc = VDC(client, resource=vdc_resource) print("Fetching vApp...") vapp_resource = vdc.get_vapp(vapp) vapp = VApp(client, resource=vapp_resource) print("Fetching VM...") vm_resource = vapp.get_vm(vm) vm = VM(client, resource=vm_resource) print("Creating Snapshot...") snaphot_resource = vm.snapshot_create(memory=False, quiesce=False) print("Waiting for Snapshot finish...") task_monitor.wait_for_success(snaphot_resource) print("Revert Back To Current Snapshot...") vm.reload() snaphot_resource = vm.snapshot_revert_to_current() print("Waiting for Revert finish...") task_monitor.wait_for_success(snaphot_resource) print("Remove All Snapshot...") snaphot_resource = vm.snapshot_remove_all() print("Waiting for Revert finish...")
def def_0100_upgrade_virtual_hardware(self): vm = VM(TestVM._client, href=TestVM._test_vapp_first_vm_href) task = vm.upgrade_virtual_hardware() result = TestVM._client.get_task_monitor().wait_for_success(task=task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)