bpmn/MSOCommonBPMN/src/main/groovy/org/onap/so/bpmn/common/scripts/VfModuleBase.groovy

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP - SO
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Modifications Copyright (c) 2019 Samsung
   8  * ================================================================================
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  * ============LICENSE_END=========================================================
  21  */
  22
  23 package org.onap.so.bpmn.common.scripts
  24
  25 import org.onap.so.logger.ErrorCode;
  26
  27 import javax.xml.parsers.DocumentBuilder
  28 import javax.xml.parsers.DocumentBuilderFactory
  29
  30 import org.w3c.dom.Document
  31 import org.w3c.dom.Element
  32 import org.w3c.dom.Node
  33 import org.w3c.dom.NodeList
  34 import org.xml.sax.InputSource
  35 import org.onap.so.logger.MessageEnum
  36 import org.slf4j.Logger
  37 import org.slf4j.LoggerFactory
  38
  39 public abstract class VfModuleBase extends AbstractServiceTaskProcessor {
  40     private static final Logger logger = LoggerFactory.getLogger( VfModuleBase.class);
  41
  42
  43     protected XmlParser xmlParser = new XmlParser()
  44
  45     /**
  46      * Get the XmlParser.
  47      *
  48      * @return the XmlParser.
  49      */
  50     protected XmlParser getXmlParser() {
  51         return xmlParser
  52     }
  53
  54     /**
  55      * Find the VF Module with specified ID in the specified Generic VF.  If no such
  56      * VF Module is found, null is returned.
  57      *
  58      * @param genericVnf The Generic VNF in which to search for the specified VF Moduel.
  59      * @param vfModuleId The ID of the VF Module for which to search.
  60      * @return a VFModule object for the found VF Module or null if no VF Module is found.
  61      */
  62     protected VfModule findVfModule(String genericVnf, String vfModuleId) {
  63
  64         def genericVnfNode = xmlParser.parseText(genericVnf)
  65         def vfModulesNode = utils.getChildNode(genericVnfNode, 'vf-modules')
  66         if (vfModulesNode == null) {
  67             return null
  68         }
  69         def vfModuleList = utils.getIdenticalChildren(vfModulesNode, 'vf-module')
  70         for (vfModuleNode in vfModuleList) {
  71             def vfModuleIdNode = utils.getChildNode(vfModuleNode, 'vf-module-id')
  72             if ((vfModuleIdNode != null) && (vfModuleIdNode.text().equals(vfModuleId))) {
  73                 return new VfModule(vfModuleNode, (vfModuleList.size() == 1))
  74             }
  75         }
  76         return null
  77     }
  78
  79     /**
  80      * Transform all '*_network' parameter specifications from the incoming '*-params' root
  81      * element to a corresponding list of 'vnf-networks' specifications (typically used when
  82      * invoking the VNF Rest Adpater). Each element in '*-params' whose name attribute ends
  83      * with '_network' is used to create an 'vnf-networks' element.
  84      *
  85      * @param paramsNode A Node representing a '*-params' element.
  86      * @return a String of 'vnf-networks' elements, one for each 'param' element whose name
  87      * attribute ends with '_network'.
  88      */
  89     protected String transformNetworkParamsToVnfNetworks(String paramsRootXml) {
  90         if ((paramsRootXml == null) || (paramsRootXml.isEmpty())) {
  91             return ''
  92         }
  93         def String vnfNetworks = ''
  94         try {
  95             paramsRootXml = utils.removeXmlNamespaces(paramsRootXml)
  96             def paramsNode = xmlParser.parseText(paramsRootXml)
  97             def params = utils.getIdenticalChildren(paramsNode, 'param')
  98             for (param in params) {
  99                 def String attrName = (String) param.attribute('name')
 100                 if (attrName.endsWith('_network')) {
 101                     def networkRole = attrName.substring(0, (attrName.length()-'_network'.length()))
 102                     def networkName = param.text()
 103                     String vnfNetwork = """
 104                                                 <vnf-networks>
 105                                                         <network-role>${MsoUtils.xmlEscape(networkRole)}</network-role>
 106                                                         <network-name>${MsoUtils.xmlEscape(networkName)}</network-name>
 107                                                 </vnf-networks>
 108                                         """
 109                     vnfNetworks = vnfNetworks + vnfNetwork
 110                 }
 111             }
 112         } catch (Exception e) {
 113             logger.warn("{} {} {} {} {}", MessageEnum.BPMN_GENERAL_WARNING.toString(),
 114                             'Exception transforming network params to vnfNetworks', "BPMN",
 115                             ErrorCode.UnknownError.getValue(), 'Exception is: \n' + e);
 116         }
 117         return vnfNetworks
 118     }
 119
 120     /**
 121      * Transform the parameter specifications from the incoming '*-params' root element to
 122      * a corresponding list of 'entry's (typically used when invoking the VNF Rest Adpater).
 123      * Each element in '*-params' is used to create an 'entry' element.
 124      *
 125      * @param paramsNode A Node representing a '*-params' element.
 126      * @return a String of 'entry' elements, one for each 'param' element.
 127      */
 128     protected String transformParamsToEntries(String paramsRootXml) {
 129         if ((paramsRootXml == null) || (paramsRootXml.isEmpty())) {
 130             return ''
 131         }
 132         def String entries = ''
 133         try {
 134             paramsRootXml = utils.removeXmlNamespaces(paramsRootXml)
 135             def paramsNode = xmlParser.parseText(paramsRootXml)
 136             def params = utils.getIdenticalChildren(paramsNode, 'param')
 137             for (param in params) {
 138                 def key = (String) param.attribute('name')
 139                 if (key == null) {
 140                     key = ''
 141                 }
 142                 def value = (String) param.text()
 143                 String entry = """
 144                                         <entry>
 145                                                 <key>${MsoUtils.xmlEscape(key)}</key>
 146                                                 <value>${MsoUtils.xmlEscape(value)}</value>
 147                                         </entry>
 148                                 """
 149                 entries = entries + entry
 150             }
 151         } catch (Exception e) {
 152             logger.warn("{} {} {} {} {}", MessageEnum.BPMN_GENERAL_WARNING.toString(),
 153                             'Exception transforming params to entries', "BPMN",
 154                             ErrorCode.UnknownError.getValue(), 'Exception transforming params to entries' + e);
 155         }
 156         return entries
 157     }
 158
 159     /**
 160      * Transform the parameter specifications from the incoming '*-params' root element to
 161      * a corresponding list of 'entry's (typically used when invoking the VNF Rest Adpater).
 162      * Each element in '*-params' is used to create an 'entry' element.
 163      *
 164      * @param paramsNode A Node representing a '*-params' element.
 165      * @return a String of 'entry' elements, one for each 'param' element.
 166      */
 167     protected String transformVolumeParamsToEntries(String paramsRootXml) {
 168         if ((paramsRootXml == null) || (paramsRootXml.isEmpty())) {
 169             return ''
 170         }
 171         def String entries = ''
 172         try {
 173             paramsRootXml = utils.removeXmlNamespaces(paramsRootXml)
 174             def paramsNode = xmlParser.parseText(paramsRootXml)
 175             def params = utils.getIdenticalChildren(paramsNode, 'param')
 176             for (param in params) {
 177                 def key = (String) param.attribute('name')
 178                 if (key == null) {
 179                     key = ''
 180                 }
 181                 if ( !(key in [
 182                     'vnf_id',
 183                     'vnf_name',
 184                     'vf_module_id',
 185                     'vf_module_name'
 186                 ])) {
 187                     def value = (String) param.text()
 188                     String entry = """
 189                                                 <entry>
 190                                                         <key>${MsoUtils.xmlEscape(key)}</key>
 191                                                         <value>${MsoUtils.xmlEscape(value)}</value>
 192                                                 </entry>
 193                                         """
 194                     entries = entries + entry
 195                 }
 196             }
 197         } catch (Exception e) {
 198             logger.warn("{} {} {} {} {}", MessageEnum.BPMN_GENERAL_WARNING.toString(),
 199                             'Exception transforming params to entries', "BPMN",
 200                             ErrorCode.UnknownError.getValue(), 'Exception transforming params to entries' + e);
 201         }
 202         return entries
 203     }
 204
 205     /*
 206      * Parses VNF parameters passed in on the incoming requests and SDNC parameters returned from SDNC get response
 207      * and puts them into the format expected by VNF adapter.
 208      * @param vnfParamsMap -  map of VNF parameters passed in the request body
 209      * @param sdncGetResponse - response string from SDNC GET topology request
 210      * @param vnfId
 211      * @param vnfName
 212      * @param vfModuleId
 213      * @param vfModuleName
 214      * @param vfModuleIndex - can be null
 215      * @return a String of key/value entries for vfModuleParams
 216      */
 217
 218
 219     protected String buildVfModuleParams(Map<String, String> vnfParamsMap, String sdncGetResponse, String vnfId, String vnfName,
 220                     String vfModuleId, String vfModuleName, String vfModuleIndex, String environmentContext, String workloadContext) {
 221
 222         //Get SDNC Response Data
 223
 224         String data = utils.getNodeXml(sdncGetResponse, "response-data")
 225
 226         String serviceData = utils.getNodeXml(data, "service-data")
 227         serviceData = utils.removeXmlPreamble(serviceData)
 228         serviceData = utils.removeXmlNamespaces(serviceData)
 229         String vnfRequestInfo = utils.getNodeXml(serviceData, "vnf-request-information")
 230         String oldVnfId = utils.getNodeXml(vnfRequestInfo, "vnf-id")
 231         oldVnfId = utils.removeXmlPreamble(oldVnfId)
 232         oldVnfId = utils.removeXmlNamespaces(oldVnfId)
 233         serviceData = serviceData.replace(oldVnfId, "")
 234         def vnfId1 = utils.getNodeText(serviceData, "vnf-id")
 235
 236         Map<String, String> paramsMap = new HashMap<String, String>()
 237
 238         if (vfModuleIndex != null) {
 239             paramsMap.put("vf_module_index", "${vfModuleIndex}")
 240         }
 241
 242         // Add-on data
 243         paramsMap.put("vnf_id", "${vnfId}")
 244         paramsMap.put("vnf_name", "${vnfName}")
 245         paramsMap.put("vf_module_id", "${vfModuleId}")
 246         paramsMap.put("vf_module_name", "${vfModuleName}")
 247         paramsMap.put("environment_context", "${environmentContext}")
 248         paramsMap.put("workload_context", "${workloadContext}")
 249
 250         InputSource source = new InputSource(new StringReader(data));
 251         DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
 252         docFactory.setNamespaceAware(true)
 253         DocumentBuilder docBuilder = docFactory.newDocumentBuilder()
 254         Document responseXml = docBuilder.parse(source)
 255
 256
 257         // Availability Zones Data
 258
 259         NodeList aZonesList = responseXml.getElementsByTagNameNS("*", "availability-zones")
 260         String aZonePosition = "0"
 261         for (int z = 0; z < aZonesList.getLength(); z++) {
 262             Node node = aZonesList.item(z)
 263             if (node.getNodeType() == Node.ELEMENT_NODE) {
 264                 Element eElement = (Element) node
 265                 String aZoneValue = utils.getElementText(eElement, "availability-zone")
 266                 aZonePosition = z.toString()
 267                 paramsMap.put("availability_zone_${aZonePosition}", "${aZoneValue}")
 268             }
 269         }
 270
 271         // Map of network-roles and network-tags from vm-networks
 272
 273         NodeList vmNetworksListGlobal = responseXml.getElementsByTagNameNS("*", "vm-networks")
 274         Map<String, String> networkRoleMap = new HashMap<String, String>()
 275         for(int n = 0; n < vmNetworksListGlobal.getLength(); n++){
 276             Node nodeNetworkKey = vmNetworksListGlobal.item(n)
 277             if (nodeNetworkKey.getNodeType() == Node.ELEMENT_NODE) {
 278                 Element eElementNetworkKey = (Element) nodeNetworkKey
 279                 String networkRole = utils.getElementText(eElementNetworkKey, "network-role")
 280                 String networkRoleValue = utils.getElementText(eElementNetworkKey, "network-role-tag")
 281                 if (networkRoleValue.isEmpty()) {
 282                     networkRoleValue = networkRole
 283                 }
 284                 networkRoleMap.put(networkRole, networkRoleValue)
 285             }
 286         }
 287
 288         // VNF Networks Data
 289
 290         StringBuilder sbNet = new StringBuilder()
 291
 292         NodeList vnfNetworkList = responseXml.getElementsByTagNameNS("*", "vnf-networks")
 293         for (int x = 0; x < vnfNetworkList.getLength(); x++) {
 294             Node node = vnfNetworkList.item(x)
 295             if (node.getNodeType() == Node.ELEMENT_NODE) {
 296                 Element eElement = (Element) node
 297                 String vnfNetworkKey = utils.getElementText(eElement, "network-role-tag")
 298                 String networkRole = utils.getElementText(eElement, "network-role")
 299                 if (vnfNetworkKey.isEmpty()) {
 300                     vnfNetworkKey = networkRoleMap.get(networkRole)
 301                     if (vnfNetworkKey == null || vnfNetworkKey.isEmpty()) {
 302                         vnfNetworkKey = networkRole
 303                     }
 304                 }
 305                 String vnfNetworkNeutronIdValue = utils.getElementText(eElement, "neutron-id")
 306                 String vnfNetworkNetNameValue = utils.getElementText(eElement, "network-name")
 307                 String vnfNetworkSubNetIdValue = utils.getElementText(eElement, "subnet-id")
 308                 String vnfNetworkV6SubNetIdValue = utils.getElementText(eElement, "ipv6-subnet-id")
 309                 String vnfNetworkNetFqdnValue = utils.getElementText(eElement, "contrail-network-fqdn")
 310                 paramsMap.put("${vnfNetworkKey}_net_id", "${vnfNetworkNeutronIdValue}")
 311                 paramsMap.put("${vnfNetworkKey}_net_name", "${vnfNetworkNetNameValue}")
 312                 paramsMap.put("${vnfNetworkKey}_subnet_id", "${vnfNetworkSubNetIdValue}")
 313                 paramsMap.put("${vnfNetworkKey}_v6_subnet_id", "${vnfNetworkV6SubNetIdValue}")
 314                 paramsMap.put("${vnfNetworkKey}_net_fqdn", "${vnfNetworkNetFqdnValue}")
 315
 316                 NodeList sriovVlanFilterList = eElement.getElementsByTagNameNS("*","sriov-vlan-filter-list")
 317                 StringBuffer sriovFilterBuf = new StringBuffer()
 318                 String values = ""
 319                 for(int i = 0; i < sriovVlanFilterList.getLength(); i++){
 320                     Node node1 = sriovVlanFilterList.item(i)
 321                     if (node1.getNodeType() == Node.ELEMENT_NODE) {
 322                         Element eElement1 = (Element) node1
 323                         String value = utils.getElementText(eElement1, "sriov-vlan-filter")
 324                         if (i != sriovVlanFilterList.getLength() - 1) {
 325                             values = sriovFilterBuf.append(value + ",")
 326                         }
 327                         else {
 328                             values = sriovFilterBuf.append(value);
 329                         }
 330                     }
 331                 }
 332                 if (!values.isEmpty()) {
 333                     paramsMap.put("${vnfNetworkKey}_ATT_VF_VLAN_FILTER", "${values}")
 334                 }
 335             }
 336         }
 337
 338         // VNF-VMS Data
 339
 340         def key
 341         def value
 342         def networkKey
 343         def networkValue
 344         def floatingIPKey
 345         def floatingIPKeyValue
 346         def floatingIPV6Key
 347         def floatingIPV6KeyValue
 348         StringBuilder sb = new StringBuilder()
 349
 350         NodeList vmsList = responseXml.getElementsByTagNameNS("*","vnf-vms")
 351         for (int x = 0; x < vmsList.getLength(); x++) {
 352             Node node = vmsList.item(x)
 353             if (node.getNodeType() == Node.ELEMENT_NODE) {
 354                 Element eElement = (Element) node
 355                 key = utils.getElementText(eElement, "vm-type")
 356                 String values
 357                 String position = "0"
 358                 StringBuilder sb1 = new StringBuilder()
 359                 NodeList valueList = eElement.getElementsByTagNameNS("*","vm-names")
 360                 NodeList vmNetworksList = eElement.getElementsByTagNameNS("*","vm-networks")
 361                 for(int i = 0; i < valueList.getLength(); i++){
 362                     Node node1 = valueList.item(i)
 363                     if (node1.getNodeType() == Node.ELEMENT_NODE) {
 364                         Element eElement1 = (Element) node1
 365                         value = utils.getElementText(eElement1, "vm-name")
 366                         if (i != valueList.getLength() - 1) {
 367                             values = sb1.append(value + ",")
 368                         }
 369                         else {
 370                             values = sb1.append(value);
 371                         }
 372                         position = i.toString()
 373                         paramsMap.put("${key}_name_${position}", "${value}")
 374                     }
 375                 }
 376                 for(int n = 0; n < vmNetworksList.getLength(); n++){
 377                     String floatingIpKeyValueStr = ""
 378                     String floatingIpV6KeyValueStr = ""
 379                     Node nodeNetworkKey = vmNetworksList.item(n)
 380                     if (nodeNetworkKey.getNodeType() == Node.ELEMENT_NODE) {
 381                         Element eElementNetworkKey = (Element) nodeNetworkKey
 382                         String ipAddressValues
 383                         String ipV6AddressValues
 384                         String networkPosition = "0"
 385                         StringBuilder sb2 = new StringBuilder()
 386                         StringBuilder sb3 = new StringBuilder()
 387                         StringBuilder sb4 = new StringBuilder()
 388                         networkKey = utils.getElementText(eElementNetworkKey, "network-role-tag")
 389                         if (networkKey.isEmpty()) {
 390                             networkKey = utils.getElementText(eElementNetworkKey, "network-role")
 391                         }
 392                         floatingIPKey = key + '_' + networkKey + '_floating_ip'
 393                         floatingIPKeyValue = utils.getElementText(eElementNetworkKey, "floating-ip")
 394                         if(!floatingIPKeyValue.isEmpty()){
 395                             paramsMap.put("$floatingIPKey", "$floatingIPKeyValue")
 396                         }
 397                         floatingIPV6Key = key + '_' + networkKey + '_floating_v6_ip'
 398                         floatingIPV6KeyValue = utils.getElementText(eElementNetworkKey, "floating-ip-v6")
 399                         if(!floatingIPV6KeyValue.isEmpty()){
 400                             paramsMap.put("$floatingIPV6Key", "$floatingIPV6KeyValue")
 401                         }
 402                         NodeList networkIpsList = eElementNetworkKey.getElementsByTagNameNS("*","network-ips")
 403                         for(int a = 0; a < networkIpsList.getLength(); a++){
 404                             Node ipAddress = networkIpsList.item(a)
 405                             if (ipAddress.getNodeType() == Node.ELEMENT_NODE) {
 406                                 Element eElementIpAddress = (Element) ipAddress
 407                                 String ipAddressValue = utils.getElementText(eElementIpAddress, "ip-address")
 408                                 if (a != networkIpsList.getLength() - 1) {
 409                                     ipAddressValues = sb2.append(ipAddressValue + ",")
 410                                 }
 411                                 else {
 412                                     ipAddressValues = sb2.append(ipAddressValue);
 413                                 }
 414                                 networkPosition = a.toString()
 415                                 paramsMap.put("${key}_${networkKey}_ip_${networkPosition}", "${ipAddressValue}")
 416                             }
 417                         }
 418
 419                         paramsMap.put("${key}_${networkKey}_ips", "${ipAddressValues}")
 420
 421                         NodeList interfaceRoutePrefixesList = eElementNetworkKey.getElementsByTagNameNS("*","interface-route-prefixes")
 422                         String interfaceRoutePrefixValues = sb3.append("[")
 423
 424                         for(int a = 0; a < interfaceRoutePrefixesList.getLength(); a++){
 425                             Node interfaceRoutePrefix = interfaceRoutePrefixesList.item(a)
 426                             if (interfaceRoutePrefix.getNodeType() == Node.ELEMENT_NODE) {
 427                                 Element eElementInterfaceRoutePrefix = (Element) interfaceRoutePrefix
 428                                 String interfaceRoutePrefixValue = utils.getElementText(eElementInterfaceRoutePrefix, "interface-route-prefix-cidr")
 429                                 if (interfaceRoutePrefixValue == null || interfaceRoutePrefixValue.isEmpty()) {
 430                                     interfaceRoutePrefixValue = utils.getElementText(eElementInterfaceRoutePrefix, "interface-route-prefix")
 431                                 }
 432                                 if (a != interfaceRoutePrefixesList.getLength() - 1) {
 433                                     interfaceRoutePrefixValues = sb3.append("{\"interface_route_table_routes_route_prefix\": \"" + interfaceRoutePrefixValue + "\"}" + ",")
 434                                 }
 435                                 else {
 436                                     interfaceRoutePrefixValues = sb3.append("{\"interface_route_table_routes_route_prefix\": \"" + interfaceRoutePrefixValue + "\"}")
 437                                 }
 438                             }
 439                         }
 440                         interfaceRoutePrefixValues = sb3.append("]")
 441                         if (interfaceRoutePrefixesList.getLength() > 0) {
 442                             paramsMap.put("${key}_${networkKey}_route_prefixes", "${interfaceRoutePrefixValues}")
 443                         }
 444
 445                         NodeList networkIpsV6List = eElementNetworkKey.getElementsByTagNameNS("*","network-ips-v6")
 446                         for(int a = 0; a < networkIpsV6List.getLength(); a++){
 447                             Node ipV6Address = networkIpsV6List.item(a)
 448                             if (ipV6Address.getNodeType() == Node.ELEMENT_NODE) {
 449                                 Element eElementIpV6Address = (Element) ipV6Address
 450                                 String ipV6AddressValue = utils.getElementText(eElementIpV6Address, "ip-address-ipv6")
 451                                 if (a != networkIpsV6List.getLength() - 1) {
 452                                     ipV6AddressValues = sb4.append(ipV6AddressValue + ",")
 453                                 }
 454                                 else {
 455                                     ipV6AddressValues = sb4.append(ipV6AddressValue);
 456                                 }
 457                                 networkPosition = a.toString()
 458                                 paramsMap.put("${key}_${networkKey}_v6_ip_${networkPosition}", "${ipV6AddressValue}")
 459                             }
 460                         }
 461                         paramsMap.put("${key}_${networkKey}_v6_ips", "${ipV6AddressValues}")
 462                     }
 463                 }
 464                 paramsMap.put("${key}_names", "${values}")
 465             }
 466         }
 467         //SDNC Response Params
 468         String sdncResponseParams = ""
 469         List<String> sdncResponseParamsToSkip = [
 470             "vnf_id",
 471             "vf_module_id",
 472             "vnf_name",
 473             "vf_module_name"
 474         ]
 475         String vnfParamsChildNodes = utils.getChildNodes(data, "vnf-parameters")
 476         if(vnfParamsChildNodes == null || vnfParamsChildNodes.length() < 1){
 477             // No SDNC params
 478         }else{
 479             NodeList paramsList = responseXml.getElementsByTagNameNS("*", "vnf-parameters")
 480             for (int z = 0; z < paramsList.getLength(); z++) {
 481                 Node node = paramsList.item(z)
 482                 Element eElement = (Element) node
 483                 String vnfParameterName = utils.getElementText(eElement, "vnf-parameter-name")
 484                 if (!sdncResponseParamsToSkip.contains(vnfParameterName)) {
 485                     String vnfParameterValue = utils.getElementText(eElement, "vnf-parameter-value")
 486                     paramsMap.put("${vnfParameterName}", "${vnfParameterValue}")
 487                 }
 488             }
 489         }
 490
 491         // make the sdnc_directives parameter
 492         String sdncDirectives = "{}"
 493         StringBuilder sdncDirectivesBuilder = new StringBuilder()
 494         sdncDirectivesBuilder.append("{ \"attributes\": [")
 495         int pcnt = 0
 496         for (Map.Entry<String, String> entry : paramsMap.entrySet()) {
 497                 String attributeName = entry.getKey()
 498                 String attributeValue = entry.getValue()
 499                 if (pcnt > 0) {
 500                     sdncDirectivesBuilder.append(",")
 501                 }
 502                 pcnt++
 503                 sdncDirectivesBuilder.append("{\"attribute_name\":\"${attributeName}\",")
 504                 sdncDirectivesBuilder.append("\"attribute_value\":\"${attributeValue}\"}")
 505         }
 506         if (pcnt > 0) {
 507             sdncDirectives = sdncDirectivesBuilder.append("]}").toString()
 508         }
 509         paramsMap.put("sdnc_directives", "${sdncDirectives}")
 510
 511         // Parameters received from the request should overwrite any parameters received from SDNC
 512         // Also build the user_directives parameter
 513         String userDirectives = "{}"
 514         if (vnfParamsMap != null) {
 515             StringBuilder userDirectivesBuilder = new StringBuilder()
 516             userDirectivesBuilder.append("{ \"attributes\": [")
 517             pcnt = 0
 518             for (Map.Entry<String, String> entry : vnfParamsMap.entrySet()) {
 519                 String vnfKey = entry.getKey()
 520                 String vnfValue = entry.getValue()
 521                 paramsMap.put("$vnfKey", "$vnfValue")
 522                 if (pcnt > 0) {
 523                     userDirectivesBuilder.append(",")
 524                 }
 525                 pcnt++
 526                 userDirectivesBuilder.append("{\"attribute_name\":\"${vnfKey}\",")
 527                 userDirectivesBuilder.append("\"attribute_value\":\"${vnfValue}\"}")
 528             }
 529             if (pcnt > 0) {
 530                 userDirectives = userDirectivesBuilder.append("]}").toString()
 531             }
 532         }
 533         paramsMap.put("user_directives", "${userDirectives}")
 534
 535         StringBuilder sbParams = new StringBuilder()
 536         def vfModuleParams = ""
 537         for (Map.Entry<String, String> entry : paramsMap.entrySet()) {
 538             String paramsXml
 539             String paramName = entry.getKey()
 540             String paramValue = entry.getValue()
 541             paramsXml =
 542                             """<entry>
 543                                                         <key>${MsoUtils.xmlEscape(paramName)}</key>
 544                                                         <value>${MsoUtils.xmlEscape(paramValue)}</value>
 545                                                 </entry>
 546                                                 """
 547
 548             vfModuleParams = sbParams.append(paramsXml)
 549         }
 550
 551         return vfModuleParams
 552
 553     }
 554
 555
 556     /*
 557      * Parses VNF parameters passed in on the incoming requests and SDNC parameters returned from SDNC get response
 558      * for both VNF and VF Module
 559      * and puts them into the format expected by VNF adapter.
 560      * @param vnfParamsMap -  map of VNF parameters passed in the request body
 561      * @param vnfSdncGetResponse - response string from SDNC GET VNF topology request
 562      * @param vfmoduleSdncGetResponse - response string from SDNC GET VF Module topology request
 563      * @param vnfId
 564      * @param vnfName
 565      * @param vfModuleId
 566      * @param vfModuleName
 567      * @param vfModuleIndex - can be null
 568      * @return a String of key/value entries for vfModuleParams
 569      */
 570
 571     protected String buildVfModuleParamsFromCombinedTopologies(Map<String, String> vnfParamsMap, String vnfSdncGetResponse, String vfmoduleSdncGetResponse, String vnfId, String vnfName,
 572                     String vfModuleId, String vfModuleName, String vfModuleIndex, String environmentContext, String workloadContext) {
 573
 574         // Set up initial parameters
 575
 576         Map<String, String> paramsMap = new HashMap<String, String>()
 577
 578         if (vfModuleIndex != null) {
 579             paramsMap.put("vf_module_index", "${vfModuleIndex}")
 580         }
 581
 582         // Add-on data
 583         paramsMap.put("vnf_id", "${vnfId}")
 584         paramsMap.put("vnf_name", "${vnfName}")
 585         paramsMap.put("vf_module_id", "${vfModuleId}")
 586         paramsMap.put("vf_module_name", "${vfModuleName}")
 587         paramsMap.put("environment_context","${environmentContext}")
 588         paramsMap.put("workload_context", "${workloadContext}")
 589
 590         //Get SDNC Response Data for VNF
 591
 592         String vnfData = utils.getNodeXml(vnfSdncGetResponse, "response-data")
 593
 594         String vnfTopology = utils.getNodeXml(vnfData, "vnf-topology")
 595         vnfTopology = utils.removeXmlPreamble(vnfTopology)
 596         vnfTopology = utils.removeXmlNamespaces(vnfTopology)
 597
 598         InputSource sourceVnf = new InputSource(new StringReader(vnfData));
 599         DocumentBuilderFactory docFactoryVnf = DocumentBuilderFactory.newInstance();
 600         docFactoryVnf.setNamespaceAware(true)
 601         DocumentBuilder docBuilderVnf = docFactoryVnf.newDocumentBuilder()
 602         Document responseXmlVnf = docBuilderVnf.parse(sourceVnf)
 603
 604         // Availability Zones Data
 605
 606         NodeList aZonesList = responseXmlVnf.getElementsByTagNameNS("*", "availability-zones")
 607         String aZonePosition = "0"
 608         for (int z = 0; z < aZonesList.getLength(); z++) {
 609             Node node = aZonesList.item(z)
 610             if (node.getNodeType() == Node.ELEMENT_NODE) {
 611                 Element eElement = (Element) node
 612                 String aZoneValue = utils.getElementText(eElement, "availability-zone")
 613                 aZonePosition = z.toString()
 614                 paramsMap.put("availability_zone_${aZonePosition}", "${aZoneValue}")
 615             }
 616         }
 617
 618         //Get SDNC Response Data for VF Module
 619
 620         String vfModuleData = utils.getNodeXml(vfmoduleSdncGetResponse, "response-data")
 621
 622         String vfModuleTopology = utils.getNodeXml(vfModuleData, "vf-module-topology")
 623         vfModuleTopology = utils.removeXmlPreamble(vfModuleTopology)
 624         vfModuleTopology = utils.removeXmlNamespaces(vfModuleTopology)
 625         String vfModuleTopologyIdentifier = utils.getNodeXml(vfModuleTopology, "vf-module-topology-identifier")
 626
 627         InputSource sourceVfModule = new InputSource(new StringReader(vfModuleData));
 628         DocumentBuilderFactory docFactoryVfModule = DocumentBuilderFactory.newInstance();
 629         docFactoryVfModule.setNamespaceAware(true)
 630         DocumentBuilder docBuilderVfModule = docFactoryVfModule.newDocumentBuilder()
 631         Document responseXmlVfModule = docBuilderVfModule.parse(sourceVfModule)
 632
 633         // Map of network-roles and network-tags from vm-networks
 634
 635         NodeList vmNetworksListGlobal = responseXmlVfModule.getElementsByTagNameNS("*", "vm-networks")
 636         Map<String, String> networkRoleMap = new HashMap<String, String>()
 637         for(int n = 0; n < vmNetworksListGlobal.getLength(); n++){
 638             Node nodeNetworkKey = vmNetworksListGlobal.item(n)
 639             if (nodeNetworkKey.getNodeType() == Node.ELEMENT_NODE) {
 640                 Element eElementNetworkKey = (Element) nodeNetworkKey
 641                 String networkRole = utils.getElementText(eElementNetworkKey, "network-role")
 642                 String networkRoleValue = utils.getElementText(eElementNetworkKey, "network-role-tag")
 643                 if (networkRoleValue.isEmpty()) {
 644                     networkRoleValue = networkRole
 645                 }
 646                 networkRoleMap.put(networkRole, networkRoleValue)
 647             }
 648         }
 649
 650         // VNF Networks Data
 651
 652         StringBuilder sbNet = new StringBuilder()
 653
 654         NodeList vnfNetworkList = responseXmlVnf.getElementsByTagNameNS("*", "vnf-networks")
 655         for (int x = 0; x < vnfNetworkList.getLength(); x++) {
 656             Node node = vnfNetworkList.item(x)
 657             if (node.getNodeType() == Node.ELEMENT_NODE) {
 658                 Element eElement = (Element) node
 659                 String vnfNetworkKey = utils.getElementText(eElement, "network-role-tag")
 660                 String networkRole = utils.getElementText(eElement, "network-role")
 661                 if (vnfNetworkKey.isEmpty()) {
 662                     vnfNetworkKey = networkRoleMap.get(networkRole)
 663                     if (vnfNetworkKey == null || vnfNetworkKey.isEmpty()) {
 664                         vnfNetworkKey = networkRole
 665                     }
 666                 }
 667                 String vnfNetworkNeutronIdValue = utils.getElementText(eElement, "neutron-id")
 668                 String vnfNetworkNetNameValue = utils.getElementText(eElement, "network-name")
 669                 String vnfNetworkSubNetIdValue = utils.getElementText(eElement, "subnet-id")
 670                 String vnfNetworkV6SubNetIdValue = utils.getElementText(eElement, "ipv6-subnet-id")
 671                 String vnfNetworkNetFqdnValue = utils.getElementText(eElement, "contrail-network-fqdn")
 672                 paramsMap.put("${vnfNetworkKey}_net_id", "${vnfNetworkNeutronIdValue}")
 673                 paramsMap.put("${vnfNetworkKey}_net_name", "${vnfNetworkNetNameValue}")
 674                 paramsMap.put("${vnfNetworkKey}_subnet_id", "${vnfNetworkSubNetIdValue}")
 675                 paramsMap.put("${vnfNetworkKey}_v6_subnet_id", "${vnfNetworkV6SubNetIdValue}")
 676                 paramsMap.put("${vnfNetworkKey}_net_fqdn", "${vnfNetworkNetFqdnValue}")
 677
 678                 NodeList sriovVlanFilterList = eElement.getElementsByTagNameNS("*","sriov-vlan-filter-list")
 679                 StringBuffer sriovFilterBuf = new StringBuffer()
 680                 String values = ""
 681                 for(int i = 0; i < sriovVlanFilterList.getLength(); i++){
 682                     Node node1 = sriovVlanFilterList.item(i)
 683                     if (node1.getNodeType() == Node.ELEMENT_NODE) {
 684                         Element eElement1 = (Element) node1
 685                         String value = utils.getElementText(eElement1, "sriov-vlan-filter")
 686                         if (i != sriovVlanFilterList.getLength() - 1) {
 687                             values = sriovFilterBuf.append(value + ",")
 688                         }
 689                         else {
 690                             values = sriovFilterBuf.append(value);
 691                         }
 692                     }
 693                 }
 694                 if (!values.isEmpty()) {
 695                     paramsMap.put("${vnfNetworkKey}_ATT_VF_VLAN_FILTER", "${values}")
 696                 }
 697             }
 698         }
 699
 700
 701
 702         // VMS Data
 703
 704         def key
 705         def value
 706         def networkKey
 707         def networkValue
 708         def floatingIPKey
 709         def floatingIPKeyValue
 710         def floatingIPV6Key
 711         def floatingIPV6KeyValue
 712         StringBuilder sb = new StringBuilder()
 713
 714         NodeList vmsList = responseXmlVfModule.getElementsByTagNameNS("*","vm")
 715         for (int x = 0; x < vmsList.getLength(); x++) {
 716             Node node = vmsList.item(x)
 717             if (node.getNodeType() == Node.ELEMENT_NODE) {
 718                 Element eElement = (Element) node
 719                 key = utils.getElementText(eElement, "vm-type")
 720                 String values
 721                 String position = "0"
 722                 StringBuilder sb1 = new StringBuilder()
 723                 NodeList valueList = eElement.getElementsByTagNameNS("*","vm-names")
 724                 NodeList vmNetworksList = eElement.getElementsByTagNameNS("*","vm-networks")
 725                 for(int i = 0; i < valueList.getLength(); i++){
 726                     Node node1 = valueList.item(i)
 727                     if (node1.getNodeType() == Node.ELEMENT_NODE) {
 728                         Element eElement1 = (Element) node1
 729                         value = utils.getElementText(eElement1, "vm-name")
 730                         if (i != valueList.getLength() - 1) {
 731                             values = sb1.append(value + ",")
 732                         }
 733                         else {
 734                             values = sb1.append(value);
 735                         }
 736                         position = i.toString()
 737                         paramsMap.put("${key}_name_${position}", "${value}")
 738                     }
 739                 }
 740                 for(int n = 0; n < vmNetworksList.getLength(); n++){
 741                     String floatingIpKeyValueStr = ""
 742                     String floatingIpV6KeyValueStr = ""
 743                     Node nodeNetworkKey = vmNetworksList.item(n)
 744                     if (nodeNetworkKey.getNodeType() == Node.ELEMENT_NODE) {
 745                         Element eElementNetworkKey = (Element) nodeNetworkKey
 746                         String ipAddressValues
 747                         String ipV6AddressValues
 748                         String networkPosition = "0"
 749                         StringBuilder sb2 = new StringBuilder()
 750                         StringBuilder sb3 = new StringBuilder()
 751                         StringBuilder sb4 = new StringBuilder()
 752                         networkKey = utils.getElementText(eElementNetworkKey, "network-role-tag")
 753                         if (networkKey.isEmpty()) {
 754                             networkKey = utils.getElementText(eElementNetworkKey, "network-role")
 755                         }
 756                         floatingIPKey = key + '_' + networkKey + '_floating_ip'
 757                         floatingIPKeyValue = utils.getElementText(eElementNetworkKey, "floating-ip")
 758                         if(!floatingIPKeyValue.isEmpty()){
 759                             paramsMap.put("$floatingIPKey", "$floatingIPKeyValue")
 760                         }
 761                         floatingIPV6Key = key + '_' + networkKey + '_floating_v6_ip'
 762                         floatingIPV6KeyValue = utils.getElementText(eElementNetworkKey, "floating-ip-v6")
 763                         if(!floatingIPV6KeyValue.isEmpty()){
 764                             paramsMap.put("$floatingIPV6Key", "$floatingIPV6KeyValue")
 765                         }
 766                         NodeList networkIpsList = eElementNetworkKey.getElementsByTagNameNS("*","network-ips")
 767                         for(int a = 0; a < networkIpsList.getLength(); a++){
 768                             Node ipAddress = networkIpsList.item(a)
 769                             if (ipAddress.getNodeType() == Node.ELEMENT_NODE) {
 770                                 Element eElementIpAddress = (Element) ipAddress
 771                                 String ipAddressValue = utils.getElementText(eElementIpAddress, "ip-address")
 772                                 if (a != networkIpsList.getLength() - 1) {
 773                                     ipAddressValues = sb2.append(ipAddressValue + ",")
 774                                 }
 775                                 else {
 776                                     ipAddressValues = sb2.append(ipAddressValue);
 777                                 }
 778                                 networkPosition = a.toString()
 779                                 paramsMap.put("${key}_${networkKey}_ip_${networkPosition}", "${ipAddressValue}")
 780                             }
 781                         }
 782
 783                         paramsMap.put("${key}_${networkKey}_ips", "${ipAddressValues}")
 784
 785                         NodeList interfaceRoutePrefixesList = eElementNetworkKey.getElementsByTagNameNS("*","interface-route-prefixes")
 786                         String interfaceRoutePrefixValues = sb3.append("[")
 787
 788                         for(int a = 0; a < interfaceRoutePrefixesList.getLength(); a++){
 789                             Node interfaceRoutePrefix = interfaceRoutePrefixesList.item(a)
 790                             if (interfaceRoutePrefix.getNodeType() == Node.ELEMENT_NODE) {
 791                                 Element eElementInterfaceRoutePrefix = (Element) interfaceRoutePrefix
 792                                 String interfaceRoutePrefixValue = utils.getElementText(eElementInterfaceRoutePrefix, "interface-route-prefix-cidr")
 793                                 if (interfaceRoutePrefixValue == null || interfaceRoutePrefixValue.isEmpty()) {
 794                                     interfaceRoutePrefixValue = utils.getElementText(eElementInterfaceRoutePrefix, "interface-route-prefix")
 795                                 }
 796                                 if (a != interfaceRoutePrefixesList.getLength() - 1) {
 797                                     interfaceRoutePrefixValues = sb3.append("{\"interface_route_table_routes_route_prefix\": \"" + interfaceRoutePrefixValue + "\"}" + ",")
 798                                 }
 799                                 else {
 800                                     interfaceRoutePrefixValues = sb3.append("{\"interface_route_table_routes_route_prefix\": \"" + interfaceRoutePrefixValue + "\"}")
 801                                 }
 802                             }
 803                         }
 804                         interfaceRoutePrefixValues = sb3.append("]")
 805                         if (interfaceRoutePrefixesList.getLength() > 0) {
 806                             paramsMap.put("${key}_${networkKey}_route_prefixes", "${interfaceRoutePrefixValues}")
 807                         }
 808
 809                         NodeList networkIpsV6List = eElementNetworkKey.getElementsByTagNameNS("*","network-ips-v6")
 810                         for(int a = 0; a < networkIpsV6List.getLength(); a++){
 811                             Node ipV6Address = networkIpsV6List.item(a)
 812                             if (ipV6Address.getNodeType() == Node.ELEMENT_NODE) {
 813                                 Element eElementIpV6Address = (Element) ipV6Address
 814                                 String ipV6AddressValue = utils.getElementText(eElementIpV6Address, "ip-address-ipv6")
 815                                 if (a != networkIpsV6List.getLength() - 1) {
 816                                     ipV6AddressValues = sb4.append(ipV6AddressValue + ",")
 817                                 }
 818                                 else {
 819                                     ipV6AddressValues = sb4.append(ipV6AddressValue);
 820                                 }
 821                                 networkPosition = a.toString()
 822                                 paramsMap.put("${key}_${networkKey}_v6_ip_${networkPosition}", "${ipV6AddressValue}")
 823                             }
 824                         }
 825                         paramsMap.put("${key}_${networkKey}_v6_ips", "${ipV6AddressValues}")
 826                     }
 827                 }
 828                 paramsMap.put("${key}_names", "${values}")
 829             }
 830         }
 831         //SDNC Response Params
 832         List<String> sdncResponseParamsToSkip = [
 833             "vnf_id",
 834             "vf_module_id",
 835             "vnf_name",
 836             "vf_module_name"
 837         ]
 838
 839         String vnfParamsChildNodes = utils.getChildNodes(vnfData, "param")
 840         if(vnfParamsChildNodes == null || vnfParamsChildNodes.length() < 1){
 841             // No SDNC params for VNF
 842         }else{
 843             NodeList paramsList = responseXmlVnf.getElementsByTagNameNS("*", "param")
 844             for (int z = 0; z < paramsList.getLength(); z++) {
 845                 Node node = paramsList.item(z)
 846                 Element eElement = (Element) node
 847                 String vnfParameterName = utils.getElementText(eElement, "name")
 848                 if (!sdncResponseParamsToSkip.contains(vnfParameterName)) {
 849                     String vnfParameterValue = utils.getElementText(eElement, "value")
 850                     paramsMap.put("${vnfParameterName}", "${vnfParameterValue}")
 851                 }
 852             }
 853         }
 854
 855         String vfModuleParamsChildNodes = utils.getChildNodes(vfModuleData, "param")
 856         if(vfModuleParamsChildNodes == null || vfModuleParamsChildNodes.length() < 1){
 857             // No SDNC params for VF Module
 858         }else{
 859             NodeList paramsList = responseXmlVfModule.getElementsByTagNameNS("*", "param")
 860             for (int z = 0; z < paramsList.getLength(); z++) {
 861                 Node node = paramsList.item(z)
 862                 Element eElement = (Element) node
 863                 String vnfParameterName = utils.getElementText(eElement, "name")
 864                 if (!sdncResponseParamsToSkip.contains(vnfParameterName)) {
 865                     String vnfParameterValue = utils.getElementText(eElement, "value")
 866                     paramsMap.put("${vnfParameterName}", "${vnfParameterValue}")
 867                 }
 868             }
 869         }
 870
 871         // make the sdnc_directives parameter
 872         String sdncDirectives = "{}"
 873         StringBuilder sdncDirectivesBuilder = new StringBuilder()
 874         sdncDirectivesBuilder.append("{ \"attributes\": [")
 875         int pcnt = 0
 876         for (Map.Entry<String, String> entry : paramsMap.entrySet()) {
 877                 String attributeName = entry.getKey()
 878                 String attributeValue = entry.getValue()
 879                 if (pcnt > 0) {
 880                     sdncDirectivesBuilder.append(",")
 881                 }
 882                 pcnt++
 883                 sdncDirectivesBuilder.append("{\"attribute_name\":\"${attributeName}\",")
 884                 sdncDirectivesBuilder.append("\"attribute_value\":\"${attributeValue}\"}")
 885         }
 886         if (pcnt > 0) {
 887             sdncDirectives = sdncDirectivesBuilder.append("]}").toString()
 888         }
 889         paramsMap.put("sdnc_directives", "${sdncDirectives}")
 890
 891
 892         // Parameters received from the request should overwrite any parameters received from SDNC
 893         String userDirectives = "{}"
 894         if (vnfParamsMap != null) {
 895             StringBuilder userDirectivesBuilder = new StringBuilder()
 896             userDirectivesBuilder.append("{ \"attributes\": [")
 897             pcnt = 0
 898             for (Map.Entry<String, String> entry : vnfParamsMap.entrySet()) {
 899                 String vnfKey = entry.getKey()
 900                 String vnfValue = entry.getValue()
 901                 paramsMap.put("$vnfKey", "$vnfValue")
 902                 if (pcnt > 0) {
 903                     userDirectivesBuilder.append(",")
 904                 }
 905                 pcnt++
 906                 userDirectivesBuilder.append("{\"attribute_name\":\"${vnfKey}\",")
 907                 userDirectivesBuilder.append("\"attribute_value\":\"${vnfValue}\"}")
 908             }
 909             if (pcnt > 0) {
 910                 userDirectives = userDirectivesBuilder.append("]}").toString()
 911             }
 912         }
 913         paramsMap.put("user_directives", "${userDirectives}")
 914
 915         StringBuilder sbParams = new StringBuilder()
 916         def vfModuleParams = ""
 917         for (Map.Entry<String, String> entry : paramsMap.entrySet()) {
 918             String paramsXml
 919             String paramName = entry.getKey()
 920             String paramValue = entry.getValue()
 921             paramsXml =
 922                             """<entry>
 923                                                 <key>${MsoUtils.xmlEscape(paramName)}</key>
 924                                                 <value>${MsoUtils.xmlEscape(paramValue)}</value>
 925                                         </entry>
 926                                         """
 927
 928             vfModuleParams = sbParams.append(paramsXml)
 929         }
 930
 931         return vfModuleParams
 932
 933     }
 934
 935
 936     /*
 937      * VBNG specific method that parses VNF parameters passed in on the
 938      * incoming requests and SDNC parameters returned from SDNC get response
 939      * and puts them into the format expected by VNF adapter.
 940      * @param vnfParamsMap -  map of VNF parameters passed in the request body
 941      * @param sdncGetResponse - response string from SDNC GET topology request
 942      * @param vnfId
 943      * @param vnfName
 944      * @param vfModuleId
 945      * @param vfModuleName
 946      * @return a String of key/value entries for vfModuleParams
 947      */
 948
 949     protected String buildVfModuleParamsVbng(String vnfParams, String sdncGetResponse, String vnfId, String vnfName,
 950                     String vfModuleId, String vfModuleName) {
 951
 952         //Get SDNC Response Data
 953
 954         String data = utils.getNodeXml(sdncGetResponse, "response-data")
 955
 956
 957
 958         // Add-on data
 959         String vnfInfo =
 960                         """<entry>
 961                                 <key>vnf_id</key>
 962                                 <value>${MsoUtils.xmlEscape(vnfId)}</value>
 963                         </entry>
 964                         <entry>
 965                                 <key>vnf_name</key>
 966                                 <value>${MsoUtils.xmlEscape(vnfName)}</value>
 967                         </entry>
 968                         <entry>
 969                                 <key>vf_module_id</key>
 970                                 <value>${MsoUtils.xmlEscape(vfModuleId)}</value>
 971                         </entry>
 972                         <entry>
 973                                 <key>vf_module_name</key>
 974                                 <value>${MsoUtils.xmlEscape(vfModuleName)}</value>
 975                         </entry>"""
 976
 977         logger.debug("vnfInfo: " + vnfInfo)
 978         InputSource source = new InputSource(new StringReader(data));
 979         DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
 980         docFactory.setNamespaceAware(true)
 981         DocumentBuilder docBuilder = docFactory.newDocumentBuilder()
 982         Document responseXml = docBuilder.parse(source)
 983
 984
 985         // Availability Zones Data
 986         String aZones = ""
 987         StringBuilder sbAZone = new StringBuilder()
 988         NodeList aZonesList = responseXml.getElementsByTagNameNS("*", "availability-zones")
 989         String aZonePosition = "0"
 990         for (int z = 0; z < aZonesList.getLength(); z++) {
 991             Node node = aZonesList.item(z)
 992             if (node.getNodeType() == Node.ELEMENT_NODE) {
 993                 Element eElement = (Element) node
 994                 String aZoneValue = utils.getElementText(eElement, "availability-zone")
 995                 aZonePosition = z.toString()
 996                 String aZoneXml =
 997                                 """<entry>
 998                                                 <key>availability_zone_${MsoUtils.xmlEscape(aZonePosition)}</key>
 999                                                 <value>${MsoUtils.xmlEscape(aZoneValue)}</value>
1000                                         </entry>"""
1001                 aZones = sbAZone.append(aZoneXml)
1002             }
1003         }
1004
1005         // Map of network-roles and network-tags from vm-networks
1006
1007         NodeList vmNetworksListGlobal = responseXml.getElementsByTagNameNS("*", "vm-networks")
1008         Map<String, String> networkRoleMap = new HashMap<String, String>()
1009         for(int n = 0; n < vmNetworksListGlobal.getLength(); n++){
1010             Node nodeNetworkKey = vmNetworksListGlobal.item(n)
1011             if (nodeNetworkKey.getNodeType() == Node.ELEMENT_NODE) {
1012                 Element eElementNetworkKey = (Element) nodeNetworkKey
1013                 String networkRole = utils.getElementText(eElementNetworkKey, "network-role")
1014                 String networkRoleValue = utils.getElementText(eElementNetworkKey, "network-role-tag")
1015                 if (networkRoleValue.isEmpty()) {
1016                     networkRoleValue = networkRole
1017                 }
1018                 networkRoleMap.put(networkRole, networkRoleValue)
1019             }
1020         }
1021
1022         // VNF Networks Data
1023         String vnfNetworkNetId = ""
1024         String vnfNetworkNetName = ""
1025         String vnfNetworkSubNetId = ""
1026         String vnfNetworkV6SubNetId = ""
1027         String vnfNetworkNetFqdn = ""
1028         String vnfNetworksSriovVlanFilters = ""
1029         StringBuilder sbNet = new StringBuilder()
1030         StringBuilder sbNet2 = new StringBuilder()
1031         StringBuilder sbNet3 = new StringBuilder()
1032         StringBuilder sbNet4 = new StringBuilder()
1033         StringBuilder sbNet5 = new StringBuilder()
1034         StringBuilder sbNet6 = new StringBuilder()
1035         NodeList vnfNetworkList = responseXml.getElementsByTagNameNS("*", "vnf-networks")
1036         for (int x = 0; x < vnfNetworkList.getLength(); x++) {
1037             Node node = vnfNetworkList.item(x)
1038             if (node.getNodeType() == Node.ELEMENT_NODE) {
1039                 Element eElement = (Element) node
1040                 String vnfNetworkKey = utils.getElementText(eElement, "network-role-tag")
1041                 String networkRole = utils.getElementText(eElement, "network-role")
1042                 if (vnfNetworkKey.isEmpty()) {
1043                     vnfNetworkKey = networkRoleMap.get(networkRole)
1044                     if (vnfNetworkKey == null || vnfNetworkKey.isEmpty()) {
1045                         vnfNetworkKey = networkRole
1046                     }
1047                 }
1048                 String vnfNetworkNeutronIdValue = utils.getElementText(eElement, "neutron-id")
1049                 String vnfNetworkNetNameValue = utils.getElementText(eElement, "network-name")
1050                 String vnfNetworkSubNetIdValue = utils.getElementText(eElement, "subnet-id")
1051                 String vnfNetworkV6SubNetIdValue = utils.getElementText(eElement, "ipv6-subnet-id")
1052                 String vnfNetworkNetFqdnValue = utils.getElementText(eElement, "contrail-network-fqdn")
1053                 String vnfNetworkNetIdXml =
1054                                 """<entry>
1055                                                         <key>${MsoUtils.xmlEscape(vnfNetworkKey)}_net_id</key>
1056                                                         <value>${MsoUtils.xmlEscape(vnfNetworkNeutronIdValue)}</value>
1057                                                 </entry>"""
1058                 vnfNetworkNetId = sbNet.append(vnfNetworkNetIdXml)
1059                 String vnfNetworkNetNameXml =
1060                                 """<entry>
1061                                                 <key>${MsoUtils.xmlEscape(vnfNetworkKey)}_net_name</key>
1062                                                 <value>${MsoUtils.xmlEscape(vnfNetworkNetNameValue)}</value>
1063                                 </entry>"""
1064                 vnfNetworkNetName = sbNet2.append(vnfNetworkNetNameXml)
1065                 String vnfNetworkSubNetIdXml =
1066                                 """<entry>
1067                                                 <key>${MsoUtils.xmlEscape(vnfNetworkKey)}_subnet_id</key>
1068                                                 <value>${MsoUtils.xmlEscape(vnfNetworkSubNetIdValue)}</value>
1069                                 </entry>"""
1070                 vnfNetworkSubNetId = sbNet3.append(vnfNetworkSubNetIdXml)
1071                 String vnfNetworkV6SubNetIdXml =
1072                                 """<entry>
1073                                                 <key>${MsoUtils.xmlEscape(vnfNetworkKey)}_v6_subnet_id</key>
1074                                                 <value>${MsoUtils.xmlEscape(vnfNetworkV6SubNetIdValue)}</value>
1075                                 </entry>"""
1076                 vnfNetworkV6SubNetId = sbNet5.append(vnfNetworkV6SubNetIdXml)
1077                 String vnfNetworkNetFqdnXml =
1078                                 """<entry>
1079                                                 <key>${MsoUtils.xmlEscape(vnfNetworkKey)}_net_fqdn</key>
1080                                                 <value>${MsoUtils.xmlEscape(vnfNetworkNetFqdnValue)}</value>
1081                                 </entry>"""
1082                 vnfNetworkNetFqdn = sbNet4.append(vnfNetworkNetFqdnXml)
1083
1084                 NodeList sriovVlanFilterList = eElement.getElementsByTagNameNS("*","sriov-vlan-filter-list")
1085                 StringBuffer sriovFilterBuf = new StringBuffer()
1086                 String values = ""
1087                 for(int i = 0; i < sriovVlanFilterList.getLength(); i++){
1088                     Node node1 = sriovVlanFilterList.item(i)
1089                     if (node1.getNodeType() == Node.ELEMENT_NODE) {
1090                         Element eElement1 = (Element) node1
1091                         String value = utils.getElementText(eElement1, "sriov-vlan-filter")
1092                         if (i != sriovVlanFilterList.getLength() - 1) {
1093                             values = sriovFilterBuf.append(value + ",")
1094                         }
1095                         else {
1096                             values = sriovFilterBuf.append(value);
1097                         }
1098                     }
1099                 }
1100                 if (!values.isEmpty()) {
1101                     String vnfNetworkSriovVlanFilterXml =
1102                                     """<entry>
1103                                                 <key>${MsoUtils.xmlEscape(vnfNetworkKey)}_ATT_VF_VLAN_FILTER</key>
1104                                                 <value>${MsoUtils.xmlEscape(values)}</value>
1105                                         </entry>"""
1106                     vnfNetworksSriovVlanFilters = sbNet6.append(vnfNetworkSriovVlanFilterXml)
1107                 }
1108             }
1109         }
1110
1111         // VNF-VMS Data
1112         String vnfVMS = ""
1113         String vnfVMSPositions = ""
1114         String vmNetworks = ""
1115         String vmNetworksPositions = ""
1116         String vmNetworksPositionsV6 = ""
1117         String interfaceRoutePrefixes = ""
1118         def key
1119         def value
1120         def networkKey
1121         def networkValue
1122         def floatingIPKey
1123         def floatingIPKeyValue
1124         def floatingIPV6Key
1125         def floatingIPV6KeyValue
1126         StringBuilder sb = new StringBuilder()
1127         StringBuilder sbPositions = new StringBuilder()
1128         StringBuilder sbVmNetworks = new StringBuilder()
1129         StringBuilder sbNetworksPositions = new StringBuilder()
1130         StringBuilder sbInterfaceRoutePrefixes = new StringBuilder()
1131         StringBuilder sbNetworksPositionsV6 = new StringBuilder()
1132
1133         NodeList vmsList = responseXml.getElementsByTagNameNS("*","vnf-vms")
1134         for (int x = 0; x < vmsList.getLength(); x++) {
1135             Node node = vmsList.item(x)
1136             if (node.getNodeType() == Node.ELEMENT_NODE) {
1137                 Element eElement = (Element) node
1138                 key = utils.getElementText(eElement, "vm-type")
1139                 String values
1140                 String position = "0"
1141                 StringBuilder sb1 = new StringBuilder()
1142                 NodeList valueList = eElement.getElementsByTagNameNS("*","vm-names")
1143                 NodeList vmNetworksList = eElement.getElementsByTagNameNS("*","vm-networks")
1144                 for(int i = 0; i < valueList.getLength(); i++){
1145                     Node node1 = valueList.item(i)
1146                     if (node1.getNodeType() == Node.ELEMENT_NODE) {
1147                         Element eElement1 = (Element) node1
1148                         value = utils.getElementText(eElement1, "vm-name")
1149                         if (i != valueList.getLength() - 1) {
1150                             values = sb1.append(value + ",")
1151                         }
1152                         else {
1153                             values = sb1.append(value);
1154                         }
1155                         position = i.toString()
1156                         String vnfPositionXml =
1157                                         """<entry>
1158                                                                 <key>${MsoUtils.xmlEscape(key)}_name_${MsoUtils.xmlEscape(position)}</key>
1159                                                                 <value>${MsoUtils.xmlEscape(value)}</value>
1160                                                         </entry>"""
1161                         nfVMSPositions = sbPositions.append(vnfPositionXml)
1162                     }
1163                 }
1164                 for(int n = 0; n < vmNetworksList.getLength(); n++){
1165                     String floatingIpKeyValueStr = ""
1166                     String floatingIpV6KeyValueStr = ""
1167                     Node nodeNetworkKey = vmNetworksList.item(n)
1168                     if (nodeNetworkKey.getNodeType() == Node.ELEMENT_NODE) {
1169                         Element eElementNetworkKey = (Element) nodeNetworkKey
1170                         String ipAddressValues
1171                         String ipV6AddressValues
1172                         String networkPosition = "0"
1173                         StringBuilder sb2 = new StringBuilder()
1174                         StringBuilder sb3 = new StringBuilder()
1175                         StringBuilder sb4 = new StringBuilder()
1176                         networkKey = utils.getElementText(eElementNetworkKey, "network-role-tag")
1177                         if (networkKey.isEmpty()) {
1178                             networkKey = utils.getElementText(eElementNetworkKey, "network-role")
1179                         }
1180                         floatingIPKey = key + '_' + networkKey + '_floating_ip'
1181                         floatingIPKeyValue = utils.getElementText(eElementNetworkKey, "floating-ip")
1182                         if(!floatingIPKeyValue.isEmpty()){
1183                             floatingIpKeyValueStr = """<entry>
1184                                                                 <key>$floatingIPKey</key>
1185                                                                 <value>$floatingIPKeyValue</value>
1186                                                         </entry>"""
1187                         }
1188                         floatingIPV6Key = key + '_' + networkKey + '_floating_v6_ip'
1189                         floatingIPV6KeyValue = utils.getElementText(eElementNetworkKey, "floating-ip-v6")
1190                         if(!floatingIPV6KeyValue.isEmpty()){
1191                             floatingIpV6KeyValueStr = """<entry>
1192                                                                 <key>$floatingIPV6Key</key>
1193                                                                 <value>$floatingIPV6KeyValue</value>
1194                                                         </entry>"""
1195                         }
1196                         NodeList networkIpsList = eElementNetworkKey.getElementsByTagNameNS("*","network-ips")
1197                         for(int a = 0; a < networkIpsList.getLength(); a++){
1198                             Node ipAddress = networkIpsList.item(a)
1199                             if (ipAddress.getNodeType() == Node.ELEMENT_NODE) {
1200                                 Element eElementIpAddress = (Element) ipAddress
1201                                 String ipAddressValue = utils.getElementText(eElementIpAddress, "ip-address")
1202                                 if (a != networkIpsList.getLength() - 1) {
1203                                     ipAddressValues = sb2.append(ipAddressValue + ",")
1204                                 }
1205                                 else {
1206                                     ipAddressValues = sb2.append(ipAddressValue);
1207                                 }
1208                                 networkPosition = a.toString()
1209                                 String vmNetworksPositionsXml =
1210                                                 """<entry>
1211                                                                                 <key>${MsoUtils.xmlEscape(key)}_${MsoUtils.xmlEscape(networkKey)}_ip_${MsoUtils.xmlEscape(networkPosition)}</key>
1212                                                                                 <value>${MsoUtils.xmlEscape(ipAddressValue)}</value>
1213                                                                         </entry>"""
1214                                 vmNetworksPositions = sbNetworksPositions.append(vmNetworksPositionsXml)
1215                             }
1216                         }
1217                         vmNetworksPositions = sbNetworksPositions.append(floatingIpKeyValueStr).append(floatingIpV6KeyValueStr)
1218
1219                         String vmNetworksXml =
1220                                         """<entry>
1221                                                                 <key>${MsoUtils.xmlEscape(key)}_${MsoUtils.xmlEscape(networkKey)}_ips</key>
1222                                                                 <value>${MsoUtils.xmlEscape(ipAddressValues)}</value>
1223                                                         </entry>"""
1224                         vmNetworks = sbVmNetworks.append(vmNetworksXml)
1225
1226                         NodeList interfaceRoutePrefixesList = eElementNetworkKey.getElementsByTagNameNS("*","interface-route-prefixes")
1227                         String interfaceRoutePrefixValues = sb3.append("[")
1228
1229                         for(int a = 0; a < interfaceRoutePrefixesList.getLength(); a++){
1230                             Node interfaceRoutePrefix = interfaceRoutePrefixesList.item(a)
1231                             if (interfaceRoutePrefix.getNodeType() == Node.ELEMENT_NODE) {
1232                                 Element eElementInterfaceRoutePrefix = (Element) interfaceRoutePrefix
1233                                 String interfaceRoutePrefixValue = utils.getElementText(eElementInterfaceRoutePrefix, "interface-route-prefix-cidr")
1234                                 if (interfaceRoutePrefixValue == null || interfaceRoutePrefixValue.isEmpty()) {
1235                                     interfaceRoutePrefixValue = utils.getElementText(eElementInterfaceRoutePrefix, "interface-route-prefix")
1236                                 }
1237                                 if (a != interfaceRoutePrefixesList.getLength() - 1) {
1238                                     interfaceRoutePrefixValues = sb3.append("{\"interface_route_table_routes_route_prefix\": \"" + interfaceRoutePrefixValue + "\"}" + ",")
1239                                 }
1240                                 else {
1241                                     interfaceRoutePrefixValues = sb3.append("{\"interface_route_table_routes_route_prefix\": \"" + interfaceRoutePrefixValue + "\"}")
1242                                 }
1243                             }
1244                         }
1245                         interfaceRoutePrefixValues = sb3.append("]")
1246                         if (interfaceRoutePrefixesList.getLength() > 0) {
1247                             String interfaceRoutePrefixesXml =
1248                                             """<entry>
1249                                                                                         <key>${MsoUtils.xmlEscape(key)}_${MsoUtils.xmlEscape(networkKey)}_route_prefixes</key>
1250                                                                                         <value>${MsoUtils.xmlEscape(interfaceRoutePrefixValues)}</value>
1251                                                                                 </entry>"""
1252                             interfaceRoutePrefixes = sbInterfaceRoutePrefixes.append(interfaceRoutePrefixesXml)
1253                         }
1254
1255                         NodeList networkIpsV6List = eElementNetworkKey.getElementsByTagNameNS("*","network-ips-v6")
1256                         for(int a = 0; a < networkIpsV6List.getLength(); a++){
1257                             Node ipV6Address = networkIpsV6List.item(a)
1258                             if (ipV6Address.getNodeType() == Node.ELEMENT_NODE) {
1259                                 Element eElementIpV6Address = (Element) ipV6Address
1260                                 String ipV6AddressValue = utils.getElementText(eElementIpV6Address, "ip-address-ipv6")
1261                                 if (a != networkIpsV6List.getLength() - 1) {
1262                                     ipV6AddressValues = sb4.append(ipV6AddressValue + ",")
1263                                 }
1264                                 else {
1265                                     ipV6AddressValues = sb4.append(ipV6AddressValue);
1266                                 }
1267                                 networkPosition = a.toString()
1268                                 String vmNetworksPositionsV6Xml =
1269                                                 """<entry>
1270                                                                                 <key>${MsoUtils.xmlEscape(key)}_${MsoUtils.xmlEscape(networkKey)}_v6_ip_${MsoUtils.xmlEscape(networkPosition)}</key>
1271                                                                                 <value>${MsoUtils.xmlEscape(ipV6AddressValue)}</value>
1272                                                                                 </entry>"""
1273                                 vmNetworksPositionsV6 = sbNetworksPositionsV6.append(vmNetworksPositionsV6Xml)
1274                             }
1275                         }
1276                         String vmNetworksV6Xml =
1277                                         """<entry>
1278                                                                 <key>${MsoUtils.xmlEscape(key)}_${MsoUtils.xmlEscape(networkKey)}_v6_ips</key>
1279                                                                 <value>${MsoUtils.xmlEscape(ipV6AddressValues)}</value>
1280                                                         </entry>"""
1281                         vmNetworks = sbVmNetworks.append(vmNetworksV6Xml)
1282                     }
1283                 }
1284                 String vnfXml =
1285                                 """<entry>
1286                                 <key>${MsoUtils.xmlEscape(key)}_names</key>
1287                                 <value>${MsoUtils.xmlEscape(values)}</value>
1288                                         </entry>"""
1289                 vnfVMS = sb.append(vnfXml)
1290             }
1291         }
1292         //SDNC Response Params
1293         String sdncResponseParams = ""
1294         List<String> sdncResponseParamsToSkip = [
1295             "vnf_id",
1296             "vf_module_id",
1297             "vnf_name",
1298             "vf_module_name"
1299         ]
1300         String vnfParamsChildNodes = utils.getChildNodes(data, "vnf-parameters")
1301         if(vnfParamsChildNodes == null || vnfParamsChildNodes.length() < 1){
1302             // No SDNC params
1303         }else{
1304             NodeList paramsList = responseXml.getElementsByTagNameNS("*", "vnf-parameters")
1305             for (int z = 0; z < paramsList.getLength(); z++) {
1306                 Node node = paramsList.item(z)
1307                 Element eElement = (Element) node
1308                 String vnfParameterName = utils.getElementText(eElement, "vnf-parameter-name")
1309                 if (!sdncResponseParamsToSkip.contains(vnfParameterName)) {
1310                     String vnfParameterValue = utils.getElementText(eElement, "vnf-parameter-value")
1311                     String paraEntry =
1312                                     """<entry>
1313                                                         <key>${MsoUtils.xmlEscape(vnfParameterName)}</key>
1314                                                         <value>${MsoUtils.xmlEscape(vnfParameterValue)}</value>
1315                                                 </entry>"""
1316                     sdncResponseParams = sb.append(paraEntry)
1317                 }
1318             }
1319         }
1320
1321
1322         def vfModuleParams = """
1323                 ${vnfInfo}
1324                 ${aZones}
1325                 ${vnfNetworkNetId}
1326                 ${vnfNetworkNetName}
1327                 ${vnfNetworkSubNetId}
1328                 ${vnfNetworkV6SubNetId}
1329                 ${vnfNetworkNetFqdn}
1330                 ${vnfNetworksSriovVlanFilters}
1331         ${vnfVMS}
1332         ${vnfVMSPositions}
1333                 ${vmNetworks}
1334                 ${vmNetworksPositions}
1335                 ${vmNetworksPositionsV6}
1336                 ${interfaceRoutePrefixes}
1337                 ${vnfParams}
1338                 ${sdncResponseParams}"""
1339
1340         return vfModuleParams
1341
1342     }
1343
1344 }