X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fconfig%2Fconfig-manager%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fconfig%2Fmanager%2Fimpl%2FConfigTransactionControllerImpl.java;h=6b7251c302975911c598ccbc0dce4fd09678403e;hb=b712eb01354ddb5878008e2a2e8f03fb19b92555;hp=3e53a7a217e1855dedb596a2b5f1dedcd707ca85;hpb=6117dc1c03128e9f7eac249b4a997449e254cdd6;p=controller.git diff --git a/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/ConfigTransactionControllerImpl.java b/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/ConfigTransactionControllerImpl.java index 3e53a7a217..7a1a74e75f 100644 --- a/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/ConfigTransactionControllerImpl.java +++ b/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/ConfigTransactionControllerImpl.java @@ -7,19 +7,40 @@ */ package org.opendaylight.controller.config.manager.impl; +import com.google.common.base.Preconditions; +import com.google.common.collect.Lists; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; +import java.util.concurrent.atomic.AtomicBoolean; +import javax.annotation.Nullable; +import javax.annotation.concurrent.GuardedBy; +import javax.management.DynamicMBean; +import javax.management.InstanceAlreadyExistsException; +import javax.management.InstanceNotFoundException; +import javax.management.MBeanServer; +import javax.management.ObjectName; import org.opendaylight.controller.config.api.DependencyResolver; +import org.opendaylight.controller.config.api.ModuleFactoryNotFoundException; import org.opendaylight.controller.config.api.ModuleIdentifier; import org.opendaylight.controller.config.api.ValidationException; +import org.opendaylight.controller.config.api.annotations.ServiceInterfaceAnnotation; import org.opendaylight.controller.config.api.jmx.ObjectNameUtil; import org.opendaylight.controller.config.manager.impl.dependencyresolver.DependencyResolverManager; +import org.opendaylight.controller.config.manager.impl.dependencyresolver.ModuleInternalTransactionalInfo; import org.opendaylight.controller.config.manager.impl.dynamicmbean.DynamicWritableWrapper; import org.opendaylight.controller.config.manager.impl.dynamicmbean.ReadOnlyAtomicBoolean; import org.opendaylight.controller.config.manager.impl.dynamicmbean.ReadOnlyAtomicBoolean.ReadOnlyAtomicBooleanImpl; import org.opendaylight.controller.config.manager.impl.factoriesresolver.HierarchicalConfigMBeanFactoriesHolder; -import org.opendaylight.controller.config.manager.impl.jmx.TransactionJMXRegistrator; import org.opendaylight.controller.config.manager.impl.jmx.TransactionModuleJMXRegistrator; import org.opendaylight.controller.config.manager.impl.jmx.TransactionModuleJMXRegistrator.TransactionModuleJMXRegistration; -import org.opendaylight.controller.config.manager.impl.util.LookupBeansUtil; +import org.opendaylight.controller.config.manager.impl.osgi.mapping.BindingContextProvider; +import org.opendaylight.controller.config.manager.impl.util.InterfacesHelper; +import org.opendaylight.controller.config.spi.AbstractModule; import org.opendaylight.controller.config.spi.Module; import org.opendaylight.controller.config.spi.ModuleFactory; import org.opendaylight.yangtools.concepts.Identifiable; @@ -27,40 +48,22 @@ import org.osgi.framework.BundleContext; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import javax.annotation.Nullable; -import javax.annotation.concurrent.GuardedBy; -import javax.management.DynamicMBean; -import javax.management.InstanceAlreadyExistsException; -import javax.management.InstanceNotFoundException; -import javax.management.MBeanServer; -import javax.management.ObjectName; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Map.Entry; -import java.util.Set; -import java.util.ArrayList; -import java.util.Collection; -import java.util.concurrent.atomic.AtomicBoolean; - -import static java.lang.String.format; - /** * This is a JMX bean representing current transaction. It contains - * {@link #transactionIdentifier}, unique version and parent version for + * transaction identifier, unique version and parent version for * optimistic locking. */ class ConfigTransactionControllerImpl implements ConfigTransactionControllerInternal, ConfigTransactionControllerImplMXBean, - Identifiable{ - private static final Logger logger = LoggerFactory.getLogger(ConfigTransactionControllerImpl.class); + Identifiable { + private static final Logger LOG = LoggerFactory.getLogger(ConfigTransactionControllerImpl.class); - private final TransactionIdentifier transactionIdentifier; + private final ConfigTransactionLookupRegistry txLookupRegistry; private final ObjectName controllerON; - private final TransactionJMXRegistrator transactionRegistrator; - private final TransactionModuleJMXRegistrator txModuleJMXRegistrator; - private final long parentVersion, currentVersion; + + private final long parentVersion; + private final long currentVersion; private final HierarchicalConfigMBeanFactoriesHolder factoriesHolder; private final DependencyResolverManager dependencyResolverManager; private final TransactionStatus transactionStatus; @@ -80,44 +83,44 @@ class ConfigTransactionControllerImpl implements private final boolean blankTransaction; - public ConfigTransactionControllerImpl(String transactionName, - TransactionJMXRegistrator transactionRegistrator, - long parentVersion, long currentVersion, - Map> currentlyRegisteredFactories, - MBeanServer transactionsMBeanServer, MBeanServer configMBeanServer, - boolean blankTransaction) { - - this.transactionIdentifier = new TransactionIdentifier(transactionName); - this.controllerON = ObjectNameUtil - .createTransactionControllerON(transactionName); - this.transactionRegistrator = transactionRegistrator; - txModuleJMXRegistrator = transactionRegistrator - .createTransactionModuleJMXRegistrator(); + @GuardedBy("this") + private final SearchableServiceReferenceWritableRegistry writableSRRegistry; + + public ConfigTransactionControllerImpl(final ConfigTransactionLookupRegistry txLookupRegistry, + final long parentVersion, final BindingContextProvider bindingContextProvider, final long currentVersion, + final Map> currentlyRegisteredFactories, + final MBeanServer transactionsMBeanServer, final MBeanServer configMBeanServer, + final boolean blankTransaction, final SearchableServiceReferenceWritableRegistry writableSRRegistry) { + this.txLookupRegistry = txLookupRegistry; + String transactionName = txLookupRegistry.getTransactionIdentifier().getName(); + this.controllerON = ObjectNameUtil.createTransactionControllerON(transactionName); this.parentVersion = parentVersion; this.currentVersion = currentVersion; this.currentlyRegisteredFactories = currentlyRegisteredFactories; this.factoriesHolder = new HierarchicalConfigMBeanFactoriesHolder(currentlyRegisteredFactories); this.transactionStatus = new TransactionStatus(); - this.dependencyResolverManager = new DependencyResolverManager(transactionName, transactionStatus); + this.dependencyResolverManager = new DependencyResolverManager(txLookupRegistry.getTransactionIdentifier(), + transactionStatus, writableSRRegistry, bindingContextProvider, transactionsMBeanServer); this.transactionsMBeanServer = transactionsMBeanServer; this.configMBeanServer = configMBeanServer; this.blankTransaction = blankTransaction; + this.writableSRRegistry = writableSRRegistry; } @Override - public void copyExistingModulesAndProcessFactoryDiff(Collection existingModules, List lastListOfFactories) { + public void copyExistingModulesAndProcessFactoryDiff(final Collection existingModules, final List lastListOfFactories) { // copy old configuration to this server for (ModuleInternalInfo oldConfigInfo : existingModules) { try { copyExistingModule(oldConfigInfo); - } catch (InstanceAlreadyExistsException e) { + } catch (final InstanceAlreadyExistsException e) { throw new IllegalStateException("Error while copying " + oldConfigInfo, e); } } processDefaultBeans(lastListOfFactories); } - private synchronized void processDefaultBeans(List lastListOfFactories) { + private synchronized void processDefaultBeans(final List lastListOfFactories) { transactionStatus.checkNotCommitStarted(); transactionStatus.checkNotAborted(); @@ -126,73 +129,103 @@ class ConfigTransactionControllerImpl implements List toBeAdded = new ArrayList<>(); List toBeRemoved = new ArrayList<>(); - for(ModuleFactory moduleFactory: factoriesHolder.getModuleFactories()) { - if (oldSet.contains(moduleFactory) == false){ + for (ModuleFactory moduleFactory : factoriesHolder.getModuleFactories()) { + if (!oldSet.contains(moduleFactory)) { toBeAdded.add(moduleFactory); } } - for(ModuleFactory moduleFactory: lastListOfFactories){ - if (newSet.contains(moduleFactory) == false) { + for (ModuleFactory moduleFactory : lastListOfFactories) { + if (!newSet.contains(moduleFactory)) { toBeRemoved.add(moduleFactory); } } // add default modules for (ModuleFactory moduleFactory : toBeAdded) { + BundleContext bundleContext = getModuleFactoryBundleContext(moduleFactory.getImplementationName()); Set defaultModules = moduleFactory.getDefaultModules(dependencyResolverManager, - getModuleFactoryBundleContext(moduleFactory.getImplementationName())); + bundleContext); for (Module module : defaultModules) { // ensure default module to be registered to jmx even if its module factory does not use dependencyResolverFactory DependencyResolver dependencyResolver = dependencyResolverManager.getOrCreate(module.getIdentifier()); + final ObjectName objectName; try { boolean defaultBean = true; - putConfigBeanToJMXAndInternalMaps(module.getIdentifier(), module, moduleFactory, null, dependencyResolver, defaultBean); - } catch (InstanceAlreadyExistsException e) { + objectName = putConfigBeanToJMXAndInternalMaps(module.getIdentifier(), module, moduleFactory, null, + dependencyResolver, defaultBean, bundleContext); + } catch (final InstanceAlreadyExistsException e) { throw new IllegalStateException(e); } + + // register default module as every possible service + final Set serviceInterfaceAnnotations = InterfacesHelper.getServiceInterfaceAnnotations(moduleFactory); + for (String qname : InterfacesHelper.getQNames(serviceInterfaceAnnotations)) { + try { + saveServiceReference(qname, module.getIdentifier().getInstanceName(), objectName); + } catch (final InstanceNotFoundException e) { + throw new IllegalStateException("Unable to register default module instance " + module + " as a service of " + qname, e); + } + } } } // remove modules belonging to removed factories - for(ModuleFactory removedFactory: toBeRemoved){ + for (ModuleFactory removedFactory : toBeRemoved) { List modulesOfRemovedFactory = dependencyResolverManager.findAllByFactory(removedFactory); for (ModuleIdentifier name : modulesOfRemovedFactory) { + // remove service refs + final ModuleFactory moduleFactory = dependencyResolverManager.findModuleInternalTransactionalInfo(name).getModuleFactory(); + final Set serviceInterfaceAnnotations = InterfacesHelper.getServiceInterfaceAnnotations(moduleFactory); + for (String qname : InterfacesHelper.getQNames(serviceInterfaceAnnotations)) { + try { + removeServiceReference(qname, name.getInstanceName()); + } catch (final InstanceNotFoundException e) { + throw new IllegalStateException("Unable to UNregister default module instance " + name + " as a service of " + qname, e); + } + } + + // close module destroyModule(name); } } } - private synchronized void copyExistingModule( - ModuleInternalInfo oldConfigBeanInfo) + private synchronized void copyExistingModule(final ModuleInternalInfo oldConfigBeanInfo) throws InstanceAlreadyExistsException { + transactionStatus.checkNotCommitStarted(); transactionStatus.checkNotAborted(); - ModuleIdentifier moduleIdentifier = oldConfigBeanInfo.getName(); + ModuleIdentifier moduleIdentifier = oldConfigBeanInfo.getIdentifier(); dependencyResolverManager.assertNotExists(moduleIdentifier); - ModuleFactory moduleFactory = factoriesHolder - .findByModuleName(moduleIdentifier.getFactoryName()); + ModuleFactory moduleFactory; + BundleContext bc; + try { + moduleFactory = factoriesHolder.findByModuleName(moduleIdentifier.getFactoryName()); + bc = getModuleFactoryBundleContext(moduleFactory.getImplementationName()); + } catch (final ModuleFactoryNotFoundException e) { + throw new IllegalStateException(e); + } Module module; - DependencyResolver dependencyResolver = dependencyResolverManager - .getOrCreate(moduleIdentifier); + DependencyResolver dependencyResolver = dependencyResolverManager.getOrCreate(moduleIdentifier); try { - BundleContext bc = getModuleFactoryBundleContext(moduleFactory.getImplementationName()); + module = moduleFactory.createModule( moduleIdentifier.getInstanceName(), dependencyResolver, oldConfigBeanInfo.getReadableModule(), bc); - } catch (Exception e) { - throw new IllegalStateException(format( + } catch (final Exception e) { + throw new IllegalStateException(String.format( "Error while copying old configuration from %s to %s", oldConfigBeanInfo, moduleFactory), e); } putConfigBeanToJMXAndInternalMaps(moduleIdentifier, module, moduleFactory, oldConfigBeanInfo, dependencyResolver, - oldConfigBeanInfo.isDefaultBean()); + oldConfigBeanInfo.isDefaultBean(), bc); } @Override - public synchronized ObjectName createModule(String factoryName, - String instanceName) throws InstanceAlreadyExistsException { + public synchronized ObjectName createModule(final String factoryName, final String instanceName) + throws InstanceAlreadyExistsException { transactionStatus.checkNotCommitStarted(); transactionStatus.checkNotAborted(); @@ -201,73 +234,101 @@ class ConfigTransactionControllerImpl implements // find factory ModuleFactory moduleFactory = factoriesHolder.findByModuleName(factoryName); + DependencyResolver dependencyResolver = dependencyResolverManager.getOrCreate(moduleIdentifier); + BundleContext bundleContext = getModuleFactoryBundleContext(moduleFactory.getImplementationName()); Module module = moduleFactory.createModule(instanceName, dependencyResolver, - getModuleFactoryBundleContext(moduleFactory.getImplementationName())); + bundleContext); boolean defaultBean = false; return putConfigBeanToJMXAndInternalMaps(moduleIdentifier, module, - moduleFactory, null, dependencyResolver, defaultBean); + moduleFactory, null, dependencyResolver, defaultBean, bundleContext); + } + + @Override + public synchronized void reCreateModule(final ObjectName objectName) throws InstanceNotFoundException { + transactionStatus.checkNotCommitStarted(); + transactionStatus.checkNotAborted(); + checkTransactionName(objectName); + ObjectNameUtil.checkDomain(objectName); + ModuleIdentifier moduleIdentifier = ObjectNameUtil.fromON(objectName, ObjectNameUtil.TYPE_MODULE); + + ModuleInternalTransactionalInfo txInfo = dependencyResolverManager.findModuleInternalTransactionalInfo(moduleIdentifier); + Module realModule = txInfo.getRealModule(); + if(realModule instanceof AbstractModule) { + ((AbstractModule)realModule).setCanReuseInstance(false); + } } private synchronized ObjectName putConfigBeanToJMXAndInternalMaps( - ModuleIdentifier moduleIdentifier, Module module, - ModuleFactory moduleFactory, - @Nullable ModuleInternalInfo maybeOldConfigBeanInfo, DependencyResolver dependencyResolver, boolean isDefaultBean) + final ModuleIdentifier moduleIdentifier, final Module module, + final ModuleFactory moduleFactory, + @Nullable final ModuleInternalInfo maybeOldConfigBeanInfo, final DependencyResolver dependencyResolver, + final boolean isDefaultBean, final BundleContext bundleContext) throws InstanceAlreadyExistsException { - logger.debug("Adding module {} to transaction {}", moduleIdentifier, this); - if (moduleIdentifier.equals(module.getIdentifier())==false) { + LOG.debug("Adding module {} to transaction {}", moduleIdentifier, this); + if (!moduleIdentifier.equals(module.getIdentifier())) { throw new IllegalStateException("Incorrect name reported by module. Expected " - + moduleIdentifier + ", got " + module.getIdentifier()); + + moduleIdentifier + ", got " + module.getIdentifier()); } - if (dependencyResolver.getIdentifier().equals(moduleIdentifier) == false ) { + if (!dependencyResolver.getIdentifier().equals(moduleIdentifier)) { throw new IllegalStateException("Incorrect name reported by dependency resolver. Expected " + moduleIdentifier + ", got " + dependencyResolver.getIdentifier()); } DynamicMBean writableDynamicWrapper = new DynamicWritableWrapper( - module, moduleIdentifier, transactionIdentifier, + module, moduleIdentifier, getTransactionIdentifier().getName(), readOnlyAtomicBoolean, transactionsMBeanServer, configMBeanServer); ObjectName writableON = ObjectNameUtil.createTransactionModuleON( - transactionIdentifier.getName(), moduleIdentifier); + getTransactionIdentifier().getName(), moduleIdentifier); // put wrapper to jmx - TransactionModuleJMXRegistration transactionModuleJMXRegistration = txModuleJMXRegistrator + TransactionModuleJMXRegistration transactionModuleJMXRegistration = getTxModuleJMXRegistrator() .registerMBean(writableDynamicWrapper, writableON); - ModuleInternalTransactionalInfo moduleInternalTransactionalInfo = new ModuleInternalTransactionalInfo( - moduleIdentifier, module, moduleFactory, - maybeOldConfigBeanInfo, transactionModuleJMXRegistration, isDefaultBean); - dependencyResolverManager.put(moduleInternalTransactionalInfo); + dependencyResolverManager.put( + moduleIdentifier, module, moduleFactory, + maybeOldConfigBeanInfo, transactionModuleJMXRegistration, isDefaultBean, bundleContext); return writableON; } @Override - public synchronized void destroyModule(ObjectName objectName) - throws InstanceNotFoundException { + public synchronized void destroyModule(final ObjectName objectName) throws InstanceNotFoundException { + checkTransactionName(objectName); + ObjectNameUtil.checkDomain(objectName); + ModuleIdentifier moduleIdentifier = ObjectNameUtil.fromON(objectName, + ObjectNameUtil.TYPE_MODULE); + destroyModule(moduleIdentifier); + } + + private void checkTransactionName(final ObjectName objectName) { String foundTransactionName = ObjectNameUtil .getTransactionName(objectName); - if (transactionIdentifier.getName().equals(foundTransactionName) == false) { + if (!getTransactionIdentifier().getName().equals(foundTransactionName)) { throw new IllegalArgumentException("Wrong transaction name " + objectName); } - ObjectNameUtil.checkDomain(objectName); - ModuleIdentifier moduleIdentifier = ObjectNameUtil.fromON(objectName, - ObjectNameUtil.TYPE_MODULE); - destroyModule(moduleIdentifier); } - private synchronized void destroyModule(ModuleIdentifier moduleIdentifier) { - logger.debug("Destroying module {} in transaction {}", moduleIdentifier, this); + private synchronized void destroyModule(final ModuleIdentifier moduleIdentifier) { + LOG.debug("Destroying module {} in transaction {}", moduleIdentifier, this); transactionStatus.checkNotAborted(); - if (blankTransaction == false) { - ModuleInternalTransactionalInfo found = - dependencyResolverManager.findModuleInternalTransactionalInfo(moduleIdentifier); - if (found.isDefaultBean()) { - logger.warn("Warning: removing default bean. This will be forbidden in next version of config-subsystem"); - } + ModuleInternalTransactionalInfo found = dependencyResolverManager.findModuleInternalTransactionalInfo(moduleIdentifier); + if (!blankTransaction && + found.isDefaultBean()) { + LOG.warn("Warning: removing default bean. This will be forbidden in next version of config-subsystem"); } + // first remove refNames, it checks for objectname existence + + try { + writableSRRegistry.removeServiceReferences( + ObjectNameUtil.createTransactionModuleON(getTransactionName(), moduleIdentifier)); + } catch (final InstanceNotFoundException e) { + LOG.error("Possible code error: cannot find {} in {}", moduleIdentifier, writableSRRegistry); + throw new IllegalStateException("Possible code error: cannot find " + moduleIdentifier, e); + } + ModuleInternalTransactionalInfo removedTInfo = dependencyResolverManager.destroyModule(moduleIdentifier); // remove from jmx removedTInfo.getTransactionModuleJMXRegistration().close(); @@ -285,19 +346,20 @@ class ConfigTransactionControllerImpl implements @Override public synchronized void validateConfig() throws ValidationException { - if (configBeanModificationDisabled.get()) + if (configBeanModificationDisabled.get()) { throw new IllegalStateException("Cannot start validation"); + } configBeanModificationDisabled.set(true); try { - validate_noLocks(); + validateNoLocks(); } finally { configBeanModificationDisabled.set(false); } } - private void validate_noLocks() throws ValidationException { + private void validateNoLocks() throws ValidationException { transactionStatus.checkNotAborted(); - logger.info("Validating transaction {}", transactionIdentifier); + LOG.trace("Validating transaction {}", getTransactionIdentifier()); // call validate() List collectedExceptions = new ArrayList<>(); for (Entry entry : dependencyResolverManager @@ -306,18 +368,18 @@ class ConfigTransactionControllerImpl implements Module module = entry.getValue(); try { module.validate(); - } catch (Exception e) { - logger.warn("Validation exception in {}", getTransactionName(), + } catch (final Exception e) { + LOG.warn("Validation exception in {}", getTransactionName(), e); collectedExceptions.add(ValidationException .createForSingleException(name, e)); } } - if (collectedExceptions.size() > 0) { + if (!collectedExceptions.isEmpty()) { throw ValidationException .createFromCollectedValidationExceptions(collectedExceptions); } - logger.info("Validated transaction {}", transactionIdentifier); + LOG.trace("Validated transaction {}", getTransactionIdentifier()); } /** @@ -334,10 +396,11 @@ class ConfigTransactionControllerImpl implements transactionStatus.checkNotCommitStarted(); configBeanModificationDisabled.set(true); try { - validate_noLocks(); - } catch (ValidationException e) { - logger.info("Commit failed on validation"); - configBeanModificationDisabled.set(false); // recoverable error + validateNoLocks(); + } catch (final ValidationException e) { + LOG.trace("Commit failed on validation"); + // recoverable error + configBeanModificationDisabled.set(false); throw e; } // errors in this state are not recoverable. modules are not mutable @@ -353,57 +416,61 @@ class ConfigTransactionControllerImpl implements public synchronized List secondPhaseCommit() { transactionStatus.checkNotAborted(); transactionStatus.checkCommitStarted(); - if (configBeanModificationDisabled.get() == false) { + if (!configBeanModificationDisabled.get()) { throw new IllegalStateException( "Internal error - validateBeforeCommitAndLockTransaction should be called " + "to obtain a lock"); } - logger.info("Committing transaction {}", transactionIdentifier); + LOG.trace("Committing transaction {}", getTransactionIdentifier()); + + Map allModules = dependencyResolverManager.getAllModules(); + + // call getInstance() on all Modules from top to bottom (from source to target of the dependency relation) + // The source of a dependency closes itself and calls getInstance recursively on the dependencies (in case of reconfiguration) + // This makes close() calls from top to bottom while createInstance() calls are performed bottom to top + List sortedModuleIdentifiers = Lists.reverse(dependencyResolverManager.getSortedModuleIdentifiers()); + for (ModuleIdentifier moduleIdentifier : sortedModuleIdentifiers) { + Module module = allModules.get(moduleIdentifier); - // call getInstance() - for (Entry entry : dependencyResolverManager - .getAllModules().entrySet()) { - Module module = entry.getValue(); - ModuleIdentifier name = entry.getKey(); try { - logger.debug("About to commit {} in transaction {}", - name, transactionIdentifier); - module.getInstance(); + LOG.debug("About to commit {} in transaction {}", + moduleIdentifier, getTransactionIdentifier()); + AutoCloseable instance = module.getInstance(); + Preconditions.checkNotNull(instance, "Instance is null:%s in transaction %s", moduleIdentifier, getTransactionIdentifier()); } catch (Exception e) { - logger.error("Commit failed on {} in transaction {}", name, - transactionIdentifier, e); + LOG.error("Commit failed on {} in transaction {}", moduleIdentifier, + getTransactionIdentifier(), e); internalAbort(); - throw new RuntimeException( - format("Error - getInstance() failed for %s in transaction %s", - name, transactionIdentifier), e); + throw new IllegalStateException( + String.format("Error - getInstance() failed for %s in transaction %s", + moduleIdentifier, getTransactionIdentifier()), e); } } - // count dependency order - - logger.info("Committed configuration {}", transactionIdentifier); + LOG.trace("Committed configuration {}", getTransactionIdentifier()); transactionStatus.setCommitted(); - // unregister this and all modules from jmx - close(); - return dependencyResolverManager.getSortedModuleIdentifiers(); + return sortedModuleIdentifiers; } @Override - public synchronized void abortConfig() { + public void abortConfig() { transactionStatus.checkNotCommitStarted(); transactionStatus.checkNotAborted(); internalAbort(); } private void internalAbort() { + LOG.trace("Aborting {}", this); transactionStatus.setAborted(); close(); } - private void close() { - transactionRegistrator.close(); + @Override + public void close() { + dependencyResolverManager.close(); + txLookupRegistry.close(); } @Override @@ -413,7 +480,7 @@ class ConfigTransactionControllerImpl implements @Override public String getTransactionName() { - return transactionIdentifier.getName(); + return getTransactionIdentifier().getName(); } /** @@ -421,37 +488,65 @@ class ConfigTransactionControllerImpl implements */ @Override public Set lookupConfigBeans() { - return lookupConfigBeans("*", "*"); + return txLookupRegistry.lookupConfigBeans(); } /** * {@inheritDoc} */ @Override - public Set lookupConfigBeans(String moduleName) { - return lookupConfigBeans(moduleName, "*"); + public Set lookupConfigBeans(final String moduleName) { + return txLookupRegistry.lookupConfigBeans(moduleName); } /** * {@inheritDoc} */ @Override - public ObjectName lookupConfigBean(String moduleName, String instanceName) + public ObjectName lookupConfigBean(final String moduleName, final String instanceName) throws InstanceNotFoundException { - return LookupBeansUtil.lookupConfigBean(this, moduleName, instanceName); + return txLookupRegistry.lookupConfigBean(moduleName, instanceName); + } + + /** + * {@inheritDoc} + */ + @Override + public Set lookupConfigBeans(final String moduleName, final String instanceName) { + return txLookupRegistry.lookupConfigBeans(moduleName, instanceName); + } + + /** + * {@inheritDoc} + */ + @Override + public void checkConfigBeanExists(final ObjectName objectName) throws InstanceNotFoundException { + txLookupRegistry.checkConfigBeanExists(objectName); } + /** * {@inheritDoc} */ @Override - public Set lookupConfigBeans(String moduleName, - String instanceName) { - ObjectName namePattern = ObjectNameUtil.createModulePattern(moduleName, - instanceName, transactionIdentifier.getName()); - return txModuleJMXRegistrator.queryNames(namePattern, null); + public Set lookupRuntimeBeans() { + return txLookupRegistry.lookupRuntimeBeans(); } + /** + * {@inheritDoc} + */ + @Override + public Set lookupRuntimeBeans(final String moduleName, + final String instanceName) { + return txLookupRegistry.lookupRuntimeBeans(moduleName, instanceName); + } + + // -- + + /** + * {@inheritDoc} + */ @Override public Set getAvailableModuleNames() { return factoriesHolder.getModuleNames(); @@ -473,11 +568,11 @@ class ConfigTransactionControllerImpl implements // @VisibleForTesting TransactionModuleJMXRegistrator getTxModuleJMXRegistrator() { - return txModuleJMXRegistrator; + return txLookupRegistry.getTxModuleJMXRegistrator(); } public TransactionIdentifier getName() { - return transactionIdentifier; + return getTransactionIdentifier(); } @Override @@ -487,15 +582,88 @@ class ConfigTransactionControllerImpl implements @Override public TransactionIdentifier getIdentifier() { - return transactionIdentifier; + return getTransactionIdentifier(); } @Override - public BundleContext getModuleFactoryBundleContext(String factoryName) { + public BundleContext getModuleFactoryBundleContext(final String factoryName) { Map.Entry factoryBundleContextEntry = this.currentlyRegisteredFactories.get(factoryName); if (factoryBundleContextEntry == null || factoryBundleContextEntry.getValue() == null) { throw new NullPointerException("Bundle context of " + factoryName + " ModuleFactory not found."); } return factoryBundleContextEntry.getValue(); } + + // service reference functionality: + + + @Override + public synchronized ObjectName lookupConfigBeanByServiceInterfaceName(final String serviceInterfaceQName, final String refName) { + return writableSRRegistry.lookupConfigBeanByServiceInterfaceName(serviceInterfaceQName, refName); + } + + @Override + public synchronized Map> getServiceMapping() { + return writableSRRegistry.getServiceMapping(); + } + + @Override + public synchronized Map lookupServiceReferencesByServiceInterfaceName(final String serviceInterfaceQName) { + return writableSRRegistry.lookupServiceReferencesByServiceInterfaceName(serviceInterfaceQName); + } + + @Override + public synchronized Set lookupServiceInterfaceNames(final ObjectName objectName) throws InstanceNotFoundException { + return writableSRRegistry.lookupServiceInterfaceNames(objectName); + } + + @Override + public synchronized String getServiceInterfaceName(final String namespace, final String localName) { + return writableSRRegistry.getServiceInterfaceName(namespace, localName); + } + + @Override + public synchronized ObjectName saveServiceReference(final String serviceInterfaceName, final String refName, final ObjectName moduleON) throws InstanceNotFoundException { + return writableSRRegistry.saveServiceReference(serviceInterfaceName, refName, moduleON); + } + + @Override + public synchronized void removeServiceReference(final String serviceInterfaceName, final String refName) throws InstanceNotFoundException { + writableSRRegistry.removeServiceReference(serviceInterfaceName, refName); + } + + @Override + public synchronized void removeAllServiceReferences() { + writableSRRegistry.removeAllServiceReferences(); + } + + @Override + public boolean removeServiceReferences(final ObjectName objectName) throws InstanceNotFoundException { + return writableSRRegistry.removeServiceReferences(objectName); + } + + @Override + public SearchableServiceReferenceWritableRegistry getWritableRegistry() { + return writableSRRegistry; + } + + @Override + public TransactionIdentifier getTransactionIdentifier() { + return txLookupRegistry.getTransactionIdentifier(); + } + + @Override + public Set getAvailableModuleFactoryQNames() { + return txLookupRegistry.getAvailableModuleFactoryQNames(); + } + + @Override + public void checkServiceReferenceExists(final ObjectName objectName) throws InstanceNotFoundException { + writableSRRegistry.checkServiceReferenceExists(objectName); + } + + @Override + public ObjectName getServiceReference(final String serviceInterfaceQName, final String refName) throws InstanceNotFoundException { + return writableSRRegistry.getServiceReference(serviceInterfaceQName, refName); + } }