Make DOMSchemaService operate of EffectiveModelContext

[mdsal.git] / dom / mdsal-dom-broker / src / main / java / org / opendaylight / mdsal / dom / broker / DOMRpcRouter.java

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 f0215481c67ecf575700aa1b7c7d2b6752f9f0d7..2128bd7fa986ec4248d5fce2dd4b2c80ecbab18d 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
@@ -21,8 +21,10 @@ 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.FluentFuture;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -35,7 +37,7 @@ import java.util.Set;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ThreadFactory;
-import javax.annotation.concurrent.GuardedBy;
+import org.checkerframework.checker.lock.qual.GuardedBy;
 import org.eclipse.jdt.annotation.NonNullByDefault;
 import org.opendaylight.mdsal.dom.api.DOMActionAvailabilityExtension;
 import org.opendaylight.mdsal.dom.api.DOMActionAvailabilityExtension.AvailabilityListener;
@@ -63,18 +65,17 @@ import org.opendaylight.yangtools.concepts.AbstractObjectRegistration;
 import org.opendaylight.yangtools.concepts.AbstractRegistration;
 import org.opendaylight.yangtools.concepts.ListenerRegistration;
 import org.opendaylight.yangtools.concepts.ObjectRegistration;
-import org.opendaylight.yangtools.util.concurrent.FluentFutures;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
 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.EffectiveModelContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextListener;
 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-public final class DOMRpcRouter extends AbstractRegistration implements SchemaContextListener {
+public final class DOMRpcRouter extends AbstractRegistration implements EffectiveModelContextListener {
     private static final ThreadFactory THREAD_FACTORY = new ThreadFactoryBuilder().setNameFormat(
             "DOMRpcRouter-listener-%s").setDaemon(true).build();
 
@@ -118,6 +119,8 @@ public final class DOMRpcRouter extends AbstractRegistration implements SchemaCo
         return rpcProviderService;
     }
 
+    @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+            justification = "https://github.com/spotbugs/spotbugs/issues/811")
     private synchronized void removeRpcImplementation(final DOMRpcImplementation implementation,
             final Set<DOMRpcIdentifier> rpcs) {
         final DOMRpcRoutingTable oldTable = routingTable;
@@ -127,6 +130,8 @@ public final class DOMRpcRouter extends AbstractRegistration implements SchemaCo
         listenerNotifier.execute(() -> notifyRemoved(newTable, implementation));
     }
 
+    @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+            justification = "https://github.com/spotbugs/spotbugs/issues/811")
     private synchronized void removeActionImplementation(final DOMActionImplementation implementation,
             final Set<DOMActionInstance> actions) {
         final DOMActionRoutingTable oldTable = actionRoutingTable;
@@ -136,14 +141,20 @@ public final class DOMRpcRouter extends AbstractRegistration implements SchemaCo
         listenerNotifier.execute(() -> notifyActionChanged(newTable, implementation));
     }
 
+    @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+            justification = "https://github.com/spotbugs/spotbugs/issues/811")
     private synchronized void removeListener(final ListenerRegistration<? extends DOMRpcAvailabilityListener> reg) {
         listeners = ImmutableList.copyOf(Collections2.filter(listeners, input -> !reg.equals(input)));
     }
 
+    @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+            justification = "https://github.com/spotbugs/spotbugs/issues/811")
     private synchronized void removeActionListener(final ListenerRegistration<? extends AvailabilityListener> reg) {
         actionListeners = ImmutableList.copyOf(Collections2.filter(actionListeners, input -> !reg.equals(input)));
     }
 
+    @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+            justification = "https://github.com/spotbugs/spotbugs/issues/811")
     private synchronized void notifyAdded(final DOMRpcRoutingTable newTable, final DOMRpcImplementation impl) {
         for (Registration<?> l : listeners) {
             l.addRpc(newTable, impl);
@@ -164,13 +175,14 @@ public final class DOMRpcRouter extends AbstractRegistration implements SchemaCo
     }
 
     @Override
-    public synchronized void onGlobalContextUpdated(final SchemaContext context) {
+    public synchronized void onModelContextUpdated(final EffectiveModelContext newModelContext) {
         final DOMRpcRoutingTable oldTable = routingTable;
-        final DOMRpcRoutingTable newTable = (DOMRpcRoutingTable) oldTable.setSchemaContext(context);
+        final DOMRpcRoutingTable newTable = (DOMRpcRoutingTable) oldTable.setSchemaContext(newModelContext);
         routingTable = newTable;
 
         final DOMActionRoutingTable oldActionTable = actionRoutingTable;
-        final DOMActionRoutingTable newActionTable = (DOMActionRoutingTable) oldActionTable.setSchemaContext(context);
+        final DOMActionRoutingTable newActionTable =
+                (DOMActionRoutingTable) oldActionTable.setSchemaContext(newModelContext);
         actionRoutingTable = newActionTable;
     }
 
@@ -371,11 +383,11 @@ public final class DOMRpcRouter extends AbstractRegistration implements SchemaCo
         }
 
         @Override
-        public FluentFuture<? extends DOMActionResult> invokeAction(final SchemaPath type,
+        public ListenableFuture<? extends DOMActionResult> invokeAction(final SchemaPath type,
                 final DOMDataTreeIdentifier path, final ContainerNode input) {
             final DOMActionRoutingTableEntry entry = (DOMActionRoutingTableEntry) actionRoutingTable.getEntry(type);
             if (entry == null) {
-                return FluentFutures.immediateFailedFluentFuture(
+                return Futures.immediateFailedFuture(
                     new DOMActionNotAvailableException("No implementation of Action %s available", type));
             }
 
@@ -402,7 +414,7 @@ public final class DOMRpcRouter extends AbstractRegistration implements SchemaCo
                 listenerNotifier.execute(() -> notifyActionChanged(newTable, implementation));
             }
 
-            return new AbstractObjectRegistration<T>(implementation) {
+            return new AbstractObjectRegistration<>(implementation) {
                 @Override
                 protected void removeRegistration() {
                     removeActionImplementation(getInstance(), instances);
@@ -413,10 +425,10 @@ public final class DOMRpcRouter extends AbstractRegistration implements SchemaCo
 
     private final class RpcServiceFacade implements DOMRpcService {
         @Override
-        public FluentFuture<DOMRpcResult> invokeRpc(final SchemaPath type, final NormalizedNode<?, ?> input) {
+        public ListenableFuture<DOMRpcResult> invokeRpc(final SchemaPath type, final NormalizedNode<?, ?> input) {
             final AbstractDOMRpcRoutingTableEntry entry = (AbstractDOMRpcRoutingTableEntry) routingTable.getEntry(type);
             if (entry == null) {
-                return FluentFutures.immediateFailedFluentFuture(
+                return Futures.immediateFailedFuture(
                     new DOMRpcImplementationNotAvailableException("No implementation of RPC %s available", type));
             }
 
@@ -458,7 +470,7 @@ public final class DOMRpcRouter extends AbstractRegistration implements SchemaCo
                 listenerNotifier.execute(() -> notifyAdded(newTable, implementation));
             }
 
-            return new AbstractDOMRpcImplementationRegistration<T>(implementation) {
+            return new AbstractDOMRpcImplementationRegistration<>(implementation) {
                 @Override
                 protected void removeRegistration() {
                     removeRpcImplementation(getInstance(), rpcs);
@@ -470,15 +482,15 @@ public final class DOMRpcRouter extends AbstractRegistration implements SchemaCo
     static final class OperationInvocation {
         private static final Logger LOG = LoggerFactory.getLogger(OperationInvocation.class);
 
-        static FluentFuture<? extends DOMActionResult> invoke(final DOMActionRoutingTableEntry entry,
+        static ListenableFuture<? extends DOMActionResult> invoke(final DOMActionRoutingTableEntry entry,
                 final SchemaPath type, final DOMDataTreeIdentifier path, final ContainerNode input) {
             return entry.getImplementations(path).get(0).invokeAction(type, path, input);
         }
 
-        static FluentFuture<DOMRpcResult> invoke(final AbstractDOMRpcRoutingTableEntry entry,
+        static ListenableFuture<DOMRpcResult> invoke(final AbstractDOMRpcRoutingTableEntry entry,
                 final NormalizedNode<?, ?> input) {
             if (entry instanceof UnknownDOMRpcRoutingTableEntry) {
-                return FluentFutures.immediateFailedFluentFuture(
+                return Futures.immediateFailedFuture(
                     new DOMRpcImplementationNotAvailableException("SchemaPath %s is not resolved to an RPC",
                         entry.getType()));
             } else if (entry instanceof RoutedDOMRpcRoutingTableEntry) {
@@ -487,11 +499,11 @@ public final class DOMRpcRouter extends AbstractRegistration implements SchemaCo
                 return invokeGlobalRpc((GlobalDOMRpcRoutingTableEntry) entry, input);
             }
 
-            return FluentFutures.immediateFailedFluentFuture(
+            return Futures.immediateFailedFuture(
                 new DOMRpcImplementationNotAvailableException("Unsupported RPC entry."));
         }
 
-        private static FluentFuture<DOMRpcResult> invokeRoutedRpc(final RoutedDOMRpcRoutingTableEntry entry,
+        private static ListenableFuture<DOMRpcResult> invokeRoutedRpc(final RoutedDOMRpcRoutingTableEntry entry,
                 final NormalizedNode<?, ?> input) {
             final Optional<NormalizedNode<?, ?>> maybeKey = NormalizedNodes.findNode(input,
                 entry.getRpcId().getContextReference());
@@ -515,7 +527,7 @@ public final class DOMRpcRouter extends AbstractRegistration implements SchemaCo
                     // Find a DOMRpcImplementation for a wild card. Usually remote-rpc-connector would register an
                     // implementation this way
                     final List<DOMRpcImplementation> mayBeRemoteImpls =
-                        entry.getImplementations(YangInstanceIdentifier.EMPTY);
+                        entry.getImplementations(YangInstanceIdentifier.empty());
 
                     if (mayBeRemoteImpls != null) {
                         return mayBeRemoteImpls.get(0)
@@ -532,14 +544,14 @@ public final class DOMRpcRouter extends AbstractRegistration implements SchemaCo
                 return impls.get(0).invokeRpc(entry.getRpcId(), input);
             }
 
-            return FluentFutures.immediateFailedFluentFuture(
+            return Futures.immediateFailedFuture(
                 new DOMRpcImplementationNotAvailableException("No implementation of RPC %s available",
                     entry.getType()));
         }
 
-        private static FluentFuture<DOMRpcResult> invokeGlobalRpc(final GlobalDOMRpcRoutingTableEntry entry,
+        private static ListenableFuture<DOMRpcResult> invokeGlobalRpc(final GlobalDOMRpcRoutingTableEntry entry,
                 final NormalizedNode<?, ?> input) {
-            return entry.getImplementations(YangInstanceIdentifier.EMPTY).get(0).invokeRpc(entry.getRpcId(), input);
+            return entry.getImplementations(YangInstanceIdentifier.empty()).get(0).invokeRpc(entry.getRpcId(), input);
         }
     }
 }