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

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