X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-binding-broker%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fsal%2Fbinding%2Fimpl%2Fconnect%2Fdom%2FBindingIndependentConnector.java;h=fe8c4a151c1691495ea4e5f00bf443b77878d930;hp=d2472669fa39def5ae4862fb86be2fea5fa7b067;hb=b15ad095a13977fad81fabd266cb5d832164d3a7;hpb=81bbe76bd26399118d028663d08e464ce6b7d040 diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/connect/dom/BindingIndependentConnector.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/connect/dom/BindingIndependentConnector.java index d2472669fa..fe8c4a151c 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/connect/dom/BindingIndependentConnector.java +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/connect/dom/BindingIndependentConnector.java @@ -57,10 +57,14 @@ import org.opendaylight.controller.sal.core.api.Broker.RoutedRpcRegistration; import org.opendaylight.controller.sal.core.api.Provider; import org.opendaylight.controller.sal.core.api.RpcImplementation; import org.opendaylight.controller.sal.core.api.RpcProvisionRegistry; +import org.opendaylight.controller.sal.core.api.RpcRegistrationListener; import org.opendaylight.controller.sal.core.api.data.DataModificationTransaction; import org.opendaylight.controller.sal.core.api.notify.NotificationListener; import org.opendaylight.controller.sal.core.api.notify.NotificationPublishService; +import org.opendaylight.yangtools.concepts.CompositeObjectRegistration; +import org.opendaylight.yangtools.concepts.CompositeObjectRegistration.CompositeObjectRegistrationBuilder; import org.opendaylight.yangtools.concepts.ListenerRegistration; +import org.opendaylight.yangtools.concepts.ObjectRegistration; import org.opendaylight.yangtools.concepts.Registration; import org.opendaylight.yangtools.yang.binding.Augmentable; import org.opendaylight.yangtools.yang.binding.Augmentation; @@ -83,6 +87,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.google.common.base.Function; +import com.google.common.base.Optional; import com.google.common.collect.FluentIterable; import com.google.common.collect.ImmutableSet; import com.google.common.collect.ImmutableSet.Builder; @@ -321,7 +326,10 @@ public class BindingIndependentConnector implements // public void startRpcForwarding() { if (biRpcRegistry != null && baRpcRegistry instanceof RouteChangePublisher) { checkState(!rpcForwarding, "Connector is already forwarding RPCs"); - domToBindingRpcManager = baRpcRegistry.registerRouteChangeListener(new DomToBindingRpcForwardingManager()); + final DomToBindingRpcForwardingManager biFwdManager = new DomToBindingRpcForwardingManager(); + + domToBindingRpcManager = baRpcRegistry.registerRouteChangeListener(biFwdManager); + biRpcRegistry.addRpcRegistrationListener(biFwdManager); if (baRpcRegistry instanceof RpcProviderRegistryImpl) { baRpcRegistryImpl = (RpcProviderRegistryImpl) baRpcRegistry; baRpcRegistryImpl.registerRouterInstantiationListener(domToBindingRpcManager.getInstance()); @@ -486,7 +494,7 @@ public class BindingIndependentConnector implements // public void onRegister( final DataCommitHandlerRegistration, DataObject> registration) { - org.opendaylight.yangtools.yang.data.api.InstanceIdentifier domPath = mappingService.toDataDom(registration + mappingService.toDataDom(registration .getPath()); } @@ -528,7 +536,7 @@ public class BindingIndependentConnector implements // */ private class DomToBindingRpcForwardingManager implements RouteChangeListener>, RouterInstantiationListener, - GlobalRpcRegistrationListener { + GlobalRpcRegistrationListener, RpcRegistrationListener { private final Map, DomToBindingRpcForwarder> forwarders = new WeakHashMap<>(); private RpcProviderRegistryImpl registryImpl; @@ -543,7 +551,7 @@ public class BindingIndependentConnector implements // @Override public void onGlobalRpcRegistered(final Class cls) { - getRpcForwarder(cls, null); + getRpcForwarder(cls, null).registerToDOMBroker(); } @Override @@ -588,31 +596,40 @@ public class BindingIndependentConnector implements // return potential; } + @Override + public void onRpcImplementationAdded(final QName name) { + + final Optional> rpcInterface = mappingService.getRpcServiceClassFor( + name.getNamespace().toString(), name.getFormattedRevision()); + if (rpcInterface.isPresent()) { + getRpcForwarder(rpcInterface.get(), null).registerToBidningBroker(); + } + } + + @Override + public void onRpcImplementationRemoved(final QName name) { + + } } private class DomToBindingRpcForwarder implements RpcImplementation, InvocationHandler { private final Set supportedRpcs; private final WeakReference> rpcServiceType; - private final Set registrations; + private Set registrations; private final Map strategiesByQName = new HashMap<>(); private final WeakHashMap strategiesByMethod = new WeakHashMap<>(); + private final RpcService proxy; + private ObjectRegistration forwarderRegistration; public DomToBindingRpcForwarder(final Class service) { this.rpcServiceType = new WeakReference>(service); this.supportedRpcs = mappingService.getRpcQNamesFor(service); - try { - for (QName rpc : supportedRpcs) { - RpcInvocationStrategy strategy = createInvocationStrategy(rpc, service); - strategiesByMethod.put(strategy.targetMethod, strategy); - strategiesByQName.put(rpc, strategy); - biRpcRegistry.addRpcImplementation(rpc, this); - } - } catch (Exception e) { - LOG.error("Could not forward Rpcs of type {}", service.getName(), e); - } - registrations = ImmutableSet.of(); + Class cls = rpcServiceType.get(); + ClassLoader clsLoader = cls.getClassLoader(); + proxy =(RpcService) Proxy.newProxyInstance(clsLoader, new Class[] { cls }, this); + createStrategies(); } /** @@ -622,16 +639,12 @@ public class BindingIndependentConnector implements // * @param context */ public DomToBindingRpcForwarder(final Class service, - final Class context) { - this.rpcServiceType = new WeakReference>(service); - this.supportedRpcs = mappingService.getRpcQNamesFor(service); + final Class context) { + this(service); Builder registrationsBuilder = ImmutableSet . builder(); try { for (QName rpc : supportedRpcs) { - RpcInvocationStrategy strategy = createInvocationStrategy(rpc, service); - strategiesByMethod.put(strategy.targetMethod, strategy); - strategiesByQName.put(rpc, strategy); registrationsBuilder.add(biRpcRegistry.addRoutedRpcImplementation(rpc, this)); } createDefaultDomForwarder(); @@ -641,6 +654,46 @@ public class BindingIndependentConnector implements // registrations = registrationsBuilder.build(); } + + + private void createStrategies() { + try { + for (QName rpc : supportedRpcs) { + RpcInvocationStrategy strategy = createInvocationStrategy(rpc, rpcServiceType.get()); + strategiesByMethod.put(strategy.targetMethod, strategy); + strategiesByQName.put(rpc, strategy); + } + } catch (Exception e) { + LOG.error("Could not forward Rpcs of type {}", rpcServiceType.get(), e); + } + + } + + /** + * Registers RPC Forwarder to DOM Broker, + * this means Binding Aware Broker has implementation of RPC + * which is registered to it. + * + * If RPC Forwarder was previously registered to DOM Broker + * or to Bidning Broker this method is noop to prevent + * creating forwarding loop. + * + */ + public void registerToDOMBroker() { + if(forwarderRegistration == null) { + CompositeObjectRegistrationBuilder builder = CompositeObjectRegistration.builderFor(this); + try { + for (QName rpc : supportedRpcs) { + builder.add(biRpcRegistry.addRpcImplementation(rpc, this)); + } + } catch (Exception e) { + LOG.error("Could not forward Rpcs of type {}", rpcServiceType.get(), e); + } + this.forwarderRegistration = builder.toInstance(); + } + } + + public void registerPaths(final Class context, final Class service, final Set> set) { QName ctx = BindingReflections.findQName(context); @@ -737,6 +790,26 @@ public class BindingIndependentConnector implements // }); } + + /** + * Registers RPC Forwarder to Binding Broker, + * this means DOM Broekr has implementation of RPC + * which is registered to it. + * + * If RPC Forwarder was previously registered to DOM Broker + * or to Bidning Broker this method is noop to prevent + * creating forwarding loop. + * + */ + public void registerToBidningBroker() { + if(forwarderRegistration == null) { + try { + this.forwarderRegistration = baRpcRegistry.addRpcImplementation((Class)rpcServiceType.get(), proxy); + } catch (Exception e) { + LOG.error("Unable to forward RPCs for {}",rpcServiceType.get(),e); + } + } + } } public boolean isRpcForwarding() {