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 [
 182                     'vnf_id',
 183                     'vnf_name',
 184                     'vf_module_id',
 185                     'vf_module_name'
 186                 ])) {
 187                     def value = (String) param.text()
 188                     String entry = """
 189                                                 <entry>
 190                                                         <key>${MsoUtils.xmlEscape(key)}</key>
 191                                                         <value>${MsoUtils.xmlEscape(value)}</value>
 192                                                 </entry>
 193                                         """
 194                     entries = entries + entry
 195                 }
 196             }
 197         } catch (Exception e) {
 198             logger.warn("{} {} {} {} {}", MessageEnum.BPMN_GENERAL_WARNING.toString(),
 199                             'Exception transforming params to entries', "BPMN",
 200                             ErrorCode.UnknownError.getValue(), 'Exception transforming params to entries' + e);
 201         }
 202         return entries
 203     }
 204
 205     /*
 206      * Parses VNF parameters passed in on the incoming requests and SDNC parameters returned from SDNC get response
 207      * and puts them into the format expected by VNF adapter.
 208      * @param vnfParamsMap -  map of VNF parameters passed in the request body
 209      * @param sdncGetResponse - response string from SDNC GET topology request
 210      * @param vnfId
 211      * @param vnfName
 212      * @param vfModuleId
 213      * @param vfModuleName
 214      * @param vfModuleIndex - can be null
 215      * @return a String of key/value entries for vfModuleParams
 216      */
 217
 218
 219     protected String buildVfModuleParams(Map<String, String> vnfParamsMap, String sdncGetResponse, String vnfId, String vnfName,
 220                     String vfModuleId, String vfModuleName, String vfModuleIndex, String environmentContext, String workloadContext) {
 221
 222         //Get SDNC Response Data
 223
 224         String data = utils.getNodeXml(sdncGetResponse, "response-data")
 225
 226         String serviceData = utils.getNodeXml(data, "service-data")
 227         serviceData = utils.removeXmlPreamble(serviceData)
 228         serviceData = utils.removeXmlNamespaces(serviceData)
 229         String vnfRequestInfo = utils.getNodeXml(serviceData, "vnf-request-information")
 230         String oldVnfId = utils.getNodeXml(vnfRequestInfo, "vnf-id")
 231         oldVnfId = utils.removeXmlPreamble(oldVnfId)
 232         oldVnfId = utils.removeXmlNamespaces(oldVnfId)
 233         serviceData = serviceData.replace(oldVnfId, "")
 234         def vnfId1 = utils.getNodeText(serviceData, "vnf-id")
 235
 236         Map<String, String> paramsMap = new HashMap<String, String>()
 237
 238         if (vfModuleIndex != null) {
 239             paramsMap.put("vf_module_index", "${vfModuleIndex}")
 240         }
 241
 242         // Add-on data
 243         paramsMap.put("vnf_id", "${vnfId}")
 244         paramsMap.put("vnf_name", "${vnfName}")
 245         paramsMap.put("vf_module_id", "${vfModuleId}")
 246         paramsMap.put("vf_module_name", "${vfModuleName}")
 247         paramsMap.put("environment_context", "${environmentContext}")
 248         paramsMap.put("workload_context", "${workloadContext}")
 249
 250         InputSource source = new InputSource(new StringReader(data));
 251         DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
 252         docFactory.setNamespaceAware(true)
 253         DocumentBuilder docBuilder = docFactory.newDocumentBuilder()
 254         Document responseXml = docBuilder.parse(source)
 255
 256
 257         // Availability Zones Data
 258
 259         NodeList aZonesList = responseXml.getElementsByTagNameNS("*", "availability-zones")
 260         String aZonePosition = "0"
 261         for (int z = 0; z < aZonesList.getLength(); z++) {
 262             Node node = aZonesList.item(z)
 263             if (node.getNodeType() == Node.ELEMENT_NODE) {
 264                 Element eElement = (Element) node
 265                 String aZoneValue = utils.getElementText(eElement, "availability-zone")
 266                 aZonePosition = z.toString()
 267                 paramsMap.put("availability_zone_${aZonePosition}", "${aZoneValue}")
 268             }
 269         }
 270
 271         // Map of network-roles and network-tags from vm-networks
 272
 273         NodeList vmNetworksListGlobal = responseXml.getElementsByTagNameNS("*", "vm-networks")
 274         Map<String, String> networkRoleMap = new HashMap<String, String>()
 275         for(int n = 0; n < vmNetworksListGlobal.getLength(); n++){
 276             Node nodeNetworkKey = vmNetworksListGlobal.item(n)
 277             if (nodeNetworkKey.getNodeType() == Node.ELEMENT_NODE) {
 278                 Element eElementNetworkKey = (Element) nodeNetworkKey
 279                 String networkRole = utils.getElementText(eElementNetworkKey, "network-role")
 280                 String networkRoleValue = utils.getElementText(eElementNetworkKey, "network-role-tag")
 281                 if (networkRoleValue.isEmpty()) {
 282                     networkRoleValue = networkRole
 283                 }
 284                 networkRoleMap.put(networkRole, networkRoleValue)
 285             }
 286         }
 287
 288         // VNF Networks Data
 289
 290         StringBuilder sbNet = new StringBuilder()
 291
 292         NodeList vnfNetworkList = responseXml.getElementsByTagNameNS("*", "vnf-networks")
 293         for (int x = 0; x < vnfNetworkList.getLength(); x++) {
 294             Node node = vnfNetworkList.item(x)
 295             if (node.getNodeType() == Node.ELEMENT_NODE) {
 296                 Element eElement = (Element) node
 297                 String vnfNetworkKey = utils.getElementText(eElement, "network-role-tag")
 298                 String networkRole = utils.getElementText(eElement, "network-role")
 299                 if (vnfNetworkKey.isEmpty()) {
 300                     vnfNetworkKey = networkRoleMap.get(networkRole)
 301                     if (vnfNetworkKey == null || vnfNetworkKey.isEmpty()) {
 302                         vnfNetworkKey = networkRole
 303                     }
 304                 }
 305                 String vnfNetworkNeutronIdValue = utils.getElementText(eElement, "neutron-id")
 306                 String vnfNetworkNetNameValue = utils.getElementText(eElement, "network-name")
 307                 String vnfNetworkSubNetIdValue = utils.getElementText(eElement, "subnet-id")
 308                 String vnfNetworkV6SubNetIdValue = utils.getElementText(eElement, "ipv6-subnet-id")
 309                 String vnfNetworkNetFqdnValue = utils.getElementText(eElement, "contrail-network-fqdn")
 310                 paramsMap.put("${vnfNetworkKey}_net_id", "${vnfNetworkNeutronIdValue}")
 311                 paramsMap.put("${vnfNetworkKey}_net_name", "${vnfNetworkNetNameValue}")
 312                 paramsMap.put("${vnfNetworkKey}_subnet_id", "${vnfNetworkSubNetIdValue}")
 313                 paramsMap.put("${vnfNetworkKey}_v6_subnet_id", "${vnfNetworkV6SubNetIdValue}")
 314                 paramsMap.put("${vnfNetworkKey}_net_fqdn", "${vnfNetworkNetFqdnValue}")
 315
 316                 NodeList sriovVlanFilterList = eElement.getElementsByTagNameNS("*","sriov-vlan-filter-list")
 317                 StringBuffer sriovFilterBuf = new StringBuffer()
 318                 String values = ""
 319                 for(int i = 0; i < sriovVlanFilterList.getLength(); i++){
 320                     Node node1 = sriovVlanFilterList.item(i)
 321                     if (node1.getNodeType() == Node.ELEMENT_NODE) {
 322                         Element eElement1 = (Element) node1
 323                         String value = utils.getElementText(eElement1, "sriov-vlan-filter")
 324                         if (i != sriovVlanFilterList.getLength() - 1) {
 325                             values = sriovFilterBuf.append(value + ",")
 326                         }
 327                         else {
 328                             values = sriovFilterBuf.append(value);
 329                         }
 330                     }
 331                 }
 332                 if (!values.isEmpty()) {
 333                     paramsMap.put("${vnfNetworkKey}_ATT_VF_VLAN_FILTER", "${values}")
 334                 }
 335             }
 336         }
 337
 338         // VNF-VMS Data
 339
 340         def key
 341         def value
 342         def networkKey
 343         def networkValue
 344         def floatingIPKey
 345         def floatingIPKeyValue
 346         def floatingIPV6Key
 347         def floatingIPV6KeyValue
 348         StringBuilder sb = new StringBuilder()
 349
 350         NodeList vmsList = responseXml.getElementsByTagNameNS("*","vnf-vms")
 351         for (int x = 0; x < vmsList.getLength(); x++) {
 352             Node node = vmsList.item(x)
 353             if (node.getNodeType() == Node.ELEMENT_NODE) {
 354                 Element eElement = (Element) node
 355                 key = utils.getElementText(eElement, "vm-type")
 356                 String values
 357                 String position = "0"
 358                 StringBuilder sb1 = new StringBuilder()
 359                 NodeList valueList = eElement.getElementsByTagNameNS("*","vm-names")
 360                 NodeList vmNetworksList = eElement.getElementsByTagNameNS("*","vm-networks")
 361                 for(int i = 0; i < valueList.getLength(); i++){
 362                     Node node1 = valueList.item(i)
 363                     if (node1.getNodeType() == Node.ELEMENT_NODE) {
 364                         Element eElement1 = (Element) node1
 365                         value = utils.getElementText(eElement1, "vm-name")
 366                         if (i != valueList.getLength() - 1) {
 367                             values = sb1.append(value + ",")
 368                         }
 369                         else {
 370                             values = sb1.append(value);
 371                         }
 372                         position = i.toString()
 373                         paramsMap.put("${key}_name_${position}", "${value}")
 374                     }
 375                 }
 376                 for(int n = 0; n < vmNetworksList.getLength(); n++){
 377                     String floatingIpKeyValueStr = ""
 378                     String floatingIpV6KeyValueStr = ""
 379                     Node nodeNetworkKey = vmNetworksList.item(n)
 380                     if (nodeNetworkKey.getNodeType() == Node.ELEMENT_NODE) {
 381                         Element eElementNetworkKey = (Element) nodeNetworkKey
 382                         String ipAddressValues
 383                         String ipV6AddressValues
 384                         String networkPosition = "0"
 385                         StringBuilder sb2 = new StringBuilder()
 386                         StringBuilder sb3 = new StringBuilder()
 387                         StringBuilder sb4 = new StringBuilder()
 388                         networkKey = utils.getElementText(eElementNetworkKey, "network-role-tag")
 389                         if (networkKey.isEmpty()) {
 390                             networkKey = utils.getElementText(eElementNetworkKey, "network-role")
 391                         }
 392                         floatingIPKey = key + '_' + networkKey + '_floating_ip'
 393                         floatingIPKeyValue = utils.getElementText(eElementNetworkKey, "floating-ip")
 394                         if(!floatingIPKeyValue.isEmpty()){
 395                             paramsMap.put("$floatingIPKey", "$floatingIPKeyValue")
 396                         }
 397                         floatingIPV6Key = key + '_' + networkKey + '_floating_v6_ip'
 398                         floatingIPV6KeyValue = utils.getElementText(eElementNetworkKey, "floating-ip-v6")
 399                         if(!floatingIPV6KeyValue.isEmpty()){
 400                             paramsMap.put("$floatingIPV6Key", "$floatingIPV6KeyValue")
 401                         }
 402                         NodeList networkIpsList = eElementNetworkKey.getElementsByTagNameNS("*","network-ips")
 403                         for(int a = 0; a < networkIpsList.getLength(); a++){
 404                             Node ipAddress = networkIpsList.item(a)
 405                             if (ipAddress.getNodeType() == Node.ELEMENT_NODE) {
 406                                 Element eElementIpAddress = (Element) ipAddress
 407                                 String ipAddressValue = utils.getElementText(eElementIpAddress, "ip-address")
 408                                 if (a != networkIpsList.getLength() - 1) {
 409                                     ipAddressValues = sb2.append(ipAddressValue + ",")
 410                                 }
 411                                 else {
 412                                     ipAddressValues = sb2.append(ipAddressValue);
 413                                 }
 414                                 networkPosition = a.toString()
 415                                 paramsMap.put("${key}_${networkKey}_ip_${networkPosition}", "${ipAddressValue}")
 416                             }
 417                         }
 418
 419                         paramsMap.put("${key}_${networkKey}_ips", "${ipAddressValues}")
 420
 421                         NodeList interfaceRoutePrefixesList = eElementNetworkKey.getElementsByTagNameNS("*","interface-route-prefixes")
 422                         String interfaceRoutePrefixValues = sb3.append("[")
 423
 424                         for(int a = 0; a < interfaceRoutePrefixesList.getLength(); a++){
 425                             Node interfaceRoutePrefix = interfaceRoutePrefixesList.item(a)
 426                             if (interfaceRoutePrefix.getNodeType() == Node.ELEMENT_NODE) {
 427                                 Element eElementInterfaceRoutePrefix = (Element) interfaceRoutePrefix
 428                                 String interfaceRoutePrefixValue = utils.getElementText(eElementInterfaceRoutePrefix, "interface-route-prefix-cidr")
 429                                 if (interfaceRoutePrefixValue == null || interfaceRoutePrefixValue.isEmpty()) {
 430                                     interfaceRoutePrefixValue = utils.getElementText(eElementInterfaceRoutePrefix, "interface-route-prefix")
 431                                 }
 432                                 if (a != interfaceRoutePrefixesList.getLength() - 1) {
 433                                     interfaceRoutePrefixValues = sb3.append("{\"interface_route_table_routes_route_prefix\": \"" + interfaceRoutePrefixValue + "\"}" + ",")
 434                                 }
 435                                 else {
 436                                     interfaceRoutePrefixValues = sb3.append("{\"interface_route_table_routes_route_prefix\": \"" + interfaceRoutePrefixValue + "\"}")
 437                                 }
 438                             }
 439                         }
 440                         interfaceRoutePrefixValues = sb3.append("]")
 441                         if (interfaceRoutePrefixesList.getLength() > 0) {
 442                             paramsMap.put("${key}_${networkKey}_route_prefixes", "${interfaceRoutePrefixValues}")
 443                         }
 444
 445                         NodeList networkIpsV6List = eElementNetworkKey.getElementsByTagNameNS("*","network-ips-v6")
 446                         for(int a = 0; a < networkIpsV6List.getLength(); a++){
 447                             Node ipV6Address = networkIpsV6List.item(a)
 448                             if (ipV6Address.getNodeType() == Node.ELEMENT_NODE) {
 449                                 Element eElementIpV6Address = (Element) ipV6Address
 450                                 String ipV6AddressValue = utils.getElementText(eElementIpV6Address, "ip-address-ipv6")
 451                                 if (a != networkIpsV6List.getLength() - 1) {
 452                                     ipV6AddressValues = sb4.append(ipV6AddressValue + ",")
 453                                 }
 454                                 else {
 455                                     ipV6AddressValues = sb4.append(ipV6AddressValue);
 456                                 }
 457                                 networkPosition = a.toString()
 458                                 paramsMap.put("${key}_${networkKey}_v6_ip_${networkPosition}", "${ipV6AddressValue}")
 459                             }
 460                         }
 461                         paramsMap.put("${key}_${networkKey}_v6_ips", "${ipV6AddressValues}")
 462                     }
 463                 }
 464                 paramsMap.put("${key}_names", "${values}")
 465             }
 466         }
 467         //SDNC Response Params
 468         String sdncResponseParams = ""
 469         List<String> sdncResponseParamsToSkip = [
 470             "vnf_id",
 471             "vf_module_id",
 472             "vnf_name",
 473             "vf_module_name"
 474         ]
 475         String vnfParamsChildNodes = utils.getChildNodes(data, "vnf-parameters")
 476         if(vnfParamsChildNodes == null || vnfParamsChildNodes.length() < 1){
 477             // No SDNC params
 478         }else{
 479             NodeList paramsList = responseXml.getElementsByTagNameNS("*", "vnf-parameters")
 480             for (int z = 0; z < paramsList.getLength(); z++) {
 481                 Node node = paramsList.item(z)
 482                 Element eElement = (Element) node
 483                 String vnfParameterName = utils.getElementText(eElement, "vnf-parameter-name")
 484                 if (!sdncResponseParamsToSkip.contains(vnfParameterName)) {
 485                     String vnfParameterValue = utils.getElementText(eElement, "vnf-parameter-value")
 486                     paramsMap.put("${vnfParameterName}", "${vnfParameterValue}")
 487                 }
 488             }
 489         }
 490
 491         // make the sdnc_directives parameter
 492         String sdncDirectives = "{}"
 493         StringBuilder sdncDirectivesBuilder = new StringBuilder()
 494         sdncDirectivesBuilder.append("{ \"attributes\": [")
 495         int pcnt = 0
 496         for (Map.Entry<String, String> entry : paramsMap.entrySet()) {
 497                 String attributeName = entry.getKey()
 498                 String attributeValue = entry.getValue()
 499                 if (pcnt > 0) {
 500                     sdncDirectivesBuilder.append(",")
 501                 }
 502                 pcnt++
 503                 sdncDirectivesBuilder.append("{\"attribute_name\":\"${attributeName}\",")
 504                 sdncDirectivesBuilder.append("\"attribute_value\":\"${attributeValue}\"}")
 505         }
 506         if (pcnt > 0) {
 507             sdncDirectives = sdncDirectivesBuilder.append("]}").toString()
 508         }
 509         paramsMap.put("sdnc_directives", "${sdncDirectives}")
 510
 511         // Parameters received from the request should overwrite any parameters received from SDNC
 512         // Also build the user_directives parameter
 513         String userDirectives = "{}"
 514         if (vnfParamsMap != null) {
 515             StringBuilder userDirectivesBuilder = new StringBuilder()
 516             userDirectivesBuilder.append("{ \"attributes\": [")
 517             pcnt = 0
 518             for (Map.Entry<String, String> entry : vnfParamsMap.entrySet()) {
 519                 String vnfKey = entry.getKey()
 520                 String vnfValue = entry.getValue()
 521                 paramsMap.put("$vnfKey", "$vnfValue")
 522                 if (!"oof_directives".equals(vnfKey)) {
 523                     if (pcnt > 0) {
 524                         userDirectivesBuilder.append(",")
 525                     }
 526                     pcnt++
 527                     userDirectivesBuilder.append("{\"attribute_name\":\"${vnfKey}\",")
 528                     userDirectivesBuilder.append("\"attribute_value\":\"${vnfValue}\"}")
 529                 }
 530             }
 531             if (pcnt > 0) {
 532                 userDirectives = userDirectivesBuilder.append("]}").toString()
 533             }
 534         }
 535         paramsMap.put("user_directives", "${userDirectives}")
 536
 537         StringBuilder sbParams = new StringBuilder()
 538         def vfModuleParams = ""
 539         for (Map.Entry<String, String> entry : paramsMap.entrySet()) {
 540             String paramsXml
 541             String paramName = entry.getKey()
 542             String paramValue = entry.getValue()
 543             paramsXml =
 544                             """<entry>
 545                                                         <key>${MsoUtils.xmlEscape(paramName)}</key>
 546                                                         <value>${MsoUtils.xmlEscape(paramValue)}</value>
 547                                                 </entry>
 548                                                 """
 549
 550             vfModuleParams = sbParams.append(paramsXml)
 551         }
 552
 553         return vfModuleParams
 554
 555     }
 556
 557
 558     /*
 559      * Parses VNF parameters passed in on the incoming requests and SDNC parameters returned from SDNC get response
 560      * for both VNF and VF Module
 561      * and puts them into the format expected by VNF adapter.
 562      * @param vnfParamsMap -  map of VNF parameters passed in the request body
 563      * @param vnfSdncGetResponse - response string from SDNC GET VNF topology request
 564      * @param vfmoduleSdncGetResponse - response string from SDNC GET VF Module topology request
 565      * @param vnfId
 566      * @param vnfName
 567      * @param vfModuleId
 568      * @param vfModuleName
 569      * @param vfModuleIndex - can be null
 570      * @return a String of key/value entries for vfModuleParams
 571      */
 572
 573     protected String buildVfModuleParamsFromCombinedTopologies(Map<String, String> vnfParamsMap, String vnfSdncGetResponse, String vfmoduleSdncGetResponse, String vnfId, String vnfName,
 574                     String vfModuleId, String vfModuleName, String vfModuleIndex, String environmentContext, String workloadContext) {
 575
 576         // Set up initial parameters
 577
 578         Map<String, String> paramsMap = new HashMap<String, String>()
 579
 580         if (vfModuleIndex != null) {
 581             paramsMap.put("vf_module_index", "${vfModuleIndex}")
 582         }
 583
 584         // Add-on data
 585         paramsMap.put("vnf_id", "${vnfId}")
 586         paramsMap.put("vnf_name", "${vnfName}")
 587         paramsMap.put("vf_module_id", "${vfModuleId}")
 588         paramsMap.put("vf_module_name", "${vfModuleName}")
 589         paramsMap.put("environment_context","${environmentContext}")
 590         paramsMap.put("workload_context", "${workloadContext}")
 591
 592         //Get SDNC Response Data for VNF
 593
 594         String vnfData = utils.getNodeXml(vnfSdncGetResponse, "response-data")
 595
 596         String vnfTopology = utils.getNodeXml(vnfData, "vnf-topology")
 597         vnfTopology = utils.removeXmlPreamble(vnfTopology)
 598         vnfTopology = utils.removeXmlNamespaces(vnfTopology)
 599
 600         InputSource sourceVnf = new InputSource(new StringReader(vnfData));
 601         DocumentBuilderFactory docFactoryVnf = DocumentBuilderFactory.newInstance();
 602         docFactoryVnf.setNamespaceAware(true)
 603         DocumentBuilder docBuilderVnf = docFactoryVnf.newDocumentBuilder()
 604         Document responseXmlVnf = docBuilderVnf.parse(sourceVnf)
 605
 606         // Availability Zones Data
 607
 608         NodeList aZonesList = responseXmlVnf.getElementsByTagNameNS("*", "availability-zones")
 609         String aZonePosition = "0"
 610         for (int z = 0; z < aZonesList.getLength(); z++) {
 611             Node node = aZonesList.item(z)
 612             if (node.getNodeType() == Node.ELEMENT_NODE) {
 613                 Element eElement = (Element) node
 614                 String aZoneValue = utils.getElementText(eElement, "availability-zone")
 615                 aZonePosition = z.toString()
 616                 paramsMap.put("availability_zone_${aZonePosition}", "${aZoneValue}")
 617             }
 618         }
 619
 620         //Get SDNC Response Data for VF Module
 621
 622         String vfModuleData = utils.getNodeXml(vfmoduleSdncGetResponse, "response-data")
 623
 624         String vfModuleTopology = utils.getNodeXml(vfModuleData, "vf-module-topology")
 625         vfModuleTopology = utils.removeXmlPreamble(vfModuleTopology)
 626         vfModuleTopology = utils.removeXmlNamespaces(vfModuleTopology)
 627         String vfModuleTopologyIdentifier = utils.getNodeXml(vfModuleTopology, "vf-module-topology-identifier")
 628
 629         InputSource sourceVfModule = new InputSource(new StringReader(vfModuleData));
 630         DocumentBuilderFactory docFactoryVfModule = DocumentBuilderFactory.newInstance();
 631         docFactoryVfModule.setNamespaceAware(true)
 632         DocumentBuilder docBuilderVfModule = docFactoryVfModule.newDocumentBuilder()
 633         Document responseXmlVfModule = docBuilderVfModule.parse(sourceVfModule)
 634
 635         // Map of network-roles and network-tags from vm-networks
 636
 637         NodeList vmNetworksListGlobal = responseXmlVfModule.getElementsByTagNameNS("*", "vm-networks")
 638         Map<String, String> networkRoleMap = new HashMap<String, String>()
 639         for(int n = 0; n < vmNetworksListGlobal.getLength(); n++){
 640             Node nodeNetworkKey = vmNetworksListGlobal.item(n)
 641             if (nodeNetworkKey.getNodeType() == Node.ELEMENT_NODE) {
 642                 Element eElementNetworkKey = (Element) nodeNetworkKey
 643                 String networkRole = utils.getElementText(eElementNetworkKey, "network-role")
 644                 String networkRoleValue = utils.getElementText(eElementNetworkKey, "network-role-tag")
 645                 if (networkRoleValue.isEmpty()) {
 646                     networkRoleValue = networkRole
 647                 }
 648                 networkRoleMap.put(networkRole, networkRoleValue)
 649             }
 650         }
 651
 652         // VNF Networks Data
 653
 654         StringBuilder sbNet = new StringBuilder()
 655
 656         NodeList vnfNetworkList = responseXmlVnf.getElementsByTagNameNS("*", "vnf-networks")
 657         for (int x = 0; x < vnfNetworkList.getLength(); x++) {
 658             Node node = vnfNetworkList.item(x)
 659             if (node.getNodeType() == Node.ELEMENT_NODE) {
 660                 Element eElement = (Element) node
 661                 String vnfNetworkKey = utils.getElementText(eElement, "network-role-tag")
 662                 String networkRole = utils.getElementText(eElement, "network-role")
 663                 if (vnfNetworkKey.isEmpty()) {
 664                     vnfNetworkKey = networkRoleMap.get(networkRole)
 665                     if (vnfNetworkKey == null || vnfNetworkKey.isEmpty()) {
 666                         vnfNetworkKey = networkRole
 667                     }
 668                 }
 669                 String vnfNetworkNeutronIdValue = utils.getElementText(eElement, "neutron-id")
 670                 String vnfNetworkNetNameValue = utils.getElementText(eElement, "network-name")
 671                 String vnfNetworkSubNetIdValue = utils.getElementText(eElement, "subnet-id")
 672                 String vnfNetworkV6SubNetIdValue = utils.getElementText(eElement, "ipv6-subnet-id")
 673                 String vnfNetworkNetFqdnValue = utils.getElementText(eElement, "contrail-network-fqdn")
 674                 paramsMap.put("${vnfNetworkKey}_net_id", "${vnfNetworkNeutronIdValue}")
 675                 paramsMap.put("${vnfNetworkKey}_net_name", "${vnfNetworkNetNameValue}")
 676                 paramsMap.put("${vnfNetworkKey}_subnet_id", "${vnfNetworkSubNetIdValue}")
 677                 paramsMap.put("${vnfNetworkKey}_v6_subnet_id", "${vnfNetworkV6SubNetIdValue}")
 678                 paramsMap.put("${vnfNetworkKey}_net_fqdn", "${vnfNetworkNetFqdnValue}")
 679
 680                 NodeList sriovVlanFilterList = eElement.getElementsByTagNameNS("*","sriov-vlan-filter-list")
 681                 StringBuffer sriovFilterBuf = new StringBuffer()
 682                 String values = ""
 683                 for(int i = 0; i < sriovVlanFilterList.getLength(); i++){
 684                     Node node1 = sriovVlanFilterList.item(i)
 685                     if (node1.getNodeType() == Node.ELEMENT_NODE) {
 686                         Element eElement1 = (Element) node1
 687                         String value = utils.getElementText(eElement1, "sriov-vlan-filter")
 688                         if (i != sriovVlanFilterList.getLength() - 1) {
 689                             values = sriovFilterBuf.append(value + ",")
 690                         }
 691                         else {
 692                             values = sriovFilterBuf.append(value);
 693                         }
 694                     }
 695                 }
 696                 if (!values.isEmpty()) {
 697                     paramsMap.put("${vnfNetworkKey}_ATT_VF_VLAN_FILTER", "${values}")
 698                 }
 699             }
 700         }
 701
 702
 703
 704         // VMS Data
 705
 706         def key
 707         def value
 708         def networkKey
 709         def networkValue
 710         def floatingIPKey
 711         def floatingIPKeyValue
 712         def floatingIPV6Key
 713         def floatingIPV6KeyValue
 714         StringBuilder sb = new StringBuilder()
 715
 716         NodeList vmsList = responseXmlVfModule.getElementsByTagNameNS("*","vm")
 717         for (int x = 0; x < vmsList.getLength(); x++) {
 718             Node node = vmsList.item(x)
 719             if (node.getNodeType() == Node.ELEMENT_NODE) {
 720                 Element eElement = (Element) node
 721                 key = utils.getElementText(eElement, "vm-type")
 722                 String values
 723                 String position = "0"
 724                 StringBuilder sb1 = new StringBuilder()
 725                 NodeList valueList = eElement.getElementsByTagNameNS("*","vm-names")
 726                 NodeList vmNetworksList = eElement.getElementsByTagNameNS("*","vm-networks")
 727                 for(int i = 0; i < valueList.getLength(); i++){
 728                     Node node1 = valueList.item(i)
 729                     if (node1.getNodeType() == Node.ELEMENT_NODE) {
 730                         Element eElement1 = (Element) node1
 731                         value = utils.getElementText(eElement1, "vm-name")
 732                         if (i != valueList.getLength() - 1) {
 733                             values = sb1.append(value + ",")
 734                         }
 735                         else {
 736                             values = sb1.append(value);
 737                         }
 738                         position = i.toString()
 739                         paramsMap.put("${key}_name_${position}", "${value}")
 740                     }
 741                 }
 742                 for(int n = 0; n < vmNetworksList.getLength(); n++){
 743                     String floatingIpKeyValueStr = ""
 744                     String floatingIpV6KeyValueStr = ""
 745                     Node nodeNetworkKey = vmNetworksList.item(n)
 746                     if (nodeNetworkKey.getNodeType() == Node.ELEMENT_NODE) {
 747                         Element eElementNetworkKey = (Element) nodeNetworkKey
 748                         String ipAddressValues
 749                         String ipV6AddressValues
 750                         String networkPosition = "0"
 751                         StringBuilder sb2 = new StringBuilder()
 752                         StringBuilder sb3 = new StringBuilder()
 753                         StringBuilder sb4 = new StringBuilder()
 754                         networkKey = utils.getElementText(eElementNetworkKey, "network-role-tag")
 755                         if (networkKey.isEmpty()) {
 756                             networkKey = utils.getElementText(eElementNetworkKey, "network-role")
 757                         }
 758                         floatingIPKey = key + '_' + networkKey + '_floating_ip'
 759                         floatingIPKeyValue = utils.getElementText(eElementNetworkKey, "floating-ip")
 760                         if(!floatingIPKeyValue.isEmpty()){
 761                             paramsMap.put("$floatingIPKey", "$floatingIPKeyValue")
 762                         }
 763                         floatingIPV6Key = key + '_' + networkKey + '_floating_v6_ip'
 764                         floatingIPV6KeyValue = utils.getElementText(eElementNetworkKey, "floating-ip-v6")
 765                         if(!floatingIPV6KeyValue.isEmpty()){
 766                             paramsMap.put("$floatingIPV6Key", "$floatingIPV6KeyValue")
 767                         }
 768                         NodeList networkIpsList = eElementNetworkKey.getElementsByTagNameNS("*","network-ips")
 769                         for(int a = 0; a < networkIpsList.getLength(); a++){
 770                             Node ipAddress = networkIpsList.item(a)
 771                             if (ipAddress.getNodeType() == Node.ELEMENT_NODE) {
 772                                 Element eElementIpAddress = (Element) ipAddress
 773                                 String ipAddressValue = utils.getElementText(eElementIpAddress, "ip-address")
 774                                 if (a != networkIpsList.getLength() - 1) {
 775                                     ipAddressValues = sb2.append(ipAddressValue + ",")
 776                                 }
 777                                 else {
 778                                     ipAddressValues = sb2.append(ipAddressValue);
 779                                 }
 780                                 networkPosition = a.toString()
 781                                 paramsMap.put("${key}_${networkKey}_ip_${networkPosition}", "${ipAddressValue}")
 782                             }
 783                         }
 784
 785                         paramsMap.put("${key}_${networkKey}_ips", "${ipAddressValues}")
 786
 787                         NodeList interfaceRoutePrefixesList = eElementNetworkKey.getElementsByTagNameNS("*","interface-route-prefixes")
 788                         String interfaceRoutePrefixValues = sb3.append("[")
 789
 790                         for(int a = 0; a < interfaceRoutePrefixesList.getLength(); a++){
 791                             Node interfaceRoutePrefix = interfaceRoutePrefixesList.item(a)
 792                             if (interfaceRoutePrefix.getNodeType() == Node.ELEMENT_NODE) {
 793                                 Element eElementInterfaceRoutePrefix = (Element) interfaceRoutePrefix
 794                                 String interfaceRoutePrefixValue = utils.getElementText(eElementInterfaceRoutePrefix, "interface-route-prefix-cidr")
 795                                 if (interfaceRoutePrefixValue == null || interfaceRoutePrefixValue.isEmpty()) {
 796                                     interfaceRoutePrefixValue = utils.getElementText(eElementInterfaceRoutePrefix, "interface-route-prefix")
 797                                 }
 798                                 if (a != interfaceRoutePrefixesList.getLength() - 1) {
 799                                     interfaceRoutePrefixValues = sb3.append("{\"interface_route_table_routes_route_prefix\": \"" + interfaceRoutePrefixValue + "\"}" + ",")
 800                                 }
 801                                 else {
 802                                     interfaceRoutePrefixValues = sb3.append("{\"interface_route_table_routes_route_prefix\": \"" + interfaceRoutePrefixValue + "\"}")
 803                                 }
 804                             }
 805                         }
 806                         interfaceRoutePrefixValues = sb3.append("]")
 807                         if (interfaceRoutePrefixesList.getLength() > 0) {
 808                             paramsMap.put("${key}_${networkKey}_route_prefixes", "${interfaceRoutePrefixValues}")
 809                         }
 810
 811                         NodeList networkIpsV6List = eElementNetworkKey.getElementsByTagNameNS("*","network-ips-v6")
 812                         for(int a = 0; a < networkIpsV6List.getLength(); a++){
 813                             Node ipV6Address = networkIpsV6List.item(a)
 814                             if (ipV6Address.getNodeType() == Node.ELEMENT_NODE) {
 815                                 Element eElementIpV6Address = (Element) ipV6Address
 816                                 String ipV6AddressValue = utils.getElementText(eElementIpV6Address, "ip-address-ipv6")
 817                                 if (a != networkIpsV6List.getLength() - 1) {
 818                                     ipV6AddressValues = sb4.append(ipV6AddressValue + ",")
 819                                 }
 820                                 else {
 821                                     ipV6AddressValues = sb4.append(ipV6AddressValue);
 822                                 }
 823                                 networkPosition = a.toString()
 824                                 paramsMap.put("${key}_${networkKey}_v6_ip_${networkPosition}", "${ipV6AddressValue}")
 825                             }
 826                         }
 827                         paramsMap.put("${key}_${networkKey}_v6_ips", "${ipV6AddressValues}")
 828                     }
 829                 }
 830                 paramsMap.put("${key}_names", "${values}")
 831             }
 832         }
 833         //SDNC Response Params
 834         List<String> sdncResponseParamsToSkip = [
 835             "vnf_id",
 836             "vf_module_id",
 837             "vnf_name",
 838             "vf_module_name"
 839         ]
 840
 841         String vnfParamsChildNodes = utils.getChildNodes(vnfData, "param")
 842         if(vnfParamsChildNodes == null || vnfParamsChildNodes.length() < 1){
 843             // No SDNC params for VNF
 844         }else{
 845             NodeList paramsList = responseXmlVnf.getElementsByTagNameNS("*", "param")
 846             for (int z = 0; z < paramsList.getLength(); z++) {
 847                 Node node = paramsList.item(z)
 848                 Element eElement = (Element) node
 849                 String vnfParameterName = utils.getElementText(eElement, "name")
 850                 if (!sdncResponseParamsToSkip.contains(vnfParameterName)) {
 851                     String vnfParameterValue = utils.getElementText(eElement, "value")
 852                     paramsMap.put("${vnfParameterName}", "${vnfParameterValue}")
 853                 }
 854             }
 855         }
 856
 857         String vfModuleParamsChildNodes = utils.getChildNodes(vfModuleData, "param")
 858         if(vfModuleParamsChildNodes == null || vfModuleParamsChildNodes.length() < 1){
 859             // No SDNC params for VF Module
 860         }else{
 861             NodeList paramsList = responseXmlVfModule.getElementsByTagNameNS("*", "param")
 862             for (int z = 0; z < paramsList.getLength(); z++) {
 863                 Node node = paramsList.item(z)
 864                 Element eElement = (Element) node
 865                 String vnfParameterName = utils.getElementText(eElement, "name")
 866                 if (!sdncResponseParamsToSkip.contains(vnfParameterName)) {
 867                     String vnfParameterValue = utils.getElementText(eElement, "value")
 868                     paramsMap.put("${vnfParameterName}", "${vnfParameterValue}")
 869                 }
 870             }
 871         }
 872
 873         // make the sdnc_directives parameter
 874         String sdncDirectives = "{}"
 875         StringBuilder sdncDirectivesBuilder = new StringBuilder()
 876         sdncDirectivesBuilder.append("{ \"attributes\": [")
 877         int pcnt = 0
 878         for (Map.Entry<String, String> entry : paramsMap.entrySet()) {
 879                 String attributeName = entry.getKey()
 880                 String attributeValue = entry.getValue()
 881                 if (pcnt > 0) {
 882                     sdncDirectivesBuilder.append(",")
 883                 }
 884                 pcnt++
 885                 sdncDirectivesBuilder.append("{\"attribute_name\":\"${attributeName}\",")
 886                 sdncDirectivesBuilder.append("\"attribute_value\":\"${attributeValue}\"}")
 887         }
 888         if (pcnt > 0) {
 889             sdncDirectives = sdncDirectivesBuilder.append("]}").toString()
 890         }
 891         paramsMap.put("sdnc_directives", "${sdncDirectives}")
 892
 893
 894         // Parameters received from the request should overwrite any parameters received from SDNC
 895         String userDirectives = "{}"
 896         if (vnfParamsMap != null) {
 897             StringBuilder userDirectivesBuilder = new StringBuilder()
 898             userDirectivesBuilder.append("{ \"attributes\": [")
 899             pcnt = 0
 900             for (Map.Entry<String, String> entry : vnfParamsMap.entrySet()) {
 901                 String vnfKey = entry.getKey()
 902                 String vnfValue = entry.getValue()
 903                 paramsMap.put("$vnfKey", "$vnfValue")
 904                 if (pcnt > 0) {
 905                     userDirectivesBuilder.append(",")
 906                 }
 907                 pcnt++
 908                 userDirectivesBuilder.append("{\"attribute_name\":\"${vnfKey}\",")
 909                 userDirectivesBuilder.append("\"attribute_value\":\"${vnfValue}\"}")
 910             }
 911             if (pcnt > 0) {
 912                 userDirectives = userDirectivesBuilder.append("]}").toString()
 913             }
 914         }
 915         paramsMap.put("user_directives", "${userDirectives}")
 916
 917         StringBuilder sbParams = new StringBuilder()
 918         def vfModuleParams = ""
 919         for (Map.Entry<String, String> entry : paramsMap.entrySet()) {
 920             String paramsXml
 921             String paramName = entry.getKey()
 922             String paramValue = entry.getValue()
 923             paramsXml =
 924                             """<entry>
 925                                                 <key>${MsoUtils.xmlEscape(paramName)}</key>
 926                                                 <value>${MsoUtils.xmlEscape(paramValue)}</value>
 927                                         </entry>
 928                                         """
 929
 930             vfModuleParams = sbParams.append(paramsXml)
 931         }
 932
 933         return vfModuleParams
 934
 935     }
 936
 937
 938     /*
 939      * VBNG specific method that parses VNF parameters passed in on the
 940      * incoming requests and SDNC parameters returned from SDNC get response
 941      * and puts them into the format expected by VNF adapter.
 942      * @param vnfParamsMap -  map of VNF parameters passed in the request body
 943      * @param sdncGetResponse - response string from SDNC GET topology request
 944      * @param vnfId
 945      * @param vnfName
 946      * @param vfModuleId
 947      * @param vfModuleName
 948      * @return a String of key/value entries for vfModuleParams
 949      */
 950
 951     protected String buildVfModuleParamsVbng(String vnfParams, String sdncGetResponse, String vnfId, String vnfName,
 952                     String vfModuleId, String vfModuleName) {
 953
 954         //Get SDNC Response Data
 955
 956         String data = utils.getNodeXml(sdncGetResponse, "response-data")
 957
 958
 959
 960         // Add-on data
 961         String vnfInfo =
 962                         """<entry>
 963                                 <key>vnf_id</key>
 964                                 <value>${MsoUtils.xmlEscape(vnfId)}</value>
 965                         </entry>
 966                         <entry>
 967                                 <key>vnf_name</key>
 968                                 <value>${MsoUtils.xmlEscape(vnfName)}</value>
 969                         </entry>
 970                         <entry>
 971                                 <key>vf_module_id</key>
 972                                 <value>${MsoUtils.xmlEscape(vfModuleId)}</value>
 973                         </entry>
 974                         <entry>
 975                                 <key>vf_module_name</key>
 976                                 <value>${MsoUtils.xmlEscape(vfModuleName)}</value>
 977                         </entry>"""
 978
 979         logger.debug("vnfInfo: " + vnfInfo)
 980         InputSource source = new InputSource(new StringReader(data));
 981         DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
 982         docFactory.setNamespaceAware(true)
 983         DocumentBuilder docBuilder = docFactory.newDocumentBuilder()
 984         Document responseXml = docBuilder.parse(source)
 985
 986
 987         // Availability Zones Data
 988         String aZones = ""
 989         StringBuilder sbAZone = new StringBuilder()
 990         NodeList aZonesList = responseXml.getElementsByTagNameNS("*", "availability-zones")
 991         String aZonePosition = "0"
 992         for (int z = 0; z < aZonesList.getLength(); z++) {
 993             Node node = aZonesList.item(z)
 994             if (node.getNodeType() == Node.ELEMENT_NODE) {
 995                 Element eElement = (Element) node
 996                 String aZoneValue = utils.getElementText(eElement, "availability-zone")
 997                 aZonePosition = z.toString()
 998                 String aZoneXml =
 999                                 """<entry>
1000                                                 <key>availability_zone_${MsoUtils.xmlEscape(aZonePosition)}</key>
1001                                                 <value>${MsoUtils.xmlEscape(aZoneValue)}</value>
1002                                         </entry>"""
1003                 aZones = sbAZone.append(aZoneXml)
1004             }
1005         }
1006
1007         // Map of network-roles and network-tags from vm-networks
1008
1009         NodeList vmNetworksListGlobal = responseXml.getElementsByTagNameNS("*", "vm-networks")
1010         Map<String, String> networkRoleMap = new HashMap<String, String>()
1011         for(int n = 0; n < vmNetworksListGlobal.getLength(); n++){
1012             Node nodeNetworkKey = vmNetworksListGlobal.item(n)
1013             if (nodeNetworkKey.getNodeType() == Node.ELEMENT_NODE) {
1014                 Element eElementNetworkKey = (Element) nodeNetworkKey
1015                 String networkRole = utils.getElementText(eElementNetworkKey, "network-role")
1016                 String networkRoleValue = utils.getElementText(eElementNetworkKey, "network-role-tag")
1017                 if (networkRoleValue.isEmpty()) {
1018                     networkRoleValue = networkRole
1019                 }
1020                 networkRoleMap.put(networkRole, networkRoleValue)
1021             }
1022         }
1023
1024         // VNF Networks Data
1025         String vnfNetworkNetId = ""
1026         String vnfNetworkNetName = ""
1027         String vnfNetworkSubNetId = ""
1028         String vnfNetworkV6SubNetId = ""
1029         String vnfNetworkNetFqdn = ""
1030         String vnfNetworksSriovVlanFilters = ""
1031         StringBuilder sbNet = new StringBuilder()
1032         StringBuilder sbNet2 = new StringBuilder()
1033         StringBuilder sbNet3 = new StringBuilder()
1034         StringBuilder sbNet4 = new StringBuilder()
1035         StringBuilder sbNet5 = new StringBuilder()
1036         StringBuilder sbNet6 = new StringBuilder()
1037         NodeList vnfNetworkList = responseXml.getElementsByTagNameNS("*", "vnf-networks")
1038         for (int x = 0; x < vnfNetworkList.getLength(); x++) {
1039             Node node = vnfNetworkList.item(x)
1040             if (node.getNodeType() == Node.ELEMENT_NODE) {
1041                 Element eElement = (Element) node
1042                 String vnfNetworkKey = utils.getElementText(eElement, "network-role-tag")
1043                 String networkRole = utils.getElementText(eElement, "network-role")
1044                 if (vnfNetworkKey.isEmpty()) {
1045                     vnfNetworkKey = networkRoleMap.get(networkRole)
1046                     if (vnfNetworkKey == null || vnfNetworkKey.isEmpty()) {
1047                         vnfNetworkKey = networkRole
1048                     }
1049                 }
1050                 String vnfNetworkNeutronIdValue = utils.getElementText(eElement, "neutron-id")
1051                 String vnfNetworkNetNameValue = utils.getElementText(eElement, "network-name")
1052                 String vnfNetworkSubNetIdValue = utils.getElementText(eElement, "subnet-id")
1053                 String vnfNetworkV6SubNetIdValue = utils.getElementText(eElement, "ipv6-subnet-id")
1054                 String vnfNetworkNetFqdnValue = utils.getElementText(eElement, "contrail-network-fqdn")
1055                 String vnfNetworkNetIdXml =
1056                                 """<entry>
1057                                                         <key>${MsoUtils.xmlEscape(vnfNetworkKey)}_net_id</key>
1058                                                         <value>${MsoUtils.xmlEscape(vnfNetworkNeutronIdValue)}</value>
1059                                                 </entry>"""
1060                 vnfNetworkNetId = sbNet.append(vnfNetworkNetIdXml)
1061                 String vnfNetworkNetNameXml =
1062                                 """<entry>
1063                                                 <key>${MsoUtils.xmlEscape(vnfNetworkKey)}_net_name</key>
1064                                                 <value>${MsoUtils.xmlEscape(vnfNetworkNetNameValue)}</value>
1065                                 </entry>"""
1066                 vnfNetworkNetName = sbNet2.append(vnfNetworkNetNameXml)
1067                 String vnfNetworkSubNetIdXml =
1068                                 """<entry>
1069                                                 <key>${MsoUtils.xmlEscape(vnfNetworkKey)}_subnet_id</key>
1070                                                 <value>${MsoUtils.xmlEscape(vnfNetworkSubNetIdValue)}</value>
1071                                 </entry>"""
1072                 vnfNetworkSubNetId = sbNet3.append(vnfNetworkSubNetIdXml)
1073                 String vnfNetworkV6SubNetIdXml =
1074                                 """<entry>
1075                                                 <key>${MsoUtils.xmlEscape(vnfNetworkKey)}_v6_subnet_id</key>
1076                                                 <value>${MsoUtils.xmlEscape(vnfNetworkV6SubNetIdValue)}</value>
1077                                 </entry>"""
1078                 vnfNetworkV6SubNetId = sbNet5.append(vnfNetworkV6SubNetIdXml)
1079                 String vnfNetworkNetFqdnXml =
1080                                 """<entry>
1081                                                 <key>${MsoUtils.xmlEscape(vnfNetworkKey)}_net_fqdn</key>
1082                                                 <value>${MsoUtils.xmlEscape(vnfNetworkNetFqdnValue)}</value>
1083                                 </entry>"""
1084                 vnfNetworkNetFqdn = sbNet4.append(vnfNetworkNetFqdnXml)
1085
1086                 NodeList sriovVlanFilterList = eElement.getElementsByTagNameNS("*","sriov-vlan-filter-list")
1087                 StringBuffer sriovFilterBuf = new StringBuffer()
1088                 String values = ""
1089                 for(int i = 0; i < sriovVlanFilterList.getLength(); i++){
1090                     Node node1 = sriovVlanFilterList.item(i)
1091                     if (node1.getNodeType() == Node.ELEMENT_NODE) {
1092                         Element eElement1 = (Element) node1
1093                         String value = utils.getElementText(eElement1, "sriov-vlan-filter")
1094                         if (i != sriovVlanFilterList.getLength() - 1) {
1095                             values = sriovFilterBuf.append(value + ",")
1096                         }
1097                         else {
1098                             values = sriovFilterBuf.append(value);
1099                         }
1100                     }
1101                 }
1102                 if (!values.isEmpty()) {
1103                     String vnfNetworkSriovVlanFilterXml =
1104                                     """<entry>
1105                                                 <key>${MsoUtils.xmlEscape(vnfNetworkKey)}_ATT_VF_VLAN_FILTER</key>
1106                                                 <value>${MsoUtils.xmlEscape(values)}</value>
1107                                         </entry>"""
1108                     vnfNetworksSriovVlanFilters = sbNet6.append(vnfNetworkSriovVlanFilterXml)
1109                 }
1110             }
1111         }
1112
1113         // VNF-VMS Data
1114         String vnfVMS = ""
1115         String vnfVMSPositions = ""
1116         String vmNetworks = ""
1117         String vmNetworksPositions = ""
1118         String vmNetworksPositionsV6 = ""
1119         String interfaceRoutePrefixes = ""
1120         def key
1121         def value
1122         def networkKey
1123         def networkValue
1124         def floatingIPKey
1125         def floatingIPKeyValue
1126         def floatingIPV6Key
1127         def floatingIPV6KeyValue
1128         StringBuilder sb = new StringBuilder()
1129         StringBuilder sbPositions = new StringBuilder()
1130         StringBuilder sbVmNetworks = new StringBuilder()
1131         StringBuilder sbNetworksPositions = new StringBuilder()
1132         StringBuilder sbInterfaceRoutePrefixes = new StringBuilder()
1133         StringBuilder sbNetworksPositionsV6 = new StringBuilder()
1134
1135         NodeList vmsList = responseXml.getElementsByTagNameNS("*","vnf-vms")
1136         for (int x = 0; x < vmsList.getLength(); x++) {
1137             Node node = vmsList.item(x)
1138             if (node.getNodeType() == Node.ELEMENT_NODE) {
1139                 Element eElement = (Element) node
1140                 key = utils.getElementText(eElement, "vm-type")
1141                 String values
1142                 String position = "0"
1143                 StringBuilder sb1 = new StringBuilder()
1144                 NodeList valueList = eElement.getElementsByTagNameNS("*","vm-names")
1145                 NodeList vmNetworksList = eElement.getElementsByTagNameNS("*","vm-networks")
1146                 for(int i = 0; i < valueList.getLength(); i++){
1147                     Node node1 = valueList.item(i)
1148                     if (node1.getNodeType() == Node.ELEMENT_NODE) {
1149                         Element eElement1 = (Element) node1
1150                         value = utils.getElementText(eElement1, "vm-name")
1151                         if (i != valueList.getLength() - 1) {
1152                             values = sb1.append(value + ",")
1153                         }
1154                         else {
1155                             values = sb1.append(value);
1156                         }
1157                         position = i.toString()
1158                         String vnfPositionXml =
1159                                         """<entry>
1160                                                                 <key>${MsoUtils.xmlEscape(key)}_name_${MsoUtils.xmlEscape(position)}</key>
1161                                                                 <value>${MsoUtils.xmlEscape(value)}</value>
1162                                                         </entry>"""
1163                         nfVMSPositions = sbPositions.append(vnfPositionXml)
1164                     }
1165                 }
1166                 for(int n = 0; n < vmNetworksList.getLength(); n++){
1167                     String floatingIpKeyValueStr = ""
1168                     String floatingIpV6KeyValueStr = ""
1169                     Node nodeNetworkKey = vmNetworksList.item(n)
1170                     if (nodeNetworkKey.getNodeType() == Node.ELEMENT_NODE) {
1171                         Element eElementNetworkKey = (Element) nodeNetworkKey
1172                         String ipAddressValues
1173                         String ipV6AddressValues
1174                         String networkPosition = "0"
1175                         StringBuilder sb2 = new StringBuilder()
1176                         StringBuilder sb3 = new StringBuilder()
1177                         StringBuilder sb4 = new StringBuilder()
1178                         networkKey = utils.getElementText(eElementNetworkKey, "network-role-tag")
1179                         if (networkKey.isEmpty()) {
1180                             networkKey = utils.getElementText(eElementNetworkKey, "network-role")
1181                         }
1182                         floatingIPKey = key + '_' + networkKey + '_floating_ip'
1183                         floatingIPKeyValue = utils.getElementText(eElementNetworkKey, "floating-ip")
1184                         if(!floatingIPKeyValue.isEmpty()){
1185                             floatingIpKeyValueStr = """<entry>
1186                                                                 <key>$floatingIPKey</key>
1187                                                                 <value>$floatingIPKeyValue</value>
1188                                                         </entry>"""
1189                         }
1190                         floatingIPV6Key = key + '_' + networkKey + '_floating_v6_ip'
1191                         floatingIPV6KeyValue = utils.getElementText(eElementNetworkKey, "floating-ip-v6")
1192                         if(!floatingIPV6KeyValue.isEmpty()){
1193                             floatingIpV6KeyValueStr = """<entry>
1194                                                                 <key>$floatingIPV6Key</key>
1195                                                                 <value>$floatingIPV6KeyValue</value>
1196                                                         </entry>"""
1197                         }
1198                         NodeList networkIpsList = eElementNetworkKey.getElementsByTagNameNS("*","network-ips")
1199                         for(int a = 0; a < networkIpsList.getLength(); a++){
1200                             Node ipAddress = networkIpsList.item(a)
1201                             if (ipAddress.getNodeType() == Node.ELEMENT_NODE) {
1202                                 Element eElementIpAddress = (Element) ipAddress
1203                                 String ipAddressValue = utils.getElementText(eElementIpAddress, "ip-address")
1204                                 if (a != networkIpsList.getLength() - 1) {
1205                                     ipAddressValues = sb2.append(ipAddressValue + ",")
1206                                 }
1207                                 else {
1208                                     ipAddressValues = sb2.append(ipAddressValue);
1209                                 }
1210                                 networkPosition = a.toString()
1211                                 String vmNetworksPositionsXml =
1212                                                 """<entry>
1213                                                                                 <key>${MsoUtils.xmlEscape(key)}_${MsoUtils.xmlEscape(networkKey)}_ip_${MsoUtils.xmlEscape(networkPosition)}</key>
1214                                                                                 <value>${MsoUtils.xmlEscape(ipAddressValue)}</value>
1215                                                                         </entry>"""
1216                                 vmNetworksPositions = sbNetworksPositions.append(vmNetworksPositionsXml)
1217                             }
1218                         }
1219                         vmNetworksPositions = sbNetworksPositions.append(floatingIpKeyValueStr).append(floatingIpV6KeyValueStr)
1220
1221                         String vmNetworksXml =
1222                                         """<entry>
1223                                                                 <key>${MsoUtils.xmlEscape(key)}_${MsoUtils.xmlEscape(networkKey)}_ips</key>
1224                                                                 <value>${MsoUtils.xmlEscape(ipAddressValues)}</value>
1225                                                         </entry>"""
1226                         vmNetworks = sbVmNetworks.append(vmNetworksXml)
1227
1228                         NodeList interfaceRoutePrefixesList = eElementNetworkKey.getElementsByTagNameNS("*","interface-route-prefixes")
1229                         String interfaceRoutePrefixValues = sb3.append("[")
1230
1231                         for(int a = 0; a < interfaceRoutePrefixesList.getLength(); a++){
1232                             Node interfaceRoutePrefix = interfaceRoutePrefixesList.item(a)
1233                             if (interfaceRoutePrefix.getNodeType() == Node.ELEMENT_NODE) {
1234                                 Element eElementInterfaceRoutePrefix = (Element) interfaceRoutePrefix
1235                                 String interfaceRoutePrefixValue = utils.getElementText(eElementInterfaceRoutePrefix, "interface-route-prefix-cidr")
1236                                 if (interfaceRoutePrefixValue == null || interfaceRoutePrefixValue.isEmpty()) {
1237                                     interfaceRoutePrefixValue = utils.getElementText(eElementInterfaceRoutePrefix, "interface-route-prefix")
1238                                 }
1239                                 if (a != interfaceRoutePrefixesList.getLength() - 1) {
1240                                     interfaceRoutePrefixValues = sb3.append("{\"interface_route_table_routes_route_prefix\": \"" + interfaceRoutePrefixValue + "\"}" + ",")
1241                                 }
1242                                 else {
1243                                     interfaceRoutePrefixValues = sb3.append("{\"interface_route_table_routes_route_prefix\": \"" + interfaceRoutePrefixValue + "\"}")
1244                                 }
1245                             }
1246                         }
1247                         interfaceRoutePrefixValues = sb3.append("]")
1248                         if (interfaceRoutePrefixesList.getLength() > 0) {
1249                             String interfaceRoutePrefixesXml =
1250                                             """<entry>
1251                                                                                         <key>${MsoUtils.xmlEscape(key)}_${MsoUtils.xmlEscape(networkKey)}_route_prefixes</key>
1252                                                                                         <value>${MsoUtils.xmlEscape(interfaceRoutePrefixValues)}</value>
1253                                                                                 </entry>"""
1254                             interfaceRoutePrefixes = sbInterfaceRoutePrefixes.append(interfaceRoutePrefixesXml)
1255                         }
1256
1257                         NodeList networkIpsV6List = eElementNetworkKey.getElementsByTagNameNS("*","network-ips-v6")
1258                         for(int a = 0; a < networkIpsV6List.getLength(); a++){
1259                             Node ipV6Address = networkIpsV6List.item(a)
1260                             if (ipV6Address.getNodeType() == Node.ELEMENT_NODE) {
1261                                 Element eElementIpV6Address = (Element) ipV6Address
1262                                 String ipV6AddressValue = utils.getElementText(eElementIpV6Address, "ip-address-ipv6")
1263                                 if (a != networkIpsV6List.getLength() - 1) {
1264                                     ipV6AddressValues = sb4.append(ipV6AddressValue + ",")
1265                                 }
1266                                 else {
1267                                     ipV6AddressValues = sb4.append(ipV6AddressValue);
1268                                 }
1269                                 networkPosition = a.toString()
1270                                 String vmNetworksPositionsV6Xml =
1271                                                 """<entry>
1272                                                                                 <key>${MsoUtils.xmlEscape(key)}_${MsoUtils.xmlEscape(networkKey)}_v6_ip_${MsoUtils.xmlEscape(networkPosition)}</key>
1273                                                                                 <value>${MsoUtils.xmlEscape(ipV6AddressValue)}</value>
1274                                                                                 </entry>"""
1275                                 vmNetworksPositionsV6 = sbNetworksPositionsV6.append(vmNetworksPositionsV6Xml)
1276                             }
1277                         }
1278                         String vmNetworksV6Xml =
1279                                         """<entry>
1280                                                                 <key>${MsoUtils.xmlEscape(key)}_${MsoUtils.xmlEscape(networkKey)}_v6_ips</key>
1281                                                                 <value>${MsoUtils.xmlEscape(ipV6AddressValues)}</value>
1282                                                         </entry>"""
1283                         vmNetworks = sbVmNetworks.append(vmNetworksV6Xml)
1284                     }
1285                 }
1286                 String vnfXml =
1287                                 """<entry>
1288                                 <key>${MsoUtils.xmlEscape(key)}_names</key>
1289                                 <value>${MsoUtils.xmlEscape(values)}</value>
1290                                         </entry>"""
1291                 vnfVMS = sb.append(vnfXml)
1292             }
1293         }
1294         //SDNC Response Params
1295         String sdncResponseParams = ""
1296         List<String> sdncResponseParamsToSkip = [
1297             "vnf_id",
1298             "vf_module_id",
1299             "vnf_name",
1300             "vf_module_name"
1301         ]
1302         String vnfParamsChildNodes = utils.getChildNodes(data, "vnf-parameters")
1303         if(vnfParamsChildNodes == null || vnfParamsChildNodes.length() < 1){
1304             // No SDNC params
1305         }else{
1306             NodeList paramsList = responseXml.getElementsByTagNameNS("*", "vnf-parameters")
1307             for (int z = 0; z < paramsList.getLength(); z++) {
1308                 Node node = paramsList.item(z)
1309                 Element eElement = (Element) node
1310                 String vnfParameterName = utils.getElementText(eElement, "vnf-parameter-name")
1311                 if (!sdncResponseParamsToSkip.contains(vnfParameterName)) {
1312                     String vnfParameterValue = utils.getElementText(eElement, "vnf-parameter-value")
1313                     String paraEntry =
1314                                     """<entry>
1315                                                         <key>${MsoUtils.xmlEscape(vnfParameterName)}</key>
1316                                                         <value>${MsoUtils.xmlEscape(vnfParameterValue)}</value>
1317                                                 </entry>"""
1318                     sdncResponseParams = sb.append(paraEntry)
1319                 }
1320             }
1321         }
1322
1323
1324         def vfModuleParams = """
1325                 ${vnfInfo}
1326                 ${aZones}
1327                 ${vnfNetworkNetId}
1328                 ${vnfNetworkNetName}
1329                 ${vnfNetworkSubNetId}
1330                 ${vnfNetworkV6SubNetId}
1331                 ${vnfNetworkNetFqdn}
1332                 ${vnfNetworksSriovVlanFilters}
1333         ${vnfVMS}
1334         ${vnfVMSPositions}
1335                 ${vmNetworks}
1336                 ${vmNetworksPositions}
1337                 ${vmNetworksPositionsV6}
1338                 ${interfaceRoutePrefixes}
1339                 ${vnfParams}
1340                 ${sdncResponseParams}"""
1341
1342         return vfModuleParams
1343
1344     }
1345
1346 }