X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-rest-connector%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fsal%2Frestconf%2Fimpl%2FRestconfImpl.xtend;h=cbfc3edf2cbf10ba164820aba15aa82749f0dbdd;hb=c61d22e4dc73fdaba09aa8c0b189ea7459679e03;hp=a65c0ff97aa73324083a0826186462d59c7006c6;hpb=54bed4dd6dfbada9a8e2ddf70ca84952aec3f55a;p=controller.git diff --git a/opendaylight/md-sal/sal-rest-connector/src/main/java/org/opendaylight/controller/sal/restconf/impl/RestconfImpl.xtend b/opendaylight/md-sal/sal-rest-connector/src/main/java/org/opendaylight/controller/sal/restconf/impl/RestconfImpl.xtend index a65c0ff97a..cbfc3edf2c 100644 --- a/opendaylight/md-sal/sal-rest-connector/src/main/java/org/opendaylight/controller/sal/restconf/impl/RestconfImpl.xtend +++ b/opendaylight/md-sal/sal-rest-connector/src/main/java/org/opendaylight/controller/sal/restconf/impl/RestconfImpl.xtend @@ -1,19 +1,28 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ package org.opendaylight.controller.sal.restconf.impl +import com.google.common.base.Preconditions +import java.net.URI import java.util.ArrayList import java.util.HashMap import java.util.List -import java.util.Set import javax.ws.rs.core.Response import org.opendaylight.controller.md.sal.common.api.TransactionStatus +import org.opendaylight.controller.sal.core.api.mount.MountInstance import org.opendaylight.controller.sal.rest.api.RestconfService import org.opendaylight.yangtools.yang.common.QName +import org.opendaylight.yangtools.yang.common.RpcResult import org.opendaylight.yangtools.yang.data.api.CompositeNode import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.InstanceIdentifierBuilder import org.opendaylight.yangtools.yang.data.api.Node import org.opendaylight.yangtools.yang.data.impl.NodeFactory -import org.opendaylight.yangtools.yang.model.api.ChoiceNode import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode import org.opendaylight.yangtools.yang.model.api.DataNodeContainer import org.opendaylight.yangtools.yang.model.api.DataSchemaNode @@ -21,15 +30,17 @@ import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode import org.opendaylight.yangtools.yang.model.api.ListSchemaNode import org.opendaylight.yangtools.yang.model.api.Module +import org.opendaylight.yangtools.yang.model.api.RpcDefinition +import org.opendaylight.yangtools.yang.model.api.SchemaContext import org.opendaylight.yangtools.yang.model.api.TypeDefinition import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition import static javax.ws.rs.core.Response.Status.* -import org.opendaylight.yangtools.yang.model.api.RpcDefinition class RestconfImpl implements RestconfService { val static RestconfImpl INSTANCE = new RestconfImpl + val static MOUNT_POINT_MODULE_NAME = "ietf-netconf" @Property BrokerFacade broker @@ -47,11 +58,6 @@ class RestconfImpl implements RestconfService { return INSTANCE } - override readAllData() { -// return broker.readOperationalData("".toInstanceIdentifier.getInstanceIdentifier); - throw new UnsupportedOperationException("Reading all data is currently not supported.") - } - override getModules() { throw new UnsupportedOperationException("TODO: auto-generated method stub") } @@ -63,11 +69,14 @@ class RestconfImpl implements RestconfService { override invokeRpc(String identifier, CompositeNode payload) { return callRpc(identifier.rpcDefinition, payload) } - - override invokeRpc(String identifier) { + + override invokeRpc(String identifier, String noPayload) { + if (!noPayload.nullOrEmpty) { + throw new ResponseException(UNSUPPORTED_MEDIA_TYPE, "Content-Type contains unsupported Media Type."); + } return callRpc(identifier.rpcDefinition, null) } - + private def StructuredData callRpc(RpcDefinition rpc, CompositeNode payload) { if (rpc === null) { throw new ResponseException(NOT_FOUND, "RPC does not exist."); @@ -88,54 +97,80 @@ class RestconfImpl implements RestconfService { if (rpcResult.result === null) { return null } - return new StructuredData(rpcResult.result, rpc.output) - } - - override readData(String identifier) { - val instanceIdentifierWithSchemaNode = identifier.resolveInstanceIdentifier - val data = broker.readOperationalData(instanceIdentifierWithSchemaNode.getInstanceIdentifier); - return new StructuredData(data, instanceIdentifierWithSchemaNode.schemaNode) + return new StructuredData(rpcResult.result, rpc.output, null) } override readConfigurationData(String identifier) { - val instanceIdentifierWithSchemaNode = identifier.resolveInstanceIdentifier - val data = broker.readConfigurationData(instanceIdentifierWithSchemaNode.getInstanceIdentifier); - return new StructuredData(data, instanceIdentifierWithSchemaNode.schemaNode) + val iiWithData = identifier.toInstanceIdentifier + var CompositeNode data = null; + if (iiWithData.mountPoint !== null) { + data = broker.readConfigurationDataBehindMountPoint(iiWithData.mountPoint, iiWithData.getInstanceIdentifier) + } else { + data = broker.readConfigurationData(iiWithData.getInstanceIdentifier); + } + return new StructuredData(data, iiWithData.schemaNode, iiWithData.mountPoint) } override readOperationalData(String identifier) { - val instanceIdentifierWithSchemaNode = identifier.resolveInstanceIdentifier - val data = broker.readOperationalData(instanceIdentifierWithSchemaNode.getInstanceIdentifier); - return new StructuredData(data, instanceIdentifierWithSchemaNode.schemaNode) - } - - override updateConfigurationDataLegacy(String identifier, CompositeNode payload) { - updateConfigurationData(identifier, payload); + val iiWithData = identifier.toInstanceIdentifier + var CompositeNode data = null; + if (iiWithData.mountPoint !== null) { + data = broker.readOperationalDataBehindMountPoint(iiWithData.mountPoint, iiWithData.getInstanceIdentifier) + } else { + data = broker.readOperationalData(iiWithData.getInstanceIdentifier); + } + return new StructuredData(data, iiWithData.schemaNode, iiWithData.mountPoint) } override updateConfigurationData(String identifier, CompositeNode payload) { - val identifierWithSchemaNode = identifier.resolveInstanceIdentifier - val value = normalizeNode(payload, identifierWithSchemaNode.schemaNode, identifierWithSchemaNode.mountPoint) - val status = broker.commitConfigurationDataPut(identifierWithSchemaNode.instanceIdentifier, value).get(); + val iiWithData = identifier.toInstanceIdentifier + val value = normalizeNode(payload, iiWithData.schemaNode, iiWithData.mountPoint) + var RpcResult status = null + if (iiWithData.mountPoint !== null) { + status = broker.commitConfigurationDataPutBehindMountPoint(iiWithData.mountPoint, + iiWithData.instanceIdentifier, value).get() + } else { + status = broker.commitConfigurationDataPut(iiWithData.instanceIdentifier, value).get(); + } switch status.result { case TransactionStatus.COMMITED: Response.status(OK).build default: Response.status(INTERNAL_SERVER_ERROR).build } } - override createConfigurationDataLegacy(String identifier, CompositeNode payload) { - createConfigurationData(identifier, payload); - } - override createConfigurationData(String identifier, CompositeNode payload) { - val uncompleteIdentifierWithSchemaNode = identifier.resolveInstanceIdentifier - var schemaNode = (uncompleteIdentifierWithSchemaNode.schemaNode as DataNodeContainer).getSchemaChildNode(payload) - if (schemaNode === null) { - schemaNode = payload.findModule(uncompleteIdentifierWithSchemaNode.instanceIdentifier)?.getSchemaChildNode(payload) - } - val value = normalizeNode(payload, schemaNode, uncompleteIdentifierWithSchemaNode.instanceIdentifier) - val completeIdentifierWithSchemaNode = uncompleteIdentifierWithSchemaNode.addLastIdentifierFromData(value, schemaNode) - val status = broker.commitConfigurationDataPost(completeIdentifierWithSchemaNode.instanceIdentifier, value)?.get(); + if (payload.namespace === null) { + throw new ResponseException(BAD_REQUEST, + "Data has bad format. Root element node must have namespace (XML format) or module name(JSON format)"); + } + var InstanceIdWithSchemaNode iiWithData; + var CompositeNode value; + if (payload.representsMountPointRootData) { // payload represents mount point data and URI represents path to the mount point + if (identifier.endsWithMountPoint) { + throw new ResponseException(BAD_REQUEST, + "URI has bad format. URI should be without \"" + ControllerContext.MOUNT + "\" for POST operation."); + } + val completIdentifier = identifier.addMountPointIdentifier + iiWithData = completIdentifier.toInstanceIdentifier + value = normalizeNode(payload, iiWithData.schemaNode, iiWithData.mountPoint) + } else { + val uncompleteInstIdWithData = identifier.toInstanceIdentifier + val parentSchema = uncompleteInstIdWithData.schemaNode as DataNodeContainer + val module = uncompleteInstIdWithData.mountPoint.findModule(payload) + if (module === null) { + throw new ResponseException(BAD_REQUEST, "Module was not found for \"" + payload.namespace + "\"") + } + val schemaNode = parentSchema.findInstanceDataChildByNameAndNamespace(payload.name, module.namespace) + value = normalizeNode(payload, schemaNode, uncompleteInstIdWithData.mountPoint) + iiWithData = uncompleteInstIdWithData.addLastIdentifierFromData(value, schemaNode) + } + var RpcResult status = null + if (iiWithData.mountPoint !== null) { + status = broker.commitConfigurationDataPostBehindMountPoint(iiWithData.mountPoint, + iiWithData.instanceIdentifier, value)?.get(); + } else { + status = broker.commitConfigurationDataPost(iiWithData.instanceIdentifier, value)?.get(); + } if (status === null) { return Response.status(ACCEPTED).build } @@ -144,12 +179,27 @@ class RestconfImpl implements RestconfService { default: Response.status(INTERNAL_SERVER_ERROR).build } } - + override createConfigurationData(CompositeNode payload) { - val schemaNode = payload.findModule(null)?.getSchemaChildNode(payload) + if (payload.namespace === null) { + throw new ResponseException(BAD_REQUEST, + "Data has bad format. Root element node must have namespace (XML format) or module name(JSON format)"); + } + val module = findModule(null, payload) + if (module === null) { + throw new ResponseException(BAD_REQUEST, + "Data has bad format. Root element node has incorrect namespace (XML format) or module name(JSON format)"); + } + val schemaNode = module.findInstanceDataChildByNameAndNamespace(payload.name, module.namespace) val value = normalizeNode(payload, schemaNode, null) - val identifierWithSchemaNode = addLastIdentifierFromData(null, value, schemaNode) - val status = broker.commitConfigurationDataPost(identifierWithSchemaNode.instanceIdentifier, value)?.get(); + val iiWithData = addLastIdentifierFromData(null, value, schemaNode) + var RpcResult status = null + if (iiWithData.mountPoint !== null) { + status = broker.commitConfigurationDataPostBehindMountPoint(iiWithData.mountPoint, + iiWithData.instanceIdentifier, value)?.get(); + } else { + status = broker.commitConfigurationDataPost(iiWithData.instanceIdentifier, value)?.get(); + } if (status === null) { return Response.status(ACCEPTED).build } @@ -158,38 +208,53 @@ class RestconfImpl implements RestconfService { default: Response.status(INTERNAL_SERVER_ERROR).build } } - + override deleteConfigurationData(String identifier) { - val instanceIdentifierWithSchemaNode = identifier.resolveInstanceIdentifier - val status = broker.commitConfigurationDataDelete(instanceIdentifierWithSchemaNode.getInstanceIdentifier).get; + val iiWithData = identifier.toInstanceIdentifier + var RpcResult status = null + if (iiWithData.mountPoint !== null) { + status = broker.commitConfigurationDataDeleteBehindMountPoint(iiWithData.mountPoint, + iiWithData.getInstanceIdentifier).get; + } else { + status = broker.commitConfigurationDataDelete(iiWithData.getInstanceIdentifier).get; + } switch status.result { case TransactionStatus.COMMITED: Response.status(OK).build default: Response.status(INTERNAL_SERVER_ERROR).build } } - private def InstanceIdWithSchemaNode resolveInstanceIdentifier(String identifier) { - val identifierWithSchemaNode = identifier.toInstanceIdentifier - if (identifierWithSchemaNode === null) { - throw new ResponseException(BAD_REQUEST, "URI has bad format"); - } - return identifierWithSchemaNode + private def dispatch URI namespace(CompositeNode data) { + return data.nodeType.namespace } - private def dispatch Module findModule(CompositeNode data, InstanceIdentifier partialPath) { - if (partialPath !== null && !partialPath.path.empty) { - return data.nodeType.namespace.findModuleByNamespace(partialPath) + private def dispatch URI namespace(CompositeNodeWrapper data) { + return data.namespace + } + + private def dispatch String localName(CompositeNode data) { + return data.nodeType.localName + } + + private def dispatch String localName(CompositeNodeWrapper data) { + return data.localName + } + + private def dispatch Module findModule(MountInstance mountPoint, CompositeNode data) { + if (mountPoint !== null) { + return mountPoint.findModuleByNamespace(data.nodeType.namespace) } else { - return data.nodeType.namespace.findModuleByNamespace + return findModuleByNamespace(data.nodeType.namespace) } } - private def dispatch Module findModule(CompositeNodeWrapper data, InstanceIdentifier partialPath) { + private def dispatch Module findModule(MountInstance mountPoint, CompositeNodeWrapper data) { + Preconditions.checkNotNull(data.namespace) var Module module = null; - if (partialPath !== null && !partialPath.path.empty) { - module = data.namespace.findModuleByNamespace(partialPath) // namespace from XML + if (mountPoint !== null) { + module = mountPoint.findModuleByNamespace(data.namespace) // namespace from XML if (module === null) { - module = data.namespace.toString.findModuleByName(partialPath) // namespace (module name) from JSON + module = mountPoint.findModuleByName(data.namespace.toString) // namespace (module name) from JSON } } else { module = data.namespace.findModuleByNamespace // namespace from XML @@ -199,19 +264,20 @@ class RestconfImpl implements RestconfService { } return module } - - private def dispatch DataSchemaNode getSchemaChildNode(DataNodeContainer parentSchemaNode, CompositeNode data) { - return parentSchemaNode?.getDataChildByName(data.nodeType.localName) + + private def dispatch getName(CompositeNode data) { + return data.nodeType.localName } - - private def dispatch DataSchemaNode getSchemaChildNode(DataNodeContainer parentSchemaNode, CompositeNodeWrapper data) { - return parentSchemaNode?.getDataChildByName(data.localName) + + private def dispatch getName(CompositeNodeWrapper data) { + return data.localName } - private def InstanceIdWithSchemaNode addLastIdentifierFromData(InstanceIdWithSchemaNode identifierWithSchemaNode, CompositeNode data, DataSchemaNode schemaOfData) { + private def InstanceIdWithSchemaNode addLastIdentifierFromData(InstanceIdWithSchemaNode identifierWithSchemaNode, + CompositeNode data, DataSchemaNode schemaOfData) { val iiOriginal = identifierWithSchemaNode?.instanceIdentifier - var InstanceIdentifierBuilder iiBuilder = null - if (iiOriginal === null) { + var InstanceIdentifierBuilder iiBuilder = null + if (iiOriginal === null) { iiBuilder = InstanceIdentifier.builder } else { iiBuilder = InstanceIdentifier.builder(iiOriginal) @@ -230,15 +296,37 @@ class RestconfImpl implements RestconfService { for (key : listNode.keyDefinition) { val dataNodeKeyValueObject = dataNode.getSimpleNodesByName(key.localName)?.head?.value if (dataNodeKeyValueObject === null) { - throw new ResponseException(BAD_REQUEST, "Data contains list \"" + dataNode.nodeType.localName + "\" which does not contain key: \"" + key.localName + "\"") + throw new ResponseException(BAD_REQUEST, + "Data contains list \"" + dataNode.nodeType.localName + "\" which does not contain key: \"" + + key.localName + "\"") } keyValues.put(key, dataNodeKeyValueObject); } return keyValues } - private def CompositeNode normalizeNode(CompositeNode node, DataSchemaNode schema, InstanceIdentifier mountPoint) { - if (schema !== null && !schema.containerOrList) { + private def endsWithMountPoint(String identifier) { + return (identifier.endsWith(ControllerContext.MOUNT) || identifier.endsWith(ControllerContext.MOUNT + "/")) + } + + private def representsMountPointRootData(CompositeNode data) { + return ((data.namespace == SchemaContext.NAME.namespace || data.namespace == MOUNT_POINT_MODULE_NAME) && + data.localName == SchemaContext.NAME.localName) + } + + private def addMountPointIdentifier(String identifier) { + if (identifier.endsWith("/")) { + return identifier + ControllerContext.MOUNT + } + return identifier + "/" + ControllerContext.MOUNT + } + + private def CompositeNode normalizeNode(CompositeNode node, DataSchemaNode schema, MountInstance mountPoint) { + if (schema === null) { + throw new ResponseException(INTERNAL_SERVER_ERROR, + "Data schema node was not found for " + node?.nodeType?.localName) + } + if (!(schema instanceof DataNodeContainer)) { throw new ResponseException(BAD_REQUEST, "Root element has to be container or list yang datatype."); } if (node instanceof CompositeNodeWrapper) { @@ -250,45 +338,58 @@ class RestconfImpl implements RestconfService { return node } - private def isContainerOrList(DataSchemaNode schemaNode) { - return (schemaNode instanceof ContainerSchemaNode) || (schemaNode instanceof ListSchemaNode) - } - private def void normalizeNode(NodeWrapper nodeBuilder, DataSchemaNode schema, QName previousAugment, - InstanceIdentifier mountPoint) { + MountInstance mountPoint) { if (schema === null) { throw new ResponseException(BAD_REQUEST, "Data has bad format.\n\"" + nodeBuilder.localName + "\" does not exist in yang schema."); } - var validQName = schema.QName - var currentAugment = previousAugment; - if (schema.augmenting) { - currentAugment = schema.QName - } else if (previousAugment !== null && schema.QName.namespace !== previousAugment.namespace) { - validQName = QName.create(currentAugment, schema.QName.localName); - } - var moduleName = controllerContext.findModuleNameByNamespace(validQName.namespace); - if (moduleName === null && mountPoint !== null && !mountPoint.path.empty) { - moduleName = controllerContext.findModuleByNamespace(validQName.namespace, mountPoint)?.name - } - if (nodeBuilder.namespace === null || nodeBuilder.namespace == validQName.namespace || - nodeBuilder.namespace.toString == moduleName) { - nodeBuilder.qname = validQName + + var QName currentAugment; + if (nodeBuilder.qname !== null) { + currentAugment = previousAugment } else { - throw new ResponseException(BAD_REQUEST, - "Data has bad format.\nIf data is in XML format then namespace for \"" + nodeBuilder.localName + - "\" should be \"" + schema.QName.namespace + "\".\nIf data is in Json format then module name for \"" + - nodeBuilder.localName + "\" should be \"" + moduleName + "\"."); + currentAugment = normalizeNodeName(nodeBuilder, schema, previousAugment, mountPoint) + if (nodeBuilder.qname === null) { + throw new ResponseException(BAD_REQUEST, + "Data has bad format.\nIf data is in XML format then namespace for \"" + nodeBuilder.localName + + "\" should be \"" + schema.QName.namespace + "\".\n" + + "If data is in JSON format then module name for \"" + nodeBuilder.localName + + "\" should be corresponding to namespace \"" + schema.QName.namespace + "\"."); + } } if (nodeBuilder instanceof CompositeNodeWrapper) { val List> children = (nodeBuilder as CompositeNodeWrapper).getValues for (child : children) { - normalizeNode(child, - findFirstSchemaByLocalName(child.localName, (schema as DataNodeContainer).childNodes), - currentAugment, mountPoint) + val potentialSchemaNodes = (schema as DataNodeContainer).findInstanceDataChildrenByName(child.localName) + if (potentialSchemaNodes.size > 1 && child.namespace === null) { + val StringBuilder namespacesOfPotentialModules = new StringBuilder; + for (potentialSchemaNode : potentialSchemaNodes) { + namespacesOfPotentialModules.append(" ").append(potentialSchemaNode.QName.namespace.toString).append("\n") + } + throw new ResponseException(BAD_REQUEST, + "Node \"" + child.localName + "\" is added as augment from more than one module. " + + "Therefore node must have namespace (XML format) or module name (JSON format)." + + "\nThe node is added as augment from modules with namespaces:\n" + namespacesOfPotentialModules) + } + var rightNodeSchemaFound = false + for (potentialSchemaNode : potentialSchemaNodes) { + if (!rightNodeSchemaFound) { + val potentialCurrentAugment = normalizeNodeName(child, potentialSchemaNode, currentAugment, + mountPoint) + if (child.qname !== null) { + normalizeNode(child, potentialSchemaNode, potentialCurrentAugment, mountPoint) + rightNodeSchemaFound = true + } + } + } + if (!rightNodeSchemaFound) { + throw new ResponseException(BAD_REQUEST, + "Schema node \"" + child.localName + "\" was not found in module.") + } } - if(schema instanceof ListSchemaNode) { + if (schema instanceof ListSchemaNode) { val listKeys = (schema as ListSchemaNode).keyDefinition for (listKey : listKeys) { var foundKey = false @@ -299,7 +400,8 @@ class RestconfImpl implements RestconfService { } if (!foundKey) { throw new ResponseException(BAD_REQUEST, - "Missing key in URI \"" + listKey.localName + "\" of list \"" + schema.QName.localName + "\"") + "Missing key in URI \"" + listKey.localName + "\" of list \"" + schema.QName.localName + + "\"") } } } @@ -307,14 +409,14 @@ class RestconfImpl implements RestconfService { val simpleNode = (nodeBuilder as SimpleNodeWrapper) val value = simpleNode.value var inputValue = value; - + if (schema.typeDefinition instanceof IdentityrefTypeDefinition) { if (value instanceof String) { - inputValue = new IdentityValuesDTO(validQName.namespace.toString, value as String, null) - } // else value is instance of ValuesDTO + inputValue = new IdentityValuesDTO(nodeBuilder.namespace.toString, value as String, null) + } // else value is already instance of IdentityValuesDTO } - val outputValue = RestCodec.from(schema.typeDefinition)?.deserialize(inputValue); + val outputValue = RestCodec.from(schema.typeDefinition, mountPoint)?.deserialize(inputValue); simpleNode.setValue(outputValue) } else if (nodeBuilder instanceof EmptyNodeWrapper) { val emptyNodeBuilder = nodeBuilder as EmptyNodeWrapper @@ -343,25 +445,27 @@ class RestconfImpl implements RestconfService { } baseType } - - private def DataSchemaNode findFirstSchemaByLocalName(String localName, Set schemas) { - for (schema : schemas) { - if (schema instanceof ChoiceNode) { - for (caze : (schema as ChoiceNode).cases) { - val result = findFirstSchemaByLocalName(localName, caze.childNodes) - if (result !== null) { - return result - } - } - } else { - val result = schemas.findFirst[n|n.QName.localName.equals(localName)] - if (result !== null) { - return result; - - } - } + + private def QName normalizeNodeName(NodeWrapper nodeBuilder, DataSchemaNode schema, QName previousAugment, + MountInstance mountPoint) { + var validQName = schema.QName + var currentAugment = previousAugment; + if (schema.augmenting) { + currentAugment = schema.QName + } else if (previousAugment !== null && schema.QName.namespace !== previousAugment.namespace) { + validQName = QName.create(currentAugment, schema.QName.localName); + } + var String moduleName = null; + if (mountPoint === null) { + moduleName = controllerContext.findModuleNameByNamespace(validQName.namespace); + } else { + moduleName = controllerContext.findModuleNameByNamespace(mountPoint, validQName.namespace) + } + if (nodeBuilder.namespace === null || nodeBuilder.namespace == validQName.namespace || + nodeBuilder.namespace.toString == moduleName || nodeBuilder.namespace == MOUNT_POINT_MODULE_NAME) { + nodeBuilder.qname = validQName } - return null + return currentAugment } }