bpmn/MSOCommonBPMN/src/main/groovy/org/openecomp/mso/bpmn/common/scripts/NetworkUtils.groovy

   1 /*-\r
   2  * ============LICENSE_START=======================================================\r
   3  * OPENECOMP - MSO\r
   4  * ================================================================================\r
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.\r
   6  * ================================================================================\r
   7  * Licensed under the Apache License, Version 2.0 (the "License");\r
   8  * you may not use this file except in compliance with the License.\r
   9  * You may obtain a copy of the License at\r
  10  * \r
  11  *      http://www.apache.org/licenses/LICENSE-2.0\r
  12  * \r
  13  * Unless required by applicable law or agreed to in writing, software\r
  14  * distributed under the License is distributed on an "AS IS" BASIS,\r
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  16  * See the License for the specific language governing permissions and\r
  17  * limitations under the License.\r
  18  * ============LICENSE_END=========================================================\r
  19  */\r
  20 \r
  21 package org.openecomp.mso.bpmn.common.scripts;\r
  22 \r
  23 import org.apache.commons.lang3.*\r
  24 \r
  25 import groovy.xml.XmlUtil\r
  26 \r
  27 import javax.xml.parsers.DocumentBuilder\r
  28 import javax.xml.parsers.DocumentBuilderFactory\r
  29 import javax.xml.transform.Transformer\r
  30 import javax.xml.transform.TransformerFactory\r
  31 import javax.xml.transform.TransformerException\r
  32 import javax.xml.transform.dom.DOMSource\r
  33 import javax.xml.transform.stream.StreamResult\r
  34 \r
  35 import org.camunda.bpm.engine.delegate.BpmnError\r
  36 import org.camunda.bpm.engine.runtime.Execution\r
  37 import org.w3c.dom.Document\r
  38 import org.w3c.dom.Element\r
  39 \r
  40 import org.w3c.dom.NamedNodeMap\r
  41 import org.w3c.dom.Node\r
  42 import org.w3c.dom.NodeList;\r
  43 import org.xml.sax.InputSource\r
  44 \r
  45 import org.camunda.bpm.engine.delegate.BpmnError\r
  46 import org.camunda.bpm.engine.runtime.Execution\r
  47 import org.openecomp.mso.bpmn.common.scripts.AbstractServiceTaskProcessor;\r
  48 import org.w3c.dom.Document\r
  49 import org.w3c.dom.Element\r
  50 import org.w3c.dom.NamedNodeMap\r
  51 import org.w3c.dom.Node\r
  52 import org.w3c.dom.NodeList;\r
  53 import org.xml.sax.InputSource\r
  54 \r
  55 \r
  56 /**\r
  57  * This groovy class supports the any Network processes that need the methods defined here.\r
  58  */\r
  59 class NetworkUtils {\r
  60 \r
  61         public MsoUtils utils = new MsoUtils()\r
  62         private AbstractServiceTaskProcessor taskProcessor\r
  63 \r
  64         public NetworkUtils(AbstractServiceTaskProcessor taskProcessor) {\r
  65                 this.taskProcessor = taskProcessor\r
  66         }\r
  67 \r
  68         /**\r
  69          * This method returns the string for Network request\r
  70          * V2 for Contrail 3.x will populate cloud-region data in same cloudSiteId filed\r
  71          * Network adapter will handle it properly\r
  72          * @param requestId either 'request-id' or 'mso-request-id'\r
  73          * @param requestInput the request in the process\r
  74          * @param queryIdResponse the response of REST AAI query by Id\r
  75          * @param routeCollection the collection\r
  76          * @param policyFqdns the policy \r
  77          * @param tableCollection the collection\r
  78          * @param cloudRegionId the cloud-region-region\r
  79          * @return String request\r
  80          */\r
  81         def CreateNetworkRequestV2(execution, requestId, messageId, requestInput, queryIdResponse, routeCollection, policyFqdns, tableCollection, cloudRegionId, backoutOnFailure, source) {\r
  82                 String createNetworkRequest = null\r
  83                 if(requestInput!=null && queryIdResponse!=null) {\r
  84                                 String serviceInstanceId = ""\r
  85                                 String sharedValue = ""\r
  86                                 String externalValue = ""\r
  87                         \r
  88                                 if (source == "VID") {\r
  89                                         sharedValue = utils.getNodeText1(queryIdResponse, "is-shared-network") != null ? utils.getNodeText1(queryIdResponse, "is-shared-network") : "false"\r
  90                                         externalValue = utils.getNodeText1(queryIdResponse, "is-external-network") != null ? utils.getNodeText1(queryIdResponse, "is-external-network") : "false"\r
  91                                         serviceInstanceId = utils.getNodeText1(requestInput, "service-instance-id")\r
  92                                         \r
  93                                 } else { // source = 'PORTAL'\r
  94                                         sharedValue = getParameterValue(requestInput, "shared")\r
  95                                         externalValue = getParameterValue(requestInput, "external")\r
  96                                         serviceInstanceId = utils.getNodeText1(requestInput, "service-instance-id") != null ? utils.getNodeText1(requestInput, "service-instance-id") : ""\r
  97                                 }\r
  98 \r
  99                                 String networkParams = ""\r
 100                                 if (utils.nodeExists(requestInput, "network-params")) {\r
 101                                         String netParams = utils.getNodeXml(requestInput, "network-params", false).replace("tag0:","").replace(":tag0","")\r
 102                                         networkParams = buildParams(netParams)\r
 103                                 }\r
 104                                                                         \r
 105                                 String failIfExists = "false"\r
 106                                 // requestInput\r
 107                                 String cloudRegion = cloudRegionId\r
 108                                 String tenantId = utils.getNodeText1(requestInput, "tenant-id")\r
 109                                 String networkType = ""\r
 110                                 if (utils.nodeExists(requestInput, "networkModelInfo")) {\r
 111                                         String networkModelInfo = utils.getNodeXml(requestInput, "networkModelInfo", false).replace("tag0:","").replace(":tag0","")\r
 112                                         networkType = utils.getNodeText1(networkModelInfo, "modelName")\r
 113                                 } else {\r
 114                                     networkType = utils.getNodeText1(queryIdResponse, "network-type")\r
 115                                 }\r
 116                                 \r
 117                                 // queryIdResponse\r
 118                                 String networkName = utils.getNodeText1(queryIdResponse, "network-name")\r
 119                                 String networkId = utils.getNodeText1(queryIdResponse, "network-id")\r
 120                                 String networkTechnology = utils.getNodeText1(queryIdResponse, "network-technology")\r
 121                                 \r
 122                                 // contrailNetwork - networkTechnology = 'Contrail' vs. 'AIC_SR_IOV')\r
 123                                 String contrailNetwork = ""\r
 124                                 if (networkTechnology.contains('Contrail') || networkTechnology.contains('contrail') || networkTechnology.contains('CONTRAIL')) {\r
 125                                         contrailNetwork = """<contrailNetwork>\r
 126                                                                <shared>${sharedValue}</shared>\r
 127                                                                <external>${externalValue}</external>\r
 128                                                                ${routeCollection}\r
 129                                                                ${policyFqdns}\r
 130                                                                ${tableCollection}\r
 131                                                          </contrailNetwork>"""\r
 132                                         networkTechnology = "CONTRAIL"    // replace\r
 133                             }\r
 134                                                                 \r
 135                                 // rebuild subnets\r
 136                                 String subnets = ""\r
 137                                 if (utils.nodeExists(queryIdResponse, "subnets")) {\r
 138                                         def subnetsGroup = utils.getNodeXml(queryIdResponse, "subnets", false)\r
 139                                         subnets = buildSubnets(subnetsGroup)\r
 140                                 }\r
 141 \r
 142                                 String physicalNetworkName = ""\r
 143                                 physicalNetworkName = utils.getNodeText1(queryIdResponse, "physical-network-name") \r
 144                                 \r
 145                                 String vlansCollection = buildVlans(queryIdResponse)\r
 146                                 \r
 147                                 String notificationUrl = ""                                   //TODO - is this coming from URN? What variable/value to use?\r
 148                                 //String notificationUrl = execution.getVariable("URN_?????") //TODO - is this coming from URN? What variable/value to use?\r
 149 \r
 150                                 createNetworkRequest = """\r
 151                                                                 <createNetworkRequest>\r
 152                                                                         <cloudSiteId>${cloudRegion}</cloudSiteId>\r
 153                                                                         <tenantId>${tenantId}</tenantId>\r
 154                                                                         <networkId>${networkId}</networkId>\r
 155                                                                         <networkName>${networkName}</networkName>\r
 156                                                                         <networkType>${networkType}</networkType>\r
 157                                                                         <modelCustomizationUuid>${modelCustomizationUuid}</modelCustomizationUuid>\r
 158                                                                         <networkTechnology>${networkTechnology}</networkTechnology>\r
 159                                                                         <providerVlanNetwork>\r
 160                                                                                 <physicalNetworkName>${physicalNetworkName}</physicalNetworkName >\r
 161                                                                                 ${vlansCollection}\r
 162                                                                         </providerVlanNetwork>\r
 163                                     ${contrailNetwork}\r
 164                                                                         ${subnets}\r
 165                                                                         <skipAAI>true</skipAAI>\r
 166                                                                         <backout>${backoutOnFailure}</backout>\r
 167                                                                         <failIfExists>${failIfExists}</failIfExists>\r
 168                                                                         ${networkParams}        \r
 169                                                                         <msoRequest>\r
 170                                                                                 <requestId>${requestId}</requestId>\r
 171                                                                                 <serviceInstanceId>${serviceInstanceId}</serviceInstanceId>\r
 172                                                                 </msoRequest>\r
 173                                                                         <messageId>${messageId}</messageId>\r
 174                                                                         <notificationUrl>${notificationUrl}</notificationUrl>\r
 175                                                                 </createNetworkRequest>\r
 176                                                                 """.trim()\r
 177                 }\r
 178                 return createNetworkRequest\r
 179                 \r
 180         }\r
 181         \r
 182         /**\r
 183          * This method returns the string for Network request\r
 184          * V2 for Contrail 3.x will populate cloud-region data in same cloudSiteId filed\r
 185          * Network adapter will handle it properly\r
 186          * @param requestId either 'request-id' or 'mso-request-id'\r
 187          * @param requestInput the request in the process\r
 188          * @param queryIdResponse the response of REST AAI query by Id\r
 189          * @param routeCollection the collection\r
 190          * @param policyFqdns the policy\r
 191          * @param cloudRegionId the cloud-region-region\r
 192          * @return String request\r
 193          */\r
 194         def UpdateNetworkRequestV2(execution, requestId, messageId, requestInput, queryIdResponse, routeCollection, policyFqdns, tableCollection, cloudRegionId, backoutOnFailure, source) {\r
 195                 String updateNetworkRequest = null\r
 196                 if(requestInput!=null && queryIdResponse!=null) {\r
 197                                 String serviceInstanceId = ""\r
 198                                 String sharedValue = ""\r
 199                                 String externalValue = ""\r
 200                         \r
 201                                 if (source == "VID") {\r
 202                                         sharedValue = utils.getNodeText1(queryIdResponse, "is-shared-network") != null ? utils.getNodeText1(queryIdResponse, "is-shared-network") : "false"\r
 203                                         externalValue = utils.getNodeText1(queryIdResponse, "is-external-network") != null ? utils.getNodeText1(queryIdResponse, "is-external-network") : "false"\r
 204                                         serviceInstanceId = utils.getNodeText1(requestInput, "service-instance-id")\r
 205                                         \r
 206                                 } else { // source = 'PORTAL'\r
 207                                         sharedValue = getParameterValue(requestInput, "shared")\r
 208                                         externalValue = getParameterValue(requestInput, "external")\r
 209                                         serviceInstanceId = utils.getNodeText1(requestInput, "service-instance-id") != null ? utils.getNodeText1(requestInput, "service-instance-id") : ""\r
 210                                 }\r
 211                                                                 \r
 212                                 String failIfExists = "false"\r
 213                                 // requestInput\r
 214                                 String cloudRegion = cloudRegionId\r
 215                                 String tenantId = utils.getNodeText1(requestInput, "tenant-id")\r
 216 \r
 217                                 // queryIdResponse\r
 218                                 String networkName = utils.getNodeText1(queryIdResponse, "network-name")\r
 219                                 String networkId = utils.getNodeText1(queryIdResponse, "network-id")\r
 220                                 \r
 221                                 String networkType = ""\r
 222                                 String modelCustomizationUuid = ""\r
 223                                 if (utils.nodeExists(requestInput, "networkModelInfo")) {\r
 224                                         String networkModelInfo = utils.getNodeXml(requestInput, "networkModelInfo", false).replace("tag0:","").replace(":tag0","")\r
 225                                         networkType = utils.getNodeText1(networkModelInfo, "modelName")\r
 226                                         modelCustomizationUuid = utils.getNodeText1(networkModelInfo, "modelCustomizationUuid")\r
 227                                 } else {\r
 228                                         networkType = utils.getNodeText1(queryIdResponse, "network-type")\r
 229                                 }\r
 230 \r
 231 \r
 232                                 // rebuild subnets\r
 233                                 String subnets = ""\r
 234                                 if (utils.nodeExists(queryIdResponse, "subnets")) {\r
 235                                         def subnetsGroup = utils.getNodeXml(queryIdResponse, "subnets", false)\r
 236                                         subnets = buildSubnets(subnetsGroup)\r
 237                                 }\r
 238 \r
 239                                 String networkParams = ""\r
 240                                 if (utils.nodeExists(requestInput, "network-params")) {\r
 241                                         String netParams = utils.getNodeXml(requestInput, "network-params", false).replace("tag0:","").replace(":tag0","")\r
 242                                         networkParams = buildParams(netParams)\r
 243                                 }\r
 244                                         \r
 245                                 String networkStackId = utils.getNodeText1(queryIdResponse, "heat-stack-id")\r
 246                                 if (networkStackId == 'null' || networkStackId == "" || networkStackId == null) {\r
 247                                         networkStackId = "force_update"\r
 248                                 }\r
 249                                 \r
 250                                 String physicalNetworkName = utils.getNodeText1(queryIdResponse, "physical-network-name")\r
 251                                 String vlansCollection = buildVlans(queryIdResponse)\r
 252                                 \r
 253                                 updateNetworkRequest = \r
 254                          """<updateNetworkRequest>\r
 255                                                                 <cloudSiteId>${cloudRegion}</cloudSiteId>\r
 256                                                                 <tenantId>${tenantId}</tenantId>\r
 257                                                                 <networkId>${networkId}</networkId>\r
 258                                                         <networkStackId>${networkStackId}</networkStackId>\r
 259                                                                 <networkName>${networkName}</networkName>\r
 260                                                                 <networkType>${networkType}</networkType>\r
 261                                                                 <modelCustomizationUuid>${modelCustomizationUuid}</modelCustomizationUuid>\r
 262                                                                 <networkTypeVersion/>\r
 263                                                                 <networkTechnology>CONTRAIL</networkTechnology>\r
 264                                                                 <providerVlanNetwork>\r
 265                                                                         <physicalNetworkName>${physicalNetworkName}</physicalNetworkName>\r
 266                                                                         ${vlansCollection}\r
 267                                                                 </providerVlanNetwork>\r
 268                                                                 <contrailNetwork>\r
 269                                                                         <shared>${sharedValue}</shared>\r
 270                                                                         <external>${externalValue}</external>\r
 271                                                                         ${routeCollection}\r
 272                                                                         ${policyFqdns}\r
 273                                                                         ${tableCollection}\r
 274                                                                 </contrailNetwork>\r
 275                                                                 ${subnets}\r
 276                                                                 <skipAAI>true</skipAAI>\r
 277                                                                 <backout>${backoutOnFailure}</backout>\r
 278                                                                 <failIfExists>${failIfExists}</failIfExists>\r
 279                                                                         ${networkParams}        \r
 280 \r
 281                                                                 <msoRequest>\r
 282                                                                   <requestId>${requestId}</requestId>\r
 283                                                                   <serviceInstanceId>${serviceInstanceId}</serviceInstanceId>\r
 284                                                                 </msoRequest>\r
 285                                                                 <messageId>${messageId}</messageId>\r
 286                                                                 <notificationUrl></notificationUrl>\r
 287                                                         </updateNetworkRequest>""".trim()\r
 288                                                    \r
 289                 }\r
 290                 return updateNetworkRequest\r
 291                 \r
 292         }\r
 293 \r
 294         /**\r
 295          * This method returns the string for Create Volume Request payload\r
 296          * @param groupId the volume-group-id\r
 297          * @param volumeName the volume-group-name\r
 298          * @param vnfType the vnf-type\r
 299          * @param tenantId the value of relationship-key 'tenant.tenant-id'\r
 300          * @return String request payload\r
 301          */\r
 302         def String CreateNetworkVolumeRequest(groupId, volumeName, vnfType, tenantId) {\r
 303 \r
 304                 String requestPayload =\r
 305                 """<volume-group xmlns="http://org.openecomp.mso/v6">\r
 306                                 <volume-group-id>${groupId}</volume-group-id>\r
 307                                 <volume-group-name>${volumeName}</volume-group-name>\r
 308                                 <heat-stack-id></heat-stack-id>\r
 309                                 <vnf-type>${vnfType}</vnf-type>\r
 310                                 <orchestration-status>Pending</orchestration-status>\r
 311                                 <relationship-list>\r
 312                                    <relationship>\r
 313                                            <related-to>tenant</related-to>\r
 314                                            <relationship-data>\r
 315                                                    <relationship-key>tenant.tenant-id</relationship-key>\r
 316                                                    <relationship-value>${tenantId}</relationship-value>\r
 317                                            </relationship-data>\r
 318                                    </relationship>\r
 319                            </relationship-list>\r
 320                    </volume-group>"""\r
 321 \r
 322                 return requestPayload\r
 323         }\r
 324 \r
 325         def String createCloudRegionVolumeRequest(groupId, volumeName, vnfType, tenantId, cloudRegion, namespace, modelCustomizationId) {\r
 326 \r
 327                                 String requestPayload =\r
 328                                 """<volume-group xmlns="${namespace}">\r
 329                                 <volume-group-id>${groupId}</volume-group-id>\r
 330                                 <volume-group-name>${volumeName}</volume-group-name>\r
 331                                 <heat-stack-id></heat-stack-id>\r
 332                                 <vnf-type>${vnfType}</vnf-type>\r
 333                                 <orchestration-status>Pending</orchestration-status>\r
 334                                 <vf-module-persona-model-customization-id>${modelCustomizationId}</vf-module-persona-model-customization-id>\r
 335                                 <relationship-list>\r
 336                                    <relationship>\r
 337                                            <related-to>tenant</related-to>\r
 338                                            <relationship-data>\r
 339                                                    <relationship-key>tenant.tenant-id</relationship-key>\r
 340                                                    <relationship-value>${tenantId}</relationship-value>\r
 341                                            </relationship-data>\r
 342                                            <relationship-data>\r
 343                                                    <relationship-key>cloud-region.cloud-owner</relationship-key>\r
 344                                                    <relationship-value>att-aic</relationship-value>\r
 345                                            </relationship-data>\r
 346                                            <relationship-data>\r
 347                                                    <relationship-key>cloud-region.cloud-region-id</relationship-key>\r
 348                                                    <relationship-value>${cloudRegion}</relationship-value>\r
 349                                            </relationship-data>\r
 350                                    </relationship>\r
 351                            </relationship-list>\r
 352                    </volume-group>"""\r
 353 \r
 354                                 return requestPayload\r
 355                         }\r
 356         \r
 357         def String createCloudRegionVolumeRequest(groupId, volumeName, vnfType, vnfId, tenantId, cloudRegion, namespace, modelCustomizationId) {\r
 358                 \r
 359                 String requestPayload =\r
 360                 """<volume-group xmlns="${namespace}">\r
 361                         <volume-group-id>${groupId}</volume-group-id>\r
 362                         <volume-group-name>${volumeName}</volume-group-name>\r
 363                         <heat-stack-id></heat-stack-id>\r
 364                         <vnf-type>${vnfType}</vnf-type>\r
 365                         <orchestration-status>Pending</orchestration-status>\r
 366                         <vf-module-persona-model-customization-id>${modelCustomizationId}</vf-module-persona-model-customization-id>\r
 367                         <relationship-list>\r
 368                                 <relationship>\r
 369                                    <related-to>generic-vnf</related-to>\r
 370                                    <relationship-data>\r
 371                                            <relationship-key>generic-vnf.vnf-id</relationship-key>\r
 372                                            <relationship-value>${vnfId}</relationship-value>\r
 373                                    </relationship-data>\r
 374                            </relationship>\r
 375                            <relationship>\r
 376                                    <related-to>tenant</related-to>\r
 377                                    <relationship-data>\r
 378                                            <relationship-key>tenant.tenant-id</relationship-key>\r
 379                                            <relationship-value>${tenantId}</relationship-value>\r
 380                                    </relationship-data>\r
 381                                    <relationship-data>\r
 382                                            <relationship-key>cloud-region.cloud-owner</relationship-key>\r
 383                                            <relationship-value>att-aic</relationship-value>\r
 384                                    </relationship-data>\r
 385                                    <relationship-data>\r
 386                                            <relationship-key>cloud-region.cloud-region-id</relationship-key>\r
 387                                            <relationship-value>${cloudRegion}</relationship-value>\r
 388                                    </relationship-data>\r
 389                            </relationship>\r
 390                    </relationship-list>\r
 391                 </volume-group>"""\r
 392         \r
 393                 return requestPayload\r
 394         }\r
 395 \r
 396 \r
 397         /**\r
 398          * This method returns the string for Update Volume Request payload\r
 399          * @param requeryAAIVolGrpNameResponse the response of query volume group name (in AAI)\r
 400           * @param heatStackId the value of heat stack id\r
 401          * @return String request payload\r
 402          */\r
 403         def String updateCloudRegionVolumeRequest(requeryAAIVolGrpNameResponse, heatStackId, namespace, modelCustomizationId) {\r
 404                 String requestPayload = ""\r
 405                 if (requeryAAIVolGrpNameResponse != null) {\r
 406                         def groupId = utils.getNodeText(requeryAAIVolGrpNameResponse, "volume-group-id")\r
 407                         def volumeName = utils.getNodeText(requeryAAIVolGrpNameResponse, "volume-group-name")\r
 408                         def vnfType = utils.getNodeText(requeryAAIVolGrpNameResponse, "vnf-type")\r
 409                         def resourceVersion = utils.getNodeText(requeryAAIVolGrpNameResponse, "resource-version")\r
 410                         def relationshipList = ""\r
 411                         if (utils.nodeExists(requeryAAIVolGrpNameResponse, "relationship")) {\r
 412                                 relationshipList = rebuildRelationship(requeryAAIVolGrpNameResponse)\r
 413                         }\r
 414 \r
 415                         requestPayload =\r
 416                                 """<volume-group xmlns="${namespace}">\r
 417                                         <volume-group-id>${groupId}</volume-group-id>\r
 418                                         <volume-group-name>${volumeName}</volume-group-name>\r
 419                                         <heat-stack-id>${heatStackId}</heat-stack-id>\r
 420                                         <vnf-type>${vnfType}</vnf-type>\r
 421                                         <orchestration-status>Active</orchestration-status>\r
 422                                         <resource-version>${resourceVersion}</resource-version>\r
 423                                         <vf-module-persona-model-customization-id>${modelCustomizationId}</vf-module-persona-model-customization-id>\r
 424                                         ${relationshipList}\r
 425                                  </volume-group>"""\r
 426                 }\r
 427 \r
 428                 return requestPayload\r
 429         }\r
 430 \r
 431 \r
 432         /**\r
 433          * This method returns the string for Update Volume Request payload\r
 434          * @param requeryAAIVolGrpNameResponse the response of query volume group name (in AAI)\r
 435          * @param heatStackId the value of heat stack id\r
 436          * @return String request payload\r
 437          */\r
 438         def String UpdateNetworkVolumeRequest(requeryAAIVolGrpNameResponse, heatStackId) {\r
 439                 String requestPayload = ""\r
 440                 if (requeryAAIVolGrpNameResponse != null) {\r
 441                         def groupId = utils.getNodeText(requeryAAIVolGrpNameResponse, "volume-group-id")\r
 442                         def volumeName = utils.getNodeText(requeryAAIVolGrpNameResponse, "volume-group-name")\r
 443                         def vnfType = utils.getNodeText(requeryAAIVolGrpNameResponse, "vnf-type")\r
 444                         def resourceVersion = utils.getNodeText(requeryAAIVolGrpNameResponse, "resource-version")\r
 445                         def relationshipList = ""\r
 446                         if (utils.nodeExists(requeryAAIVolGrpNameResponse, "relationship")) {\r
 447                                 relationshipList = rebuildRelationship(requeryAAIVolGrpNameResponse)\r
 448                         }\r
 449 \r
 450                         requestPayload =\r
 451                                 """<volume-group xmlns="http://org.openecomp.mso/v6">\r
 452                                         <volume-group-id>${groupId}</volume-group-id>\r
 453                                         <volume-group-name>${volumeName}</volume-group-name>\r
 454                                         <heat-stack-id>${heatStackId}</heat-stack-id>\r
 455                                         <vnf-type>${vnfType}</vnf-type>\r
 456                                         <orchestration-status>Active</orchestration-status>\r
 457                                         <resource-version>${resourceVersion}</resource-version>\r
 458                                         ${relationshipList}\r
 459                                  </volume-group>"""\r
 460                 }\r
 461 \r
 462                 return requestPayload\r
 463         }\r
 464 \r
 465         /**\r
 466          * This method returns the string for Create Contrail Network payload\r
 467          * @param requeryIdAAIResponse the response from AAI query by id\r
 468          * @param createNetworkResponse the response of create network\r
 469          * @return String contrailNetworkCreatedUpdate\r
 470          */\r
 471         def ContrailNetworkCreatedUpdate(requeryIdAAIResponse, createNetworkResponse, schemaVersion) {\r
 472 \r
 473                 String contrailNetworkCreatedUpdate = ""\r
 474                 if(requeryIdAAIResponse!=null && createNetworkResponse!=null) {\r
 475 \r
 476                         def l3Network = utils.getNodeXml(requeryIdAAIResponse, "l3-network", false).replace("tag0:","").replace(":tag0","")\r
 477                         def createNetworkContrailResponse = ""\r
 478                         if (utils.nodeExists(createNetworkResponse, 'createNetworkResponse')) {\r
 479                            createNetworkContrailResponse = utils.getNodeXml(createNetworkResponse, "createNetworkResponse", false).replace("tag0:","").replace(":tag0","")\r
 480                         } else {\r
 481                            createNetworkContrailResponse = utils.getNodeXml(createNetworkResponse, "updateNetworkContrailResponse", false).replace("tag0:","").replace(":tag0","")\r
 482                         }\r
 483                            \r
 484                         // rebuild network\r
 485                         def networkList = ["network-id", "network-name", "network-type", "network-role", "network-technology", "neutron-network-id", "is-bound-to-vpn", "service-id", "network-role-instance", "resource-version", "resource-model-uuid", "orchestration-status", "heat-stack-id", "mso-catalog-key", "contrail-network-fqdn",\r
 486                                                              "physical-network-name", "is-provider-network", "is-shared-network", "is-external-network"]\r
 487                         String rebuildNetworkElements = buildNetworkElements(l3Network, createNetworkContrailResponse, networkList)\r
 488 \r
 489                         // rebuild 'subnets'\r
 490                         def rebuildSubnetList = ""\r
 491                         if (utils.nodeExists(requeryIdAAIResponse, 'subnet')) {\r
 492                              rebuildSubnetList = buildSubnets(requeryIdAAIResponse, createNetworkResponse)\r
 493                         }\r
 494 \r
 495                         // rebuild 'segmentation-assignments'\r
 496                         def rebuildSegmentationAssignments = ""\r
 497                         if (utils.nodeExists(requeryIdAAIResponse, 'segmentation-assignments')) {\r
 498                                 List elementList = ["segmentation-id"]  \r
 499                                 rebuildSegmentationAssignments =  buildXMLElements(requeryIdAAIResponse, "", "segmentation-assignments", elementList)\r
 500                         }\r
 501                         \r
 502                         // rebuild 'ctag-assignments' / rebuildCtagAssignments\r
 503                         def rebuildCtagAssignmentsList = ""\r
 504                         if (utils.nodeExists(requeryIdAAIResponse, 'ctag-assignment')) {\r
 505                                 rebuildCtagAssignmentsList = rebuildCtagAssignments(requeryIdAAIResponse)\r
 506                         }\r
 507 \r
 508                         // rebuild 'relationship'\r
 509                         def relationshipList = ""\r
 510                         if (utils.nodeExists(requeryIdAAIResponse, 'relationship-list')) {\r
 511                                 String rootRelationshipData = getFirstNodeXml(requeryIdAAIResponse, "relationship-list").drop(38).trim().replace("tag0:","").replace(":tag0","")\r
 512                                 if (utils.nodeExists(rootRelationshipData, 'relationship')) {\r
 513                                         relationshipList = rebuildRelationship(rootRelationshipData)\r
 514                                 }\r
 515                         }\r
 516 \r
 517                         //Check for optional contrail network fqdn within CreateNetworkResponse\r
 518                         String contrailNetworkFQDN\r
 519                         if(utils.nodeExists(createNetworkResponse, "contrail-network-fqdn")){\r
 520                                 contrailNetworkFQDN = utils.getNodeXml(createNetworkResponse, "contrail-network-fqdn")\r
 521                                 contrailNetworkFQDN = utils.removeXmlNamespaces(contrailNetworkFQDN)\r
 522                                 contrailNetworkFQDN = utils.removeXmlPreamble(contrailNetworkFQDN)\r
 523                         }else{\r
 524                                 contrailNetworkFQDN = ""\r
 525                         }\r
 526 \r
 527                         contrailNetworkCreatedUpdate =\r
 528                                  """<l3-network xmlns="${schemaVersion}">\r
 529                                                 ${rebuildNetworkElements}\r
 530                                                 ${rebuildSubnetList}\r
 531                                                 ${rebuildSegmentationAssignments}\r
 532                                                 ${rebuildCtagAssignmentsList}\r
 533                                                 ${relationshipList}\r
 534                                                 ${contrailNetworkFQDN}\r
 535                                       </l3-network>""".trim()\r
 536 \r
 537                 }\r
 538                         return contrailNetworkCreatedUpdate\r
 539         }\r
 540 \r
 541         \r
 542         \r
 543         /**\r
 544          * This method returns the value for the name paramName.\r
 545          *   Ex:   <network-params>\r
 546          *            <param name="shared">1</param>\r
 547          *            <param name="external">0</external>\r
 548          *         </network-params>\r
 549          *\r
 550          * @param xmlInput the XML document\r
 551          * @param paramName the param name (ex: 'shared')\r
 552          * @return a param value for 'shared' (ex: '1')\r
 553          */\r
 554         def getParameterValue(xmlInput, paramName) {\r
 555                 def rtn=""\r
 556                 if(xmlInput!=null){\r
 557                         def xml= new XmlSlurper().parseText(xmlInput)\r
 558                         rtn= xml.'**'.find {param->param.'@name'.text() == paramName}\r
 559                 }\r
 560                 if (rtn==null) {\r
 561                         return ""\r
 562                 } else {\r
 563                    return rtn\r
 564                 }\r
 565         }\r
 566 \r
 567         /**\r
 568          * This method returns the name of param if found/match with paramName.\r
 569          *   Ex:   <network-params>\r
 570          *            <param name="shared">1</param>\r
 571          *            <param name="external">0</external>\r
 572          *         </network-params>\r
 573          *\r
 574          * @param xmlInput the XML document\r
 575          * @param paramName the param name (ex: 'shared', )\r
 576          * @return a param name for 'shared' (ex: 'shared' if found)\r
 577          */\r
 578         def getParameterName(xmlInput, paramName) {\r
 579                 def rtn=""\r
 580                 if(xmlInput!=null){\r
 581                         def xml= new XmlSlurper().parseText(xmlInput)\r
 582                         try {\r
 583                                 rtn= xml.'**'.find {param->param.'@name' == paramName}.'@name'\r
 584                         } catch (Exception ex) {\r
 585                             rtn=""\r
 586                         }\r
 587                 }\r
 588                 if (rtn==null || rtn=="") {\r
 589                         return ""\r
 590                 } else {\r
 591                    return rtn\r
 592                 }\r
 593         }\r
 594 \r
 595         /**\r
 596          * This method returns the networkParams xml string.\r
 597          *   Ex: input:  \r
 598          *         <network-params>\r
 599          *            <param name="shared">1</param>\r
 600          *            <param name="external">0</external>\r
 601          *         </network-params>\r
 602          *         \r
 603          *   Sample result:\r
 604          *         <networkParams>\r
 605      *            <shared>1</shared>\r
 606      *            <external>0</external>\r
 607      *         </networkParams>\r
 608      *           \r
 609          */\r
 610         \r
 611         def buildParams(networkParams) {\r
 612                 def build = ""\r
 613                         def netParams = new XmlParser().parseText(networkParams)\r
 614                         try {\r
 615                                 def paramsList = netParams.'**'.findAll {param->param.'@name'}.'@name'\r
 616                                 if (paramsList.size() > 0) {\r
 617                                         build += "<networkParams>"\r
 618                                         for (i in 0..paramsList.size()-1) {\r
 619                         def name = netParams.'**'.find {param->param.'@name' == paramsList[i]}.'@name'\r
 620                                                 def value= netParams.'**'.find {param->param.'@name' == paramsList[i]}.text()\r
 621                                                 build += "<${name}>${value}</${name}>"\r
 622                                         }\r
 623                                         build += "</networkParams>"\r
 624                                 }       \r
 625                            \r
 626                         } catch (Exception ex) {\r
 627                                 println ' buildParams error - ' + ex.getMessage()\r
 628                                 build = ""\r
 629                         }       \r
 630                 return build\r
 631         }\r
 632         \r
 633         def getVlans(xmlInput) {\r
 634                 def rtn = ""\r
 635                 if (xmlInput!=null) {\r
 636                         def vlansList = getListWithElements(xmlInput, 'vlans')\r
 637                         def vlansListSize = vlansList.size()\r
 638                         if (vlansListSize > 0) {\r
 639                                 for (i in 0..vlansListSize-1) {\r
 640                                    rtn += '<vlans>'+vlansList[i]+'</vlans>'\r
 641                                 }\r
 642                         }\r
 643                 }\r
 644                 return rtn\r
 645 \r
 646 \r
 647         }\r
 648 \r
 649         /**\r
 650          * This method returns the uri value for the vpn bindings.\r
 651          * Return the a list of value of vpn binding in the <related-link> string.\r
 652          * Ex.\r
 653          *   <relationship-list>\r
 654          *      <relationship>\r
 655          *          <related-to>vpn-binding</related-to>\r
 656          *          <related-link>https://aai-app-e2e.test.openecomp.com:8443/aai/v6/network/vpn-bindings/vpn-binding/85f015d0-2e32-4c30-96d2-87a1a27f8017/</related-link>\r
 657          *          <relationship-data>\r
 658          *             <relationship-key>vpn-binding.vpn-id</relationship-key>\r
 659          *             <relationship-value>85f015d0-2e32-4c30-96d2-87a1a27f8017</relationship-value>\r
 660          *          </relationship-data>\r
 661          *       </relationship>\r
 662          *              <relationship>\r
 663          *              <related-to>vpn-binding</related-to>\r
 664          *                      <related-link>https://aai-ext1.test.openecomp.com:8443/aai/v6/network/vpn-bindings/vpn-binding/24a4b507-853a-4a38-99aa-05fcc54be24d/</related-link>\r
 665          *                      <relationship-data>\r
 666          *                         <relationship-key>vpn-binding.vpn-id</relationship-key>\r
 667          *                         <relationship-value>24a4b507-853a-4a38-99aa-05fcc54be24d</relationship-value>\r
 668          *                  </relationship-data>\r
 669          *                      <related-to-property>\r
 670          *                        <property-key>vpn-binding.vpn-name</property-key>\r
 671          *                        <property-value>oam_protected_net_6_MTN5_msotest1</property-value>\r
 672          *                      </related-to-property>\r
 673          *              </relationship>\r
 674          * @param xmlInput the XML document\r
 675          * @return a list of vpn binding values\r
 676          *            ex: ['aai/v6/network/vpn-bindings/vpn-binding/85f015d0-2e32-4c30-96d2-87a1a27f8017/', 'aai/v6/network/vpn-bindings/vpn-binding/c980a6ef-3b88-49f0-9751-dbad8608d0a6/']\r
 677          *\r
 678          **/\r
 679         def getVnfBindingObject(xmlInput) {\r
 680                 //def rtn = null\r
 681                 List rtn = []\r
 682                 if (xmlInput!=null) {\r
 683                         def relationshipList = getListWithElements(xmlInput, 'relationship')\r
 684                         def relationshipListSize = relationshipList.size()\r
 685                         if (relationshipListSize > 0) {\r
 686                                 for (i in 0..relationshipListSize-1) {\r
 687                                    def relationshipXml = XmlUtil.serialize(relationshipList[i])\r
 688                                    if (utils.getNodeText(relationshipXml, 'related-to') == "vpn-binding") {\r
 689                                           def relatedLink = utils.getNodeText(relationshipXml, 'related-link')\r
 690                                           if (relatedLink != null || relatedLink != "") {\r
 691                                                  rtn.add(relatedLink.substring(relatedLink.indexOf("/aai/"), relatedLink.length()))\r
 692                                           }\r
 693                                    }\r
 694                                 }\r
 695                         }\r
 696                 }\r
 697                 return rtn\r
 698         }\r
 699         /**\r
 700          * similar to VNF bindings method\r
 701         * @param xmlInput the XML document\r
 702         * @return a list of network policy values\r
 703         *            ex: ['aai/v$/network/network-policies/network-policy/cee6d136-e378-4678-a024-2cd15f0ee0cg', 'aai/v$/network/network-policies/network-policy/cee6d136-e378-4678-a024-2cd15f0ee0cg']\r
 704         *\r
 705         **/\r
 706         def getNetworkPolicyObject(xmlInput) {\r
 707                 //def rtn = null\r
 708                 List rtn = []\r
 709                 if (xmlInput!=null) {\r
 710                         def relationshipList = getListWithElements(xmlInput, 'relationship')\r
 711                         def relationshipListSize = relationshipList.size()\r
 712                         if (relationshipListSize > 0) {\r
 713                                 for (i in 0..relationshipListSize-1) {\r
 714                                    def relationshipXml = XmlUtil.serialize(relationshipList[i])\r
 715                                    if (utils.getNodeText(relationshipXml, 'related-to') == "network-policy") {\r
 716                                           def relatedLink = utils.getNodeText(relationshipXml, 'related-link')\r
 717                                           if (relatedLink != null || relatedLink != "") {\r
 718                                                  rtn.add(relatedLink.substring(relatedLink.indexOf("/aai/"), relatedLink.length()))\r
 719                                           }\r
 720                                    }\r
 721                                 }\r
 722                         }\r
 723                 }\r
 724                 return rtn\r
 725         }\r
 726 \r
 727         /**\r
 728          * similar to network policymethod\r
 729         * @param xmlInput the XML document\r
 730         * @return a list of network policy values\r
 731         *            ex: ['aai/v$/network/route-table-references/route-table-reference/refFQDN1', 'aai/v$/network/route-table-references/route-table-reference/refFQDN2']\r
 732         *\r
 733         **/\r
 734         def getNetworkTableRefObject(xmlInput) {\r
 735                 //def rtn = null\r
 736                 List rtn = []\r
 737                 if (xmlInput!=null) {\r
 738                         def relationshipList = getListWithElements(xmlInput, 'relationship')\r
 739                         def relationshipListSize = relationshipList.size()\r
 740                         if (relationshipListSize > 0) {\r
 741                                 for (i in 0..relationshipListSize-1) {\r
 742                                    def relationshipXml = XmlUtil.serialize(relationshipList[i])\r
 743                                    if (utils.getNodeText(relationshipXml, 'related-to') == "route-table-reference") {\r
 744                                           def relatedLink = utils.getNodeText1(relationshipXml, 'related-link')\r
 745                                           if (relatedLink != null || relatedLink != "") {\r
 746                                                  rtn.add(relatedLink.substring(relatedLink.indexOf("/aai/"), relatedLink.length()))\r
 747                                           }\r
 748                                    }\r
 749                                 }\r
 750                         }\r
 751                 }\r
 752                 return rtn\r
 753         }\r
 754         \r
 755         /**\r
 756          * similar to network policymethod\r
 757         * @param xmlInput the XML document\r
 758         * @return a list of IDs for related VNF instances\r
 759         *\r
 760         **/\r
 761         def getRelatedVnfIdList(xmlInput) {\r
 762                 //def rtn = null\r
 763                 List rtn = []\r
 764                 if (xmlInput!=null) {\r
 765                         def relationshipList = getListWithElements(xmlInput, 'relationship')\r
 766                         def relationshipListSize = relationshipList.size()\r
 767                         if (relationshipListSize > 0) {\r
 768                                 for (i in 0..relationshipListSize-1) {\r
 769                                    def relationshipXml = XmlUtil.serialize(relationshipList[i])\r
 770                                    if (utils.getNodeText(relationshipXml, 'related-to') == "generic-vnf") {\r
 771                                           def relatedLink = utils.getNodeText1(relationshipXml, 'related-link')\r
 772                                           if (relatedLink != null || relatedLink != "") {\r
 773                                                  if (relatedLink.substring(relatedLink.indexOf("/generic-vnf/")+13, relatedLink.length()).contains('/')) {\r
 774                                                          rtn.add(relatedLink.substring(relatedLink.indexOf("/generic-vnf/")+13, relatedLink.length()-1))\r
 775                                                  } else {\r
 776                                                      rtn.add(relatedLink.substring(relatedLink.indexOf("/generic-vnf/")+13, relatedLink.length()))\r
 777                                                  }\r
 778 \r
 779                                           }\r
 780                                    }\r
 781                                 }\r
 782                         }\r
 783                 }\r
 784                 return rtn\r
 785         }\r
 786         \r
 787         /**\r
 788          * similar to network policymethod\r
 789         * @param xmlInput the XML document\r
 790         * @return a list of IDs for related Network instances\r
 791         *\r
 792         **/\r
 793         def getRelatedNetworkIdList(xmlInput) {\r
 794                 //def rtn = null\r
 795                 List rtn = []\r
 796                 if (xmlInput!=null) {\r
 797                         def relationshipList = getListWithElements(xmlInput, 'relationship')\r
 798                         def relationshipListSize = relationshipList.size()\r
 799                         if (relationshipListSize > 0) {\r
 800                                 for (i in 0..relationshipListSize-1) {\r
 801                                    def relationshipXml = XmlUtil.serialize(relationshipList[i])\r
 802                                    if (utils.getNodeText(relationshipXml, 'related-to') == "l3-network") {\r
 803                                           def relatedLink = utils.getNodeText1(relationshipXml, 'related-link')\r
 804                                           if (relatedLink != null || relatedLink != "") {\r
 805                                                  if (relatedLink.substring(relatedLink.indexOf("/l3-network/")+12, relatedLink.length()).contains('/')) {\r
 806                                                          rtn.add(relatedLink.substring(relatedLink.indexOf("/l3-network/")+12, relatedLink.length()-1))\r
 807                                                  } else {\r
 808                                                      rtn.add(relatedLink.substring(relatedLink.indexOf("/l3-network/")+12, relatedLink.length()))\r
 809                                                  }\r
 810 \r
 811                                           }\r
 812                                    }\r
 813                                 }\r
 814                         }\r
 815                 }\r
 816                 return rtn\r
 817         }\r
 818         \r
 819         def isVfRelationshipExist(xmlInput) {\r
 820                 Boolean rtn = false\r
 821                 if (xmlInput!=null) {\r
 822                         def relationshipList = getListWithElements(xmlInput, 'relationship')\r
 823                         def relationshipListSize = relationshipList.size()\r
 824                         if (relationshipListSize > 0) {\r
 825                                 for (i in 0..relationshipListSize-1) {\r
 826                                    def relationshipXml = XmlUtil.serialize(relationshipList[i])\r
 827                                    if (utils.getNodeText(relationshipXml, 'related-to') == "vf-module") { \r
 828                                              rtn = true\r
 829                                    }\r
 830                                 }\r
 831                         }\r
 832                 }\r
 833                 return rtn\r
 834 \r
 835         }\r
 836 \r
 837         def getCloudRegion(xmlInput) {\r
 838                 String lcpCloudRegion = ""\r
 839                 if (xmlInput!=null) {\r
 840                         def relationshipList = getListWithElements(xmlInput, 'relationship')\r
 841                         def relationshipListSize = relationshipList.size()\r
 842                         if (relationshipListSize > 0) {\r
 843                                 for (i in 0..relationshipListSize-1) {\r
 844                                    def relationshipXml = XmlUtil.serialize(relationshipList[i])\r
 845                                    if (utils.getNodeText(relationshipXml, 'related-to') == "cloud-region") {\r
 846                                           def relatedLink = utils.getNodeText1(relationshipXml, 'related-link')\r
 847                                           if (relatedLink != null || relatedLink != "") {\r
 848                                                  lcpCloudRegion = relatedLink.substring(relatedLink.indexOf("/att-aic/")+9, relatedLink.length())\r
 849                                                  if (lcpCloudRegion.contains('/')) {\r
 850                                                          lcpCloudRegion = relatedLink.substring(relatedLink.indexOf("/att-aic/")+9, relatedLink.length()-1)\r
 851                                                  }\r
 852                                           }\r
 853                                    }\r
 854                                 }\r
 855                         }\r
 856                 }\r
 857                 return lcpCloudRegion\r
 858         }\r
 859         \r
 860         def getTenantId(xmlInput) {\r
 861                 String tenantId = ""\r
 862                 if (xmlInput!=null) {\r
 863                         def relationshipList = getListWithElements(xmlInput, 'relationship')\r
 864                         def relationshipListSize = relationshipList.size()\r
 865                         if (relationshipListSize > 0) {\r
 866                                 for (i in 0..relationshipListSize-1) {\r
 867                                    def relationshipXml = XmlUtil.serialize(relationshipList[i])\r
 868                                    if (utils.getNodeText(relationshipXml, 'related-to') == "tenant") {\r
 869                                           def relatedLink = utils.getNodeText1(relationshipXml, 'related-link')\r
 870                                           if (relatedLink != null || relatedLink != "") {\r
 871                                                  tenantId = relatedLink.substring(relatedLink.indexOf("/tenant/")+8, relatedLink.length())\r
 872                                                  if (tenantId.contains('/')) {\r
 873                                                          tenantId = relatedLink.substring(relatedLink.indexOf("/tenant/")+8, relatedLink.length()-1)\r
 874                                                  }\r
 875                                           }\r
 876                                    }\r
 877                                 }\r
 878                         }\r
 879                 }\r
 880                 return tenantId\r
 881         }\r
 882         \r
 883         def isInstanceValueMatch(linkResource, globalSubscriberId, serviceType) {\r
 884                 Boolean rtn = false\r
 885                 try {\r
 886                         String globalSubscriberIdLink = linkResource.substring(linkResource.indexOf("/customer/")+10, linkResource.indexOf("/service-subscriptions"))\r
 887                         String serviceTypeLink = linkResource.substring(linkResource.indexOf("/service-subscription/")+22, linkResource.indexOf("/service-instances"))\r
 888                         if (globalSubscriberIdLink == globalSubscriberId) { \r
 889                                         rtn = true\r
 890                         } else {\r
 891                                 if (serviceTypeLink == serviceType) {\r
 892                                         rtn = true\r
 893                                 }\r
 894                         }\r
 895                         \r
 896                 } catch (Exception ex) {\r
 897                     println 'Exception - ' + ex.getMessage()\r
 898                         return false\r
 899                 }\r
 900         return rtn\r
 901         }\r
 902         \r
 903         def getListWithElements(xmlInput, groupName) {\r
 904                 def rtn = ""\r
 905                 if (xmlInput != null) {\r
 906                         def relationshipData = new XmlSlurper().parseText(xmlInput)\r
 907                         rtn = relationshipData.'**'.findAll {it.name() == groupName}\r
 908                 }\r
 909                 return rtn\r
 910 \r
 911         }\r
 912 \r
 913         // build network single elements\r
 914         def buildNetworkElements(l3Network, createNetworkContrailResponse, networkList) {\r
 915                 def replaceNetworkId = ""\r
 916                 def replaceNeutronNetworkId = ""\r
 917                 def replaceContrailNetworkFqdn = ""\r
 918                 if (l3Network != null && createNetworkContrailResponse != null) {\r
 919                         if (utils.nodeExists(l3Network, 'heat-stack-id')) {\r
 920                                 replaceNetworkId = utils.getNodeText(l3Network, 'heat-stack-id')\r
 921                         } else {\r
 922                                 if (utils.nodeExists(createNetworkContrailResponse, 'networkStackId')) {\r
 923                                         replaceNetworkId = utils.getNodeText(createNetworkContrailResponse, 'networkStackId')\r
 924                                 }\r
 925                         }\r
 926                         if (utils.nodeExists(l3Network, 'neutron-network-id')) {\r
 927                                 replaceNeutronNetworkId = utils.getNodeText(l3Network, 'neutron-network-id')\r
 928                         } else {\r
 929                                 if (utils.nodeExists(createNetworkContrailResponse, 'neutronNetworkId')) {\r
 930                                         replaceNeutronNetworkId = utils.getNodeText(createNetworkContrailResponse, 'neutronNetworkId')\r
 931                                 }\r
 932                         }\r
 933                         if (utils.nodeExists(l3Network, 'contrail-network-fqdn')) {\r
 934                                 replaceContrailNetworkFqdn = utils.getNodeText(l3Network, 'contrail-network-fqdn')\r
 935                         } else {\r
 936                                 if (utils.nodeExists(createNetworkContrailResponse, 'networkFqdn')) {\r
 937                                         replaceContrailNetworkFqdn = utils.getNodeText(createNetworkContrailResponse, 'networkFqdn')\r
 938                                 }\r
 939                         }\r
 940                 }\r
 941 \r
 942                 String var = ""\r
 943                 def xmlNetwork = ""\r
 944                 if (l3Network != null) {\r
 945                         for (element in networkList) {\r
 946                                 def xml= new XmlSlurper().parseText(l3Network)\r
 947                                 var = xml.'**'.find {it.name() == element}\r
 948                                 if (var == null) {\r
 949                                         if (element=="orchestration-status") {\r
 950                                                 if (var.toString() == 'pending-create' || var.toString() == 'PendingCreate') {\r
 951                                                         xmlNetwork += "<"+element+">"+"Created"+"</"+element+">"\r
 952                                             } else { //pending-update or PendingUpdate\r
 953                                                         xmlNetwork += "<"+element+">"+"Active"+"</"+element+">"\r
 954                                             }\r
 955                                         }       \r
 956 \r
 957                                         if (element=="heat-stack-id") {\r
 958                                                 if (replaceNetworkId != "") {\r
 959                                                         xmlNetwork += "<"+element+">"+replaceNetworkId+"</"+element+">"\r
 960                                                 }\r
 961                                         }\r
 962                                         if (element=="neutron-network-id") {\r
 963                                                 if (replaceNeutronNetworkId != "") {\r
 964                                                         xmlNetwork += "<"+element+">"+replaceNeutronNetworkId+"</"+element+">"\r
 965                                                 }\r
 966                                         }\r
 967                                         if (element=="contrail-network-fqdn") {\r
 968                                                 if (replaceContrailNetworkFqdn != "") {\r
 969                                                         xmlNetwork += "<"+element+">"+replaceContrailNetworkFqdn+"</"+element+">"\r
 970                                                 }\r
 971                                         }\r
 972 \r
 973                                 } else {\r
 974                                         if (element=="orchestration-status") {\r
 975                                            if (element=="orchestration-status") {\r
 976                                                   if (var.toString() == 'pending-create' || var.toString() == 'PendingCreate') {\r
 977                                                       xmlNetwork += "<"+element+">"+"Created"+"</"+element+">"\r
 978                                                   } else { //pending-update or PendingUpdate\r
 979                                                           xmlNetwork += "<"+element+">"+"Active"+"</"+element+">"\r
 980                                                   }\r
 981                                            }   \r
 982                                     } else {\r
 983                                     xmlNetwork += "<"+element+">"+var.toString()+"</"+element+">"\r
 984                                         }\r
 985                                 }       \r
 986                          }\r
 987 \r
 988                 }\r
 989                 return xmlNetwork\r
 990         }\r
 991 \r
 992         def buildSubnets(requeryIdAAIResponse, createNetworkResponse) {\r
 993                 def rebuildingSubnets = ""\r
 994                 if (requeryIdAAIResponse != null && utils.nodeExists(requeryIdAAIResponse, 'subnets')) {\r
 995                         def subnetIdMapValue = ""\r
 996                         def subnetsGroup = utils.getNodeXml(requeryIdAAIResponse, "subnets", false)\r
 997                         def subnetsData = new XmlSlurper().parseText(subnetsGroup)\r
 998                         rebuildingSubnets += "<subnets>"\r
 999                         try {\r
1000                                 def subnets = subnetsData.'**'.findAll {it.name() == "subnet"}\r
1001                                 def subnetsSize = subnets.size()\r
1002                                 for (i in 0..subnetsSize-1) {\r
1003                                    def subnet = subnets[i]\r
1004                                    def subnetXml = XmlUtil.serialize(subnet)\r
1005                                    def orchestrationStatus = utils.getNodeText1(subnetXml, "orchestration-status")\r
1006                                    if (orchestrationStatus == "PendingDelete" || orchestrationStatus == "pending-delete") {\r
1007                                            // skip, do not include in processing, remove!!!\r
1008                                    } else {\r
1009                                       def subnetList = ["subnet-id", "neutron-subnet-id", "gateway-address", "network-start-address", "cidr-mask", "ip-version", "orchestration-status", "dhcp-enabled", "dhcp-start", "dhcp-end", "resource-version", "subnet-name"]\r
1010                                       rebuildingSubnets += buildSubNetworkElements(subnetXml, createNetworkResponse, subnetList, "subnet")\r
1011                                    }\r
1012                                 }\r
1013                                 if (utils.nodeExists(subnetsData, 'relationship')) {\r
1014                                         rebuildingSubnets = rebuildRelationship(requeryIdAAIResponse)\r
1015                                 }\r
1016 \r
1017                         } catch (Exception ex) {\r
1018                                 // error\r
1019                         } finally {\r
1020                                 rebuildingSubnets += "</subnets>"\r
1021                         }\r
1022                 }\r
1023                 return rebuildingSubnets\r
1024         }\r
1025 \r
1026         def buildSubnets(queryIdResponse) {\r
1027                 def rebuildingSubnets = ""\r
1028                 def subnetsData = new XmlSlurper().parseText(queryIdResponse)\r
1029                 //rebuildingSubnets += "<subnets>"\r
1030                 try {\r
1031                         def subnets = subnetsData.'**'.findAll {it.name() == "subnet"}\r
1032                         def subnetsSize = subnets.size()\r
1033                         for (i in 0..subnetsSize-1) {\r
1034                            def subnet = subnets[i]\r
1035                            def subnetXml = XmlUtil.serialize(subnet)\r
1036                            def orchestrationStatus = utils.getNodeText1(subnetXml, "orchestration-status")\r
1037                            if (orchestrationStatus == "pending-delete" || orchestrationStatus == "PendingDelete") {\r
1038                                    // skip, do not include in processing, remove!!!\r
1039                            } else {\r
1040                                         def subnetList = ["dhcp-start", "dhcp-end", "network-start-address", "cidr-mask", "dhcp-enabled", "gateway-address", "ip-version", "subnet-id", "subnet-name"]\r
1041                                         rebuildingSubnets += buildSubNetworkElements(subnetXml, subnetList, "subnets")\r
1042                                         //rebuildingSubnets += buildSubNetworkElements(subnetXml, subnetList, "")\r
1043                            }                    }\r
1044                 } catch (Exception ex) {\r
1045                    //\r
1046                 } finally {\r
1047                   //rebuildingSubnets += "</subnets>"\r
1048                 }\r
1049                 return rebuildingSubnets\r
1050         }\r
1051 \r
1052 \r
1053         // build subnet sub-network single elements\r
1054         def buildSubNetworkElements(subnetXml, createNetworkResponse, elementList, parentName) {\r
1055                 String var = ""\r
1056                 def xmlBuild = ""\r
1057                 if (parentName != "") {\r
1058                    xmlBuild += "<"+parentName+">"\r
1059                 }\r
1060                 if (subnetXml != null) {\r
1061                         for (element in elementList) {\r
1062                           def xml= new XmlSlurper().parseText(subnetXml)\r
1063                           var = xml.'**'.find {it.name() == element}\r
1064                           if (var != null) {\r
1065                                  if (element=="orchestration-status") {\r
1066                                         if(var.toString() == 'pending-create' || var.toString() == 'PendingCreate') {   \r
1067                                                 xmlBuild += "<"+element+">"+"Created"+"</"+element+">"\r
1068                                         } else { // pending-update or PendingUpdate'\r
1069                                            xmlBuild += "<"+element+">"+"Active"+"</"+element+">"\r
1070                                         }\r
1071                                  } else { // "subnet-id", "neutron-subnet-id"\r
1072                                          if (element=="subnet-id") {\r
1073                                                  if (utils.nodeExists(createNetworkResponse, "subnetMap")) {\r
1074                                                          xmlBuild += "<"+element+">"+var.toString()+"</"+element+">"\r
1075                                                          String neutronSubnetId = extractNeutSubId(createNetworkResponse, var.toString())\r
1076                                                          xmlBuild += "<neutron-subnet-id>"+neutronSubnetId+"</neutron-subnet-id>"\r
1077                                                  }\r
1078                                          } else {\r
1079                                              if (element=="neutron-subnet-id") {\r
1080                                // skip\r
1081                                                  } else {\r
1082                                                     xmlBuild += "<"+element+">"+var.toString()+"</"+element+">"\r
1083                                                  }\r
1084                                          }\r
1085                                  }\r
1086                           }\r
1087                         }\r
1088 \r
1089                 }\r
1090                 if (parentName != "") {\r
1091                    xmlBuild += "</"+parentName+">"\r
1092                 }\r
1093                 return xmlBuild\r
1094         }\r
1095 \r
1096         // build subnet sub-network single elements\r
1097         def buildSubNetworkElements(subnetXml, elementList, parentName) {\r
1098                 def var = ""\r
1099                 def xmlBuild = ""\r
1100                 if (parentName != "") {\r
1101                         xmlBuild += "<"+parentName+">"\r
1102                  }\r
1103                 if (subnetXml != null) {\r
1104                     def networkStartAddress = ""\r
1105                         for (element in elementList) {\r
1106                                 def xml= new XmlSlurper().parseText(subnetXml)\r
1107                                 var = xml.'**'.find {it.name() == element}\r
1108                                 if (element == "dhcp-start") {\r
1109                                         xmlBuild += "<allocationPools>"\r
1110                                         if (var.toString() == 'null') {\r
1111                                                 xmlBuild += "<start>"+""+"</start>"\r
1112                                         } else {\r
1113                                                 xmlBuild += "<start>"+var.toString()+"</start>"\r
1114                                         }\r
1115                                 }\r
1116                                 if (element == "dhcp-end") {\r
1117                                         if (var.toString() == 'null') {\r
1118                                                 xmlBuild += "<end>"+""+"</end>"\r
1119                                         } else {\r
1120                                                 xmlBuild += "<end>"+var.toString()+"</end>"\r
1121                                         }\r
1122                                         xmlBuild += "</allocationPools>"\r
1123                                 }\r
1124                                 if (element == "network-start-address" || element == "cidr-mask") {\r
1125                                         if (element == "network-start-address") {\r
1126                                                 networkStartAddress = var.toString()\r
1127                                         }\r
1128                                         if (element == "cidr-mask") {\r
1129                                                 xmlBuild += "<cidr>"+networkStartAddress+"/"+var.toString()+"</cidr>"\r
1130                                         }\r
1131                                 }\r
1132                                 if (element == "dhcp-enabled") {\r
1133                                         xmlBuild += "<enableDHCP>"+var.toString()+"</enableDHCP>"\r
1134                                 }\r
1135                                 if (element == "gateway-address") {\r
1136                                         xmlBuild += "<gatewayIp>"+var.toString()+"</gatewayIp>"\r
1137                                 }\r
1138                                 if (element == "ip-version") {\r
1139                                         xmlBuild += "<ipVersion>"+var.toString()+"</ipVersion>"\r
1140                                 }\r
1141                                 if (element == "subnet-id") {\r
1142                                         xmlBuild += "<subnetId>"+var.toString()+"</subnetId>"\r
1143                                 }\r
1144                                 if ((element == "subnet-name") && (var != null)) {\r
1145                                         xmlBuild += "<subnetName>"+var.toString()+"</subnetName>"\r
1146                                 }\r
1147                         }\r
1148                 }\r
1149                 if (parentName != "") {\r
1150                         xmlBuild += "</"+parentName+">"\r
1151                  }\r
1152                 return xmlBuild\r
1153         }\r
1154 \r
1155         // rebuild ctag-assignments\r
1156         def rebuildCtagAssignments(xmlInput) {\r
1157                 def rebuildingCtagAssignments = ""\r
1158                 if (xmlInput!=null) {\r
1159                         def ctagAssignmentsData = new XmlSlurper().parseText(xmlInput)\r
1160                         rebuildingCtagAssignments += "<ctag-assignments>"\r
1161                         def ctagAssignments = ctagAssignmentsData.'**'.findAll {it.name() == "ctag-assignment"}\r
1162                         def ctagAssignmentsSize = ctagAssignments.size()\r
1163                         for (i in 0..ctagAssignmentsSize-1) {\r
1164                                 def ctagAssignment = ctagAssignments[i]\r
1165                                 def ctagAssignmentXml = XmlUtil.serialize(ctagAssignment)\r
1166                                 rebuildingCtagAssignments += "<ctag-assignment>"\r
1167                                 List elementList = ["vlan-id-inner", "resource-version"]\r
1168                                 rebuildingCtagAssignments +=  buildXMLElements(ctagAssignmentXml, ""      , "", elementList)\r
1169                                 if (utils.nodeExists(ctagAssignmentXml, 'relationship')) {\r
1170                                         rebuildingCtagAssignments += rebuildRelationship(ctagAssignmentXml)\r
1171                                 }\r
1172                                 rebuildingCtagAssignments += "</ctag-assignment>"\r
1173                         }\r
1174                         rebuildingCtagAssignments += "</ctag-assignments>"\r
1175                 }\r
1176                 return rebuildingCtagAssignments\r
1177         }\r
1178 \r
1179         // rebuild 'relationship-list'\r
1180         def rebuildRelationship(xmlInput) {\r
1181                 def rebuildingSubnets = ""\r
1182                 if (xmlInput!=null) {\r
1183                         def subnetsData = new XmlSlurper().parseText(xmlInput)\r
1184                         rebuildingSubnets += "<relationship-list>"\r
1185                         def relationships = subnetsData.'**'.findAll {it.name() == "relationship"}\r
1186                         def relationshipsSize = relationships.size()\r
1187                         for (i in 0..relationshipsSize-1) {\r
1188                                 def relationship = relationships[i]\r
1189                                 def relationshipXml = XmlUtil.serialize(relationship)\r
1190                                 rebuildingSubnets += "<relationship>"\r
1191                                 def relationshipList = ["related-to", "related-link"]\r
1192                                 rebuildingSubnets += buildSubNetworkElements(relationshipXml, "", relationshipList, "")\r
1193                                 if (utils.nodeExists(relationshipXml, 'relationship-data')) {\r
1194                                         def relationshipDataXmlData = new XmlSlurper().parseText(relationshipXml)\r
1195                                         def relationshipsData = relationshipDataXmlData.'**'.findAll {it.name() == "relationship-data"}\r
1196                                         def relationshipsDataSize = relationshipsData.size()\r
1197                                         for (j in 0..relationshipsDataSize-1) {\r
1198                                                 def relationshipData = relationshipsData[j]\r
1199                                                 def relationshipDataXml = XmlUtil.serialize(relationshipData)\r
1200                                                 def relationshipDataList =  ["relationship-key", "relationship-value"]\r
1201                                                 rebuildingSubnets += buildXMLElements(relationshipDataXml, "", "relationship-data", relationshipDataList)\r
1202                                         }\r
1203                                 }\r
1204                                 if (utils.nodeExists(relationshipXml, 'related-to-property')) {\r
1205                                         def relationshipDataXmlData = new XmlSlurper().parseText(relationshipXml)\r
1206                                         def relationshipsData = relationshipDataXmlData.'**'.findAll {it.name() == "related-to-property"}\r
1207                                         def relationshipsDataSize = relationshipsData.size()\r
1208                                         for (j in 0..relationshipsDataSize-1) {\r
1209                                                 def relationshipData = relationshipsData[j]\r
1210                                                 def relationshipDataXml = XmlUtil.serialize(relationshipData)\r
1211                                                 def relationshipDataList =  ["property-key", "property-value"]\r
1212                                                 rebuildingSubnets += buildXMLElements(relationshipDataXml, "", "related-to-property", relationshipDataList)\r
1213                                         }\r
1214                                 }\r
1215 \r
1216                                 rebuildingSubnets += "</relationship>"\r
1217                         }\r
1218                         rebuildingSubnets += "</relationship-list>"\r
1219                 }\r
1220                 return rebuildingSubnets\r
1221         }\r
1222         \r
1223         def buildVlans(queryIdResponse) {\r
1224                 def rebuildingSubnets = "<vlans>"\r
1225                 def subnetsData = new XmlSlurper().parseText(queryIdResponse)\r
1226 \r
1227                 try {\r
1228                         def subnets = subnetsData.'**'.findAll {it.name() == "segmentation-assignments"}\r
1229                         def subnetsSize = subnets.size()\r
1230                         for (i in 0..subnetsSize-1) {\r
1231                            def subnet = subnets[i]\r
1232                            def subnetXml = XmlUtil.serialize(subnet)\r
1233                            \r
1234                            String vlan = utils.getNodeText1(subnetXml, "segmentation-id")\r
1235                            if (i>0){\r
1236                                    rebuildingSubnets += ","\r
1237                            }\r
1238                            rebuildingSubnets += vlan\r
1239                         }\r
1240                 } catch (Exception ex) {\r
1241                    //\r
1242                 } finally {\r
1243                   //rebuildingSubnets += "</subnets>"\r
1244                 rebuildingSubnets += "</vlans>"\r
1245                 }\r
1246                 return rebuildingSubnets\r
1247         }\r
1248 \r
1249         /* Utility code to rebuild xml/elements in a list:\r
1250          * rebuild xml with 1) unbounded groups of elements; or\r
1251          *                  2) one group of elements; or\r
1252          *                  3) just one or more elements (in a list as argument)\r
1253          * @param xmlInput the XML document\r
1254          * @param parentName the parent name  (ex: 'inputs')\r
1255          * @param childrenName the chilrendName (ex: 'entry' as unbounded/occurs>1)\r
1256          * @param elementList the element list of children (ex: 'key', 'value')\r
1257          * @return a string of rebuild xml\r
1258          *\r
1259          * Ex 1: xmlInput:\r
1260          *    <ws:inputs>\r
1261          *       <ws:entry>\r
1262          *          <ws:key>name</ws:key>\r
1263          *          <ws:value>Edward</ws:value>\r
1264          *       </ws:entry>\r
1265          *       <ws:entry>\r
1266          *          <ws:key>age</ws:key>\r
1267          *          <ws:value>30</ws:value>\r
1268          *       </ws:entry>\r
1269          *       <ws:entry>\r
1270          *          <ws:key>age</ws:key>\r
1271          *          <ws:value>30</ws:value>\r
1272          *       </ws:entry>\r
1273          *    <ws:/inputs>\r
1274          * Usage:\r
1275          * List elementList = ["key", "value"]\r
1276          * String rebuild =  buildXMLElements(xmlInput, "inputs", "entry", elementList)\r
1277          *\r
1278          * Ex 2: xmlInput // no parent tag\r
1279          *   <ws:sdnc-request-header>\r
1280          *    <ws:svc-request-id>fec8ec88-151a-45c9-ad60-8233e0fc8ff2</ws:svc-request-id>\r
1281          *    <ws:svc-notification-url>https://msojra.mtsnj.aic.cip.openecomp.com:8443/adapters/rest/SDNCNotify</ws:svc-notification-url>\r
1282          *    <ws:svc-action>assign</ws:svc-action>\r
1283          *   </ws:sdnc-request-header>\r
1284          * Usage:\r
1285          * List elementList = ["svc-request-id", "svc-notification-url", "svc-action"]\r
1286          * String rebuild =  buildXMLElements(xmlInput, ""      , "sdnc-request-header", elementList)  // no parent tag\r
1287          *\r
1288          * Ex 3: xmlInput // elements one after another (with no parent & children tag)\r
1289          * <ws:test-id>myTestid</ws:test-id>\r
1290          * <ws:test-user>myUser</ws:test-user>\r
1291          * Usage:\r
1292          * List elementList = ["test-id", "test-user"]\r
1293          * String rebuild =  buildXMLElements(xmlInput, ""      , "", elementList)\r
1294          *\r
1295          */\r
1296         def buildXMLElements(xmlInput, parentName, childrenName, elementList) {\r
1297                 def varChildren = ""\r
1298                 def var = ""\r
1299                 def xmlBuildUnbounded = ""\r
1300                 if (parentName!="") {xmlBuildUnbounded += "<"+parentName+">" +'\n'}\r
1301                 if (xmlInput != null) {\r
1302                         def xml= new XmlSlurper().parseText(xmlInput)\r
1303                         if (childrenName!="") {\r
1304                                 varChildren = xml.'**'.findAll {it.name() == childrenName}\r
1305                                 for (i in 0..varChildren.size()-1) {\r
1306                                         xmlBuildUnbounded += "<"+childrenName+">" +'\n'\r
1307                                         for (element in elementList) {\r
1308                                                 var = varChildren[i].'*'.find {it.name() == element}\r
1309                                            if (var != null) {\r
1310                                                   xmlBuildUnbounded += "<"+element+">"+var.toString()+"</"+element+">" +'\n'\r
1311                                            }\r
1312                                         }\r
1313                                         xmlBuildUnbounded += "</"+childrenName+">" +'\n'\r
1314                                 }\r
1315                         } else {\r
1316                                 for (element in elementList) {\r
1317                                         var = xml.'*'.find {it.name() == element}\r
1318                                         if (var != null) {\r
1319                                                 xmlBuildUnbounded += "<"+element+">"+var.toString()+"</"+element+">" +'\n'\r
1320                                         }\r
1321                                 }\r
1322                         }\r
1323 \r
1324                 }\r
1325                 if (parentName!="") {xmlBuildUnbounded += "</"+parentName+">" +'\n'}\r
1326                 return xmlBuildUnbounded\r
1327          }\r
1328 \r
1329         def getFirstNodeXml(xmlInput, element){\r
1330                 def nodeAsText = ""\r
1331                 def nodeToSerialize =  ""\r
1332                 if (xmlInput != null) {\r
1333                         def fxml= new XmlSlurper().parseText(xmlInput)\r
1334                         if (utils.nodeExists(xmlInput, "payload")) {\r
1335                                 nodeToSerialize = fxml.'payload'.'l3-network'.'*'.find {it.name() == element}\r
1336                                 if (nodeToSerialize!=null) {\r
1337                                         nodeAsText = XmlUtil.serialize(nodeToSerialize)\r
1338                                 } else {\r
1339                                     nodeAsText = ""\r
1340                                 }\r
1341 \r
1342                         } else {\r
1343                                 nodeToSerialize = fxml.'*'.find {it.name() == element}\r
1344                                 if (nodeToSerialize!=null) {\r
1345                                         nodeAsText = XmlUtil.serialize(nodeToSerialize)\r
1346                                 } else {\r
1347                                         nodeAsText = ""\r
1348                                 }\r
1349 \r
1350                         }\r
1351                 }\r
1352                 return nodeAsText\r
1353 \r
1354         }\r
1355 \r
1356 //TODO: This method still needs to be tested before using.\r
1357         /**\r
1358          *\r
1359          * This method is similar to the gennetwork:ContrailNetworUpdateCompletedObject\r
1360          * BPEL method.  It extracts all of the required subnet information\r
1361          * for each subnet listed with an orch status equal to the one provided\r
1362          * and puts the corresponding infomation with the appropriate node for\r
1363          * updating aai. The method sets the orch status for each subnet to active\r
1364          *\r
1365          * @param subnetsXml the entire subnets xml\r
1366          * @param requestInput the request in the process\r
1367          * @param queryIdResponse the response of REST AAI query by Id\r
1368          * @param queryVpnBindingResponse the response of REST AAI query by vpn binding\r
1369          * @param routeCollection the collection of vpnBinding's 'global-route-target'\r
1370          * @return String request\r
1371          */\r
1372         public String networkUpdateSubnetInfo(String subnetsXml, String networkResponseXml){\r
1373 \r
1374                         String subnets = ""\r
1375                         StringBuilder sb = new StringBuilder()\r
1376                         InputSource source = new InputSource(new StringReader(subnetsXml));\r
1377                         DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();\r
1378                         docFactory.setNamespaceAware(true)\r
1379                         DocumentBuilder docBuilder = docFactory.newDocumentBuilder()\r
1380                         Document xml = docBuilder.parse(source)\r
1381                         NodeList nodeList = xml.getElementsByTagNameNS("*", "subnet")\r
1382                         for (int x = 0; x < nodeList.getLength(); x++) {\r
1383                                 Node node = nodeList.item(x)\r
1384                                 String subnet = ""\r
1385                                 if (node.getNodeType() == Node.ELEMENT_NODE) {\r
1386                                         Element eElement = (Element) node\r
1387                                         String subnetOrchStatus = eElement.getElementsByTagNameNS("*", "orchestration-status").item(0).getTextContent()\r
1388                                         if(subnetOrchStatus.equals("pending-create")){\r
1389 \r
1390                                                 String subnetId = eElement.getElementsByTagNameNS("*", "subnet-id").item(0).getTextContent()\r
1391                                                 def netAddress = eElement.getElementsByTagNameNS("*", "network-start-address").item(0).getTextContent()\r
1392                                                 def mask = eElement.getElementsByTagNameNS("*", "cidr-mask").item(0).getTextContent()\r
1393                                                 def dhcpEnabledSubnet = eElement.getElementsByTagNameNS("*", "dhcp-enabled").item(0).getTextContent()\r
1394                                                 def gatewayAddress = eElement.getElementsByTagNameNS("*", "gateway-address").item(0).getTextContent()\r
1395                                                 def ipVersion = eElement.getElementsByTagNameNS("*", "ip-version").item(0).getTextContent()\r
1396                                                 def relationshipList =  eElement.getElementsByTagNameNS("*", "relationship-list").item(0).getTextContent() //TODO: test this\r
1397                                                 String neutronSubnetId = extractNeutSubId(networkResponseXml, subnetId)\r
1398                                                 subnet =\r
1399                                                 """<subnet>\r
1400                                         <subnetId>${subnetId}</subnetId>\r
1401                                         <neutron-subnet-id>${neutronSubnetId}</neutron-subnet-id>\r
1402                                         <gateway-address>${gatewayAddress}</gateway-address>\r
1403                                         <network-start-address>${netAddress}</network-start-address>\r
1404                                         <cidr-mask>${mask}</cidr-mask>\r
1405                                         <ip-Version>${ipVersion}</ip-Version>\r
1406                                         <orchestration-status>active</orchestration-status>\r
1407                                         <dhcp-enabled>${dhcpEnabledSubnet}</dhcp-enabled>\r
1408                                         <relationship-list>${relationshipList}</relationship-list>\r
1409                                         </subnet>"""\r
1410 \r
1411                                         }else if(subnetOrchStatus.equals("pending-delete")){\r
1412                                                 StringWriter writer = new StringWriter()\r
1413                                                 Transformer transformer = TransformerFactory.newInstance().newTransformer()\r
1414                                                 transformer.transform(new DOMSource(node), new StreamResult(writer))\r
1415                                                 subnet = writer.toString()\r
1416 \r
1417                                         }else{\r
1418                                                 subnet = ""\r
1419                                         }\r
1420                                 }\r
1421                                 subnets = sb.append(subnet)\r
1422                         }\r
1423 \r
1424                         subnets = utils.removeXmlPreamble(subnets)\r
1425 \r
1426                         String subnetsList =\r
1427                         """<subnets>\r
1428                         ${subnets}\r
1429                         </subnets>"""\r
1430 \r
1431                         return subnetsList\r
1432         }\r
1433 \r
1434 \r
1435         /**\r
1436          *\r
1437          * This method extracts the "value" node text for the the given subnet Id.\r
1438          *\r
1439          * @param String inputSource - xml that contains the subnet id key and value\r
1440          * @param String subnetId - for which you want the value of\r
1441 \r
1442          * @return String value - node text of node named value associated with the given subnet id\r
1443          */\r
1444         public String extractNeutSubId(String inputSource, String subnetId){\r
1445 \r
1446                                 String value = ""\r
1447                                 InputSource source = new InputSource(new StringReader(inputSource));\r
1448                                 DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();\r
1449                                 docFactory.setNamespaceAware(true)\r
1450                                 DocumentBuilder docBuilder = docFactory.newDocumentBuilder()\r
1451                                 Document xml = docBuilder.parse(source)\r
1452                                 NodeList nodeList = xml.getElementsByTagNameNS("*", "entry")\r
1453                                 for (int x = 0; x < nodeList.getLength(); x++) {\r
1454                                         Node node = nodeList.item(x)\r
1455                                         String subnet = ""\r
1456                                         if (node.getNodeType() == Node.ELEMENT_NODE) {\r
1457                                                 Element eElement = (Element) node\r
1458                                                 String key = eElement.getElementsByTagNameNS("*", "key").item(0).getTextContent()\r
1459                                                 if(key.equals(subnetId)){\r
1460                                                         value = eElement.getElementsByTagNameNS("*", "value").item(0).getTextContent()\r
1461                                                 }\r
1462                                         }\r
1463                                 }\r
1464                                 return value\r
1465                         }\r
1466 \r
1467         public boolean isRollbackEnabled (Execution execution, String payloadXml) {\r
1468                 \r
1469                 def rollbackEnabled = false\r
1470                 def rollbackValueSet = false\r
1471                 if (utils.nodeExists(payloadXml, "backout-on-failure")) {\r
1472                         String backoutValue = utils.getNodeText1(payloadXml, "backout-on-failure")\r
1473                         if (backoutValue != null && !backoutValue.isEmpty()) {\r
1474                                 if (backoutValue.equalsIgnoreCase("false")) {\r
1475                                         rollbackEnabled = false\r
1476                                 }\r
1477                                 else {\r
1478                                         rollbackEnabled = true\r
1479                                 }\r
1480                                 rollbackValueSet = true;\r
1481                         }\r
1482                 }\r
1483                 \r
1484                 if (!rollbackValueSet) {\r
1485                         if (execution.getVariable("URN_mso_rollback") != null) {\r
1486                             rollbackEnabled = execution.getVariable("URN_mso_rollback").toBoolean()\r
1487                         }   \r
1488                 }\r
1489                 return rollbackEnabled\r
1490         }\r
1491 }\r