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%2FControllerContext.xtend;h=c2b0ae8bdbb716580b1197108d0e91168b3d6ef0;hb=9b5e23126a416565449279462df8dcede442fefd;hp=49b997fa50f5b75767dc368923cf3c4b159ac3c6;hpb=ec885a4eba20a0b75fb74f93535398da75d43e48;p=controller.git diff --git a/opendaylight/md-sal/sal-rest-connector/src/main/java/org/opendaylight/controller/sal/restconf/impl/ControllerContext.xtend b/opendaylight/md-sal/sal-rest-connector/src/main/java/org/opendaylight/controller/sal/restconf/impl/ControllerContext.xtend index 49b997fa50..b26810347c 100644 --- a/opendaylight/md-sal/sal-rest-connector/src/main/java/org/opendaylight/controller/sal/restconf/impl/ControllerContext.xtend +++ b/opendaylight/md-sal/sal-rest-connector/src/main/java/org/opendaylight/controller/sal/restconf/impl/ControllerContext.xtend @@ -1,6 +1,7 @@ package org.opendaylight.controller.sal.restconf.impl import com.google.common.collect.BiMap +import com.google.common.collect.FluentIterable import com.google.common.collect.HashBiMap import java.net.URI import java.net.URLDecoder @@ -8,52 +9,144 @@ import java.net.URLEncoder import java.util.HashMap import java.util.List import java.util.Map +import java.util.concurrent.ConcurrentHashMap +import org.opendaylight.controller.sal.core.api.model.SchemaServiceListener +import org.opendaylight.controller.sal.core.api.mount.MountService +import org.opendaylight.controller.sal.rest.impl.RestUtil +import org.opendaylight.controller.sal.rest.impl.RestconfProvider import org.opendaylight.yangtools.yang.common.QName import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.InstanceIdentifierBuilder import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument +import org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodec import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode 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 +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.type.IdentityrefTypeDefinition +import org.slf4j.LoggerFactory import static com.google.common.base.Preconditions.* +import static javax.ws.rs.core.Response.Status.* +import org.opendaylight.controller.sal.core.api.mount.MountInstance -class ControllerContext { +class ControllerContext implements SchemaServiceListener { + val static LOG = LoggerFactory.getLogger(ControllerContext) + val static ControllerContext INSTANCE = new ControllerContext + val static NULL_VALUE = "null" + val static MOUNT_MODULE = "yang-ext" + val static MOUNT_NODE = "mount" + public val static MOUNT = "yang-ext:mount" @Property - SchemaContext schemas; + var SchemaContext globalSchema; + + @Property + var MountService mountService; private val BiMap uriToModuleName = HashBiMap.create(); private val Map moduleNameToUri = uriToModuleName.inverse(); + private val Map qnameToRpc = new ConcurrentHashMap(); + + private new() { + if (INSTANCE !== null) { + throw new IllegalStateException("Already instantiated"); + } + } + + static def getInstance() { + return INSTANCE + } + + private def void checkPreconditions() { + if (globalSchema === null) { + throw new ResponseException(SERVICE_UNAVAILABLE, RestconfProvider::NOT_INITALIZED_MSG) + } + } + + def setSchemas(SchemaContext schemas) { + onGlobalContextUpdated(schemas) + } public def InstanceIdWithSchemaNode toInstanceIdentifier(String restconfInstance) { - val ret = InstanceIdentifier.builder(); + checkPreconditions val pathArgs = restconfInstance.split("/"); - val schemaNode = ret.collectPathArguments(pathArgs, restconfInstance.findModule); - new InstanceIdWithSchemaNode(ret.toInstance, schemaNode) + if (pathArgs.empty) { + return null; + } + if (pathArgs.head.empty) { + pathArgs.remove(0) + } + val startModule = pathArgs.head.toModuleName(); + if (startModule === null) { + throw new ResponseException(BAD_REQUEST, "First node in URI has to be in format \"moduleName:nodeName\"") + } + val iiWithSchemaNode = collectPathArguments(InstanceIdentifier.builder(), pathArgs, + globalSchema.getLatestModule(startModule), null); + if (iiWithSchemaNode === null) { + throw new ResponseException(BAD_REQUEST, "URI has bad format") + } + return iiWithSchemaNode + } + + private def getLatestModule(SchemaContext schema, String moduleName) { + checkArgument(schema !== null); + checkArgument(moduleName !== null && !moduleName.empty) + val modules = schema.modules.filter[m|m.name == moduleName] + return modules.filterLatestModule } - def findModule(String restconfInstance) { - val pathArgs = restconfInstance.split("/"); - val first = pathArgs.get(0); - val startModule = first.toModuleName(); - val module = schemas.findModuleByNamespace(moduleNameToUri.get(startModule)); - checkArgument(module.size == 1); // Only one version supported now - module.iterator.next + private def filterLatestModule(Iterable modules) { + var latestModule = modules.head + for (module : modules) { + if (module.revision.after(latestModule.revision)) { + latestModule = module + } + } + return latestModule + } + + def findModuleByName(String moduleName) { + checkPreconditions + checkArgument(moduleName !== null && !moduleName.empty) + return globalSchema.getLatestModule(moduleName) + } + + def findModuleByName(MountInstance mountPoint, String moduleName) { + checkArgument(moduleName !== null && mountPoint !== null) + val mountPointSchema = mountPoint.schemaContext; + return mountPointSchema?.getLatestModule(moduleName); + } + + def findModuleByNamespace(URI namespace) { + checkPreconditions + checkArgument(namespace !== null) + val moduleSchemas = globalSchema.findModuleByNamespace(namespace) + return moduleSchemas?.filterLatestModule + } + + def findModuleByNamespace(MountInstance mountPoint, URI namespace) { + checkArgument(namespace !== null && mountPoint !== null) + val mountPointSchema = mountPoint.schemaContext; + val moduleSchemas = mountPointSchema?.findModuleByNamespace(namespace) + return moduleSchemas?.filterLatestModule } def String toFullRestconfIdentifier(InstanceIdentifier path) { + checkPreconditions val elements = path.path; val ret = new StringBuilder(); val startQName = elements.get(0).nodeType; - val initialModule = schemas.findModuleByNamespaceAndRevision(startQName.namespace, startQName.revision) + val initialModule = globalSchema.findModuleByNamespaceAndRevision(startQName.namespace, startQName.revision) var node = initialModule as DataSchemaNode; for (element : elements) { node = node.childByQName(element.nodeType); @@ -76,11 +169,45 @@ class ControllerContext { throw new IllegalArgumentException("Conversion of generic path argument is not supported"); } - public def CharSequence toRestconfIdentifier(QName qname) { + def findModuleNameByNamespace(URI namespace) { + checkPreconditions + var moduleName = uriToModuleName.get(namespace) + if (moduleName === null) { + val module = findModuleByNamespace(namespace) + if (module === null) return null + moduleName = module.name + uriToModuleName.put(namespace, moduleName) + } + return moduleName + } + + def findModuleNameByNamespace(MountInstance mountPoint, URI namespace) { + val module = mountPoint.findModuleByNamespace(namespace); + return module?.name + } + + def findNamespaceByModuleName(String moduleName) { + var namespace = moduleNameToUri.get(moduleName) + if (namespace === null) { + var module = findModuleByName(moduleName) + if(module === null) return null + namespace = module.namespace + uriToModuleName.put(namespace, moduleName) + } + return namespace + } + + def findNamespaceByModuleName(MountInstance mountPoint, String moduleName) { + val module = mountPoint.findModuleByName(moduleName) + return module?.namespace + } + + def CharSequence toRestconfIdentifier(QName qname) { + checkPreconditions var module = uriToModuleName.get(qname.namespace) - if (module == null) { - val moduleSchema = schemas.findModuleByNamespaceAndRevision(qname.namespace, qname.revision); - if(moduleSchema == null) throw new IllegalArgumentException() + if (module === null) { + val moduleSchema = globalSchema.findModuleByNamespaceAndRevision(qname.namespace, qname.revision); + if(moduleSchema === null) throw new IllegalArgumentException() uriToModuleName.put(qname.namespace, moduleSchema.name) module = moduleSchema.name; } @@ -133,38 +260,117 @@ class ControllerContext { } private def toUriString(Object object) { - if(object == null) return ""; + if(object === null) return ""; return URLEncoder.encode(object.toString) } - - def DataSchemaNode collectPathArguments(InstanceIdentifierBuilder builder, List strings, DataNodeContainer parentNode) { + + private def InstanceIdWithSchemaNode collectPathArguments(InstanceIdentifierBuilder builder, List strings, + DataNodeContainer parentNode, MountInstance mountPoint) { checkNotNull(strings) - if (strings.length == 0) { + if (parentNode === null) { return null; } - val nodeRef = strings.get(0); - - //val moduleName = nodeRef.toModuleName(); - val nodeName = nodeRef.toNodeName(); - val naiveTargetNode = parentNode.getDataChildByName(nodeName); - - //var URI namespace; - var DataSchemaNode targetNode = naiveTargetNode; - - /*if(moduleName !== null) { - namespace = moduleNameToUri.get(moduleName); + if (strings.empty) { + return new InstanceIdWithSchemaNode(builder.toInstance, parentNode as DataSchemaNode, mountPoint) + } + + val nodeName = strings.head.toNodeName + val moduleName = strings.head.toModuleName + var DataSchemaNode targetNode = null + if (!moduleName.nullOrEmpty) { + // if it is mount point + if (moduleName == MOUNT_MODULE && nodeName == MOUNT_NODE) { + if (mountPoint !== null) { + throw new ResponseException(BAD_REQUEST, "Restconf supports just one mount point in URI.") + } + + if (mountService === null) { + throw new ResponseException(SERVICE_UNAVAILABLE, "MountService was not found. " + + "Finding behind mount points does not work." + ) + } + + val partialPath = builder.toInstance; + val mount = mountService.getMountPoint(partialPath) + if (mount === null) { + LOG.debug("Instance identifier to missing mount point: {}", partialPath) + throw new ResponseException(BAD_REQUEST, "Mount point does not exist.") + } + + val mountPointSchema = mount.schemaContext; + if (mountPointSchema === null) { + throw new ResponseException(BAD_REQUEST, "Mount point does not contain any schema with modules.") + } + + if (strings.size == 1) { // any data node is not behind mount point + return new InstanceIdWithSchemaNode(InstanceIdentifier.builder().toInstance, mountPointSchema, mount) + } + + val moduleNameBehindMountPoint = strings.get(1).toModuleName() + if (moduleNameBehindMountPoint === null) { + throw new ResponseException(BAD_REQUEST, + "First node after mount point in URI has to be in format \"moduleName:nodeName\"") + } + + val moduleBehindMountPoint = mountPointSchema.getLatestModule(moduleNameBehindMountPoint) + if (moduleBehindMountPoint === null) { + throw new ResponseException(BAD_REQUEST, + "URI has bad format. \"" + moduleName + "\" module does not exist in mount point.") + } + + return collectPathArguments(InstanceIdentifier.builder(), strings.subList(1, strings.size), + moduleBehindMountPoint, mount); + } - }*/ + var Module module = null; + if (mountPoint === null) { + module = globalSchema.getLatestModule(moduleName) + if (module === null) { + throw new ResponseException(BAD_REQUEST, + "URI has bad format. \"" + moduleName + "\" module does not exist.") + } + } else { + module = mountPoint.schemaContext?.getLatestModule(moduleName) + if (module === null) { + throw new ResponseException(BAD_REQUEST, + "URI has bad format. \"" + moduleName + "\" module does not exist in mount point.") + } + } + targetNode = parentNode.findInstanceDataChild(nodeName, module.namespace) + if (targetNode === null) { + throw new ResponseException(BAD_REQUEST, "URI has bad format. Possible reasons:\n" + + "1. \"" + strings.head + "\" was not found in parent data node.\n" + + "2. \"" + strings.head + "\" is behind mount point. Then it should be in format \"/" + MOUNT + "/" + strings.head + "\".") + } + } else { // string without module name + targetNode = parentNode.findInstanceDataChild(nodeName, null) + if (targetNode === null) { + throw new ResponseException(BAD_REQUEST, "URI has bad format. \"" + nodeName + "\" was not found in parent data node.\n") + } + } + // Number of consumed elements var consumed = 1; if (targetNode instanceof ListSchemaNode) { val listNode = targetNode as ListSchemaNode; val keysSize = listNode.keyDefinition.size - val uriKeyValues = strings.subList(1, keysSize); + + // every key has to be filled + if ((strings.length - consumed) < keysSize) { + throw new ResponseException(BAD_REQUEST,"Missing key for list \"" + listNode.QName.localName + "\".") + } + val uriKeyValues = strings.subList(consumed, consumed + keysSize); val keyValues = new HashMap(); var i = 0; for (key : listNode.keyDefinition) { val uriKeyValue = uriKeyValues.get(i); + + // key value cannot be NULL + if (uriKeyValue.equals(NULL_VALUE)) { + throw new ResponseException(BAD_REQUEST, "URI has bad format. List \"" + listNode.QName.localName + + "\" cannot contain \"null\" value as a key." + ) + } keyValues.addKeyValue(listNode.getDataChildByName(key), uriKeyValue); i = i + 1; } @@ -176,44 +382,101 @@ class ControllerContext { builder.node(targetNode.QName); } if (targetNode instanceof DataNodeContainer) { - val remaining = strings.subList(consumed, strings.length - 1); - val result = builder.collectPathArguments(remaining, targetNode as DataNodeContainer); + val remaining = strings.subList(consumed, strings.length); + val result = builder.collectPathArguments(remaining, targetNode as DataNodeContainer, mountPoint); return result } + + return new InstanceIdWithSchemaNode(builder.toInstance, targetNode, mountPoint) + } + + def DataSchemaNode findInstanceDataChild(DataNodeContainer container, String name, URI moduleNamespace) { + var DataSchemaNode potentialNode = null + if (moduleNamespace === null) { + potentialNode = container.getDataChildByName(name); + } else { + potentialNode = container.childNodes.filter[n|n.QName.localName == name && n.QName.namespace == moduleNamespace].head + } - return targetNode + if (potentialNode.instantiatedDataSchema) { + return potentialNode; + } + val allCases = container.childNodes.filter(ChoiceNode).map[cases].flatten + for (caze : allCases) { + potentialNode = caze.findInstanceDataChild(name, moduleNamespace); + if (potentialNode !== null) { + return potentialNode; + } + } + return null; + } + + static def boolean isInstantiatedDataSchema(DataSchemaNode node) { + switch node { + LeafSchemaNode: return true + LeafListSchemaNode: return true + ContainerSchemaNode: return true + ListSchemaNode: return true + default: return false + } } - def void addKeyValue(HashMap map, DataSchemaNode node, String uriValue) { + private def void addKeyValue(HashMap map, DataSchemaNode node, String uriValue) { checkNotNull(uriValue); checkArgument(node instanceof LeafSchemaNode); - val decoded = URLDecoder.decode(uriValue); + val urlDecoded = URLDecoder.decode(uriValue); + val typedef = (node as LeafSchemaNode).type; + + var decoded = TypeDefinitionAwareCodec.from(typedef)?.deserialize(urlDecoded) + if(decoded === null) { + var baseType = RestUtil.resolveBaseTypeFrom(typedef) + if(baseType instanceof IdentityrefTypeDefinition) { + decoded = toQName(urlDecoded) + } + } map.put(node.QName, decoded); - } - def String toModuleName(String str) { + private static def String toModuleName(String str) { + checkNotNull(str) if (str.contains(":")) { val args = str.split(":"); - checkArgument(args.size === 2); - return args.get(0); - } else { - return null; + if (args.size === 2) { + return args.get(0); + } } + return null; } - def String toNodeName(String str) { + private def String toNodeName(String str) { if (str.contains(":")) { val args = str.split(":"); - checkArgument(args.size === 2); - return args.get(1); - } else { - return str; + if (args.size === 2) { + return args.get(1); + } } + return str; } - - public def QName toRpcQName(String name) { - - + + private def QName toQName(String name) { + val module = name.toModuleName; + val node = name.toNodeName; + val namespace = FluentIterable.from(globalSchema.modules.sort[o1,o2 | o1.revision.compareTo(o2.revision)]) // + .transform[QName.create(namespace,revision,it.name)].findFirst[module == localName] + ; + return QName.create(namespace,node); } + + def getRpcDefinition(String name) { + return qnameToRpc.get(name.toQName) + } + + override onGlobalContextUpdated(SchemaContext context) { + this.globalSchema = context; + for (operation : context.operations) { + val qname = operation.QName; + qnameToRpc.put(qname, operation); + } + } + }