lcm/lcm/nf/biz/change_ext_conn.py

   1 # Copyright 2019 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.biz.common import port_save
  20 from lcm.nf.biz.grant_vnf import grant_resource
  21 from lcm.nf.const import RESOURCE_MAP, GRANT_TYPE, OPERATION_STATE_TYPE
  22 from lcm.nf.const import VNF_STATUS
  23 from lcm.pub.database.models import VmInstModel, NfInstModel, PortInstModel
  24 from lcm.pub.utils.notificationsutil import NotificationsUtil, prepare_notification
  25 from lcm.pub.utils.values import ignore_case_get
  26 from lcm.pub.utils.timeutil import now_time
  27 from lcm.pub.utils.jobutil import JobUtil
  28 from lcm.pub.exceptions import NFLCMException
  29 from lcm.pub.vimapi import adaptor
  30
  31 logger = logging.getLogger(__name__)
  32
  33
  34 class ChangeExtConn(Thread):
  35     def __init__(self, data, nf_inst_id, job_id):
  36         super(ChangeExtConn, self).__init__()
  37         self.data = data
  38         self.nf_inst_id = nf_inst_id
  39         self.job_id = job_id
  40         self.vnf_insts = NfInstModel.objects.filter(nfinstid=self.nf_inst_id)
  41         self.extVirtualLinks = ignore_case_get(self.data, "extVirtualLinks")
  42         self.vimConnectionInfo = ignore_case_get(self.data, "vimConnectionInfo")
  43         self.additionalParams = ignore_case_get(self.data, "additionalParams")
  44
  45     def run(self):
  46         try:
  47             JobUtil.add_job_status(self.job_id,
  48                                    10,
  49                                    "Start to apply grant.")
  50             self.apply_grant()
  51             JobUtil.add_job_status(self.job_id,
  52                                    50,
  53                                    "Start to change ext conn.")
  54             self.do_operation()
  55             self.vnf_insts.update(
  56                 status='INSTANTIATED',
  57                 lastuptime=now_time()
  58             )
  59             JobUtil.add_job_status(self.job_id,
  60                                    100,
  61                                    "Change ext conn success.")
  62         except NFLCMException as e:
  63             logger.error(e.message)
  64             self.change_ext_conn_failed_handle(e.message)
  65         except Exception as e:
  66             logger.error(e.message)
  67             logger.error(traceback.format_exc())
  68             self.change_ext_conn_failed_handle(e.message)
  69
  70     def apply_grant(self):
  71         vdus = VmInstModel.objects.filter(instid=self.nf_inst_id)
  72         apply_result = grant_resource(data=self.data,
  73                                       nf_inst_id=self.nf_inst_id,
  74                                       job_id=self.job_id,
  75                                       grant_type=GRANT_TYPE.CHANGE_CONNECTIVITY,
  76                                       vdus=vdus)
  77         logger.debug("Grant resource end, response: %s" % apply_result)
  78
  79     def do_operation(self):
  80         logger.info('Operation resource begin')
  81         logger.debug("self.vimConnectionInfo: %s" % self.vimConnectionInfo)
  82         vnfd_info = json.loads(self.vnf_insts[0].vnfd_model)
  83         vm_id = ignore_case_get(self.additionalParams, "vmid")
  84         if not vm_id:
  85             vms = VmInstModel.objects.filter(instid=self.nf_inst_id)
  86             vm_id = vms[0].resourceid
  87         vim_id = ignore_case_get(self.vimConnectionInfo[0], "vimid")
  88         accessInfo = ignore_case_get(self.vimConnectionInfo[0], "accessInfo")
  89         tenant = ignore_case_get(accessInfo, "tenant")
  90
  91         self.vim_cache, self.res_cache = {}, {}
  92         for extVirtualLink in self.extVirtualLinks:
  93             network_id = ignore_case_get(extVirtualLink, "resourceId")
  94             ext_cps = ignore_case_get(extVirtualLink, "extCps")
  95             for ext_cp in ext_cps:
  96                 cpd_id = ignore_case_get(ext_cp, "cpdId")
  97                 cp_config = ignore_case_get(ext_cp, "cpConfig")
  98                 # cp_instance_id = ignore_case_get(cp_config[0], "cpInstanceId")
  99                 cp_protocol_data = ignore_case_get(cp_config[0], "cpProtocolData")
 100                 # mac_address = ignore_case_get(ignore_case_get(cp_protocol_data[0], "ipOverEthernet"), "macAddress")
 101                 ip_addresses = ignore_case_get(ignore_case_get(cp_protocol_data[0], "ipOverEthernet"), "ipAddresses")
 102                 # fixed_addresse = ignore_case_get(ip_addresses[0], "fixedAddresses")[0]
 103                 # addressRange = ignore_case_get(ip_addresses[0], "addressRange")
 104                 # minAddress = ignore_case_get(addressRange, "minAddress")
 105                 # maxAddress = ignore_case_get(addressRange, "maxAddress")
 106                 subnet_id = ignore_case_get(ip_addresses[0], "subnetId")
 107
 108                 vdu_id = ""
 109                 cps = ignore_case_get(vnfd_info, "cps")
 110                 for cp in cps:
 111                     cpd_id_in_model = ignore_case_get(cp, "cpd_id")
 112                     if cpd_id == cpd_id_in_model:
 113                         vdu_id = ignore_case_get(cp, "vdu_id")
 114                         break
 115
 116                 port = {
 117                     "cp_id": cpd_id,
 118                     "cpd_id": cpd_id,
 119                     "vm_id": vm_id,
 120                     "description": "",
 121                     "properties": {
 122                         # "name": "",
 123                         # "mac_address": mac_address,
 124                         # "ip_address:": fixed_addresse,
 125                         # "ip_range_start": minAddress,
 126                         # "ip_range_end": maxAddress,
 127                         "location_info": {
 128                             "vimid": vim_id,
 129                             "tenant": tenant
 130                         }
 131                     },
 132                     "vl_id": network_id,
 133                     "vdu_id": vdu_id,
 134                     "networkId": network_id,
 135                     "subnetId": subnet_id
 136                 }
 137                 for resource_type in ['vdus', 'vls', 'cps', 'volume_storages']:
 138                     for resource in ignore_case_get(vnfd_info, resource_type):
 139                         if "location_info" not in resource["properties"]:
 140                             resource["properties"]["location_info"] = {}
 141                         resource["properties"]["location_info"]["vimid"] = vim_id
 142                         resource["properties"]["location_info"]["tenant"] = tenant
 143
 144                 # if cp_instance_id:
 145                 #     ret = adaptor.get_port_of_vm(self.vim_cache, self.res_cache, vnfd_info, port,
 146                 #                                  self.do_notify_op, "port")
 147                 #     port_info = ignore_case_get(ret, "interfaceAttachment")
 148                 #     net_id = ignore_case_get(port_info, "net_id")
 149                 #     if network_id == net_id:
 150                 #         adaptor.update_port(self.vim_cache, self.res_cache, vnfd_info, port,
 151                 #                             self.do_notify_op, "port")
 152                 #     else:
 153                 #         adaptor.delete_port_of_vm(self.vim_cache, self.res_cache, vnfd_info, port,
 154                 #                                   self.do_notify_op, "port")
 155                 #         adaptor.create_port_of_vm(self.vim_cache, self.res_cache, vnfd_info, port,
 156                 #                                   self.do_notify_op, "port")
 157                 # else:
 158                 adaptor.create_port(self.vim_cache, self.res_cache, vnfd_info, port, self.do_create_port_notify, "port")
 159                 port["port_id"] = self.port_id
 160                 logger.debug('create_port_of_vm request data = %s' % port)
 161                 adaptor.create_port_of_vm(self.vim_cache, self.res_cache, vnfd_info, port,
 162                                           self.do_notify_op, "port")
 163                 PortInstModel.objects.filter(resourceid=self.port_id).update(vmid=vm_id)
 164         logger.info('Operate resource complete')
 165
 166     def send_notification(self):
 167         data = prepare_notification(nfinstid=self.nf_inst_id,
 168                                     jobid=self.job_id,
 169                                     operation=self.op_type,
 170                                     operation_state=OPERATION_STATE_TYPE.COMPLETED)
 171         self.set_ext_connectivity(data['changedExtConnectivity'])
 172
 173         logger.debug('Notify request data = %s' % data)
 174         NotificationsUtil().send_notification(data)
 175
 176     def rollback_operation(self):
 177         pass
 178
 179     def query_inst_resource(self, inst_resource):
 180         logger.debug('Query resource begin')
 181         for resource_type in RESOURCE_MAP.keys():
 182             resource_table = globals().get(resource_type + 'InstModel')
 183             resource_insts = resource_table.objects.filter(instid=self.nf_inst_id)
 184             for resource_inst in resource_insts:
 185                 if not resource_inst.resourceid:
 186                     continue
 187                 inst_resource[RESOURCE_MAP.get(resource_type)].append(self.get_resource(resource_inst))
 188         logger.debug('Query resource end, resource=%s' % inst_resource)
 189
 190     def get_resource(self, resource):
 191         return {
 192             "vim_id": resource.vimid,
 193             "tenant_id": resource.tenant,
 194             "res_id": resource.resourceid
 195         }
 196
 197     def do_create_port_notify(self, res_type, ret):
 198         self.port_id = ignore_case_get(ret, "id")
 199         port_save("", self.nf_inst_id, ret)
 200
 201     def do_notify_op(self, operation_type, status, resid):
 202         if operation_type == "delete":
 203             PortInstModel.objects.filter()
 204             # TODO delete port from table
 205         elif operation_type == "create":
 206             pass
 207             # TODO save port in table
 208         else:
 209             pass
 210             # TODO update port in table
 211         logger.info('VNF resource %s updated to: %s' % (resid, status))
 212
 213     def set_ext_connectivity(self, ext_connectivity):
 214         for extVirtualLink in self.extVirtualLinks:
 215             vim_connection_id = ignore_case_get(extVirtualLink, "vimConnectionId")
 216             network_id = ignore_case_get(extVirtualLink, "resourceId")
 217             ext_cps = ignore_case_get(extVirtualLink, "extCps")
 218             ext_link_ports = []
 219             for ext_cp in ext_cps:
 220                 cpd_id = ignore_case_get(ext_cp, "cpdId")
 221                 cp_config = ignore_case_get(ext_cp, "cpConfig")
 222                 cp_instance_id = ignore_case_get(cp_config[0], "cpInstanceId")
 223                 ext_link_ports.append({
 224                     'id': cp_instance_id,
 225                     'resourceHandle': {
 226                         'vimConnectionId': vim_connection_id,
 227                         'resourceId': self.res_cache.get("port").get(cp_instance_id),
 228                         'resourceProviderId': cpd_id,
 229                         'vimLevelResourceType': 'port'
 230                     },
 231                     'cpInstanceId': cp_instance_id
 232                 })
 233             network_resource = {
 234                 'vimConnectionId': vim_connection_id,
 235                 'resourceId': network_id,
 236                 'resourceProviderId': "",
 237                 'vimLevelResourceType': 'network'
 238             }
 239             ext_connectivity.append({
 240                 'id': network_id,
 241                 'resourceHandle': network_resource,
 242                 'extLinkPorts': ext_link_ports
 243             })
 244
 245     def change_ext_conn_failed_handle(self, error_msg):
 246         logger.error('Chnage ext conn failed, detail message: %s', error_msg)
 247         self.vnf_insts.update(status=VNF_STATUS.FAILED,
 248                               lastuptime=now_time())
 249         JobUtil.add_job_status(self.job_id, 255, error_msg)