lcm/ns/sfcs/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.ns.sfcs.utils import get_fp_model_by_fp_inst_id
  20 from lcm.pub.database.models import FPInstModel, NfInstModel, CPInstModel, PortInstModel, VNFCInstModel
  21 from lcm.pub.msapi import extsys
  22 from lcm.pub.msapi import sdncdriver
  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["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"]