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