def create(client, context, name, description): logging.debug("_INIT_create_catalog__") logging.debug("name = [%s] desc = [%s] ", name, description) result = pyvcloudprovider_pb2.CreateCatalogResult() result.created = False try: logged_in_org = client.get_org() org = Org(client, resource=logged_in_org) try: catalog = org.create_catalog(name=name, description=description) result.created = True except Exception as e: error_message = "__ ERROR Creating catalog [{0}] __ERROR_MESSAGE__ [{1}]".format( name, str(e)) logging.warn(error_message) context.set_code(grpc.StatusCode.INVALID_ARGUMENT) context.set_details(error_message) except Exception as e: error_message = "__ ERROR Creating catalog [{0}] __ERROR_MESSAGE__ [{1}]".format( name, str(e)) logging.warn(error_message) context.set_code(grpc.StatusCode.INVALID_ARGUMENT) context.set_details(error_message) logging.debug("_DONE_create_catalog__") return result
def read(client, context, name): #logging.basicConfig(level=logging.DEBUG) logging.debug("__INIT__read[catalog]__ %s", name) logging.debug("catalog_name %s", name) try: logged_in_org = client.get_org() org = Org(client, resource=logged_in_org) result = pyvcloudprovider_pb2.ReadCatalogResult() result.present = False try: catalog = org.get_catalog(name) logging.info(vars(catalog)) logging.info("\n==desc=[%s]", catalog.Description) result.name = str(catalog.get("name")) result.description = str(catalog.Description) result.shared = catalog.IsPublished result.present = True except Exception as e: logging.warning( "__ERROR__ while reading catalog[{0}]. __ERROR_MESSAGE__[{1}]". format(name, str(e))) return result except Exception as e: logging.error( "__ERROR__ while reading catalog[{0}]. __ERROR_MESSAGE__[{1}]". format(name, str(e))) raise
def update(client, context, old_name, new_name, description): logging.info("\n __INIT_update_catalog__") logging.debug( "\n old_name = [%s] new_name = [%s] desc = [%s]", old_name, new_name, description) result = pyvcloudprovider_pb2.UpdateCatalogResult() result.updated = False try: logged_in_org = client.get_org() org = Org(client, resource=logged_in_org) try: catalog = org.update_catalog( old_catalog_name=old_name, new_catalog_name=new_name, description=description) result.updated = True except Exception as e: error_message = "Error occured while updating catalog {0} __ERROR_MESSAGE__ {1}".format( old_name, str(e)) logging.error(error_message) context.set_code(grpc.StatusCode.INVALID_ARGUMENT) context.set_details(error_message) except Exception as e: error_message = "Error occured while updating catalog {0} __ERROR_MESSAGE__ {1}".format( old_name, str(e)) logging.error(error_message) context.set_code(grpc.StatusCode.INVALID_ARGUMENT) context.set_details(error_message) logging.debug("__DONE_update_catalog__") return result
def delete(client, context, name): logging.debug("=== delete catalog called === \n") try: logged_in_org = client.get_org() org = Org(client, resource=logged_in_org) result = pyvcloudprovider_pb2.DeleteCatalogResult() result.deleted = False try: catalog = org.delete_catalog(name) result.deleted = True except Exception as e: error_message = "Error occured while deleting catalog {0} __ERROR_MESSAGE__ {1}".format( name, str(e)) logging.error(error_message) context.set_code(grpc.StatusCode.INVALID_ARGUMENT) context.set_details(error_message) return result except Exception as e: error_message = "Error occured while deleting catalog {0} __ERROR_MESSAGE__ {1}".format( name, str(e)) logging.error(error_message) context.set_code(grpc.StatusCode.INVALID_ARGUMENT) context.set_details(error_message)
def list_catalogs_or_items(ctx, catalog_name): try: restore_session(ctx) client = ctx.obj['client'] if catalog_name is None: in_use_org_href = ctx.obj['profiles'].get('org_href') org = Org(client, in_use_org_href) result = org.list_catalogs() else: result = [] if is_sysadmin(ctx): resource_type = ResourceType.ADMIN_CATALOG_ITEM.value else: resource_type = ResourceType.CATALOG_ITEM.value q = client.get_typed_query( resource_type, query_result_format=QueryResultFormat.ID_RECORDS, equality_filter=('catalogName', catalog_name)) records = list(q.execute()) if len(records) == 0: result = 'not found' else: for r in records: result.append(to_dict(r, resource_type=resource_type)) stdout(result, ctx) except Exception as e: stderr(e, ctx)
def read(self, request): logging.info("__INIT__read[VappVm]") res = vapp_vm_pb2.ReadVappVmResult() res.present = 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) read_vapp_vm_resp = vapp.get_vm(request.target_vm_name) vm = VM(client=self.client, href=None, resource=read_vapp_vm_resp) res.present = True except Exception as e: errmsg = '__ERROR_read[VappVm] failed for VappVm {0}. __ErrorMessage__ {1}' logging.warn(errmsg.format(request.target_vm_name, str(e))) return res logging.info("__DONE__read[VappVm]") return res
def test_09_catalog_unshare_access(self): org_in_use = self.client.get_org_by_name( self.config['vcd']['org_in_use']) org = Org(self.client, resource=org_in_use) control_access = org.unshare_catalog_with_org_members( self.config['vcd']['catalog']) assert control_access.IsSharedToEveryone.text == 'false'
def test_03_remove_all_catalog_access(self): org_in_use = self.client.get_org_by_name( self.config['vcd']['org_in_use']) org = Org(self.client, resource=org_in_use) control_access = org.remove_catalog_access_settings( self.config['vcd']['catalog'], remove_all=True) self.assertFalse(hasattr(control_access, 'AccessSettings'))
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_catalog(cls): """Creates a catalog by the name specified in the configuration file. Skips creating one, if such a catalog already exists. :raises: Exception: if the class variable _org_href is not populated. """ cls._basic_check() if cls._org_href is None: raise Exception('Org ' + cls._config['vcd']['default_org_name'] + ' doesn\'t exist.') try: catalog_author_client = Environment.get_client_in_default_org( CommonRoles.CATALOG_AUTHOR) org = Org(catalog_author_client, href=cls._org_href) catalog_name = cls._config['vcd']['default_catalog_name'] catalog_records = org.list_catalogs() for catalog_record in catalog_records: if catalog_record.get('name') == catalog_name: cls._logger.debug('Reusing existing catalog ' + catalog_name) return cls._logger.debug('Creating new catalog ' + catalog_name) catalog_resource = org.create_catalog( name=catalog_name, description='') catalog_author_client.get_task_monitor().wait_for_success( task=catalog_resource.Tasks.Task[0]) finally: catalog_author_client.logout()
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 share_catalog(cls): """Shares the test catalog with all members in the test organization. :raises: Exception: if the class variable _org_href is not populated. :raises: EntityNotFoundException: if the catalog in question is missing. """ cls._basic_check() if cls._org_href is None: raise Exception('Org ' + cls._config['vcd']['default_org_name'] + ' doesn\'t exist.') try: catalog_author_client = Environment.get_client_in_default_org( CommonRoles.CATALOG_AUTHOR) org = Org(catalog_author_client, href=cls._org_href) catalog_name = cls._config['vcd']['default_catalog_name'] catalog_records = org.list_catalogs() for catalog_record in catalog_records: if catalog_record.get('name') == catalog_name: cls._logger.debug('Sharing catalog ' + catalog_name + ' to' ' all members of org ' + org.get_name()) org.share_catalog_with_org_members( catalog_name=catalog_name) return raise EntityNotFoundException('Catalog ' + catalog_name + 'doesn\'t exist.') finally: catalog_author_client.logout()
def capture(ctx, name, catalog, template, customizable, description): 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) catalog_resource = org.get_catalog(catalog) vdc_href = ctx.obj['profiles'].get('vdc_href') vdc = VDC(client, href=vdc_href) vapp_resource = vdc.get_vapp(name) overwrite = False if template is None: template = vapp_resource.get('name') else: overwrite = True task = org.capture_vapp( catalog_resource, vapp_href=vapp_resource.get('href'), catalog_item_name=template, description=description, customize_on_instantiate=customizable == 'customizable', overwrite=overwrite) stdout(task, ctx) except Exception as e: stderr(e, ctx)
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 test_001_list_edge_gateways(self): logged_in_org = self.client.get_org() org = Org(self.client, resource=logged_in_org) v = org.get_vdc(self.config['vcd']['vdc']) vdc = VDC(self.client, resource=v) edge_gateways = vdc.list_edge_gateways() assert len(edge_gateways) > 0
def test_1002_deploy_vm(self): logged_in_org = self.client.get_org() org = Org(self.client, resource=logged_in_org) v = org.get_vdc(self.config['vcd']['vdc']) vdc = VDC(self.client, href=v.get('href')) assert self.config['vcd']['vdc'] == vdc.get_resource().get('name') 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) vm_resource = vapp.get_vm(self.config['vcd']['vm']) vm = VM(self.client, resource=vm_resource) result = vm.deploy() # result = vm.shutdown() task = self.client.get_task_monitor().wait_for_status( task=result, timeout=60, poll_frequency=2, fail_on_statuses=None, expected_target_statuses=[ TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR, TaskStatus.CANCELED], callback=None) assert task.get('status') == TaskStatus.SUCCESS.value
def test_update_catalog(self): logged_in_org = self.client.get_org() org = Org(self.client, resource=logged_in_org) catalog = org.update_catalog(self.config['vcd']['catalog'], self.config['vcd']['new_name'], self.config['vcd']['new_desc']) assert self.config['vcd']['new_name'] == catalog.get('name') assert self.config['vcd']['new_desc'] == catalog['Description']
def test_1006_snapshot_create(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']) assert vapp_resource.get('name') == self.config['vcd']['vapp'] vapp = VApp(self.client, resource=vapp_resource) vm_resource = vapp.get_vm(self.config['vcd']['vm']) assert vm_resource.get('name') == self.config['vcd']['vm'] vm = VM(self.client, resource=vm_resource) task = vm.snapshot_create(memory=False, quiesce=False) task = self.client.get_task_monitor().wait_for_status( task=task, timeout=120, poll_frequency=2, fail_on_statuses=None, expected_target_statuses=[ TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR, TaskStatus.CANCELED], callback=None) assert task.get('status') == TaskStatus.SUCCESS.value
def create(ctx, user_name, password, role_name, full_name, description, email, telephone, im, enabled, alert_enabled, alert_email, alert_email_prefix, external, default_cached, group_role, stored_vm_quota, deployed_vm_quota): try: if len(password) < 6: raise Exception('Password must be at least 6 characters long.') restore_session(ctx) client = ctx.obj['client'] in_use_org_href = ctx.obj['profiles'].get('org_href') org = Org(client, in_use_org_href) role = org.get_role_record(role_name) role_href = role.get('href') result = org.create_user( user_name=user_name, password=password, role_href=role_href, full_name=full_name, description=description, email=email, telephone=telephone, im=im, alert_email=alert_email, alert_email_prefix=alert_email_prefix, stored_vm_quota=stored_vm_quota, deployed_vm_quota=deployed_vm_quota, is_group_role=group_role, is_default_cached=default_cached, is_external=external, is_alert_enabled=alert_enabled, is_enabled=enabled) stdout('User \'%s\' is successfully created.' % result.get('name'), ctx) except Exception as e: stderr(e, ctx)
def test_0002_modify_memory(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) vm_resource = vapp.get_vm(self.config['vcd']['vm']) vm = VM(self.client, resource=vm_resource) task = vm.modify_memory(self.config['vcd']['memory']) task = self.client.get_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) assert task.get('status') == TaskStatus.SUCCESS.value vm.reload() assert vm.get_memory() == self.config['vcd']['memory']
def create_disk(client): logging.info('INIT create_disk') logged_in_org = client.get_org() org = Org(client, resource=logged_in_org) v = org.get_vdc('OVD2') if v is None: raise errors.VDCNotFoundError(vappInfo.vdc) vdc = VDC(client, href=v.get('href')) #task=vdc.delete_disk('disk01') result = vdc.add_disk('disk02', "100") logging.info('DONE create_disk %s', result) task = client.get_task_monitor().wait_for_status( task=result.Tasks.Task[0], timeout=60, poll_frequency=2, fail_on_status=None, expected_target_statuses=[ TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR, TaskStatus.CANCELED ], callback=task_callback) st = task.get('status') if st == TaskStatus.SUCCESS.value: logging.info("__LOG__ created DISK") #cresult.created = True else: raise errors.VCDDiskCreationError( etree.tostring(task, pretty_print=True))
def test_080_update_disk(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) result = vdc.update_disk( name=self.config['vcd']['idisk_name'], new_name=self.config['vcd']['idisk_new_name'], new_size=self.config['vcd']['idisk_new_size'], new_description=self.config['vcd']['idisk_new_description'], new_storage_profile_name=self.config['vcd']['idisk_new_sp_name'], new_iops=self.config['vcd']['idisk_new_iops']) task = self.client.get_task_monitor().wait_for_status( task=result, 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 test_060_attach_disk_to_vm_in_vapp(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']) assert self.config['vcd']['vapp'] == vapp_resource.get('name') vapp = VApp(self.client, resource=vapp_resource) disk = vdc.get_disk(self.config['vcd']['idisk_name']) result = vapp.attach_disk_to_vm(disk_href=disk.get('href'), vm_name=self.config['vcd']['vm']) 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 update(self): logging.info("__INIT__update[Vdc]") res = vdc_pb2.UpdateVdcResult() res.updated = 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: vdc_resource = org.get_vdc(name) vdc = VDC(self.client, name=name, resource=vdc_resource) result = vdc.enable_vdc(is_enabled) res.updated = True except Exception as e: error_message = '__ERROR_update[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__update[Vdc]") return res
def create_users(cls): """Creates users for each of the roles in CommonRoles. Skips creating users which are already present in the organization. :raises: Exception: if the class variable _org_href is not populated. """ cls._basic_check() if cls._org_href is None: raise Exception('Org ' + cls._config['vcd']['default_org_name'] + ' doesn\'t exist.') org = Org(cls._sys_admin_client, href=cls._org_href) for role_enum in cls._user_name_for_roles.keys(): user_name = cls._user_name_for_roles[role_enum] user_records = list( org.list_users(name_filter=('name', user_name))) if len(user_records) > 0: cls._logger.debug('Reusing existing user ' + user_name + '.') cls._user_href_for_user_names[user_name] = \ user_records[0].get('href') continue role = org.get_role_record(role_enum.value) cls._logger.debug('Creating user ' + user_name + '.') user_resource = org.create_user( user_name=user_name, password=cls._config['vcd']['default_org_user_password'], role_href=role.get('href'), is_enabled=True) cls._user_href_for_user_names[user_name] = \ user_resource.get('href')
def update(self): logging.info("__INIT__update[User]") res = user_pb2.UpdateUserResult() res.updated = False context = self.context logged_in_org = self.client.get_org() org = Org(self.client, resource=logged_in_org) name = self.name is_enabled = self.is_enabled try: result = org.update_user(name, is_enabled) res.updated = True except Exception as e: error_message = '__ERROR_update[user] failed for user {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__update[User]") return res
def test_001_instantiate_vapp(self): logged_in_org = self.client.get_org() org = Org(self.client, resource=logged_in_org) v = org.get_vdc(self.config['vcd']['vdc']) vdc = VDC(self.client, href=v.get('href')) assert self.config['vcd']['vdc'] == vdc.get_resource().get('name') result = vdc.instantiate_vapp( self.config['vcd']['vapp'], self.config['vcd']['catalog'], self.config['vcd']['template'], network='net2', fence_mode='natRouted', deploy=False, power_on=False) task = self.client.get_task_monitor().wait_for_status( task=result.Tasks.Task[0], timeout=60, poll_frequency=2, fail_on_statuses=None, expected_target_statuses=[ TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR, TaskStatus.CANCELED ], callback=None) assert task.get('status') == TaskStatus.SUCCESS.value
def test_100_instantiate_vapp_identical(self): logged_in_org = self.client.get_org() org = Org(self.client, resource=logged_in_org) v = org.get_vdc(self.config['vcd']['vdc']) vdc = VDC(self.client, href=v.get('href')) assert self.config['vcd']['vdc'] == vdc.get_resource().get('name') result = vdc.instantiate_vapp( self.config['vcd']['vapp'], self.config['vcd']['catalog'], self.config['vcd']['template'], network=self.config['vcd']['network'], fence_mode='bridged', deploy=True, power_on=False, identical=True) task = self.client.get_task_monitor().wait_for_status( task=result.Tasks.Task[0], timeout=60, poll_frequency=2, fail_on_statuses=None, expected_target_statuses=[ TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR, TaskStatus.CANCELED ], callback=None) assert task.get('status') == TaskStatus.SUCCESS.value vdc.reload() vapp_resource = vdc.get_vapp(self.config['vcd']['vapp']) vm = vapp_resource.xpath( '//vcloud:VApp/vcloud:Children/vcloud:Vm', namespaces=NSMAP) assert len(vm) > 0 assert vm[0].get('name') == self.config['vcd']['vm']
def info(ctx, catalog_name, item_name): 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) if item_name is None: catalog = org.get_catalog(catalog_name) result = to_dict(catalog) # We don't have a way to know in advance if a user has access to a # catalog's ACL or not. So we try to retrieve it always. If the # call fails due to permission issues, we silently eat the # exception and exclude ACL settings from the output of the current # command. Users who have access to ACL of the catalog will remain # unaffected. Also any other errors/exceptions will bubble up as # usual. try: access_control_settings = access_settings_to_dict( org.get_catalog_access_settings(catalog_name)) result.update(access_control_settings) except AccessForbiddenException as e: pass else: catalog_item = org.get_catalog_item(catalog_name, item_name) result = to_dict(catalog_item) vapp = VApp(client, href=catalog_item.Entity.get('href')) vapp.reload() template = vapp_to_dict(vapp.resource) for k, v in template.items(): result['template-%s' % k] = v stdout(result, ctx) except Exception as e: stderr(e, ctx)
def Update(self, request, context): """ Update an organization. Expected request params: :param org_name: (string): name of organisation :param is_enabled: (bool): enable/disable the organization :return (bool): true/false based on the api execution success """ logging.info("__INIT_update_org_[org_plugin]") org_name = request.name is_enabled = request.is_enabled res = org_pb2.UpdateOrgResult() res.updated = False try: vref = VCDClientRef() client = vref.get_ref() org_resource = client.get_org_by_name(org_name) org = Org(client, resource=org_resource) org.update_org(is_enabled) logging.info("__DONE_update_org_[org_plugin]") res.updated = True return res except Exception as e: error_message = '__ERROR_update_org_[org_plugin] failed for org {0} '.format( org_name) logging.warn(error_message, e) context.set_code(grpc.StatusCode.INVALID_ARGUMENT) context.set_details(error_message) return res
def read(client, context, vapp_info): logging.debug('__INIT__vapp_read [ {0} ]'.format(vapp_info)) try: cresult = vapp_pb2.ReadVAppResult() logged_in_org = client.get_org() org = Org(client, resource=logged_in_org) v = org.get_vdc(vapp_info.vdc) vdc = VDC(client, href=v.get('href')) try: vapp = vdc.get_vapp(vapp_info.name) except Exception as e: logging.error("error occured in vapp", e) cresult.present = False return cresult logging.debug('vapp read [ %s ]', vapp) if vapp: nconfig_section = vapp.NetworkConfigSection nconfig = nconfig_section.findall( "{http://www.vmware.com/vcloud/v1.5}NetworkConfig") for i in range(0, len(nconfig)): print(nconfig[i].get('networkName')) cresult.network.append(nconfig[i].get('networkName')) cresult.name = vapp_info.name cresult.present = True else: cresult.present = False logging.debug('__LOG__ vapp not found [ {0} ] '.format(vapp_info)) logging.debug('__DONE__vapp_read [ {0} ][{1}] '.format( cresult, vapp_info)) return cresult except Exception as e: error_message = 'ERROR........ {0}'.format(e) context.set_code(grpc.StatusCode.INVALID_ARGUMENT) context.set_details(error_message)
def capture_vapp(client, context, capture_info): logging.debug("__INIT__capture_vapp [%s]", capture_info) vapp_name = capture_info.vapp_name vdc_name = capture_info.vdc_name catalog_name = capture_info.catalog_name item_name = capture_info.item_name desc = capture_info.description customize_on_instantiate = capture_info.customize_on_instantiate result = catalog_item_pb2.CaptureVAppResult() try: logged_in_org = client.get_org() org = Org(client, resource=logged_in_org) v = org.get_vdc(vdc_name) if v is None: raise errors.VDCNotFoundError(vappInfo.vdc) vdc = VDC(client, href=v.get('href')) vapp = vdc.get_vapp(vapp_name) logging.info(vapp.get('href')) catalog = org.get_catalog(catalog_name) org.capture_vapp(catalog_resource=catalog, vapp_href=vapp.get('href'), catalog_item_name=item_name, description=desc, customize_on_instantiate=customize_on_instantiate) result.captured = True logging.debug("__DONE__capture_vapp [%s] , [%s] , [%s] ", vapp_name, vdc_name, catalog_name) return result except Exception as e: error_message = 'ERROR.. capture vapp failed {0} {1} {2}'.format( vapp_name, vdc_name, catalog_name) logging.warn(error_message, e) context.set_code(grpc.StatusCode.INVALID_ARGUMENT) context.set_details(error_message)
def test_1003_reset_vapp(self): logged_in_org = self.client.get_org() org = Org(self.client, resource=logged_in_org) v = org.get_vdc(self.config['vcd']['vdc']) vdc = VDC(self.client, href=v.get('href')) assert self.config['vcd']['vdc'] == vdc.get_resource().get('name') 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) result = vapp.power_reset() # result = vapp.reboot() 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 power_off(client, target_vdc, target_vapp, target_vm_name): logging.info("__INIT__delete[VappVm]") powered_off = False org_resource = client.get_org() org = Org(client, resource=org_resource) try: vdc_resource = org.get_vdc(target_vdc) vdc = VDC(slef.client, name=target_vdc, resource=vdc_resource) vapp_resource = vdc.get_vapp(target_vapp) vapp = VApp(client, name=target_vapp, resource=vapp_resource) vapp_vm_resource = vapp.get_vm(target_vm_name) vm = VM(client, resource=vapp_vm_resource) vm.power_off() powered_off = True except Exception as e: error_message = '__ERROR_power_off[VappVm] failed for VappVm {0}. __ErrorMessage__ {1}'.format( target_vm_name, str(e)) logging.warn(error_message) return powered_off
def create(client, name, description): logging.debug("=== create catalog called === \n") try: logged_in_org = client.get_org() logging.info("loged in org ================ \n\n\n\n\n") org = Org(client, resource=logged_in_org) logging.info( "\n\n\n\n\n\n got ord ,,,, ================== \n\n\n") result = pyvcloudprovider_pb2.CreateCatalogResult() result.created = False try: catalog = org.create_catalog(name, description) result.created = True except Exception as e: logging.info("\n Not Created catalog [" + name + "]") return result except Exception as e: print(e) print("\n") logging.warn("error occured", e)
def remove(ctx, catalog_name, access_list, all): try: client = ctx.obj['client'] in_use_org_href = ctx.obj['profiles'].get('org_href') org = Org(client, in_use_org_href) if all: click.confirm( 'Do you want to remove all access settings from the catalog ' '\'%s\'' % catalog_name, abort=True) updated_acl = org.remove_catalog_access_settings( catalog_name=catalog_name, access_settings_list=acl_str_to_list_of_dict(access_list), remove_all=all) stdout( access_settings_to_list( updated_acl, ctx.obj['profiles'].get('org_in_use')), ctx, sort_headers=False) except Exception as e: stderr(e, ctx)
def download(ctx, catalog_name, item_name, file_name, progress, overwrite): try: restore_session(ctx) save_as_name = item_name if file_name is not None: save_as_name = file_name if not overwrite and os.path.isfile(save_as_name): raise Exception('File exists.') client = ctx.obj['client'] in_use_org_href = ctx.obj['profiles'].get('org_href') org = Org(client, in_use_org_href) cb = download_callback if progress else None bytes_written = org.download_catalog_item( catalog_name, item_name, save_as_name, callback=cb, task_callback=task_callback) result = {'file': save_as_name, 'size': bytes_written} stdout(result, ctx) except Exception as e: stderr(e, ctx)
def delete(client, vappInfo): logging.debug("===INIT delete vapp called === \n") try: logged_in_org = client.get_org() org = Org(client, resource=logged_in_org) v = org.get_vdc(vappInfo.vdc) vdc = VDC(client, href=v.get('href')) cresult = vapp_pb2.DeleteVAppResult() cresult.deleted = False try: logging.info(" calling delete_vapp............") result = vdc.delete_vapp(name=vappInfo.name, force=True) logging.info(" delete proceeding............") task = client.get_task_monitor().wait_for_status( task=result, timeout=60, poll_frequency=2, fail_on_statuses=None, expected_target_statuses=[ TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR, TaskStatus.CANCELED ], callback=task_callback) if task.get('status') == TaskStatus.SUCCESS.value: cresult.deleted = True except Exception as e: logging.exception("\n Not Deleted VApp [" + vappInfo.name + "]") return cresult except Exception as e: logging.exception("error occured create vapp ", e)
def info(ctx, catalog_name, item_name): try: client = ctx.obj['client'] in_use_org_href = ctx.obj['profiles'].get('org_href') org = Org(client, in_use_org_href) if item_name is None: catalog = org.get_catalog(catalog_name) result = to_dict(catalog) access_control_settings = access_settings_to_dict( org.get_catalog_access_settings(catalog_name)) result.update(access_control_settings) else: catalog_item = org.get_catalog_item(catalog_name, item_name) result = to_dict(catalog_item) vapp = VApp(client, href=catalog_item.Entity.get('href')) vapp.reload() template = vapp_to_dict(vapp.resource) for k, v in template.items(): result['template-%s' % k] = v stdout(result, ctx) except Exception as e: stderr(e, ctx)
def info(ctx, name): try: restore_session(ctx) client = ctx.obj['client'] in_use_org_name = ctx.obj['profiles'].get('org_in_use') in_use_vdc = ctx.obj['profiles'].get('vdc_in_use') org_href = ctx.obj['profiles'].get('org_href') org = Org(client, href=org_href) vdc_resource = org.get_vdc(name) vdc = VDC(client, resource=vdc_resource) access_settings = None try: access_settings = vdc.get_access_settings() except OperationNotSupportedException: pass result = vdc_to_dict(vdc_resource, access_settings_to_dict(access_settings)) result['in_use'] = in_use_vdc == name result['org'] = in_use_org_name stdout(result, ctx) except Exception as e: stderr(e, ctx)
def remove(ctx, vdc_name, access_list, all): try: restore_session(ctx) client = ctx.obj['client'] in_use_org_href = ctx.obj['profiles'].get('org_href') if all: click.confirm( 'Do you want to remove all access settings from the vdc ' '\'%s\'' % vdc_name, abort=True) org = Org(client, in_use_org_href) vdc_resource = org.get_vdc(vdc_name) vdc = VDC(client, resource=vdc_resource) vdc.remove_access_settings( access_settings_list=acl_str_to_list_of_dict(access_list), remove_all=all) stdout('Access settings removed from vdc \'%s\'.' % vdc_name, ctx) except Exception as e: stderr(e, ctx)
def test_0003_power_on(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) vm_resource = vapp.get_vm(self.config['vcd']['vm']) vm = VM(self.client, resource=vm_resource) task = vm.power_on() task = self.client.get_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) assert task.get('status') == TaskStatus.SUCCESS.value
def upload(ctx, catalog_name, file_name, item_name, progress): 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) cb = upload_callback if progress else None filename, file_extension = os.path.splitext(file_name) if file_extension == '.ova': bytes_written = org.upload_ovf(catalog_name, file_name, item_name, callback=cb) else: bytes_written = org.upload_media(catalog_name, file_name, item_name, callback=cb) result = {'file': file_name, 'size': bytes_written} stdout(result, ctx) except Exception as e: stderr(e, ctx)
def test_200_delete_all_disks(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) disks = vdc.get_disks() for disk in disks: result = vdc.delete_disk(disk_id=disk.get('id')) task = self.client.get_task_monitor().wait_for_status( task=result, timeout=30, poll_frequency=2, fail_on_status=None, expected_target_statuses=[ TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR, TaskStatus.CANCELED ], callback=None) assert task.get('status') == TaskStatus.SUCCESS.value
def test_011_update_vapp_network(self): logged_in_org = self.client.get_org() org = Org(self.client, resource=logged_in_org) v = org.get_vdc(self.config['vcd']['vdc']) vdc = VDC(self.client, href=v.get('href')) assert self.config['vcd']['vdc'] == vdc.get_resource().get('name') vapp = vdc.get_vapp(self.config['vcd']['vapp']) assert self.config['vcd']['vapp'] == vapp.get('name') result = vdc.reconfigure_vapp_network(self.config['vcd']['vapp'], 'net2', self.config['vcd']['fence_mode']) task = self.client.get_task_monitor().wait_for_status( task=result, timeout=60, poll_frequency=2, fail_on_status=None, expected_target_statuses=[ TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR, TaskStatus.CANCELED ], callback=None) assert task.get('status') == TaskStatus.SUCCESS.value
def read_and_return(self): response = dict() response_data = dict() vdc_resources = dict() copy_result = dict() vdc_resources = self.get_vdc_org_resource() self.vdc_resources = vdc_resources self.org = Org(self.client, resource=self.client.get_org()) platform = Platform(self.org.client) self.platform = platform vdc_name = self.vdc_org_name vdc_response = VDC(self.client, name=self.vdc, resource=(self.org.get_vdc(self.vdc))) result = vdc_response.list_edge_gateways() for ko in result: copy_result.update(ko) self.copy_result = copy_result #networks_result_xml = str() networks_result_xml = vdc_response.get_gateway(self.edge_input_to_get) response_data = vdc_response.list_edge_gateways() for m in response_data: edge_href = m['href'] self.edge_href = edge_href for e in result: del e['href'] #result_n_gateway = Gateway(self.edge_input_to_get,self.edge_href,resource=(self.org.get_vdc(self.vdc))) #response['networks_result_xml'] = networks_result_xml response['edge-gw-info'] = result_n_gateway response['edge-gw-href'] = edge_href response['edge-gw-copy'] = response_data response['edge-gw-name'] = self.edge_input_to_get response['edge-gw'] = result self.vdc_response = vdc_response # vdc_resource = self.org.get_vdc(self.org) # self.vdc = VDC(self.client, name=self.vdc, resource=vdc_resource) # vdc = self.vdc response['changed'] = True return response
def login(session_id=None): log_requests = True if config['log'] == True else False log_headers = True if config['log'] == True else False log_bodies = True if config['log'] == True else False client = Client(config['host'], api_version=config['api_version'], verify_ssl_certs=config['verify_ssl_certs'], log_file=config['log_file'], log_requests=log_requests, log_headers=log_headers, log_bodies=log_bodies) if not config['verify_ssl_certs']: requests.packages.urllib3.disable_warnings() try: if session_id is not None: client.rehydrate_from_token(session_id) else: client.set_credentials( BasicLoginCredentials(config['username'], config['org'], config['password'])) logged_in_org = client.get_org() org = Org(client, resource=logged_in_org) org_url = "https://%s/cloud/org/%s" % (config['host'], logged_in_org) the_vdc = org.get_vdc(config['vdc']) # Set contextual data: ctx.client = client ctx.vdc = VDC(client, href=the_vdc.get('href')) ctx.token = client._session.headers['x-vcloud-authorization'] except Exception as e: if config['debug'] == True: print("Exception: {}\n".format(e)) return False return True
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 test_010_create_disk(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) result = vdc.create_disk( name=self.config['vcd']['idisk_name'], size=self.config['vcd']['idisk_size'], description=self.config['vcd']['idisk_description']) task = self.client.get_task_monitor().wait_for_status( task=result.Tasks.Task[0], timeout=30, poll_frequency=2, fail_on_status=None, expected_target_statuses=[ TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR, TaskStatus.CANCELED ], callback=None) assert task.get('status') == TaskStatus.SUCCESS.value
def test_012_add_disk(self): logged_in_org = self.client.get_org() org = Org(self.client, resource=logged_in_org) v = org.get_vdc(self.config['vcd']['vdc']) vdc = VDC(self.client, href=v.get('href')) assert self.config['vcd']['vdc'] == vdc.get_resource().get('name') vapp_resource = vdc.get_vapp(self.config['vcd']['vapp']) assert self.config['vcd']['vapp'] == vapp_resource.get('name') vm_name = self.config['vcd']['vm'] vapp = VApp(self.client, resource=vapp_resource) disk_size = 1024 # 1GB result = vapp.add_disk_to_vm(vm_name, disk_size) task = self.client.get_task_monitor().wait_for_status( task=result, timeout=60, poll_frequency=2, fail_on_status=None, expected_target_statuses=[ TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR, TaskStatus.CANCELED ], callback=None) assert task.get('status') == TaskStatus.SUCCESS.value
class VcdResource(VcdAnsibleModule): def __init__(self, **kwargs): super(VcdResource, self).__init__(**kwargs) operation = self.params.get('operation') vdc = self.params.get('vdc') org_name = self.params.get('org_name') org = self.params.get('org') name = self.params.get('name') host = self.params.get('host') user = self.params.get('user') password = self.params.get('password') vdc_org_name = self.params.get('vdc_org_name') self.operation = operation self.vdc = vdc self.org_name = org_name self.org = org self.name = name self.host = host self.user = user self.password = password self.vdc_org_name = vdc_org_name def get_vdc_org_resource(self): if self.params.get(self.vdc_org_name): return self.client.get_org_by_name(self.params.get(self.vdc_org_name)) return self.client.get_org() def manage_operations(self): operation = self.params.get('operation') if operation == "read_and_return": return self.read_and_return() def read_and_return(self): response = dict() vdc_resources = dict() vdc_resources = self.get_vdc_org_resource() self.vdc_resources = vdc_resources self.org = Org(self.client, resource=self.client.get_org()) platform = "" #platform = Platform(self.org.client) self.platform = platform vddc_name = self.vdc_org_name vdc_response = VDC(self.client, name=self.vdc, resource=(self.org.get_vdc(self.vdc))) result = vdc_response.list_edge_gateways() response['edge-gw'] = result for e in result: del e['href'] self.vdc_response = vdc_response response['changed'] = True return response
def main(): argument_spec = vcd_fetch_vapps_argument_spec() response = dict(msg=dict(type='str'), vapps=[]) module = VcdAnsibleModule(argument_spec=argument_spec, supports_check_mode=True) try: vdc = module.params['vdc'] client = module.client org_resource = client.get_org() org = Org(client, resource=org_resource) vdc_resource = org.get_vdc(vdc) vdc = VDC(client, resource=vdc_resource) vapps = vdc.list_resources(EntityType.VAPP) for vapp in vapps: response['vapps'].append(vapp.get('name')) except Exception as error: response['msg'] = error.__str__() module.fail_json(**response) module.exit_json(**response)
def delete(self): logging.info("__INIT__delete[User]") res = user_pb2.DeleteUserResult() res.deleted = False context = self.context logged_in_org = self.client.get_org() org = Org(self.client, resource=logged_in_org) try: result = org.delete_user(self.name) res.deleted = True except Exception as e: res.deleted = False error_message = '__ERROR_delete[user] failed for user {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__delete[User]") return res
def get_org_name_of_ovdc(vdc_id): """Get org_name from vdc_id using OVDC_TO_ORG_MAP. Update OVDC_TO_ORG_MAP for new {org_name:vdc_id} pair :param vdc_id: unique ovdc id :return: org_name """ if vdc_id in OVDC_TO_ORG_MAP: org_name = OVDC_TO_ORG_MAP.get(vdc_id) else: client = get_vcd_sys_admin_client() vdc_href = f"{client._uri}/vdc/{vdc_id}" vdc_resource = client.get_resource(get_admin_href(vdc_href)) vdc_obj = VDC(client, resource=vdc_resource) link = find_link(vdc_obj.resource, RelationType.UP, EntityType.ADMIN_ORG.value) org = Org(client, href=link.href) '''Add the entry to the map to be used next time the \ same ovdc is requested''' OVDC_TO_ORG_MAP[vdc_id] = org.get_name() org_name = org.get_name() return org_name
def __init__(self, **kwargs): super(VdcNet, self).__init__(**kwargs) self.vdc_name = self.params.get('vdc_name') self.org_name = self.params.get('org_name') self.gateway_name = self.params.get('gateway_name') self.network_name = self.params.get('network_name') self.description = self.params.get('description') self.parent_network_name = self.params.get('parent_network_name') self.shared = self.params.get('shared') self.gateway_ip = self.params.get('gateway_ip') self.netmask = self.params.get('netmask') self.network_cidr = self.params.get('network_cidr') self.primary_dns_ip = self.params.get('primary_dns_ip') self.secondary_dns_ip = self.params.get('secondary_dns_ip') self.dns_suffix = self.params.get('dns_suffix') self.ip_range_start = self.params.get('ip_range_start') self.ip_range_end = self.params.get('ip_range_end') self.dhcp_enabled = self.params.get('dhcp_enabled') self.default_lease_time = self.params.get('default_lease_time') self.max_lease_time = self.params.get('max_lease_time') self.dhcp_ip_range_start = self.params.get('dhcp_ip_range_start') self.dhcp_ip_range_end = self.params.get('dhcp_ip_range_end') self.force = self.params.get('force') self.state = self.params.get('state') self.direct = self.params.get('direct') self.isolated = self.params.get('isolated') self.routed = self.params.get('routed') self.guest_vlan_allowed = self.params.get('guest_vlan_allowed') self.sub_interface = self.params.get('sub_interface') self.distributed_interface = self.params.get('distributed_interface') self.retain_net_info_across_deployments = self.params.get( 'retain_net_info_across_deployments') org_resource = self.client.get_org_by_name(self.org_name) self.org = Org(self.client, resource=org_resource) vdc_resource = self.org.get_vdc(self.vdc_name) self.vdc = VDC(self.client, name=self.vdc_name, resource=vdc_resource)
def delete_catalog_item(item_name): org = Org(CLIENT, href=ORG_HREF) try: org.delete_catalog_item(CATALOG_NAME, item_name) utils.wait_for_catalog_item_to_resolve(CLIENT, CATALOG_NAME, item_name, org=org) org.reload() except EntityNotFoundException: pass
def create_nodes_thread(self): LOGGER.debug('about to add nodes to cluster with name: %s', self.cluster_name) try: org_resource = self.client_tenant.get_org() org = Org(self.client_tenant, resource=org_resource) vdc = VDC(self.client_tenant, href=self.cluster['vdc_href']) vapp = VApp(self.client_tenant, href=self.cluster['vapp_href']) template = self.get_template() self.update_task( TaskStatus.RUNNING, message='Creating %s node(s) for %s(%s)' % (self.body['node_count'], self.cluster_name, self.cluster_id)) new_nodes = add_nodes(self.body['node_count'], template, self.body['node_type'], self.config, self.client_tenant, org, vdc, vapp, self.body) if self.body['node_type'] == TYPE_NFS: self.update_task(TaskStatus.SUCCESS, message='Created %s node(s) for %s(%s)' % (self.body['node_count'], self.cluster_name, self.cluster_id)) elif self.body['node_type'] == TYPE_NODE: self.update_task(TaskStatus.RUNNING, message='Adding %s node(s) to %s(%s)' % (self.body['node_count'], self.cluster_name, self.cluster_id)) target_nodes = [] for spec in new_nodes['specs']: target_nodes.append(spec['target_vm_name']) vapp.reload() join_cluster(self.config, vapp, template, target_nodes) self.update_task(TaskStatus.SUCCESS, message='Added %s node(s) to cluster %s(%s)' % (self.body['node_count'], self.cluster_name, self.cluster_id)) except NodeCreationError as e: error_obj = error_to_json(e) LOGGER.error(traceback.format_exc()) self.update_task( TaskStatus.ERROR, error_message=error_obj[ERROR_MESSAGE][ERROR_DESCRIPTION]) raise except Exception as e: error_obj = error_to_json(e) LOGGER.error(traceback.format_exc()) self.update_task( TaskStatus.ERROR, error_message=error_obj[ERROR_MESSAGE][ERROR_DESCRIPTION])
class EdgeInCatalogWhole(VcdAnsibleModule): def __init__(self, **kwargs): super(EdgeInCatalogWhole, self).__init__(**kwargs) self.host = self.params.get('host') self.host = self.params.get('host') self.user = self.params.get('user') self.password = self.params.get('password') self.api_version = self.params.get('api_version') self.vdc_name = self.params.get('vdc_name') self.org_name = self.params.get('org_name') self.edge_name = self.params.get('edge_name') logged_in_org = self.client.get_org_by_name(self.org_name) self.org = Org(self.client, resource=logged_in_org) #org_resource = self.client.get_org_by_name(self.org_name) #self.org = Org(self.client, resource=org_resource) vdc_resource = self.org.get_vdc(self.vdc_name) self.vdc = VDC(self.client, name=self.vdc_name, resource=vdc_resource) def manage_states(self): operation = self.params.get('operation') if operation == "read": return self.get_edge_information() def get_edge_information(self): operation = self.params.get('operation') if operation: return self.run_get_edge_information() raise ValueError("Operation type is must be read, now is missing") def run_get_edge_information(self): response = dict() response['changed'] = False edge_name = self.params.get('edge_name') description = self.params.get('description') try: self.vdc.get_direct_orgvdc_network(edge_name) except EntityNotFoundException: msg = 'EDGE INFO Cannot be found for {0} ' response['msg'] = error.__str__(msg) response['changed'] = True else: msg = 'EDGE INFO Network {0} is already present' response['warnings'] = msg.format(edge_name) return response
def test_008_update_disk_storage_profile(self): logged_in_org = self.client.get_org() org = Org(self.client, resource=logged_in_org) v = org.get_vdc(self.config['vcd']['vdc']) vdc = VDC(self.client, href=v.get('href')) taskObj = vdc.update_disk(self.config['vcd']['disk'], "3072", "DiskUpdated", "3 GB Disk", "*", "200") task = self.client.get_task_monitor().wait_for_status( task=taskObj, timeout=30, poll_frequency=2, fail_on_status=None, expected_target_statuses=[ TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR, TaskStatus.CANCELED ], callback=None) assert task.get('status') == TaskStatus.SUCCESS.value print(("Updating VDC disk: " + str(etree.tostring(task, pretty_print=True), "utf-8")))