lcm/ns_sfcs/biz/create_portpairgp.py

   1 # Copyright 2016 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
  16 import json
  17 import logging
  18
  19 from lcm.pub.database.models import FPInstModel, NfInstModel, CPInstModel, PortInstModel, VNFCInstModel
  20 from lcm.pub.msapi import extsys
  21 from lcm.pub.msapi import sdncdriver
  22 from lcm.ns_sfcs.biz.utils import get_fp_model_by_fp_inst_id
  23
  24 logger = logging.getLogger(__name__)
  25
  26
  27 class CreatePortPairGroup(object):
  28     def __init__(self, data):
  29         self.fp_inst_id = data["fpinstid"]
  30         self.ns_model_data = data["ns_model_data"]
  31         self.ns_inst_id = data["nsinstid"]
  32         self.fp_model = get_fp_model_by_fp_inst_id(self.ns_model_data,
  33                                                    self.fp_inst_id)
  34         self.port_pair_groups = []
  35         self.port_pair_group_db_infos = []
  36         self.sdncontrollerid = ""
  37
  38     def do_biz(self):
  39         logger.info("CreatePortPairGroup start")
  40         self.init_port_pair_group(self.fp_model)
  41         self.create_port_pair_and_groups()
  42         self.save_port_pair_group_info_2_db()
  43         logger.info("CreatePortPairGroup end")
  44
  45     def create_port_pair_and_groups(self):
  46         for port_pair_group_info in self.port_pair_groups:
  47             port_pairs_info = port_pair_group_info.get("portpair")
  48             port_pair_ids = []
  49             for port_pair_info in port_pairs_info:
  50                 port_pair_ids.append(self.create_port_pair(port_pair_info))
  51             self.create_port_pair_and_group(port_pair_ids)
  52
  53     def save_port_pair_group_info_2_db(self):
  54         logger.info("portpairgroups in fpinstmodel:%s" % self.port_pair_group_db_infos)
  55         FPInstModel.objects.filter(fpinstid=self.fp_inst_id).update(
  56             portpairgroups=json.JSONEncoder().encode(self.port_pair_group_db_infos))
  57
  58     def create_port_pair_and_group(self, port_pair_ids):
  59         # url = const.port_pair_group_url
  60         port_pair_group = {
  61             "sdnControllerId": self.sdncontrollerid,
  62             "url": extsys.get_sdn_controller_by_id(self.sdncontrollerid)["url"],
  63             "portPairs": port_pair_ids
  64         }
  65         port_pair_group_id = sdncdriver.create_port_pair_group(port_pair_group)
  66         port_pair_group_info = {
  67             "groupid": port_pair_group_id,
  68             "portpair": port_pair_ids}
  69
  70         self.port_pair_group_db_infos.append(port_pair_group_info)
  71
  72     def create_port_pair(self, port_pair_info):
  73         # url = const.port_pair_url
  74         port_pair_info.update({
  75             "sdnControllerId": self.sdncontrollerid,
  76             "url": extsys.get_sdn_controller_by_id(self.sdncontrollerid)["url"]})
  77         return sdncdriver.create_port_pair(port_pair_info)
  78
  79     def init_port_pair_group(self, fp_model):
  80         forwarder_list = fp_model["forwarder_list"]
  81         self.sdncontrollerid = FPInstModel.objects.filter(fpinstid=self.fp_inst_id).get().sdncontrollerid
  82         index = 0
  83         while index < len(forwarder_list):
  84             if (forwarder_list[index]["type"] == "cp"):
  85                 index += self.generate_port_pair_group_cp(index, forwarder_list)
  86             else:
  87                 index += self.generate_port_pair_group_vnf(index, forwarder_list)
  88             index += 1
  89
  90         logger.info("port pair group: %s" % self.port_pair_groups)
  91
  92     def generate_port_pair_group_cp(self, index, forwarder_list):
  93         cur_forwarder = forwarder_list[index]["node_name"]
  94         cur_cp_model_info = self.get_cp_model_info_by_cpid(cur_forwarder)
  95         if (index < len(forwarder_list) - 1 and forwarder_list[index + 1]["type"] == "cp"):
  96             next_forward = forwarder_list[index + 1]["node_name"]
  97             next_cp_model_info = self.get_cp_model_info_by_cpid(next_forward)
  98             if (cur_cp_model_info["pnf_id"] == next_cp_model_info["pnf_id"]):  # same port pair group
  99                 self.generate_port_pair_group_type_cp(cur_cp_model_info, next_cp_model_info)
 100                 return 1
 101         self.generate_port_pair_group_type_cp(cur_cp_model_info, cur_cp_model_info)
 102         return 0
 103
 104     def generate_port_pair_group_vnf(self, index, forwarder_list):
 105         incre = 0
 106         cur_vnf_id = forwarder_list[index]["node_name"]
 107         cur_forwarder = forwarder_list[index]["capability"]
 108         self.vnf_model_in_ns_info = self.get_vnf_model_info_by_vnf_id(cur_vnf_id)
 109         vnf_inst_database_info = NfInstModel.objects.filter(vnf_id=self.vnf_model_in_ns_info["vnf_id"],
 110                                                             ns_inst_id=self.ns_inst_id).get()
 111         self.vnf_inst_database_info = vnf_inst_database_info
 112         logger.info("VNFD MODEL : %s" % vnf_inst_database_info.vnfd_model)
 113         vnfd_model_info = json.loads(vnf_inst_database_info.vnfd_model)
 114         # vnfd_model_info = json.dumps(vnf_inst_database_info.vnfd_model)
 115         # vnfd_model_info = json.dumps(self.vnf_inst_database_info.vnfd_model)
 116         self.vnfd_model_info = vnfd_model_info
 117         logger.info("forward list: %s" % forwarder_list)
 118         logger.info("current fowarder : %s" % cur_forwarder)
 119         cpd_id = self.get_cpdid_info_forwarder(vnfd_model_info, cur_forwarder)
 120         self.cp_model_in_vnf = self.get_cp_from_vnfd_model(cpd_id)
 121         vnfc_inst_infos = VNFCInstModel.objects.filter(nfinstid=vnf_inst_database_info.nfinstid)
 122         if not vnfc_inst_infos:
 123             logger.error("VNFCInstModel is None")
 124             return 0
 125         logger.info("vnfc instance id: %s" % vnfc_inst_infos.get().vnfcinstanceid)
 126         logger.info("cpd id: %s" % cpd_id)
 127         cp_inst_infos = []
 128         for vnfc_inst_info in vnfc_inst_infos:
 129             cp_db_info = CPInstModel.objects.filter(cpdid=cpd_id,
 130                                                     # ownertype=OWNER_TYPE.VNF,
 131                                                     ownertype=3,
 132                                                     ownerid=vnfc_inst_info.vnfcinstanceid).get()
 133             if cp_db_info:
 134                 cp_inst_infos.append(cp_db_info)
 135         if not cp_inst_infos:
 136             logger.error("CPInstModel is None")
 137             return 0
 138         logger.info("cp info : %s" % cp_inst_infos)
 139         port_pairs = []
 140         if (index < len(forwarder_list) - 1 and forwarder_list[index + 1]["type"] == "vnf"):
 141             next_vnf_id = forwarder_list[index + 1]["node_name"]
 142             if (cur_vnf_id != next_vnf_id):
 143                 for cp_inst_info in cp_inst_infos:
 144                     port_pairs.append(self.generate_port_pair_group(cp_inst_info, cp_inst_info))
 145             else:
 146                 next_forwarder = forwarder_list[index]["capability"]
 147                 next_forwarder_cpd_id = self.get_cpdid_info_forwarder(vnfd_model_info, next_forwarder)
 148
 149                 vnfc_inst_infos = VNFCInstModel.objects.filter(nfinstid=vnf_inst_database_info.nfinstid)
 150
 151                 if not vnfc_inst_infos:
 152                     logger.error("VNFCInstModel is None")
 153                     return 0
 154                 next_cp_inst_infos = []
 155                 for vnfc_inst_info in vnfc_inst_infos:
 156                     next_cp_db_info = CPInstModel.objects.filter(cpdid=next_forwarder_cpd_id,
 157                                                                  # ownertype=OWNER_TYPE.VNF,
 158                                                                  ownertype=3,
 159                                                                  ownerid=vnfc_inst_info.vnfcinstanceid).get()
 160                     if next_cp_db_info:
 161                         next_cp_inst_infos.append(next_cp_db_info)
 162
 163                 port_pairs.append(self.generate_port_pair_group(cp_inst_infos[0], next_cp_inst_infos[0]))
 164                 incre = 1
 165
 166         else:
 167             for cp_inst_info in cp_inst_infos:
 168                 port_pairs.append(self.generate_port_pair_group(cp_inst_info, cp_inst_info))
 169         self.port_pair_groups.append(
 170             {
 171                 "portpair": port_pairs
 172             }
 173         )
 174         return incre
 175
 176     def generate_port_pair_group_type_cp(self, ingress_cp_model_info, egress_cp_model_info):
 177         sf_type = ""
 178         request_reclassification = False
 179         nsh_aware = True
 180         sf_param = {}
 181         if ingress_cp_model_info["pnf_id"] == "":
 182             pass
 183         else:
 184             pnf_model_info = self.get_pnf_model_info_by_cpid(ingress_cp_model_info["pnf_id"])
 185             sf_type = "pnf_" + pnf_model_info["properties"]["pnf_type"]
 186             nsh_aware = pnf_model_info["properties"]["nsh_aware"]
 187             request_reclassification = pnf_model_info["properties"]["request_reclassification"]
 188             sf_param = pnf_model_info["properties"]
 189         sf_param["mng-address"] = pnf_model_info["properties"]["management_address"]
 190         port_pair_info = {
 191             "sfType": sf_type,
 192             "nshAware": nsh_aware,
 193             "requestReclassification": request_reclassification,
 194             "ingress": {
 195                 "encapsulation": ingress_cp_model_info["properties"]["sfc_encapsulation"],
 196                 "ip": ingress_cp_model_info["properties"]["ip_address"],
 197                 "mac": ingress_cp_model_info["properties"]["mac_address"],
 198                 "portName": ingress_cp_model_info["properties"].get("interface_name")
 199             },
 200             "egress": {
 201                 "encapsulation": egress_cp_model_info["properties"]["sfc_encapsulation"],
 202                 "ip": egress_cp_model_info["properties"]["ip_address"],
 203                 "mac": egress_cp_model_info["properties"]["mac_address"],
 204                 "portName": egress_cp_model_info["properties"].get("interface_name")
 205             },
 206             "sfParam": sf_param
 207         }
 208         self.port_pair_groups.append(
 209             {
 210                 "portpair": [port_pair_info]
 211             }
 212         )
 213
 214     def generate_port_pair_group(self, ingress_cp_inst_info, egress_cp_inst_info):
 215         if (ingress_cp_inst_info.relatedport != ""):
 216             ingress_port = ingress_cp_inst_info.relatedport
 217         else:
 218             ingress_port = CPInstModel.objects.filter(cpinstanceid=ingress_cp_inst_info.relatedcp,
 219                                                       ownertype="vnf",
 220                                                       ownerid=self.vnf_inst_database_info.nfinstid).get().relatedport
 221         if (egress_cp_inst_info.relatedport != ""):
 222             egress_port = egress_cp_inst_info.relatedport
 223         else:
 224             egress_port = CPInstModel.objects.filter(cpinstanceid=egress_cp_inst_info.relatedcp,
 225                                                      ownertype="vnf",
 226                                                      ownerid=self.vnf_inst_database_info.nfinstid).get().relatedport
 227         ingress_port_inst_info = PortInstModel.objects.filter(portid=ingress_port).get()
 228         egress_port_inst_info = PortInstModel.objects.filter(portid=egress_port).get()
 229
 230         port_pair_info = {
 231             "sfType": "vnf_" + self.vnf_model_in_ns_info["properties"]["vnf_type"],
 232             "nshAware": self.vnf_model_in_ns_info["properties"]["nsh_aware"],
 233             "requestReclassification": self.vnf_model_in_ns_info["properties"]["request_reclassification"],
 234             "ingress": {
 235                 "encapsulation": ingress_port_inst_info.sfcencapsulation,
 236                 "ip": ingress_port_inst_info.ipaddress,
 237                 "mac": ingress_port_inst_info.macaddress
 238             },
 239             "egress": {
 240                 "encapsulation": egress_port_inst_info.sfcencapsulation,
 241                 "ip": egress_port_inst_info.ipaddress,
 242                 "mac": egress_port_inst_info.macaddress
 243             },
 244             "sfParam": self.vnf_model_in_ns_info["properties"]
 245         }
 246         return port_pair_info
 247
 248     def get_cp_from_vnfd_model(self, cpdid):
 249         for cp_model in self.vnfd_model_info["cps"]:
 250             if cp_model["cp_id"] == cpdid:
 251                 return cp_model
 252
 253     def get_pnf_model_info_by_cpid(self, pnfid):
 254         for pnf_model_info in self.ns_model_data["pnfs"]:
 255             if (pnf_model_info["pnf_id"] == pnfid):
 256                 return pnf_model_info
 257
 258     def get_cp_model_info_by_cpid(self, cpid):
 259         for cp_model_info in self.ns_model_data["cps"]:
 260             if (cp_model_info["cp_id"] == cpid):
 261                 return cp_model_info
 262
 263     def get_vnf_model_info_by_vnf_id(self, vnfid):
 264         for vnf_model_info in self.ns_model_data["ns_vnfs"]:
 265             if (vnf_model_info["vnf_id"] == vnfid):
 266                 return vnf_model_info
 267
 268     def get_cpdid_info_forwarder(self, vnf_model, forwarder):
 269         logger.info("vnf_exposed %s" % type(vnf_model))
 270         # logger.info("vnf_exposed %s" % json.loads(vnf_model))
 271         # vnf_model = json.loads(vnf_model)
 272         logger.info("vnf_exposed %s" % type(vnf_model["vnf_exposed"]))
 273         logger.info("vnf_exposed %s" % vnf_model["vnf_exposed"])
 274         logger.info("foward_cps %s" % vnf_model["vnf_exposed"]["forward_cps"])
 275         for forwarder_info in vnf_model["vnf_exposed"]["forward_cps"]:
 276             if (forwarder_info["key_name"] == forwarder):
 277                 return forwarder_info["cp_id"]