import com.google.common.collect.Collections2;
import com.google.common.collect.ImmutableSet;
-import com.google.common.util.concurrent.Futures;
import java.util.Collection;
import java.util.Set;
import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.mdsal.dom.spi.RpcRoutingStrategy;
import org.opendaylight.yangtools.concepts.Registration;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.RpcService;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.osgi.framework.Bundle;
final Set<DOMRpcIdentifier> rpcs = ImmutableSet.copyOf(Collections2.transform(paths, DOMRpcIdentifier::create));
reg = domRpcProvider.registerRpcImplementation((rpc, input) -> {
- return Futures.immediateFailedCheckedFuture(new DOMRpcImplementationNotAvailableException(
+ return FluentFutures.immediateFailedFluentFuture(new DOMRpcImplementationNotAvailableException(
"Action %s has no instance matching %s", rpc, input));
}, rpcs);
LOG.debug("Registered provider for {}", interfaceName);
import java.lang.reflect.Proxy;
import java.util.Collection;
import java.util.Map.Entry;
+import java.util.concurrent.Future;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
if (result instanceof BindingRpcFutureAware) {
return ((BindingRpcFutureAware) result).getBindingFuture();
} else if (result instanceof LegacyDOMRpcResultFutureAdapter) {
- CheckedFuture<org.opendaylight.mdsal.dom.api.DOMRpcResult, org.opendaylight.mdsal.dom.api.DOMRpcException>
- delegateFuture = ((LegacyDOMRpcResultFutureAdapter)result).delegate();
+ Future<org.opendaylight.mdsal.dom.api.DOMRpcResult> delegateFuture =
+ ((LegacyDOMRpcResultFutureAdapter)result).delegate();
if (delegateFuture instanceof BindingRpcFutureAware) {
return ((BindingRpcFutureAware) delegateFuture).getBindingFuture();
}
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ImmutableSet;
import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
org.opendaylight.mdsal.dom.api.DOMRpcImplementation delegateImpl =
new org.opendaylight.mdsal.dom.api.DOMRpcImplementation() {
@Override
- public CheckedFuture<org.opendaylight.mdsal.dom.api.DOMRpcResult,
- org.opendaylight.mdsal.dom.api.DOMRpcException> invokeRpc(
+ public FluentFuture<org.opendaylight.mdsal.dom.api.DOMRpcResult> invokeRpc(
org.opendaylight.mdsal.dom.api.DOMRpcIdentifier rpc, NormalizedNode<?, ?> input) {
return new MdsalDOMRpcResultFutureAdapter(implementation.invokeRpc(convert(rpc), input));
}
@Override
public CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(final SchemaPath type,
final NormalizedNode<?, ?> input) {
- final CheckedFuture<org.opendaylight.mdsal.dom.api.DOMRpcResult, org.opendaylight.mdsal.dom.api.DOMRpcException>
- future = delegateRpcService.invokeRpc(type, input);
+ final FluentFuture<org.opendaylight.mdsal.dom.api.DOMRpcResult> future =
+ delegateRpcService.invokeRpc(type, input);
return future instanceof MdsalDOMRpcResultFutureAdapter ? ((MdsalDOMRpcResultFutureAdapter)future).delegate()
: new LegacyDOMRpcResultFutureAdapter(future);
}
import com.google.common.collect.ImmutableList;
import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.AbstractMap.SimpleEntry;
import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.controller.md.sal.dom.store.impl.TestModel;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult result =
new org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult(RPC_OUTPUT,
Collections.singleton(RpcResultBuilder.newError(ErrorType.RPC, "tag", "message")));
- testMdsalRpcImpl.init(Futures.immediateCheckedFuture(result));
+ testMdsalRpcImpl.init(FluentFutures.immediateFluentFuture(result));
ListenableFuture<DOMRpcResult> future = legacyRpcRouter.invokeRpc(legacyTestRpcIdentifier.getType(), RPC_INPUT);
// Test exception returned
TestMdsalDOMRpcException rpcEx = new TestMdsalDOMRpcException();
- testMdsalRpcImpl.init(Futures.immediateFailedCheckedFuture(rpcEx));
+ testMdsalRpcImpl.init(FluentFutures.immediateFailedFluentFuture(rpcEx));
try {
legacyRpcRouter.invokeRpc(legacyTestRpcIdentifier.getType(), RPC_INPUT).get();
// Test no input or output
- testMdsalRpcImpl.init(Futures.immediateCheckedFuture(null));
+ testMdsalRpcImpl.init(FluentFutures.immediateNullFluentFuture());
future = legacyRpcRouter.invokeRpc(legacyTestRpcNoInputIdentifier.getType(), null);
private static class TestMdsalDOMRpcImplementation
extends AbstractDOMRpcImplementation<org.opendaylight.mdsal.dom.api.DOMRpcIdentifier>
implements org.opendaylight.mdsal.dom.api.DOMRpcImplementation {
- CheckedFuture<org.opendaylight.mdsal.dom.api.DOMRpcResult,
- org.opendaylight.mdsal.dom.api.DOMRpcException> returnFuture;
+ FluentFuture<org.opendaylight.mdsal.dom.api.DOMRpcResult> returnFuture;
@Override
- public CheckedFuture<org.opendaylight.mdsal.dom.api.DOMRpcResult,
- org.opendaylight.mdsal.dom.api.DOMRpcException> invokeRpc(
+ public FluentFuture<org.opendaylight.mdsal.dom.api.DOMRpcResult> invokeRpc(
final org.opendaylight.mdsal.dom.api.DOMRpcIdentifier rpc, final NormalizedNode<?, ?> input) {
rpcInput = new SimpleEntry<>(rpc, input);
return returnFuture;
}
- void init(CheckedFuture<org.opendaylight.mdsal.dom.api.DOMRpcResult,
- org.opendaylight.mdsal.dom.api.DOMRpcException> retFuture) {
+ void init(FluentFuture<org.opendaylight.mdsal.dom.api.DOMRpcResult> retFuture) {
this.returnFuture = retFuture;
rpcInput = null;
}
*/
package org.opendaylight.controller.sal.core.compat;
-import com.google.common.util.concurrent.CheckedFuture;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import com.google.common.util.concurrent.AbstractFuture;
+import com.google.common.util.concurrent.ListenableFuture;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
* @author Thomas Pantelis
*/
@SuppressWarnings("checkstyle:ClassTypeParameterName")
-public abstract class AbstractDOMRpcResultFutureAdapter<T extends DOMRpcResult, TE extends DOMRpcException,
- F extends DOMRpcResult, FE extends DOMRpcException> implements CheckedFuture<T, TE> {
- private final CheckedFuture<F, FE> delegate;
- private final ExceptionMapper<TE> exMapper;
+public abstract class AbstractDOMRpcResultFutureAdapter<T extends DOMRpcResult, F extends DOMRpcResult,
+ D extends ListenableFuture<F>, E extends DOMRpcException> extends AbstractFuture<T> {
+ private final D delegate;
+ private final ExceptionMapper<E> exMapper;
private volatile Optional<T> result;
- AbstractDOMRpcResultFutureAdapter(CheckedFuture<F, FE> delegate, ExceptionMapper<TE> exMapper) {
+ AbstractDOMRpcResultFutureAdapter(D delegate, ExceptionMapper<E> exMapper) {
this.delegate = delegate;
this.exMapper = exMapper;
}
protected abstract T transform(F fromResult);
- public CheckedFuture<F, FE> delegate() {
+ public D delegate() {
return delegate;
}
}
}
- @Override
- @SuppressFBWarnings("BC_UNCONFIRMED_CAST_OF_RETURN_VALUE")
- public T checkedGet() throws TE {
- try {
- return get();
- } catch (InterruptedException | ExecutionException e) {
- throw exMapper.apply(e);
- }
- }
-
- @Override
- @SuppressFBWarnings("BC_UNCONFIRMED_CAST_OF_RETURN_VALUE")
- public T checkedGet(final long timeout, final TimeUnit unit) throws TimeoutException, TE {
- try {
- return get(timeout, unit);
- } catch (InterruptedException | ExecutionException e) {
- throw exMapper.apply(e);
- }
- }
-
private synchronized T transformIfNecessary(F delegateResult) {
if (result == null) {
if (delegateResult == null) {
package org.opendaylight.controller.sal.core.compat;
import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcImplementationNotAvailableException;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
*
* @author Thomas Pantelis
*/
-public class LegacyDOMRpcResultFutureAdapter extends AbstractDOMRpcResultFutureAdapter<DOMRpcResult, DOMRpcException,
- org.opendaylight.mdsal.dom.api.DOMRpcResult, org.opendaylight.mdsal.dom.api.DOMRpcException> {
+public class LegacyDOMRpcResultFutureAdapter extends AbstractDOMRpcResultFutureAdapter<DOMRpcResult,
+ org.opendaylight.mdsal.dom.api.DOMRpcResult, FluentFuture<org.opendaylight.mdsal.dom.api.DOMRpcResult>,
+ DOMRpcException> implements CheckedFuture<DOMRpcResult, DOMRpcException> {
private static final ExceptionMapper<DOMRpcException> LEGACY_DOM_RPC_EX_MAPPER =
new ExceptionMapper<DOMRpcException>("rpc", DOMRpcException.class) {
}
};
- public LegacyDOMRpcResultFutureAdapter(CheckedFuture<org.opendaylight.mdsal.dom.api.DOMRpcResult,
- org.opendaylight.mdsal.dom.api.DOMRpcException> delegate) {
+ public LegacyDOMRpcResultFutureAdapter(FluentFuture<org.opendaylight.mdsal.dom.api.DOMRpcResult> delegate) {
super(delegate, LEGACY_DOM_RPC_EX_MAPPER);
}
+ @Override
+ @SuppressFBWarnings("BC_UNCONFIRMED_CAST_OF_RETURN_VALUE")
+ public DOMRpcResult checkedGet() throws DOMRpcException {
+ try {
+ return get();
+ } catch (InterruptedException | ExecutionException e) {
+ throw LEGACY_DOM_RPC_EX_MAPPER.apply(e);
+ }
+ }
+
+ @Override
+ @SuppressFBWarnings("BC_UNCONFIRMED_CAST_OF_RETURN_VALUE")
+ public DOMRpcResult checkedGet(final long timeout, final TimeUnit unit) throws TimeoutException, DOMRpcException {
+ try {
+ return get(timeout, unit);
+ } catch (InterruptedException | ExecutionException e) {
+ throw LEGACY_DOM_RPC_EX_MAPPER.apply(e);
+ }
+ }
+
@Override
protected DOMRpcResult transform(org.opendaylight.mdsal.dom.api.DOMRpcResult fromResult) {
return new DefaultDOMRpcResult(fromResult.getResult(), fromResult.getErrors());
* @author Thomas Pantelis
*/
public class MdsalDOMRpcResultFutureAdapter extends AbstractDOMRpcResultFutureAdapter<
- DOMRpcResult, DOMRpcException, org.opendaylight.controller.md.sal.dom.api.DOMRpcResult,
- org.opendaylight.controller.md.sal.dom.api.DOMRpcException> {
+ DOMRpcResult, org.opendaylight.controller.md.sal.dom.api.DOMRpcResult,
+ CheckedFuture<org.opendaylight.controller.md.sal.dom.api.DOMRpcResult,
+ org.opendaylight.controller.md.sal.dom.api.DOMRpcException>, DOMRpcException> {
private static final ExceptionMapper<DOMRpcException> MDSAL_DOM_RPC_EX_MAPPER =
new ExceptionMapper<DOMRpcException>("rpc", DOMRpcException.class) {
@Override