import org.opendaylight.yangtools.yang.model.api.SchemaContext
import static com.google.common.base.Preconditions.*
-import java.util.Date
class ControllerContext {
+
+ val static NULL_VALUE = "null"
@Property
SchemaContext schemas;
if (pathArgs.empty) {
return null;
}
+ if (pathArgs.head.empty) {
+ pathArgs.remove(0)
+ }
val schemaNode = ret.collectPathArguments(pathArgs, restconfInstance.findModule);
+ if (schemaNode == null) {
+ return null
+ }
new InstanceIdWithSchemaNode(ret.toInstance, schemaNode)
}
- def findModule(String restconfInstance) {
+ private def findModule(String restconfInstance) {
checkNotNull(restconfInstance);
val pathArgs = restconfInstance.split("/");
if (pathArgs.empty) {
throw new IllegalArgumentException("Conversion of generic path argument is not supported");
}
- public def CharSequence toRestconfIdentifier(QName qname) {
+ def CharSequence toRestconfIdentifier(QName qname) {
var module = uriToModuleName.get(qname.namespace)
if (module == null) {
val moduleSchema = schemas.findModuleByNamespaceAndRevision(qname.namespace, qname.revision);
return URLEncoder.encode(object.toString)
}
- def DataSchemaNode collectPathArguments(InstanceIdentifierBuilder builder, List<String> strings,
+ private def DataSchemaNode collectPathArguments(InstanceIdentifierBuilder builder, List<String> strings,
DataNodeContainer parentNode) {
checkNotNull(strings)
if (strings.empty) {
}
val nodeRef = strings.head;
- //val moduleName = nodeRef.toModuleName();
val nodeName = nodeRef.toNodeName();
val targetNode = parentNode.getDataChildByName(nodeName);
if (targetNode == null) {
+ val children = parentNode.childNodes
+ for (child : children) {
+ if (child instanceof ChoiceNode) {
+ val choice = child as ChoiceNode
+ for (caze : choice.cases) {
+ val result = builder.collectPathArguments(strings, caze as DataNodeContainer);
+ if (result != null)
+ return result
+ }
+ }
+ }
+ return null
+ }
+ if (targetNode instanceof ChoiceNode) {
return null
}
if (targetNode instanceof ListSchemaNode) {
val listNode = targetNode as ListSchemaNode;
val keysSize = listNode.keyDefinition.size
+ // 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;
}
consumed = consumed + i;
builder.nodeWithKey(targetNode.QName, keyValues);
} else {
-
// Only one instance of node is allowed
builder.node(targetNode.QName);
}
return targetNode
}
- 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);
}
- def String toModuleName(String str) {
+ private def String toModuleName(String str) {
checkNotNull(str)
if (str.contains(":")) {
val args = str.split(":");
}
}
- def String toNodeName(String str) {
+ private def String toNodeName(String str) {
if (str.contains(":")) {
val args = str.split(":");
checkArgument(args.size === 2);
package org.opendaylight.controller.sal.restconf.impl.test;
-import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.*;
import java.io.FileNotFoundException;
import java.util.Set;
import org.junit.Test;
import org.opendaylight.controller.sal.restconf.impl.ControllerContext;
import org.opendaylight.controller.sal.restconf.impl.InstanceIdWithSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
@BeforeClass
public static void init() throws FileNotFoundException {
Set<Module> allModules = TestUtils.loadModules(ControllerContextTest.class.getResource("/full-versions/yangs").getPath());
- assertEquals(4, allModules.size());
SchemaContext schemaContext = TestUtils.loadSchemaContext(allModules);
controllerContext.setSchemas(schemaContext);
}
@Test
public void testToInstanceIdentifierList() throws FileNotFoundException {
- InstanceIdWithSchemaNode instanceIdentifier = controllerContext.toInstanceIdentifier("ietf-interfaces:interfaces/interface/foo");
- DataSchemaNode schemaNode = instanceIdentifier.getSchemaNode();
- assertEquals(schemaNode.getQName().getLocalName(), "interface");
+ InstanceIdWithSchemaNode instanceIdentifier = controllerContext.toInstanceIdentifier("simple-nodes:userWithoutClass/foo");
+ assertEquals(instanceIdentifier.getSchemaNode().getQName().getLocalName(), "userWithoutClass");
+
+ instanceIdentifier = controllerContext.toInstanceIdentifier("simple-nodes:userWithoutClass/foo/full-name");
+ assertEquals(instanceIdentifier.getSchemaNode().getQName().getLocalName(), "full-name");
+
+ instanceIdentifier = controllerContext.toInstanceIdentifier("simple-nodes:user/foo/boo");
+ assertEquals(instanceIdentifier.getSchemaNode().getQName().getLocalName(), "user");
+
+ instanceIdentifier = controllerContext.toInstanceIdentifier("simple-nodes:user//boo");
+ assertEquals(instanceIdentifier.getSchemaNode().getQName().getLocalName(), "user");
+
+ instanceIdentifier = controllerContext.toInstanceIdentifier("simple-nodes:users/user/foo");
+ assertEquals(instanceIdentifier.getSchemaNode().getQName().getLocalName(), "user");
+
+ instanceIdentifier = controllerContext.toInstanceIdentifier("simple-nodes:user/null/boo");
+ assertNull(instanceIdentifier);
+
+ instanceIdentifier = controllerContext.toInstanceIdentifier("simple-nodes:user/foo");
+ assertNull(instanceIdentifier);
+
+ }
+
+ @Test
+ public void testToInstanceIdentifierContainer() throws FileNotFoundException {
+ InstanceIdWithSchemaNode instanceIdentifier = controllerContext.toInstanceIdentifier("simple-nodes:users");
+ assertEquals(instanceIdentifier.getSchemaNode().getQName().getLocalName(), "users");
+ assertTrue(instanceIdentifier.getSchemaNode() instanceof ContainerSchemaNode);
+ assertEquals(2, ((ContainerSchemaNode)instanceIdentifier.getSchemaNode()).getChildNodes().size());
+ }
+
+ @Test
+ public void testToInstanceIdentifierChoice() throws FileNotFoundException {
+ InstanceIdWithSchemaNode instanceIdentifier = controllerContext.toInstanceIdentifier("simple-nodes:food/beer");
+ assertEquals(instanceIdentifier.getSchemaNode().getQName().getLocalName(), "beer");
+
+ instanceIdentifier = controllerContext.toInstanceIdentifier("simple-nodes:food/snack");
+ assertNull(instanceIdentifier);
+
+ instanceIdentifier = controllerContext.toInstanceIdentifier("simple-nodes:food/sports-arena");
+ assertNull(instanceIdentifier);
+
+ instanceIdentifier = controllerContext.toInstanceIdentifier("simple-nodes:food/snack/sports-arena");
+ assertNull(instanceIdentifier);
+
}
}
@BeforeClass
public static void init() throws FileNotFoundException {
Set<Module> allModules = TestUtils.loadModules(JsonMapperTest.class.getResource("/full-versions/yangs").getPath());
- assertEquals(4, allModules.size());
SchemaContext schemaContext = TestUtils.loadSchemaContext(allModules);
controllerContext.setSchemas(schemaContext);
}
@BeforeClass
public static void init() throws FileNotFoundException {
Set<Module> allModules = TestUtils.loadModules(RestconfImplTest.class.getResource("/full-versions/yangs").getPath());
- assertEquals(4, allModules.size());
SchemaContext schemaContext = TestUtils.loadSchemaContext(allModules);
ControllerContext controllerContext = new ControllerContext();
controllerContext.setSchemas(schemaContext);
--- /dev/null
+module simple-nodes {
+ yang-version 1;
+ namespace "urn:opendaylight:simple-nodes";
+ prefix "sn";
+
+ description
+ "test file containing yang data nodes";
+
+ revision "2013-07-30" {
+ description
+ "Initial revision.";
+ reference "will be defined";
+ }
+
+ container users {
+ leaf user {
+ type string;
+ }
+
+ leaf group {
+ type string;
+ }
+ }
+
+ list user {
+ key "name class";
+ leaf name {
+ type string;
+ }
+ leaf full-name {
+ type string;
+ }
+ leaf class {
+ type string;
+ }
+ }
+
+ list userWithoutClass {
+ key "name";
+ leaf name {
+ type string;
+ }
+ leaf full-name {
+ type string;
+ }
+ }
+
+ container food {
+ choice snack {
+ case sports-arena {
+ leaf pretzel {
+ type string;
+ }
+ leaf beer {
+ type string;
+ }
+ }
+ case late-night {
+ leaf chocolate {
+ type enumeration {
+ enum dark;
+ enum milk;
+ enum first-available;
+ }
+ }
+ }
+ }
+ }
+
+}