1 # Copyright 2016-2017 ZTE Corporation.
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
7 # http://www.apache.org/licenses/LICENSE-2.0
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.
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
30 logger = logging.getLogger(__name__)
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
42 self.vl_properties = ""
44 self.vl_inst_name = ""
45 self.related_network_id = ""
46 self.related_subnetwork_id = ""
51 self.route_external = ""
57 self.create_vl_to_vim()
58 self.create_vl_to_resmgr()
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)
69 def exception_handle(self, e):
70 detail = "vl instantiation failed, detail message: %s" % e.message
72 return {"result": 1, "detail": detail, "vlId": self.vl_inst_id}
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 ""
87 def get_vl_info(self, vl_all_info):
88 return vl_all_info[self.index - 1]
90 def create_vl_to_vim(self):
91 self.vim_id = self.vl_properties["location_info"]["vimid"]
93 self.vim_id = ignore_case_get(self.additionalParam, "location")
94 self.tenant = ignore_case_get(self.vl_properties["location_info"], "tenant")
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),
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}]
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 ""
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"]
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)
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.")
141 def create_vl_to_resmgr(self):
142 self.vim_id = json.JSONDecoder().decode(self.vim_id) if isinstance(self.vim_id, (str, unicode)) else self.vim_id
143 vim_id = self.vim_id['cloud_owner'] + self.vim_id['cloud_regionid']
145 "vlInstanceId": self.vl_inst_id,
146 "name": self.vl_profile.get("networkName", ""),
147 "backendId": str(self.related_network_id),
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": "",
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", "")
173 resmgr.create_vl(req_param)
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", "")
181 for vl_id in vl_id_list:
182 vl_inst_info = VLInstModel.objects.filter(vldid=vl_id)
184 vl_inst_id_list.append(vl_inst_info[0].vlinstanceid)
186 vl_inst_id_list.append("")
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)
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()
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)
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
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,
218 "subnet-id": self.related_subnetwork_id,
219 "dhcp-enabled": False
223 "relationship-list": {
226 "related-to": "service-instance",
227 "relationship-data": [
229 "relationship-key": "customer.global-customer-id",
230 "relationship-value": self.global_customer_id
233 "relationship-key": "service-subscription.service-type",
234 "relationship-value": self.service_type
237 "relationship-key": "service-instance.service-instance-id",
238 "relationship-value": self.owner_id
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))
250 logger.error(traceback.format_exc())