opendaylight/md-sal/sal-rest-connector/src/main/java/org/opendaylight/controller/sal/restconf/impl/RestconfImpl.xtend

   1 package org.opendaylight.controller.sal.restconf.impl
   2
   3 import java.util.List
   4 import org.opendaylight.controller.sal.rest.api.RestconfService
   5 import org.opendaylight.yangtools.yang.data.api.CompositeNode
   6 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer
   7 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode
   8
   9 class RestconfImpl implements RestconfService {
  10
  11     val static RestconfImpl INSTANCE = new RestconfImpl
  12
  13     @Property
  14     BrokerFacade broker
  15
  16     @Property
  17     extension ControllerContext controllerContext
  18
  19     private new() {
  20         if (INSTANCE != null) {
  21             throw new IllegalStateException("Already instantiated");
  22         }
  23     }
  24
  25     static def getInstance() {
  26         return INSTANCE
  27     }
  28
  29     override readAllData() {
  30 //        return broker.readOperationalData("".toInstanceIdentifier.getInstanceIdentifier);
  31         throw new UnsupportedOperationException("Reading all data is currently not supported.")
  32     }
  33
  34     override getModules() {
  35         throw new UnsupportedOperationException("TODO: auto-generated method stub")
  36     }
  37
  38     override getRoot() {
  39         return null;
  40     }
  41
  42     override readData(String identifier) {
  43         val instanceIdentifierWithSchemaNode = identifier.toInstanceIdentifier
  44         val data = broker.readOperationalData(instanceIdentifierWithSchemaNode.getInstanceIdentifier);
  45         return new StructuredData(data, instanceIdentifierWithSchemaNode.schemaNode)
  46     }
  47
  48     override createConfigurationData(String identifier, CompositeNode payload) {
  49         val identifierWithSchemaNode = identifier.toInstanceIdentifier
  50         val value = resolveNodeNamespaceBySchema(payload, identifierWithSchemaNode.schemaNode)
  51         return broker.commitConfigurationDataPut(identifierWithSchemaNode.instanceIdentifier,value).get();
  52     }
  53
  54     override updateConfigurationData(String identifier, CompositeNode payload) {
  55         val identifierWithSchemaNode = identifier.toInstanceIdentifier
  56         val value = resolveNodeNamespaceBySchema(payload, identifierWithSchemaNode.schemaNode)
  57         return broker.commitConfigurationDataPut(identifierWithSchemaNode.instanceIdentifier,value).get();
  58     }
  59
  60     override invokeRpc(String identifier, CompositeNode payload) {
  61         val rpc = identifier.toQName;
  62         val value = resolveNodeNamespaceBySchema(payload, controllerContext.getRpcInputSchema(rpc))
  63         val rpcResult = broker.invokeRpc(rpc, value);
  64         val schema = controllerContext.getRpcOutputSchema(rpc);
  65         return new StructuredData(rpcResult.result, schema);
  66     }
  67
  68     override readConfigurationData(String identifier) {
  69         val instanceIdentifierWithSchemaNode = identifier.toInstanceIdentifier
  70         val data = broker.readOperationalData(instanceIdentifierWithSchemaNode.getInstanceIdentifier);
  71         return new StructuredData(data, instanceIdentifierWithSchemaNode.schemaNode)
  72     }
  73
  74     override readOperationalData(String identifier) {
  75         val instanceIdentifierWithSchemaNode = identifier.toInstanceIdentifier
  76         val data = broker.readOperationalData(instanceIdentifierWithSchemaNode.getInstanceIdentifier);
  77         return new StructuredData(data, instanceIdentifierWithSchemaNode.schemaNode)
  78     }
  79
  80     override updateConfigurationDataLegacy(String identifier, CompositeNode payload) {
  81         updateConfigurationData(identifier,payload);
  82     }
  83
  84     override createConfigurationDataLegacy(String identifier, CompositeNode payload) {
  85         createConfigurationData(identifier,payload);
  86     }
  87
  88     override createOperationalData(String identifier, CompositeNode payload) {
  89         val identifierWithSchemaNode = identifier.toInstanceIdentifier
  90         val value = resolveNodeNamespaceBySchema(payload, identifierWithSchemaNode.schemaNode)
  91         return broker.commitOperationalDataPut(identifierWithSchemaNode.instanceIdentifier,value).get();
  92     }
  93
  94     override updateOperationalData(String identifier, CompositeNode payload) {
  95         val identifierWithSchemaNode = identifier.toInstanceIdentifier
  96         val value = resolveNodeNamespaceBySchema(payload, identifierWithSchemaNode.schemaNode)
  97         return broker.commitOperationalDataPut(identifierWithSchemaNode.instanceIdentifier,value).get();
  98     }
  99
 100     private def CompositeNode resolveNodeNamespaceBySchema(CompositeNode node, DataSchemaNode schema) {
 101         if (node instanceof CompositeNodeWrapper) {
 102             addNamespaceToNodeFromSchemaRecursively(node as CompositeNodeWrapper, schema)
 103             return (node as CompositeNodeWrapper).unwrap(null)
 104         }
 105         return node
 106     }
 107
 108     private def void addNamespaceToNodeFromSchemaRecursively(NodeWrapper<?> nodeBuilder, DataSchemaNode schema) {
 109         if (nodeBuilder.namespace == null) {
 110             nodeBuilder.namespace = schema.QName.namespace
 111         }
 112         if (nodeBuilder instanceof CompositeNodeWrapper) {
 113             val List<NodeWrapper<?>> children = (nodeBuilder as CompositeNodeWrapper).getValues
 114             for (child : children) {
 115                 addNamespaceToNodeFromSchemaRecursively(child,
 116                     (schema as DataNodeContainer).childNodes.findFirst[n|n.QName.localName.equals(child.localName)])
 117             }
 118         }
 119     }
 120
 121 }