opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/connect/dom/DomToBindingRpcForwardingManager.java

   1 package org.opendaylight.controller.sal.binding.impl.connect.dom;
   2
   3 import com.google.common.base.Optional;
   4 import java.util.Map;
   5 import java.util.Map.Entry;
   6 import java.util.Set;
   7 import java.util.WeakHashMap;
   8 import org.opendaylight.controller.md.sal.common.api.routing.RouteChange;
   9 import org.opendaylight.controller.md.sal.common.api.routing.RouteChangeListener;
  10 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
  11 import org.opendaylight.controller.sal.binding.api.rpc.RpcContextIdentifier;
  12 import org.opendaylight.controller.sal.binding.api.rpc.RpcRouter;
  13 import org.opendaylight.controller.sal.binding.impl.RpcProviderRegistryImpl;
  14 import org.opendaylight.controller.sal.core.api.RpcProvisionRegistry;
  15 import org.opendaylight.controller.sal.core.api.RpcRegistrationListener;
  16 import org.opendaylight.yangtools.yang.binding.BaseIdentity;
  17 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  18 import org.opendaylight.yangtools.yang.binding.RpcService;
  19 import org.opendaylight.yangtools.yang.common.QName;
  20 import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService;
  21
  22 /**
  23  * Manager responsible for instantiating forwarders responsible for
  24  * forwarding of RPC invocations from DOM Broker to Binding Aware Broker
  25  *
  26  */
  27 class DomToBindingRpcForwardingManager implements
  28     RouteChangeListener<RpcContextIdentifier, InstanceIdentifier<?>>,
  29     RpcProviderRegistryImpl.RouterInstantiationListener,
  30     RpcProviderRegistryImpl.GlobalRpcRegistrationListener, RpcRegistrationListener {
  31
  32     private final Map<Class<? extends RpcService>, DomToBindingRpcForwarder> forwarders = new WeakHashMap<>();
  33     private final BindingIndependentMappingService mappingService;
  34     private final RpcProvisionRegistry biRpcRegistry;
  35     private final RpcProviderRegistry baRpcRegistry;
  36     private RpcProviderRegistryImpl registryImpl;
  37
  38     DomToBindingRpcForwardingManager(final BindingIndependentMappingService mappingService, final RpcProvisionRegistry biRpcRegistry,
  39         final RpcProviderRegistry baRpcRegistry) {
  40         this.mappingService = mappingService;
  41         this.biRpcRegistry = biRpcRegistry;
  42         this.baRpcRegistry = baRpcRegistry;
  43     }
  44
  45     public RpcProviderRegistryImpl getRegistryImpl() {
  46         return registryImpl;
  47     }
  48
  49     public void setRegistryImpl(final RpcProviderRegistryImpl registryImpl) {
  50         this.registryImpl = registryImpl;
  51     }
  52
  53     @Override
  54     public void onGlobalRpcRegistered(final Class<? extends RpcService> cls) {
  55         getRpcForwarder(cls, null).registerToDOMBroker();
  56     }
  57
  58     @Override
  59     public void onGlobalRpcUnregistered(final Class<? extends RpcService> cls) {
  60         // NOOP
  61     }
  62
  63     @Override
  64     public void onRpcRouterCreated(final RpcRouter<?> router) {
  65         Class<? extends BaseIdentity> ctx = router.getContexts().iterator().next();
  66         getRpcForwarder(router.getServiceType(), ctx);
  67     }
  68
  69     @Override
  70     public void onRouteChange(final RouteChange<RpcContextIdentifier, InstanceIdentifier<?>> change) {
  71         // Process removals first
  72         for (Entry<RpcContextIdentifier, Set<InstanceIdentifier<?>>> entry : change.getRemovals().entrySet()) {
  73             final Class<? extends BaseIdentity> context = entry.getKey().getRoutingContext();
  74             if (context != null) {
  75                 final Class<? extends RpcService> service = entry.getKey().getRpcService();
  76                 getRpcForwarder(service, context).removePaths(context, service, entry.getValue());
  77             }
  78         }
  79
  80         for (Entry<RpcContextIdentifier, Set<InstanceIdentifier<?>>> entry : change.getAnnouncements().entrySet()) {
  81             final Class<? extends BaseIdentity> context = entry.getKey().getRoutingContext();
  82             if (context != null) {
  83                 final Class<? extends RpcService> service = entry.getKey().getRpcService();
  84                 getRpcForwarder(service, context).registerPaths(context, service, entry.getValue());
  85             }
  86         }
  87     }
  88
  89     private DomToBindingRpcForwarder getRpcForwarder(final Class<? extends RpcService> service,
  90         final Class<? extends BaseIdentity> context) {
  91         DomToBindingRpcForwarder potential = forwarders.get(service);
  92         if (potential != null) {
  93             return potential;
  94         }
  95         if (context == null) {
  96             potential = new DomToBindingRpcForwarder(service, mappingService, biRpcRegistry, baRpcRegistry,registryImpl);
  97         } else {
  98             potential = new DomToBindingRpcForwarder(service, context, mappingService, biRpcRegistry, baRpcRegistry,registryImpl);
  99         }
 100
 101         forwarders.put(service, potential);
 102         return potential;
 103     }
 104
 105     @Override
 106     public void onRpcImplementationAdded(final QName name) {
 107
 108         final Optional<Class<? extends RpcService>> rpcInterface = mappingService.getRpcServiceClassFor(
 109             name.getNamespace().toString(), name.getFormattedRevision());
 110         if (rpcInterface.isPresent()) {
 111             getRpcForwarder(rpcInterface.get(), null).registerToBindingBroker();
 112         }
 113     }
 114
 115     @Override
 116     public void onRpcImplementationRemoved(final QName name) {
 117
 118     }
 119 }