catalog/packages/biz/service_descriptor.py

   1 # Copyright (c) 2019, CMCC Technologies. Co., Ltd.
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #         http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 import json
  16 import logging
  17 import os
  18 import uuid
  19
  20 from catalog.packages.const import PKG_STATUS
  21 from catalog.pub.config.config import CATALOG_ROOT_PATH
  22 from catalog.pub.database.models import ServicePackageModel, VnfPackageModel, PnfPackageModel
  23 from catalog.pub.exceptions import CatalogException, PackageNotFoundException
  24 from catalog.pub.utils import toscaparser, fileutil
  25 from catalog.pub.utils.values import ignore_case_get
  26
  27 logger = logging.getLogger(__name__)
  28
  29
  30 class ServiceDescriptor(object):
  31     """
  32     Action for Service Descriptor
  33     """
  34
  35     def __init__(self):
  36         pass
  37
  38     def create(self, data, csar_id=None):
  39         """
  40         Create a Service package
  41         :param data:
  42         :param csar_id:
  43         :return:
  44         """
  45         logger.info('Start to create a ServiceD...')
  46         user_defined_data = ignore_case_get(data, 'userDefinedData', {})
  47         data = {
  48             'id': csar_id if csar_id else str(uuid.uuid4()),
  49             'servicedOnboardingState': PKG_STATUS.CREATED,
  50             'servicedOperationalState': PKG_STATUS.DISABLED,
  51             'servicedUsageState': PKG_STATUS.NOT_IN_USE,
  52             'userDefinedData': user_defined_data,
  53             '_links': None  # TODO
  54         }
  55         ServicePackageModel.objects.create(
  56             servicePackageId=data['id'],
  57             onboardingState=data['servicedOnboardingState'],
  58             operationalState=data['servicedOperationalState'],
  59             usageState=data['servicedUsageState'],
  60             userDefinedData=json.dumps(user_defined_data)
  61         )
  62         logger.info('A ServiceD(%s) has been created.' % data['id'])
  63         return data
  64
  65     def parse_serviced_and_save(self, serviced_info_id, local_file_name):
  66         """
  67         Parse service package and save information to DB
  68         :param serviced_info_id:
  69         :param local_file_name:
  70         :return:
  71         """
  72         logger.info('Start to process ServiceD(%s)...' % serviced_info_id)
  73         service_pkgs = ServicePackageModel.objects.filter(servicePackageId=serviced_info_id)
  74         service_pkgs.update(onboardingState=PKG_STATUS.PROCESSING)
  75
  76         serviced_json = toscaparser.parse_sd(local_file_name)
  77         serviced = json.JSONDecoder().decode(serviced_json)
  78
  79         serviced_id = serviced.get("service", {}).get("properties", {}).get("descriptor_id", "")
  80         serviced_name = serviced.get("service", {}).get("properties", {}).get("name", "")
  81         serviced_version = serviced.get("service", {}).get("properties", {}).get("version", "")
  82         serviced_designer = serviced.get("service", {}).get("properties", {}).get("designer", "")
  83         invariant_id = serviced.get("service", {}).get("properties", {}).get("invariant_id", "")
  84         if serviced_id == "":
  85             raise CatalogException("serviced_id(%s) does not exist in metadata." % serviced_id)
  86         other_nspkg = ServicePackageModel.objects.filter(servicedId=serviced_id)
  87         if other_nspkg and other_nspkg[0].servicePackageId != serviced_info_id:
  88             logger.warn("ServiceD(%s,%s) already exists.", serviced_id, other_nspkg[0].servicePackageId)
  89             raise CatalogException("ServiceD(%s) already exists." % serviced_id)
  90
  91         for vnf in serviced["vnfs"]:
  92             vnfd_id = vnf["properties"].get("descriptor_id", "undefined")
  93             if vnfd_id == "undefined":
  94                 vnfd_id = vnf["properties"].get("id", "undefined")
  95             pkg = VnfPackageModel.objects.filter(vnfdId=vnfd_id)
  96             if not pkg:
  97                 pkg = VnfPackageModel.objects.filter(vnfPackageId=vnfd_id)
  98             if not pkg:
  99                 vnfd_name = vnf.get("vnf_id", "undefined")
 100                 logger.error("[%s] is not distributed.", vnfd_name)
 101                 raise CatalogException("VNF package(%s) is not distributed." % vnfd_id)
 102
 103         for pnf in serviced["pnfs"]:
 104             pnfd_id = pnf["properties"].get("descriptor_id", "undefined")
 105             if pnfd_id == "undefined":
 106                 pnfd_id = pnf["properties"].get("id", "undefined")
 107             pkg = PnfPackageModel.objects.filter(pnfdId=pnfd_id)
 108             if not pkg:
 109                 pkg = PnfPackageModel.objects.filter(pnfPackageId=pnfd_id)
 110             if not pkg:
 111                 pnfd_name = pnf.get("pnf_id", "undefined")
 112                 logger.error("[%s] is not distributed.", pnfd_name)
 113                 raise CatalogException("PNF package(%s) is not distributed." % pnfd_name)
 114
 115         service_pkgs.update(
 116             servicedId=serviced_id,
 117             servicedName=serviced_name,
 118             servicedDesigner=serviced_designer,
 119             servicedDescription=serviced.get("description", ""),
 120             servicedVersion=serviced_version,
 121             invariantId=invariant_id,
 122             onboardingState=PKG_STATUS.ONBOARDED,
 123             operationalState=PKG_STATUS.ENABLED,
 124             usageState=PKG_STATUS.NOT_IN_USE,
 125             servicePackageUri=local_file_name,
 126             sdcCsarId=serviced_info_id,
 127             localFilePath=local_file_name,
 128             servicedModel=serviced_json
 129         )
 130         logger.info('ServiceD(%s) has been processed.' % serviced_info_id)
 131
 132     def delete_single(self, serviced_info_id):
 133         """
 134         Delete a service package by given id
 135         :param serviced_info_id:
 136         :return:
 137         """
 138         logger.info('Start to delete ServiceD(%s)...' % serviced_info_id)
 139         service_pkgs = ServicePackageModel.objects.filter(servicePackageId=serviced_info_id)
 140         if not service_pkgs.exists():
 141             logger.warn('ServiceD(%s) not found.' % serviced_info_id)
 142             raise PackageNotFoundException("Service package[%s] not Found." % serviced_info_id)
 143         service_pkgs.delete()
 144
 145         # Delete package dir
 146         service_pkg_path = os.path.join(CATALOG_ROOT_PATH, serviced_info_id)
 147         fileutil.delete_dirs(service_pkg_path)
 148         logger.info('ServiceD(%s) has been deleted.' % serviced_info_id)