def test_0010_update(self):
"""Test the method Platform.update_external_network()
Update name and description of the external network created by setup.
Verifies name and description after update completes. Reset the name
and description to original.
This test passes if name and description are updated successfully.
"""
logger = Environment.get_default_logger()
platform = Platform(TestExtNet._sys_admin_client)
new_name = 'updated_' + TestExtNet._name
new_description = 'Updated ' + TestExtNet._description
ext_net = platform.update_external_network(TestExtNet._name, new_name,
new_description)
task = ext_net['{' + NSMAP['vcloud'] + '}Tasks'].Task[0]
TestExtNet._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
logger.debug('Updated external network ' + TestExtNet._name + '.')
ext_net = platform.get_external_network(new_name)
self.assertIsNotNone(ext_net)
self.assertEqual(new_description,
ext_net['{' + NSMAP['vcloud'] + '}Description'].text)
# Reset the name and description to original
ext_net = platform.update_external_network(new_name, self._name,
self._description)
task = ext_net['{' + NSMAP['vcloud'] + '}Tasks'].Task[0]
TestExtNet._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
def test_0030_enable_subnet(self):
"""Test the method externalNetwork.enable_subnet()
Enable subnet of external network
This test passes if subnet is enabled successfully.
"""
logger = Environment.get_default_logger()
platform = Platform(TestExtNet._sys_admin_client)
ext_net = self._get_ext_net(platform).enable_subnet(
TestExtNet._gateway2, True)
task = ext_net['{' + NSMAP['vcloud'] + '}Tasks'].Task[0]
TestExtNet._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
logger.debug(
'Enabled subnet of external network ' + TestExtNet._name + '.')
ext_net = platform.get_external_network(self._name)
self.assertIsNotNone(ext_net)
config = ext_net['{' + NSMAP['vcloud'] + '}Configuration']
ip_scope = config.IpScopes.IpScope
for scope in ip_scope:
if scope.Gateway == TestExtNet._gateway2:
ip_scope = scope
break
self.assertIsNotNone(ip_scope)
self.assertEqual(ip_scope.IsEnabled, True)
def test_0055_delete_ip_range(self):
"""Test the method externalNetwork.delete_ip_range()
Delete ip range of a subnet in external network
This test passes if the ip range for a subnet is
deleted successfully.
"""
logger = Environment.get_default_logger()
platform = Platform(TestExtNet._sys_admin_client)
ext_net = self._get_ext_net(platform).delete_ip_range(
TestExtNet._gateway2,
[TestExtNet._ip_range4])
task = ext_net['{' + NSMAP['vcloud'] + '}Tasks'].Task[0]
TestExtNet._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
logger.debug(
'Deleted ip-range of a subnet in external network'
+ TestExtNet._name + '.')
ext_net = platform.get_external_network(self._name)
self.assertIsNotNone(ext_net)
config = ext_net['{' + NSMAP['vcloud'] + '}Configuration']
ip_scope = config.IpScopes.IpScope
for scope in ip_scope:
if scope.Gateway == TestExtNet._gateway2:
ip_scope = scope
break
self.assertIsNotNone(ip_scope)
self.assertFalse(self.__validate_ip_range(ip_scope,
TestExtNet._ip_range4))
def test_0060_attach_port_group(self):
"""Attach a portgroup to an external network
This test passes if the portgroup from another vCenter is added
to external network successfully.
"""
if TestExtNet._vc2_host_ip is None or TestExtNet._vc2_host_ip == '':
return
logger = Environment.get_default_logger()
platform = Platform(TestExtNet._sys_admin_client)
vc_name = TestExtNet._config['vc2']['vcenter_host_name']
portgrouphelper = PortgroupHelper(TestExtNet._sys_admin_client)
pg_name = portgrouphelper.get_available_portgroup_name(
vc_name, TestExtNet._portgroupType)
ext_net = self._get_ext_net(platform).attach_port_group(
vc_name,
pg_name)
task = ext_net['{' + NSMAP['vcloud'] + '}Tasks'].Task[0]
TestExtNet._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
logger.debug(
'Attach a portgroup to an external network'
+ TestExtNet._name + '.')
ext_net = platform.get_external_network(self._name)
self.assertIsNotNone(ext_net)
vc_record = platform.get_vcenter(vc_name)
vc_href = vc_record.get('href')
vim_port_group_refs = \
ext_net['{' + NSMAP['vmext'] + '}VimPortGroupRefs']
vc_href_found = False
for vim_obj_ref in vim_port_group_refs.VimObjectRef:
if vim_obj_ref.VimServerRef.get('href') == vc_href:
vc_href_found = True
break
self.assertTrue(vc_href_found)
def list_vcenters(ctx):
try:
restore_session(ctx)
platform = Platform(ctx.obj['client'])
stdout(platform.list_vcenters(), ctx)
except Exception as e:
stderr(e, ctx)
def info(ctx, name):
try:
restore_session(ctx)
platform = Platform(ctx.obj['client'])
stdout(platform.get_vcenter(name=name), ctx)
except Exception as e:
stderr(e, ctx)
def test_0000_setup(self):
"""Load configuration and create a click runner to invoke CLI."""
self._config = Environment.get_config()
GatewayTest._logger = Environment.get_default_logger()
GatewayTest._runner = CliRunner()
default_org = self._config['vcd']['default_org_name']
self._login()
GatewayTest._runner.invoke(org, ['use', default_org])
GatewayTest._api_version = self._config['vcd']['api_version']
GatewayTest._ext_network_name = self._get_first_external_network()
self.client = Environment.get_sys_admin_client()
platform = Platform(self.client)
ext_net_resource = platform.get_external_network(
GatewayTest._ext_network_name)
self.assertTrue(len(ext_net_resource) > 0)
ip_scopes = ext_net_resource.xpath(
'vcloud:Configuration/vcloud:IpScopes/vcloud:IpScope',
namespaces=NSMAP)
first_ipscope = ip_scopes[0]
GatewayTest._gateway_ip = first_ipscope.Gateway.text
prefix_len = netmask_to_cidr_prefix_len(GatewayTest._gateway_ip,
first_ipscope.Netmask.text)
GatewayTest._subnet_addr = GatewayTest._gateway_ip + '/' + str(
prefix_len)
def test_0055_delete_ip_range(self):
"""Test the method externalNetwork.delete_ip_range()
Delete ip range of a subnet in external network
This test passes if the ip range for a subnet is
deleted successfully.
"""
logger = Environment.get_default_logger()
platform = Platform(TestExtNet._sys_admin_client)
ext_net = self._get_ext_net(platform).delete_ip_range(
TestExtNet._gateway2, [TestExtNet._ip_range4])
task = ext_net['{' + NSMAP['vcloud'] + '}Tasks'].Task[0]
TestExtNet._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
logger.debug('Deleted ip-range of a subnet in external network' +
TestExtNet._name + '.')
ext_net = platform.get_external_network(self._name)
self.assertIsNotNone(ext_net)
config = ext_net['{' + NSMAP['vcloud'] + '}Configuration']
ip_scope = config.IpScopes.IpScope
for scope in ip_scope:
if scope.Gateway == TestExtNet._gateway2:
ip_scope = scope
break
self.assertIsNotNone(ip_scope)
self.assertFalse(
self.__validate_ip_range(ip_scope, TestExtNet._ip_range4))
def test_0003_get_vc_negative(self):
try:
platform = Platform(self.client)
platform.get_vcenter(self.config['vcd']['vcenter_invalid'])
assert False
except Exception as e:
assert 'not found' in str(e).lower()
def test_0010_update(self):
"""Test the method Platform.update_external_network()
Update name and description of the external network created by setup.
Verifies name and description after update completes. Reset the name
and description to original.
This test passes if name and description are updated successfully.
"""
logger = Environment.get_default_logger()
platform = Platform(TestExtNet._sys_admin_client)
new_name = 'updated_' + TestExtNet._name
new_description = 'Updated ' + TestExtNet._description
ext_net = platform.update_external_network(TestExtNet._name, new_name,
new_description)
task = ext_net['{' + NSMAP['vcloud'] + '}Tasks'].Task[0]
TestExtNet._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
logger.debug('Updated external network ' + TestExtNet._name + '.')
ext_net = platform.get_external_network(new_name)
self.assertIsNotNone(ext_net)
self.assertEqual(new_description,
ext_net['{' + NSMAP['vcloud'] + '}Description'].text)
# Reset the name and description to original
ext_net = platform.update_external_network(new_name, self._name,
self._description)
task = ext_net['{' + NSMAP['vcloud'] + '}Tasks'].Task[0]
TestExtNet._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
def create_external_network(cls):
"""Creates an external network by the name specified in the config file.
Skips creating one, if such a network already exists. Also stores the
href and name of the network as class variables for future use.
"""
cls._basic_check()
net_name = cls._config['external_network']['name']
platform = Platform(cls._sys_admin_client)
net_refs = platform.list_external_networks()
if net_name is not '*':
for net_ref in net_refs:
if net_ref.get('name').lower() == net_name.lower():
cls._logger.debug('Reusing existing ' + net_name)
cls._external_network_href = net_ref.get('href')
cls._external_network_name = net_name
return
cls._logger.debug('Creating new external network' + net_name)
ext_nw = cls._create_external_network()
cls._external_network_href = ext_nw.get('href')
cls._external_network_name = net_name
cls._logger.debug('Created external network ' + net_name)
else:
if len(net_refs) > 0:
cls._logger.debug('Defaulting to first network : ' +
net_refs[0].get('name'))
cls._external_network_href = net_refs[0].get('href')
cls._external_network_name = net_refs[0].get('name')
else:
cls._logger.debug('No usable network found. Aborting test.')
raise Exception('Test Aborted. No usable external network.')
def info(ctx, name):
try:
restore_session(ctx)
platform = Platform(ctx.obj['client'])
stdout(platform.get_vcenter(name), ctx)
except Exception as e:
stderr(e, ctx)
def test_0021_list_available_port_group_names(self):
"""Test the method Platform.list_port_group_names, this method fetches
list of portgroup name for a particular vCenter"""
platform = Platform(TestVC._client)
port_group_names = \
platform.list_available_port_group_names(TestVC._vcenter_host_name)
self.assertTrue(len(port_group_names) > 0)
def test_0061_detach_port_group(self):
"""Detach a portgroup from an external network
This test passes if the portgroup from another vCenter is removed
from external network successfully.
"""
if TestExtNet._vc2_host_ip is None or TestExtNet._vc2_host_ip == '':
return
logger = Environment.get_default_logger()
platform = Platform(TestExtNet._sys_admin_client)
vc_name = TestExtNet._config['vc2']['vcenter_host_name']
port_group_helper = PortgroupHelper(TestExtNet._sys_admin_client)
pg_name = port_group_helper.get_ext_net_portgroup_name(
vc_name, self._name)
ext_net = self._get_ext_net(platform).detach_port_group(
vc_name, pg_name)
task = ext_net['{' + NSMAP['vcloud'] + '}Tasks'].Task[0]
TestExtNet._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
logger.debug('Detach a portgroup from an external network' +
TestExtNet._name)
ext_net = platform.get_external_network(self._name)
self.assertIsNotNone(ext_net)
vc_record = platform.get_vcenter(vc_name)
vc_href = vc_record.get('href')
vim_port_group_ref = ext_net.VimPortGroupRef
vc_href_found = False
if vim_port_group_ref.VimServerRef.get('href') == vc_href:
vc_href_found = True
self.assertFalse(vc_href_found)
def test_0036_get_storage_profiles(self):
"""Get storage profile(s) of a PVDC."""
platform = Platform(TestPVDC._sys_admin_client)
_, _, pvdc_ext_res = platform.get_pvdc(TestPVDC._pvdc_name)
pvdc = PVDC(TestPVDC._sys_admin_client, resource=pvdc_ext_res)
pvdc_storage_profiles = pvdc.get_storage_profiles()
self.assertTrue(len(pvdc_storage_profiles) > 0)
def attach_vc(cls):
"""Attaches VC and NSX to vCD as per configuration file.
If VC is already attached no further action is taken.
:return: Nothing
"""
cls._basic_check()
platform = Platform(cls._sys_admin_client)
vc_name = cls._config['vc']['vcenter_host_name']
for record in platform.list_vcenters():
if record.get('name').lower() == vc_name.lower():
cls._logger.debug(vc_name + ' is already attached.')
return
# Untested code - see VCDA-603
platform.attach_vcenter(
vc_server_name=vc_name,
vc_server_host=cls._config['vc']['vcenter_host_ip'],
vc_admin_user=cls._config['vc']['vcenter_admin_username'],
vc_admin_pwd=cls._config['vc']['vcenter_admin_password'],
nsx_server_name=cls._config['nsx']['nsx_hostname'],
nsx_host=cls._config['nsx']['nsx_host_ip'],
nsx_admin_user=cls._config['nsx']['nsx_admin_username'],
nsx_admin_pwd=cls._config['nsx']['nsx_admin_password'],
is_enabled=True)
def test_0030_enable_subnet(self):
"""Test the method externalNetwork.enable_subnet()
Enable subnet of external network
This test passes if subnet is enabled successfully.
"""
logger = Environment.get_default_logger()
platform = Platform(TestExtNet._sys_admin_client)
ext_net = self._get_ext_net(platform).enable_subnet(
TestExtNet._gateway2, True)
task = ext_net['{' + NSMAP['vcloud'] + '}Tasks'].Task[0]
TestExtNet._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
logger.debug('Enabled subnet of external network ' + TestExtNet._name +
'.')
ext_net = platform.get_external_network(self._name)
self.assertIsNotNone(ext_net)
config = ext_net['{' + NSMAP['vcloud'] + '}Configuration']
ip_scope = config.IpScopes.IpScope
for scope in ip_scope:
if scope.Gateway == TestExtNet._gateway2:
ip_scope = scope
break
self.assertIsNotNone(ip_scope)
self.assertEqual(ip_scope.IsEnabled, True)
def test_0020_add_subnet(self):
"""Test the method externalNetwork.add_subnet()
Add subnet to the existing external network
This test passes if subnet is added successfully.
"""
logger = Environment.get_default_logger()
platform = Platform(TestExtNet._sys_admin_client)
ext_net_resource = platform.get_external_network(self._name)
extnet_obj = ExternalNetwork(TestExtNet._sys_admin_client,
resource=ext_net_resource)
ext_net = extnet_obj.add_subnet(self._name, TestExtNet._gateway2,
TestExtNet._netmask,
[TestExtNet._ip_range2],
TestExtNet._dns1, TestExtNet._dns2,
TestExtNet._dns_suffix)
task = ext_net['{' + NSMAP['vcloud'] + '}Tasks'].Task[0]
TestExtNet._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
logger.debug('Added subnet to external network ' + TestExtNet._name +
'.')
ext_net = platform.get_external_network(self._name)
self.assertIsNotNone(ext_net)
config = ext_net['{' + NSMAP['vcloud'] + '}Configuration']
new_subnet = config.IpScopes.IpScope[-1]
self.assertEqual(TestExtNet._gateway2, new_subnet.Gateway.text)
self.assertEqual(TestExtNet._netmask, new_subnet.Netmask.text)
def detach(ctx, name):
try:
restore_session(ctx)
platform = Platform(ctx.obj['client'])
stdout(platform.detach_vcenter(vc_name=name), ctx)
except Exception as e:
stderr(e, ctx)
def test_0060_attach_port_group(self):
"""Attach a portgroup to an external network
This test passes if the portgroup from another vCenter is added
to external network successfully.
"""
if TestExtNet._vc2_host_ip is None or TestExtNet._vc2_host_ip == '':
return
logger = Environment.get_default_logger()
platform = Platform(TestExtNet._sys_admin_client)
vc_name = TestExtNet._config['vc2']['vcenter_host_name']
portgrouphelper = PortgroupHelper(TestExtNet._sys_admin_client)
pg_name = portgrouphelper.get_available_portgroup_name(
vc_name, TestExtNet._portgroupType)
ext_net = self._get_ext_net(platform).attach_port_group(
vc_name, pg_name)
task = ext_net['{' + NSMAP['vcloud'] + '}Tasks'].Task[0]
TestExtNet._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
logger.debug('Attach a portgroup to an external network' +
TestExtNet._name + '.')
ext_net = platform.get_external_network(self._name)
self.assertIsNotNone(ext_net)
vc_record = platform.get_vcenter(vc_name)
vc_href = vc_record.get('href')
vim_port_group_refs = \
ext_net['{' + NSMAP['vmext'] + '}VimPortGroupRefs']
vc_href_found = False
for vim_obj_ref in vim_port_group_refs.VimObjectRef:
if vim_obj_ref.VimServerRef.get('href') == vc_href:
vc_href_found = True
break
self.assertTrue(vc_href_found)
def test_0020_add_subnet(self):
"""Test the method externalNetwork.add_subnet()
Add subnet to the existing external network
This test passes if subnet is added successfully.
"""
logger = Environment.get_default_logger()
platform = Platform(TestExtNet._sys_admin_client)
ext_net_resource = platform.get_external_network(self._name)
extnet_obj = ExternalNetwork(TestExtNet._sys_admin_client,
resource=ext_net_resource)
ext_net = extnet_obj.add_subnet(self._name,
TestExtNet._gateway2,
TestExtNet._netmask,
[TestExtNet._ip_range2],
TestExtNet._dns1,
TestExtNet._dns2,
TestExtNet._dns_suffix)
task = ext_net['{' + NSMAP['vcloud'] + '}Tasks'].Task[0]
TestExtNet._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
logger.debug(
'Added subnet to external network ' + TestExtNet._name + '.')
ext_net = platform.get_external_network(self._name)
self.assertIsNotNone(ext_net)
config = ext_net['{' + NSMAP['vcloud'] + '}Configuration']
new_subnet = config.IpScopes.IpScope[-1]
self.assertEqual(TestExtNet._gateway2, new_subnet.Gateway.text)
self.assertEqual(TestExtNet._netmask, new_subnet.Netmask.text)
def list_vcenters(ctx):
try:
restore_session(ctx)
platform = Platform(ctx.obj['client'])
stdout(platform.list_vcenters(), ctx)
except Exception as e:
stderr(e, ctx)
def detach(ctx, name):
try:
restore_session(ctx)
platform = Platform(ctx.obj['client'])
stdout(platform.detach_vcenter(vc_name=name), ctx)
except Exception as e:
stderr(e, ctx)
def test_0061_detach_port_group(self):
"""Detach a portgroup from an external network
This test passes if the portgroup from another vCenter is removed
from external network successfully.
"""
if TestExtNet._vc2_host_ip is None or TestExtNet._vc2_host_ip == '':
return
logger = Environment.get_default_logger()
platform = Platform(TestExtNet._sys_admin_client)
vc_name = TestExtNet._config['vc2']['vcenter_host_name']
port_group_helper = PortgroupHelper(TestExtNet._sys_admin_client)
pg_name = port_group_helper.get_ext_net_portgroup_name(vc_name,
self._name)
ext_net = self._get_ext_net(platform).detach_port_group(vc_name,
pg_name)
task = ext_net['{' + NSMAP['vcloud'] + '}Tasks'].Task[0]
TestExtNet._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
logger.debug(
'Detach a portgroup from an external network' + TestExtNet._name)
ext_net = platform.get_external_network(self._name)
self.assertIsNotNone(ext_net)
vc_record = platform.get_vcenter(vc_name)
vc_href = vc_record.get('href')
vim_port_group_ref = ext_net.VimPortGroupRef
vc_href_found = False
if vim_port_group_ref.VimServerRef.get('href') == vc_href:
vc_href_found = True
self.assertFalse(vc_href_found)
def test_0021_list_available_port_group_names(self):
"""Test the method Platform.list_port_group_names, this method fetches
list of portgroup name for a particular vCenter"""
platform = Platform(TestVC._client)
port_group_names = \
platform.list_available_port_group_names(TestVC._vcenter_host_name)
self.assertTrue(len(port_group_names) > 0)
def test_0030_attach_resource_pools(self):
"""Attach resource pool(s) to a PVDC."""
platform = Platform(TestPVDC._sys_admin_client)
task = platform.attach_resource_pools_to_provider_vdc(
TestPVDC._pvdc_name, TestPVDC._resource_pool_names)
res = TestPVDC._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
self.assertEqual(res.get('status'), TaskStatus.SUCCESS.value)
def test_0020_get_vc(self):
"""Platform.get_vcenter finds a known vcenter."""
logger = Environment.get_default_logger()
platform = Platform(TestVC._client)
vcenter = platform.get_vcenter(TestVC._vcenter_host_name)
logger.debug('vCenter: name=%s, url=%s' %
(vcenter.get('name'), vcenter.Url.text))
self.assertIsNotNone(vcenter)
def test_0010_list_vc(self):
"""Platform.list_vcenters prints a list of virtual center servers."""
logger = Environment.get_default_logger()
platform = Platform(TestVC._client)
vcenters = platform.list_vcenters()
for vcenter in vcenters:
logger.debug('vCenter found: %s' % vcenter.get('name'))
self.assertTrue(len(vcenters) > 0)
def enable(ctx, name):
try:
restore_session(ctx)
platform = Platform(ctx.obj['client'])
stdout(platform.enable_disable_vcenter(vc_name=name, enable_flag=True),
ctx)
except Exception as e:
stderr(e, ctx)
def list_datastores(ctx):
try:
restore_session(ctx)
platform = Platform(ctx.obj['client'])
result = platform.list_datastores()
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def test_0055_del_storage_profile(self):
"""Delete storage profile(s) from a PVDC."""
platform = Platform(TestPVDC._sys_admin_client)
task = platform.pvdc_del_storage_profile(TestPVDC._pvdc_name,
TestPVDC._storage_profiles)
res = TestPVDC._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
self.assertEqual(res.get('status'), TaskStatus.SUCCESS.value)
def test_0060_detach_resource_pools(self):
"""Disable and delete resource pool(s) from a PVDC."""
platform = Platform(TestPVDC._sys_admin_client)
task = platform.detach_resource_pools_from_provider_vdc(
TestPVDC._pvdc_name,
TestPVDC._resource_pool_names)
TestPVDC._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
def test_0060_detach_resource_pools(self):
"""Disable and delete resource pool(s) from a PVDC."""
platform = Platform(TestPVDC._sys_admin_client)
task = platform.detach_resource_pools_from_provider_vdc(
TestPVDC._pvdc_name, TestPVDC._resource_pool_names)
res = TestPVDC._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
self.assertEqual(res.get('status'), TaskStatus.SUCCESS.value)
def test_0037_get_storage_profile(self):
"""Get a storage profile of a PVDC by name."""
platform = Platform(TestPVDC._sys_admin_client)
_, _, pvdc_ext_res = platform.get_pvdc(TestPVDC._pvdc_name)
pvdc = PVDC(TestPVDC._sys_admin_client, resource=pvdc_ext_res)
pvdc_storage_profile = pvdc.get_storage_profile(
TestPVDC._storage_profiles[0])
self.assertIsNotNone(pvdc_storage_profile)
def test_0030_attach_resource_pools(self):
"""Attach resource pool(s) to a PVDC."""
platform = Platform(TestPVDC._sys_admin_client)
task = platform.attach_resource_pools_to_provider_vdc(
TestPVDC._pvdc_name,
TestPVDC._resource_pool_names)
TestPVDC._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
def test_0015_list_datastores(self):
"""List all datastores
Invokes the list_datastores of the platform.
"""
platform = Platform(client=TestDatastore._client)
datastore_list = platform.list_datastores()
# Verify
self.assertTrue(len(datastore_list) > 0)
def disable(ctx, name):
try:
restore_session(ctx)
platform = Platform(ctx.obj['client'])
stdout(platform.enable_disable_vcenter(
vc_name=name, enable_flag=False), ctx)
except Exception as e:
stderr(e, ctx)
def test_0020_get_vc(self):
"""Platform.get_vcenter finds a known vcenter."""
logger = Environment.get_default_logger()
platform = Platform(TestVC._client)
vcenter = platform.get_vcenter(TestVC._vcenter_host_name)
logger.debug('vCenter: name=%s, url=%s' %
(vcenter.get('name'), vcenter.Url.text))
self.assertIsNotNone(vcenter)
def test_0010_list_vc(self):
"""Platform.list_vcenters prints a list of virtual center servers."""
logger = Environment.get_default_logger()
platform = Platform(TestVC._client)
vcenters = platform.list_vcenters()
for vcenter in vcenters:
logger.debug('vCenter found: %s' % vcenter.get('name'))
self.assertTrue(len(vcenters) > 0)
def test_0060_detach_resource_pools(self):
"""Disable and delete resource pool(s) from a PVDC."""
platform = Platform(TestPVDC._sys_admin_client)
task = platform.detach_resource_pools_from_provider_vdc(
TestPVDC._pvdc_name,
TestPVDC._resource_pool_names)
res = TestPVDC._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
self.assertEqual(res.get('status'), TaskStatus.SUCCESS.value)
def test_0030_get_vc_negative(self):
"""Platform.get_vcenter does not find a non-existent vcenter."""
try:
platform = Platform(TestVC._client)
platform.get_vcenter(TestVC._vcenter_invalid)
self.fail('Should not be able to find VC that does not exist ' +
TestVC._vcenter_invalid)
except EntityNotFoundException as e:
return
def unregister(ctx, nsxt_name):
try:
restore_session(ctx)
client = ctx.obj['client']
platform = Platform(client)
platform.unregister_nsxt_manager(nsxt_manager_name=nsxt_name)
stdout('NSX-T manager unregistered successfully.', ctx)
except Exception as e:
stderr(e, ctx)
def test_0070_list_available_pvdc_with_filter(self):
"""List available provider Vdcs.
"""
platform = Platform(TestExtNet._sys_admin_client)
ext_net_resource = platform.get_external_network(
TestExtNet._common_ext_net_name)
extnet_obj = ExternalNetwork(TestExtNet._sys_admin_client,
resource=ext_net_resource)
pvdc_name_list = extnet_obj.list_provider_vdc('name==*')
def unregister(ctx, nsxt_name):
try:
restore_session(ctx)
client = ctx.obj['client']
platform = Platform(client)
platform.unregister_nsxt_manager(nsxt_manager_name=nsxt_name)
stdout('NSX-T manager unregistered successfully.', ctx)
except Exception as e:
stderr(e, ctx)
def test_0050_migrate_vms_back(self):
"""Migrate VM(s) from one resource pool to another."""
platform = Platform(TestPVDC._sys_admin_client)
task = platform.pvdc_migrate_vms(TestPVDC._pvdc_name,
TestPVDC._vms_to_migrate,
TestPVDC._target_resource_pool)
res = TestPVDC._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
self.assertEqual(res.get('status'), TaskStatus.SUCCESS.value)
def test_0030_get_vc_negative(self):
"""Platform.get_vcenter does not find a non-existent vcenter."""
try:
platform = Platform(TestVC._client)
platform.get_vcenter(TestVC._vcenter_invalid)
self.fail('Should not be able to find VC that does not exist ' +
TestVC._vcenter_invalid)
except EntityNotFoundException as e:
return
def test_0055_del_storage_profile(self):
"""Delete storage profile(s) from a PVDC."""
platform = Platform(TestPVDC._sys_admin_client)
task = platform.pvdc_del_storage_profile(
TestPVDC._pvdc_name,
TestPVDC._storage_profiles)
res = TestPVDC._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
self.assertEqual(res.get('status'), TaskStatus.SUCCESS.value)
def test_0030_attach_resource_pools(self):
"""Attach resource pool(s) to a PVDC."""
platform = Platform(TestPVDC._sys_admin_client)
task = platform.attach_resource_pools_to_provider_vdc(
TestPVDC._pvdc_name,
TestPVDC._resource_pool_names)
res = TestPVDC._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
self.assertEqual(res.get('status'), TaskStatus.SUCCESS.value)
def test_0070_list_available_pvdc_with_filter(self):
"""List available provider Vdcs.
"""
platform = Platform(TestExtNet._sys_admin_client)
ext_net_resource = platform.get_external_network(
TestExtNet._common_ext_net_name)
extnet_obj = ExternalNetwork(TestExtNet._sys_admin_client,
resource=ext_net_resource)
pvdc_name_list = extnet_obj.list_provider_vdc('name==*')
def test_0090_list_allocated_ip_with_gateway_filter(self):
"""List allocated ips.
"""
platform = Platform(TestExtNet._sys_admin_client)
ext_net_name = TestExtNet._config['external_network']['name']
ext_net_resource = platform.get_external_network(ext_net_name)
extnet_obj = ExternalNetwork(TestExtNet._sys_admin_client,
resource=ext_net_resource)
allocated_ip_dict = extnet_obj.list_allocated_ip_address('name==*')
self.assertTrue(len(allocated_ip_dict) > 0)
def test_0080_list_available_gateways_with_filter(self):
"""List available gateways.
"""
platform = Platform(TestExtNet._sys_admin_client)
ext_net_name = TestExtNet._config['external_network']['name']
ext_net_resource = platform.get_external_network(ext_net_name)
extnet_obj = ExternalNetwork(TestExtNet._sys_admin_client,
resource=ext_net_resource)
gateway_name_list = extnet_obj.list_extnw_gateways('name==*')
self.assertTrue(len(gateway_name_list) > 0)
def test_0050_migrate_vms_back(self):
"""Migrate VM(s) from one resource pool to another."""
platform = Platform(TestPVDC._sys_admin_client)
task = platform.pvdc_migrate_vms(
TestPVDC._pvdc_name,
TestPVDC._vms_to_migrate,
TestPVDC._target_resource_pool)
res = TestPVDC._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
self.assertEqual(res.get('status'), TaskStatus.SUCCESS.value)
def list_available_port_groups(ctx, vc_name):
try:
restore_session(ctx)
platform = Platform(ctx.obj['client'])
port_groups = platform.list_available_port_group_names(
vim_server_name=vc_name)
output = {}
output['available port-groups'] = port_groups
stdout(output, ctx)
except Exception as e:
stderr(e, ctx)
def attach_port_group(self, vim_server_name, port_group_name):
"""Attach a portgroup to an external network.
:param str vc_name: name of vc where portgroup is present.
:param str pg_name: name of the portgroup to be attached to
external network.
return: object containing vmext:VMWExternalNetwork XML element that
representing the external network.
:rtype: lxml.objectify.ObjectifiedElement
"""
ext_net = self.get_resource()
platform = Platform(self.client)
if not vim_server_name or not port_group_name:
raise InvalidParameterException(
"Either vCenter Server name is none or portgroup name is none")
vc_record = platform.get_vcenter(vim_server_name)
vc_href = vc_record.get('href')
pg_moref_types = \
platform.get_port_group_moref_types(vim_server_name,
port_group_name)
if hasattr(ext_net, '{' + NSMAP['vmext'] + '}VimPortGroupRef'):
vim_port_group_refs = E_VMEXT.VimPortGroupRefs()
vim_object_ref1 = self.__create_vimobj_ref(
vc_href, pg_moref_types[0], pg_moref_types[1])
# Create a new VimObjectRef using vc href, portgroup moref and type
# from existing VimPortGroupRef. Add the VimObjectRef to
# VimPortGroupRefs and then delete VimPortGroupRef
# from external network.
vim_pg_ref = ext_net['{' + NSMAP['vmext'] + '}VimPortGroupRef']
vc2_href = vim_pg_ref.VimServerRef.get('href')
vim_object_ref2 = self.__create_vimobj_ref(
vc2_href, vim_pg_ref.MoRef.text, vim_pg_ref.VimObjectType.text)
vim_port_group_refs.append(vim_object_ref1)
vim_port_group_refs.append(vim_object_ref2)
ext_net.remove(vim_pg_ref)
ext_net.append(vim_port_group_refs)
else:
vim_port_group_refs = \
ext_net['{' + NSMAP['vmext'] + '}VimPortGroupRefs']
vim_object_ref1 = self.__create_vimobj_ref(
vc_href, pg_moref_types[0], pg_moref_types[1])
vim_port_group_refs.append(vim_object_ref1)
return self.client. \
put_linked_resource(ext_net, rel=RelationType.EDIT,
media_type=EntityType.
EXTERNAL_NETWORK.value,
contents=ext_net)
def test_0095_list_sub_allocated_ip(self):
"""List sub allocated ip.
"""
self.__add_sub_allocate_ip_pool()
platform = Platform(TestExtNet._sys_admin_client)
ext_net_name = TestExtNet._config['external_network']['name']
ext_net_resource = platform.get_external_network(ext_net_name)
extnet_obj = ExternalNetwork(TestExtNet._sys_admin_client,
resource=ext_net_resource)
sub_allocated_ip_dict = extnet_obj.list_gateway_ip_suballocation()
self.assertTrue(len(sub_allocated_ip_dict) > 0)
def list_nsxt(ctx):
try:
restore_session(ctx)
client = ctx.obj['client']
platform = Platform(client)
query = platform.list_nsxt_managers()
result = []
for record in list(query):
result.append(to_dict(record, exclude=['href']))
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def test_0096_list_sub_allocated_ip_with_gateway_filter(self):
"""List sub allocated ips.
"""
platform = Platform(TestExtNet._sys_admin_client)
ext_net_name = TestExtNet._config['external_network']['name']
ext_net_resource = platform.get_external_network(ext_net_name)
extnet_obj = ExternalNetwork(TestExtNet._sys_admin_client,
resource=ext_net_resource)
sub_allocated_ip_dict = \
extnet_obj.list_gateway_ip_suballocation('name==*')
self.assertTrue(len(sub_allocated_ip_dict) > 0)
self.__remove_sub_allocate_ip_pool()
def test_0050_enable_vc(self):
"""Platform.enable_vcenter enables a vcenter.
Wait for async command to complete before checking result.
"""
platform = Platform(TestVC._client)
task = platform.enable_disable_vcenter(
vc_name=TestVC._vcServerName, enable_flag=True)
TestVC._client.get_task_monitor().wait_for_success(task=task)
vc = platform.get_vcenter(name=TestVC._vcServerName)
self.assertTrue(vc.IsEnabled)
def test_create_pvdc(self):
platform = Platform(self.client)
pvdc = platform.create_provider_vdc(
vim_server_name=self.config['vcd']['vimServerName'],
resource_pool_names=self.config['vcd']['resourcePoolNames'],
storage_profiles=self.config['vcd']['storageProfiles'],
pvdc_name=self.config['vcd']['pvdcName'],
is_enabled=self.config['vcd']['isEnabled'],
description=self.config['vcd']['description'],
highest_hw_vers=self.config['vcd']['highestSuppHWVers'],
nsxt_manager_name=self.config['vcd']['nsxtManager'])
assert self.config['vcd']['pvdcName'] == pvdc.get('name')
