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 {
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;
}
private void startDomBroker() {
checkState(executor != null);
- biBrokerImpl = new BrokerImpl();
- biBrokerImpl.setRouter(new SchemaAwareRpcBroker("/", mockSchemaService));
+
+ SchemaAwareRpcBroker router = new SchemaAwareRpcBroker("/", mockSchemaService);
+ ClassToInstanceMap<BrokerService> services = MutableClassToInstanceMap.create();
+ biBrokerImpl = new BrokerImpl(router,services);
}
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;
/**
*
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);
}
@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<BrokerService> 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;
}
}
*/
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;
/**
*
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;
- }
-
}
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;
@Override
public java.lang.AutoCloseable createInstance() {
- ServiceReference<SchemaService> 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<SchemaService> {
- private BundleContext bundleContext;
- private ServiceReference<SchemaService> reference;
private SchemaService delegate;
- public GlobalSchemaServiceProxy(final BundleContext bundleContext, final ServiceReference<SchemaService> 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;
}
}
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;
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;
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<SchemaServiceListener> 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
return listener;
}
}
+
+ private class SchemaListener implements SchemaContextListener {
+
+ @Override
+ public void onGlobalContextUpdated(final SchemaContext ctx) {
+ normalizer = new DataNormalizer(ctx);
+ }
+
+ }
}
+++ /dev/null
-/**
- * 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<DataBrokerService> dataReg = null;
- private ServiceRegistration<DataProviderService> dataProviderReg = null;
- private ServiceRegistration<MountService> mountReg = null;
- private ServiceRegistration<MountProvisionService> mountProviderReg = null;
- private SchemaService schemaService = null;
- private ServiceRegistration<RpcProvisionRegistry> 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<String, String> emptyProperties = new Hashtable<String, String>();
- broker.setBundleContext(context);
-
- final ServiceReference<SchemaService> serviceRef = context
- .getServiceReference(SchemaService.class);
- schemaService = context.<SchemaService> 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;
- }
-}
*/
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;
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);
private final Set<ProviderContextImpl> providerSessions = Collections
.synchronizedSet(new HashSet<ProviderContextImpl>());
- private BundleContext bundleContext = null;
-
private AutoCloseable deactivator = null;
private RpcRouter router = null;
+ private final ClassToInstanceMap<BrokerService> services;
+
+ public BrokerImpl(final RpcRouter router,final ClassToInstanceMap<BrokerService> 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) {
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");
+ }
}
}
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;
}
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
*/
public void setRouter(final RpcRouter router) {
this.router = router;
}
+
+ protected <T extends BrokerService> Optional<T> getGlobalService(final Class<T> service) {
+ return Optional.fromNullable(services.getInstance(service));
+ }
+
}
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;
private final ClassToInstanceMap<BrokerService> 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<RpcResult<CompositeNode>> rpc(final QName rpc,
final CompositeNode input) {
+ checkNotClosed();
return broker.invokeRpcAsync(rpc, input);
}
@Override
public <T extends BrokerService> T getService(final Class<T> service) {
+ checkNotClosed();
final T localProxy = instantiatedServices.getInstance(service);
if (localProxy != null) {
return localProxy;
}
- final ServiceReference<T> 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<T> 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
}
}
broker.consumerSessionClosed(this);
+ broker = null;
}
@Override
/**
* @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.");
+ }
}
private ServiceTracker<SchemaServiceListener, SchemaServiceListener> listenerTracker;
private BundleTracker<Iterable<Registration<URL>>> 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;
}
}
@Override
- public ListenerRegistration<SchemaServiceListener> registerSchemaServiceListener(final SchemaServiceListener listener) {
+ public synchronized ListenerRegistration<SchemaServiceListener> registerSchemaServiceListener(final SchemaServiceListener listener) {
Optional<SchemaContext> potentialCtx = contextResolver.getSchemaContext();
if(potentialCtx.isPresent()) {
listener.onGlobalContextUpdated(potentialCtx.get());
}
- private void updateContext(final SchemaContext snapshot) {
+ private synchronized void updateContext(final SchemaContext snapshot) {
Object[] services = listenerTracker.getServices();
for (ListenerRegistration<SchemaServiceListener> listener : listeners) {
try {
}
@Override
- public SchemaServiceListener addingService(final ServiceReference<SchemaServiceListener> reference) {
+ public synchronized SchemaServiceListener addingService(final ServiceReference<SchemaServiceListener> reference) {
SchemaServiceListener listener = context.getService(reference);
SchemaContext _ctxContext = getGlobalContext();
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<RpcRegistrationWrapper> 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);
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<QName> getSupportedRpcs() {
- return getBroker().getRouter().getSupportedRpcs();
+ return getBrokerChecked().getRouter().getSupportedRpcs();
}
@Override
public ListenerRegistration<RpcRegistrationListener> addRpcRegistrationListener(
final RpcRegistrationListener listener) {
- return getBroker().getRouter().addRpcRegistrationListener(listener);
+ return getBrokerChecked().getRouter().addRpcRegistrationListener(listener);
}
/**
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;
private T delegate;
private final ServiceReference<T> reference;
- public AbstractBrokerServiceProxy(final ServiceReference<T> ref, final T delegate) {
+ public AbstractBrokerServiceProxy(final @Nullable ServiceReference<T> 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() {
@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<String,String>());
}
}
}
}
-
+
container async-data-broker {
uses config:service-ref {
refine type {
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;
+ }
+ }
}
}
}