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