lcm/ns/vls/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.const 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, (unicode, 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("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         req_param = {
 143             "vlInstanceId": self.vl_inst_id,
 144             "name": self.vl_profile.get("networkName", ""),
 145             "backendId": str(self.related_network_id),
 146             "isPublic": "True",
 147             "dcName": "",
 148             "vimId": str(self.vim_id),
 149             "vimName": self.vim_name,
 150             "physicialNet": self.vl_profile.get("physicalNetwork", ""),
 151             "nsId": self.owner_id,
 152             "nsName": self.ns_name,
 153             "description": self.description,
 154             "networkType": self.vl_profile.get("networkType", ""),
 155             "segmentation": str(self.vl_profile.get("segmentationId", "")),
 156             "mtu": str(self.vl_profile.get("mtu", "")),
 157             "vlanTransparent": str(self.vl_profile.get("vlanTransparent", "")),
 158             "routerExternal": self.route_external,
 159             "resourceProviderType": "",
 160             "resourceProviderId": "",
 161             "subnet_list": [{
 162                 "subnet_name": self.vl_profile.get("initiationParameters").get("name", ""),
 163                 "cidr": self.vl_profile.get("cidr", "192.168.0.0/24"),
 164                 "ip_version": self.vl_profile.get("ip_version", const.IPV4),
 165                 "enable_dhcp": self.vl_profile.get("dhcpEnabled", False),
 166                 "gateway_ip": self.vl_profile.get("gatewayIp", ""),
 167                 "dns_nameservers": self.vl_profile.get("dns_nameservers", ""),
 168                 "host_routes": self.vl_profile.get("host_routes", "")
 169             }]
 170         }
 171         resmgr.create_vl(req_param)
 172
 173     def create_vl_inst_id_in_vnffg(self):
 174         if "vnffgs" in self.context:
 175             for vnffg_info in self.context["vnffgs"]:
 176                 vl_id_list = vnffg_info.get("properties", {}).get("dependent_virtual_link", "")
 177                 if vl_id_list:
 178                     vl_inst_id_list = []
 179                     for vl_id in vl_id_list:
 180                         vl_inst_info = VLInstModel.objects.filter(vldid=vl_id)
 181                         if vl_inst_info:
 182                             vl_inst_id_list.append(vl_inst_info[0].vlinstanceid)
 183                         else:
 184                             vl_inst_id_list.append("")
 185                     vl_inst_id_str = ""
 186                     for vl_inst_id in vl_inst_id_list:
 187                         vl_inst_id_str += vl_inst_id + ","
 188                     vl_inst_id_str = vl_inst_id_str[:-1]
 189                     VNFFGInstModel.objects.filter(vnffgdid=vnffg_info["vnffg_id"], nsinstid=self.owner_id).update(
 190                         vllist=vl_inst_id_str)
 191
 192     def save_vl_to_db(self):
 193         VLInstModel(vlinstanceid=self.vl_inst_id, vldid=self.vld_id, vlinstancename=self.vl_inst_name,
 194                     ownertype=self.owner_type, ownerid=self.owner_id, relatednetworkid=self.related_network_id,
 195                     relatedsubnetworkid=self.related_subnetwork_id, vimid=self.vim_id, tenant=self.tenant).save()
 196         # do_biz_with_share_lock("create-vllist-in-vnffg-%s" % self.owner_id, self.create_vl_inst_id_in_vnffg)
 197         self.create_vl_inst_id_in_vnffg()
 198
 199     def create_network_and_subnet_in_aai(self):
 200         logger.debug("CreateVls::create_network_in_aai::report network[%s] to aai." % self.vl_inst_id)
 201         try:
 202             ns_insts = NSInstModel.objects.filter(id=self.owner_id)
 203             self.global_customer_id = ns_insts[0].global_customer_id
 204             self.service_type = ns_insts[0].service_type
 205             data = {
 206                 "network-id": self.vl_inst_id,
 207                 "network-name": self.vl_inst_name,
 208                 "is-bound-to-vpn": False,
 209                 "is-provider-network": True,
 210                 "is-shared-network": True,
 211                 "is-external-network": True,
 212                 "subnets": {
 213                     "subnet": [
 214                         {
 215                             "subnet-id": self.related_subnetwork_id,
 216                             "dhcp-enabled": False
 217                         }
 218                     ]
 219                 },
 220                 "relationship-list": {
 221                     "relationship": [
 222                         {
 223                             "related-to": "service-instance",
 224                             "relationship-data": [
 225                                 {
 226                                     "relationship-key": "customer.global-customer-id",
 227                                     "relationship-value": self.global_customer_id
 228                                 },
 229                                 {
 230                                     "relationship-key": "service-subscription.service-type",
 231                                     "relationship-value": self.service_type
 232                                 },
 233                                 {
 234                                     "relationship-key": "service-instance.service-instance-id",
 235                                     "relationship-value": self.owner_id
 236                                 }
 237                             ]
 238                         }
 239                     ]
 240                 }
 241             }
 242             resp_data, resp_status = create_network_aai(self.vl_inst_id, data)
 243             logger.debug("Success to create network[%s] to aai: [%s].", self.vl_inst_id, resp_status)
 244         except NSLCMException as e:
 245             logger.debug("Fail to create network[%s] to aai, detail message: %s" % (self.vl_inst_id, e.message))
 246         except:
 247             logger.error(traceback.format_exc())