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