From: Jie Han Date: Mon, 30 Jul 2018 06:20:07 +0000 (+0800) Subject: Remove AbstractDOMRpcRoutingTableEntry.invokeRpc X-Git-Tag: release/fluorine~18 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=commitdiff_plain;h=8b846e31bfcaeb74dcfc1c2560b769d3a50671dc;p=mdsal.git 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 --- 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));