def get(cls, name: str, subcategory: str = None) -> "ResourceCategory": # pylint: disable=arguments-differ """Get resource category with given name. It returns resource category with all subcategories by default. You can get resource category with only one subcategory if you provide it's name as `subcategory` parameter. Args: name (str): Resource category name. subcategory (str, optional): Name of subcategory. Defaults to None. Raises: ResourceNotFound: Subcategory with given name does not exist Returns: BaseCategory: BaseCategory instance """ category_obj: "ResourceCategory" = super().get(name=name) if not subcategory: return category_obj filtered_subcategories: Dict[str, str] = list( filter(lambda x: x["name"] == subcategory, category_obj.subcategories)) if not filtered_subcategories: raise ResourceNotFound( f"Subcategory {subcategory} does not exist.") category_obj.subcategories = filtered_subcategories return category_obj
def create_from_request_response(cls, request_response: dict) -> "VnfInstantiation": """Create VNF instantiation object based on request details. Raises: ResourceNotFound: Service related with given object doesn't exist ResourceNotFound: No ServiceInstantiation related with given VNF instantiation ResourceNotFound: VNF related with given object doesn't exist InvalidResponse: Invalid dictionary - couldn't create VnfInstantiation object Returns: VnfInstantiation: VnfInstantiation object """ if request_response.get("request", {}).get("requestScope") == "vnf" and \ request_response.get("request", {}).get("requestType") == "createInstance": service: SdcService = None for related_instance in request_response.get("request", {}).get("requestDetails", {})\ .get("relatedInstanceList", []): if related_instance.get("relatedInstance", {}).get("modelInfo", {})\ .get("modelType") == "service": service = SdcService(related_instance.get("relatedInstance", {})\ .get("modelInfo", {}).get("modelName")) if not service: raise ResourceNotFound("No related service in Vnf instance details response") vnf: Vnf = None for service_vnf in service.vnfs: if service_vnf.name == request_response.get("request", {})\ .get("requestDetails", {}).get("modelInfo", {}).get("modelCustomizationName"): vnf = service_vnf if not vnf: raise ResourceNotFound("No vnf in service vnfs list") return cls( name=request_response.get("request", {})\ .get("instanceReferences", {}).get("vnfInstanceName"), request_id=request_response.get("request", {}).get("requestId"), instance_id=request_response.get("request", {})\ .get("instanceReferences", {}).get("vnfInstanceId"), line_of_business=request_response.get("request", {})\ .get("requestDetails", {}).get("lineOfBusiness", {}).get("lineOfBusinessName"), platform=request_response.get("request", {})\ .get("requestDetails", {}).get("platform", {}).get("platformName"), vnf=vnf ) raise InvalidResponse("Invalid vnf instantions in response dictionary's requestList")
def get_by_unique_uuid(cls, unique_uuid: str) -> "Service": """Get the service model using unique uuid. Returns: Service: object with provided unique_uuid Raises: ResourceNotFound: No service with given unique_uuid exists """ services: List["Service"] = cls.get_all() for service in services: if service.unique_uuid == unique_uuid: return service raise ResourceNotFound("Service with given unique uuid doesn't exist")
def get(cls, name: str) -> "BaseCategory": """Get category with given name. Raises: ResourceNotFound: Category with given name does not exist Returns: BaseCategory: BaseCategory instance """ category_obj: "BaseCategory" = cls(name) if category_obj.exists(): return category_obj msg = f"{cls.category_name()} with \"{name}\" name does not exist." raise ResourceNotFound(msg)
def vf_module(self) -> "VfModule": """Vf module associated with that vf module instance. Returns: VfModule: VfModule object associated with vf module instance """ if not self._vf_module: for vf_module in self.vnf_instance.vnf.vf_modules: if vf_module.model_version_id == self.model_version_id: self._vf_module = vf_module return self._vf_module msg = (f'Could not find VF modules for the VF Module instance' f' with model version ID "{self.model_version_id}"') raise ResourceNotFound(msg) return self._vf_module
def get_input(self, input_name: str) -> Input: """Get input by it's name. Args: input_name (str): Input name Raises: ResourceNotFound: Resource doesn't have input with given name Returns: Input: Found input object """ for input_obj in self.inputs: if input_obj.name == input_name: return input_obj raise ResourceNotFound(f"SDC resource has no {input_name} input")
def get_by_owning_entity_name(cls, owning_entity_name: str) -> "OwningEntity": """Get owning entity resource by it's name. Raises: ResourceNotFound: Owning entity requested by a name does not exist. Returns: OwningEntity: Owning entity requested by a name. """ for owning_entity in cls.get_all(): if owning_entity.name == owning_entity_name: return owning_entity msg = f'Owning entity "{owning_entity_name}" does not exist.' raise ResourceNotFound(msg)
def __init__(self, name: str, version: str = None, sdc_values: Dict[str, str] = None): """Initialize Vl object. Vl has to exists in SDC. Args: name (str): Vl name version (str): Vl version sdc_values (Dict[str, str], optional): Sdc values of existing Vl. Defaults to None. Raises: ResourceNotFound: Vl doesn't exist in SDC """ super().__init__(name=name, version=version, sdc_values=sdc_values) if not sdc_values and not self.exists(): raise ResourceNotFound( "This Vl has to exist prior to object initialization.")
def get_by_name_and_version(cls, blueprint_name: str, blueprint_version: str) -> "BlueprintModel": """Retrieve blueprint model with provided name and version. Args: blueprint_name (str): Blueprint model name blueprint_version (str): Blueprint model version Returns: BlueprintModel: Blueprint model object Raises: ResourceNotFound: Blueprint model with provided name and version doesn't exist """ try: blueprint_model = cls.send_message_json( "GET", "Retrieve blueprint", f"{cls._url}/api/v1/blueprint-model/by-name/{blueprint_name}" f"/version/{blueprint_version}", auth=cls.auth) return cls( blueprint_model_id=blueprint_model["blueprintModel"]['id'], artifact_uuid=blueprint_model["blueprintModel"] ['artifactUUId'], artifact_type=blueprint_model["blueprintModel"] ['artifactType'], artifact_version=blueprint_model["blueprintModel"] ['artifactVersion'], internal_version=blueprint_model["blueprintModel"] ['internalVersion'], created_date=blueprint_model["blueprintModel"]['createdDate'], artifact_name=blueprint_model["blueprintModel"] ['artifactName'], published=blueprint_model["blueprintModel"]['published'], updated_by=blueprint_model["blueprintModel"]['updatedBy'], tags=blueprint_model["blueprintModel"]['tags']) except ResourceNotFound: raise ResourceNotFound( f"BlueprintModel blueprint_name='{blueprint_name}" f" and blueprint_version='{blueprint_version}' not found")
def get_property(self, property_name: str) -> Property: """Get resource property by it's name. Args: property_name (str): property name Raises: ResourceNotFound: Resource has no property with given name Returns: Property: Resource's property object """ for property_obj in self.properties: if property_obj.name == property_name: return property_obj msg = f"Resource has no property with {property_name} name" raise ResourceNotFound(msg)
def vnf(self) -> "Vnf": """Vnf associated with that vnf instance. Raises: ResourceNotFound: Could not find VNF for that VNF instance Returns: Vnf: Vnf object associated with vnf instance """ if not self._vnf: for vnf in self.service_instance.sdc_service.vnfs: if vnf.model_version_id == self.model_version_id: self._vnf = vnf return self._vnf msg = (f'Could not find VNF for the VNF instance' f' with model version ID "{self.model_version_id}"') raise ResourceNotFound(msg) return self._vnf
def pnf(self) -> "Pnf": """Pnf associated with that pnf instance. Raises: ResourceNotFound: Could not find PNF for that PNF instance Returns: Pnf: Pnf object associated with Pnf instance """ if not self._pnf: for pnf in self.service_instance.sdc_service.pnfs: if pnf.model_version_id == self.model_version_id: self._pnf = pnf return self._pnf msg = (f'Could not find PNF for the PNF instance' f' with model version ID "{self.model_version_id}"') raise ResourceNotFound(msg) return self._pnf
def get_component_by_name(self, component_name: str) -> Component: """Get resource's component by it's name. Get component by name. Args: component_name (str): Component's name Raises: ResourceNotFound: Component with given name does not exist Returns: Component: Component object """ for component in self.components: if component.sdc_resource.name == component_name: return component msg = f"SDC resource {component_name} is not a component" raise ResourceNotFound(msg)
def get_component(self, sdc_resource: "SdcResource") -> Component: """Get resource's component. Get component by SdcResource object. Args: sdc_resource (SdcResource): Component's SdcResource Raises: ResourceNotFound: Component with given SdcResource does not exist Returns: Component: Component object """ for component in self.components: if component.sdc_resource.name == sdc_resource.name: return component msg = f"SDC resource {sdc_resource.name} is not a component" raise ResourceNotFound(msg)
def check_loop_template(cls, service: Service) -> str: """ Return loop template name if exists. Args: service (Service): the distributed sdc service with tca blueprint artifact Raises: ResourceNotFound: Template not found. Returns: if required template exists in CLAMP or not """ url = f"{cls.base_url()}/templates/" for template in cls.send_message_json('GET', 'Get Loop Templates', url): if template["modelService"]["serviceDetails"]["name"] == service.name: return template["name"] raise ResourceNotFound("Template not found.")
def get_by_id(cls, cloud_owner: str, cloud_region_id: str) -> "CloudRegion": """Get CloudRegion object by cloud_owner and cloud-region-id field value. This method calls A&AI cloud region API filtering them by cloud_owner and cloud-region-id field value. Raises: ResourceNotFound: Cloud region with given id does not exist. Returns: CloudRegion: CloudRegion object with given cloud-region-id. """ try: return next(cls.get_all(cloud_owner=cloud_owner, cloud_region_id=cloud_region_id)) except StopIteration: msg = ( f'CloudRegion with {cloud_owner}, ' f'{cloud_region_id} cloud-id not found. ' ) raise ResourceNotFound(msg)
def get_nf_unique_id(self, nf_name: str) -> str: """ Get nf (network function) uniqueID. Get nf uniqueID from service nf in sdc. Args: nf_name (str): the nf from which we extract the unique ID Returns: the nf unique ID Raises: ResourceNotFound: Couldn't find NF by name. """ url = f"{self._base_create_url()}/services/{self.unique_identifier}" request_return = self.send_message_json('GET', 'Get nf unique ID', url) for instance in filter(lambda x: x["componentName"] == nf_name, request_return["componentInstances"]): return instance["uniqueId"] raise ResourceNotFound(f"NF '{nf_name}'")
def send_message( cls, method: str, action: str, url: str, # pylint: disable=too-many-locals **kwargs ) -> Union[requests.Response, None]: """ Send a message to an ONAP service. Args: method (str): which method to use (GET, POST, PUT, PATCH, ...) action (str): what action are we doing, used in logs strings. url (str): the url to use exception (Exception, optional): if an error occurs, raise the exception given instead of RequestError **kwargs: Arbitrary keyword arguments. any arguments used by requests can be used here. Raises: RequestError: if other exceptions weren't caught or didn't raise, or if there was an ambiguous exception by a request ResourceNotFound: 404 returned APIError: returned an error code within 400 and 599, except 404 ConnectionFailed: connection can't be established Returns: the request response if OK """ cert = kwargs.pop('cert', None) basic_auth: Dict[str, str] = kwargs.pop('basic_auth', None) exception = kwargs.pop('exception', None) headers = kwargs.pop('headers', cls.headers).copy() if OnapService.permanent_headers: for header in OnapService.permanent_headers: headers.update(header) data = kwargs.get('data', None) try: # build the request with the requested method session = cls.__requests_retry_session() if cert: session.cert = cert OnapService._set_basic_auth_if_needed(basic_auth, session) cls._logger.debug("[%s][%s] sent header: %s", cls.server, action, headers) cls._logger.debug("[%s][%s] url used: %s", cls.server, action, url) cls._logger.debug("[%s][%s] data sent: %s", cls.server, action, data) response = session.request(method, url, headers=headers, verify=False, proxies=cls.proxy, **kwargs) cls._logger.info( "[%s][%s] response code: %s", cls.server, action, response.status_code if response is not None else "n/a") cls._logger.debug( "[%s][%s] response: %s", cls.server, action, response.text if (response is not None and response.headers.get("Content-Type", "") == \ "application/json") else "n/a") response.raise_for_status() return response except HTTPError as cause: cls._logger.error("[%s][%s] API returned and error: %s", cls.server, action, headers) msg = f'Code: {cause.response.status_code}. Info: {cause.response.text}.' if cause.response.status_code == 404: exc = ResourceNotFound(msg) else: exc = APIError(msg) raise exc from cause except ConnectionError as cause: cls._logger.error("[%s][%s] Failed to connect: %s", cls.server, action, cause) msg = f"Can't connect to {url}." raise ConnectionFailed(msg) from cause except RequestException as cause: cls._logger.error("[%s][%s] Request failed: %s", cls.server, action, cause) if not exception: msg = f"Ambiguous error while requesting {url}." raise RequestError(msg) raise exception