def __init__(self, sysadmin_client: vcd_client.Client, log_wire=True): vcd_utils.raise_error_if_user_not_from_system_org(sysadmin_client) self._sysadmin_client: vcd_client.Client = sysadmin_client self._cloudapi_client = None self._session = self._sysadmin_client.get_vcloud_session() self._is_operation_supported = True try: wire_logger = logger.NULL_LOGGER if log_wire: wire_logger = logger.SERVER_CLOUDAPI_WIRE_LOGGER self._cloudapi_client = \ vcd_utils.get_cloudapi_client_from_vcd_client(self._sysadmin_client, # noqa: E501 logger.SERVER_LOGGER, # noqa: E501 wire_logger) self._cloudapi_version = \ cloudapi_constants.CloudApiVersion.VERSION_2_0_0 if float(self._cloudapi_client.get_api_version()) < \ GLOBAL_PVDC_COMPUTE_POLICY_MIN_VERSION: self._cloudapi_version = \ cloudapi_constants.CloudApiVersion.VERSION_1_0_0 # Since the /cloudapi endpoint was added before the compute policy # endpoint. Mere presence of the /cloudapi uri is not enough, we # need to make sure that this cloud api client will be of actual # use to us. self._cloudapi_client.do_request( method=RequestMethod.GET, cloudapi_version=self._cloudapi_version, resource_url_relative_path= f"{cloudapi_constants.CloudApiResource.VDC_COMPUTE_POLICIES}" ) # noqa: E501 except requests.exceptions.HTTPError as err: logger.SERVER_LOGGER.error(err) self._is_operation_supported = False
def cleanup_rde_artifacts(logger=NULL_LOGGER): """Cleanup all defined entity related artifacts. Deletes the following - - CSE interface - Native entity type """ try: rde_version_in_use = rde_utils.get_runtime_rde_version_by_vcd_api_version( CLIENT.get_api_version()) # noqa: E501 rde_metadata = rde_utils.get_rde_metadata(rde_version_in_use) cloudapi_client = pyvcloud_utils.get_cloudapi_client_from_vcd_client( client=CLIENT, logger_debug=logger, logger_wire=SERVER_CLOUDAPI_WIRE_LOGGER) schema_svc = def_schema_svc.DefSchemaService( cloudapi_client=cloudapi_client) # noqa: E501 if rde_constants.RDEMetadataKey.ENTITY_TYPE in rde_metadata: # delete entity_type entity_type: common_models.DefEntityType = \ rde_metadata[rde_constants.RDEMetadataKey.ENTITY_TYPE] schema_svc.delete_entity_type(entity_type.get_id()) logger.debug(f"Deleted entity type: {entity_type.name}") if rde_constants.RDEMetadataKey.INTERFACES in rde_metadata: # delete interface interfaces: List[common_models.DefInterface] = \ rde_metadata[rde_constants.RDEMetadataKey.INTERFACES] for i in interfaces: interface_id = i.get_id() if interface_id != common_models.K8Interface.VCD_INTERFACE.value.get_id( ): # noqa: E501 schema_svc.delete_interface(interface_id) logger.debug(f"Deleted interface: {i.name}") except Exception as e: logger.warning(f"Failed to clean up RDE artifacts: {e}")
def __init__(self, cluster_id: str, client: vcd_client.Client): self._client = client self._cloudapi_client = \ vcd_utils.get_cloudapi_client_from_vcd_client(client) self._cluster_id = cluster_id self._def_entity: Optional[common_models.DefEntity] = None self._vapp: Optional[vcd_vapp.VApp] = None
def __init__(self, entity_type_id: str, client: vcd_client.Client, logger_debug: logging.Logger = NULL_LOGGER, logger_wire: logging.Logger = NULL_LOGGER): self._client = client self._cloudapi_client = vcd_utils.get_cloudapi_client_from_vcd_client( client=client, logger_debug=logger_debug, logger_wire=logger_wire) self._entity_type_id = entity_type_id self._logger_debug = logger_debug self._logger_wire = logger_wire
def __init__(self, cluster_id: str, client: vcd_client.Client, logger_debug: logging.Logger = NULL_LOGGER, logger_wire: logging.Logger = NULL_LOGGER): self._client = client self._cloudapi_client = vcd_utils.get_cloudapi_client_from_vcd_client( client=client, logger_debug=logger_debug, logger_wire=logger_wire) self._cluster_id = cluster_id self._def_entity: Optional[common_models.DefEntity] = None self._vapp: Optional[vcd_vapp.VApp] = None
def __init__(self, sysadmin_client: vcd_client.Client, log_wire=False, logger_debug=NULL_LOGGER): vcd_utils.raise_error_if_user_not_from_system_org(sysadmin_client) self.logger_wire = SERVER_CLOUDAPI_WIRE_LOGGER \ if log_wire else NULL_LOGGER self.logger_debug = logger_debug self.cloudapi_client = vcd_utils.get_cloudapi_client_from_vcd_client( sysadmin_client, logger_debug=self.logger_debug, logger_wire=self.logger_wire)
def cloudapi_client(self): if self._cloudapi_client is None: log_wire = server_utils.get_server_runtime_config().get( 'service', {}).get('log_wire', False) # noqa: E501 logger_wire = logger.NULL_LOGGER if log_wire: logger_wire = logger.SERVER_CLOUDAPI_WIRE_LOGGER self._cloudapi_client = \ vcd_utils.get_cloudapi_client_from_vcd_client(self.client, logger.SERVER_LOGGER, # noqa: E501 logger_wire) return self._cloudapi_client
def __init__( self, sysadmin_client: vcd_client.Client, logger_debug=NULL_LOGGER, logger_wire=NULL_LOGGER ): vcd_utils.raise_error_if_user_not_from_system_org(sysadmin_client) self.cloudapi_client = vcd_utils.get_cloudapi_client_from_vcd_client( sysadmin_client, logger_debug=logger_debug, logger_wire=logger_wire )
def __init__(self, client): logger_wire = logger.NULL_LOGGER if os.getenv(cli_constants.ENV_CSE_CLIENT_WIRE_LOGGING): logger_wire = logger.CLIENT_WIRE_LOGGER self._cloudapi_client = \ vcd_utils.get_cloudapi_client_from_vcd_client( client=client, logger_debug=logger.CLIENT_LOGGER, logger_wire=logger_wire) self._native_cluster_api = NativeClusterApi(client) self._client = client self._server_rde_version = \ def_utils.get_runtime_rde_version_by_vcd_api_version( float(client.get_api_version()))
def __init__(self, client): logger_wire = logger.NULL_LOGGER if os.getenv(cli_constants.ENV_CSE_CLIENT_WIRE_LOGGING): logger_wire = logger.CLIENT_WIRE_LOGGER self._cloudapi_client = \ vcd_utils.get_cloudapi_client_from_vcd_client( client=client, logger_debug=logger.CLIENT_LOGGER, logger_wire=logger_wire) self._native_cluster_api = NativeClusterApi(client) self._client = client schema_service = def_schema_svc.DefSchemaService(self._cloudapi_client) self._server_rde_version = \ schema_service.get_latest_registered_schema_version()
def __init__(self, gateway: vcd_gateway.Gateway, client: vcd_client.Client): assert gateway.is_nsxt_backed() self._gateway = gateway self._client = client self._cloudapi_client = \ pyvcloud_utils.get_cloudapi_client_from_vcd_client(client) gateway_id = core_utils.extract_id_from_href(self._gateway.href) self._gateway_urn = f'{nsxt_constants.GATEWAY_URN_PREFIX}:' \ f'{gateway_id}' self._gateway_relative_path = \ f'{cloudapi_constants.CloudApiResource.EDGE_GATEWAYS}/' \ f'{self._gateway_urn}'
def _get_gateway( client: vcd_client.Client, org_name: str, network_name: str, ): config = server_utils.get_server_runtime_config() logger_wire = NULL_LOGGER if utils.str_to_bool(config.get_value_at('service.log_wire')): logger_wire = SERVER_CLOUDAPI_WIRE_LOGGER cloudapi_client = vcd_utils.get_cloudapi_client_from_vcd_client( client=client, logger_debug=LOGGER, logger_wire=logger_wire) gateway_name, gateway_href, gateway_exists = None, None, False page, page_count = 1, 1 base_path = f'{cloudapi_constants.CloudApiResource.ORG_VDC_NETWORKS}?filter=name=={network_name};_context==includeAccessible&pageSize=1&page=' # noqa: E501 while page <= page_count: response, headers = cloudapi_client.do_request( method=RequestMethod.GET, cloudapi_version=cloudapi_constants.CloudApiVersion.VERSION_1_0_0, resource_url_relative_path=base_path + f'{page}', return_response_headers=True) for entry in response['values']: # only routed networks allowed is_target_network = entry['orgRef']['name'] == org_name and \ entry['networkType'] == 'NAT_ROUTED' if is_target_network: if gateway_exists: raise MultipleRecordsException( f"Multiple routed networks named {network_name} found. CSE Server expects unique network names." ) # noqa: E501 gateway_exists = True gateway_name = entry['connection']['routerRef']['name'] gateway_id = entry['connection']['routerRef']['id'].split( ':').pop() # noqa: E501 gateway_href = headers['Content-Location'].split('cloudapi')[ 0] + f'api/admin/edgeGateway/{gateway_id}' # noqa: E501 page += 1 page_count = response['pageCount'] if not gateway_exists: raise EntityNotFoundException( f"No routed networks named {network_name} found.") # noqa: E501 gateway = vcd_gateway.Gateway(client, name=gateway_name, href=gateway_href) return gateway
def _update_user_context_map(self, api_version: Optional[str]): _client = vcd_utils.connect_vcd_user_via_token( tenant_auth_token=self._auth_token, is_jwt_token=self._is_jwt, api_version=api_version) log_wire = server_utils.get_server_runtime_config() \ .get('service', {}).get('log_wire', False) # noqa: E501 logger_wire = logger.NULL_LOGGER if log_wire: logger_wire = logger.SERVER_CLOUDAPI_WIRE_LOGGER _cloudapi_client = vcd_utils.get_cloudapi_client_from_vcd_client( _client, logger.SERVER_LOGGER, logger_wire) _user_context = user_context.UserContext( client=_client, cloud_api_client=_cloudapi_client) self._user_context_map[api_version] = _user_context
def __init__(self, client): logger_wire = logger.CLIENT_WIRE_LOGGER \ if core_utils.str_to_bool( os.getenv(cli_constants.ENV_CSE_CLIENT_WIRE_LOGGING) ) \ else logger.NULL_LOGGER self._client = client self._cloudapi_client = \ vcd_utils.get_cloudapi_client_from_vcd_client( client=client, logger_debug=logger.CLIENT_LOGGER, logger_wire=logger_wire ) self._nativeCluster = DEClusterNative(client) self._tkgCluster = DEClusterTKGS(client) schema_svc = def_schema_svc.DefSchemaService(self._cloudapi_client) self._server_rde_version = \ schema_svc.get_latest_registered_schema_version()
def _update_sysadmin_user_context_map(self, api_version: Optional[str]): _sysadmin_client = vcd_utils.get_sys_admin_client( api_version=api_version) log_wire = server_utils.get_server_runtime_config() \ .get('service', {}).get('log_wire', False) logger_wire = logger.NULL_LOGGER if log_wire: logger_wire = logger.SERVER_CLOUDAPI_WIRE_LOGGER _sysadmin_cloudapi_client = \ vcd_utils.get_cloudapi_client_from_vcd_client( _sysadmin_client, logger.SERVER_LOGGER, logger_wire) _sysadmin_user_context = user_context.UserContext( client=_sysadmin_client, cloud_api_client=_sysadmin_cloudapi_client) self._sysadmin_user_context_map[api_version] = _sysadmin_user_context
def rde_exists(rde_name, logger=NULL_LOGGER): try: cloudapi_client: CloudApiClient = \ pyvcloud_utils.get_cloudapi_client_from_vcd_client( CLIENT, logger_debug=logger, logger_wire=SERVER_CLOUDAPI_WIRE_LOGGER) # To avoid cyclic import from container_service_extension.rde.common.entity_service import \ DefEntityService entity_svc = DefEntityService(cloudapi_client) rde_version = rde_utils.get_runtime_rde_version_by_vcd_api_version( CLIENT.get_api_version()) entity = \ entity_svc.get_native_rde_by_name_and_rde_version( rde_name, rde_version) return bool(entity) except Exception as e: logger.warning(f"Exception occured when checking if rde exists: {e}") return False
def delete_rde(cluster_name, logger=NULL_LOGGER): """Delete defined entity with the given name. NOTE: RDE names are not unique. This function deletes all occurances """ try: cloudapi_client: CloudApiClient = \ pyvcloud_utils.get_cloudapi_client_from_vcd_client( CLIENT, logger_debug=logger, logger_wire=SERVER_CLOUDAPI_WIRE_LOGGER) # noqa: E501 from container_service_extension.rde.common.entity_service import DefEntityService # noqa: E501 entity_svc = DefEntityService(cloudapi_client) for cluster_rde in \ entity_svc.list_all_native_rde_by_name_and_rde_version( cluster_name, rde_utils.get_runtime_rde_version_by_vcd_api_version(CLIENT.get_api_version())): # noqa: E501 entity_svc.resolve_entity(cluster_rde.id, cluster_rde.entityType) entity_svc.delete_entity(cluster_rde.id) except cse_exceptions.DefEntityServiceError as e: PYTEST_LOGGER.error(f"Failed to delete RDE: {e}") pass
def __init__(self, sysadmin_client: vcd_client.Client, debug_logger=logger.SERVER_LOGGER, log_wire=True): # Ensure correct credentials and api version vcd_utils.raise_error_if_user_not_from_system_org(sysadmin_client) client_api_version = float(sysadmin_client.get_api_version()) if client_api_version < constants.MQTT_MIN_API_VERSION: raise ValueError(f'API version {client_api_version} ' f'is less than required version ' f'{constants.MQTT_MIN_API_VERSION} to use MQTT') self._sysadmin_client: vcd_client.Client = sysadmin_client wire_logger = logger.NULL_LOGGER if log_wire: wire_logger = logger.SERVER_CLOUDAPI_WIRE_LOGGER self._wire_logger = wire_logger self._debug_logger = debug_logger self._cloudapi_client = \ vcd_utils.get_cloudapi_client_from_vcd_client( self._sysadmin_client, self._debug_logger, self._wire_logger)
def _load_def_schema(self, msg_update_callback=utils.NullPrinter()): """Load cluster interface and cluster entity type to global context. If defined entity framework is supported by vCD api version, load defined entity interface and defined entity type registered during server install :param utils.NullMessagePrinter msg_update_callback: """ sysadmin_client = None try: sysadmin_client = vcd_utils.get_sys_admin_client(api_version=None) logger_wire = logger.NULL_LOGGER if utils.str_to_bool( utils.str_to_bool(self.config['service'].get( 'log_wire', False))): # noqa: E501 logger_wire = logger.SERVER_CLOUDAPI_WIRE_LOGGER cloudapi_client = \ vcd_utils.get_cloudapi_client_from_vcd_client(sysadmin_client, logger.SERVER_LOGGER, # noqa: E501 logger_wire) raise_error_if_def_not_supported(cloudapi_client) server_rde_version = server_utils.get_rde_version_in_use() msg_update_callback.general( f"Using RDE version: {server_rde_version}") # noqa: E501 schema_svc = def_schema_svc.DefSchemaService(cloudapi_client) def_metadata_dict: dict = def_utils.get_rde_metadata( server_rde_version) # noqa: E501 entity_type: common_models.DefEntityType = \ def_metadata_dict[def_constants.RDEMetadataKey.ENTITY_TYPE] # noqa: E501 interfaces: List[common_models.DefInterface] = \ def_metadata_dict[def_constants.RDEMetadataKey.INTERFACES] # noqa: E501 for interface in interfaces: # TODO change _kubernetesInterface to an array once additional # interface for CSE is added. self._kubernetesInterface = \ schema_svc.get_interface(interface.get_id()) self._nativeEntityType = \ schema_svc.get_entity_type(entity_type.get_id()) msg = f"Successfully loaded defined entity schema " \ f"{entity_type.get_id()} to global context" msg_update_callback.general(msg) logger.SERVER_LOGGER.debug(msg) except cse_exception.DefNotSupportedException: msg = "Skipping initialization of defined entity type" \ " and defined entity interface" msg_update_callback.info(msg) logger.SERVER_LOGGER.debug(msg) except cse_exception.DefSchemaServiceError as e: msg = f"Error while loading defined entity schema: {e.error_message}" # noqa: E501 msg_update_callback.error(msg) logger.SERVER_LOGGER.debug(msg) raise except Exception as e: msg = f"Failed to load defined entity schema to global context: {str(e)}" # noqa: E501 msg_update_callback.error(msg) logger.SERVER_LOGGER.error(msg) raise finally: if sysadmin_client: sysadmin_client.logout()