lcm/pub/utils/toscaparser/nsdmodel.py

   1 # Copyright 2017 ZTE Corporation.
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #         http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 import functools
  16
  17 from lcm.pub.utils.toscaparser.basemodel import BaseInfoModel
  18
  19
  20 class EtsiNsdInfoModel(BaseInfoModel):
  21
  22     def __init__(self, path, params):
  23         tosca = self.buildToscaTemplate(path, params)
  24         self.parseModel(tosca)
  25
  26     def parseModel(self, tosca):
  27         self.buidMetadata(tosca)
  28         if hasattr(tosca, 'topology_template') and hasattr(tosca.topology_template, 'inputs'):
  29             self.inputs = self.buildInputs(tosca.topology_template.inputs)
  30
  31         nodeTemplates = map(functools.partial(self.buildNode, inputs=tosca.inputs, parsed_params=tosca.parsed_params),
  32                             tosca.nodetemplates)
  33
  34         self.vnfs = self._get_all_vnf(nodeTemplates)
  35         self.pnfs = self._get_all_pnf(nodeTemplates)
  36         self.vls = self.get_all_vl(nodeTemplates)
  37         self.cps = self.get_all_cp(nodeTemplates)
  38         self.routers = self.get_all_router(nodeTemplates)
  39         self.fps = self._get_all_fp(nodeTemplates)
  40         self.vnffgs = self._get_all_vnffg(tosca.topology_template.groups)
  41         self.server_groups = self.get_all_server_group(tosca.topology_template.groups)
  42         self.ns_exposed = self.get_all_endpoint_exposed(tosca.topology_template)
  43         self.policies = self._get_policies_scaling(tosca.topology_template.policies)
  44         self.ns_flavours = self.get_all_flavour(tosca.topology_template.groups)
  45
  46
  47     def buildInputs(self, top_inputs):
  48         ret = {}
  49         for tmpinput in top_inputs:
  50             tmp = {}
  51             tmp['type'] = tmpinput.type
  52             tmp['description'] = tmpinput.description
  53             tmp['default'] = tmpinput.default
  54
  55             ret[tmpinput.name] = tmp
  56         return ret
  57
  58     def buildNode(self, nodeTemplate, inputs, parsed_params):
  59         ret ={}
  60         ret['name'] = nodeTemplate.name
  61         ret['nodeType'] = nodeTemplate.type
  62         if 'description' in nodeTemplate.entity_tpl:
  63             ret['description'] = nodeTemplate.entity_tpl['description']
  64         else:
  65             ret['description'] = ''
  66         props = self.buildProperties(nodeTemplate, parsed_params)
  67         ret['properties'] = self.verify_properties(props, inputs, parsed_params)
  68         ret['requirements'] = self.build_requirements(nodeTemplate)
  69         self.buildCapabilities(nodeTemplate, inputs, ret)
  70         self.buildArtifacts(nodeTemplate, inputs, ret)
  71         interfaces = self.build_interfaces(nodeTemplate)
  72         if interfaces: ret['interfaces'] = interfaces
  73         return ret
  74
  75     def _get_all_vnf(self, nodeTemplates):
  76         vnfs = []
  77         for node in nodeTemplates:
  78             if self.isVnf(node):
  79                 vnf = {}
  80                 vnf['vnf_id'] = node['name']
  81                 vnf['description'] = node['description']
  82                 vnf['properties'] = node['properties']
  83                 vnf['dependencies'] = map(lambda x: self.get_requirement_node_name(x), self.getNodeDependencys(node))
  84                 vnf['networks'] = self.get_networks(node)
  85
  86                 vnfs.append(vnf)
  87         return vnfs
  88
  89     def _get_all_pnf(self, nodeTemplates):
  90         pnfs = []
  91         for node in nodeTemplates:
  92             if self.isPnf(node):
  93                 pnf = {}
  94                 pnf['pnf_id'] = node['name']
  95                 pnf['description'] = node['description']
  96                 pnf['properties'] = node['properties']
  97                 pnf['cps'] = self.getVirtalBindingCpIds(node, nodeTemplates)
  98
  99                 pnfs.append(pnf)
 100         return pnfs
 101
 102     def getVirtalBindingCpIds(self, node, nodeTemplates):
 103         return map(lambda x: x['name'], self.getVirtalBindingCps(node, nodeTemplates))
 104
 105     def getVirtalBindingCps(self, node, nodeTemplates):
 106         cps = []
 107         for tmpnode in nodeTemplates:
 108             if 'requirements' in tmpnode:
 109                 for item in tmpnode['requirements']:
 110                     for key, value in item.items():
 111                         if key.upper().startswith('VIRTUALBINDING'):
 112                             req_node_name = self.get_requirement_node_name(value)
 113                             if req_node_name != None and req_node_name == node['name']:
 114                                 cps.append(tmpnode)
 115         return cps
 116
 117     def get_all_vl(self, nodeTemplates):
 118         vls = []
 119         for node in nodeTemplates:
 120             if self.isVl(node):
 121                 vl = {}
 122                 vl['vl_id'] = node['name']
 123                 vl['description'] = node['description']
 124                 vl['properties'] = node['properties']
 125                 vl['route_external'] = False
 126                 vl['route_id'] = self._get_vl_route_id(node)
 127                 vls.append(vl)
 128             if self._isExternalVL(node):
 129                 vl = {}
 130                 vl['vl_id'] = node['name']
 131                 vl['description'] = node['description']
 132                 vl['properties'] = node['properties']
 133                 vl['route_external'] = True
 134                 vls.append(vl)
 135         return vls
 136
 137     def _get_vl_route_id(self, node):
 138         route_ids = map(lambda x: self.get_requirement_node_name(x),
 139                         self.getRequirementByName(node, 'virtual_route'))
 140         if len(route_ids) > 0:
 141             return route_ids[0]
 142         return ""
 143
 144     def _isExternalVL(self, node):
 145         return node['nodeType'].upper().find('.ROUTEEXTERNALVL') >= 0
 146
 147     def get_all_cp(self, nodeTemplates):
 148         cps = []
 149         for node in nodeTemplates:
 150             if self.isCp(node):
 151                 cp = {}
 152                 cp['cp_id'] = node['name']
 153                 cp['cpd_id'] = node['name']
 154                 cp['description'] = node['description']
 155                 cp['properties'] = node['properties']
 156                 cp['vl_id'] = self.get_node_vl_id(node)
 157                 binding_node_ids = map(lambda x: self.get_requirement_node_name(x), self.getVirtualbindings(node))
 158                 #                 cp['vnf_id'] = self._filter_vnf_id(binding_node_ids, nodeTemplates)
 159                 cp['pnf_id'] = self._filter_pnf_id(binding_node_ids, nodeTemplates)
 160                 vls = self.buil_cp_vls(node)
 161                 if len(vls) > 1:
 162                     cp['vls'] = vls
 163                 cps.append(cp)
 164         return cps
 165
 166     def buil_cp_vls(self, node):
 167         return map(lambda x: self._build_cp_vl(x), self.getVirtualLinks(node))
 168
 169     def _build_cp_vl(self, req):
 170         cp_vl = {}
 171         cp_vl['vl_id'] = self.get_prop_from_obj(req, 'node')
 172         relationship = self.get_prop_from_obj(req, 'relationship')
 173         if relationship != None:
 174             properties = self.get_prop_from_obj(relationship, 'properties')
 175             if properties != None and isinstance(properties, dict):
 176                 for key, value in properties.items():
 177                     cp_vl[key] = value
 178         return cp_vl
 179
 180     def _filter_pnf_id(self, node_ids, node_templates):
 181         for node_id in node_ids:
 182             node = self.get_node_by_name(node_templates, node_id)
 183             if self.isPnf(node):
 184                 return node_id
 185         return ""
 186
 187     def get_all_router(self, nodeTemplates):
 188         rets = []
 189         for node in nodeTemplates:
 190             if self._isRouter(node):
 191                 ret = {}
 192                 ret['router_id'] = node['name']
 193                 ret['description'] = node['description']
 194                 ret['properties'] = node['properties']
 195                 ret['external_vl_id'] = self._get_router_external_vl_id(node)
 196                 ret['external_ip_addresses'] = self._get_external_ip_addresses(node)
 197
 198                 rets.append(ret)
 199         return rets
 200
 201     def _isRouter(self, node):
 202         return node['nodeType'].upper().find('.ROUTER.') >= 0 or node['nodeType'].upper().endswith('.ROUTER')
 203
 204     def _get_router_external_vl(self, node):
 205         return self.getRequirementByName(node, 'external_virtual_link')
 206
 207     def _get_router_external_vl_id(self, node):
 208         ids = map(lambda x: self.get_requirement_node_name(x), self._get_router_external_vl(node))
 209         if len(ids) > 0:
 210             return ids[0]
 211         return ""
 212
 213     def _get_external_ip_addresses(self, node):
 214         external_vls = self._get_router_external_vl(node)
 215         if len(external_vls) > 0:
 216             if 'relationship' in external_vls[0] and 'properties' in external_vls[0]['relationship'] and 'router_ip_address' in external_vls[0]['relationship']['properties']:
 217                 return external_vls[0]['relationship']['properties']['router_ip_address']
 218         return []
 219
 220     def _get_all_fp(self, nodeTemplates):
 221         fps = []
 222         for node in nodeTemplates:
 223             if self._isFp(node):
 224                 fp = {}
 225                 fp['fp_id'] = node['name']
 226                 fp['description'] = node['description']
 227                 fp['properties'] = node['properties']
 228                 fp['forwarder_list'] = self._getForwarderList(node, nodeTemplates)
 229
 230                 fps.append(fp)
 231         return fps
 232
 233     def _isFp(self, node):
 234         return node['nodeType'].upper().find('.FP.') >= 0 or node['nodeType'].upper().find('.SFP.') >= 0 or node[
 235             'nodeType'].upper().endswith('.FP') or node['nodeType'].upper().endswith('.SFP')
 236
 237     def _getForwarderList(self, node, node_templates):
 238         forwarderList = []
 239         if 'requirements' in node:
 240             for item in node['requirements']:
 241                 for key, value in item.items():
 242                     if key == 'forwarder':
 243                         tmpnode = self.get_node_by_req(node_templates, value)
 244                         type = 'cp' if self.isCp(tmpnode) else 'vnf'
 245                         req_node_name = self.get_requirement_node_name(value)
 246                         if isinstance(value, dict) and 'capability' in value:
 247                             forwarderList.append(
 248                                 {"type": type, "node_name": req_node_name, "capability": value['capability']})
 249                         else:
 250                             forwarderList.append({"type": type, "node_name": req_node_name, "capability": ""})
 251
 252         return forwarderList
 253
 254     def get_node_by_req(self, node_templates, req):
 255         req_node_name = self.get_requirement_node_name(req)
 256         return self.get_node_by_name(node_templates, req_node_name)
 257
 258     def _get_all_vnffg(self, groups):
 259         vnffgs = []
 260         for group in groups:
 261             if self._isVnffg(group):
 262                 vnffg = {}
 263                 vnffg['vnffg_id'] = group.name
 264                 vnffg['description'] = group.description
 265                 if 'properties' in group.tpl:
 266                     vnffg['properties'] = group.tpl['properties']
 267                 vnffg['members'] = group.members
 268
 269                 vnffgs.append(vnffg)
 270         return vnffgs
 271
 272     def _isVnffg(self, group):
 273         return group.type.upper().find('.VNFFG.') >= 0 or group.type.upper().find(
 274             '.SFC.') >= 0 or group.type.upper().endswith('.VNFFG') or group.type.upper().endswith('.SFC')
 275
 276     def get_all_server_group(self, groups):
 277         rets = []
 278         for group in groups:
 279             if self._isServerGroup(group):
 280                 ret = {}
 281                 ret['group_id'] = group.name
 282                 ret['description'] = group.description
 283                 if 'properties' in group.tpl:
 284                     ret['properties'] = group.tpl['properties']
 285                 ret['members'] = group.members
 286
 287                 rets.append(ret)
 288         return rets
 289
 290     def _isServerGroup(self, group):
 291         return group.type.upper().find('.AFFINITYORANTIAFFINITYGROUP.') >= 0 or group.type.upper().endswith(
 292             '.AFFINITYORANTIAFFINITYGROUP')
 293
 294     def get_all_endpoint_exposed(self, topo_tpl):
 295         if 'substitution_mappings' in topo_tpl.tpl:
 296             external_cps = self._get_external_cps(topo_tpl.tpl['substitution_mappings'])
 297             forward_cps = self._get_forward_cps(topo_tpl.tpl['substitution_mappings'])
 298             return {"external_cps": external_cps, "forward_cps": forward_cps}
 299         return {}
 300
 301     def _get_external_cps(self, subs_mappings):
 302         external_cps = []
 303         if 'requirements' in subs_mappings:
 304             for key, value in subs_mappings['requirements'].items():
 305                 if isinstance(value, list) and len(value) > 0:
 306                     external_cps.append({"key_name": key, "cpd_id": value[0]})
 307                 else:
 308                     external_cps.append({"key_name": key, "cpd_id": value})
 309         return external_cps
 310
 311     def _get_forward_cps(self, subs_mappings):
 312         forward_cps = []
 313         if 'capabilities' in subs_mappings:
 314             for key, value in subs_mappings['capabilities'].items():
 315                 if isinstance(value, list) and len(value) > 0:
 316                     forward_cps.append({"key_name": key, "cpd_id": value[0]})
 317                 else:
 318                     forward_cps.append({"key_name": key, "cpd_id": value})
 319         return forward_cps
 320
 321     def _get_policies_scaling(self, top_policies):
 322         policies_scaling = []
 323         scaling_policies = self.get_scaling_policies(top_policies)
 324         if len(scaling_policies) > 0:
 325             policies_scaling.append({"scaling": scaling_policies})
 326         return policies_scaling
 327
 328     def get_policies_by_keyword(self, top_policies, keyword):
 329         ret = []
 330         for policy in top_policies:
 331             if policy.type.upper().find(keyword) >= 0:
 332                 tmp = {}
 333                 tmp['policy_id'] = policy.name
 334                 tmp['description'] = policy.description
 335                 if 'properties' in policy.entity_tpl:
 336                     tmp['properties'] = policy.entity_tpl['properties']
 337                 tmp['targets'] = policy.targets
 338                 ret.append(tmp)
 339
 340         return ret
 341
 342     def get_scaling_policies(self, top_policies):
 343         return self.get_policies_by_keyword(top_policies, '.SCALING')
 344
 345     def get_all_flavour(self, groups):
 346         rets = []
 347         for group in groups:
 348             if self._isFlavour(group):
 349                 ret = {}
 350                 ret['flavour_id'] = group.name
 351                 ret['description'] = group.description
 352                 if 'properties' in group.tpl:
 353                     ret['properties'] = group.tpl['properties']
 354                 ret['members'] = group.members
 355
 356                 rets.append(ret)
 357         return rets
 358
 359     def _isFlavour(self, group):
 360         return group.type.upper().find('FLAVOUR') >= 0