Change DOM invokeRpc to FluentFuture

CheckedFuture is deprecated.

This breaks the controller - corresppnding patch is
https://git.opendaylight.org/gerrit/#/c/74366/

Change-Id: I08f396b872699512171a24732d9473ca96b89778
Signed-off-by: Tom Pantelis <tompantelis@gmail.com>

diff --git a/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/BindingDOMRpcImplementationAdapter.java b/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/BindingDOMRpcImplementationAdapter.java
index a1a0602c4a69df89c8fdc1b17eef075dd5bd9e89..e421908cf111267413e079f39127200c8456fbcd 100644 (file)
--- a/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/BindingDOMRpcImplementationAdapter.java
+++ b/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/BindingDOMRpcImplementationAdapter.java
@@ -10,7 +10,7 @@ package org.opendaylight.mdsal.binding.dom.adapter;
 import com.google.common.base.Preconditions;
 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.FluentFuture;
 import com.google.common.util.concurrent.ListenableFuture;
 import java.lang.reflect.Method;
 import java.util.HashMap;
@@ -21,7 +21,6 @@ import javax.annotation.Nonnull;
 import org.opendaylight.mdsal.binding.dom.adapter.invoke.RpcServiceInvoker;
 import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
 import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
-import org.opendaylight.mdsal.dom.api.DOMRpcException;
 import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
 import org.opendaylight.mdsal.dom.api.DOMRpcImplementation;
 import org.opendaylight.mdsal.dom.api.DOMRpcResult;
@@ -68,8 +67,7 @@ public class BindingDOMRpcImplementationAdapter implements DOMRpcImplementation
 
     @Nonnull
     @Override
-    public CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(@Nonnull final DOMRpcIdentifier rpc,
-            final NormalizedNode<?, ?> input) {
+    public FluentFuture<DOMRpcResult> invokeRpc(@Nonnull final DOMRpcIdentifier rpc, final NormalizedNode<?, ?> input) {
 
         final SchemaPath schemaPath = rpc.getType();
         final DataObject bindingInput = input != null ? deserialize(rpc.getType(), input) : null;
@@ -94,8 +92,7 @@ public class BindingDOMRpcImplementationAdapter implements DOMRpcImplementation
         return invoker.invokeRpc(delegate, schemaPath.getLastComponent(), input);
     }
 
-    private CheckedFuture<DOMRpcResult, DOMRpcException> transformResult(
-            final ListenableFuture<RpcResult<?>> bindingResult) {
+    private FluentFuture<DOMRpcResult> transformResult(final ListenableFuture<RpcResult<?>> bindingResult) {
         return LazyDOMRpcResultFuture.create(codec, bindingResult);
     }
 }

diff --git a/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/LazyDOMRpcResultFuture.java b/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/LazyDOMRpcResultFuture.java
index c24bf4f8eb90e73eb76f747843a74460c9da22b4..a706edc5d6e1a68c6b627167f1fc16e8873ead88 100644 (file)
--- a/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/LazyDOMRpcResultFuture.java
+++ b/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/LazyDOMRpcResultFuture.java
@@ -8,7 +8,8 @@
 package org.opendaylight.mdsal.binding.dom.adapter;
 
 import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.AbstractFuture;
+import com.google.common.util.concurrent.FluentFuture;
 import com.google.common.util.concurrent.ListenableFuture;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executor;
@@ -17,12 +18,22 @@ import java.util.concurrent.TimeoutException;
 import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
 import org.opendaylight.mdsal.dom.api.DOMRpcException;
 import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DefaultDOMRpcException;
 import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
+import org.opendaylight.yangtools.util.concurrent.ExceptionMapper;
 import org.opendaylight.yangtools.yang.binding.DataContainer;
 import org.opendaylight.yangtools.yang.common.RpcResult;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 
-final class LazyDOMRpcResultFuture implements CheckedFuture<DOMRpcResult, DOMRpcException>, BindingRpcFutureAware {
+final class LazyDOMRpcResultFuture extends AbstractFuture<DOMRpcResult> implements BindingRpcFutureAware {
+    private static final ExceptionMapper<DOMRpcException> DOM_RPC_EX_MAPPER =
+            new ExceptionMapper<DOMRpcException>("rpc", DOMRpcException.class) {
+        @Override
+        protected DOMRpcException newWithCause(String message, Throwable cause) {
+            return cause instanceof DOMRpcException ? (DOMRpcException)cause
+                    : new DefaultDOMRpcException("RPC failed", cause);
+        }
+    };
 
     private final ListenableFuture<RpcResult<?>> bindingFuture;
     private final BindingNormalizedNodeCodecRegistry codec;
@@ -34,7 +45,7 @@ final class LazyDOMRpcResultFuture implements CheckedFuture<DOMRpcResult, DOMRpc
         this.codec = Preconditions.checkNotNull(codec, "codec");
     }
 
-    static CheckedFuture<DOMRpcResult, DOMRpcException> create(final BindingNormalizedNodeCodecRegistry codec,
+    static FluentFuture<DOMRpcResult> create(final BindingNormalizedNodeCodecRegistry codec,
             final ListenableFuture<RpcResult<?>> bindingResult) {
         return new LazyDOMRpcResultFuture(bindingResult, codec);
     }
@@ -59,7 +70,12 @@ final class LazyDOMRpcResultFuture implements CheckedFuture<DOMRpcResult, DOMRpc
         if (result != null) {
             return result;
         }
-        return transformIfNecessary(bindingFuture.get());
+
+        try {
+            return transformIfNecessary(bindingFuture.get());
+        } catch (ExecutionException e) {
+            throw new ExecutionException(e.getMessage(), DOM_RPC_EX_MAPPER.apply(e));
+        }
     }
 
     @Override
@@ -68,26 +84,11 @@ final class LazyDOMRpcResultFuture implements CheckedFuture<DOMRpcResult, DOMRpc
         if (result != null) {
             return result;
         }
-        return transformIfNecessary(bindingFuture.get(timeout, unit));
-    }
-
-    @Override
-    public DOMRpcResult checkedGet() throws DOMRpcException {
-        try {
-            return get();
-        } catch (InterruptedException | ExecutionException e) {
-            // FIXME: Add exception mapping
-            throw new RuntimeException(e);
-        }
-    }
 
-    @Override
-    public DOMRpcResult checkedGet(final long timeout, final TimeUnit unit) throws TimeoutException, DOMRpcException {
         try {
-            return get(timeout, unit);
-        } catch (InterruptedException | ExecutionException e) {
-            // FIXME: Add exception mapping
-            throw new RuntimeException(e);
+            return transformIfNecessary(bindingFuture.get(timeout, unit));
+        } catch (ExecutionException e) {
+            throw new ExecutionException(e.getMessage(), DOM_RPC_EX_MAPPER.apply(e));
         }
     }
 
@@ -119,5 +120,4 @@ final class LazyDOMRpcResultFuture implements CheckedFuture<DOMRpcResult, DOMRpc
         }
         return new DefaultDOMRpcResult(input.getErrors());
     }
-
 }

diff --git a/binding/mdsal-binding-dom-adapter/src/test/java/org/opendaylight/mdsal/binding/dom/adapter/BindingDOMRpcIntegrationTest.java b/binding/mdsal-binding-dom-adapter/src/test/java/org/opendaylight/mdsal/binding/dom/adapter/BindingDOMRpcIntegrationTest.java
new file mode 100644 (file)
index 0000000..92a022e
--- /dev/null
+++ b/binding/mdsal-binding-dom-adapter/src/test/java/org/opendaylight/mdsal/binding/dom/adapter/BindingDOMRpcIntegrationTest.java
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2016 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.mdsal.binding.dom.adapter;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Multimap;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
+import org.opendaylight.mdsal.binding.dom.adapter.test.util.BindingBrokerTestFactory;
+import org.opendaylight.mdsal.binding.dom.adapter.test.util.BindingTestContext;
+import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
+import org.opendaylight.mdsal.dom.api.DOMRpcProviderService;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.md.sal.knock.knock.rev180723.KnockKnockInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.md.sal.knock.knock.rev180723.KnockKnockInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.md.sal.knock.knock.rev180723.KnockKnockOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.md.sal.knock.knock.rev180723.KnockKnockOutputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.md.sal.knock.knock.rev180723.OpendaylightKnockKnockRpcService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.Top;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.TopLevelList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.TopLevelListKey;
+import org.opendaylight.yangtools.concepts.ObjectRegistration;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.util.BindingReflections;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+
+public class BindingDOMRpcIntegrationTest {
+    private static final InstanceIdentifier<TopLevelList> BA_NODE_ID = InstanceIdentifier.create(Top.class)
+            .child(TopLevelList.class, new TopLevelListKey("a"));
+
+    private static final QName KNOCK_KNOCK_QNAME = QName.create(KnockKnockOutput.QNAME, "knock-knock");
+    private static final SchemaPath KNOCK_KNOCK_PATH = SchemaPath.create(true, KNOCK_KNOCK_QNAME);
+
+    private RpcProviderService baRpcProviderService;
+    private RpcConsumerRegistry baRpcConsumerService;
+    private DOMRpcProviderService biRpcProviderService;
+    private BindingTestContext testContext;
+    private DOMRpcService biRpcService;
+    private final OpendaylightKnockKnockRpcServiceImpl knockRpcImpl = new OpendaylightKnockKnockRpcServiceImpl();
+
+    @Before
+    public void setup() throws Exception {
+        BindingBrokerTestFactory testFactory = new BindingBrokerTestFactory();
+        testFactory.setExecutor(MoreExecutors.newDirectExecutorService());
+        testContext = testFactory.getTestContext();
+
+        testContext.setSchemaModuleInfos(ImmutableSet.of(
+                BindingReflections.getModuleInfo(OpendaylightKnockKnockRpcService.class),
+                BindingReflections.getModuleInfo(Top.class)));
+        testContext.start();
+        baRpcProviderService = testContext.getBindingRpcProviderRegistry();
+        baRpcConsumerService = testContext.getBindingRpcConsumerRegistry();
+        biRpcProviderService = testContext.getDomRpcRegistry();
+        biRpcService = testContext.getDomRpcInvoker();
+    }
+
+    @Test
+    public void testBindingRegistrationWithDOMInvocation()
+            throws InterruptedException, ExecutionException, TimeoutException {
+        knockRpcImpl.registerTo(baRpcProviderService, BA_NODE_ID).setKnockKnockResult(knockResult(true, "open"));
+
+        final OpendaylightKnockKnockRpcService baKnockService =
+                baRpcConsumerService.getRpcService(OpendaylightKnockKnockRpcService.class);
+        assertNotSame(knockRpcImpl, baKnockService);
+
+        KnockKnockInput baKnockKnockInput = knockKnock(BA_NODE_ID).setQuestion("who's there?").build();
+
+        ContainerNode biKnockKnockInput = toDOMKnockKnockInput(baKnockKnockInput);
+        DOMRpcResult domResult = biRpcService.invokeRpc(KNOCK_KNOCK_PATH, biKnockKnockInput).get(5, TimeUnit.SECONDS);
+        assertNotNull(domResult);
+        assertNotNull(domResult.getResult());
+        assertTrue("Binding KnockKnock service was not invoked",
+                knockRpcImpl.getReceivedKnocks().containsKey(BA_NODE_ID));
+        assertEquals(baKnockKnockInput, knockRpcImpl.getReceivedKnocks().get(BA_NODE_ID).iterator().next());
+    }
+
+    @Test
+    public void testDOMRegistrationWithBindingInvocation()
+            throws InterruptedException, ExecutionException, TimeoutException {
+        KnockKnockOutput baKnockKnockOutput = new KnockKnockOutputBuilder().setAnswer("open").build();
+
+        biRpcProviderService.registerRpcImplementation((rpc, input) ->
+            FluentFutures.immediateFluentFuture(new DefaultDOMRpcResult(testContext.getCodec()
+                    .getCodecFactory().toNormalizedNodeRpcData(baKnockKnockOutput))),
+            DOMRpcIdentifier.create(KNOCK_KNOCK_PATH, testContext.getCodec().toNormalized(BA_NODE_ID)));
+
+        final OpendaylightKnockKnockRpcService baKnockService =
+                baRpcConsumerService.getRpcService(OpendaylightKnockKnockRpcService.class);
+        Future<RpcResult<KnockKnockOutput>> baResult = baKnockService.knockKnock(knockKnock(BA_NODE_ID)
+            .setQuestion("Who's there?").build());
+        assertNotNull(baResult);
+        assertEquals(baKnockKnockOutput, baResult.get(5, TimeUnit.SECONDS).getResult());
+    }
+
+    @Test
+    public void testBindingRpcShortcut() throws InterruptedException, ExecutionException, TimeoutException {
+        final ListenableFuture<RpcResult<KnockKnockOutput>> baKnockResult = knockResult(true, "open");
+        knockRpcImpl.registerTo(baRpcProviderService, BA_NODE_ID).setKnockKnockResult(baKnockResult);
+
+        final OpendaylightKnockKnockRpcService baKnockService =
+                baRpcConsumerService.getRpcService(OpendaylightKnockKnockRpcService.class);
+
+        KnockKnockInput baKnockKnockInput = knockKnock(BA_NODE_ID).setQuestion("who's there?").build();
+        ListenableFuture<RpcResult<KnockKnockOutput>> future = baKnockService.knockKnock(baKnockKnockInput);
+
+        final RpcResult<KnockKnockOutput> rpcResult = future.get(5, TimeUnit.SECONDS);
+
+        assertEquals(baKnockResult.get().getResult().getClass(), rpcResult.getResult().getClass());
+        assertSame(baKnockResult.get().getResult(), rpcResult.getResult());
+        assertSame(baKnockKnockInput, knockRpcImpl.getReceivedKnocks().get(BA_NODE_ID).iterator().next());
+    }
+
+    private static ListenableFuture<RpcResult<KnockKnockOutput>> knockResult(final boolean success,
+            final String answer) {
+        KnockKnockOutput output = new KnockKnockOutputBuilder().setAnswer(answer).build();
+        RpcResult<KnockKnockOutput> result = RpcResultBuilder.<KnockKnockOutput>status(success).withResult(output)
+                .build();
+        return Futures.immediateFuture(result);
+    }
+
+    private static KnockKnockInputBuilder knockKnock(final InstanceIdentifier<TopLevelList> listId) {
+        KnockKnockInputBuilder builder = new KnockKnockInputBuilder();
+        builder.setKnockerId(listId);
+        return builder;
+    }
+
+    private ContainerNode toDOMKnockKnockInput(final KnockKnockInput from) {
+        return testContext.getCodec().getCodecFactory().toNormalizedNodeRpcData(from);
+    }
+
+    private static class OpendaylightKnockKnockRpcServiceImpl implements OpendaylightKnockKnockRpcService {
+        private ListenableFuture<RpcResult<KnockKnockOutput>> knockKnockResult;
+        private final Multimap<InstanceIdentifier<?>, KnockKnockInput> receivedKnocks = HashMultimap.create();
+        private ObjectRegistration<OpendaylightKnockKnockRpcServiceImpl> registration;
+
+        OpendaylightKnockKnockRpcServiceImpl setKnockKnockResult(
+                final ListenableFuture<RpcResult<KnockKnockOutput>> kkOutput) {
+            this.knockKnockResult = kkOutput;
+            return this;
+        }
+
+        Multimap<InstanceIdentifier<?>, KnockKnockInput> getReceivedKnocks() {
+            return receivedKnocks;
+        }
+
+        OpendaylightKnockKnockRpcServiceImpl registerTo(final RpcProviderService registry,
+                InstanceIdentifier<?>... paths) {
+            registration = registry.registerRpcImplementation(OpendaylightKnockKnockRpcService.class, this,
+                    ImmutableSet.copyOf(paths));
+            assertNotNull(registration);
+            return this;
+        }
+
+        @Override
+        public ListenableFuture<RpcResult<KnockKnockOutput>> knockKnock(KnockKnockInput input) {
+            receivedKnocks.put(input.getKnockerId(), input);
+            return knockKnockResult;
+        }
+    }
+}

diff --git a/binding/mdsal-binding-dom-adapter/src/test/java/org/opendaylight/mdsal/binding/dom/adapter/BindingDOMRpcProviderServiceAdapterTest.java b/binding/mdsal-binding-dom-adapter/src/test/java/org/opendaylight/mdsal/binding/dom/adapter/BindingDOMRpcProviderServiceAdapterTest.java
deleted file mode 100644 (file)
index c0831b1..0000000
--- a/binding/mdsal-binding-dom-adapter/src/test/java/org/opendaylight/mdsal/binding/dom/adapter/BindingDOMRpcProviderServiceAdapterTest.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Copyright (c) 2016 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.mdsal.binding.dom.adapter;
-
-import static org.junit.Assert.assertNotNull;
-import static org.mockito.Mockito.mock;
-
-import com.google.common.collect.ImmutableSet;
-import com.google.common.util.concurrent.ListenableFuture;
-import java.util.concurrent.Executors;
-import org.junit.Test;
-import org.opendaylight.mdsal.binding.dom.adapter.test.util.BindingBrokerTestFactory;
-import org.opendaylight.mdsal.binding.dom.adapter.test.util.BindingTestContext;
-import org.opendaylight.mdsal.dom.api.DOMRpcProviderService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.bi.ba.rpcservice.rev140701.OpendaylightTestRpcServiceService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.bi.ba.rpcservice.rev140701.RockTheHouseInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.bi.ba.rpcservice.rev140701.RockTheHouseOutput;
-import org.opendaylight.yangtools.yang.common.RpcResult;
-
-public class BindingDOMRpcProviderServiceAdapterTest {
-
-    @Test
-    public void basicTest() throws Exception {
-        final DOMRpcProviderService providerService = mock(DOMRpcProviderService.class);
-        final BindingBrokerTestFactory testFactory = new BindingBrokerTestFactory();
-        testFactory.setExecutor(Executors.newCachedThreadPool());
-
-        final BindingTestContext testContext = testFactory.getTestContext();
-        testContext.start();
-
-        final BindingDOMRpcProviderServiceAdapter adapter =
-                new BindingDOMRpcProviderServiceAdapter(providerService, testContext.getCodec());
-
-        assertNotNull(adapter.registerRpcImplementation(OpendaylightTestRpcServiceService.class, new TestImpl()));
-        assertNotNull(adapter.registerRpcImplementation(OpendaylightTestRpcServiceService.class, new TestImpl(),
-                ImmutableSet.of()));
-    }
-
-    private class TestImpl implements OpendaylightTestRpcServiceService {
-
-        @Override
-        public ListenableFuture<RpcResult<RockTheHouseOutput>> rockTheHouse(final RockTheHouseInput input) {
-            return null;
-        }
-    }
-}
\ No newline at end of file

diff --git a/binding/mdsal-binding-dom-adapter/src/test/java/org/opendaylight/mdsal/binding/dom/adapter/LazyDOMRpcResultFutureTest.java b/binding/mdsal-binding-dom-adapter/src/test/java/org/opendaylight/mdsal/binding/dom/adapter/LazyDOMRpcResultFutureTest.java
index 4afcadbbf887a625db05ba78c0e02a96b61e3737..39fb640107ffdf5106082bcdd50d8b56f8fd20ec 100644 (file)
--- a/binding/mdsal-binding-dom-adapter/src/test/java/org/opendaylight/mdsal/binding/dom/adapter/LazyDOMRpcResultFutureTest.java
+++ b/binding/mdsal-binding-dom-adapter/src/test/java/org/opendaylight/mdsal/binding/dom/adapter/LazyDOMRpcResultFutureTest.java
@@ -65,11 +65,11 @@ public class LazyDOMRpcResultFutureTest {
         verify(future).addListener(any(), any());
 
         assertTrue(lazyDOMRpcResultFuture.isCancelled() && lazyDOMRpcResultFuture.isDone());
-        assertEquals(lazyDOMRpcResultFuture.checkedGet(), lazyDOMRpcResultFuture.get(1, TimeUnit.SECONDS));
+        assertEquals(lazyDOMRpcResultFuture.get(), lazyDOMRpcResultFuture.get(1, TimeUnit.SECONDS));
         final Field result = LazyDOMRpcResultFuture.class.getDeclaredField("result");
         result.setAccessible(true);
         result.set(lazyDOMRpcResultFuture, null);
-        assertEquals(lazyDOMRpcResultFuture.checkedGet(1, TimeUnit.SECONDS), lazyDOMRpcResultFuture.get());
+        assertEquals(lazyDOMRpcResultFuture.get(1, TimeUnit.SECONDS), lazyDOMRpcResultFuture.get());
 
         result.set(lazyDOMRpcResultFuture, null);
         doReturn(new Object()).when(domRpcResult).getResult();
@@ -86,7 +86,7 @@ public class LazyDOMRpcResultFutureTest {
     public void checkedGetWithException() throws Throwable {
         doThrow(InterruptedException.class).when(future).get();
         try {
-            lazyDOMRpcResultFuture.checkedGet();
+            lazyDOMRpcResultFuture.get();
         } catch (RuntimeException e) {
             throw e.getCause();
         }
@@ -97,9 +97,9 @@ public class LazyDOMRpcResultFutureTest {
     public void checkedGetWithException2() throws Throwable {
         doThrow(InterruptedException.class).when(future).get(1, TimeUnit.SECONDS);
         try {
-            lazyDOMRpcResultFuture.checkedGet(1, TimeUnit.SECONDS);
+            lazyDOMRpcResultFuture.get(1, TimeUnit.SECONDS);
         } catch (RuntimeException e) {
             throw e.getCause();
         }
     }
-}
\ No newline at end of file
+}

diff --git a/binding/mdsal-binding-dom-adapter/src/test/java/org/opendaylight/mdsal/binding/dom/adapter/test/util/BindingTestContext.java b/binding/mdsal-binding-dom-adapter/src/test/java/org/opendaylight/mdsal/binding/dom/adapter/test/util/BindingTestContext.java
index 9eb9df47df15a1ac8e571ce9860fd4f4f922f907..710dd065c133bca3af22df7da5cc44721f89b5be 100644 (file)
--- a/binding/mdsal-binding-dom-adapter/src/test/java/org/opendaylight/mdsal/binding/dom/adapter/test/util/BindingTestContext.java
+++ b/binding/mdsal-binding-dom-adapter/src/test/java/org/opendaylight/mdsal/binding/dom/adapter/test/util/BindingTestContext.java
@@ -14,12 +14,14 @@ import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.util.concurrent.ListeningExecutorService;
 import com.google.common.util.concurrent.MoreExecutors;
+import java.util.Set;
 import javassist.ClassPool;
 import org.opendaylight.mdsal.binding.api.DataBroker;
 import org.opendaylight.mdsal.binding.api.MountPointService;
 import org.opendaylight.mdsal.binding.api.NotificationPublishService;
 import org.opendaylight.mdsal.binding.api.NotificationService;
 import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
 import org.opendaylight.mdsal.binding.dom.adapter.BindingDOMDataBrokerAdapter;
 import org.opendaylight.mdsal.binding.dom.adapter.BindingDOMMountPointServiceAdapter;
 import org.opendaylight.mdsal.binding.dom.adapter.BindingDOMNotificationPublishServiceAdapter;
@@ -84,7 +86,7 @@ public class BindingTestContext implements AutoCloseable {
 
     private DOMNotificationService domListenService;
 
-
+    private Set<YangModuleInfo> schemaModuleInfos;
 
     public DOMDataBroker getDomAsyncDataBroker() {
         return newDOMDataBroker;
@@ -154,11 +156,11 @@ public class BindingTestContext implements AutoCloseable {
         mockSchemaService.registerSchemaContextListener(codec);
     }
 
-    private void updateYangSchema(final ImmutableSet<YangModuleInfo> moduleInfos) {
+    private void updateYangSchema(final Set<YangModuleInfo> moduleInfos) {
         mockSchemaService.changeSchema(getContext(moduleInfos));
     }
 
-    private static SchemaContext getContext(final ImmutableSet<YangModuleInfo> moduleInfos) {
+    private static SchemaContext getContext(final Set<YangModuleInfo> moduleInfos) {
         final ModuleInfoBackedContext ctx = ModuleInfoBackedContext.create();
         ctx.addModuleInfos(moduleInfos);
         return ctx.tryToCreateSchemaContext().get();
@@ -179,7 +181,10 @@ public class BindingTestContext implements AutoCloseable {
         startBindingBroker();
 
         startForwarding();
-        if (startWithSchema) {
+
+        if (schemaModuleInfos != null) {
+            updateYangSchema(schemaModuleInfos);
+        } else if (this.startWithSchema) {
             loadYangSchemaFromClasspath();
         }
     }
@@ -217,6 +222,14 @@ public class BindingTestContext implements AutoCloseable {
         return domRouter.getRpcService();
     }
 
+    public RpcProviderService getBindingRpcProviderRegistry() {
+        return baProviderRpc;
+    }
+
+    public RpcConsumerRegistry getBindingRpcConsumerRegistry() {
+        return baConsumerRpc;
+    }
+
     @Override
     public void close() throws Exception {
 
@@ -229,4 +242,8 @@ public class BindingTestContext implements AutoCloseable {
     public DataBroker getDataBroker() {
         return dataBroker;
     }
+
+    public void setSchemaModuleInfos(Set<YangModuleInfo> moduleInfos) {
+        this.schemaModuleInfos = moduleInfos;
+    }
 }

diff --git a/binding/mdsal-binding-test-model/src/main/yang/opendaylight-knock-knock-rpc.yang b/binding/mdsal-binding-test-model/src/main/yang/opendaylight-knock-knock-rpc.yang
new file mode 100644 (file)
index 0000000..5334380
--- /dev/null
+++ b/binding/mdsal-binding-test-model/src/main/yang/opendaylight-knock-knock-rpc.yang
@@ -0,0 +1,29 @@
+module opendaylight-knock-knock-rpc {
+    namespace "urn:opendaylight:params:xml:ns:yang:md:sal:knock-knock";
+    prefix knock-knock;
+
+    import yang-ext {prefix ext;}
+    import opendaylight-test-routed-rpc {prefix routed;}
+
+    revision 2018-07-23 {
+    }
+
+    rpc knock-knock {
+        input {
+            leaf knocker-id {
+                ext:context-reference routed:test-context;
+                type instance-identifier;
+            }
+
+            leaf question {
+                type string;
+            }
+        }
+
+        output {
+            leaf answer {
+                type string;
+            }
+        }
+    }
+}

diff --git a/binding/mdsal-binding-test-model/src/main/yang/opendaylight-of-migration-test-model.yang b/binding/mdsal-binding-test-model/src/main/yang/opendaylight-of-migration-test-model.yang
index 273cf3c32272762722463312e87bbd4cfc3c1212..0b74a4461f414f48e13a37977d1887a6fd7a43ac 100644 (file)
--- a/binding/mdsal-binding-test-model/src/main/yang/opendaylight-of-migration-test-model.yang
+++ b/binding/mdsal-binding-test-model/src/main/yang/opendaylight-of-migration-test-model.yang
@@ -134,23 +134,4 @@ module opendaylight-of-migration-test-model {
             type string;
         }
     }
-
-    rpc knock-knock {
-        input {
-            leaf knocker-id {
-                ext:context-reference routed:test-context;
-                type instance-identifier;
-            }
-
-            leaf question {
-                type string;
-            }
-        }
-
-        output {
-            leaf answer {
-                type string;
-            }
-        }
-    }
 }

diff --git a/binding2/mdsal-binding2-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/javav2/dom/adapter/impl/operation/BindingDOMOperationImplementationAdapter.java b/binding2/mdsal-binding2-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/javav2/dom/adapter/impl/operation/BindingDOMOperationImplementationAdapter.java
index e7775b3fe4f66bef8ce0f918a38d32f6de7dba1c..fc395752b5b2f0a86c283c1c1dbdf6e288fa839e 100644 (file)
--- a/binding2/mdsal-binding2-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/javav2/dom/adapter/impl/operation/BindingDOMOperationImplementationAdapter.java
+++ b/binding2/mdsal-binding2-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/javav2/dom/adapter/impl/operation/BindingDOMOperationImplementationAdapter.java
@@ -11,8 +11,7 @@ import com.google.common.annotations.Beta;
 import com.google.common.base.Preconditions;
 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.FluentFuture;
 import com.google.common.util.concurrent.JdkFutureAdapters;
 import com.google.common.util.concurrent.ListenableFuture;
 import java.lang.reflect.Method;
@@ -28,11 +27,9 @@ import org.opendaylight.mdsal.binding.javav2.dom.codec.serialized.LazySerialized
 import org.opendaylight.mdsal.binding.javav2.runtime.reflection.BindingReflections;
 import org.opendaylight.mdsal.binding.javav2.spec.base.Operation;
 import org.opendaylight.mdsal.binding.javav2.spec.base.TreeNode;
-import org.opendaylight.mdsal.dom.api.DOMRpcException;
 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;
@@ -79,29 +76,13 @@ public class BindingDOMOperationImplementationAdapter implements DOMRpcImplement
     @SuppressWarnings("deprecation")
     @Nonnull
     @Override
-    public CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(@Nonnull final DOMRpcIdentifier rpc,
+    public FluentFuture<DOMRpcResult> invokeRpc(@Nonnull final DOMRpcIdentifier rpc,
             @Nullable final NormalizedNode<?, ?> input) {
 
         final SchemaPath schemaPath = rpc.getType();
         final TreeNode bindingInput = input != null ? deserialize(rpc.getType(), input) : null;
         final ListenableFuture<RpcResult<?>> bindingResult = invoke(schemaPath, bindingInput);
-        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);
-        }
+        return transformResult(bindingResult);
     }
 
     @Override
@@ -121,8 +102,7 @@ public class BindingDOMOperationImplementationAdapter implements DOMRpcImplement
         return JdkFutureAdapters.listenInPoolThread(invoker.invoke(delegate, schemaPath.getLastComponent(), input));
     }
 
-    private ListenableFuture<DOMRpcResult>
-            transformResult(final ListenableFuture<RpcResult<?>> bindingResult) {
+    private FluentFuture<DOMRpcResult> transformResult(final ListenableFuture<RpcResult<?>> bindingResult) {
         return LazyDOMOperationResultFuture.create(codec, bindingResult);
     }
 }

diff --git a/binding2/mdsal-binding2-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/javav2/dom/adapter/impl/operation/LazyDOMOperationResultFuture.java b/binding2/mdsal-binding2-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/javav2/dom/adapter/impl/operation/LazyDOMOperationResultFuture.java
index c1d9a0aa288417e679bedbad5def8bcd600bc627..946226a9fe0b384c75e9123204ca410b419f8071 100644 (file)
--- a/binding2/mdsal-binding2-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/javav2/dom/adapter/impl/operation/LazyDOMOperationResultFuture.java
+++ b/binding2/mdsal-binding2-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/javav2/dom/adapter/impl/operation/LazyDOMOperationResultFuture.java
@@ -9,6 +9,8 @@ package org.opendaylight.mdsal.binding.javav2.dom.adapter.impl.operation;
 
 import com.google.common.annotations.Beta;
 import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.AbstractFuture;
+import com.google.common.util.concurrent.FluentFuture;
 import com.google.common.util.concurrent.ListenableFuture;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executor;
@@ -17,8 +19,11 @@ import java.util.concurrent.TimeoutException;
 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.api.DefaultDOMRpcException;
 import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
+import org.opendaylight.yangtools.util.concurrent.ExceptionMapper;
 import org.opendaylight.yangtools.yang.binding.DataContainer;
 import org.opendaylight.yangtools.yang.common.RpcResult;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
@@ -27,7 +32,15 @@ import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  * DOM operation result from Binding.
  */
 @Beta
-final class LazyDOMOperationResultFuture implements ListenableFuture<DOMRpcResult> {
+final class LazyDOMOperationResultFuture extends AbstractFuture<DOMRpcResult> {
+    private static final ExceptionMapper<DOMRpcException> DOM_RPC_EX_MAPPER =
+            new ExceptionMapper<DOMRpcException>("rpc", DOMRpcException.class) {
+        @Override
+        protected DOMRpcException newWithCause(String message, Throwable cause) {
+            return cause instanceof DOMRpcException ? (DOMRpcException)cause
+                    : new DefaultDOMRpcException("RPC failed", cause);
+        }
+    };
 
     private final ListenableFuture<RpcResult<?>> bindingFuture;
     private final BindingNormalizedNodeCodecRegistry codec;
@@ -39,7 +52,7 @@ final class LazyDOMOperationResultFuture implements ListenableFuture<DOMRpcResul
         this.codec = Preconditions.checkNotNull(codec, "codec");
     }
 
-    static ListenableFuture<DOMRpcResult> create(final BindingNormalizedNodeCodecRegistry codec,
+    static FluentFuture<DOMRpcResult> create(final BindingNormalizedNodeCodecRegistry codec,
             final ListenableFuture<RpcResult<?>> bindingResult) {
         return new LazyDOMOperationResultFuture(bindingResult, codec);
     }
@@ -63,7 +76,12 @@ final class LazyDOMOperationResultFuture implements ListenableFuture<DOMRpcResul
         if (result != null) {
             return result;
         }
-        return transformIfNecessary(bindingFuture.get());
+
+        try {
+            return transformIfNecessary(bindingFuture.get());
+        } catch (ExecutionException e) {
+            throw new ExecutionException(e.getMessage(), DOM_RPC_EX_MAPPER.apply(e));
+        }
     }
 
     @Override
@@ -72,7 +90,12 @@ final class LazyDOMOperationResultFuture implements ListenableFuture<DOMRpcResul
         if (result != null) {
             return result;
         }
-        return transformIfNecessary(bindingFuture.get(timeout, unit));
+
+        try {
+            return transformIfNecessary(bindingFuture.get(timeout, unit));
+        } catch (ExecutionException e) {
+            throw new ExecutionException(e.getMessage(), DOM_RPC_EX_MAPPER.apply(e));
+        }
     }
 
     @Override
@@ -104,4 +127,4 @@ final class LazyDOMOperationResultFuture implements ListenableFuture<DOMRpcResul
         return new DefaultDOMRpcResult(input.getErrors());
     }
 
-}
\ No newline at end of file
+}

diff --git a/dom/mdsal-dom-api/src/main/java/org/opendaylight/mdsal/dom/api/DOMRpcImplementation.java b/dom/mdsal-dom-api/src/main/java/org/opendaylight/mdsal/dom/api/DOMRpcImplementation.java
index 7708001551ee96c347c5ad980fdaf582e7c8e3b6..8d5adb4fed5865a56ed5ff89a7d5ba0e77b05acc 100644 (file)
--- a/dom/mdsal-dom-api/src/main/java/org/opendaylight/mdsal/dom/api/DOMRpcImplementation.java
+++ b/dom/mdsal-dom-api/src/main/java/org/opendaylight/mdsal/dom/api/DOMRpcImplementation.java
@@ -7,7 +7,7 @@
  */
 package org.opendaylight.mdsal.dom.api;
 
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
@@ -23,12 +23,11 @@ public interface DOMRpcImplementation {
      *
      * @param rpc RPC identifier which was invoked
      * @param input Input arguments, null if the RPC does not take any.
-     * @return A {@link CheckedFuture} which will return either a result structure,
+     * @return A {@link FluentFuture} which will return either a result structure,
      *         or report a subclass of {@link DOMRpcException} reporting a transport
      *         error.
      */
-    @Nonnull CheckedFuture<DOMRpcResult, DOMRpcException>
-        invokeRpc(@Nonnull DOMRpcIdentifier rpc, @Nullable NormalizedNode<?, ?> input);
+    @Nonnull FluentFuture<DOMRpcResult> invokeRpc(@Nonnull DOMRpcIdentifier rpc, @Nullable NormalizedNode<?, ?> input);
 
     /**
      * Return the relative invocation cost of this implementation. Default implementation return 0.

diff --git a/dom/mdsal-dom-api/src/main/java/org/opendaylight/mdsal/dom/api/DOMRpcService.java b/dom/mdsal-dom-api/src/main/java/org/opendaylight/mdsal/dom/api/DOMRpcService.java
index 997f94c720e8a78df9a014e3b3edfe15cdfbc32a..3f64416a49619b584236b0f55ab34ee706188f4d 100644 (file)
--- a/dom/mdsal-dom-api/src/main/java/org/opendaylight/mdsal/dom/api/DOMRpcService.java
+++ b/dom/mdsal-dom-api/src/main/java/org/opendaylight/mdsal/dom/api/DOMRpcService.java
@@ -7,7 +7,7 @@
  */
 package org.opendaylight.mdsal.dom.api;
 
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 import org.opendaylight.yangtools.concepts.ListenerRegistration;
@@ -27,12 +27,11 @@ public interface DOMRpcService extends DOMService {
      *
      * @param type SchemaPath of the RPC to be invoked
      * @param input Input arguments, null if the RPC does not take any.
-     * @return A {@link CheckedFuture} which will return either a result structure,
+     * @return A {@link FluentFuture} which will return either a result structure,
      *         or report a subclass of {@link DOMRpcException} reporting a transport
      *         error.
      */
-    @Nonnull CheckedFuture<DOMRpcResult, DOMRpcException>
-        invokeRpc(@Nonnull SchemaPath type, @Nullable NormalizedNode<?, ?> input);
+    @Nonnull FluentFuture<DOMRpcResult> invokeRpc(@Nonnull SchemaPath type, @Nullable NormalizedNode<?, ?> input);
 
     /**
      * Register a {@link DOMRpcAvailabilityListener} with this service to receive notifications

diff --git a/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/AbstractDOMRpcRoutingTableEntry.java b/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/AbstractDOMRpcRoutingTableEntry.java
index ff7b0fd4ef80803cf5edf1845a75d123cf121d30..9d6f58e5abbbee26e2e396027cfe3793d7f241b7 100644 (file)
--- a/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/AbstractDOMRpcRoutingTableEntry.java
+++ b/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/AbstractDOMRpcRoutingTableEntry.java
@@ -12,14 +12,13 @@ import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableMap.Builder;
 import com.google.common.collect.Maps;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
 import org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener;
-import org.opendaylight.mdsal.dom.api.DOMRpcException;
 import org.opendaylight.mdsal.dom.api.DOMRpcImplementation;
 import org.opendaylight.mdsal.dom.api.DOMRpcResult;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
@@ -116,7 +115,7 @@ abstract class AbstractDOMRpcRoutingTableEntry {
         return v.isEmpty() ? null : newInstance(v);
     }
 
-    protected abstract CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(NormalizedNode<?, ?> input);
+    protected abstract FluentFuture<DOMRpcResult> invokeRpc(NormalizedNode<?, ?> input);
 
     protected abstract AbstractDOMRpcRoutingTableEntry newInstance(
             Map<YangInstanceIdentifier, List<DOMRpcImplementation>> impls);

diff --git a/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/DOMRpcRouter.java b/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/DOMRpcRouter.java
index 48c8525ba056e7e64e272277d1e6a8df2df38a20..145059ca69f5ee5e1a23414cef33f26163c99be9 100644 (file)
--- a/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/DOMRpcRouter.java
+++ b/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/DOMRpcRouter.java
@@ -19,8 +19,7 @@ import com.google.common.collect.MapDifference;
 import com.google.common.collect.MapDifference.ValueDifference;
 import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.FluentFuture;
 import com.google.common.util.concurrent.ThreadFactoryBuilder;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -33,7 +32,6 @@ import java.util.concurrent.Executors;
 import java.util.concurrent.ThreadFactory;
 import javax.annotation.concurrent.GuardedBy;
 import org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener;
-import org.opendaylight.mdsal.dom.api.DOMRpcException;
 import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
 import org.opendaylight.mdsal.dom.api.DOMRpcImplementation;
 import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
@@ -46,6 +44,7 @@ import org.opendaylight.mdsal.dom.spi.AbstractDOMRpcImplementationRegistration;
 import org.opendaylight.yangtools.concepts.AbstractListenerRegistration;
 import org.opendaylight.yangtools.concepts.AbstractRegistration;
 import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
@@ -216,11 +215,10 @@ public final class DOMRpcRouter extends AbstractRegistration implements SchemaCo
 
     private final class RpcServiceFacade implements DOMRpcService {
         @Override
-        public CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(final SchemaPath type,
-                final NormalizedNode<?, ?> input) {
+        public FluentFuture<DOMRpcResult> invokeRpc(final SchemaPath type, final NormalizedNode<?, ?> input) {
             final AbstractDOMRpcRoutingTableEntry entry = routingTable.getEntry(type);
             if (entry == null) {
-                return Futures.immediateFailedCheckedFuture(
+                return FluentFutures.immediateFailedFluentFuture(
                     new DOMRpcImplementationNotAvailableException("No implementation of RPC %s available", type));
             }
 

diff --git a/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/GlobalDOMRpcRoutingTableEntry.java b/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/GlobalDOMRpcRoutingTableEntry.java
index 42d438a99a1c58476b36ac916fc7829984da1c58..cfe4111de27326ecb573fa14c76bd6a956ef2b68 100644 (file)
--- a/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/GlobalDOMRpcRoutingTableEntry.java
+++ b/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/GlobalDOMRpcRoutingTableEntry.java
@@ -8,10 +8,9 @@
 package org.opendaylight.mdsal.dom.broker;
 
 import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
 import java.util.List;
 import java.util.Map;
-import org.opendaylight.mdsal.dom.api.DOMRpcException;
 import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
 import org.opendaylight.mdsal.dom.api.DOMRpcImplementation;
 import org.opendaylight.mdsal.dom.api.DOMRpcResult;
@@ -37,7 +36,7 @@ final class GlobalDOMRpcRoutingTableEntry extends AbstractDOMRpcRoutingTableEntr
     }
 
     @Override
-    protected CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(final NormalizedNode<?, ?> input) {
+    protected FluentFuture<DOMRpcResult> invokeRpc(final NormalizedNode<?, ?> input) {
         return getImplementations(YangInstanceIdentifier.EMPTY).get(0).invokeRpc(rpcId, input);
     }
 
@@ -46,4 +45,4 @@ final class GlobalDOMRpcRoutingTableEntry extends AbstractDOMRpcRoutingTableEntr
             List<DOMRpcImplementation>> impls) {
         return new GlobalDOMRpcRoutingTableEntry(rpcId, impls);
     }
-}
\ No newline at end of file
+}

diff --git a/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/RoutedDOMRpcRoutingTableEntry.java b/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/RoutedDOMRpcRoutingTableEntry.java
index 2fc06a0f54717ae49ab306c2763031cf09bb4c38..804f36926b0ca42315bbff4cf9bcfd70ab02cdb3 100644 (file)
--- a/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/RoutedDOMRpcRoutingTableEntry.java
+++ b/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/RoutedDOMRpcRoutingTableEntry.java
@@ -8,16 +8,15 @@
 package org.opendaylight.mdsal.dom.broker;
 
 import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.FluentFuture;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
-import org.opendaylight.mdsal.dom.api.DOMRpcException;
 import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
 import org.opendaylight.mdsal.dom.api.DOMRpcImplementation;
 import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
 import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodes;
@@ -46,7 +45,7 @@ final class RoutedDOMRpcRoutingTableEntry extends AbstractDOMRpcRoutingTableEntr
     }
 
     @Override
-    protected CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(final NormalizedNode<?, ?> input) {
+    protected FluentFuture<DOMRpcResult> invokeRpc(final NormalizedNode<?, ?> input) {
         final Optional<NormalizedNode<?, ?>> maybeKey = NormalizedNodes.findNode(input, keyId);
 
         // Routing key is present, attempt to deliver as a routed RPC
@@ -82,7 +81,7 @@ final class RoutedDOMRpcRoutingTableEntry extends AbstractDOMRpcRoutingTableEntr
             return impls.get(0).invokeRpc(globalRpcId, input);
         }
 
-        return Futures.<DOMRpcResult, DOMRpcException>immediateFailedCheckedFuture(
+        return FluentFutures.immediateFailedFluentFuture(
             new DOMRpcImplementationNotAvailableException("No implementation of RPC %s available", getSchemaPath()));
     }
 

diff --git a/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/UnknownDOMRpcRoutingTableEntry.java b/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/UnknownDOMRpcRoutingTableEntry.java
index 0fae746b2c8d74c409cebe2262dd60c4563fc021..d4a085a3e3ce1a933e337b93d1430e56dcb68e12 100644 (file)
--- a/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/UnknownDOMRpcRoutingTableEntry.java
+++ b/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/UnknownDOMRpcRoutingTableEntry.java
@@ -7,30 +7,29 @@
  */
 package org.opendaylight.mdsal.dom.broker;
 
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.FluentFuture;
 import java.util.List;
 import java.util.Map;
-import org.opendaylight.mdsal.dom.api.DOMRpcException;
 import org.opendaylight.mdsal.dom.api.DOMRpcImplementation;
 import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
 import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
 
 final class UnknownDOMRpcRoutingTableEntry extends AbstractDOMRpcRoutingTableEntry {
-    private final CheckedFuture<DOMRpcResult, DOMRpcException> unknownRpc;
+    private final FluentFuture<DOMRpcResult> unknownRpc;
 
     UnknownDOMRpcRoutingTableEntry(final SchemaPath schemaPath, final Map<YangInstanceIdentifier,
             List<DOMRpcImplementation>> impls) {
         super(schemaPath, impls);
-        unknownRpc = Futures.<DOMRpcResult, DOMRpcException>immediateFailedCheckedFuture(
+        unknownRpc = FluentFutures.immediateFailedFluentFuture(
             new DOMRpcImplementationNotAvailableException("SchemaPath %s is not resolved to an RPC", schemaPath));
     }
 
     @Override
-    protected CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(final NormalizedNode<?, ?> input) {
+    protected FluentFuture<DOMRpcResult> invokeRpc(final NormalizedNode<?, ?> input) {
         return unknownRpc;
     }
 
@@ -39,4 +38,4 @@ final class UnknownDOMRpcRoutingTableEntry extends AbstractDOMRpcRoutingTableEnt
             List<DOMRpcImplementation>> impls) {
         return new UnknownDOMRpcRoutingTableEntry(getSchemaPath(), impls);
     }
-}
\ No newline at end of file
+}

diff --git a/dom/mdsal-dom-broker/src/test/java/org/opendaylight/mdsal/dom/broker/GlobalDOMRpcRoutingTableEntryTest.java b/dom/mdsal-dom-broker/src/test/java/org/opendaylight/mdsal/dom/broker/GlobalDOMRpcRoutingTableEntryTest.java
index f155f97bde3eb0b9267625a69a3d41a3d377a953..4f1ecfc691663205b7742b21ba588c5a2b877404 100644 (file)
--- a/dom/mdsal-dom-broker/src/test/java/org/opendaylight/mdsal/dom/broker/GlobalDOMRpcRoutingTableEntryTest.java
+++ b/dom/mdsal-dom-broker/src/test/java/org/opendaylight/mdsal/dom/broker/GlobalDOMRpcRoutingTableEntryTest.java
@@ -17,6 +17,9 @@ import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import org.junit.Test;
 import org.opendaylight.mdsal.dom.api.DOMRpcImplementation;
 import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
@@ -27,7 +30,7 @@ import org.opendaylight.yangtools.yang.model.api.SchemaPath;
 public class GlobalDOMRpcRoutingTableEntryTest extends TestUtils {
 
     @Test
-    public void basicTest() throws Exception {
+    public void basicTest() throws InterruptedException, TimeoutException {
         final Map<YangInstanceIdentifier, List<DOMRpcImplementation>> rpcImplementations = new HashMap<>();
         final List<DOMRpcImplementation> rpcImplementation = new ArrayList<>();
         final RpcDefinition rpcDefinition = mock(RpcDefinition.class);
@@ -47,10 +50,11 @@ public class GlobalDOMRpcRoutingTableEntryTest extends TestUtils {
 
         try {
             globalDOMRpcRoutingTableEntry.newInstance(rpcImplementations)
-                    .invokeRpc(TEST_CONTAINER).checkedGet();
+                    .invokeRpc(TEST_CONTAINER).get(5, TimeUnit.SECONDS);
             fail("Expected DOMRpcImplementationNotAvailableException");
-        } catch (DOMRpcImplementationNotAvailableException e) {
-            assertTrue(e.getMessage().contains(EXCEPTION_TEXT));
+        } catch (ExecutionException e) {
+            assertTrue(e.getCause() instanceof DOMRpcImplementationNotAvailableException);
+            assertTrue(e.getCause().getMessage().contains(EXCEPTION_TEXT));
         }
     }
-}
\ No newline at end of file
+}

diff --git a/dom/mdsal-dom-broker/src/test/java/org/opendaylight/mdsal/dom/broker/RoutedDOMRpcRoutingTableEntryTest.java b/dom/mdsal-dom-broker/src/test/java/org/opendaylight/mdsal/dom/broker/RoutedDOMRpcRoutingTableEntryTest.java
index 02c04ad785af39e9c014e4cad02ab642fbf72acd..190d821b784c4a0d3d0ca2016b02fc09efbfca4a 100644 (file)
--- a/dom/mdsal-dom-broker/src/test/java/org/opendaylight/mdsal/dom/broker/RoutedDOMRpcRoutingTableEntryTest.java
+++ b/dom/mdsal-dom-broker/src/test/java/org/opendaylight/mdsal/dom/broker/RoutedDOMRpcRoutingTableEntryTest.java
@@ -14,6 +14,8 @@ import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 
 import java.util.HashMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeoutException;
 import org.junit.Test;
 import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
 import org.opendaylight.mdsal.dom.broker.util.TestModel;
@@ -24,7 +26,7 @@ public class RoutedDOMRpcRoutingTableEntryTest extends TestUtils {
 
     @SuppressWarnings("checkstyle:IllegalCatch")
     @Test
-    public void basicTest() throws Exception {
+    public void basicTest() throws InterruptedException, TimeoutException {
         final RpcDefinition rpcDefinition = mock(RpcDefinition.class);
         doReturn(SchemaPath.ROOT).when(rpcDefinition).getPath();
 
@@ -33,10 +35,10 @@ public class RoutedDOMRpcRoutingTableEntryTest extends TestUtils {
         assertNotNull(routedDOMRpcRoutingTableEntry.newInstance(new HashMap<>()));
 
         try {
-            routedDOMRpcRoutingTableEntry.invokeRpc(TEST_CHILD).checkedGet();
+            routedDOMRpcRoutingTableEntry.invokeRpc(TEST_CHILD).get();
             fail("Expected DOMRpcImplementationNotAvailableException");
-        } catch (final Exception e) {
-            assertTrue(e instanceof DOMRpcImplementationNotAvailableException);
+        } catch (ExecutionException e) {
+            assertTrue(e.getCause() instanceof DOMRpcImplementationNotAvailableException);
         }
     }
-}
\ No newline at end of file
+}

diff --git a/dom/mdsal-dom-broker/src/test/java/org/opendaylight/mdsal/dom/broker/TestUtils.java b/dom/mdsal-dom-broker/src/test/java/org/opendaylight/mdsal/dom/broker/TestUtils.java
index 1a717d51c13a6ff4ddef31be19110212462c62f0..2404015fe90e982c732b91c74b4cbf3f39946eb0 100644 (file)
--- a/dom/mdsal-dom-broker/src/test/java/org/opendaylight/mdsal/dom/broker/TestUtils.java
+++ b/dom/mdsal-dom-broker/src/test/java/org/opendaylight/mdsal/dom/broker/TestUtils.java
@@ -10,16 +10,15 @@ package org.opendaylight.mdsal.dom.broker;
 
 import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.leafNode;
 
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.FluentFuture;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
-import org.opendaylight.mdsal.dom.api.DOMRpcException;
 import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
 import org.opendaylight.mdsal.dom.api.DOMRpcImplementation;
 import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
 import org.opendaylight.mdsal.dom.api.DOMRpcResult;
 import org.opendaylight.mdsal.dom.broker.util.TestModel;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
@@ -69,16 +68,17 @@ abstract class TestUtils {
     }
 
     private static final class TestRpcImplementation implements DOMRpcImplementation {
-        private final CheckedFuture<DOMRpcResult, DOMRpcException> unknownRpc;
+        private final FluentFuture<DOMRpcResult> unknownRpc;
 
         private TestRpcImplementation() {
-            unknownRpc = Futures.immediateFailedCheckedFuture(
+            unknownRpc = FluentFutures.immediateFailedFluentFuture(
                     new DOMRpcImplementationNotAvailableException(EXCEPTION_TEXT));
         }
 
+        @Override
         @Nonnull
-        public CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(
-                @Nonnull final DOMRpcIdentifier rpc, @Nullable final NormalizedNode<?, ?> input) {
+        public FluentFuture<DOMRpcResult> invokeRpc(@Nonnull final DOMRpcIdentifier rpc,
+                @Nullable final NormalizedNode<?, ?> input) {
             return unknownRpc;
         }
     }

diff --git a/dom/mdsal-dom-spi/src/main/java/org/opendaylight/mdsal/dom/spi/ForwardingDOMRpcImplementation.java b/dom/mdsal-dom-spi/src/main/java/org/opendaylight/mdsal/dom/spi/ForwardingDOMRpcImplementation.java
index af7d305e20ebd0bbb422fecf7e981199052b7eaf..ebafae0573f543bc4eb5163695abe1f6a6cc2755 100644 (file)
--- a/dom/mdsal-dom-spi/src/main/java/org/opendaylight/mdsal/dom/spi/ForwardingDOMRpcImplementation.java
+++ b/dom/mdsal-dom-spi/src/main/java/org/opendaylight/mdsal/dom/spi/ForwardingDOMRpcImplementation.java
@@ -8,9 +8,8 @@
 package org.opendaylight.mdsal.dom.spi;
 
 import com.google.common.collect.ForwardingObject;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
 import javax.annotation.Nonnull;
-import org.opendaylight.mdsal.dom.api.DOMRpcException;
 import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
 import org.opendaylight.mdsal.dom.api.DOMRpcImplementation;
 import org.opendaylight.mdsal.dom.api.DOMRpcResult;
@@ -26,8 +25,7 @@ public abstract class ForwardingDOMRpcImplementation extends ForwardingObject im
     protected abstract DOMRpcImplementation delegate();
 
     @Override
-    public CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(
-            final DOMRpcIdentifier type, final NormalizedNode<?, ?> input) {
+    public FluentFuture<DOMRpcResult> invokeRpc(final DOMRpcIdentifier type, final NormalizedNode<?, ?> input) {
         return delegate().invokeRpc(type, input);
     }
 }

diff --git a/dom/mdsal-dom-spi/src/main/java/org/opendaylight/mdsal/dom/spi/ForwardingDOMRpcService.java b/dom/mdsal-dom-spi/src/main/java/org/opendaylight/mdsal/dom/spi/ForwardingDOMRpcService.java
index 3f420e7f3f611954d108e708e513e24f7830f221..317b3ea13cababe1180c8faac0ea4f0b13e74aca 100644 (file)
--- a/dom/mdsal-dom-spi/src/main/java/org/opendaylight/mdsal/dom/spi/ForwardingDOMRpcService.java
+++ b/dom/mdsal-dom-spi/src/main/java/org/opendaylight/mdsal/dom/spi/ForwardingDOMRpcService.java
@@ -8,10 +8,9 @@
 package org.opendaylight.mdsal.dom.spi;
 
 import com.google.common.collect.ForwardingObject;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
 import javax.annotation.Nonnull;
 import org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener;
-import org.opendaylight.mdsal.dom.api.DOMRpcException;
 import org.opendaylight.mdsal.dom.api.DOMRpcResult;
 import org.opendaylight.mdsal.dom.api.DOMRpcService;
 import org.opendaylight.yangtools.concepts.ListenerRegistration;
@@ -27,8 +26,7 @@ public abstract class ForwardingDOMRpcService extends ForwardingObject implement
     protected abstract DOMRpcService delegate();
 
     @Override
-    public CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(
-            final SchemaPath type, final NormalizedNode<?, ?> input) {
+    public FluentFuture<DOMRpcResult> invokeRpc(final SchemaPath type, final NormalizedNode<?, ?> input) {
         return delegate().invokeRpc(type, input);
     }