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