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

   1 /*-\r
   2  * ============LICENSE_START=======================================================\r
   3  * OPENECOMP - MSO\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 groovy.util.Node;\r
  24 \r
  25 import javax.xml.parsers.DocumentBuilder\r
  26 import javax.xml.parsers.DocumentBuilderFactory\r
  27 \r
  28 import org.apache.commons.lang3.*\r
  29 import org.camunda.bpm.engine.runtime.Execution\r
  30 import org.w3c.dom.Document\r
  31 import org.w3c.dom.Element\r
  32 import org.w3c.dom.Node\r
  33 import org.w3c.dom.NodeList\r
  34 import org.xml.sax.InputSource\r
  35 \r
  36 \r
  37 public abstract class VfModuleBase extends AbstractServiceTaskProcessor {\r
  38         \r
  39         protected XmlParser xmlParser = new XmlParser()\r
  40         \r
  41         /**\r
  42          * Get the XmlParser.\r
  43          * \r
  44          * @return the XmlParser.\r
  45          */\r
  46         protected XmlParser getXmlParser() {\r
  47                 return xmlParser\r
  48         }\r
  49         \r
  50         /**\r
  51          * Find the VF Module with specified ID in the specified Generic VF.  If no such\r
  52          * VF Module is found, null is returned.\r
  53          * \r
  54          * @param genericVnf The Generic VNF in which to search for the specified VF Moduel.\r
  55          * @param vfModuleId The ID of the VF Module for which to search.\r
  56          * @return a VFModule object for the found VF Module or null if no VF Module is found.\r
  57          */\r
  58         protected VfModule findVfModule(String genericVnf, String vfModuleId) {\r
  59                 \r
  60                 def genericVnfNode = xmlParser.parseText(genericVnf)\r
  61                 def vfModulesNode = utils.getChildNode(genericVnfNode, 'vf-modules')\r
  62                 if (vfModulesNode == null) {\r
  63                         return null\r
  64                 }\r
  65                 def vfModuleList = utils.getIdenticalChildren(vfModulesNode, 'vf-module')\r
  66                 for (vfModuleNode in vfModuleList) {\r
  67                         def vfModuleIdNode = utils.getChildNode(vfModuleNode, 'vf-module-id')\r
  68                         if ((vfModuleIdNode != null) && (vfModuleIdNode.text().equals(vfModuleId))) {\r
  69                                 return new VfModule(vfModuleNode, (vfModuleList.size() == 1))\r
  70                         }\r
  71                 }\r
  72                 return null\r
  73         }\r
  74         \r
  75         /**\r
  76          * Transform all '*_network' parameter specifications from the incoming '*-params' root\r
  77          * element to a corresponding list of 'vnf-networks' specifications (typically used when\r
  78          * invoking the VNF Rest Adpater). Each element in '*-params' whose name attribute ends\r
  79          * with '_network' is used to create an 'vnf-networks' element.\r
  80          * \r
  81          * @param paramsNode A Node representing a '*-params' element.\r
  82          * @return a String of 'vnf-networks' elements, one for each 'param' element whose name\r
  83          * attribute ends with '_network'.\r
  84          */\r
  85         protected String transformNetworkParamsToVnfNetworks(String paramsRootXml) {\r
  86                 if ((paramsRootXml == null) || (paramsRootXml.isEmpty())) {\r
  87                         return ''\r
  88                 }\r
  89                 def String vnfNetworks = ''\r
  90                 try {\r
  91                         paramsRootXml = utils.removeXmlNamespaces(paramsRootXml)\r
  92                         def paramsNode = xmlParser.parseText(paramsRootXml)\r
  93                         def params = utils.getIdenticalChildren(paramsNode, 'param')\r
  94                         for (param in params) {\r
  95                                 def String attrName = (String) param.attribute('name')\r
  96                                 if (attrName.endsWith('_network')) {\r
  97                                         def networkRole = attrName.substring(0, (attrName.length()-'_network'.length()))\r
  98                                         def networkName = param.text()\r
  99                                         String vnfNetwork = """\r
 100                                                 <vnf-networks>\r
 101                                                         <network-role>${networkRole}</network-role>\r
 102                                                         <network-name>${networkName}</network-name>\r
 103                                                 </vnf-networks>\r
 104                                         """\r
 105                                         vnfNetworks = vnfNetworks + vnfNetwork\r
 106                                 }\r
 107                         }\r
 108                 } catch (Exception e) {\r
 109                         logWarn('Exception transforming \'_network\' params to vnfNetworks', e)\r
 110                 }\r
 111                 return vnfNetworks\r
 112         }\r
 113         \r
 114         /**\r
 115          * Transform the parameter specifications from the incoming '*-params' root element to\r
 116          * a corresponding list of 'entry's (typically used when invoking the VNF Rest Adpater).\r
 117          * Each element in '*-params' is used to create an 'entry' element.\r
 118          *\r
 119          * @param paramsNode A Node representing a '*-params' element.\r
 120          * @return a String of 'entry' elements, one for each 'param' element.\r
 121          */\r
 122         protected String transformParamsToEntries(String paramsRootXml) {\r
 123                 if ((paramsRootXml == null) || (paramsRootXml.isEmpty())) {\r
 124                         return ''\r
 125                 }\r
 126                 def String entries = ''\r
 127                 try {\r
 128                         paramsRootXml = utils.removeXmlNamespaces(paramsRootXml)\r
 129                         def paramsNode = xmlParser.parseText(paramsRootXml)\r
 130                         def params = utils.getIdenticalChildren(paramsNode, 'param')\r
 131                         for (param in params) {\r
 132                                 def key = (String) param.attribute('name')\r
 133                                 if (key == null) {\r
 134                                         key = ''\r
 135                                 }\r
 136                                 def value = (String) param.text()\r
 137                                 String entry = """\r
 138                                         <entry>\r
 139                                                 <key>${key}</key>\r
 140                                                 <value>${value}</value>\r
 141                                         </entry>\r
 142                                 """\r
 143                                 entries = entries + entry\r
 144                         }\r
 145                 } catch (Exception e) {\r
 146                         logWarn('Exception transforming params to entries', e)\r
 147                 }\r
 148                 return entries\r
 149         }\r
 150         \r
 151         /**\r
 152          * Transform the parameter specifications from the incoming '*-params' root element to\r
 153          * a corresponding list of 'entry's (typically used when invoking the VNF Rest Adpater).\r
 154          * Each element in '*-params' is used to create an 'entry' element.\r
 155          *\r
 156          * @param paramsNode A Node representing a '*-params' element.\r
 157          * @return a String of 'entry' elements, one for each 'param' element.\r
 158          */\r
 159         protected String transformVolumeParamsToEntries(String paramsRootXml) {\r
 160                 if ((paramsRootXml == null) || (paramsRootXml.isEmpty())) {\r
 161                         return ''\r
 162                 }\r
 163                 def String entries = ''\r
 164                 try {\r
 165                         paramsRootXml = utils.removeXmlNamespaces(paramsRootXml)\r
 166                         def paramsNode = xmlParser.parseText(paramsRootXml)\r
 167                         def params = utils.getIdenticalChildren(paramsNode, 'param')\r
 168                         for (param in params) {\r
 169                                 def key = (String) param.attribute('name')\r
 170                                 if (key == null) {\r
 171                                         key = ''\r
 172                                 }\r
 173                                 if ( !(key in ['vnf_id', 'vnf_name', 'vf_module_id', 'vf_module_name'])) {\r
 174                                         def value = (String) param.text()\r
 175                                         String entry = """\r
 176                                                 <entry>\r
 177                                                         <key>${key}</key>\r
 178                                                         <value>${value}</value>\r
 179                                                 </entry>\r
 180                                         """\r
 181                                         entries = entries + entry\r
 182                                 }\r
 183                         }\r
 184                 } catch (Exception e) {\r
 185                         logWarn('Exception transforming params to entries', e)\r
 186                 }\r
 187                 return entries\r
 188         }\r
 189         \r
 190         /**\r
 191          * Extract the Tenant Id from the Volume Group information returned by AAI.\r
 192          * \r
 193          * @param volumeGroupXml Volume Group XML returned by AAI.\r
 194          * @return the Tenant Id extracted from the Volume Group information. 'null' is returned if\r
 195          * the Tenant Id is missing or could not otherwise be extracted.\r
 196          */\r
 197         protected String getTenantIdFromVolumeGroup(String volumeGroupXml) {\r
 198                 def groovy.util.Node volumeGroupNode = xmlParser.parseText(volumeGroupXml)\r
 199                 def groovy.util.Node relationshipList = utils.getChildNode(volumeGroupNode, 'relationship-list')\r
 200                 if (relationshipList != null) {\r
 201                         def groovy.util.NodeList relationships = utils.getIdenticalChildren(relationshipList, 'relationship')\r
 202                         for (groovy.util.Node relationship in relationships) {\r
 203                                 def groovy.util.Node relatedTo = utils.getChildNode(relationship, 'related-to')\r
 204                                 if ((relatedTo != null) && (relatedTo.text().equals('tenant'))) {\r
 205                                         def groovy.util.NodeList relationshipDataList = utils.getIdenticalChildren(relationship, 'relationship-data')\r
 206                                         for (groovy.util.Node relationshipData in relationshipDataList) {\r
 207                                                 def groovy.util.Node relationshipKey = utils.getChildNode(relationshipData, 'relationship-key')\r
 208                                                 if ((relationshipKey != null) && (relationshipKey.text().equals('tenant.tenant-id'))) {\r
 209                                                         def groovy.util.Node relationshipValue = utils.getChildNode(relationshipData, 'relationship-value')\r
 210                                                         if (relationshipValue != null) {\r
 211                                                                 return relationshipValue.text()\r
 212                                                         }\r
 213                                                 }\r
 214                                         }\r
 215                                 }\r
 216                         }\r
 217                 }\r
 218                 return null\r
 219         }\r
 220         \r
 221         \r
 222         /*\r
 223          * Parses VNF parameters passed in on the incoming requests and SDNC parameters returned from SDNC get response\r
 224          * and puts them into the format expected by VNF adapter.\r
 225          * @param vnfParamsMap -  map of VNF parameters passed in the request body\r
 226          * @param sdncGetResponse - response string from SDNC GET topology request\r
 227          * @param vnfId\r
 228          * @param vnfName\r
 229          * @param vfModuleId\r
 230          * @param vfModuleName\r
 231          * @param vfModuleIndex - can be null\r
 232          * @return a String of key/value entries for vfModuleParams\r
 233          */\r
 234           \r
 235          \r
 236          protected String buildVfModuleParams(Map<String, String> vnfParamsMap, String sdncGetResponse, String vnfId, String vnfName,\r
 237                         String vfModuleId, String vfModuleName, String vfModuleIndex) {\r
 238                         \r
 239                         //Get SDNC Response Data\r
 240                         \r
 241                         String data = utils.getNodeXml(sdncGetResponse, "response-data")\r
 242                         data = data.replaceAll("&lt;", "<")\r
 243                         data = data.replaceAll("&gt;", ">")\r
 244 \r
 245                         String serviceData = utils.getNodeXml(data, "service-data")\r
 246                         serviceData = utils.removeXmlPreamble(serviceData)\r
 247                         serviceData = utils.removeXmlNamespaces(serviceData)\r
 248                         String vnfRequestInfo = utils.getNodeXml(serviceData, "vnf-request-information")\r
 249                         String oldVnfId = utils.getNodeXml(vnfRequestInfo, "vnf-id")\r
 250                         oldVnfId = utils.removeXmlPreamble(oldVnfId)\r
 251                         oldVnfId = utils.removeXmlNamespaces(oldVnfId)\r
 252                         serviceData = serviceData.replace(oldVnfId, "")\r
 253                         def vnfId1 = utils.getNodeText1(serviceData, "vnf-id")\r
 254                         \r
 255                         Map<String, String> paramsMap = new HashMap<String, String>()\r
 256                         \r
 257                         if (vfModuleIndex != null) {\r
 258                                 paramsMap.put("vf_module_index", "${vfModuleIndex}")\r
 259                         }\r
 260 \r
 261                         // Add-on data\r
 262                         paramsMap.put("vnf_id", "${vnfId}")\r
 263                         paramsMap.put("vnf_name", "${vnfName}")\r
 264                         paramsMap.put("vf_module_id", "${vfModuleId}")\r
 265                         paramsMap.put("vf_module_name", "${vfModuleName}")\r
 266                         \r
 267                         InputSource source = new InputSource(new StringReader(data));\r
 268                         DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();\r
 269                         docFactory.setNamespaceAware(true)\r
 270                         DocumentBuilder docBuilder = docFactory.newDocumentBuilder()\r
 271                         Document responseXml = docBuilder.parse(source)\r
 272 \r
 273 \r
 274                         // Availability Zones Data\r
 275                         \r
 276                         NodeList aZonesList = responseXml.getElementsByTagNameNS("*", "availability-zones")\r
 277                         String aZonePosition = "0"\r
 278                         for (int z = 0; z < aZonesList.getLength(); z++) {\r
 279                                 Node node = aZonesList.item(z)\r
 280                                 if (node.getNodeType() == Node.ELEMENT_NODE) {\r
 281                                         Element eElement = (Element) node\r
 282                                         String aZoneValue = utils.getElementText(eElement, "availability-zone")\r
 283                                         aZonePosition = z.toString()\r
 284                                         paramsMap.put("availability_zone_${aZonePosition}", "${aZoneValue}")\r
 285                                 }\r
 286                         }\r
 287 \r
 288                         // VNF Networks Data\r
 289                         \r
 290                         StringBuilder sbNet = new StringBuilder()\r
 291                         \r
 292                         NodeList vnfNetworkList = responseXml.getElementsByTagNameNS("*", "vnf-networks")\r
 293                         for (int x = 0; x < vnfNetworkList.getLength(); x++) {\r
 294                                 Node node = vnfNetworkList.item(x)\r
 295                                 if (node.getNodeType() == Node.ELEMENT_NODE) {\r
 296                                         Element eElement = (Element) node\r
 297                                         String vnfNetworkKey = utils.getElementText(eElement, "network-role")\r
 298                                         String vnfNetworkNeutronIdValue = utils.getElementText(eElement, "neutron-id")\r
 299                                         String vnfNetworkNetNameValue = utils.getElementText(eElement, "network-name")\r
 300                                         String vnfNetworkSubNetIdValue = utils.getElementText(eElement, "subnet-id")\r
 301                                         String vnfNetworkV6SubNetIdValue = utils.getElementText(eElement, "ipv6-subnet-id")\r
 302                                         String vnfNetworkNetFqdnValue = utils.getElementText(eElement, "contrail-network-fqdn")\r
 303                                         paramsMap.put("${vnfNetworkKey}_net_id", "${vnfNetworkNeutronIdValue}")\r
 304                                         paramsMap.put("${vnfNetworkKey}_net_name", "${vnfNetworkNetNameValue}")\r
 305                                         paramsMap.put("${vnfNetworkKey}_subnet_id", "${vnfNetworkSubNetIdValue}")\r
 306                                         paramsMap.put("${vnfNetworkKey}_v6_subnet_id", "${vnfNetworkV6SubNetIdValue}")\r
 307                                         paramsMap.put("${vnfNetworkKey}_net_fqdn", "${vnfNetworkNetFqdnValue}")\r
 308                                         \r
 309                                         NodeList sriovVlanFilterList = eElement.getElementsByTagNameNS("*","sriov-vlan-filter-list")\r
 310                                         StringBuffer sriovFilterBuf = new StringBuffer()\r
 311                                         String values = ""\r
 312                                         for(int i = 0; i < sriovVlanFilterList.getLength(); i++){\r
 313                                                 Node node1 = sriovVlanFilterList.item(i)\r
 314                                                 if (node1.getNodeType() == Node.ELEMENT_NODE) {\r
 315                                                         Element eElement1 = (Element) node1\r
 316                                                         String value = utils.getElementText(eElement1, "sriov-vlan-filter")\r
 317                                                         if (i != sriovVlanFilterList.getLength() - 1) {\r
 318                                                                 values = sriovFilterBuf.append(value + ",")\r
 319                                                         }\r
 320                                                         else {\r
 321                                                                 values = sriovFilterBuf.append(value);\r
 322                                                         }\r
 323                                                 }\r
 324                                         }\r
 325                                         if (!values.isEmpty()) {\r
 326                                                         paramsMap.put("${vnfNetworkKey}_ATT_VF_VLAN_FILTER", "${values}")\r
 327                                                 }\r
 328                                         }\r
 329                         }\r
 330 \r
 331                         // VNF-VMS Data\r
 332                         \r
 333                         def key\r
 334                         def value\r
 335                         def networkKey\r
 336                         def networkValue\r
 337                         def floatingIPKey\r
 338                         def floatingIPKeyValue\r
 339                         def floatingIPV6Key\r
 340                         def floatingIPV6KeyValue\r
 341                         StringBuilder sb = new StringBuilder()\r
 342 \r
 343                         NodeList vmsList = responseXml.getElementsByTagNameNS("*","vnf-vms")\r
 344                         for (int x = 0; x < vmsList.getLength(); x++) {\r
 345                                 Node node = vmsList.item(x)\r
 346                                 if (node.getNodeType() == Node.ELEMENT_NODE) {\r
 347                                         Element eElement = (Element) node\r
 348                                         key = utils.getElementText(eElement, "vm-type")\r
 349                                         String values\r
 350                                         String position = "0"\r
 351                                         StringBuilder sb1 = new StringBuilder()\r
 352                                         NodeList valueList = eElement.getElementsByTagNameNS("*","vm-names")\r
 353                                         NodeList vmNetworksList = eElement.getElementsByTagNameNS("*","vm-networks")\r
 354                                         for(int i = 0; i < valueList.getLength(); i++){\r
 355                                                 Node node1 = valueList.item(i)\r
 356                                                 if (node1.getNodeType() == Node.ELEMENT_NODE) {\r
 357                                                         Element eElement1 = (Element) node1\r
 358                                                         value = utils.getElementText(eElement1, "vm-name")\r
 359                                                         if (i != valueList.getLength() - 1) {\r
 360                                                                 values = sb1.append(value + ",")\r
 361                                                         }\r
 362                                                         else {\r
 363                                                                 values = sb1.append(value);\r
 364                                                         }\r
 365                                                         position = i.toString()\r
 366                                                         paramsMap.put("${key}_name_${position}", "${value}")\r
 367                                                 }\r
 368                                         }\r
 369                                         for(int n = 0; n < vmNetworksList.getLength(); n++){\r
 370                                                 String floatingIpKeyValueStr = ""\r
 371                                                 String floatingIpV6KeyValueStr = ""\r
 372                                                 Node nodeNetworkKey = vmNetworksList.item(n)\r
 373                                                 if (nodeNetworkKey.getNodeType() == Node.ELEMENT_NODE) {\r
 374                                                         Element eElementNetworkKey = (Element) nodeNetworkKey\r
 375                                                         String ipAddressValues\r
 376                                                         String ipV6AddressValues\r
 377                                                         String networkPosition = "0"\r
 378                                                         StringBuilder sb2 = new StringBuilder()\r
 379                                                         StringBuilder sb3 = new StringBuilder()\r
 380                                                         StringBuilder sb4 = new StringBuilder()\r
 381                                                         networkKey = utils.getElementText(eElementNetworkKey, "network-role")\r
 382                                                         floatingIPKey = key + '_' + networkKey + '_floating_ip'\r
 383                                                         floatingIPKeyValue = utils.getElementText(eElementNetworkKey, "floating-ip")\r
 384                                                         if(!floatingIPKeyValue.isEmpty()){\r
 385                                                                 paramsMap.put("$floatingIPKey", "$floatingIPKeyValue")\r
 386                                                         }\r
 387                                                         floatingIPV6Key = key + '_' + networkKey + '_floating_v6_ip'\r
 388                                                         floatingIPV6KeyValue = utils.getElementText(eElementNetworkKey, "floating-ip-v6")\r
 389                                                         if(!floatingIPV6KeyValue.isEmpty()){\r
 390                                                                 paramsMap.put("$floatingIPV6Key", "$floatingIPV6KeyValue")\r
 391                                                         }\r
 392                                                         NodeList networkIpsList = eElementNetworkKey.getElementsByTagNameNS("*","network-ips")\r
 393                                                         for(int a = 0; a < networkIpsList.getLength(); a++){\r
 394                                                                 Node ipAddress = networkIpsList.item(a)\r
 395                                                                 if (ipAddress.getNodeType() == Node.ELEMENT_NODE) {\r
 396                                                                         Element eElementIpAddress = (Element) ipAddress\r
 397                                                                         String ipAddressValue = utils.getElementText(eElementIpAddress, "ip-address")\r
 398                                                                         if (a != networkIpsList.getLength() - 1) {\r
 399                                                                                 ipAddressValues = sb2.append(ipAddressValue + ",")\r
 400                                                                         }\r
 401                                                                         else {\r
 402                                                                                 ipAddressValues = sb2.append(ipAddressValue);\r
 403                                                                         }\r
 404                                                                         networkPosition = a.toString()\r
 405                                                                         paramsMap.put("${key}_${networkKey}_ip_${networkPosition}", "${ipAddressValue}")\r
 406                                                                 }\r
 407                                                         }\r
 408                                                         \r
 409                                                         paramsMap.put("${key}_${networkKey}_ips", "${ipAddressValues}")\r
 410                                                         \r
 411                                                         NodeList interfaceRoutePrefixesList = eElementNetworkKey.getElementsByTagNameNS("*","interface-route-prefixes")\r
 412                                                         String interfaceRoutePrefixValues = sb3.append("[")\r
 413                                                         \r
 414                                                         for(int a = 0; a < interfaceRoutePrefixesList.getLength(); a++){\r
 415                                                                 Node interfaceRoutePrefix = interfaceRoutePrefixesList.item(a)\r
 416                                                                 if (interfaceRoutePrefix.getNodeType() == Node.ELEMENT_NODE) {\r
 417                                                                         Element eElementInterfaceRoutePrefix = (Element) interfaceRoutePrefix\r
 418                                                                         String interfaceRoutePrefixValue = utils.getElementText(eElementInterfaceRoutePrefix, "interface-route-prefix-cidr")\r
 419                                                                         if (interfaceRoutePrefixValue == null || interfaceRoutePrefixValue.isEmpty()) {\r
 420                                                                                 interfaceRoutePrefixValue = utils.getElementText(eElementInterfaceRoutePrefix, "interface-route-prefix")\r
 421                                                                         }\r
 422                                                                         if (a != interfaceRoutePrefixesList.getLength() - 1) {\r
 423                                                                                 interfaceRoutePrefixValues = sb3.append("{\"interface_route_table_routes_route_prefix\": \"" + interfaceRoutePrefixValue + "\"}" + ",")\r
 424                                                                         }\r
 425                                                                         else {\r
 426                                                                                 interfaceRoutePrefixValues = sb3.append("{\"interface_route_table_routes_route_prefix\": \"" + interfaceRoutePrefixValue + "\"}")\r
 427                                                                         }\r
 428                                                                 }\r
 429                                                         }\r
 430                                                         interfaceRoutePrefixValues = sb3.append("]")\r
 431                                                         if (interfaceRoutePrefixesList.getLength() > 0) {\r
 432                                                                 paramsMap.put("${key}_${networkKey}_route_prefixes", "${interfaceRoutePrefixValues}")\r
 433                                                         }\r
 434                                                         \r
 435                                                         NodeList networkIpsV6List = eElementNetworkKey.getElementsByTagNameNS("*","network-ips-v6")\r
 436                                                         for(int a = 0; a < networkIpsV6List.getLength(); a++){\r
 437                                                                 Node ipV6Address = networkIpsV6List.item(a)\r
 438                                                                 if (ipV6Address.getNodeType() == Node.ELEMENT_NODE) {\r
 439                                                                         Element eElementIpV6Address = (Element) ipV6Address\r
 440                                                                         String ipV6AddressValue = utils.getElementText(eElementIpV6Address, "ip-address-ipv6")\r
 441                                                                         if (a != networkIpsV6List.getLength() - 1) {\r
 442                                                                                 ipV6AddressValues = sb4.append(ipV6AddressValue + ",")\r
 443                                                                         }\r
 444                                                                         else {\r
 445                                                                                 ipV6AddressValues = sb4.append(ipV6AddressValue);\r
 446                                                                         }\r
 447                                                                         networkPosition = a.toString()\r
 448                                                                         paramsMap.put("${key}_${networkKey}_v6_ip_${networkPosition}", "${ipV6AddressValue}")\r
 449                                                                 }\r
 450                                                         }\r
 451                                                         paramsMap.put("${key}_${networkKey}_v6_ips", "${ipV6AddressValues}")\r
 452                                                 }\r
 453                                         }\r
 454                                         paramsMap.put("${key}_names", "${values}")\r
 455                                 }\r
 456                         }\r
 457                 //SDNC Response Params\r
 458                         String sdncResponseParams = ""\r
 459                         List<String> sdncResponseParamsToSkip = ["vnf_id", "vf_module_id", "vnf_name", "vf_module_name"]\r
 460                         String vnfParamsChildNodes = utils.getChildNodes(data, "vnf-parameters")\r
 461                         if(vnfParamsChildNodes == null || vnfParamsChildNodes.length() < 1){\r
 462                                 // No SDNC params\r
 463                         }else{\r
 464                                 NodeList paramsList = responseXml.getElementsByTagNameNS("*", "vnf-parameters")\r
 465                                 for (int z = 0; z < paramsList.getLength(); z++) {\r
 466                                         Node node = paramsList.item(z)\r
 467                                         Element eElement = (Element) node\r
 468                                         String vnfParameterName = utils.getElementText(eElement, "vnf-parameter-name")\r
 469                                         if (!sdncResponseParamsToSkip.contains(vnfParameterName)) {\r
 470                                                 String vnfParameterValue = utils.getElementText(eElement, "vnf-parameter-value")\r
 471                                                 paramsMap.put("${vnfParameterName}", "${vnfParameterValue}")\r
 472                                         }\r
 473                                 }\r
 474                         }\r
 475                         \r
 476                 // Parameters received from the request should overwrite any parameters received from SDNC\r
 477                 if (vnfParamsMap != null) {\r
 478                         for (Map.Entry<String, String> entry : vnfParamsMap.entrySet()) {\r
 479                                 String vnfKey = entry.getKey()\r
 480                                 String vnfValue = entry.getValue()\r
 481                                 paramsMap.put("$vnfKey", "$vnfValue")\r
 482                         }\r
 483                 }\r
 484                 \r
 485                 StringBuilder sbParams = new StringBuilder()\r
 486                 def vfModuleParams = ""\r
 487                 for (Map.Entry<String, String> entry : paramsMap.entrySet()) {\r
 488                         String paramsXml\r
 489                         String paramName = entry.getKey()\r
 490                         String paramValue = entry.getValue()\r
 491                         paramsXml =\r
 492                                         """<entry>\r
 493                                                 <key>${paramName}</key>\r
 494                                                 <value>${paramValue}</value>\r
 495                                         </entry>\r
 496                                         """\r
 497 \r
 498                         vfModuleParams = sbParams.append(paramsXml)\r
 499                 }\r
 500                 \r
 501                 return vfModuleParams\r
 502                 \r
 503         }\r
 504         \r
 505 \r
 506         /*\r
 507          * VBNG specific method that parses VNF parameters passed in on the \r
 508          * incoming requests and SDNC parameters returned from SDNC get response\r
 509          * and puts them into the format expected by VNF adapter.\r
 510          * @param vnfParamsMap -  map of VNF parameters passed in the request body\r
 511          * @param sdncGetResponse - response string from SDNC GET topology request\r
 512          * @param vnfId\r
 513          * @param vnfName\r
 514          * @param vfModuleId\r
 515          * @param vfModuleName\r
 516          * @return a String of key/value entries for vfModuleParams\r
 517          */\r
 518         \r
 519         protected String buildVfModuleParamsVbng(String vnfParams, String sdncGetResponse, String vnfId, String vnfName,\r
 520                         String vfModuleId, String vfModuleName) {\r
 521                                 \r
 522                 //Get SDNC Response Data\r
 523                                 \r
 524                 String data = utils.getNodeXml(sdncGetResponse, "response-data")\r
 525                 data = data.replaceAll("&lt;", "<")\r
 526                 data = data.replaceAll("&gt;", ">")\r
 527         \r
 528                 \r
 529         \r
 530                 // Add-on data\r
 531                 String vnfInfo =\r
 532                         """<entry>\r
 533                                 <key>vnf_id</key>\r
 534                                 <value>${vnfId}</value>\r
 535                         </entry>\r
 536                         <entry>\r
 537                                 <key>vnf_name</key>\r
 538                                 <value>${vnfName}</value>\r
 539                         </entry>\r
 540                         <entry>\r
 541                                 <key>vf_module_id</key>\r
 542                                 <value>${vfModuleId}</value>\r
 543                         </entry>\r
 544                         <entry>\r
 545                                 <key>vf_module_name</key>\r
 546                                 <value>${vfModuleName}</value>\r
 547                         </entry>"""\r
 548         \r
 549                 utils.logAudit("vnfInfo: " + vnfInfo)\r
 550                 InputSource source = new InputSource(new StringReader(data));\r
 551                 DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();\r
 552                 docFactory.setNamespaceAware(true)\r
 553                 DocumentBuilder docBuilder = docFactory.newDocumentBuilder()\r
 554                 Document responseXml = docBuilder.parse(source)\r
 555         \r
 556         \r
 557                 // Availability Zones Data\r
 558                 String aZones = ""\r
 559                 StringBuilder sbAZone = new StringBuilder()\r
 560                 NodeList aZonesList = responseXml.getElementsByTagNameNS("*", "availability-zones")\r
 561                 String aZonePosition = "0"\r
 562                 for (int z = 0; z < aZonesList.getLength(); z++) {\r
 563                         Node node = aZonesList.item(z)\r
 564                         if (node.getNodeType() == Node.ELEMENT_NODE) {\r
 565                                 Element eElement = (Element) node\r
 566                                 String aZoneValue = utils.getElementText(eElement, "availability-zone")\r
 567                                 aZonePosition = z.toString()\r
 568                                 String aZoneXml =\r
 569                                         """<entry>\r
 570                                                 <key>availability_zone_${aZonePosition}</key>\r
 571                                                 <value>${aZoneValue}</value>\r
 572                                         </entry>"""\r
 573                                 aZones = sbAZone.append(aZoneXml)\r
 574                         }\r
 575                 }\r
 576         \r
 577                 // VNF Networks Data\r
 578                 String vnfNetworkNetId = ""\r
 579                 String vnfNetworkNetName = ""\r
 580                 String vnfNetworkSubNetId = ""\r
 581                 String vnfNetworkV6SubNetId = ""\r
 582                 String vnfNetworkNetFqdn = ""\r
 583                 String vnfNetworksSriovVlanFilters = ""\r
 584                 StringBuilder sbNet = new StringBuilder()\r
 585                 StringBuilder sbNet2 = new StringBuilder()\r
 586                 StringBuilder sbNet3 = new StringBuilder()\r
 587                 StringBuilder sbNet4 = new StringBuilder()\r
 588                 StringBuilder sbNet5 = new StringBuilder()\r
 589                 StringBuilder sbNet6 = new StringBuilder()\r
 590                 NodeList vnfNetworkList = responseXml.getElementsByTagNameNS("*", "vnf-networks")\r
 591                 for (int x = 0; x < vnfNetworkList.getLength(); x++) {\r
 592                         Node node = vnfNetworkList.item(x)\r
 593                         if (node.getNodeType() == Node.ELEMENT_NODE) {\r
 594                                 Element eElement = (Element) node\r
 595                                 String vnfNetworkKey = utils.getElementText(eElement, "network-role")\r
 596                                 String vnfNetworkNeutronIdValue = utils.getElementText(eElement, "neutron-id")\r
 597                                 String vnfNetworkNetNameValue = utils.getElementText(eElement, "network-name")\r
 598                                 String vnfNetworkSubNetIdValue = utils.getElementText(eElement, "subnet-id")\r
 599                                 String vnfNetworkV6SubNetIdValue = utils.getElementText(eElement, "ipv6-subnet-id")\r
 600                                 String vnfNetworkNetFqdnValue = utils.getElementText(eElement, "contrail-network-fqdn")\r
 601                                 String vnfNetworkNetIdXml =\r
 602                                                 """<entry>\r
 603                                                         <key>${vnfNetworkKey}_net_id</key>\r
 604                                                         <value>${vnfNetworkNeutronIdValue}</value>\r
 605                                                 </entry>"""\r
 606                                 vnfNetworkNetId = sbNet.append(vnfNetworkNetIdXml)\r
 607                                 String vnfNetworkNetNameXml =\r
 608                                                 """<entry>\r
 609                                                 <key>${vnfNetworkKey}_net_name</key>\r
 610                                                 <value>${vnfNetworkNetNameValue}</value>\r
 611                                 </entry>"""\r
 612                                 vnfNetworkNetName = sbNet2.append(vnfNetworkNetNameXml)\r
 613                                 String vnfNetworkSubNetIdXml =\r
 614                                                 """<entry>\r
 615                                                 <key>${vnfNetworkKey}_subnet_id</key>\r
 616                                                 <value>${vnfNetworkSubNetIdValue}</value>\r
 617                                 </entry>"""\r
 618                                 vnfNetworkSubNetId = sbNet3.append(vnfNetworkSubNetIdXml)\r
 619                                 String vnfNetworkV6SubNetIdXml =\r
 620                                                 """<entry>\r
 621                                                 <key>${vnfNetworkKey}_v6_subnet_id</key>\r
 622                                                 <value>${vnfNetworkV6SubNetIdValue}</value>\r
 623                                 </entry>"""\r
 624                                 vnfNetworkV6SubNetId = sbNet5.append(vnfNetworkV6SubNetIdXml)\r
 625                                 String vnfNetworkNetFqdnXml =\r
 626                                                 """<entry>\r
 627                                                 <key>${vnfNetworkKey}_net_fqdn</key>\r
 628                                                 <value>${vnfNetworkNetFqdnValue}</value>\r
 629                                 </entry>"""\r
 630                                 vnfNetworkNetFqdn = sbNet4.append(vnfNetworkNetFqdnXml)\r
 631                                                 \r
 632                                 NodeList sriovVlanFilterList = eElement.getElementsByTagNameNS("*","sriov-vlan-filter-list")\r
 633                                 StringBuffer sriovFilterBuf = new StringBuffer()\r
 634                                 String values = ""\r
 635                                 for(int i = 0; i < sriovVlanFilterList.getLength(); i++){\r
 636                                         Node node1 = sriovVlanFilterList.item(i)\r
 637                                         if (node1.getNodeType() == Node.ELEMENT_NODE) {\r
 638                                                 Element eElement1 = (Element) node1\r
 639                                                 String value = utils.getElementText(eElement1, "sriov-vlan-filter")\r
 640                                                 if (i != sriovVlanFilterList.getLength() - 1) {\r
 641                                                         values = sriovFilterBuf.append(value + ",")\r
 642                                                 }\r
 643                                                 else {\r
 644                                                         values = sriovFilterBuf.append(value);\r
 645                                                 }\r
 646                                         }\r
 647                                 }\r
 648                                 if (!values.isEmpty()) {\r
 649                                                 String vnfNetworkSriovVlanFilterXml =\r
 650                                                                 """<entry>\r
 651                                                 <key>${vnfNetworkKey}_ATT_VF_VLAN_FILTER</key>\r
 652                                                 <value>${values}</value>\r
 653                                         </entry>"""\r
 654                                                 vnfNetworksSriovVlanFilters = sbNet6.append(vnfNetworkSriovVlanFilterXml)\r
 655                                 }\r
 656                         }\r
 657                 }\r
 658         \r
 659                 // VNF-VMS Data\r
 660                 String vnfVMS = ""\r
 661                 String vnfVMSPositions = ""\r
 662                 String vmNetworks = ""\r
 663                 String vmNetworksPositions = ""\r
 664                 String vmNetworksPositionsV6 = ""\r
 665                 String interfaceRoutePrefixes = ""\r
 666                 def key\r
 667                 def value\r
 668                 def networkKey\r
 669                 def networkValue\r
 670                 def floatingIPKey\r
 671                 def floatingIPKeyValue\r
 672                 def floatingIPV6Key\r
 673                 def floatingIPV6KeyValue\r
 674                 StringBuilder sb = new StringBuilder()\r
 675                 StringBuilder sbPositions = new StringBuilder()\r
 676                 StringBuilder sbVmNetworks = new StringBuilder()\r
 677                 StringBuilder sbNetworksPositions = new StringBuilder()\r
 678                 StringBuilder sbInterfaceRoutePrefixes = new StringBuilder()\r
 679                 StringBuilder sbNetworksPositionsV6 = new StringBuilder()\r
 680 \r
 681                 NodeList vmsList = responseXml.getElementsByTagNameNS("*","vnf-vms")\r
 682                 for (int x = 0; x < vmsList.getLength(); x++) {\r
 683                         Node node = vmsList.item(x)\r
 684                         if (node.getNodeType() == Node.ELEMENT_NODE) {\r
 685                                 Element eElement = (Element) node\r
 686                                 key = utils.getElementText(eElement, "vm-type")\r
 687                                 String values\r
 688                                 String position = "0"\r
 689                                 StringBuilder sb1 = new StringBuilder()\r
 690                                 NodeList valueList = eElement.getElementsByTagNameNS("*","vm-names")\r
 691                                 NodeList vmNetworksList = eElement.getElementsByTagNameNS("*","vm-networks")\r
 692                                 for(int i = 0; i < valueList.getLength(); i++){\r
 693                                         Node node1 = valueList.item(i)\r
 694                                         if (node1.getNodeType() == Node.ELEMENT_NODE) {\r
 695                                                 Element eElement1 = (Element) node1\r
 696                                                 value = utils.getElementText(eElement1, "vm-name")\r
 697                                                 if (i != valueList.getLength() - 1) {\r
 698                                                         values = sb1.append(value + ",")\r
 699                                                 }\r
 700                                                 else {\r
 701                                                         values = sb1.append(value);\r
 702                                                 }\r
 703                                                 position = i.toString()\r
 704                                                 String vnfPositionXml =\r
 705                                                                 """<entry>\r
 706                                                                 <key>${key}_name_${position}</key>\r
 707                                                                 <value>${value}</value>\r
 708                                                         </entry>"""\r
 709                                                 vnfVMSPositions = sbPositions.append(vnfPositionXml)\r
 710                                         }\r
 711                                 }\r
 712                                 for(int n = 0; n < vmNetworksList.getLength(); n++){\r
 713                                         String floatingIpKeyValueStr = ""\r
 714                                         String floatingIpV6KeyValueStr = ""\r
 715                                         Node nodeNetworkKey = vmNetworksList.item(n)\r
 716                                         if (nodeNetworkKey.getNodeType() == Node.ELEMENT_NODE) {\r
 717                                                 Element eElementNetworkKey = (Element) nodeNetworkKey\r
 718                                                 String ipAddressValues\r
 719                                                 String ipV6AddressValues\r
 720                                                 String networkPosition = "0"\r
 721                                                 StringBuilder sb2 = new StringBuilder()\r
 722                                                 StringBuilder sb3 = new StringBuilder()\r
 723                                                 StringBuilder sb4 = new StringBuilder()\r
 724                                                 networkKey = utils.getElementText(eElementNetworkKey, "network-role")\r
 725                                                 floatingIPKey = key + '_' + networkKey + '_floating_ip'\r
 726                                                 floatingIPKeyValue = utils.getElementText(eElementNetworkKey, "floating-ip")\r
 727                                                 if(!floatingIPKeyValue.isEmpty()){\r
 728                                                         floatingIpKeyValueStr = """<entry>\r
 729                                                                 <key>$floatingIPKey</key>\r
 730                                                                 <value>$floatingIPKeyValue</value>\r
 731                                                         </entry>"""\r
 732                                                 }\r
 733                                                 floatingIPV6Key = key + '_' + networkKey + '_floating_v6_ip'\r
 734                                                 floatingIPV6KeyValue = utils.getElementText(eElementNetworkKey, "floating-ip-v6")\r
 735                                                 if(!floatingIPV6KeyValue.isEmpty()){\r
 736                                                         floatingIpV6KeyValueStr = """<entry>\r
 737                                                                 <key>$floatingIPV6Key</key>\r
 738                                                                 <value>$floatingIPV6KeyValue</value>\r
 739                                                         </entry>"""\r
 740                                                 }\r
 741                                                 NodeList networkIpsList = eElementNetworkKey.getElementsByTagNameNS("*","network-ips")\r
 742                                                 for(int a = 0; a < networkIpsList.getLength(); a++){\r
 743                                                         Node ipAddress = networkIpsList.item(a)\r
 744                                                         if (ipAddress.getNodeType() == Node.ELEMENT_NODE) {\r
 745                                                                 Element eElementIpAddress = (Element) ipAddress\r
 746                                                                 String ipAddressValue = utils.getElementText(eElementIpAddress, "ip-address")\r
 747                                                                 if (a != networkIpsList.getLength() - 1) {\r
 748                                                                         ipAddressValues = sb2.append(ipAddressValue + ",")\r
 749                                                                 }\r
 750                                                                 else {\r
 751                                                                         ipAddressValues = sb2.append(ipAddressValue);\r
 752                                                                 }\r
 753                                                                 networkPosition = a.toString()\r
 754                                                                 String vmNetworksPositionsXml =\r
 755                                                                                                 """<entry>\r
 756                                                                                 <key>${key}_${networkKey}_ip_${networkPosition}</key>\r
 757                                                                                 <value>${ipAddressValue}</value>\r
 758                                                                         </entry>"""\r
 759                                                                 vmNetworksPositions = sbNetworksPositions.append(vmNetworksPositionsXml)\r
 760                                                         }\r
 761                                                 }\r
 762                                                 vmNetworksPositions = sbNetworksPositions.append(floatingIpKeyValueStr).append(floatingIpV6KeyValueStr)\r
 763                                                         \r
 764                                                 String vmNetworksXml =\r
 765                                                                                 """<entry>\r
 766                                                                 <key>${key}_${networkKey}_ips</key>\r
 767                                                                 <value>${ipAddressValues}</value>\r
 768                                                         </entry>"""\r
 769                                                 vmNetworks = sbVmNetworks.append(vmNetworksXml)\r
 770                                                                 \r
 771                                                 NodeList interfaceRoutePrefixesList = eElementNetworkKey.getElementsByTagNameNS("*","interface-route-prefixes")\r
 772                                                 String interfaceRoutePrefixValues = sb3.append("[")\r
 773                                                                 \r
 774                                                 for(int a = 0; a < interfaceRoutePrefixesList.getLength(); a++){\r
 775                                                         Node interfaceRoutePrefix = interfaceRoutePrefixesList.item(a)\r
 776                                                         if (interfaceRoutePrefix.getNodeType() == Node.ELEMENT_NODE) {\r
 777                                                                 Element eElementInterfaceRoutePrefix = (Element) interfaceRoutePrefix\r
 778                                                                 String interfaceRoutePrefixValue = utils.getElementText(eElementInterfaceRoutePrefix, "interface-route-prefix-cidr")\r
 779                                                                 if (interfaceRoutePrefixValue == null || interfaceRoutePrefixValue.isEmpty()) {\r
 780                                                                         interfaceRoutePrefixValue = utils.getElementText(eElementInterfaceRoutePrefix, "interface-route-prefix")\r
 781                                                                 }\r
 782                                                                 if (a != interfaceRoutePrefixesList.getLength() - 1) {\r
 783                                                                         interfaceRoutePrefixValues = sb3.append("{\"interface_route_table_routes_route_prefix\": \"" + interfaceRoutePrefixValue + "\"}" + ",")\r
 784                                                                 }\r
 785                                                                 else {\r
 786                                                                         interfaceRoutePrefixValues = sb3.append("{\"interface_route_table_routes_route_prefix\": \"" + interfaceRoutePrefixValue + "\"}")\r
 787                                                                 }\r
 788                                                         }\r
 789                                                 }\r
 790                                                 interfaceRoutePrefixValues = sb3.append("]")\r
 791                                                 if (interfaceRoutePrefixesList.getLength() > 0) {\r
 792                                                         String interfaceRoutePrefixesXml =\r
 793                                                                                                         """<entry>\r
 794                                                                                         <key>${key}_${networkKey}_route_prefixes</key>\r
 795                                                                                         <value>${interfaceRoutePrefixValues}</value>\r
 796                                                                                 </entry>"""                                     \r
 797                                                         interfaceRoutePrefixes = sbInterfaceRoutePrefixes.append(interfaceRoutePrefixesXml)\r
 798                                                 }\r
 799                                                         \r
 800                                                 NodeList networkIpsV6List = eElementNetworkKey.getElementsByTagNameNS("*","network-ips-v6")\r
 801                                                 for(int a = 0; a < networkIpsV6List.getLength(); a++){\r
 802                                                         Node ipV6Address = networkIpsV6List.item(a)\r
 803                                                         if (ipV6Address.getNodeType() == Node.ELEMENT_NODE) {\r
 804                                                                 Element eElementIpV6Address = (Element) ipV6Address\r
 805                                                                 String ipV6AddressValue = utils.getElementText(eElementIpV6Address, "ip-address-ipv6")\r
 806                                                                 if (a != networkIpsV6List.getLength() - 1) {\r
 807                                                                         ipV6AddressValues = sb4.append(ipV6AddressValue + ",")\r
 808                                                                 }\r
 809                                                                 else {\r
 810                                                                         ipV6AddressValues = sb4.append(ipV6AddressValue);\r
 811                                                                 }\r
 812                                                                 networkPosition = a.toString()\r
 813                                                                 String vmNetworksPositionsV6Xml =\r
 814                                                                                 """<entry>\r
 815                                                                                 <key>${key}_${networkKey}_v6_ip_${networkPosition}</key>\r
 816                                                                                 <value>${ipV6AddressValue}</value>\r
 817                                                                                 </entry>"""\r
 818                                                                 vmNetworksPositionsV6 = sbNetworksPositionsV6.append(vmNetworksPositionsV6Xml)\r
 819                                                         }\r
 820                                                 }\r
 821                                                 String vmNetworksV6Xml =\r
 822                                                                 """<entry>\r
 823                                                                 <key>${key}_${networkKey}_v6_ips</key>\r
 824                                                                 <value>${ipV6AddressValues}</value>\r
 825                                                         </entry>"""\r
 826                                                 vmNetworks = sbVmNetworks.append(vmNetworksV6Xml)\r
 827                                         }\r
 828                                 }\r
 829                                 String vnfXml =\r
 830                                                                 """<entry>\r
 831                                 <key>${key}_names</key>\r
 832                                 <value>${values}</value>\r
 833                                         </entry>"""\r
 834                                 vnfVMS = sb.append(vnfXml)\r
 835                         }\r
 836                 }\r
 837         //SDNC Response Params\r
 838                 String sdncResponseParams = ""\r
 839                 List<String> sdncResponseParamsToSkip = ["vnf_id", "vf_module_id", "vnf_name", "vf_module_name"]\r
 840                 String vnfParamsChildNodes = utils.getChildNodes(data, "vnf-parameters")\r
 841                 if(vnfParamsChildNodes == null || vnfParamsChildNodes.length() < 1){\r
 842                         // No SDNC params\r
 843                 }else{\r
 844                         NodeList paramsList = responseXml.getElementsByTagNameNS("*", "vnf-parameters")\r
 845                         for (int z = 0; z < paramsList.getLength(); z++) {\r
 846                                 Node node = paramsList.item(z)\r
 847                                 Element eElement = (Element) node\r
 848                                 String vnfParameterName = utils.getElementText(eElement, "vnf-parameter-name")\r
 849                                 if (!sdncResponseParamsToSkip.contains(vnfParameterName)) {\r
 850                                         String vnfParameterValue = utils.getElementText(eElement, "vnf-parameter-value")\r
 851                                         String paraEntry =\r
 852                                                 """<entry>\r
 853                                                         <key>${vnfParameterName}</key>\r
 854                                                         <value>${vnfParameterValue}</value>\r
 855                                                 </entry>"""\r
 856                                         sdncResponseParams = sb.append(paraEntry)\r
 857                                 }\r
 858                         }\r
 859                 }\r
 860         \r
 861         \r
 862                 def vfModuleParams = """\r
 863                 ${vnfInfo}\r
 864                 ${aZones}\r
 865                 ${vnfNetworkNetId}\r
 866                 ${vnfNetworkNetName}\r
 867                 ${vnfNetworkSubNetId}\r
 868                 ${vnfNetworkV6SubNetId}\r
 869                 ${vnfNetworkNetFqdn}\r
 870                 ${vnfNetworksSriovVlanFilters}\r
 871         ${vnfVMS}\r
 872         ${vnfVMSPositions}\r
 873                 ${vmNetworks}\r
 874                 ${vmNetworksPositions}\r
 875                 ${vmNetworksPositionsV6}\r
 876                 ${interfaceRoutePrefixes}\r
 877                 ${vnfParams}\r
 878                 ${sdncResponseParams}"""\r
 879                         \r
 880                 return vfModuleParams\r
 881                         \r
 882         }\r
 883         \r
 884 }