lcm/ns/ns_instant.py

   1 # Copyright 2016-2017 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 import json
  15 import logging
  16 import time
  17 import traceback
  18 import uuid
  19
  20 from rest_framework import status
  21
  22 from lcm.pub.config.config import WORKFLOW_OPTION
  23 from lcm.pub.database.models import DefPkgMappingModel, ServiceBaseInfoModel, InputParamMappingModel
  24 from lcm.pub.database.models import NSInstModel, VNFFGInstModel, WFPlanModel
  25 from lcm.pub.exceptions import NSLCMException
  26 from lcm.pub.msapi import activiti
  27 from lcm.pub.msapi import sdc_run_catalog
  28 from lcm.pub.msapi.catalog import get_process_id, query_rawdata_from_catalog
  29 from lcm.pub.msapi.catalog import get_servicetemplate_id, get_servicetemplate
  30 from lcm.pub.msapi.extsys import select_vnfm
  31 from lcm.pub.msapi.wso2bpel import workflow_run
  32 from lcm.pub.utils import toscautil
  33 from lcm.pub.utils.jobutil import JobUtil
  34 from lcm.pub.utils.values import ignore_case_get
  35 from lcm.workflows import build_in
  36
  37 logger = logging.getLogger(__name__)
  38
  39
  40 class InstantNSService(object):
  41     def __init__(self, ns_inst_id, plan_content):
  42         self.ns_inst_id = ns_inst_id
  43         self.req_data = plan_content
  44
  45     def do_biz(self):
  46         try:
  47             job_id = JobUtil.create_job("NS", "NS_INST", self.ns_inst_id)
  48             logger.debug('ns-instant(%s) workflow starting...' % self.ns_inst_id)
  49             logger.debug('req_data=%s' % self.req_data)
  50             ns_inst = NSInstModel.objects.get(id=self.ns_inst_id)
  51
  52             input_parameters = []
  53             for key, val in self.req_data['additionalParamForNs'].items():
  54                 input_parameters.append({"key": key, "value": val})
  55
  56             vim_id = ''
  57             if 'location' in self.req_data['additionalParamForNs']:
  58                 vim_id = self.req_data['additionalParamForNs']['location']
  59             location_constraints = []
  60             if 'locationConstraints' in self.req_data:
  61                 location_constraints = self.req_data['locationConstraints']
  62
  63             JobUtil.add_job_status(job_id, 5, 'Start query nsd(%s)' % ns_inst.nspackage_id)
  64             dst_plan = None
  65             if WORKFLOW_OPTION == "wso2":
  66                 src_plan = query_rawdata_from_catalog(ns_inst.nspackage_id, input_parameters)
  67                 dst_plan = toscautil.convert_nsd_model(src_plan["rawData"])
  68             else:
  69                 dst_plan = sdc_run_catalog.parse_nsd(ns_inst.nspackage_id, input_parameters)
  70             logger.debug('tosca plan dest:%s' % dst_plan)
  71
  72             NSInstModel.objects.filter(id=self.ns_inst_id).update(nsd_model=dst_plan)
  73
  74             params_json = json.JSONEncoder().encode(self.req_data["additionalParamForNs"])
  75             # start
  76             params_vnf = []
  77             plan_dict = json.JSONDecoder().decode(dst_plan)
  78             for vnf in ignore_case_get(plan_dict, "vnfs"):
  79                 vnfd_id = vnf['properties']['id']
  80                 # vnfd = NfPackageModel.objects.get(vnfdid=vnfd_id)
  81                 # vnfpackage_info = query_vnfpackage_by_id(vnfd_id)
  82                 # vnfd_model = json.JSONDecoder().decode(ignore_case_get(vnfpackage_info["packageInfo"], "vnfdModel"))
  83                 # vnfm_type = vnfd_model["metadata"].get("vnfmType", "ztevmanagerdriver")
  84                 vnfm_type = vnf['properties'].get("nf_type", "ztevmanagerdriver")
  85                 vimid = self.get_vnf_vim_id(vim_id, location_constraints, vnfd_id)
  86                 vnfm_info = select_vnfm(vnfm_type=vnfm_type, vim_id=vimid)
  87                 params_vnf.append({
  88                     "vnfProfileId": vnf["vnf_id"],
  89                     "additionalParam": {
  90                         "vimId": vimid,
  91                         "vnfmInstanceId": vnfm_info["vnfmId"],
  92                         "vnfmType": vnfm_type,
  93                         "inputs": params_json
  94                     }
  95                 })
  96             # end
  97
  98             self.set_vl_vim_id(vim_id, location_constraints, plan_dict)
  99             dst_plan = json.JSONEncoder().encode(plan_dict)
 100             logger.debug('tosca plan dest add vimid:%s' % dst_plan)
 101             NSInstModel.objects.filter(id=self.ns_inst_id).update(nsd_model=dst_plan)
 102
 103             vnf_params_json = json.JSONEncoder().encode(params_vnf)
 104             plan_input = {
 105                 'jobId': job_id,
 106                 'nsInstanceId': self.req_data["nsInstanceId"],
 107                 'object_context': dst_plan,
 108                 'object_additionalParamForNs': params_json,
 109                 'object_additionalParamForVnf': vnf_params_json
 110             }
 111             plan_input.update(**self.get_model_count(dst_plan))
 112             plan_input["sdnControllerId"] = ignore_case_get(
 113                 self.req_data['additionalParamForNs'], "sdncontroller")
 114
 115             ServiceBaseInfoModel(service_id=self.ns_inst_id,
 116                                  service_name=ns_inst.name,
 117                                  service_type='NFVO',
 118                                  description=ns_inst.description,
 119                                  active_status='--',
 120                                  status=ns_inst.status,
 121                                  creator='--',
 122                                  create_time=int(time.time() * 1000)).save()
 123
 124             if WORKFLOW_OPTION == "wso2":
 125                 service_tpl = get_servicetemplate(ns_inst.nsd_id)
 126                 DefPkgMappingModel(service_id=self.ns_inst_id,
 127                                    service_def_id=service_tpl['csarId'],
 128                                    template_name=service_tpl['templateName'],
 129                                    template_id=service_tpl['serviceTemplateId']).save()
 130
 131                 for key, val in self.req_data['additionalParamForNs'].items():
 132                     InputParamMappingModel(service_id=self.ns_inst_id,
 133                                            input_key=key,
 134                                            input_value=val).save()
 135
 136                 for vnffg in ignore_case_get(plan_dict, "vnffgs"):
 137                     VNFFGInstModel(vnffgdid=vnffg["vnffg_id"],
 138                                    vnffginstid=str(uuid.uuid4()),
 139                                    nsinstid=self.ns_inst_id,
 140                                    endpointnumber=0).save()
 141             else:
 142                 # TODO:
 143                 pass
 144
 145             if WORKFLOW_OPTION == "wso2":
 146                 return self.start_wso2_workflow(job_id, ns_inst, plan_input)
 147             elif WORKFLOW_OPTION == "activiti":
 148                 return self.start_activiti_workflow()
 149             else:
 150                 return self.start_buildin_workflow(job_id, plan_input)
 151
 152         except Exception as e:
 153             logger.error(traceback.format_exc())
 154             logger.error("ns-instant(%s) workflow error:%s" % (self.ns_inst_id, e.message))
 155             JobUtil.add_job_status(job_id, 255, 'NS instantiation failed: %s' % e.message)
 156             return dict(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 157
 158     def start_wso2_workflow(self, job_id, ns_inst, plan_input):
 159         servicetemplate_id = get_servicetemplate_id(ns_inst.nsd_id)
 160         process_id = get_process_id('init', servicetemplate_id)
 161         data = {"processId": process_id, "params": {"planInput": plan_input}}
 162         logger.debug('ns-instant(%s) workflow data:%s' % (self.ns_inst_id, data))
 163
 164         ret = workflow_run(data)
 165         logger.info("ns-instant(%s) workflow result:%s" % (self.ns_inst_id, ret))
 166         JobUtil.add_job_status(job_id, 10, 'NS inst(%s) wso2 workflow started: %s' % (
 167             self.ns_inst_id, ret.get('status')))
 168         if ret.get('status') == 1:
 169             return dict(data={'jobId': job_id}, status=status.HTTP_200_OK)
 170         return dict(data={'error': ret['message']}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 171
 172     def start_activiti_workflow(self, job_id, plan_input):
 173         plans = WFPlanModel.objects.filter()
 174         if not plans:
 175             raise NSLCMException("No plan is found, you should deploy plan first!")
 176         data = {
 177             "processId": plans[0].process_id,
 178             "params": plan_input
 179         }
 180         ret = activiti.exec_workflow(data)
 181         logger.info("ns-instant(%s) workflow result:%s" % (self.ns_inst_id, ret))
 182         JobUtil.add_job_status(job_id, 10, 'NS inst(%s) activiti workflow started: %s' % (
 183             self.ns_inst_id, ret.get('status')))
 184         if ret.get('status') == 1:
 185             return dict(data={'jobId': job_id}, status=status.HTTP_200_OK)
 186         return dict(data={'error': ret['message']}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 187
 188     def start_buildin_workflow(self, job_id, plan_input):
 189         JobUtil.add_job_status(job_id, 10, 'NS inst(%s) buildin workflow started.' % self.ns_inst_id)
 190         build_in.run_ns_instantiate(plan_input)
 191         return dict(data={'jobId': job_id}, status=status.HTTP_200_OK)
 192
 193     def get_vnf_vim_id(self, vim_id, location_constraints, vnfdid):
 194         for location in location_constraints:
 195             if "vnfProfileId" in location and vnfdid == location["vnfProfileId"]:
 196                 return location["locationConstraints"]["vimId"]
 197         if vim_id:
 198             return vim_id
 199         raise NSLCMException("No Vim info is found for vnf(%s)." % vnfdid)
 200
 201     def set_vl_vim_id(self, vim_id, location_constraints, plan_dict):
 202         if "vls" not in plan_dict:
 203             logger.debug("No vl is found in nsd.")
 204             return
 205         vl_vnf = {}
 206         for vnf in ignore_case_get(plan_dict, "vnfs"):
 207             if "dependencies" in vnf:
 208                 for depend in vnf["dependencies"]:
 209                     vl_vnf[depend["vl_id"]] = vnf['properties']['id']
 210         vnf_vim = {}
 211         for location in location_constraints:
 212             if "vnfProfileId" in location:
 213                 vnfd_id = location["vnfProfileId"]
 214                 vnf_vim[vnfd_id] = location["locationConstraints"]["vimId"]
 215         for vl in plan_dict["vls"]:
 216             vnfdid = ignore_case_get(vl_vnf, vl["vl_id"])
 217             vimid = ignore_case_get(vnf_vim, vnfdid)
 218             if not vimid:
 219                 vimid = vim_id
 220             if not vimid:
 221                 raise NSLCMException("No Vim info for vl(%s) of vnf(%s)." % (vl["vl_id"], vnfdid))
 222             if "location_info" not in vl["properties"]:
 223                 vl["properties"]["location_info"] = {}
 224             vl["properties"]["location_info"]["vimid"] = vimid
 225
 226     @staticmethod
 227     def get_model_count(context):
 228         data = json.JSONDecoder().decode(context)
 229         vls = len(data.get('vls', []))
 230         sfcs = len(data.get('fps', []))
 231         vnfs = len(data.get('vnfs', []))
 232         return {'vlCount': str(vls), 'sfcCount': str(sfcs), 'vnfCount': str(vnfs)}