import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.JdkFutureAdapters;
import com.google.common.util.concurrent.ListenableFuture;
import java.lang.reflect.Method;
import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
import org.opendaylight.mdsal.dom.api.DOMRpcImplementation;
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.yangtools.util.concurrent.ExceptionMapper;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
inputQname = QName.create(BindingReflections.getQNameModule(type), "input").intern();
}
+ @SuppressWarnings("deprecation")
@Nonnull
@Override
public CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(@Nonnull final DOMRpcIdentifier rpc,
final SchemaPath schemaPath = rpc.getType();
final TreeNode bindingInput = input != null ? deserialize(rpc.getType(), input) : null;
final ListenableFuture<RpcResult<?>> bindingResult = invoke(schemaPath, bindingInput);
- return transformResult(bindingResult);
+ return Futures.makeChecked(transformResult(bindingResult),
+ new ExceptionMapper<DOMRpcException>("invokeRPc", DOMRpcException.class) {
+
+ @Override
+ protected DOMRpcException newWithCause(final String message, final Throwable cause) {
+ return new DOMRpcInvokeException(message, cause);
+ }
+ });
+ }
+
+ private class DOMRpcInvokeException extends DOMRpcException {
+
+ private static final long serialVersionUID = 1L;
+
+ protected DOMRpcInvokeException(final String message, final Throwable cause) {
+ super(message, cause);
+ }
}
@Override
return JdkFutureAdapters.listenInPoolThread(invoker.invoke(delegate, schemaPath.getLastComponent(), input));
}
- private CheckedFuture<DOMRpcResult, DOMRpcException>
+ private ListenableFuture<DOMRpcResult>
transformResult(final ListenableFuture<RpcResult<?>> bindingResult) {
return LazyDOMOperationResultFuture.create(codec, bindingResult);
}
import com.google.common.annotations.Beta;
import com.google.common.base.Preconditions;
-import com.google.common.base.Throwables;
-import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import javax.annotation.Nonnull;
import org.opendaylight.mdsal.binding.javav2.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
import org.opendaylight.mdsal.binding.javav2.spec.base.TreeNode;
-import org.opendaylight.mdsal.dom.api.DOMRpcException;
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.yangtools.yang.binding.DataContainer;
* DOM operation result from Binding.
*/
@Beta
-final class LazyDOMOperationResultFuture implements CheckedFuture<DOMRpcResult, DOMRpcException> {
+final class LazyDOMOperationResultFuture implements ListenableFuture<DOMRpcResult> {
private final ListenableFuture<RpcResult<?>> bindingFuture;
private final BindingNormalizedNodeCodecRegistry codec;
this.codec = Preconditions.checkNotNull(codec, "codec");
}
- static CheckedFuture<DOMRpcResult, DOMRpcException> create(final BindingNormalizedNodeCodecRegistry codec,
+ static ListenableFuture<DOMRpcResult> create(final BindingNormalizedNodeCodecRegistry codec,
final ListenableFuture<RpcResult<?>> bindingResult) {
return new LazyDOMOperationResultFuture(bindingResult, codec);
}
return transformIfNecessary(bindingFuture.get(timeout, unit));
}
- @Override
- public DOMRpcResult checkedGet() throws DOMRpcException {
- try {
- return get();
- } catch (InterruptedException | ExecutionException e) {
- // FIXME: Add exception mapping
- throw Throwables.propagate(e);
- }
- }
-
- @Override
- public DOMRpcResult checkedGet(@Nonnull final long timeout, final TimeUnit unit)
- throws TimeoutException, DOMRpcException {
- try {
- return get(timeout, unit);
- } catch (InterruptedException | ExecutionException e) {
- // FIXME: Add exception mapping
- throw Throwables.propagate(e);
- }
- }
-
@Override
public boolean isCancelled() {
return bindingFuture.isCancelled();
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
-import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.JdkFutureAdapters;
import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import org.opendaylight.mdsal.binding.javav2.spec.base.Instantiable;
import org.opendaylight.mdsal.binding.javav2.spec.base.Rpc;
import org.opendaylight.mdsal.binding.javav2.spec.base.TreeNode;
-import org.opendaylight.mdsal.dom.api.DOMRpcException;
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.mdsal.dom.spi.RpcRoutingStrategy;
}
private ListenableFuture<RpcResult<?>> invoke0(final SchemaPath schemaPath, final NormalizedNode<?, ?> input) {
- final CheckedFuture<DOMRpcResult, DOMRpcException> result = delegate.invokeRpc(schemaPath, input);
-
- if (result instanceof LazyDOMOperationResultFuture) {
- return ((LazyDOMOperationResultFuture) result).getBindingFuture();
+ final ListenableFuture<DOMRpcResult> listenInPoolThread =
+ JdkFutureAdapters.listenInPoolThread(delegate.invokeRpc(schemaPath, input));
+ if (listenInPoolThread instanceof LazyDOMOperationResultFuture) {
+ return ((LazyDOMOperationResultFuture) listenInPoolThread).getBindingFuture();
}
- return transformFuture(schemaPath, result, codec.getCodecFactory());
+ return transformFuture(schemaPath, listenInPoolThread, codec.getCodecFactory());
}
private ListenableFuture<RpcResult<?>> transformFuture(final SchemaPath rpc,
bindingResult = null;
}
return RpcResult.class.cast(RpcResultBuilder.success(bindingResult).build());
- });
+ }, MoreExecutors.directExecutor());
}
}
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
-import javax.annotation.Nonnull;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
import org.opendaylight.mdsal.binding.javav2.api.BindingTransactionChain;
import org.opendaylight.mdsal.binding.javav2.api.ReadTransaction;
import org.opendaylight.mdsal.binding.javav2.api.WriteTransaction;
};
}
- private CheckedFuture<Void, TransactionCommitFailedException> listenForFailure(final WriteTransaction tx,
- final CheckedFuture<Void, TransactionCommitFailedException> future) {
- Futures.addCallback(future, new FutureCallback<Void>() {
+ private <T, F extends ListenableFuture<T>> F listenForFailure(final WriteTransaction tx, final F future) {
+ Futures.addCallback(future, new FutureCallback<T>() {
@Override
- public void onFailure(@Nonnull final Throwable throwable) {
+ public void onFailure(final Throwable throwable) {
failTransactionChain(tx, throwable);
}
@Override
- public void onSuccess(final Void result) {
+ public void onSuccess(final T result) {
// Intentionally NOOP
}
- });
+ }, MoreExecutors.directExecutor());
return future;
}