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
  25 from lcm.pub.msapi.aai import create_network_aai, create_subnet_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.save_vl_to_db()
  59             if REPORT_TO_AAI:
  60                 self.create_network_aai()
  61             return {"result": 0, "detail": "instantiation vl success", "vlId": self.vl_inst_id}
  62         except NSLCMException as e:
  63             return self.exception_handle(e)
  64         except Exception as e:
  65             logger.error(traceback.format_exc())
  66             return self.exception_handle(e)
  67
  68     def exception_handle(self, e):
  69         detail = "vl instantiation failed, detail message: %s" % e.args[0]
  70         logger.error(detail)
  71         return {"result": 1, "detail": detail, "vlId": self.vl_inst_id}
  72
  73     def get_data(self):
  74         if isinstance(self.context, str):
  75             self.context = json.JSONDecoder().decode(self.context)
  76         vl_info = self.get_vl_info(ignore_case_get(self.context, "vls"))
  77         self.vld_id = ignore_case_get(vl_info, "vl_id")
  78         self.description = ignore_case_get(vl_info, "description")
  79         self.vl_properties = ignore_case_get(vl_info, "properties")
  80         self.vl_profile = ignore_case_get(self.vl_properties, "vl_profile")
  81         self.vl_inst_name = ignore_case_get(self.vl_profile, "networkName")
  82         self.route_external = ignore_case_get(vl_info, "route_external")
  83         ns_info = NSInstModel.objects.filter(id=self.owner_id)
  84         self.ns_name = ns_info[0].name if ns_info else ""
  85
  86     def get_vl_info(self, vl_all_info):
  87         return vl_all_info[self.index - 1]
  88
  89     def create_vl_to_vim(self):
  90         self.vim_id = self.vl_properties["location_info"]["vimid"]
  91         if not self.vim_id:
  92             if isinstance(self.additionalParam, str):
  93                 self.additionalParam = json.JSONDecoder().decode(self.additionalParam)
  94             self.vim_id = ignore_case_get(self.additionalParam, "location")
  95         self.tenant = ignore_case_get(self.vl_properties["location_info"], "tenant")
  96         network_data = {
  97             "tenant": self.tenant,
  98             "network_name": self.vl_profile.get("networkName", ""),
  99             "shared": const.SHARED_NET,
 100             "network_type": self.vl_profile.get("networkType", ""),
 101             "segmentation_id": self.vl_profile.get("segmentationId", ""),
 102             "physical_network": self.vl_profile.get("physicalNetwork", ""),
 103             "mtu": self.vl_profile.get("mtu", const.DEFAULT_MTU),
 104             "vlan_transparent": self.vl_profile.get("vlanTransparent", False),
 105             "subnet_list": [{
 106                 "subnet_name": self.vl_profile.get("networkName"),  # self.vl_profile.get("initiationParameters").get("name", ""),
 107                 "cidr": self.vl_profile.get("cidr", "192.168.0.0/24"),
 108                 "ip_version": self.vl_profile.get("ip_version", const.IPV4),
 109                 "enable_dhcp": self.vl_profile.get("dhcpEnabled", False),
 110                 "gateway_ip": self.vl_profile.get("gatewayIp", ""),
 111                 "dns_nameservers": self.vl_profile.get("dns_nameservers", ""),
 112                 "host_routes": self.vl_profile.get("host_routes", "")}]}
 113         startip = self.vl_profile.get("startIp", "")
 114         endip = self.vl_profile.get("endIp", "")
 115         if startip and endip:
 116             network_data["subnet_list"][0]["allocation_pools"] = [
 117                 {"start": startip, "end": endip}]
 118
 119         vl_resp = self.create_network_to_vim(network_data)
 120         self.related_network_id = vl_resp["id"]
 121         self.related_subnetwork_id = vl_resp["subnet_list"][0]["id"] if vl_resp["subnet_list"] else ""
 122
 123     def create_network_to_vim(self, network_data):
 124         vim_resp_body = extsys.get_vim_by_id(self.vim_id)
 125         self.vim_name = vim_resp_body["name"]
 126         data = {
 127             "vimid": self.vim_id,
 128             "vimtype": vim_resp_body["type"],
 129             "url": vim_resp_body["url"],
 130             "user": vim_resp_body["userName"],
 131             "passwd": vim_resp_body["password"],
 132             "tenant": vim_resp_body["tenant"]}
 133         vim_api = vimadaptor.VimAdaptor(data)
 134         if not network_data["tenant"]:
 135             network_data["tenant"] = vim_resp_body["tenant"]
 136         vl_ret = vim_api.create_network(network_data)
 137         if vl_ret[0] != 0:
 138             logger.error("Send post vl request to vim failed, detail is %s" % vl_ret[1])
 139             raise NSLCMException("Send post vl request to vim failed.")
 140         return vl_ret[1]
 141
 142     def create_vl_inst_id_in_vnffg(self):
 143         if "vnffgs" in self.context:
 144             for vnffg_info in self.context["vnffgs"]:
 145                 vl_id_list = vnffg_info.get("properties", {}).get("dependent_virtual_link", "")
 146                 if vl_id_list:
 147                     vl_inst_id_list = []
 148                     for vl_id in vl_id_list:
 149                         vl_inst_info = VLInstModel.objects.filter(vldid=vl_id)
 150                         if vl_inst_info:
 151                             vl_inst_id_list.append(vl_inst_info[0].vlinstanceid)
 152                         else:
 153                             vl_inst_id_list.append("")
 154                     vl_inst_id_str = ""
 155                     for vl_inst_id in vl_inst_id_list:
 156                         vl_inst_id_str += vl_inst_id + ","
 157                     vl_inst_id_str = vl_inst_id_str[:-1]
 158                     VNFFGInstModel.objects.filter(vnffgdid=vnffg_info["vnffg_id"], nsinstid=self.owner_id).update(
 159                         vllist=vl_inst_id_str)
 160
 161     def save_vl_to_db(self):
 162         vim_id = json.JSONEncoder().encode(self.vim_id)
 163         VLInstModel(vlinstanceid=self.vl_inst_id, vldid=self.vld_id, vlinstancename=self.vl_inst_name,
 164                     ownertype=self.owner_type, ownerid=self.owner_id, relatednetworkid=self.related_network_id,
 165                     relatedsubnetworkid=self.related_subnetwork_id, vimid=vim_id, tenant=self.tenant).save()
 166         # do_biz_with_share_lock("create-vllist-in-vnffg-%s" % self.owner_id, self.create_vl_inst_id_in_vnffg)
 167         self.create_vl_inst_id_in_vnffg()
 168
 169     def create_network_aai(self):
 170         logger.debug("CreateVls::create_network_in_aai::report network[%s] to aai." % self.vl_inst_id)
 171         try:
 172             ns_insts = NSInstModel.objects.filter(id=self.owner_id)
 173             self.global_customer_id = ns_insts[0].global_customer_id
 174             self.service_type = ns_insts[0].service_type
 175             data = {
 176                 "network-id": self.vl_inst_id,
 177                 "network-name": self.vl_inst_id,
 178                 "is-bound-to-vpn": False,
 179                 "is-provider-network": True,
 180                 "is-shared-network": True,
 181                 "is-external-network": True,
 182                 # "subnets": {
 183                 #     "subnet": [
 184                 #         {
 185                 #             "subnet-id": self.related_subnetwork_id,
 186                 #             "dhcp-enabled": False
 187                 #         }
 188                 #     ]
 189                 # },
 190                 "relationship-list": {
 191                     "relationship": [
 192                         {
 193                             "related-to": "service-instance",
 194                             "relationship-data": [
 195                                 {
 196                                     "relationship-key": "customer.global-customer-id",
 197                                     "relationship-value": self.global_customer_id
 198                                 },
 199                                 {
 200                                     "relationship-key": "service-subscription.service-type",
 201                                     "relationship-value": self.service_type
 202                                 },
 203                                 {
 204                                     "relationship-key": "service-instance.service-instance-id",
 205                                     "relationship-value": self.owner_id
 206                                 }
 207                             ]
 208                         }
 209                     ]
 210                 }
 211             }
 212             resp_data, resp_status = create_network_aai(self.vl_inst_id, data)
 213             logger.debug("Success to create network[%s] to aai: [%s].", self.vl_inst_id, resp_status)
 214         except NSLCMException as e:
 215             logger.debug("Fail to create network[%s] to aai, detail message: %s" % (self.vl_inst_id, e.args[0]))
 216         except:
 217             logger.error(traceback.format_exc())
 218
 219     def create_subnet_in_aai(self):
 220         logger.debug("CreateVls::create_subnet_in_aai::report subnet[%s] to aai." % self.related_subnetwork_id)
 221         try:
 222             data = {
 223                 "subnets": {
 224                     "subnet": [
 225                         {
 226                             "subnet-id": self.related_subnetwork_id,
 227                             "dhcp-enabled": False
 228                         }
 229                     ]
 230                 },
 231             }
 232             resp_data, resp_status = create_subnet_aai(self.vl_inst_id, self.related_subnetwork_id, data)
 233             logger.debug("Success to create subnet[%s] to aai: [%s].", self.related_subnetwork_id, resp_status)
 234         except NSLCMException as e:
 235             logger.debug("Fail to create subnet[%s] to aai, detail message: %s" % (
 236                 self.related_subnetwork_id, e.args[0]))
 237         except:
 238             logger.error(traceback.format_exc())