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