X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-dom-broker%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fsal%2Fdom%2Fbroker%2FBrokerImpl.java;h=581a2f9cf8a2edf3dd9e092668915302b8410397;hp=e4bd0343cfcf62999d3becca52177eaf8d366bcd;hb=4ef15f7a7e3fb5bcaa6a3202d268a5c945e0aa71;hpb=da4cff5c3a5bc732fb046b563b886a7aaab67c30 diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/BrokerImpl.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/BrokerImpl.java index e4bd0343cf..581a2f9cf8 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/BrokerImpl.java +++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/BrokerImpl.java @@ -7,35 +7,38 @@ */ package org.opendaylight.controller.sal.dom.broker; +import com.google.common.base.Optional; import com.google.common.base.Preconditions; -import com.google.common.util.concurrent.ListenableFuture; - +import com.google.common.collect.ClassToInstanceMap; +import com.google.common.collect.ImmutableClassToInstanceMap; +import com.google.common.util.concurrent.CheckedFuture; import java.util.Collections; import java.util.HashSet; import java.util.Set; -import java.util.concurrent.Future; - -import org.opendaylight.controller.md.sal.common.api.routing.RouteChangeListener; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import org.opendaylight.controller.md.sal.dom.api.DOMRpcAvailabilityListener; +import org.opendaylight.controller.md.sal.dom.api.DOMRpcException; +import org.opendaylight.controller.md.sal.dom.api.DOMRpcIdentifier; +import org.opendaylight.controller.md.sal.dom.api.DOMRpcImplementation; +import org.opendaylight.controller.md.sal.dom.api.DOMRpcImplementationRegistration; +import org.opendaylight.controller.md.sal.dom.api.DOMRpcProviderService; +import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult; +import org.opendaylight.controller.md.sal.dom.api.DOMRpcService; +import org.opendaylight.controller.md.sal.dom.broker.impl.DOMRpcRouter; import org.opendaylight.controller.sal.core.api.Broker; +import org.opendaylight.controller.sal.core.api.BrokerService; import org.opendaylight.controller.sal.core.api.Consumer; import org.opendaylight.controller.sal.core.api.Provider; import org.opendaylight.yangtools.concepts.ListenerRegistration; -import org.opendaylight.yangtools.yang.common.QName; -import org.opendaylight.yangtools.yang.common.RpcResult; -import org.opendaylight.yangtools.yang.data.api.CompositeNode; +import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; import org.osgi.framework.BundleContext; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import org.opendaylight.controller.sal.dom.broker.spi.RpcRouter; -import org.opendaylight.controller.sal.core.api.RpcRegistrationListener; -import org.opendaylight.controller.sal.core.api.RpcProvisionRegistry; -import org.opendaylight.controller.sal.core.api.RpcImplementation; -import org.opendaylight.controller.sal.core.api.RpcRoutingContext; -import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier; -import org.opendaylight.controller.sal.core.api.RoutedRpcDefaultImplementation; -public class BrokerImpl implements Broker, RpcProvisionRegistry, AutoCloseable { - private final static Logger log = LoggerFactory.getLogger(BrokerImpl.class); +public class BrokerImpl implements Broker, DOMRpcProviderService, DOMRpcService, AutoCloseable { + private static final Logger LOG = LoggerFactory.getLogger(BrokerImpl.class); // Broker Generic Context private final Set sessions = Collections @@ -43,18 +46,35 @@ public class BrokerImpl implements Broker, RpcProvisionRegistry, AutoCloseable { private final Set providerSessions = Collections .synchronizedSet(new HashSet()); - private BundleContext bundleContext = null; + private AutoCloseable deactivator; + + private final DOMRpcService rpcService; + private final DOMRpcProviderService rpcProvider; + + private final ClassToInstanceMap services; - private AutoCloseable deactivator = null; + public BrokerImpl(final DOMRpcRouter router,final ClassToInstanceMap services) { + this(router, router, services); + } - private RpcRouter router = null; + public BrokerImpl(final DOMRpcService rpcService, final DOMRpcProviderService rpcProvider, + final ClassToInstanceMap services) { + this.rpcService = Preconditions.checkNotNull(rpcService, "DOMRpcService must not be null"); + this.rpcProvider = Preconditions.checkNotNull(rpcProvider, "DOMRpcProviderService must not be null"); + this.services = ImmutableClassToInstanceMap.copyOf(services); + } @Override public ConsumerSession registerConsumer(final Consumer consumer, final BundleContext ctx) { + return registerConsumer(consumer); + } + + @Override + public ConsumerSession registerConsumer(final Consumer consumer) { checkPredicates(consumer); - log.trace("Registering consumer {}", consumer); - final ConsumerContextImpl session = newSessionFor(consumer, ctx); + LOG.trace("Registering consumer {}", consumer); + final ConsumerContextImpl session = newSessionFor(consumer); consumer.onSessionInitiated(session); sessions.add(session); return session; @@ -63,48 +83,50 @@ public class BrokerImpl implements Broker, RpcProvisionRegistry, AutoCloseable { @Override public ProviderSession registerProvider(final Provider provider, final BundleContext ctx) { + return registerProvider(provider); + } + + @Override + public ProviderSession registerProvider(final Provider provider) { checkPredicates(provider); - final ProviderContextImpl session = newSessionFor(provider, ctx); + final ProviderContextImpl session = newSessionFor(provider); provider.onSessionInitiated(session); providerSessions.add(session); return session; } - protected Future> invokeRpcAsync(final QName rpc, - final CompositeNode input) { - return router.invokeRpc(rpc, input); - } - // Validation private void checkPredicates(final Provider prov) { Preconditions.checkNotNull(prov, "Provider should not be null."); - for (ProviderContextImpl session : providerSessions) { - if (prov.equals(session.getProvider())) - throw new IllegalStateException("Provider already registered"); + synchronized (providerSessions) { + for (final ProviderContextImpl session : providerSessions) { + if (prov.equals(session.getProvider())) { + throw new IllegalStateException("Provider already registered"); + } + } } } private void checkPredicates(final Consumer cons) { Preconditions.checkNotNull(cons, "Consumer should not be null."); - for (ConsumerContextImpl session : sessions) { - if (cons.equals(session.getConsumer())) - throw new IllegalStateException("Consumer already registered"); + synchronized (sessions) { + for (final ConsumerContextImpl session : sessions) { + if (cons.equals(session.getConsumer())) { + throw new IllegalStateException("Consumer already registered"); + } + } } } // Private Factory methods - private ConsumerContextImpl newSessionFor(final Consumer provider, - final BundleContext ctx) { - ConsumerContextImpl ret = new ConsumerContextImpl(provider, ctx); - ret.setBroker(this); + private ConsumerContextImpl newSessionFor(final Consumer provider) { + final ConsumerContextImpl ret = new ConsumerContextImpl(provider, this); return ret; } - private ProviderContextImpl newSessionFor(final Provider provider, - final BundleContext ctx) { - ProviderContextImpl ret = new ProviderContextImpl(provider, ctx); - ret.setBroker(this); + private ProviderContextImpl newSessionFor(final Provider provider) { + final ProviderContextImpl ret = new ProviderContextImpl(provider, this); return ret; } @@ -122,64 +144,9 @@ public class BrokerImpl implements Broker, RpcProvisionRegistry, AutoCloseable { } } - @Override - public RpcRegistration addRpcImplementation(final QName rpcType, - final RpcImplementation implementation) - throws IllegalArgumentException { - return router.addRpcImplementation(rpcType, implementation); - } - - @Override - public RoutedRpcRegistration addRoutedRpcImplementation( - final QName rpcType, final RpcImplementation implementation) { - return router.addRoutedRpcImplementation(rpcType, implementation); - } - - @Override - public void setRoutedRpcDefaultDelegate( - final RoutedRpcDefaultImplementation defaultImplementation) { - router.setRoutedRpcDefaultDelegate(defaultImplementation); - } - - @Override - public ListenerRegistration addRpcRegistrationListener( - final RpcRegistrationListener listener) { - return router.addRpcRegistrationListener(listener); - } - - @Override - public > ListenerRegistration registerRouteChangeListener( - final L listener) { - return router.registerRouteChangeListener(listener); - } - - @Override - public Set getSupportedRpcs() { - return router.getSupportedRpcs(); - } - - @Override - public ListenableFuture> invokeRpc( - final QName rpc, final CompositeNode input) { - return router.invokeRpc(rpc, input); - } - - /** - * @return the bundleContext - */ - public BundleContext getBundleContext() { - return bundleContext; - } - - /** - * @param bundleContext - * the bundleContext to set - */ - public void setBundleContext(final BundleContext bundleContext) { - this.bundleContext = bundleContext; - } - /** + * Gets deactivator. + * * @return the deactivator */ public AutoCloseable getDeactivator() { @@ -187,6 +154,8 @@ public class BrokerImpl implements Broker, RpcProvisionRegistry, AutoCloseable { } /** + * Sets deactivator. + * * @param deactivator * the deactivator to set */ @@ -194,18 +163,35 @@ public class BrokerImpl implements Broker, RpcProvisionRegistry, AutoCloseable { this.deactivator = deactivator; } - /** - * @return the router - */ - public RpcRouter getRouter() { - return router; + protected Optional getGlobalService(final Class service) { + return Optional.fromNullable(services.getInstance(service)); } - /** - * @param router - * the router to set - */ - public void setRouter(final RpcRouter router) { - this.router = router; + @Nonnull + @Override + public DOMRpcImplementationRegistration registerRpcImplementation( + @Nonnull final T implementation, @Nonnull final DOMRpcIdentifier... rpcs) { + return rpcProvider.registerRpcImplementation(implementation, rpcs); + } + + @Nonnull + @Override + public DOMRpcImplementationRegistration registerRpcImplementation( + @Nonnull final T implementation, @Nonnull final Set rpcs) { + return rpcProvider.registerRpcImplementation(implementation, rpcs); + } + + @Nonnull + @Override + public CheckedFuture invokeRpc(@Nonnull final SchemaPath type, + @Nullable final NormalizedNode input) { + return rpcService.invokeRpc(type, input); + } + + @Nonnull + @Override + public ListenerRegistration registerRpcListener( + @Nonnull final T listener) { + return rpcService.registerRpcListener(listener); } }