bpmn/MSOCommonBPMN/src/main/groovy/org/onap/so/bpmn/common/scripts/VfModuleBase.groovy

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