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.Verify.verifyNotNull;
  11 import static java.util.Objects.requireNonNull;
  12
  13 import com.google.common.annotations.VisibleForTesting;
  14 import com.google.common.collect.ClassToInstanceMap;
  15 import com.google.common.collect.Collections2;
  16 import com.google.common.collect.ImmutableClassToInstanceMap;
  17 import com.google.common.collect.ImmutableList;
  18 import com.google.common.collect.ImmutableList.Builder;
  19 import com.google.common.collect.ImmutableSet;
  20 import com.google.common.collect.MapDifference;
  21 import com.google.common.collect.MapDifference.ValueDifference;
  22 import com.google.common.collect.Maps;
  23 import com.google.common.collect.Sets;
  24 import com.google.common.util.concurrent.Futures;
  25 import com.google.common.util.concurrent.ListenableFuture;
  26 import com.google.common.util.concurrent.ThreadFactoryBuilder;
  27 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
  28 import java.util.ArrayList;
  29 import java.util.Collection;
  30 import java.util.Collections;
  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.inject.Inject;
  41 import javax.inject.Singleton;
  42 import org.checkerframework.checker.lock.qual.GuardedBy;
  43 import org.eclipse.jdt.annotation.NonNull;
  44 import org.eclipse.jdt.annotation.NonNullByDefault;
  45 import org.opendaylight.mdsal.dom.api.DOMActionAvailabilityExtension;
  46 import org.opendaylight.mdsal.dom.api.DOMActionAvailabilityExtension.AvailabilityListener;
  47 import org.opendaylight.mdsal.dom.api.DOMActionImplementation;
  48 import org.opendaylight.mdsal.dom.api.DOMActionInstance;
  49 import org.opendaylight.mdsal.dom.api.DOMActionNotAvailableException;
  50 import org.opendaylight.mdsal.dom.api.DOMActionProviderService;
  51 import org.opendaylight.mdsal.dom.api.DOMActionProviderServiceExtension;
  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 removeActionImplementation(final DOMActionImplementation implementation,
 147             final Set<DOMActionInstance> actions) {
 148         final DOMActionRoutingTable oldTable = actionRoutingTable;
 149         final DOMActionRoutingTable newTable = (DOMActionRoutingTable) oldTable.remove(implementation, actions);
 150         actionRoutingTable = newTable;
 151
 152         listenerNotifier.execute(() -> notifyActionChanged(newTable, implementation));
 153     }
 154
 155     @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
 156             justification = "https://github.com/spotbugs/spotbugs/issues/811")
 157     private synchronized void removeListener(final ListenerRegistration<? extends DOMRpcAvailabilityListener> reg) {
 158         listeners = ImmutableList.copyOf(Collections2.filter(listeners, input -> !reg.equals(input)));
 159     }
 160
 161     @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
 162             justification = "https://github.com/spotbugs/spotbugs/issues/811")
 163     private synchronized void removeActionListener(final ListenerRegistration<? extends AvailabilityListener> reg) {
 164         actionListeners = ImmutableList.copyOf(Collections2.filter(actionListeners, input -> !reg.equals(input)));
 165     }
 166
 167     @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
 168             justification = "https://github.com/spotbugs/spotbugs/issues/811")
 169     private synchronized void notifyAdded(final DOMRpcRoutingTable newTable, final DOMRpcImplementation impl) {
 170         for (Registration<?> l : listeners) {
 171             l.addRpc(newTable, impl);
 172         }
 173     }
 174
 175     private synchronized void notifyRemoved(final DOMRpcRoutingTable newTable, final DOMRpcImplementation impl) {
 176         for (Registration<?> l : listeners) {
 177             l.removeRpc(newTable, impl);
 178         }
 179     }
 180
 181     private synchronized void notifyActionChanged(final DOMActionRoutingTable newTable,
 182             final DOMActionImplementation impl) {
 183         for (ActionRegistration<?> l : actionListeners) {
 184             l.actionChanged(newTable, impl);
 185         }
 186     }
 187
 188     @Override
 189     public synchronized void onModelContextUpdated(final EffectiveModelContext newModelContext) {
 190         final DOMRpcRoutingTable oldTable = routingTable;
 191         final DOMRpcRoutingTable newTable = (DOMRpcRoutingTable) oldTable.setSchemaContext(newModelContext);
 192         routingTable = newTable;
 193
 194         final DOMActionRoutingTable oldActionTable = actionRoutingTable;
 195         final DOMActionRoutingTable newActionTable =
 196                 (DOMActionRoutingTable) oldActionTable.setSchemaContext(newModelContext);
 197         actionRoutingTable = newActionTable;
 198     }
 199
 200     @Override
 201     protected void removeRegistration() {
 202         if (listenerRegistration != null) {
 203             listenerRegistration.close();
 204             listenerRegistration = null;
 205         }
 206         listenerNotifier.shutdown();
 207     }
 208
 209     @VisibleForTesting
 210     synchronized Collection<?> listeners() {
 211         return listeners;
 212     }
 213
 214     @VisibleForTesting
 215     DOMRpcRoutingTable routingTable() {
 216         return routingTable;
 217     }
 218
 219     private static final class Registration<T extends DOMRpcAvailabilityListener>
 220         extends AbstractListenerRegistration<T> {
 221
 222         private Map<QName, Set<YangInstanceIdentifier>> prevRpcs;
 223         private DOMRpcRouter router;
 224
 225         Registration(final DOMRpcRouter router, final T listener, final Map<QName, Set<YangInstanceIdentifier>> rpcs) {
 226             super(listener);
 227             this.router = requireNonNull(router);
 228             this.prevRpcs = requireNonNull(rpcs);
 229         }
 230
 231         @Override
 232         protected void removeRegistration() {
 233             router.removeListener(this);
 234             router = null;
 235         }
 236
 237         void initialTable() {
 238             final Collection<DOMRpcIdentifier> added = new ArrayList<>();
 239             for (Entry<QName, Set<YangInstanceIdentifier>> e : prevRpcs.entrySet()) {
 240                 added.addAll(Collections2.transform(e.getValue(), i -> DOMRpcIdentifier.create(e.getKey(), i)));
 241             }
 242             if (!added.isEmpty()) {
 243                 getInstance().onRpcAvailable(added);
 244             }
 245         }
 246
 247         void addRpc(final DOMRpcRoutingTable newTable, final DOMRpcImplementation impl) {
 248             final T l = getInstance();
 249             if (!l.acceptsImplementation(impl)) {
 250                 return;
 251             }
 252
 253             final Map<QName, Set<YangInstanceIdentifier>> rpcs = verifyNotNull(newTable.getOperations(l));
 254             final MapDifference<QName, Set<YangInstanceIdentifier>> diff = Maps.difference(prevRpcs, rpcs);
 255
 256             final Collection<DOMRpcIdentifier> added = new ArrayList<>();
 257             for (Entry<QName, Set<YangInstanceIdentifier>> e : diff.entriesOnlyOnRight().entrySet()) {
 258                 added.addAll(Collections2.transform(e.getValue(), i -> DOMRpcIdentifier.create(e.getKey(), i)));
 259             }
 260             for (Entry<QName, ValueDifference<Set<YangInstanceIdentifier>>> e : diff.entriesDiffering().entrySet()) {
 261                 for (YangInstanceIdentifier i : Sets.difference(e.getValue().rightValue(), e.getValue().leftValue())) {
 262                     added.add(DOMRpcIdentifier.create(e.getKey(), i));
 263                 }
 264             }
 265
 266             prevRpcs = rpcs;
 267             if (!added.isEmpty()) {
 268                 l.onRpcAvailable(added);
 269             }
 270         }
 271
 272         void removeRpc(final DOMRpcRoutingTable newTable, final DOMRpcImplementation impl) {
 273             final T l = getInstance();
 274             if (!l.acceptsImplementation(impl)) {
 275                 return;
 276             }
 277
 278             final Map<QName, Set<YangInstanceIdentifier>> rpcs = verifyNotNull(newTable.getOperations(l));
 279             final MapDifference<QName, Set<YangInstanceIdentifier>> diff = Maps.difference(prevRpcs, rpcs);
 280
 281             final Collection<DOMRpcIdentifier> removed = new ArrayList<>();
 282             for (Entry<QName, Set<YangInstanceIdentifier>> e : diff.entriesOnlyOnLeft().entrySet()) {
 283                 removed.addAll(Collections2.transform(e.getValue(), i -> DOMRpcIdentifier.create(e.getKey(), i)));
 284             }
 285             for (Entry<QName, ValueDifference<Set<YangInstanceIdentifier>>> e : diff.entriesDiffering().entrySet()) {
 286                 for (YangInstanceIdentifier i : Sets.difference(e.getValue().leftValue(), e.getValue().rightValue())) {
 287                     removed.add(DOMRpcIdentifier.create(e.getKey(), i));
 288                 }
 289             }
 290
 291             prevRpcs = rpcs;
 292             if (!removed.isEmpty()) {
 293                 l.onRpcUnavailable(removed);
 294             }
 295         }
 296     }
 297
 298     private static final class ActionRegistration<T extends AvailabilityListener>
 299         extends AbstractListenerRegistration<T> {
 300
 301         private Map<Absolute, Set<DOMDataTreeIdentifier>> prevActions;
 302         private DOMRpcRouter router;
 303
 304         ActionRegistration(final DOMRpcRouter router, final T listener,
 305                 final Map<Absolute, Set<DOMDataTreeIdentifier>> actions) {
 306             super(listener);
 307             this.router = requireNonNull(router);
 308             this.prevActions = requireNonNull(actions);
 309         }
 310
 311         @Override
 312         protected void removeRegistration() {
 313             router.removeActionListener(this);
 314             router = null;
 315         }
 316
 317         void initialTable() {
 318             final Collection<DOMActionInstance> added = new ArrayList<>();
 319             for (Entry<Absolute, Set<DOMDataTreeIdentifier>> e : prevActions.entrySet()) {
 320                 added.addAll(Collections2.transform(e.getValue(), i -> DOMActionInstance.of(e.getKey(), i)));
 321             }
 322             if (!added.isEmpty()) {
 323                 getInstance().onActionsChanged(ImmutableSet.of(), ImmutableSet.copyOf(added));
 324             }
 325         }
 326
 327         void actionChanged(final DOMActionRoutingTable newTable, final DOMActionImplementation impl) {
 328             final T l = getInstance();
 329             if (!l.acceptsImplementation(impl)) {
 330                 return;
 331             }
 332
 333             final Map<Absolute, Set<DOMDataTreeIdentifier>> actions = verifyNotNull(newTable.getOperations(l));
 334             final MapDifference<Absolute, Set<DOMDataTreeIdentifier>> diff = Maps.difference(prevActions, actions);
 335
 336             final Set<DOMActionInstance> removed = new HashSet<>();
 337             final Set<DOMActionInstance> added = new HashSet<>();
 338
 339             for (Entry<Absolute, Set<DOMDataTreeIdentifier>> e : diff.entriesOnlyOnLeft().entrySet()) {
 340                 removed.addAll(Collections2.transform(e.getValue(), i -> DOMActionInstance.of(e.getKey(), i)));
 341             }
 342
 343             for (Entry<Absolute, Set<DOMDataTreeIdentifier>> e : diff.entriesOnlyOnRight().entrySet()) {
 344                 added.addAll(Collections2.transform(e.getValue(), i -> DOMActionInstance.of(e.getKey(), i)));
 345             }
 346
 347             for (Entry<Absolute, ValueDifference<Set<DOMDataTreeIdentifier>>> e : diff.entriesDiffering().entrySet()) {
 348                 for (DOMDataTreeIdentifier i : Sets.difference(e.getValue().leftValue(), e.getValue().rightValue())) {
 349                     removed.add(DOMActionInstance.of(e.getKey(), i));
 350                 }
 351
 352                 for (DOMDataTreeIdentifier i : Sets.difference(e.getValue().rightValue(), e.getValue().leftValue())) {
 353                     added.add(DOMActionInstance.of(e.getKey(), i));
 354                 }
 355             }
 356
 357             prevActions = actions;
 358             if (!removed.isEmpty() || !added.isEmpty()) {
 359                 l.onActionsChanged(removed, added);
 360             }
 361         }
 362     }
 363
 364     @NonNullByDefault
 365     private final class ActionAvailabilityFacade implements DOMActionAvailabilityExtension {
 366         @Override
 367         public <T extends AvailabilityListener> ListenerRegistration<T> registerAvailabilityListener(final T listener) {
 368             synchronized (DOMRpcRouter.this) {
 369                 final ActionRegistration<T> ret = new ActionRegistration<>(DOMRpcRouter.this,
 370                     listener, actionRoutingTable.getOperations(listener));
 371                 final Builder<ActionRegistration<?>> b = ImmutableList.builder();
 372                 b.addAll(actionListeners);
 373                 b.add(ret);
 374                 actionListeners = b.build();
 375
 376                 listenerNotifier.execute(ret::initialTable);
 377                 return ret;
 378             }
 379         }
 380     }
 381
 382     @NonNullByDefault
 383     private final class ActionServiceFacade implements DOMActionService {
 384         private final ClassToInstanceMap<DOMActionServiceExtension> extensions = ImmutableClassToInstanceMap.of(
 385             DOMActionAvailabilityExtension.class, new ActionAvailabilityFacade());
 386
 387         @Override
 388         public ClassToInstanceMap<DOMActionServiceExtension> getExtensions() {
 389             return extensions;
 390         }
 391
 392         @Override
 393         public ListenableFuture<? extends DOMActionResult> invokeAction(final Absolute type,
 394                 final DOMDataTreeIdentifier path, final ContainerNode input) {
 395             final DOMActionRoutingTableEntry entry = (DOMActionRoutingTableEntry) actionRoutingTable.getEntry(type);
 396             if (entry == null) {
 397                 return Futures.immediateFailedFuture(
 398                     new DOMActionNotAvailableException("No implementation of Action %s available", type));
 399             }
 400
 401             return OperationInvocation.invoke(entry, type, path, requireNonNull(input));
 402         }
 403     }
 404
 405     @NonNullByDefault
 406     private final class ActionProviderServiceFacade implements DOMActionProviderService {
 407         @Override
 408         public ClassToInstanceMap<DOMActionProviderServiceExtension> getExtensions() {
 409             return ImmutableClassToInstanceMap.of();
 410         }
 411
 412         @Override
 413         public <T extends DOMActionImplementation> ObjectRegistration<T> registerActionImplementation(
 414             final T implementation, final Set<DOMActionInstance> instances) {
 415
 416             synchronized (DOMRpcRouter.this) {
 417                 final DOMActionRoutingTable oldTable = actionRoutingTable;
 418                 final DOMActionRoutingTable newTable = (DOMActionRoutingTable) oldTable.add(implementation, instances);
 419                 actionRoutingTable = newTable;
 420
 421                 listenerNotifier.execute(() -> notifyActionChanged(newTable, implementation));
 422             }
 423
 424             return new AbstractObjectRegistration<>(implementation) {
 425                 @Override
 426                 protected void removeRegistration() {
 427                     removeActionImplementation(getInstance(), instances);
 428                 }
 429             };
 430         }
 431     }
 432
 433     private final class RpcServiceFacade implements DOMRpcService {
 434         @Override
 435         public ListenableFuture<? extends DOMRpcResult> invokeRpc(final QName type, final NormalizedNode<?, ?> input) {
 436             final AbstractDOMRpcRoutingTableEntry entry = (AbstractDOMRpcRoutingTableEntry) routingTable.getEntry(type);
 437             if (entry == null) {
 438                 return Futures.immediateFailedFuture(
 439                     new DOMRpcImplementationNotAvailableException("No implementation of RPC %s available", type));
 440             }
 441
 442             return OperationInvocation.invoke(entry, requireNonNull(input));
 443         }
 444
 445         @Override
 446         public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(final T listener) {
 447             synchronized (DOMRpcRouter.this) {
 448                 final Registration<T> ret = new Registration<>(DOMRpcRouter.this, listener,
 449                     routingTable.getOperations(listener));
 450                 final Builder<Registration<?>> b = ImmutableList.builder();
 451                 b.addAll(listeners);
 452                 b.add(ret);
 453                 listeners = b.build();
 454
 455                 listenerNotifier.execute(ret::initialTable);
 456                 return ret;
 457             }
 458         }
 459     }
 460
 461     private final class RpcProviderServiceFacade implements DOMRpcProviderService {
 462         @Override
 463         public <T extends DOMRpcImplementation> DOMRpcImplementationRegistration<T> registerRpcImplementation(
 464             final T implementation, final DOMRpcIdentifier... rpcs) {
 465             return registerRpcImplementation(implementation, ImmutableSet.copyOf(rpcs));
 466         }
 467
 468         @Override
 469         public <T extends DOMRpcImplementation> DOMRpcImplementationRegistration<T> registerRpcImplementation(
 470             final T implementation, final Set<DOMRpcIdentifier> rpcs) {
 471
 472             synchronized (DOMRpcRouter.this) {
 473                 final DOMRpcRoutingTable oldTable = routingTable;
 474                 final DOMRpcRoutingTable newTable = (DOMRpcRoutingTable) oldTable.add(implementation, rpcs);
 475                 routingTable = newTable;
 476
 477                 listenerNotifier.execute(() -> notifyAdded(newTable, implementation));
 478             }
 479
 480             return new AbstractDOMRpcImplementationRegistration<>(implementation) {
 481                 @Override
 482                 protected void removeRegistration() {
 483                     removeRpcImplementation(getInstance(), rpcs);
 484                 }
 485             };
 486         }
 487     }
 488
 489     static final class OperationInvocation {
 490         private static final Logger LOG = LoggerFactory.getLogger(OperationInvocation.class);
 491
 492         static ListenableFuture<? extends DOMActionResult> invoke(final DOMActionRoutingTableEntry entry,
 493                 final Absolute type, final DOMDataTreeIdentifier path, final ContainerNode input) {
 494             return entry.getImplementations(path).get(0).invokeAction(type, path, input);
 495         }
 496
 497         static ListenableFuture<? extends DOMRpcResult> invoke(final AbstractDOMRpcRoutingTableEntry entry,
 498                 final NormalizedNode<?, ?> input) {
 499             if (entry instanceof UnknownDOMRpcRoutingTableEntry) {
 500                 return Futures.immediateFailedFuture(
 501                     new DOMRpcImplementationNotAvailableException("%s is not resolved to an RPC", entry.getType()));
 502             } else if (entry instanceof RoutedDOMRpcRoutingTableEntry) {
 503                 return invokeRoutedRpc((RoutedDOMRpcRoutingTableEntry) entry, input);
 504             } else if (entry instanceof GlobalDOMRpcRoutingTableEntry) {
 505                 return invokeGlobalRpc((GlobalDOMRpcRoutingTableEntry) entry, input);
 506             }
 507
 508             return Futures.immediateFailedFuture(
 509                 new DOMRpcImplementationNotAvailableException("Unsupported RPC entry."));
 510         }
 511
 512         private static ListenableFuture<? extends DOMRpcResult> invokeRoutedRpc(
 513                 final RoutedDOMRpcRoutingTableEntry entry, final NormalizedNode<?, ?> input) {
 514             final Optional<NormalizedNode<?, ?>> maybeKey = NormalizedNodes.findNode(input,
 515                 entry.getRpcId().getContextReference());
 516
 517             // Routing key is present, attempt to deliver as a routed RPC
 518             if (maybeKey.isPresent()) {
 519                 final NormalizedNode<?, ?> key = maybeKey.get();
 520                 final Object value = key.getValue();
 521                 if (value instanceof YangInstanceIdentifier) {
 522                     final YangInstanceIdentifier iid = (YangInstanceIdentifier) value;
 523
 524                     // Find a DOMRpcImplementation for a specific iid
 525                     final List<DOMRpcImplementation> specificImpls = entry.getImplementations(iid);
 526                     if (specificImpls != null) {
 527                         return specificImpls.get(0)
 528                             .invokeRpc(DOMRpcIdentifier.create(entry.getType(), iid), input);
 529                     }
 530
 531                     LOG.debug("No implementation for context {} found will now look for wildcard id", iid);
 532
 533                     // Find a DOMRpcImplementation for a wild card. Usually remote-rpc-connector would register an
 534                     // implementation this way
 535                     final List<DOMRpcImplementation> mayBeRemoteImpls =
 536                         entry.getImplementations(YangInstanceIdentifier.empty());
 537
 538                     if (mayBeRemoteImpls != null) {
 539                         return mayBeRemoteImpls.get(0)
 540                             .invokeRpc(DOMRpcIdentifier.create(entry.getType(), iid), input);
 541                     }
 542
 543                 } else {
 544                     LOG.warn("Ignoring wrong context value {}", value);
 545                 }
 546             }
 547
 548             final List<DOMRpcImplementation> impls = entry.getImplementations(null);
 549             if (impls != null) {
 550                 return impls.get(0).invokeRpc(entry.getRpcId(), input);
 551             }
 552
 553             return Futures.immediateFailedFuture(
 554                 new DOMRpcImplementationNotAvailableException("No implementation of RPC %s available",
 555                     entry.getType()));
 556         }
 557
 558         private static ListenableFuture<? extends DOMRpcResult> invokeGlobalRpc(
 559                 final GlobalDOMRpcRoutingTableEntry entry, final NormalizedNode<?, ?> input) {
 560             return entry.getImplementations(YangInstanceIdentifier.empty()).get(0).invokeRpc(entry.getRpcId(), input);
 561         }
 562     }
 563 }