lcm/pub/utils/toscaparser/nsdmodel.py

   1 import functools
   2
   3 from lcm.pub.utils.toscaparser.basemodel import BaseInfoModel
   4
   5
   6 class EtsiNsdInfoModel(BaseInfoModel):
   7
   8     def __init__(self, path, params):
   9         tosca = self.buildToscaTemplate(path, params)
  10         self.parseModel(tosca)
  11
  12     def parseModel(self, tosca):
  13         self.buidMetadata(tosca)
  14         if hasattr(tosca, 'topology_template') and hasattr(tosca.topology_template, 'inputs'):
  15             self.inputs = self.buildInputs(tosca.topology_template.inputs)
  16
  17         nodeTemplates = map(functools.partial(self.buildNode, inputs=tosca.inputs, parsed_params=tosca.parsed_params),
  18                             tosca.nodetemplates)
  19
  20         self.vnfs = self._get_all_vnf(nodeTemplates)
  21         self.pnfs = self._get_all_pnf(nodeTemplates)
  22         self.vls = self.get_all_vl(nodeTemplates)
  23         self.cps = self.get_all_cp(nodeTemplates)
  24         self.routers = self.get_all_router(nodeTemplates)
  25         self.fps = self._get_all_fp(nodeTemplates)
  26         self.vnffgs = self._get_all_vnffg(tosca.topology_template.groups)
  27         self.server_groups = self.get_all_server_group(tosca.topology_template.groups)
  28         self.ns_exposed = self.get_all_endpoint_exposed(tosca.topology_template)
  29
  30
  31     def buildInputs(self, top_inputs):
  32         ret = {}
  33         for tmpinput in top_inputs:
  34             tmp = {}
  35             tmp['type'] = tmpinput.type
  36             tmp['description'] = tmpinput.description
  37             tmp['default'] = tmpinput.default
  38
  39             ret[tmpinput.name] = tmp
  40         return ret
  41
  42     def buildNode(self, nodeTemplate, inputs, parsed_params):
  43         ret ={}
  44         ret['name'] = nodeTemplate.name
  45         ret['nodeType'] = nodeTemplate.type
  46         if 'description' in nodeTemplate.entity_tpl:
  47             ret['description'] = nodeTemplate.entity_tpl['description']
  48         else:
  49             ret['description'] = ''
  50         props = self.buildProperties(nodeTemplate, parsed_params)
  51         ret['properties'] = self.verify_properties(props, inputs, parsed_params)
  52         ret['requirements'] = self.build_requirements(nodeTemplate)
  53         self.buildCapabilities(nodeTemplate, inputs, ret)
  54         self.buildArtifacts(nodeTemplate, inputs, ret)
  55         interfaces = self.build_interfaces(nodeTemplate)
  56         if interfaces: ret['interfaces'] = interfaces
  57         return ret
  58
  59     def _get_all_vnf(self, nodeTemplates):
  60         vnfs = []
  61         for node in nodeTemplates:
  62             if self.isVnf(node):
  63                 vnf = {}
  64                 vnf['vnf_id'] = node['name']
  65                 vnf['description'] = node['description']
  66                 vnf['properties'] = node['properties']
  67                 vnf['dependencies'] = map(lambda x: self.get_requirement_node_name(x), self.getNodeDependencys(node))
  68                 vnf['networks'] = self.get_networks(node)
  69
  70                 vnfs.append(vnf)
  71         return vnfs
  72
  73     def _get_all_pnf(self, nodeTemplates):
  74         pnfs = []
  75         for node in nodeTemplates:
  76             if self.isPnf(node):
  77                 pnf = {}
  78                 pnf['pnf_id'] = node['name']
  79                 pnf['description'] = node['description']
  80                 pnf['properties'] = node['properties']
  81                 pnf['cps'] = self.getVirtalBindingCpIds(node, nodeTemplates)
  82
  83                 pnfs.append(pnf)
  84         return pnfs
  85
  86     def getVirtalBindingCpIds(self, node, nodeTemplates):
  87         return map(lambda x: x['name'], self.getVirtalBindingCps(node, nodeTemplates))
  88
  89     def getVirtalBindingCps(self, node, nodeTemplates):
  90         cps = []
  91         for tmpnode in nodeTemplates:
  92             if 'requirements' in tmpnode:
  93                 for item in tmpnode['requirements']:
  94                     for key, value in item.items():
  95                         if key.upper().startswith('VIRTUALBINDING'):
  96                             req_node_name = self.get_requirement_node_name(value)
  97                             if req_node_name != None and req_node_name == node['name']:
  98                                 cps.append(tmpnode)
  99         return cps
 100
 101     def get_all_vl(self, nodeTemplates):
 102         vls = []
 103         for node in nodeTemplates:
 104             if self.isVl(node):
 105                 vl = {}
 106                 vl['vl_id'] = node['name']
 107                 vl['description'] = node['description']
 108                 vl['properties'] = node['properties']
 109                 vl['route_external'] = False
 110                 vl['route_id'] = self._get_vl_route_id(node)
 111                 vls.append(vl)
 112             if self._isExternalVL(node):
 113                 vl = {}
 114                 vl['vl_id'] = node['name']
 115                 vl['description'] = node['description']
 116                 vl['properties'] = node['properties']
 117                 vl['route_external'] = True
 118                 vls.append(vl)
 119         return vls
 120
 121     def _get_vl_route_id(self, node):
 122         route_ids = map(lambda x: self.get_requirement_node_name(x),
 123                         self.getRequirementByName(node, 'virtual_route'))
 124         if len(route_ids) > 0:
 125             return route_ids[0]
 126         return ""
 127
 128     def _isExternalVL(self, node):
 129         return node['nodeType'].upper().find('.ROUTEEXTERNALVL') >= 0
 130
 131     def get_all_cp(self, nodeTemplates):
 132         cps = []
 133         for node in nodeTemplates:
 134             if self.isCp(node):
 135                 cp = {}
 136                 cp['cp_id'] = node['name']
 137                 cp['cpd_id'] = node['name']
 138                 cp['description'] = node['description']
 139                 cp['properties'] = node['properties']
 140                 cp['vl_id'] = self.get_node_vl_id(node)
 141                 binding_node_ids = map(lambda x: self.get_requirement_node_name(x), self.getVirtualbindings(node))
 142                 #                 cp['vnf_id'] = self._filter_vnf_id(binding_node_ids, nodeTemplates)
 143                 cp['pnf_id'] = self._filter_pnf_id(binding_node_ids, nodeTemplates)
 144                 vls = self.buil_cp_vls(node)
 145                 if len(vls) > 1:
 146                     cp['vls'] = vls
 147                 cps.append(cp)
 148         return cps
 149
 150     def buil_cp_vls(self, node):
 151         return map(lambda x: self._build_cp_vl(x), self.getVirtualLinks(node))
 152
 153     def _build_cp_vl(self, req):
 154         cp_vl = {}
 155         cp_vl['vl_id'] = self.get_prop_from_obj(req, 'node')
 156         relationship = self.get_prop_from_obj(req, 'relationship')
 157         if relationship != None:
 158             properties = self.get_prop_from_obj(relationship, 'properties')
 159             if properties != None and isinstance(properties, dict):
 160                 for key, value in properties.items():
 161                     cp_vl[key] = value
 162         return cp_vl
 163
 164     def _filter_pnf_id(self, node_ids, node_templates):
 165         for node_id in node_ids:
 166             node = self.get_node_by_name(node_templates, node_id)
 167             if self.isPnf(node):
 168                 return node_id
 169         return ""
 170
 171     def get_all_router(self, nodeTemplates):
 172         rets = []
 173         for node in nodeTemplates:
 174             if self._isRouter(node):
 175                 ret = {}
 176                 ret['router_id'] = node['name']
 177                 ret['description'] = node['description']
 178                 ret['properties'] = node['properties']
 179                 ret['external_vl_id'] = self._get_router_external_vl_id(node)
 180                 ret['external_ip_addresses'] = self._get_external_ip_addresses(node)
 181
 182                 rets.append(ret)
 183         return rets
 184
 185     def _isRouter(self, node):
 186         return node['nodeType'].upper().find('.ROUTER.') >= 0 or node['nodeType'].upper().endswith('.ROUTER')
 187
 188     def _get_router_external_vl(self, node):
 189         return self.getRequirementByName(node, 'external_virtual_link')
 190
 191     def _get_router_external_vl_id(self, node):
 192         ids = map(lambda x: self.get_requirement_node_name(x), self._get_router_external_vl(node))
 193         if len(ids) > 0:
 194             return ids[0]
 195         return ""
 196
 197     def _get_external_ip_addresses(self, node):
 198         external_vls = self._get_router_external_vl(node)
 199         if len(external_vls) > 0:
 200             if 'relationship' in external_vls[0] and 'properties' in external_vls[0]['relationship'] and 'router_ip_address' in external_vls[0]['relationship']['properties']:
 201                 return external_vls[0]['relationship']['properties']['router_ip_address']
 202         return []
 203
 204     def _get_all_fp(self, nodeTemplates):
 205         fps = []
 206         for node in nodeTemplates:
 207             if self._isFp(node):
 208                 fp = {}
 209                 fp['fp_id'] = node['name']
 210                 fp['description'] = node['description']
 211                 fp['properties'] = node['properties']
 212                 fp['forwarder_list'] = self._getForwarderList(node, nodeTemplates)
 213
 214                 fps.append(fp)
 215         return fps
 216
 217     def _isFp(self, node):
 218         return node['nodeType'].upper().find('.FP.') >= 0 or node['nodeType'].upper().find('.SFP.') >= 0 or node[
 219             'nodeType'].upper().endswith('.FP') or node['nodeType'].upper().endswith('.SFP')
 220
 221     def _getForwarderList(self, node, node_templates):
 222         forwarderList = []
 223         if 'requirements' in node:
 224             for item in node['requirements']:
 225                 for key, value in item.items():
 226                     if key == 'forwarder':
 227                         tmpnode = self.get_node_by_req(node_templates, value)
 228                         type = 'cp' if self.isCp(tmpnode) else 'vnf'
 229                         req_node_name = self.get_requirement_node_name(value)
 230                         if isinstance(value, dict) and 'capability' in value:
 231                             forwarderList.append(
 232                                 {"type": type, "node_name": req_node_name, "capability": value['capability']})
 233                         else:
 234                             forwarderList.append({"type": type, "node_name": req_node_name, "capability": ""})
 235
 236         return forwarderList
 237
 238     def get_node_by_req(self, node_templates, req):
 239         req_node_name = self.get_requirement_node_name(req)
 240         return self.get_node_by_name(node_templates, req_node_name)
 241
 242     def _get_all_vnffg(self, groups):
 243         vnffgs = []
 244         for group in groups:
 245             if self._isVnffg(group):
 246                 vnffg = {}
 247                 vnffg['vnffg_id'] = group.name
 248                 vnffg['description'] = group.description
 249                 if 'properties' in group.tpl:
 250                     vnffg['properties'] = group.tpl['properties']
 251                 vnffg['members'] = group.members
 252
 253                 vnffgs.append(vnffg)
 254         return vnffgs
 255
 256     def _isVnffg(self, group):
 257         return group.type.upper().find('.VNFFG.') >= 0 or group.type.upper().find(
 258             '.SFC.') >= 0 or group.type.upper().endswith('.VNFFG') or group.type.upper().endswith('.SFC')
 259
 260     def get_all_server_group(self, groups):
 261         rets = []
 262         for group in groups:
 263             if self._isServerGroup(group):
 264                 ret = {}
 265                 ret['group_id'] = group.name
 266                 ret['description'] = group.description
 267                 if 'properties' in group.tpl:
 268                     ret['properties'] = group.tpl['properties']
 269                 ret['members'] = group.members
 270
 271                 rets.append(ret)
 272         return rets
 273
 274     def _isServerGroup(self, group):
 275         return group.type.upper().find('.AFFINITYORANTIAFFINITYGROUP.') >= 0 or group.type.upper().endswith(
 276             '.AFFINITYORANTIAFFINITYGROUP')
 277
 278     def get_all_endpoint_exposed(self, topo_tpl):
 279         if 'substitution_mappings' in topo_tpl.tpl:
 280             external_cps = self._get_external_cps(topo_tpl.tpl['substitution_mappings'])
 281             forward_cps = self._get_forward_cps(topo_tpl.tpl['substitution_mappings'])
 282             return {"external_cps": external_cps, "forward_cps": forward_cps}
 283         return {}
 284
 285     def _get_external_cps(self, subs_mappings):
 286         external_cps = []
 287         if 'requirements' in subs_mappings:
 288             for key, value in subs_mappings['requirements'].items():
 289                 if isinstance(value, list) and len(value) > 0:
 290                     external_cps.append({"key_name": key, "cpd_id": value[0]})
 291                 else:
 292                     external_cps.append({"key_name": key, "cpd_id": value})
 293         return external_cps
 294
 295     def _get_forward_cps(self, subs_mappings):
 296         forward_cps = []
 297         if 'capabilities' in subs_mappings:
 298             for key, value in subs_mappings['capabilities'].items():
 299                 if isinstance(value, list) and len(value) > 0:
 300                     forward_cps.append({"key_name": key, "cpd_id": value[0]})
 301                 else:
 302                     forward_cps.append({"key_name": key, "cpd_id": value})
 303         return forward_cps