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