def get_test_vapp_with_network(cls, client):
"""Gets the vapp for testing in current vDC.
:param pyvcloud.vcd.client.Client client: client which will be used to
create the VDC object.
:return: the vdc that is backing the organization in which all tests
will run.
:rtype: pyvcloud.vcd.vdc.VDC
"""
if not cls._vapp_href:
vdc = Environment.get_test_vdc(client)
try:
vapp = vdc.get_vapp(VAppConstants.name)
cls._vapp_href = vapp.get('href')
except EntityNotFoundException:
cls._vapp_href = create_vapp_from_template(
client,
vdc,
VAppConstants.name,
cls._config['vcd']['default_catalog_name'],
cls._config['vcd']['default_template_file_name'],
power_on=False,
deploy=False)
vapp = VApp(client, href=cls._vapp_href)
vapp.create_vapp_network(
VAppConstants.network1_name,
VAppConstants.network1_cidr,
ip_ranges=VAppConstants.network1_ip_ranges)
return VApp(client, href=cls._vapp_href)
def get_test_vapp_with_network(cls, client):
"""Gets the vapp for testing in current vDC.
:param pyvcloud.vcd.client.Client client: client which will be used to
create the VDC object.
:return: the vdc that is backing the organization in which all tests
will run.
:rtype: pyvcloud.vcd.vdc.VDC
"""
if not cls._vapp_href:
vdc = Environment.get_test_vdc(client)
try:
vapp = vdc.get_vapp(VAppConstants.name)
cls._vapp_href = vapp.get('href')
except EntityNotFoundException:
cls._vapp_href = create_vapp_from_template(
client,
vdc,
VAppConstants.name,
cls._config['vcd']['default_catalog_name'],
cls._config['vcd']['default_template_file_name'],
power_on=False,
deploy=False)
vapp = VApp(client, href=cls._vapp_href)
task = vapp.create_vapp_network(
VAppConstants.network1_name,
VAppConstants.network1_cidr,
ip_ranges=VAppConstants.network1_ip_ranges)
client.get_task_monitor().wait_for_success(task=task)
return VApp(client, href=cls._vapp_href)
def create_vapp_network(ctx, vapp_name, name, subnet, description,
primary_dns_ip, secondary_dns_ip, dns_suffix,
ip_ranges, is_guest_vlan_allowed):
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(vapp_name)
vapp = VApp(client, resource=vapp_resource)
task = vapp.create_vapp_network(
name, subnet, description, primary_dns_ip, secondary_dns_ip,
dns_suffix, ip_ranges, is_guest_vlan_allowed)
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
class VappNetwork(VcdAnsibleModule):
def __init__(self, **kwargs):
super(VappNetwork, self).__init__(**kwargs)
vapp_resource = self.get_resource()
self.vapp = VApp(self.client, resource=vapp_resource)
def manage_states(self):
state = self.params.get('state')
if state == "present":
return self.add_network()
if state == "update":
return self.update_network()
if state == "absent":
return self.delete_network()
def manage_operations(self):
operation = self.params.get('operation')
if operation == "read":
return self.get_all_networks()
def get_resource(self):
vapp = self.params.get('vapp')
vdc = self.params.get('vdc')
org_resource = Org(self.client, resource=self.client.get_org())
vdc_resource = VDC(self.client, resource=org_resource.get_vdc(vdc))
vapp_resource_href = vdc_resource.get_resource_href(
name=vapp, entity_type=EntityType.VAPP)
vapp_resource = self.client.get_resource(vapp_resource_href)
return vapp_resource
def get_network(self):
network_name = self.params.get('network')
networks = self.vapp.get_all_networks()
for network in networks:
if network.get('{' + NSMAP['ovf'] + '}name') == network_name:
return network
raise EntityNotFoundException('Can\'t find the specified vApp network')
def get_all_networks(self):
response = dict()
response['changed'] = False
response['msg'] = defaultdict(dict)
for network in self.vapp.get_all_networks():
name = network.get('{' + NSMAP['ovf'] + '}name')
n = {'description': str(network.Description)}
response['msg'][name] = n
return response
def add_network(self):
network_name = self.params.get('network')
network_cidr = self.params.get('network_cidr')
network_description = self.params.get('description')
primary_dns_ip = self.params.get('primary_dns_ip')
secondary_dns_ip = self.params.get('secondary_dns_ip')
dns_suffix = self.params.get('dns_suffix')
ip_ranges = self.params.get('ip_ranges')
is_guest_vx_vlan_allowed = self.params.get('is_guest_vx_vlan_allowed')
response = dict()
response['changed'] = False
try:
self.get_network()
except EntityNotFoundException:
add_network_task = self.vapp.create_vapp_network(
name=network_name,
network_cidr=network_cidr,
description=network_description,
primary_dns_ip=primary_dns_ip,
secondary_dns_ip=secondary_dns_ip,
dns_suffix=dns_suffix,
ip_ranges=ip_ranges,
is_guest_vx_vlan_allowed=is_guest_vx_vlan_allowed)
self.execute_task(add_network_task)
response['msg'] = 'Vapp Network {} has been added'.format(
network_name)
response['changed'] = True
else:
response[
'warnings'] = 'Vapp Network {} is already present.'.format(
network_name)
return response
def update_network(self):
network_name = self.params.get('network')
new_network_name = self.params.get('new_network')
network_description = self.params.get('description')
response = dict()
response['changed'] = False
try:
self.get_network()
except EntityNotFoundException:
response['warnings'] = 'Vapp Network {} is not present'.format(
network_name)
else:
update_network_task = self.vapp.update_vapp_network(
network_name=network_name,
new_net_name=new_network_name,
new_net_desc=network_description)
self.execute_task(update_network_task)
response['msg'] = 'Vapp Network {} has been updated'.format(
network_name)
response['changed'] = True
return response
def delete_network(self):
network_name = self.params.get('network')
response = dict()
response['changed'] = False
try:
self.get_network()
except EntityNotFoundException:
response['warnings'] = 'Vapp Network {} is not present'.format(
network_name)
else:
delete_network_task = self.vapp.delete_vapp_network(network_name)
self.execute_task(delete_network_task)
response['msg'] = 'Vapp Network {} has been deleted.'.format(
network_name)
response['changed'] = True
return response
def test_0000_setup(self):
"""Setup the vms required for the other tests in this module.
Create a vApp with just one vm as per the configuration stated above.
This test passes if the vApp and vm hrefs are not None.
"""
logger = Environment.get_default_logger()
TestVM._client = Environment.get_client_in_default_org(
TestVM._test_runner_role)
TestVM._sys_admin_client = Environment.get_sys_admin_client()
vdc = Environment.get_test_vdc(TestVM._client)
TestVM._media_resource = Environment.get_test_media_resource()
logger.debug('Creating vApp ' + TestVM._test_vapp_name + '.')
TestVM._test_vapp_href = create_customized_vapp_from_template(
client=TestVM._client,
vdc=vdc,
name=TestVM._test_vapp_name,
catalog_name=Environment.get_default_catalog_name(),
template_name=Environment.get_default_template_name(),
memory_size=TestVM._test_vapp_first_vm_memory_size,
num_cpu=TestVM._test_vapp_first_vm_num_cpu,
disk_size=TestVM._test_vapp_first_vm_first_disk_size,
vm_name=TestVM._test_vapp_first_vm_name,
nw_adapter_type=TestVM._test_vapp_first_vm_network_adapter_type)
self.assertIsNotNone(TestVM._test_vapp_href)
vapp = VApp(TestVM._client, href=TestVM._test_vapp_href)
TestVM._test_vapp = vapp
vm_resource = vapp.get_vm(TestVM._test_vapp_first_vm_name)
TestVM._test_vapp_first_vm_href = vm_resource.get('href')
self.assertIsNotNone(TestVM._test_vapp_first_vm_href)
logger.debug('Creating empty vApp.')
TestVM._empty_vapp_href = \
create_empty_vapp(client=TestVM._client,
vdc=vdc,
name=TestVM._empty_vapp_name,
description=TestVM._empty_vapp_description)
TestVM._empty_vapp_owner_name = Environment. \
get_username_for_role_in_test_org(TestVM._test_runner_role)
# Create independent disk
TestVM._idisk = vdc.create_disk(name=self._idisk_name,
size=self._idisk_size,
description=self._idisk_description)
# Upload template with vm tools.
catalog_author_client = Environment.get_client_in_default_org(
CommonRoles.CATALOG_AUTHOR)
org_admin_client = Environment.get_client_in_default_org(
CommonRoles.ORGANIZATION_ADMINISTRATOR)
org = Environment.get_test_org(org_admin_client)
catalog_name = Environment.get_config()['vcd']['default_catalog_name']
catalog_items = org.list_catalog_items(catalog_name)
template_name = Environment.get_config(
)['vcd']['default_template_vmtools_file_name']
catalog_item_flag = False
for item in catalog_items:
if item.get('name').lower() == template_name.lower():
logger.debug('Reusing existing template ' + template_name)
catalog_item_flag = True
break
if not catalog_item_flag:
logger.debug('Uploading template ' + template_name +
' to catalog ' + catalog_name + '.')
org.upload_ovf(catalog_name=catalog_name, file_name=template_name)
# wait for the template import to finish in vCD.
catalog_item = org.get_catalog_item(name=catalog_name,
item_name=template_name)
template = catalog_author_client.get_resource(
catalog_item.Entity.get('href'))
catalog_author_client.get_task_monitor().wait_for_success(
task=template.Tasks.Task[0])
# Create Vapp with template of vmware tools
logger.debug('Creating vApp ' + TestVM._test_vapp_vmtools_name + '.')
TestVM._test_vapp_vmtools_href = create_customized_vapp_from_template(
client=TestVM._client,
vdc=vdc,
name=TestVM._test_vapp_vmtools_name,
catalog_name=catalog_name,
template_name=template_name)
self.assertIsNotNone(TestVM._test_vapp_href)
vapp = VApp(TestVM._client, href=TestVM._test_vapp_vmtools_href)
TestVM._test_vapp_vmtools = vapp
vm_resource = vapp.get_vm(TestVM._test_vapp_vmtools_vm_name)
TestVM._test_vapp_vmtools_vm_href = vm_resource.get('href')
self.assertIsNotNone(TestVM._test_vapp_vmtools_vm_href)
resource = TestVM._sys_admin_client.get_extension()
result = TestVM._sys_admin_client.get_linked_resource(
resource, RelationType.DOWN, EntityType.DATASTORE_REFERENCES.value)
if hasattr(result, '{' + NSMAP['vcloud'] + '}Reference'):
for reference in result['{' + NSMAP['vcloud'] + '}Reference']:
if reference.get('name') == 'shared-disk-2':
TestVM._datastore_id = reference.get('id')
break
vapp = Environment.get_vapp_in_test_vdc(
client=TestVM._client, vapp_name=TestVM._test_vapp_name)
logger.debug('Creating a vApp network in ' + TestVM._test_vapp_name)
task = vapp.create_vapp_network(
TestVM._vapp_network_name, TestVM._vapp_network_cidr,
TestVM._vapp_network_description, TestVM._vapp_network_dns1,
TestVM._vapp_network_dns2, TestVM._vapp_network_dns_suffix,
[TestVM._vapp_network_ip_range])
result = TestVM._client.get_task_monitor().wait_for_success(task)
self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
vapp.reload()
