lcm/lcm/nf/vnfs/vnf_create/inst_vnf.py

   1 # Copyright 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 traceback
  17 from threading import Thread
  18
  19 from lcm.nf.vnfs.const import vnfd_model_dict
  20 from lcm.pub.database.models import NfInstModel, NfvoRegInfoModel, VmInstModel, NetworkInstModel, \
  21     SubNetworkInstModel, PortInstModel, StorageInstModel, FlavourInstModel, VNFCInstModel, VLInstModel, CPInstModel
  22 from lcm.pub.exceptions import NFLCMException
  23 from lcm.pub.msapi.catalog import query_rawdata_from_catalog
  24 from lcm.pub.msapi.nfvolcm import apply_grant_to_nfvo, notify_lcm_to_nfvo, get_packageinfo_by_vnfdid
  25 from lcm.pub.utils import toscautil
  26 from lcm.pub.utils.jobutil import JobUtil
  27 from lcm.pub.utils.timeutil import now_time
  28 from lcm.pub.utils.values import ignore_case_get
  29 from lcm.pub.vimapi import adaptor
  30
  31 logger = logging.getLogger(__name__)
  32
  33
  34 class InstVnf(Thread):
  35     def __init__(self, data, nf_inst_id, job_id):
  36         super(InstVnf, self).__init__()
  37         self.data = data
  38         self.nf_inst_id = nf_inst_id
  39         self.job_id = job_id
  40         self.nfvo_inst_id = ''
  41         self.vnfm_inst_id = ''
  42         self.csar_id = ''
  43         self.vnfd_info = []
  44         self.inst_resource = {'volumn': [],  # [{"vim_id": ignore_case_get(ret, "vim_id")},{}]
  45                               'network': [],
  46                               'subnet': [],
  47                               'port': [],
  48                               'flavor': [],
  49                               'vm': [],
  50                               }
  51         # self.create_res_result = {
  52         #     'jobid': 'res_001',
  53         #     'resourceResult': [{'name': 'vm01'}, {'name': 'vm02'}],
  54         #     'resource_result':{
  55         #         'affectedvnfc':[
  56         #             {
  57         #                 'status':'success',
  58         #                 'vnfcinstanceid':'1',
  59         #                 'computeresource':{'resourceid':'11'},
  60         #                 'vduid':'111',
  61         #                 'vdutype':'1111'
  62         #             }
  63         #         ],
  64         #         'affectedvirtuallink':[
  65         #             {
  66         #                 'status': 'success',
  67         #                 'virtuallinkinstanceid':'',
  68         #                 'networkresource':{'resourceid':'1'},
  69         #                 'subnetworkresource':{'resourceid':'1'},
  70         #                 'virtuallinkdescid': '',
  71         #             }
  72         #         ],
  73         #         'affectedcp':[{
  74         #             'status': 'success',
  75         #             'portresource':{'resourceid':'1'},
  76         #             'cpinstanceid':'2',
  77         #             'cpdid':'22',
  78         #             'ownertype':'222',
  79         #             'ownerid':'2222',
  80         #             'virtuallinkinstanceid':'22222',
  81         #
  82         #         }],
  83         #
  84         #     }
  85         # }
  86
  87     def run(self):
  88         try:
  89             self.inst_pre()
  90             self.apply_grant()
  91             self.create_res()
  92             self.lcm_notify()
  93             JobUtil.add_job_status(self.job_id, 100, "Instantiate Vnf success.")
  94             # is_exist = JobStatusModel.objects.filter(jobid=self.job_id).exists()
  95             # logger.debug("check_ns_inst_name_exist::is_exist=%s" % is_exist)
  96         except NFLCMException as e:
  97             self.vnf_inst_failed_handle(e.message)
  98             # self.rollback(e.message)
  99         except:
 100             self.vnf_inst_failed_handle('unexpected exception')
 101             logger.error(traceback.format_exc())
 102             # self.rollback('unexpected exception')
 103
 104     def inst_pre(self):
 105         vnf_insts = NfInstModel.objects.filter(nfinstid=self.nf_inst_id)
 106         if not vnf_insts.exists():
 107             raise NFLCMException('VNF nf_inst_id is not exist.')
 108
 109         # self.vnfm_inst_id = vnf_insts[0].vnfm_inst_id
 110         if vnf_insts[0].status != 'NOT_INSTANTIATED':
 111             raise NFLCMException('VNF instantiationState is not NOT_INSTANTIATED.')
 112
 113         JobUtil.add_job_status(self.job_id, 5, 'Get packageinfo by vnfd_id')
 114         # get csar_id from nslcm by vnfd_id
 115         self.package_info = get_packageinfo_by_vnfdid(vnf_insts[0].vnfdid)
 116         self.package_id = ignore_case_get(self.package_info, "package_id")
 117         self.csar_id = ignore_case_get(self.package_info, "csar_id")
 118
 119         JobUtil.add_job_status(self.job_id, 10, 'Get rawdata from catalog by csar_id')
 120         # get rawdata from catalog by csar_id
 121         input_parameters = []
 122         for key, val in self.data['additionalParams'].items():
 123             input_parameters.append({"key": key, "value": val})
 124         raw_data = query_rawdata_from_catalog(self.csar_id, input_parameters)
 125         self.vnfd_info = toscautil.convert_vnfd_model(raw_data["rawData"])  # convert to inner json
 126         self.vnfd_info = json.JSONDecoder().decode(self.vnfd_info)
 127
 128         self.vnfd_info = vnfd_model_dict
 129
 130         self.checkParameterExist()
 131         # update NfInstModel
 132         NfInstModel.objects.filter(nfinstid=self.nf_inst_id).\
 133             update(flavour_id=ignore_case_get(self.data, "flavourId"),
 134                    input_params=self.data,
 135                    vnfd_model=self.vnfd_info,
 136                    localizationLanguage=ignore_case_get(self.data, 'localizationLanguage'),
 137                    lastuptime=now_time())
 138         JobUtil.add_job_status(self.job_id, 15, 'Nf instancing pre-check finish')
 139         logger.info("Nf instancing pre-check finish")
 140
 141     def apply_grant(self):
 142         logger.info('[NF instantiation] send resource grand request to nfvo start')
 143         # self.check_vm_capacity()
 144         content_args = {'vnfInstanceId': self.nf_inst_id, 'vnfDescriptorId': '',
 145                         'lifecycleOperation': 'Instantiate', 'jobId': self.job_id,
 146                         'addResource': [], 'removeResource': [],
 147                         'placementConstraint': [], 'additionalParam': {}}
 148
 149         vdus = ignore_case_get(self.vnfd_info, "vdus")
 150         res_index = 1
 151         for vdu in vdus:
 152             res_def = {'type': 'VDU',
 153                        'resDefId': str(res_index),
 154                        'resDesId': ignore_case_get(vdu, "vdu_id")}
 155             content_args['addResource'].append(res_def)
 156             res_index += 1
 157
 158         logger.info('content_args=%s' % content_args)
 159         self.apply_result = apply_grant_to_nfvo(content_args)
 160         vim_info = ignore_case_get(self.apply_result, "vim")
 161
 162         for vdu in self.vnfd_info["vdus"]:
 163             if "location_info" in vdu["properties"]:
 164                 vdu["properties"]["location_info"]["vimid"] = ignore_case_get(vim_info, "vimid")
 165                 vdu["properties"]["location_info"]["tenant"] = ignore_case_get(
 166                     ignore_case_get(vim_info, "accessinfo"), "tenant")
 167             else:
 168                 vdu["properties"]["location_info"] = {"vimid":ignore_case_get(vim_info, "vimid"),
 169                                                       "tenant":ignore_case_get(
 170                                                           ignore_case_get(vim_info, "accessinfo"), "tenant")}
 171
 172         # update resources_table
 173         NfInstModel.objects.filter(nfinstid=self.nf_inst_id).update(status='INSTANTIATED', lastuptime=now_time())
 174         JobUtil.add_job_status(self.job_id,20, 'Nf instancing apply grant finish')
 175         logger.info("Nf instancing apply grant finish")
 176
 177     def create_res(self):
 178         logger.info("[NF instantiation] create resource start")
 179         adaptor.create_vim_res('', self.do_notify, self.do_rollback)
 180
 181         JobUtil.add_job_status(self.job_id, 70, '[NF instantiation] create resource finish')
 182         logger.info("[NF instantiation] create resource finish")
 183
 184     # def check_res_status(self):
 185     #     logger.info("[NF instantiation] confirm all vms are active start")
 186     #     vnfcs = self.create_res_result['resource_result']['affectedvnfc']
 187     #     for vnfc in vnfcs:
 188     #         if 'success' != vnfc['status']:
 189     #             logger.error("VNFC_STATUS_IS_NOT_ACTIVE[vduid=%s]" % vnfc['vduId'])
 190     #             raise NFLCMException(msgid="VNFC_STATUS_IS_NOT_ACTIVE[vduid=%s]", args=vnfc['vduId'])
 191     #
 192     #     JobUtil.add_job_status(self.job_id, 80, 'SAVE_VNFC_TO_DB')
 193     #     vls = self.create_res_result['resource_result']['affectedvirtuallink']
 194     #     cps = self.create_res_result['resource_result']['affectedcp']
 195     #
 196     #     for vnfc in vnfcs:
 197     #         if 'failed' == vnfc['status']:
 198     #             continue
 199     #         compute_resource = vnfc['computeresource']
 200     #         vminst = VmInstModel.objects.filter(resouceid=compute_resource['resourceid']).first()
 201     #         VNFCInstModel.objects.create(
 202     #             vnfcinstanceid=vnfc['vnfcinstanceid'],
 203     #             vduid=vnfc['vduid'],
 204     #             vdutype=vnfc['vdutype'],
 205     #             nfinstid=self.nf_inst_id,
 206     #             vmid=vminst.vmid)
 207     #     for vl in vls:
 208     #         if 'failed' == vl['status']:
 209     #             continue
 210     #         network_resource = vl['networkresource']
 211     #         subnet_resource = vl['subnetworkresource']
 212     #         networkinst = NetworkInstModel.objects.filter(resouceid=network_resource['resourceid']).first()
 213     #         subnetinst = SubNetworkInstModel.objects.filter(resouceid=subnet_resource['resourceid']).first()
 214     #         VLInstModel.objects.create(
 215     #             vlinstanceid=vl['virtuallinkinstanceid'],
 216     #             vldid=vl['virtuallinkdescid'],
 217     #             ownertype='0',
 218     #             ownerid=self.nf_inst_id,
 219     #             relatednetworkid=networkinst.networkid,
 220     #             relatedsubnetworkid=subnetinst.subnetworkid)
 221     #     # # for vs in vss:
 222     #     for cp in cps:
 223     #         if 'failed' == cp['status']:
 224     #             continue
 225     #         port_resource = cp['portresource']
 226     #         portinst = PortInstModel.objects.filter(resouceid=port_resource['resourceid']).first()
 227     #         ttt = portinst.portid
 228     #         CPInstModel.objects.create(
 229     #             cpinstanceid=cp['cpinstanceid'],
 230     #             cpdid=cp['cpdid'],
 231     #             relatedtype='2',
 232     #             relatedport=portinst.portid,
 233     #             ownertype=cp['ownertype'],
 234     #             ownerid=cp['ownerid'],
 235     #             vlinstanceid=cp['virtuallinkinstanceid'])
 236     #     # self.add_job(43, 'INST_DPLY_VM_PRGS')
 237     #     logger.info("[NF instantiation] confirm all vms are active end")
 238
 239     def lcm_notify(self):
 240         logger.info('[NF instantiation] send notify request to nfvo start')
 241         reg_info = NfvoRegInfoModel.objects.filter(vnfminstid=self.vnfm_inst_id).first()
 242         # vm_info = VmInstModel.objects.filter(nfinstid=self.nf_inst_id)
 243         vmlist = []
 244         # nfs = NfInstModel.objects.filter(nfinstid=self.nf_inst_id)
 245         # nf = nfs[0]
 246         # allocate_data = json.loads(nf.initallocatedata)
 247         # vmlist = json.loads(nf.predefinedvm)
 248         addition_param = {'vmList': vmlist}
 249         affected_vnfc = []
 250         vnfcs = VNFCInstModel.objects.filter(nfinstid=self.nf_inst_id)
 251         for vnfc in vnfcs:
 252             compute_resource = {}
 253             if vnfc.vmid:
 254                 vm = VmInstModel.objects.filter(vmid=vnfc.vmid)
 255                 if vm:
 256                     compute_resource = {'vimId': vm[0].vimid, 'resourceId': vm[0].resouceid,
 257                                         'resourceName': vm[0].vmname, 'tenant': vm[0].tenant}
 258             affected_vnfc.append(
 259                 {'vnfcInstanceId': vnfc.vnfcinstanceid, 'vduId': vnfc.vduid, 'changeType': 'added',
 260                  'computeResource': compute_resource, 'storageResource': [], 'vduType': vnfc.vdutype})
 261         affected_vl = []
 262         vls = VLInstModel.objects.filter(ownerid=self.nf_inst_id)
 263         for vl in vls:
 264             network_resource = {}
 265             subnet_resource = {}
 266             if vl.relatednetworkid:
 267                 network = NetworkInstModel.objects.filter(networkid=vl.relatednetworkid)
 268                 subnet = SubNetworkInstModel.objects.filter(subnetworkid=vl.relatedsubnetworkid)
 269                 if network:
 270                     network_resource = {'vimId': network[0].vimid, 'resourceId': network[0].resouceid,
 271                                         'resourceName': network[0].name, 'tenant': network[0].tenant}
 272                 if subnet:
 273                     subnet_resource = {'vimId': subnet[0].vimid, 'resourceId': subnet[0].resouceid,
 274                                        'resourceName': subnet[0].name, 'tenant': subnet[0].tenant}
 275             affected_vl.append(
 276                 {'virtualLinkInstanceId': vl.vlinstanceid, 'virtualLinkDescId': vl.vldid, 'changeType': 'added',
 277                  'networkResource': network_resource, 'subnetworkResource': subnet_resource, 'tenant': vl.tenant})
 278         affected_vs = []
 279         vss = StorageInstModel.objects.filter(instid=self.nf_inst_id)
 280         for vs in vss:
 281             affected_vs.append(
 282                 {'virtualStorageInstanceId': vs.storageid, 'virtualStorageDescId': '', 'changeType': 'added',
 283                  'storageResource': {'vimId': vs.vimid, 'resourceId': vs.resouceid,
 284                                      'resourceName': vs.name, 'tenant': vs.tenant}})
 285         affected_cp = []
 286         # vnfc cps
 287         for vnfc in vnfcs:
 288             cps = CPInstModel.objects.filter(ownerid=vnfc.vnfcinstanceid, ownertype=3)
 289             for cp in cps:
 290                 port_resource = {}
 291                 if cp.relatedport:
 292                     port = PortInstModel.objects.filter(portid=cp.relatedport)
 293                     if port:
 294                         port_resource = {'vimId': port[0].vimid, 'resourceId': port[0].resouceid,
 295                                          'resourceName': port[0].name, 'tenant': port[0].tenant}
 296                 affected_cp.append(
 297                     {'cPInstanceId': cp.cpinstanceid, 'cpdId': cp.cpdid, 'ownerid': cp.ownerid,
 298                      'ownertype': cp.ownertype, 'changeType': 'added', 'portResource': port_resource,
 299                      'virtualLinkInstanceId': cp.vlinstanceid})
 300         # nf cps
 301         cps = CPInstModel.objects.filter(ownerid=self.nf_inst_id, ownertype=0)
 302         logger.info('vnf_inst_id=%s, cps size=%s' % (self.nf_inst_id, cps.count()))
 303         for cp in cps:
 304             port_resource = {}
 305             if cp.relatedport:
 306                 port = PortInstModel.objects.filter(portid=cp.relatedport)
 307                 if port:
 308                     port_resource = {'vimId': port[0].vimid, 'resourceId': port[0].resouceid,
 309                                      'resourceName': port[0].name, 'tenant': port[0].tenant}
 310             affected_cp.append(
 311                 {'cPInstanceId': cp.cpinstanceid, 'cpdId': cp.cpdid, 'ownerid': cp.ownerid, 'ownertype': cp.ownertype,
 312                  'changeType': 'added', 'portResource': port_resource,
 313                  'virtualLinkInstanceId': cp.vlinstanceid})
 314         # affectedcapacity = {}
 315         # reserved_total = allocate_data.get('reserved_total', {})
 316         # affectedcapacity['vm'] = str(reserved_total.get('vmnum', 0))
 317         # affectedcapacity['vcpu'] = str(reserved_total.get('vcpunum', 0))
 318         # affectedcapacity['vMemory'] = str(reserved_total.get('memorysize', 0))
 319         # affectedcapacity['port'] = str(reserved_total.get('portnum', 0))
 320         # affectedcapacity['localStorage'] = str(reserved_total.get('hdsize', 0))
 321         # affectedcapacity['sharedStorage'] = str(reserved_total.get('shdsize', 0))
 322         content_args = {
 323             # "vnfdmodule": allocate_data,
 324             "additionalParam": addition_param,
 325             "nfvoInstanceId": reg_info.nfvoid,
 326             "vnfmInstanceId": self.vnfm_inst_id,
 327             "status": 'finished',
 328             "nfInstanceId": self.nf_inst_id,
 329             "operation": 'instantiate',
 330             "jobId": '',
 331             # 'affectedcapacity': affectedcapacity,
 332             'affectedService': [],
 333             'affectedVnfc': affected_vnfc,
 334             'affectedVirtualLink': affected_vl,
 335             'affectedVirtualStorage': affected_vs,
 336             'affectedCp': affected_cp}
 337         logger.info('content_args=%s' % content_args)
 338         # call rest api
 339         resp = notify_lcm_to_nfvo(content_args, self.nf_inst_id)
 340         logger.info('[NF instantiation] get lcm response %s' % resp)
 341         if resp[0] != 0:
 342             logger.error("notify lifecycle to nfvo failed.[%s]" % resp[1])
 343             raise NFLCMException("send notify request to nfvo failed")
 344         logger.info('[NF instantiation] send notify request to nfvo end')
 345
 346     def load_nfvo_config(self):
 347         logger.info("[NF instantiation]get nfvo connection info start")
 348         reg_info = NfvoRegInfoModel.objects.filter(vnfminstid='vnfm111').first()
 349         if reg_info:
 350             self.vnfm_inst_id = reg_info.vnfminstid
 351             self.nfvo_inst_id = reg_info.nfvoid
 352             logger.info("[NF instantiation] Registered nfvo id is [%s]" % self.nfvo_inst_id)
 353         else:
 354             raise NFLCMException("Nfvo was not registered")
 355         logger.info("[NF instantiation]get nfvo connection info end")
 356
 357     def vnf_inst_failed_handle(self, error_msg):
 358         logger.error('VNF instantiation failed, detail message: %s' % error_msg)
 359         NfInstModel.objects.filter(nfinstid=self.nf_inst_id).update(status='failed', lastuptime=now_time())
 360         JobUtil.add_job_status(self.job_id, 255, error_msg)
 361
 362     def do_notify(self, res_type, progress, ret):
 363         logger.info('creating [%s] resource' % res_type)
 364         progress = 20 + int(progress/2)     # 20-70
 365         if res_type == adaptor.OPT_CREATE_VOLUME:
 366             logger.info('Create vloumns!')
 367             if ret["returnCode"] == adaptor.RES_NEW:  # new create
 368                 self.inst_resource['volumn'].append({"vim_id": ignore_case_get(ret, "vim_id"),
 369                                                      "res_id": ignore_case_get(ret, "res_id")})
 370             JobUtil.add_job_status(self.job_id, progress, 'Create vloumns!')
 371             StorageInstModel.objects.create(
 372                 storageid='1',
 373                 vimid='1',
 374                 resouceid='1',
 375                 name='40G',
 376                 tenant='admin',
 377                 insttype=0,
 378                 is_predefined=ret["returnCode"],
 379                 instid=self.nf_inst_id)
 380         elif res_type == adaptor.OPT_CREATE_NETWORK:
 381             logger.info('Create networks!')
 382             if ret["returnCode"] == adaptor.RES_NEW:
 383                 self.inst_resource['network'].append({"vim_id": ignore_case_get(ret, "vim_id"),
 384                                                       "res_id": ignore_case_get(ret, "res_id")})
 385             # self.inst_resource['network'].append({"vim_id": "1"}, {"res_id": "2"})
 386             JobUtil.add_job_status(self.job_id, progress, 'Create networks!')
 387             NetworkInstModel.objects.create(
 388                 networkid='1',
 389                 vimid='1',
 390                 resouceid='1',
 391                 name='pnet_network',
 392                 tenant='admin',
 393                 insttype=0,
 394                 is_predefined=ret["returnCode"],
 395                 instid=self.nf_inst_id)
 396         elif res_type == adaptor.OPT_CREATE_SUBNET:
 397             logger.info('Create subnets!')
 398             if ret["returnCode"] == adaptor.RES_NEW:
 399                 self.inst_resource['subnet'].append({"vim_id": ignore_case_get(ret, "vim_id"),
 400                                                      "res_id": ignore_case_get(ret, "res_id")})
 401             # self.inst_resource['subnet'].append({"vim_id": "1"}, {"res_id": "2"})
 402             JobUtil.add_job_status(self.job_id, progress, 'Create subnets!')
 403             SubNetworkInstModel.objects.create(
 404                 subnetworkid='1',
 405                 vimid='1',
 406                 resouceid='1',
 407                 networkid='1',
 408                 name='sub_pnet',
 409                 tenant='admin',
 410                 insttype=0,
 411                 is_predefined=ret["returnCode"],
 412                 instid=self.nf_inst_id)
 413         elif res_type == adaptor.OPT_CREATE_PORT:
 414             logger.info('Create ports!')
 415             if ret["returnCode"] == adaptor.RES_NEW:
 416                 self.inst_resource['port'].append({"vim_id": ignore_case_get(ret, "vim_id"),
 417                                                    "res_id": ignore_case_get(ret, "res_id")})
 418             # self.inst_resource['port'].append({"vim_id": "1"}, {"res_id": "2"})
 419             JobUtil.add_job_status(self.job_id, progress, 'Create ports!')
 420             PortInstModel.objects.create(
 421                 portid='1',
 422                 networkid='1',
 423                 subnetworkid='1',
 424                 vimid='1',
 425                 resouceid='1',
 426                 name='aaa_pnet_cp',
 427                 tenant='admin',
 428                 insttype=0,
 429                 is_predefined=ret["returnCode"],
 430                 instid=self.nf_inst_id)
 431         elif res_type == adaptor.OPT_CREATE_FLAVOR:
 432             logger.info('Create flavors!')
 433             if ret["returnCode"] == adaptor.RES_NEW:
 434                 self.inst_resource['flavor'].append({"vim_id": ignore_case_get(ret, "vim_id"),
 435                                                      "res_id": ignore_case_get(ret, "res_id")})
 436             # self.inst_resource['flavor'].append({"vim_id": "1"}, {"res_id": "2"})
 437             JobUtil.add_job_status(self.job_id, progress, 'Create flavors!')
 438             FlavourInstModel.objects.create(
 439                 falavourid='1',
 440                 name='1',
 441                 vcpu='1',
 442                 extraspecs='1',
 443                 is_predefined=ret["returnCode"],
 444                 instid=self.nf_inst_id)
 445         elif res_type == adaptor.OPT_CREATE_VM:
 446             logger.info('Create vms!')
 447             if ret["returnCode"] == adaptor.RES_NEW:
 448                 self.inst_resource['vm'].append({"vim_id": ignore_case_get(ret, "vim_id"),
 449                                                  "res_id": ignore_case_get(ret, "res_id")})
 450             # self.inst_resource['vm'].append({"vim_id": "1"}, {"res_id": "2"})
 451             JobUtil.add_job_status(self.job_id, progress, 'Create vms!')
 452             VmInstModel.objects.create(
 453                 vmid="1",
 454                 vimid="1",
 455                 resouceid="11",
 456                 insttype=0,
 457                 instid=self.nf_inst_id,
 458                 vmname="test_01",
 459                 is_predefined=ret["returnCode"],
 460                 operationalstate=1)
 461
 462     def do_rollback(self, args_=None):
 463         logger.error('error info : %s' % args_)
 464         adaptor.delete_vim_res(self.inst_resource, self.do_notify_delete)
 465         logger.error('rollback resource complete')
 466
 467         StorageInstModel.objects.filter(instid=self.nf_inst_id).delete()
 468         NetworkInstModel.objects.filter(instid=self.nf_inst_id).delete()
 469         SubNetworkInstModel.objects.filter(instid=self.nf_inst_id).delete()
 470         PortInstModel.objects.filter(instid=self.nf_inst_id).delete()
 471         FlavourInstModel.objects.filter(instid=self.nf_inst_id).delete()
 472         VmInstModel.objects.filter(instid=self.nf_inst_id).delete()
 473         logger.error('delete table complete')
 474         raise NFLCMException("Create resource failed")
 475
 476     def do_notify_delete(self, ret):
 477         logger.error('Deleting [%s] resource' % ret)
 478
 479     def checkParameterExist(self):
 480         # if ignore_case_get(self.data, "flavourId") not in self.vnfd_info:
 481         #     raise NFLCMException('Input parameter is not defined in vnfd_info.')
 482         pass