2 * ============LICENSE_START=======================================================
\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
11 * http://www.apache.org/licenses/LICENSE-2.0
\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
21 package org.openecomp.mso.bpmn.common.scripts
\r
23 import groovy.xml.XmlUtil
\r
25 import java.text.SimpleDateFormat
\r
27 import org.apache.commons.codec.binary.Base64
\r
28 import org.openecomp.mso.bpmn.core.BPMNLogger
\r
29 import org.openecomp.mso.bpmn.core.xml.XmlTool
\r
30 import org.openecomp.mso.logger.MessageEnum
\r
31 import org.openecomp.mso.logger.MsoLogger
\r
32 import org.openecomp.mso.utils.CryptoUtils
\r
33 import org.slf4j.MDC
\r
34 import org.w3c.dom.Element
\r
37 def initializeEndPoints(execution){
\r
38 // use this placeholder to initialize end points, if called independently, this need to be set
\r
39 execution.setVariable("AAIEndPoint","http://localhost:28080/SoapUIMocks")
\r
43 * Use getNodeText1 Instead!
\r
46 def getNodeText(xmlInput,element){
\r
49 def xml= new XmlSlurper().parseText(xmlInput)
\r
50 rtn= xml.'**'.find{node->node.name()==element}.text()
\r
54 def getMultNodes(xmlInput, element){
\r
57 def xml= new XmlSlurper().parseText(xmlInput)
\r
58 nodes = xml.'**'.findAll{ node-> node.name() == element }*.text()
\r
62 def getNodeText1(xmlInput,element){
\r
65 def xml= new XmlSlurper().parseText(xmlInput)
\r
66 rtn= xml.'**'.find{node->node.name()==element}
\r
73 def getNodeXml(xmlInput,element){
\r
74 return getNodeXml(xmlInput, element, true)
\r
76 def getNodeXml(xmlInput,element,incPreamble){
\r
77 def fxml= new XmlSlurper().parseText(xmlInput)
\r
78 def nodeToSerialize = fxml.'**'.find {it.name() == element}
\r
79 if(nodeToSerialize==null){
\r
82 def nodeAsText = XmlUtil.serialize(nodeToSerialize)
\r
84 nodeAsText = removeXmlPreamble(nodeAsText)
\r
88 def nodeExists(xmlInput,element){
\r
90 def fxml= new XmlSlurper().parseText(xmlInput)
\r
91 def nodeToSerialize = fxml.'**'.find {it.name() == element}
\r
92 return nodeToSerialize!=null
\r
93 } catch(Exception e) {
\r
99 /***** Utilities when using XmlParser *****/
\r
102 * Convert a Node into a String by deserializing it and formatting it.
\r
104 * @param node Node to be converted.
\r
105 * @return the Node as a String.
\r
107 def String nodeToString(Node node) {
\r
108 def String nodeAsString = groovy.xml.XmlUtil.serialize(node)
\r
109 nodeAsString = removeXmlPreamble(nodeAsString)
\r
110 return formatXml(nodeAsString)
\r
114 * Get the specified child Node of the specified parent. If there are
\r
115 * multiple children of the same name, only the first one is returned.
\r
116 * If there are no children with the specified name, 'null' is returned.
\r
118 * @param parent Parent Node in which to find a child.
\r
119 * @param childNodeName Name of the child Node to get.
\r
120 * @return the (first) child Node with the specified name or 'null'
\r
121 * if a child Node with the specified name does not exist.
\r
123 def Node getChildNode(Node parent, String childNodeName) {
\r
124 def NodeList nodeList = getIdenticalChildren(parent, childNodeName)
\r
125 if (nodeList.size() == 0) {
\r
128 return nodeList.get(0)
\r
133 * Get the textual value of the specified child Node of the specified parent.
\r
134 * If there are no children with the specified name, 'null' is returned.
\r
136 * @param parent Parent Node in which to find a child.
\r
137 * @param childNodeName Name of the child Node whose value to get.
\r
138 * @return the textual value of child Node with the specified name or 'null'
\r
139 * if a child Node with the specified name does not exist.
\r
141 def String getChildNodeText(Node parent, String childNodeName) {
\r
142 def Node childNode = getChildNode(parent, childNodeName)
\r
143 if (childNode == null) {
\r
146 return childNode.text()
\r
151 * Get all of the child nodes from the specified parent that have the
\r
152 * specified name. The returned NodeList could be empty.
\r
154 * @param parent Parent Node in which to find children.
\r
155 * @param childNodeName Name of the children to get.
\r
156 * @return a NodeList of all the children from the parent with the specified
\r
157 * name. The list could be empty.
\r
159 def NodeList getIdenticalChildren(Node parent, String childNodeName) {
\r
160 return (NodeList) parent.get(childNodeName)
\r
163 /***** End of Utilities when using XmlParser *****/
\r
166 /** these are covered under the common function above**/
\r
167 def getSubscriberName(xmlInput,element){
\r
169 if(xmlInput!=null){
\r
170 def xml= new XmlSlurper().parseText(xmlInput)
\r
171 rtn= xml.'**'.find{node->node.name()==element}.text()
\r
175 def getTenantInformation(xmlInput,element){
\r
176 def xml= new XmlSlurper().parseText(xmlInput)
\r
177 def nodeToSerialize = xml.'**'.find {it.name() == 'service-information'}
\r
178 def nodeAsText = XmlUtil.serialize(nodeToSerialize)
\r
181 def getServiceInstanceId(xmlInput,element){
\r
182 def xml= new XmlSlurper().parseText(xmlInput)
\r
183 return ( xml.'**'.find{node->node.name()==element}.text() )
\r
185 //for aai tenant url
\r
186 def searchResourceLink(xmlInput, resourceType){
\r
187 def fxml= new XmlSlurper().parseText(xmlInput)
\r
188 def element = fxml.'**'.find {it.'resource-type' == resourceType}
\r
189 return (element == null) ? null : element.'resource-link'.text()
\r
192 def searchMetaData(xmlInput, searchName, searchValue){
\r
193 def fxml= new XmlSlurper().parseText(xmlInput)
\r
194 def ret = fxml.'**'.find {it.metaname.text() == searchName && it.metaval.text() == searchValue}
\r
196 return ret.parent().parent()
\r
201 def searchMetaDataNode(fxml, searchName, searchValue){
\r
202 def ret = fxml.'**'.find {it.metaname.text() == searchName && it.metaval.text() == searchValue}
\r
204 return ret.parent().parent()
\r
209 // for Trinity L3 add/delete bonding
\r
210 def getPBGFList(isDebugLogEnabled, xmlInput){
\r
211 xmlInput = xmlInput.replaceAll("&", "&")
\r
212 xmlInput = xmlInput.replaceAll("<", "<")
\r
213 xmlInput = xmlInput.replaceAll(">", ">")
\r
214 log("DEBUG", "getPBGFList: xmlInput " + xmlInput,isDebugLogEnabled)
\r
215 ArrayList myNodes = new ArrayList()
\r
216 if(nodeExists(xmlInput,"nbnc-response-information")){
\r
217 def respInfo=getNodeXml(xmlInput,"nbnc-response-information", false)
\r
218 if(respInfo!=null){
\r
219 def fxml= new XmlSlurper().parseText(respInfo)
\r
220 fxml.'virtual-datacenter-list'.each { vdc ->
\r
221 //we only want to add two BGF per VDC, BGF1 and BGF2
\r
222 def routerList = vdc.'router-list'.first()
\r
223 routerList.each{ myList ->
\r
224 def physNodes = myList.'**'.findAll {it.'border-element-tangibility'.text() =~ /PHYSICAL/}
\r
227 if(nodeToAdd==null){
\r
230 def beid = nodeToAdd.'border-element-id'.text() +
\r
231 " " + nodeToAdd.'border-element-type'.text() +
\r
233 it.'border-element-id'.text() +
\r
234 " " + it.'border-element-type'.text()
\r
235 def mytag = nodeToAdd.'border-element-id'
\r
236 mytag[0].replaceBody(beid)
\r
239 def mytag = nodeToAdd.'vlan-id'
\r
240 def ind = mytag.text().indexOf('.')
\r
242 def vlan = mytag.text().substring(0,ind)
\r
243 mytag[0].replaceBody(vlan)
\r
245 myNodes.add(XmlUtil.serialize(nodeToAdd))
\r
257 def getPBGFList(xmlInput){
\r
258 getPBGFList("false", xmlInput)
\r
261 def String decodeXML(xml) {
\r
262 def String decodedXml = xml.replaceAll("&", "&")
\r
263 decodedXml = decodedXml.replaceAll("<", "<")
\r
264 decodedXml = decodedXml.replaceAll(">", ">")
\r
267 def getMetaVal(node, name){
\r
269 return node.'**'.find {it.metaname.text() == name}.metaval.text()
\r
270 }catch(Exception e){
\r
274 def getRelationshipVal(node, name){
\r
276 return node.'**'.find {it.'relationship-key'.text() == name}.'relationship-value'.text()
\r
277 }catch(Exception e){
\r
283 def log(logmode,logtxt,isDebugLogEnabled="false"){
\r
284 MsoLogger msoLogger = MsoLogger.getMsoLogger(MsoLogger.Catalog.BPEL);
\r
285 if ("INFO"==logmode) {
\r
286 msoLogger.info(MessageEnum.BPMN_GENERAL_EXCEPTION_ARG, logtxt);
\r
287 } else if ("WARN"==logmode) {
\r
288 // to see the warning text displayed in the log entry, the text must also be passed as arg0 (2nd argument) to invoke the correct MsoLogger warn() method
\r
289 msoLogger.warn (MessageEnum.BPMN_GENERAL_WARNING, logtxt, "BPMN", MsoLogger.getServiceName(), MsoLogger.ErrorCode.UnknownError, logtxt);
\r
290 } else if ("ERROR"==logmode) {
\r
291 // to see the error text displayed in the log entry, the text must also be passed as arg0 (2nd argument) to invoke the correct MsoLogger error() method
\r
292 msoLogger.error(MessageEnum.BPMN_GENERAL_EXCEPTION_ARG, logtxt, "BPMN", MsoLogger.getServiceName(), MsoLogger.ErrorCode.UnknownError, logtxt);
\r
295 BPMNLogger.debug(isDebugLogEnabled, logtxt);
\r
299 def logContext(requestId, serviceInstanceId){
\r
300 MsoLogger msoLogger = MsoLogger.getMsoLogger(MsoLogger.Catalog.BPEL);
\r
301 msoLogger.setLogContext(requestId, serviceInstanceId);
\r
304 def logMetrics(elapsedTime, logtxt){
\r
305 MsoLogger metricsLogger = MsoLogger.getMsoLogger(MsoLogger.Catalog.BPEL);
\r
307 metricsLogger.recordMetricEvent (elapsedTime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc,
\r
308 logtxt, "BPMN", MsoLogger.getServiceName(), null);
\r
311 def logAudit(logtxt){
\r
312 MsoLogger auditLogger = MsoLogger.getMsoLogger(MsoLogger.Catalog.BPEL);
\r
313 long startTime = System.currentTimeMillis();
\r
315 auditLogger.recordAuditEvent (startTime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc, logtxt);
\r
318 // headers: header - name-value
\r
319 def getHeaderNameValue(xmlInput, nameAttribute){
\r
321 if(xmlInput!=null){
\r
322 def xml= new XmlSlurper().parseText(xmlInput)
\r
323 rtn= xml.'**'.find {header->header.'@name'.text() == nameAttribute}.'@value'
\r
329 * Gets the children of the specified element.
\r
331 public String getChildNodes(xmlInput, element) {
\r
332 def xml= new XmlSlurper().parseText(xmlInput)
\r
333 def thisElement = xml.'**'.find {it.name() == element}
\r
334 StringBuilder out = new StringBuilder()
\r
335 if (thisElement != null) {
\r
336 thisElement.children().each() {
\r
337 String nodeAsText = removeXmlPreamble(XmlUtil.serialize(it))
\r
338 if (out.length() > 0) {
\r
339 out.append(System.lineSeparator())
\r
341 out.append(nodeAsText)
\r
344 return out.toString();
\r
348 * Encodes a value so it can be used inside an XML text element.
\r
349 * @param s the string to encode
\r
350 * @return the encoded string
\r
352 public String xmlEncode(Object value) {
\r
353 return XmlTool.encode(value)
\r
357 * Encodes a value so it can be used inside an XML attribute.
\r
358 * @param s the string to encode
\r
359 * @return the encoded string
\r
361 public String xmlEncodeAttr(Object value) {
\r
362 return XmlTool.encodeAttr(value)
\r
366 * Decodes XML entities in a string value
\r
367 * @param value a value with embedded XML entities
\r
368 * @return the decoded string
\r
370 public String xmlDecode(Object value) {
\r
371 return XmlTool.decode(value)
\r
375 * Removes the preamble, if present, from an XML document.
\r
376 * Also, for historical reasons, this also trims leading and trailing
\r
377 * whitespace from the resulting document. TODO: remove the trimming
\r
378 * and fix unit tests that depend on EXACT xml format.
\r
379 * @param xml the XML document
\r
380 * @return a possibly modified document
\r
382 public String removeXmlPreamble(def xml) {
\r
387 return XmlTool.removePreamble(xml).trim()
\r
391 * Removes namespaces and namespace declarations from an XML document.
\r
392 * @param xml the XML document
\r
393 * @return a possibly modified document
\r
395 public String removeXmlNamespaces(def xml) {
\r
396 return XmlTool.removeNamespaces(xml);
\r
400 * Use formatXml instead. Note: this method inserts an XML preamble.
\r
403 def formatXML(xmlInput) {
\r
404 def parseXml = null
\r
405 def formatXml = null
\r
406 if (xmlInput !=null) {
\r
407 parseXml = new XmlParser().parseText(xmlInput)
\r
408 formatXml = XmlUtil.serialize(parseXml)
\r
413 * Reformats an XML document. The result will not contain an XML preamble
\r
414 * or a trailing newline.
\r
415 * @param xml the XML document
\r
416 * @return a reformatted document
\r
418 public String formatXml(def xml) {
\r
419 return XmlTool.normalize(xml);
\r
422 // build single elements
\r
423 def buildElements(xmlInput, elementList, parentName) {
\r
426 if (parentName != "") {
\r
427 xmlBuild += "<tns2:"+parentName+">"
\r
429 if (xmlInput != null) {
\r
430 for (element in elementList) {
\r
431 def xml= new XmlSlurper().parseText(xmlInput)
\r
432 var = xml.'**'.find {it.name() == element}
\r
434 xmlBuild += "<tns2:"+element+">"+var.toString()+"</tns2:"+element+">"
\r
438 if (parentName != "") {
\r
439 xmlBuild += "</tns2:"+parentName+">"
\r
444 // build the Unbounded elements
\r
445 def buildElementsUnbounded(xmlInput, elementList, parentName) {
\r
446 def varParents = ""
\r
448 def xmlBuildUnbounded = ""
\r
449 if (xmlInput != null) {
\r
450 def xml= new XmlSlurper().parseText(xmlInput)
\r
451 varParents = xml.'**'.findAll {it.name() == parentName}
\r
452 //println " Unbounded ${parentName} - varParent.Size() - " + varParents.size()
\r
453 for (i in 0..varParents.size()-1) {
\r
454 if (parentName != "") {
\r
455 xmlBuildUnbounded += "<tns2:"+parentName+">"
\r
457 for (element in elementList) {
\r
458 var = varParents[i].'*'.find {it.name() == element}
\r
460 xmlBuildUnbounded += "<tns2:"+element+">"+var.toString()+"</tns2:"+element+">"
\r
461 //println " i = " + i + ", element: " + element + " = " + var.toString()
\r
464 if (parentName != "") {
\r
465 xmlBuildUnbounded += "</tns2:"+parentName+">"
\r
469 return xmlBuildUnbounded
\r
472 // Build l2-homing-information
\r
473 def buildL2HomingInformation(xmlInput) {
\r
474 def elementsL2HomingList = ["evc-name", "topology", "preferred-aic-clli"]
\r
475 def rebuildL2Home = ''
\r
476 if (xmlInput != null) {
\r
477 rebuildL2Home = buildElements(xmlInput, elementsL2HomingList, "l2-homing-information")
\r
479 return rebuildL2Home
\r
482 // Build internet-evc-access-information
\r
483 def buildInternetEvcAccessInformation(xmlInput) {
\r
484 def elementsInternetEvcAccessInformationList = ["internet-evc-speed-value", "internet-evc-speed-units", "ip-version"]
\r
485 def rebuildInternetEvcAccess = ''
\r
486 if (xmlInput != null) {
\r
487 rebuildInternetEvcAccess = buildElements(xmlInput, elementsInternetEvcAccessInformationList, "internet-evc-access-information")
\r
489 return rebuildInternetEvcAccess
\r
492 // Build ucpe-vms-service-information
\r
493 def buildUcpeVmsServiceInformation(xmlInput) {
\r
494 def rebuildUcpeVmsServiceInformation = ''
\r
495 if (xmlInput != null) {
\r
496 def ucpeVmsServiceInformation = getNodeXml(xmlInput, "ucpe-vms-service-information").drop(38).trim()
\r
497 rebuildUcpeVmsServiceInformation = "<tns2:ucpe-vms-service-information>"
\r
498 // transport-service-information
\r
499 rebuildUcpeVmsServiceInformation += "<tns2:transport-service-information>"
\r
500 def transportServiceInformation = getNodeXml(ucpeVmsServiceInformation, "transport-service-information").drop(38).trim()
\r
501 def elementsTransportServiceInformationList = ["transport-service-type"]
\r
502 rebuildUcpeVmsServiceInformation += buildElements(transportServiceInformation, elementsTransportServiceInformationList, "")
\r
504 def accessCircuitInfoList = ["access-circuit-id", "dual-mode"]
\r
505 rebuildUcpeVmsServiceInformation += buildElementsUnbounded(transportServiceInformation, accessCircuitInfoList, "access-circuit-info")
\r
506 } catch (Exception e) {
\r
507 log("ERROR", " Optional - Exception ACCESS-CIRCUIT-INFO - 'access-circuit-info' ")
\r
509 rebuildUcpeVmsServiceInformation += "</tns2:transport-service-information>"
\r
510 // ucpe-information
\r
511 def elementsUcpeInformationList = ["ucpe-host-name", "ucpe-activation-code", "out-of-band-management-modem" ]
\r
512 rebuildUcpeVmsServiceInformation += buildElements(ucpeVmsServiceInformation, elementsUcpeInformationList, "ucpe-information")
\r
514 rebuildUcpeVmsServiceInformation += "<tns2:vnf-list>"
\r
515 def vnfListList = ["vnf-instance-id", "vnf-sequence-number", "vnf-type", "vnf-vendor", "vnf-model", "vnf-id", "prov-status", "operational-state", "orchestration-status", "equipment-role" ]
\r
516 rebuildUcpeVmsServiceInformation += buildElementsUnbounded(ucpeVmsServiceInformation, vnfListList, "vnf-information")
\r
517 rebuildUcpeVmsServiceInformation += "</tns2:vnf-list>"
\r
518 rebuildUcpeVmsServiceInformation += "</tns2:ucpe-vms-service-information>"
\r
520 log("DEBUG", " rebuildUcpeVmsServiceInformation - " + rebuildUcpeVmsServiceInformation)
\r
521 return rebuildUcpeVmsServiceInformation
\r
524 // Build internet-service-change-details
\r
525 def buildInternetServiceChangeDetails(xmlInput) {
\r
526 def rebuildInternetServiceChangeDetails = ""
\r
527 if (xmlInput != null) {
\r
529 def internetServiceChangeDetails = getNodeXml(xmlInput, "internet-service-change-details").drop(38).trim()
\r
530 rebuildInternetServiceChangeDetails = "<tns:internet-service-change-details>"
\r
531 rebuildInternetServiceChangeDetails += buildElements(internetServiceChangeDetails, ["internet-evc-speed-value"], "")
\r
532 rebuildInternetServiceChangeDetails += buildElements(internetServiceChangeDetails, ["internet-evc-speed-units"], "")
\r
534 def tProvidedV4LanPublicPrefixesChangesList = ["request-index", "v4-next-hop-address", "v4-lan-public-prefix", "v4-lan-public-prefix-length"]
\r
535 rebuildInternetServiceChangeDetails += buildElementsUnbounded(internetServiceChangeDetails, tProvidedV4LanPublicPrefixesChangesList, "t-provided-v4-lan-public-prefixes")
\r
536 } catch (Exception e) {
\r
537 log("ERROR"," Optional - Exception in INTERNET-SERVICE-CHANGE-DETAILS 't-provided-v4-lan-public-prefixes ")
\r
540 def tProvidedV6LanPublicPrefixesChangesList = ["request-index", "v6-next-hop-address", "v6-lan-public-prefix", "v6-lan-public-prefix-length"]
\r
541 rebuildInternetServiceChangeDetails += buildElementsUnbounded(internetServiceChangeDetails, tProvidedV6LanPublicPrefixesChangesList, "t-provided-v6-lan-public-prefixes")
\r
542 } catch (Exception e) {
\r
543 log("ERROR"," Optional - Exception INTERNET-SERVICE-CHANGE-DETAILS 't-provided-v6-lan-public-prefixes ")
\r
545 rebuildInternetServiceChangeDetails += "</tns:internet-service-change-details>"
\r
546 } catch (Exception e) {
\r
547 log("ERROR", " Optional - Exception INTERNET-SERVICE-CHANGE-DETAILS 'internet-service-change-details' ")
\r
550 return rebuildInternetServiceChangeDetails
\r
554 def buildVrLan(xmlInput) {
\r
556 def rebuildVrLan = ''
\r
557 if (xmlInput != null) {
\r
559 rebuildVrLan = "<tns2:vr-lan>"
\r
560 def vrLan = getNodeXml(xmlInput, "vr-lan").drop(38).trim()
\r
561 rebuildVrLan += buildElements(vrLan, ["routing-protocol"], "")
\r
563 // vr-lan-interface
\r
564 def rebuildVrLanInterface = "<tns2:vr-lan-interface>"
\r
565 def vrLanInterface = getNodeXml(vrLan, "vr-lan-interface").drop(38).trim()
\r
566 rebuildVrLanInterface += buildVrLanInterfacePartial(vrLanInterface)
\r
569 def dhcp = getNodeXml(vrLan, "dhcp").drop(38).trim()
\r
570 def rebuildDhcp = buildDhcp(dhcp)
\r
571 rebuildVrLanInterface += rebuildDhcp
\r
574 def pat = getNodeXml(vrLan, "pat").drop(38).trim()
\r
575 def rebuildPat = buildPat(pat)
\r
576 rebuildVrLanInterface += rebuildPat
\r
579 def rebuildNat = ""
\r
581 def nat = getNodeXml(vrLan, "nat").drop(38).trim()
\r
582 rebuildNat = buildNat(nat)
\r
583 } catch (Exception e) {
\r
584 log("ERROR", " Optional - Exception 'nat' ")
\r
586 rebuildVrLanInterface += rebuildNat
\r
589 def firewallLite = getNodeXml(vrLan, "firewall-lite").drop(38).trim()
\r
590 def rebuildFirewallLite = buildFirewallLite(firewallLite)
\r
591 rebuildVrLanInterface += rebuildFirewallLite
\r
594 def rebuildStaticRoutes = ""
\r
596 def staticRoutes = getNodeXml(vrLan, "static-routes").drop(38).trim()
\r
597 rebuildStaticRoutes = buildStaticRoutes(staticRoutes)
\r
598 } catch (Exception e) {
\r
599 log("ERROR", " Optional - Exception 'static-routes' ")
\r
601 rebuildVrLanInterface += rebuildStaticRoutes
\r
603 rebuildVrLan += rebuildVrLanInterface
\r
604 rebuildVrLan += "</tns2:vr-lan-interface>"
\r
605 rebuildVrLan += "</tns2:vr-lan>"
\r
608 log("DEBUG", " rebuildVrLan - " + rebuildVrLan)
\r
609 return rebuildVrLan
\r
612 // Build vr-lan-interface
\r
613 def buildVrLanInterfacePartial(xmlInput) {
\r
614 def rebuildingVrLanInterface = ''
\r
615 if (xmlInput != null) {
\r
616 def vrLanInterfaceList = ["vr-designation", "v4-vr-lan-prefix", "v4-vr-lan-address", "v4-vr-lan-prefix-length", "v6-vr-lan-prefix", "v6-vr-lan-address", "v6-vr-lan-prefix-length", "v4-vce-loopback-address", "v6-vce-wan-address"]
\r
617 rebuildingVrLanInterface += buildElements(xmlInput, vrLanInterfaceList, "")
\r
618 rebuildingVrLanInterface += "<tns2:v4-public-lan-prefixes>"
\r
620 def tProvidedV4LanPublicPrefixes = getNodeXml(xmlInput, "v4-public-lan-prefixes").drop(38).trim()
\r
621 def tProvidedV4LanPublicPrefixesList = ["request-index", "v4-next-hop-address", "v4-lan-public-prefix", "v4-lan-public-prefix-length" ]
\r
622 rebuildingVrLanInterface += buildElementsUnbounded(xmlInput, tProvidedV4LanPublicPrefixesList, "t-provided-v4-lan-public-prefixes")
\r
623 } catch (Exception ex) {
\r
624 log("ERROR", " Optional - Exception VR-LAN INTERFACE 'v4-public-lan-prefixes' ")
\r
626 rebuildingVrLanInterface += "</tns2:v4-public-lan-prefixes>"
\r
627 rebuildingVrLanInterface += "<tns2:v6-public-lan-prefixes>"
\r
629 def tProvidedV6LanPublicPrefixes = getNodeXml(xmlInput, "v6-public-lan-prefixes").drop(38).trim()
\r
630 def tProvidedV6LanPublicPrefixesList = ["request-index", "v6-next-hop-address", "v6-lan-public-prefix", "v6-lan-public-prefix-length" ]
\r
631 rebuildingVrLanInterface += buildElementsUnbounded(xmlInput, tProvidedV6LanPublicPrefixesList, "t-provided-v6-lan-public-prefixes")
\r
632 } catch (Exception e) {
\r
633 log("ERROR", " Optional - Exception VR-LAN INTERFACE 'v6-public-lan-prefixes' ")
\r
635 rebuildingVrLanInterface += "</tns2:v6-public-lan-prefixes>"
\r
637 log("DEBUG", " rebuildingVrLanInterface - " + rebuildingVrLanInterface)
\r
638 return rebuildingVrLanInterface
\r
642 def buildDhcp(xmlInput) {
\r
643 def rebuildingDhcp = ''
\r
644 if (xmlInput != null) {
\r
645 def dhcpData = new XmlSlurper().parseText(xmlInput)
\r
646 rebuildingDhcp = "<tns2:dhcp>"
\r
647 def dhcpList1 = ["v4-dhcp-server-enabled", "v6-dhcp-server-enabled", "use-v4-default-pool", "v4-dhcp-default-pool-prefix", "v4-dhcp-default-pool-prefix-length"]
\r
648 rebuildingDhcp += buildElements(xmlInput, dhcpList1, "")
\r
650 def excludedV4DhcpAddressesFromDefaultPoolList = ["excluded-v4-address"]
\r
651 rebuildingDhcp += buildElementsUnbounded(xmlInput, excludedV4DhcpAddressesFromDefaultPoolList, "excluded-v4-dhcp-addresses-from-default-pool")
\r
652 } catch (Exception e) {
\r
653 log("ERROR", " Optional - Exception DHCP 'excluded-v4-dhcp-addresses-from-default-pool' ")
\r
656 def v4DhcpPools = dhcpData.'**'.findAll {it.name() == "v4-dhcp-pools"}
\r
657 def v4DhcpPoolsSize = v4DhcpPools.size()
\r
658 // println " v4DhcpPoolsSize = " + v4DhcpPools.size()
\r
659 for (i in 0..v4DhcpPoolsSize-1) {
\r
660 def v4DhcpPool = v4DhcpPools[i]
\r
661 def v4DhcpPoolXml = XmlUtil.serialize(v4DhcpPool)
\r
662 rebuildingDhcp += "<tns2:v4-dhcp-pools>"
\r
663 def v4DhcpPoolsList1 = ["v4-dhcp-pool-prefix", "v4-dhcp-pool-prefix-length" ]
\r
664 rebuildingDhcp += buildElements(v4DhcpPoolXml, v4DhcpPoolsList1, "")
\r
666 def excludedV4AddressesList = ["excluded-v4-address"]
\r
667 rebuildingDhcp += buildElementsUnbounded(v4DhcpPoolXml, excludedV4AddressesList, "excluded-v4-addresses")
\r
668 } catch (Exception e) {
\r
669 log("ERROR", " Optional - Exception DHCP 'excluded-v4-addresses' ")
\r
671 def v4DhcpPoolsList2 = ["v4-dhcp-relay-gateway-address", "v4-dhcp-relay-next-hop-address"]
\r
672 rebuildingDhcp += buildElements(v4DhcpPoolXml, v4DhcpPoolsList2, "")
\r
673 rebuildingDhcp += "</tns2:v4-dhcp-pools>"
\r
675 } catch (Exception e) {
\r
676 log("ERROR"," Optional - Exception DHCP 'v4-dhcp-pools' ")
\r
678 def dhcpList2 = ["use-v6-default-pool", "v6-dhcp-default-pool-prefix", "v6-dhcp-default-pool-prefix-length"]
\r
679 rebuildingDhcp += buildElements(xmlInput, dhcpList2, "")
\r
681 def excludedV6DhcpAddressesFromDdefaultPoolList = ["excluded-v6-address"]
\r
682 rebuildingDhcp += buildElementsUnbounded(xmlInput, excludedV6DhcpAddressesFromDdefaultPoolList, "excluded-v6-dhcp-addresses-from-default-pool")
\r
683 } catch (Exception e) {
\r
684 log("ERROR", " Optional - Exception DHCP 'excluded-v6-dhcp-addresses-from-default-pool' ")
\r
687 def v6DhcpPools = dhcpData.'**'.findAll {it.name() == "v6-dhcp-pools"}
\r
688 def v6DhcpPoolsSize = v6DhcpPools.size()
\r
689 //println " v6DhcpPoolsSize = " + v6DhcpPools.size()
\r
690 for (i in 0..v6DhcpPoolsSize-1) {
\r
691 def v6DhcpPool = v6DhcpPools[i]
\r
692 def v6DhcpPoolXml = XmlUtil.serialize(v6DhcpPool)
\r
693 rebuildingDhcp += "<tns2:v6-dhcp-pools>"
\r
694 def v6DhcpPoolsList1 = ["v6-dhcp-pool-prefix", "v6-dhcp-pool-prefix-length"]
\r
695 rebuildingDhcp += buildElements(v6DhcpPoolXml, v6DhcpPoolsList1, "")
\r
697 def excludedV6AddressesList = ["excluded-v6-address"]
\r
698 rebuildingDhcp += buildElementsUnbounded(v6DhcpPoolXml, excludedV6AddressesList, "excluded-v6-addresses")
\r
699 } catch (Exception e) {
\r
700 log("ERROR", " Optional - Exception DHCP 'excluded-v6-addresses' ")
\r
702 def v6DhcpPoolsList2 = ["v6-dhcp-relay-gateway-address", "v6-dhcp-relay-next-hop-address"]
\r
703 rebuildingDhcp += buildElements(v6DhcpPoolXml, v6DhcpPoolsList2, "")
\r
704 rebuildingDhcp += "</tns2:v6-dhcp-pools>"
\r
706 } catch (Exception e) {
\r
707 log("ERROR", " Optional - Exception DHCP 'v6-dhcp-pools' ")
\r
709 rebuildingDhcp += "</tns2:dhcp>"
\r
711 log("DEBUG", " rebuildingDhcp - " + rebuildingDhcp)
\r
712 return rebuildingDhcp
\r
716 def buildPat(xmlInput) {
\r
717 def rebuildingPat = ''
\r
718 if (xmlInput != null) {
\r
719 rebuildingPat = "<tns2:pat>"
\r
720 def patList = ["v4-pat-enabled", "use-v4-default-pool", "v4-pat-default-pool-prefix", "v4-pat-default-pool-prefix-length"]
\r
721 rebuildingPat += buildElements(xmlInput, patList, "")
\r
723 def v4PatPools = getNodeXml(xmlInput, "v4-pat-pools").drop(38).trim()
\r
724 def v4PatPoolsList = ["v4-pat-pool-prefix", "v4-pat-pool-prefix-length", "v4-pat-pool-next-hop-address"]
\r
725 rebuildingPat += buildElementsUnbounded(xmlInput, v4PatPoolsList, "v4-pat-pools")
\r
726 } catch (Exception e) {
\r
727 log("ERROR", " Optional - Exception 'v4-pat-pool-next-hop-address' ")
\r
729 rebuildingPat += "</tns2:pat>"
\r
731 log("DEBUG", " rebuildingPat - " + rebuildingPat)
\r
732 return rebuildingPat
\r
736 def buildNat(xmlInput) {
\r
737 def rebuildingNat = ''
\r
738 if (xmlInput != null) {
\r
739 rebuildingNat = "<tns2:nat>"
\r
740 rebuildingNat += buildElements(xmlInput, ["v4-nat-enabled"], "")
\r
742 def v4NatMappingEntries = getNodeXml(xmlInput, "v4-nat-mapping-entries").drop(38).trim()
\r
743 def v4NatMappingEntriesList = ["v4-nat-internal", "v4-nat-next-hop-address", "v4-nat-external"]
\r
744 rebuildingNat += buildElementsUnbounded(xmlInput, v4NatMappingEntriesList, "v4-nat-mapping-entries")
\r
745 } catch (Exception e) {
\r
746 log("ERROR", " Optional - Exception 'v4-nat-external' ")
\r
748 rebuildingNat += "</tns2:nat>"
\r
750 log("DEBUG", " rebuildingNat - " + rebuildingNat)
\r
751 return rebuildingNat
\r
754 // Build firewall-lite
\r
755 def buildFirewallLite(xmlInput) {
\r
756 def rebuildingFirewallLite = ''
\r
758 if (xmlInput != null) {
\r
760 def firewallLiteData = new XmlSlurper().parseText(xmlInput)
\r
761 rebuildingFirewallLite = "<tns2:firewall-lite>"
\r
762 def firewallLiteList = ["stateful-firewall-lite-v4-enabled", "stateful-firewall-lite-v6-enabled"]
\r
763 rebuildingFirewallLite += buildElements(xmlInput, firewallLiteList, "")
\r
766 def v4FirewallPacketFilters = firewallLiteData.'**'.findAll {it.name() == "v4-firewall-packet-filters"}
\r
767 def v4FirewallPacketFiltersSize = v4FirewallPacketFilters.size()
\r
768 //println " v4FirewallPacketFiltersSize = " + v4FirewallPacketFilters.size()
\r
769 for (i in 0..v4FirewallPacketFiltersSize-1) {
\r
770 def v4FirewallPacketFilter = v4FirewallPacketFilters[i]
\r
771 def v4FirewallPacketFilterXml = XmlUtil.serialize(v4FirewallPacketFilter)
\r
772 rebuildingFirewallLite += "<tns2:v4-firewall-packet-filters>"
\r
773 def v4FirewallPacketFiltersList = ["v4-firewall-prefix", "v4-firewall-prefix-length", "allow-icmp-ping"]
\r
774 rebuildingFirewallLite += buildElements(v4FirewallPacketFilterXml, v4FirewallPacketFiltersList, "")
\r
776 def udpPortsList = ["port-number"]
\r
777 rebuildingFirewallLite += buildElementsUnbounded(v4FirewallPacketFilterXml, udpPortsList, "udp-ports")
\r
778 } catch (Exception e) {
\r
779 log("ERROR", " Optional - Exception FIREWALL-LITE v4 'udp-ports' ")
\r
782 def tcpPortsList = ["port-number"]
\r
783 rebuildingFirewallLite += buildElementsUnbounded(v4FirewallPacketFilterXml, tcpPortsList, "tcp-ports")
\r
784 } catch (Exception e) {
\r
785 log("ERROR", " Optional - Exception FIREWALL-LITE v4 'tcp-ports' ")
\r
787 rebuildingFirewallLite += "</tns2:v4-firewall-packet-filters>"
\r
789 } catch (Exception e) {
\r
790 log("ERROR", " Optional - Exception FIREWALL-LITE 'v4-firewall-packet-filters' ")
\r
794 def v6FirewallPacketFilters = firewallLiteData.'**'.findAll {it.name() == "v6-firewall-packet-filters"}
\r
795 def v6FirewallPacketFiltersSize = v6FirewallPacketFilters.size()
\r
796 //println " v6FirewallPacketFiltersSize = " + v6FirewallPacketFilters.size()
\r
797 for (i in 0..v6FirewallPacketFiltersSize-1) {
\r
798 def v6FirewallPacketFilter = v6FirewallPacketFilters[i]
\r
799 def v6FirewallPacketFilterXml = XmlUtil.serialize(v6FirewallPacketFilter)
\r
800 rebuildingFirewallLite += "<tns2:v6-firewall-packet-filters>"
\r
801 def v6FirewallPacketFiltersList = ["v6-firewall-prefix", "v6-firewall-prefix-length", "allow-icmp-ping"]
\r
802 rebuildingFirewallLite += buildElements(v6FirewallPacketFilterXml, v6FirewallPacketFiltersList, "")
\r
804 def udpPortsList = ["port-number"]
\r
805 rebuildingFirewallLite += buildElementsUnbounded(v6FirewallPacketFilterXml, udpPortsList, "udp-ports")
\r
806 } catch (Exception e) {
\r
807 log("ERROR", " Optional - Exception FIREWALL-LITE v6 'udp-ports' ")
\r
810 def tcpPortsList = ["port-number"]
\r
811 rebuildingFirewallLite += buildElementsUnbounded(v6FirewallPacketFilterXml, tcpPortsList, "tcp-ports")
\r
812 } catch (Exception e) {
\r
813 log("ERROR", " Optional - Exception FIREWALL-LITE v6 'tcp-ports' ")
\r
815 rebuildingFirewallLite += "</tns2:v6-firewall-packet-filters>"
\r
817 } catch (Exception e) {
\r
818 log("ERROR", " Optional - Exception FIREWALL-LITE 'v6-firewall-packet-filters' ")
\r
820 rebuildingFirewallLite+= "</tns2:firewall-lite>"
\r
822 log("DEBUG", " rebuildingFirewallLite - " + rebuildingFirewallLite)
\r
823 return rebuildingFirewallLite
\r
826 def buildStaticRoutes(xmlInput) {
\r
827 def rebuildingStaticRoutes = ''
\r
828 if (xmlInput != null) {
\r
829 rebuildingStaticRoutes = "<tns2:static-routes>"
\r
830 def v4StaticRouteslist = ["v4-static-route-prefix","v4-static-route-prefix-length", "v4-next-hop-address"]
\r
831 rebuildingStaticRoutes += buildElementsUnbounded(xmlInput, v4StaticRouteslist, "v4-static-routes")
\r
832 def v6StaticRouteslist = ["v6-static-route-prefix","v6-static-route-prefix-length", "v6-next-hop-address"]
\r
833 rebuildingStaticRoutes += buildElementsUnbounded(xmlInput, v6StaticRouteslist, "v6-static-routes")
\r
834 rebuildingStaticRoutes += "</tns2:static-routes>"
\r
836 log("DEBUG", " rebuildingStaticRoutes - " + rebuildingStaticRoutes)
\r
837 return rebuildingStaticRoutes
\r
840 public String generateCurrentTimeInUtc(){
\r
841 final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
\r
842 sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
\r
843 final String utcTime = sdf.format(new Date());
\r
847 public String generateCurrentTimeInGMT(){
\r
848 final SimpleDateFormat sdf = new SimpleDateFormat("E, d MMM yyyy h:m:s z");
\r
849 sdf.setTimeZone(TimeZone.getTimeZone("GMT"));
\r
850 final String utcTime = sdf.format(new Date());
\r
856 * @param encryptedAuth: encrypted credentials from urn properties
\r
857 * @param msoKey: key to use to decrypt from urn properties
\r
858 * @return base 64 encoded basic auth credentials
\r
860 def getBasicAuth(encryptedAuth, msoKey){
\r
861 if ((encryptedAuth == null || encryptedAuth.isEmpty()) || (msoKey == null || msoKey.isEmpty()))
\r
864 def auth = decrypt(encryptedAuth, msoKey)
\r
865 byte[] encoded = Base64.encodeBase64(auth.getBytes())
\r
866 String encodedString = new String(encoded)
\r
867 encodedString = "Basic " + encodedString
\r
868 return encodedString
\r
869 } catch (Exception ex) {
\r
870 log("ERROR", "Unable to encode basic auth")
\r
875 def encrypt(toEncrypt, msokey){
\r
877 String result = CryptoUtils.encrypt(toEncrypt, msokey);
\r
880 catch (Exception e) {
\r
881 log("ERROR", "Failed to encrypt credentials")
\r
885 def decrypt(toDecrypt, msokey){
\r
887 String result = CryptoUtils.decrypt(toDecrypt, msokey);
\r
890 catch (Exception e) {
\r
891 log("ERROR", "Failed to decrypt credentials")
\r
897 * Return URL with qualified host name (if any) or urn mapping
\r
898 * @param String url from urn mapping
\r
899 * @return String url with qualified host name
\r
901 public String getQualifiedHostNameForCallback(String urnCallbackUrl) {
\r
902 def callbackUrlToUse = urnCallbackUrl
\r
904 //swap host name with qualified host name from the jboss properties
\r
905 def qualifiedHostName = System.getProperty("jboss.qualified.host.name")
\r
906 if(qualifiedHostName!=null){
\r
907 log("DEBUG", "qualifiedHostName:\n" + qualifiedHostName)
\r
908 callbackUrlToUse = callbackUrlToUse.replaceAll("(http://)(.*)(:28080*)", {orig, first, torepl, last -> "${first}${qualifiedHostName}${last}"})
\r
910 }catch(Exception e){
\r
911 log("DEBUG", "unable to grab qualified host name, using what's in urn properties for callbackurl. Exception was: " + e.printStackTrace())
\r
913 return callbackUrlToUse
\r
918 * Retrieves text context of the element if the element exists, returns empty string otherwise
\r
919 * @param com.sun.org.apache.xerces.internal.dom.DeferredElementNSImpl element to parse
\r
920 * param String tagName tagName
\r
921 * @return String text content of the element
\r
923 public String getElementText(Element element, String tagName) {
\r
925 org.w3c.dom.NodeList nodeList = element.getElementsByTagNameNS("*", tagName)
\r
926 if (nodeList != null && nodeList.length > 0) {
\r
927 text = nodeList.item(0).getTextContent()
\r
934 * Find the lowest unused module-index value in a given xml
\r
936 public String getLowestUnusedIndex(String xml) {
\r
937 if (xml == null || xml.isEmpty()) {
\r
940 def moduleIndexList = getMultNodes(xml, "module-index")
\r
941 if (moduleIndexList == null || moduleIndexList.size() == 0) {
\r
944 def sortedModuleIndexList = moduleIndexList.sort { a, b -> a.compareTo b }
\r
946 for (i in 0..sortedModuleIndexList.size()-1) {
\r
947 if (Integer.parseInt(sortedModuleIndexList[i]) != i) {
\r
948 return i.toString()
\r
951 return sortedModuleIndexList.size().toString()
\r
954 * This utility checks if there is transaction id already present in MDC.
\r
955 * If found, it returns same else creates new, sets in MDC for future use before returning
\r
956 * @return String RequestId in UUID format.
\r
958 public String getRequestID()
\r
960 String requestId = MDC.get("RequestId")
\r
961 if(requestId == null || requestId.isEmpty())
\r
963 requestId = java.util.UUID.randomUUID()
\r
964 MDC.put("RequestId",requestId)
\r
965 log("DEBUG","MsoUtils - Created new RequestId: " + requestId)
\r
969 log("DEBUG","MsoUtils - Using existing RequestId: " + requestId)
\r