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 test_100_instantiate_vapp_identical(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')
result = vdc.instantiate_vapp(self.config['vcd']['vapp'],
self.config['vcd']['catalog'],
self.config['vcd']['template'],
network=self.config['vcd']['network'],
fence_mode='bridged',
deploy=True,
power_on=False,
identical=True)
task = self.client.get_task_monitor().wait_for_status(
task=result.Tasks.Task[0],
timeout=60,
poll_frequency=2,
fail_on_status=None,
expected_target_statuses=[
TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
assert task.get('status') == TaskStatus.SUCCESS.value
# vdc.reload()
vdc.resource = vdc.client.get_resource(vdc.href)
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
vm = vapp_resource.xpath('//vcloud:VApp/vcloud:Children/vcloud:Vm',
namespaces=NSMAP)
assert len(vm) > 0
assert vm[0].get('name') == self.config['vcd']['vm']
def get_org_name_from_ovdc_id(sysadmin_client: vcd_client.Client, vdc_id):
"""Get org_name from vdc_id using OVDC_TO_ORG_MAP.
Update OVDC_TO_ORG_MAP for new {org_name:vdc_id} pair
:param vdc_id: unique ovdc id
:return: org_name
:rtype: str
"""
raise_error_if_not_sysadmin(sysadmin_client)
if vdc_id in OVDC_TO_ORG_MAP:
return OVDC_TO_ORG_MAP.get(vdc_id)
vdc_href = f"{sysadmin_client.get_api_uri()}/vdc/{vdc_id}"
vdc_resource = sysadmin_client.get_resource(get_admin_href(vdc_href))
vdc_obj = VDC(sysadmin_client, resource=vdc_resource)
link = vcd_client.find_link(vdc_obj.get_resource(),
vcd_client.RelationType.UP,
vcd_client.EntityType.ADMIN_ORG.value)
org = vcd_org.Org(sysadmin_client, href=link.href)
OVDC_TO_ORG_MAP[vdc_id] = org.get_name()
return org.get_name()
def get_org_name_href_from_ovdc_id(sysadmin_client: vcd_client.Client, vdc_id):
"""Get org name and href from vdc_id using OVDC_TO_ORG_MAP.
Update OVDC_TO_ORG_MAP for new vdc_id
:param pyvcloud.vcd.client.Client sysadmin_client:
:param vdc_id: unique ovdc id
:return: org's name and href
:rtype: dict
"""
raise_error_if_user_not_from_system_org(sysadmin_client)
if vdc_id in OVDC_TO_ORG_MAP:
return OVDC_TO_ORG_MAP.get(vdc_id)
vdc_href = f"{sysadmin_client.get_api_uri()}/vdc/{vdc_id}"
vdc_resource = sysadmin_client.get_resource(get_admin_href(vdc_href))
vdc_obj = VDC(sysadmin_client, resource=vdc_resource)
link = vcd_client.find_link(vdc_obj.get_resource(),
vcd_client.RelationType.UP,
vcd_client.EntityType.ADMIN_ORG.value)
org_href = link.href
org = vcd_org.Org(sysadmin_client, href=org_href)
org_name = org.get_name()
result = {'name': org_name, 'href': org_href}
OVDC_TO_ORG_MAP[vdc_id] = result
return result
def test_060_attach_disk_to_vm_in_vapp(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 self.config['vcd']['vapp'] == vapp_resource.get('name')
vapp = VApp(self.client, resource=vapp_resource)
disk = vdc.get_disk(self.config['vcd']['idisk_name'])
result = vapp.attach_disk_to_vm(disk_href=disk.get('href'),
vm_name=self.config['vcd']['vm'])
task = self.client.get_task_monitor().wait_for_status(
task=result,
timeout=60,
poll_frequency=2,
fail_on_status=None,
expected_target_statuses=[
TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
assert task.get('status') == TaskStatus.SUCCESS.value
def test_060_attach_disk_to_vm_in_vapp(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 self.config['vcd']['vapp'] == vapp_resource.get('name')
vapp = VApp(self.client, resource=vapp_resource)
disk = vdc.get_disk(self.config['vcd']['idisk_name'])
result = vapp.attach_disk_to_vm(disk_href=disk.get('href'),
vm_name=self.config['vcd']['vm'])
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_001_instantiate_vapp(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')
result = vdc.instantiate_vapp(
self.config['vcd']['vapp'],
self.config['vcd']['catalog'],
self.config['vcd']['template'],
network='net2',
fence_mode='natRouted',
deploy=False,
power_on=False)
task = self.client.get_task_monitor().wait_for_status(
task=result.Tasks.Task[0],
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_100_instantiate_vapp_identical(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')
result = vdc.instantiate_vapp(
self.config['vcd']['vapp'],
self.config['vcd']['catalog'],
self.config['vcd']['template'],
network=self.config['vcd']['network'],
fence_mode='bridged',
deploy=True,
power_on=False,
identical=True)
task = self.client.get_task_monitor().wait_for_status(
task=result.Tasks.Task[0],
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
vdc.reload()
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
vm = vapp_resource.xpath(
'//vcloud:VApp/vcloud:Children/vcloud:Vm', namespaces=NSMAP)
assert len(vm) > 0
assert vm[0].get('name') == self.config['vcd']['vm']
def test_0001_modify_cpu(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_cpu(self.config['vcd']['cpu'],
self.config['vcd']['cores_per_socket'])
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()
cpus = vm.get_cpus()
assert cpus['num_cpus'] == self.config['vcd']['cpu']
assert cpus['num_cores_per_socket'] == self.config['vcd'][
'cores_per_socket']
def get_org_name_from_ovdc_id(vdc_id):
"""Get org_name from vdc_id using OVDC_TO_ORG_MAP.
Update OVDC_TO_ORG_MAP for new {org_name:vdc_id} pair
:param vdc_id: unique ovdc id
:return: org_name
:rtype: str
"""
if vdc_id in OVDC_TO_ORG_MAP:
org_name = OVDC_TO_ORG_MAP.get(vdc_id)
else:
client = None
try:
client = get_sys_admin_client()
vdc_href = f"{client._uri}/vdc/{vdc_id}"
vdc_resource = client.get_resource(get_admin_href(vdc_href))
vdc_obj = VDC(client, resource=vdc_resource)
link = find_link(vdc_obj.get_resource(), RelationType.UP,
EntityType.ADMIN_ORG.value)
org = Org(client, href=link.href)
OVDC_TO_ORG_MAP[vdc_id] = org.get_name()
org_name = org.get_name()
finally:
if client:
client.logout
return org_name
def test_0002_add_vm(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, href=vdc_resource.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)
catalog_item = org.get_catalog_item(self.config['vcd']['catalog'],
self.config['vcd']['template'])
source_vapp_resource = self.client.get_resource(
catalog_item.Entity.get('href'))
spec = {'source_vm_name': self.config['vcd']['vm'],
'vapp': source_vapp_resource}
spec['target_vm_name'] = self.config['vcd']['hostname']
spec['hostname'] = self.config['vcd']['hostname']
spec['network'] = self.config['vcd']['network']
spec['ip_allocation_mode'] = self.config['vcd']['ip_allocation_mode']
spec['storage_profile'] = vdc.get_storage_profile(
self.config['vcd']['storage_profile'])
vms = [spec]
result = vapp.add_vms(vms)
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_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_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 connect_org_vdc_network(self,
orgvdc_network_name,
retain_ip=None,
is_deployed=None,
fence_mode=FenceMode.BRIDGED.value):
"""Connect the vapp to an orgvdc network.
:param orgvdc_network_name: (str): name of the orgvdc network to be
connected
:param retain_ip: (bool): True if the network resources such as
IP/MAC of router will be retained across deployments.
:param is_deployed: (bool): True if this orgvdc network has been
deployed.
:param fence_mode: (str): Controls connectivity to the parent
network. One of bridged, isolated or natRouted. bridged by default.
:return: A :class:`lxml.objectify.StringElement` object representing
the asynchronous task that is connecting the network.
:raises: Exception: If orgvdc network does not exist in the vdc or if
it is already connected to the vapp.
"""
vdc = VDC(self.client,
href=find_link(self.resource, RelationType.UP,
EntityType.VDC.value).href)
orgvdc_networks = \
vdc.list_orgvdc_network_resources(orgvdc_network_name)
if len(orgvdc_networks) == 0:
raise EntityNotFoundException(
"Orgvdc network \'%s\' does not exist in vdc "
"\'%s\'" %
(orgvdc_network_name, vdc.get_resource().get('name')))
orgvdc_network_href = orgvdc_networks[0].get('href')
network_configuration_section = \
deepcopy(self.resource.NetworkConfigSection)
matched_orgvdc_network_config = \
self._search_for_network_config_by_name(
orgvdc_network_name, network_configuration_section)
if matched_orgvdc_network_config is not None:
raise InvalidStateException(
"Orgvdc network \'%s\' is already connected to "
"vapp." % orgvdc_network_name)
configuration = E.Configuration(
E.ParentNetwork(href=orgvdc_network_href), E.FenceMode(fence_mode))
if retain_ip is not None:
configuration.append(E.RetainNetInfoAcrossDeployments(retain_ip))
network_config = E.NetworkConfig(configuration,
networkName=orgvdc_network_name)
if is_deployed is not None:
network_config.append(E.IsDeployed(is_deployed))
network_configuration_section.append(network_config)
return self.client.put_linked_resource(
self.resource.NetworkConfigSection, RelationType.EDIT,
EntityType.NETWORK_CONFIG_SECTION.value,
network_configuration_section)
def test_get_vdc(self):
org_to_use = self.client.get_org_by_name(
self.config['vcd']['org_to_use'])
org = Org(self.client, href=org_to_use.get('href'))
resource = org.get_vdc(self.config['vcd']['new_vdc'])
assert resource is not None
vdc = VDC(self.client, resource=resource)
assert self.config['vcd']['new_vdc'] == vdc.get_resource().get('name')
def test_get_vdc(self):
org_to_use = self.client.get_org_by_name(
self.config['vcd']['org_to_use'])
org = Org(self.client, href=org_to_use.get('href'))
resource = org.get_vdc(self.config['vcd']['new_vdc'])
assert resource is not None
vdc = VDC(self.client, resource=resource)
assert self.config['vcd']['new_vdc'] == vdc.get_resource().get('name')
def test_1000_delete_vapp(self):
org_resource = self.client.get_org_by_name(
self.config['vcd']['org_to_use'])
self.logger.debug('org: %s' % org_resource.get('name'))
org = Org(self.client, href=org_resource.get('href'))
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')
result = vdc.delete_vapp(self.config['vcd']['vapp'], force=True)
task = self.client.get_task_monitor().wait_for_status(task=result)
assert task.get('status') == TaskStatus.SUCCESS.value
def test_0007_delete(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)
task = vapp.delete_vms([self.config['vcd']['vm']])
task = self.client.get_task_monitor().wait_for_status(task)
assert task.get('status') == TaskStatus.SUCCESS.value
def test_0007_delete(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)
task = vapp.delete_vms([self.config['vcd']['vm']])
task = self.client.get_task_monitor().wait_for_status(task)
assert task.get('status') == TaskStatus.SUCCESS.value
def test_110_instantiate_vapp_custom_disk_size(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')
result = vdc.instantiate_vapp(
self.config['vcd']['vapp'],
self.config['vcd']['catalog'],
self.config['vcd']['template'],
network=self.config['vcd']['network'],
fence_mode='bridged',
deploy=True,
power_on=False,
disk_size=self.config['vcd']['disk_size_new'])
task = self.client.get_task_monitor().wait_for_status(
task=result.Tasks.Task[0],
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
vdc.resource = vdc.client.get_resource(vdc.href)
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
vms = vapp_resource.xpath(
'//vcloud:VApp/vcloud:Children/vcloud:Vm', namespaces=NSMAP)
assert len(vms) > 0
items = vms[0].xpath(
'//ovf:VirtualHardwareSection/ovf:Item',
namespaces={
'ovf': NSMAP['ovf']
})
assert len(items) > 0
found_disk = False
for item in items:
if item['{' + NSMAP['rasd'] + '}ResourceType'] == 17: # NOQA
found_disk = True
assert item['{' + NSMAP['rasd'] + '}VirtualQuantity'] == \
(self.config['vcd']['disk_size_new'] * 1024 * 1024)
break
# this check makes sure that the vm isn't disk-less
assert found_disk
# cleanup
self.test_100_delete_vapp()
def test_0001_create_vapp(self):
org_resource = self.client.get_org_by_name(
self.config['vcd']['org_to_use'])
self.logger.debug('org: %s' % org_resource.get('name'))
org = Org(self.client, href=org_resource.get('href'))
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')
result = vdc.create_vapp(self.config['vcd']['vapp'],
network=self.config['vcd']['network'],
fence_mode=self.config['vcd']['fence_mode'])
task = self.client.get_task_monitor().wait_for_status(
task=result.Tasks.Task[0])
assert task.get('status') == TaskStatus.SUCCESS.value
def get_pvdc_id(ovdc: VDC):
"""Get id of pvdc backing an ovdc.
:param pyvcloud.vcd.VDC ovdc: This ovdc object has to be created with a
sys admin client.
:return: pvdc id
:rtype: str
"""
raise_error_if_user_not_from_system_org(ovdc.client)
pvdc_element = ovdc.get_resource().ProviderVdcReference
pvdc_id = pvdc_element.get('id')
return extract_id(pvdc_id)
def test_1000_delete_vapp(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')
result = vdc.delete_vapp(self.config['vcd']['vapp'], force=True)
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_0003_get_vm_info(self):
org_resource = self.client.get_org_by_name(
self.config['vcd']['org_to_use'])
self.logger.debug('org: %s' % org_resource.get('name'))
org = Org(self.client, href=org_resource.get('href'))
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 self.config['vcd']['vapp'] == vapp_resource.get('name')
vapp = VApp(self.client, resource=vapp_resource)
vm_name = self.config['vcd']['hostname']
vm_resource = vapp.get_vm(vm_name)
self.logger.debug('vm name: %s' % vm_resource.get('name'))
vm = VM(self.client, resource=vm_resource)
vcenter = vm.get_vc()
self.logger.debug('vCenter: %s' % vcenter)
assert vcenter == self.config['vcd']['vcenter']
def test_1000_delete_vapp(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')
result = vdc.delete_vapp(self.config['vcd']['vapp'], force=True)
task = self.client.get_task_monitor().wait_for_status(
task=result,
timeout=60,
poll_frequency=2,
fail_on_status=None,
expected_target_statuses=[
TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
assert task.get('status') == TaskStatus.SUCCESS.value
def test_0005_power_off(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.power_off()
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
def test_011_update_vapp_network(self):
logged_in_org = self.client.get_org()
org = Org(self.client, org_resource=logged_in_org)
v = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, vdc_href=v.get('href'))
assert self.config['vcd']['vdc'] == vdc.get_resource().get('name')
vapp = vdc.get_vapp(self.config['vcd']['vapp'])
assert self.config['vcd']['vapp'] == vapp.get('name')
result = vdc.reconfigure_vapp_network(self.config['vcd']['vapp'],
'net2',
self.config['vcd']['fence_mode'])
task = self.client.get_task_monitor().wait_for_status(
task=result,
timeout=60,
poll_frequency=2,
fail_on_status=None,
expected_target_statuses=[
TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
assert task.get('status') == TaskStatus.SUCCESS.value
def get_pvdc_id(sysadmin_client: vcd_client.Client, ovdc: VDC):
"""Get id of pvdc backing an ovdc.
:param pyvcloud.vcd.VDC ovdc: This ovdc object has to be created with a
sys admin client.
:return: pvdc id
:rtype: str
"""
raise_error_if_not_sysadmin(sysadmin_client)
pvdc_element = ovdc.get_resource().ProviderVdcReference
# To support <= VCD 9.1 where no 'id' is present in pvdc
# element, it has to be extracted from href. Once VCD 9.1 support
# is discontinued, this code is not required.
if float(sysadmin_client.get_api_version()) < float(vcd_client.ApiVersion.VERSION_31.value): # noqa: E501
pvdc_href = pvdc_element.get('href')
return pvdc_href.split("/")[-1]
else:
pvdc_id = pvdc_element.get('id')
return extract_id(pvdc_id)
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_0002_add_vm(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, href=vdc_resource.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)
catalog_item = org.get_catalog_item(self.config['vcd']['catalog'],
self.config['vcd']['template'])
source_vapp_resource = self.client.get_resource(
catalog_item.Entity.get('href'))
spec = {
'source_vm_name': self.config['vcd']['vm'],
'vapp': source_vapp_resource
}
spec['target_vm_name'] = self.config['vcd']['hostname']
spec['hostname'] = self.config['vcd']['hostname']
spec['network'] = self.config['vcd']['network']
spec['ip_allocation_mode'] = self.config['vcd']['ip_allocation_mode']
spec['storage_profile'] = vdc.get_storage_profile(
self.config['vcd']['storage_profile'])
vms = [spec]
result = vapp.add_vms(vms)
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_get_vdc(self):
logged_in_org = self.client.get_org()
org = Org(self.client, org_resource=logged_in_org)
v = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, vdc_href=v.get('href'))
assert self.config['vcd']['vdc'] == vdc.get_resource().get('name')
def connect_org_vdc_network(self,
orgvdc_network_name,
retain_ip=None,
is_deployed=None,
fence_mode=FenceMode.BRIDGED.value):
"""Connect the vApp to an org vdc network.
:param str orgvdc_network_name: name of the org vdc network to be
connected to.
:param bool retain_ip: True, if the network resources such as IP/MAC
of router will be retained across deployments.
:param bool is_deployed: True, if this org vdc network has been
deployed.
:param str fence_mode: mode of connectivity to the parent network.
Acceptable values are 'bridged', 'isolated' or 'natRouted'. Default
value is 'bridged'.
:return: an object containing EntityType.TASK XML data which represents
the asynchronous task that is connecting the vApp to the network.
:rtype: lxml.objectify.ObjectifiedElement
:raises: EntityNotFoundException: if named org vdc network does not
exist.
:raises: InvalidStateException: if the vApp is already connected to the
org vdc network.
"""
vdc = VDC(self.client,
href=find_link(self.resource, RelationType.UP,
EntityType.VDC.value).href)
orgvdc_networks = \
vdc.list_orgvdc_network_resources(orgvdc_network_name)
if len(orgvdc_networks) == 0:
raise EntityNotFoundException(
"Org vdc network \'%s\' does not exist in vdc "
"\'%s\'" %
(orgvdc_network_name, vdc.get_resource().get('name')))
orgvdc_network_href = orgvdc_networks[0].get('href')
network_configuration_section = \
deepcopy(self.resource.NetworkConfigSection)
matched_orgvdc_network_config = \
self._search_for_network_config_by_name(
orgvdc_network_name, network_configuration_section)
if matched_orgvdc_network_config is not None:
raise InvalidStateException(
"Org vdc network \'%s\' is already connected to "
"vApp." % orgvdc_network_name)
configuration = E.Configuration(
E.ParentNetwork(href=orgvdc_network_href), E.FenceMode(fence_mode))
if retain_ip is not None:
configuration.append(E.RetainNetInfoAcrossDeployments(retain_ip))
network_config = E.NetworkConfig(configuration,
networkName=orgvdc_network_name)
if is_deployed is not None:
network_config.append(E.IsDeployed(is_deployed))
network_configuration_section.append(network_config)
return self.client.put_linked_resource(
self.resource.NetworkConfigSection, RelationType.EDIT,
EntityType.NETWORK_CONFIG_SECTION.value,
network_configuration_section)
