def test_0002_add_vm(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, href=vdc_resource.get('href')) assert self.config['vcd']['vdc'] == vdc.get_resource().get('name') vapp_resource = vdc.get_vapp(self.config['vcd']['vapp']) assert vapp_resource.get('name') == self.config['vcd']['vapp'] vapp = VApp(self.client, resource=vapp_resource) catalog_item = org.get_catalog_item(self.config['vcd']['catalog'], self.config['vcd']['template']) source_vapp_resource = self.client.get_resource( catalog_item.Entity.get('href')) spec = {'source_vm_name': self.config['vcd']['vm'], 'vapp': source_vapp_resource} spec['target_vm_name'] = self.config['vcd']['hostname'] spec['hostname'] = self.config['vcd']['hostname'] spec['network'] = self.config['vcd']['network'] spec['ip_allocation_mode'] = self.config['vcd']['ip_allocation_mode'] spec['storage_profile'] = vdc.get_storage_profile( self.config['vcd']['storage_profile']) vms = [spec] result = vapp.add_vms(vms) 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 add_vm(ctx, name, source_vapp, source_vm, catalog, target_vm, hostname, network, ip_allocation_mode, storage_profile, password_auto, accept_all_eulas): try: client = ctx.obj['client'] in_use_org_href = ctx.obj['profiles'].get('org_href') org = Org(client, in_use_org_href) vdc_href = ctx.obj['profiles'].get('vdc_href') vdc = VDC(client, href=vdc_href) source_vapp_resource = None if catalog is None: source_vapp_resource = vdc.get_vapp(source_vapp) else: catalog_item = org.get_catalog_item(catalog, source_vapp) source_vapp_resource = client.get_resource( catalog_item.Entity.get('href')) assert source_vapp_resource is not None vapp_resource = vdc.get_vapp(name) vapp = VApp(client, resource=vapp_resource) spec = {'source_vm_name': source_vm, 'vapp': source_vapp_resource} if target_vm is not None: spec['target_vm_name'] = target_vm if hostname is not None: spec['hostname'] = hostname if network is not None: spec['network'] = network spec['ip_allocation_mode'] = ip_allocation_mode if storage_profile is not None: spec['storage_profile'] = vdc.get_storage_profile(storage_profile) if password_auto is not None: spec['password_auto'] = password_auto task = vapp.add_vms([spec], all_eulas_accepted=accept_all_eulas) stdout(task, ctx) except Exception as e: stderr(e, ctx)
def test_0002_add_vm(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, href=vdc_resource.get('href')) assert self.config['vcd']['vdc'] == vdc.get_resource().get('name') vapp_resource = vdc.get_vapp(self.config['vcd']['vapp']) assert vapp_resource.get('name') == self.config['vcd']['vapp'] vapp = VApp(self.client, resource=vapp_resource) catalog_item = org.get_catalog_item(self.config['vcd']['catalog'], self.config['vcd']['template']) source_vapp_resource = self.client.get_resource( catalog_item.Entity.get('href')) spec = { 'source_vm_name': self.config['vcd']['vm'], 'vapp': source_vapp_resource } spec['target_vm_name'] = self.config['vcd']['hostname'] spec['hostname'] = self.config['vcd']['hostname'] spec['network'] = self.config['vcd']['network'] spec['ip_allocation_mode'] = self.config['vcd']['ip_allocation_mode'] spec['storage_profile'] = vdc.get_storage_profile( self.config['vcd']['storage_profile']) vms = [spec] result = vapp.add_vms(vms, all_eulas_accepted=True) task = self.client.get_task_monitor().wait_for_status(task=result) assert task.get('status') == TaskStatus.SUCCESS.value
def create_from_vapp(self, request): logging.info("__INIT__create[VappVm] source_catalog_name[%s]", request.source_vapp) res = vapp_vm_pb2.CreateVappVmResult() res.created = False source_vapp_resource = self.get_vapp_resource( request.target_vdc, vapp_name=request.source_vapp) target_vapp_resource = self.get_vapp_resource( request.target_vdc, vapp_name=request.target_vapp) specs = [{ 'vapp': source_vapp_resource, 'source_vm_name': request.source_vm_name, 'target_vm_name': request.target_vm_name, 'hostname': request.hostname, 'password': request.password, 'password_auto': request.password_auto, 'password_reset': request.password_reset, 'cust_script': request.cust_script, 'network': request.network, # 'storage_profile': request.storage_profile }] try: vapp = VApp(self.client, resource=target_vapp_resource) create_vapp_vm_resp = vapp.add_vms( specs, power_on=request.power_on, all_eulas_accepted=request.all_eulas_accepted) task_monitor = self.client.get_task_monitor() task = task_monitor.wait_for_status( task=create_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.VappVmCreateError( etree.tostring(task, pretty_print=True)) message = 'status : {0} '.format(st) logging.info(message) res.created = True except Exception as e: errmsg = '''__ERROR_create[VappVm] failed for vm {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__create[VappVm]") return res
def create_from_vapp(self, request): logging.info( "__INIT__create[VappVm] source_catalog_name[%s]", request.source_vapp) res = vapp_vm_pb2.CreateVappVmResult() res.created = False source_vapp_resource = self.get_vapp_resource( request.target_vdc, vapp_name=request.source_vapp) target_vapp_resource = self.get_vapp_resource( request.target_vdc, vapp_name=request.target_vapp) specs = [{ 'vapp': source_vapp_resource, 'source_vm_name': request.source_vm_name, 'target_vm_name': request.target_vm_name, 'hostname': request.hostname, 'password': request.password, 'password_auto': request.password_auto, 'password_reset': request.password_reset, 'cust_script': request.cust_script, 'network': request.network, # 'storage_profile': request.storage_profile }] try: vapp = VApp(self.client, resource=target_vapp_resource) create_vapp_vm_resp = vapp.add_vms(specs, power_on=request.power_on, all_eulas_accepted=request.all_eulas_accepted) task_monitor = self.client.get_task_monitor() task = task_monitor.wait_for_status( task=create_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.VappVmCreateError( etree.tostring(task, pretty_print=True)) message = 'status : {0} '.format(st) logging.info(message) res.created = True except Exception as e: errmsg = '''__ERROR_create[VappVm] failed for vm {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__create[VappVm]") return res
def _clone(self, source_vapp_name, target_vapp_name, target_vm_name, source_delete): """Clone VM from one vApp to another. :param: str source vApp name :param: str target vApp name :param: str target VM name :param: bool source delete option :return: an object containing EntityType.TASK XML data which represents the asynchronous task that is copying VM :rtype: lxml.objectify.ObjectifiedElement """ from pyvcloud.vcd.vapp import VApp vm_resource = self.get_resource() resource_type = ResourceType.VAPP.value if self.is_powered_off(vm_resource) or source_delete: records1 = self.___validate_vapp_records( vapp_name=source_vapp_name, resource_type=resource_type) source_vapp_href = records1[0].get('href') records2 = self.___validate_vapp_records( vapp_name=target_vapp_name, resource_type=resource_type) target_vapp_href = records2[0].get('href') source_vapp = VApp(self.client, href=source_vapp_href) target_vapp = VApp(self.client, href=target_vapp_href) target_vapp.reload() spec = { 'vapp': source_vapp.get_resource(), 'source_vm_name': self.get_resource().get('name'), 'target_vm_name': target_vm_name } return target_vapp.add_vms([spec], deploy=False, power_on=False, all_eulas_accepted=True, source_delete=source_delete ) else: raise InvalidStateException("VM Must be powered off.")
def copy_to(self, source_vapp_name, target_vapp_name, target_vm_name): """Copy VM from one vApp to another. :param: str source vApp name :param: str target vApp name :param: str target VM name :return: an object containing EntityType.TASK XML data which represents the asynchronous task that is copying VM :rtype: lxml.objectify.ObjectifiedElement """ from pyvcloud.vcd.vapp import VApp vm_resource = self.get_resource() resource_type = ResourceType.VAPP.value if self.is_powered_off(vm_resource): records1 = self.___validate_vapp_records( vapp_name=source_vapp_name, resource_type=resource_type) source_vapp_href = records1[0].get('href') records2 = self.___validate_vapp_records( vapp_name=target_vapp_name, resource_type=resource_type) target_vapp_href = records2[0].get('href') source_vapp = VApp(self.client, href=source_vapp_href) target_vapp = VApp(self.client, href=target_vapp_href) target_vapp.reload() spec = { 'vapp': source_vapp.get_resource(), 'source_vm_name': self.get_resource().get('name'), 'target_vm_name': target_vm_name } return target_vapp.add_vms([spec], deploy=False, power_on=False, all_eulas_accepted=True ) else: raise InvalidStateException("VM Must be powered off.")
def test_0002_add_vm(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, href=vdc_resource.get('href')) assert self.config['vcd']['vdc'] == vdc.get_resource().get('name') vapp_resource = vdc.get_vapp(self.config['vcd']['vapp']) assert vapp_resource.get('name') == self.config['vcd']['vapp'] vapp = VApp(self.client, resource=vapp_resource) catalog_item = org.get_catalog_item(self.config['vcd']['catalog'], self.config['vcd']['template']) source_vapp_resource = self.client.get_resource( catalog_item.Entity.get('href')) spec = { 'source_vm_name': self.config['vcd']['vm'], 'vapp': source_vapp_resource } spec['target_vm_name'] = self.config['vcd']['hostname'] spec['hostname'] = self.config['vcd']['hostname'] spec['network'] = self.config['vcd']['network'] spec['ip_allocation_mode'] = self.config['vcd']['ip_allocation_mode'] spec['storage_profile'] = vdc.get_storage_profile( self.config['vcd']['storage_profile']) vms = [spec] result = vapp.add_vms(vms) 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 add_vm(ctx, name, source_vapp, source_vm, catalog, target_vm, hostname, network, ip_allocation_mode, storage_profile, password_auto, accept_all_eulas): try: restore_session(ctx, vdc_required=True) client = ctx.obj['client'] in_use_org_href = ctx.obj['profiles'].get('org_href') org = Org(client, in_use_org_href) vdc_href = ctx.obj['profiles'].get('vdc_href') vdc = VDC(client, href=vdc_href) source_vapp_resource = None if catalog is None: source_vapp_resource = vdc.get_vapp(source_vapp) else: catalog_item = org.get_catalog_item(catalog, source_vapp) source_vapp_resource = client.get_resource( catalog_item.Entity.get('href')) assert source_vapp_resource is not None vapp_resource = vdc.get_vapp(name) vapp = VApp(client, resource=vapp_resource) spec = {'source_vm_name': source_vm, 'vapp': source_vapp_resource} if target_vm is not None: spec['target_vm_name'] = target_vm if hostname is not None: spec['hostname'] = hostname if network is not None: spec['network'] = network spec['ip_allocation_mode'] = ip_allocation_mode if storage_profile is not None: spec['storage_profile'] = vdc.get_storage_profile(storage_profile) if password_auto is not None: spec['password_auto'] = password_auto task = vapp.add_vms([spec], all_eulas_accepted=accept_all_eulas) stdout(task, ctx) except Exception as e: stderr(e, ctx)
def create_from_catalog(self, request): logging.info("__INIT__create[VappVm] source_catalog_name[%s]", request.source_catalog_name) res = vapp_vm_pb2.CreateVappVmResult() res.created = False logged_in_org = self.client.get_org() org = Org(self.client, resource=logged_in_org) 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) catalog_item = org.get_catalog_item(request.source_catalog_name, request.source_template_name) source_vapp_resource = self.client.get_resource( catalog_item.Entity.get('href')) specs = [{ 'source_vm_name': request.source_vm_name, 'vapp': source_vapp_resource, 'target_vm_name': request.target_vm_name, 'hostname': request.hostname, 'network': request.network, 'ip_allocation_mode': request.ip_allocation_mode, # 'storage_profile': request.storage_profile }] create_vapp_vm_resp = vapp.add_vms( specs, power_on=request.power_on, all_eulas_accepted=request.all_eulas_accepted) task_monitor = self.client.get_task_monitor() task = task_monitor.wait_for_status( task=create_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.VappVmCreateError( etree.tostring(task, pretty_print=True)) message = 'status : {0} '.format(st) logging.info(message) res.created = True except Exception as e: errmsg = '''__ERROR_create[VappVm] failed for vm {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__create[VappVm]") return res
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
def create(client): print("=============== __LOG__Create_VDC =======================\n\n") vdc_name = "ACME_PAYG" vapp_name = "test2" org_resource = client.get_org() org = Org(client, resource=org_resource) print("Org name: ", org.get_name()) print("Vdc name: ", vdc_name) try: 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) print("vapp : ", vapp) catalog_item = org.get_catalog_item('ACME', 'tinyova') source_vapp_resource = client.get_resource( catalog_item.Entity.get('href')) print("source_vapp_resource: ", source_vapp_resource) spec = { 'source_vm_name': 'Tiny Linux template', 'vapp': source_vapp_resource } storage_profiles = [{ 'name': 'Performance', 'enabled': True, 'units': 'MB', 'limit': 0, 'default': True }] spec['target_vm_name'] = 'ubuntu_pcp_11' spec['hostname'] = 'ubuntu' spec['network'] = 'global' spec['ip_allocation_mode'] = 'dhcp' #spec['storage_profile'] = storage_profiles vms = [spec] result = vapp.add_vms(vms) print("result: ", result) #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=None) #st = task.get('status') #if st == TaskStatus.SUCCESS.value: # message = 'status : {0} '.format(st) # logging.info(message) #else: # print("st : ", st) # raise Exception(task) print("=============================================\n\n") return True except Exception as e: error_message = '__ERROR_ [create_vdc] failed for vdc {0} '.format( vdc_name) logging.warn(error_message, e) return False
vms = [] for vm_cfg in cfg.vapp['vms']: print(vm_cfg) source_vapp_resource = client.get_resource(catalog_item.Entity.get('href')) create_master_vm(vms, source_vapp_resource, vm_cfg) # wait for the master to start and get the first ip time.sleep(15) for vm_slave_cfg in vm_cfg['slaves']: source_slave_vapp_resource = client.get_resource( catalog_item.Entity.get('href')) create_slave_vm(vms, vm_cfg['name'], source_slave_vapp_resource, vm_slave_cfg) print("Creating (if needed) ...") result = vapp.add_vms(vms) handle_task(client, result) print("Statuses ...") while (vapp.get_all_vms() is None or len(vapp.get_all_vms()) < len(cfg.vapp['vms'])): print(" VMs ... {0}\r".format("waiting full start ...".ljust(20)), end='') vapp.reload() for vm in vapp.get_all_vms(): vm_obj = VM(client, resource=vm) while (vm_obj.is_powered_on() == False): print(" VM '{0}' ... {1}\r".format(vm.get('name'), "DOWN (waiting)".ljust(20)), end='') vm_obj.reload()
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
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
def create_from_catalog(self, request): logging.info("__INIT__create[VappVm] source_catalog_name[%s]", request.source_catalog_name) res = vapp_vm_pb2.CreateVappVmResult() res.created = False logged_in_org = self.client.get_org() org = Org(self.client, resource=logged_in_org) 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) catalog_item = org.get_catalog_item(request.source_catalog_name, request.source_template_name) source_vapp_resource = self.client.get_resource( catalog_item.Entity.get('href')) specs = [{ 'source_vm_name': request.source_vm_name, 'vapp': source_vapp_resource, 'target_vm_name': request.target_vm_name, 'hostname': request.hostname, 'network': request.network, 'ip_allocation_mode': request.ip_allocation_mode, # 'storage_profile': request.storage_profile }] create_vapp_vm_resp = vapp.add_vms(specs, power_on=request.power_on, all_eulas_accepted=request.all_eulas_accepted) task_monitor = self.client.get_task_monitor() task = task_monitor.wait_for_status( task=create_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.VappVmCreateError( etree.tostring(task, pretty_print=True)) message = 'status : {0} '.format(st) logging.info(message) res.created = True except Exception as e: errmsg = '''__ERROR_create[VappVm] failed for vm {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__create[VappVm]") return res