def cluster_rollback(self):
"""Implements rollback for cluster creation failure"""
LOGGER.info('About to rollback cluster with name: %s' %
self.cluster_name)
clusters = load_from_metadata(self.client_tenant,
name=self.cluster_name)
if len(clusters) != 1:
LOGGER.debug('Cluster %s not found.' % self.cluster_name)
return
self.cluster = clusters[0]
vdc = VDC(self.client_tenant, href=self.cluster['vdc_href'])
vdc.delete_vapp(self.cluster['name'], force=True)
LOGGER.info('Successfully deleted cluster: %s' % self.cluster_name)
def cluster_rollback(self):
"""Rollback for cluster creation failure."""
LOGGER.info(f"About to rollback cluster with name: "
"{self.cluster_name}")
self._connect_tenant()
clusters = load_from_metadata(
self.tenant_client, name=self.cluster_name)
if len(clusters) != 1:
LOGGER.debug(f"Cluster {self.cluster_name} not found.")
return
self.cluster = clusters[0]
vdc = VDC(self.tenant_client, href=self.cluster['vdc_href'])
vdc.delete_vapp(self.cluster['name'], force=True)
LOGGER.info(f"Successfully deleted cluster: {self.cluster_name}")
def delete_cluster_thread(self):
LOGGER.debug('about to delete cluster with name: %s',
self.cluster_name)
try:
vdc = VDC(self.client_tenant, href=self.cluster['vdc_href'])
delete_task = vdc.delete_vapp(self.cluster['name'], force=True)
self.client_tenant.get_task_monitor().\
wait_for_status(
task=delete_task,
timeout=600,
poll_frequency=5,
fail_on_status=None,
expected_target_statuses=[TaskStatus.SUCCESS],
callback=None)
self.update_task(TaskStatus.SUCCESS,
self.op,
message='Deleted cluster %s(%s)' %
(self.cluster_name, self.cluster_id))
except Exception as e:
LOGGER.error(traceback.format_exc())
self.update_task(self.cluster_name,
self.cluster_id,
TaskStatus.ERROR,
self.op,
error_message=str(e))
def delete_vapp(vapp_name):
vdc = VDC(CLIENT, href=VDC_HREF)
try:
task = vdc.delete_vapp(vapp_name, force=True)
CLIENT.get_task_monitor().wait_for_success(task)
vdc.reload()
except EntityNotFoundException:
pass
def delete(ctx, name, force):
try:
client = ctx.obj['client']
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
task = vdc.delete_vapp(name, force)
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
def delete_vapp(vapp_name, vdc_href, logger=NULL_LOGGER):
logger.debug(f"Deleting vapp {vapp_name} in vdc {vdc_href}.")
vdc = VDC(CLIENT, href=vdc_href)
try:
task = vdc.delete_vapp(vapp_name, force=True)
CLIENT.get_task_monitor().wait_for_success(task)
vdc.reload()
logger.debug(f"Successfully deleted the vapp {vapp_name}.")
except EntityNotFoundException as e:
logger.warning(f"Failed to vapp {vapp_name}: {e}")
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 delete_cluster_thread(self):
LOGGER.debug('about to delete cluster with name: %s',
self.cluster_name)
try:
vdc = VDC(self.client_tenant, href=self.cluster['vdc_href'])
task = vdc.delete_vapp(self.cluster['name'], force=True)
self.client_tenant.get_task_monitor().wait_for_status(task)
self.update_task(TaskStatus.SUCCESS,
message='Deleted cluster %s(%s)' %
(self.cluster_name, self.cluster_id))
except Exception as e:
LOGGER.error(traceback.format_exc())
self.update_task(TaskStatus.ERROR, error_message=str(e))
def delete(ctx, name, vm_names, force):
try:
client = ctx.obj['client']
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
if len(vm_names) == 0:
task = vdc.delete_vapp(name, force)
else:
vapp_resource = vdc.get_vapp(name)
vapp = VApp(client, resource=vapp_resource)
task = vapp.delete_vms(vm_names)
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
def delete_cluster_thread(self):
LOGGER.debug(f"About to delete cluster with name: {self.cluster_name}")
try:
vdc = VDC(self.tenant_client, href=self.cluster['vdc_href'])
task = vdc.delete_vapp(self.cluster['name'], force=True)
self.tenant_client.get_task_monitor().wait_for_status(task)
self.update_task(TaskStatus.SUCCESS,
message=f"Deleted cluster {self.cluster_name}"
f"({self.cluster_id})")
except Exception as e:
LOGGER.error(traceback.format_exc())
self.update_task(TaskStatus.ERROR, error_message=str(e))
finally:
self._disconnect_sys_admin()
def delete(ctx, name, vm_names, force):
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 len(vm_names) == 0:
task = vdc.delete_vapp(name, force)
else:
vapp_resource = vdc.get_vapp(name)
vapp = VApp(client, resource=vapp_resource)
task = vapp.delete_vms(vm_names)
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
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_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 delete(client, vappInfo):
logging.debug("===INIT delete vapp called === \n")
try:
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
v = org.get_vdc(vappInfo.vdc)
vdc = VDC(client, href=v.get('href'))
cresult = vapp_pb2.DeleteVAppResult()
cresult.deleted = False
try:
logging.info(" calling delete_vapp............")
result = vdc.delete_vapp(name=vappInfo.name, force=True)
logging.info(" delete proceeding............")
task = 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=task_callback)
if task.get('status') == TaskStatus.SUCCESS.value:
cresult.deleted = True
except Exception as e:
logging.exception("\n Not Deleted VApp [" + vappInfo.name + "]")
return cresult
except Exception as e:
logging.exception("error occured create vapp ", e)
def delete(client, vappInfo):
logging.debug("===INIT delete vapp called === \n")
try:
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
v = org.get_vdc(vappInfo.vdc)
vdc = VDC(client, href=v.get('href'))
cresult = vapp_pb2.DeleteVAppResult()
cresult.deleted = False
try:
logging.info(" calling delete_vapp............")
result = vdc.delete_vapp(name=vappInfo.name, force=True)
logging.info(" delete proceeding............")
task = 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=task_callback)
if task.get('status') == TaskStatus.SUCCESS.value:
cresult.deleted = True
except Exception as e:
logging.exception("\n Not Deleted VApp [" + vappInfo.name + "]")
return cresult
except Exception as e:
logging.exception("error occured create vapp ", e)
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
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
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
vm_obj.reload()
time.sleep(5)
print(" VM '{0}' ... {1} - IP = {2}".format(
vm.get('name'), "UP",
vm_obj.list_nics()[0]['ip_address'].ljust(20)))
if (vapp.is_powered_on()):
print(" vApp '{0}' ... powering off {1}\r".format(cfg.vapp['name'],
"".ljust(20)),
end='')
# result = vapp.shutdown()
result = vapp.power_off()
handle_task(client, result)
print(" vApp '{0}' ... DOWN {1}\r".format(cfg.vapp['name'], "".ljust(20)),
end='')
result = vapp.undeploy()
handle_task(client, result)
print(" vApp '{0}' ... UNDEPLOYED {1}\r".format(cfg.vapp['name'],
"".ljust(20)))
else:
print(" vApp '{0}' ... UNDEPLOYED (already)".format(
cfg.vapp['name']).ljust(20))
result = vdc.delete_vapp(cfg.vapp['name'], force=True)
handle_task(client, result)
print(" vApp '{0}' ... DELETED".format(cfg.vapp['name']).ljust(20))
# Log out.
print("All done!")
client.logout()
def _delete_cluster(self, *args, cluster_name, cluster_vdc_href):
LOGGER.debug(f"About to delete cluster with name: {cluster_name}")
vdc = VDC(self.tenant_client, href=cluster_vdc_href)
task = vdc.delete_vapp(cluster_name, force=True)
self.tenant_client.get_task_monitor().wait_for_status(task)
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):
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
