From 8b846e31bfcaeb74dcfc1c2560b769d3a50671dc Mon Sep 17 00:00:00 2001 From: Jie Han Date: Mon, 30 Jul 2018 14:20:07 +0800 Subject: [PATCH] Remove AbstractDOMRpcRoutingTableEntry.invokeRpc Make routing entry not directly tied to invocation model and add an inner static class RpcInvocation in DOMRpcRouter to be used to invoke rpc with routing entries. Change-Id: I55fa669bff8a18eb182a579b9dd636294d54e460 Signed-off-by: Jie Han --- .../AbstractDOMRpcRoutingTableEntry.java | 18 ++--- .../mdsal/dom/broker/DOMRpcRouter.java | 78 ++++++++++++++++++- .../broker/GlobalDOMRpcRoutingTableEntry.java | 18 +---- .../broker/RoutedDOMRpcRoutingTableEntry.java | 67 +--------------- .../UnknownDOMRpcRoutingTableEntry.java | 9 +-- .../GlobalDOMRpcRoutingTableEntryTest.java | 5 +- .../RoutedDOMRpcRoutingTableEntryTest.java | 3 +- .../UnknownDOMRpcRoutingTableEntryTest.java | 3 +- 8 files changed, 102 insertions(+), 99 deletions(-) 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 04a90d7d61..32f8ba6053 100644 --- 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,7 +12,6 @@ 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.FluentFuture; import java.util.ArrayList; import java.util.Comparator; import java.util.List; @@ -20,24 +19,27 @@ 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.DOMRpcIdentifier; import org.opendaylight.mdsal.dom.api.DOMRpcImplementation; -import org.opendaylight.mdsal.dom.api.DOMRpcResult; 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; abstract class AbstractDOMRpcRoutingTableEntry { private final Map> implementations; - private final SchemaPath schemaPath; + private final DOMRpcIdentifier rpcId; - AbstractDOMRpcRoutingTableEntry(final SchemaPath schemaPath, final Map> implementations) { - this.schemaPath = Preconditions.checkNotNull(schemaPath); + this.rpcId = Preconditions.checkNotNull(rpcId); this.implementations = Preconditions.checkNotNull(implementations); } final SchemaPath getSchemaPath() { - return schemaPath; + return rpcId.getType(); + } + + final DOMRpcIdentifier getRpcId() { + return rpcId; } final List getImplementations(final YangInstanceIdentifier context) { @@ -116,8 +118,6 @@ abstract class AbstractDOMRpcRoutingTableEntry { return v.isEmpty() ? null : newInstance(v); } - protected abstract FluentFuture invokeRpc(NormalizedNode input); - protected abstract AbstractDOMRpcRoutingTableEntry newInstance( Map> 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 b27dd95a6b..af7a8bf96a 100644 --- 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 @@ -24,8 +24,10 @@ import com.google.common.util.concurrent.ThreadFactoryBuilder; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; +import java.util.List; import java.util.Map; import java.util.Map.Entry; +import java.util.Optional; import java.util.Set; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; @@ -47,9 +49,12 @@ 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.data.api.schema.NormalizedNodes; import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.opendaylight.yangtools.yang.model.api.SchemaContextListener; import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; public final class DOMRpcRouter extends AbstractRegistration implements SchemaContextListener { private static final ThreadFactory THREAD_FACTORY = new ThreadFactoryBuilder().setNameFormat( @@ -222,7 +227,7 @@ public final class DOMRpcRouter extends AbstractRegistration implements SchemaCo new DOMRpcImplementationNotAvailableException("No implementation of RPC %s available", type)); } - return entry.invokeRpc(input); + return RpcInvocation.invoke(entry, input); } @Override @@ -268,4 +273,75 @@ public final class DOMRpcRouter extends AbstractRegistration implements SchemaCo }; } } + + static final class RpcInvocation { + private static final Logger LOG = LoggerFactory.getLogger(RpcInvocation.class); + + static FluentFuture invoke(final AbstractDOMRpcRoutingTableEntry entry, + final NormalizedNode input) { + if (entry instanceof UnknownDOMRpcRoutingTableEntry) { + return FluentFutures.immediateFailedFluentFuture( + new DOMRpcImplementationNotAvailableException("SchemaPath %s is not resolved to an RPC", + entry.getSchemaPath())); + } else if (entry instanceof RoutedDOMRpcRoutingTableEntry) { + return invokeRoutedRpc((RoutedDOMRpcRoutingTableEntry) entry, input); + } else if (entry instanceof GlobalDOMRpcRoutingTableEntry) { + return invokeGlobalRpc((GlobalDOMRpcRoutingTableEntry) entry, input); + } + + return FluentFutures.immediateFailedFluentFuture( + new DOMRpcImplementationNotAvailableException("Unsupported RPC entry.")); + } + + private static FluentFuture invokeRoutedRpc(final RoutedDOMRpcRoutingTableEntry entry, + final NormalizedNode input) { + final Optional> maybeKey = NormalizedNodes.findNode(input, + entry.getRpcId().getContextReference()); + + // Routing key is present, attempt to deliver as a routed RPC + if (maybeKey.isPresent()) { + final NormalizedNode key = maybeKey.get(); + final Object value = key.getValue(); + if (value instanceof YangInstanceIdentifier) { + final YangInstanceIdentifier iid = (YangInstanceIdentifier) value; + + // Find a DOMRpcImplementation for a specific iid + final List specificImpls = entry.getImplementations(iid); + if (specificImpls != null) { + return specificImpls.get(0) + .invokeRpc(DOMRpcIdentifier.create(entry.getSchemaPath(), iid), input); + } + + LOG.debug("No implementation for context {} found will now look for wildcard id", iid); + + // Find a DOMRpcImplementation for a wild card. Usually remote-rpc-connector would register an + // implementation this way + final List mayBeRemoteImpls = + entry.getImplementations(YangInstanceIdentifier.EMPTY); + + if (mayBeRemoteImpls != null) { + return mayBeRemoteImpls.get(0) + .invokeRpc(DOMRpcIdentifier.create(entry.getSchemaPath(), iid), input); + } + + } else { + LOG.warn("Ignoring wrong context value {}", value); + } + } + + final List impls = entry.getImplementations(null); + if (impls != null) { + return impls.get(0).invokeRpc(entry.getRpcId(), input); + } + + return FluentFutures.immediateFailedFluentFuture( + new DOMRpcImplementationNotAvailableException("No implementation of RPC %s available", + entry.getSchemaPath())); + } + + private static FluentFuture invokeGlobalRpc(final GlobalDOMRpcRoutingTableEntry entry, + final NormalizedNode input) { + return entry.getImplementations(YangInstanceIdentifier.EMPTY).get(0).invokeRpc(entry.getRpcId(), input); + } + } } 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 cfe4111de2..a2d27014e5 100644 --- 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 @@ -7,42 +7,30 @@ */ package org.opendaylight.mdsal.dom.broker; -import com.google.common.base.Preconditions; -import com.google.common.util.concurrent.FluentFuture; import java.util.List; import java.util.Map; 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.yang.data.api.YangInstanceIdentifier; -import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.opendaylight.yangtools.yang.model.api.RpcDefinition; final class GlobalDOMRpcRoutingTableEntry extends AbstractDOMRpcRoutingTableEntry { - private final DOMRpcIdentifier rpcId; private GlobalDOMRpcRoutingTableEntry(final DOMRpcIdentifier rpcId, final Map> impls) { - super(rpcId.getType(), impls); - this.rpcId = Preconditions.checkNotNull(rpcId); + super(rpcId, impls); } // We do not need the RpcDefinition, but this makes sure we do not // forward something we don't know to be an RPC. GlobalDOMRpcRoutingTableEntry(final RpcDefinition def, final Map> impls) { - super(def.getPath(), impls); - this.rpcId = DOMRpcIdentifier.create(def.getPath()); - } - - @Override - protected FluentFuture invokeRpc(final NormalizedNode input) { - return getImplementations(YangInstanceIdentifier.EMPTY).get(0).invokeRpc(rpcId, input); + super(DOMRpcIdentifier.create(def.getPath()), impls); } @Override protected GlobalDOMRpcRoutingTableEntry newInstance(final Map> impls) { - return new GlobalDOMRpcRoutingTableEntry(rpcId, impls); + return new GlobalDOMRpcRoutingTableEntry(getRpcId(), impls); } } 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 804f36926b..6079b724fb 100644 --- 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 @@ -7,87 +7,28 @@ */ package org.opendaylight.mdsal.dom.broker; -import com.google.common.base.Preconditions; -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.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; import org.opendaylight.yangtools.yang.model.api.RpcDefinition; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; final class RoutedDOMRpcRoutingTableEntry extends AbstractDOMRpcRoutingTableEntry { - private static final Logger LOG = LoggerFactory.getLogger(RoutedDOMRpcRoutingTableEntry.class); - private final DOMRpcIdentifier globalRpcId; - private final YangInstanceIdentifier keyId; - private RoutedDOMRpcRoutingTableEntry(final DOMRpcIdentifier globalRpcId, - final YangInstanceIdentifier keyId, + private RoutedDOMRpcRoutingTableEntry(final DOMRpcIdentifier routedRpcId, final Map> impls) { - super(globalRpcId.getType(), impls); - this.keyId = Preconditions.checkNotNull(keyId); - this.globalRpcId = Preconditions.checkNotNull(globalRpcId); + super(routedRpcId, impls); } RoutedDOMRpcRoutingTableEntry(final RpcDefinition def, final YangInstanceIdentifier keyId, final Map> impls) { - super(def.getPath(), impls); - this.keyId = Preconditions.checkNotNull(keyId); - this.globalRpcId = DOMRpcIdentifier.create(def.getPath()); - } - - @Override - protected FluentFuture invokeRpc(final NormalizedNode input) { - final Optional> maybeKey = NormalizedNodes.findNode(input, keyId); - - // Routing key is present, attempt to deliver as a routed RPC - if (maybeKey.isPresent()) { - final NormalizedNode key = maybeKey.get(); - final Object value = key.getValue(); - if (value instanceof YangInstanceIdentifier) { - final YangInstanceIdentifier iid = (YangInstanceIdentifier) value; - - // Find a DOMRpcImplementation for a specific iid - final List specificImpls = getImplementations(iid); - if (specificImpls != null) { - return specificImpls.get(0).invokeRpc(DOMRpcIdentifier.create(getSchemaPath(), iid), input); - } - - LOG.debug("No implementation for context {} found will now look for wildcard id", iid); - - // Find a DOMRpcImplementation for a wild card. Usually remote-rpc-connector would register an - // implementation this way - final List mayBeRemoteImpls = getImplementations(YangInstanceIdentifier.EMPTY); - - if (mayBeRemoteImpls != null) { - return mayBeRemoteImpls.get(0).invokeRpc(DOMRpcIdentifier.create(getSchemaPath(), iid), input); - } - - } else { - LOG.warn("Ignoring wrong context value {}", value); - } - } - - final List impls = getImplementations(null); - if (impls != null) { - return impls.get(0).invokeRpc(globalRpcId, input); - } - - return FluentFutures.immediateFailedFluentFuture( - new DOMRpcImplementationNotAvailableException("No implementation of RPC %s available", getSchemaPath())); + super(DOMRpcIdentifier.create(def.getPath(), keyId), impls); } @Override protected RoutedDOMRpcRoutingTableEntry newInstance(final Map> impls) { - return new RoutedDOMRpcRoutingTableEntry(globalRpcId, keyId, impls); + return new RoutedDOMRpcRoutingTableEntry(getRpcId(), impls); } } 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 d4a085a3e3..e830f7a91e 100644 --- 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 @@ -10,12 +10,12 @@ package org.opendaylight.mdsal.dom.broker; import com.google.common.util.concurrent.FluentFuture; import java.util.List; import java.util.Map; +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.model.api.SchemaPath; final class UnknownDOMRpcRoutingTableEntry extends AbstractDOMRpcRoutingTableEntry { @@ -23,16 +23,11 @@ final class UnknownDOMRpcRoutingTableEntry extends AbstractDOMRpcRoutingTableEnt UnknownDOMRpcRoutingTableEntry(final SchemaPath schemaPath, final Map> impls) { - super(schemaPath, impls); + super(DOMRpcIdentifier.create(schemaPath), impls); unknownRpc = FluentFutures.immediateFailedFluentFuture( new DOMRpcImplementationNotAvailableException("SchemaPath %s is not resolved to an RPC", schemaPath)); } - @Override - protected FluentFuture invokeRpc(final NormalizedNode input) { - return unknownRpc; - } - @Override protected UnknownDOMRpcRoutingTableEntry newInstance(final Map> impls) { 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 4f1ecfc691..83e881e91f 100644 --- 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 @@ -23,6 +23,7 @@ import java.util.concurrent.TimeoutException; import org.junit.Test; import org.opendaylight.mdsal.dom.api.DOMRpcImplementation; import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException; +import org.opendaylight.mdsal.dom.broker.DOMRpcRouter.RpcInvocation; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.model.api.RpcDefinition; import org.opendaylight.yangtools.yang.model.api.SchemaPath; @@ -49,8 +50,8 @@ public class GlobalDOMRpcRoutingTableEntryTest extends TestUtils { rpcImplementation)); try { - globalDOMRpcRoutingTableEntry.newInstance(rpcImplementations) - .invokeRpc(TEST_CONTAINER).get(5, TimeUnit.SECONDS); + RpcInvocation.invoke(globalDOMRpcRoutingTableEntry.newInstance(rpcImplementations), + TEST_CONTAINER).get(5, TimeUnit.SECONDS); fail("Expected DOMRpcImplementationNotAvailableException"); } catch (ExecutionException e) { assertTrue(e.getCause() instanceof DOMRpcImplementationNotAvailableException); 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 190d821b78..a67908dda1 100644 --- 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 @@ -18,6 +18,7 @@ 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.DOMRpcRouter.RpcInvocation; import org.opendaylight.mdsal.dom.broker.util.TestModel; import org.opendaylight.yangtools.yang.model.api.RpcDefinition; import org.opendaylight.yangtools.yang.model.api.SchemaPath; @@ -35,7 +36,7 @@ public class RoutedDOMRpcRoutingTableEntryTest extends TestUtils { assertNotNull(routedDOMRpcRoutingTableEntry.newInstance(new HashMap<>())); try { - routedDOMRpcRoutingTableEntry.invokeRpc(TEST_CHILD).get(); + RpcInvocation.invoke(routedDOMRpcRoutingTableEntry, TEST_CHILD).get(); fail("Expected DOMRpcImplementationNotAvailableException"); } catch (ExecutionException e) { assertTrue(e.getCause() instanceof DOMRpcImplementationNotAvailableException); diff --git a/dom/mdsal-dom-broker/src/test/java/org/opendaylight/mdsal/dom/broker/UnknownDOMRpcRoutingTableEntryTest.java b/dom/mdsal-dom-broker/src/test/java/org/opendaylight/mdsal/dom/broker/UnknownDOMRpcRoutingTableEntryTest.java index 50d81bfdb7..319841a4cf 100644 --- a/dom/mdsal-dom-broker/src/test/java/org/opendaylight/mdsal/dom/broker/UnknownDOMRpcRoutingTableEntryTest.java +++ b/dom/mdsal-dom-broker/src/test/java/org/opendaylight/mdsal/dom/broker/UnknownDOMRpcRoutingTableEntryTest.java @@ -17,6 +17,7 @@ import java.util.List; import java.util.Map; import org.junit.Test; import org.opendaylight.mdsal.dom.api.DOMRpcImplementation; +import org.opendaylight.mdsal.dom.broker.DOMRpcRouter.RpcInvocation; import org.opendaylight.mdsal.dom.broker.util.TestModel; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.model.api.SchemaPath; @@ -37,7 +38,7 @@ public class UnknownDOMRpcRoutingTableEntryTest extends TestUtils { assertNotNull(test); assertNotNull(test.newInstance(emptyImpls)); - assertNotNull(test.invokeRpc(TEST_CONTAINER)); + assertNotNull(RpcInvocation.invoke(test, TEST_CONTAINER)); assertNotNull(test.getImplementations()); assertEquals(test.getImplementations(YangInstanceIdentifier.EMPTY), TEST_LIST); assertTrue(test.containsContext(YangInstanceIdentifier.EMPTY)); -- 2.36.6