opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/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.controller.md.sal.dom.broker.impl;
   9
  10 import com.google.common.annotations.VisibleForTesting;
  11 import com.google.common.collect.ImmutableSet;
  12 import com.google.common.util.concurrent.CheckedFuture;
  13 import com.google.common.util.concurrent.FluentFuture;
  14 import java.util.Collections;
  15 import java.util.Map;
  16 import java.util.Set;
  17 import java.util.WeakHashMap;
  18 import java.util.stream.Collectors;
  19 import org.opendaylight.controller.md.sal.dom.api.DOMRpcAvailabilityListener;
  20 import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
  21 import org.opendaylight.controller.md.sal.dom.api.DOMRpcIdentifier;
  22 import org.opendaylight.controller.md.sal.dom.api.DOMRpcImplementation;
  23 import org.opendaylight.controller.md.sal.dom.api.DOMRpcImplementationRegistration;
  24 import org.opendaylight.controller.md.sal.dom.api.DOMRpcProviderService;
  25 import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
  26 import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
  27 import org.opendaylight.controller.md.sal.dom.spi.AbstractDOMRpcImplementationRegistration;
  28 import org.opendaylight.controller.sal.core.compat.LegacyDOMRpcResultFutureAdapter;
  29 import org.opendaylight.controller.sal.core.compat.MdsalDOMRpcResultFutureAdapter;
  30 import org.opendaylight.controller.sal.core.compat.RpcAvailabilityListenerAdapter;
  31 import org.opendaylight.yangtools.concepts.AbstractListenerRegistration;
  32 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  33 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  34 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  35 import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
  36 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  37
  38 public final class DOMRpcRouter implements AutoCloseable, DOMRpcService, DOMRpcProviderService, SchemaContextListener {
  39     // This mapping is used to translate mdsal DOMRpcImplementations to their corresponding legacy
  40     // DOMRpcImplementations registered thru this interface when invoking a DOMRpcAvailabilityListener.
  41     private final Map<org.opendaylight.mdsal.dom.api.DOMRpcImplementation, DOMRpcImplementation> implMapping =
  42             Collections.synchronizedMap(new WeakHashMap<>());
  43
  44     private final org.opendaylight.mdsal.dom.api.DOMRpcService delegateRpcService;
  45     private final org.opendaylight.mdsal.dom.api.DOMRpcProviderService delegateRpcProviderService;
  46
  47     // Note - this is only used for backward compatibility for UTs that use the empty constructor which creates
  48     // a local mdsal DOMRpcRouter that needs to be updated with the SchemaContext. In production, the mdsal API
  49     // services are passed via the constructor and are set up externally with the SchemaContext.
  50     private final SchemaContextListener delegateSchemaContextListener;
  51
  52     @VisibleForTesting
  53     public DOMRpcRouter() {
  54         org.opendaylight.mdsal.dom.broker.DOMRpcRouter delegate = new org.opendaylight.mdsal.dom.broker.DOMRpcRouter();
  55         this.delegateRpcService = delegate.getRpcService();
  56         this.delegateRpcProviderService = delegate.getRpcProviderService();
  57         this.delegateSchemaContextListener = delegate;
  58     }
  59
  60     public DOMRpcRouter(final org.opendaylight.mdsal.dom.api.DOMRpcService delegateRpcService,
  61             final org.opendaylight.mdsal.dom.api.DOMRpcProviderService delegateRpcProviderService) {
  62         this.delegateRpcService = delegateRpcService;
  63         this.delegateRpcProviderService = delegateRpcProviderService;
  64         this.delegateSchemaContextListener = null;
  65     }
  66
  67     @Override
  68     public <T extends DOMRpcImplementation> DOMRpcImplementationRegistration<T> registerRpcImplementation(
  69             final T implementation, final DOMRpcIdentifier... rpcs) {
  70         return registerRpcImplementation(implementation, ImmutableSet.copyOf(rpcs));
  71     }
  72
  73     @Override
  74     public synchronized <T extends DOMRpcImplementation> DOMRpcImplementationRegistration<T> registerRpcImplementation(
  75             final T implementation, final Set<DOMRpcIdentifier> rpcs) {
  76         org.opendaylight.mdsal.dom.api.DOMRpcImplementation delegateImpl =
  77             new org.opendaylight.mdsal.dom.api.DOMRpcImplementation() {
  78                 @Override
  79                 public FluentFuture<org.opendaylight.mdsal.dom.api.DOMRpcResult> invokeRpc(
  80                         final org.opendaylight.mdsal.dom.api.DOMRpcIdentifier rpc, final NormalizedNode<?, ?> input) {
  81                     return new MdsalDOMRpcResultFutureAdapter(implementation.invokeRpc(convert(rpc), input));
  82                 }
  83
  84                 @Override
  85                 public long invocationCost() {
  86                     return implementation.invocationCost();
  87                 }
  88             };
  89
  90         implMapping.put(delegateImpl, implementation);
  91
  92         final org.opendaylight.mdsal.dom.api.DOMRpcImplementationRegistration
  93             <org.opendaylight.mdsal.dom.api.DOMRpcImplementation> reg = delegateRpcProviderService
  94                 .registerRpcImplementation(delegateImpl,
  95                         rpcs.stream().map(DOMRpcRouter::convert).collect(Collectors.toSet()));
  96
  97         return new AbstractDOMRpcImplementationRegistration<T>(implementation) {
  98             @Override
  99             protected void removeRegistration() {
 100                 reg.close();
 101                 implMapping.remove(delegateImpl);
 102             }
 103         };
 104     }
 105
 106     private static org.opendaylight.mdsal.dom.api.DOMRpcIdentifier convert(final DOMRpcIdentifier from) {
 107         return org.opendaylight.mdsal.dom.api.DOMRpcIdentifier.create(from.getType(), from.getContextReference());
 108     }
 109
 110     private static DOMRpcIdentifier convert(final org.opendaylight.mdsal.dom.api.DOMRpcIdentifier from) {
 111         return DOMRpcIdentifier.create(from.getType(), from.getContextReference());
 112     }
 113
 114     @Override
 115     public CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(final SchemaPath type,
 116                                                                   final NormalizedNode<?, ?> input) {
 117         final FluentFuture<org.opendaylight.mdsal.dom.api.DOMRpcResult> future =
 118                 delegateRpcService.invokeRpc(type, input);
 119         return future instanceof MdsalDOMRpcResultFutureAdapter ? ((MdsalDOMRpcResultFutureAdapter)future).delegate()
 120                 : new LegacyDOMRpcResultFutureAdapter(future);
 121     }
 122
 123     @Override
 124     public synchronized <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(
 125             final T listener) {
 126         final ListenerRegistration<org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener> reg =
 127             delegateRpcService.registerRpcListener(new RpcAvailabilityListenerAdapter<T>(listener) {
 128                 @Override
 129                 public boolean acceptsImplementation(final org.opendaylight.mdsal.dom.api.DOMRpcImplementation impl) {
 130                     // If the DOMRpcImplementation wasn't registered thru this interface then the mapping won't be
 131                     // present - in this we can't call the listener so just assume acceptance which is the default
 132                     // behavior. This should be fine since a legacy listener would not be aware of implementation types
 133                     // registered via the new mdsal API.
 134                     final DOMRpcImplementation legacyImpl = implMapping.get(impl);
 135                     return legacyImpl != null ? delegate().acceptsImplementation(legacyImpl) : true;
 136                 }
 137             });
 138
 139         return new AbstractListenerRegistration<T>(listener) {
 140             @Override
 141             protected void removeRegistration() {
 142                 reg.close();
 143             }
 144         };
 145     }
 146
 147     @Override
 148     public void close() {
 149     }
 150
 151     @Override
 152     @VisibleForTesting
 153     public void onGlobalContextUpdated(final SchemaContext context) {
 154         if (delegateSchemaContextListener != null) {
 155             delegateSchemaContextListener.onGlobalContextUpdated(context);
 156         }
 157     }
 158 }