</prerequisites>
<dependencies>
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>bgp-rib-api-config</artifactId>
<artifactId>threadpool-config-api</artifactId>
<version>${controller.config.version}</version>
</dependency>
+
+ <!--test dependencies -->
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>config-manager</artifactId>
+ <version>${controller.config.version}</version>
+ <scope>test</scope>
+ <type>test-jar</type>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>config-manager</artifactId>
+ <version>${controller.config.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>config-util</artifactId>
+ <version>${controller.config.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>mockito-configuration</artifactId>
+ <version>${project.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>netty-event-executor-config</artifactId>
+ <version>${controller.config.version}</version>
+ <scope>test</scope>
+ </dependency>
+
</dependencies>
<build>
--- /dev/null
+package org.opendaylight.controller.config.reconnectstrategy.util;
+
+import io.netty.util.concurrent.Future;
+
+import org.opendaylight.protocol.framework.ReconnectStrategy;
+
+final public class ReconnectStrategyCloseable implements ReconnectStrategy,
+ AutoCloseable {
+
+ private final ReconnectStrategy inner;
+
+ public ReconnectStrategyCloseable(ReconnectStrategy inner) {
+ this.inner = inner;
+ }
+
+ @Override
+ public void close() throws Exception {
+
+ }
+
+ @Override
+ public int getConnectTimeout() throws Exception {
+ return this.inner.getConnectTimeout();
+ }
+
+ @Override
+ public Future<Void> scheduleReconnect(Throwable cause) {
+ return this.inner.scheduleReconnect(cause);
+ }
+
+ @Override
+ public void reconnectSuccessful() {
+ this.inner.reconnectSuccessful();
+ }
+}
@Override
public java.lang.AutoCloseable createInstance() {
final BGPMessageFactory messageFactoryDependency = getMessageFactoryDependency();
- return new BGPDispatcherImpl(messageFactoryDependency, getBossGroupDependency(), getWorkerGroupDependency());
+ return new BGPDispatcherImpl(messageFactoryDependency,
+ getBossGroupDependency(), getWorkerGroupDependency());
}
}
import java.net.InetSocketAddress;
+import org.opendaylight.controller.config.api.JmxAttributeValidationException;
import org.opendaylight.protocol.bgp.rib.impl.BGPImpl;
/**
@Override
public void validate() {
super.validate();
- // Add custom validation for module attributes here.
+ JmxAttributeValidationException.checkNotNull(getHost(),
+ "value is not set.", hostJmxAttribute);
+
+ JmxAttributeValidationException.checkNotNull(getPort(),
+ "value is not set.", portJmxAttribute);
+ JmxAttributeValidationException.checkCondition((getPort() >= 0)
+ && (getPort() <= 65535), "value" + getPort()
+ + " is out of range (0-65535).", portJmxAttribute);
}
@Override
*/
package org.opendaylight.controller.config.yang.bgp.rib.impl;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.opendaylight.controller.config.api.JmxAttributeValidationException;
import org.opendaylight.protocol.bgp.rib.impl.BGPSessionProposalImpl;
import org.opendaylight.protocol.bgp.rib.impl.spi.BGPSessionPreferences;
import org.opendaylight.protocol.bgp.rib.impl.spi.BGPSessionProposal;
@Override
public void validate() {
super.validate();
- // Add custom validation for module attributes here.
+ JmxAttributeValidationException.checkNotNull(getBgpId(),
+ "value is not set.", bgpIdJmxAttribute);
+ JmxAttributeValidationException.checkCondition(
+ isValidIPv4Address(getBgpId()), "value " + getBgpId()
+ + " is not valid IPv4 address", bgpIdJmxAttribute);
+
+ JmxAttributeValidationException.checkNotNull(getAsNumber(),
+ "value is not set.", asNumberJmxAttribute);
}
@Override
return inner.getProposal();
}
}
+
+ private boolean isValidIPv4Address(final String address) {
+ Pattern pattern = Pattern.compile(Ipv4Address.PATTERN_CONSTANTS.get(0));
+ Matcher matcher = pattern.matcher(address);
+ return matcher.matches();
+ }
}
import java.io.IOException;
+import org.opendaylight.controller.config.api.JmxAttributeValidationException;
import org.opendaylight.controller.sal.binding.api.AbstractBindingAwareProvider;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
@Override
public void validate() {
super.validate();
- // Add custom validation for module attributes here.
+ JmxAttributeValidationException.checkNotNull(getRibName(),
+ "value is not set.", ribNameJmxAttribute);
+ JmxAttributeValidationException.checkCondition(!getRibName().isEmpty(),
+ "should not be empty string.", ribNameJmxAttribute);
}
@Override
--- /dev/null
+/**
+* Generated file
+
+* Generated from: yang module name: reconnect-strategy yang module local name: never-reconnect-strategy
+* Generated by: org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator
+* Generated at: Tue Nov 12 13:27:18 CET 2013
+*
+* Do not modify this file unless it is present under src/main directory
+*/
+package org.opendaylight.controller.config.yang.reconnectstrategy;
+
+import org.opendaylight.controller.config.api.JmxAttributeValidationException;
+import org.opendaylight.controller.config.reconnectstrategy.util.ReconnectStrategyCloseable;
+import org.opendaylight.protocol.framework.NeverReconnectStrategy;
+import org.opendaylight.protocol.framework.ReconnectStrategy;
+
+/**
+*
+*/
+public final class NeverReconnectStrategyModule extends org.opendaylight.controller.config.yang.reconnectstrategy.AbstractNeverReconnectStrategyModule
+{
+
+ public NeverReconnectStrategyModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) {
+ super(identifier, dependencyResolver);
+ }
+
+ public NeverReconnectStrategyModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver, NeverReconnectStrategyModule oldModule, java.lang.AutoCloseable oldInstance) {
+ super(identifier, dependencyResolver, oldModule, oldInstance);
+ }
+
+ @Override
+ public void validate(){
+ super.validate();
+ JmxAttributeValidationException.checkNotNull(getTimeout(),
+ "value is not set.", timeoutJmxAttribute);
+ JmxAttributeValidationException.checkCondition(getTimeout() >= 0,
+ "value " + getTimeout() + " is less than 0",
+ timeoutJmxAttribute);
+ }
+
+ @Override
+ public java.lang.AutoCloseable createInstance() {
+ ReconnectStrategy reconnectStrategy = new NeverReconnectStrategy(getExecutorDependency(), getTimeout());
+ return new ReconnectStrategyCloseable(reconnectStrategy);
+ }
+}
--- /dev/null
+/**
+* Generated file
+
+* Generated from: yang module name: reconnect-strategy yang module local name: never-reconnect-strategy
+* Generated by: org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator
+* Generated at: Tue Nov 12 13:27:18 CET 2013
+*
+* Do not modify this file unless it is present under src/main directory
+*/
+package org.opendaylight.controller.config.yang.reconnectstrategy;
+
+/**
+*
+*/
+public class NeverReconnectStrategyModuleFactory extends org.opendaylight.controller.config.yang.reconnectstrategy.AbstractNeverReconnectStrategyModuleFactory
+{
+
+
+}
--- /dev/null
+/**
+* Generated file
+
+* Generated from: yang module name: reconnect-strategy yang module local name: reconnect-immediately-strategy
+* Generated by: org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator
+* Generated at: Tue Nov 12 13:27:18 CET 2013
+*
+* Do not modify this file unless it is present under src/main directory
+*/
+package org.opendaylight.controller.config.yang.reconnectstrategy;
+
+import org.opendaylight.controller.config.api.JmxAttributeValidationException;
+import org.opendaylight.controller.config.reconnectstrategy.util.ReconnectStrategyCloseable;
+import org.opendaylight.protocol.framework.ReconnectImmediatelyStrategy;
+import org.opendaylight.protocol.framework.ReconnectStrategy;
+
+/**
+*
+*/
+public final class ReconnectImmediatelyStrategyModule extends org.opendaylight.controller.config.yang.reconnectstrategy.AbstractReconnectImmediatelyStrategyModule
+{
+
+ public ReconnectImmediatelyStrategyModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) {
+ super(identifier, dependencyResolver);
+ }
+
+ public ReconnectImmediatelyStrategyModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver, ReconnectImmediatelyStrategyModule oldModule, java.lang.AutoCloseable oldInstance) {
+ super(identifier, dependencyResolver, oldModule, oldInstance);
+ }
+
+ @Override
+ public void validate(){
+ super.validate();
+ JmxAttributeValidationException.checkNotNull(getTimeout(),
+ "value is not set.", timeoutJmxAttribute);
+ JmxAttributeValidationException.checkCondition(getTimeout() >= 0,
+ "value " + getTimeout() + " is less than 0",
+ timeoutJmxAttribute);
+ }
+
+ @Override
+ public java.lang.AutoCloseable createInstance() {
+ final ReconnectStrategy reconnectStrategy = new ReconnectImmediatelyStrategy(getExecutorDependency(), getTimeout());
+ return new ReconnectStrategyCloseable(reconnectStrategy);
+ }
+}
--- /dev/null
+/**
+* Generated file
+
+* Generated from: yang module name: reconnect-strategy yang module local name: reconnect-immediately-strategy
+* Generated by: org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator
+* Generated at: Tue Nov 12 13:27:18 CET 2013
+*
+* Do not modify this file unless it is present under src/main directory
+*/
+package org.opendaylight.controller.config.yang.reconnectstrategy;
+
+/**
+*
+*/
+public class ReconnectImmediatelyStrategyModuleFactory extends org.opendaylight.controller.config.yang.reconnectstrategy.AbstractReconnectImmediatelyStrategyModuleFactory
+{
+
+
+}
--- /dev/null
+/**
+* Generated file
+
+* Generated from: yang module name: reconnect-strategy yang module local name: timed-reconnect-strategy
+* Generated by: org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator
+* Generated at: Tue Nov 12 13:27:18 CET 2013
+*
+* Do not modify this file unless it is present under src/main directory
+*/
+package org.opendaylight.controller.config.yang.reconnectstrategy;
+
+import org.opendaylight.controller.config.api.JmxAttributeValidationException;
+import org.opendaylight.controller.config.reconnectstrategy.util.ReconnectStrategyCloseable;
+import org.opendaylight.protocol.framework.ReconnectStrategy;
+import org.opendaylight.protocol.framework.TimedReconnectStrategy;
+
+/**
+*
+*/
+public final class TimedReconnectStrategyModule extends org.opendaylight.controller.config.yang.reconnectstrategy.AbstractTimedReconnectStrategyModule
+{
+
+ public TimedReconnectStrategyModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) {
+ super(identifier, dependencyResolver);
+ }
+
+ public TimedReconnectStrategyModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver, TimedReconnectStrategyModule oldModule, java.lang.AutoCloseable oldInstance) {
+ super(identifier, dependencyResolver, oldModule, oldInstance);
+ }
+
+ @Override
+ public void validate(){
+ super.validate();
+ JmxAttributeValidationException.checkNotNull(getSleepFactor(),
+ "value is not set.", sleepFactorJmxAttribute);
+ JmxAttributeValidationException.checkCondition(getSleepFactor()
+ .doubleValue() >= 1,
+ "value " + getSleepFactor() + " is less than 1",
+ sleepFactorJmxAttribute);
+
+ JmxAttributeValidationException.checkNotNull(getConnectTime(),
+ "value is not set.", connectTimeJmxAttribute);
+ JmxAttributeValidationException.checkCondition(getConnectTime() >= 0,
+ "value " + getConnectTime() + " is less than 0",
+ connectTimeJmxAttribute);
+
+ JmxAttributeValidationException.checkNotNull(getMaxSleep(),
+ "value is not set.", minSleepJmxAttribute);
+ JmxAttributeValidationException.checkCondition(
+ getMaxSleep() == null || getMinSleep() <= getMaxSleep(),
+ "value " + getMinSleep() + " is greter than MaxSleep " + getMaxSleep(),
+ minSleepJmxAttribute);
+ }
+
+ @Override
+ public java.lang.AutoCloseable createInstance() {
+ ReconnectStrategy reconnectStrategy = new TimedReconnectStrategy(
+ getExecutorDependency(), getConnectTime(), getMinSleep(),
+ getSleepFactor().doubleValue(), getMaxSleep(),
+ getMaxAttempts(), getDeadline());
+ return new ReconnectStrategyCloseable(reconnectStrategy);
+ }
+}
--- /dev/null
+/**
+* Generated file
+
+* Generated from: yang module name: reconnect-strategy yang module local name: timed-reconnect-strategy
+* Generated by: org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator
+* Generated at: Tue Nov 12 13:27:18 CET 2013
+*
+* Do not modify this file unless it is present under src/main directory
+*/
+package org.opendaylight.controller.config.yang.reconnectstrategy;
+
+/**
+*
+*/
+public class TimedReconnectStrategyModuleFactory extends org.opendaylight.controller.config.yang.reconnectstrategy.AbstractTimedReconnectStrategyModuleFactory
+{
+
+
+}
--- /dev/null
+// vi: set smarttab et sw=4 tabstop=4:
+module reconnect-strategy {
+ yang-version 1;
+ namespace "urn:opendaylight:params:xml:ns:yang:controller:reconnectstrategy";
+ prefix "rs";
+
+ import config { prefix config; revision-date 2013-04-05; }
+ import threadpool { prefix th; revision-date 2013-04-09; }
+
+ organization "Cisco Systems, Inc.";
+
+ contact "Milos Fabian <milfabia@cisco.com>";
+
+ description
+ "This module contains the base YANG definitions for
+ reconnect strategy.
+
+ Copyright (c)2013 Cisco Systems, Inc. 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";
+
+ revision "2013-11-09" {
+ description
+ "Initial revision";
+ }
+
+ identity reconnect-strategy {
+ description
+ "Service representing a reconnect strategy.";
+
+ base "config:service-type";
+ config:java-class "org.opendaylight.protocol.framework.ReconnectStrategy";
+ }
+
+ identity never-reconnect-strategy {
+ base config:module-type;
+ config:provided-service reconnect-strategy;
+ config:java-name-prefix NeverReconnectStrategy;
+ }
+
+ augment "/config:modules/config:module/config:configuration" {
+ case never-reconnect-strategy {
+ when "/config:modules/config:module/config:type = 'never-reconnect-strategy'";
+
+ leaf timeout {
+ mandatory true;
+ type int32;
+ }
+
+ container executor {
+ uses config:service-ref {
+ refine type {
+ mandatory true;
+ config:required-identity th:netty-event-executor;
+ }
+ }
+ }
+ }
+ }
+
+ identity reconnect-immediately-strategy {
+ base config:module-type;
+ config:provided-service reconnect-strategy;
+ config:java-name-prefix ReconnectImmediatelyStrategy;
+ }
+
+ augment "/config:modules/config:module/config:configuration" {
+ case reconnect-immediately-strategy {
+ when "/config:modules/config:module/config:type = 'reconnect-immediately-strategy'";
+
+ leaf timeout {
+ mandatory true;
+ type int32;
+ }
+
+ container executor {
+ uses config:service-ref {
+ refine type {
+ mandatory true;
+ config:required-identity th:netty-event-executor;
+ }
+ }
+ }
+ }
+ }
+
+ identity timed-reconnect-strategy {
+ base config:module-type;
+ config:provided-service reconnect-strategy;
+ config:java-name-prefix TimedReconnectStrategy;
+ }
+
+ augment "/config:modules/config:module/config:configuration" {
+ case timed-reconnect-strategy {
+ when "/config:modules/config:module/config:type = 'timed-reconnect-strategy'";
+
+ leaf deadline {
+ mandatory true;
+ type int64;
+ }
+
+ leaf max-attempts {
+ mandatory true;
+ type int64;
+ }
+
+ leaf max-sleep {
+ mandatory true;
+ type int64;
+ }
+
+ leaf min-sleep {
+ mandatory true;
+ type int64;
+ }
+
+ leaf sleep-factor {
+ mandatory true;
+ type decimal64 {
+ fraction-digits 2;
+ }
+ }
+
+ leaf connect-time {
+ mandatory true;
+ type int32;
+ }
+
+ container executor {
+ uses config:service-ref {
+ refine type {
+ mandatory true;
+ config:required-identity th:netty-event-executor;
+ }
+ }
+ }
+ }
+ }
+}
+
--- /dev/null
+package org.opendaylight.controller.config.yang.bgp.reconnectstrategy;
+
+import javax.management.InstanceAlreadyExistsException;
+import javax.management.ObjectName;
+
+import org.opendaylight.controller.config.manager.impl.AbstractConfigTest;
+import org.opendaylight.controller.config.util.ConfigRegistryJMXClient;
+import org.opendaylight.controller.config.util.ConfigTransactionJMXClient;
+import org.opendaylight.controller.config.yang.netty.eventexecutor.GlobalEventExecutorModuleFactory;
+import org.opendaylight.controller.config.yang.netty.eventexecutor.GlobalEventExecutorModuleMXBean;
+
+public class GlobalEventExecutorUtil extends AbstractConfigTest {
+
+ private final String instanceName = "global-executor";
+
+ private ObjectName createInstance(
+ final ConfigTransactionJMXClient transaction,
+ final String instanceName, GlobalEventExecutorModuleFactory factory)
+ throws InstanceAlreadyExistsException {
+ ObjectName nameCreated = transaction.createModule(
+ factory.getImplementationName(), instanceName);
+ transaction.newMBeanProxy(nameCreated,
+ GlobalEventExecutorModuleMXBean.class);
+ return nameCreated;
+ }
+
+ private ObjectName createBean(GlobalEventExecutorModuleFactory factory,
+ ConfigRegistryJMXClient configRegistryClient)
+ throws InstanceAlreadyExistsException {
+ ConfigTransactionJMXClient transaction = configRegistryClient
+ .createTransaction();
+ ObjectName objectName = createInstance(transaction, instanceName,
+ factory);
+ transaction.validateConfig();
+ transaction.commit();
+ return objectName;
+ }
+
+ public static ObjectName createGlobalEventExecutorBean(
+ GlobalEventExecutorModuleFactory factory,
+ ConfigRegistryJMXClient configRegistryClient)
+ throws InstanceAlreadyExistsException {
+ GlobalEventExecutorUtil util = new GlobalEventExecutorUtil();
+ return util.createBean(factory, configRegistryClient);
+ }
+
+}
--- /dev/null
+package org.opendaylight.controller.config.yang.bgp.reconnectstrategy;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import javax.management.InstanceAlreadyExistsException;
+import javax.management.InstanceNotFoundException;
+import javax.management.ObjectName;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.controller.config.api.ConflictingVersionException;
+import org.opendaylight.controller.config.api.ValidationException;
+import org.opendaylight.controller.config.api.jmx.CommitStatus;
+import org.opendaylight.controller.config.manager.impl.AbstractConfigTest;
+import org.opendaylight.controller.config.manager.impl.factoriesresolver.HardcodedModuleFactoriesResolver;
+import org.opendaylight.controller.config.util.ConfigTransactionJMXClient;
+import org.opendaylight.controller.config.yang.netty.eventexecutor.GlobalEventExecutorModuleFactory;
+import org.opendaylight.controller.config.yang.reconnectstrategy.AbstractNeverReconnectStrategyModuleFactory;
+import org.opendaylight.controller.config.yang.reconnectstrategy.NeverReconnectStrategyModuleFactory;
+import org.opendaylight.controller.config.yang.reconnectstrategy.NeverReconnectStrategyModuleMXBean;
+
+public class NeverReconnectStrategyModuleTest extends AbstractConfigTest {
+
+ private final String instanceName = "never";
+
+ private NeverReconnectStrategyModuleFactory factory;
+
+ private ObjectName executor;
+
+ @Before
+ public void setUp() throws Exception {
+ this.factory = new NeverReconnectStrategyModuleFactory();
+ GlobalEventExecutorModuleFactory executorFactory = new GlobalEventExecutorModuleFactory();
+ super.initConfigTransactionManagerImpl(new HardcodedModuleFactoriesResolver(
+ factory, executorFactory));
+ this.executor = GlobalEventExecutorUtil.createGlobalEventExecutorBean(
+ executorFactory, configRegistryClient);
+ }
+
+ @Test
+ public void testValidationException1()
+ throws InstanceAlreadyExistsException {
+ try {
+ ConfigTransactionJMXClient transaction = configRegistryClient
+ .createTransaction();
+ createInstance(transaction, instanceName, null, this.executor);
+ transaction.validateConfig();
+ fail();
+ } catch (ValidationException e) {
+ assertTrue(e.getMessage().contains("value is not set."));
+ }
+ }
+
+ @Test
+ public void testValidationException2()
+ throws InstanceAlreadyExistsException {
+ try {
+ ConfigTransactionJMXClient transaction = configRegistryClient
+ .createTransaction();
+ createInstance(transaction, instanceName, -1, this.executor);
+ transaction.validateConfig();
+ fail();
+ } catch (ValidationException e) {
+ assertTrue(e.getMessage().contains("is less than 0"));
+ }
+ }
+
+ @Test
+ public void testValidationException3()
+ throws InstanceAlreadyExistsException {
+ try {
+ ConfigTransactionJMXClient transaction = configRegistryClient
+ .createTransaction();
+ createInstance(transaction, instanceName, 100, null);
+ transaction.validateConfig();
+ fail();
+ } catch (ValidationException e) {
+ assertTrue(e.getMessage().contains(
+ "expected dependency implementing interface"));
+ }
+ }
+
+ @Test
+ public void testCreateBean() throws Exception {
+ ConfigTransactionJMXClient transaction = configRegistryClient
+ .createTransaction();
+ createInstance(transaction, instanceName, 500, this.executor);
+ transaction.validateConfig();
+ CommitStatus status = transaction.commit();
+ assertBeanCount(1, factory.getImplementationName());
+ assertStatus(status, 1, 0, 1);
+ }
+
+ @Test
+ public void testReusingOldInstance() throws InstanceAlreadyExistsException,
+ ConflictingVersionException, ValidationException {
+ ConfigTransactionJMXClient transaction = configRegistryClient
+ .createTransaction();
+ createInstance(transaction, instanceName, 100, this.executor);
+ transaction.commit();
+ transaction = configRegistryClient.createTransaction();
+ assertBeanCount(1, factory.getImplementationName());
+ CommitStatus status = transaction.commit();
+ assertBeanCount(1, factory.getImplementationName());
+ assertStatus(status, 0, 0, 2);
+ }
+
+ @Test
+ public void testReconfigure() throws InstanceAlreadyExistsException,
+ ConflictingVersionException, ValidationException,
+ InstanceNotFoundException {
+ ConfigTransactionJMXClient transaction = configRegistryClient
+ .createTransaction();
+ createInstance(transaction, instanceName, 500, this.executor);
+ transaction.commit();
+ transaction = configRegistryClient.createTransaction();
+ assertBeanCount(1, factory.getImplementationName());
+ NeverReconnectStrategyModuleMXBean mxBean = transaction
+ .newMBeanProxy(transaction.lookupConfigBean(
+ AbstractNeverReconnectStrategyModuleFactory.NAME,
+ instanceName), NeverReconnectStrategyModuleMXBean.class);
+ mxBean.setTimeout(200);
+ CommitStatus status = transaction.commit();
+ assertBeanCount(1, factory.getImplementationName());
+ assertStatus(status, 0, 1, 1);
+ }
+
+ private ObjectName createInstance(
+ final ConfigTransactionJMXClient transaction,
+ final String instanceName, final Integer timeout,
+ final ObjectName executor) throws InstanceAlreadyExistsException {
+ ObjectName nameCreated = transaction.createModule(
+ factory.getImplementationName(), instanceName);
+ NeverReconnectStrategyModuleMXBean mxBean = transaction.newMBeanProxy(
+ nameCreated, NeverReconnectStrategyModuleMXBean.class);
+ mxBean.setTimeout(timeout);
+ mxBean.setExecutor(executor);
+ return nameCreated;
+ }
+
+}
--- /dev/null
+package org.opendaylight.controller.config.yang.bgp.reconnectstrategy;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import javax.management.InstanceAlreadyExistsException;
+import javax.management.InstanceNotFoundException;
+import javax.management.ObjectName;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.controller.config.api.ConflictingVersionException;
+import org.opendaylight.controller.config.api.ValidationException;
+import org.opendaylight.controller.config.api.jmx.CommitStatus;
+import org.opendaylight.controller.config.manager.impl.AbstractConfigTest;
+import org.opendaylight.controller.config.manager.impl.factoriesresolver.HardcodedModuleFactoriesResolver;
+import org.opendaylight.controller.config.util.ConfigTransactionJMXClient;
+import org.opendaylight.controller.config.yang.netty.eventexecutor.GlobalEventExecutorModuleFactory;
+import org.opendaylight.controller.config.yang.reconnectstrategy.AbstractReconnectImmediatelyStrategyModuleFactory;
+import org.opendaylight.controller.config.yang.reconnectstrategy.ReconnectImmediatelyStrategyModuleFactory;
+import org.opendaylight.controller.config.yang.reconnectstrategy.ReconnectImmediatelyStrategyModuleMXBean;
+
+public class ReconnectImmediatelyStrategyModuleTest extends AbstractConfigTest {
+
+ private final String instanceName = "immediately";
+
+ private ReconnectImmediatelyStrategyModuleFactory factory;
+
+ private ObjectName executor;
+
+ @Before
+ public void setUp() throws Exception {
+ this.factory = new ReconnectImmediatelyStrategyModuleFactory();
+ GlobalEventExecutorModuleFactory executorFactory = new GlobalEventExecutorModuleFactory();
+ super.initConfigTransactionManagerImpl(new HardcodedModuleFactoriesResolver(
+ factory, executorFactory));
+ this.executor = GlobalEventExecutorUtil.createGlobalEventExecutorBean(
+ executorFactory, configRegistryClient);
+ }
+
+ @Test
+ public void testValidationException1()
+ throws InstanceAlreadyExistsException {
+ try {
+ ConfigTransactionJMXClient transaction = configRegistryClient
+ .createTransaction();
+ createInstance(transaction, instanceName, null, this.executor);
+ transaction.validateConfig();
+ fail();
+ } catch (ValidationException e) {
+ assertTrue(e.getMessage().contains("value is not set."));
+ }
+ }
+
+ @Test
+ public void testValidationException2()
+ throws InstanceAlreadyExistsException {
+ try {
+ ConfigTransactionJMXClient transaction = configRegistryClient
+ .createTransaction();
+ createInstance(transaction, instanceName, -1, this.executor);
+ transaction.validateConfig();
+ fail();
+ } catch (ValidationException e) {
+ assertTrue(e.getMessage().contains("is less than 0"));
+ }
+ }
+
+ @Test
+ public void testValidationException3()
+ throws InstanceAlreadyExistsException {
+ try {
+ ConfigTransactionJMXClient transaction = configRegistryClient
+ .createTransaction();
+ createInstance(transaction, instanceName, 100, null);
+ transaction.validateConfig();
+ fail();
+ } catch (ValidationException e) {
+ assertTrue(e.getMessage().contains(
+ "expected dependency implementing interface"));
+ }
+ }
+
+ @Test
+ public void testCreateBean() throws Exception {
+ ConfigTransactionJMXClient transaction = configRegistryClient
+ .createTransaction();
+ createInstance(transaction, instanceName, 500, this.executor);
+ transaction.validateConfig();
+ CommitStatus status = transaction.commit();
+ assertBeanCount(1, factory.getImplementationName());
+ assertStatus(status, 1, 0, 1);
+ }
+
+ @Test
+ public void testReusingOldInstance() throws InstanceAlreadyExistsException,
+ ConflictingVersionException, ValidationException {
+ ConfigTransactionJMXClient transaction = configRegistryClient
+ .createTransaction();
+ createInstance(transaction, instanceName, 100, this.executor);
+ transaction.commit();
+ transaction = configRegistryClient.createTransaction();
+ assertBeanCount(1, factory.getImplementationName());
+ CommitStatus status = transaction.commit();
+ assertBeanCount(1, factory.getImplementationName());
+ assertStatus(status, 0, 0, 2);
+ }
+
+ @Test
+ public void testReconfigure() throws InstanceAlreadyExistsException,
+ ConflictingVersionException, ValidationException,
+ InstanceNotFoundException {
+ ConfigTransactionJMXClient transaction = configRegistryClient
+ .createTransaction();
+ createInstance(transaction, instanceName, 500, this.executor);
+ transaction.commit();
+ transaction = configRegistryClient.createTransaction();
+ assertBeanCount(1, factory.getImplementationName());
+ ReconnectImmediatelyStrategyModuleMXBean mxBean = transaction
+ .newMBeanProxy(transaction.lookupConfigBean(
+ AbstractReconnectImmediatelyStrategyModuleFactory.NAME,
+ instanceName),
+ ReconnectImmediatelyStrategyModuleMXBean.class);
+ mxBean.setTimeout(200);
+ CommitStatus status = transaction.commit();
+ assertBeanCount(1, factory.getImplementationName());
+ assertStatus(status, 0, 1, 1);
+ }
+
+ private ObjectName createInstance(
+ final ConfigTransactionJMXClient transaction,
+ final String instanceName, final Integer timeout,
+ final ObjectName executor) throws InstanceAlreadyExistsException {
+ ObjectName nameCreated = transaction.createModule(
+ factory.getImplementationName(), instanceName);
+ ReconnectImmediatelyStrategyModuleMXBean mxBean = transaction
+ .newMBeanProxy(nameCreated,
+ ReconnectImmediatelyStrategyModuleMXBean.class);
+ mxBean.setTimeout(timeout);
+ mxBean.setExecutor(executor);
+ return nameCreated;
+ }
+
+}
--- /dev/null
+package org.opendaylight.controller.config.yang.bgp.reconnectstrategy;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.math.BigDecimal;
+
+import javax.management.InstanceAlreadyExistsException;
+import javax.management.InstanceNotFoundException;
+import javax.management.ObjectName;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.controller.config.api.ConflictingVersionException;
+import org.opendaylight.controller.config.api.ValidationException;
+import org.opendaylight.controller.config.api.jmx.CommitStatus;
+import org.opendaylight.controller.config.manager.impl.AbstractConfigTest;
+import org.opendaylight.controller.config.manager.impl.factoriesresolver.HardcodedModuleFactoriesResolver;
+import org.opendaylight.controller.config.util.ConfigTransactionJMXClient;
+import org.opendaylight.controller.config.yang.netty.eventexecutor.GlobalEventExecutorModuleFactory;
+import org.opendaylight.controller.config.yang.reconnectstrategy.AbstractTimedReconnectStrategyModuleFactory;
+import org.opendaylight.controller.config.yang.reconnectstrategy.TimedReconnectStrategyModuleFactory;
+import org.opendaylight.controller.config.yang.reconnectstrategy.TimedReconnectStrategyModuleMXBean;
+
+public class TimedReconnectStrategyModuleTest extends AbstractConfigTest {
+
+ private final String instanceName = "timed";
+
+ private TimedReconnectStrategyModuleFactory factory;
+
+ private ObjectName executor;
+
+ @Before
+ public void setUp() throws Exception {
+ this.factory = new TimedReconnectStrategyModuleFactory();
+ GlobalEventExecutorModuleFactory executorFactory = new GlobalEventExecutorModuleFactory();
+ super.initConfigTransactionManagerImpl(new HardcodedModuleFactoriesResolver(
+ factory, executorFactory));
+ this.executor = GlobalEventExecutorUtil.createGlobalEventExecutorBean(
+ executorFactory, configRegistryClient);
+ }
+
+ @Test
+ public void testValidationException1()
+ throws InstanceAlreadyExistsException {
+ try {
+ ConfigTransactionJMXClient transaction = configRegistryClient
+ .createTransaction();
+ createInstance(transaction, instanceName, 500, 100L, null, 500L,
+ 10L, 10000L, this.executor);
+ transaction.validateConfig();
+ fail();
+ } catch (ValidationException e) {
+ assertTrue(e.getMessage().contains("SleepFactor value is not set."));
+ }
+ }
+
+ @Test
+ public void testValidationException2()
+ throws InstanceAlreadyExistsException {
+ try {
+ ConfigTransactionJMXClient transaction = configRegistryClient
+ .createTransaction();
+ createInstance(transaction, instanceName, 500, 100L,
+ new BigDecimal(0.5), 500L, 10L, 10000L, this.executor);
+ transaction.validateConfig();
+ fail();
+ } catch (ValidationException e) {
+ assertTrue(e.getMessage().contains("value 0.5 is less than 1"));
+ }
+ }
+
+ @Test
+ public void testValidationException3()
+ throws InstanceAlreadyExistsException {
+ try {
+ ConfigTransactionJMXClient transaction = configRegistryClient
+ .createTransaction();
+ createInstance(transaction, instanceName, null, 100L,
+ new BigDecimal(1.0), 500L, 10L, 10000L, this.executor);
+ transaction.validateConfig();
+ fail();
+ } catch (ValidationException e) {
+ assertTrue(e.getMessage().contains("ConnectTime value is not set."));
+ }
+ }
+
+ @Test
+ public void testValidationException4()
+ throws InstanceAlreadyExistsException {
+ try {
+ ConfigTransactionJMXClient transaction = configRegistryClient
+ .createTransaction();
+ createInstance(transaction, instanceName, -1, 100L, new BigDecimal(
+ 1.0), 500L, 10L, 10000L, this.executor);
+ transaction.validateConfig();
+ fail();
+ } catch (ValidationException e) {
+ assertTrue(e.getMessage().contains("value -1 is less than 0"));
+ }
+ }
+
+ @Test
+ public void testValidationException5()
+ throws InstanceAlreadyExistsException {
+ try {
+ ConfigTransactionJMXClient transaction = configRegistryClient
+ .createTransaction();
+ createInstance(transaction, instanceName, 100, null,
+ new BigDecimal(1.0), null, 10L, 10000L, this.executor);
+ transaction.validateConfig();
+ fail();
+ } catch (ValidationException e) {
+ assertTrue(e.getMessage().contains("MinSleep value is not set."));
+ }
+ }
+
+ @Test
+ public void testValidationException6()
+ throws InstanceAlreadyExistsException {
+ try {
+ ConfigTransactionJMXClient transaction = configRegistryClient
+ .createTransaction();
+ createInstance(transaction, instanceName, 100, 300L,
+ new BigDecimal(1.0), 100L, 10L, 10000L, this.executor);
+ transaction.validateConfig();
+ fail();
+ } catch (ValidationException e) {
+ assertTrue(e.getMessage().contains(
+ "value 300 is greter than MaxSleep 100"));
+ }
+ }
+
+ @Test
+ public void testValidationException7()
+ throws InstanceAlreadyExistsException {
+ try {
+ ConfigTransactionJMXClient transaction = configRegistryClient
+ .createTransaction();
+ createInstance(transaction, instanceName, 100, 100L,
+ new BigDecimal(1.0), 300L, 10L, 10000L, null);
+ transaction.validateConfig();
+ fail();
+ } catch (ValidationException e) {
+ assertTrue(e.getMessage().contains(
+ "expected dependency implementing interface"));
+ }
+ }
+
+ @Test
+ public void testCreateBean() throws Exception {
+ ConfigTransactionJMXClient transaction = configRegistryClient
+ .createTransaction();
+ createInstance(transaction, instanceName, 500, 100L,
+ new BigDecimal(1.0), 500L, 10L, 10000L, this.executor);
+ transaction.validateConfig();
+ CommitStatus status = transaction.commit();
+ assertBeanCount(1, factory.getImplementationName());
+ assertStatus(status, 1, 0, 1);
+ }
+
+ @Test
+ public void testReusingOldInstance() throws InstanceAlreadyExistsException,
+ ConflictingVersionException, ValidationException {
+ ConfigTransactionJMXClient transaction = configRegistryClient
+ .createTransaction();
+ createInstance(transaction, instanceName, 500, 100L,
+ new BigDecimal(1.0), 500L, 10L, 10000L, this.executor);
+ transaction.commit();
+ transaction = configRegistryClient.createTransaction();
+ assertBeanCount(1, factory.getImplementationName());
+ CommitStatus status = transaction.commit();
+ assertBeanCount(1, factory.getImplementationName());
+ assertStatus(status, 0, 0, 2);
+ }
+
+ @Test
+ public void testReconfigure() throws InstanceAlreadyExistsException,
+ ConflictingVersionException, ValidationException,
+ InstanceNotFoundException {
+ ConfigTransactionJMXClient transaction = configRegistryClient
+ .createTransaction();
+ createInstance(transaction, instanceName, 500, 100L,
+ new BigDecimal(1.0), new Long(500), new Long(10), new Long(
+ 10000), this.executor);
+ transaction.commit();
+ transaction = configRegistryClient.createTransaction();
+ assertBeanCount(1, factory.getImplementationName());
+ TimedReconnectStrategyModuleMXBean mxBean = transaction
+ .newMBeanProxy(transaction.lookupConfigBean(
+ AbstractTimedReconnectStrategyModuleFactory.NAME,
+ instanceName), TimedReconnectStrategyModuleMXBean.class);
+ assertEquals(mxBean.getMinSleep(), new Long(100));
+ mxBean.setMinSleep(200L);
+ assertEquals(mxBean.getMinSleep(), new Long(200));
+ CommitStatus status = transaction.commit();
+ assertBeanCount(1, factory.getImplementationName());
+ assertStatus(status, 0, 1, 1);
+
+ }
+
+ private ObjectName createInstance(
+ final ConfigTransactionJMXClient transaction,
+ final String instanceName, final Integer connectTime,
+ final Long minSleep, final BigDecimal sleepFactor,
+ final Long maxSleep, final Long maxAttempts, final Long deadline,
+ final ObjectName executor) throws InstanceAlreadyExistsException {
+ ObjectName nameCreated = transaction.createModule(
+ factory.getImplementationName(), instanceName);
+ TimedReconnectStrategyModuleMXBean mxBean = transaction.newMBeanProxy(
+ nameCreated, TimedReconnectStrategyModuleMXBean.class);
+ mxBean.setConnectTime(connectTime);
+ mxBean.setDeadline(deadline);
+ mxBean.setMaxAttempts(maxAttempts);
+ mxBean.setMaxSleep(maxSleep);
+ mxBean.setMinSleep(minSleep);
+ mxBean.setSleepFactor(sleepFactor);
+ mxBean.setExecutor(executor);
+ return nameCreated;
+ }
+
+}
<osgi.version>5.0.0</osgi.version>
<yangtools.version>0.5.9-SNAPSHOT</yangtools.version>
- <controller.config.version>0.2.2-SNAPSHOT</controller.config.version>
+ <controller.config.version>0.2.3-SNAPSHOT</controller.config.version>
<yang.binding.version>0.6.0-SNAPSHOT</yang.binding.version>
<ietf.types.version>2010.09.24.1</ietf.types.version>
</properties>
Code Review / bgpcep.git / commitdiff