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;
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;
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();
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;
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;
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);
}
@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;
}
}
@VisibleForTesting
- Collection<?> listeners() {
+ synchronized Collection<?> listeners() {
return listeners;
}
}
@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));
}
listenerNotifier.execute(() -> notifyActionChanged(newTable, implementation));
}
- return new AbstractObjectRegistration<T>(implementation) {
+ return new AbstractObjectRegistration<>(implementation) {
@Override
protected void removeRegistration() {
removeActionImplementation(getInstance(), instances);
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));
}
listenerNotifier.execute(() -> notifyAdded(newTable, implementation));
}
- return new AbstractDOMRpcImplementationRegistration<T>(implementation) {
+ return new AbstractDOMRpcImplementationRegistration<>(implementation) {
@Override
protected void removeRegistration() {
removeRpcImplementation(getInstance(), rpcs);
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) {
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());
// 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)
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);
}
}
}