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 create(ctx, name, description, catalog, template, network, memory, cpu,
disk_size, ip_allocation_mode, vm_name, hostname, storage_profile,
accept_all_eulas):
try:
client = ctx.obj['client']
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
if catalog is None and template is None:
vapp_resource = vdc.create_vapp(
name,
description=description,
network=network,
accept_all_eulas=accept_all_eulas)
else:
vapp_resource = vdc.instantiate_vapp(
name,
catalog,
template,
network=network,
memory=memory,
cpu=cpu,
disk_size=disk_size,
deploy=True,
power_on=True,
accept_all_eulas=accept_all_eulas,
cust_script=None,
ip_allocation_mode=ip_allocation_mode,
vm_name=vm_name,
hostname=hostname,
storage_profile=storage_profile)
stdout(vapp_resource.Tasks.Task[0], ctx)
except Exception as e:
stderr(e, ctx)
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 instantiate_vapp(cls):
"""Instantiates the test template in the test catalog.
This template will be used to create the test vApp. if the vApp already
exists then skips creating it.
:raises: Exception: if the class variable _ovdc_href is not populated.
"""
cls._basic_check()
if cls._ovdc_href is None:
raise Exception('OVDC ' + cls._config['vcd']['default_ovdc_name'] +
' doesn\'t exist.')
try:
catalog_author_client = Environment.get_client_in_default_org(
CommonRoles.CATALOG_AUTHOR)
vdc = VDC(catalog_author_client, href=cls._ovdc_href)
vapp_name = cls._config['vcd']['default_vapp_name']
vapp_resource = vdc.get_vapp(vapp_name)
cls._logger.debug('Reusing existing vApp ' + vapp_name + '.')
cls._vapp_href = vapp_resource.get('href')
except EntityNotFoundException as e:
cls._logger.debug('Instantiating vApp ' + vapp_name + '.')
vapp_resource = vdc.instantiate_vapp(
name=vapp_name,
catalog=cls._config['vcd']['default_catalog_name'],
template=cls._config['vcd']['default_template_file_name'],
accept_all_eulas=True)
catalog_author_client.get_task_monitor()\
.wait_for_success(task=vapp_resource.Tasks.Task[0])
cls._vapp_href = vapp_resource.get('href')
finally:
catalog_author_client.logout()
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 create(ctx, name, description, catalog, template, network, memory, cpu,
disk_size, ip_allocation_mode, vm_name, hostname, storage_profile,
accept_all_eulas):
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)
if catalog is None and template is None:
vapp_resource = vdc.create_vapp(
name,
description=description,
network=network,
accept_all_eulas=accept_all_eulas)
else:
vapp_resource = vdc.instantiate_vapp(
name,
catalog,
template,
description=description,
network=network,
memory=memory,
cpu=cpu,
disk_size=disk_size,
deploy=True,
power_on=True,
accept_all_eulas=accept_all_eulas,
cust_script=None,
ip_allocation_mode=ip_allocation_mode,
vm_name=vm_name,
hostname=hostname,
storage_profile=storage_profile)
stdout(vapp_resource.Tasks.Task[0], ctx)
except Exception as e:
stderr(e, ctx)
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 create(ctx, catalog, template, name, network, memory, cpu,
ip_allocation_mode):
try:
cust_script = None
client = ctx.obj['client']
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
vapp_resource = vdc.instantiate_vapp(
name,
catalog,
template,
network=network,
memory=memory,
cpu=cpu,
deploy=True,
power_on=True,
cust_script=cust_script,
ip_allocation_mode=ip_allocation_mode)
stdout(vapp_resource.Tasks.Task[0], ctx)
except Exception as e:
stderr(e, ctx)
def instantiate_vapp(cls):
"""Instantiates the test template in the test catalog to create the
test vApp. If the vApp already exists then skips creating it.
:return: Nothing
:raises: Exception: If the class variable _ovdc_href is not populated.
"""
cls._basic_check()
if cls._ovdc_href is None:
raise Exception('OVDC ' + cls._config['vcd']['default_ovdc_name'] +
' doesn\'t exist.')
try:
# TODO : use vApp author - see VCDA-603
catalog_author_client = Environment.get_client_in_default_org(
CommonRoles.CATALOG_AUTHOR)
vdc = VDC(catalog_author_client, href=cls._ovdc_href)
vapp_name = cls._config['vcd']['default_vapp_name']
vapp_resource = vdc.get_vapp(vapp_name)
print('Reusing existing vApp ' + vapp_name + '.')
cls._vapp_href = vapp_resource.get('href')
# TODO : Change to ResourceNotFoundException -- see VCDA-603
except Exception as e:
if 'not found' in str(e):
print('Instantiating vApp ' + vapp_name + '.')
vapp_resource = vdc.instantiate_vapp(
name=vapp_name,
catalog=cls._config['vcd']['default_catalog_name'],
template=cls._config['vcd']['default_template_file_name'],
accept_all_eulas=True)
catalog_author_client.get_task_monitor()\
.wait_for_success(task=vapp_resource.Tasks.Task[0])
cls._vapp_href = vapp_resource.get('href')
finally:
catalog_author_client.logout()
name=network['network_name'],
type=FenceMode.ISOLATED.value)
if len(new_network_list) > 0:
print("Isolated network is visible in VDC: {0}".format(
network['network_name']))
network_exists = True
else:
print("Isolated network is not visible yet: {0}".format(
network['network_name']))
time.sleep(3)
# Check for vApps and create them if they don't exist. We have to
# reload the VDC object so it has all the links to current vApps.
vdc.reload()
for vapp_cfg in cfg.vapps:
try:
vapp = vdc.get_vapp(vapp_cfg['name'])
print("vApp exists: {0}".format(vapp_cfg['name']))
except Exception:
print("vApp does not exist: name={0}".format(vapp_cfg['name']))
vapp_resource = vdc.instantiate_vapp(**vapp_cfg)
print("vApp instantiated")
# We don't track the task as instantiating a vApp takes a while.
# Uncomment below if you want to ensure the vApps are available.
# handle_task(client, vapp_resource.Tasks.Task[0])
# Log out.
print("All done!")
client.logout()
class Vapp(VcdAnsibleModule):
def __init__(self, **kwargs):
super(Vapp, self).__init__(**kwargs)
logged_in_org = self.client.get_org()
self.org = Org(self.client, resource=logged_in_org)
vdc_resource = self.org.get_vdc(self.params.get('vdc'))
self.vdc = VDC(self.client, href=vdc_resource.get('href'))
def manage_states(self):
state = self.params.get('state')
if state == "present":
return self.create()
if state == "absent":
return self.delete()
def manage_operations(self):
operation = self.params.get('operation')
if operation == "poweron":
return self.power_on()
if operation == "poweroff":
return self.power_off()
if operation == "list_vms":
return self.list_vms()
if operation == "list_networks":
return self.list_networks()
if operation == "share":
return self.share()
if operation == "unshare":
return self.unshare()
if operation == "set_meta":
return self.set_meta()
if operation == "get_meta":
return self.get_meta()
if operation == "remove_meta":
return self.remove_meta()
if operation == "add_org_network":
return self.add_org_network()
if operation == "delete_org_network":
return self.delete_org_network()
def get_vapp(self):
vapp_name = self.params.get('vapp_name')
vapp_resource = self.vdc.get_vapp(vapp_name)
return VApp(self.client, name=vapp_name, resource=vapp_resource)
def instantiate(self):
params = self.params
vapp_name = params.get('vapp_name')
catalog_name = params.get('catalog_name')
template_name = params.get('template_name')
description = params.get('description')
network = params.get('network')
fence_mode = params.get('fence_mode')
ip_allocation_mode = params.get('ip_allocation_mode')
deploy = params.get('deploy')
power_on = params.get('power_on')
accept_all_eulas = params.get('accept_all_eulas')
memory = params.get('memory')
cpu = params.get('cpu')
disk_size = params.get('disk_size')
vmpassword = params.get('vmpassword')
cust_script = params.get('cust_script')
vm_name = params.get('vm_name')
hostname = params.get('hostname')
ip_address = params.get('ip_address')
storage_profile = params.get('storage_profile')
network_adapter_type = params.get('network_adapter_type')
response = dict()
response['changed'] = False
try:
self.vdc.get_vapp(vapp_name)
except EntityNotFoundException:
create_vapp_task = self.vdc.instantiate_vapp(
name=vapp_name,
catalog=catalog_name,
template=template_name,
description=description,
network=network,
fence_mode=fence_mode,
ip_allocation_mode=ip_allocation_mode,
deploy=deploy,
power_on=power_on,
accept_all_eulas=accept_all_eulas,
memory=memory,
cpu=cpu,
disk_size=disk_size,
password=vmpassword,
cust_script=cust_script,
vm_name=vm_name,
hostname=hostname,
ip_address=ip_address,
storage_profile=storage_profile,
network_adapter_type=network_adapter_type)
self.execute_task(create_vapp_task.Tasks.Task[0])
msg = 'Vapp {} has been created'
response['msg'] = msg.format(vapp_name)
response['changed'] = True
else:
msg = "Vapp {} is already present"
response['warnings'] = msg.format(vapp_name)
return response
def create(self):
params = self.params
catalog_name = params.get('catalog_name')
# vapp initialization if catalog has been provided
if catalog_name:
return self.instantiate()
vapp_name = params.get('vapp_name')
description = params.get('description')
network = params.get('network')
fence_mode = params.get('fence_mode')
accept_all_eulas = params.get('accept_all_eulas')
response = dict()
response['changed'] = False
try:
self.vdc.get_vapp(vapp_name)
except EntityNotFoundException:
create_vapp_task = self.vdc.create_vapp(
name=vapp_name,
description=description,
network=network,
fence_mode=fence_mode,
accept_all_eulas=accept_all_eulas)
self.execute_task(create_vapp_task.Tasks.Task[0])
msg = 'Vapp {} has been created'
response['msg'] = msg.format(vapp_name)
response['changed'] = True
else:
msg = "Vapp {} is already present"
response['warnings'] = msg.format(vapp_name)
return response
def delete(self):
vapp_name = self.params.get('vapp_name')
force = self.params.get('force')
response = dict()
response['changed'] = False
try:
self.vdc.get_vapp(vapp_name)
except EntityNotFoundException:
response['warnings'] = "Vapp {} is not present.".format(vapp_name)
else:
delete_vapp_task = self.vdc.delete_vapp(
name=vapp_name, force=force)
self.execute_task(delete_vapp_task)
response['msg'] = 'Vapp {} has been deleted.'.format(vapp_name)
response['changed'] = True
return response
def power_on(self):
response = dict()
response['changed'] = False
vapp_name = self.params.get('vapp_name')
try:
vapp = self.get_vapp()
deploy_vapp_task = vapp.deploy()
self.execute_task(deploy_vapp_task)
msg = 'Vapp {} has been powered on'
response['msg'] = msg.format(vapp_name)
response['changed'] = True
except OperationNotSupportedException as ex:
response['warnings'] = str(ex)
except EntityNotFoundException as ex:
response['warnings'] = str(ex)
return response
def power_off(self):
response = dict()
response['changed'] = False
vapp_name = self.params.get('vapp_name')
try:
vapp = self.get_vapp()
undeploy_vapp_task = vapp.undeploy(action="powerOff")
self.execute_task(undeploy_vapp_task)
response['msg'] = 'Vapp {} has been powered off'.format(vapp_name)
response['changed'] = True
except OperationNotSupportedException as ex:
response['warnings'] = str(ex)
except EntityNotFoundException as ex:
response['warnings'] = str(ex)
return response
def list_vms(self):
response = dict()
response['msg'] = list()
response['changed'] = False
try:
vapp = self.get_vapp()
for vm in vapp.get_all_vms():
try:
ip = vapp.get_primary_ip(vm.get('name'))
except Exception:
ip = None
finally:
response['msg'].append({
"name": vm.get('name'),
"status": VM_STATUSES[vm.get('status')],
"deployed": vm.get('deployed') == 'true',
"ip_address": ip
})
except EntityNotFoundException as ex:
response['warnings'] = str(ex)
return response
def list_networks(self):
response = dict()
response['changed'] = False
try:
vapp = self.get_vapp()
networks = vapp.get_all_networks()
response['msg'] = [
network.get('{' + NSMAP['ovf'] + '}name') for network in networks
]
except EntityNotFoundException as ex:
response['warnings'] = str(ex)
return response
def share(self):
response = dict()
response['changed'] = False
access = self.params.get("shared_access")
try:
vapp = self.get_vapp()
vapp.share_with_org_members(everyone_access_level=access)
msg = "Vapp is shared across org with {0} access"
response['msg'] = msg.format(access)
response['changed'] = True
except EntityNotFoundException as ex:
response['warnings'] = str(ex)
return response
def unshare(self):
response = dict()
response['changed'] = False
try:
vapp = self.get_vapp()
vapp.unshare_from_org_members()
response['msg'] = "Sharing has been stopped for Vapp"
response['changed'] = True
except EntityNotFoundException as ex:
response['warnings'] = str(ex)
return response
def set_meta(self):
response = dict()
response['changed'] = False
vapp_name = self.params.get('vapp_name')
metadata = self.params.get('metadata')
domain = self.params.get("metadata_domain")
visibility = self.params.get("metadata_visibility")
metadata_type = self.params.get("metadata_type")
metadata_type = "Metadata{0}Value".format(metadata_type)
try:
vapp = self.get_vapp()
domain = MetadataDomain(domain)
visibility = MetadataVisibility(visibility)
metadata_type = MetadataValueType(metadata_type)
set_meta_task = vapp.set_multiple_metadata(metadata,
domain=domain,
visibility=visibility,
metadata_value_type=metadata_type)
self.execute_task(set_meta_task)
msg = "Metadata {0} have been set to vApp {1}"
response["msg"] = msg.format(list(metadata.keys()), vapp_name)
except EntityNotFoundException as ex:
response['warnings'] = str(ex)
return response
def get_meta(self):
response = dict()
response['changed'] = False
response['msg'] = dict()
try:
vapp = self.get_vapp()
metadata = vapp.get_metadata()
response['msg'] = {
metadata.MetadataEntry.Key.text: metadata.MetadataEntry.TypedValue.Value.text
}
except EntityNotFoundException as ex:
response['warnings'] = str(ex)
return response
def remove_meta(self):
response = dict()
response['changed'] = False
vapp_name = self.params.get('vapp_name')
domain = self.params.get("metadata_domain")
metadata = self.params.get('metadata')
domain = MetadataDomain(domain)
response['msg'] = list()
try:
vapp = self.get_vapp()
for key in metadata:
remove_meta_task = vapp.remove_metadata(key, domain=domain)
self.execute_task(remove_meta_task)
msg = "Metadata {0} have been removed from vApp {1}"
response["msg"] = msg.format(list(metadata.keys()), vapp_name)
except EntityNotFoundException as ex:
response['warnings'] = str(ex)
return response
def add_org_network(self):
response = dict()
response['changed'] = False
vapp_name = self.params.get('vapp_name')
network = self.params.get("network")
try:
vapp = self.get_vapp()
vapp.connect_org_vdc_network(network)
response['changed'] = True
msg = "Org Network {0} has been added to vApp {1}"
response['msg'] = msg.format(network, vapp_name)
except EntityNotFoundException as ex:
response['warnings'] = str(ex)
except InvalidStateException as ex:
response['warnings'] = str(ex)
return response
def delete_org_network(self):
response = dict()
response['changed'] = False
vapp_name = self.params.get('vapp_name')
network = self.params.get("network")
try:
vapp = self.get_vapp()
vapp.disconnect_org_vdc_network(network)
response['changed'] = True
msg = "Org Network {0} has been added to vApp {1}"
response['msg'] = msg.format(network, vapp_name)
except EntityNotFoundException as ex:
response['warnings'] = str(ex)
except InvalidStateException as ex:
response['warnings'] = str(ex)
return response
def create(client, context, vappInfo):
logging.debug('__INIT__vapp_create [ {0} ]'.format(vappInfo))
cresult = vapp_pb2.CreateVAppResult()
cresult.created = False
#cresult.in_vapp_info=vapp_pb2.CreateVAppInfo()
cresult.in_vapp_info.CopyFrom(vappInfo)
try:
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
v = org.get_vdc(vappInfo.vdc)
if v is None:
raise errors.VDCNotFoundError(vappInfo.vdc)
vdc = VDC(client, href=v.get('href'))
logging.info("__LOG__vapp_create_calling instantiate_vapp............")
network = None
memory = None
storage_profile = None
accept_all_eulas = False
power_on = False
if vappInfo.network:
network = vappInfo.network
if vappInfo.memory:
memory = vappInfo.memory
if vappInfo.storage_profile:
storage_profile = vappInfo.storage_profile
if vappInfo.accept_all_eulas:
accept_all_eulas = vappInfo.accept_all_eulas
if vappInfo.power_on:
power_on = vappInfo.power_on
logging.info(
"__LOG__ CREATE VAPP Params - MEMORY = [%s] NETWORK = [%s] storage_profile =[%s] ",
memory, network, storage_profile)
result = vdc.instantiate_vapp(name=vappInfo.name,
catalog=vappInfo.catalog_name,
template=vappInfo.template_name,
network=network,
memory=memory,
cpu=vappInfo.cpu,
power_on=power_on,
storage_profile=storage_profile,
accept_all_eulas=accept_all_eulas)
task = 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=task_callback)
st = task.get('status')
if st == TaskStatus.SUCCESS.value:
cresult.created = True
else:
raise errors.VCDVappCreationError(
etree.tostring(task, pretty_print=True))
vapp = vdc.get_vapp(vappInfo.name)
if vappInfo.power_on is True:
logging.info("Powering on [Vapp %v]".format(vappInfo.name))
vapp.power_on()
else:
logging.info("Powering off [Vapp %v]".format(vappInfo.name))
vapp.undeploy()
except Exception as e:
error_message = 'ERROR.. Not Created VApp {0} {1}'.format(
vappInfo.name, str(e))
logging.warn(error_message, e)
context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
context.set_details(error_message)
return cresult
class Vapp(VcdAnsibleModule):
def __init__(self, **kwargs):
super(Vapp, self).__init__(**kwargs)
logged_in_org = self.client.get_org()
self.org = Org(self.client, resource=logged_in_org)
vdc_resource = self.org.get_vdc(self.params.get('vdc'))
self.vdc = VDC(self.client, href=vdc_resource.get('href'))
def manage_states(self):
state = self.params.get('state')
if state == "present":
catalog_name = self.params.get('catalog_name')
if catalog_name:
return self.instantiate()
else:
return self.create()
if state == "absent":
return self.delete()
def manage_operations(self):
state = self.params.get('operation')
if state == "poweron":
return self.power_on()
if state == "poweroff":
return self.power_off()
if state == "deploy":
return self.deploy()
if state == "undeploy":
return self.undeploy()
if state == "list_vms":
return self.list_vms()
if state == "list_networks":
return self.list_networks()
def instantiate(self):
params = self.params
vapp_name = params.get('vapp_name')
catalog_name = params.get('catalog_name')
template_name = params.get('template_name')
description = params.get('description')
network = params.get('network')
fence_mode = params.get('fence_mode')
ip_allocation_mode = params.get('ip_allocation_mode')
deploy = params.get('deploy')
power_on = params.get('power_on')
accept_all_eulas = params.get('accept_all_eulas')
memory = params.get('memory')
cpu = params.get('cpu')
disk_size = params.get('disk_size')
vmpassword = params.get('vmpassword')
cust_script = params.get('cust_script')
vm_name = params.get('vm_name')
hostname = params.get('hostname')
ip_address = params.get('ip_address')
storage_profile = params.get('storage_profile')
network_adapter_type = params.get('network_adapter_type')
response = dict()
response['changed'] = False
try:
self.vdc.get_vapp(vapp_name)
except EntityNotFoundException:
create_vapp_task = self.vdc.instantiate_vapp(
name=vapp_name,
catalog=catalog_name,
template=template_name,
description=description,
network=network,
fence_mode=fence_mode,
ip_allocation_mode=ip_allocation_mode,
deploy=deploy,
power_on=power_on,
accept_all_eulas=accept_all_eulas,
memory=memory,
cpu=cpu,
disk_size=disk_size,
password=vmpassword,
cust_script=cust_script,
vm_name=vm_name,
hostname=hostname,
ip_address=ip_address,
storage_profile=storage_profile,
network_adapter_type=network_adapter_type)
self.execute_task(create_vapp_task.Tasks.Task[0])
response['msg'] = 'Vapp {} has been created.'.format(vapp_name)
response['changed'] = True
else:
response['warnings'] = "Vapp {} is already present.".format(vapp_name)
return response
def create(self):
params = self.params
vapp_name = params.get('vapp_name')
description = params.get('description')
network = params.get('network')
fence_mode = params.get('fence_mode')
accept_all_eulas = params.get('accept_all_eulas')
response = dict()
response['changed'] = False
try:
self.vdc.get_vapp(vapp_name)
except EntityNotFoundException:
create_vapp_task = self.vdc.create_vapp(
name=vapp_name,
description=description,
network=network,
fence_mode=fence_mode,
accept_all_eulas=accept_all_eulas)
self.execute_task(create_vapp_task.Tasks.Task[0])
response['msg'] = 'Vapp {} has been created.'.format(vapp_name)
response['changed'] = True
else:
response['warnings'] = "Vapp {} is already present.".format(vapp_name)
return response
def delete(self):
vapp_name = self.params.get('vapp_name')
force = self.params.get('force')
response = dict()
response['changed'] = False
try:
self.vdc.get_vapp(vapp_name)
except EntityNotFoundException:
response['warnings'] = "Vapp {} is not present.".format(vapp_name)
else:
delete_vapp_task = self.vdc.delete_vapp(name=vapp_name, force=force)
self.execute_task(delete_vapp_task)
response['msg'] = 'Vapp {} has been deleted.'.format(vapp_name)
response['changed'] = True
return response
def power_on(self):
vapp_name = self.params.get('vapp_name')
response = dict()
response['changed'] = False
try:
vapp_resource = self.vdc.get_vapp(vapp_name)
vapp = VApp(self.client, name=vapp_name, resource=vapp_resource)
power_on_vapp_task = vapp.power_on()
self.execute_task(power_on_vapp_task)
response['msg'] = 'Vapp {} has been powered on.'.format(vapp_name)
response['changed'] = True
except OperationNotSupportedException:
response['warnings'] = 'Vapp {} is already powered on.'.format(vapp_name)
return response
def power_off(self):
vapp_name = self.params.get('vapp_name')
response = dict()
response['changed'] = False
try:
vapp_resource = self.vdc.get_vapp(vapp_name)
vapp = VApp(self.client, name=vapp_name, resource=vapp_resource)
power_off_vapp_task = vapp.power_off()
self.execute_task(power_off_vapp_task)
response['msg'] = 'Vapp {} has been powered off.'.format(vapp_name)
response['changed'] = True
except OperationNotSupportedException:
response['warnings'] = 'Vapp {} is already powered off.'.format(vapp_name)
return response
def deploy(self):
vapp_name = self.params.get('vapp_name')
response = dict()
response['changed'] = False
try:
vapp_resource = self.vdc.get_vapp(vapp_name)
vapp = VApp(self.client, name=vapp_name, resource=vapp_resource)
deploy_vapp_task = vapp.deploy()
self.execute_task(deploy_vapp_task)
response['msg'] = 'Vapp {} has been deployed.'.format(vapp_name)
response['changed'] = True
except OperationNotSupportedException:
response['warnings'] = 'Vapp {} is already deployed.'.format(vapp_name)
return response
def undeploy(self):
vapp_name = self.params.get('vapp_name')
response = dict()
response['changed'] = False
try:
vapp_resource = self.vdc.get_vapp(vapp_name)
vapp = VApp(self.client, name=vapp_name, resource=vapp_resource)
undeploy_vapp_task = vapp.undeploy()
self.execute_task(undeploy_vapp_task)
response['msg'] = 'Vapp {} has been undeployed.'.format(vapp_name)
response['changed'] = True
except OperationNotSupportedException:
response['warnings'] = 'Vapp {} is already undeployed.'.format(vapp_name)
return response
def list_vms(self):
vapp_name = self.params.get('vapp_name')
vapp_resource = self.vdc.get_vapp(vapp_name)
vapp = VApp(self.client, name=vapp_name, resource=vapp_resource)
response = dict()
response['msg'] = []
for vm in vapp.get_all_vms():
vm_details = dict()
vm_details['name'] = vm.get('name')
vm_details['status'] = VM_STATUSES[vm.get('status')]
vm_details['deployed'] = vm.get('deployed')=='true'
try:
vm_details['ip_address'] = vapp.get_primary_ip(vm.get('name'))
except:
vm_details['ip_address'] = None
response['msg'].append(vm_details)
return response
def list_networks(self):
vapp_name = self.params.get('vapp_name')
vapp_resource = self.vdc.get_vapp(vapp_name)
vapp = VApp(self.client, name=vapp_name, resource=vapp_resource)
response = dict()
response['msg'] = []
for network in vapp.get_all_networks():
response['msg'].append(network.get('{'+NSMAP['ovf']+'}name'))
return response
def create(client, context, vappInfo):
logging.debug('__INIT__vapp_create [ {0} ]'.format(vappInfo))
cresult = vapp_pb2.CreateVAppResult()
cresult.created = False
#cresult.in_vapp_info=vapp_pb2.CreateVAppInfo()
cresult.in_vapp_info.CopyFrom(vappInfo)
try:
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
v = org.get_vdc(vappInfo.vdc)
if v is None:
raise errors.VDCNotFoundError(vappInfo.vdc)
vdc = VDC(client, href=v.get('href'))
logging.info("__LOG__vapp_create_calling instantiate_vapp............")
network = None
memory = None
storage_profile = None
accept_all_eulas = False
power_on = False
if vappInfo.network:
network = vappInfo.network
if vappInfo.memory:
memory = vappInfo.memory
if vappInfo.storage_profile:
storage_profile = vappInfo.storage_profile
if vappInfo.accept_all_eulas:
accept_all_eulas = vappInfo.accept_all_eulas
if vappInfo.power_on:
power_on = vappInfo.power_on
logging.info(
"__LOG__ CREATE VAPP Params - MEMORY = [%s] NETWORK = [%s] storage_profile =[%s] ",
memory, network, storage_profile)
result = vdc.instantiate_vapp(
name=vappInfo.name,
catalog=vappInfo.catalog_name,
template=vappInfo.template_name,
network=network,
memory=memory,
cpu=vappInfo.cpu,
power_on=power_on,
storage_profile=storage_profile,
accept_all_eulas=accept_all_eulas)
task = 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=task_callback)
st = task.get('status')
if st == TaskStatus.SUCCESS.value:
cresult.created = True
else:
raise errors.VCDVappCreationError(
etree.tostring(task, pretty_print=True))
vapp = vdc.get_vapp(vappInfo.name)
if vappInfo.power_on is True:
logging.info("Powering on [Vapp %v]".format(vappInfo.name))
vapp.power_on()
else:
logging.info("Powering off [Vapp %v]".format(vappInfo.name))
vapp.undeploy()
except Exception as e:
error_message = 'ERROR.. Not Created VApp {0} {1}'.format(
vappInfo.name, str(e))
logging.warn(error_message, e)
context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
context.set_details(error_message)
return cresult
def create_template(ctx, config, client, org, vdc_resource, catalog,
no_capture, template):
ctx.obj = {}
ctx.obj['client'] = client
try:
source_ova_item = org.get_catalog_item(config['broker']['catalog'],
template['source_ova_name'])
except Exception:
source_ova_item = upload_source_ova(config, client, org, template)
click.secho('Find source ova \'%s\': %s' %
(template['source_ova_name'],
bool_to_msg(source_ova_item is not None)))
if source_ova_item is None:
return None
item_id = source_ova_item.get('id')
flag = False
while True:
q = client.get_typed_query(
'adminCatalogItem',
query_result_format=QueryResultFormat.ID_RECORDS,
qfilter='id==%s' % item_id)
records = list(q.execute())
if records[0].get('status') == 'RESOLVED':
if flag:
click.secho('done', fg='blue')
break
else:
if flag:
click.secho('.', nl=False, fg='green')
else:
click.secho('Waiting for upload to complete...',
nl=False,
fg='green')
flag = True
time.sleep(5)
vdc = VDC(client, resource=vdc_resource)
try:
vapp_resource = vdc.get_vapp(template['temp_vapp'])
except Exception:
vapp_resource = None
if vapp_resource is None:
click.secho('Creating vApp template \'%s\'' % template['temp_vapp'],
fg='green')
init_script = get_data_file('init-%s.sh' % template['name'])
vapp_resource = vdc.instantiate_vapp(
template['temp_vapp'],
catalog.get('name'),
template['source_ova_name'],
network=config['broker']['network'],
fence_mode='bridged',
ip_allocation_mode=config['broker']['ip_allocation_mode'],
deploy=True,
power_on=True,
memory=template['mem'],
cpu=template['cpu'],
password=None,
cust_script=init_script,
accept_all_eulas=True,
vm_name=template['temp_vapp'],
hostname=template['temp_vapp'],
storage_profile=config['broker']['storage_profile'])
stdout(vapp_resource.Tasks.Task[0], ctx)
vapp = VApp(client, resource=vapp_resource)
vapp.reload()
vs = get_vsphere(config, vapp, template['temp_vapp'])
vs.connect()
moid = vapp.get_vm_moid(template['temp_vapp'])
vm = vs.get_vm_by_moid(moid)
vs.wait_until_tools_ready(vm,
sleep=5,
callback=wait_for_tools_ready_callback)
click.secho('Customizing vApp template \'%s\'' % template['temp_vapp'],
fg='green')
vapp.reload()
password_auto = vapp.get_admin_password(template['temp_vapp'])
cust_script = get_data_file('cust-%s.sh' % template['name'])
result = vs.execute_script_in_guest(
vm,
'root',
password_auto,
cust_script,
target_file=None,
wait_for_completion=True,
wait_time=10,
get_output=True,
delete_script=True,
callback=wait_for_guest_execution_callback)
click.secho('Result: %s' % result, fg='green')
result_stdout = result[1].content.decode()
result_stderr = result[2].content.decode()
click.secho('stderr:')
if len(result_stderr) > 0:
click.secho(result_stderr, err=True)
click.secho('stdout:')
if len(result_stdout) > 0:
click.secho(result_stdout, err=False)
if result[0] != 0:
raise Exception('Failed customizing VM')
if not no_capture:
capture_as_template(ctx, config, vapp_resource, org, catalog, template)
if template['cleanup']:
click.secho('Deleting vApp template \'%s\' ' %
template['temp_vapp'],
fg='green')
vdc.reload()
task = vdc.delete_vapp(template['temp_vapp'], force=True)
stdout(task, ctx)
class Vapp(VcdAnsibleModule):
def __init__(self, **kwargs):
super(Vapp, self).__init__(**kwargs)
logged_in_org = self.client.get_org()
self.org = Org(self.client, resource=logged_in_org)
vdc_resource = self.org.get_vdc(self.params.get('vdc'))
self.vdc = VDC(self.client, href=vdc_resource.get('href'))
def manage_states(self):
state = self.params.get('state')
if state == "present":
return self.create()
if state == "absent":
return self.delete()
def manage_operations(self):
state = self.params.get('operation')
if state == "poweron":
return self.power_on()
if state == "poweroff":
return self.power_off()
if state == "deploy":
return self.deploy()
if state == "undeploy":
return self.undeploy()
if state == "list_vms":
return self.list_vms()
if state == "list_networks":
return self.list_networks()
def get_vapp(self):
vapp_name = self.params.get('vapp_name')
vapp_resource = self.vdc.get_vapp(vapp_name)
return VApp(self.client, name=vapp_name, resource=vapp_resource)
def instantiate(self):
params = self.params
vapp_name = params.get('vapp_name')
catalog_name = params.get('catalog_name')
template_name = params.get('template_name')
description = params.get('description')
network = params.get('network')
fence_mode = params.get('fence_mode')
ip_allocation_mode = params.get('ip_allocation_mode')
deploy = params.get('deploy')
power_on = params.get('power_on')
accept_all_eulas = params.get('accept_all_eulas')
memory = params.get('memory')
cpu = params.get('cpu')
disk_size = params.get('disk_size')
vmpassword = params.get('vmpassword')
cust_script = params.get('cust_script')
vm_name = params.get('vm_name')
hostname = params.get('hostname')
ip_address = params.get('ip_address')
storage_profile = params.get('storage_profile')
network_adapter_type = params.get('network_adapter_type')
response = dict()
response['changed'] = False
try:
self.vdc.get_vapp(vapp_name)
except EntityNotFoundException:
create_vapp_task = self.vdc.instantiate_vapp(
name=vapp_name,
catalog=catalog_name,
template=template_name,
description=description,
network=network,
fence_mode=fence_mode,
ip_allocation_mode=ip_allocation_mode,
deploy=deploy,
power_on=power_on,
accept_all_eulas=accept_all_eulas,
memory=memory,
cpu=cpu,
disk_size=disk_size,
password=vmpassword,
cust_script=cust_script,
vm_name=vm_name,
hostname=hostname,
ip_address=ip_address,
storage_profile=storage_profile,
network_adapter_type=network_adapter_type)
self.execute_task(create_vapp_task.Tasks.Task[0])
response['msg'] = 'Vapp {} has been created.'.format(vapp_name)
response['changed'] = True
else:
response['warnings'] = "Vapp {} is already present.".format(vapp_name)
return response
def create(self):
params = self.params
catalog_name = params.get('catalog_name')
# vapp initialization if catalog has been provided
if catalog_name:
return self.instantiate()
vapp_name = params.get('vapp_name')
description = params.get('description')
network = params.get('network')
fence_mode = params.get('fence_mode')
accept_all_eulas = params.get('accept_all_eulas')
response = dict()
response['changed'] = False
try:
self.vdc.get_vapp(vapp_name)
except EntityNotFoundException:
create_vapp_task = self.vdc.create_vapp(
name=vapp_name,
description=description,
network=network,
fence_mode=fence_mode,
accept_all_eulas=accept_all_eulas)
self.execute_task(create_vapp_task.Tasks.Task[0])
response['msg'] = 'Vapp {} has been created.'.format(vapp_name)
response['changed'] = True
else:
response['warnings'] = "Vapp {} is already present.".format(vapp_name)
return response
def delete(self):
vapp_name = self.params.get('vapp_name')
force = self.params.get('force')
response = dict()
response['changed'] = False
try:
self.vdc.get_vapp(vapp_name)
except EntityNotFoundException:
response['warnings'] = "Vapp {} is not present.".format(vapp_name)
else:
delete_vapp_task = self.vdc.delete_vapp(name=vapp_name, force=force)
self.execute_task(delete_vapp_task)
response['msg'] = 'Vapp {} has been deleted.'.format(vapp_name)
response['changed'] = True
return response
def power_on(self):
vapp_name = self.params.get('vapp_name')
response = dict()
response['changed'] = False
vapp = self.get_vapp()
try:
if not vapp.is_powered_on():
vapp_resource = self.vdc.get_vapp(vapp_name)
vapp = VApp(self.client, name=vapp_name, resource=vapp_resource)
power_on_vapp_task = vapp.power_on()
self.execute_task(power_on_vapp_task)
response['msg'] = 'Vapp {} has been powered on.'.format(vapp_name)
response['changed'] = True
else:
response['warnings'] = 'Vapp {} is already powered on.'.format(vapp_name)
except OperationNotSupportedException:
response['warnings'] = 'Operation is not supported. You may have no VM(s) in {}'.format(vapp_name)
return response
def power_off(self):
vapp_name = self.params.get('vapp_name')
response = dict()
response['changed'] = False
vapp = self.get_vapp()
try:
if not vapp.is_powered_off():
vapp_resource = self.vdc.get_vapp(vapp_name)
vapp = VApp(self.client, name=vapp_name, resource=vapp_resource)
power_off_vapp_task = vapp.power_off()
self.execute_task(power_off_vapp_task)
response['msg'] = 'Vapp {} has been powered off.'.format(vapp_name)
response['changed'] = True
else:
response['warnings'] = 'Vapp {} is already powered off.'.format(vapp_name)
except OperationNotSupportedException:
response['warnings'] = 'Operation is not supported. You may have no VM(s) in {}'.format(vapp_name)
return response
def deploy(self):
vapp_name = self.params.get('vapp_name')
response = dict()
response['changed'] = False
vapp = self.get_vapp()
if not vapp.is_deployed():
vapp_resource = self.vdc.get_vapp(vapp_name)
vapp = VApp(self.client, name=vapp_name, resource=vapp_resource)
deploy_vapp_task = vapp.deploy()
self.execute_task(deploy_vapp_task)
response['msg'] = 'Vapp {} has been deployed.'.format(vapp_name)
response['changed'] = True
else:
response['warnings'] = 'Vapp {} is already deployed.'.format(vapp_name)
return response
def undeploy(self):
vapp_name = self.params.get('vapp_name')
response = dict()
response['changed'] = False
vapp = self.get_vapp()
if vapp.is_deployed():
vapp_resource = self.vdc.get_vapp(vapp_name)
vapp = VApp(self.client, name=vapp_name, resource=vapp_resource)
undeploy_vapp_task = vapp.undeploy()
self.execute_task(undeploy_vapp_task)
response['msg'] = 'Vapp {} has been undeployed.'.format(vapp_name)
response['changed'] = True
else:
response['warnings'] = 'Vapp {} is already undeployed.'.format(vapp_name)
return response
def list_vms(self):
vapp = self.get_vapp()
response = dict()
response['msg'] = list()
for vm in vapp.get_all_vms():
vm_details = dict()
vm_details['name'] = vm.get('name')
vm_details['status'] = VM_STATUSES[vm.get('status')]
vm_details['deployed'] = vm.get('deployed') == 'true'
try:
vm_details['ip_address'] = vapp.get_primary_ip(vm.get('name'))
except Exception:
vm_details['ip_address'] = None
response['msg'].append(vm_details)
return response
def list_networks(self):
vapp = self.get_vapp()
response = dict()
response['msg'] = list()
for network in vapp.get_all_networks():
response['msg'].append(network.get('{' + NSMAP['ovf'] + '}name'))
return response
class Vapp(VcdAnsibleModule):
def __init__(self, **kwargs):
super(Vapp, self).__init__(**kwargs)
logged_in_org = self.client.get_org()
self.org = Org(self.client, resource=logged_in_org)
vdc_resource = self.org.get_vdc(self.params.get('vdc'))
self.vdc = VDC(self.client, href=vdc_resource.get('href'))
def manage_states(self):
state = self.params.get('state')
if state == "present":
return self.create()
if state == "absent":
return self.delete()
def manage_operations(self):
state = self.params.get('operation')
if state == "poweron":
return self.power_on()
if state == "poweroff":
return self.power_off()
if state == "deploy":
return self.deploy()
if state == "undeploy":
return self.undeploy()
def create(self):
params = self.params
vapp_name = params.get('vapp_name')
catalog_name = params.get('catalog_name')
template_name = params.get('template_name')
description = params.get('description')
network = params.get('network')
fence_mode = params.get('fence_mode')
ip_allocation_mode = params.get('ip_allocation_mode')
deploy = params.get('deploy')
power_on = params.get('power_on')
accept_all_eulas = params.get('accept_all_eulas')
memory = params.get('memory')
cpu = params.get('cpu')
disk_size = params.get('disk_size')
vmpassword = params.get('vmpassword')
cust_script = params.get('cust_script')
vm_name = params.get('vm_name')
hostname = params.get('hostname')
ip_address = params.get('ip_address')
storage_profile = params.get('storage_profile')
network_adapter_type = params.get('network_adapter_type')
response = dict()
response['changed'] = False
try:
self.vdc.get_vapp(vapp_name)
except EntityNotFoundException:
create_vapp_task = self.vdc.instantiate_vapp(
name=vapp_name,
catalog=catalog_name,
template=template_name,
description=description,
network=network,
fence_mode=fence_mode,
ip_allocation_mode=ip_allocation_mode,
deploy=deploy,
power_on=power_on,
accept_all_eulas=accept_all_eulas,
memory=memory,
cpu=cpu,
disk_size=disk_size,
password=vmpassword,
cust_script=cust_script,
vm_name=vm_name,
hostname=hostname,
ip_address=ip_address,
storage_profile=storage_profile,
network_adapter_type=network_adapter_type)
self.execute_task(create_vapp_task.Tasks.Task[0])
response['msg'] = 'Vapp {} has been created.'.format(vapp_name)
response['changed'] = True
else:
response['warnings'] = "Vapp {} is already present.".format(
vapp_name)
return response
def delete(self):
vapp_name = self.params.get('vapp_name')
force = self.params.get('force')
response = dict()
response['changed'] = False
try:
self.vdc.get_vapp(vapp_name)
except EntityNotFoundException:
response['warnings'] = "Vapp {} is not present.".format(vapp_name)
else:
delete_vapp_task = self.vdc.delete_vapp(name=vapp_name,
force=force)
self.execute_task(delete_vapp_task)
response['msg'] = 'Vapp {} has been deleted.'.format(vapp_name)
response['changed'] = True
return response
def power_on(self):
vapp_name = self.params.get('vapp_name')
response = dict()
response['changed'] = False
try:
vapp_resource = self.vdc.get_vapp(vapp_name)
vapp = VApp(self.client, name=vapp_name, resource=vapp_resource)
power_on_vapp_task = vapp.power_on()
self.execute_task(power_on_vapp_task)
response['msg'] = 'Vapp {} has been powered on.'.format(vapp_name)
response['changed'] = True
except OperationNotSupportedException:
response['warnings'] = 'Vapp {} is already powered on.'.format(
vapp_name)
return response
def power_off(self):
vapp_name = self.params.get('vapp_name')
response = dict()
response['changed'] = False
try:
vapp_resource = self.vdc.get_vapp(vapp_name)
vapp = VApp(self.client, name=vapp_name, resource=vapp_resource)
power_off_vapp_task = vapp.power_off()
self.execute_task(power_off_vapp_task)
response['msg'] = 'Vapp {} has been powered off.'.format(vapp_name)
response['changed'] = True
except OperationNotSupportedException:
response['warnings'] = 'Vapp {} is already powered off.'.format(
vapp_name)
return response
def deploy(self):
vapp_name = self.params.get('vapp_name')
response = dict()
response['changed'] = False
try:
vapp_resource = self.vdc.get_vapp(vapp_name)
vapp = VApp(self.client, name=vapp_name, resource=vapp_resource)
deploy_vapp_task = vapp.deploy()
self.execute_task(deploy_vapp_task)
response['msg'] = 'Vapp {} has been deployed.'.format(vapp_name)
response['changed'] = True
except OperationNotSupportedException:
response['warnings'] = 'Vapp {} is already deployed.'.format(
vapp_name)
return response
def undeploy(self):
vapp_name = self.params.get('vapp_name')
response = dict()
response['changed'] = False
try:
vapp_resource = self.vdc.get_vapp(vapp_name)
vapp = VApp(self.client, name=vapp_name, resource=vapp_resource)
undeploy_vapp_task = vapp.undeploy()
self.execute_task(undeploy_vapp_task)
response['msg'] = 'Vapp {} has been undeployed.'.format(vapp_name)
response['changed'] = True
except OperationNotSupportedException:
response['warnings'] = 'Vapp {} is already undeployed.'.format(
vapp_name)
return response
name=network['network_name'],
type=FenceMode.ISOLATED.value)
if len(new_network_list) > 0:
print("Isolated network is visible in VDC: {0}".format(
network['network_name']))
network_exists = True
else:
print("Isolated network is not visible yet: {0}".format(
network['network_name']))
time.sleep(3)
# Check for vApps and create them if they don't exist. We have to
# reload the VDC object so it has all the links to current vApps.
vdc.reload()
for vapp_cfg in cfg.vapps:
try:
vapp = vdc.get_vapp(vapp_cfg['name'])
print("vApp exists: {0}".format(vapp_cfg['name']))
except Exception:
print("vApp does not exist: name={0}".format(vapp_cfg['name']))
vapp_resource = vdc.instantiate_vapp(**vapp_cfg)
print("vApp instantiated")
# We don't track the task as instantiating a vApp takes a while.
# Uncomment below if you want to ensure the vApps are available.
# handle_task(client, vapp_resource.Tasks.Task[0])
# Log out.
print("All done!")
client.logout()