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                          * Parses VNF parameters passed in on the incoming requests and SDNC parameters returned from SDNC get response\r
 508                          * for both VNF and VF Module\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 vnfSdncGetResponse - response string from SDNC GET VNF topology request\r
 512                          * @param vfmoduleSdncGetResponse - response string from SDNC GET VF Module topology request\r
 513                          * @param vnfId\r
 514                          * @param vnfName\r
 515                          * @param vfModuleId\r
 516                          * @param vfModuleName\r
 517                          * @param vfModuleIndex - can be null\r
 518                          * @return a String of key/value entries for vfModuleParams\r
 519                          */                       \r
 520                          \r
 521                          protected String buildVfModuleParamsFromCombinedTopologies(Map<String, String> vnfParamsMap, String vnfSdncGetResponse, String vfmoduleSdncGetResponse, String vnfId, String vnfName,\r
 522                                         String vfModuleId, String vfModuleName, String vfModuleIndex) {\r
 523                                         \r
 524                                         // Set up initial parameters\r
 525                                         \r
 526                                         Map<String, String> paramsMap = new HashMap<String, String>()\r
 527                                         \r
 528                                         if (vfModuleIndex != null) {\r
 529                                                 paramsMap.put("vf_module_index", "${vfModuleIndex}")\r
 530                                         }\r
 531                 \r
 532                                         // Add-on data\r
 533                                         paramsMap.put("vnf_id", "${vnfId}")\r
 534                                         paramsMap.put("vnf_name", "${vnfName}")\r
 535                                         paramsMap.put("vf_module_id", "${vfModuleId}")\r
 536                                         paramsMap.put("vf_module_name", "${vfModuleName}")                                      \r
 537                                         \r
 538                                         //Get SDNC Response Data for VNF\r
 539                                         \r
 540                                         String vnfData = utils.getNodeXml(vnfSdncGetResponse, "response-data")\r
 541                                         vnfData = vnfData.replaceAll("&lt;", "<")\r
 542                                         vnfData = vnfData.replaceAll("&gt;", ">")\r
 543                 \r
 544                                         String vnfTopology = utils.getNodeXml(vnfData, "vnf-topology")\r
 545                                         vnfTopology = utils.removeXmlPreamble(vnfTopology)\r
 546                                         vnfTopology = utils.removeXmlNamespaces(vnfTopology)\r
 547                                                                                 \r
 548                                         InputSource sourceVnf = new InputSource(new StringReader(vnfData));\r
 549                                         DocumentBuilderFactory docFactoryVnf = DocumentBuilderFactory.newInstance();\r
 550                                         docFactoryVnf.setNamespaceAware(true)\r
 551                                         DocumentBuilder docBuilderVnf = docFactoryVnf.newDocumentBuilder()\r
 552                                         Document responseXmlVnf = docBuilderVnf.parse(sourceVnf)\r
 553                                 \r
 554                                         // Availability Zones Data\r
 555                                         \r
 556                                         NodeList aZonesList = responseXmlVnf.getElementsByTagNameNS("*", "availability-zones")\r
 557                                         String aZonePosition = "0"\r
 558                                         for (int z = 0; z < aZonesList.getLength(); z++) {\r
 559                                                 Node node = aZonesList.item(z)\r
 560                                                 if (node.getNodeType() == Node.ELEMENT_NODE) {\r
 561                                                         Element eElement = (Element) node\r
 562                                                         String aZoneValue = utils.getElementText(eElement, "availability-zone")\r
 563                                                         aZonePosition = z.toString()\r
 564                                                         paramsMap.put("availability_zone_${aZonePosition}", "${aZoneValue}")\r
 565                                                 }\r
 566                                         }\r
 567                 \r
 568                                         // VNF Networks Data\r
 569                                         \r
 570                                         StringBuilder sbNet = new StringBuilder()\r
 571                                         \r
 572                                         NodeList vnfNetworkList = responseXmlVnf.getElementsByTagNameNS("*", "vnf-networks")\r
 573                                         for (int x = 0; x < vnfNetworkList.getLength(); x++) {\r
 574                                                 Node node = vnfNetworkList.item(x)\r
 575                                                 if (node.getNodeType() == Node.ELEMENT_NODE) {\r
 576                                                         Element eElement = (Element) node\r
 577                                                         String vnfNetworkKey = utils.getElementText(eElement, "network-role")\r
 578                                                         String vnfNetworkNeutronIdValue = utils.getElementText(eElement, "neutron-id")\r
 579                                                         String vnfNetworkNetNameValue = utils.getElementText(eElement, "network-name")\r
 580                                                         String vnfNetworkSubNetIdValue = utils.getElementText(eElement, "subnet-id")\r
 581                                                         String vnfNetworkV6SubNetIdValue = utils.getElementText(eElement, "ipv6-subnet-id")\r
 582                                                         String vnfNetworkNetFqdnValue = utils.getElementText(eElement, "contrail-network-fqdn")\r
 583                                                         paramsMap.put("${vnfNetworkKey}_net_id", "${vnfNetworkNeutronIdValue}")\r
 584                                                         paramsMap.put("${vnfNetworkKey}_net_name", "${vnfNetworkNetNameValue}")\r
 585                                                         paramsMap.put("${vnfNetworkKey}_subnet_id", "${vnfNetworkSubNetIdValue}")\r
 586                                                         paramsMap.put("${vnfNetworkKey}_v6_subnet_id", "${vnfNetworkV6SubNetIdValue}")\r
 587                                                         paramsMap.put("${vnfNetworkKey}_net_fqdn", "${vnfNetworkNetFqdnValue}")\r
 588                                                         \r
 589                                                         NodeList sriovVlanFilterList = eElement.getElementsByTagNameNS("*","sriov-vlan-filter-list")\r
 590                                                         StringBuffer sriovFilterBuf = new StringBuffer()\r
 591                                                         String values = ""\r
 592                                                         for(int i = 0; i < sriovVlanFilterList.getLength(); i++){\r
 593                                                                 Node node1 = sriovVlanFilterList.item(i)\r
 594                                                                 if (node1.getNodeType() == Node.ELEMENT_NODE) {\r
 595                                                                         Element eElement1 = (Element) node1\r
 596                                                                         String value = utils.getElementText(eElement1, "sriov-vlan-filter")\r
 597                                                                         if (i != sriovVlanFilterList.getLength() - 1) {\r
 598                                                                                 values = sriovFilterBuf.append(value + ",")\r
 599                                                                         }\r
 600                                                                         else {\r
 601                                                                                 values = sriovFilterBuf.append(value);\r
 602                                                                         }\r
 603                                                                 }\r
 604                                                         }\r
 605                                                         if (!values.isEmpty()) {\r
 606                                                                         paramsMap.put("${vnfNetworkKey}_ATT_VF_VLAN_FILTER", "${values}")\r
 607                                                                 }\r
 608                                                         }\r
 609                                         }\r
 610                                         \r
 611                                         //Get SDNC Response Data for VF Module\r
 612                                         \r
 613                                         String vfModuleData = utils.getNodeXml(vfmoduleSdncGetResponse, "response-data")\r
 614                                         vfModuleData = vfModuleData.replaceAll("&lt;", "<")\r
 615                                         vfModuleData = vfModuleData.replaceAll("&gt;", ">")\r
 616                 \r
 617                                         String vfModuleTopology = utils.getNodeXml(vfModuleData, "vf-module-topology")\r
 618                                         vfModuleTopology = utils.removeXmlPreamble(vfModuleTopology)\r
 619                                         vfModuleTopology = utils.removeXmlNamespaces(vfModuleTopology)\r
 620                                         String vfModuleTopologyIdentifier = utils.getNodeXml(vfModuleTopology, "vf-module-topology-identifier")\r
 621                                         \r
 622                                         InputSource sourceVfModule = new InputSource(new StringReader(vfModuleData));\r
 623                                         DocumentBuilderFactory docFactoryVfModule = DocumentBuilderFactory.newInstance();\r
 624                                         docFactoryVfModule.setNamespaceAware(true)\r
 625                                         DocumentBuilder docBuilderVfModule = docFactoryVfModule.newDocumentBuilder()\r
 626                                         Document responseXmlVfModule = docBuilderVfModule.parse(sourceVfModule)\r
 627                                 \r
 628                                         // VMS Data\r
 629                                         \r
 630                                         def key\r
 631                                         def value\r
 632                                         def networkKey\r
 633                                         def networkValue\r
 634                                         def floatingIPKey\r
 635                                         def floatingIPKeyValue\r
 636                                         def floatingIPV6Key\r
 637                                         def floatingIPV6KeyValue\r
 638                                         StringBuilder sb = new StringBuilder()\r
 639                 \r
 640                                         NodeList vmsList = responseXmlVfModule.getElementsByTagNameNS("*","vm")\r
 641                                         for (int x = 0; x < vmsList.getLength(); x++) {\r
 642                                                 Node node = vmsList.item(x)\r
 643                                                 if (node.getNodeType() == Node.ELEMENT_NODE) {\r
 644                                                         Element eElement = (Element) node\r
 645                                                         key = utils.getElementText(eElement, "vm-type")\r
 646                                                         String values\r
 647                                                         String position = "0"\r
 648                                                         StringBuilder sb1 = new StringBuilder()\r
 649                                                         NodeList valueList = eElement.getElementsByTagNameNS("*","vm-names")\r
 650                                                         NodeList vmNetworksList = eElement.getElementsByTagNameNS("*","vm-networks")\r
 651                                                         for(int i = 0; i < valueList.getLength(); i++){\r
 652                                                                 Node node1 = valueList.item(i)\r
 653                                                                 if (node1.getNodeType() == Node.ELEMENT_NODE) {\r
 654                                                                         Element eElement1 = (Element) node1\r
 655                                                                         value = utils.getElementText(eElement1, "vm-name")\r
 656                                                                         if (i != valueList.getLength() - 1) {\r
 657                                                                                 values = sb1.append(value + ",")\r
 658                                                                         }\r
 659                                                                         else {\r
 660                                                                                 values = sb1.append(value);\r
 661                                                                         }\r
 662                                                                         position = i.toString()\r
 663                                                                         paramsMap.put("${key}_name_${position}", "${value}")\r
 664                                                                 }\r
 665                                                         }\r
 666                                                         for(int n = 0; n < vmNetworksList.getLength(); n++){\r
 667                                                                 String floatingIpKeyValueStr = ""\r
 668                                                                 String floatingIpV6KeyValueStr = ""\r
 669                                                                 Node nodeNetworkKey = vmNetworksList.item(n)\r
 670                                                                 if (nodeNetworkKey.getNodeType() == Node.ELEMENT_NODE) {\r
 671                                                                         Element eElementNetworkKey = (Element) nodeNetworkKey\r
 672                                                                         String ipAddressValues\r
 673                                                                         String ipV6AddressValues\r
 674                                                                         String networkPosition = "0"\r
 675                                                                         StringBuilder sb2 = new StringBuilder()\r
 676                                                                         StringBuilder sb3 = new StringBuilder()\r
 677                                                                         StringBuilder sb4 = new StringBuilder()\r
 678                                                                         networkKey = utils.getElementText(eElementNetworkKey, "network-role")\r
 679                                                                         floatingIPKey = key + '_' + networkKey + '_floating_ip'\r
 680                                                                         floatingIPKeyValue = utils.getElementText(eElementNetworkKey, "floating-ip")\r
 681                                                                         if(!floatingIPKeyValue.isEmpty()){\r
 682                                                                                 paramsMap.put("$floatingIPKey", "$floatingIPKeyValue")\r
 683                                                                         }\r
 684                                                                         floatingIPV6Key = key + '_' + networkKey + '_floating_v6_ip'\r
 685                                                                         floatingIPV6KeyValue = utils.getElementText(eElementNetworkKey, "floating-ip-v6")\r
 686                                                                         if(!floatingIPV6KeyValue.isEmpty()){\r
 687                                                                                 paramsMap.put("$floatingIPV6Key", "$floatingIPV6KeyValue")\r
 688                                                                         }\r
 689                                                                         NodeList networkIpsList = eElementNetworkKey.getElementsByTagNameNS("*","network-ips")\r
 690                                                                         for(int a = 0; a < networkIpsList.getLength(); a++){\r
 691                                                                                 Node ipAddress = networkIpsList.item(a)\r
 692                                                                                 if (ipAddress.getNodeType() == Node.ELEMENT_NODE) {\r
 693                                                                                         Element eElementIpAddress = (Element) ipAddress\r
 694                                                                                         String ipAddressValue = utils.getElementText(eElementIpAddress, "ip-address")\r
 695                                                                                         if (a != networkIpsList.getLength() - 1) {\r
 696                                                                                                 ipAddressValues = sb2.append(ipAddressValue + ",")\r
 697                                                                                         }\r
 698                                                                                         else {\r
 699                                                                                                 ipAddressValues = sb2.append(ipAddressValue);\r
 700                                                                                         }\r
 701                                                                                         networkPosition = a.toString()\r
 702                                                                                         paramsMap.put("${key}_${networkKey}_ip_${networkPosition}", "${ipAddressValue}")\r
 703                                                                                 }\r
 704                                                                         }\r
 705                                                                         \r
 706                                                                         paramsMap.put("${key}_${networkKey}_ips", "${ipAddressValues}")\r
 707                                                                         \r
 708                                                                         NodeList interfaceRoutePrefixesList = eElementNetworkKey.getElementsByTagNameNS("*","interface-route-prefixes")\r
 709                                                                         String interfaceRoutePrefixValues = sb3.append("[")\r
 710                                                                         \r
 711                                                                         for(int a = 0; a < interfaceRoutePrefixesList.getLength(); a++){\r
 712                                                                                 Node interfaceRoutePrefix = interfaceRoutePrefixesList.item(a)\r
 713                                                                                 if (interfaceRoutePrefix.getNodeType() == Node.ELEMENT_NODE) {\r
 714                                                                                         Element eElementInterfaceRoutePrefix = (Element) interfaceRoutePrefix\r
 715                                                                                         String interfaceRoutePrefixValue = utils.getElementText(eElementInterfaceRoutePrefix, "interface-route-prefix-cidr")\r
 716                                                                                         if (interfaceRoutePrefixValue == null || interfaceRoutePrefixValue.isEmpty()) {\r
 717                                                                                                 interfaceRoutePrefixValue = utils.getElementText(eElementInterfaceRoutePrefix, "interface-route-prefix")\r
 718                                                                                         }\r
 719                                                                                         if (a != interfaceRoutePrefixesList.getLength() - 1) {\r
 720                                                                                                 interfaceRoutePrefixValues = sb3.append("{\"interface_route_table_routes_route_prefix\": \"" + interfaceRoutePrefixValue + "\"}" + ",")\r
 721                                                                                         }\r
 722                                                                                         else {\r
 723                                                                                                 interfaceRoutePrefixValues = sb3.append("{\"interface_route_table_routes_route_prefix\": \"" + interfaceRoutePrefixValue + "\"}")\r
 724                                                                                         }\r
 725                                                                                 }\r
 726                                                                         }\r
 727                                                                         interfaceRoutePrefixValues = sb3.append("]")\r
 728                                                                         if (interfaceRoutePrefixesList.getLength() > 0) {\r
 729                                                                                 paramsMap.put("${key}_${networkKey}_route_prefixes", "${interfaceRoutePrefixValues}")\r
 730                                                                         }\r
 731                                                                         \r
 732                                                                         NodeList networkIpsV6List = eElementNetworkKey.getElementsByTagNameNS("*","network-ips-v6")\r
 733                                                                         for(int a = 0; a < networkIpsV6List.getLength(); a++){\r
 734                                                                                 Node ipV6Address = networkIpsV6List.item(a)\r
 735                                                                                 if (ipV6Address.getNodeType() == Node.ELEMENT_NODE) {\r
 736                                                                                         Element eElementIpV6Address = (Element) ipV6Address\r
 737                                                                                         String ipV6AddressValue = utils.getElementText(eElementIpV6Address, "ip-address-ipv6")\r
 738                                                                                         if (a != networkIpsV6List.getLength() - 1) {\r
 739                                                                                                 ipV6AddressValues = sb4.append(ipV6AddressValue + ",")\r
 740                                                                                         }\r
 741                                                                                         else {\r
 742                                                                                                 ipV6AddressValues = sb4.append(ipV6AddressValue);\r
 743                                                                                         }\r
 744                                                                                         networkPosition = a.toString()\r
 745                                                                                         paramsMap.put("${key}_${networkKey}_v6_ip_${networkPosition}", "${ipV6AddressValue}")\r
 746                                                                                 }\r
 747                                                                         }\r
 748                                                                         paramsMap.put("${key}_${networkKey}_v6_ips", "${ipV6AddressValues}")\r
 749                                                                 }\r
 750                                                         }\r
 751                                                         paramsMap.put("${key}_names", "${values}")\r
 752                                                 }\r
 753                                         }\r
 754                                 //SDNC Response Params\r
 755                                         List<String> sdncResponseParamsToSkip = ["vnf_id", "vf_module_id", "vnf_name", "vf_module_name"]\r
 756                                         \r
 757                                         String vnfParamsChildNodes = utils.getChildNodes(vnfData, "param")\r
 758                                         if(vnfParamsChildNodes == null || vnfParamsChildNodes.length() < 1){\r
 759                                                 // No SDNC params for VNF\r
 760                                         }else{\r
 761                                                 NodeList paramsList = responseXmlVnf.getElementsByTagNameNS("*", "param")\r
 762                                                 for (int z = 0; z < paramsList.getLength(); z++) {\r
 763                                                         Node node = paramsList.item(z)\r
 764                                                         Element eElement = (Element) node\r
 765                                                         String vnfParameterName = utils.getElementText(eElement, "name")\r
 766                                                         if (!sdncResponseParamsToSkip.contains(vnfParameterName)) {\r
 767                                                                 String vnfParameterValue = utils.getElementText(eElement, "value")\r
 768                                                                 paramsMap.put("${vnfParameterName}", "${vnfParameterValue}")\r
 769                                                         }\r
 770                                                 }\r
 771                                         }\r
 772                                         \r
 773                                         String vfModuleParamsChildNodes = utils.getChildNodes(vfModuleData, "param")\r
 774                                         if(vfModuleParamsChildNodes == null || vfModuleParamsChildNodes.length() < 1){\r
 775                                                 // No SDNC params for VF Module\r
 776                                         }else{\r
 777                                                 NodeList paramsList = responseXmlVfModule.getElementsByTagNameNS("*", "param")\r
 778                                                 for (int z = 0; z < paramsList.getLength(); z++) {\r
 779                                                         Node node = paramsList.item(z)\r
 780                                                         Element eElement = (Element) node\r
 781                                                         String vnfParameterName = utils.getElementText(eElement, "name")\r
 782                                                         if (!sdncResponseParamsToSkip.contains(vnfParameterName)) {\r
 783                                                                 String vnfParameterValue = utils.getElementText(eElement, "value")\r
 784                                                                 paramsMap.put("${vnfParameterName}", "${vnfParameterValue}")\r
 785                                                         }\r
 786                                                 }\r
 787                                         }\r
 788                                         \r
 789                                 // Parameters received from the request should overwrite any parameters received from SDNC\r
 790                                 if (vnfParamsMap != null) {\r
 791                                         for (Map.Entry<String, String> entry : vnfParamsMap.entrySet()) {\r
 792                                                 String vnfKey = entry.getKey()\r
 793                                                 String vnfValue = entry.getValue()\r
 794                                                 paramsMap.put("$vnfKey", "$vnfValue")\r
 795                                         }\r
 796                                 }\r
 797                                 \r
 798                                 StringBuilder sbParams = new StringBuilder()\r
 799                                 def vfModuleParams = ""\r
 800                                 for (Map.Entry<String, String> entry : paramsMap.entrySet()) {\r
 801                                         String paramsXml\r
 802                                         String paramName = entry.getKey()\r
 803                                         String paramValue = entry.getValue()\r
 804                                         paramsXml =\r
 805                                                         """<entry>\r
 806                                                 <key>${paramName}</key>\r
 807                                                 <value>${paramValue}</value>\r
 808                                         </entry>\r
 809                                         """\r
 810                 \r
 811                                         vfModuleParams = sbParams.append(paramsXml)\r
 812                                 }\r
 813                                 \r
 814                                 return vfModuleParams\r
 815                                 \r
 816                         }\r
 817         \r
 818 \r
 819         /*\r
 820          * VBNG specific method that parses VNF parameters passed in on the \r
 821          * incoming requests and SDNC parameters returned from SDNC get response\r
 822          * and puts them into the format expected by VNF adapter.\r
 823          * @param vnfParamsMap -  map of VNF parameters passed in the request body\r
 824          * @param sdncGetResponse - response string from SDNC GET topology request\r
 825          * @param vnfId\r
 826          * @param vnfName\r
 827          * @param vfModuleId\r
 828          * @param vfModuleName\r
 829          * @return a String of key/value entries for vfModuleParams\r
 830          */\r
 831         \r
 832         protected String buildVfModuleParamsVbng(String vnfParams, String sdncGetResponse, String vnfId, String vnfName,\r
 833                         String vfModuleId, String vfModuleName) {\r
 834                                 \r
 835                 //Get SDNC Response Data\r
 836                                 \r
 837                 String data = utils.getNodeXml(sdncGetResponse, "response-data")\r
 838                 data = data.replaceAll("&lt;", "<")\r
 839                 data = data.replaceAll("&gt;", ">")\r
 840         \r
 841                 \r
 842         \r
 843                 // Add-on data\r
 844                 String vnfInfo =\r
 845                         """<entry>\r
 846                                 <key>vnf_id</key>\r
 847                                 <value>${vnfId}</value>\r
 848                         </entry>\r
 849                         <entry>\r
 850                                 <key>vnf_name</key>\r
 851                                 <value>${vnfName}</value>\r
 852                         </entry>\r
 853                         <entry>\r
 854                                 <key>vf_module_id</key>\r
 855                                 <value>${vfModuleId}</value>\r
 856                         </entry>\r
 857                         <entry>\r
 858                                 <key>vf_module_name</key>\r
 859                                 <value>${vfModuleName}</value>\r
 860                         </entry>"""\r
 861         \r
 862                 utils.logAudit("vnfInfo: " + vnfInfo)\r
 863                 InputSource source = new InputSource(new StringReader(data));\r
 864                 DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();\r
 865                 docFactory.setNamespaceAware(true)\r
 866                 DocumentBuilder docBuilder = docFactory.newDocumentBuilder()\r
 867                 Document responseXml = docBuilder.parse(source)\r
 868         \r
 869         \r
 870                 // Availability Zones Data\r
 871                 String aZones = ""\r
 872                 StringBuilder sbAZone = new StringBuilder()\r
 873                 NodeList aZonesList = responseXml.getElementsByTagNameNS("*", "availability-zones")\r
 874                 String aZonePosition = "0"\r
 875                 for (int z = 0; z < aZonesList.getLength(); z++) {\r
 876                         Node node = aZonesList.item(z)\r
 877                         if (node.getNodeType() == Node.ELEMENT_NODE) {\r
 878                                 Element eElement = (Element) node\r
 879                                 String aZoneValue = utils.getElementText(eElement, "availability-zone")\r
 880                                 aZonePosition = z.toString()\r
 881                                 String aZoneXml =\r
 882                                         """<entry>\r
 883                                                 <key>availability_zone_${aZonePosition}</key>\r
 884                                                 <value>${aZoneValue}</value>\r
 885                                         </entry>"""\r
 886                                 aZones = sbAZone.append(aZoneXml)\r
 887                         }\r
 888                 }\r
 889         \r
 890                 // VNF Networks Data\r
 891                 String vnfNetworkNetId = ""\r
 892                 String vnfNetworkNetName = ""\r
 893                 String vnfNetworkSubNetId = ""\r
 894                 String vnfNetworkV6SubNetId = ""\r
 895                 String vnfNetworkNetFqdn = ""\r
 896                 String vnfNetworksSriovVlanFilters = ""\r
 897                 StringBuilder sbNet = new StringBuilder()\r
 898                 StringBuilder sbNet2 = new StringBuilder()\r
 899                 StringBuilder sbNet3 = new StringBuilder()\r
 900                 StringBuilder sbNet4 = new StringBuilder()\r
 901                 StringBuilder sbNet5 = new StringBuilder()\r
 902                 StringBuilder sbNet6 = new StringBuilder()\r
 903                 NodeList vnfNetworkList = responseXml.getElementsByTagNameNS("*", "vnf-networks")\r
 904                 for (int x = 0; x < vnfNetworkList.getLength(); x++) {\r
 905                         Node node = vnfNetworkList.item(x)\r
 906                         if (node.getNodeType() == Node.ELEMENT_NODE) {\r
 907                                 Element eElement = (Element) node\r
 908                                 String vnfNetworkKey = utils.getElementText(eElement, "network-role")\r
 909                                 String vnfNetworkNeutronIdValue = utils.getElementText(eElement, "neutron-id")\r
 910                                 String vnfNetworkNetNameValue = utils.getElementText(eElement, "network-name")\r
 911                                 String vnfNetworkSubNetIdValue = utils.getElementText(eElement, "subnet-id")\r
 912                                 String vnfNetworkV6SubNetIdValue = utils.getElementText(eElement, "ipv6-subnet-id")\r
 913                                 String vnfNetworkNetFqdnValue = utils.getElementText(eElement, "contrail-network-fqdn")\r
 914                                 String vnfNetworkNetIdXml =\r
 915                                                 """<entry>\r
 916                                                         <key>${vnfNetworkKey}_net_id</key>\r
 917                                                         <value>${vnfNetworkNeutronIdValue}</value>\r
 918                                                 </entry>"""\r
 919                                 vnfNetworkNetId = sbNet.append(vnfNetworkNetIdXml)\r
 920                                 String vnfNetworkNetNameXml =\r
 921                                                 """<entry>\r
 922                                                 <key>${vnfNetworkKey}_net_name</key>\r
 923                                                 <value>${vnfNetworkNetNameValue}</value>\r
 924                                 </entry>"""\r
 925                                 vnfNetworkNetName = sbNet2.append(vnfNetworkNetNameXml)\r
 926                                 String vnfNetworkSubNetIdXml =\r
 927                                                 """<entry>\r
 928                                                 <key>${vnfNetworkKey}_subnet_id</key>\r
 929                                                 <value>${vnfNetworkSubNetIdValue}</value>\r
 930                                 </entry>"""\r
 931                                 vnfNetworkSubNetId = sbNet3.append(vnfNetworkSubNetIdXml)\r
 932                                 String vnfNetworkV6SubNetIdXml =\r
 933                                                 """<entry>\r
 934                                                 <key>${vnfNetworkKey}_v6_subnet_id</key>\r
 935                                                 <value>${vnfNetworkV6SubNetIdValue}</value>\r
 936                                 </entry>"""\r
 937                                 vnfNetworkV6SubNetId = sbNet5.append(vnfNetworkV6SubNetIdXml)\r
 938                                 String vnfNetworkNetFqdnXml =\r
 939                                                 """<entry>\r
 940                                                 <key>${vnfNetworkKey}_net_fqdn</key>\r
 941                                                 <value>${vnfNetworkNetFqdnValue}</value>\r
 942                                 </entry>"""\r
 943                                 vnfNetworkNetFqdn = sbNet4.append(vnfNetworkNetFqdnXml)\r
 944                                                 \r
 945                                 NodeList sriovVlanFilterList = eElement.getElementsByTagNameNS("*","sriov-vlan-filter-list")\r
 946                                 StringBuffer sriovFilterBuf = new StringBuffer()\r
 947                                 String values = ""\r
 948                                 for(int i = 0; i < sriovVlanFilterList.getLength(); i++){\r
 949                                         Node node1 = sriovVlanFilterList.item(i)\r
 950                                         if (node1.getNodeType() == Node.ELEMENT_NODE) {\r
 951                                                 Element eElement1 = (Element) node1\r
 952                                                 String value = utils.getElementText(eElement1, "sriov-vlan-filter")\r
 953                                                 if (i != sriovVlanFilterList.getLength() - 1) {\r
 954                                                         values = sriovFilterBuf.append(value + ",")\r
 955                                                 }\r
 956                                                 else {\r
 957                                                         values = sriovFilterBuf.append(value);\r
 958                                                 }\r
 959                                         }\r
 960                                 }\r
 961                                 if (!values.isEmpty()) {\r
 962                                                 String vnfNetworkSriovVlanFilterXml =\r
 963                                                                 """<entry>\r
 964                                                 <key>${vnfNetworkKey}_ATT_VF_VLAN_FILTER</key>\r
 965                                                 <value>${values}</value>\r
 966                                         </entry>"""\r
 967                                                 vnfNetworksSriovVlanFilters = sbNet6.append(vnfNetworkSriovVlanFilterXml)\r
 968                                 }\r
 969                         }\r
 970                 }\r
 971         \r
 972                 // VNF-VMS Data\r
 973                 String vnfVMS = ""\r
 974                 String vnfVMSPositions = ""\r
 975                 String vmNetworks = ""\r
 976                 String vmNetworksPositions = ""\r
 977                 String vmNetworksPositionsV6 = ""\r
 978                 String interfaceRoutePrefixes = ""\r
 979                 def key\r
 980                 def value\r
 981                 def networkKey\r
 982                 def networkValue\r
 983                 def floatingIPKey\r
 984                 def floatingIPKeyValue\r
 985                 def floatingIPV6Key\r
 986                 def floatingIPV6KeyValue\r
 987                 StringBuilder sb = new StringBuilder()\r
 988                 StringBuilder sbPositions = new StringBuilder()\r
 989                 StringBuilder sbVmNetworks = new StringBuilder()\r
 990                 StringBuilder sbNetworksPositions = new StringBuilder()\r
 991                 StringBuilder sbInterfaceRoutePrefixes = new StringBuilder()\r
 992                 StringBuilder sbNetworksPositionsV6 = new StringBuilder()\r
 993 \r
 994                 NodeList vmsList = responseXml.getElementsByTagNameNS("*","vnf-vms")\r
 995                 for (int x = 0; x < vmsList.getLength(); x++) {\r
 996                         Node node = vmsList.item(x)\r
 997                         if (node.getNodeType() == Node.ELEMENT_NODE) {\r
 998                                 Element eElement = (Element) node\r
 999                                 key = utils.getElementText(eElement, "vm-type")\r
1000                                 String values\r
1001                                 String position = "0"\r
1002                                 StringBuilder sb1 = new StringBuilder()\r
1003                                 NodeList valueList = eElement.getElementsByTagNameNS("*","vm-names")\r
1004                                 NodeList vmNetworksList = eElement.getElementsByTagNameNS("*","vm-networks")\r
1005                                 for(int i = 0; i < valueList.getLength(); i++){\r
1006                                         Node node1 = valueList.item(i)\r
1007                                         if (node1.getNodeType() == Node.ELEMENT_NODE) {\r
1008                                                 Element eElement1 = (Element) node1\r
1009                                                 value = utils.getElementText(eElement1, "vm-name")\r
1010                                                 if (i != valueList.getLength() - 1) {\r
1011                                                         values = sb1.append(value + ",")\r
1012                                                 }\r
1013                                                 else {\r
1014                                                         values = sb1.append(value);\r
1015                                                 }\r
1016                                                 position = i.toString()\r
1017                                                 String vnfPositionXml =\r
1018                                                                 """<entry>\r
1019                                                                 <key>${key}_name_${position}</key>\r
1020                                                                 <value>${value}</value>\r
1021                                                         </entry>"""\r
1022                                                 vnfVMSPositions = sbPositions.append(vnfPositionXml)\r
1023                                         }\r
1024                                 }\r
1025                                 for(int n = 0; n < vmNetworksList.getLength(); n++){\r
1026                                         String floatingIpKeyValueStr = ""\r
1027                                         String floatingIpV6KeyValueStr = ""\r
1028                                         Node nodeNetworkKey = vmNetworksList.item(n)\r
1029                                         if (nodeNetworkKey.getNodeType() == Node.ELEMENT_NODE) {\r
1030                                                 Element eElementNetworkKey = (Element) nodeNetworkKey\r
1031                                                 String ipAddressValues\r
1032                                                 String ipV6AddressValues\r
1033                                                 String networkPosition = "0"\r
1034                                                 StringBuilder sb2 = new StringBuilder()\r
1035                                                 StringBuilder sb3 = new StringBuilder()\r
1036                                                 StringBuilder sb4 = new StringBuilder()\r
1037                                                 networkKey = utils.getElementText(eElementNetworkKey, "network-role")\r
1038                                                 floatingIPKey = key + '_' + networkKey + '_floating_ip'\r
1039                                                 floatingIPKeyValue = utils.getElementText(eElementNetworkKey, "floating-ip")\r
1040                                                 if(!floatingIPKeyValue.isEmpty()){\r
1041                                                         floatingIpKeyValueStr = """<entry>\r
1042                                                                 <key>$floatingIPKey</key>\r
1043                                                                 <value>$floatingIPKeyValue</value>\r
1044                                                         </entry>"""\r
1045                                                 }\r
1046                                                 floatingIPV6Key = key + '_' + networkKey + '_floating_v6_ip'\r
1047                                                 floatingIPV6KeyValue = utils.getElementText(eElementNetworkKey, "floating-ip-v6")\r
1048                                                 if(!floatingIPV6KeyValue.isEmpty()){\r
1049                                                         floatingIpV6KeyValueStr = """<entry>\r
1050                                                                 <key>$floatingIPV6Key</key>\r
1051                                                                 <value>$floatingIPV6KeyValue</value>\r
1052                                                         </entry>"""\r
1053                                                 }\r
1054                                                 NodeList networkIpsList = eElementNetworkKey.getElementsByTagNameNS("*","network-ips")\r
1055                                                 for(int a = 0; a < networkIpsList.getLength(); a++){\r
1056                                                         Node ipAddress = networkIpsList.item(a)\r
1057                                                         if (ipAddress.getNodeType() == Node.ELEMENT_NODE) {\r
1058                                                                 Element eElementIpAddress = (Element) ipAddress\r
1059                                                                 String ipAddressValue = utils.getElementText(eElementIpAddress, "ip-address")\r
1060                                                                 if (a != networkIpsList.getLength() - 1) {\r
1061                                                                         ipAddressValues = sb2.append(ipAddressValue + ",")\r
1062                                                                 }\r
1063                                                                 else {\r
1064                                                                         ipAddressValues = sb2.append(ipAddressValue);\r
1065                                                                 }\r
1066                                                                 networkPosition = a.toString()\r
1067                                                                 String vmNetworksPositionsXml =\r
1068                                                                                                 """<entry>\r
1069                                                                                 <key>${key}_${networkKey}_ip_${networkPosition}</key>\r
1070                                                                                 <value>${ipAddressValue}</value>\r
1071                                                                         </entry>"""\r
1072                                                                 vmNetworksPositions = sbNetworksPositions.append(vmNetworksPositionsXml)\r
1073                                                         }\r
1074                                                 }\r
1075                                                 vmNetworksPositions = sbNetworksPositions.append(floatingIpKeyValueStr).append(floatingIpV6KeyValueStr)\r
1076                                                         \r
1077                                                 String vmNetworksXml =\r
1078                                                                                 """<entry>\r
1079                                                                 <key>${key}_${networkKey}_ips</key>\r
1080                                                                 <value>${ipAddressValues}</value>\r
1081                                                         </entry>"""\r
1082                                                 vmNetworks = sbVmNetworks.append(vmNetworksXml)\r
1083                                                                 \r
1084                                                 NodeList interfaceRoutePrefixesList = eElementNetworkKey.getElementsByTagNameNS("*","interface-route-prefixes")\r
1085                                                 String interfaceRoutePrefixValues = sb3.append("[")\r
1086                                                                 \r
1087                                                 for(int a = 0; a < interfaceRoutePrefixesList.getLength(); a++){\r
1088                                                         Node interfaceRoutePrefix = interfaceRoutePrefixesList.item(a)\r
1089                                                         if (interfaceRoutePrefix.getNodeType() == Node.ELEMENT_NODE) {\r
1090                                                                 Element eElementInterfaceRoutePrefix = (Element) interfaceRoutePrefix\r
1091                                                                 String interfaceRoutePrefixValue = utils.getElementText(eElementInterfaceRoutePrefix, "interface-route-prefix-cidr")\r
1092                                                                 if (interfaceRoutePrefixValue == null || interfaceRoutePrefixValue.isEmpty()) {\r
1093                                                                         interfaceRoutePrefixValue = utils.getElementText(eElementInterfaceRoutePrefix, "interface-route-prefix")\r
1094                                                                 }\r
1095                                                                 if (a != interfaceRoutePrefixesList.getLength() - 1) {\r
1096                                                                         interfaceRoutePrefixValues = sb3.append("{\"interface_route_table_routes_route_prefix\": \"" + interfaceRoutePrefixValue + "\"}" + ",")\r
1097                                                                 }\r
1098                                                                 else {\r
1099                                                                         interfaceRoutePrefixValues = sb3.append("{\"interface_route_table_routes_route_prefix\": \"" + interfaceRoutePrefixValue + "\"}")\r
1100                                                                 }\r
1101                                                         }\r
1102                                                 }\r
1103                                                 interfaceRoutePrefixValues = sb3.append("]")\r
1104                                                 if (interfaceRoutePrefixesList.getLength() > 0) {\r
1105                                                         String interfaceRoutePrefixesXml =\r
1106                                                                                                         """<entry>\r
1107                                                                                         <key>${key}_${networkKey}_route_prefixes</key>\r
1108                                                                                         <value>${interfaceRoutePrefixValues}</value>\r
1109                                                                                 </entry>"""                                     \r
1110                                                         interfaceRoutePrefixes = sbInterfaceRoutePrefixes.append(interfaceRoutePrefixesXml)\r
1111                                                 }\r
1112                                                         \r
1113                                                 NodeList networkIpsV6List = eElementNetworkKey.getElementsByTagNameNS("*","network-ips-v6")\r
1114                                                 for(int a = 0; a < networkIpsV6List.getLength(); a++){\r
1115                                                         Node ipV6Address = networkIpsV6List.item(a)\r
1116                                                         if (ipV6Address.getNodeType() == Node.ELEMENT_NODE) {\r
1117                                                                 Element eElementIpV6Address = (Element) ipV6Address\r
1118                                                                 String ipV6AddressValue = utils.getElementText(eElementIpV6Address, "ip-address-ipv6")\r
1119                                                                 if (a != networkIpsV6List.getLength() - 1) {\r
1120                                                                         ipV6AddressValues = sb4.append(ipV6AddressValue + ",")\r
1121                                                                 }\r
1122                                                                 else {\r
1123                                                                         ipV6AddressValues = sb4.append(ipV6AddressValue);\r
1124                                                                 }\r
1125                                                                 networkPosition = a.toString()\r
1126                                                                 String vmNetworksPositionsV6Xml =\r
1127                                                                                 """<entry>\r
1128                                                                                 <key>${key}_${networkKey}_v6_ip_${networkPosition}</key>\r
1129                                                                                 <value>${ipV6AddressValue}</value>\r
1130                                                                                 </entry>"""\r
1131                                                                 vmNetworksPositionsV6 = sbNetworksPositionsV6.append(vmNetworksPositionsV6Xml)\r
1132                                                         }\r
1133                                                 }\r
1134                                                 String vmNetworksV6Xml =\r
1135                                                                 """<entry>\r
1136                                                                 <key>${key}_${networkKey}_v6_ips</key>\r
1137                                                                 <value>${ipV6AddressValues}</value>\r
1138                                                         </entry>"""\r
1139                                                 vmNetworks = sbVmNetworks.append(vmNetworksV6Xml)\r
1140                                         }\r
1141                                 }\r
1142                                 String vnfXml =\r
1143                                                                 """<entry>\r
1144                                 <key>${key}_names</key>\r
1145                                 <value>${values}</value>\r
1146                                         </entry>"""\r
1147                                 vnfVMS = sb.append(vnfXml)\r
1148                         }\r
1149                 }\r
1150         //SDNC Response Params\r
1151                 String sdncResponseParams = ""\r
1152                 List<String> sdncResponseParamsToSkip = ["vnf_id", "vf_module_id", "vnf_name", "vf_module_name"]\r
1153                 String vnfParamsChildNodes = utils.getChildNodes(data, "vnf-parameters")\r
1154                 if(vnfParamsChildNodes == null || vnfParamsChildNodes.length() < 1){\r
1155                         // No SDNC params\r
1156                 }else{\r
1157                         NodeList paramsList = responseXml.getElementsByTagNameNS("*", "vnf-parameters")\r
1158                         for (int z = 0; z < paramsList.getLength(); z++) {\r
1159                                 Node node = paramsList.item(z)\r
1160                                 Element eElement = (Element) node\r
1161                                 String vnfParameterName = utils.getElementText(eElement, "vnf-parameter-name")\r
1162                                 if (!sdncResponseParamsToSkip.contains(vnfParameterName)) {\r
1163                                         String vnfParameterValue = utils.getElementText(eElement, "vnf-parameter-value")\r
1164                                         String paraEntry =\r
1165                                                 """<entry>\r
1166                                                         <key>${vnfParameterName}</key>\r
1167                                                         <value>${vnfParameterValue}</value>\r
1168                                                 </entry>"""\r
1169                                         sdncResponseParams = sb.append(paraEntry)\r
1170                                 }\r
1171                         }\r
1172                 }\r
1173         \r
1174         \r
1175                 def vfModuleParams = """\r
1176                 ${vnfInfo}\r
1177                 ${aZones}\r
1178                 ${vnfNetworkNetId}\r
1179                 ${vnfNetworkNetName}\r
1180                 ${vnfNetworkSubNetId}\r
1181                 ${vnfNetworkV6SubNetId}\r
1182                 ${vnfNetworkNetFqdn}\r
1183                 ${vnfNetworksSriovVlanFilters}\r
1184         ${vnfVMS}\r
1185         ${vnfVMSPositions}\r
1186                 ${vmNetworks}\r
1187                 ${vmNetworksPositions}\r
1188                 ${vmNetworksPositionsV6}\r
1189                 ${interfaceRoutePrefixes}\r
1190                 ${vnfParams}\r
1191                 ${sdncResponseParams}"""\r
1192                         \r
1193                 return vfModuleParams\r
1194                         \r
1195         }\r
1196         \r
1197 }