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