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