catalog/packages/biz/ns_descriptor.py

   1 # Copyright 2018 ZTE Corporation.
   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
  16 import json
  17 import logging
  18 import os
  19 import uuid
  20
  21 from catalog.packages.biz.common import parse_file_range, read, save
  22 from catalog.packages.const import PKG_STATUS
  23 from catalog.pub.config.config import CATALOG_ROOT_PATH
  24 from catalog.pub.database.models import NSPackageModel, PnfPackageModel, VnfPackageModel
  25 from catalog.pub.exceptions import CatalogException, ResourceNotFoundException
  26 from catalog.pub.utils import fileutil, toscaparser
  27 from catalog.pub.utils.values import ignore_case_get
  28 from catalog.packages.biz.notificationsutil import NsdNotifications
  29 from catalog.packages import const
  30
  31 logger = logging.getLogger(__name__)
  32
  33 METADATA = "metadata"
  34
  35
  36 class NsDescriptor(object):
  37     """
  38     NS Package
  39     """
  40
  41     def __init__(self):
  42         pass
  43
  44     def create(self, data, id=None):
  45         """
  46         Create NS package
  47         :param data:
  48         :param id:
  49         :return:
  50         """
  51         logger.info('Start to create a NSD...')
  52         user_defined_data = ignore_case_get(data, 'userDefinedData', {})
  53         data = {
  54             'id': id if id else str(uuid.uuid4()),
  55             'nsdOnboardingState': const.PKG_STATUS.CREATED,
  56             'nsdOperationalState': const.PKG_STATUS.DISABLED,
  57             'nsdUsageState': const.PKG_STATUS.NOT_IN_USE,
  58             'userDefinedData': user_defined_data,
  59             '_links': None  # TODO
  60         }
  61         NSPackageModel.objects.create(
  62             nsPackageId=data['id'],
  63             onboardingState=data['nsdOnboardingState'],
  64             operationalState=data['nsdOperationalState'],
  65             usageState=data['nsdUsageState'],
  66             userDefinedData=json.dumps(user_defined_data)
  67         )
  68         logger.info('A NSD(%s) has been created.' % data['id'])
  69         return data
  70
  71     def update(self, data, nsd_info_id):
  72         """
  73         Update NS package
  74         :param data:
  75         :param nsd_info_id:
  76         :return:
  77         """
  78         usageState = PKG_STATUS.IN_USE if data["usageState"] else PKG_STATUS.NOT_IN_USE
  79         NSPackageModel.objects.filter(nsPackageId=nsd_info_id).update(usageState=usageState)
  80
  81     def query_multiple(self, nsdId=None):
  82         """
  83         Query NS package list
  84         :param nsdId:
  85         :return:
  86         """
  87         if nsdId:
  88             ns_pkgs = NSPackageModel.objects.filter(nsdId=nsdId)
  89         else:
  90             ns_pkgs = NSPackageModel.objects.all()
  91         response_data = []
  92         for ns_pkg in ns_pkgs:
  93             data = self.fill_resp_data(ns_pkg)
  94             response_data.append(data)
  95         return response_data
  96
  97     def query_single(self, nsd_info_id):
  98         """
  99         Query NS package by id
 100         :param nsd_info_id:
 101         :return:
 102         """
 103         ns_pkgs = NSPackageModel.objects.filter(nsPackageId=nsd_info_id)
 104         if not ns_pkgs.exists():
 105             logger.error('NSD(%s) does not exist.' % nsd_info_id)
 106             raise ResourceNotFoundException('NSD(%s) does not exist.' % nsd_info_id)
 107         return self.fill_resp_data(ns_pkgs[0])
 108
 109     def delete_single(self, nsd_info_id):
 110         """
 111         Delete NSD package by id
 112         :param nsd_info_id:
 113         :return:
 114         """
 115         logger.info('Start to delete NSD(%s)...' % nsd_info_id)
 116         ns_pkgs = NSPackageModel.objects.filter(nsPackageId=nsd_info_id)
 117         if not ns_pkgs.exists():
 118             logger.info('NSD(%s) has been deleted.' % nsd_info_id)
 119             return
 120         '''
 121         if ns_pkgs[0].operationalState != PKG_STATUS.DISABLED:
 122             logger.error('NSD(%s) shall be DISABLED.' % nsd_info_id)
 123             raise CatalogException('NSD(%s) shall be DISABLED.' % nsd_info_id)
 124         if ns_pkgs[0].usageState != PKG_STATUS.NOT_IN_USE:
 125             logger.error('NSD(%s) shall be NOT_IN_USE.' % nsd_info_id)
 126             raise CatalogException('NSD(%s) shall be NOT_IN_USE.' % nsd_info_id)
 127         '''
 128         ns_pkgs.delete()
 129         ns_pkg_path = os.path.join(CATALOG_ROOT_PATH, nsd_info_id)
 130         fileutil.delete_dirs(ns_pkg_path)
 131         send_notification(const.NSD_NOTIFICATION_TYPE.NSD_DELETION, nsd_info_id)
 132         logger.info('NSD(%s) has been deleted.' % nsd_info_id)
 133
 134     def upload(self, nsd_info_id, remote_file):
 135         """
 136         Upload NS package file
 137         :param nsd_info_id:
 138         :param remote_file:
 139         :return:
 140         """
 141         logger.info('Start to upload NSD(%s)...' % nsd_info_id)
 142         ns_pkgs = NSPackageModel.objects.filter(nsPackageId=nsd_info_id)
 143         if not ns_pkgs.exists():
 144             logger.error('NSD(%s) does not exist.' % nsd_info_id)
 145             raise CatalogException('NSD(%s) does not exist.' % nsd_info_id)
 146         ns_pkgs.update(onboardingState=const.PKG_STATUS.UPLOADING)
 147
 148         local_file_name = save(remote_file, nsd_info_id)
 149         logger.info('NSD(%s) content has been uploaded.' % nsd_info_id)
 150         return local_file_name
 151
 152     def download(self, nsd_info_id, file_range):
 153         """
 154         Download NS package file
 155         :param nsd_info_id:
 156         :param file_range:
 157         :return:
 158         """
 159         logger.info('Start to download NSD(%s)...' % nsd_info_id)
 160         ns_pkgs = NSPackageModel.objects.filter(nsPackageId=nsd_info_id)
 161         if not ns_pkgs.exists():
 162             logger.error('NSD(%s) does not exist.' % nsd_info_id)
 163             raise ResourceNotFoundException('NSD(%s) does not exist.' % nsd_info_id)
 164         if ns_pkgs[0].onboardingState != const.PKG_STATUS.ONBOARDED:
 165             logger.error('NSD(%s) is not ONBOARDED.' % nsd_info_id)
 166             raise CatalogException('NSD(%s) is not ONBOARDED.' % nsd_info_id)
 167
 168         local_file_path = ns_pkgs[0].localFilePath
 169         start, end = parse_file_range(local_file_path, file_range)
 170         logger.info('NSD(%s) has been downloaded.' % nsd_info_id)
 171         return read(local_file_path, start, end)
 172
 173     def parse_nsd_and_save(self, nsd_info_id, local_file_name):
 174         """
 175         Parse NSD and save the information
 176         :param nsd_info_id:
 177         :param local_file_name:
 178         :return:
 179         """
 180         logger.info('Start to process NSD(%s)...' % nsd_info_id)
 181         ns_pkgs = NSPackageModel.objects.filter(nsPackageId=nsd_info_id)
 182         ns_pkgs.update(onboardingState=const.PKG_STATUS.PROCESSING)
 183
 184         nsd_json = toscaparser.parse_nsd(local_file_name)
 185         logger.debug("%s", nsd_json)
 186         nsd = json.JSONDecoder().decode(nsd_json)
 187
 188         nsd_id = nsd.get("ns", {}).get("properties", {}).get("descriptor_id", "")
 189         nsd_name = nsd.get("ns", {}).get("properties", {}).get("name", "")
 190         nsd_version = nsd.get("ns", {}).get("properties", {}).get("version", "")
 191         nsd_designer = nsd.get("ns", {}).get("properties", {}).get("designer", "")
 192         invariant_id = nsd.get("ns", {}).get("properties", {}).get("invariant_id", "")
 193         if nsd_id == "":
 194             raise CatalogException("nsd_id(%s) does not exist in metadata." % nsd_id)
 195         other_nspkg = NSPackageModel.objects.filter(nsdId=nsd_id)
 196         if other_nspkg and other_nspkg[0].nsPackageId != nsd_info_id:
 197             failure_details = "NSD(%s,%s) already exists.", nsd_id, other_nspkg[0].nsPackageId
 198             logger.warn(failure_details)
 199             send_notification(const.NSD_NOTIFICATION_TYPE.NSD_ONBOARDING_FAILURE, nsd_info_id, nsd_id,
 200                               failure_details=failure_details)
 201             raise CatalogException("NSD(%s) already exists." % nsd_id)
 202
 203         for vnf in nsd["vnfs"]:
 204             vnfd_id = vnf["properties"].get("descriptor_id", "undefined")
 205             if vnfd_id == "undefined":
 206                 vnfd_id = vnf["properties"].get("id", "undefined")
 207             pkg = VnfPackageModel.objects.filter(vnfdId=vnfd_id)
 208             if not pkg:
 209                 pkg = VnfPackageModel.objects.filter(vnfPackageId=vnfd_id)
 210             if not pkg:
 211                 vnfd_name = vnf.get("vnf_id", "undefined")
 212                 logger.error("[%s] is not distributed.", vnfd_name)
 213                 raise CatalogException("VNF package(%s) is not distributed." % vnfd_id)
 214
 215         for pnf in nsd["pnfs"]:
 216             pnfd_id = pnf["properties"].get("descriptor_id", "undefined")
 217             if pnfd_id == "undefined":
 218                 pnfd_id = pnf["properties"].get("id", "undefined")
 219             pkg = PnfPackageModel.objects.filter(pnfdId=pnfd_id)
 220             if not pkg:
 221                 pkg = PnfPackageModel.objects.filter(pnfPackageId=pnfd_id)
 222             if not pkg:
 223                 pnfd_name = pnf.get("pnf_id", "undefined")
 224                 logger.error("[%s] is not distributed.", pnfd_name)
 225                 raise CatalogException("PNF package(%s) is not distributed." % pnfd_name)
 226
 227         ns_pkgs.update(
 228             nsdId=nsd_id,
 229             nsdName=nsd_name,
 230             nsdDesginer=nsd_designer,
 231             nsdDescription=nsd.get("description", ""),
 232             nsdVersion=nsd_version,
 233             invariantId=invariant_id,
 234             onboardingState=const.PKG_STATUS.ONBOARDED,
 235             operationalState=const.PKG_STATUS.ENABLED,
 236             usageState=const.PKG_STATUS.NOT_IN_USE,
 237             nsPackageUri=local_file_name,
 238             sdcCsarId=nsd_info_id,
 239             localFilePath=local_file_name,
 240             nsdModel=nsd_json
 241         )
 242         send_notification(const.NSD_NOTIFICATION_TYPE.NSD_ONBOARDING, nsd_info_id, nsd_id)
 243         logger.info('NSD(%s) has been processed.' % nsd_info_id)
 244
 245     def fill_resp_data(self, ns_pkg):
 246         """
 247         File response data
 248         :param ns_pkg:
 249         :return:
 250         """
 251         data = {
 252             'id': ns_pkg.nsPackageId,
 253             'nsdId': ns_pkg.nsdId,
 254             'nsdName': ns_pkg.nsdName,
 255             'nsdVersion': ns_pkg.nsdVersion,
 256             'nsdDesigner': ns_pkg.nsdDesginer,
 257             'nsdInvariantId': ns_pkg.invariantId,
 258             'vnfPkgIds': [],
 259             'pnfdInfoIds': [],  # TODO
 260             'nestedNsdInfoIds': [],  # TODO
 261             'nsdOnboardingState': ns_pkg.onboardingState,
 262             'onboardingFailureDetails': None,  # TODO
 263             'nsdOperationalState': ns_pkg.operationalState,
 264             'nsdUsageState': ns_pkg.usageState,
 265             'userDefinedData': {},
 266             '_links': None  # TODO
 267         }
 268
 269         if ns_pkg.nsdModel:
 270             nsd_model = json.JSONDecoder().decode(ns_pkg.nsdModel)
 271             vnf_pkg_ids = []
 272             for vnf in nsd_model['vnfs']:
 273                 vnfd_id = vnf["properties"].get("descriptor_id", "undefined")
 274                 if vnfd_id == "undefined":
 275                     vnfd_id = vnf["properties"].get("id", "undefined")
 276                 pkgs = VnfPackageModel.objects.filter(vnfdId=vnfd_id)
 277                 if not pkgs:
 278                     pkgs = VnfPackageModel.objects.filter(vnfPackageId=vnfd_id)
 279                 for pkg in pkgs:
 280                     vnf_pkg_ids.append(pkg.vnfPackageId)
 281             data['vnfPkgIds'] = vnf_pkg_ids
 282
 283             pnf_info_ids = []
 284             for pnf in nsd_model['pnfs']:
 285                 pnfd_id = pnf["properties"].get("descriptor_id", "undefined")
 286                 if pnfd_id == "undefined":
 287                     pnfd_id = pnf["properties"].get("id", "undefined")
 288                 pkgs = PnfPackageModel.objects.filter(pnfdId=pnfd_id)
 289                 if not pkgs:
 290                     pkgs = PnfPackageModel.objects.filter(pnfPackageId=pnfd_id)
 291                 for pkg in pkgs:
 292                     pnf_info_ids.append(pkg.pnfPackageId)
 293             data['pnfInfoIds'] = pnf_info_ids  # TODO: need reconfirming
 294
 295         if ns_pkg.userDefinedData:
 296             user_defined_data = json.JSONDecoder().decode(ns_pkg.userDefinedData)
 297             data['userDefinedData'] = user_defined_data
 298
 299         return data
 300
 301     def handle_upload_failed(self, nsd_info_id):
 302         ns_pkg = NSPackageModel.objects.filter(nsPackageId=nsd_info_id)
 303         ns_pkg.update(onboardingState=const.PKG_STATUS.CREATED)
 304
 305
 306 def send_notification(type, nsd_info_id, nsd_id=None, failure_details=None, operational_state=None):
 307     """
 308     Send notification
 309     :param type:
 310     :param nsd_info_id:
 311     :param nsd_id:
 312     :param failure_details:
 313     :param operational_state:
 314     :return:
 315     """
 316     notify = NsdNotifications(type, nsd_info_id, nsd_id,
 317                               failure_details=failure_details,
 318                               operational_state=operational_state)
 319     notify.send_notification()