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