From: Tony Tkacik Date: Mon, 30 Jun 2014 17:57:35 +0000 (+0200) Subject: Bug 488: Removed requirement for DOM providers to supply BundleContext. X-Git-Tag: release/helium~565^2 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=commitdiff_plain;h=1f6daaf007e78df276604baa4c515a50037a649d Bug 488: Removed requirement for DOM providers to supply BundleContext. Change-Id: I7a3a852dbe1dc9a48398943fc89b542e663531bc Signed-off-by: Tony Tkacik --- diff --git a/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/sal/binding/test/util/BindingTestContext.java b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/sal/binding/test/util/BindingTestContext.java index 623b2fdd63..1ea56381ef 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/sal/binding/test/util/BindingTestContext.java +++ b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/sal/binding/test/util/BindingTestContext.java @@ -66,6 +66,7 @@ import com.google.common.base.Predicate; import com.google.common.collect.ClassToInstanceMap; import com.google.common.collect.ImmutableClassToInstanceMap; import com.google.common.collect.ImmutableMap; +import com.google.common.collect.MutableClassToInstanceMap; import com.google.common.util.concurrent.ListeningExecutorService; public class BindingTestContext implements AutoCloseable { @@ -160,11 +161,10 @@ public class BindingTestContext implements AutoCloseable { newDOMDataBroker = new DOMDataBrokerImpl(newDatastores, executor); - biCompatibleBroker = new BackwardsCompatibleDataBroker(newDOMDataBroker); + biCompatibleBroker = new BackwardsCompatibleDataBroker(newDOMDataBroker,mockSchemaService); mockSchemaService.registerSchemaServiceListener(configStore); mockSchemaService.registerSchemaServiceListener(operStore); - mockSchemaService.registerSchemaServiceListener(biCompatibleBroker); biDataLegacyBroker = biCompatibleBroker; } @@ -338,8 +338,10 @@ public class BindingTestContext implements AutoCloseable { private void startDomBroker() { checkState(executor != null); - biBrokerImpl = new BrokerImpl(); - biBrokerImpl.setRouter(new SchemaAwareRpcBroker("/", mockSchemaService)); + + SchemaAwareRpcBroker router = new SchemaAwareRpcBroker("/", mockSchemaService); + ClassToInstanceMap services = MutableClassToInstanceMap.create(); + biBrokerImpl = new BrokerImpl(router,services); } diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/dom/impl/DomBrokerImplModule.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/dom/impl/DomBrokerImplModule.java index 767785dbf1..998d884b0c 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/dom/impl/DomBrokerImplModule.java +++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/dom/impl/DomBrokerImplModule.java @@ -8,10 +8,26 @@ package org.opendaylight.controller.config.yang.md.sal.dom.impl; import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker; +import org.opendaylight.controller.md.sal.dom.broker.impl.compat.BackwardsCompatibleDataBroker; +import org.opendaylight.controller.sal.core.api.BrokerService; +import org.opendaylight.controller.sal.core.api.RpcProvisionRegistry; +import org.opendaylight.controller.sal.core.api.data.DataBrokerService; +import org.opendaylight.controller.sal.core.api.data.DataProviderService; import org.opendaylight.controller.sal.core.api.data.DataStore; -import org.opendaylight.controller.sal.dom.broker.BrokerConfigActivator; +import org.opendaylight.controller.sal.core.api.model.SchemaService; +import org.opendaylight.controller.sal.core.api.mount.MountProvisionService; +import org.opendaylight.controller.sal.core.api.mount.MountService; import org.opendaylight.controller.sal.dom.broker.BrokerImpl; -import org.osgi.framework.BundleContext; +import org.opendaylight.controller.sal.dom.broker.DataBrokerImpl; +import org.opendaylight.controller.sal.dom.broker.GlobalBundleScanningSchemaServiceImpl; +import org.opendaylight.controller.sal.dom.broker.MountPointManagerImpl; +import org.opendaylight.controller.sal.dom.broker.impl.SchemaAwareDataStoreAdapter; +import org.opendaylight.controller.sal.dom.broker.impl.SchemaAwareRpcBroker; +import org.opendaylight.controller.sal.dom.broker.impl.SchemaContextProviders; +import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier; + +import com.google.common.collect.ClassToInstanceMap; +import com.google.common.collect.MutableClassToInstanceMap; /** * @@ -19,8 +35,6 @@ import org.osgi.framework.BundleContext; public final class DomBrokerImplModule extends org.opendaylight.controller.config.yang.md.sal.dom.impl.AbstractDomBrokerImplModule { - private BundleContext bundleContext; - public DomBrokerImplModule(final org.opendaylight.controller.config.api.ModuleIdentifier identifier, final org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) { super(identifier, dependencyResolver); } @@ -36,23 +50,58 @@ public final class DomBrokerImplModule extends org.opendaylight.controller.confi @Override public java.lang.AutoCloseable createInstance() { - final BrokerImpl broker = new BrokerImpl(); - final BrokerConfigActivator activator = new BrokerConfigActivator(); - final DataStore store = getDataStoreDependency(); + final DataStore legacyStore = getDataStoreDependency(); final DOMDataBroker asyncBroker= getAsyncDataBrokerDependency(); - activator.start(broker, store, asyncBroker,getBundleContext()); + ClassToInstanceMap services = MutableClassToInstanceMap.create(); + + + SchemaService schemaService = getSchemaServiceImpl(); + services.putInstance(SchemaService.class, schemaService); + SchemaAwareRpcBroker router = new SchemaAwareRpcBroker("/", SchemaContextProviders + .fromSchemaService(schemaService)); + services.putInstance(RpcProvisionRegistry.class, router); + + final DataProviderService legacyData; + if(asyncBroker != null) { + services.putInstance(DOMDataBroker.class, asyncBroker); + legacyData = new BackwardsCompatibleDataBroker(asyncBroker,schemaService); + } else { + legacyData = createLegacyDataService(legacyStore,schemaService); + } + services.putInstance(DataProviderService.class,legacyData); + services.putInstance(DataBrokerService.class, legacyData); -// final DomBrokerImplRuntimeMXBean domBrokerRuntimeMXBean = new DomBrokerRuntimeMXBeanImpl(activator.getDataService()); -// getRootRuntimeBeanRegistratorWrapper().register(domBrokerRuntimeMXBean); - return broker; + + MountPointManagerImpl mountService = new MountPointManagerImpl(); + services.putInstance(MountService.class, mountService); + services.putInstance(MountProvisionService.class, mountService); + + return new BrokerImpl(router, services); } - private BundleContext getBundleContext() { - return this.bundleContext; + private DataProviderService createLegacyDataService(final DataStore legacyStore, final SchemaService schemaService) { + InstanceIdentifier rootPath = InstanceIdentifier.builder().toInstance(); + DataBrokerImpl dataService = new DataBrokerImpl(); + SchemaAwareDataStoreAdapter wrappedStore = new SchemaAwareDataStoreAdapter(); + wrappedStore.changeDelegate(legacyStore); + wrappedStore.setValidationEnabled(false); + + schemaService.registerSchemaServiceListener(wrappedStore); + + dataService.registerConfigurationReader(rootPath, wrappedStore); + dataService.registerCommitHandler(rootPath, wrappedStore); + dataService.registerOperationalReader(rootPath, wrappedStore); + return dataService; } - public void setBundleContext(final BundleContext bundleContext) { - this.bundleContext = bundleContext; + private SchemaService getSchemaServiceImpl() { + final SchemaService schemaService; + if(getRootSchemaService() != null) { + schemaService = getRootSchemaServiceDependency(); + } else { + schemaService = GlobalBundleScanningSchemaServiceImpl.getInstance(); + } + return schemaService; } } diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/dom/impl/DomBrokerImplModuleFactory.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/dom/impl/DomBrokerImplModuleFactory.java index 38f5009feb..f1fcb495aa 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/dom/impl/DomBrokerImplModuleFactory.java +++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/dom/impl/DomBrokerImplModuleFactory.java @@ -7,10 +7,6 @@ */ package org.opendaylight.controller.config.yang.md.sal.dom.impl; -import org.opendaylight.controller.config.api.DependencyResolver; -import org.opendaylight.controller.config.api.DynamicMBeanWithInstance; -import org.opendaylight.controller.config.spi.Module; -import org.osgi.framework.BundleContext; /** * @@ -18,19 +14,4 @@ import org.osgi.framework.BundleContext; public class DomBrokerImplModuleFactory extends org.opendaylight.controller.config.yang.md.sal.dom.impl.AbstractDomBrokerImplModuleFactory { - @Override - public Module createModule(String instanceName, DependencyResolver dependencyResolver, BundleContext bundleContext) { - DomBrokerImplModule module = (DomBrokerImplModule) super.createModule(instanceName, dependencyResolver, bundleContext); - module.setBundleContext(bundleContext); - return module; - } - - @Override - public Module createModule(String instanceName, DependencyResolver dependencyResolver, - DynamicMBeanWithInstance old, BundleContext bundleContext) throws Exception { - DomBrokerImplModule module = (DomBrokerImplModule) super.createModule(instanceName, dependencyResolver, old, bundleContext); - module.setBundleContext(bundleContext); - return module; - } - } diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/dom/impl/SchemaServiceImplSingletonModule.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/dom/impl/SchemaServiceImplSingletonModule.java index fd24944018..fbc418dc2a 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/dom/impl/SchemaServiceImplSingletonModule.java +++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/dom/impl/SchemaServiceImplSingletonModule.java @@ -15,7 +15,6 @@ import org.opendaylight.yangtools.yang.model.api.Module; import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.opendaylight.yangtools.yang.model.api.SchemaServiceListener; import org.osgi.framework.BundleContext; -import org.osgi.framework.ServiceReference; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -57,43 +56,21 @@ org.opendaylight.controller.config.yang.md.sal.dom.impl.AbstractSchemaServiceImp @Override public java.lang.AutoCloseable createInstance() { - ServiceReference ref = getBundleContext().getServiceReference(SchemaService.class); - if (ref != null) { - return new GlobalSchemaServiceProxy(getBundleContext(), ref); - } - - GlobalBundleScanningSchemaServiceImpl newInstance = new GlobalBundleScanningSchemaServiceImpl(getBundleContext()); - newInstance.start(); - return newInstance; + return GlobalBundleScanningSchemaServiceImpl.getInstance(); } public class GlobalSchemaServiceProxy implements AutoCloseable, SchemaService, Delegator { - private BundleContext bundleContext; - private ServiceReference reference; private SchemaService delegate; - public GlobalSchemaServiceProxy(final BundleContext bundleContext, final ServiceReference ref) { - this.bundleContext = bundleContext; - this.reference = ref; - this.delegate = bundleContext.getService(reference); + public GlobalSchemaServiceProxy() { + this.delegate = GlobalBundleScanningSchemaServiceImpl.getInstance(); } @Override public void close() throws Exception { if (delegate != null) { delegate = null; - - try { - bundleContext.ungetService(reference); - } catch (IllegalStateException e) { - // Indicates the service was already unregistered which can happen normally - // on shutdown. - LOG.debug( "Error unregistering service", e ); - } - - reference = null; - bundleContext = null; } } diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/compat/BackwardsCompatibleDataBroker.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/compat/BackwardsCompatibleDataBroker.java index 5b34fba69a..f361af948c 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/compat/BackwardsCompatibleDataBroker.java +++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/compat/BackwardsCompatibleDataBroker.java @@ -1,5 +1,7 @@ package org.opendaylight.controller.md.sal.dom.broker.impl.compat; +import javax.annotation.concurrent.ThreadSafe; + import org.opendaylight.controller.md.sal.common.api.RegistrationListener; import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler; import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandlerRegistration; @@ -11,6 +13,7 @@ import org.opendaylight.controller.sal.core.api.data.DataChangeListener; import org.opendaylight.controller.sal.core.api.data.DataModificationTransaction; import org.opendaylight.controller.sal.core.api.data.DataProviderService; import org.opendaylight.controller.sal.core.api.data.DataValidator; +import org.opendaylight.controller.sal.core.api.model.SchemaService; import org.opendaylight.yangtools.concepts.AbstractObjectRegistration; import org.opendaylight.yangtools.concepts.ListenerRegistration; import org.opendaylight.yangtools.concepts.Registration; @@ -18,19 +21,18 @@ import org.opendaylight.yangtools.yang.data.api.CompositeNode; import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier; import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.opendaylight.yangtools.yang.model.api.SchemaContextListener; +import org.opendaylight.yangtools.yang.model.api.SchemaServiceListener; -public class BackwardsCompatibleDataBroker implements DataProviderService, SchemaContextListener { +@ThreadSafe +public class BackwardsCompatibleDataBroker implements DataProviderService { private final DOMDataBroker backingBroker; - private DataNormalizer normalizer; + private volatile DataNormalizer normalizer; + private final ListenerRegistration schemaReg; - public BackwardsCompatibleDataBroker(final DOMDataBroker newBiDataImpl) { + public BackwardsCompatibleDataBroker(final DOMDataBroker newBiDataImpl, final SchemaService schemaService) { backingBroker = newBiDataImpl; - } - - @Override - public void onGlobalContextUpdated(final SchemaContext ctx) { - normalizer = new DataNormalizer(ctx); + schemaReg = schemaService.registerSchemaServiceListener(new SchemaListener()); } @Override @@ -148,4 +150,13 @@ public class BackwardsCompatibleDataBroker implements DataProviderService, Schem return listener; } } + + private class SchemaListener implements SchemaContextListener { + + @Override + public void onGlobalContextUpdated(final SchemaContext ctx) { + normalizer = new DataNormalizer(ctx); + } + + } } diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/BrokerConfigActivator.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/BrokerConfigActivator.java deleted file mode 100644 index 3291afa061..0000000000 --- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/BrokerConfigActivator.java +++ /dev/null @@ -1,134 +0,0 @@ -/** - * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.controller.sal.dom.broker; - -import java.util.Hashtable; - -import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker; -import org.opendaylight.controller.md.sal.dom.broker.impl.compat.BackwardsCompatibleDataBroker; -import org.opendaylight.controller.sal.core.api.RpcProvisionRegistry; -import org.opendaylight.controller.sal.core.api.data.DataBrokerService; -import org.opendaylight.controller.sal.core.api.data.DataProviderService; -import org.opendaylight.controller.sal.core.api.data.DataStore; -import org.opendaylight.controller.sal.core.api.model.SchemaService; -import org.opendaylight.controller.sal.core.api.mount.MountProvisionService; -import org.opendaylight.controller.sal.core.api.mount.MountService; -import org.opendaylight.controller.sal.dom.broker.impl.SchemaAwareDataStoreAdapter; -import org.opendaylight.controller.sal.dom.broker.impl.SchemaAwareRpcBroker; -import org.opendaylight.controller.sal.dom.broker.impl.SchemaContextProviders; -import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier; -import org.opendaylight.yangtools.yang.model.api.SchemaServiceListener; -import org.osgi.framework.BundleContext; -import org.osgi.framework.ServiceReference; -import org.osgi.framework.ServiceRegistration; - -public class BrokerConfigActivator implements AutoCloseable { - - private static InstanceIdentifier ROOT = InstanceIdentifier.builder() - .toInstance(); - - private DataProviderService dataService; - - private ServiceRegistration dataReg = null; - private ServiceRegistration dataProviderReg = null; - private ServiceRegistration mountReg = null; - private ServiceRegistration mountProviderReg = null; - private SchemaService schemaService = null; - private ServiceRegistration rpcProvisionRegistryReg = null; - private MountPointManagerImpl mountService = null; - - private SchemaAwareDataStoreAdapter wrappedStore = null; - - public void start(final BrokerImpl broker, final DataStore store, - final DOMDataBroker asyncBroker, final BundleContext context) { - - final Hashtable emptyProperties = new Hashtable(); - broker.setBundleContext(context); - - final ServiceReference serviceRef = context - .getServiceReference(SchemaService.class); - schemaService = context. getService(serviceRef); - - broker.setRouter(new SchemaAwareRpcBroker("/", SchemaContextProviders - .fromSchemaService(schemaService))); - - if (asyncBroker == null) { - dataService = new DataBrokerImpl(); - dataProviderReg = context.registerService( - DataProviderService.class, dataService, emptyProperties); - - wrappedStore = new SchemaAwareDataStoreAdapter(); - wrappedStore.changeDelegate(store); - wrappedStore.setValidationEnabled(false); - context.registerService(SchemaServiceListener.class, wrappedStore, - emptyProperties); - - dataService.registerConfigurationReader(ROOT, wrappedStore); - dataService.registerCommitHandler(ROOT, wrappedStore); - dataService.registerOperationalReader(ROOT, wrappedStore); - } else { - BackwardsCompatibleDataBroker compatibleDataBroker = new BackwardsCompatibleDataBroker( - asyncBroker); - context.registerService(SchemaServiceListener.class, - compatibleDataBroker, emptyProperties); - dataService = compatibleDataBroker; - } - - mountService = new MountPointManagerImpl(); - dataReg = context.registerService(DataBrokerService.class, dataService, - emptyProperties); - mountReg = context.registerService(MountService.class, mountService, - emptyProperties); - mountProviderReg = context.registerService(MountProvisionService.class, - mountService, emptyProperties); - - rpcProvisionRegistryReg = context - .registerService(RpcProvisionRegistry.class, - broker.getRouter(), emptyProperties); - } - - @Override - public void close() { - - if (dataReg != null) { - dataReg.unregister(); - dataReg = null; - } - if (dataProviderReg != null) { - dataProviderReg.unregister(); - dataProviderReg = null; - } - if (mountReg != null) { - mountReg.unregister(); - mountReg = null; - } - if (mountProviderReg != null) { - mountProviderReg.unregister(); - mountProviderReg = null; - } - if (rpcProvisionRegistryReg != null) { - rpcProvisionRegistryReg.unregister(); - rpcProvisionRegistryReg = null; - } - } - - /** - * @return the dataService - */ - public DataProviderService getDataService() { - return dataService; - } - - /** - * @param dataService - * the dataService to set - */ - public void setDataService(final DataProviderService dataService) { - this.dataService = dataService; - } -} 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..1af03e5046 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,9 +7,6 @@ */ package org.opendaylight.controller.sal.dom.broker; -import com.google.common.base.Preconditions; -import com.google.common.util.concurrent.ListenableFuture; - import java.util.Collections; import java.util.HashSet; import java.util.Set; @@ -17,22 +14,29 @@ import java.util.concurrent.Future; import org.opendaylight.controller.md.sal.common.api.routing.RouteChangeListener; 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.controller.sal.core.api.RoutedRpcDefaultImplementation; +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.RpcRoutingContext; +import org.opendaylight.controller.sal.dom.broker.spi.RpcRouter; 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.InstanceIdentifier; 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; + +import com.google.common.base.Optional; +import com.google.common.base.Preconditions; +import com.google.common.collect.ClassToInstanceMap; +import com.google.common.collect.ImmutableClassToInstanceMap; +import com.google.common.util.concurrent.ListenableFuture; public class BrokerImpl implements Broker, RpcProvisionRegistry, AutoCloseable { private final static Logger log = LoggerFactory.getLogger(BrokerImpl.class); @@ -43,12 +47,18 @@ public class BrokerImpl implements Broker, RpcProvisionRegistry, AutoCloseable { private final Set providerSessions = Collections .synchronizedSet(new HashSet()); - private BundleContext bundleContext = null; - private AutoCloseable deactivator = null; private RpcRouter router = null; + private final ClassToInstanceMap services; + + public BrokerImpl(final RpcRouter router,final ClassToInstanceMap services) { + this.router = Preconditions.checkNotNull(router, "RPC Router must not be null"); + this.services = ImmutableClassToInstanceMap.copyOf(services); + } + + @Override public ConsumerSession registerConsumer(final Consumer consumer, final BundleContext ctx) { @@ -79,8 +89,9 @@ public class BrokerImpl implements Broker, RpcProvisionRegistry, AutoCloseable { private void checkPredicates(final Provider prov) { Preconditions.checkNotNull(prov, "Provider should not be null."); for (ProviderContextImpl session : providerSessions) { - if (prov.equals(session.getProvider())) + if (prov.equals(session.getProvider())) { throw new IllegalStateException("Provider already registered"); + } } } @@ -88,23 +99,22 @@ public class BrokerImpl implements Broker, RpcProvisionRegistry, AutoCloseable { private void checkPredicates(final Consumer cons) { Preconditions.checkNotNull(cons, "Consumer should not be null."); for (ConsumerContextImpl session : sessions) { - if (cons.equals(session.getConsumer())) + 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); + 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); + ProviderContextImpl ret = new ProviderContextImpl(provider, this); return ret; } @@ -164,21 +174,6 @@ public class BrokerImpl implements Broker, RpcProvisionRegistry, AutoCloseable { 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; - } - /** * @return the deactivator */ @@ -208,4 +203,9 @@ public class BrokerImpl implements Broker, RpcProvisionRegistry, AutoCloseable { public void setRouter(final RpcRouter router) { this.router = router; } + + protected Optional getGlobalService(final Class service) { + return Optional.fromNullable(services.getInstance(service)); + } + } diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/ConsumerContextImpl.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/ConsumerContextImpl.java index fa81bc9040..e96b242720 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/ConsumerContextImpl.java +++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/ConsumerContextImpl.java @@ -20,9 +20,9 @@ import org.opendaylight.controller.sal.dom.broker.osgi.ProxyFactory; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.common.RpcResult; import org.opendaylight.yangtools.yang.data.api.CompositeNode; -import org.osgi.framework.BundleContext; -import org.osgi.framework.ServiceReference; +import com.google.common.base.Optional; +import com.google.common.base.Preconditions; import com.google.common.collect.ClassToInstanceMap; import com.google.common.collect.MutableClassToInstanceMap; @@ -30,41 +30,39 @@ class ConsumerContextImpl implements ConsumerSession { private final ClassToInstanceMap instantiatedServices = MutableClassToInstanceMap .create(); - private final BundleContext context; private final Consumer consumer; private BrokerImpl broker = null; @GuardedBy("this") private boolean closed = false; - public ConsumerContextImpl(final Consumer consumer, final BundleContext ctx) { - this.consumer = consumer; - this.context = ctx; + public ConsumerContextImpl(final Consumer provider, final BrokerImpl brokerImpl) { + broker = brokerImpl; + consumer = provider; } @Override public Future> rpc(final QName rpc, final CompositeNode input) { + checkNotClosed(); return broker.invokeRpcAsync(rpc, input); } @Override public T getService(final Class service) { + checkNotClosed(); final T localProxy = instantiatedServices.getInstance(service); if (localProxy != null) { return localProxy; } - final ServiceReference serviceRef = context - .getServiceReference(service); - if (serviceRef == null) { - return null; - } - final T serviceImpl = context.getService(serviceRef); - final T ret = ProxyFactory.createProxy(serviceRef, serviceImpl); - if (ret != null) { + final Optional serviceImpl = broker.getGlobalService(service); + if(serviceImpl.isPresent()) { + final T ret = ProxyFactory.createProxy(null,serviceImpl.get()); instantiatedServices.putInstance(service, ret); + return ret; + } else { + return null; } - return ret; } @Override @@ -83,6 +81,7 @@ class ConsumerContextImpl implements ConsumerSession { } } broker.consumerSessionClosed(this); + broker = null; } @Override @@ -93,22 +92,19 @@ class ConsumerContextImpl implements ConsumerSession { /** * @return the broker */ - public BrokerImpl getBroker() { + protected final BrokerImpl getBrokerChecked() { + checkNotClosed(); return broker; } - /** - * @param broker - * the broker to set - */ - public void setBroker(final BrokerImpl broker) { - this.broker = broker; - } - /** * @return the _consumer */ public Consumer getConsumer() { return consumer; } + + protected final void checkNotClosed() { + Preconditions.checkState(!closed, "Session is closed."); + } } diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/GlobalBundleScanningSchemaServiceImpl.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/GlobalBundleScanningSchemaServiceImpl.java index 430963a884..c9402c62ab 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/GlobalBundleScanningSchemaServiceImpl.java +++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/GlobalBundleScanningSchemaServiceImpl.java @@ -50,11 +50,24 @@ public class GlobalBundleScanningSchemaServiceImpl implements SchemaContextProvi private ServiceTracker listenerTracker; private BundleTracker>> bundleTracker; private boolean starting = true; + private static GlobalBundleScanningSchemaServiceImpl instance; - public GlobalBundleScanningSchemaServiceImpl(final BundleContext context) { + private GlobalBundleScanningSchemaServiceImpl(final BundleContext context) { this.context = Preconditions.checkNotNull(context); } + public synchronized static GlobalBundleScanningSchemaServiceImpl createInstance(final BundleContext ctx) { + Preconditions.checkState(instance == null); + instance = new GlobalBundleScanningSchemaServiceImpl(ctx); + instance.start(); + return instance; + } + + public synchronized static GlobalBundleScanningSchemaServiceImpl getInstance() { + Preconditions.checkState(instance != null, "Global Instance was not instantiated"); + return instance; + } + public BundleContext getContext() { return context; } @@ -96,7 +109,7 @@ public class GlobalBundleScanningSchemaServiceImpl implements SchemaContextProvi } @Override - public ListenerRegistration registerSchemaServiceListener(final SchemaServiceListener listener) { + public synchronized ListenerRegistration registerSchemaServiceListener(final SchemaServiceListener listener) { Optional potentialCtx = contextResolver.getSchemaContext(); if(potentialCtx.isPresent()) { listener.onGlobalContextUpdated(potentialCtx.get()); @@ -116,7 +129,7 @@ public class GlobalBundleScanningSchemaServiceImpl implements SchemaContextProvi } - private void updateContext(final SchemaContext snapshot) { + private synchronized void updateContext(final SchemaContext snapshot) { Object[] services = listenerTracker.getServices(); for (ListenerRegistration listener : listeners) { try { @@ -194,7 +207,7 @@ public class GlobalBundleScanningSchemaServiceImpl implements SchemaContextProvi } @Override - public SchemaServiceListener addingService(final ServiceReference reference) { + public synchronized SchemaServiceListener addingService(final ServiceReference reference) { SchemaServiceListener listener = context.getService(reference); SchemaContext _ctxContext = getGlobalContext(); diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/ProviderContextImpl.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/ProviderContextImpl.java index 5e8c0e8253..b8bb279297 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/ProviderContextImpl.java +++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/ProviderContextImpl.java @@ -18,21 +18,20 @@ import org.opendaylight.controller.sal.core.api.RpcImplementation; import org.opendaylight.controller.sal.core.api.RpcRegistrationListener; import org.opendaylight.yangtools.concepts.ListenerRegistration; import org.opendaylight.yangtools.yang.common.QName; -import org.osgi.framework.BundleContext; class ProviderContextImpl extends ConsumerContextImpl implements ProviderSession { private final Set registrations = new HashSet<>(); private final Provider provider; - public ProviderContextImpl(final Provider provider, final BundleContext ctx) { - super(null, ctx); + public ProviderContextImpl(final Provider provider, final BrokerImpl broker) { + super(null, broker); this.provider = provider; } @Override public RpcRegistrationWrapper addRpcImplementation(final QName rpcType, final RpcImplementation implementation) throws IllegalArgumentException { - final RpcRegistration origReg = getBroker().getRouter() + final RpcRegistration origReg = getBrokerChecked().getRouter() .addRpcImplementation(rpcType, implementation); final RpcRegistrationWrapper newReg = new RpcRegistrationWrapper( origReg); @@ -56,24 +55,24 @@ class ProviderContextImpl extends ConsumerContextImpl implements ProviderSession final QName rpcType, final RpcImplementation implementation) { throw new UnsupportedOperationException( "TODO: auto-generated method stub"); + } @Override public RoutedRpcRegistration addRoutedRpcImplementation( final QName rpcType, final RpcImplementation implementation) { - throw new UnsupportedOperationException( - "TODO: auto-generated method stub"); + return getBrokerChecked().getRouter().addRoutedRpcImplementation(rpcType, implementation); } @Override public Set getSupportedRpcs() { - return getBroker().getRouter().getSupportedRpcs(); + return getBrokerChecked().getRouter().getSupportedRpcs(); } @Override public ListenerRegistration addRpcRegistrationListener( final RpcRegistrationListener listener) { - return getBroker().getRouter().addRpcRegistrationListener(listener); + return getBrokerChecked().getRouter().addRpcRegistrationListener(listener); } /** diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/osgi/AbstractBrokerServiceProxy.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/osgi/AbstractBrokerServiceProxy.java index 853e3e391f..8d33ff7997 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/osgi/AbstractBrokerServiceProxy.java +++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/osgi/AbstractBrokerServiceProxy.java @@ -14,6 +14,8 @@ import java.util.Collections; import java.util.HashSet; import java.util.Set; +import javax.annotation.Nullable; + import org.opendaylight.controller.sal.core.api.BrokerService; import org.opendaylight.yangtools.concepts.Registration; import org.osgi.framework.ServiceReference; @@ -23,9 +25,9 @@ public abstract class AbstractBrokerServiceProxy implem private T delegate; private final ServiceReference reference; - public AbstractBrokerServiceProxy(final ServiceReference ref, final T delegate) { + public AbstractBrokerServiceProxy(final @Nullable ServiceReference ref, final T delegate) { this.delegate = checkNotNull(delegate, "Delegate should not be null."); - this.reference = checkNotNull(ref, "Reference should not be null."); + this.reference = ref; } protected final T getDelegate() { diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/osgi/SchemaServiceActivator.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/osgi/SchemaServiceActivator.java index f893f96d18..113a9c08db 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/osgi/SchemaServiceActivator.java +++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/osgi/SchemaServiceActivator.java @@ -23,7 +23,7 @@ public class SchemaServiceActivator implements BundleActivator { @Override public void start(final BundleContext context) { - schemaService = new GlobalBundleScanningSchemaServiceImpl(context); + schemaService = GlobalBundleScanningSchemaServiceImpl.createInstance(context); schemaService.start(); schemaServiceReg = context.registerService(SchemaService.class, schemaService, new Hashtable()); } diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/yang/opendaylight-dom-broker-impl.yang b/opendaylight/md-sal/sal-dom-broker/src/main/yang/opendaylight-dom-broker-impl.yang index 82897b0198..a0ee5c50c9 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/main/yang/opendaylight-dom-broker-impl.yang +++ b/opendaylight/md-sal/sal-dom-broker/src/main/yang/opendaylight-dom-broker-impl.yang @@ -55,7 +55,7 @@ module opendaylight-sal-dom-broker-impl { } } } - + container async-data-broker { uses config:service-ref { refine type { @@ -63,7 +63,15 @@ module opendaylight-sal-dom-broker-impl { config:required-identity sal:dom-async-data-broker; } } - + } + + container root-schema-service { + uses config:service-ref { + refine type { + mandatory false; + config:required-identity sal:schema-service; + } + } } } }