Merge "Fix two neutron service defects"

[controller.git] / opendaylight / md-sal / sal-rest-connector / src / main / java / org / opendaylight / controller / sal / restconf / impl / ControllerContext.xtend

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 419ca50ee995a032e5a63b3dc7ea1f50d79ba50e..624178569d4e71551507f7733cec7c93bf4b032c 100644 (file)
--- 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
@@ -24,15 +24,33 @@ import org.opendaylight.yangtools.yang.model.api.ListSchemaNode
 import org.opendaylight.yangtools.yang.model.api.SchemaContext
 
 import static com.google.common.base.Preconditions.*
-import java.util.Date
+import org.opendaylight.controller.sal.core.api.model.SchemaServiceListener
+import org.opendaylight.yangtools.yang.model.api.RpcDefinition
+import java.util.concurrent.ConcurrentHashMap
 
-class ControllerContext {
+class ControllerContext implements SchemaServiceListener {
+
+    val static ControllerContext INSTANCE = new ControllerContext
+
+    val static NULL_VALUE = "null"
 
     @Property
     SchemaContext schemas;
 
     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");
+        }
+    }
+
+    static def getInstance() {
+        return INSTANCE
+    }
 
     public def InstanceIdWithSchemaNode toInstanceIdentifier(String restconfInstance) {
         val ret = InstanceIdentifier.builder();
@@ -40,11 +58,17 @@ class ControllerContext {
         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) {
@@ -95,7 +119,7 @@ class ControllerContext {
         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);
@@ -156,7 +180,7 @@ class ControllerContext {
         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) {
@@ -164,10 +188,23 @@ class ControllerContext {
         }
         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
         }
 
@@ -176,11 +213,21 @@ class ControllerContext {
         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;
             }
@@ -200,7 +247,7 @@ class ControllerContext {
         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);
@@ -208,7 +255,7 @@ class ControllerContext {
 
     }
 
-    def String toModuleName(String str) {
+    private def String toModuleName(String str) {
         checkNotNull(str)
         if (str.contains(":")) {
             val args = str.split(":");
@@ -219,7 +266,7 @@ class ControllerContext {
         }
     }
 
-    def String toNodeName(String str) {
+    private def String toNodeName(String str) {
         if (str.contains(":")) {
             val args = str.split(":");
             checkArgument(args.size === 2);
@@ -229,6 +276,27 @@ class ControllerContext {
         }
     }
 
-    public def QName toRpcQName(String name) {
+    public def QName toQName(String name) {
+        val module = name.toModuleName;
+        val node = name.toNodeName;
+        val namespace = moduleNameToUri.get(module);
+        return new QName(namespace,null,node);
     }
+
+    override onGlobalContextUpdated(SchemaContext context) {
+        this.schemas = context;
+        for(operation : context.operations) {
+            val qname = new QName(operation.QName.namespace,null,operation.QName.localName);
+            qnameToRpc.put(qname,operation);
+        }
+    }
+    
+    def ContainerSchemaNode getRpcOutputSchema(QName name) {
+        qnameToRpc.get(name)?.output;
+    }
+    
+    def ContainerSchemaNode getRpcInputSchema(QName name) {
+        qnameToRpc.get(name)?.input;
+    }
+
 }