def create(ctx, name, pvdc_name, network_pool_name, allocation_model, sp_name, sp_limit, description, cpu_allocated, cpu_limit): try: restore_session(ctx) client = ctx.obj['client'] in_use_org_href = ctx.obj['profiles'].get('org_href') org = Org(client, in_use_org_href) storage_profiles = [{ 'name': sp_name, 'enabled': True, 'units': 'MB', 'limit': sp_limit, 'default': True }] vdc_resource = org.create_org_vdc(name, pvdc_name, network_pool_name=network_pool_name, description=description, allocation_model=allocation_model, cpu_allocated=cpu_allocated, cpu_limit=cpu_limit, storage_profiles=storage_profiles, uses_fast_provisioning=True, is_thin_provision=True) stdout(vdc_resource.Tasks.Task[0], ctx) except Exception as e: stderr(e, ctx)
def create(ctx, name, pvdc_name, network_pool_name, allocation_model, sp_name, sp_limit, description, cpu_allocated, cpu_limit): try: restore_session(ctx) client = ctx.obj['client'] in_use_org_href = ctx.obj['profiles'].get('org_href') org = Org(client, in_use_org_href) storage_profiles = [{ 'name': sp_name, 'enabled': True, 'units': 'MB', 'limit': sp_limit, 'default': True }] vdc_resource = org.create_org_vdc( name, pvdc_name, network_pool_name=network_pool_name, description=description, allocation_model=allocation_model, cpu_allocated=cpu_allocated, cpu_limit=cpu_limit, storage_profiles=storage_profiles, uses_fast_provisioning=True, is_thin_provision=True) stdout(vdc_resource.Tasks.Task[0], ctx) except Exception as e: stderr(e, ctx)
def test_create_vdc(self): org_to_use = self.client.get_org_by_name( self.config['vcd']['org_to_use']) org = Org(self.client, href=org_to_use.get('href')) storage_profiles = [{ 'name': self.config['vcd']['storage_profile'], 'enabled': True, 'units': 'MB', 'limit': 0, 'default': True }] vdc_resource = org.create_org_vdc( self.config['vcd']['new_vdc'], self.config['vcd']['provider_vdc'], network_pool_name=self.config['vcd']['network_pool'], description='description', allocation_model='AllocationVApp', cpu_allocated=0, cpu_limit=0, storage_profiles=storage_profiles, uses_fast_provisioning=True, is_thin_provision=True) task = self.client.get_task_monitor().wait_for_status( task=vdc_resource.Tasks.Task[0], timeout=30, poll_frequency=2, fail_on_statuses=None, expected_target_statuses=[ TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR, TaskStatus.CANCELED ], callback=None) assert task.get('status') == TaskStatus.SUCCESS.value
def create_ovdc(cls): """Creates an org vdc with the name specified in the config file. Skips creating one, if such an org vdc already exists. Also stores the href of the org vdc as class variable for future use. :raises: Exception: if the class variable _org_href or _pvdc_name is not populated. """ cls._basic_check() if cls._org_href is None: raise Exception('Org ' + cls._config['vcd']['default_org_name'] + ' doesn\'t exist.') if cls._pvdc_name is None: raise Exception('pVDC ' + cls._config['vcd']['default_pvdc_name'] + ' doesn\'t exist.') org = Org(cls._sys_admin_client, href=cls._org_href) ovdc_name = cls._config['vcd']['default_ovdc_name'] for vdc in org.list_vdcs(): if vdc.get('name').lower() == ovdc_name.lower(): cls._logger.debug('Reusing existing ovdc ' + ovdc_name + '.') cls._ovdc_href = vdc.get('href') return storage_profiles = [{ 'name': cls._config['vcd']['default_storage_profile_name'], 'enabled': True, 'units': 'MB', 'limit': 0, 'default': True }] system = System( cls._sys_admin_client, admin_resource=cls._sys_admin_client.get_admin()) netpool_to_use = cls._get_netpool_name_to_use(system) cls._logger.debug('Creating ovdc ' + ovdc_name + '.') vdc_resource = org.create_org_vdc( ovdc_name, cls._pvdc_name, network_pool_name=netpool_to_use, network_quota=cls._config['vcd']['default_network_quota'], storage_profiles=storage_profiles, uses_fast_provisioning=True, is_thin_provision=True) cls._sys_admin_client.get_task_monitor().wait_for_success( task=vdc_resource.Tasks.Task[0]) org.reload() # The following contraption is required to get the non admin href of # the ovdc. vdc_resource contains the admin version of the href since # we created the ovdc as a sys admin. for vdc in org.list_vdcs(): if vdc.get('name').lower() == ovdc_name.lower(): cls._ovdc_href = vdc.get('href')
# Ensure VDC exists. If we create it reload the org as it affects # org resource contents and future calls might fail otherwise. try: vdc_resource = org.get_vdc(cfg.vdc['vdc_name']) vdc = VDC(client, resource=vdc_resource) print("VDC already exists: {0}".format(vdc.name)) except Exception: print("VDC does not exist, creating: {0}".format(cfg.vdc['vdc_name'])) vdc_kwargs = cfg.vdc # Vet the netpool and pvcd arguments as either can be '*' in which # case we need to find default values. _fill_in_pvdc_default(client, vdc_kwargs) _fill_in_netpool_default(client, vdc_kwargs) # Now create the VDC. admin_vdc_resource = org.create_org_vdc(**vdc_kwargs) # The 'admin_vdc_resource' is not a task but an AdminVdc entity. Tasks # are two levels down. handle_task(client, admin_vdc_resource.Tasks.Task[0]) org.reload() vdc_resource = org.get_vdc(cfg.vdc['vdc_name']) vdc = VDC(client, resource=vdc_resource) print("VDC now exists: {0}".format(vdc.name)) # Ensure the catalog exists. For now we don't do anything special with # permissions. As with VDC's we reload the org if we create a catalog # so that it's visible in future calls. try: catalog_resource = org.get_catalog_resource(cfg.catalog['name']) print("Catalog already exists: {0}".format(cfg.catalog['name'])) except Exception:
class Vdc(VcdAnsibleModule): def __init__(self, **kwargs): super(Vdc, self).__init__(**kwargs) self.org = Org(self.client, resource=self.get_vdc_org_resource()) def manage_states(self): state = self.params.get('state') if state == 'present': return self.create() if state == 'absent': return self.delete() if state == 'update': return self.update() def manage_operations(self): operation = self.params.get('operation') if operation == 'list_vdcs': return self.list_vdcs() def get_vdc_org_resource(self): if self.params.get('vdc_org_name'): return self.client.get_org_by_name(self.params.get('vdc_org_name')) return self.client.get_org() def create(self): vdc_name = self.params.get('vdc_name') is_enabled = self.params.get('is_enabled') provider_vdc_name = self.params.get('provider_vdc_name') description = self.params.get('description') allocation_model = self.params.get('allocation_model') storage_profiles = self.params.get('storage_profiles') cpu_units = self.params.get('cpu_units') cpu_allocated = self.params.get('cpu_allocated') cpu_limit = self.params.get('cpu_limit') mem_units = self.params.get('mem_units') mem_allocated = self.params.get('mem_allocated') mem_limit = self.params.get('mem_limit') nic_quota = self.params.get('nic_quota') network_quota = self.params.get('network_quota') vm_quota = self.params.get('vm_quota') resource_guaranteed_memory = self.params.get( 'resource_guaranteed_memory') resource_guaranteed_cpu = self.params.get('resource_guaranteed_cpu') vcpu_in_mhz = self.params.get('vcpu_in_mhz') is_thin_provision = self.params.get('is_thin_provision') network_pool_name = self.params.get('network_pool_name') uses_fast_provisioning = self.params.get('uses_fast_provisioning') over_commit_allowed = self.params.get('over_commit_allowed') vm_discovery_enabled = self.params.get('vm_discovery_enabled') response = dict() response['changed'] = False if not self.org.get_vdc(vdc_name): create_vdc_task = self.org.create_org_vdc( vdc_name=vdc_name, provider_vdc_name=provider_vdc_name, description=description, allocation_model=allocation_model, storage_profiles=storage_profiles, cpu_units=cpu_units, cpu_allocated=cpu_allocated, cpu_limit=cpu_limit, mem_units=mem_units, mem_allocated=mem_allocated, mem_limit=mem_limit, nic_quota=nic_quota, network_quota=network_quota, vm_quota=vm_quota, resource_guaranteed_memory=resource_guaranteed_memory, resource_guaranteed_cpu=resource_guaranteed_cpu, vcpu_in_mhz=vcpu_in_mhz, is_thin_provision=is_thin_provision, network_pool_name=network_pool_name, uses_fast_provisioning=uses_fast_provisioning, over_commit_allowed=over_commit_allowed, vm_discovery_enabled=vm_discovery_enabled, is_enabled=is_enabled) self.execute_task(create_vdc_task.Tasks.Task[0]) response['msg'] = 'VDC {} has been created.'.format(vdc_name) response['changed'] = True else: response['warnings'] = 'VDC {} is already present.'.format( vdc_name) return response def update(self): vdc_name = self.params.get('vdc_name') is_enabled = self.params.get('is_enabled') response = dict() response['changed'] = False try: vdc_resource = self.org.get_vdc(vdc_name, is_admin_operation=True) vdc = VDC(self.client, name=vdc_name, resource=vdc_resource) vdc.enable_vdc(enable=is_enabled) response['msg'] = 'VDC {} has been updated.'.format(vdc_name) response['changed'] = True except OperationNotSupportedException: m = "VDC {} may already in {} state" response['warnings'] = m.format( vdc_name, "enabled") if is_enabled else m.format( vdc_name, "disabled") return response def delete(self): vdc_name = self.params.get('vdc_name') response = dict() response['changed'] = False try: vdc_resource = self.org.get_vdc(vdc_name, is_admin_operation=True) vdc = VDC(self.client, name=vdc_name, resource=vdc_resource) vdc.enable_vdc(enable=False) except EntityNotFoundException: response['warnings'] = 'VDC {} is not present.'.format(vdc_name) return except OperationNotSupportedException: pass delete_vdc_task = vdc.delete_vdc() self.execute_task(delete_vdc_task) response['msg'] = 'VDC {} has been deleted.'.format(vdc_name) response['changed'] = True return response def list_vdcs(self): response = dict() response['changed'] = False response['msg'] = list() for vdc in self.org.list_vdcs(): response['msg'].append(vdc.get('name')) return response
class Vdc(VcdAnsibleModule): def __init__(self, **kwargs): super(Vdc, self).__init__(**kwargs) logged_in_org = self.client.get_org() self.org = Org(self.client, resource=logged_in_org) def manage_states(self): state = self.params.get('state') if state == 'present': return self.create() if state == 'absent': return self.delete() if state == 'update': return self.update() def create(self): vdc_name = self.params.get('vdc_name') is_enabled = self.params.get('is_enabled') provider_vdc_name = self.params.get('provider_vdc_name') description = self.params.get('description') allocation_model = self.params.get('allocation_model') storage_profiles = json.loads(self.params.get('storage_profiles')) cpu_units = self.params.get('cpu_units') cpu_allocated = self.params.get('cpu_allocated') cpu_limit = self.params.get('cpu_limit') mem_units = self.params.get('mem_units') mem_allocated = self.params.get('mem_allocated') mem_limit = self.params.get('mem_limit') nic_quota = self.params.get('nic_quota') network_quota = self.params.get('network_quota') vm_quota = self.params.get('vm_quota') resource_guaranteed_memory = self.params.get( 'resource_guaranteed_memory') resource_guaranteed_cpu = self.params.get('resource_guaranteed_cpu') vcpu_in_mhz = self.params.get('vcpu_in_mhz') is_thin_provision = self.params.get('is_thin_provision') network_pool_name = self.params.get('network_pool_name') uses_fast_provisioning = self.params.get('uses_fast_provisioning') over_commit_allowed = self.params.get('over_commit_allowed') vm_discovery_enabled = self.params.get('vm_discovery_enabled') storage_profiles = storage_profiles if type( storage_profiles) is list else [storage_profiles] response = dict() response['changed'] = False try: self.org.get_vdc(vdc_name) except EntityNotFoundException: create_vdc_task = self.org.create_org_vdc( vdc_name=vdc_name, provider_vdc_name=provider_vdc_name, description=description, allocation_model=allocation_model, storage_profiles=storage_profiles, cpu_units=cpu_units, cpu_allocated=cpu_allocated, cpu_limit=cpu_limit, mem_units=mem_units, mem_allocated=mem_allocated, mem_limit=mem_limit, nic_quota=nic_quota, network_quota=network_quota, vm_quota=vm_quota, resource_guaranteed_memory=resource_guaranteed_memory, resource_guaranteed_cpu=resource_guaranteed_cpu, vcpu_in_mhz=vcpu_in_mhz, is_thin_provision=is_thin_provision, network_pool_name=network_pool_name, uses_fast_provisioning=uses_fast_provisioning, over_commit_allowed=over_commit_allowed, vm_discovery_enabled=vm_discovery_enabled, is_enabled=is_enabled) self.execute_task(create_vdc_task.Tasks.Task[0]) response['msg'] = 'VDC {} has been created.'.format(vdc_name) response['changed'] = True else: response['warnings'] = 'VDC {} is already present.'.format( vdc_name) return response def update(self): vdc_name = self.params.get('vdc_name') is_enabled = self.params.get('is_enabled') response = dict() response['changed'] = False vdc_resource = self.org.get_vdc(vdc_name) vdc = VDC(self.client, name=vdc_name, resource=vdc_resource) vdc.enable_vdc(enable=is_enabled) response['msg'] = 'VDC {} has been updated.'.format(vdc_name) response['changed'] = True return response def delete(self): vdc_name = self.params.get('vdc_name') response = dict() response['changed'] = False try: vdc_resource = self.org.get_vdc(vdc_name) except EntityNotFoundException: response['warnings'] = 'VDC {} is not present.'.format(vdc_name) else: vdc = VDC(self.client, name=vdc_name, resource=vdc_resource) vdc.enable_vdc(enable=False) delete_vdc_task = vdc.delete_vdc() self.execute_task(delete_vdc_task) response['msg'] = 'VDC {} has been deleted.'.format(vdc_name) response['changed'] = True return response
class Vdc(VcdAnsibleModule): def __init__(self, **kwargs): super(Vdc, self).__init__(**kwargs) self.org = Org(self.client, resource=self.get_vdc_org_resource()) def manage_states(self): state = self.params.get('state') if state == 'present': return self.create() if state == 'absent': return self.delete() if state == 'update': return self.update() def manage_operations(self): operation = self.params.get('operation') if operation == 'add_storage_profile': return self.add_storage_profile() if operation == 'update_storage_profile': return self.update_storage_profile() if operation == 'delete_storage_profile': return self.delete_storage_profile() if operation == 'list_storage_profiles': return self.get_storage_profiles() def get_vdc_org_resource(self): if self.params.get('vdc_org_name'): return self.client.get_org_by_name(self.params.get('vdc_org_name')) return self.client.get_org() def get_vdc(self): try: vdc_name = self.params['vdc_name'] vdc_resource = self.org.get_vdc(vdc_name) assert vdc_resource is not None except AssertionError: msg = "{0} is not found" raise EntityNotFoundException(msg.format(vdc_name)) return VDC(self.client, name=vdc_name, resource=vdc_resource) def create(self): vdc_name = self.params['vdc_name'] is_enabled = self.params['is_enabled'] provider_vdc_name = self.params['provider_vdc_name'] description = self.params['description'] or '' allocation_model = self.params['allocation_model'] or 'AllocationVApp' storage_profiles = self.params['storage_profiles'] cpu_units = self.params['cpu_units'] or "MHz" cpu_allocated = self.params['cpu_allocated'] or 0 cpu_limit = self.params['cpu_limit'] or 0 mem_units = self.params['mem_units'] or 'MB' mem_allocated = self.params['mem_allocated'] or 0 mem_limit = self.params['mem_limit'] or 0 nic_quota = self.params['nic_quota'] or 0 network_quota = self.params['network_quota'] or 0 vm_quota = self.params['vm_quota'] or 0 resource_guaranteed_memory = self.params[ 'resource_guaranteed_memory'] or 1.0 resource_guaranteed_cpu = self.params['resource_guaranteed_cpu'] or 1.0 vcpu_in_mhz = self.params['vcpu_in_mhz'] is_thin_provision = self.params['is_thin_provision'] network_pool_name = self.params['network_pool_name'] uses_fast_provisioning = self.params['uses_fast_provisioning'] over_commit_allowed = self.params['over_commit_allowed'] vm_discovery_enabled = self.params['vm_discovery_enabled'] response = dict() response['changed'] = False response['msg'] = self.params["description"] or "None" try: self.get_vdc() except EntityNotFoundException: create_vdc_task = self.org.create_org_vdc( vdc_name=vdc_name, provider_vdc_name=provider_vdc_name, description=description, allocation_model=allocation_model, storage_profiles=storage_profiles, cpu_units=cpu_units, cpu_allocated=cpu_allocated, cpu_limit=cpu_limit, mem_units=mem_units, mem_allocated=mem_allocated, mem_limit=mem_limit, nic_quota=nic_quota, network_quota=network_quota, vm_quota=vm_quota, resource_guaranteed_memory=resource_guaranteed_memory, resource_guaranteed_cpu=resource_guaranteed_cpu, vcpu_in_mhz=vcpu_in_mhz, is_thin_provision=is_thin_provision, network_pool_name=network_pool_name, uses_fast_provisioning=uses_fast_provisioning, over_commit_allowed=over_commit_allowed, vm_discovery_enabled=vm_discovery_enabled, is_enabled=is_enabled) self.execute_task(create_vdc_task.Tasks.Task[0]) response['msg'] = 'VDC {} has been created'.format(vdc_name) response['changed'] = True else: response['warnings'] = 'VDC {} is already present'.format(vdc_name) return response def update(self): vdc_name = self.params['vdc_name'] description = self.params['description'] allocation_model = self.params['allocation_model'] cpu_units = self.params['cpu_units'] cpu_allocated = self.params['cpu_allocated'] cpu_limit = self.params['cpu_limit'] mem_units = self.params['mem_units'] mem_allocated = self.params['mem_allocated'] mem_limit = self.params['mem_limit'] nic_quota = self.params['nic_quota'] network_quota = self.params['network_quota'] vm_quota = self.params['vm_quota'] resource_guaranteed_memory = self.params['resource_guaranteed_memory'] resource_guaranteed_cpu = self.params['resource_guaranteed_cpu'] vcpu_in_mhz = self.params['vcpu_in_mhz'] is_thin_provision = self.params['is_thin_provision'] is_enabled = self.params['is_enabled'] response = dict() response['changed'] = False try: self.get_vdc() update_org_vdc_task = self.org.update_org_vdc( vdc_name, description, allocation_model, cpu_units, cpu_allocated, cpu_limit, mem_units, mem_allocated, mem_limit, nic_quota, network_quota, vm_quota, resource_guaranteed_memory, resource_guaranteed_cpu, vcpu_in_mhz, is_thin_provision, is_enabled) self.execute_task(update_org_vdc_task) response['msg'] = 'VDC {} has been updated'.format(vdc_name) response['changed'] = True except OperationNotSupportedException: msg = "VDC {} may already in desired state" response['warnings'] = msg.format(vdc_name) except EntityNotFoundException: response['warnings'] = 'VDC {} is not present.'.format(vdc_name) return response def delete(self): vdc_name = self.params['vdc_name'] response = dict() response['changed'] = False try: vdc = self.get_vdc() vdc.enable_vdc(enable=False) delete_vdc_task = vdc.delete_vdc() self.execute_task(delete_vdc_task) response['msg'] = 'VDC {} has been deleted.'.format(vdc_name) response['changed'] = True except EntityNotFoundException: response['warnings'] = 'VDC {} is not present.'.format(vdc_name) except OperationNotSupportedException: pass return response def get_storage_profiles(self): vdc_name = self.params['vdc_name'] response = dict() response['changed'] = False try: vdc = self.get_vdc() response['msg'] = [ storage_profile.get("name") for storage_profile in vdc.get_storage_profiles() ] except EntityNotFoundException: msg = 'VDC {} is not present' response['warnings'] = msg.format(vdc_name) return response def _update_response(self, response, msg, warning): vdc_name = self.params['vdc_name'] if response['msg']: response['msg'] = msg.format(response['msg'], vdc_name) if response['warnings']: response['warnings'] = warning.format(response['warnings']) return response def add_storage_profile(self): vdc_name = self.params['vdc_name'] profiles = self.params['storage_profiles'] response = dict() response['changed'] = False response['msg'] = list() response['warnings'] = list() storage_profiles = self.get_storage_profiles()['msg'] msg = 'VDC Storage profile(s) {0} are added' warning = 'VDC Storage profile(s) {0} are already present' try: vdc = self.get_vdc() for profile in profiles: name = profile['name'] if name not in storage_profiles: enabled = profile['enabled'] default = profile['default'] kwargs = { 'enabled': True if enabled == 'true' else False, 'default': True if default == 'true' else False, 'limit_in_mb': profile['limit'] } task = vdc.add_storage_profile(name, **kwargs) self.execute_task(task) response['msg'].append(profile['name']) continue response['warnings'].append(name) response = self._update_response(response, msg, warning) except EntityNotFoundException: msg = 'VDC {} is not present' response['warnings'] = msg.format(vdc_name) return response def update_storage_profile(self): vdc_name = self.params['vdc_name'] profiles = self.params['storage_profiles'] response = dict() response['changed'] = False response['msg'] = list() response['warnings'] = list() storage_profiles = self.get_storage_profiles()['msg'] msg = 'Storage profile(s) {0} are updated' warning = 'VDC Storage profile(s) {0} are not found' try: vdc = self.get_vdc() for profile in profiles: name = profile['name'] if name in storage_profiles: enabled = True if profile['enabled'] == 'true' else False kwargs = { 'default': profile.get('default', None), 'limit_in_mb': profile.get('limit', None) } vdc.update_storage_profile(name, enabled, **kwargs) response['msg'].append(name) continue response['warnings'].append(name) response = self._update_response(response, msg, warning) except EntityNotFoundException: msg = 'VDC {} is not present' response['warnings'] = msg.format(vdc_name) return response def delete_storage_profile(self): vdc_name = self.params['vdc_name'] profiles = self.params['storage_profiles'] response = dict() response['msg'] = list() response['warnings'] = list() response['changed'] = False storage_profiles = self.get_storage_profiles()['msg'] msg = 'Storage profile(s) {0} are deleted' warning = 'VDC Storage profile(s) {0} are not found' try: vdc = self.get_vdc() for profile in profiles: name = profile.get("name") if name in storage_profiles: remove_vdc_task = vdc.remove_storage_profile(name) self.execute_task(remove_vdc_task) response['msg'].append(name) continue response['warnings'].append(name) response = self._update_response(response, msg, warning) except EntityNotFoundException: msg = 'VDC {} is not present' response['warnings'] = msg.format(vdc_name) return response
def create(self, provider_vdc_name, description, allocation_model, storage_profiles, cpu_units, cpu_allocated, cpu_limit, mem_units, mem_allocated, mem_limit, nic_quota, network_quota, vm_quota, resource_guaranteed_memory, resource_guaranteed_cpu, vcpu_in_mhz, is_thin_provision, network_pool_name, uses_fast_provisioning, over_commit_allowed, vm_discovery_enabled): logging.info("__INIT__create[Vdc]") res = vdc_pb2.CreateVdcResult() res.created = False context = self.context logged_in_org = self.client.get_org() org = Org(self.client, resource=logged_in_org) #Vdc details name = self.name is_enabled = self.is_enabled try: storage_profiles = json.loads(storage_profiles) if not network_pool_name.strip(): network_pool_name = None create_vdc_resp = org.create_org_vdc( vdc_name=name, provider_vdc_name=provider_vdc_name, description=description, allocation_model=allocation_model, storage_profiles=storage_profiles, cpu_units=cpu_units, cpu_allocated=cpu_allocated, cpu_limit=cpu_limit, mem_units=mem_units, mem_allocated=mem_allocated, mem_limit=mem_limit, nic_quota=nic_quota, network_quota=network_quota, vm_quota=vm_quota, resource_guaranteed_memory=resource_guaranteed_memory, resource_guaranteed_cpu=resource_guaranteed_cpu, vcpu_in_mhz=vcpu_in_mhz, is_thin_provision=is_thin_provision, network_pool_name=network_pool_name, uses_fast_provisioning=uses_fast_provisioning, over_commit_allowed=over_commit_allowed, vm_discovery_enabled=vm_discovery_enabled, is_enabled=is_enabled) task = self.client.get_task_monitor().wait_for_status( task=create_vdc_resp.Tasks.Task[0], timeout=60, poll_frequency=2, fail_on_statuses=None, expected_target_statuses=[ TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR, TaskStatus.CANCELED ], callback=None) st = task.get('status') if st == TaskStatus.SUCCESS.value: message = 'delete vdc status : {0} '.format(st) logging.info(message) else: raise errors.VCDVdcCreateError( etree.tostring(task, pretty_print=True)) res.created = True except Exception as e: error_message = '__ERROR_create[Vdc] failed for Vdc {0}. __ErrorMessage__ {1}'.format( self.name, str(e)) logging.warn(error_message) context.set_code(grpc.StatusCode.INVALID_ARGUMENT) context.set_details(error_message) return res logging.info("__DONE__create[Vdc]") return res
class Vdc(VcdAnsibleModule): def __init__(self, **kwargs): super(Vdc, self).__init__(**kwargs) logged_in_org = self.client.get_org() self.org = Org(self.client, resource=logged_in_org) def manage_states(self): state = self.params.get('state') if state == 'present': return self.create() if state == 'absent': return self.delete() if state == 'update': return self.update() def create(self): vdc_name = self.params.get('vdc_name') is_enabled = self.params.get('is_enabled') provider_vdc_name = self.params.get('provider_vdc_name') description = self.params.get('description') allocation_model = self.params.get('allocation_model') storage_profiles = json.loads(self.params.get('storage_profiles')) cpu_units = self.params.get('cpu_units') cpu_allocated = self.params.get('cpu_allocated') cpu_limit = self.params.get('cpu_limit') mem_units = self.params.get('mem_units') mem_allocated = self.params.get('mem_allocated') mem_limit = self.params.get('mem_limit') nic_quota = self.params.get('nic_quota') network_quota = self.params.get('network_quota') vm_quota = self.params.get('vm_quota') resource_guaranteed_memory = self.params.get('resource_guaranteed_memory') resource_guaranteed_cpu = self.params.get('resource_guaranteed_cpu') vcpu_in_mhz = self.params.get('vcpu_in_mhz') is_thin_provision = self.params.get('is_thin_provision') network_pool_name = self.params.get('network_pool_name') uses_fast_provisioning = self.params.get('uses_fast_provisioning') over_commit_allowed = self.params.get('over_commit_allowed') vm_discovery_enabled = self.params.get('vm_discovery_enabled') storage_profiles = storage_profiles if type(storage_profiles) is list else [storage_profiles] response = dict() response['changed'] = False try: self.org.get_vdc(vdc_name) except EntityNotFoundException: create_vdc_task = self.org.create_org_vdc( vdc_name=vdc_name, provider_vdc_name=provider_vdc_name, description=description, allocation_model=allocation_model, storage_profiles=storage_profiles, cpu_units=cpu_units, cpu_allocated=cpu_allocated, cpu_limit=cpu_limit, mem_units=mem_units, mem_allocated=mem_allocated, mem_limit=mem_limit, nic_quota=nic_quota, network_quota=network_quota, vm_quota=vm_quota, resource_guaranteed_memory=resource_guaranteed_memory, resource_guaranteed_cpu=resource_guaranteed_cpu, vcpu_in_mhz=vcpu_in_mhz, is_thin_provision=is_thin_provision, network_pool_name=network_pool_name, uses_fast_provisioning=uses_fast_provisioning, over_commit_allowed=over_commit_allowed, vm_discovery_enabled=vm_discovery_enabled, is_enabled=is_enabled) self.execute_task(create_vdc_task.Tasks.Task[0]) response['msg'] = 'VDC {} has been created.'.format(vdc_name) response['changed'] = True else: response['warnings'] = 'VDC {} is already present.'.format(vdc_name) return response def update(self): vdc_name = self.params.get('vdc_name') is_enabled = self.params.get('is_enabled') response = dict() response['changed'] = False vdc_resource = self.org.get_vdc(vdc_name) vdc = VDC(self.client, name=vdc_name, resource=vdc_resource) vdc.enable_vdc(enable=is_enabled) response['msg'] = 'VDC {} has been updated.'.format(vdc_name) response['changed'] = True return response def delete(self): vdc_name = self.params.get('vdc_name') response = dict() response['changed'] = False try: vdc_resource = self.org.get_vdc(vdc_name) except EntityNotFoundException: response['warnings'] = 'VDC {} is not present.'.format(vdc_name) else: vdc = VDC(self.client, name=vdc_name, resource=vdc_resource) vdc.enable_vdc(enable=False) delete_vdc_task = vdc.delete_vdc() self.execute_task(delete_vdc_task) response['msg'] = 'VDC {} has been deleted.'.format(vdc_name) response['changed'] = True return response