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