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 _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_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 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 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_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 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_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_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_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)
