Added support for RPCs to Binding-Aware SAL

Added support for RPCs to Binding-Aware SAL. The implementations
of the RPCs are mapped to interfaces describing RPC contract.

The registered implementation is registered for all RPCs described
in the interface and only one registered implementation of the
interface could exists at-the time.

It is possible to register implementation of derived interface,
but client must request the derived interface to access its
implementation of rpcs defined in super interface.

Signed-off-by: Tony Tkacik <ttkacik@cisco.com>

diff --git a/opendaylight/sal/yang-prototype/sal/sal-binding-api/src/main/java/org/opendaylight/controller/sal/binding/api/DataProviderService.java b/opendaylight/sal/yang-prototype/sal/sal-binding-api/src/main/java/org/opendaylight/controller/sal/binding/api/DataProviderService.java
index e4e7be5c6c196cef628d8598d498ad3928cfc3a2..8f90ddbbea8e073056f43d566e4996acf500c48a 100644 (file)
--- a/opendaylight/sal/yang-prototype/sal/sal-binding-api/src/main/java/org/opendaylight/controller/sal/binding/api/DataProviderService.java
+++ b/opendaylight/sal/yang-prototype/sal/sal-binding-api/src/main/java/org/opendaylight/controller/sal/binding/api/DataProviderService.java
@@ -62,24 +62,6 @@ public interface DataProviderService extends DataBrokerService {
      * @param store\r
      * @param refresher\r
      */\r
      * @param store\r
      * @param refresher\r
      */\r

-    void removeRefresher(DataStoreIdentifier store, DataRefresher refresher);\r
-\r
-    /**\r
-     * Trigger for refreshing of the data exposed by the {@link Provider}\r
-     * \r
-\r
-     * \r
-     */\r
-    public interface DataRefresher extends\r
-            BindingAwareProvider.ProviderFunctionality {\r
-\r
-        /**\r
-         * Fired when some component explicitly requested the data refresh.\r
-         * \r
-         * The provider which exposed the {@link DataRefresher} should republish\r
-         * its provided data by editing the data in all affected data stores.\r
-         */\r
-        void refreshData();\r
-    }\r
+   void removeRefresher(DataStoreIdentifier store, DataRefresher refresher);\r

 \r
 }\r
 \r
 }\r

diff --git a/opendaylight/sal/yang-prototype/sal/sal-binding-api/src/main/java/org/opendaylight/controller/sal/binding/api/DataRefresher.java b/opendaylight/sal/yang-prototype/sal/sal-binding-api/src/main/java/org/opendaylight/controller/sal/binding/api/DataRefresher.java
index 56b2a9f4dabdb0c675360b8e417d1d2090f1a5db..0f9997651fd677dbb4fb01536278c43252d439c3 100644 (file)
--- a/opendaylight/sal/yang-prototype/sal/sal-binding-api/src/main/java/org/opendaylight/controller/sal/binding/api/DataRefresher.java
+++ b/opendaylight/sal/yang-prototype/sal/sal-binding-api/src/main/java/org/opendaylight/controller/sal/binding/api/DataRefresher.java
@@ -7,9 +7,20 @@
  */\r
 package org.opendaylight.controller.sal.binding.api;\r
 \r
  */\r
 package org.opendaylight.controller.sal.binding.api;\r
 \r

-import org.opendaylight.controller.sal.binding.api.BindingAwareProvider.ProviderFunctionality;\r
-\r
-public interface DataRefresher extends ProviderFunctionality {\r
+/**\r
+ * Trigger for refreshing of the data exposed by the {@link Provider}\r
+ * \r
+ * \r
+ * \r
+ */\r
+public interface DataRefresher extends\r
+        BindingAwareProvider.ProviderFunctionality {\r

 \r
 \r

+    /**\r
+     * Fired when some component explicitly requested the data refresh.\r
+     * \r
+     * The provider which exposed the {@link DataRefresher} should republish its\r
+     * provided data by editing the data in all affected data stores.\r
+     */\r

     void refreshData();\r
     void refreshData();\r

-}\r
+}
\ No newline at end of file

diff --git a/opendaylight/sal/yang-prototype/sal/sal-binding-broker-impl/pom.xml b/opendaylight/sal/yang-prototype/sal/sal-binding-broker-impl/pom.xml
index f126744652b78f8a4b87cf14a3b8adf5852c0137..2d427cb61fa5aa6993e4648d83a3c2d27bf3eb2d 100644 (file)
--- a/opendaylight/sal/yang-prototype/sal/sal-binding-broker-impl/pom.xml
+++ b/opendaylight/sal/yang-prototype/sal/sal-binding-broker-impl/pom.xml
@@ -11,6 +11,11 @@
 \r
 \r
        <dependencies>\r
 \r
 \r
        <dependencies>\r

+               <dependency>\r
+                       <groupId>org.opendaylight.controller</groupId>\r
+                       <artifactId>sal-common-util</artifactId>\r
+                       <version>1.0-SNAPSHOT</version>\r
+               </dependency>\r

                <dependency>\r
                        <groupId>org.opendaylight.controller</groupId>\r
                        <artifactId>sal-binding-api</artifactId>\r
                <dependency>\r
                        <groupId>org.opendaylight.controller</groupId>\r
                        <artifactId>sal-binding-api</artifactId>\r

diff --git a/opendaylight/sal/yang-prototype/sal/sal-binding-broker-impl/src/main/java/org/opendaylight/controller/sal/binding/impl/BindingBrokerImpl.java b/opendaylight/sal/yang-prototype/sal/sal-binding-broker-impl/src/main/java/org/opendaylight/controller/sal/binding/impl/BindingBrokerImpl.java
index 2209f84cac7ca86b29da96487dd1b45329daca5d..32eff18d4a3644069cec3d8cfce0bbdff7fb5c36 100644 (file)
--- a/opendaylight/sal/yang-prototype/sal/sal-binding-broker-impl/src/main/java/org/opendaylight/controller/sal/binding/impl/BindingBrokerImpl.java
+++ b/opendaylight/sal/yang-prototype/sal/sal-binding-broker-impl/src/main/java/org/opendaylight/controller/sal/binding/impl/BindingBrokerImpl.java
@@ -7,17 +7,36 @@
  */
 package org.opendaylight.controller.sal.binding.impl;
 
  */
 package org.opendaylight.controller.sal.binding.impl;
 

+import java.util.Collection;
+import java.util.Collections;

 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;

+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;

 
 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
 import org.opendaylight.controller.sal.binding.api.BindingAwareConsumer;
 import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
 import org.opendaylight.controller.sal.binding.api.BindingAwareService;
 
 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
 import org.opendaylight.controller.sal.binding.api.BindingAwareConsumer;
 import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
 import org.opendaylight.controller.sal.binding.api.BindingAwareService;

+import org.opendaylight.controller.sal.binding.spi.Mapper;
+import org.opendaylight.controller.sal.binding.spi.MappingProvider;
+import org.opendaylight.controller.sal.binding.spi.RpcMapper;
+import org.opendaylight.controller.sal.binding.spi.RpcMapper.RpcProxyInvocationHandler;

 import org.opendaylight.controller.sal.binding.spi.SALBindingModule;
 import org.opendaylight.controller.sal.binding.spi.SALBindingModule;

+import org.opendaylight.controller.sal.common.util.Rpcs;
+import org.opendaylight.controller.sal.core.api.Provider;
+import org.opendaylight.controller.sal.core.api.RpcImplementation;
+import org.opendaylight.controller.yang.binding.DataObject;

 import org.opendaylight.controller.yang.binding.RpcService;
 import org.opendaylight.controller.yang.binding.RpcService;

+import org.opendaylight.controller.yang.common.QName;
+import org.opendaylight.controller.yang.common.RpcResult;
+import org.opendaylight.controller.yang.data.api.CompositeNode;

 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 


@@ -31,6 +50,22 @@ public class BindingBrokerImpl implements BindingAwareBroker {
 
     private Set<SALBindingModule> modules = new HashSet<SALBindingModule>();
     private Map<Class<? extends BindingAwareService>, SALBindingModule> salServiceProviders = new HashMap<Class<? extends BindingAwareService>, SALBindingModule>();
 
     private Set<SALBindingModule> modules = new HashSet<SALBindingModule>();
     private Map<Class<? extends BindingAwareService>, SALBindingModule> salServiceProviders = new HashMap<Class<? extends BindingAwareService>, SALBindingModule>();

+    private MappingProvider mapping;
+    private BIFacade biFacade = new BIFacade();
+    private org.opendaylight.controller.sal.core.api.Broker.ProviderSession biSession;
+    private ExecutorService executor;
+
+    Map<Class<? extends RpcService>, RpcService> rpcImpls = Collections
+            .synchronizedMap(new HashMap<Class<? extends RpcService>, RpcService>());
+
+    private RpcProxyInvocationHandler rpcProxyHandler = new RpcProxyInvocationHandler() {
+
+        @Override
+        public Future<RpcResult<? extends DataObject>> invokeRpc(
+                RpcService proxy, QName rpc, DataObject input) {
+            return rpcProxyInvoked(proxy, rpc, input);
+        }
+    };

 
     @Override
     public ConsumerSession registerConsumer(BindingAwareConsumer consumer) {
 
     @Override
     public ConsumerSession registerConsumer(BindingAwareConsumer consumer) {


@@ -41,9 +76,7 @@ public class BindingBrokerImpl implements BindingAwareBroker {
         consumer.onSessionInitialized(session);
 
         sessions.add(session);
         consumer.onSessionInitialized(session);
 
         sessions.add(session);

-

         return session;
         return session;

-

     }
 
     @Override
     }
 
     @Override


@@ -116,11 +149,101 @@ public class BindingBrokerImpl implements BindingAwareBroker {
 
     }
 
 
     }
 

+    private <T extends RpcService> T newRpcProxyForSession(Class<T> service) {
+
+        RpcMapper<T> mapper = mapping.rpcMapperForClass(service);
+        if (mapper == null) {
+            log.error("Mapper for " + service + "is unavailable.");
+            return null;
+        }
+        T proxy = mapper.getConsumerProxy(rpcProxyHandler);
+
+        return proxy;
+    }
+
+    private Future<RpcResult<? extends DataObject>> rpcProxyInvoked(
+            RpcService rpcProxy, QName rpcType, DataObject inputData) {
+        if (rpcProxy == null) {
+            throw new IllegalArgumentException("Proxy must not be null");
+        }
+        if (rpcType == null) {
+            throw new IllegalArgumentException(
+                    "rpcType (QName) should not be null");
+        }
+        Future<RpcResult<? extends DataObject>> ret = null;
+
+        // Real invocation starts here
+        RpcMapper<? extends RpcService> mapper = mapping
+                .rpcMapperForProxy(rpcProxy);
+        RpcService impl = rpcImpls.get(mapper.getServiceClass());
+
+        if (impl == null) {
+            // RPC is probably remote
+            CompositeNode inputNode = null;
+            Mapper<? extends DataObject> inputMapper = mapper.getInputMapper();
+            if (inputMapper != null) {
+                inputNode = inputMapper.domFromObject(inputData);
+            }
+            Future<RpcResult<CompositeNode>> biResult = biSession.rpc(rpcType,
+                    inputNode);
+            ret = new TranslatedFuture(biResult, mapper);
+
+        } else {
+            // RPC is local
+            Callable<RpcResult<? extends DataObject>> invocation = localRpcCallableFor(
+                    impl, mapper, rpcType, inputData);
+            ret = executor.submit(invocation);
+        }
+        return ret;
+    }
+
+    private Callable<RpcResult<? extends DataObject>> localRpcCallableFor(
+            final RpcService impl,
+            final RpcMapper<? extends RpcService> mapper, final QName rpcType,
+            final DataObject inputData) {
+
+        return new Callable<RpcResult<? extends DataObject>>() {
+
+            @Override
+            public RpcResult<? extends DataObject> call() throws Exception {
+                return mapper.invokeRpcImplementation(rpcType, impl, inputData);
+            }
+        };
+    }
+
+    // Binding Independent invocation of Binding Aware RPC
+    private RpcResult<CompositeNode> invokeLocalRpc(QName rpc,
+            CompositeNode inputNode) {
+        RpcMapper<? extends RpcService> mapper = mapping.rpcMapperForData(rpc,
+                inputNode);
+
+        DataObject inputTO = mapper.getInputMapper().objectFromDom(inputNode);
+
+        RpcService impl = rpcImpls.get(mapper.getServiceClass());
+        if (impl == null) {
+            log.warn("Implementation for rpc: " + rpc + "not available.");
+        }
+        RpcResult<? extends DataObject> result = mapper
+                .invokeRpcImplementation(rpc, impl, inputTO);
+        DataObject outputTO = result.getResult();
+
+        CompositeNode outputNode = null;
+        if (outputTO != null) {
+            outputNode = mapper.getOutputMapper().domFromObject(outputTO);
+        }
+        return Rpcs.getRpcResult(result.isSuccessful(), outputNode,
+                result.getErrors());
+    }
+

     private class ConsumerSessionImpl implements
             BindingAwareBroker.ConsumerSession {
 
         private final BindingAwareConsumer consumer;
     private class ConsumerSessionImpl implements
             BindingAwareBroker.ConsumerSession {
 
         private final BindingAwareConsumer consumer;

-        private Map<Class<? extends BindingAwareService>, BindingAwareService> sessionSalServices = new HashMap<Class<? extends BindingAwareService>, BindingAwareService>();
+        private Map<Class<? extends BindingAwareService>, BindingAwareService> sessionSalServices = Collections
+                .synchronizedMap(new HashMap<Class<? extends BindingAwareService>, BindingAwareService>());
+
+        private Map<Class<? extends RpcService>, RpcService> sessionRpcProxies = Collections
+                .synchronizedMap(new HashMap<Class<? extends RpcService>, RpcService>());

 
         public ConsumerSessionImpl(BindingAwareConsumer cons) {
             this.consumer = cons;
 
         public ConsumerSessionImpl(BindingAwareConsumer cons) {
             this.consumer = cons;


@@ -153,9 +276,27 @@ public class BindingBrokerImpl implements BindingAwareBroker {
         }
 
         @Override
         }
 
         @Override

-        public <T extends RpcService> T getRpcService(Class<T> module) {
-            // TODO Implement this method
-            throw new UnsupportedOperationException("Not implemented");
+        public <T extends RpcService> T getRpcService(Class<T> service) {
+            RpcService current = sessionRpcProxies.get(service);
+            if (current != null) {
+                if (service.isInstance(current)) {
+                    @SuppressWarnings("unchecked")
+                    T ret = (T) current;
+                    return ret;
+                } else {
+                    log.error("Proxy  for rpc service " + service.getName()
+                            + " does not implement the service interface");
+                    throw new IllegalStateException("Service implementation "
+                            + current.getClass().getName()
+                            + "does not implement " + service.getName());
+                }
+            } else {
+                T ret = BindingBrokerImpl.this.newRpcProxyForSession(service);
+                if (ret != null) {
+                    sessionRpcProxies.put(service, ret);
+                }
+                return ret;
+            }

         }
 
         public BindingAwareConsumer getConsumer() {
         }
 
         public BindingAwareConsumer getConsumer() {


@@ -176,12 +317,20 @@ public class BindingBrokerImpl implements BindingAwareBroker {
 
         @Override
         public void addRpcImplementation(RpcService implementation) {
 
         @Override
         public void addRpcImplementation(RpcService implementation) {

+            if (implementation == null) {
+                throw new IllegalArgumentException(
+                        "Implementation should not be null");
+            }

             // TODO Implement this method
             throw new UnsupportedOperationException("Not implemented");
         }
 
         @Override
         public void removeRpcImplementation(RpcService implementation) {
             // TODO Implement this method
             throw new UnsupportedOperationException("Not implemented");
         }
 
         @Override
         public void removeRpcImplementation(RpcService implementation) {

+            if (implementation == null) {
+                throw new IllegalArgumentException(
+                        "Implementation should not be null");
+            }

             // TODO Implement this method
             throw new UnsupportedOperationException("Not implemented");
         }
             // TODO Implement this method
             throw new UnsupportedOperationException("Not implemented");
         }


@@ -192,4 +341,96 @@ public class BindingBrokerImpl implements BindingAwareBroker {
 
     }
 
 
     }
 

+    private class BIFacade implements Provider,RpcImplementation {
+
+        @Override
+        public Set<QName> getSupportedRpcs() {
+            return Collections.emptySet();
+        }
+
+        @Override
+        public RpcResult<CompositeNode> invokeRpc(QName rpc, CompositeNode input) {
+            if (rpc == null) {
+                throw new IllegalArgumentException(
+                        "Rpc type should not be null");
+            }
+
+            return BindingBrokerImpl.this.invokeLocalRpc(rpc, input);
+        }
+
+        @Override
+        public void onSessionInitiated(
+                org.opendaylight.controller.sal.core.api.Broker.ProviderSession session) {
+            
+            BindingBrokerImpl.this.biSession = session;
+            for (SALBindingModule module : modules) {
+                try {
+                    module.onBISessionAvailable(biSession);
+                } catch(Exception e) {
+                    log.error("Module " +module +" throwed unexpected exception",e);
+                }
+            }
+        }
+
+        @Override
+        public Collection<ProviderFunctionality> getProviderFunctionality() {
+            return Collections.emptySet();
+        }
+
+    }
+
+    private static class TranslatedFuture implements
+            Future<RpcResult<? extends DataObject>> {
+        private final Future<RpcResult<CompositeNode>> realFuture;
+        private final RpcMapper<?> mapper;
+
+        public TranslatedFuture(Future<RpcResult<CompositeNode>> future,
+                RpcMapper<?> mapper) {
+            realFuture = future;
+            this.mapper = mapper;
+        }
+
+        @Override
+        public boolean cancel(boolean mayInterruptIfRunning) {
+            return realFuture.cancel(mayInterruptIfRunning);
+        }
+
+        @Override
+        public boolean isCancelled() {
+            return realFuture.isCancelled();
+        }
+
+        @Override
+        public boolean isDone() {
+            return realFuture.isDone();
+        }
+
+        @Override
+        public RpcResult<? extends DataObject> get()
+                throws InterruptedException, ExecutionException {
+            RpcResult<CompositeNode> val = realFuture.get();
+            return tranlate(val);
+        }
+
+        @Override
+        public RpcResult<? extends DataObject> get(long timeout, TimeUnit unit)
+                throws InterruptedException, ExecutionException,
+                TimeoutException {
+            RpcResult<CompositeNode> val = realFuture.get(timeout, unit);
+            return tranlate(val);
+        }
+
+        private RpcResult<? extends DataObject> tranlate(
+                RpcResult<CompositeNode> result) {
+            CompositeNode outputNode = result.getResult();
+            DataObject outputTO = null;
+            if (outputNode != null) {
+                Mapper<?> outputMapper = mapper.getOutputMapper();
+                outputTO = outputMapper.objectFromDom(outputNode);
+            }
+            return Rpcs.getRpcResult(result.isSuccessful(), outputTO,
+                    result.getErrors());
+        }
+
+    }

 }
 }

diff --git a/opendaylight/sal/yang-prototype/sal/sal-binding-broker-impl/src/main/java/org/opendaylight/controller/sal/binding/impl/DataModule.java b/opendaylight/sal/yang-prototype/sal/sal-binding-broker-impl/src/main/java/org/opendaylight/controller/sal/binding/impl/DataModule.java
new file mode 100644 (file)
index 0000000..cbd6b00
--- /dev/null
+++ b/opendaylight/sal/yang-prototype/sal/sal-binding-broker-impl/src/main/java/org/opendaylight/controller/sal/binding/impl/DataModule.java
@@ -0,0 +1,198 @@
+package org.opendaylight.controller.sal.binding.impl;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.Future;
+
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ConsumerSession;
+import org.opendaylight.controller.sal.binding.api.BindingAwareProvider.ProviderFunctionality;
+import org.opendaylight.controller.sal.binding.api.BindingAwareService;
+import org.opendaylight.controller.sal.binding.api.DataBrokerService;
+import org.opendaylight.controller.sal.binding.api.DataCommitHandler;
+import org.opendaylight.controller.sal.binding.api.DataProviderService;
+import org.opendaylight.controller.sal.binding.api.DataValidator;
+import org.opendaylight.controller.sal.binding.spi.MappingProvider;
+import org.opendaylight.controller.sal.binding.spi.SALBindingModule;
+import org.opendaylight.controller.sal.common.DataStoreIdentifier;
+import org.opendaylight.controller.sal.binding.api.DataRefresher;
+import org.opendaylight.controller.yang.binding.DataRoot;
+import org.opendaylight.controller.yang.common.RpcResult;
+import org.opendaylight.controller.yang.data.api.CompositeNode;
+
+public class DataModule implements SALBindingModule {
+
+    private BindingAwareBroker broker;
+    private org.opendaylight.controller.sal.core.api.Broker.ProviderSession biSession;
+    private MappingProvider mappingProvider;
+    private final BIFacade biFacade = new BIFacade();
+    private org.opendaylight.controller.sal.core.api.data.DataProviderService biDataService;
+
+    @Override
+    public void setBroker(BindingAwareBroker broker) {
+        this.broker = broker;
+    }
+
+    @Override
+    public void onBISessionAvailable(
+            org.opendaylight.controller.sal.core.api.Broker.ProviderSession session) {
+        this.biSession = session;
+        this.biDataService = session
+                .getService(org.opendaylight.controller.sal.core.api.data.DataProviderService.class);
+        // biDataService.addRefresher(store, refresher)
+
+    }
+
+    @Override
+    public void setMappingProvider(MappingProvider provider) {
+        this.mappingProvider = provider;
+
+    }
+
+    @Override
+    public Set<Class<? extends BindingAwareService>> getProvidedServices() {
+        Set<Class<? extends BindingAwareService>> ret = new HashSet<Class<? extends BindingAwareService>>();
+        ret.add(DataBrokerService.class);
+        ret.add(DataProviderService.class);
+        return ret;
+    }
+
+    @Override
+    public <T extends BindingAwareService> T getServiceForSession(
+            Class<T> service, ConsumerSession session) {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public Set<Class<? extends ProviderFunctionality>> getSupportedProviderFunctionality() {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    private class DataBrokerSession implements DataBrokerService {
+
+        @Override
+        public <T extends DataRoot> T getData(DataStoreIdentifier store,
+                Class<T> rootType) {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        @Override
+        public <T extends DataRoot> T getData(DataStoreIdentifier store,
+                T filter) {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        @Override
+        public <T extends DataRoot> T getCandidateData(
+                DataStoreIdentifier store, Class<T> rootType) {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        @Override
+        public <T extends DataRoot> T getCandidateData(
+                DataStoreIdentifier store, T filter) {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        @Override
+        public RpcResult<DataRoot> editCandidateData(DataStoreIdentifier store,
+                DataRoot changeSet) {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        @Override
+        public Future<RpcResult<Void>> commit(DataStoreIdentifier store) {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+    }
+
+    private class DataProviderSession extends DataBrokerSession implements
+            DataProviderService {
+
+        @Override
+        public void addValidator(DataStoreIdentifier store,
+                DataValidator validator) {
+            // TODO Auto-generated method stub
+
+        }
+
+        @Override
+        public void removeValidator(DataStoreIdentifier store,
+                DataValidator validator) {
+            // TODO Auto-generated method stub
+
+        }
+
+        @Override
+        public void addCommitHandler(DataStoreIdentifier store,
+                DataCommitHandler provider) {
+            // TODO Auto-generated method stub
+
+        }
+
+        @Override
+        public void removeCommitHandler(DataStoreIdentifier store,
+                DataCommitHandler provider) {
+            // TODO Auto-generated method stub
+
+        }
+
+        @Override
+        public void addRefresher(DataStoreIdentifier store,
+                DataRefresher refresher) {
+            // TODO Auto-generated method stub
+
+        }
+
+        @Override
+        public void removeRefresher(DataStoreIdentifier store,
+                DataRefresher refresher) {
+            // TODO Auto-generated method stub
+
+        }
+
+    }
+
+    private class BIFacade
+            implements
+            org.opendaylight.controller.sal.core.api.data.DataCommitHandler,
+            org.opendaylight.controller.sal.core.api.data.DataValidator,
+            org.opendaylight.controller.sal.core.api.data.DataProviderService.DataRefresher {
+
+        @Override
+        public RpcResult<Void> validate(CompositeNode toValidate) {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        @Override
+        public Set<DataStoreIdentifier> getSupportedDataStores() {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        @Override
+        public RpcResult<CommitTransaction> requestCommit(
+                DataStoreIdentifier store) {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        @Override
+        public void refreshData() {
+            // TODO Auto-generated method stub
+            
+        }
+
+    }
+
+}

diff --git a/opendaylight/sal/yang-prototype/sal/sal-binding-spi/src/main/java/org/opendaylight/controller/sal/binding/spi/MappingProvider.java b/opendaylight/sal/yang-prototype/sal/sal-binding-spi/src/main/java/org/opendaylight/controller/sal/binding/spi/MappingProvider.java
index a7fbb240895ca7a5d7144c12d94fa25e98414cc8..b29eac2871c2a1534ead86f552a4acf5a3ddabf9 100644 (file)
--- a/opendaylight/sal/yang-prototype/sal/sal-binding-spi/src/main/java/org/opendaylight/controller/sal/binding/spi/MappingProvider.java
+++ b/opendaylight/sal/yang-prototype/sal/sal-binding-spi/src/main/java/org/opendaylight/controller/sal/binding/spi/MappingProvider.java
@@ -8,12 +8,40 @@
 package org.opendaylight.controller.sal.binding.spi;
 
 import org.opendaylight.controller.yang.binding.DataObject;
 package org.opendaylight.controller.sal.binding.spi;
 
 import org.opendaylight.controller.yang.binding.DataObject;

+import org.opendaylight.controller.yang.binding.RpcService;

 import org.opendaylight.controller.yang.common.QName;
 import org.opendaylight.controller.yang.common.QName;

+import org.opendaylight.controller.yang.data.api.CompositeNode;

 
 public interface MappingProvider {
 
 
 public interface MappingProvider {
 

-    <T extends DataObject> Mapper<T> getMapper(Class<T> type);
-    Mapper<DataObject> getMapper(QName name);
+    <T extends DataObject> Mapper<T> mapperForClass(Class<T> type);
+    Mapper<DataObject> mapperForQName(QName name);
+    
+    /**
+     * Returns {@link RpcMapper} associated to class
+     * 
+     * @param type Class for which RpcMapper should provide mapping
+     * @return
+     */
+    <T extends RpcService> RpcMapper<T> rpcMapperForClass(Class<T> type);
+    
+    /**
+     * Returns {@link RpcMapper} associated to the {@link RpcService} proxy.
+     * 
+     * @param proxy
+     * @return
+     */
+    RpcMapper<? extends RpcService> rpcMapperForProxy(RpcService proxy);
+    
+    /**
+     * 
+     * 
+     * @param rpc
+     * @param inputNode
+     * @return
+     */
+    RpcMapper<? extends RpcService> rpcMapperForData(QName rpc,
+            CompositeNode inputNode);

 
     <T extends MappingExtension> MappingExtensionFactory<T> getExtensionFactory(Class<T> cls);
 
 
     <T extends MappingExtension> MappingExtensionFactory<T> getExtensionFactory(Class<T> cls);
 


@@ -25,4 +53,6 @@ public interface MappingProvider {
         T forClass(Class<?> obj);
     }
 
         T forClass(Class<?> obj);
     }
 

+
+

 }
 }

diff --git a/opendaylight/sal/yang-prototype/sal/sal-binding-spi/src/main/java/org/opendaylight/controller/sal/binding/spi/RpcMapper.java b/opendaylight/sal/yang-prototype/sal/sal-binding-spi/src/main/java/org/opendaylight/controller/sal/binding/spi/RpcMapper.java
new file mode 100644 (file)
index 0000000..0db1bc2
--- /dev/null
+++ b/opendaylight/sal/yang-prototype/sal/sal-binding-spi/src/main/java/org/opendaylight/controller/sal/binding/spi/RpcMapper.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.sal.binding.spi;
+
+import java.util.Set;
+import java.util.concurrent.Future;
+
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
+import org.opendaylight.controller.yang.binding.DataObject;
+import org.opendaylight.controller.yang.binding.RpcService;
+import org.opendaylight.controller.yang.common.QName;
+import org.opendaylight.controller.yang.common.RpcResult;
+
+public interface RpcMapper<T extends RpcService> {
+    
+    Set<QName> getRpcQNames();
+    
+    /**
+     * Returns a class object representing subinterface
+     * to whom, this mapper is assigned.
+     * 
+     * @return
+     */
+    Class<T> getServiceClass();
+    
+    /**
+     * Returns a Binding Mapper for Rpc Input Data
+     * @return
+     */
+    Mapper<?> getInputMapper();
+    /**
+     * Returns a Binding Mapper for Rpc Output Data
+     * 
+     * @return
+     */
+    Mapper<?> getOutputMapper();
+    
+    /**
+     * Returns a consumer proxy, which is responsible
+     * for invoking the rpc functionality of {@link BindingAwareBroker} implementation.
+     * 
+     * @return Proxy of {@link RpcService} assigned to this mapper.
+     */
+    T getConsumerProxy(RpcProxyInvocationHandler handler);
+    
+    /**
+     * Invokes the method of RpcService representing the supplied rpc.
+     * 
+     * @param rpc QName of Rpc
+     * @param impl Implementation of RpcService on which the method should be invoked
+     * @param baInput Input Data to RPC method
+     * @return Result of RPC invocation.
+     */
+    RpcResult<? extends DataObject> invokeRpcImplementation(QName rpc,
+            RpcService impl, DataObject baInput);
+    
+    public interface RpcProxyInvocationHandler {
+        
+        Future<RpcResult<? extends DataObject>> invokeRpc(RpcService proxy, QName rpc, DataObject input);
+    }
+}