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

   1 /*
   2  * Copyright (c) 2015 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.mdsal.dom.broker;
   9
  10 import static com.google.common.base.Preconditions.checkArgument;
  11 import static com.google.common.base.Verify.verifyNotNull;
  12 import static java.util.Objects.requireNonNull;
  13
  14 import com.google.common.annotations.VisibleForTesting;
  15 import com.google.common.collect.ClassToInstanceMap;
  16 import com.google.common.collect.Collections2;
  17 import com.google.common.collect.ImmutableClassToInstanceMap;
  18 import com.google.common.collect.ImmutableList;
  19 import com.google.common.collect.ImmutableList.Builder;
  20 import com.google.common.collect.ImmutableMap;
  21 import com.google.common.collect.ImmutableSet;
  22 import com.google.common.collect.MapDifference;
  23 import com.google.common.collect.MapDifference.ValueDifference;
  24 import com.google.common.collect.Maps;
  25 import com.google.common.collect.Sets;
  26 import com.google.common.util.concurrent.Futures;
  27 import com.google.common.util.concurrent.ListenableFuture;
  28 import com.google.common.util.concurrent.ThreadFactoryBuilder;
  29 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
  30 import java.util.ArrayList;
  31 import java.util.Collection;
  32 import java.util.Collections;
  33 import java.util.HashSet;
  34 import java.util.List;
  35 import java.util.Map;
  36 import java.util.Map.Entry;
  37 import java.util.Optional;
  38 import java.util.Set;
  39 import java.util.concurrent.ExecutorService;
  40 import java.util.concurrent.Executors;
  41 import java.util.concurrent.ThreadFactory;
  42 import javax.inject.Inject;
  43 import javax.inject.Singleton;
  44 import org.checkerframework.checker.lock.qual.GuardedBy;
  45 import org.eclipse.jdt.annotation.NonNull;
  46 import org.eclipse.jdt.annotation.NonNullByDefault;
  47 import org.opendaylight.mdsal.dom.api.DOMActionAvailabilityExtension;
  48 import org.opendaylight.mdsal.dom.api.DOMActionAvailabilityExtension.AvailabilityListener;
  49 import org.opendaylight.mdsal.dom.api.DOMActionImplementation;
  50 import org.opendaylight.mdsal.dom.api.DOMActionInstance;
  51 import org.opendaylight.mdsal.dom.api.DOMActionNotAvailableException;
  52 import org.opendaylight.mdsal.dom.api.DOMActionProviderService;
  53 import org.opendaylight.mdsal.dom.api.DOMActionResult;
  54 import org.opendaylight.mdsal.dom.api.DOMActionService;
  55 import org.opendaylight.mdsal.dom.api.DOMActionServiceExtension;
  56 import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
  57 import org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener;
  58 import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
  59 import org.opendaylight.mdsal.dom.api.DOMRpcImplementation;
  60 import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
  61 import org.opendaylight.mdsal.dom.api.DOMRpcImplementationRegistration;
  62 import org.opendaylight.mdsal.dom.api.DOMRpcProviderService;
  63 import org.opendaylight.mdsal.dom.api.DOMRpcResult;
  64 import org.opendaylight.mdsal.dom.api.DOMRpcService;
  65 import org.opendaylight.mdsal.dom.api.DOMSchemaService;
  66 import org.opendaylight.mdsal.dom.spi.AbstractDOMRpcImplementationRegistration;
  67 import org.opendaylight.yangtools.concepts.AbstractListenerRegistration;
  68 import org.opendaylight.yangtools.concepts.AbstractObjectRegistration;
  69 import org.opendaylight.yangtools.concepts.AbstractRegistration;
  70 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  71 import org.opendaylight.yangtools.concepts.ObjectRegistration;
  72 import org.opendaylight.yangtools.yang.common.QName;
  73 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  74 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  75 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  76 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodes;
  77 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
  78 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextListener;
  79 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
  80 import org.slf4j.Logger;
  81 import org.slf4j.LoggerFactory;
  82
  83 @Singleton
  84 public final class DOMRpcRouter extends AbstractRegistration
  85         implements DOMRpcRouterServices, EffectiveModelContextListener {
  86     private static final ThreadFactory THREAD_FACTORY = new ThreadFactoryBuilder().setNameFormat(
  87             "DOMRpcRouter-listener-%s").setDaemon(true).build();
  88
  89     private final ExecutorService listenerNotifier = Executors.newSingleThreadExecutor(THREAD_FACTORY);
  90     private final @NonNull DOMActionProviderService actionProviderService = new ActionProviderServiceFacade();
  91     private final @NonNull DOMActionService actionService = new ActionServiceFacade();
  92     private final @NonNull DOMRpcProviderService rpcProviderService = new RpcProviderServiceFacade();
  93     private final @NonNull DOMRpcService rpcService = new RpcServiceFacade();
  94
  95     @GuardedBy("this")
  96     private Collection<Registration<?>> listeners = Collections.emptyList();
  97
  98     @GuardedBy("this")
  99     private Collection<ActionRegistration<?>> actionListeners = Collections.emptyList();
 100
 101     private volatile DOMRpcRoutingTable routingTable = DOMRpcRoutingTable.EMPTY;
 102
 103     private volatile DOMActionRoutingTable actionRoutingTable = DOMActionRoutingTable.EMPTY;
 104
 105     private ListenerRegistration<?> listenerRegistration;
 106
 107     @Inject
 108     public static DOMRpcRouter newInstance(final DOMSchemaService schemaService) {
 109         final DOMRpcRouter rpcRouter = new DOMRpcRouter();
 110         rpcRouter.listenerRegistration = schemaService.registerSchemaContextListener(rpcRouter);
 111         return rpcRouter;
 112     }
 113
 114     @Override
 115     public DOMActionService getActionService() {
 116         return actionService;
 117     }
 118
 119     @Override
 120     public DOMActionProviderService getActionProviderService() {
 121         return actionProviderService;
 122     }
 123
 124     @Override
 125     public DOMRpcService getRpcService() {
 126         return rpcService;
 127     }
 128
 129     @Override
 130     public DOMRpcProviderService getRpcProviderService() {
 131         return rpcProviderService;
 132     }
 133
 134     @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
 135             justification = "https://github.com/spotbugs/spotbugs/issues/811")
 136     private synchronized void removeRpcImplementation(final DOMRpcImplementation implementation,
 137             final Set<DOMRpcIdentifier> rpcs) {
 138         final DOMRpcRoutingTable oldTable = routingTable;
 139         final DOMRpcRoutingTable newTable = (DOMRpcRoutingTable) oldTable.remove(implementation, rpcs);
 140         routingTable = newTable;
 141
 142         listenerNotifier.execute(() -> notifyRemoved(newTable, implementation));
 143     }
 144
 145     @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
 146             justification = "https://github.com/spotbugs/spotbugs/issues/811")
 147     private synchronized void removeRpcImplementations(final Map<DOMRpcIdentifier, DOMRpcImplementation> map) {
 148         final DOMRpcRoutingTable oldTable = routingTable;
 149         final DOMRpcRoutingTable newTable = (DOMRpcRoutingTable) oldTable.removeAll(map);
 150         routingTable = newTable;
 151
 152         listenerNotifier.execute(() -> notifyRemoved(newTable, map.values()));
 153     }
 154
 155     @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
 156             justification = "https://github.com/spotbugs/spotbugs/issues/811")
 157     private synchronized void removeActionImplementation(final DOMActionImplementation implementation,
 158             final Set<DOMActionInstance> actions) {
 159         final DOMActionRoutingTable oldTable = actionRoutingTable;
 160         final DOMActionRoutingTable newTable = (DOMActionRoutingTable) oldTable.remove(implementation, actions);
 161         actionRoutingTable = newTable;
 162
 163         listenerNotifier.execute(() -> notifyActionChanged(newTable, implementation));
 164     }
 165
 166     @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
 167             justification = "https://github.com/spotbugs/spotbugs/issues/811")
 168     private synchronized void removeListener(final ListenerRegistration<? extends DOMRpcAvailabilityListener> reg) {
 169         listeners = ImmutableList.copyOf(Collections2.filter(listeners, input -> !reg.equals(input)));
 170     }
 171
 172     @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
 173             justification = "https://github.com/spotbugs/spotbugs/issues/811")
 174     private synchronized void removeActionListener(final ListenerRegistration<? extends AvailabilityListener> reg) {
 175         actionListeners = ImmutableList.copyOf(Collections2.filter(actionListeners, input -> !reg.equals(input)));
 176     }
 177
 178     @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
 179             justification = "https://github.com/spotbugs/spotbugs/issues/811")
 180     private synchronized void notifyAdded(final DOMRpcRoutingTable newTable, final DOMRpcImplementation impl) {
 181         for (Registration<?> l : listeners) {
 182             l.addRpc(newTable, impl);
 183         }
 184     }
 185
 186     @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
 187             justification = "https://github.com/spotbugs/spotbugs/issues/811")
 188     private synchronized void notifyAdded(final DOMRpcRoutingTable newTable,
 189             final Collection<? extends DOMRpcImplementation> impls) {
 190         for (Registration<?> l : listeners) {
 191             for (DOMRpcImplementation impl : impls) {
 192                 l.addRpc(newTable, impl);
 193             }
 194         }
 195     }
 196
 197     @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
 198             justification = "https://github.com/spotbugs/spotbugs/issues/811")
 199     private synchronized void notifyRemoved(final DOMRpcRoutingTable newTable, final DOMRpcImplementation impl) {
 200         for (Registration<?> l : listeners) {
 201             l.removeRpc(newTable, impl);
 202         }
 203     }
 204
 205     @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
 206             justification = "https://github.com/spotbugs/spotbugs/issues/811")
 207     private synchronized void notifyRemoved(final DOMRpcRoutingTable newTable,
 208             final Collection<? extends DOMRpcImplementation> impls) {
 209         for (Registration<?> l : listeners) {
 210             for (DOMRpcImplementation impl : impls) {
 211                 l.removeRpc(newTable, impl);
 212             }
 213         }
 214     }
 215
 216     private synchronized void notifyActionChanged(final DOMActionRoutingTable newTable,
 217             final DOMActionImplementation impl) {
 218         for (ActionRegistration<?> l : actionListeners) {
 219             l.actionChanged(newTable, impl);
 220         }
 221     }
 222
 223     @Override
 224     public synchronized void onModelContextUpdated(final EffectiveModelContext newModelContext) {
 225         final DOMRpcRoutingTable oldTable = routingTable;
 226         final DOMRpcRoutingTable newTable = (DOMRpcRoutingTable) oldTable.setSchemaContext(newModelContext);
 227         routingTable = newTable;
 228
 229         final DOMActionRoutingTable oldActionTable = actionRoutingTable;
 230         final DOMActionRoutingTable newActionTable =
 231                 (DOMActionRoutingTable) oldActionTable.setSchemaContext(newModelContext);
 232         actionRoutingTable = newActionTable;
 233     }
 234
 235     @Override
 236     protected void removeRegistration() {
 237         if (listenerRegistration != null) {
 238             listenerRegistration.close();
 239             listenerRegistration = null;
 240         }
 241         listenerNotifier.shutdown();
 242     }
 243
 244     @VisibleForTesting
 245     synchronized Collection<?> listeners() {
 246         return listeners;
 247     }
 248
 249     @VisibleForTesting
 250     DOMRpcRoutingTable routingTable() {
 251         return routingTable;
 252     }
 253
 254     private static final class Registration<T extends DOMRpcAvailabilityListener>
 255         extends AbstractListenerRegistration<T> {
 256
 257         private Map<QName, Set<YangInstanceIdentifier>> prevRpcs;
 258         private DOMRpcRouter router;
 259
 260         Registration(final DOMRpcRouter router, final T listener, final Map<QName, Set<YangInstanceIdentifier>> rpcs) {
 261             super(listener);
 262             this.router = requireNonNull(router);
 263             this.prevRpcs = requireNonNull(rpcs);
 264         }
 265
 266         @Override
 267         protected void removeRegistration() {
 268             router.removeListener(this);
 269             router = null;
 270         }
 271
 272         void initialTable() {
 273             final Collection<DOMRpcIdentifier> added = new ArrayList<>();
 274             for (Entry<QName, Set<YangInstanceIdentifier>> e : prevRpcs.entrySet()) {
 275                 added.addAll(Collections2.transform(e.getValue(), i -> DOMRpcIdentifier.create(e.getKey(), i)));
 276             }
 277             if (!added.isEmpty()) {
 278                 getInstance().onRpcAvailable(added);
 279             }
 280         }
 281
 282         void addRpc(final DOMRpcRoutingTable newTable, final DOMRpcImplementation impl) {
 283             final T l = getInstance();
 284             if (!l.acceptsImplementation(impl)) {
 285                 return;
 286             }
 287
 288             final Map<QName, Set<YangInstanceIdentifier>> rpcs = verifyNotNull(newTable.getOperations(l));
 289             final MapDifference<QName, Set<YangInstanceIdentifier>> diff = Maps.difference(prevRpcs, rpcs);
 290
 291             final Collection<DOMRpcIdentifier> added = new ArrayList<>();
 292             for (Entry<QName, Set<YangInstanceIdentifier>> e : diff.entriesOnlyOnRight().entrySet()) {
 293                 added.addAll(Collections2.transform(e.getValue(), i -> DOMRpcIdentifier.create(e.getKey(), i)));
 294             }
 295             for (Entry<QName, ValueDifference<Set<YangInstanceIdentifier>>> e : diff.entriesDiffering().entrySet()) {
 296                 for (YangInstanceIdentifier i : Sets.difference(e.getValue().rightValue(), e.getValue().leftValue())) {
 297                     added.add(DOMRpcIdentifier.create(e.getKey(), i));
 298                 }
 299             }
 300
 301             prevRpcs = rpcs;
 302             if (!added.isEmpty()) {
 303                 l.onRpcAvailable(added);
 304             }
 305         }
 306
 307         void removeRpc(final DOMRpcRoutingTable newTable, final DOMRpcImplementation impl) {
 308             final T l = getInstance();
 309             if (!l.acceptsImplementation(impl)) {
 310                 return;
 311             }
 312
 313             final Map<QName, Set<YangInstanceIdentifier>> rpcs = verifyNotNull(newTable.getOperations(l));
 314             final MapDifference<QName, Set<YangInstanceIdentifier>> diff = Maps.difference(prevRpcs, rpcs);
 315
 316             final Collection<DOMRpcIdentifier> removed = new ArrayList<>();
 317             for (Entry<QName, Set<YangInstanceIdentifier>> e : diff.entriesOnlyOnLeft().entrySet()) {
 318                 removed.addAll(Collections2.transform(e.getValue(), i -> DOMRpcIdentifier.create(e.getKey(), i)));
 319             }
 320             for (Entry<QName, ValueDifference<Set<YangInstanceIdentifier>>> e : diff.entriesDiffering().entrySet()) {
 321                 for (YangInstanceIdentifier i : Sets.difference(e.getValue().leftValue(), e.getValue().rightValue())) {
 322                     removed.add(DOMRpcIdentifier.create(e.getKey(), i));
 323                 }
 324             }
 325
 326             prevRpcs = rpcs;
 327             if (!removed.isEmpty()) {
 328                 l.onRpcUnavailable(removed);
 329             }
 330         }
 331     }
 332
 333     private static final class ActionRegistration<T extends AvailabilityListener>
 334         extends AbstractListenerRegistration<T> {
 335
 336         private Map<Absolute, Set<DOMDataTreeIdentifier>> prevActions;
 337         private DOMRpcRouter router;
 338
 339         ActionRegistration(final DOMRpcRouter router, final T listener,
 340                 final Map<Absolute, Set<DOMDataTreeIdentifier>> actions) {
 341             super(listener);
 342             this.router = requireNonNull(router);
 343             this.prevActions = requireNonNull(actions);
 344         }
 345
 346         @Override
 347         protected void removeRegistration() {
 348             router.removeActionListener(this);
 349             router = null;
 350         }
 351
 352         void initialTable() {
 353             final Collection<DOMActionInstance> added = new ArrayList<>();
 354             for (Entry<Absolute, Set<DOMDataTreeIdentifier>> e : prevActions.entrySet()) {
 355                 added.addAll(Collections2.transform(e.getValue(), i -> DOMActionInstance.of(e.getKey(), i)));
 356             }
 357             if (!added.isEmpty()) {
 358                 getInstance().onActionsChanged(ImmutableSet.of(), ImmutableSet.copyOf(added));
 359             }
 360         }
 361
 362         void actionChanged(final DOMActionRoutingTable newTable, final DOMActionImplementation impl) {
 363             final T l = getInstance();
 364             if (!l.acceptsImplementation(impl)) {
 365                 return;
 366             }
 367
 368             final Map<Absolute, Set<DOMDataTreeIdentifier>> actions = verifyNotNull(newTable.getOperations(l));
 369             final MapDifference<Absolute, Set<DOMDataTreeIdentifier>> diff = Maps.difference(prevActions, actions);
 370
 371             final Set<DOMActionInstance> removed = new HashSet<>();
 372             final Set<DOMActionInstance> added = new HashSet<>();
 373
 374             for (Entry<Absolute, Set<DOMDataTreeIdentifier>> e : diff.entriesOnlyOnLeft().entrySet()) {
 375                 removed.addAll(Collections2.transform(e.getValue(), i -> DOMActionInstance.of(e.getKey(), i)));
 376             }
 377
 378             for (Entry<Absolute, Set<DOMDataTreeIdentifier>> e : diff.entriesOnlyOnRight().entrySet()) {
 379                 added.addAll(Collections2.transform(e.getValue(), i -> DOMActionInstance.of(e.getKey(), i)));
 380             }
 381
 382             for (Entry<Absolute, ValueDifference<Set<DOMDataTreeIdentifier>>> e : diff.entriesDiffering().entrySet()) {
 383                 for (DOMDataTreeIdentifier i : Sets.difference(e.getValue().leftValue(), e.getValue().rightValue())) {
 384                     removed.add(DOMActionInstance.of(e.getKey(), i));
 385                 }
 386
 387                 for (DOMDataTreeIdentifier i : Sets.difference(e.getValue().rightValue(), e.getValue().leftValue())) {
 388                     added.add(DOMActionInstance.of(e.getKey(), i));
 389                 }
 390             }
 391
 392             prevActions = actions;
 393             if (!removed.isEmpty() || !added.isEmpty()) {
 394                 l.onActionsChanged(removed, added);
 395             }
 396         }
 397     }
 398
 399     @NonNullByDefault
 400     private final class ActionAvailabilityFacade implements DOMActionAvailabilityExtension {
 401         @Override
 402         public <T extends AvailabilityListener> ListenerRegistration<T> registerAvailabilityListener(final T listener) {
 403             synchronized (DOMRpcRouter.this) {
 404                 final ActionRegistration<T> ret = new ActionRegistration<>(DOMRpcRouter.this,
 405                     listener, actionRoutingTable.getOperations(listener));
 406                 final Builder<ActionRegistration<?>> b = ImmutableList.builder();
 407                 b.addAll(actionListeners);
 408                 b.add(ret);
 409                 actionListeners = b.build();
 410
 411                 listenerNotifier.execute(ret::initialTable);
 412                 return ret;
 413             }
 414         }
 415     }
 416
 417     @NonNullByDefault
 418     private final class ActionServiceFacade implements DOMActionService {
 419         private final ClassToInstanceMap<DOMActionServiceExtension> extensions = ImmutableClassToInstanceMap.of(
 420             DOMActionAvailabilityExtension.class, new ActionAvailabilityFacade());
 421
 422         @Override
 423         public ClassToInstanceMap<DOMActionServiceExtension> getExtensions() {
 424             return extensions;
 425         }
 426
 427         @Override
 428         public ListenableFuture<? extends DOMActionResult> invokeAction(final Absolute type,
 429                 final DOMDataTreeIdentifier path, final ContainerNode input) {
 430             final DOMActionRoutingTableEntry entry = (DOMActionRoutingTableEntry) actionRoutingTable.getEntry(type);
 431             if (entry == null) {
 432                 return Futures.immediateFailedFuture(
 433                     new DOMActionNotAvailableException("No implementation of Action %s available", type));
 434             }
 435
 436             return OperationInvocation.invoke(entry, type, path, requireNonNull(input));
 437         }
 438     }
 439
 440     @NonNullByDefault
 441     private final class ActionProviderServiceFacade implements DOMActionProviderService {
 442         @Override
 443         public <T extends DOMActionImplementation> ObjectRegistration<T> registerActionImplementation(
 444             final T implementation, final Set<DOMActionInstance> instances) {
 445
 446             synchronized (DOMRpcRouter.this) {
 447                 final DOMActionRoutingTable oldTable = actionRoutingTable;
 448                 final DOMActionRoutingTable newTable = (DOMActionRoutingTable) oldTable.add(implementation, instances);
 449                 actionRoutingTable = newTable;
 450
 451                 listenerNotifier.execute(() -> notifyActionChanged(newTable, implementation));
 452             }
 453
 454             return new AbstractObjectRegistration<>(implementation) {
 455                 @Override
 456                 protected void removeRegistration() {
 457                     removeActionImplementation(getInstance(), instances);
 458                 }
 459             };
 460         }
 461     }
 462
 463     private final class RpcServiceFacade implements DOMRpcService {
 464         @Override
 465         public ListenableFuture<? extends DOMRpcResult> invokeRpc(final QName type, final NormalizedNode input) {
 466             final AbstractDOMRpcRoutingTableEntry entry = (AbstractDOMRpcRoutingTableEntry) routingTable.getEntry(type);
 467             if (entry == null) {
 468                 return Futures.immediateFailedFuture(
 469                     new DOMRpcImplementationNotAvailableException("No implementation of RPC %s available", type));
 470             }
 471
 472             return OperationInvocation.invoke(entry, requireNonNull(input));
 473         }
 474
 475         @Override
 476         public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(final T listener) {
 477             synchronized (DOMRpcRouter.this) {
 478                 final Registration<T> ret = new Registration<>(DOMRpcRouter.this, listener,
 479                     routingTable.getOperations(listener));
 480                 final Builder<Registration<?>> b = ImmutableList.builder();
 481                 b.addAll(listeners);
 482                 b.add(ret);
 483                 listeners = b.build();
 484
 485                 listenerNotifier.execute(ret::initialTable);
 486                 return ret;
 487             }
 488         }
 489     }
 490
 491     private final class RpcProviderServiceFacade implements DOMRpcProviderService {
 492         @Override
 493         public <T extends DOMRpcImplementation> DOMRpcImplementationRegistration<T> registerRpcImplementation(
 494                 final T implementation, final DOMRpcIdentifier... rpcs) {
 495             return registerRpcImplementation(implementation, ImmutableSet.copyOf(rpcs));
 496         }
 497
 498         @Override
 499         public <T extends DOMRpcImplementation> DOMRpcImplementationRegistration<T> registerRpcImplementation(
 500                 final T implementation, final Set<DOMRpcIdentifier> rpcs) {
 501
 502             synchronized (DOMRpcRouter.this) {
 503                 final DOMRpcRoutingTable oldTable = routingTable;
 504                 final DOMRpcRoutingTable newTable = (DOMRpcRoutingTable) oldTable.add(implementation, rpcs);
 505                 routingTable = newTable;
 506
 507                 listenerNotifier.execute(() -> notifyAdded(newTable, implementation));
 508             }
 509
 510             return new AbstractDOMRpcImplementationRegistration<>(implementation) {
 511                 @Override
 512                 protected void removeRegistration() {
 513                     removeRpcImplementation(getInstance(), rpcs);
 514                 }
 515             };
 516         }
 517
 518         @Override
 519         public org.opendaylight.yangtools.concepts.Registration registerRpcImplementations(
 520                 final Map<DOMRpcIdentifier, DOMRpcImplementation> map) {
 521             final ImmutableMap<DOMRpcIdentifier, DOMRpcImplementation> defensive = ImmutableMap.copyOf(map);
 522             checkArgument(!map.isEmpty());
 523
 524             synchronized (DOMRpcRouter.this) {
 525                 final DOMRpcRoutingTable oldTable = routingTable;
 526                 final DOMRpcRoutingTable newTable = (DOMRpcRoutingTable) oldTable.addAll(defensive);
 527                 routingTable = newTable;
 528
 529                 listenerNotifier.execute(() -> notifyAdded(newTable, defensive.values()));
 530             }
 531
 532             return new AbstractRegistration() {
 533                 @Override
 534                 protected void removeRegistration() {
 535                     removeRpcImplementations(defensive);
 536                 }
 537             };
 538         }
 539     }
 540
 541     static final class OperationInvocation {
 542         private static final Logger LOG = LoggerFactory.getLogger(OperationInvocation.class);
 543
 544         static ListenableFuture<? extends DOMActionResult> invoke(final DOMActionRoutingTableEntry entry,
 545                 final Absolute type, final DOMDataTreeIdentifier path, final ContainerNode input) {
 546             return entry.getImplementations(path).get(0).invokeAction(type, path, input);
 547         }
 548
 549         static ListenableFuture<? extends DOMRpcResult> invoke(final AbstractDOMRpcRoutingTableEntry entry,
 550                 final NormalizedNode input) {
 551             if (entry instanceof UnknownDOMRpcRoutingTableEntry) {
 552                 return Futures.immediateFailedFuture(
 553                     new DOMRpcImplementationNotAvailableException("%s is not resolved to an RPC", entry.getType()));
 554             } else if (entry instanceof RoutedDOMRpcRoutingTableEntry) {
 555                 return invokeRoutedRpc((RoutedDOMRpcRoutingTableEntry) entry, input);
 556             } else if (entry instanceof GlobalDOMRpcRoutingTableEntry) {
 557                 return invokeGlobalRpc((GlobalDOMRpcRoutingTableEntry) entry, input);
 558             }
 559
 560             return Futures.immediateFailedFuture(
 561                 new DOMRpcImplementationNotAvailableException("Unsupported RPC entry."));
 562         }
 563
 564         private static ListenableFuture<? extends DOMRpcResult> invokeRoutedRpc(
 565                 final RoutedDOMRpcRoutingTableEntry entry, final NormalizedNode input) {
 566             final Optional<NormalizedNode> maybeKey = NormalizedNodes.findNode(input,
 567                 entry.getRpcId().getContextReference());
 568
 569             // Routing key is present, attempt to deliver as a routed RPC
 570             if (maybeKey.isPresent()) {
 571                 final NormalizedNode key = maybeKey.get();
 572                 final Object value = key.body();
 573                 if (value instanceof YangInstanceIdentifier) {
 574                     final YangInstanceIdentifier iid = (YangInstanceIdentifier) value;
 575
 576                     // Find a DOMRpcImplementation for a specific iid
 577                     final List<DOMRpcImplementation> specificImpls = entry.getImplementations(iid);
 578                     if (specificImpls != null) {
 579                         return specificImpls.get(0)
 580                             .invokeRpc(DOMRpcIdentifier.create(entry.getType(), iid), input);
 581                     }
 582
 583                     LOG.debug("No implementation for context {} found will now look for wildcard id", iid);
 584
 585                     // Find a DOMRpcImplementation for a wild card. Usually remote-rpc-connector would register an
 586                     // implementation this way
 587                     final List<DOMRpcImplementation> mayBeRemoteImpls =
 588                         entry.getImplementations(YangInstanceIdentifier.empty());
 589
 590                     if (mayBeRemoteImpls != null) {
 591                         return mayBeRemoteImpls.get(0)
 592                             .invokeRpc(DOMRpcIdentifier.create(entry.getType(), iid), input);
 593                     }
 594
 595                 } else {
 596                     LOG.warn("Ignoring wrong context value {}", value);
 597                 }
 598             }
 599
 600             final List<DOMRpcImplementation> impls = entry.getImplementations(null);
 601             if (impls != null) {
 602                 return impls.get(0).invokeRpc(entry.getRpcId(), input);
 603             }
 604
 605             return Futures.immediateFailedFuture(
 606                 new DOMRpcImplementationNotAvailableException("No implementation of RPC %s available",
 607                     entry.getType()));
 608         }
 609
 610         private static ListenableFuture<? extends DOMRpcResult> invokeGlobalRpc(
 611                 final GlobalDOMRpcRoutingTableEntry entry, final NormalizedNode input) {
 612             return entry.getImplementations(YangInstanceIdentifier.empty()).get(0).invokeRpc(entry.getRpcId(), input);
 613         }
 614     }
 615 }