bpmn/MSOCommonBPMN/src/main/groovy/org/openecomp/mso/bpmn/common/scripts/VfModuleBase.groovy

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * OPENECOMP - MSO
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.mso.bpmn.common.scripts;
  22
  23 //import groovy.util.Node;
  24
  25 import javax.xml.parsers.DocumentBuilder
  26 import javax.xml.parsers.DocumentBuilderFactory
  27
  28 import org.apache.commons.lang3.*
  29 import org.camunda.bpm.engine.runtime.Execution
  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
  36
  37 public abstract class VfModuleBase extends AbstractServiceTaskProcessor {
  38
  39         protected XmlParser xmlParser = new XmlParser()
  40
  41         /**
  42          * Get the XmlParser.
  43          *
  44          * @return the XmlParser.
  45          */
  46         protected XmlParser getXmlParser() {
  47                 return xmlParser
  48         }
  49
  50         /**
  51          * Find the VF Module with specified ID in the specified Generic VF.  If no such
  52          * VF Module is found, null is returned.
  53          *
  54          * @param genericVnf The Generic VNF in which to search for the specified VF Moduel.
  55          * @param vfModuleId The ID of the VF Module for which to search.
  56          * @return a VFModule object for the found VF Module or null if no VF Module is found.
  57          */
  58         protected VfModule findVfModule(String genericVnf, String vfModuleId) {
  59
  60                 def genericVnfNode = xmlParser.parseText(genericVnf)
  61                 def vfModulesNode = utils.getChildNode(genericVnfNode, 'vf-modules')
  62                 if (vfModulesNode == null) {
  63                         return null
  64                 }
  65                 def vfModuleList = utils.getIdenticalChildren(vfModulesNode, 'vf-module')
  66                 for (vfModuleNode in vfModuleList) {
  67                         def vfModuleIdNode = utils.getChildNode(vfModuleNode, 'vf-module-id')
  68                         if ((vfModuleIdNode != null) && (vfModuleIdNode.text().equals(vfModuleId))) {
  69                                 return new VfModule(vfModuleNode, (vfModuleList.size() == 1))
  70                         }
  71                 }
  72                 return null
  73         }
  74
  75         /**
  76          * Transform all '*_network' parameter specifications from the incoming '*-params' root
  77          * element to a corresponding list of 'vnf-networks' specifications (typically used when
  78          * invoking the VNF Rest Adpater). Each element in '*-params' whose name attribute ends
  79          * with '_network' is used to create an 'vnf-networks' element.
  80          *
  81          * @param paramsNode A Node representing a '*-params' element.
  82          * @return a String of 'vnf-networks' elements, one for each 'param' element whose name
  83          * attribute ends with '_network'.
  84          */
  85         protected String transformNetworkParamsToVnfNetworks(String paramsRootXml) {
  86                 if ((paramsRootXml == null) || (paramsRootXml.isEmpty())) {
  87                         return ''
  88                 }
  89                 def String vnfNetworks = ''
  90                 try {
  91                         paramsRootXml = utils.removeXmlNamespaces(paramsRootXml)
  92                         def paramsNode = xmlParser.parseText(paramsRootXml)
  93                         def params = utils.getIdenticalChildren(paramsNode, 'param')
  94                         for (param in params) {
  95                                 def String attrName = (String) param.attribute('name')
  96                                 if (attrName.endsWith('_network')) {
  97                                         def networkRole = attrName.substring(0, (attrName.length()-'_network'.length()))
  98                                         def networkName = param.text()
  99                                         String vnfNetwork = """
 100                                                 <vnf-networks>
 101                                                         <network-role>${networkRole}</network-role>
 102                                                         <network-name>${networkName}</network-name>
 103                                                 </vnf-networks>
 104                                         """
 105                                         vnfNetworks = vnfNetworks + vnfNetwork
 106                                 }
 107                         }
 108                 } catch (Exception e) {
 109                         logWarn('Exception transforming \'_network\' params to vnfNetworks', e)
 110                 }
 111                 return vnfNetworks
 112         }
 113
 114         /**
 115          * Transform the parameter specifications from the incoming '*-params' root element to
 116          * a corresponding list of 'entry's (typically used when invoking the VNF Rest Adpater).
 117          * Each element in '*-params' is used to create an 'entry' element.
 118          *
 119          * @param paramsNode A Node representing a '*-params' element.
 120          * @return a String of 'entry' elements, one for each 'param' element.
 121          */
 122         protected String transformParamsToEntries(String paramsRootXml) {
 123                 if ((paramsRootXml == null) || (paramsRootXml.isEmpty())) {
 124                         return ''
 125                 }
 126                 def String entries = ''
 127                 try {
 128                         paramsRootXml = utils.removeXmlNamespaces(paramsRootXml)
 129                         def paramsNode = xmlParser.parseText(paramsRootXml)
 130                         def params = utils.getIdenticalChildren(paramsNode, 'param')
 131                         for (param in params) {
 132                                 def key = (String) param.attribute('name')
 133                                 if (key == null) {
 134                                         key = ''
 135                                 }
 136                                 def value = (String) param.text()
 137                                 String entry = """
 138                                         <entry>
 139                                                 <key>${key}</key>
 140                                                 <value>${value}</value>
 141                                         </entry>
 142                                 """
 143                                 entries = entries + entry
 144                         }
 145                 } catch (Exception e) {
 146                         logWarn('Exception transforming params to entries', e)
 147                 }
 148                 return entries
 149         }
 150
 151         /**
 152          * Transform the parameter specifications from the incoming '*-params' root element to
 153          * a corresponding list of 'entry's (typically used when invoking the VNF Rest Adpater).
 154          * Each element in '*-params' is used to create an 'entry' element.
 155          *
 156          * @param paramsNode A Node representing a '*-params' element.
 157          * @return a String of 'entry' elements, one for each 'param' element.
 158          */
 159         protected String transformVolumeParamsToEntries(String paramsRootXml) {
 160                 if ((paramsRootXml == null) || (paramsRootXml.isEmpty())) {
 161                         return ''
 162                 }
 163                 def String entries = ''
 164                 try {
 165                         paramsRootXml = utils.removeXmlNamespaces(paramsRootXml)
 166                         def paramsNode = xmlParser.parseText(paramsRootXml)
 167                         def params = utils.getIdenticalChildren(paramsNode, 'param')
 168                         for (param in params) {
 169                                 def key = (String) param.attribute('name')
 170                                 if (key == null) {
 171                                         key = ''
 172                                 }
 173                                 if ( !(key in ['vnf_id', 'vnf_name', 'vf_module_id', 'vf_module_name'])) {
 174                                         def value = (String) param.text()
 175                                         String entry = """
 176                                                 <entry>
 177                                                         <key>${key}</key>
 178                                                         <value>${value}</value>
 179                                                 </entry>
 180                                         """
 181                                         entries = entries + entry
 182                                 }
 183                         }
 184                 } catch (Exception e) {
 185                         logWarn('Exception transforming params to entries', e)
 186                 }
 187                 return entries
 188         }
 189
 190         /**
 191          * Extract the Tenant Id from the Volume Group information returned by AAI.
 192          *
 193          * @param volumeGroupXml Volume Group XML returned by AAI.
 194          * @return the Tenant Id extracted from the Volume Group information. 'null' is returned if
 195          * the Tenant Id is missing or could not otherwise be extracted.
 196          */
 197         protected String getTenantIdFromVolumeGroup(String volumeGroupXml) {
 198                 def groovy.util.Node volumeGroupNode = xmlParser.parseText(volumeGroupXml)
 199                 def groovy.util.Node relationshipList = utils.getChildNode(volumeGroupNode, 'relationship-list')
 200                 if (relationshipList != null) {
 201                         def groovy.util.NodeList relationships = utils.getIdenticalChildren(relationshipList, 'relationship')
 202                         for (groovy.util.Node relationship in relationships) {
 203                                 def groovy.util.Node relatedTo = utils.getChildNode(relationship, 'related-to')
 204                                 if ((relatedTo != null) && (relatedTo.text().equals('tenant'))) {
 205                                         def groovy.util.NodeList relationshipDataList = utils.getIdenticalChildren(relationship, 'relationship-data')
 206                                         for (groovy.util.Node relationshipData in relationshipDataList) {
 207                                                 def groovy.util.Node relationshipKey = utils.getChildNode(relationshipData, 'relationship-key')
 208                                                 if ((relationshipKey != null) && (relationshipKey.text().equals('tenant.tenant-id'))) {
 209                                                         def groovy.util.Node relationshipValue = utils.getChildNode(relationshipData, 'relationship-value')
 210                                                         if (relationshipValue != null) {
 211                                                                 return relationshipValue.text()
 212                                                         }
 213                                                 }
 214                                         }
 215                                 }
 216                         }
 217                 }
 218                 return null
 219         }
 220
 221
 222         /*
 223          * Parses VNF parameters passed in on the incoming requests and SDNC parameters returned from SDNC get response
 224          * and puts them into the format expected by VNF adapter.
 225          * @param vnfParamsMap -  map of VNF parameters passed in the request body
 226          * @param sdncGetResponse - response string from SDNC GET topology request
 227          * @param vnfId
 228          * @param vnfName
 229          * @param vfModuleId
 230          * @param vfModuleName
 231          * @return a String of key/value entries for vfModuleParams
 232          */
 233
 234
 235          protected String buildVfModuleParams(String vnfParams, String sdncGetResponse, String vnfId, String vnfName,
 236                         String vfModuleId, String vfModuleName) {
 237
 238                         //Get SDNC Response Data
 239
 240                         String data = utils.getNodeXml(sdncGetResponse, "response-data")
 241                         data = data.replaceAll("&lt;", "<")
 242                         data = data.replaceAll("&gt;", ">")
 243
 244                         String serviceData = utils.getNodeXml(data, "service-data")
 245                         serviceData = utils.removeXmlPreamble(serviceData)
 246                         serviceData = utils.removeXmlNamespaces(serviceData)
 247                         String vnfRequestInfo = utils.getNodeXml(serviceData, "vnf-request-information")
 248                         String oldVnfId = utils.getNodeXml(vnfRequestInfo, "vnf-id")
 249                         oldVnfId = utils.removeXmlPreamble(oldVnfId)
 250                         oldVnfId = utils.removeXmlNamespaces(oldVnfId)
 251                         serviceData = serviceData.replace(oldVnfId, "")
 252                         def vnfId1 = utils.getNodeText1(serviceData, "vnf-id")
 253
 254                         // Add-on data
 255                         String vnfInfo =
 256                                 """<entry>
 257                                                 <key>vnf_id</key>
 258                                                 <value>${vnfId}</value>
 259                                         </entry>
 260                                         <entry>
 261                                                 <key>vnf_name</key>
 262                                                 <value>${vnfName}</value>
 263                                         </entry>
 264                                         <entry>
 265                                                 <key>vf_module_id</key>
 266                                                 <value>${vfModuleId}</value>
 267                                         </entry>
 268                                         <entry>
 269                                                 <key>vf_module_name</key>
 270                                                 <value>${vfModuleName}</value>
 271                                         </entry>"""
 272
 273                         utils.logAudit("vnfInfo: " + vnfInfo)
 274                         InputSource source = new InputSource(new StringReader(data));
 275                         DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
 276                         docFactory.setNamespaceAware(true)
 277                         DocumentBuilder docBuilder = docFactory.newDocumentBuilder()
 278                         Document responseXml = docBuilder.parse(source)
 279
 280
 281                         // Availability Zones Data
 282                         String aZones = ""
 283                         StringBuilder sbAZone = new StringBuilder()
 284                         NodeList aZonesList = responseXml.getElementsByTagNameNS("*", "availability-zones")
 285                         String aZonePosition = "0"
 286                         for (int z = 0; z < aZonesList.getLength(); z++) {
 287                                 Node node = aZonesList.item(z)
 288                                 if (node.getNodeType() == Node.ELEMENT_NODE) {
 289                                         Element eElement = (Element) node
 290                                         String aZoneValue = utils.getElementText(eElement, "availability-zone")
 291                                         aZonePosition = z.toString()
 292                                         String aZoneXml =
 293                                                         """<entry>
 294                                                 <key>availability_zone_${aZonePosition}</key>
 295                                                 <value>${aZoneValue}</value>
 296                                 </entry>"""
 297                                         aZones = sbAZone.append(aZoneXml)
 298                                 }
 299                         }
 300
 301                         // VNF Networks Data
 302                         String vnfNetworkNetId = ""
 303                         String vnfNetworkNetName = ""
 304                         String vnfNetworkSubNetId = ""
 305                         String vnfNetworkV6SubNetId = ""
 306                         String vnfNetworkNetFqdn = ""
 307                         String vnfNetworksSriovVlanFilters = ""
 308                         StringBuilder sbNet = new StringBuilder()
 309                         StringBuilder sbNet2 = new StringBuilder()
 310                         StringBuilder sbNet3 = new StringBuilder()
 311                         StringBuilder sbNet4 = new StringBuilder()
 312                         StringBuilder sbNet5 = new StringBuilder()
 313                         StringBuilder sbNet6 = new StringBuilder()
 314                         NodeList vnfNetworkList = responseXml.getElementsByTagNameNS("*", "vnf-networks")
 315                         for (int x = 0; x < vnfNetworkList.getLength(); x++) {
 316                                 Node node = vnfNetworkList.item(x)
 317                                 if (node.getNodeType() == Node.ELEMENT_NODE) {
 318                                         Element eElement = (Element) node
 319                                         String vnfNetworkKey = utils.getElementText(eElement, "network-role")
 320                                         String vnfNetworkNeutronIdValue = utils.getElementText(eElement, "neutron-id")
 321                                         String vnfNetworkNetNameValue = utils.getElementText(eElement, "network-name")
 322                                         String vnfNetworkSubNetIdValue = utils.getElementText(eElement, "subnet-id")
 323                                         String vnfNetworkV6SubNetIdValue = utils.getElementText(eElement, "ipv6-subnet-id")
 324                                         String vnfNetworkNetFqdnValue = utils.getElementText(eElement, "contrail-network-fqdn")
 325                                         String vnfNetworkNetIdXml =
 326                                                         """<entry>
 327                                                                 <key>${vnfNetworkKey}_net_id</key>
 328                                                                 <value>${vnfNetworkNeutronIdValue}</value>
 329                                                         </entry>"""
 330                                         vnfNetworkNetId = sbNet.append(vnfNetworkNetIdXml)
 331                                         String vnfNetworkNetNameXml =
 332                                                         """<entry>
 333                                                 <key>${vnfNetworkKey}_net_name</key>
 334                                                 <value>${vnfNetworkNetNameValue}</value>
 335                                 </entry>"""
 336                                         vnfNetworkNetName = sbNet2.append(vnfNetworkNetNameXml)
 337                                         String vnfNetworkSubNetIdXml =
 338                                                         """<entry>
 339                                                 <key>${vnfNetworkKey}_subnet_id</key>
 340                                                 <value>${vnfNetworkSubNetIdValue}</value>
 341                                 </entry>"""
 342                                         vnfNetworkSubNetId = sbNet3.append(vnfNetworkSubNetIdXml)
 343                                         String vnfNetworkV6SubNetIdXml =
 344                                                         """<entry>
 345                                                 <key>${vnfNetworkKey}_v6_subnet_id</key>
 346                                                 <value>${vnfNetworkV6SubNetIdValue}</value>
 347                                 </entry>"""
 348                                         vnfNetworkV6SubNetId = sbNet5.append(vnfNetworkV6SubNetIdXml)
 349                                         String vnfNetworkNetFqdnXml =
 350                                                         """<entry>
 351                                                 <key>${vnfNetworkKey}_net_fqdn</key>
 352                                                 <value>${vnfNetworkNetFqdnValue}</value>
 353                                 </entry>"""
 354                                         vnfNetworkNetFqdn = sbNet4.append(vnfNetworkNetFqdnXml)
 355
 356                                         NodeList sriovVlanFilterList = eElement.getElementsByTagNameNS("*","sriov-vlan-filter-list")
 357                                         StringBuffer sriovFilterBuf = new StringBuffer()
 358                                         String values = ""
 359                                         for(int i = 0; i < sriovVlanFilterList.getLength(); i++){
 360                                                 Node node1 = sriovVlanFilterList.item(i)
 361                                                 if (node1.getNodeType() == Node.ELEMENT_NODE) {
 362                                                         Element eElement1 = (Element) node1
 363                                                         String value = utils.getElementText(eElement1, "sriov-vlan-filter")
 364                                                         if (i != sriovVlanFilterList.getLength() - 1) {
 365                                                                 values = sriovFilterBuf.append(value + ",")
 366                                                         }
 367                                                         else {
 368                                                                 values = sriovFilterBuf.append(value);
 369                                                         }
 370                                                 }
 371                                         }
 372                                         if (!values.isEmpty()) {
 373                                                         String vnfNetworkSriovVlanFilterXml =
 374                                                                         """<entry>
 375                                                                 <key>${vnfNetworkKey}_ATT_VF_VLAN_FILTER</key>
 376                                                                 <value>${values}</value>
 377                                                         </entry>"""
 378                                                         vnfNetworksSriovVlanFilters = sbNet6.append(vnfNetworkSriovVlanFilterXml)
 379                                                 }
 380                                         }
 381                         }
 382
 383                         // VNF-VMS Data
 384                         String vnfVMS = ""
 385                         String vnfVMSPositions = ""
 386                         String vmNetworks = ""
 387                         String vmNetworksPositions = ""
 388                         String vmNetworksPositionsV6 = ""
 389                         String interfaceRoutePrefixes = ""
 390                         def key
 391                         def value
 392                         def networkKey
 393                         def networkValue
 394                         def floatingIPKey
 395                         def floatingIPKeyValue
 396                         def floatingIPV6Key
 397                         def floatingIPV6KeyValue
 398                         StringBuilder sb = new StringBuilder()
 399                         StringBuilder sbPositions = new StringBuilder()
 400                         StringBuilder sbVmNetworks = new StringBuilder()
 401                         StringBuilder sbNetworksPositions = new StringBuilder()
 402                         StringBuilder sbInterfaceRoutePrefixes = new StringBuilder()
 403                         StringBuilder sbNetworksPositionsV6 = new StringBuilder()
 404
 405                         NodeList vmsList = responseXml.getElementsByTagNameNS("*","vnf-vms")
 406                         for (int x = 0; x < vmsList.getLength(); x++) {
 407                                 Node node = vmsList.item(x)
 408                                 if (node.getNodeType() == Node.ELEMENT_NODE) {
 409                                         Element eElement = (Element) node
 410                                         key = utils.getElementText(eElement, "vm-type")
 411                                         String values
 412                                         String position = "0"
 413                                         StringBuilder sb1 = new StringBuilder()
 414                                         NodeList valueList = eElement.getElementsByTagNameNS("*","vm-names")
 415                                         NodeList vmNetworksList = eElement.getElementsByTagNameNS("*","vm-networks")
 416                                         for(int i = 0; i < valueList.getLength(); i++){
 417                                                 Node node1 = valueList.item(i)
 418                                                 if (node1.getNodeType() == Node.ELEMENT_NODE) {
 419                                                         Element eElement1 = (Element) node1
 420                                                         value = utils.getElementText(eElement1, "vm-name")
 421                                                         if (i != valueList.getLength() - 1) {
 422                                                                 values = sb1.append(value + ",")
 423                                                         }
 424                                                         else {
 425                                                                 values = sb1.append(value);
 426                                                         }
 427                                                         position = i.toString()
 428                                                         String vnfPositionXml =
 429                                                                         """<entry>
 430                                                                 <key>${key}_name_${position}</key>
 431                                                                 <value>${value}</value>
 432                                                         </entry>"""
 433                                                         vnfVMSPositions = sbPositions.append(vnfPositionXml)
 434                                                 }
 435                                         }
 436                                         for(int n = 0; n < vmNetworksList.getLength(); n++){
 437                                                 String floatingIpKeyValueStr = ""
 438                                                 String floatingIpV6KeyValueStr = ""
 439                                                 Node nodeNetworkKey = vmNetworksList.item(n)
 440                                                 if (nodeNetworkKey.getNodeType() == Node.ELEMENT_NODE) {
 441                                                         Element eElementNetworkKey = (Element) nodeNetworkKey
 442                                                         String ipAddressValues
 443                                                         String ipV6AddressValues
 444                                                         String networkPosition = "0"
 445                                                         StringBuilder sb2 = new StringBuilder()
 446                                                         StringBuilder sb3 = new StringBuilder()
 447                                                         StringBuilder sb4 = new StringBuilder()
 448                                                         networkKey = utils.getElementText(eElementNetworkKey, "network-role")
 449                                                         floatingIPKey = key + '_' + networkKey + '_floating_ip'
 450                                                         floatingIPKeyValue = utils.getElementText(eElementNetworkKey, "floating-ip")
 451                                                         if(!floatingIPKeyValue.isEmpty()){
 452                                                                 floatingIpKeyValueStr = """<entry>
 453                                                                 <key>$floatingIPKey</key>
 454                                                                 <value>$floatingIPKeyValue</value>
 455                                                         </entry>"""
 456                                                         }
 457                                                         floatingIPV6Key = key + '_' + networkKey + '_floating_v6_ip'
 458                                                         floatingIPV6KeyValue = utils.getElementText(eElementNetworkKey, "floating-ip-v6")
 459                                                         if(!floatingIPV6KeyValue.isEmpty()){
 460                                                                 floatingIpV6KeyValueStr = """<entry>
 461                                                                 <key>$floatingIPV6Key</key>
 462                                                                 <value>$floatingIPV6KeyValue</value>
 463                                                         </entry>"""
 464                                                         }
 465                                                         NodeList networkIpsList = eElementNetworkKey.getElementsByTagNameNS("*","network-ips")
 466                                                         for(int a = 0; a < networkIpsList.getLength(); a++){
 467                                                                 Node ipAddress = networkIpsList.item(a)
 468                                                                 if (ipAddress.getNodeType() == Node.ELEMENT_NODE) {
 469                                                                         Element eElementIpAddress = (Element) ipAddress
 470                                                                         String ipAddressValue = utils.getElementText(eElementIpAddress, "ip-address")
 471                                                                         if (a != networkIpsList.getLength() - 1) {
 472                                                                                 ipAddressValues = sb2.append(ipAddressValue + ",")
 473                                                                         }
 474                                                                         else {
 475                                                                                 ipAddressValues = sb2.append(ipAddressValue);
 476                                                                         }
 477                                                                         networkPosition = a.toString()
 478                                                                         String vmNetworksPositionsXml =
 479                                                                                         """<entry>
 480                                                                                 <key>${key}_${networkKey}_ip_${networkPosition}</key>
 481                                                                                 <value>${ipAddressValue}</value>
 482                                                                         </entry>"""
 483                                                                         vmNetworksPositions = sbNetworksPositions.append(vmNetworksPositionsXml)
 484                                                                 }
 485                                                         }
 486                                                         vmNetworksPositions = sbNetworksPositions.append(floatingIpKeyValueStr).append(floatingIpV6KeyValueStr)
 487
 488                                                         String vmNetworksXml =
 489                                                                         """<entry>
 490                                                                 <key>${key}_${networkKey}_ips</key>
 491                                                                 <value>${ipAddressValues}</value>
 492                                                         </entry>"""
 493                                                         vmNetworks = sbVmNetworks.append(vmNetworksXml)
 494
 495                                                         NodeList interfaceRoutePrefixesList = eElementNetworkKey.getElementsByTagNameNS("*","interface-route-prefixes")
 496                                                         String interfaceRoutePrefixValues = sb3.append("[")
 497
 498                                                         for(int a = 0; a < interfaceRoutePrefixesList.getLength(); a++){
 499                                                                 Node interfaceRoutePrefix = interfaceRoutePrefixesList.item(a)
 500                                                                 if (interfaceRoutePrefix.getNodeType() == Node.ELEMENT_NODE) {
 501                                                                         Element eElementInterfaceRoutePrefix = (Element) interfaceRoutePrefix
 502                                                                         String interfaceRoutePrefixValue = utils.getElementText(eElementInterfaceRoutePrefix, "interface-route-prefix-cidr")
 503                                                                         if (interfaceRoutePrefixValue == null || interfaceRoutePrefixValue.isEmpty()) {
 504                                                                                 interfaceRoutePrefixValue = utils.getElementText(eElementInterfaceRoutePrefix, "interface-route-prefix")
 505                                                                         }
 506                                                                         if (a != interfaceRoutePrefixesList.getLength() - 1) {
 507                                                                                 interfaceRoutePrefixValues = sb3.append("{\"interface_route_table_routes_route_prefix\": \"" + interfaceRoutePrefixValue + "\"}" + ",")
 508                                                                         }
 509                                                                         else {
 510                                                                                 interfaceRoutePrefixValues = sb3.append("{\"interface_route_table_routes_route_prefix\": \"" + interfaceRoutePrefixValue + "\"}")
 511                                                                         }
 512                                                                 }
 513                                                         }
 514                                                         interfaceRoutePrefixValues = sb3.append("]")
 515                                                         if (interfaceRoutePrefixesList.getLength() > 0) {
 516                                                                 String interfaceRoutePrefixesXml =
 517                                                                                                 """<entry>
 518                                                                                         <key>${key}_${networkKey}_route_prefixes</key>
 519                                                                                         <value>${interfaceRoutePrefixValues}</value>
 520                                                                                 </entry>"""
 521                                                                 interfaceRoutePrefixes = sbInterfaceRoutePrefixes.append(interfaceRoutePrefixesXml)
 522                                                         }
 523
 524                                                         NodeList networkIpsV6List = eElementNetworkKey.getElementsByTagNameNS("*","network-ips-v6")
 525                                                         for(int a = 0; a < networkIpsV6List.getLength(); a++){
 526                                                                 Node ipV6Address = networkIpsV6List.item(a)
 527                                                                 if (ipV6Address.getNodeType() == Node.ELEMENT_NODE) {
 528                                                                         Element eElementIpV6Address = (Element) ipV6Address
 529                                                                         String ipV6AddressValue = utils.getElementText(eElementIpV6Address, "ip-address-ipv6")
 530                                                                         if (a != networkIpsV6List.getLength() - 1) {
 531                                                                                 ipV6AddressValues = sb4.append(ipV6AddressValue + ",")
 532                                                                         }
 533                                                                         else {
 534                                                                                 ipV6AddressValues = sb4.append(ipV6AddressValue);
 535                                                                         }
 536                                                                         networkPosition = a.toString()
 537                                                                         String vmNetworksPositionsV6Xml =
 538                                                                                         """<entry>
 539                                                                                 <key>${key}_${networkKey}_v6_ip_${networkPosition}</key>
 540                                                                                 <value>${ipV6AddressValue}</value>
 541                                                                         </entry>"""
 542                                                                         vmNetworksPositionsV6 = sbNetworksPositionsV6.append(vmNetworksPositionsV6Xml)
 543                                                                 }
 544                                                         }
 545                                                         String vmNetworksV6Xml =
 546                                                                         """<entry>
 547                                                                 <key>${key}_${networkKey}_v6_ips</key>
 548                                                                 <value>${ipV6AddressValues}</value>
 549                                                         </entry>"""
 550                                                         vmNetworks = sbVmNetworks.append(vmNetworksV6Xml)
 551                                                 }
 552                                         }
 553                                         String vnfXml =
 554                                                         """<entry>
 555                                 <key>${key}_names</key>
 556                                 <value>${values}</value>
 557                                         </entry>"""
 558                                         vnfVMS = sb.append(vnfXml)
 559                                 }
 560                         }
 561                 //SDNC Response Params
 562                         String sdncResponseParams = ""
 563                         List<String> sdncResponseParamsToSkip = ["vnf_id", "vf_module_id", "vnf_name", "vf_module_name"]
 564                         String vnfParamsChildNodes = utils.getChildNodes(data, "vnf-parameters")
 565                         if(vnfParamsChildNodes == null || vnfParamsChildNodes.length() < 1){
 566                                 // No SDNC params
 567                         }else{
 568                                 NodeList paramsList = responseXml.getElementsByTagNameNS("*", "vnf-parameters")
 569                                 for (int z = 0; z < paramsList.getLength(); z++) {
 570                                         Node node = paramsList.item(z)
 571                                         Element eElement = (Element) node
 572                                         String vnfParameterName = utils.getElementText(eElement, "vnf-parameter-name")
 573                                         if (!sdncResponseParamsToSkip.contains(vnfParameterName)) {
 574                                                 String vnfParameterValue = utils.getElementText(eElement, "vnf-parameter-value")
 575                                                 String paraEntry =
 576                                                 """<entry>
 577                                                         <key>${vnfParameterName}</key>
 578                                                         <value>${vnfParameterValue}</value>
 579                                                 </entry>"""
 580                                                 sdncResponseParams = sb.append(paraEntry)
 581                                         }
 582                                 }
 583                         }
 584
 585
 586                 def vfModuleParams = """
 587                 ${vnfInfo}
 588                 ${aZones}
 589                 ${vnfNetworkNetId}
 590                 ${vnfNetworkNetName}
 591                 ${vnfNetworkSubNetId}
 592                 ${vnfNetworkV6SubNetId}
 593                 ${vnfNetworkNetFqdn}
 594                 ${vnfNetworksSriovVlanFilters}
 595         ${vnfVMS}
 596         ${vnfVMSPositions}
 597                 ${vmNetworks}
 598                 ${vmNetworksPositions}
 599                 ${vmNetworksPositionsV6}
 600                 ${interfaceRoutePrefixes}
 601                 ${vnfParams}
 602                 ${sdncResponseParams}"""
 603
 604                 return vfModuleParams
 605
 606         }
 607
 608
 609 }