package org.opendaylight.controller.sal.restconf.impl
-import org.opendaylight.yangtools.yang.model.api.SchemaContext
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates
+import com.google.common.collect.BiMap
+import com.google.common.collect.FluentIterable
+import com.google.common.collect.HashBiMap
import java.net.URI
-import java.util.Map
+import java.net.URLDecoder
+import java.net.URLEncoder
import java.util.HashMap
+import java.util.List
+import java.util.Map
+import java.util.concurrent.ConcurrentHashMap
+import javax.ws.rs.core.Response
+import org.opendaylight.controller.sal.core.api.model.SchemaServiceListener
+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.model.api.ChoiceNode
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode
+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.ListSchemaNode
-
-import java.net.URLEncoder
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.InstanceIdentifierBuilder
-import java.util.List
-import static com.google.common.base.Preconditions.*;
-import com.google.common.collect.Collections2
-import com.google.common.collect.BiMap
-import com.google.common.collect.HashBiMap
+import org.opendaylight.yangtools.yang.model.api.DataSchemaNode
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode
-import java.net.URLDecoder
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode
+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 org.opendaylight.controller.sal.core.api.mount.MountService
+import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode
-class ControllerContext {
+class ControllerContext implements SchemaServiceListener {
+ val static LOG = LoggerFactory.getLogger(ControllerContext)
+ val static ControllerContext INSTANCE = new ControllerContext
+ val static NULL_VALUE = "null"
@Property
- SchemaContext schemas;
+ var SchemaContext globalSchema;
+
+ @Property
+ var MountService mountService;
private val BiMap<URI, String> uriToModuleName = HashBiMap.create();
private val Map<String, URI> moduleNameToUri = uriToModuleName.inverse();
+ private val Map<QName, RpcDefinition> qnameToRpc = new ConcurrentHashMap();
+
+ private new() {
+ if (INSTANCE !== null) {
+ throw new IllegalStateException("Already instantiated");
+ }
+ }
- public def InstanceIdentifier toInstanceIdentifier(String restconfInstance) {
+ static def getInstance() {
+ return INSTANCE
+ }
+
+ private def void checkPreconditions() {
+ if (globalSchema === null) {
+ throw new ResponseException(Response.Status.SERVICE_UNAVAILABLE, RestconfProvider::NOT_INITALIZED_MSG)
+ }
+ }
+
+ def setSchemas(SchemaContext schemas) {
+ onGlobalContextUpdated(schemas)
+ }
+
+ public def InstanceIdWithSchemaNode toInstanceIdentifier(String restconfInstance) {
val ret = InstanceIdentifier.builder();
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
- ret.collectPathArguments(pathArgs, module.iterator.next);
- return ret.toInstance
+ if (pathArgs.empty) {
+ return null;
+ }
+ if (pathArgs.head.empty) {
+ pathArgs.remove(0)
+ }
+ val schemaNode = ret.collectPathArguments(pathArgs, globalSchema.findModule(pathArgs.head));
+ if (schemaNode === null) {
+ return null
+ }
+ return new InstanceIdWithSchemaNode(ret.toInstance, schemaNode)
+ }
+
+ private static def findModule(SchemaContext context,String argument) {
+ //checkPreconditions
+ checkNotNull(argument);
+ val startModule = argument.toModuleName();
+ return context.getLatestModule(startModule)
+ }
+
+ static def getLatestModule(SchemaContext schema,String moduleName) {
+ checkArgument(schema != null);
+ checkArgument(moduleName !== null && !moduleName.empty)
+ val modules = schema.modules.filter[m|m.name == moduleName]
+ var latestModule = modules.head
+ for (module : modules) {
+ if (module.revision.after(latestModule.revision)) {
+ latestModule = module
+ }
+ }
+ return latestModule
}
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);
throw new IllegalArgumentException("Conversion of generic path argument is not supported");
}
- public def CharSequence toRestconfIdentifier(QName qname) {
+ def findModuleByNamespace(URI namespace) {
+ checkPreconditions
+ var module = uriToModuleName.get(namespace)
+ if (module === null) {
+ val moduleSchemas = globalSchema.findModuleByNamespace(namespace);
+ if(moduleSchemas === null) return null
+ var latestModule = moduleSchemas.head
+ for (m : moduleSchemas) {
+ if (m.revision.after(latestModule.revision)) {
+ latestModule = m
+ }
+ }
+ if(latestModule === null) return null
+ uriToModuleName.put(namespace, latestModule.name)
+ module = latestModule.name;
+ }
+ return module
+ }
+
+ def findNamespaceByModule(String module) {
+ var namespace = moduleNameToUri.get(module)
+ if (namespace === null) {
+ val moduleSchemas = globalSchema.modules.filter[it|it.name.equals(module)]
+ var latestModule = moduleSchemas.head
+ for (m : moduleSchemas) {
+ if (m.revision.after(latestModule.revision)) {
+ latestModule = m
+ }
+ }
+ if(latestModule === null) return null
+ namespace = latestModule.namespace
+ uriToModuleName.put(namespace, latestModule.name)
+ }
+ return 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;
}
}
private def toUriString(Object object) {
- if(object == null) return "";
+ if(object === null) return "";
return URLEncoder.encode(object.toString)
}
- def void collectPathArguments(InstanceIdentifierBuilder builder, List<String> strings, DataNodeContainer parentNode) {
+ private def DataSchemaNode collectPathArguments(InstanceIdentifierBuilder builder, List<String> strings,
+ DataNodeContainer parentNode) {
checkNotNull(strings)
- if (strings.length == 0) {
- return;
+ if (parentNode === null) {
+ return null;
}
- val nodeRef = strings.get(0);
-
- //val moduleName = nodeRef.toModuleName();
- val nodeName = nodeRef.toNodeName();
- val naiveTargetNode = parentNode.getDataChildByName(nodeName);
+ if (strings.empty) {
+ return parentNode as DataSchemaNode;
+ }
+ val nodeRef = strings.head;
- //var URI namespace;
- var DataSchemaNode targetNode = naiveTargetNode;
+ val nodeName = nodeRef.toNodeName;
+ var targetNode = parentNode.findInstanceDataChild(nodeName);
+ if (targetNode instanceof ChoiceNode) {
+ return null
+ }
+
+ if (targetNode === null) {
+ // Node is possibly in other mount point
+ val partialPath = builder.toInstance;
+ val mountPointSchema = mountService?.getMountPoint(partialPath)?.schemaContext;
+ if(mountPointSchema != null) {
+ return builder.collectPathArguments(strings, mountPointSchema.findModule(strings.head));
+ }
+ return null
+ }
+
- /*if(moduleName !== null) {
- namespace = moduleNameToUri.get(moduleName);
-
- }*/
// 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) {
+ return null;
+ }
+ val uriKeyValues = strings.subList(consumed, consumed + keysSize);
val keyValues = new HashMap<QName, Object>();
var i = 0;
for (key : listNode.keyDefinition) {
val uriKeyValue = uriKeyValues.get(i);
+
+ // key value cannot be NULL
+ if (uriKeyValue.equals(NULL_VALUE)) {
+ return null
+ }
keyValues.addKeyValue(listNode.getDataChildByName(key), uriKeyValue);
i = i + 1;
}
builder.node(targetNode.QName);
}
if (targetNode instanceof DataNodeContainer) {
- val remaining = strings.subList(consumed, strings.length - 1);
- builder.collectPathArguments(remaining, targetNode as DataNodeContainer);
+ val remaining = strings.subList(consumed, strings.length);
+ val result = builder.collectPathArguments(remaining, targetNode as DataNodeContainer);
+ return result
+ }
+
+ return targetNode
+ }
+
+ static def DataSchemaNode findInstanceDataChild(DataNodeContainer container, String name) {
+ // FIXME: Add namespace comparison
+ var potentialNode = container.getDataChildByName(name);
+ if(potentialNode.instantiatedDataSchema) {
+ return potentialNode;
+ }
+ val allCases = container.childNodes.filter(ChoiceNode).map[cases].flatten
+ for (caze : allCases) {
+ potentialNode = caze.findInstanceDataChild(name);
+ 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<QName, Object> map, DataSchemaNode node, String uriValue) {
+ private def void addKeyValue(HashMap<QName, Object> 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);
}
}
- def String toNodeName(String str) {
+ private def String toNodeName(String str) {
if (str.contains(":")) {
val args = str.split(":");
checkArgument(args.size === 2);
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);
+ }
+ }
+
}
Code Review / controller.git / blobdiff