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