org.opendaylight.mdsal.binding.dom.adapter

Class BindingDOMRpcServiceAdapter

java.lang.Object

org.opendaylight.mdsal.binding.dom.adapter.BindingDOMRpcServiceAdapter

All Implemented Interfaces:

BindingService, RpcConsumerRegistry, org.opendaylight.yangtools.concepts.Delegator<DOMRpcService>

public class BindingDOMRpcServiceAdapter
extends Object
implements RpcConsumerRegistry

Field Summary

Fields

Modifier and Type	Field and Description
protected static org.opendaylight.mdsal.binding.dom.adapter.BindingDOMAdapterBuilder.Factory<RpcConsumerRegistry>	BUILDER_FACTORY

Constructor Summary

Constructors

Constructor and Description
BindingDOMRpcServiceAdapter(DOMRpcService domService, BindingToNormalizedNodeCodec codec)

Method Summary

Modifier and Type	Method and Description
protected BindingToNormalizedNodeCodec	getCodec()
T	getDelegate()
<T extends RpcService> T	getRpcService(Class<T> rpcService) Returns an implementation of a requested RPC service.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

BUILDER_FACTORY

protected static final org.opendaylight.mdsal.binding.dom.adapter.BindingDOMAdapterBuilder.Factory<RpcConsumerRegistry> BUILDER_FACTORY

Constructor Detail

BindingDOMRpcServiceAdapter

public BindingDOMRpcServiceAdapter(DOMRpcService domService,
                                   BindingToNormalizedNodeCodec codec)

Method Detail

getRpcService

public <T extends RpcService> T getRpcService(Class<T> rpcService)

Description copied from interface: RpcConsumerRegistry

Returns an implementation of a requested RPC service.

The returned instance is not an actual implementation of the RPC service interface, but a proxy implementation of the interface that forwards to an actual implementation, if any.

The following describes the behavior of the proxy when invoking RPC methods:

• If an actual implementation is registered with the MD-SAL, all invocations are forwarded to the registered implementation.
• If no actual implementation is registered, all invocations will fail by throwing IllegalStateException.
• Prior to invoking the actual implementation, the method arguments are are validated. If any are invalid, an IllegalArgumentException is thrown.

The returned proxy is automatically updated with the most recent registered implementation.

The generated RPC method APIs require implementors to return a Future instance that wraps the RpcResult. Since RPC methods may be implemented asynchronously, callers should avoid blocking on the Future result. Instead, it is recommended to use JdkFutureAdapters.listenInPoolThread(java.util.concurrent.Future) or JdkFutureAdapters.listenInPoolThread(java.util.concurrent.Future, java.util.concurrent.Executor) to listen for Rpc Result. This will asynchronously listen for future result in executor and will not block current thread.

   final Future<RpcResult<SomeRpcOutput>> future = someRpcService.someRpc( ... );
   Futures.addCallback(JdkFutureAdapters.listenInThreadPool(future), new FutureCallback<RpcResult<
   SomeRpcOutput>>() {

       public void onSuccess(RpcResult<SomeRpcOutput> result) {
          // process result ...
       }

       public void onFailure(Throwable t) {
          // RPC failed
       }
   );
 

Specified by:

getRpcService in interface RpcConsumerRegistry

Parameters:

rpcService - the interface of the RPC Service. Typically this is an interface generated from a YANG model.

Returns:

the proxy for the requested RPC service. This method never returns null.

getDelegate

public final T getDelegate()

Specified by:

getDelegate in interface org.opendaylight.yangtools.concepts.Delegator<T>

getCodec

protected final BindingToNormalizedNodeCodec getCodec()