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