def node_rollback(self, node_list): """Implements rollback for node creation failure :param list node_list: faulty nodes to be deleted """ LOGGER.info('About to rollback nodes from cluster with name: %s' % self.cluster_name) LOGGER.info('Node list to be deleted:%s' % node_list) vapp = VApp(self.client_tenant, href=self.cluster['vapp_href']) template = self.get_template() try: delete_nodes_from_cluster(self.config, vapp, template, node_list, force=True) except Exception: LOGGER.warning("Couldn't delete node %s from cluster:%s" % (node_list, self.cluster_name)) for vm_name in node_list: vm = VM(self.client_tenant, resource=vapp.get_vm(vm_name)) try: vm.undeploy() except Exception: LOGGER.warning("Couldn't undeploy VM %s" % vm_name) vapp.delete_vms(node_list) LOGGER.info('Successfully deleted nodes: %s' % node_list)
def node_rollback(self, node_list): """Rollback for node creation failure. :param list node_list: faulty nodes to be deleted """ LOGGER.info(f"About to rollback nodes from cluster with name: " "{self.cluster_name}") LOGGER.info(f"Node list to be deleted:{node_list}") vapp = VApp(self.tenant_client, href=self.cluster['vapp_href']) template = self._get_template() try: server_config = get_server_runtime_config() delete_nodes_from_cluster(server_config, vapp, template, node_list, force=True) except Exception: LOGGER.warning("Couldn't delete node {node_list} from cluster:" "{self.cluster_name}") for vm_name in node_list: vm = VM(self.tenant_client, resource=vapp.get_vm(vm_name)) try: vm.undeploy() except Exception: LOGGER.warning(f"Couldn't undeploy VM {vm_name}") vapp.delete_vms(node_list) LOGGER.info(f"Successfully deleted nodes: {node_list}")
def delete_vm(client): print("================= Vdc delete request ===================") vdc_name = "pcp_vdc_02" target_vm_name = "pcp_vm" org_resource = client.get_org() org = Org(client, resource=org_resource) print("Org name: ", org.get_name()) print("Vdc name: ", vdc_name) vdc_resource = org.get_vdc(vdc_name) vdc = VDC(client, name=vdc_name, resource=vdc_resource) vapp_resource = vdc.get_vapp(vapp_name) vapp = VApp(client, name=vapp_name, resource=vapp_resource) delete_vapp_vm_resp = vapp.delete_vms(target_vm_name) task = client.get_task_monitor().wait_for_status( task=delete_vapp_vm_resp, timeout=60, poll_frequency=2, fail_on_statuses=None, expected_target_statuses=[ TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR, TaskStatus.CANCELED ], callback=None) st = task.get('status') if st == TaskStatus.SUCCESS.value: message = 'delete vdc status : {0} '.format(st) logging.info(message) else: raise errors.VCDVdcDeleteError(etree.tostring(task, pretty_print=True))
def delete_nodes_thread(self): LOGGER.debug(f"About to delete nodes from cluster with name: " f"{self.cluster_name}") try: vapp = VApp(self.tenant_client, href=self.cluster['vapp_href']) template = self._get_template() self._update_task( TaskStatus.RUNNING, message=f"Deleting " f"{len(self.req_spec.get(RequestKey.NODE_NAMES_LIST))}" f" node(s) from " f"{self.cluster_name}({self.cluster_id})") try: server_config = get_server_runtime_config() delete_nodes_from_cluster( server_config, vapp, template, self.req_spec.get(RequestKey.NODE_NAMES_LIST), self.req_spec.get(RequestKey.FORCE_DELETE)) except Exception: LOGGER.error(f"Couldn't delete node " f"{self.req_spec.get(RequestKey.NODE_NAMES_LIST)}" f" from cluster:{self.cluster_name}") self._update_task( TaskStatus.RUNNING, message=f"Undeploying " f"{len(self.req_spec.get(RequestKey.NODE_NAMES_LIST))}" f" node(s) for {self.cluster_name}({self.cluster_id})") for vm_name in self.req_spec.get(RequestKey.NODE_NAMES_LIST): vm = VM(self.tenant_client, resource=vapp.get_vm(vm_name)) try: task = vm.undeploy() self.tenant_client.get_task_monitor().wait_for_status(task) except Exception: LOGGER.warning(f"Couldn't undeploy VM {vm_name}") self._update_task( TaskStatus.RUNNING, message=f"Deleting " f"{len(self.req_spec.get(RequestKey.NODE_NAMES_LIST))}" f" VM(s) for {self.cluster_name}({self.cluster_id})") task = vapp.delete_vms(self.req_spec.get(RequestKey.NODE_NAMES_LIST)) # noqa: E501 self.tenant_client.get_task_monitor().wait_for_status(task) self._update_task( TaskStatus.SUCCESS, message=f"Deleted " f"{len(self.req_spec.get(RequestKey.NODE_NAMES_LIST))}" f" node(s) to cluster " f"{self.cluster_name}({self.cluster_id})") except Exception as e: LOGGER.error(traceback.format_exc()) error_obj = error_to_json(e) stack_trace = \ ''.join(error_obj[ERROR_MESSAGE_KEY][ERROR_STACKTRACE_KEY]) self._update_task( TaskStatus.ERROR, error_message=error_obj[ERROR_MESSAGE_KEY][ERROR_DESCRIPTION_KEY], # noqa: E501 stack_trace=stack_trace) finally: self._disconnect_sys_admin()
def delete_vm(client): print("================= Vdc delete request ===================") vdc_name = "pcp_vdc_02" target_vm_name = "pcp_vm" org_resource = client.get_org() org = Org(client, resource=org_resource) print("Org name: ", org.get_name()) print("Vdc name: ", vdc_name) vdc_resource = org.get_vdc(vdc_name) vdc = VDC(client, name=vdc_name, resource=vdc_resource) vapp_resource = vdc.get_vapp(vapp_name) vapp = VApp(client, name=vapp_name, resource=vapp_resource) delete_vapp_vm_resp = vapp.delete_vms(target_vm_name) task = client.get_task_monitor().wait_for_status(task=delete_vapp_vm_resp, timeout=60, poll_frequency=2, fail_on_statuses=None, expected_target_statuses=[ TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR, TaskStatus.CANCELED ], callback=None) st = task.get('status') if st == TaskStatus.SUCCESS.value: message = 'delete vdc status : {0} '.format(st) logging.info(message) else: raise errors.VCDVdcDeleteError(etree.tostring(task, pretty_print=True))
def delete(self, request): logging.info("__INIT__delete[VappVm]") res = vapp_vm_pb2.DeleteVappVmResult() res.deleted = False org_resource = self.client.get_org() org = Org(self.client, resource=org_resource) try: vdc_resource = org.get_vdc(request.target_vdc) vdc = VDC(self.client, name=request.target_vdc, resource=vdc_resource) vapp_resource = vdc.get_vapp(request.target_vapp) vapp = VApp(self.client, name=request.target_vapp, resource=vapp_resource) # Before deleting power_off vm # self.power_off(request.target_vdc, request.target_vapp) # Before deleting undeploy vm self.undeploy(request) vms = [request.target_vm_name] delete_vapp_vm_resp = vapp.delete_vms(vms) task = self.client.get_task_monitor().wait_for_status( task=delete_vapp_vm_resp, timeout=60, poll_frequency=2, fail_on_statuses=None, expected_target_statuses=[ TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR, TaskStatus.CANCELED ], callback=None) st = task.get('status') if st != TaskStatus.SUCCESS.value: raise errors.VappVmDeleteError( etree.tostring(task, pretty_print=True)) message = 'delete vapp_vm status : {0} '.format(st) logging.info(message) res.deleted = True except Exception as e: res.deleted = False errmsg = '__ERROR_delete[VappVm] failed for VappVm {0}. __ErrorMessage__ {1}' logging.warn(errmsg.format(request.target_vm_name, str(e))) self.context.set_code(grpc.StatusCode.INVALID_ARGUMENT) self.context.set_details(errmsg) return res logging.info("__DONE__delete[VappVm]") return res
def delete(self, request): logging.info("__INIT__delete[VappVm]") res = vapp_vm_pb2.DeleteVappVmResult() res.deleted = False org_resource = self.client.get_org() org = Org(self.client, resource=org_resource) try: vdc_resource = org.get_vdc(request.target_vdc) vdc = VDC( self.client, name=request.target_vdc, resource=vdc_resource) vapp_resource = vdc.get_vapp(request.target_vapp) vapp = VApp( self.client, name=request.target_vapp, resource=vapp_resource) # Before deleting power_off vm # self.power_off(request.target_vdc, request.target_vapp) # Before deleting undeploy vm self.undeploy(request) vms = [request.target_vm_name] delete_vapp_vm_resp = vapp.delete_vms(vms) task = self.client.get_task_monitor().wait_for_status( task=delete_vapp_vm_resp, timeout=60, poll_frequency=2, fail_on_statuses=None, expected_target_statuses=[ TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR, TaskStatus.CANCELED ], callback=None) st = task.get('status') if st != TaskStatus.SUCCESS.value: raise errors.VappVmDeleteError( etree.tostring(task, pretty_print=True)) message = 'delete vapp_vm status : {0} '.format(st) logging.info(message) res.deleted = True except Exception as e: res.deleted = False errmsg = '__ERROR_delete[VappVm] failed for VappVm {0}. __ErrorMessage__ {1}' logging.warn(errmsg.format(request.target_vm_name, str(e))) self.context.set_code(grpc.StatusCode.INVALID_ARGUMENT) self.context.set_details(errmsg) return res logging.info("__DONE__delete[VappVm]") return res
def test_0007_delete(self): logged_in_org = self.client.get_org() org = Org(self.client, resource=logged_in_org) vdc_resource = org.get_vdc(self.config['vcd']['vdc']) vdc = VDC(self.client, resource=vdc_resource) assert self.config['vcd']['vdc'] == vdc.get_resource().get('name') vapp_resource = vdc.get_vapp(self.config['vcd']['vapp']) vapp = VApp(self.client, resource=vapp_resource) task = vapp.delete_vms([self.config['vcd']['vm']]) task = self.client.get_task_monitor().wait_for_status(task) assert task.get('status') == TaskStatus.SUCCESS.value
def 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_nodes_thread(self): LOGGER.debug(f"About to delete nodes from cluster with name: " f"{self.cluster_name}") try: vapp = VApp(self.tenant_client, href=self.cluster['vapp_href']) template = self.get_template() self.update_task( TaskStatus.RUNNING, message=f"Deleting {len(self.req_spec['nodes'])} node(s) from " f"{self.cluster_name}({self.cluster_id})") try: server_config = get_server_runtime_config() delete_nodes_from_cluster(server_config, vapp, template, self.req_spec['nodes'], self.req_spec['force']) except Exception: LOGGER.error(f"Couldn't delete node {self.req_spec['nodes']} " f"from cluster:{self.cluster_name}") self.update_task( TaskStatus.RUNNING, message=f"Undeploying {len(self.req_spec['nodes'])} node(s) " f"for {self.cluster_name}({self.cluster_id})") for vm_name in self.req_spec['nodes']: vm = VM(self.tenant_client, resource=vapp.get_vm(vm_name)) try: task = vm.undeploy() self.tenant_client.get_task_monitor().wait_for_status(task) except Exception: LOGGER.warning(f"Couldn't undeploy VM {vm_name}") self.update_task( TaskStatus.RUNNING, message=f"Deleting {len(self.req_spec['nodes'])} VM(s) for " f"{self.cluster_name}({self.cluster_id})") task = vapp.delete_vms(self.req_spec['nodes']) self.tenant_client.get_task_monitor().wait_for_status(task) self.update_task( TaskStatus.SUCCESS, message=f"Deleted {len(self.req_spec['nodes'])} node(s) to " f"cluster {self.cluster_name}({self.cluster_id})") except Exception as e: LOGGER.error(traceback.format_exc()) error_obj = error_to_json(e) stack_trace = ''.join(error_obj[ERROR_MESSAGE][ERROR_STACKTRACE]) self.update_task( TaskStatus.ERROR, error_message=error_obj[ERROR_MESSAGE][ERROR_DESCRIPTION], stack_trace=stack_trace) 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 _delete_nodes(self, *args, cluster_name, cluster_vapp_href, node_names_list): LOGGER.debug(f"About to delete nodes {node_names_list} " f"from cluster {cluster_name}") vapp = VApp(self.tenant_client, href=cluster_vapp_href) try: delete_nodes_from_cluster(vapp, node_names_list) except Exception: LOGGER.error(f"Couldn't delete node {node_names_list} " f"from cluster:{cluster_name}") for vm_name in node_names_list: vm = VM(self.tenant_client, resource=vapp.get_vm(vm_name)) try: task = vm.undeploy() self.tenant_client.get_task_monitor().wait_for_status(task) except Exception: LOGGER.warning(f"Couldn't undeploy VM {vm_name}") task = vapp.delete_vms(node_names_list) self.tenant_client.get_task_monitor().wait_for_status(task)
def delete_nodes_thread(self): LOGGER.debug('about to delete nodes from cluster with name: %s', self.cluster_name) try: vapp = VApp(self.client_tenant, href=self.cluster['vapp_href']) template = self.get_template() self.update_task( TaskStatus.RUNNING, message='Deleting %s node(s) from %s(%s)' % (len(self.body['nodes']), self.cluster_name, self.cluster_id)) try: delete_nodes_from_cluster(self.config, vapp, template, self.body['nodes'], self.body['force']) except Exception: LOGGER.error("Couldn't delete node %s from cluster:%s" % (self.body['nodes'], self.cluster_name)) self.update_task( TaskStatus.RUNNING, message='Undeploying %s node(s) for %s(%s)' % (len(self.body['nodes']), self.cluster_name, self.cluster_id)) for vm_name in self.body['nodes']: vm = VM(self.client_tenant, resource=vapp.get_vm(vm_name)) try: task = vm.undeploy() self.client_tenant.get_task_monitor().wait_for_status(task) except Exception as e: LOGGER.warning('couldn\'t undeploy VM %s' % vm_name) self.update_task( TaskStatus.RUNNING, message='Deleting %s VM(s) for %s(%s)' % (len(self.body['nodes']), self.cluster_name, self.cluster_id)) task = vapp.delete_vms(self.body['nodes']) self.client_tenant.get_task_monitor().wait_for_status(task) self.update_task( TaskStatus.SUCCESS, message='Deleted %s node(s) to cluster %s(%s)' % (len(self.body['nodes']), self.cluster_name, self.cluster_id)) except Exception as e: LOGGER.error(traceback.format_exc()) self.update_task(TaskStatus.ERROR, error_message=str(e))
class VappVM(VcdAnsibleModule): def __init__(self, **kwargs): super(VappVM, self).__init__(**kwargs) vapp_resource = self.get_target_resource() self.vapp = VApp(self.client, resource=vapp_resource) def manage_states(self): state = self.params.get('state') if state == "present": return self.add_vm() if state == "absent": return self.delete_vm() if state == "update": return self.update_vm() def manage_operations(self): operation = self.params.get('operation') if operation == "poweron": return self.power_on_vm() if operation == "poweroff": return self.power_off_vm() if operation == "reloadvm": return self.reload_vm() if operation == "deploy": return self.deploy_vm() if operation == "undeploy": return self.undeploy_vm() if operation == "list_disks": return self.list_disks() if operation == "list_nics": return self.list_nics() def get_source_resource(self): source_catalog_name = self.params.get('source_catalog_name') source_template_name = self.params.get('source_template_name') source_vdc = self.params.get('source_vdc') source_vapp = self.params.get('source_vapp') org_resource = Org(self.client, resource=self.client.get_org()) source_vapp_resource = None if source_vapp: source_vdc_resource = VDC( self.client, resource=org_resource.get_vdc(source_vdc)) source_vapp_resource_href = source_vdc_resource.get_resource_href( name=source_vapp, entity_type=EntityType.VAPP) source_vapp_resource = self.client.get_resource( source_vapp_resource_href) if source_catalog_name: catalog_item = org_resource.get_catalog_item( source_catalog_name, source_template_name) source_vapp_resource = self.client.get_resource( catalog_item.Entity.get('href')) return source_vapp_resource def get_target_resource(self): target_vapp = self.params.get('target_vapp') target_vdc = self.params.get('target_vdc') org_resource = Org(self.client, resource=self.client.get_org()) target_vapp_resource = None target_vdc_resource = VDC( self.client, resource=org_resource.get_vdc(target_vdc)) target_vapp_resource = target_vdc_resource.get_vapp(target_vapp) return target_vapp_resource def get_storage_profile(self, profile_name): target_vdc = self.params.get('target_vdc') org_resource = Org(self.client, resource=self.client.get_org()) vdc_resource = VDC( self.client, resource=org_resource.get_vdc(target_vdc)) return vdc_resource.get_storage_profile(profile_name) def get_vm(self): vapp_vm_resource = self.vapp.get_vm(self.params.get('target_vm_name')) return VM(self.client, resource=vapp_vm_resource) def add_vm(self): params = self.params source_vapp_resource = self.get_source_resource() target_vm_name = params.get('target_vm_name') source_vm_name = params.get('source_vm_name') hostname = params.get('hostname') vmpassword = params.get('vmpassword') vmpassword_auto = params.get('vmpassword_auto') vmpassword_reset = params.get('vmpassword_reset') network = params.get('network') all_eulas_accepted = params.get('all_eulas_accepted') power_on = params.get('power_on') deploy = params.get('deploy') ip_allocation_mode = params.get('ip_allocation_mode') cust_script = params.get('cust_script') storage_profile = params.get('storage_profile') response = dict() response['changed'] = False try: self.get_vm() except EntityNotFoundException: spec = { 'source_vm_name': source_vm_name, 'vapp': source_vapp_resource, 'target_vm_name': target_vm_name, 'hostname': hostname, 'password': vmpassword, 'password_auto': vmpassword_auto, 'password_reset': vmpassword_reset, 'ip_allocation_mode': ip_allocation_mode, 'network': network, 'cust_script': cust_script } spec = {k: v for k, v in spec.items() if v} if storage_profile: spec['storage_profile'] = self.get_storage_profile(storage_profile) specs = [spec] args = { "specs": specs, "deploy": deploy, "power_on": power_on, "all_eulas_accepted": all_eulas_accepted } add_vms_task = self.vapp.add_vms(**args) self.execute_task(add_vms_task) response['msg'] = 'VM {} has been created.'.format(target_vm_name) response['changed'] = True else: msg = 'VM {} is already present.' response['warnings'] = msg.format(target_vm_name) return response def delete_vm(self): vm_name = self.params.get('target_vm_name') response = dict() response['changed'] = False try: vm = self.get_vm() except EntityNotFoundException: response['warnings'] = 'VM {} is not present.'.format(vm_name) else: if not vm.is_powered_off(): self.undeploy_vm() delete_vms_task = self.vapp.delete_vms([vm_name]) self.execute_task(delete_vms_task) response['msg'] = 'VM {} has been deleted.'.format(vm_name) response['changed'] = True return response def update_vm(self): vm_name = self.params.get('target_vm_name') response = dict() response['changed'] = False if self.params.get("virtual_cpus"): self.update_vm_cpu() response['changed'] = True if self.params.get("memory"): self.update_vm_memory() response['changed'] = True response['msg'] = 'VM {} has been updated.'.format(vm_name) return response def update_vm_cpu(self): virtual_cpus = self.params.get('virtual_cpus') cores_per_socket = self.params.get('cores_per_socket') vm = self.get_vm() update_cpu_task = vm.modify_cpu(virtual_cpus, cores_per_socket) return self.execute_task(update_cpu_task) def update_vm_memory(self): memory = self.params.get('memory') vm = self.get_vm() update_memory_task = vm.modify_memory(memory) return self.execute_task(update_memory_task) def power_on_vm(self): vm_name = self.params.get('target_vm_name') response = dict() response['changed'] = False vm = self.get_vm() if not vm.is_powered_on(): self.deploy_vm() response['msg'] = 'VM {} has been powered on.'.format(vm_name) response['changed'] = True else: response['warnings'] = 'VM {} is powered on.'.format(vm_name) return response def power_off_vm(self,): vm_name = self.params.get('target_vm_name') response = dict() response['changed'] = False vm = self.get_vm() if not vm.is_powered_off(): self.undeploy_vm() response['msg'] = 'VM {} has been powered off.'.format(vm_name) response['changed'] = True else: response['warnings'] = 'VM {} is powered off.'.format(vm_name) return response def reload_vm(self): vm_name = self.params.get('target_vm_name') response = dict() response['changed'] = False vm = self.get_vm() vm.reload() response['msg'] = 'VM {} has been reloaded.'.format(vm_name) response['changed'] = True return response def deploy_vm(self): vm_name = self.params.get('target_vm_name') force_customization = self.params.get('force_customization') response = dict() response['changed'] = False vm = self.get_vm() if not vm.is_deployed(): deploy_vm_task = vm.deploy(force_customization=force_customization) self.execute_task(deploy_vm_task) msg = 'VM {} has been deployed' response['msg'] = msg.format(vm_name) response['changed'] = True else: msg = 'VM {} is already deployed' response['warnings'] = msg.format(vm_name) return response def undeploy_vm(self): vm_name = self.params.get('target_vm_name') response = dict() response['changed'] = False vm = self.get_vm() if not vm.is_deployed(): undeploy_vm_task = vm.undeploy(action="powerOff") self.execute_task(undeploy_vm_task) msg = 'VM {} has been undeployed' response['msg'] = msg.format(vm_name) response['changed'] = True else: msg = 'VM {} is already undeployed' response['warnings'] = msg.format(vm_name) return response def list_disks(self): response = dict() response['changed'] = False response['msg'] = list() vm = self.get_vm() response['msg'] = vm.list_virtual_hardware_section( is_cpu=False, is_memory=False, is_disk=True) return response def list_nics(self): response = dict() response['changed'] = False response['msg'] = list() vm = self.get_vm() response['msg'] = vm.list_nics() return response
class VappVM(object): def __init__(self, module, vapp_resource): self.module = module self.vapp = VApp(module.client, resource=vapp_resource) def execute_task(self, task): client = self.module.client task_monitor = client.get_task_monitor() task_state = task_monitor.wait_for_status(task=task, timeout=60, poll_frequency=2, fail_on_statuses=None, expected_target_statuses=[ TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR, TaskStatus.CANCELED ], callback=None) task_status = task_state.get('status') if task_status != TaskStatus.SUCCESS.value: raise Exception(etree.tostring(task_state, pretty_print=True)) return 1 def get_vm(self, vm_name): vapp_vm_resource = self.vapp.get_vm(vm_name) return VM(self.module.client, resource=vapp_vm_resource) def add_vms(self, target_vm_name, source_vapp_resource): params = self.module.params source_vm_name = params.get('source_vm_name') hostname = params.get('hostname') vmpassword = params.get('vmpassword') vmpassword_auto = params.get('vmpassword_auto') vmpassword_reset = params.get('vmpassword_reset') network = params.get('network') all_eulas_accepted = params.get('all_eulas_accepted', True) power_on = params.get('power_on', True) ip_allocation_mode = params.get('ip_allocation_mode') # cust_script = module.params.get('cust_script') # storage_profile = module.params.get('storage_profile') response = dict() specs = [{ 'source_vm_name': source_vm_name, 'vapp': source_vapp_resource, 'target_vm_name': target_vm_name, 'hostname': hostname, 'password': vmpassword, 'password_auto': vmpassword_auto, 'password_reset': vmpassword_reset, 'ip_allocation_mode': ip_allocation_mode, 'network': network, # 'cust_script': cust_script, # 'storage_profile': storage_profile }] add_vms_task = self.vapp.add_vms(specs, power_on=power_on, all_eulas_accepted=all_eulas_accepted) self.execute_task(add_vms_task) response['msg'] = 'Vapp VM {} has been created.'.format(target_vm_name) response['changed'] = True return response def delete_vms(self, vm_name): response = dict() self.undeploy_vm(vm_name) delete_vms_task = self.vapp.delete_vms([vm_name]) self.execute_task(delete_vms_task) response['msg'] = 'Vapp VM {} has been deleted.'.format(vm_name) response['changed'] = True return response def power_on_vm(self, vm_name): vm = self.get_vm(vm_name) response = dict() power_on_task = vm.power_on() self.execute_task(power_on_task) response['msg'] = 'Vapp VM {} has been powered on.'.format(vm_name) response['changed'] = True return response def power_off_vm(self, vm_name): vm = self.get_vm(vm_name) response = dict() power_off_task = vm.power_off() self.execute_task(power_off_task) response['msg'] = 'Vapp VM {} has been powered off.'.format(vm_name) response['changed'] = True return response def reload_vm(self, vm_name): vm = self.get_vm(vm_name) response = dict() vm.reload() response['msg'] = 'Vapp VM {} has been reloaded.'.format(vm_name) response['changed'] = True return response def update_cpu_of_vm(self, vm_name): params = self.module.params vm = self.get_vm(vm_name) virtual_cpus = params.get('virtual_cpus') cores_per_socket = params.get('cores_per_socket') response = dict() self.power_off_vm(vm_name) update_cpu_task = vm.modify_cpu(virtual_cpus, cores_per_socket) self.execute_task(update_cpu_task) response['msg'] = 'Vapp VM {} has been updated.'.format(vm_name) response['changed'] = True return response def update_memory_of_vm(self, vm_name): params = self.module.params vm = self.get_vm(vm_name) memory = params.get('memory') response = dict() self.power_off_vm(vm_name) update_memory_task = vm.modify_memory(memory) self.execute_task(update_memory_task) response['msg'] = 'Vapp VM {} has been updated.'.format(vm_name) response['changed'] = True return response def deploy_vm(self, vm_name): vm = self.get_vm(vm_name) response = dict() deploy_vm_task = vm.deploy() self.execute_task(deploy_vm_task) response['msg'] = 'Vapp VM {} has been deployed.'.format(vm_name) response['changed'] = True return response def undeploy_vm(self, vm_name): vm = self.get_vm(vm_name) response = dict() undeploy_vm_task = vm.undeploy() self.execute_task(undeploy_vm_task) response['msg'] = 'Vapp VM {} has been undeployed.'.format(vm_name) response['changed'] = True return response
class VappVM(VcdAnsibleModule): def __init__(self, **kwargs): super(VappVM, self).__init__(**kwargs) vapp_resource = self.get_target_resource() self.vapp = VApp(self.client, resource=vapp_resource) def manage_states(self): state = self.params.get('state') if state == "present": return self.add_vm() if state == "absent": return self.delete_vm() if state == "update": return self.update_vm() def manage_operations(self): operation = self.params.get('operation') if operation == "poweron": return self.power_on_vm() if operation == "poweroff": return self.power_off_vm() if operation == "reloadvm": return self.reload_vm() if operation == "deploy": return self.deploy_vm() if operation == "undeploy": return self.undeploy_vm() if operation == "list_disks": return self.list_disks() if operation == "list_nics": return self.list_nics() def get_source_resource(self): source_catalog_name = self.params.get('source_catalog_name') source_template_name = self.params.get('source_template_name') source_vdc = self.params.get('source_vdc') source_vapp = self.params.get('source_vapp') org_resource = Org(self.client, resource=self.client.get_org()) source_vapp_resource = None if source_vapp: source_vdc_resource = VDC( self.client, resource=org_resource.get_vdc(source_vdc)) source_vapp_resource_href = source_vdc_resource.get_resource_href( name=source_vapp, entity_type=EntityType.VAPP) source_vapp_resource = self.client.get_resource( source_vapp_resource_href) if source_catalog_name: catalog_item = org_resource.get_catalog_item( source_catalog_name, source_template_name) source_vapp_resource = self.client.get_resource( catalog_item.Entity.get('href')) return source_vapp_resource def get_target_resource(self): target_vapp = self.params.get('target_vapp') target_vdc = self.params.get('target_vdc') org_resource = Org(self.client, resource=self.client.get_org()) target_vapp_resource = None target_vdc_resource = VDC( self.client, resource=org_resource.get_vdc(target_vdc)) target_vapp_resource = target_vdc_resource.get_vapp(target_vapp) return target_vapp_resource def get_storage_profile(self, profile_name): target_vdc = self.params.get('target_vdc') org_resource = Org(self.client, resource=self.client.get_org()) vdc_resource = VDC(self.client, resource=org_resource.get_vdc(target_vdc)) return vdc_resource.get_storage_profile(profile_name) def get_vm(self): vapp_vm_resource = self.vapp.get_vm(self.params.get('target_vm_name')) return VM(self.client, resource=vapp_vm_resource) def add_vm(self): params = self.params source_vapp_resource = self.get_source_resource() target_vm_name = params.get('target_vm_name') source_vm_name = params.get('source_vm_name') hostname = params.get('hostname') vmpassword = params.get('vmpassword') vmpassword_auto = params.get('vmpassword_auto') vmpassword_reset = params.get('vmpassword_reset') network = params.get('network') all_eulas_accepted = params.get('all_eulas_accepted') power_on = params.get('power_on') ip_allocation_mode = params.get('ip_allocation_mode') cust_script = params.get('cust_script') storage_profile = params.get('storage_profile') properties = params.get('properties') response = dict() response['changed'] = False try: self.get_vm() except EntityNotFoundException: spec = { 'source_vm_name': source_vm_name, 'vapp': source_vapp_resource, 'target_vm_name': target_vm_name, 'hostname': hostname, 'password': vmpassword, 'password_auto': vmpassword_auto, 'password_reset': vmpassword_reset, 'ip_allocation_mode': ip_allocation_mode, 'network': network, 'cust_script': cust_script } if storage_profile!='': spec['storage_profile'] = self.get_storage_profile(storage_profile) spec = {k: v for k, v in spec.items() if v} source_vm = self.vapp.to_sourced_item(spec) # Check the source vm if we need to inject OVF properties. source_vapp = VApp(self.client, resource=source_vapp_resource) vm = source_vapp.get_vm(source_vm_name) productsection = vm.find('ovf:ProductSection', NSMAP) if productsection is not None: for prop in productsection.iterfind('ovf:Property', NSMAP): if properties and prop.get('{'+NSMAP['ovf']+'}key') in properties: val = prop.find('ovf:Value', NSMAP) if val: prop.remove(val) val = E_OVF.Value() val.set('{'+NSMAP['ovf']+'}value', properties[prop.get('{'+NSMAP['ovf']+'}key')]) prop.append(val) source_vm.InstantiationParams.append(productsection) source_vm.VmGeneralParams.NeedsCustomization = E.NeedsCustomization('true') params = E.RecomposeVAppParams(deploy='true', powerOn='true' if power_on else 'false') params.append(source_vm) if all_eulas_accepted is not None: params.append(E.AllEULAsAccepted(all_eulas_accepted)) add_vms_task = self.client.post_linked_resource( self.get_target_resource(), RelationType.RECOMPOSE, EntityType.RECOMPOSE_VAPP_PARAMS.value, params) self.execute_task(add_vms_task) response['msg'] = 'Vapp VM {} has been created.'.format( target_vm_name) response['changed'] = True else: response['warnings'] = 'Vapp VM {} is already present.'.format( target_vm_name) return response def delete_vm(self): vm_name = self.params.get('target_vm_name') response = dict() response['changed'] = False try: self.get_vm() except EntityNotFoundException: response['warnings'] = 'Vapp VM {} is not present.'.format(vm_name) else: self.undeploy_vm() delete_vms_task = self.vapp.delete_vms([vm_name]) self.execute_task(delete_vms_task) response['msg'] = 'Vapp VM {} has been deleted.'.format(vm_name) response['changed'] = True return response def update_vm(self): vm_name = self.params.get('target_vm_name') response = dict() response['changed'] = False if self.params.get("virtual_cpus"): self.update_vm_cpu() response['changed'] = True if self.params.get("memory"): self.update_vm_memory() response['changed'] = True response['msg'] = 'Vapp VM {} has been updated.'.format(vm_name) return response def update_vm_cpu(self): virtual_cpus = self.params.get('virtual_cpus') cores_per_socket = self.params.get('cores_per_socket') vm = self.get_vm() update_cpu_task = vm.modify_cpu(virtual_cpus, cores_per_socket) return self.execute_task(update_cpu_task) def update_vm_memory(self): memory = self.params.get('memory') vm = self.get_vm() update_memory_task = vm.modify_memory(memory) return self.execute_task(update_memory_task) def power_on_vm(self): vm_name = self.params.get('target_vm_name') response = dict() response['changed'] = False try: vm = self.get_vm() power_on_task = vm.power_on() self.execute_task(power_on_task) response['msg'] = 'Vapp VM {} has been powered on.'.format(vm_name) response['changed'] = True except OperationNotSupportedException: response['warnings'] = 'Vapp VM {} is already powered on.'.format( vm_name) return response def power_off_vm(self,): vm_name = self.params.get('target_vm_name') response = dict() response['changed'] = False try: vm = self.get_vm() power_off_task = vm.power_off() self.execute_task(power_off_task) response['msg'] = 'Vapp VM {} has been powered off.'.format( vm_name) response['changed'] = True except OperationNotSupportedException: response['warnings'] = 'Vapp VM {} is already powered off.'.format( vm_name) return response def reload_vm(self): vm_name = self.params.get('target_vm_name') response = dict() response['changed'] = False vm = self.get_vm() vm.reload() response['msg'] = 'Vapp VM {} has been reloaded.'.format(vm_name) response['changed'] = True return response def deploy_vm(self): vm_name = self.params.get('target_vm_name') response = dict() response['changed'] = False try: vm = self.get_vm() deploy_vm_task = vm.deploy() self.execute_task(deploy_vm_task) response['msg'] = 'Vapp VM {} has been deployed.'.format(vm_name) response['changed'] = True except OperationNotSupportedException: response['warnings'] = 'Vapp VM {} is already deployed.'.format( vm_name) return response def undeploy_vm(self): vm_name = self.params.get('target_vm_name') response = dict() response['changed'] = False try: vm = self.get_vm() undeploy_vm_task = vm.undeploy() self.execute_task(undeploy_vm_task) response['msg'] = 'Vapp VM {} has been undeployed.'.format(vm_name) response['changed'] = True except OperationNotSupportedException: response['warnings'] = 'Vapp VM {} is already undeployed.'.format( vm_name) return response def list_disks(self): response = dict() response['changed'] = False response['msg'] = [] vm = self.get_vm() disks = self.client.get_resource(vm.resource.get('href') + '/virtualHardwareSection/disks') for disk in disks.Item: if disk['{'+NSMAP['rasd']+'}ResourceType'] == 17: response['msg'].append({ 'id': disk['{'+NSMAP['rasd']+'}InstanceID'].text, 'name': disk['{'+NSMAP['rasd']+'}ElementName'].text, 'description': disk['{'+NSMAP['rasd']+'}Description'].text, 'size': disk['{'+NSMAP['rasd']+'}HostResource'].get('{'+NSMAP['vcloud']+'}capacity') }) return response def list_nics(self): response = dict() response['changed'] = False response['msg'] = [] vm = self.get_vm() nics = self.client.get_resource(vm.resource.get('href') + '/networkConnectionSection') for nic in nics.NetworkConnection: response['msg'].append({ 'index': nic.NetworkConnectionIndex.text, 'network': nic.get('network') }) return response
class VappVM(VcdAnsibleModule): def __init__(self, **kwargs): super(VappVM, self).__init__(**kwargs) vapp_resource = self.get_target_resource() self.vapp = VApp(self.client, resource=vapp_resource) def manage_states(self): state = self.params.get('state') if state == "present": return self.add_vm() if state == "absent": return self.delete_vm() if state == "update": return self.update_vm() def manage_operations(self): operation = self.params.get('operation') if operation == "poweron": return self.power_on_vm() if operation == "poweroff": return self.power_off_vm() if operation == "reloadvm": return self.reload_vm() if operation == "deploy": return self.deploy_vm() if operation == "undeploy": return self.undeploy_vm() if operation == "list_disks": return self.list_disks() if operation == "list_nics": return self.list_nics() if operation == "snapshot": return self.take_snapshot() if operation == "revert": return self.revert_to_snapshot() def get_source_resource(self): source_catalog_name = self.params.get('source_catalog_name') source_template_name = self.params.get('source_template_name') source_vdc = self.params.get('source_vdc') source_vapp = self.params.get('source_vapp') org_resource = Org(self.client, resource=self.client.get_org()) source_vapp_resource = None if source_vapp: source_vdc_resource = VDC( self.client, resource=org_resource.get_vdc(source_vdc)) source_vapp_resource_href = source_vdc_resource.get_resource_href( name=source_vapp, entity_type=EntityType.VAPP) source_vapp_resource = self.client.get_resource( source_vapp_resource_href) if source_catalog_name: catalog_item = org_resource.get_catalog_item( source_catalog_name, source_template_name) source_vapp_resource = self.client.get_resource( catalog_item.Entity.get('href')) return source_vapp_resource def get_target_resource(self): target_vapp = self.params.get('target_vapp') target_vdc = self.params.get('target_vdc') org_resource = Org(self.client, resource=self.client.get_org()) target_vapp_resource = None target_vdc_resource = VDC( self.client, resource=org_resource.get_vdc(target_vdc)) target_vapp_resource = target_vdc_resource.get_vapp(target_vapp) return target_vapp_resource def get_storage_profile(self, profile_name): target_vdc = self.params.get('target_vdc') org_resource = Org(self.client, resource=self.client.get_org()) vdc_resource = VDC(self.client, resource=org_resource.get_vdc(target_vdc)) return vdc_resource.get_storage_profile(profile_name) def get_vm(self): vapp_vm_resource = self.vapp.get_vm(self.params.get('target_vm_name')) return VM(self.client, resource=vapp_vm_resource) def add_vm(self): params = self.params source_vapp_resource = self.get_source_resource() target_vm_name = params.get('target_vm_name') source_vm_name = params.get('source_vm_name') hostname = params.get('hostname') vmpassword = params.get('vmpassword') vmpassword_auto = params.get('vmpassword_auto') vmpassword_reset = params.get('vmpassword_reset') network = params.get('network') all_eulas_accepted = params.get('all_eulas_accepted') power_on = params.get('power_on') ip_allocation_mode = params.get('ip_allocation_mode') cust_script = params.get('cust_script') storage_profile = params.get('storage_profile') properties = params.get('properties') response = dict() response['changed'] = False try: self.get_vm() except EntityNotFoundException: spec = { 'source_vm_name': source_vm_name, 'vapp': source_vapp_resource, 'target_vm_name': target_vm_name, 'hostname': hostname, 'password': vmpassword, 'password_auto': vmpassword_auto, 'password_reset': vmpassword_reset, 'ip_allocation_mode': ip_allocation_mode, 'network': network, 'cust_script': cust_script } if storage_profile!='': spec['storage_profile'] = self.get_storage_profile(storage_profile) spec = {k: v for k, v in spec.items() if v} source_vm = self.vapp.to_sourced_item(spec) # Check the source vm if we need to inject OVF properties. source_vapp = VApp(self.client, resource=source_vapp_resource) vm = source_vapp.get_vm(source_vm_name) productsection = vm.find('ovf:ProductSection', NSMAP) if productsection is not None: for prop in productsection.iterfind('ovf:Property', NSMAP): if properties and prop.get('{'+NSMAP['ovf']+'}key') in properties: val = prop.find('ovf:Value', NSMAP) if val: prop.remove(val) val = E_OVF.Value() val.set('{'+NSMAP['ovf']+'}value', properties[prop.get('{'+NSMAP['ovf']+'}key')]) prop.append(val) source_vm.InstantiationParams.append(productsection) source_vm.VmGeneralParams.NeedsCustomization = E.NeedsCustomization('true') params = E.RecomposeVAppParams(deploy='true', powerOn='true' if power_on else 'false') params.append(source_vm) if all_eulas_accepted is not None: params.append(E.AllEULAsAccepted(all_eulas_accepted)) add_vms_task = self.client.post_linked_resource( self.get_target_resource(), RelationType.RECOMPOSE, EntityType.RECOMPOSE_VAPP_PARAMS.value, params) self.execute_task(add_vms_task) response['msg'] = 'Vapp VM {} has been created.'.format( target_vm_name) response['changed'] = True else: response['warnings'] = 'Vapp VM {} is already present.'.format( target_vm_name) return response def delete_vm(self): vm_name = self.params.get('target_vm_name') response = dict() response['changed'] = False try: self.get_vm() except EntityNotFoundException: response['warnings'] = 'Vapp VM {} is not present.'.format(vm_name) else: self.undeploy_vm() delete_vms_task = self.vapp.delete_vms([vm_name]) self.execute_task(delete_vms_task) response['msg'] = 'Vapp VM {} has been deleted.'.format(vm_name) response['changed'] = True return response def update_vm(self): vm_name = self.params.get('target_vm_name') response = dict() response['changed'] = False if self.params.get("virtual_cpus"): self.update_vm_cpu() response['changed'] = True if self.params.get("memory"): self.update_vm_memory() response['changed'] = True response['msg'] = 'Vapp VM {} has been updated.'.format(vm_name) return response def update_vm_cpu(self): virtual_cpus = self.params.get('virtual_cpus') cores_per_socket = self.params.get('cores_per_socket') vm = self.get_vm() update_cpu_task = vm.modify_cpu(virtual_cpus, cores_per_socket) return self.execute_task(update_cpu_task) def update_vm_memory(self): memory = self.params.get('memory') vm = self.get_vm() update_memory_task = vm.modify_memory(memory) return self.execute_task(update_memory_task) def power_on_vm(self): vm_name = self.params.get('target_vm_name') response = dict() response['changed'] = False try: vm = self.get_vm() power_on_task = vm.power_on() self.execute_task(power_on_task) response['msg'] = 'Vapp VM {} has been powered on.'.format(vm_name) response['changed'] = True except OperationNotSupportedException: response['warnings'] = 'Vapp VM {} is already powered on.'.format( vm_name) return response def power_off_vm(self,): vm_name = self.params.get('target_vm_name') response = dict() response['changed'] = False try: vm = self.get_vm() power_off_task = vm.power_off() self.execute_task(power_off_task) response['msg'] = 'Vapp VM {} has been powered off.'.format( vm_name) response['changed'] = True except OperationNotSupportedException: response['warnings'] = 'Vapp VM {} is already powered off.'.format( vm_name) return response def reload_vm(self): vm_name = self.params.get('target_vm_name') response = dict() response['changed'] = False vm = self.get_vm() vm.reload() response['msg'] = 'Vapp VM {} has been reloaded.'.format(vm_name) response['changed'] = True return response def deploy_vm(self): vm_name = self.params.get('target_vm_name') response = dict() response['changed'] = False try: vm = self.get_vm() deploy_vm_task = vm.deploy() self.execute_task(deploy_vm_task) response['msg'] = 'Vapp VM {} has been deployed.'.format(vm_name) response['changed'] = True except OperationNotSupportedException: response['warnings'] = 'Vapp VM {} is already deployed.'.format( vm_name) return response def undeploy_vm(self): vm_name = self.params.get('target_vm_name') response = dict() response['changed'] = False try: vm = self.get_vm() undeploy_vm_task = vm.undeploy() self.execute_task(undeploy_vm_task) response['msg'] = 'Vapp VM {} has been undeployed.'.format(vm_name) response['changed'] = True except OperationNotSupportedException: response['warnings'] = 'Vapp VM {} is already undeployed.'.format( vm_name) return response def list_disks(self): response = dict() response['changed'] = False response['msg'] = [] vm = self.get_vm() disks = self.client.get_resource(vm.resource.get('href') + '/virtualHardwareSection/disks') for disk in disks.Item: if disk['{'+NSMAP['rasd']+'}ResourceType'] == 17: response['msg'].append({ 'id': disk['{'+NSMAP['rasd']+'}InstanceID'].text, 'name': disk['{'+NSMAP['rasd']+'}ElementName'].text, 'description': disk['{'+NSMAP['rasd']+'}Description'].text, 'size': disk['{'+NSMAP['rasd']+'}HostResource'].get('{'+NSMAP['vcloud']+'}capacity') }) return response def list_nics(self): response = dict() response['changed'] = False response['msg'] = [] vm = self.get_vm() nics = self.client.get_resource(vm.resource.get('href') + '/networkConnectionSection') for nic in nics.NetworkConnection: response['msg'].append({ 'index': nic.NetworkConnectionIndex.text, 'network': nic.get('network') }) return response def take_snapshot(self): response = dict(changed=False, msg=[]) vm = self.get_vm() snapshot_create_taks = vm.snapshot_create(memory=True, quiesce=True) self.execute_task(snapshot_create_taks) response["changed"] = True return response def revert_to_snapshot(self): response = dict(changed=False, msg=[]) vm = self.get_vm() revert_to_current_task = vm.snapshot_revert_to_current() self.execute_task(revert_to_current_task) response["changed"] = True return response
class VappVM(VcdAnsibleModule): def __init__(self, **kwargs): super(VappVM, self).__init__(**kwargs) vapp_resource = self.get_target_resource() self.vapp = VApp(self.client, resource=vapp_resource) def manage_states(self): state = self.params.get('state') if state == "present": return self.add_vm() if state == "absent": return self.delete_vm() if state == "update": return self.update_vm() def manage_operations(self): operation = self.params.get('operation') if operation == "poweron": return self.power_on_vm() if operation == "poweroff": return self.power_off_vm() if operation == "reloadvm": return self.reload_vm() if operation == "deploy": return self.deploy_vm() if operation == "undeploy": return self.undeploy_vm() def get_source_resource(self): source_catalog_name = self.params.get('source_catalog_name') source_template_name = self.params.get('source_template_name') source_vdc = self.params.get('source_vdc') source_vapp = self.params.get('source_vapp') org_resource = Org(self.client, resource=self.client.get_org()) source_vapp_resource = None if source_vapp: source_vdc_resource = VDC( self.client, resource=org_resource.get_vdc(source_vdc)) source_vapp_resource_href = source_vdc_resource.get_resource_href( name=source_vapp, entity_type=EntityType.VAPP) source_vapp_resource = self.client.get_resource( source_vapp_resource_href) if source_catalog_name: catalog_item = org_resource.get_catalog_item( source_catalog_name, source_template_name) source_vapp_resource = self.client.get_resource( catalog_item.Entity.get('href')) return source_vapp_resource def get_target_resource(self): target_vapp = self.params.get('target_vapp') target_vdc = self.params.get('target_vdc') org_resource = Org(self.client, resource=self.client.get_org()) target_vapp_resource = None target_vdc_resource = VDC(self.client, resource=org_resource.get_vdc(target_vdc)) target_vapp_resource = target_vdc_resource.get_vapp(target_vapp) return target_vapp_resource def get_vm(self): vapp_vm_resource = self.vapp.get_vm(self.params.get('target_vm_name')) return VM(self.client, resource=vapp_vm_resource) def add_vm(self): params = self.params source_vapp_resource = self.get_source_resource() target_vm_name = params.get('target_vm_name') source_vm_name = params.get('source_vm_name') hostname = params.get('hostname') vmpassword = params.get('vmpassword') vmpassword_auto = params.get('vmpassword_auto') vmpassword_reset = params.get('vmpassword_reset') network = params.get('network') all_eulas_accepted = params.get('all_eulas_accepted', True) power_on = params.get('power_on', True) ip_allocation_mode = params.get('ip_allocation_mode') # cust_script = params.get('cust_script') # storage_profile = params.get('storage_profile') response = dict() response['changed'] = False try: self.get_vm() except EntityNotFoundException: specs = [{ 'source_vm_name': source_vm_name, 'vapp': source_vapp_resource, 'target_vm_name': target_vm_name, 'hostname': hostname, 'password': vmpassword, 'password_auto': vmpassword_auto, 'password_reset': vmpassword_reset, 'ip_allocation_mode': ip_allocation_mode, 'network': network, # 'cust_script': cust_script, # 'storage_profile': json.loads(storage_profile) }] add_vms_task = self.vapp.add_vms( specs, power_on=power_on, all_eulas_accepted=all_eulas_accepted) self.execute_task(add_vms_task) response['msg'] = 'Vapp VM {} has been created.'.format( target_vm_name) response['changed'] = True else: response['msg'] = 'Vapp VM {} is already present.'.format( target_vm_name) return response def delete_vm(self): vm_name = self.params.get('target_vm_name') response = dict() response['changed'] = False try: self.get_vm() except EntityNotFoundException: response['msg'] = 'Vapp VM {} is not present.'.format(vm_name) else: self.undeploy_vm() delete_vms_task = self.vapp.delete_vms([vm_name]) self.execute_task(delete_vms_task) response['msg'] = 'Vapp VM {} has been deleted.'.format(vm_name) response['changed'] = True return response def update_vm(self): vm_name = self.params.get('target_vm_name') response = dict() response['changed'] = False if self.params.get("virtual_cpus"): self.update_vm_cpu() response['changed'] = True if self.params.get("memory"): self.update_vm_memory() response['changed'] = True response['msg'] = 'Vapp VM {} has been updated.'.format(vm_name) return response def update_vm_cpu(self): virtual_cpus = self.params.get('virtual_cpus') cores_per_socket = self.params.get('cores_per_socket') vm = self.get_vm() update_cpu_task = vm.modify_cpu(virtual_cpus, cores_per_socket) return self.execute_task(update_cpu_task) def update_vm_memory(self): memory = self.params.get('memory') vm = self.get_vm() update_memory_task = vm.modify_memory(memory) return self.execute_task(update_memory_task) def power_on_vm(self): vm_name = self.params.get('target_vm_name') response = dict() response['changed'] = False try: vm = self.get_vm() power_on_task = vm.power_on() self.execute_task(power_on_task) response['msg'] = 'Vapp VM {} has been powered on.'.format(vm_name) response['changed'] = True except OperationNotSupportedException: response['msg'] = 'Vapp VM {} is already powered on.'.format( vm_name) return response def power_off_vm(self, ): vm_name = self.params.get('target_vm_name') response = dict() response['changed'] = False try: vm = self.get_vm() power_off_task = vm.power_off() self.execute_task(power_off_task) response['msg'] = 'Vapp VM {} has been powered off.'.format( vm_name) response['changed'] = True except OperationNotSupportedException: response['msg'] = 'Vapp VM {} is already powered off.'.format( vm_name) return response def reload_vm(self): vm_name = self.params.get('target_vm_name') response = dict() response['changed'] = False vm = self.get_vm() vm.reload() response['msg'] = 'Vapp VM {} has been reloaded.'.format(vm_name) response['changed'] = True return response def deploy_vm(self): vm_name = self.params.get('target_vm_name') response = dict() response['changed'] = False try: vm = self.get_vm() deploy_vm_task = vm.deploy() self.execute_task(deploy_vm_task) response['msg'] = 'Vapp VM {} has been deployed.'.format(vm_name) response['changed'] = True except OperationNotSupportedException: response['msg'] = 'Vapp VM {} is already deployed.'.format(vm_name) return response def undeploy_vm(self): vm_name = self.params.get('target_vm_name') response = dict() response['changed'] = False try: vm = self.get_vm() undeploy_vm_task = vm.undeploy() self.execute_task(undeploy_vm_task) response['msg'] = 'Vapp VM {} has been undeployed.'.format(vm_name) response['changed'] = True except OperationNotSupportedException: response['msg'] = 'Vapp VM {} is already undeployed.'.format( vm_name) return response