<artifactId>yang-ext</artifactId>
<version>${yang-ext.version}</version>
</dependency>
-
<!-- bgppcep dependencies -->
<dependency>
<groupId>org.opendaylight.bgpcep</groupId>
<artifactId>util</artifactId>
<version>${bgpcep.version}</version>
</dependency>
-
- <dependency>
- <groupId>org.opendaylight.bgpcep</groupId>
- <artifactId>framework</artifactId>
- <version>${bgpcep.version}</version>
- </dependency>
-
+ <dependency>
+ <groupId>org.opendaylight.bgpcep</groupId>
+ <artifactId>framework</artifactId>
+ <version>${bgpcep.version}</version>
+ </dependency>
<!--Netty-->
<dependency>
<groupId>io.netty</groupId>
target
.classpath
.settings
+/target
<groupId>org.osgi</groupId>
<artifactId>org.osgi.core</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>concepts</artifactId>
+ <version>${opendaylight.yangtools.version}</version>
+ </dependency>
</dependencies>
<build>
<instructions>
<Import-Package>
javax.management,
- org.opendaylight.protocol.concepts,
+ org.opendaylight.yangtools.concepts,
org.osgi.framework,
</Import-Package>
<Export-Package>
*/
package org.opendaylight.controller.config.api;
-public class ModuleIdentifier {
+import org.opendaylight.yangtools.concepts.Identifier;
+
+public class ModuleIdentifier implements Identifier {
private static final long serialVersionUID = 1L;
private final String factoryName, instanceName;
import org.opendaylight.controller.config.api.ModuleIdentifier;
import org.opendaylight.controller.config.api.annotations.RequireInterface;
+import org.opendaylight.yangtools.concepts.Identifiable;
/**
* </p>
*/
@NotThreadSafe
-public interface Module {
+public interface Module extends Identifiable<ModuleIdentifier>{
/**
* This method will be called as first phase in two phase commit. Instance
* can check attributes, but is not allowed to do any kind of work that
*/
AutoCloseable getInstance();
- ModuleIdentifier getName();
-
}
<artifactId>guava</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>concepts</artifactId>
+ <version>${opendaylight.yangtools.version}</version>
+ </dependency>
</dependencies>
<build>
org.slf4j,
javax.management,
org.osgi.framework,
- org.opendaylight.protocol.concepts,
+ org.opendaylight.yangtools.concepts.*,
org.apache.commons.io,
org.osgi.util.tracker,
</Import-Package>
// runtime jmx registrator),
// also closes osgi registration and ModuleJMXRegistrator
// registration
- currentConfig.remove(toBeDestroyed.getName());
+ currentConfig.remove(toBeDestroyed.getIdentifier());
}
// set RuntimeBeanRegistrators on beans implementing
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.opendaylight.yangtools.concepts.Identifiable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*/
class ConfigTransactionControllerImpl implements
ConfigTransactionControllerInternal,
- ConfigTransactionControllerImplMXBean {
+ ConfigTransactionControllerImplMXBean,
+ Identifiable<TransactionIdentifier>{
private static final Logger logger = LoggerFactory.getLogger(ConfigTransactionControllerImpl.class);
private final TransactionIdentifier transactionIdentifier;
Set<? extends Module> defaultModules = moduleFactory.getDefaultModules(dependencyResolverManager);
for (Module module : defaultModules) {
try {
- putConfigBeanToJMXAndInternalMaps(module.getName(), module, moduleFactory, null);
+ putConfigBeanToJMXAndInternalMaps(module.getIdentifier(), module, moduleFactory, null);
} catch (InstanceAlreadyExistsException e) {
throw new IllegalStateException(e);
}
@Nullable ModuleInternalInfo maybeOldConfigBeanInfo)
throws InstanceAlreadyExistsException {
logger.debug("Adding module {} to transaction {}", moduleIdentifier, this);
- if (moduleIdentifier.equals(module.getName())==false) {
+ if (moduleIdentifier.equals(module.getIdentifier())==false) {
throw new IllegalStateException("Incorrect name reported by module. Expected "
- + moduleIdentifier + ", got " + module.getName());
+ + moduleIdentifier + ", got " + module.getIdentifier());
}
DynamicMBean writableDynamicWrapper = new DynamicWritableWrapper(
module, moduleIdentifier, transactionIdentifier,
public List<ModuleFactory> getCurrentlyRegisteredFactories() {
return currentlyRegisteredFactories;
}
+
+ @Override
+ public TransactionIdentifier getIdentifier() {
+ return transactionIdentifier;
+ }
}
import org.opendaylight.controller.config.api.ModuleIdentifier;
import org.opendaylight.controller.config.manager.impl.jmx.ModuleJMXRegistrator;
import org.opendaylight.controller.config.manager.impl.osgi.BeanToOsgiServiceManager.OsgiRegistration;
+import org.opendaylight.yangtools.concepts.Identifiable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* compareTo method.
*/
public class DestroyedModule implements AutoCloseable,
- Comparable<DestroyedModule> {
+ Comparable<DestroyedModule>, Identifiable<ModuleIdentifier> {
private static final Logger logger = LoggerFactory
.getLogger(DestroyedModule.class);
- private final ModuleIdentifier name;
+ private final ModuleIdentifier identifier;
private final AutoCloseable instance;
private final ModuleJMXRegistrator oldJMXRegistrator;
private final OsgiRegistration osgiRegistration;
private final int orderingIdx;
- DestroyedModule(ModuleIdentifier name, AutoCloseable instance,
+ DestroyedModule(ModuleIdentifier identifier, AutoCloseable instance,
ModuleJMXRegistrator oldJMXRegistrator,
OsgiRegistration osgiRegistration, int orderingIdx) {
- this.name = name;
+ this.identifier = identifier;
this.instance = instance;
this.oldJMXRegistrator = oldJMXRegistrator;
this.osgiRegistration = osgiRegistration;
this.orderingIdx = orderingIdx;
}
- public ModuleIdentifier getName() {
- return name;
- }
-
@Override
public void close() {
- logger.info("Destroying {}", name);
+ logger.info("Destroying {}", identifier);
try {
instance.close();
} catch (Exception e) {
- logger.error("Error while closing instance of {}", name, e);
+ logger.error("Error while closing instance of {}", identifier, e);
}
try {
oldJMXRegistrator.close();
} catch (Exception e) {
- logger.error("Error while closing jmx registrator of {}", name, e);
+ logger.error("Error while closing jmx registrator of {}", identifier, e);
}
try {
osgiRegistration.close();
} catch (Exception e) {
- logger.error("Error while closing osgi registration of {}", name, e);
+ logger.error("Error while closing osgi registration of {}", identifier, e);
}
}
public int compareTo(DestroyedModule o) {
return Integer.compare(orderingIdx, o.orderingIdx);
}
+
+ @Override
+ public ModuleIdentifier getIdentifier() {
+ return identifier;
+ }
}
import org.opendaylight.controller.config.manager.impl.jmx.ModuleJMXRegistrator;
import org.opendaylight.controller.config.manager.impl.jmx.RootRuntimeBeanRegistratorImpl;
import org.opendaylight.controller.config.manager.impl.osgi.BeanToOsgiServiceManager.OsgiRegistration;
+import org.opendaylight.yangtools.concepts.Identifiable;
/**
* Provides metadata about Module from controller to registry.
*/
-public class ModuleInternalInfo implements Comparable<ModuleInternalInfo> {
+public class ModuleInternalInfo implements Comparable<ModuleInternalInfo>,
+ Identifiable<ModuleIdentifier>{
private final ModuleIdentifier name;
// this registrator is passed to runtime bean registrator and config
return osgiRegistration;
}
+ @Deprecated
public ModuleIdentifier getName() {
return name;
}
getReadableModule().getInstance(), getModuleJMXRegistrator(),
getOsgiRegistration(), getOrderingIdx());
}
+
+ @Override
+ public ModuleIdentifier getIdentifier() {
+ return name;
+ }
}
.TransactionModuleJMXRegistration;
import org.opendaylight.controller.config.spi.Module;
import org.opendaylight.controller.config.spi.ModuleFactory;
+import org.opendaylight.yangtools.concepts.Identifiable;
-public class ModuleInternalTransactionalInfo {
+public class ModuleInternalTransactionalInfo implements Identifiable<ModuleIdentifier> {
private final ModuleIdentifier name;
private final Module module;
private final ModuleFactory moduleFactory;
maybeOldInternalInfo.getOrderingIdx());
}
+ @Deprecated
public Module getModule() {
return module;
}
public TransactionModuleJMXRegistration getTransactionModuleJMXRegistration() {
return transactionModuleJMXRegistration;
}
+
+ @Override
+ public ModuleIdentifier getIdentifier() {
+ return name;
+ }
}
*/
package org.opendaylight.controller.config.manager.impl;
-public class TransactionIdentifier {
+import org.opendaylight.yangtools.concepts.Identifier;
+
+public class TransactionIdentifier implements Identifier {
+
private final String name;
public TransactionIdentifier(String name) {
import org.opendaylight.controller.config.manager.impl.TransactionStatus;
import org.opendaylight.controller.config.spi.Module;
import org.opendaylight.controller.config.spi.ModuleFactory;
+import org.opendaylight.yangtools.concepts.Identifiable;
/**
* Protect {@link org.opendaylight.controller.config.spi.Module#getInstance()}
* during validation. Tracks dependencies for ordering purposes.
*/
final class DependencyResolverImpl implements DependencyResolver,
- Comparable<DependencyResolverImpl> {
+ Identifiable<ModuleIdentifier>, Comparable<DependencyResolverImpl> {
private final ModulesHolder modulesHolder;
private final ModuleIdentifier name;
private final TransactionStatus transactionStatus;
this.modulesHolder = modulesHolder;
}
+ @Deprecated
public ModuleIdentifier getName() {
return name;
}
impl.maxDependencyDepth = maxDepth;
return maxDepth;
}
+
+ @Override
+ public ModuleIdentifier getIdentifier() {
+ return name;
+ }
}
return instance;
}
- @Override
- public ModuleIdentifier getName() {
- return new ModuleIdentifier(getClass().getCanonicalName(), "mock");
- }
}
import org.junit.Test;
import org.opendaylight.controller.config.spi.Module;
+import org.opendaylight.yangtools.concepts.Identifiable;
import com.google.common.collect.Sets;
@Test
public void testGetAllInterfaces() {
Set<Class<?>> expected = Sets.<Class<?>> newHashSet(SuperA.class, SuperBMXBean.class, SuperC.class,
- SubA.class, Module.class);
+ SubA.class, Identifiable.class, Module.class);
assertEquals(expected,
InterfacesHelper.getAllInterfaces(SubClass.class));
}
private final DependencyResolver dependencyResolver;
private final AutoCloseable oldCloseable;
private final TestingParallelAPSPImpl oldInstance;
- private final ModuleIdentifier name;
+ private final ModuleIdentifier identifier;
private ObjectName threadPoolON;
private TestingParallelAPSPImpl instance;
private String someParam;
- public TestingParallelAPSPModule(ModuleIdentifier name,
+ public TestingParallelAPSPModule(ModuleIdentifier identifier,
DependencyResolver dependencyResolver,
@Nullable AutoCloseable oldCloseable,
@Nullable TestingParallelAPSPImpl oldInstance) {
- this.name = name;
+ this.identifier = identifier;
this.dependencyResolver = dependencyResolver;
this.oldCloseable = oldCloseable;
this.oldInstance = oldInstance;
}
- @Override
- public ModuleIdentifier getName() {
- return name;
- }
-
@Override
public ObjectName getThreadPool() {
return threadPoolON;
}
return instance;
}
+
+ @Override
+ public ModuleIdentifier getIdentifier() {
+ return identifier;
+ }
+
+
}
this.moduleIdentifier = moduleIdentifier;
}
- @Override
- public ModuleIdentifier getName() {
- return moduleIdentifier;
- }
-
@Override
public int getThreadCount() {
return threadCount;
public Closeable getInstance() {
return new MockedThreadPool(threadCount);
}
+
+ @Override
+ public ModuleIdentifier getIdentifier() {
+ return moduleIdentifier;
+ }
}
public static class MockedThreadPool implements TestingThreadPoolIfc,
RuntimeBeanRegistratorAwareModule,
TestingScheduledThreadPoolServiceInterface {
- private final ModuleIdentifier name;
+ private final ModuleIdentifier identifier;
@Nullable
private final AutoCloseable oldCloseable;
@Nullable
private RootRuntimeBeanRegistrator runtimeBeanRegistrator;
private boolean recreate;
- public TestingScheduledThreadPoolModule(ModuleIdentifier name,
+ public TestingScheduledThreadPoolModule(ModuleIdentifier identifier,
@Nullable AutoCloseable oldCloseable,
@Nullable TestingScheduledThreadPoolImpl oldInstance) {
- this.name = name;
+ this.identifier = identifier;
this.oldCloseable = oldCloseable;
this.oldInstance = oldInstance;
}
- @Override
- public ModuleIdentifier getName() {
- return name;
- }
-
@Override
public void setRuntimeBeanRegistrator(
RootRuntimeBeanRegistrator runtimeBeanRegistrator) {
this.recreate = recreate;
}
+ @Override
+ public ModuleIdentifier getIdentifier() {
+ return identifier;
+ }
+
+
}
this.oldInstance = oldInstance;
}
- @Override
- public ModuleIdentifier getName() {
- return name;
- }
// attributes
@Override
return instance;
}
+ @Override
+ public ModuleIdentifier getIdentifier() {
+ return name;
+ }
+
}
import org.opendaylight.controller.config.api.JmxAttribute;
import org.opendaylight.controller.config.api.JmxAttributeValidationException;
+import org.opendaylight.controller.config.api.ModuleIdentifier;
import com.google.common.collect.Sets;
return setter;
}
+
}
<jolokia.version>1.1.1</jolokia.version>
<opendaylight.yang.version>0.5.9-SNAPSHOT</opendaylight.yang.version>
<opendaylight.binding.version>0.6.0-SNAPSHOT</opendaylight.binding.version>
+ <opendaylight.yangtools.version>0.1.1-SNAPSHOT</opendaylight.yangtools.version>
<jmxGeneratorPath>${project.build.directory}/generated-sources/config</jmxGeneratorPath>
</properties>
private final ${instanceType} oldInstance;
private ${instanceType} instance;
private final ${dependencyResolverType} dependencyResolver;
- private final ${moduleNameType} name;
+ private final ${moduleNameType} identifier;
<#if runtime=true>
private ${registratorType} rootRuntimeBeanRegistratorWrapper;
</#if>
- public ${typeDeclaration.name}(${moduleNameType} name, ${dependencyResolverType} dependencyResolver) {
- this.name = name;
+ public ${typeDeclaration.name}(${moduleNameType} identifier, ${dependencyResolverType} dependencyResolver) {
+ this.identifier = identifier;
this.dependencyResolver = dependencyResolver;
this.oldInstance = null;
this.oldModule = null;
}
- public ${typeDeclaration.name}(${moduleNameType} name, ${dependencyResolverType} dependencyResolver, ${typeDeclaration.name} oldModule, ${instanceType} oldInstance) {
- this.name = name;
+ public ${typeDeclaration.name}(${moduleNameType} identifier, ${dependencyResolverType} dependencyResolver, ${typeDeclaration.name} oldModule, ${instanceType} oldInstance) {
+ this.identifier = identifier;
this.dependencyResolver = dependencyResolver;
this.oldInstance = oldInstance;
this.oldModule = oldModule;
}
@Override
- public final ${moduleNameType} getName() {
- return name;
+ public ${moduleNameType} getIdentifier() {
+ return identifier;
}
public boolean canReuseInstance(${typeDeclaration.name} oldModule){
<@typeDeclarationD object=typeDeclaration/>
{
- public ${typeDeclaration.name}(${moduleNameType} name, ${dependencyResolverType} dependencyResolver) {
- super(name, dependencyResolver);
+ public ${typeDeclaration.name}(${moduleNameType} identifier, ${dependencyResolverType} dependencyResolver) {
+ super(identifier, dependencyResolver);
}
- public ${typeDeclaration.name}(${moduleNameType} name, ${dependencyResolverType} dependencyResolver, ${typeDeclaration.name} oldModule, ${instanceType} oldInstance) {
- super(name, dependencyResolver, oldModule, oldInstance);
+ public ${typeDeclaration.name}(${moduleNameType} identifier, ${dependencyResolverType} dependencyResolver, ${typeDeclaration.name} oldModule, ${instanceType} oldInstance) {
+ super(identifier, dependencyResolver, oldModule, oldInstance);
}
@Override
*/
package org.opendaylight.controller.config.yang.test.impl;
+import org.opendaylight.controller.config.api.ModuleIdentifier;
+
/**
*
*/
}
};
}
+
}
*/
package org.opendaylight.controller.config.yang.test.impl;
+import org.opendaylight.controller.config.api.ModuleIdentifier;
+
/**
*
*/
}
};
}
+
}
*/
package org.opendaylight.controller.config.yang.test.impl;
+
/**
*
*/
}
};
}
+
}
<dependency>
<groupId>org.opendaylight.bgpcep</groupId>
<artifactId>mockito-configuration</artifactId>
+ <version>${bgpcep.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
<dependency>
<groupId>org.opendaylight.bgpcep</groupId>
<artifactId>mockito-configuration</artifactId>
+ <version>${bgpcep.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
<dependency>
<groupId>org.opendaylight.bgpcep</groupId>
<artifactId>framework</artifactId>
+ <version>${bgpcep.version}</version>
</dependency>
</dependencies>
<dependency>
<groupId>org.opendaylight.bgpcep</groupId>
<artifactId>framework</artifactId>
+ <version>${bgpcep.version}</version>
</dependency>
<dependency>
<groupId>com.google.guava</groupId>
<dependency>
<groupId>org.opendaylight.bgpcep</groupId>
<artifactId>mockito-configuration</artifactId>
+ <version>${bgpcep.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<dependency>
<groupId>io.netty</groupId>
<artifactId>netty-handler</artifactId>
+ <version>${netconf.netty.version}</version>
</dependency>
</dependencies>
Code Review / controller.git / commitdiff