From: Tomas Olvecky Date: Mon, 21 Oct 2013 16:00:05 +0000 (+0200) Subject: Add ModuleFactory#getDefaultModules method to config-api. X-Git-Tag: jenkins-controller-bulk-release-prepare-only-2-1~577 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=commitdiff_plain;h=2c6fd09ad16f5c2968390a674865efbbe5f1fcec Add ModuleFactory#getDefaultModules method to config-api. Add method to populate pre-existing state. Modify code generator to generate a blank implementation. Calling of the method is done by config-manager every time new ModuleFactory is discovered in OSGi service registry, each time in a separate transaction. Implement default module functionality in config-manager. Add DependencyResolverFactory for default modules to be able to lookup dependencies. Implement new service tracker tracking ModuleFactory instances in order to commit blank transactions every time ModuleFactory service appears or disappears. Clean up pom versions: merge config.yangstore.version into config.version. Change-Id: I47229c9e403b817b24740c8f77ad43abcc720094 Signed-off-by: Tomas Olvecky --- diff --git a/opendaylight/commons/opendaylight/pom.xml b/opendaylight/commons/opendaylight/pom.xml index 0356f4fd32..30c0e474dc 100644 --- a/opendaylight/commons/opendaylight/pom.xml +++ b/opendaylight/commons/opendaylight/pom.xml @@ -76,9 +76,8 @@ 0.6.0-SNAPSHOT 0.4.1-SNAPSHOT - 0.2.1-SNAPSHOT + 0.2.2-SNAPSHOT 0.2.2-SNAPSHOT - 0.2.2-SNAPSHOT 1.0-SNAPSHOT 0.5.1-SNAPSHOT 0.5.1-SNAPSHOT diff --git a/opendaylight/config/config-api/pom.xml b/opendaylight/config/config-api/pom.xml index e0f274950d..218362a07b 100644 --- a/opendaylight/config/config-api/pom.xml +++ b/opendaylight/config/config-api/pom.xml @@ -6,13 +6,14 @@ config-subsystem org.opendaylight.controller - 0.2.1-SNAPSHOT + 0.2.2-SNAPSHOT config-api ${project.artifactId} bundle + com.google.code.findbugs diff --git a/opendaylight/config/config-api/src/main/java/org/opendaylight/controller/config/api/DependencyResolverFactory.java b/opendaylight/config/config-api/src/main/java/org/opendaylight/controller/config/api/DependencyResolverFactory.java new file mode 100644 index 0000000000..77f40c84fd --- /dev/null +++ b/opendaylight/config/config-api/src/main/java/org/opendaylight/controller/config/api/DependencyResolverFactory.java @@ -0,0 +1,14 @@ +/* + * 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.config.api; + +public interface DependencyResolverFactory { + + DependencyResolver createDependencyResolver(ModuleIdentifier moduleIdentifier); + +} diff --git a/opendaylight/config/config-api/src/main/java/org/opendaylight/controller/config/spi/ModuleFactory.java b/opendaylight/config/config-api/src/main/java/org/opendaylight/controller/config/spi/ModuleFactory.java index 00db2c2cd4..e300523913 100644 --- a/opendaylight/config/config-api/src/main/java/org/opendaylight/controller/config/spi/ModuleFactory.java +++ b/opendaylight/config/config-api/src/main/java/org/opendaylight/controller/config/spi/ModuleFactory.java @@ -10,9 +10,12 @@ package org.opendaylight.controller.config.spi; import javax.management.DynamicMBean; import org.opendaylight.controller.config.api.DependencyResolver; +import org.opendaylight.controller.config.api.DependencyResolverFactory; import org.opendaylight.controller.config.api.DynamicMBeanWithInstance; import org.opendaylight.controller.config.api.annotations.AbstractServiceInterface; +import java.util.Set; + /** * Factory which creates {@link Module instances. An instance of this interface * needs to be exported into the OSGi Service Registry. Such an instance @@ -88,4 +91,15 @@ public interface ModuleFactory { boolean isModuleImplementingServiceInterface( Class serviceInterface); + /** + * Called when ModuleFactory is registered to config manager. + * Useful for populating the registry with pre-existing state. Since + * the method is called for each ModuleFactory separately and transaction + * is committed automatically, returned modules MUST be valid and commitable + * without any manual intervention. + * @param dependencyResolverFactory factory for getting dependency resolvers for each module. + * @return set of default modules. Null is not allowed. + */ + public Set getDefaultModules(DependencyResolverFactory dependencyResolverFactory); + } diff --git a/opendaylight/config/config-manager/pom.xml b/opendaylight/config/config-manager/pom.xml index b3a04633aa..2019cb6a36 100644 --- a/opendaylight/config/config-manager/pom.xml +++ b/opendaylight/config/config-manager/pom.xml @@ -4,19 +4,19 @@ config-subsystem org.opendaylight.controller - 0.2.1-SNAPSHOT + 0.2.2-SNAPSHOT .. config-manager ${project.artifactId} bundle + ${project.groupId} config-api - 0.2.1-SNAPSHOT org.slf4j @@ -30,11 +30,13 @@ com.google.code.findbugs jsr305 + commons-io commons-io @@ -44,19 +46,16 @@ org.opendaylight.bgpcep mockito-configuration - ${bgpcep.version} test ${project.groupId} config-util - 0.2.1-SNAPSHOT test ${project.groupId} config-util - 0.2.1-SNAPSHOT test test-jar diff --git a/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/ConfigRegistryImpl.java b/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/ConfigRegistryImpl.java index 97d57a4591..18b4d3bc57 100644 --- a/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/ConfigRegistryImpl.java +++ b/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/ConfigRegistryImpl.java @@ -45,6 +45,7 @@ import org.opendaylight.controller.config.manager.impl.osgi.BeanToOsgiServiceMan import org.opendaylight.controller.config.manager.impl.osgi.BeanToOsgiServiceManager.OsgiRegistration; import org.opendaylight.controller.config.manager.impl.util.LookupBeansUtil; import org.opendaylight.controller.config.spi.Module; +import org.opendaylight.controller.config.spi.ModuleFactory; import org.osgi.framework.BundleContext; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -54,10 +55,8 @@ import org.slf4j.LoggerFactory; * Transactions. It is registered in Platform MBean Server. */ @ThreadSafe -public class ConfigRegistryImpl implements AutoCloseable, - ConfigRegistryImplMXBean { - private static final Logger logger = LoggerFactory - .getLogger(ConfigRegistryImpl.class); +public class ConfigRegistryImpl implements AutoCloseable, ConfigRegistryImplMXBean { + private static final Logger logger = LoggerFactory.getLogger(ConfigRegistryImpl.class); private final ModuleFactoriesResolver resolver; private final MBeanServer configMBeanServer; @@ -98,6 +97,9 @@ public class ConfigRegistryImpl implements AutoCloseable, // internal jmx server shared by all transactions private final MBeanServer transactionsMBeanServer; + @GuardedBy("this") + private List lastListOfFactories = Collections.emptyList(); + // constructor public ConfigRegistryImpl(ModuleFactoriesResolver resolver, BundleContext bundleContext, MBeanServer configMBeanServer) { @@ -130,30 +132,21 @@ public class ConfigRegistryImpl implements AutoCloseable, private synchronized ConfigTransactionControllerInternal beginConfigInternal() { versionCounter++; - String transactionName = "ConfigTransaction-" + version + "-" - + versionCounter; + String transactionName = "ConfigTransaction-" + version + "-" + versionCounter; TransactionJMXRegistrator transactionRegistrator = baseJMXRegistrator .createTransactionJMXRegistrator(transactionName); + List allCurrentFactories = Collections.unmodifiableList(resolver.getAllFactories()); ConfigTransactionControllerInternal transactionController = new ConfigTransactionControllerImpl( transactionName, transactionRegistrator, version, - versionCounter, resolver.getAllFactories(), - transactionsMBeanServer, configMBeanServer); + versionCounter, allCurrentFactories, transactionsMBeanServer, configMBeanServer); try { - transactionRegistrator.registerMBean(transactionController, transactionController.getControllerObjectName - ()); + transactionRegistrator.registerMBean(transactionController, transactionController.getControllerObjectName()); } catch (InstanceAlreadyExistsException e) { throw new IllegalStateException(e); } - // copy old configuration to this server - for (ModuleInternalInfo oldConfigInfo : currentConfig.getEntries()) { - try { - transactionController.copyExistingModule(oldConfigInfo); - } catch (InstanceAlreadyExistsException e) { - throw new IllegalStateException("Error while copying " - + oldConfigInfo, e); - } - } + transactionController.copyExistingModulesAndProcessFactoryDiff(currentConfig.getEntries(), lastListOfFactories); + transactionsHolder.add(transactionName, transactionController); return transactionController; } @@ -162,20 +155,15 @@ public class ConfigRegistryImpl implements AutoCloseable, * {@inheritDoc} */ @Override - public synchronized CommitStatus commitConfig( - ObjectName transactionControllerON) + public synchronized CommitStatus commitConfig(ObjectName transactionControllerON) throws ConflictingVersionException, ValidationException { final String transactionName = ObjectNameUtil .getTransactionName(transactionControllerON); - logger.info( - "About to commit {}. Current parentVersion: {}, versionCounter {}", - transactionName, version, versionCounter); + logger.info("About to commit {}. Current parentVersion: {}, versionCounter {}", transactionName, version, versionCounter); // find ConfigTransactionController - Map transactions = transactionsHolder - .getCurrentTransactions(); - ConfigTransactionControllerInternal configTransactionController = transactions - .get(transactionName); + Map transactions = transactionsHolder.getCurrentTransactions(); + ConfigTransactionControllerInternal configTransactionController = transactions.get(transactionName); if (configTransactionController == null) { throw new IllegalArgumentException(String.format( "Transaction with name '%s' not found", transactionName)); @@ -190,33 +178,28 @@ public class ConfigRegistryImpl implements AutoCloseable, } // optimistic lock ok - CommitInfo commitInfo = configTransactionController - .validateBeforeCommitAndLockTransaction(); - final ConfigRegistryImpl a = this; + CommitInfo commitInfo = configTransactionController.validateBeforeCommitAndLockTransaction(); + lastListOfFactories = Collections.unmodifiableList(configTransactionController.getCurrentlyRegisteredFactories()); // non recoverable from here: try { - final CommitStatus secondPhaseCommitStatus = secondPhaseCommit( + return secondPhaseCommit( configTransactionController, commitInfo); - - return secondPhaseCommitStatus; } catch (Throwable t) { // some libs throw Errors: e.g. // javax.xml.ws.spi.FactoryFinder$ConfigurationError isHealthy = false; - logger.error( - "Configuration Transaction failed on 2PC, server is unhealthy", - t); - if (t instanceof RuntimeException) + logger.error("Configuration Transaction failed on 2PC, server is unhealthy", t); + if (t instanceof RuntimeException) { throw (RuntimeException) t; - else if (t instanceof Error) + } else if (t instanceof Error) { throw (Error) t; - else + } else { throw new RuntimeException(t); + } } } - private CommitStatus secondPhaseCommit( - ConfigTransactionControllerInternal configTransactionController, - CommitInfo commitInfo) { + private CommitStatus secondPhaseCommit(ConfigTransactionControllerInternal configTransactionController, + CommitInfo commitInfo) { // close instances which were destroyed by the user, including // (hopefully) runtime beans 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 5038079c22..5e8fac6048 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 @@ -9,10 +9,8 @@ package org.opendaylight.controller.config.manager.impl; import static java.lang.String.format; -import java.util.ArrayList; -import java.util.List; +import java.util.*; import java.util.Map.Entry; -import java.util.Set; import java.util.concurrent.atomic.AtomicBoolean; import javax.annotation.Nullable; @@ -50,8 +48,7 @@ import org.slf4j.LoggerFactory; class ConfigTransactionControllerImpl implements ConfigTransactionControllerInternal, ConfigTransactionControllerImplMXBean { - private static final Logger logger = LoggerFactory - .getLogger(ConfigTransactionControllerImpl.class); + private static final Logger logger = LoggerFactory.getLogger(ConfigTransactionControllerImpl.class); private final TransactionIdentifier transactionIdentifier; private final ObjectName controllerON; @@ -62,6 +59,7 @@ class ConfigTransactionControllerImpl implements private final DependencyResolverManager dependencyResolverManager; private final TransactionStatus transactionStatus; private final MBeanServer transactionsMBeanServer; + private final List currentlyRegisteredFactories; /** * Disables ability of {@link DynamicWritableWrapper} to change attributes @@ -77,7 +75,7 @@ class ConfigTransactionControllerImpl implements public ConfigTransactionControllerImpl(String transactionName, TransactionJMXRegistrator transactionRegistrator, long parentVersion, long currentVersion, - List currentlyRegisteredFactories, + List currentlyRegisteredFactories, MBeanServer transactionsMBeanServer, MBeanServer configMBeanServer) { this.transactionIdentifier = new TransactionIdentifier(transactionName); @@ -88,17 +86,69 @@ class ConfigTransactionControllerImpl implements .createTransactionModuleJMXRegistrator(); this.parentVersion = parentVersion; this.currentVersion = currentVersion; - this.factoriesHolder = new HierarchicalConfigMBeanFactoriesHolder( - currentlyRegisteredFactories); + this.currentlyRegisteredFactories = currentlyRegisteredFactories; + this.factoriesHolder = new HierarchicalConfigMBeanFactoriesHolder(currentlyRegisteredFactories); this.transactionStatus = new TransactionStatus(); - this.dependencyResolverManager = new DependencyResolverManager( - transactionName, transactionStatus); + this.dependencyResolverManager = new DependencyResolverManager(transactionName, transactionStatus); this.transactionsMBeanServer = transactionsMBeanServer; this.configMBeanServer = configMBeanServer; } @Override - public synchronized void copyExistingModule( + public void copyExistingModulesAndProcessFactoryDiff(Collection existingModules, List lastListOfFactories) { + // copy old configuration to this server + for (ModuleInternalInfo oldConfigInfo : existingModules) { + try { + copyExistingModule(oldConfigInfo); + } catch (InstanceAlreadyExistsException e) { + throw new IllegalStateException("Error while copying " + oldConfigInfo, e); + } + } + processDefaultBeans(lastListOfFactories); + } + + private synchronized void processDefaultBeans(List lastListOfFactories) { + transactionStatus.checkNotCommitStarted(); + transactionStatus.checkNotAborted(); + + Set oldSet = new HashSet<>(lastListOfFactories); + Set newSet = new HashSet<>(currentlyRegisteredFactories); + + List toBeAdded = new ArrayList<>(); + List toBeRemoved = new ArrayList<>(); + for(ModuleFactory moduleFactory: currentlyRegisteredFactories) { + if (oldSet.contains(moduleFactory) == false){ + toBeAdded.add(moduleFactory); + } + } + for(ModuleFactory moduleFactory: lastListOfFactories){ + if (newSet.contains(moduleFactory) == false) { + toBeRemoved.add(moduleFactory); + } + } + // add default modules + for (ModuleFactory moduleFactory : toBeAdded) { + Set defaultModules = moduleFactory.getDefaultModules(dependencyResolverManager); + for (Module module : defaultModules) { + try { + putConfigBeanToJMXAndInternalMaps(module.getName(), module, moduleFactory, null); + } catch (InstanceAlreadyExistsException e) { + throw new IllegalStateException(e); + } + } + } + + // remove modules belonging to removed factories + for(ModuleFactory removedFactory: toBeRemoved){ + List modulesOfRemovedFactory = dependencyResolverManager.findAllByFactory(removedFactory); + for (ModuleIdentifier name : modulesOfRemovedFactory) { + destroyModule(name); + } + } + } + + + private synchronized void copyExistingModule( ModuleInternalInfo oldConfigBeanInfo) throws InstanceAlreadyExistsException { transactionStatus.checkNotCommitStarted(); @@ -121,8 +171,7 @@ class ConfigTransactionControllerImpl implements "Error while copying old configuration from %s to %s", oldConfigBeanInfo, moduleFactory), e); } - putConfigBeanToJMXAndInternalMaps(moduleIdentifier, module, - moduleFactory, oldConfigBeanInfo); + putConfigBeanToJMXAndInternalMaps(moduleIdentifier, module, moduleFactory, oldConfigBeanInfo); } @Override @@ -131,17 +180,13 @@ class ConfigTransactionControllerImpl implements transactionStatus.checkNotCommitStarted(); transactionStatus.checkNotAborted(); - ModuleIdentifier moduleIdentifier = new ModuleIdentifier(factoryName, - instanceName); + ModuleIdentifier moduleIdentifier = new ModuleIdentifier(factoryName, instanceName); dependencyResolverManager.assertNotExists(moduleIdentifier); // find factory - ModuleFactory moduleFactory = factoriesHolder - .findByModuleName(factoryName); - DependencyResolver dependencyResolver = dependencyResolverManager - .getOrCreate(moduleIdentifier); - Module module = moduleFactory.createModule(instanceName, - dependencyResolver); + ModuleFactory moduleFactory = factoriesHolder.findByModuleName(factoryName); + DependencyResolver dependencyResolver = dependencyResolverManager.getOrCreate(moduleIdentifier); + Module module = moduleFactory.createModule(instanceName, dependencyResolver); return putConfigBeanToJMXAndInternalMaps(moduleIdentifier, module, moduleFactory, null); } @@ -151,7 +196,11 @@ class ConfigTransactionControllerImpl implements ModuleFactory moduleFactory, @Nullable ModuleInternalInfo maybeOldConfigBeanInfo) throws InstanceAlreadyExistsException { - + logger.debug("Adding module {} to transaction {}", moduleIdentifier, this); + if (moduleIdentifier.equals(module.getName())==false) { + throw new IllegalStateException("Incorrect name reported by module. Expected " + + moduleIdentifier + ", got " + module.getName()); + } DynamicMBean writableDynamicWrapper = new DynamicWritableWrapper( module, moduleIdentifier, transactionIdentifier, readOnlyAtomicBoolean, transactionsMBeanServer, @@ -180,11 +229,15 @@ class ConfigTransactionControllerImpl implements + objectName); } ObjectNameUtil.checkDomain(objectName); - transactionStatus.checkNotAborted(); ModuleIdentifier moduleIdentifier = ObjectNameUtil.fromON(objectName, ObjectNameUtil.TYPE_MODULE); - ModuleInternalTransactionalInfo removedTInfo = dependencyResolverManager - .destroyModule(moduleIdentifier); + destroyModule(moduleIdentifier); + } + + private void destroyModule(ModuleIdentifier moduleIdentifier) { + logger.debug("Destroying module {} in transaction {}", moduleIdentifier, this); + transactionStatus.checkNotAborted(); + ModuleInternalTransactionalInfo removedTInfo = dependencyResolverManager.destroyModule(moduleIdentifier); // remove from jmx removedTInfo.getTransactionModuleJMXRegistration().close(); } @@ -395,4 +448,9 @@ class ConfigTransactionControllerImpl implements public TransactionIdentifier getName() { return transactionIdentifier; } + + @Override + public List getCurrentlyRegisteredFactories() { + return currentlyRegisteredFactories; + } } diff --git a/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/ConfigTransactionControllerInternal.java b/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/ConfigTransactionControllerInternal.java index 58d3bc1e4b..f9699b91cd 100644 --- a/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/ConfigTransactionControllerInternal.java +++ b/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/ConfigTransactionControllerInternal.java @@ -7,13 +7,16 @@ */ package org.opendaylight.controller.config.manager.impl; +import java.util.Collection; import java.util.List; +import java.util.Set; import javax.management.InstanceAlreadyExistsException; import javax.management.ObjectName; import org.opendaylight.controller.config.api.ModuleIdentifier; import org.opendaylight.controller.config.api.ValidationException; +import org.opendaylight.controller.config.spi.ModuleFactory; /** * Defines contract between {@link ConfigTransactionControllerImpl} (producer) @@ -22,11 +25,15 @@ import org.opendaylight.controller.config.api.ValidationException; interface ConfigTransactionControllerInternal extends ConfigTransactionControllerImplMXBean { + + /** - * Copy already committed module to current transaction. + * 1, Copy already committed modules to current transaction. + * 2, Diff: compute added and removed factories from last run, then create new modules using + * {@link org.opendaylight.controller.config.spi.ModuleFactory#getDefaultModules(org.opendaylight.controller.config.api.DependencyResolverFactory)} + * and remove modules belonging to removed factories. */ - void copyExistingModule(ModuleInternalInfo oldConfigBeanInfo) - throws InstanceAlreadyExistsException; + void copyExistingModulesAndProcessFactoryDiff(Collection entries, List lastListOfFactories); /** * Call {@link org.opendaylight.controller.config.spi.Module#validate()} on @@ -62,4 +69,5 @@ interface ConfigTransactionControllerInternal extends */ boolean isClosed(); + List getCurrentlyRegisteredFactories(); } diff --git a/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/ModuleInternalTransactionalInfo.java b/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/ModuleInternalTransactionalInfo.java index a1bc59f5d5..571bbad753 100644 --- a/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/ModuleInternalTransactionalInfo.java +++ b/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/ModuleInternalTransactionalInfo.java @@ -46,7 +46,7 @@ public class ModuleInternalTransactionalInfo { public DestroyedModule toDestroyedModule() { if (maybeOldInternalInfo == null) { - throw new IllegalStateException("Cannot destoy uncommitted module"); + throw new IllegalStateException("Cannot destroy uncommitted module"); } DynamicReadableWrapper oldModule = maybeOldInternalInfo .getReadableModule(); diff --git a/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/dependencyresolver/DependencyResolverManager.java b/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/dependencyresolver/DependencyResolverManager.java index 34b3093f5d..fe94af89fa 100644 --- a/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/dependencyresolver/DependencyResolverManager.java +++ b/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/dependencyresolver/DependencyResolverManager.java @@ -7,15 +7,13 @@ */ package org.opendaylight.controller.config.manager.impl.dependencyresolver; -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; +import java.util.*; import javax.annotation.concurrent.GuardedBy; import javax.management.InstanceAlreadyExistsException; +import org.opendaylight.controller.config.api.DependencyResolver; +import org.opendaylight.controller.config.api.DependencyResolverFactory; import org.opendaylight.controller.config.api.JmxAttribute; import org.opendaylight.controller.config.api.ModuleIdentifier; import org.opendaylight.controller.config.manager.impl.CommitInfo; @@ -29,7 +27,7 @@ import org.opendaylight.controller.config.spi.ModuleFactory; * transaction. Observes usage of DependencyResolver within modules to figure * out dependency tree. */ -public class DependencyResolverManager implements TransactionHolder { +public class DependencyResolverManager implements TransactionHolder, DependencyResolverFactory { @GuardedBy("this") private final Map moduleIdentifiersToDependencyResolverMap = new HashMap<>(); private final ModulesHolder modulesHolder; @@ -41,6 +39,11 @@ public class DependencyResolverManager implements TransactionHolder { this.transactionStatus = transactionStatus; } + @Override + public DependencyResolver createDependencyResolver(ModuleIdentifier moduleIdentifier) { + return getOrCreate(moduleIdentifier); + } + public synchronized DependencyResolverImpl getOrCreate(ModuleIdentifier name) { DependencyResolverImpl dependencyResolver = moduleIdentifiersToDependencyResolverMap .get(name); @@ -128,4 +131,14 @@ public class DependencyResolverManager implements TransactionHolder { throws InstanceAlreadyExistsException { modulesHolder.assertNotExists(moduleIdentifier); } + + public List findAllByFactory(ModuleFactory factory) { + List result = new ArrayList<>(); + for( ModuleInternalTransactionalInfo info : modulesHolder.getAllInfos()) { + if (factory.equals(info.getModuleFactory())) { + result.add(info.getName()); + } + } + return result; + } } diff --git a/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/dependencyresolver/ModulesHolder.java b/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/dependencyresolver/ModulesHolder.java index 7747e55693..65cf9bc4fc 100644 --- a/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/dependencyresolver/ModulesHolder.java +++ b/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/dependencyresolver/ModulesHolder.java @@ -7,13 +7,7 @@ */ package org.opendaylight.controller.config.manager.impl.dependencyresolver; -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; +import java.util.*; import javax.annotation.concurrent.GuardedBy; import javax.management.InstanceAlreadyExistsException; @@ -120,4 +114,8 @@ class ModulesHolder implements TransactionHolder { + moduleIdentifier); } } + + public Collection getAllInfos(){ + return commitMap.values(); + } } diff --git a/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/factoriesresolver/ModuleFactoriesResolver.java b/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/factoriesresolver/ModuleFactoriesResolver.java index 9678d70615..4c6697e6b2 100644 --- a/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/factoriesresolver/ModuleFactoriesResolver.java +++ b/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/factoriesresolver/ModuleFactoriesResolver.java @@ -20,6 +20,6 @@ import org.opendaylight.controller.config.spi.ModuleFactory; */ public interface ModuleFactoriesResolver { - List getAllFactories(); + List getAllFactories(); } diff --git a/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/osgi/BlankTransactionServiceTracker.java b/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/osgi/BlankTransactionServiceTracker.java new file mode 100644 index 0000000000..bcc8b11e07 --- /dev/null +++ b/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/osgi/BlankTransactionServiceTracker.java @@ -0,0 +1,57 @@ +/* + * 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.config.manager.impl.osgi; + +import org.opendaylight.controller.config.api.jmx.CommitStatus; +import org.opendaylight.controller.config.manager.impl.ConfigRegistryImpl; +import org.opendaylight.controller.config.spi.ModuleFactory; +import org.osgi.framework.BundleContext; +import org.osgi.framework.ServiceReference; +import org.osgi.util.tracker.ServiceTrackerCustomizer; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import javax.management.ObjectName; + +/** + * Every time factory is added or removed, blank transaction is triggered to handle + * {@link org.opendaylight.controller.config.spi.ModuleFactory#getDefaultModules(org.opendaylight.controller.config.api.DependencyResolverFactory)} + * functionality. + */ +public class BlankTransactionServiceTracker implements ServiceTrackerCustomizer { + private static final Logger logger = LoggerFactory.getLogger(BlankTransactionServiceTracker.class); + + private final ConfigRegistryImpl configRegistry; + + public BlankTransactionServiceTracker(ConfigRegistryImpl configRegistry) { + this.configRegistry = configRegistry; + } + + @Override + public Object addingService(ServiceReference moduleFactoryServiceReference) { + blankTransaction(); + return null; + } + + private void blankTransaction() { + // create transaction + ObjectName tx = configRegistry.beginConfig(); + CommitStatus commitStatus = configRegistry.commitConfig(tx); + logger.debug("Committed blank transaction with status {}", commitStatus); + } + + @Override + public void modifiedService(ServiceReference moduleFactoryServiceReference, Object o) { + blankTransaction(); + } + + @Override + public void removedService(ServiceReference moduleFactoryServiceReference, Object o) { + blankTransaction(); + } +} diff --git a/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/osgi/BundleContextBackedModuleFactoriesResolver.java b/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/osgi/BundleContextBackedModuleFactoriesResolver.java index 77bfc495b8..7c8c4e6008 100644 --- a/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/osgi/BundleContextBackedModuleFactoriesResolver.java +++ b/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/osgi/BundleContextBackedModuleFactoriesResolver.java @@ -30,7 +30,7 @@ public class BundleContextBackedModuleFactoriesResolver implements } @Override - public List getAllFactories() { + public List getAllFactories() { Collection> serviceReferences; try { serviceReferences = bundleContext.getServiceReferences( diff --git a/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/osgi/ConfigManagerActivator.java b/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/osgi/ConfigManagerActivator.java index 81b9ea9606..f567f1b31e 100644 --- a/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/osgi/ConfigManagerActivator.java +++ b/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/osgi/ConfigManagerActivator.java @@ -13,8 +13,10 @@ import javax.management.MBeanServer; import org.opendaylight.controller.config.manager.impl.ConfigRegistryImpl; import org.opendaylight.controller.config.manager.impl.jmx.ConfigRegistryJMXRegistrator; +import org.opendaylight.controller.config.spi.ModuleFactory; import org.osgi.framework.BundleActivator; import org.osgi.framework.BundleContext; +import org.osgi.util.tracker.ServiceTracker; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -28,21 +30,24 @@ public class ConfigManagerActivator implements BundleActivator { @Override public void start(BundleContext context) throws Exception { - extenderBundleTracker = new ExtenderBundleTracker(context); - extenderBundleTracker.open(); - BundleContextBackedModuleFactoriesResolver bundleContextBackedModuleFactoriesResolver = new BundleContextBackedModuleFactoriesResolver( - context); - - MBeanServer configMBeanServer = ManagementFactory - .getPlatformMBeanServer(); + BundleContextBackedModuleFactoriesResolver bundleContextBackedModuleFactoriesResolver = + new BundleContextBackedModuleFactoriesResolver(context); + MBeanServer configMBeanServer = ManagementFactory.getPlatformMBeanServer(); configRegistry = new ConfigRegistryImpl( bundleContextBackedModuleFactoriesResolver, context, configMBeanServer); - // register config registry to jmx - configRegistryJMXRegistrator = new ConfigRegistryJMXRegistrator( - configMBeanServer); + // register config registry to jmx + configRegistryJMXRegistrator = new ConfigRegistryJMXRegistrator(configMBeanServer); configRegistryJMXRegistrator.registerToJMX(configRegistry); + + // track bundles containing factories + extenderBundleTracker = new ExtenderBundleTracker(context); + extenderBundleTracker.open(); + + BlankTransactionServiceTracker customizer = new BlankTransactionServiceTracker(configRegistry); + ServiceTracker serviceTracker = new ServiceTracker(context, ModuleFactory.class, customizer); + serviceTracker.open(); } @Override diff --git a/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/osgi/ExtenderBundleTracker.java b/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/osgi/ExtenderBundleTracker.java index 22a1216959..29e7e3a656 100644 --- a/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/osgi/ExtenderBundleTracker.java +++ b/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/osgi/ExtenderBundleTracker.java @@ -14,6 +14,8 @@ import java.net.URL; import java.util.List; import org.apache.commons.io.IOUtils; +import org.opendaylight.controller.config.api.jmx.CommitStatus; +import org.opendaylight.controller.config.manager.impl.ConfigRegistryImpl; import org.opendaylight.controller.config.spi.ModuleFactory; import org.osgi.framework.Bundle; import org.osgi.framework.BundleContext; @@ -24,20 +26,20 @@ import org.osgi.util.tracker.BundleTracker; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import javax.management.ObjectName; + /** * OSGi extender that listens for bundle activation events. Reads file * META-INF/services/org.opendaylight.controller.config.spi.ModuleFactory, each * line should contain an implementation of ModuleFactory interface. Creates new * instance with default constructor and registers it into OSGi service * registry. There is no need for listening for implementing removedBundle as - * the services are unregistered automatically. Code based on - * http://www.toedter.com/blog/?p=236 + * the services are unregistered automatically. + * Code based on http://www.toedter.com/blog/?p=236 */ - public class ExtenderBundleTracker extends BundleTracker { - private static final Logger logger = LoggerFactory - .getLogger(ExtenderBundleTracker.class); + private static final Logger logger = LoggerFactory.getLogger(ExtenderBundleTracker.class); public ExtenderBundleTracker(BundleContext context) { super(context, Bundle.ACTIVE, null); @@ -46,10 +48,8 @@ public class ExtenderBundleTracker extends BundleTracker { @Override public Object addingBundle(Bundle bundle, BundleEvent event) { - URL resource = bundle.getEntry("META-INF/services/" - + ModuleFactory.class.getName()); - logger.trace( - "Got addingBundle event of bundle {}, resource {}, event {}", + URL resource = bundle.getEntry("META-INF/services/" + ModuleFactory.class.getName()); + logger.trace("Got addingBundle event of bundle {}, resource {}, event {}", bundle, resource, event); if (resource != null) { try (InputStream inputStream = resource.openStream()) { @@ -58,29 +58,20 @@ public class ExtenderBundleTracker extends BundleTracker { registerFactory(factoryClassName, bundle); } } catch (Exception e) { - logger.error("Error while reading {}, stopping bundle {}", - resource, bundle, e); - stopBundleQuietly(bundle); + logger.error("Error while reading {}", resource, e); throw new RuntimeException(e); } - } return bundle; } - private static void stopBundleQuietly(Bundle bundle) { - try { - bundle.stop(); - } catch (BundleException e2) { - logger.warn( - "Ignoring fact that bundle.stop failed on {}, reason {}", - bundle, e2.toString()); - } + @Override + public void removedBundle(Bundle bundle, BundleEvent event, Object object) { + super.removedBundle(bundle,event,object); } // TODO:test - private static ServiceRegistration registerFactory( - String factoryClassName, Bundle bundle) { + private static ServiceRegistration registerFactory(String factoryClassName, Bundle bundle) { String errorMessage; try { Class clazz = bundle.loadClass(factoryClassName); diff --git a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/ClassBasedModuleFactory.java b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/ClassBasedModuleFactory.java index afc79a5c16..f0ad562940 100644 --- a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/ClassBasedModuleFactory.java +++ b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/ClassBasedModuleFactory.java @@ -8,11 +8,16 @@ package org.opendaylight.controller.config.manager.impl; import java.lang.reflect.Constructor; +import java.lang.reflect.InvocationTargetException; import java.util.Arrays; +import java.util.HashSet; import java.util.List; +import java.util.Set; import org.opendaylight.controller.config.api.DependencyResolver; +import org.opendaylight.controller.config.api.DependencyResolverFactory; import org.opendaylight.controller.config.api.DynamicMBeanWithInstance; +import org.opendaylight.controller.config.api.ModuleIdentifier; import org.opendaylight.controller.config.api.annotations.AbstractServiceInterface; import org.opendaylight.controller.config.spi.Module; import org.opendaylight.controller.config.spi.ModuleFactory; @@ -21,8 +26,10 @@ import com.google.common.base.Preconditions; import com.google.common.base.Throwables; /** - * Creates new Config beans by calling {@link Class#newInstance()} on provided - * config bean class. + * Creates new modules by reflection. Provided class must have this constructor: + * ctor(DynamicMBeanWithInstance.class, ModuleIdentifier.class). + * When reconfiguring, both parameters will be non null. When creating new + * instance first parameter will be null. * */ public class ClassBasedModuleFactory implements ModuleFactory { @@ -51,28 +58,32 @@ public class ClassBasedModuleFactory implements ModuleFactory { public Module createModule(String instanceName, DependencyResolver dependencyResolver, DynamicMBeanWithInstance old) throws Exception { - Preconditions.checkNotNull(dependencyResolver); Preconditions.checkNotNull(old); + return constructModule(instanceName, dependencyResolver, old); + } + + private Module constructModule(String instanceName, DependencyResolver dependencyResolver, DynamicMBeanWithInstance old) throws InstantiationException, IllegalAccessException, InvocationTargetException { + Preconditions.checkNotNull(dependencyResolver); + ModuleIdentifier moduleIdentifier = new ModuleIdentifier(implementationName, instanceName); Constructor declaredConstructor; try { - declaredConstructor = configBeanClass - .getDeclaredConstructor(DynamicMBeanWithInstance.class); + declaredConstructor = configBeanClass.getDeclaredConstructor(DynamicMBeanWithInstance.class, ModuleIdentifier.class); } catch (NoSuchMethodException e) { throw new IllegalStateException( "Did not find constructor with parameters (DynamicMBeanWithInstance) in " + configBeanClass, e); } Preconditions.checkState(declaredConstructor != null); - return declaredConstructor.newInstance(old); + return declaredConstructor.newInstance(old, moduleIdentifier); } @Override public Module createModule(String instanceName, DependencyResolver dependencyResolver) { try { - return configBeanClass.newInstance(); - } catch (Exception e) { - throw Throwables.propagate(e); + return constructModule(instanceName, dependencyResolver, null); + } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) { + throw new RuntimeException(e); } } @@ -92,4 +103,9 @@ public class ClassBasedModuleFactory implements ModuleFactory { } return false; } + + @Override + public Set getDefaultModules(DependencyResolverFactory dependencyResolverFactory) { + return new HashSet(); + } } diff --git a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/ConfigTransactionControllerImplTest.java b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/ConfigTransactionControllerImplTest.java index 593f99f062..eceb6757ed 100644 --- a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/ConfigTransactionControllerImplTest.java +++ b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/ConfigTransactionControllerImplTest.java @@ -61,7 +61,7 @@ public class ConfigTransactionControllerImplTest extends baseJMXRegistrator = new BaseJMXRegistrator( ManagementFactory.getPlatformMBeanServer()); transactionsMBeanServer = MBeanServerFactory.createMBeanServer(); - List currentlyRegisteredFactories = new ArrayList<>(); + List currentlyRegisteredFactories = new ArrayList<>(); TransactionJMXRegistrator jmxRegistrator123 = baseJMXRegistrator .createTransactionJMXRegistrator(transactionName123); diff --git a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/factoriesresolver/HardcodedModuleFactoriesResolver.java b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/factoriesresolver/HardcodedModuleFactoriesResolver.java index e489a2256b..04f651f6d3 100644 --- a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/factoriesresolver/HardcodedModuleFactoriesResolver.java +++ b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/factoriesresolver/HardcodedModuleFactoriesResolver.java @@ -12,16 +12,15 @@ import java.util.List; import org.opendaylight.controller.config.spi.ModuleFactory; -public class HardcodedModuleFactoriesResolver implements - ModuleFactoriesResolver { - private final List list; +public class HardcodedModuleFactoriesResolver implements ModuleFactoriesResolver { + private final List list; public HardcodedModuleFactoriesResolver(ModuleFactory... list) { this.list = Arrays.asList(list); } @Override - public List getAllFactories() { + public List getAllFactories() { return list; } diff --git a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/testingservices/parallelapsp/TestingParallelAPSPModuleFactory.java b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/testingservices/parallelapsp/TestingParallelAPSPModuleFactory.java index 0a53d75c40..dd83e91747 100644 --- a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/testingservices/parallelapsp/TestingParallelAPSPModuleFactory.java +++ b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/testingservices/parallelapsp/TestingParallelAPSPModuleFactory.java @@ -11,11 +11,16 @@ import javax.annotation.concurrent.ThreadSafe; import javax.management.ObjectName; import org.opendaylight.controller.config.api.DependencyResolver; +import org.opendaylight.controller.config.api.DependencyResolverFactory; import org.opendaylight.controller.config.api.DynamicMBeanWithInstance; import org.opendaylight.controller.config.api.ModuleIdentifier; import org.opendaylight.controller.config.api.annotations.AbstractServiceInterface; +import org.opendaylight.controller.config.spi.Module; import org.opendaylight.controller.config.spi.ModuleFactory; +import java.util.HashSet; +import java.util.Set; + @ThreadSafe public class TestingParallelAPSPModuleFactory implements ModuleFactory { @@ -59,4 +64,9 @@ public class TestingParallelAPSPModuleFactory implements ModuleFactory { Class serviceInterface) { return false; } + + @Override + public Set getDefaultModules(DependencyResolverFactory dependencyResolverFactory) { + return new HashSet(); + } } diff --git a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/testingservices/parallelapsp/test/MockedDependenciesTest.java b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/testingservices/parallelapsp/test/MockedDependenciesTest.java index c27e01f19b..29e91fd924 100644 --- a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/testingservices/parallelapsp/test/MockedDependenciesTest.java +++ b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/testingservices/parallelapsp/test/MockedDependenciesTest.java @@ -49,19 +49,20 @@ public class MockedDependenciesTest extends AbstractParallelAPSPTest { public static class MockedThreadPoolModule implements Module, MockedTestingThreadPoolConfigMXBean, TestingThreadPoolServiceInterface { - int threadCount; - public MockedThreadPoolModule() { - } + private final ModuleIdentifier moduleIdentifier; + + int threadCount; public MockedThreadPoolModule( - DynamicMBeanWithInstance dynamicMBeanWithInstance) { + DynamicMBeanWithInstance dynamicMBeanWithInstance, ModuleIdentifier moduleIdentifier) { // no reconfiguration / reuse is supported + this.moduleIdentifier = moduleIdentifier; } @Override public ModuleIdentifier getName() { - return new ModuleIdentifier("a", "b"); + return moduleIdentifier; } @Override diff --git a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/testingservices/scheduledthreadpool/TestingScheduledThreadPoolModuleFactory.java b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/testingservices/scheduledthreadpool/TestingScheduledThreadPoolModuleFactory.java index 8244bc153d..c4426d18e3 100644 --- a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/testingservices/scheduledthreadpool/TestingScheduledThreadPoolModuleFactory.java +++ b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/testingservices/scheduledthreadpool/TestingScheduledThreadPoolModuleFactory.java @@ -8,9 +8,12 @@ package org.opendaylight.controller.config.manager.testingservices.scheduledthreadpool; import java.util.Arrays; +import java.util.HashSet; import java.util.List; +import java.util.Set; import org.opendaylight.controller.config.api.DependencyResolver; +import org.opendaylight.controller.config.api.DependencyResolverFactory; import org.opendaylight.controller.config.api.DynamicMBeanWithInstance; import org.opendaylight.controller.config.api.ModuleIdentifier; import org.opendaylight.controller.config.api.annotations.AbstractServiceInterface; @@ -63,4 +66,8 @@ public class TestingScheduledThreadPoolModuleFactory implements ModuleFactory { return configBean; } + @Override + public Set getDefaultModules(DependencyResolverFactory dependencyResolverFactory) { + return new HashSet(); + } } diff --git a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/testingservices/threadpool/TestingFixedThreadPoolModuleFactory.java b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/testingservices/threadpool/TestingFixedThreadPoolModuleFactory.java index ba60b39ca1..2c6ba1715d 100644 --- a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/testingservices/threadpool/TestingFixedThreadPoolModuleFactory.java +++ b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/testingservices/threadpool/TestingFixedThreadPoolModuleFactory.java @@ -8,9 +8,12 @@ package org.opendaylight.controller.config.manager.testingservices.threadpool; import java.util.Arrays; +import java.util.HashSet; import java.util.List; +import java.util.Set; import org.opendaylight.controller.config.api.DependencyResolver; +import org.opendaylight.controller.config.api.DependencyResolverFactory; import org.opendaylight.controller.config.api.DynamicMBeanWithInstance; import org.opendaylight.controller.config.api.ModuleIdentifier; import org.opendaylight.controller.config.api.annotations.AbstractServiceInterface; @@ -62,4 +65,9 @@ public class TestingFixedThreadPoolModuleFactory implements ModuleFactory { Class serviceInterface) { return ifc.contains(serviceInterface); } + + @Override + public Set getDefaultModules(DependencyResolverFactory dependencyResolverFactory) { + return new HashSet(); + } } diff --git a/opendaylight/config/config-persister-api/pom.xml b/opendaylight/config/config-persister-api/pom.xml index 867c12c18c..504c295639 100644 --- a/opendaylight/config/config-persister-api/pom.xml +++ b/opendaylight/config/config-persister-api/pom.xml @@ -4,7 +4,7 @@ config-subsystem org.opendaylight.controller - 0.2.1-SNAPSHOT + 0.2.2-SNAPSHOT .. config-persister-api @@ -15,7 +15,6 @@ ${project.groupId} config-util - 0.2.1-SNAPSHOT com.google.guava diff --git a/opendaylight/config/config-persister-file-adapter/pom.xml b/opendaylight/config/config-persister-file-adapter/pom.xml index 45683f578e..a5c026da27 100644 --- a/opendaylight/config/config-persister-file-adapter/pom.xml +++ b/opendaylight/config/config-persister-file-adapter/pom.xml @@ -6,7 +6,7 @@ config-subsystem org.opendaylight.controller - 0.2.1-SNAPSHOT + 0.2.2-SNAPSHOT .. config-persister-file-adapter @@ -18,7 +18,6 @@ ${project.groupId} config-persister-api - ${project.version} org.apache.commons @@ -37,7 +36,6 @@ org.opendaylight.bgpcep mockito-configuration - ${bgpcep.version} test diff --git a/opendaylight/config/config-util/pom.xml b/opendaylight/config/config-util/pom.xml index 443b06cdd2..bf681b1065 100644 --- a/opendaylight/config/config-util/pom.xml +++ b/opendaylight/config/config-util/pom.xml @@ -4,7 +4,7 @@ config-subsystem org.opendaylight.controller - 0.2.1-SNAPSHOT + 0.2.2-SNAPSHOT .. config-util @@ -16,7 +16,6 @@ ${project.groupId} config-api - 0.2.1-SNAPSHOT org.jolokia diff --git a/opendaylight/config/logback-config/pom.xml b/opendaylight/config/logback-config/pom.xml index 7b38737411..451ac3e27e 100644 --- a/opendaylight/config/logback-config/pom.xml +++ b/opendaylight/config/logback-config/pom.xml @@ -6,7 +6,7 @@ org.opendaylight.controller config-subsystem - 0.2.1-SNAPSHOT + 0.2.2-SNAPSHOT logback-config ${project.artifactId} @@ -19,7 +19,6 @@ ${project.groupId} config-api - 0.2.1-SNAPSHOT org.slf4j @@ -28,12 +27,10 @@ ch.qos.logback logback-classic - ${logback.version} ch.qos.logback logback-core - ${logback.version} @@ -50,26 +47,22 @@ ${project.groupId} config-manager - 0.2.1-SNAPSHOT test test-jar ${project.groupId} config-manager - 0.2.1-SNAPSHOT test ${project.groupId} config-util - 0.2.1-SNAPSHOT test org.opendaylight.bgpcep mockito-configuration - ${bgpcep.version} test diff --git a/opendaylight/config/pom.xml b/opendaylight/config/pom.xml index 1812fbb449..1ea922e07e 100755 --- a/opendaylight/config/pom.xml +++ b/opendaylight/config/pom.xml @@ -10,8 +10,7 @@ - org.opendaylight.controller - 0.2.1-SNAPSHOT + 0.2.2-SNAPSHOT config-subsystem pom ${project.artifactId} @@ -114,6 +113,96 @@ commons-lang3 ${commons.lang.version} + + + ${project.groupId} + config-api + ${config.version} + + + + ${project.groupId} + config-util + ${config.version} + + + ${project.groupId} + config-util + ${config.version} + test-jar + + + ${project.groupId} + config-manager + ${config.version} + + + ${project.groupId} + config-manager + ${config.version} + test-jar + + + ${project.groupId} + config-persister-api + ${config.version} + + + org.opendaylight.bgpcep + mockito-configuration + ${bgpcep.version} + + + org.opendaylight.yangtools + binding-generator-spi + ${opendaylight.binding.version} + + + org.opendaylight.yangtools + binding-generator-util + ${opendaylight.binding.version} + + + org.opendaylight.yangtools + yang-parser-impl + ${opendaylight.yang.version} + + + org.opendaylight.yangtools + binding-generator-impl + ${opendaylight.binding.version} + + + ${project.groupId} + yang-test + ${config.version} + + + org.opendaylight.controller + yang-jmx-generator + ${config.version} + + + org.opendaylight.controller + yang-jmx-generator + ${config.version} + test-jar + + + org.opendaylight.yangtools + binding-type-provider + ${opendaylight.binding.version} + + + org.opendaylight.yangtools + yang-maven-plugin-spi + ${opendaylight.yang.version} + + + ${project.groupId} + yang-store-api + ${config.version} + @@ -167,6 +256,9 @@ build-helper-maven-plugin + + + @@ -200,7 +292,7 @@ org.opendaylight.controller yang-jmx-generator-plugin - 0.2.1-SNAPSHOT + ${config.version} diff --git a/opendaylight/config/yang-jmx-generator-it/pom.xml b/opendaylight/config/yang-jmx-generator-it/pom.xml index 6168ea6139..336d0c3b82 100644 --- a/opendaylight/config/yang-jmx-generator-it/pom.xml +++ b/opendaylight/config/yang-jmx-generator-it/pom.xml @@ -6,7 +6,7 @@ config-subsystem org.opendaylight.controller - 0.2.1-SNAPSHOT + 0.2.2-SNAPSHOT yang-jmx-generator-it @@ -16,38 +16,32 @@ ${project.groupId} config-api - 0.2.1-SNAPSHOT test ${project.groupId} yang-test - 0.2.1-SNAPSHOT test ${project.groupId} config-manager - 0.2.1-SNAPSHOT test test-jar ${project.groupId} config-manager - 0.2.1-SNAPSHOT test ${project.groupId} config-util - 0.2.1-SNAPSHOT test org.opendaylight.bgpcep mockito-configuration - ${bgpcep.version} test diff --git a/opendaylight/config/yang-jmx-generator-plugin/pom.xml b/opendaylight/config/yang-jmx-generator-plugin/pom.xml index 48fbe05514..eca5037ed3 100644 --- a/opendaylight/config/yang-jmx-generator-plugin/pom.xml +++ b/opendaylight/config/yang-jmx-generator-plugin/pom.xml @@ -4,10 +4,11 @@ config-subsystem org.opendaylight.controller - 0.2.1-SNAPSHOT + 0.2.2-SNAPSHOT .. yang-jmx-generator-plugin + @@ -18,19 +19,16 @@ org.opendaylight.controller yang-jmx-generator - 0.2.1-SNAPSHOT org.opendaylight.yangtools yang-maven-plugin-spi - ${opendaylight.yang.version} org.opendaylight.yangtools binding-type-provider - ${opendaylight.binding.version} @@ -49,7 +47,6 @@ ${project.groupId} config-api - 0.2.1-SNAPSHOT @@ -58,7 +55,6 @@ - com.googlecode.slf4j-maven-plugin-log slf4j-maven-plugin-log 1.0.0 @@ -72,7 +68,6 @@ org.opendaylight.controller yang-jmx-generator - 0.2.1-SNAPSHOT test test-jar @@ -87,7 +82,6 @@ org.opendaylight.bgpcep mockito-configuration - ${bgpcep.version} test diff --git a/opendaylight/config/yang-jmx-generator-plugin/src/main/resources/freeMarker/factory_abs_template.ftl b/opendaylight/config/yang-jmx-generator-plugin/src/main/resources/freeMarker/factory_abs_template.ftl index adfbcebd0b..5fd1496f40 100644 --- a/opendaylight/config/yang-jmx-generator-plugin/src/main/resources/freeMarker/factory_abs_template.ftl +++ b/opendaylight/config/yang-jmx-generator-plugin/src/main/resources/freeMarker/factory_abs_template.ftl @@ -60,4 +60,9 @@ package ${packageName}; throw new UnsupportedOperationException("Class reloading is not supported"); } + @Override + public java.util.Set<${moduleInstanceType}> getDefaultModules(org.opendaylight.controller.config.api.DependencyResolverFactory dependencyResolverFactory) { + return new java.util.HashSet<${moduleInstanceType}>(); + } + } diff --git a/opendaylight/config/yang-jmx-generator-plugin/src/test/java/org/opendaylight/controller/config/yangjmxgenerator/plugin/JMXGeneratorTest.java b/opendaylight/config/yang-jmx-generator-plugin/src/test/java/org/opendaylight/controller/config/yangjmxgenerator/plugin/JMXGeneratorTest.java index 0c2678fd53..d4e6a22dcd 100644 --- a/opendaylight/config/yang-jmx-generator-plugin/src/test/java/org/opendaylight/controller/config/yangjmxgenerator/plugin/JMXGeneratorTest.java +++ b/opendaylight/config/yang-jmx-generator-plugin/src/test/java/org/opendaylight/controller/config/yangjmxgenerator/plugin/JMXGeneratorTest.java @@ -24,14 +24,7 @@ import static org.mockito.Mockito.mock; import java.io.File; import java.io.IOException; import java.nio.charset.Charset; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; +import java.util.*; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; @@ -476,8 +469,16 @@ public class JMXGeneratorTest extends AbstractGeneratorTest { assertEquals(2, fieldDeclarations.size()); - assertEquals("Incorrenct number of generated methods", 5, - visitor.methods.size()); + + Set expectedMethods = new HashSet<>(Arrays.asList("String getImplementationName()", + "org.opendaylight.controller.config.spi.Module createModule(String instanceName,org.opendaylight.controller.config.api.DependencyResolver dependencyResolver)", + "org.opendaylight.controller.config.spi.Module createModule(String instanceName,org.opendaylight.controller.config.api.DependencyResolver dependencyResolver,org.opendaylight.controller.config.api.DynamicMBeanWithInstance old)", + "org.opendaylight.controller.config.threads.java.NamingThreadFactoryModule handleChangedClass(org.opendaylight.controller.config.api.DynamicMBeanWithInstance old)", + "org.opendaylight.controller.config.threads.java.NamingThreadFactoryModule instantiateModule(String instanceName,org.opendaylight.controller.config.api.DependencyResolver dependencyResolver,org.opendaylight.controller.config.threads.java.NamingThreadFactoryModule oldModule,java.lang.AutoCloseable oldInstance)", + "org.opendaylight.controller.config.threads.java.NamingThreadFactoryModule instantiateModule(String instanceName,org.opendaylight.controller.config.api.DependencyResolver dependencyResolver)", + "java.util.Set getDefaultModules(org.opendaylight.controller.config.api.DependencyResolverFactory dependencyResolverFactory)", + "boolean isModuleImplementingServiceInterface(Class serviceInterface)")); + assertEquals("Incorrenct number of generated methods", expectedMethods, visitor.methods); assertEquals("Incorrenct number of generated method descriptions", 0, visitor.methodDescriptions.size()); assertEquals("Incorrenct number of generated method javadoc", 0, @@ -536,8 +537,8 @@ public class JMXGeneratorTest extends AbstractGeneratorTest { visitor.methodDescriptions.size()); assertEquals("Incorrenct number of generated method javadoc", 3, visitor.methodJavadoc.size()); - assertNotNull("Missing javadoc for setMaximumSize method", - visitor.methodJavadoc.get("setMaximumSize")); + assertNotNull("Missing javadoc for setMaximumSize method " + visitor.methodJavadoc, + visitor.methodJavadoc.get("void setMaximumSize(java.lang.Long maximumSize)")); } private void assertDeclaredField(Set fieldDeclarations, @@ -602,7 +603,7 @@ public class JMXGeneratorTest extends AbstractGeneratorTest { private String implmts; private final Set fieldDeclarations = Sets.newHashSet(); private final Set constructors = Sets.newHashSet(); - private final Map methods = Maps.newHashMap(); + private final Set methods = new HashSet(); private final Map requireIfc = Maps.newHashMap(); private final Map methodJavadoc = Maps.newHashMap(); @@ -631,10 +632,21 @@ public class JMXGeneratorTest extends AbstractGeneratorTest { if (node.isConstructor()) constructors.add(node.toString()); else { - String methodName = node.getName().toString(); - if (node.getJavadoc() != null) - methodJavadoc.put(methodName, node.getJavadoc().toString()); - methods.put(methodName, node.toString()); + String methodSignature = node.getReturnType2() + " " + node.getName() + "("; + boolean first = true; + for (Object o : node.parameters()) { + if (first){ + first = false; + } else { + methodSignature += ","; + } + methodSignature += o.toString(); + } + methodSignature += ")"; + methods.add(methodSignature); + if (node.getJavadoc() != null) { + methodJavadoc.put(methodSignature, node.getJavadoc().toString()); + } } return super.visit(node); } diff --git a/opendaylight/config/yang-jmx-generator/pom.xml b/opendaylight/config/yang-jmx-generator/pom.xml index 0f7fe6e781..37846384bf 100644 --- a/opendaylight/config/yang-jmx-generator/pom.xml +++ b/opendaylight/config/yang-jmx-generator/pom.xml @@ -6,7 +6,7 @@ config-subsystem org.opendaylight.controller - 0.2.1-SNAPSHOT + 0.2.2-SNAPSHOT yang-jmx-generator @@ -22,15 +22,11 @@ org.opendaylight.yangtools binding-generator-spi - ${opendaylight.binding.version} org.opendaylight.yangtools binding-generator-util - ${opendaylight.binding.version} - - com.google.guava guava @@ -39,25 +35,21 @@ org.opendaylight.bgpcep mockito-configuration - ${bgpcep.version} test org.opendaylight.yangtools yang-parser-impl - ${opendaylight.yang.version} test ${project.groupId} config-api - 0.2.1-SNAPSHOT test org.opendaylight.yangtools binding-generator-impl - ${opendaylight.binding.version} test diff --git a/opendaylight/config/yang-store-api/pom.xml b/opendaylight/config/yang-store-api/pom.xml index 4393903fd5..6e850b2566 100644 --- a/opendaylight/config/yang-store-api/pom.xml +++ b/opendaylight/config/yang-store-api/pom.xml @@ -4,19 +4,17 @@ config-subsystem org.opendaylight.controller - 0.2.1-SNAPSHOT + 0.2.2-SNAPSHOT .. yang-store-api ${project.artifactId} bundle - ${config.yangstore.version} org.opendaylight.controller yang-jmx-generator - ${config.version} diff --git a/opendaylight/config/yang-store-impl/pom.xml b/opendaylight/config/yang-store-impl/pom.xml index c9105262f9..07ac4d4bb6 100644 --- a/opendaylight/config/yang-store-impl/pom.xml +++ b/opendaylight/config/yang-store-impl/pom.xml @@ -4,19 +4,17 @@ config-subsystem org.opendaylight.controller - 0.2.1-SNAPSHOT + 0.2.2-SNAPSHOT .. yang-store-impl ${project.artifactId} bundle - ${config.yangstore.version} ${project.groupId} yang-store-api - ${config.yangstore.version} org.osgi @@ -29,12 +27,10 @@ ${project.groupId} yang-jmx-generator - ${config.version} org.opendaylight.yangtools binding-type-provider - ${opendaylight.binding.version} commons-io @@ -47,7 +43,6 @@ org.opendaylight.bgpcep mockito-configuration - ${bgpcep.version} test diff --git a/opendaylight/config/yang-test/pom.xml b/opendaylight/config/yang-test/pom.xml index 626032f195..3de06882a6 100644 --- a/opendaylight/config/yang-test/pom.xml +++ b/opendaylight/config/yang-test/pom.xml @@ -5,19 +5,22 @@ org.opendaylight.controller config-subsystem - 0.2.1-SNAPSHOT + 0.2.2-SNAPSHOT yang-test Artifact that contains only generated code from yang files. Suitable for testing. + ${project.artifactId} + + 3.0.4 + ${project.groupId} config-api - 0.2.1-SNAPSHOT org.slf4j @@ -29,10 +32,7 @@ - ${project.artifactId} - - 3.0.4 - + diff --git a/opendaylight/distribution/opendaylight/pom.xml b/opendaylight/distribution/opendaylight/pom.xml index 5927d26bd7..81164ae752 100644 --- a/opendaylight/distribution/opendaylight/pom.xml +++ b/opendaylight/distribution/opendaylight/pom.xml @@ -160,12 +160,12 @@ org.opendaylight.controller yang-store-api - ${config.yangstore.version} + ${config.version} org.opendaylight.controller yang-store-impl - ${config.yangstore.version} + ${config.version} org.opendaylight.controller diff --git a/opendaylight/netconf/pom.xml b/opendaylight/netconf/pom.xml index b9f9314499..8436a1388b 100644 --- a/opendaylight/netconf/pom.xml +++ b/opendaylight/netconf/pom.xml @@ -93,12 +93,12 @@ ${project.groupId} yang-store-api - ${config.yangstore.version} + ${config.version} ${project.groupId} yang-store-impl - ${config.yangstore.version} + ${config.version} ${project.groupId}