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