lcm/ns_vls/biz/create_vls.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
  15 import json
  16 import logging
  17 import traceback
  18 import uuid
  19
  20 from lcm.ns.enum import OWNER_TYPE
  21 from lcm.pub.config.config import REPORT_TO_AAI
  22 from lcm.pub.database.models import VLInstModel, NSInstModel, VNFFGInstModel
  23 from lcm.pub.exceptions import NSLCMException
  24 from lcm.pub.msapi import extsys, resmgr
  25 from lcm.pub.msapi.aai import create_network_aai
  26 from lcm.pub.nfvi.vim import const
  27 from lcm.pub.nfvi.vim import vimadaptor
  28 from lcm.pub.utils.values import ignore_case_get
  29
  30 logger = logging.getLogger(__name__)
  31
  32
  33 class CreateVls(object):
  34     def __init__(self, data):
  35         self.owner_id = ignore_case_get(data, "nsInstanceId")
  36         self.index = int(float(ignore_case_get(data, "vlIndex")))
  37         self.context = ignore_case_get(data, "context")
  38         self.additionalParam = ignore_case_get(data, "additionalParamForNs")
  39         self.vl_inst_id = str(uuid.uuid4())
  40         self.owner_type = OWNER_TYPE.NS
  41         self.vld_id = ""
  42         self.vl_properties = ""
  43         self.vl_profile = ""
  44         self.vl_inst_name = ""
  45         self.related_network_id = ""
  46         self.related_subnetwork_id = ""
  47         self.vim_id = ""
  48         self.vim_name = ""
  49         self.tenant = ""
  50         self.description = ""
  51         self.route_external = ""
  52         self.ns_name = ""
  53
  54     def do(self):
  55         try:
  56             self.get_data()
  57             self.create_vl_to_vim()
  58             self.create_vl_to_resmgr()
  59             self.save_vl_to_db()
  60             if REPORT_TO_AAI:
  61                 self.create_network_and_subnet_in_aai()
  62             return {"result": 0, "detail": "instantiation vl success", "vlId": self.vl_inst_id}
  63         except NSLCMException as e:
  64             return self.exception_handle(e)
  65         except Exception as e:
  66             logger.error(traceback.format_exc())
  67             return self.exception_handle(e)
  68
  69     def exception_handle(self, e):
  70         detail = "vl instantiation failed, detail message: %s" % e.message
  71         logger.error(detail)
  72         return {"result": 1, "detail": detail, "vlId": self.vl_inst_id}
  73
  74     def get_data(self):
  75         if isinstance(self.context, str):
  76             self.context = json.JSONDecoder().decode(self.context)
  77         vl_info = self.get_vl_info(ignore_case_get(self.context, "vls"))
  78         self.vld_id = ignore_case_get(vl_info, "vl_id")
  79         self.description = ignore_case_get(vl_info, "description")
  80         self.vl_properties = ignore_case_get(vl_info, "properties")
  81         self.vl_profile = ignore_case_get(self.vl_properties, "vl_profile")
  82         self.vl_inst_name = ignore_case_get(self.vl_profile, "networkName")
  83         self.route_external = ignore_case_get(vl_info, "route_external")
  84         ns_info = NSInstModel.objects.filter(id=self.owner_id)
  85         self.ns_name = ns_info[0].name if ns_info else ""
  86
  87     def get_vl_info(self, vl_all_info):
  88         return vl_all_info[self.index - 1]
  89
  90     def create_vl_to_vim(self):
  91         self.vim_id = self.vl_properties["location_info"]["vimid"]
  92         if not self.vim_id:
  93             self.vim_id = ignore_case_get(self.additionalParam, "location")
  94         self.tenant = ignore_case_get(self.vl_properties["location_info"], "tenant")
  95         network_data = {
  96             "tenant": self.tenant,
  97             "network_name": self.vl_profile.get("networkName", ""),
  98             "shared": const.SHARED_NET,
  99             "network_type": self.vl_profile.get("networkType", ""),
 100             "segmentation_id": self.vl_profile.get("segmentationId", ""),
 101             "physical_network": self.vl_profile.get("physicalNetwork", ""),
 102             "mtu": self.vl_profile.get("mtu", const.DEFAULT_MTU),
 103             "vlan_transparent": self.vl_profile.get("vlanTransparent", False),
 104             "subnet_list": [{
 105                 "subnet_name": self.vl_profile.get("networkName"),  # self.vl_profile.get("initiationParameters").get("name", ""),
 106                 "cidr": self.vl_profile.get("cidr", "192.168.0.0/24"),
 107                 "ip_version": self.vl_profile.get("ip_version", const.IPV4),
 108                 "enable_dhcp": self.vl_profile.get("dhcpEnabled", False),
 109                 "gateway_ip": self.vl_profile.get("gatewayIp", ""),
 110                 "dns_nameservers": self.vl_profile.get("dns_nameservers", ""),
 111                 "host_routes": self.vl_profile.get("host_routes", "")}]}
 112         startip = self.vl_profile.get("startIp", "")
 113         endip = self.vl_profile.get("endIp", "")
 114         if startip and endip:
 115             network_data["subnet_list"][0]["allocation_pools"] = [
 116                 {"start": startip, "end": endip}]
 117
 118         vl_resp = self.create_network_to_vim(network_data)
 119         self.related_network_id = vl_resp["id"]
 120         self.related_subnetwork_id = vl_resp["subnet_list"][0]["id"] if vl_resp["subnet_list"] else ""
 121
 122     def create_network_to_vim(self, network_data):
 123         vim_resp_body = extsys.get_vim_by_id(self.vim_id)
 124         self.vim_name = vim_resp_body["name"]
 125         data = {
 126             "vimid": self.vim_id,
 127             "vimtype": vim_resp_body["type"],
 128             "url": vim_resp_body["url"],
 129             "user": vim_resp_body["userName"],
 130             "passwd": vim_resp_body["password"],
 131             "tenant": vim_resp_body["tenant"]}
 132         vim_api = vimadaptor.VimAdaptor(data)
 133         if not network_data["tenant"]:
 134             network_data["tenant"] = vim_resp_body["tenant"]
 135         vl_ret = vim_api.create_network(network_data)
 136         if vl_ret[0] != 0:
 137             logger.error("Send post vl request to vim failed, detail is %s" % vl_ret[1])
 138             raise NSLCMException("Send post vl request to vim failed.")
 139         return vl_ret[1]
 140
 141     def create_vl_to_resmgr(self):
 142         self.vim_id = json.JSONDecoder().decode(self.vim_id) if isinstance(self.vim_id, str) else self.vim_id
 143         vim_id = self.vim_id['cloud_owner'] + self.vim_id['cloud_regionid']
 144         req_param = {
 145             "vlInstanceId": self.vl_inst_id,
 146             "name": self.vl_profile.get("networkName", ""),
 147             "backendId": str(self.related_network_id),
 148             "isPublic": "True",
 149             "dcName": "",
 150             "vimId": str(vim_id),
 151             "vimName": self.vim_name,
 152             "physicialNet": self.vl_profile.get("physicalNetwork", ""),
 153             "nsId": self.owner_id,
 154             "nsName": self.ns_name,
 155             "description": self.description,
 156             "networkType": self.vl_profile.get("networkType", ""),
 157             "segmentation": str(self.vl_profile.get("segmentationId", "")),
 158             "mtu": str(self.vl_profile.get("mtu", "")),
 159             "vlanTransparent": str(self.vl_profile.get("vlanTransparent", "")),
 160             "routerExternal": self.route_external,
 161             "resourceProviderType": "",
 162             "resourceProviderId": "",
 163             "subnet_list": [{
 164                 "subnet_name": self.vl_profile.get("networkName", ""),  # self.vl_profile.get("initiationParameters").get("name", ""),
 165                 "cidr": self.vl_profile.get("cidr", "192.168.0.0/24"),
 166                 "ip_version": self.vl_profile.get("ip_version", const.IPV4),
 167                 "enable_dhcp": self.vl_profile.get("dhcpEnabled", False),
 168                 "gateway_ip": self.vl_profile.get("gatewayIp", ""),
 169                 "dns_nameservers": self.vl_profile.get("dns_nameservers", ""),
 170                 "host_routes": self.vl_profile.get("host_routes", "")
 171             }]
 172         }
 173         resmgr.create_vl(req_param)
 174
 175     def create_vl_inst_id_in_vnffg(self):
 176         if "vnffgs" in self.context:
 177             for vnffg_info in self.context["vnffgs"]:
 178                 vl_id_list = vnffg_info.get("properties", {}).get("dependent_virtual_link", "")
 179                 if vl_id_list:
 180                     vl_inst_id_list = []
 181                     for vl_id in vl_id_list:
 182                         vl_inst_info = VLInstModel.objects.filter(vldid=vl_id)
 183                         if vl_inst_info:
 184                             vl_inst_id_list.append(vl_inst_info[0].vlinstanceid)
 185                         else:
 186                             vl_inst_id_list.append("")
 187                     vl_inst_id_str = ""
 188                     for vl_inst_id in vl_inst_id_list:
 189                         vl_inst_id_str += vl_inst_id + ","
 190                     vl_inst_id_str = vl_inst_id_str[:-1]
 191                     VNFFGInstModel.objects.filter(vnffgdid=vnffg_info["vnffg_id"], nsinstid=self.owner_id).update(
 192                         vllist=vl_inst_id_str)
 193
 194     def save_vl_to_db(self):
 195         vim_id = json.JSONEncoder().encode(self.vim_id)
 196         VLInstModel(vlinstanceid=self.vl_inst_id, vldid=self.vld_id, vlinstancename=self.vl_inst_name,
 197                     ownertype=self.owner_type, ownerid=self.owner_id, relatednetworkid=self.related_network_id,
 198                     relatedsubnetworkid=self.related_subnetwork_id, vimid=vim_id, tenant=self.tenant).save()
 199         # do_biz_with_share_lock("create-vllist-in-vnffg-%s" % self.owner_id, self.create_vl_inst_id_in_vnffg)
 200         self.create_vl_inst_id_in_vnffg()
 201
 202     def create_network_and_subnet_in_aai(self):
 203         logger.debug("CreateVls::create_network_in_aai::report network[%s] to aai." % self.vl_inst_id)
 204         try:
 205             ns_insts = NSInstModel.objects.filter(id=self.owner_id)
 206             self.global_customer_id = ns_insts[0].global_customer_id
 207             self.service_type = ns_insts[0].service_type
 208             data = {
 209                 "network-id": self.vl_inst_id,
 210                 "network-name": self.vl_inst_name,
 211                 "is-bound-to-vpn": False,
 212                 "is-provider-network": True,
 213                 "is-shared-network": True,
 214                 "is-external-network": True,
 215                 "subnets": {
 216                     "subnet": [
 217                         {
 218                             "subnet-id": self.related_subnetwork_id,
 219                             "dhcp-enabled": False
 220                         }
 221                     ]
 222                 },
 223                 "relationship-list": {
 224                     "relationship": [
 225                         {
 226                             "related-to": "service-instance",
 227                             "relationship-data": [
 228                                 {
 229                                     "relationship-key": "customer.global-customer-id",
 230                                     "relationship-value": self.global_customer_id
 231                                 },
 232                                 {
 233                                     "relationship-key": "service-subscription.service-type",
 234                                     "relationship-value": self.service_type
 235                                 },
 236                                 {
 237                                     "relationship-key": "service-instance.service-instance-id",
 238                                     "relationship-value": self.owner_id
 239                                 }
 240                             ]
 241                         }
 242                     ]
 243                 }
 244             }
 245             resp_data, resp_status = create_network_aai(self.vl_inst_id, data)
 246             logger.debug("Success to create network[%s] to aai: [%s].", self.vl_inst_id, resp_status)
 247         except NSLCMException as e:
 248             logger.debug("Fail to create network[%s] to aai, detail message: %s" % (self.vl_inst_id, e.message))
 249         except:
 250             logger.error(traceback.format_exc())