From: Tom Pantelis Date: Fri, 7 Nov 2014 18:42:12 +0000 (+0000) Subject: Merge "BUG 2317 : StatisticsManager does not unregister from yang notifications on... X-Git-Tag: release/lithium~876^2~2 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=commitdiff_plain;h=e316a0ef36279a72767703d190f38a39d7d49395;hp=6f91cec70b454e78c27704585c3c81b354635f16 Merge "BUG 2317 : StatisticsManager does not unregister from yang notifications on close" --- diff --git a/opendaylight/commons/filter-valve/src/test/java/org/opendaylight/controller/filtervalve/cors/jaxb/ParserTest.java b/opendaylight/commons/filter-valve/src/test/java/org/opendaylight/controller/filtervalve/cors/jaxb/ParserTest.java index fc6c01b381..735cf3c5e5 100644 --- a/opendaylight/commons/filter-valve/src/test/java/org/opendaylight/controller/filtervalve/cors/jaxb/ParserTest.java +++ b/opendaylight/commons/filter-valve/src/test/java/org/opendaylight/controller/filtervalve/cors/jaxb/ParserTest.java @@ -9,11 +9,11 @@ package org.opendaylight.controller.filtervalve.cors.jaxb; import static org.hamcrest.core.Is.is; +import static org.hamcrest.CoreMatchers.containsString; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertThat; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; -import static org.junit.matchers.JUnitMatchers.containsString; import com.google.common.base.Optional; import java.io.File; diff --git a/opendaylight/commons/liblldp/src/test/java/org/opendaylight/controller/sal/packet/BitBufferHelperTest.java b/opendaylight/commons/liblldp/src/test/java/org/opendaylight/controller/sal/packet/BitBufferHelperTest.java index 07fbf0599b..07b18d7725 100644 --- a/opendaylight/commons/liblldp/src/test/java/org/opendaylight/controller/sal/packet/BitBufferHelperTest.java +++ b/opendaylight/commons/liblldp/src/test/java/org/opendaylight/controller/sal/packet/BitBufferHelperTest.java @@ -9,8 +9,7 @@ package org.opendaylight.controller.sal.packet; -import junit.framework.Assert; - +import org.junit.Assert; import org.junit.Test; import org.opendaylight.controller.liblldp.BitBufferHelper; diff --git a/opendaylight/commons/opendaylight/pom.xml b/opendaylight/commons/opendaylight/pom.xml index 198d17a79a..ae37f4ae2a 100644 --- a/opendaylight/commons/opendaylight/pom.xml +++ b/opendaylight/commons/opendaylight/pom.xml @@ -219,6 +219,13 @@ + + org.opendaylight.controller + config-artifacts + ${config.version} + pom + import + org.opendaylight.controller netconf-artifacts @@ -226,6 +233,7 @@ pom import + org.apache.sshd sshd-core @@ -839,60 +847,6 @@ - - org.opendaylight.controller - config-api - ${config.version} - - - org.opendaylight.controller - config-manager - ${config.version} - test-jar - - - org.opendaylight.controller - config-manager - ${config.version} - - - org.opendaylight.controller - config-persister-api - ${config.version} - test-jar - - - org.opendaylight.controller - config-persister-api - ${config.version} - - - org.opendaylight.controller - config-persister-directory-xml-adapter - ${config.version} - - - org.opendaylight.controller - config-persister-file-xml-adapter - ${config.version} - - - org.opendaylight.controller - config-persister-feature-adapter - ${config.version} - - - - org.opendaylight.controller - config-util - ${config.version} - - - org.opendaylight.controller - config-util - ${config.version} - test-jar - org.opendaylight.controller configuration @@ -1035,11 +989,6 @@ liblldp ${sal.version} - - org.opendaylight.controller - logback-config - ${config.version} - org.opendaylight.controller @@ -1052,26 +1001,6 @@ ${dummy-console.version} - - org.opendaylight.controller - netty-config-api - ${config.version} - - - org.opendaylight.controller - netty-event-executor-config - ${config.version} - - - org.opendaylight.controller - netty-threadgroup-config - ${config.version} - - - org.opendaylight.controller - netty-timer-config - ${config.version} - org.opendaylight.controller networkconfig.bridgedomain.northbound @@ -1234,11 +1163,6 @@ sal-rest-connector-config ${mdsal.version} - - org.opendaylight.controller - config-netty-config - ${config.version} - org.opendaylight.controller md-sal-config @@ -1341,16 +1265,6 @@ ${karaf.security.version} - - org.opendaylight.controller - shutdown-api - ${config.version} - - - org.opendaylight.controller - shutdown-impl - ${config.version} - org.opendaylight.controller statistics.northbound @@ -1387,17 +1301,6 @@ ${switchmanager.northbound.version} - - - org.opendaylight.controller - threadpool-config-api - ${config.version} - - - org.opendaylight.controller - threadpool-config-impl - ${config.version} - org.opendaylight.controller topology.northbound @@ -1445,22 +1348,6 @@ web ${web.version} - - org.opendaylight.controller - yang-jmx-generator - ${config.version} - - - org.opendaylight.controller - yang-jmx-generator - ${config.version} - test-jar - - - org.opendaylight.controller - yang-test - ${config.version} - org.opendaylight.controller.md forwardingrules-manager @@ -1554,14 +1441,6 @@ xml runtime - - org.opendaylight.controller - features-config-netty - ${config.version} - features - xml - runtime - org.opendaylight.controller features-flow @@ -1672,14 +1551,6 @@ ${mdsal.version} test - - org.opendaylight.controller - features-config - ${config.version} - features - xml - runtime - org.opendaylight.controller features-protocol-framework @@ -1688,22 +1559,6 @@ xml runtime - - org.opendaylight.controller - features-config-persister - ${config.version} - features - xml - runtime - - - org.opendaylight.controller - config-netty-features - ${config.version} - features - xml - runtime - org.opendaylight.controller features-base diff --git a/opendaylight/config/config-api/src/test/java/org/opendaylight/controller/config/api/IdentityAttributeRefTest.java b/opendaylight/config/config-api/src/test/java/org/opendaylight/controller/config/api/IdentityAttributeRefTest.java index 6e8ece343f..91e1f14849 100644 --- a/opendaylight/config/config-api/src/test/java/org/opendaylight/controller/config/api/IdentityAttributeRefTest.java +++ b/opendaylight/config/config-api/src/test/java/org/opendaylight/controller/config/api/IdentityAttributeRefTest.java @@ -1,17 +1,13 @@ package org.opendaylight.controller.config.api; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; import org.junit.Assert; import org.junit.Test; -import org.mockito.Mock; -import org.mockito.MockitoAnnotations; -import org.opendaylight.controller.config.api.annotations.AbstractServiceInterface; import org.opendaylight.yangtools.yang.binding.BaseIdentity; -import javax.management.*; - -import static org.mockito.Matchers.any; -import static org.mockito.Mockito.*; - public class IdentityAttributeRefTest { IdentityAttributeRef attr = new IdentityAttributeRef("attr"); diff --git a/opendaylight/config/config-api/src/test/java/org/opendaylight/controller/config/api/JmxAttributeValidationExceptionTest.java b/opendaylight/config/config-api/src/test/java/org/opendaylight/controller/config/api/JmxAttributeValidationExceptionTest.java index f6e7dfb505..9ff7405257 100644 --- a/opendaylight/config/config-api/src/test/java/org/opendaylight/controller/config/api/JmxAttributeValidationExceptionTest.java +++ b/opendaylight/config/config-api/src/test/java/org/opendaylight/controller/config/api/JmxAttributeValidationExceptionTest.java @@ -1,23 +1,18 @@ package org.opendaylight.controller.config.api; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertThat; +import com.google.common.collect.Lists; import java.nio.file.AccessDeniedException; import java.util.ArrayList; import java.util.Arrays; import java.util.List; - -import com.google.common.collect.Lists; import org.hamcrest.CoreMatchers; -import org.junit.Assert; -import org.junit.Before; import org.junit.Test; -import javax.management.Query; - -import static org.junit.Assert.*; - public class JmxAttributeValidationExceptionTest { - private JmxAttribute jmxAttribute = new JmxAttribute("attr1"); + private final JmxAttribute jmxAttribute = new JmxAttribute("attr1"); @Test public void testJmxAttributeValidationExceptionElement() throws Exception { @@ -28,7 +23,7 @@ public class JmxAttributeValidationExceptionTest { @Test public void testJmxAttributeValidationExceptionList() throws Exception { - List attributeNames = new ArrayList(); + List attributeNames = new ArrayList<>(); attributeNames.add(new JmxAttribute("att1")); attributeNames.add(new JmxAttribute("att2")); attributeNames.add(new JmxAttribute("att3")); @@ -38,7 +33,7 @@ public class JmxAttributeValidationExceptionTest { @Test public void testJmxAttributeValidationExceptionList2() throws Exception { - List attributeNames = new ArrayList(); + List attributeNames = new ArrayList<>(); attributeNames.add(new JmxAttribute("att1")); attributeNames.add(new JmxAttribute("att2")); attributeNames.add(new JmxAttribute("att3")); @@ -84,7 +79,7 @@ public class JmxAttributeValidationExceptionTest { JmxAttributeValidationException.checkCondition(false, "message", jmxAttribute); } - private void assertJmxEx(JmxAttributeValidationException e, String message, JmxAttribute... attrNames) { + private void assertJmxEx(final JmxAttributeValidationException e, final String message, final JmxAttribute... attrNames) { assertEquals(message, e.getMessage()); assertEquals(Lists.newArrayList(attrNames), e.getAttributeNames()); } diff --git a/opendaylight/config/config-api/src/test/java/org/opendaylight/controller/config/api/ModuleIdentifierTest.java b/opendaylight/config/config-api/src/test/java/org/opendaylight/controller/config/api/ModuleIdentifierTest.java index c0e584a098..2771b407f4 100644 --- a/opendaylight/config/config-api/src/test/java/org/opendaylight/controller/config/api/ModuleIdentifierTest.java +++ b/opendaylight/config/config-api/src/test/java/org/opendaylight/controller/config/api/ModuleIdentifierTest.java @@ -1,11 +1,8 @@ package org.opendaylight.controller.config.api; -import junit.framework.Assert; -import org.junit.Test; - import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotEquals; +import org.junit.Test; public class ModuleIdentifierTest { String fact = new String("factory"); diff --git a/opendaylight/config/config-api/src/test/java/org/opendaylight/controller/config/api/ValidationExceptionTest.java b/opendaylight/config/config-api/src/test/java/org/opendaylight/controller/config/api/ValidationExceptionTest.java index 30712c966d..8b4f2fe258 100644 --- a/opendaylight/config/config-api/src/test/java/org/opendaylight/controller/config/api/ValidationExceptionTest.java +++ b/opendaylight/config/config-api/src/test/java/org/opendaylight/controller/config/api/ValidationExceptionTest.java @@ -1,23 +1,20 @@ package org.opendaylight.controller.config.api; -import static junit.framework.Assert.assertEquals; -import static junit.framework.Assert.assertTrue; -import static junit.framework.Assert.fail; -import static org.junit.Assert.assertNotEquals; +import static org.hamcrest.CoreMatchers.containsString; +import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertThat; -import static org.junit.matchers.JUnitMatchers.containsString; - +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; import com.google.common.collect.Lists; import java.util.Map; - import org.junit.Assert; import org.junit.Test; public class ValidationExceptionTest { - private String instance = "instance"; + private final String instance = "instance"; private final ModuleIdentifier mi = new ModuleIdentifier("module", instance); - private String instance2 = "instance2"; + private final String instance2 = "instance2"; private final ModuleIdentifier mi2 = new ModuleIdentifier("module", instance2); private final String message = "ex message"; private final Exception e = new IllegalStateException(message); diff --git a/opendaylight/config/config-api/src/test/java/org/opendaylight/controller/config/api/jmx/CommitStatusTest.java b/opendaylight/config/config-api/src/test/java/org/opendaylight/controller/config/api/jmx/CommitStatusTest.java index 36ebc9de93..cb8271a581 100644 --- a/opendaylight/config/config-api/src/test/java/org/opendaylight/controller/config/api/jmx/CommitStatusTest.java +++ b/opendaylight/config/config-api/src/test/java/org/opendaylight/controller/config/api/jmx/CommitStatusTest.java @@ -1,17 +1,16 @@ package org.opendaylight.controller.config.api.jmx; +import java.util.ArrayList; +import java.util.List; +import javax.management.ObjectName; import org.junit.Assert; import org.junit.Before; import org.junit.Test; -import javax.management.ObjectName; -import java.util.ArrayList; -import java.util.List; - public class CommitStatusTest { - List newInst = new ArrayList(); - List reusedInst = new ArrayList(); - List recreatedInst = new ArrayList(); + List newInst = new ArrayList<>(); + List reusedInst = new ArrayList<>(); + List recreatedInst = new ArrayList<>(); @Before public void setUp() throws Exception { @@ -43,9 +42,9 @@ public class CommitStatusTest { @Test public void testNotEqual() throws Exception { - List newInst2 = new ArrayList(); - List reusedInst2 = new ArrayList(); - List recreatedInst2 = new ArrayList(); + List newInst2 = new ArrayList<>(); + List reusedInst2 = new ArrayList<>(); + List recreatedInst2 = new ArrayList<>(); newInst2.add(new ObjectName("first: key1 = value1")); reusedInst2.add(new ObjectName("second: key = val")); diff --git a/opendaylight/config/config-api/src/test/java/org/opendaylight/controller/config/api/jmx/ObjectNameUtilTest.java b/opendaylight/config/config-api/src/test/java/org/opendaylight/controller/config/api/jmx/ObjectNameUtilTest.java index 02c1c4b981..e69ff921cc 100644 --- a/opendaylight/config/config-api/src/test/java/org/opendaylight/controller/config/api/jmx/ObjectNameUtilTest.java +++ b/opendaylight/config/config-api/src/test/java/org/opendaylight/controller/config/api/jmx/ObjectNameUtilTest.java @@ -7,18 +7,15 @@ */ package org.opendaylight.controller.config.api.jmx; -import static junit.framework.Assert.fail; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; - +import static org.junit.Assert.fail; import com.google.common.base.Throwables; import com.google.common.collect.Maps; - import java.util.HashMap; import java.util.Map; import javax.management.ObjectName; -import junit.framework.Assert; import org.junit.Before; import org.junit.Test; import org.opendaylight.controller.config.api.ModuleIdentifier; @@ -84,7 +81,7 @@ public class ObjectNameUtilTest { assertPattern(on, pattern); } - private void assertPattern(ObjectName test, ObjectName pattern) { + private void assertPattern(final ObjectName test, final ObjectName pattern) { assertTrue(pattern.isPattern()); assertTrue(pattern.apply(test)); } @@ -150,11 +147,11 @@ public class ObjectNameUtilTest { }, IllegalArgumentException.class); } - private void assertFailure(Runnable test, Class ex) { + private void assertFailure(final Runnable test, final Class ex) { try { test.run(); } catch(Exception e) { - Assert.assertTrue("Failed with wrong exception: " + Throwables.getStackTraceAsString(e), + assertTrue("Failed with wrong exception: " + Throwables.getStackTraceAsString(e), e.getClass().isAssignableFrom(ex)); return; } diff --git a/opendaylight/config/config-artifacts/pom.xml b/opendaylight/config/config-artifacts/pom.xml new file mode 100644 index 0000000000..430d6b41bc --- /dev/null +++ b/opendaylight/config/config-artifacts/pom.xml @@ -0,0 +1,224 @@ + + + + + + 4.0.0 + org.opendaylight.controller + config-artifacts + 0.3.0-SNAPSHOT + pom + + + + + ${project.groupId} + config-api + ${project.version} + + + ${project.groupId} + config-manager + ${project.version} + + + ${project.groupId} + config-manager + ${project.version} + test-jar + test + + + ${project.groupId} + config-module-archetype + ${project.version} + + + ${project.groupId} + config-netty-config + ${project.version} + + + ${project.groupId} + config-persister-api + ${project.version} + + + ${project.groupId} + config-persister-api + ${project.version} + test-jar + test + + + ${project.groupId} + config-persister-directory-adapter + ${project.version} + + + ${project.groupId} + config-persister-directory-autodetect-adapter + ${project.version} + + + ${project.groupId} + config-persister-directory-xml-adapter + ${project.version} + + + ${project.groupId} + config-persister-feature-adapter + ${project.version} + + + ${project.groupId} + config-persister-file-adapter + ${project.version} + + + ${project.groupId} + config-persister-file-xml-adapter + ${project.version} + + + ${project.groupId} + config-plugin-parent + ${project.version} + + + ${project.groupId} + config-util + ${project.version} + + + ${project.groupId} + config-util + ${project.version} + test-jar + test + + + ${project.groupId} + logback-config + ${project.version} + + + ${project.groupId} + logback-config-loader + ${project.version} + + + ${project.groupId} + netty-config-api + ${project.version} + + + ${project.groupId} + netty-event-executor-config + ${project.version} + + + ${project.groupId} + netty-threadgroup-config + ${project.version} + + + ${project.groupId} + netty-timer-config + ${project.version} + + + ${project.groupId} + shutdown-api + ${project.version} + + + ${project.groupId} + shutdown-impl + ${project.version} + + + ${project.groupId} + threadpool-config-api + ${project.version} + + + ${project.groupId} + threadpool-config-impl + ${project.version} + + + ${project.groupId} + yang-jmx-generator + ${project.version} + + + ${project.groupId} + yang-jmx-generator + ${project.version} + test-jar + test + + + ${project.groupId} + yang-jmx-generator-plugin + ${project.version} + + + ${project.groupId} + yang-store-api + ${project.version} + + + ${project.groupId} + yang-store-impl + ${project.version} + + + ${project.groupId} + yang-test + ${project.version} + + + + ${project.groupId} + features-config + ${project.version} + features + xml + runtime + + + ${project.groupId} + features-config-netty + ${project.version} + features + xml + runtime + + + ${project.groupId} + features-config-persister + ${project.version} + features + xml + runtime + + + ${project.groupId} + config-netty-features + ${project.version} + features + xml + runtime + + + + + diff --git a/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/util/InterfacesHelper.java b/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/util/InterfacesHelper.java index 4d94c6d265..5cb1513d9c 100644 --- a/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/util/InterfacesHelper.java +++ b/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/util/InterfacesHelper.java @@ -7,17 +7,16 @@ */ package org.opendaylight.controller.config.manager.impl.util; -import org.opendaylight.controller.config.api.annotations.AbstractServiceInterface; -import org.opendaylight.controller.config.api.annotations.ServiceInterfaceAnnotation; -import org.opendaylight.controller.config.spi.Module; -import org.opendaylight.controller.config.spi.ModuleFactory; - -import javax.management.JMX; import java.util.Arrays; import java.util.Collections; import java.util.HashSet; import java.util.Iterator; import java.util.Set; +import javax.management.JMX; +import org.opendaylight.controller.config.api.annotations.AbstractServiceInterface; +import org.opendaylight.controller.config.api.annotations.ServiceInterfaceAnnotation; +import org.opendaylight.controller.config.spi.Module; +import org.opendaylight.controller.config.spi.ModuleFactory; public class InterfacesHelper { @@ -40,7 +39,7 @@ public class InterfacesHelper { } - private static Set> getAllSuperInterfaces(Set> ifcs) { + private static Set> getAllSuperInterfaces(final Set> ifcs) { Set> interfaces = new HashSet<>(ifcs); // create copy to modify // each interface can extend other interfaces Set> result = new HashSet<>(); @@ -61,7 +60,7 @@ public class InterfacesHelper { * Get interfaces that this class is derived from that are JMX interfaces. */ public static Set> getMXInterfaces( - Class configBeanClass) { + final Class configBeanClass) { Set> allInterfaces = getAllInterfaces(configBeanClass); Set> result = new HashSet<>(); for (Class clazz : allInterfaces) { @@ -78,7 +77,7 @@ public class InterfacesHelper { * annotation. */ public static Set> getServiceInterfaces( - Class configBeanClass) { + final Class configBeanClass) { Set> allInterfaces = getAllInterfaces(configBeanClass); Set> result = new HashSet<>(); for (Class clazz : allInterfaces) { @@ -93,7 +92,7 @@ public class InterfacesHelper { return result; } - public static Set> getAllAbstractServiceClasses(Class configBeanClass) { + public static Set> getAllAbstractServiceClasses(final Class configBeanClass) { Set> foundGeneratedSIClasses = new HashSet<>(); for (Class clazz : getAllInterfaces(configBeanClass)) { @@ -111,7 +110,7 @@ public class InterfacesHelper { * {@link org.opendaylight.controller.config.api.annotations.ServiceInterfaceAnnotation#osgiRegistrationType()} */ public static Set> getOsgiRegistrationTypes( - Class configBeanClass) { + final Class configBeanClass) { Set> serviceInterfaces = getServiceInterfaces(configBeanClass); Set> result = new HashSet<>(); for (Class clazz : serviceInterfaces) { @@ -122,7 +121,7 @@ public class InterfacesHelper { return result; } - public static Set getQNames(Set siAnnotations) { + public static Set getQNames(final Set siAnnotations) { Set qNames = new HashSet<>(); for (ServiceInterfaceAnnotation sia: siAnnotations) { qNames.add(sia.value()); @@ -130,12 +129,12 @@ public class InterfacesHelper { return Collections.unmodifiableSet(qNames); } - public static Set getServiceInterfaceAnnotations(ModuleFactory factory) { + public static Set getServiceInterfaceAnnotations(final ModuleFactory factory) { Set> implementedServiceIntefaces = Collections.unmodifiableSet(factory.getImplementedServiceIntefaces()); return getServiceInterfaceAnnotations(implementedServiceIntefaces); } - private static Set getServiceInterfaceAnnotations(Set> implementedServiceIntefaces) { + private static Set getServiceInterfaceAnnotations(final Set> implementedServiceIntefaces) { Set> inspected = getAllAbstractServiceInterfaceClasses(implementedServiceIntefaces); Set result = new HashSet<>(); // SIs can form hierarchies, inspect superclass until it does not extend AbstractSI @@ -149,9 +148,9 @@ public class InterfacesHelper { } static Set> getAllAbstractServiceInterfaceClasses( - Set> directlyImplementedAbstractSIs) { + final Set> directlyImplementedAbstractSIs) { - Set> allInterfaces = getAllSuperInterfaces((Set) directlyImplementedAbstractSIs); + Set> allInterfaces = getAllSuperInterfaces(directlyImplementedAbstractSIs); Set> result = new HashSet<>(); for(Class ifc: allInterfaces){ if (AbstractServiceInterface.class.isAssignableFrom(ifc) && diff --git a/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/util/OsgiRegistrationUtil.java b/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/util/OsgiRegistrationUtil.java index f839452dca..4f792e72b1 100644 --- a/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/util/OsgiRegistrationUtil.java +++ b/opendaylight/config/config-manager/src/main/java/org/opendaylight/controller/config/manager/impl/util/OsgiRegistrationUtil.java @@ -9,7 +9,6 @@ package org.opendaylight.controller.config.manager.impl.util; import static com.google.common.base.Preconditions.checkNotNull; - import java.util.ArrayList; import java.util.List; import java.util.ListIterator; @@ -27,7 +26,7 @@ public class OsgiRegistrationUtil { } @SafeVarargs - public static AutoCloseable registerService(BundleContext bundleContext, T service, Class ... interfaces) { + public static AutoCloseable registerService(final BundleContext bundleContext, final T service, final Class ... interfaces) { checkNotNull(service); checkNotNull(interfaces); List autoCloseableList = new ArrayList<>(); @@ -48,7 +47,7 @@ public class OsgiRegistrationUtil { }; } - public static AutoCloseable wrap(final BundleTracker bundleTracker) { + public static AutoCloseable wrap(final BundleTracker bundleTracker) { checkNotNull(bundleTracker); return new AutoCloseable() { @Override diff --git a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/dependencyresolver/DependencyResolverManagerTest.java b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/dependencyresolver/DependencyResolverManagerTest.java index 48d7de0e82..83ee87ce0e 100644 --- a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/dependencyresolver/DependencyResolverManagerTest.java +++ b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/dependencyresolver/DependencyResolverManagerTest.java @@ -100,10 +100,10 @@ public class DependencyResolverManagerTest extends AbstractLockedPlatformMBeanSe tested.put(moduleIdentifier, mockedModule(), - moduleFactory, - maybeOldInternalInfo, - transactionModuleJMXRegistration, - isDefaultBean, mock(BundleContext.class)); + moduleFactory, + maybeOldInternalInfo, + transactionModuleJMXRegistration, + isDefaultBean, mock(BundleContext.class)); } private static Module mockedModule() { diff --git a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/osgi/BlankTransactionServiceTrackerTest.java b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/osgi/BlankTransactionServiceTrackerTest.java index 471c98a676..8ceee0caf5 100644 --- a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/osgi/BlankTransactionServiceTrackerTest.java +++ b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/osgi/BlankTransactionServiceTrackerTest.java @@ -1,14 +1,13 @@ package org.opendaylight.controller.config.manager.impl.osgi; -import static junit.framework.Assert.assertNotNull; -import static junit.framework.Assert.assertSame; -import static junit.framework.Assert.fail; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertSame; +import static org.junit.Assert.fail; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.doThrow; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; - import java.util.Collections; import javax.management.ObjectName; import org.junit.Before; diff --git a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/osgi/BundleContextBackedModuleFactoriesResolverTest.java b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/osgi/BundleContextBackedModuleFactoriesResolverTest.java index dc3deddddc..44e6e9ab77 100644 --- a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/osgi/BundleContextBackedModuleFactoriesResolverTest.java +++ b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/osgi/BundleContextBackedModuleFactoriesResolverTest.java @@ -1,13 +1,12 @@ package org.opendaylight.controller.config.manager.impl.osgi; -import static junit.framework.Assert.fail; +import static org.hamcrest.CoreMatchers.containsString; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertThat; import static org.junit.Assert.assertTrue; -import static org.junit.matchers.JUnitMatchers.containsString; +import static org.junit.Assert.fail; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; - import com.google.common.collect.Lists; import java.util.Map; import org.junit.Before; @@ -24,8 +23,8 @@ public class BundleContextBackedModuleFactoriesResolverTest { @Mock private BundleContext bundleContext; private BundleContextBackedModuleFactoriesResolver resolver; - private ServiceReference s1; - private ServiceReference s2; + private ServiceReference s1; + private ServiceReference s2; private ModuleFactory f1; private ModuleFactory f2; @@ -42,15 +41,15 @@ public class BundleContextBackedModuleFactoriesResolverTest { resolver = new BundleContextBackedModuleFactoriesResolver(bundleContext); } - private ModuleFactory getMockFactory(String name) { + private ModuleFactory getMockFactory(final String name) { ModuleFactory mock = mock(ModuleFactory.class); doReturn(name).when(mock).toString(); doReturn(name).when(mock).getImplementationName(); return mock; } - private ServiceReference getServiceRef() { - ServiceReference mock = mock(ServiceReference.class); + private ServiceReference getServiceRef() { + ServiceReference mock = mock(ServiceReference.class); doReturn("serviceRef").when(mock).toString(); final Bundle bundle = mock(Bundle.class); doReturn(bundleContext).when(bundle).getBundleContext(); diff --git a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/osgi/ModuleFactoryBundleTrackerTest.java b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/osgi/ModuleFactoryBundleTrackerTest.java index 5b83412083..25d770e6c9 100644 --- a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/osgi/ModuleFactoryBundleTrackerTest.java +++ b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/osgi/ModuleFactoryBundleTrackerTest.java @@ -1,8 +1,8 @@ package org.opendaylight.controller.config.manager.impl.osgi; -import static junit.framework.Assert.assertEquals; -import static junit.framework.Assert.assertNotNull; -import static junit.framework.Assert.fail; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.fail; import static org.mockito.Matchers.any; import static org.mockito.Matchers.anyObject; import static org.mockito.Matchers.anyString; @@ -11,10 +11,8 @@ import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyZeroInteractions; - import java.util.Dictionary; import java.util.Set; - import org.junit.Before; import org.junit.Test; import org.mockito.Mock; @@ -44,7 +42,7 @@ public class ModuleFactoryBundleTrackerTest { @Before public void setUp() throws Exception { MockitoAnnotations.initMocks(this); - doAnswer(new Answer() { + doAnswer(new Answer() { @Override public Object answer(final InvocationOnMock invocation) throws Throwable { return getClass().getClassLoader().loadClass((String) invocation.getArguments()[0]); @@ -141,7 +139,7 @@ public class ModuleFactoryBundleTrackerTest { } static class WrongConstructorTestingFactory extends TestingFactory { - WrongConstructorTestingFactory(String randomParam) { + WrongConstructorTestingFactory(final String randomParam) { } } diff --git a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/osgi/RefreshingSCPModuleInfoRegistryTest.java b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/osgi/RefreshingSCPModuleInfoRegistryTest.java index 79391d4343..9edb64ac6b 100644 --- a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/osgi/RefreshingSCPModuleInfoRegistryTest.java +++ b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/osgi/RefreshingSCPModuleInfoRegistryTest.java @@ -1,5 +1,9 @@ package org.opendaylight.controller.config.manager.impl.osgi; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; +import java.util.Dictionary; import org.junit.Test; import org.mockito.Mockito; import org.opendaylight.controller.config.manager.impl.osgi.mapping.RefreshingSCPModuleInfoRegistry; @@ -10,12 +14,6 @@ import org.opendaylight.yangtools.yang.model.api.SchemaContextProvider; import org.osgi.framework.BundleContext; import org.osgi.framework.ServiceRegistration; -import java.util.*; - -import static org.mockito.Mockito.doNothing; -import static org.mockito.Mockito.doReturn; -import static org.mockito.Mockito.mock; - public class RefreshingSCPModuleInfoRegistryTest { @Test public void testConstructor() throws Exception { @@ -24,8 +22,7 @@ public class RefreshingSCPModuleInfoRegistryTest { doReturn("string").when(prov).toString(); BundleContext ctxt = mock(BundleContext.class); - Dictionary dict = new Hashtable(); - ServiceRegistration servReg = mock(ServiceRegistration.class); + ServiceRegistration servReg = mock(ServiceRegistration.class); doReturn(servReg).when(ctxt).registerService(Mockito.any(Class.class), Mockito.any(SchemaContextProvider.class), Mockito.any(Dictionary.class)); doReturn(servReg).when(ctxt).registerService(Mockito.anyString(), Mockito.any(Object.class), Mockito.any(Dictionary.class)); RefreshingSCPModuleInfoRegistry scpreg = new RefreshingSCPModuleInfoRegistry(reg, prov, ctxt); diff --git a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/util/InterfacesHelperTest.java b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/util/InterfacesHelperTest.java index 220bef03bc..4be40a64f5 100644 --- a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/util/InterfacesHelperTest.java +++ b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/util/InterfacesHelperTest.java @@ -8,7 +8,7 @@ package org.opendaylight.controller.config.manager.impl.util; import static org.junit.Assert.assertEquals; - +import com.google.common.collect.ImmutableSet; import com.google.common.collect.Sets; import java.util.Collections; import java.util.HashSet; @@ -92,7 +92,7 @@ public class InterfacesHelperTest { input.add(clazz); Set> result = InterfacesHelper.getAllAbstractServiceInterfaceClasses(input); - Set> expected = Sets.newHashSet((Class) TestingScheduledThreadPoolServiceInterface.class, + Set> expected = ImmutableSet.of((Class) TestingScheduledThreadPoolServiceInterface.class, TestingThreadPoolServiceInterface.class ); assertEquals(expected, result); diff --git a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/util/OsgiRegistrationUtilTest.java b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/util/OsgiRegistrationUtilTest.java index fb59e3d515..f1efc4787d 100644 --- a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/util/OsgiRegistrationUtilTest.java +++ b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/util/OsgiRegistrationUtilTest.java @@ -4,7 +4,6 @@ import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; - import org.junit.Test; import org.mockito.InOrder; import org.mockito.Mockito; @@ -37,7 +36,7 @@ public class OsgiRegistrationUtilTest { OsgiRegistrationUtil.wrap(serviceReg).close(); verify(serviceReg).unregister(); - final BundleTracker tracker = mock(BundleTracker.class); + final BundleTracker tracker = mock(BundleTracker.class); doNothing().when(tracker).close(); OsgiRegistrationUtil.wrap(tracker).close(); verify(tracker).close(); @@ -49,7 +48,7 @@ public class OsgiRegistrationUtilTest { } private ServiceRegistration mockServiceRegistration() { - ServiceRegistration mock = mock(ServiceRegistration.class); + ServiceRegistration mock = mock(ServiceRegistration.class); doNothing().when(mock).unregister(); return mock; } 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 e5306a4fa6..d34e73ec47 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 @@ -7,7 +7,9 @@ */ package org.opendaylight.controller.config.manager.testingservices.scheduledthreadpool; -import com.google.common.collect.Sets; +import com.google.common.collect.ImmutableSet; +import java.util.HashSet; +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; @@ -19,20 +21,16 @@ import org.opendaylight.controller.config.spi.Module; import org.opendaylight.controller.config.spi.ModuleFactory; import org.osgi.framework.BundleContext; -import java.util.Collections; -import java.util.HashSet; -import java.util.Set; - public class TestingScheduledThreadPoolModuleFactory implements ModuleFactory { public static final String NAME = "scheduled"; - private static Set> ifc = Collections.unmodifiableSet(Sets.newHashSet( + private static Set> ifc = ImmutableSet.of( (Class) TestingScheduledThreadPoolServiceInterface.class, - TestingThreadPoolServiceInterface.class)); + TestingThreadPoolServiceInterface.class); @Override public boolean isModuleImplementingServiceInterface( - Class serviceInterface) { + final Class serviceInterface) { return ifc.contains(serviceInterface); } @@ -42,15 +40,15 @@ public class TestingScheduledThreadPoolModuleFactory implements ModuleFactory { } @Override - public Module createModule(String instanceName, - DependencyResolver dependencyResolver, BundleContext bundleContext) { + public Module createModule(final String instanceName, + final DependencyResolver dependencyResolver, final BundleContext bundleContext) { return new TestingScheduledThreadPoolModule(new ModuleIdentifier(NAME, instanceName), null, null); } @Override - public Module createModule(String instanceName, - DependencyResolver dependencyResolver, DynamicMBeanWithInstance old, BundleContext bundleContext) + public Module createModule(final String instanceName, + final DependencyResolver dependencyResolver, final DynamicMBeanWithInstance old, final BundleContext bundleContext) throws Exception { TestingScheduledThreadPoolImpl oldInstance; try { @@ -68,7 +66,7 @@ public class TestingScheduledThreadPoolModuleFactory implements ModuleFactory { } @Override - public Set getDefaultModules(DependencyResolverFactory dependencyResolverFactory, BundleContext bundleContext) { + public Set getDefaultModules(final DependencyResolverFactory dependencyResolverFactory, final BundleContext bundleContext) { return new HashSet(); } diff --git a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/testingservices/scheduledthreadpool/test/TwoInterfacesExportTest.java b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/testingservices/scheduledthreadpool/test/TwoInterfacesExportTest.java index ca038f1f1c..9c8b575fe5 100644 --- a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/testingservices/scheduledthreadpool/test/TwoInterfacesExportTest.java +++ b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/testingservices/scheduledthreadpool/test/TwoInterfacesExportTest.java @@ -7,38 +7,35 @@ */ package org.opendaylight.controller.config.manager.testingservices.scheduledthreadpool.test; +import static org.hamcrest.CoreMatchers.containsString; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertThat; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; -import static org.junit.matchers.JUnitMatchers.containsString; - import javax.annotation.Nullable; import javax.management.DynamicMBean; import javax.management.InstanceAlreadyExistsException; import javax.management.InstanceNotFoundException; import javax.management.ObjectName; - import org.junit.Test; import org.opendaylight.controller.config.api.ValidationException; import org.opendaylight.controller.config.api.jmx.ObjectNameUtil; import org.opendaylight.controller.config.manager.testingservices.parallelapsp.TestingParallelAPSPConfigMXBean; import org.opendaylight.controller.config.manager.testingservices.parallelapsp.TestingParallelAPSPModuleFactory; import org.opendaylight.controller.config.manager.testingservices.scheduledthreadpool.TestingScheduledThreadPoolImpl; -import org.opendaylight.controller.config.manager.testingservices.scheduledthreadpool - .TestingScheduledThreadPoolModuleFactory; +import org.opendaylight.controller.config.manager.testingservices.scheduledthreadpool.TestingScheduledThreadPoolModuleFactory; import org.opendaylight.controller.config.util.ConfigTransactionJMXClient; public class TwoInterfacesExportTest extends AbstractScheduledTest { - private void assertExists(String moduleName, String instanceName) + private void assertExists(final String moduleName, final String instanceName) throws Exception { assertExists(null, moduleName, instanceName); } - private void assertExists(@Nullable ConfigTransactionJMXClient transaction, - String moduleName, String instanceName) + private void assertExists(@Nullable final ConfigTransactionJMXClient transaction, + final String moduleName, final String instanceName) throws InstanceNotFoundException { if (transaction != null) { transaction.lookupConfigBean(moduleName, instanceName); @@ -56,13 +53,13 @@ public class TwoInterfacesExportTest extends AbstractScheduledTest { } } - private void assertNotExists(String moduleName, String instanceName) { + private void assertNotExists(final String moduleName, final String instanceName) { assertNotExists(null, moduleName, instanceName); } private void assertNotExists( - @Nullable ConfigTransactionJMXClient transaction, - String moduleName, String instanceName) { + @Nullable final ConfigTransactionJMXClient transaction, + final String moduleName, final String instanceName) { if (transaction != null) { try { 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 bec2868557..d385a7db5a 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 @@ -7,7 +7,9 @@ */ package org.opendaylight.controller.config.manager.testingservices.threadpool; -import com.google.common.collect.Sets; +import com.google.common.collect.ImmutableSet; +import java.util.HashSet; +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; @@ -19,16 +21,12 @@ import org.opendaylight.controller.config.spi.Module; import org.opendaylight.controller.config.spi.ModuleFactory; import org.osgi.framework.BundleContext; -import java.util.Collections; -import java.util.HashSet; -import java.util.Set; - public class TestingFixedThreadPoolModuleFactory extends AbstractTestingFixedThreadPoolModuleFactory implements ModuleFactory { public static final String NAME = "fixed"; - private static Set> ifc = Collections.unmodifiableSet(Sets.newHashSet( + private static final Set> ifc = ImmutableSet.of( (Class) ModifiableThreadPoolServiceInterface.class, - TestingThreadPoolServiceInterface.class)); + TestingThreadPoolServiceInterface.class); @Override public String getImplementationName() { @@ -36,15 +34,15 @@ public class TestingFixedThreadPoolModuleFactory extends AbstractTestingFixedThr } @Override - public TestingFixedThreadPoolModule createModule(String instanceName, - DependencyResolver dependencyResolver, BundleContext bundleContext) { + public TestingFixedThreadPoolModule createModule(final String instanceName, + final DependencyResolver dependencyResolver, final BundleContext bundleContext) { return new TestingFixedThreadPoolModule(new ModuleIdentifier(NAME, instanceName), null, null); } @Override - public Module createModule(String instanceName, - DependencyResolver dependencyResolver, DynamicMBeanWithInstance old, BundleContext bundleContext) + public Module createModule(final String instanceName, + final DependencyResolver dependencyResolver, final DynamicMBeanWithInstance old, final BundleContext bundleContext) throws Exception { int threadCount = (Integer) old.getAttribute("ThreadCount"); // is the instance compatible? @@ -65,12 +63,12 @@ public class TestingFixedThreadPoolModuleFactory extends AbstractTestingFixedThr @Override public boolean isModuleImplementingServiceInterface( - Class serviceInterface) { + final Class serviceInterface) { return ifc.contains(serviceInterface); } @Override - public Set getDefaultModules(DependencyResolverFactory dependencyResolverFactory, BundleContext bundleContext) { + public Set getDefaultModules(final DependencyResolverFactory dependencyResolverFactory, final BundleContext bundleContext) { return new HashSet(); } diff --git a/opendaylight/config/config-netty-config/pom.xml b/opendaylight/config/config-netty-config/pom.xml index 257c36779c..1e7a027b5b 100644 --- a/opendaylight/config/config-netty-config/pom.xml +++ b/opendaylight/config/config-netty-config/pom.xml @@ -1,4 +1,5 @@ + - 4.0.0 - - org.opendaylight.controller - config-subsystem - 0.3.0-SNAPSHOT - - config-netty-config - Configuration files for sal-rest-connector - jar - - - - org.codehaus.mojo - build-helper-maven-plugin - - - attach-artifacts - - attach-artifact - - package - - - - ${project.build.directory}/classes/initial/00-netty.xml - xml - config - - - - - - - - + 4.0.0 + + org.opendaylight.controller + config-subsystem + 0.3.0-SNAPSHOT + + config-netty-config + Configuration files for sal-rest-connector + jar + + + + org.codehaus.mojo + build-helper-maven-plugin + + + attach-artifacts + + attach-artifact + + package + + + + ${project.build.directory}/classes/initial/00-netty.xml + xml + config + + + + + + + + diff --git a/opendaylight/config/config-persister-directory-xml-adapter/src/main/java/org/opendaylight/controller/config/persist/storage/directory/xml/XmlDirectoryPersister.java b/opendaylight/config/config-persister-directory-xml-adapter/src/main/java/org/opendaylight/controller/config/persist/storage/directory/xml/XmlDirectoryPersister.java index 7f8ebd7fdd..92bf080662 100644 --- a/opendaylight/config/config-persister-directory-xml-adapter/src/main/java/org/opendaylight/controller/config/persist/storage/directory/xml/XmlDirectoryPersister.java +++ b/opendaylight/config/config-persister-directory-xml-adapter/src/main/java/org/opendaylight/controller/config/persist/storage/directory/xml/XmlDirectoryPersister.java @@ -7,17 +7,9 @@ */ package org.opendaylight.controller.config.persist.storage.directory.xml; +import static com.google.common.base.Preconditions.checkArgument; import com.google.common.base.Optional; import com.google.common.io.Files; -import org.opendaylight.controller.config.persist.api.ConfigSnapshotHolder; -import org.opendaylight.controller.config.persist.api.Persister; -import org.opendaylight.controller.config.persist.storage.file.xml.model.ConfigSnapshot; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import javax.xml.bind.JAXBContext; -import javax.xml.bind.JAXBException; -import javax.xml.bind.Unmarshaller; import java.io.File; import java.io.FilenameFilter; import java.io.IOException; @@ -27,11 +19,17 @@ import java.util.Collections; import java.util.List; import java.util.Set; import java.util.SortedSet; - -import static com.google.common.base.Preconditions.checkArgument; +import javax.xml.bind.JAXBContext; +import javax.xml.bind.JAXBException; +import javax.xml.bind.Unmarshaller; +import org.opendaylight.controller.config.persist.api.ConfigSnapshotHolder; +import org.opendaylight.controller.config.persist.api.Persister; +import org.opendaylight.controller.config.persist.storage.file.xml.model.ConfigSnapshot; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; public class XmlDirectoryPersister implements Persister { - private static final Logger logger = LoggerFactory.getLogger(XmlDirectoryPersister.class); + private static final Logger LOG = LoggerFactory.getLogger(XmlDirectoryPersister.class); private final File storage; private final Optional extensionsFilter; @@ -39,25 +37,25 @@ public class XmlDirectoryPersister implements Persister { /** * Creates XmlDirectoryPersister that picks up all files in specified folder */ - public XmlDirectoryPersister(File storage) { + public XmlDirectoryPersister(final File storage) { this(storage, Optional.absent()); } /** * Creates XmlDirectoryPersister that picks up files only with specified file extension */ - public XmlDirectoryPersister(File storage, Set fileExtensions) { + public XmlDirectoryPersister(final File storage, final Set fileExtensions) { this(storage, Optional.of(getFilter(fileExtensions))); } - private XmlDirectoryPersister(File storage, Optional extensionsFilter) { + private XmlDirectoryPersister(final File storage, final Optional extensionsFilter) { checkArgument(storage.exists() && storage.isDirectory(), "Storage directory does not exist: " + storage); this.storage = storage; this.extensionsFilter = extensionsFilter; } @Override - public void persistConfig(ConfigSnapshotHolder holder) throws IOException { + public void persistConfig(final ConfigSnapshotHolder holder) throws IOException { throw new UnsupportedOperationException("This adapter is read only. Please set readonly=true on " + getClass()); } @@ -70,11 +68,11 @@ public class XmlDirectoryPersister implements Persister { List sortedFiles = new ArrayList<>(Arrays.asList(filesArray)); Collections.sort(sortedFiles); // combine all found files - logger.debug("Reading files in following order: {}", sortedFiles); + LOG.debug("Reading files in following order: {}", sortedFiles); List result = new ArrayList<>(); for (File file : sortedFiles) { - logger.trace("Adding file '{}' to combined result", file); + LOG.trace("Adding file '{}' to combined result", file); Optional h = fromXmlSnapshot(file); // Ignore non valid snapshot if(h.isPresent() == false) { @@ -86,12 +84,12 @@ public class XmlDirectoryPersister implements Persister { return result; } - private Optional fromXmlSnapshot(File file) { + private Optional fromXmlSnapshot(final File file) { try { return Optional.of(loadLastConfig(file)); } catch (JAXBException e) { // In case of parse error, issue a warning, ignore and continue - logger.warn( + LOG.warn( "Unable to parse configuration snapshot from {}. Initial config from {} will be IGNORED in this run. " + "Note that subsequent config files may fail due to this problem. " + "Xml markup in this file needs to be fixed, for detailed information see enclosed exception.", @@ -101,7 +99,7 @@ public class XmlDirectoryPersister implements Persister { return Optional.absent(); } - public static ConfigSnapshotHolder loadLastConfig(File file) throws JAXBException { + public static ConfigSnapshotHolder loadLastConfig(final File file) throws JAXBException { JAXBContext jaxbContext = JAXBContext.newInstance(ConfigSnapshot.class); Unmarshaller um = jaxbContext.createUnmarshaller(); @@ -132,7 +130,7 @@ public class XmlDirectoryPersister implements Persister { return new FilenameFilter() { @Override - public boolean accept(File dir, String name) { + public boolean accept(final File dir, final String name) { String ext = Files.getFileExtension(name); return fileExtensions.contains(ext); } diff --git a/opendaylight/config/config-persister-directory-xml-adapter/src/main/java/org/opendaylight/controller/config/persist/storage/directory/xml/XmlDirectoryStorageAdapter.java b/opendaylight/config/config-persister-directory-xml-adapter/src/main/java/org/opendaylight/controller/config/persist/storage/directory/xml/XmlDirectoryStorageAdapter.java index 40f8c283dd..42ab93b585 100644 --- a/opendaylight/config/config-persister-directory-xml-adapter/src/main/java/org/opendaylight/controller/config/persist/storage/directory/xml/XmlDirectoryStorageAdapter.java +++ b/opendaylight/config/config-persister-directory-xml-adapter/src/main/java/org/opendaylight/controller/config/persist/storage/directory/xml/XmlDirectoryStorageAdapter.java @@ -11,21 +11,20 @@ package org.opendaylight.controller.config.persist.storage.directory.xml; import com.google.common.base.Preconditions; import com.google.common.base.Splitter; import com.google.common.collect.Sets; +import java.io.File; +import java.util.Set; import org.opendaylight.controller.config.persist.api.Persister; import org.opendaylight.controller.config.persist.api.PropertiesProvider; import org.opendaylight.controller.config.persist.api.StorageAdapter; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import java.io.File; -import java.util.Set; - /** * StorageAdapter that retrieves initial configuration from a directory. If multiple files are present, snapshot and * required capabilities will be merged together. Writing to this persister is not supported. */ public class XmlDirectoryStorageAdapter implements StorageAdapter { - private static final Logger logger = LoggerFactory.getLogger(XmlDirectoryStorageAdapter.class); + private static final Logger LOG = LoggerFactory.getLogger(XmlDirectoryStorageAdapter.class); public static final String DIRECTORY_STORAGE_PROP = "directoryStorage"; public static final String INCLUDE_EXT_PROP = "includeExtensions"; @@ -33,23 +32,23 @@ public class XmlDirectoryStorageAdapter implements StorageAdapter { @Override - public Persister instantiate(PropertiesProvider propertiesProvider) { + public Persister instantiate(final PropertiesProvider propertiesProvider) { String fileStorageProperty = propertiesProvider.getProperty(DIRECTORY_STORAGE_PROP); Preconditions.checkNotNull(fileStorageProperty, "Unable to find " + propertiesProvider.getFullKeyForReporting(DIRECTORY_STORAGE_PROP)); File storage = new File(fileStorageProperty); String fileExtensions = propertiesProvider.getProperty(INCLUDE_EXT_PROP); - logger.debug("Using storage: {}", storage); + LOG.debug("Using storage: {}", storage); if(fileExtensions != null) { - logger.debug("Using extensions: {}", fileExtensions); + LOG.debug("Using extensions: {}", fileExtensions); return new XmlDirectoryPersister(storage, splitExtensions(fileExtensions)); } else { return new XmlDirectoryPersister(storage); } } - private Set splitExtensions(String fileExtensions) { + private Set splitExtensions(final String fileExtensions) { return Sets.newHashSet(Splitter.on(EXTENSIONS_SEPARATOR).trimResults().omitEmptyStrings() .split(fileExtensions)); } diff --git a/opendaylight/config/config-persister-directory-xml-adapter/src/test/java/org/opendaylight/controller/config/persist/storage/directory/xml/DirectoryStorageAdapterTest.java b/opendaylight/config/config-persister-directory-xml-adapter/src/test/java/org/opendaylight/controller/config/persist/storage/directory/xml/DirectoryStorageAdapterTest.java index 7af06bd3e3..11c7e1253a 100644 --- a/opendaylight/config/config-persister-directory-xml-adapter/src/test/java/org/opendaylight/controller/config/persist/storage/directory/xml/DirectoryStorageAdapterTest.java +++ b/opendaylight/config/config-persister-directory-xml-adapter/src/test/java/org/opendaylight/controller/config/persist/storage/directory/xml/DirectoryStorageAdapterTest.java @@ -12,13 +12,12 @@ import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; - +import com.google.common.base.Optional; import java.io.File; import java.io.IOException; import java.util.Collections; import java.util.List; import java.util.SortedSet; - import org.junit.Test; import org.opendaylight.controller.config.persist.api.ConfigSnapshotHolder; import org.opendaylight.controller.config.persist.api.Persister; @@ -27,13 +26,11 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.xml.sax.SAXException; -import com.google.common.base.Optional; - public class DirectoryStorageAdapterTest { + private static final Logger LOG = LoggerFactory.getLogger(DirectoryStorageAdapterTest.class); Persister tested; - Logger logger = LoggerFactory.getLogger(DirectoryStorageAdapterTest.class.toString()); - private Persister instantiatePersisterFromAdapter(File file, Optional extensions){ + private Persister instantiatePersisterFromAdapter(final File file, final Optional extensions){ PropertiesProviderTest pp = new PropertiesProviderTest(); pp.addProperty(XmlDirectoryStorageAdapter.DIRECTORY_STORAGE_PROP,file.getPath()); if(extensions.isPresent()) { @@ -44,7 +41,7 @@ public class DirectoryStorageAdapterTest { return dsa.instantiate(pp); } - private Persister instantiatePersisterFromAdapter(File file){ + private Persister instantiatePersisterFromAdapter(final File file){ return instantiatePersisterFromAdapter(file, Optional.absent()); } @@ -74,7 +71,7 @@ public class DirectoryStorageAdapterTest { } } - private File getFolder(String folderName) { + private File getFolder(final String folderName) { File result = new File(("src/test/resources/" + folderName).replace("/", File.separator)); assertTrue(result + " is not a directory", result.isDirectory()); @@ -86,7 +83,7 @@ public class DirectoryStorageAdapterTest { File folder = getFolder("oneFile"); tested = instantiatePersisterFromAdapter(folder, Optional.of("xml")); - logger.info("Testing : " + tested.toString()); + LOG.info("Testing : {}", tested); List results = tested.loadLastConfigs(); assertEquals(1, results.size()); ConfigSnapshotHolder result = results.get(0); @@ -97,10 +94,10 @@ public class DirectoryStorageAdapterTest { public void testOneFileWrongExtension() throws Exception { File folder = getFolder("oneFile"); tested = instantiatePersisterFromAdapter(folder, Optional.of("aa, bb")); - logger.info("Testing : " + tested.toString()); + LOG.info("Testing : {}", tested); } - private void assertResult(ConfigSnapshotHolder result, String s, String... caps) throws SAXException, IOException { + private void assertResult(final ConfigSnapshotHolder result, final String s, final String... caps) throws SAXException, IOException { assertXMLEqual(s, result.getConfigSnapshot()); int i = 0; for (String capFromSnapshot : result.getCapabilities()) { @@ -112,7 +109,7 @@ public class DirectoryStorageAdapterTest { public void testTwoFilesAllExtensions() throws Exception { File folder = getFolder("twoFiles"); tested = instantiatePersisterFromAdapter(folder); - logger.info("Testing : " + tested.toString()); + LOG.info("Testing : {}", tested); List results = tested.loadLastConfigs(); assertEquals(2, results.size()); @@ -124,7 +121,7 @@ public class DirectoryStorageAdapterTest { public void testTwoFilesTwoExtensions() throws Exception { File folder = getFolder("twoFiles"); tested = instantiatePersisterFromAdapter(folder, Optional.of("xml, xml2")); - logger.info("Testing : " + tested.toString()); + LOG.info("Testing : {}", tested); assertEquals(2, tested.loadLastConfigs().size()); } @@ -132,7 +129,7 @@ public class DirectoryStorageAdapterTest { public void testTwoFilesOnlyOneExtension() throws Exception { File folder = getFolder("twoFiles"); tested = instantiatePersisterFromAdapter(folder, Optional.of("xml")); - logger.info("Testing : " + tested.toString()); + LOG.info("Testing : ", tested); List results = tested.loadLastConfigs(); assertEquals(1, results.size()); @@ -143,7 +140,7 @@ public class DirectoryStorageAdapterTest { public void testTwoFilesOneInvalid() throws Exception { File folder = getFolder("twoFiles_corrupt"); tested = instantiatePersisterFromAdapter(folder, Optional.of("xml")); - logger.info("Testing : " + tested.toString()); + LOG.info("Testing : {}", tested); List results = tested.loadLastConfigs(); assertEquals(1, results.size()); diff --git a/opendaylight/config/config-persister-feature-adapter/src/main/java/org/opendaylight/controller/configpusherfeature/internal/ConfigPusherCustomizer.java b/opendaylight/config/config-persister-feature-adapter/src/main/java/org/opendaylight/controller/configpusherfeature/internal/ConfigPusherCustomizer.java index abb1dbe9aa..52bca76555 100644 --- a/opendaylight/config/config-persister-feature-adapter/src/main/java/org/opendaylight/controller/configpusherfeature/internal/ConfigPusherCustomizer.java +++ b/opendaylight/config/config-persister-feature-adapter/src/main/java/org/opendaylight/controller/configpusherfeature/internal/ConfigPusherCustomizer.java @@ -17,14 +17,14 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class ConfigPusherCustomizer implements ServiceTrackerCustomizer, AutoCloseable { - private static final Logger LOGGER = LoggerFactory.getLogger(ConfigPusherCustomizer.class); + private static final Logger LOG = LoggerFactory.getLogger(ConfigPusherCustomizer.class); private ConfigFeaturesListener configFeaturesListener = null; private FeatureServiceCustomizer featureServiceCustomizer = null; private ServiceTracker fsst = null; @Override public ConfigPusher addingService(ServiceReference configPusherServiceReference) { - LOGGER.trace("Got ConfigPusherCustomizer.addingService {}", configPusherServiceReference); + LOG.trace("Got ConfigPusherCustomizer.addingService {}", configPusherServiceReference); BundleContext bc = configPusherServiceReference.getBundle().getBundleContext(); ConfigPusher cpService = bc.getService(configPusherServiceReference); featureServiceCustomizer = new FeatureServiceCustomizer(cpService); diff --git a/opendaylight/config/config-persister-feature-adapter/src/main/java/org/opendaylight/controller/configpusherfeature/internal/ConfigPushingRunnable.java b/opendaylight/config/config-persister-feature-adapter/src/main/java/org/opendaylight/controller/configpusherfeature/internal/ConfigPushingRunnable.java index b0e64b84d2..1a40bb34d7 100644 --- a/opendaylight/config/config-persister-feature-adapter/src/main/java/org/opendaylight/controller/configpusherfeature/internal/ConfigPushingRunnable.java +++ b/opendaylight/config/config-persister-feature-adapter/src/main/java/org/opendaylight/controller/configpusherfeature/internal/ConfigPushingRunnable.java @@ -40,14 +40,14 @@ public class ConfigPushingRunnable implements Runnable { while(true) { try { if(!interuppted) { - if(toInstall.isEmpty()) { - event = queue.take(); - } else { - event = queue.poll(POLL_TIME, TimeUnit.MILLISECONDS); - } - if(event != null && event.getFeature() !=null) { - processFeatureEvent(event,toInstall); - } + if(toInstall.isEmpty()) { + event = queue.take(); + } else { + event = queue.poll(POLL_TIME, TimeUnit.MILLISECONDS); + } + if(event != null && event.getFeature() !=null) { + processFeatureEvent(event,toInstall); + } } else if(toInstall.isEmpty()) { LOGGER.error("ConfigPushingRunnable - exiting"); return; diff --git a/opendaylight/config/config-persister-feature-adapter/src/main/java/org/opendaylight/controller/configpusherfeature/internal/FeatureConfigPusher.java b/opendaylight/config/config-persister-feature-adapter/src/main/java/org/opendaylight/controller/configpusherfeature/internal/FeatureConfigPusher.java index 5c5061277b..7b90580a66 100644 --- a/opendaylight/config/config-persister-feature-adapter/src/main/java/org/opendaylight/controller/configpusherfeature/internal/FeatureConfigPusher.java +++ b/opendaylight/config/config-persister-feature-adapter/src/main/java/org/opendaylight/controller/configpusherfeature/internal/FeatureConfigPusher.java @@ -7,11 +7,11 @@ */ package org.opendaylight.controller.configpusherfeature.internal; +import com.google.common.collect.LinkedHashMultimap; import java.util.ArrayList; import java.util.Arrays; import java.util.LinkedHashSet; import java.util.List; - import org.apache.karaf.features.Feature; import org.apache.karaf.features.FeaturesService; import org.opendaylight.controller.config.persist.api.ConfigPusher; @@ -19,13 +19,11 @@ import org.opendaylight.controller.config.persist.api.ConfigSnapshotHolder; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import com.google.common.collect.LinkedHashMultimap; - /* * Simple class to push configs to the config subsystem from Feature's configfiles */ public class FeatureConfigPusher { - private static final Logger LOGGER = LoggerFactory.getLogger(FeatureConfigPusher.class); + private static final Logger LOG = LoggerFactory.getLogger(FeatureConfigPusher.class); private static final int MAX_RETRIES=100; private static final int RETRY_PAUSE_MILLIS=1; private FeaturesService featuresService = null; @@ -46,7 +44,7 @@ public class FeatureConfigPusher { /* * @param p - ConfigPusher to push ConfigSnapshotHolders */ - public FeatureConfigPusher(ConfigPusher p, FeaturesService f) { + public FeatureConfigPusher(final ConfigPusher p, final FeaturesService f) { pusher = p; featuresService = f; } @@ -59,7 +57,7 @@ public class FeatureConfigPusher { * If a Feature is not in the returned LinkedHashMultimap then we couldn't push its configs * (Ususally because it was not yet installed) */ - public LinkedHashMultimap pushConfigs(List features) throws Exception, InterruptedException { + public LinkedHashMultimap pushConfigs(final List features) throws Exception, InterruptedException { LinkedHashMultimap pushedFeatures = LinkedHashMultimap.create(); for(Feature feature: features) { LinkedHashSet configSnapShots = pushConfig(feature); @@ -70,7 +68,7 @@ public class FeatureConfigPusher { return pushedFeatures; } - private LinkedHashSet pushConfig(Feature feature) throws Exception, InterruptedException { + private LinkedHashSet pushConfig(final Feature feature) throws Exception, InterruptedException { LinkedHashSet configs = new LinkedHashSet(); if(isInstalled(feature)) { ChildAwareFeatureWrapper wrappedFeature = new ChildAwareFeatureWrapper(feature,featuresService); @@ -83,20 +81,20 @@ public class FeatureConfigPusher { return configs; } - private boolean isInstalled(Feature feature) { + private boolean isInstalled(final Feature feature) { for(int retries=0;retries installedFeatures = Arrays.asList(featuresService.listInstalledFeatures()); if(installedFeatures.contains(feature)) { return true; } else { - LOGGER.warn("Karaf featuresService.listInstalledFeatures() has not yet finished installing feature (retry {}) {} {}",retries,feature.getName(),feature.getVersion()); + LOG.warn("Karaf featuresService.listInstalledFeatures() has not yet finished installing feature (retry {}) {} {}",retries,feature.getName(),feature.getVersion()); } } catch (Exception e) { if(retries < MAX_RETRIES) { - LOGGER.warn("Karaf featuresService.listInstalledFeatures() has thrown an exception, retry {}, Exception {}", retries,e); + LOG.warn("Karaf featuresService.listInstalledFeatures() has thrown an exception, retry {}", retries, e); } else { - LOGGER.error("Giving up on Karaf featuresService.listInstalledFeatures() which has thrown an exception, retry {}, Exception {}", retries,e); + LOG.error("Giving up on Karaf featuresService.listInstalledFeatures() which has thrown an exception, retry {}", retries, e); throw e; } } @@ -106,11 +104,11 @@ public class FeatureConfigPusher { throw new IllegalStateException(e1); } } - LOGGER.error("Giving up (after {} retries) on Karaf featuresService.listInstalledFeatures() which has not yet finished installing feature {} {}",MAX_RETRIES,feature.getName(),feature.getVersion()); + LOG.error("Giving up (after {} retries) on Karaf featuresService.listInstalledFeatures() which has not yet finished installing feature {} {}",MAX_RETRIES,feature.getName(),feature.getVersion()); return false; } - private LinkedHashSet pushConfig(LinkedHashSet configs) throws InterruptedException { + private LinkedHashSet pushConfig(final LinkedHashSet configs) throws InterruptedException { LinkedHashSet configsToPush = new LinkedHashSet(configs); configsToPush.removeAll(pushedConfigs); if(!configsToPush.isEmpty()) { diff --git a/opendaylight/config/config-persister-feature-adapter/src/main/java/org/opendaylight/controller/configpusherfeature/internal/FeatureConfigSnapshotHolder.java b/opendaylight/config/config-persister-feature-adapter/src/main/java/org/opendaylight/controller/configpusherfeature/internal/FeatureConfigSnapshotHolder.java index d1a92ebe7f..5ab5c959f7 100644 --- a/opendaylight/config/config-persister-feature-adapter/src/main/java/org/opendaylight/controller/configpusherfeature/internal/FeatureConfigSnapshotHolder.java +++ b/opendaylight/config/config-persister-feature-adapter/src/main/java/org/opendaylight/controller/configpusherfeature/internal/FeatureConfigSnapshotHolder.java @@ -106,16 +106,15 @@ public class FeatureConfigSnapshotHolder implements ConfigSnapshotHolder { @Override public String toString() { - StringBuilder b = new StringBuilder(); - Path p = Paths.get(fileInfo.getFinalname()); - b.append(p.getFileName()) - .append("(") - .append(getCauseFeature()) - .append(",") - .append(getFeature()) - .append(")"); - return b.toString(); - + StringBuilder b = new StringBuilder(); + Path p = Paths.get(fileInfo.getFinalname()); + b.append(p.getFileName()) + .append("(") + .append(getCauseFeature()) + .append(",") + .append(getFeature()) + .append(")"); + return b.toString(); } @Override diff --git a/opendaylight/config/config-persister-file-xml-adapter/src/test/java/org/opendaylight/controller/config/persist/storage/file/xml/FileStorageAdapterTest.java b/opendaylight/config/config-persister-file-xml-adapter/src/test/java/org/opendaylight/controller/config/persist/storage/file/xml/FileStorageAdapterTest.java index 2bfe70adb8..942ba4c4b3 100644 --- a/opendaylight/config/config-persister-file-xml-adapter/src/test/java/org/opendaylight/controller/config/persist/storage/file/xml/FileStorageAdapterTest.java +++ b/opendaylight/config/config-persister-file-xml-adapter/src/test/java/org/opendaylight/controller/config/persist/storage/file/xml/FileStorageAdapterTest.java @@ -8,12 +8,12 @@ package org.opendaylight.controller.config.persist.storage.file.xml; -import static junit.framework.Assert.assertFalse; +import static org.junit.Assert.assertFalse; import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual; import static org.hamcrest.CoreMatchers.is; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertThat; - +import com.google.common.base.Charsets; import java.io.File; import java.io.FileNotFoundException; import java.io.IOException; @@ -21,17 +21,12 @@ import java.nio.file.Files; import java.util.List; import java.util.SortedSet; import java.util.TreeSet; - -import junit.framework.Assert; - import org.junit.Before; import org.junit.Test; import org.mockito.Mockito; import org.opendaylight.controller.config.persist.api.ConfigSnapshotHolder; import org.opendaylight.controller.config.persist.test.PropertiesProviderTest; -import com.google.common.base.Charsets; - public class FileStorageAdapterTest { private static int i; @@ -42,8 +37,9 @@ public class FileStorageAdapterTest { @Before public void setUp() throws Exception { file = Files.createTempFile("testFilePersist", ".txt").toFile(); - if (!file.exists()) + if (!file.exists()) { return; + } com.google.common.io.Files.write("", file, Charsets.UTF_8); i = 1; } @@ -71,7 +67,7 @@ public class FileStorageAdapterTest { storage.persistConfig(holder); - Assert.assertEquals(storage.toString().replace("\\","/"),"XmlFileStorageAdapter [storage="+NON_EXISTENT_DIRECTORY+NON_EXISTENT_FILE+"]"); + assertEquals(storage.toString().replace("\\","/"),"XmlFileStorageAdapter [storage="+NON_EXISTENT_DIRECTORY+NON_EXISTENT_FILE+"]"); delete(new File(NON_EXISTENT_DIRECTORY)); } @Test @@ -109,7 +105,7 @@ public class FileStorageAdapterTest { storage.setNumberOfBackups(Integer.MAX_VALUE); List last = storage.loadLastConfigs(); - Assert.assertEquals(createCaps(), last.get(0).getCapabilities()); + assertEquals(createCaps(), last.get(0).getCapabilities()); } private SortedSet createCaps() { @@ -188,8 +184,9 @@ public class FileStorageAdapterTest { @Test public void testNoLastConfig() throws Exception { File file = Files.createTempFile("testFilePersist", ".txt").toFile(); - if (!file.exists()) + if (!file.exists()) { return; + } XmlFileStorageAdapter storage = new XmlFileStorageAdapter(); storage.setFileStorage(file); @@ -223,12 +220,14 @@ public class FileStorageAdapterTest { return "" + i++ + ""; } - private void delete(File f) throws IOException { + private void delete(final File f) throws IOException { if (f.isDirectory()) { - for (File c : f.listFiles()) + for (File c : f.listFiles()) { delete(c); + } } - if (!f.delete()) + if (!f.delete()) { throw new FileNotFoundException("Failed to delete file: " + f); + } } } diff --git a/opendaylight/config/config-util/src/test/java/org/opendaylight/controller/config/util/AttributeEntryTest.java b/opendaylight/config/config-util/src/test/java/org/opendaylight/controller/config/util/AttributeEntryTest.java index b2afd3542e..200fa8854d 100644 --- a/opendaylight/config/config-util/src/test/java/org/opendaylight/controller/config/util/AttributeEntryTest.java +++ b/opendaylight/config/config-util/src/test/java/org/opendaylight/controller/config/util/AttributeEntryTest.java @@ -2,8 +2,6 @@ package org.opendaylight.controller.config.util; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNull; - -import org.junit.After; import org.junit.Before; import org.junit.Test; diff --git a/opendaylight/config/config-util/src/test/java/org/opendaylight/controller/config/util/ConfigRegistryClientsTest.java b/opendaylight/config/config-util/src/test/java/org/opendaylight/controller/config/util/ConfigRegistryClientsTest.java index 0524f0019a..fc1c3f8afe 100644 --- a/opendaylight/config/config-util/src/test/java/org/opendaylight/controller/config/util/ConfigRegistryClientsTest.java +++ b/opendaylight/config/config-util/src/test/java/org/opendaylight/controller/config/util/ConfigRegistryClientsTest.java @@ -7,29 +7,25 @@ */ package org.opendaylight.controller.config.util; +import static org.hamcrest.CoreMatchers.hasItem; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; import static org.junit.Assert.assertThat; -import static org.junit.matchers.JUnitMatchers.hasItem; - +import com.google.common.collect.Sets; import java.lang.management.ManagementFactory; import java.util.HashMap; import java.util.Map; import java.util.Set; - import javax.management.InstanceNotFoundException; import javax.management.MBeanServer; import javax.management.ObjectName; - import org.junit.After; import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.opendaylight.controller.config.api.ConfigRegistry; -import com.google.common.collect.Sets; - public class ConfigRegistryClientsTest { private TestingConfigRegistry testingRegistry; @@ -145,7 +141,7 @@ public class ConfigRegistryClientsTest { assertEquals(Sets.newHashSet(TestingConfigRegistry.run2, TestingConfigRegistry.run1, TestingConfigRegistry.run3), jmxLookup); } - private Set lookupRuntimeBeans(ConfigRegistryClient client) + private Set lookupRuntimeBeans(final ConfigRegistryClient client) throws Exception { Set beans = client.lookupRuntimeBeans(); for (ObjectName on : beans) { @@ -178,7 +174,7 @@ public class ConfigRegistryClientsTest { } private Set clientLookupRuntimeBeansWithModuleAndInstance( - ConfigRegistryClient client, String moduleName, String instanceName) { + final ConfigRegistryClient client, final String moduleName, final String instanceName) { Set beans = client.lookupRuntimeBeans(moduleName, instanceName); if (beans.size() > 0) { assertEquals("RuntimeBean", @@ -220,7 +216,7 @@ public class ConfigRegistryClientsTest { assertThat(clientLookupServiceInterfaceNames(testingRegistryON), hasItem(TestingConfigRegistry.serviceQName2)); } - private Set clientLookupServiceInterfaceNames(ObjectName client) throws InstanceNotFoundException{ + private Set clientLookupServiceInterfaceNames(final ObjectName client) throws InstanceNotFoundException{ return jmxRegistryClient.lookupServiceInterfaceNames(client); } diff --git a/opendaylight/config/config-util/src/test/java/org/opendaylight/controller/config/util/LookupTest.java b/opendaylight/config/config-util/src/test/java/org/opendaylight/controller/config/util/LookupTest.java index 4489762a47..3bc362b38c 100644 --- a/opendaylight/config/config-util/src/test/java/org/opendaylight/controller/config/util/LookupTest.java +++ b/opendaylight/config/config-util/src/test/java/org/opendaylight/controller/config/util/LookupTest.java @@ -93,8 +93,7 @@ public class LookupTest { public void testLookupConfigBeans2() throws Exception { Method method = LookupRegistry.class.getMethod("lookupConfigBeans", String.class, String.class); - Object[] args = new Object[] { TestingConfigRegistry.moduleName1, - TestingConfigRegistry.instName1 }; + Object[] args = new Object[] { TestingConfigRegistry.moduleName1, TestingConfigRegistry.instName1 }; test(method, args); } @@ -102,8 +101,7 @@ public class LookupTest { public void testLookupConfigBean() throws Exception { Method method = LookupRegistry.class.getMethod("lookupConfigBean", String.class, String.class); - Object[] args = new Object[] { TestingConfigRegistry.moduleName1, - TestingConfigRegistry.instName1 }; + Object[] args = new Object[] { TestingConfigRegistry.moduleName1, TestingConfigRegistry.instName1 }; test(method, args); } diff --git a/opendaylight/config/logback-config-loader/src/test/java/org/opendaylight/controller/logback/config/loader/test/LogbackConfigurationLoaderTest.java b/opendaylight/config/logback-config-loader/src/test/java/org/opendaylight/controller/logback/config/loader/test/LogbackConfigurationLoaderTest.java index 2e9bf1df00..adbb9f4cd6 100644 --- a/opendaylight/config/logback-config-loader/src/test/java/org/opendaylight/controller/logback/config/loader/test/LogbackConfigurationLoaderTest.java +++ b/opendaylight/config/logback-config-loader/src/test/java/org/opendaylight/controller/logback/config/loader/test/LogbackConfigurationLoaderTest.java @@ -58,23 +58,22 @@ public class LogbackConfigurationLoaderTest { // check logs String[] expectedLogs = new String[] { - "LoggingEvent -> [INFO] org.opendaylight.controller.logback.config.loader.test.LogbackConfigurationLoaderTest: LOGBACK ready -> about to use it", - "LoggingEvent -> [TRACE] org.opendaylight.controller.logback.config.loader.test.logwork.Tracer: tracing", - "LoggingEvent -> [DEBUG] org.opendaylight.controller.logback.config.loader.test.logwork.Tracer: debugging", - "LoggingEvent -> [INFO] org.opendaylight.controller.logback.config.loader.test.logwork.Tracer: infoing", - "LoggingEvent -> [WARN] org.opendaylight.controller.logback.config.loader.test.logwork.Tracer: warning", - "LoggingEvent -> [ERROR] org.opendaylight.controller.logback.config.loader.test.logwork.Tracer: erroring", - "LoggingEvent -> [DEBUG] org.opendaylight.controller.logback.config.loader.test.logwork.Debugger: debugging", - "LoggingEvent -> [INFO] org.opendaylight.controller.logback.config.loader.test.logwork.Debugger: infoing", - "LoggingEvent -> [WARN] org.opendaylight.controller.logback.config.loader.test.logwork.Debugger: warning", - "LoggingEvent -> [ERROR] org.opendaylight.controller.logback.config.loader.test.logwork.Debugger: erroring", - "LoggingEvent -> [INFO] org.opendaylight.controller.logback.config.loader.test.logwork.Informer: infoing", - "LoggingEvent -> [WARN] org.opendaylight.controller.logback.config.loader.test.logwork.Informer: warning", - "LoggingEvent -> [ERROR] org.opendaylight.controller.logback.config.loader.test.logwork.Informer: erroring", - "LoggingEvent -> [WARN] org.opendaylight.controller.logback.config.loader.test.logwork.Warner: warning", - "LoggingEvent -> [ERROR] org.opendaylight.controller.logback.config.loader.test.logwork.Warner: erroring", - "LoggingEvent -> [ERROR] org.opendaylight.controller.logback.config.loader.test.logwork.Errorer: erroring" - + "LoggingEvent -> [INFO] org.opendaylight.controller.logback.config.loader.test.LogbackConfigurationLoaderTest: LOGBACK ready -> about to use it", + "LoggingEvent -> [TRACE] org.opendaylight.controller.logback.config.loader.test.logwork.Tracer: tracing", + "LoggingEvent -> [DEBUG] org.opendaylight.controller.logback.config.loader.test.logwork.Tracer: debugging", + "LoggingEvent -> [INFO] org.opendaylight.controller.logback.config.loader.test.logwork.Tracer: infoing", + "LoggingEvent -> [WARN] org.opendaylight.controller.logback.config.loader.test.logwork.Tracer: warning", + "LoggingEvent -> [ERROR] org.opendaylight.controller.logback.config.loader.test.logwork.Tracer: erroring", + "LoggingEvent -> [DEBUG] org.opendaylight.controller.logback.config.loader.test.logwork.Debugger: debugging", + "LoggingEvent -> [INFO] org.opendaylight.controller.logback.config.loader.test.logwork.Debugger: infoing", + "LoggingEvent -> [WARN] org.opendaylight.controller.logback.config.loader.test.logwork.Debugger: warning", + "LoggingEvent -> [ERROR] org.opendaylight.controller.logback.config.loader.test.logwork.Debugger: erroring", + "LoggingEvent -> [INFO] org.opendaylight.controller.logback.config.loader.test.logwork.Informer: infoing", + "LoggingEvent -> [WARN] org.opendaylight.controller.logback.config.loader.test.logwork.Informer: warning", + "LoggingEvent -> [ERROR] org.opendaylight.controller.logback.config.loader.test.logwork.Informer: erroring", + "LoggingEvent -> [WARN] org.opendaylight.controller.logback.config.loader.test.logwork.Warner: warning", + "LoggingEvent -> [ERROR] org.opendaylight.controller.logback.config.loader.test.logwork.Warner: erroring", + "LoggingEvent -> [ERROR] org.opendaylight.controller.logback.config.loader.test.logwork.Errorer: erroring" }; List logSnapshot = new ArrayList<>(TestAppender.getLogRecord()); diff --git a/opendaylight/config/logback-config-loader/src/test/resources/logback-test.xml b/opendaylight/config/logback-config-loader/src/test/resources/logback-test.xml index 7fb760aca7..52f2521969 100755 --- a/opendaylight/config/logback-config-loader/src/test/resources/logback-test.xml +++ b/opendaylight/config/logback-config-loader/src/test/resources/logback-test.xml @@ -1,17 +1,17 @@ - - - - - - %date{"yyyy-MM-dd HH:mm:ss.SSS z"} [%thread] %-5level %logger{36} - %msg%n - - - - - - - - - - - + + + + + + %date{"yyyy-MM-dd HH:mm:ss.SSS z"} [%thread] %-5level %logger{36} - %msg%n + + + + + + + + + + + diff --git a/opendaylight/config/logback-config-loader/src/test/resources/logback.d/logback-alt.xml b/opendaylight/config/logback-config-loader/src/test/resources/logback.d/logback-alt.xml index ca489d5c78..e4f8dfc26b 100755 --- a/opendaylight/config/logback-config-loader/src/test/resources/logback.d/logback-alt.xml +++ b/opendaylight/config/logback-config-loader/src/test/resources/logback.d/logback-alt.xml @@ -1,19 +1,19 @@ - - - - - - - %date{"yyyy-MM-dd HH:mm:ss.SSS z"} [%thread] %-5level %logger{36} - %msg%n - - - - - - - - - - - - + + + + + + + %date{"yyyy-MM-dd HH:mm:ss.SSS z"} [%thread] %-5level %logger{36} - %msg%n + + + + + + + + + + + + diff --git a/opendaylight/config/logback-config-loader/src/test/resources/logback.d/logback-alt2.xml b/opendaylight/config/logback-config-loader/src/test/resources/logback.d/logback-alt2.xml index 89f82c5046..83557f6072 100755 --- a/opendaylight/config/logback-config-loader/src/test/resources/logback.d/logback-alt2.xml +++ b/opendaylight/config/logback-config-loader/src/test/resources/logback.d/logback-alt2.xml @@ -1,12 +1,12 @@ - - - - - - - - - - - - + + + + + + + + + + + + diff --git a/opendaylight/config/logback-config-loader/src/test/resources/logback.d/logback-alt3.xml b/opendaylight/config/logback-config-loader/src/test/resources/logback.d/logback-alt3.xml index a37b6f7f21..a944cc28b5 100755 --- a/opendaylight/config/logback-config-loader/src/test/resources/logback.d/logback-alt3.xml +++ b/opendaylight/config/logback-config-loader/src/test/resources/logback.d/logback-alt3.xml @@ -1,11 +1,11 @@ - - - - - - - - - - - + + + + + + + + + + + diff --git a/opendaylight/config/logback-config/src/main/java/org/opendaylight/controller/config/yang/logback/config/ContextSetterImpl.java b/opendaylight/config/logback-config/src/main/java/org/opendaylight/controller/config/yang/logback/config/ContextSetterImpl.java index ff7da5df48..087648cae7 100644 --- a/opendaylight/config/logback-config/src/main/java/org/opendaylight/controller/config/yang/logback/config/ContextSetterImpl.java +++ b/opendaylight/config/logback-config/src/main/java/org/opendaylight/controller/config/yang/logback/config/ContextSetterImpl.java @@ -7,16 +7,6 @@ */ package org.opendaylight.controller.config.yang.logback.config; -import java.io.Closeable; -import java.io.IOException; -import java.util.HashMap; -import java.util.Iterator; -import java.util.List; -import java.util.Map; -import java.util.Set; - -import org.slf4j.LoggerFactory; - import ch.qos.logback.classic.Level; import ch.qos.logback.classic.LoggerContext; import ch.qos.logback.classic.encoder.PatternLayoutEncoder; @@ -26,10 +16,17 @@ import ch.qos.logback.core.Appender; import ch.qos.logback.core.rolling.FixedWindowRollingPolicy; import ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy; import ch.qos.logback.core.rolling.TimeBasedRollingPolicy; - import com.google.common.base.Optional; import com.google.common.base.Preconditions; import com.google.common.collect.Sets; +import java.io.Closeable; +import java.io.IOException; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Set; +import org.slf4j.LoggerFactory; /** * Implementation of {@link ContextSetter}. Resets running logback @@ -40,12 +37,13 @@ public class ContextSetterImpl implements ContextSetter, Closeable { private final LogbackStatusListener statusListener; private static final org.slf4j.Logger LOGGER = LoggerFactory.getLogger(ContextSetterImpl.class); - public ContextSetterImpl(LogbackRuntimeRegistrator rootRuntimeBeanRegistratorWrapper) { + public ContextSetterImpl(final LogbackRuntimeRegistrator rootRuntimeBeanRegistratorWrapper) { statusListener = new LogbackStatusListener(rootRuntimeBeanRegistratorWrapper); statusListener.register(); } - public void updateContext(LogbackModule module) { + @Override + public void updateContext(final LogbackModule module) { LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory(); List loggersBefore = context.getLoggerList(); @@ -53,12 +51,12 @@ public class ContextSetterImpl implements ContextSetter, Closeable { createLoggers(context, module, Sets.newHashSet(loggersBefore)); } - private Map> createConsoleAppenders(LoggerContext context, LogbackModule module) { + private Map> createConsoleAppenders(final LoggerContext context, final LogbackModule module) { Map> appendersMap = new HashMap<>(); for (ConsoleAppenderTO appender : module.getConsoleAppenderTO()) { Preconditions.checkState(appendersMap.containsKey(appender.getName()) == false, "Duplicate appender name %s", appender.getName()); - ch.qos.logback.core.ConsoleAppender app = new ch.qos.logback.core.ConsoleAppender(); + ch.qos.logback.core.ConsoleAppender app = new ch.qos.logback.core.ConsoleAppender<>(); app.setContext(context); PatternLayoutEncoder encoder = new PatternLayoutEncoder(); encoder.setContext(context); @@ -77,8 +75,8 @@ public class ContextSetterImpl implements ContextSetter, Closeable { return appendersMap; } - private void createLoggers(LoggerContext context, LogbackModule module, - Set loggersBefore) { + private void createLoggers(final LoggerContext context, final LogbackModule module, + final Set loggersBefore) { Map> appendersMap = getAppenders(module, context); @@ -97,8 +95,8 @@ public class ContextSetterImpl implements ContextSetter, Closeable { } } - private void addNewAppenders(Map> appendersMap, LoggerTO logger, - ch.qos.logback.classic.Logger logbackLogger, Optional>> appendersBefore) { + private void addNewAppenders(final Map> appendersMap, final LoggerTO logger, + final ch.qos.logback.classic.Logger logbackLogger, final Optional>> appendersBefore) { if (logger.getAppenders() != null) { for (String appenderName : logger.getAppenders()) { if (appendersMap.containsKey(appenderName)) { @@ -112,8 +110,8 @@ public class ContextSetterImpl implements ContextSetter, Closeable { } } - private void removeBeforeAppenders(Set loggersBefore, LoggerTO logger, - ch.qos.logback.classic.Logger logbackLogger, Optional>> appendersBefore) { + private void removeBeforeAppenders(final Set loggersBefore, final LoggerTO logger, + final ch.qos.logback.classic.Logger logbackLogger, final Optional>> appendersBefore) { if (appendersBefore.isPresent()) { for (Appender appenderBefore : appendersBefore.get()) { logbackLogger.detachAppender(appenderBefore); @@ -125,8 +123,8 @@ public class ContextSetterImpl implements ContextSetter, Closeable { } } - private Optional>> getAppendersBefore(Set loggersBefore, - ch.qos.logback.classic.Logger logbackLogger) { + private Optional>> getAppendersBefore(final Set loggersBefore, + final ch.qos.logback.classic.Logger logbackLogger) { if (loggersBefore.contains(logbackLogger)) { Iterator> appenderIt = logbackLogger.iteratorForAppenders(); Set> appendersBefore = Sets.newHashSet(); @@ -140,7 +138,7 @@ public class ContextSetterImpl implements ContextSetter, Closeable { } - private Map> getAppenders(LogbackModule module, LoggerContext context) { + private Map> getAppenders(final LogbackModule module, final LoggerContext context) { Map> appendersMap = new HashMap<>(); addAllAppenders(appendersMap, createRollingAppenders(context, module)); addAllAppenders(appendersMap, createFileAppenders(context, module)); @@ -149,8 +147,8 @@ public class ContextSetterImpl implements ContextSetter, Closeable { return appendersMap; } - private void addAllAppenders(Map> allAppenders, - Map> appendersToAdd) { + private void addAllAppenders(final Map> allAppenders, + final Map> appendersToAdd) { for (String appenderName : appendersToAdd.keySet()) { Preconditions.checkState(allAppenders.containsKey(appenderName) == false, "Duplicate appender name %s", appenderName); @@ -158,12 +156,12 @@ public class ContextSetterImpl implements ContextSetter, Closeable { } } - private Map> createFileAppenders(LoggerContext context, LogbackModule module) { + private Map> createFileAppenders(final LoggerContext context, final LogbackModule module) { Map> appendersMap = new HashMap<>(); for (FileAppenderTO appender : module.getFileAppenderTO()) { Preconditions.checkState(appendersMap.containsKey(appender.getName()) == false, "Duplicate appender name %s", appender.getName()); - ch.qos.logback.core.FileAppender app = new ch.qos.logback.core.FileAppender<>(); + ch.qos.logback.core.FileAppender app = new ch.qos.logback.core.FileAppender<>(); app.setAppend(appender.getAppend()); app.setContext(context); PatternLayoutEncoder encoder = new PatternLayoutEncoder(); @@ -180,12 +178,12 @@ public class ContextSetterImpl implements ContextSetter, Closeable { return appendersMap; } - private Map> createRollingAppenders(LoggerContext context, LogbackModule module) { + private Map> createRollingAppenders(final LoggerContext context, final LogbackModule module) { Map> appendersMap = new HashMap<>(); for (RollingFileAppenderTO appender : module.getRollingFileAppenderTO()) { Preconditions.checkState(appendersMap.containsKey(appender.getName()) == false, "Duplicate appender name %s", appender.getName()); - ch.qos.logback.core.rolling.RollingFileAppender app = new ch.qos.logback.core.rolling.RollingFileAppender<>(); + ch.qos.logback.core.rolling.RollingFileAppender app = new ch.qos.logback.core.rolling.RollingFileAppender<>(); app.setAppend(appender.getAppend()); app.setContext(context); PatternLayoutEncoder encoder = new PatternLayoutEncoder(); @@ -204,7 +202,7 @@ public class ContextSetterImpl implements ContextSetter, Closeable { policy.start(); app.setRollingPolicy(policy); } else if (appender.getRollingPolicyType().equals("TimeBasedRollingPolicy")) { - TimeBasedRollingPolicy policy = new TimeBasedRollingPolicy(); + TimeBasedRollingPolicy policy = new TimeBasedRollingPolicy<>(); policy.setContext(context); policy.setMaxHistory(appender.getMaxHistory()); if (appender.getCleanHistoryOnStart() != null) { @@ -215,7 +213,7 @@ public class ContextSetterImpl implements ContextSetter, Closeable { policy.start(); app.setRollingPolicy(policy); } - SizeBasedTriggeringPolicy triggeringPolicy = new SizeBasedTriggeringPolicy(); + SizeBasedTriggeringPolicy triggeringPolicy = new SizeBasedTriggeringPolicy<>(); triggeringPolicy.setContext(context); triggeringPolicy.setMaxFileSize(appender.getMaxFileSize()); triggeringPolicy.start(); diff --git a/opendaylight/config/logback-config/src/main/java/org/opendaylight/controller/config/yang/logback/config/LogbackModuleFactory.java b/opendaylight/config/logback-config/src/main/java/org/opendaylight/controller/config/yang/logback/config/LogbackModuleFactory.java index b5d0d1b4de..bd19d5eecd 100644 --- a/opendaylight/config/logback-config/src/main/java/org/opendaylight/controller/config/yang/logback/config/LogbackModuleFactory.java +++ b/opendaylight/config/logback-config/src/main/java/org/opendaylight/controller/config/yang/logback/config/LogbackModuleFactory.java @@ -16,6 +16,18 @@ */ package org.opendaylight.controller.config.yang.logback.config; +import ch.qos.logback.classic.Logger; +import ch.qos.logback.classic.LoggerContext; +import ch.qos.logback.classic.encoder.PatternLayoutEncoder; +import ch.qos.logback.classic.spi.ILoggingEvent; +import ch.qos.logback.classic.spi.LoggerComparator; +import ch.qos.logback.core.Appender; +import ch.qos.logback.core.rolling.FixedWindowRollingPolicy; +import ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy; +import ch.qos.logback.core.rolling.TimeBasedRollingPolicy; +import com.google.common.base.Preconditions; +import com.google.common.collect.Lists; +import com.google.common.collect.Sets; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; @@ -24,7 +36,6 @@ import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Set; - import org.apache.commons.lang3.StringUtils; import org.opendaylight.controller.config.api.DependencyResolver; import org.opendaylight.controller.config.api.DependencyResolverFactory; @@ -32,20 +43,6 @@ import org.opendaylight.controller.config.api.ModuleIdentifier; import org.osgi.framework.BundleContext; import org.slf4j.LoggerFactory; -import ch.qos.logback.classic.Logger; -import ch.qos.logback.classic.LoggerContext; -import ch.qos.logback.classic.encoder.PatternLayoutEncoder; -import ch.qos.logback.classic.spi.ILoggingEvent; -import ch.qos.logback.classic.spi.LoggerComparator; -import ch.qos.logback.core.Appender; -import ch.qos.logback.core.rolling.FixedWindowRollingPolicy; -import ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy; -import ch.qos.logback.core.rolling.TimeBasedRollingPolicy; - -import com.google.common.base.Preconditions; -import com.google.common.collect.Lists; -import com.google.common.collect.Sets; - /** * */ @@ -59,8 +56,8 @@ public class LogbackModuleFactory extends private Map fileDTOs; @Override - public LogbackModule instantiateModule(String instanceName, DependencyResolver dependencyResolver, - BundleContext bundleContext) { + public LogbackModule instantiateModule(final String instanceName, final DependencyResolver dependencyResolver, + final BundleContext bundleContext) { Preconditions.checkArgument(instanceName.equals(INSTANCE_NAME), "There should be just one instance of logback, named " + INSTANCE_NAME); prepareDTOs(); @@ -74,8 +71,8 @@ public class LogbackModuleFactory extends } @Override - public LogbackModule instantiateModule(String instanceName, DependencyResolver dependencyResolver, - LogbackModule oldModule, AutoCloseable oldInstance, BundleContext bundleContext) { + public LogbackModule instantiateModule(final String instanceName, final DependencyResolver dependencyResolver, + final LogbackModule oldModule, final AutoCloseable oldInstance, final BundleContext bundleContext) { Preconditions.checkArgument(instanceName.equals(INSTANCE_NAME), "There should be just one instance of logback, named " + INSTANCE_NAME); prepareDTOs(); @@ -97,7 +94,7 @@ public class LogbackModuleFactory extends prepareAppendersDTOs(context); } - private void prepareAppendersDTOs(LoggerContext context) { + private void prepareAppendersDTOs(final LoggerContext context) { this.rollingDTOs = new HashMap<>(); this.consoleDTOs = new HashMap<>(); this.fileDTOs = new HashMap<>(); @@ -131,7 +128,7 @@ public class LogbackModuleFactory extends app.setFileNamePattern(rollingPolicy.getFileNamePattern()); app.setRollingPolicyType("FixedWindowRollingPolicy"); } else if (rollingApp.getRollingPolicy() instanceof TimeBasedRollingPolicy) { - TimeBasedRollingPolicy rollingPolicy = (TimeBasedRollingPolicy) rollingApp.getRollingPolicy(); + TimeBasedRollingPolicy rollingPolicy = (TimeBasedRollingPolicy) rollingApp.getRollingPolicy(); app.setRollingPolicyType("TimeBasedRollingPolicy"); app.setFileNamePattern(rollingPolicy.getFileNamePattern()); app.setMaxHistory(rollingPolicy.getMaxHistory()); @@ -166,7 +163,7 @@ public class LogbackModuleFactory extends } } - private Map prepareLoggersDTOs(LoggerContext context) { + private Map prepareLoggersDTOs(final LoggerContext context) { Map DTOs = new HashMap<>(); List appenders = new ArrayList<>(); List loggersToBeAdd = removeUnusableLoggers(context.getLoggerList(), @@ -192,7 +189,7 @@ public class LogbackModuleFactory extends return DTOs; } - private List removeUnusableLoggers(List loggerList, Logger rootLogger) { + private List removeUnusableLoggers(final List loggerList, final Logger rootLogger) { Collections.sort(loggerList, new LoggerComparator()); Map loggersToReturn = new HashMap<>(); @@ -234,8 +231,8 @@ public class LogbackModuleFactory extends } @Override - public Set getDefaultModules(DependencyResolverFactory dependencyResolverFactory, - BundleContext bundleContext) { + public Set getDefaultModules(final DependencyResolverFactory dependencyResolverFactory, + final BundleContext bundleContext) { DependencyResolver resolver = dependencyResolverFactory.createDependencyResolver(new ModuleIdentifier( getImplementationName(), INSTANCE_NAME)); LogbackModule defaultLogback = instantiateModule(INSTANCE_NAME, resolver, bundleContext); diff --git a/opendaylight/config/logback-config/src/test/java/org/opendaylight/controller/config/yang/logback/config/LogbackModuleTest.java b/opendaylight/config/logback-config/src/test/java/org/opendaylight/controller/config/yang/logback/config/LogbackModuleTest.java index 75323d256e..9e07cc68cb 100644 --- a/opendaylight/config/logback-config/src/test/java/org/opendaylight/controller/config/yang/logback/config/LogbackModuleTest.java +++ b/opendaylight/config/logback-config/src/test/java/org/opendaylight/controller/config/yang/logback/config/LogbackModuleTest.java @@ -7,9 +7,9 @@ */ package org.opendaylight.controller.config.yang.logback.config; +import static org.hamcrest.CoreMatchers.containsString; import static org.junit.Assert.assertThat; import static org.junit.Assert.fail; -import static org.junit.matchers.JUnitMatchers.containsString; import java.util.ArrayList; import java.util.Arrays; diff --git a/opendaylight/config/netconf-config-dispatcher/src/main/java/org/opendaylight/controller/config/yang/config/netconf/client/dispatcher/NetconfClientDispatcherModule.java b/opendaylight/config/netconf-config-dispatcher/src/main/java/org/opendaylight/controller/config/yang/config/netconf/client/dispatcher/NetconfClientDispatcherModule.java index 344ef3dec3..0a10c2d3a8 100644 --- a/opendaylight/config/netconf-config-dispatcher/src/main/java/org/opendaylight/controller/config/yang/config/netconf/client/dispatcher/NetconfClientDispatcherModule.java +++ b/opendaylight/config/netconf-config-dispatcher/src/main/java/org/opendaylight/controller/config/yang/config/netconf/client/dispatcher/NetconfClientDispatcherModule.java @@ -12,8 +12,7 @@ import org.opendaylight.controller.netconf.client.NetconfClientDispatcherImpl; /** * */ -public final class NetconfClientDispatcherModule extends org.opendaylight.controller.config.yang.config.netconf.client.dispatcher.AbstractNetconfClientDispatcherModule - { +public final class NetconfClientDispatcherModule extends org.opendaylight.controller.config.yang.config.netconf.client.dispatcher.AbstractNetconfClientDispatcherModule { public NetconfClientDispatcherModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) { super(identifier, dependencyResolver); diff --git a/opendaylight/config/netty-timer-config/src/test/java/org/opendaylight/controller/config/yang/netty/timer/HashedWheelTimerModuleTest.java b/opendaylight/config/netty-timer-config/src/test/java/org/opendaylight/controller/config/yang/netty/timer/HashedWheelTimerModuleTest.java index 5fe5f9496e..578476f0f7 100644 --- a/opendaylight/config/netty-timer-config/src/test/java/org/opendaylight/controller/config/yang/netty/timer/HashedWheelTimerModuleTest.java +++ b/opendaylight/config/netty-timer-config/src/test/java/org/opendaylight/controller/config/yang/netty/timer/HashedWheelTimerModuleTest.java @@ -7,12 +7,11 @@ */ package org.opendaylight.controller.config.yang.netty.timer; +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 junit.framework.Assert; - import org.junit.Before; import org.junit.Test; import org.opendaylight.controller.config.api.ConflictingVersionException; @@ -42,9 +41,9 @@ public class HashedWheelTimerModuleTest extends AbstractConfigTest { try { createInstance(transaction, instanceName, 0L, 10, true); transaction.validateConfig(); - Assert.fail(); + fail(); } catch (ValidationException e) { - Assert.assertTrue(e.getMessage().contains("TickDuration value must be greater than 0")); + assertTrue(e.getMessage().contains("TickDuration value must be greater than 0")); } } @@ -53,9 +52,9 @@ public class HashedWheelTimerModuleTest extends AbstractConfigTest { try { createInstance(transaction, instanceName, 500L, 0, true); transaction.validateConfig(); - Assert.fail(); + fail(); } catch (ValidationException e) { - Assert.assertTrue(e.getMessage().contains("TicksPerWheel value must be greater than 0")); + assertTrue(e.getMessage().contains("TicksPerWheel value must be greater than 0")); } } @@ -112,7 +111,7 @@ public class HashedWheelTimerModuleTest extends AbstractConfigTest { assertStatus(status, 0, 1, 1); } - private ObjectName createInstance(ConfigTransactionJMXClient transaction, String instanceName, + private ObjectName createInstance(final ConfigTransactionJMXClient transaction, final String instanceName, final Long tickDuration, final Integer ticksPerWheel, final boolean hasThreadfactory) throws InstanceAlreadyExistsException { ObjectName nameCreated = transaction.createModule(factory.getImplementationName(), instanceName); @@ -126,7 +125,7 @@ public class HashedWheelTimerModuleTest extends AbstractConfigTest { return nameCreated; } - private ObjectName createThreadfactoryInstance(ConfigTransactionJMXClient transaction, String instanceName, + private ObjectName createThreadfactoryInstance(final ConfigTransactionJMXClient transaction, final String instanceName, final String namePrefix) throws InstanceAlreadyExistsException { ObjectName nameCreated = transaction.createModule(threadFactory.getImplementationName(), instanceName); NamingThreadFactoryModuleMXBean mxBean = transaction.newMBeanProxy(nameCreated, diff --git a/opendaylight/config/pom.xml b/opendaylight/config/pom.xml index ea7b243179..ad2607a8db 100644 --- a/opendaylight/config/pom.xml +++ b/opendaylight/config/pom.xml @@ -41,6 +41,8 @@ netconf-config-dispatcher config-module-archetype config-netty-config + + config-artifacts diff --git a/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/async/AsyncEventBusConfigBeanTest.java b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/async/AsyncEventBusConfigBeanTest.java index 0b339fc600..92b81220ff 100644 --- a/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/async/AsyncEventBusConfigBeanTest.java +++ b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/async/AsyncEventBusConfigBeanTest.java @@ -7,9 +7,9 @@ */ package org.opendaylight.controller.config.threadpool.async; +import static org.hamcrest.CoreMatchers.containsString; import static org.junit.Assert.assertThat; import static org.junit.Assert.fail; -import static org.junit.matchers.JUnitMatchers.containsString; import javax.management.InstanceAlreadyExistsException; import javax.management.ObjectName; diff --git a/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/eventbus/SyncEventBusConfigBeanTest.java b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/eventbus/SyncEventBusConfigBeanTest.java index aeb6d6b959..6d0449cf5a 100644 --- a/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/eventbus/SyncEventBusConfigBeanTest.java +++ b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/eventbus/SyncEventBusConfigBeanTest.java @@ -20,10 +20,10 @@ import org.opendaylight.controller.config.yang.threadpool.impl.EventBusModuleFac import javax.management.InstanceAlreadyExistsException; import javax.management.ObjectName; +import static org.hamcrest.CoreMatchers.containsString; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertThat; import static org.junit.Assert.fail; -import static org.junit.matchers.JUnitMatchers.containsString; public class SyncEventBusConfigBeanTest extends AbstractConfigTest { diff --git a/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/fixed/FixedThreadPoolConfigBeanTest.java b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/fixed/FixedThreadPoolConfigBeanTest.java index 62b295be8d..f968e287c2 100644 --- a/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/fixed/FixedThreadPoolConfigBeanTest.java +++ b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/fixed/FixedThreadPoolConfigBeanTest.java @@ -7,10 +7,10 @@ */ package org.opendaylight.controller.config.threadpool.fixed; +import static org.hamcrest.CoreMatchers.containsString; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertThat; import static org.junit.Assert.fail; -import static org.junit.matchers.JUnitMatchers.containsString; import java.lang.management.ManagementFactory; import java.lang.management.ThreadInfo; diff --git a/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/flexible/FlexibleThreadPoolConfigBeanTest.java b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/flexible/FlexibleThreadPoolConfigBeanTest.java index a1d1c40655..9ae721ee87 100644 --- a/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/flexible/FlexibleThreadPoolConfigBeanTest.java +++ b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/flexible/FlexibleThreadPoolConfigBeanTest.java @@ -24,9 +24,9 @@ import javax.management.InstanceAlreadyExistsException; import javax.management.InstanceNotFoundException; import javax.management.ObjectName; +import static org.hamcrest.CoreMatchers.containsString; import static org.junit.Assert.assertThat; import static org.junit.Assert.fail; -import static org.junit.matchers.JUnitMatchers.containsString; public class FlexibleThreadPoolConfigBeanTest extends AbstractConfigTest { diff --git a/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/naming/NamingThreadPoolFactoryConfigBeanTest.java b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/naming/NamingThreadPoolFactoryConfigBeanTest.java index 499beced5f..be3d59bf39 100644 --- a/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/naming/NamingThreadPoolFactoryConfigBeanTest.java +++ b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/naming/NamingThreadPoolFactoryConfigBeanTest.java @@ -7,11 +7,11 @@ */ package org.opendaylight.controller.config.threadpool.naming; +import static org.hamcrest.CoreMatchers.containsString; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertThat; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; -import static org.junit.matchers.JUnitMatchers.containsString; import javax.management.InstanceAlreadyExistsException; import javax.management.InstanceNotFoundException; diff --git a/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/scheduled/ScheduledThreadPoolConfigBeanTest.java b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/scheduled/ScheduledThreadPoolConfigBeanTest.java index 0fc2fd6eb3..6482fe9c1b 100644 --- a/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/scheduled/ScheduledThreadPoolConfigBeanTest.java +++ b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/scheduled/ScheduledThreadPoolConfigBeanTest.java @@ -7,11 +7,11 @@ */ package org.opendaylight.controller.config.threadpool.scheduled; +import static org.hamcrest.CoreMatchers.containsString; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertThat; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; -import static org.junit.matchers.JUnitMatchers.containsString; import javax.management.InstanceAlreadyExistsException; import javax.management.InstanceNotFoundException; diff --git a/opendaylight/config/yang-jmx-generator-plugin/src/main/java/org/opendaylight/controller/config/yangjmxgenerator/plugin/ftl/TemplateFactory.java b/opendaylight/config/yang-jmx-generator-plugin/src/main/java/org/opendaylight/controller/config/yangjmxgenerator/plugin/ftl/TemplateFactory.java index f8f5cd6742..ca1e823ec7 100644 --- a/opendaylight/config/yang-jmx-generator-plugin/src/main/java/org/opendaylight/controller/config/yangjmxgenerator/plugin/ftl/TemplateFactory.java +++ b/opendaylight/config/yang-jmx-generator-plugin/src/main/java/org/opendaylight/controller/config/yangjmxgenerator/plugin/ftl/TemplateFactory.java @@ -607,9 +607,8 @@ public class TemplateFactory { String varName = BindingGeneratorUtil .parseToValidParamName(attrEntry.getKey()); - { - ModuleField field; + ModuleField field; if (isIdentity) { String identityBaseClass = getInnerTypeFromIdentity(((TypedAttribute) attributeIfc).getType()); IdentityRefModuleField identityField = new IdentityRefModuleField(type, varName, @@ -641,7 +640,8 @@ public class TemplateFactory { nullableDefaultWrapped, isDependency, dependency, isListOfDependencies, needsDepResolver); } moduleFields.add(field); - } + + String getterName = "get" + attributeIfc.getUpperCaseCammelCase(); MethodDefinition getter = new MethodDefinition(type, diff --git a/opendaylight/config/yang-jmx-generator-plugin/src/main/java/org/opendaylight/controller/config/yangjmxgenerator/plugin/gofactory/AbsModuleGeneratedObjectFactory.java b/opendaylight/config/yang-jmx-generator-plugin/src/main/java/org/opendaylight/controller/config/yangjmxgenerator/plugin/gofactory/AbsModuleGeneratedObjectFactory.java index 33546b1e2a..2378fac6e7 100644 --- a/opendaylight/config/yang-jmx-generator-plugin/src/main/java/org/opendaylight/controller/config/yangjmxgenerator/plugin/gofactory/AbsModuleGeneratedObjectFactory.java +++ b/opendaylight/config/yang-jmx-generator-plugin/src/main/java/org/opendaylight/controller/config/yangjmxgenerator/plugin/gofactory/AbsModuleGeneratedObjectFactory.java @@ -318,11 +318,11 @@ public class AbsModuleGeneratedObjectFactory { .append("}\n"); } else { result.append(format( - "private %s %sDependency;\n"+ - "protected final %s get%sDependency(){\n"+ - "return %sDependency;\n"+ - "}", - osgi, moduleField.getName(), osgi, moduleField.getAttributeName(), moduleField.getName())); + "private %s %sDependency;\n"+ + "protected final %s get%sDependency(){\n"+ + "return %sDependency;\n"+ + "}", + osgi, moduleField.getName(), osgi, moduleField.getAttributeName(), moduleField.getName())); } } } diff --git a/opendaylight/config/yang-jmx-generator-plugin/src/test/java/org/opendaylight/controller/config/yangjmxgenerator/plugin/JMXGeneratorFileNamesValidationTest.java b/opendaylight/config/yang-jmx-generator-plugin/src/test/java/org/opendaylight/controller/config/yangjmxgenerator/plugin/JMXGeneratorFileNamesValidationTest.java index e33f1cddc4..cdff5090bb 100644 --- a/opendaylight/config/yang-jmx-generator-plugin/src/test/java/org/opendaylight/controller/config/yangjmxgenerator/plugin/JMXGeneratorFileNamesValidationTest.java +++ b/opendaylight/config/yang-jmx-generator-plugin/src/test/java/org/opendaylight/controller/config/yangjmxgenerator/plugin/JMXGeneratorFileNamesValidationTest.java @@ -7,11 +7,11 @@ */ package org.opendaylight.controller.config.yangjmxgenerator.plugin; +import static org.hamcrest.CoreMatchers.containsString; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertThat; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; -import static org.junit.matchers.JUnitMatchers.containsString; import org.junit.Test; import org.opendaylight.controller.config.yangjmxgenerator.ConfigConstants; diff --git a/opendaylight/config/yang-jmx-generator-plugin/src/test/java/org/opendaylight/controller/config/yangjmxgenerator/plugin/JMXGeneratorGeneratedFilesTrackerTest.java b/opendaylight/config/yang-jmx-generator-plugin/src/test/java/org/opendaylight/controller/config/yangjmxgenerator/plugin/JMXGeneratorGeneratedFilesTrackerTest.java index 4112ff017a..589fe41f46 100644 --- a/opendaylight/config/yang-jmx-generator-plugin/src/test/java/org/opendaylight/controller/config/yangjmxgenerator/plugin/JMXGeneratorGeneratedFilesTrackerTest.java +++ b/opendaylight/config/yang-jmx-generator-plugin/src/test/java/org/opendaylight/controller/config/yangjmxgenerator/plugin/JMXGeneratorGeneratedFilesTrackerTest.java @@ -7,10 +7,8 @@ */ package org.opendaylight.controller.config.yangjmxgenerator.plugin; +import static org.junit.Assert.assertEquals; import java.io.File; - -import junit.framework.Assert; - import org.junit.Test; public class JMXGeneratorGeneratedFilesTrackerTest { @@ -20,7 +18,7 @@ public class JMXGeneratorGeneratedFilesTrackerTest { JMXGenerator.GeneratedFilesTracker tracker = new JMXGenerator.GeneratedFilesTracker(); tracker.addFile(new File("./a/b/c")); - Assert.assertEquals(1, tracker.getFiles().size()); + assertEquals(1, tracker.getFiles().size()); tracker.addFile(new File("./a/b/c")); } } 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 864ebdf954..42112013e9 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 @@ -7,6 +7,7 @@ */ package org.opendaylight.controller.config.yangjmxgenerator.plugin; +import static org.hamcrest.CoreMatchers.containsString; import static org.hamcrest.CoreMatchers.equalTo; import static org.hamcrest.CoreMatchers.is; import static org.junit.Assert.assertEquals; @@ -15,7 +16,6 @@ import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertThat; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; -import static org.junit.matchers.JUnitMatchers.containsString; import static org.mockito.Matchers.any; import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.doReturn; diff --git a/opendaylight/config/yang-jmx-generator/src/main/java/org/opendaylight/controller/config/yangjmxgenerator/attribute/Dependency.java b/opendaylight/config/yang-jmx-generator/src/main/java/org/opendaylight/controller/config/yangjmxgenerator/attribute/Dependency.java index b3e7b90c96..6ea2ea1724 100644 --- a/opendaylight/config/yang-jmx-generator/src/main/java/org/opendaylight/controller/config/yangjmxgenerator/attribute/Dependency.java +++ b/opendaylight/config/yang-jmx-generator/src/main/java/org/opendaylight/controller/config/yangjmxgenerator/attribute/Dependency.java @@ -10,43 +10,43 @@ package org.opendaylight.controller.config.yangjmxgenerator.attribute; import org.opendaylight.controller.config.yangjmxgenerator.ServiceInterfaceEntry; public class Dependency { - private final ServiceInterfaceEntry sie; - private final boolean mandatory; + private final ServiceInterfaceEntry sie; + private final boolean mandatory; - public Dependency(ServiceInterfaceEntry sie, boolean mandatory) { - this.sie = sie; - this.mandatory = mandatory; - } + public Dependency(ServiceInterfaceEntry sie, boolean mandatory) { + this.sie = sie; + this.mandatory = mandatory; + } - public ServiceInterfaceEntry getSie() { - return sie; - } + public ServiceInterfaceEntry getSie() { + return sie; + } - public boolean isMandatory() { - return mandatory; - } + public boolean isMandatory() { + return mandatory; + } - @Override - public boolean equals(Object o) { - if (this == o) - return true; - if (o == null || getClass() != o.getClass()) - return false; + @Override + public boolean equals(Object o) { + if (this == o) + return true; + if (o == null || getClass() != o.getClass()) + return false; - Dependency that = (Dependency) o; + Dependency that = (Dependency) o; - if (mandatory != that.mandatory) - return false; - if (!sie.equals(that.sie)) - return false; + if (mandatory != that.mandatory) + return false; + if (!sie.equals(that.sie)) + return false; - return true; - } - - @Override - public int hashCode() { - int result = sie.hashCode(); - result = 31 * result + (mandatory ? 1 : 0); - return result; - } + return true; + } + + @Override + public int hashCode() { + int result = sie.hashCode(); + result = 31 * result + (mandatory ? 1 : 0); + return result; } +} diff --git a/opendaylight/config/yang-jmx-generator/src/test/java/org/opendaylight/controller/config/yangjmxgenerator/AbstractYangTest.java b/opendaylight/config/yang-jmx-generator/src/test/java/org/opendaylight/controller/config/yangjmxgenerator/AbstractYangTest.java index b9f2ba9cd1..e3c3a3024c 100644 --- a/opendaylight/config/yang-jmx-generator/src/test/java/org/opendaylight/controller/config/yangjmxgenerator/AbstractYangTest.java +++ b/opendaylight/config/yang-jmx-generator/src/test/java/org/opendaylight/controller/config/yangjmxgenerator/AbstractYangTest.java @@ -7,8 +7,7 @@ */ package org.opendaylight.controller.config.yangjmxgenerator; -import static junit.framework.Assert.assertNotNull; -import static junit.framework.Assert.format; +import static org.junit.Assert.assertNotNull; import static org.hamcrest.CoreMatchers.is; import static org.junit.Assert.assertThat; @@ -92,8 +91,8 @@ public abstract class AbstractYangTest { QName qName = identitySchemaNode.getQName(); Preconditions.checkArgument( result.containsKey(qName) == false, - format("Two identities of %s contain same " + "qname %s", - module, qName)); + "Two identities of %s contain same qname %s", + module, qName); result.put(qName, identitySchemaNode); } return result; diff --git a/opendaylight/config/yang-jmx-generator/src/test/java/org/opendaylight/controller/config/yangjmxgenerator/RuntimeBeanEntryTest.java b/opendaylight/config/yang-jmx-generator/src/test/java/org/opendaylight/controller/config/yangjmxgenerator/RuntimeBeanEntryTest.java index e80ebc67a5..38b0a3afec 100644 --- a/opendaylight/config/yang-jmx-generator/src/test/java/org/opendaylight/controller/config/yangjmxgenerator/RuntimeBeanEntryTest.java +++ b/opendaylight/config/yang-jmx-generator/src/test/java/org/opendaylight/controller/config/yangjmxgenerator/RuntimeBeanEntryTest.java @@ -7,10 +7,10 @@ */ package org.opendaylight.controller.config.yangjmxgenerator; -import static junit.framework.Assert.assertNotNull; -import static junit.framework.Assert.assertNull; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; import static org.mockito.Mockito.doReturn; diff --git a/opendaylight/config/yang-test/src/test/java/org/opendaylight/controller/config/yang/test/impl/NetconfTestImplModuleTest.java b/opendaylight/config/yang-test/src/test/java/org/opendaylight/controller/config/yang/test/impl/NetconfTestImplModuleTest.java index 13a31f5976..fb9264749b 100644 --- a/opendaylight/config/yang-test/src/test/java/org/opendaylight/controller/config/yang/test/impl/NetconfTestImplModuleTest.java +++ b/opendaylight/config/yang-test/src/test/java/org/opendaylight/controller/config/yang/test/impl/NetconfTestImplModuleTest.java @@ -9,8 +9,6 @@ package org.opendaylight.controller.config.yang.test.impl; import com.google.common.collect.Lists; -import junit.framework.Assert; - import org.junit.Before; import org.junit.Test; import org.opendaylight.controller.config.api.IdentityAttributeRef; @@ -96,7 +94,7 @@ public class NetconfTestImplModuleTest extends AbstractConfigTest { List testingDeps = proxy.getTestingDeps(); ObjectName testingDep = proxy.getTestingDep(); - Assert.assertEquals(TESTING_DEP_PREFIX, ObjectNameUtil.getInstanceName(testingDep)); + assertEquals(TESTING_DEP_PREFIX, ObjectNameUtil.getInstanceName(testingDep)); assertTestingDeps(testingDeps, 4); transaction.abortConfig(); @@ -135,11 +133,11 @@ public class NetconfTestImplModuleTest extends AbstractConfigTest { } private void assertTestingDeps(List testingDeps, int i) { - Assert.assertEquals(i, testingDeps.size()); + assertEquals(i, testingDeps.size()); int c = 1; for (ObjectName testingDep : testingDeps) { - Assert.assertEquals(TESTING_DEP_PREFIX + Integer.toString(c++), ObjectNameUtil.getInstanceName(testingDep)); + assertEquals(TESTING_DEP_PREFIX + Integer.toString(c++), ObjectNameUtil.getInstanceName(testingDep)); } } diff --git a/opendaylight/karaf-branding/pom.xml b/opendaylight/karaf-branding/pom.xml index dfdc3b76cb..7b2bd864f2 100644 --- a/opendaylight/karaf-branding/pom.xml +++ b/opendaylight/karaf-branding/pom.xml @@ -8,7 +8,6 @@ 0.2.0-SNAPSHOT ../.. - org.opendaylight.controller karaf.branding 1.1.0-SNAPSHOT bundle diff --git a/opendaylight/md-sal/benchmark-data-store/pom.xml b/opendaylight/md-sal/benchmark-data-store/pom.xml index 7d47add017..b196c3180f 100644 --- a/opendaylight/md-sal/benchmark-data-store/pom.xml +++ b/opendaylight/md-sal/benchmark-data-store/pom.xml @@ -16,7 +16,6 @@ and is available at http://www.eclipse.org/legal/epl-v10.html 4.0.0 - org.opendaylight.controller benchmark-data-store diff --git a/opendaylight/md-sal/compatibility/sal-compatibility/src/test/java/org/opendaylight/controller/sal/compatibility/test/MDFlowMappingTest.java b/opendaylight/md-sal/compatibility/sal-compatibility/src/test/java/org/opendaylight/controller/sal/compatibility/test/MDFlowMappingTest.java index 78e82c32de..2490ace648 100644 --- a/opendaylight/md-sal/compatibility/sal-compatibility/src/test/java/org/opendaylight/controller/sal/compatibility/test/MDFlowMappingTest.java +++ b/opendaylight/md-sal/compatibility/sal-compatibility/src/test/java/org/opendaylight/controller/sal/compatibility/test/MDFlowMappingTest.java @@ -7,8 +7,7 @@ */ package org.opendaylight.controller.sal.compatibility.test; -import junit.framework.Assert; - +import org.junit.Assert; import org.junit.Test; import org.opendaylight.controller.sal.action.Action; import org.opendaylight.controller.sal.action.PushVlan; diff --git a/opendaylight/md-sal/compatibility/sal-compatibility/src/test/java/org/opendaylight/controller/sal/compatibility/test/TestToSalConversionsUtils.java b/opendaylight/md-sal/compatibility/sal-compatibility/src/test/java/org/opendaylight/controller/sal/compatibility/test/TestToSalConversionsUtils.java index 45341fb734..54ffddbbe3 100644 --- a/opendaylight/md-sal/compatibility/sal-compatibility/src/test/java/org/opendaylight/controller/sal/compatibility/test/TestToSalConversionsUtils.java +++ b/opendaylight/md-sal/compatibility/sal-compatibility/src/test/java/org/opendaylight/controller/sal/compatibility/test/TestToSalConversionsUtils.java @@ -22,8 +22,6 @@ import java.util.ArrayList; import java.util.Collections; import java.util.List; -import junit.framework.Assert; - import org.junit.Test; import org.opendaylight.controller.sal.action.Flood; import org.opendaylight.controller.sal.action.FloodAll; @@ -198,7 +196,7 @@ public class TestToSalConversionsUtils { public void testFromNodeConnectorRef() throws ConstructionException { Node node = new Node(NodeIDType.OPENFLOW, 42L); NodeConnector nodeConnector = ToSalConversionsUtils.fromNodeConnectorRef(new Uri("1"), node); - Assert.assertEquals("OF|1@OF|00:00:00:00:00:00:00:2a", nodeConnector.toString()); + assertEquals("OF|1@OF|00:00:00:00:00:00:00:2a", nodeConnector.toString()); } private void checkSalMatch(org.opendaylight.controller.sal.match.Match match, MtchType mt) throws ConstructionException { diff --git a/opendaylight/md-sal/compatibility/sal-compatibility/src/test/java/org/opendaylight/controller/sal/compatibility/topology/test/TopologyMappingTest.java b/opendaylight/md-sal/compatibility/sal-compatibility/src/test/java/org/opendaylight/controller/sal/compatibility/topology/test/TopologyMappingTest.java index 9369217d78..2a0d47e9c2 100644 --- a/opendaylight/md-sal/compatibility/sal-compatibility/src/test/java/org/opendaylight/controller/sal/compatibility/topology/test/TopologyMappingTest.java +++ b/opendaylight/md-sal/compatibility/sal-compatibility/src/test/java/org/opendaylight/controller/sal/compatibility/topology/test/TopologyMappingTest.java @@ -7,7 +7,7 @@ */ package org.opendaylight.controller.sal.compatibility.topology.test; -import junit.framework.Assert; +import static org.junit.Assert.assertEquals; import org.junit.Test; import org.opendaylight.controller.sal.compatibility.topology.TopologyMapping; @@ -30,7 +30,7 @@ public class TopologyMappingTest { NodeId nodeId = new NodeId("openflow:1"); String observedNodeId = TopologyMapping.toADNodeId(nodeId); - Assert.assertEquals("1", observedNodeId); + assertEquals("1", observedNodeId); } /** @@ -43,7 +43,7 @@ public class TopologyMappingTest { TpId source = new TpId("foo:2"); NodeConnector observedNodeConnector = TopologyMapping.toADNodeConnector(source, nodeId); - Assert.assertEquals("OF|2@OF|00:00:00:00:00:00:00:01", observedNodeConnector.toString()); + assertEquals("OF|2@OF|00:00:00:00:00:00:00:01", observedNodeConnector.toString()); } /** @@ -54,7 +54,7 @@ public class TopologyMappingTest { TpId source = new TpId("foo:2"); String observedNodeConnectorId = TopologyMapping.toADNodeConnectorId(source); - Assert.assertEquals("2", observedNodeConnectorId); + assertEquals("2", observedNodeConnectorId); } /** @@ -66,7 +66,7 @@ public class TopologyMappingTest { NodeId nodeId = new NodeId("openflow:1"); Node observedNode = TopologyMapping.toADNode(nodeId); - Assert.assertEquals("OF|00:00:00:00:00:00:00:01", observedNode.toString()); + assertEquals("OF|00:00:00:00:00:00:00:01", observedNode.toString()); } /** @@ -79,7 +79,7 @@ public class TopologyMappingTest { TpId source = new TpId("192.168.0.1"); NodeConnector observedNodeConnector = TopologyMapping.toADNodeConnector(source, nodeId); - Assert.assertEquals("MD_SAL_DEPRECATED|192.168.0.1@MD_SAL_DEPRECATED|some_unknown_node", observedNodeConnector.toString()); + assertEquals("MD_SAL_DEPRECATED|192.168.0.1@MD_SAL_DEPRECATED|some_unknown_node", observedNodeConnector.toString()); } } diff --git a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/example/ExampleActor.java b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/example/ExampleActor.java index 06538fd2ae..2437bb4b7d 100644 --- a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/example/ExampleActor.java +++ b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/example/ExampleActor.java @@ -13,6 +13,13 @@ import akka.actor.Props; import akka.japi.Creator; import com.google.common.base.Optional; import com.google.protobuf.ByteString; +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.util.HashMap; +import java.util.Map; import org.opendaylight.controller.cluster.DataPersistenceProvider; import org.opendaylight.controller.cluster.example.messages.KeyValue; import org.opendaylight.controller.cluster.example.messages.KeyValueSaved; @@ -20,30 +27,24 @@ import org.opendaylight.controller.cluster.example.messages.PrintRole; import org.opendaylight.controller.cluster.example.messages.PrintState; import org.opendaylight.controller.cluster.raft.ConfigParams; import org.opendaylight.controller.cluster.raft.RaftActor; +import org.opendaylight.controller.cluster.raft.RaftState; import org.opendaylight.controller.cluster.raft.base.messages.CaptureSnapshotReply; +import org.opendaylight.controller.cluster.raft.behaviors.Leader; import org.opendaylight.controller.cluster.raft.protobuff.client.messages.Payload; -import java.io.ByteArrayInputStream; -import java.io.ByteArrayOutputStream; -import java.io.IOException; -import java.io.ObjectInputStream; -import java.io.ObjectOutputStream; -import java.util.HashMap; -import java.util.Map; - /** * A sample actor showing how the RaftActor is to be extended */ public class ExampleActor extends RaftActor { - private final Map state = new HashMap(); + private final Map state = new HashMap<>(); private final DataPersistenceProvider dataPersistenceProvider; private long persistIdentifier = 1; - public ExampleActor(String id, Map peerAddresses, - Optional configParams) { + public ExampleActor(final String id, final Map peerAddresses, + final Optional configParams) { super(id, peerAddresses, configParams); this.dataPersistenceProvider = new PersistentDataProvider(); } @@ -58,7 +59,7 @@ public class ExampleActor extends RaftActor { }); } - @Override public void onReceiveCommand(Object message) throws Exception{ + @Override public void onReceiveCommand(final Object message) throws Exception{ if(message instanceof KeyValue){ if(isLeader()) { String persistId = Long.toString(persistIdentifier++); @@ -77,7 +78,15 @@ public class ExampleActor extends RaftActor { } else if (message instanceof PrintRole) { if(LOG.isDebugEnabled()) { - LOG.debug("{} = {}, Peers={}", getId(), getRaftState(), getPeers()); + String followers = ""; + if (getRaftState() == RaftState.Leader) { + followers = ((Leader)this.getCurrentBehavior()).printFollowerStates(); + LOG.debug("{} = {}, Peers={}, followers={}", getId(), getRaftState(), getPeers(), followers); + } else { + LOG.debug("{} = {}, Peers={}", getId(), getRaftState(), getPeers()); + } + + } } else { @@ -85,8 +94,8 @@ public class ExampleActor extends RaftActor { } } - @Override protected void applyState(ActorRef clientActor, String identifier, - Object data) { + @Override protected void applyState(final ActorRef clientActor, final String identifier, + final Object data) { if(data instanceof KeyValue){ KeyValue kv = (KeyValue) data; state.put(kv.getKey(), kv.getValue()); @@ -106,7 +115,7 @@ public class ExampleActor extends RaftActor { getSelf().tell(new CaptureSnapshotReply(bs), null); } - @Override protected void applySnapshot(ByteString snapshot) { + @Override protected void applySnapshot(final ByteString snapshot) { state.clear(); try { state.putAll((HashMap) toObject(snapshot)); @@ -118,7 +127,7 @@ public class ExampleActor extends RaftActor { } } - private ByteString fromObject(Object snapshot) throws Exception { + private ByteString fromObject(final Object snapshot) throws Exception { ByteArrayOutputStream b = null; ObjectOutputStream o = null; try { @@ -138,7 +147,7 @@ public class ExampleActor extends RaftActor { } } - private Object toObject(ByteString bs) throws ClassNotFoundException, IOException { + private Object toObject(final ByteString bs) throws ClassNotFoundException, IOException { Object obj = null; ByteArrayInputStream bis = null; ObjectInputStream ois = null; @@ -166,7 +175,7 @@ public class ExampleActor extends RaftActor { return dataPersistenceProvider; } - @Override public void onReceiveRecover(Object message)throws Exception { + @Override public void onReceiveRecover(final Object message)throws Exception { super.onReceiveRecover(message); } @@ -175,11 +184,11 @@ public class ExampleActor extends RaftActor { } @Override - protected void startLogRecoveryBatch(int maxBatchSize) { + protected void startLogRecoveryBatch(final int maxBatchSize) { } @Override - protected void appendRecoveredLogEntry(Payload data) { + protected void appendRecoveredLogEntry(final Payload data) { } @Override @@ -191,6 +200,6 @@ public class ExampleActor extends RaftActor { } @Override - protected void applyRecoverySnapshot(ByteString snapshot) { + protected void applyRecoverySnapshot(final ByteString snapshot) { } } diff --git a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/example/ExampleConfigParamsImpl.java b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/example/ExampleConfigParamsImpl.java index 6192cad230..2faae48838 100644 --- a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/example/ExampleConfigParamsImpl.java +++ b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/example/ExampleConfigParamsImpl.java @@ -15,7 +15,7 @@ import org.opendaylight.controller.cluster.raft.DefaultConfigParamsImpl; public class ExampleConfigParamsImpl extends DefaultConfigParamsImpl { @Override public long getSnapshotBatchCount() { - return 50; + return 25; } @Override diff --git a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/example/TestDriver.java b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/example/TestDriver.java index cb51a8951a..f202a8bb1d 100644 --- a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/example/TestDriver.java +++ b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/example/TestDriver.java @@ -6,7 +6,6 @@ import com.google.common.base.Optional; import org.opendaylight.controller.cluster.example.messages.PrintRole; import org.opendaylight.controller.cluster.example.messages.PrintState; import org.opendaylight.controller.cluster.raft.ConfigParams; -import org.opendaylight.controller.cluster.raft.client.messages.AddRaftPeer; import java.io.BufferedReader; import java.io.InputStreamReader; @@ -35,7 +34,6 @@ public class TestDriver { * Commands * bye * createNodes:{num} - * addNodes:{num} * stopNode:{nodeName} * reinstateNode:{nodeName} * addClients:{num} @@ -66,11 +64,6 @@ public class TestDriver { int n = Integer.parseInt(arr[1]); td.createNodes(n); - } else if (command.startsWith("addNodes")) { - String[] arr = command.split(":"); - int n = Integer.parseInt(arr[1]); - td.addNodes(n); - } else if (command.startsWith("addClients")) { String[] arr = command.split(":"); int n = Integer.parseInt(arr[1]); @@ -134,32 +127,6 @@ public class TestDriver { } } - // add new nodes , pass in the count - public void addNodes(int num) { - Map newPeers = new HashMap<>(); - for (int i=0; i < num; i++) { - nameCounter = nameCounter + 1; - newPeers.put("example-"+nameCounter, "akka://default/user/example-"+nameCounter); - allPeers.put("example-"+nameCounter, "akka://default/user/example-"+nameCounter); - - } - Map newActorRefs = new HashMap(num); - for (Map.Entry entry : newPeers.entrySet()) { - ActorRef exampleActor = createExampleActor(entry.getKey()); - newActorRefs.put(entry.getKey(), exampleActor); - - //now also add these new nodes as peers from the previous nodes - for (ActorRef actor : actorRefs.values()) { - actor.tell(new AddRaftPeer(entry.getKey(), entry.getValue()), null); - } - - System.out.println("Added node:" + entry); - } - - actorRefs.putAll(newActorRefs); - } - - // add num clients to all nodes in the system public void addClients(int num) { for(Map.Entry actorRefEntry : actorRefs.entrySet()) { diff --git a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/AbstractReplicatedLogImpl.java b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/AbstractReplicatedLogImpl.java index 2be4a0c36f..a2c9d660ad 100644 --- a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/AbstractReplicatedLogImpl.java +++ b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/AbstractReplicatedLogImpl.java @@ -7,8 +7,6 @@ */ package org.opendaylight.controller.cluster.raft; -import com.google.protobuf.ByteString; - import java.util.ArrayList; import java.util.List; @@ -20,27 +18,23 @@ public abstract class AbstractReplicatedLogImpl implements ReplicatedLog { // We define this as ArrayList so we can use ensureCapacity. protected ArrayList journal; - protected ByteString snapshot; + protected long snapshotIndex = -1; protected long snapshotTerm = -1; // to be used for rollback during save snapshot failure protected ArrayList snapshottedJournal; - protected ByteString previousSnapshot; protected long previousSnapshotIndex = -1; protected long previousSnapshotTerm = -1; - public AbstractReplicatedLogImpl(ByteString state, long snapshotIndex, + public AbstractReplicatedLogImpl(long snapshotIndex, long snapshotTerm, List unAppliedEntries) { - this.snapshot = state; this.snapshotIndex = snapshotIndex; this.snapshotTerm = snapshotTerm; this.journal = new ArrayList<>(unAppliedEntries); } - public AbstractReplicatedLogImpl() { - this.snapshot = null; this.journal = new ArrayList<>(); } @@ -154,11 +148,6 @@ public abstract class AbstractReplicatedLogImpl implements ReplicatedLog { return logEntryIndex <= snapshotIndex && snapshotIndex != -1; } - @Override - public ByteString getSnapshot() { - return snapshot; - } - @Override public long getSnapshotIndex() { return snapshotIndex; @@ -185,18 +174,13 @@ public abstract class AbstractReplicatedLogImpl implements ReplicatedLog { this.snapshotTerm = snapshotTerm; } - @Override - public void setSnapshot(ByteString snapshot) { - this.snapshot = snapshot; - } - @Override public void clear(int startIndex, int endIndex) { journal.subList(startIndex, endIndex).clear(); } @Override - public void snapshotPreCommit(ByteString snapshot, long snapshotCapturedIndex, long snapshotCapturedTerm) { + public void snapshotPreCommit(long snapshotCapturedIndex, long snapshotCapturedTerm) { snapshottedJournal = new ArrayList<>(journal.size()); snapshottedJournal.addAll(journal.subList(0, (int)(snapshotCapturedIndex - snapshotIndex))); @@ -207,9 +191,6 @@ public abstract class AbstractReplicatedLogImpl implements ReplicatedLog { previousSnapshotTerm = snapshotTerm; setSnapshotTerm(snapshotCapturedTerm); - - previousSnapshot = getSnapshot(); - setSnapshot(snapshot); } @Override @@ -217,7 +198,6 @@ public abstract class AbstractReplicatedLogImpl implements ReplicatedLog { snapshottedJournal = null; previousSnapshotIndex = -1; previousSnapshotTerm = -1; - previousSnapshot = null; } @Override @@ -231,9 +211,5 @@ public abstract class AbstractReplicatedLogImpl implements ReplicatedLog { snapshotTerm = previousSnapshotTerm; previousSnapshotTerm = -1; - - snapshot = previousSnapshot; - previousSnapshot = null; - } } diff --git a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/FollowerLogInformation.java b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/FollowerLogInformation.java index f3de983538..2c4304d404 100644 --- a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/FollowerLogInformation.java +++ b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/FollowerLogInformation.java @@ -61,5 +61,16 @@ public interface FollowerLogInformation { */ public AtomicLong getMatchIndex(); + /** + * Checks if the follower is active by comparing the last updated with the duration + * @return boolean + */ + public boolean isFollowerActive(); + + /** + * restarts the timeout clock of the follower + */ + public void markFollowerActive(); + } diff --git a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/FollowerLogInformationImpl.java b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/FollowerLogInformationImpl.java index 94f9a53a85..c0cfd7e862 100644 --- a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/FollowerLogInformationImpl.java +++ b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/FollowerLogInformationImpl.java @@ -8,6 +8,10 @@ package org.opendaylight.controller.cluster.raft; +import com.google.common.base.Stopwatch; +import scala.concurrent.duration.FiniteDuration; + +import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicLong; public class FollowerLogInformationImpl implements FollowerLogInformation{ @@ -18,11 +22,17 @@ public class FollowerLogInformationImpl implements FollowerLogInformation{ private final AtomicLong matchIndex; + private final Stopwatch stopwatch; + + private final long followerTimeoutMillis; + public FollowerLogInformationImpl(String id, AtomicLong nextIndex, - AtomicLong matchIndex) { + AtomicLong matchIndex, FiniteDuration followerTimeoutDuration) { this.id = id; this.nextIndex = nextIndex; this.matchIndex = matchIndex; + this.stopwatch = new Stopwatch(); + this.followerTimeoutMillis = followerTimeoutDuration.toMillis(); } public long incrNextIndex(){ @@ -57,4 +67,17 @@ public class FollowerLogInformationImpl implements FollowerLogInformation{ return matchIndex; } + @Override + public boolean isFollowerActive() { + long elapsed = stopwatch.elapsed(TimeUnit.MILLISECONDS); + return (stopwatch.isRunning()) && (elapsed <= followerTimeoutMillis); + } + + @Override + public void markFollowerActive() { + if (stopwatch.isRunning()) { + stopwatch.reset(); + } + stopwatch.start(); + } } diff --git a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/RaftActor.java b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/RaftActor.java index 2459c2ff8b..617bb7e534 100644 --- a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/RaftActor.java +++ b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/RaftActor.java @@ -18,6 +18,7 @@ import akka.persistence.SaveSnapshotFailure; import akka.persistence.SaveSnapshotSuccess; import akka.persistence.SnapshotOffer; import akka.persistence.SnapshotSelectionCriteria; +import com.google.common.annotations.VisibleForTesting; import com.google.common.base.Optional; import com.google.common.base.Stopwatch; import com.google.protobuf.ByteString; @@ -30,12 +31,12 @@ import org.opendaylight.controller.cluster.raft.base.messages.CaptureSnapshot; import org.opendaylight.controller.cluster.raft.base.messages.CaptureSnapshotReply; import org.opendaylight.controller.cluster.raft.base.messages.Replicate; import org.opendaylight.controller.cluster.raft.base.messages.SendHeartBeat; +import org.opendaylight.controller.cluster.raft.base.messages.SendInstallSnapshot; +import org.opendaylight.controller.cluster.raft.behaviors.AbstractRaftActorBehavior; import org.opendaylight.controller.cluster.raft.behaviors.Follower; import org.opendaylight.controller.cluster.raft.behaviors.RaftActorBehavior; -import org.opendaylight.controller.cluster.raft.client.messages.AddRaftPeer; import org.opendaylight.controller.cluster.raft.client.messages.FindLeader; import org.opendaylight.controller.cluster.raft.client.messages.FindLeaderReply; -import org.opendaylight.controller.cluster.raft.client.messages.RemoveRaftPeer; import org.opendaylight.controller.cluster.raft.messages.AppendEntriesReply; import org.opendaylight.controller.cluster.raft.protobuff.client.messages.Payload; import org.opendaylight.controller.protobuff.messages.cluster.raft.AppendEntriesMessages; @@ -340,20 +341,6 @@ public abstract class RaftActor extends AbstractUntypedPersistentActor { context.getReplicatedLog().getSnapshotTerm(), context.getReplicatedLog().size()); - } else if (message instanceof AddRaftPeer){ - - // FIXME : Do not add raft peers like this. - // When adding a new Peer we have to ensure that the a majority of - // the peers know about the new Peer. Doing it this way may cause - // a situation where multiple Leaders may emerge - AddRaftPeer arp = (AddRaftPeer)message; - context.addToPeers(arp.getName(), arp.getAddress()); - - } else if (message instanceof RemoveRaftPeer){ - - RemoveRaftPeer rrp = (RemoveRaftPeer)message; - context.removePeer(rrp.getName()); - } else if (message instanceof CaptureSnapshot) { LOG.info("CaptureSnapshot received by actor"); CaptureSnapshot cs = (CaptureSnapshot)message; @@ -388,6 +375,7 @@ public abstract class RaftActor extends AbstractUntypedPersistentActor { } public java.util.Set getPeers() { + return context.getPeerAddresses().keySet(); } @@ -636,7 +624,7 @@ public abstract class RaftActor extends AbstractUntypedPersistentActor { //be greedy and remove entries from in-mem journal which are in the snapshot // and update snapshotIndex and snapshotTerm without waiting for the success, - context.getReplicatedLog().snapshotPreCommit(stateInBytes, + context.getReplicatedLog().snapshotPreCommit( captureSnapshot.getLastAppliedIndex(), captureSnapshot.getLastAppliedTerm()); @@ -644,16 +632,19 @@ public abstract class RaftActor extends AbstractUntypedPersistentActor { "and term:{}", captureSnapshot.getLastAppliedIndex(), captureSnapshot.getLastAppliedTerm()); + if (isLeader() && captureSnapshot.isInstallSnapshotInitiated()) { + // this would be call straight to the leader and won't initiate in serialization + currentBehavior.handleMessage(getSelf(), new SendInstallSnapshot(stateInBytes)); + } + captureSnapshot = null; hasSnapshotCaptureInitiated = false; } - private class ReplicatedLogImpl extends AbstractReplicatedLogImpl { public ReplicatedLogImpl(Snapshot snapshot) { - super(ByteString.copyFrom(snapshot.getState()), - snapshot.getLastAppliedIndex(), snapshot.getLastAppliedTerm(), + super(snapshot.getLastAppliedIndex(), snapshot.getLastAppliedTerm(), snapshot.getUnAppliedEntries()); } @@ -843,4 +834,12 @@ public abstract class RaftActor extends AbstractUntypedPersistentActor { } } + @VisibleForTesting + void setCurrentBehavior(AbstractRaftActorBehavior behavior) { + currentBehavior = behavior; + } + + protected RaftActorBehavior getCurrentBehavior() { + return currentBehavior; + } } diff --git a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/ReplicatedLog.java b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/ReplicatedLog.java index 85893333c2..7ee85322a6 100644 --- a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/ReplicatedLog.java +++ b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/ReplicatedLog.java @@ -8,8 +8,6 @@ package org.opendaylight.controller.cluster.raft; -import com.google.protobuf.ByteString; - import java.util.List; /** @@ -122,13 +120,6 @@ public interface ReplicatedLog { */ boolean isInSnapshot(long index); - /** - * Get the snapshot - * - * @return an object representing the snapshot if it exists. null otherwise - */ - ByteString getSnapshot(); - /** * Get the index of the snapshot * @@ -156,12 +147,6 @@ public interface ReplicatedLog { */ public void setSnapshotTerm(long snapshotTerm); - /** - * sets the snapshot in bytes - * @param snapshot - */ - public void setSnapshot(ByteString snapshot); - /** * Clears the journal entries with startIndex(inclusive) and endIndex (exclusive) * @param startIndex @@ -172,12 +157,10 @@ public interface ReplicatedLog { /** * Handles all the bookkeeping in order to perform a rollback in the * event of SaveSnapshotFailure - * @param snapshot * @param snapshotCapturedIndex * @param snapshotCapturedTerm */ - public void snapshotPreCommit(ByteString snapshot, - long snapshotCapturedIndex, long snapshotCapturedTerm); + public void snapshotPreCommit(long snapshotCapturedIndex, long snapshotCapturedTerm); /** * Sets the Replicated log to state after snapshot success. diff --git a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/base/messages/CaptureSnapshot.java b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/base/messages/CaptureSnapshot.java index bb86e1a37d..d4dd3350f3 100644 --- a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/base/messages/CaptureSnapshot.java +++ b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/base/messages/CaptureSnapshot.java @@ -13,13 +13,20 @@ public class CaptureSnapshot { private long lastAppliedTerm; private long lastIndex; private long lastTerm; + private boolean installSnapshotInitiated; public CaptureSnapshot(long lastIndex, long lastTerm, long lastAppliedIndex, long lastAppliedTerm) { + this(lastIndex, lastTerm, lastAppliedIndex, lastAppliedTerm, false); + } + + public CaptureSnapshot(long lastIndex, long lastTerm,long lastAppliedIndex, + long lastAppliedTerm, boolean installSnapshotInitiated) { this.lastIndex = lastIndex; this.lastTerm = lastTerm; this.lastAppliedIndex = lastAppliedIndex; this.lastAppliedTerm = lastAppliedTerm; + this.installSnapshotInitiated = installSnapshotInitiated; } public long getLastAppliedIndex() { @@ -37,4 +44,8 @@ public class CaptureSnapshot { public long getLastTerm() { return lastTerm; } + + public boolean isInstallSnapshotInitiated() { + return installSnapshotInitiated; + } } diff --git a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/base/messages/InitiateInstallSnapshot.java b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/base/messages/InitiateInstallSnapshot.java new file mode 100644 index 0000000000..7844914873 --- /dev/null +++ b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/base/messages/InitiateInstallSnapshot.java @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2014 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.cluster.raft.base.messages; + +/** + * Internal message by Leader to initiate an install snapshot + */ +public class InitiateInstallSnapshot { +} + diff --git a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/base/messages/SendInstallSnapshot.java b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/base/messages/SendInstallSnapshot.java index 6c3313f316..83c85d9135 100644 --- a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/base/messages/SendInstallSnapshot.java +++ b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/base/messages/SendInstallSnapshot.java @@ -8,7 +8,16 @@ package org.opendaylight.controller.cluster.raft.base.messages; -import java.io.Serializable; +import com.google.protobuf.ByteString; -public class SendInstallSnapshot implements Serializable { +public class SendInstallSnapshot { + private ByteString snapshot; + + public SendInstallSnapshot(ByteString snapshot) { + this.snapshot = snapshot; + } + + public ByteString getSnapshot() { + return snapshot; + } } diff --git a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/behaviors/Leader.java b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/behaviors/Leader.java index de748675a7..ef104e7f58 100644 --- a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/behaviors/Leader.java +++ b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/behaviors/Leader.java @@ -11,6 +11,8 @@ package org.opendaylight.controller.cluster.raft.behaviors; import akka.actor.ActorRef; import akka.actor.ActorSelection; import akka.actor.Cancellable; +import com.google.common.annotations.VisibleForTesting; +import com.google.common.base.Optional; import com.google.common.base.Preconditions; import com.google.protobuf.ByteString; import org.opendaylight.controller.cluster.raft.ClientRequestTracker; @@ -20,6 +22,8 @@ import org.opendaylight.controller.cluster.raft.FollowerLogInformationImpl; import org.opendaylight.controller.cluster.raft.RaftActorContext; import org.opendaylight.controller.cluster.raft.RaftState; import org.opendaylight.controller.cluster.raft.ReplicatedLogEntry; +import org.opendaylight.controller.cluster.raft.base.messages.CaptureSnapshot; +import org.opendaylight.controller.cluster.raft.base.messages.InitiateInstallSnapshot; import org.opendaylight.controller.cluster.raft.base.messages.Replicate; import org.opendaylight.controller.cluster.raft.base.messages.SendHeartBeat; import org.opendaylight.controller.cluster.raft.base.messages.SendInstallSnapshot; @@ -66,8 +70,7 @@ import java.util.concurrent.atomic.AtomicLong; public class Leader extends AbstractRaftActorBehavior { - protected final Map followerToLog = - new HashMap(); + protected final Map followerToLog = new HashMap(); protected final Map mapFollowerToSnapshot = new HashMap<>(); private final Set followers; @@ -79,6 +82,8 @@ public class Leader extends AbstractRaftActorBehavior { private final int minReplicationCount; + private Optional snapshot; + public Leader(RaftActorContext context) { super(context); @@ -88,7 +93,8 @@ public class Leader extends AbstractRaftActorBehavior { FollowerLogInformation followerLogInformation = new FollowerLogInformationImpl(followerId, new AtomicLong(context.getCommitIndex()), - new AtomicLong(-1)); + new AtomicLong(-1), + context.getConfigParams().getElectionTimeOutInterval()); followerToLog.put(followerId, followerLogInformation); } @@ -103,6 +109,7 @@ public class Leader extends AbstractRaftActorBehavior { minReplicationCount = 0; } + snapshot = Optional.absent(); // Immediately schedule a heartbeat // Upon election: send initial empty AppendEntries RPCs @@ -117,6 +124,15 @@ public class Leader extends AbstractRaftActorBehavior { } + private Optional getSnapshot() { + return snapshot; + } + + @VisibleForTesting + void setSnapshot(Optional snapshot) { + this.snapshot = snapshot; + } + @Override protected RaftActorBehavior handleAppendEntries(ActorRef sender, AppendEntries appendEntries) { @@ -146,6 +162,8 @@ public class Leader extends AbstractRaftActorBehavior { return this; } + followerLogInformation.markFollowerActive(); + if (appendEntriesReply.isSuccess()) { followerLogInformation .setMatchIndex(appendEntriesReply.getLogLastIndex()); @@ -246,10 +264,18 @@ public class Leader extends AbstractRaftActorBehavior { if (message instanceof SendHeartBeat) { sendHeartBeat(); return this; - } else if(message instanceof SendInstallSnapshot) { + + } else if(message instanceof InitiateInstallSnapshot) { installSnapshotIfNeeded(); + + } else if(message instanceof SendInstallSnapshot) { + // received from RaftActor + setSnapshot(Optional.of(((SendInstallSnapshot) message).getSnapshot())); + sendInstallSnapshot(); + } else if (message instanceof Replicate) { replicate((Replicate) message); + } else if (message instanceof InstallSnapshotReply){ handleInstallSnapshotReply( (InstallSnapshotReply) message); @@ -263,8 +289,9 @@ public class Leader extends AbstractRaftActorBehavior { private void handleInstallSnapshotReply(InstallSnapshotReply reply) { String followerId = reply.getFollowerId(); - FollowerToSnapshot followerToSnapshot = - mapFollowerToSnapshot.get(followerId); + FollowerToSnapshot followerToSnapshot = mapFollowerToSnapshot.get(followerId); + FollowerLogInformation followerLogInformation = followerToLog.get(followerId); + followerLogInformation.markFollowerActive(); if (followerToSnapshot != null && followerToSnapshot.getChunkIndex() == reply.getChunkIndex()) { @@ -280,8 +307,6 @@ public class Leader extends AbstractRaftActorBehavior { ); } - FollowerLogInformation followerLogInformation = - followerToLog.get(followerId); followerLogInformation.setMatchIndex( context.getReplicatedLog().getSnapshotIndex()); followerLogInformation.setNextIndex( @@ -293,6 +318,12 @@ public class Leader extends AbstractRaftActorBehavior { followerToLog.get(followerId).getNextIndex().get()); } + if (mapFollowerToSnapshot.isEmpty()) { + // once there are no pending followers receiving snapshots + // we can remove snapshot from the memory + setSnapshot(Optional.absent()); + } + } else { followerToSnapshot.markSendStatus(true); } @@ -344,64 +375,87 @@ public class Leader extends AbstractRaftActorBehavior { if (followerActor != null) { FollowerLogInformation followerLogInformation = followerToLog.get(followerId); long followerNextIndex = followerLogInformation.getNextIndex().get(); - List entries = Collections.emptyList(); + boolean isFollowerActive = followerLogInformation.isFollowerActive(); + List entries = null; if (mapFollowerToSnapshot.get(followerId) != null) { - if (mapFollowerToSnapshot.get(followerId).canSendNextChunk()) { + // if install snapshot is in process , then sent next chunk if possible + if (isFollowerActive && mapFollowerToSnapshot.get(followerId).canSendNextChunk()) { sendSnapshotChunk(followerActor, followerId); + } else { + // we send a heartbeat even if we have not received a reply for the last chunk + sendAppendEntriesToFollower(followerActor, followerNextIndex, + Collections.emptyList()); } } else { + long leaderLastIndex = context.getReplicatedLog().lastIndex(); + long leaderSnapShotIndex = context.getReplicatedLog().getSnapshotIndex(); - if (context.getReplicatedLog().isPresent(followerNextIndex)) { + if (isFollowerActive && + context.getReplicatedLog().isPresent(followerNextIndex)) { // FIXME : Sending one entry at a time entries = context.getReplicatedLog().getFrom(followerNextIndex, 1); - followerActor.tell( - new AppendEntries(currentTerm(), context.getId(), - prevLogIndex(followerNextIndex), - prevLogTerm(followerNextIndex), entries, - context.getCommitIndex()).toSerializable(), - actor() - ); - - } else { - // if the followers next index is not present in the leaders log, then snapshot should be sent - long leaderSnapShotIndex = context.getReplicatedLog().getSnapshotIndex(); - long leaderLastIndex = context.getReplicatedLog().lastIndex(); - if (followerNextIndex >= 0 && leaderLastIndex >= followerNextIndex ) { - // if the follower is just not starting and leader's index - // is more than followers index - if(LOG.isDebugEnabled()) { - LOG.debug("SendInstallSnapshot to follower:{}," + - "follower-nextIndex:{}, leader-snapshot-index:{}, " + - "leader-last-index:{}", followerId, - followerNextIndex, leaderSnapShotIndex, leaderLastIndex - ); - } - - actor().tell(new SendInstallSnapshot(), actor()); - } else { - followerActor.tell( - new AppendEntries(currentTerm(), context.getId(), - prevLogIndex(followerNextIndex), - prevLogTerm(followerNextIndex), entries, - context.getCommitIndex()).toSerializable(), - actor() + } else if (isFollowerActive && followerNextIndex >= 0 && + leaderLastIndex >= followerNextIndex ) { + // if the followers next index is not present in the leaders log, and + // if the follower is just not starting and if leader's index is more than followers index + // then snapshot should be sent + + if(LOG.isDebugEnabled()) { + LOG.debug("InitiateInstallSnapshot to follower:{}," + + "follower-nextIndex:{}, leader-snapshot-index:{}, " + + "leader-last-index:{}", followerId, + followerNextIndex, leaderSnapShotIndex, leaderLastIndex ); } + actor().tell(new InitiateInstallSnapshot(), actor()); + + // we would want to sent AE as the capture snapshot might take time + entries = Collections.emptyList(); + + } else { + //we send an AppendEntries, even if the follower is inactive + // in-order to update the followers timestamp, in case it becomes active again + entries = Collections.emptyList(); } + + sendAppendEntriesToFollower(followerActor, followerNextIndex, entries); + } } } } + private void sendAppendEntriesToFollower(ActorSelection followerActor, long followerNextIndex, + List entries) { + followerActor.tell( + new AppendEntries(currentTerm(), context.getId(), + prevLogIndex(followerNextIndex), + prevLogTerm(followerNextIndex), entries, + context.getCommitIndex()).toSerializable(), + actor() + ); + } + /** * An installSnapshot is scheduled at a interval that is a multiple of * a HEARTBEAT_INTERVAL. This is to avoid the need to check for installing * snapshots at every heartbeat. + * + * Install Snapshot works as follows + * 1. Leader sends a InitiateInstallSnapshot message to self + * 2. Leader then initiates the capture snapshot by sending a CaptureSnapshot message to actor + * 3. RaftActor on receipt of the CaptureSnapshotReply (from Shard), stores the received snapshot in the replicated log + * and makes a call to Leader's handleMessage , with SendInstallSnapshot message. + * 4. Leader , picks the snapshot from im-mem ReplicatedLog and sends it in chunks to the Follower + * 5. On complete, Follower sends back a InstallSnapshotReply. + * 6. On receipt of the InstallSnapshotReply for the last chunk, Leader marks the install complete for that follower + * and replenishes the memory by deleting the snapshot in Replicated log. + * */ - private void installSnapshotIfNeeded(){ + private void installSnapshotIfNeeded() { for (String followerId : followers) { ActorSelection followerActor = context.getPeerActorSelection(followerId); @@ -412,6 +466,58 @@ public class Leader extends AbstractRaftActorBehavior { long nextIndex = followerLogInformation.getNextIndex().get(); + if (!context.getReplicatedLog().isPresent(nextIndex) && + context.getReplicatedLog().isInSnapshot(nextIndex)) { + LOG.info("{} follower needs a snapshot install", followerId); + if (snapshot.isPresent()) { + // if a snapshot is present in the memory, most likely another install is in progress + // no need to capture snapshot + sendSnapshotChunk(followerActor, followerId); + + } else { + initiateCaptureSnapshot(); + //we just need 1 follower who would need snapshot to be installed. + // when we have the snapshot captured, we would again check (in SendInstallSnapshot) + // who needs an install and send to all who need + break; + } + + } + } + } + } + + // on every install snapshot, we try to capture the snapshot. + // Once a capture is going on, another one issued will get ignored by RaftActor. + private void initiateCaptureSnapshot() { + LOG.info("Initiating Snapshot Capture to Install Snapshot, Leader:{}", getLeaderId()); + ReplicatedLogEntry lastAppliedEntry = context.getReplicatedLog().get(context.getLastApplied()); + long lastAppliedIndex = -1; + long lastAppliedTerm = -1; + + if (lastAppliedEntry != null) { + lastAppliedIndex = lastAppliedEntry.getIndex(); + lastAppliedTerm = lastAppliedEntry.getTerm(); + } else if (context.getReplicatedLog().getSnapshotIndex() > -1) { + lastAppliedIndex = context.getReplicatedLog().getSnapshotIndex(); + lastAppliedTerm = context.getReplicatedLog().getSnapshotTerm(); + } + + boolean isInstallSnapshotInitiated = true; + actor().tell(new CaptureSnapshot(lastIndex(), lastTerm(), + lastAppliedIndex, lastAppliedTerm, isInstallSnapshotInitiated), + actor()); + } + + + private void sendInstallSnapshot() { + for (String followerId : followers) { + ActorSelection followerActor = context.getPeerActorSelection(followerId); + + if(followerActor != null) { + FollowerLogInformation followerLogInformation = followerToLog.get(followerId); + long nextIndex = followerLogInformation.getNextIndex().get(); + if (!context.getReplicatedLog().isPresent(nextIndex) && context.getReplicatedLog().isInSnapshot(nextIndex)) { sendSnapshotChunk(followerActor, followerId); @@ -426,20 +532,21 @@ public class Leader extends AbstractRaftActorBehavior { */ private void sendSnapshotChunk(ActorSelection followerActor, String followerId) { try { - followerActor.tell( - new InstallSnapshot(currentTerm(), context.getId(), - context.getReplicatedLog().getSnapshotIndex(), - context.getReplicatedLog().getSnapshotTerm(), - getNextSnapshotChunk(followerId, - context.getReplicatedLog().getSnapshot()), - mapFollowerToSnapshot.get(followerId).incrementChunkIndex(), - mapFollowerToSnapshot.get(followerId).getTotalChunks() - ).toSerializable(), - actor() - ); - LOG.info("InstallSnapshot sent to follower {}, Chunk: {}/{}", - followerActor.path(), mapFollowerToSnapshot.get(followerId).getChunkIndex(), - mapFollowerToSnapshot.get(followerId).getTotalChunks()); + if (snapshot.isPresent()) { + followerActor.tell( + new InstallSnapshot(currentTerm(), context.getId(), + context.getReplicatedLog().getSnapshotIndex(), + context.getReplicatedLog().getSnapshotTerm(), + getNextSnapshotChunk(followerId,snapshot.get()), + mapFollowerToSnapshot.get(followerId).incrementChunkIndex(), + mapFollowerToSnapshot.get(followerId).getTotalChunks() + ).toSerializable(), + actor() + ); + LOG.info("InstallSnapshot sent to follower {}, Chunk: {}/{}", + followerActor.path(), mapFollowerToSnapshot.get(followerId).getChunkIndex(), + mapFollowerToSnapshot.get(followerId).getTotalChunks()); + } } catch (IOException e) { LOG.error(e, "InstallSnapshot failed for Leader."); } @@ -456,10 +563,9 @@ public class Leader extends AbstractRaftActorBehavior { mapFollowerToSnapshot.put(followerId, followerToSnapshot); } ByteString nextChunk = followerToSnapshot.getNextChunk(); - if(LOG.isDebugEnabled()) { + if (LOG.isDebugEnabled()) { LOG.debug("Leader's snapshot nextChunk size:{}", nextChunk.size()); } - return nextChunk; } @@ -495,14 +601,11 @@ public class Leader extends AbstractRaftActorBehavior { // Scheduling the heartbeat only once here because heartbeats do not // need to be sent if there are other messages being sent to the remote // actor. - heartbeatSchedule = - context.getActorSystem().scheduler().scheduleOnce( - interval, - context.getActor(), new SendHeartBeat(), - context.getActorSystem().dispatcher(), context.getActor()); + heartbeatSchedule = context.getActorSystem().scheduler().scheduleOnce( + interval, context.getActor(), new SendHeartBeat(), + context.getActorSystem().dispatcher(), context.getActor()); } - private void scheduleInstallSnapshotCheck(FiniteDuration interval) { if(followers.size() == 0){ // Optimization - do not bother scheduling a heartbeat as there are @@ -517,7 +620,7 @@ public class Leader extends AbstractRaftActorBehavior { installSnapshotSchedule = context.getActorSystem().scheduler().scheduleOnce( interval, - context.getActor(), new SendInstallSnapshot(), + context.getActor(), new InitiateInstallSnapshot(), context.getActorSystem().dispatcher(), context.getActor()); } @@ -628,4 +731,19 @@ public class Leader extends AbstractRaftActorBehavior { } } + // called from example-actor for printing the follower-states + public String printFollowerStates() { + StringBuilder sb = new StringBuilder(); + for(FollowerLogInformation followerLogInformation : followerToLog.values()) { + boolean isFollowerActive = followerLogInformation.isFollowerActive(); + sb.append("{"+followerLogInformation.getId() + " state:" + isFollowerActive + "},"); + + } + return "[" + sb.toString() + "]"; + } + + @VisibleForTesting + void markFollowerActive(String followerId) { + followerToLog.get(followerId).markFollowerActive(); + } } diff --git a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/client/messages/AddRaftPeer.java b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/client/messages/AddRaftPeer.java deleted file mode 100644 index d1f4c43c86..0000000000 --- a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/client/messages/AddRaftPeer.java +++ /dev/null @@ -1,23 +0,0 @@ -package org.opendaylight.controller.cluster.raft.client.messages; - -/** - * Created by kramesha on 7/17/14. - */ -public class AddRaftPeer { - - private String name; - private String address; - - public AddRaftPeer(String name, String address) { - this.name = name; - this.address = address; - } - - public String getName() { - return name; - } - - public String getAddress() { - return address; - } -} diff --git a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/client/messages/RemoveRaftPeer.java b/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/client/messages/RemoveRaftPeer.java deleted file mode 100644 index 4b766e04b7..0000000000 --- a/opendaylight/md-sal/sal-akka-raft/src/main/java/org/opendaylight/controller/cluster/raft/client/messages/RemoveRaftPeer.java +++ /dev/null @@ -1,16 +0,0 @@ -package org.opendaylight.controller.cluster.raft.client.messages; - -/** - * Created by kramesha on 7/17/14. - */ -public class RemoveRaftPeer { - private String name; - - public RemoveRaftPeer(String name) { - this.name = name; - } - - public String getName() { - return name; - } -} diff --git a/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/AbstractReplicatedLogImplTest.java b/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/AbstractReplicatedLogImplTest.java index 913665861d..398a2e9b36 100644 --- a/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/AbstractReplicatedLogImplTest.java +++ b/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/AbstractReplicatedLogImplTest.java @@ -7,21 +7,19 @@ */ package org.opendaylight.controller.cluster.raft; -import junit.framework.Assert; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; - -import java.util.HashMap; -import java.util.List; -import java.util.Map; - import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; -import static org.opendaylight.controller.cluster.raft.MockRaftActorContext.MockPayload; -import static org.opendaylight.controller.cluster.raft.MockRaftActorContext.MockReplicatedLogEntry; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import org.junit.After; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.opendaylight.controller.cluster.raft.MockRaftActorContext.MockPayload; +import org.opendaylight.controller.cluster.raft.MockRaftActorContext.MockReplicatedLogEntry; /** * */ @@ -65,7 +63,7 @@ public class AbstractReplicatedLogImplTest { // now create a snapshot of 3 entries, with 1 unapplied entry left in the log // It removes the entries which have made it to snapshot // and updates the snapshot index and term - Map state = takeSnapshot(3); + Map state = takeSnapshot(3); // check the values after the snapshot. // each index value passed in the test is the logical index (log entry index) @@ -131,8 +129,8 @@ public class AbstractReplicatedLogImplTest { } // create a snapshot for test - public Map takeSnapshot(int numEntries) { - Map map = new HashMap(numEntries); + public Map takeSnapshot(final int numEntries) { + Map map = new HashMap<>(numEntries); List entries = replicatedLogImpl.getEntriesTill(numEntries); for (ReplicatedLogEntry entry : entries) { map.put(entry.getIndex(), entry.getData().toString()); @@ -149,22 +147,24 @@ public class AbstractReplicatedLogImplTest { } class MockAbstractReplicatedLogImpl extends AbstractReplicatedLogImpl { @Override - public void appendAndPersist(ReplicatedLogEntry replicatedLogEntry) { + public void appendAndPersist(final ReplicatedLogEntry replicatedLogEntry) { } @Override - public void removeFromAndPersist(long index) { + public void removeFromAndPersist(final long index) { } - public void setSnapshotIndex(long snapshotIndex) { + @Override + public void setSnapshotIndex(final long snapshotIndex) { this.snapshotIndex = snapshotIndex; } - public void setSnapshotTerm(long snapshotTerm) { + @Override + public void setSnapshotTerm(final long snapshotTerm) { this.snapshotTerm = snapshotTerm; } - public List getEntriesTill(int index) { + public List getEntriesTill(final int index) { return journal.subList(0, index); } } diff --git a/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/FollowerLogInformationImplTest.java b/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/FollowerLogInformationImplTest.java new file mode 100644 index 0000000000..7df9f3713f --- /dev/null +++ b/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/FollowerLogInformationImplTest.java @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2014 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.cluster.raft; + + +import com.google.common.base.Stopwatch; +import com.google.common.util.concurrent.Uninterruptibles; +import org.junit.Test; +import scala.concurrent.duration.FiniteDuration; + +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicLong; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +public class FollowerLogInformationImplTest { + + @Test + public void testIsFollowerActive() { + + FiniteDuration timeoutDuration = + new FiniteDuration(500, TimeUnit.MILLISECONDS); + + FollowerLogInformation followerLogInformation = + new FollowerLogInformationImpl( + "follower1", new AtomicLong(10), new AtomicLong(9), timeoutDuration); + + + + assertFalse("Follower should be termed inactive before stopwatch starts", + followerLogInformation.isFollowerActive()); + + followerLogInformation.markFollowerActive(); + if (sleepWithElaspsedTimeReturned(200) > 200) { + return; + } + assertTrue("Follower should be active", followerLogInformation.isFollowerActive()); + + if (sleepWithElaspsedTimeReturned(400) > 400) { + return; + } + assertFalse("Follower should be inactive after time lapsed", + followerLogInformation.isFollowerActive()); + + followerLogInformation.markFollowerActive(); + assertTrue("Follower should be active from inactive", + followerLogInformation.isFollowerActive()); + } + + // we cannot rely comfortably that the sleep will indeed sleep for the desired time + // hence getting the actual elapsed time and do a match. + // if the sleep has spilled over, then return the test gracefully + private long sleepWithElaspsedTimeReturned(long millis) { + Stopwatch stopwatch = new Stopwatch(); + stopwatch.start(); + Uninterruptibles.sleepUninterruptibly(millis, TimeUnit.MILLISECONDS); + stopwatch.stop(); + return stopwatch.elapsed(TimeUnit.MILLISECONDS); + } +} diff --git a/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/RaftActorTest.java b/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/RaftActorTest.java index ca864eb426..87e40f236c 100644 --- a/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/RaftActorTest.java +++ b/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/RaftActorTest.java @@ -31,6 +31,8 @@ import org.opendaylight.controller.cluster.raft.base.messages.ApplySnapshot; import org.opendaylight.controller.cluster.raft.base.messages.ApplyState; import org.opendaylight.controller.cluster.raft.base.messages.CaptureSnapshot; import org.opendaylight.controller.cluster.raft.base.messages.CaptureSnapshotReply; +import org.opendaylight.controller.cluster.raft.behaviors.Follower; +import org.opendaylight.controller.cluster.raft.behaviors.Leader; import org.opendaylight.controller.cluster.raft.client.messages.FindLeader; import org.opendaylight.controller.cluster.raft.client.messages.FindLeaderReply; import org.opendaylight.controller.cluster.raft.protobuff.client.messages.Payload; @@ -557,7 +559,6 @@ public class RaftActorTest extends AbstractActorTest { config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); - DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); TestActorRef mockActorRef = TestActorRef.create(getSystem(), MockRaftActor.props(persistenceId, @@ -600,7 +601,6 @@ public class RaftActorTest extends AbstractActorTest { verify(dataPersistenceProvider, times(2)).persist(anyObject(), any(Procedure.class)); - mockActorRef.tell(PoisonPill.getInstance(), getRef()); } @@ -646,8 +646,9 @@ public class RaftActorTest extends AbstractActorTest { DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); - TestActorRef mockActorRef = TestActorRef.create(getSystem(), MockRaftActor.props(persistenceId, - Collections.EMPTY_MAP, Optional.of(config), dataPersistenceProvider), persistenceId); + TestActorRef mockActorRef = TestActorRef.create(getSystem(), + MockRaftActor.props(persistenceId,Collections.EMPTY_MAP, + Optional.of(config), dataPersistenceProvider), persistenceId); MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); @@ -659,6 +660,10 @@ public class RaftActorTest extends AbstractActorTest { mockRaftActor.onReceiveCommand(new CaptureSnapshot(-1,1,-1,1)); + RaftActorContext raftActorContext = mockRaftActor.getRaftActorContext(); + + mockRaftActor.setCurrentBehavior(new Leader(raftActorContext)); + mockRaftActor.onReceiveCommand(new CaptureSnapshotReply(snapshotBytes)); verify(dataPersistenceProvider).saveSnapshot(anyObject()); @@ -698,6 +703,9 @@ public class RaftActorTest extends AbstractActorTest { new MockRaftActorContext.MockPayload("C"), new MockRaftActorContext.MockPayload("D"))); + RaftActorContext raftActorContext = mockRaftActor.getRaftActorContext(); + mockRaftActor.setCurrentBehavior(new Follower(raftActorContext)); + mockRaftActor.onReceiveCommand(new CaptureSnapshot(-1, 1, 2, 1)); verify(mockRaftActor.delegate).createSnapshot(); @@ -710,8 +718,6 @@ public class RaftActorTest extends AbstractActorTest { verify(dataPersistenceProvider).deleteMessages(100); - assertNotNull("Snapshot should not be null", mockRaftActor.getReplicatedLog().getSnapshot()); - assertEquals(2, mockRaftActor.getReplicatedLog().size()); assertNotNull(mockRaftActor.getReplicatedLog().get(3)); @@ -755,8 +761,6 @@ public class RaftActorTest extends AbstractActorTest { } }; - - } @Test @@ -780,13 +784,15 @@ public class RaftActorTest extends AbstractActorTest { oldReplicatedLog.append(new MockRaftActorContext.MockReplicatedLogEntry(1,0,mock(Payload.class))); oldReplicatedLog.append(new MockRaftActorContext.MockReplicatedLogEntry(1,1,mock(Payload.class))); - oldReplicatedLog.append(new MockRaftActorContext.MockReplicatedLogEntry(1,2,mock(Payload.class))); + oldReplicatedLog.append( + new MockRaftActorContext.MockReplicatedLogEntry(1, 2, + mock(Payload.class))); ByteString snapshotBytes = fromObject(Arrays.asList( - new MockRaftActorContext.MockPayload("A"), - new MockRaftActorContext.MockPayload("B"), - new MockRaftActorContext.MockPayload("C"), - new MockRaftActorContext.MockPayload("D"))); + new MockRaftActorContext.MockPayload("A"), + new MockRaftActorContext.MockPayload("B"), + new MockRaftActorContext.MockPayload("C"), + new MockRaftActorContext.MockPayload("D"))); Snapshot snapshot = mock(Snapshot.class); @@ -798,9 +804,11 @@ public class RaftActorTest extends AbstractActorTest { verify(mockRaftActor.delegate).applySnapshot(eq(snapshotBytes)); - assertTrue("The replicatedLog should have changed", oldReplicatedLog != mockRaftActor.getReplicatedLog()); + assertTrue("The replicatedLog should have changed", + oldReplicatedLog != mockRaftActor.getReplicatedLog()); - assertEquals("lastApplied should be same as in the snapshot", (Long) 3L, mockRaftActor.getLastApplied()); + assertEquals("lastApplied should be same as in the snapshot", + (Long) 3L, mockRaftActor.getLastApplied()); assertEquals(0, mockRaftActor.getReplicatedLog().size()); @@ -833,6 +841,10 @@ public class RaftActorTest extends AbstractActorTest { new MockRaftActorContext.MockPayload("C"), new MockRaftActorContext.MockPayload("D"))); + RaftActorContext raftActorContext = mockRaftActor.getRaftActorContext(); + + mockRaftActor.setCurrentBehavior(new Leader(raftActorContext)); + mockRaftActor.onReceiveCommand(new CaptureSnapshot(-1,1,-1,1)); mockRaftActor.onReceiveCommand(new CaptureSnapshotReply(snapshotBytes)); @@ -843,8 +855,6 @@ public class RaftActorTest extends AbstractActorTest { assertEquals("Snapshot index should not have advanced because save snapshot failed", -1, mockRaftActor.getReplicatedLog().getSnapshotIndex()); - assertNull("Snapshot should be null", mockRaftActor.getReplicatedLog().getSnapshot()); - mockActorRef.tell(PoisonPill.getInstance(), getRef()); } diff --git a/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/behaviors/CandidateTest.java b/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/behaviors/CandidateTest.java index a8d47e2c60..fb02481115 100644 --- a/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/behaviors/CandidateTest.java +++ b/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/behaviors/CandidateTest.java @@ -3,7 +3,7 @@ package org.opendaylight.controller.cluster.raft.behaviors; import akka.actor.ActorRef; import akka.actor.Props; import akka.testkit.JavaTestKit; -import junit.framework.Assert; +import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.opendaylight.controller.cluster.raft.DefaultConfigParamsImpl; diff --git a/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/behaviors/FollowerTest.java b/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/behaviors/FollowerTest.java index edeab11e2a..83b9ad3ec7 100644 --- a/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/behaviors/FollowerTest.java +++ b/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/behaviors/FollowerTest.java @@ -4,7 +4,6 @@ import akka.actor.ActorRef; import akka.actor.Props; import akka.testkit.JavaTestKit; import com.google.protobuf.ByteString; -import junit.framework.Assert; import org.junit.Test; import org.opendaylight.controller.cluster.raft.DefaultConfigParamsImpl; import org.opendaylight.controller.cluster.raft.MockRaftActorContext; @@ -87,7 +86,7 @@ public class FollowerTest extends AbstractRaftActorBehaviorTest { RaftActorBehavior raftBehavior = follower.handleMessage(followerActor, new ElectionTimeout()); - Assert.assertTrue(raftBehavior instanceof Candidate); + assertTrue(raftBehavior instanceof Candidate); } @Test diff --git a/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/behaviors/LeaderTest.java b/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/behaviors/LeaderTest.java index 030b4b2376..705c69607c 100644 --- a/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/behaviors/LeaderTest.java +++ b/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/behaviors/LeaderTest.java @@ -1,15 +1,14 @@ package org.opendaylight.controller.cluster.raft.behaviors; import akka.actor.ActorRef; -import akka.actor.ActorSystem; import akka.actor.Props; import akka.testkit.JavaTestKit; +import com.google.common.base.Optional; import com.google.protobuf.ByteString; import org.junit.Assert; import org.junit.Test; import org.opendaylight.controller.cluster.raft.DefaultConfigParamsImpl; import org.opendaylight.controller.cluster.raft.FollowerLogInformation; -import org.opendaylight.controller.cluster.raft.FollowerLogInformationImpl; import org.opendaylight.controller.cluster.raft.MockRaftActorContext; import org.opendaylight.controller.cluster.raft.RaftActorContext; import org.opendaylight.controller.cluster.raft.RaftState; @@ -17,6 +16,8 @@ import org.opendaylight.controller.cluster.raft.ReplicatedLogImplEntry; import org.opendaylight.controller.cluster.raft.SerializationUtils; import org.opendaylight.controller.cluster.raft.base.messages.ApplyLogEntries; import org.opendaylight.controller.cluster.raft.base.messages.ApplyState; +import org.opendaylight.controller.cluster.raft.base.messages.CaptureSnapshot; +import org.opendaylight.controller.cluster.raft.base.messages.InitiateInstallSnapshot; import org.opendaylight.controller.cluster.raft.base.messages.Replicate; import org.opendaylight.controller.cluster.raft.base.messages.SendHeartBeat; import org.opendaylight.controller.cluster.raft.base.messages.SendInstallSnapshot; @@ -29,6 +30,7 @@ import org.opendaylight.controller.cluster.raft.utils.DoNothingActor; import org.opendaylight.controller.cluster.raft.utils.MessageCollectorActor; import org.opendaylight.controller.protobuff.messages.cluster.raft.AppendEntriesMessages; import org.opendaylight.controller.protobuff.messages.cluster.raft.InstallSnapshotMessages; +import scala.concurrent.duration.FiniteDuration; import java.io.ByteArrayOutputStream; import java.io.IOException; @@ -36,7 +38,7 @@ import java.io.ObjectOutputStream; import java.util.HashMap; import java.util.List; import java.util.Map; -import java.util.concurrent.atomic.AtomicLong; +import java.util.concurrent.TimeUnit; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; @@ -72,8 +74,7 @@ public class LeaderTest extends AbstractRaftActorBehaviorTest { ActorRef followerActor = getTestActor(); - MockRaftActorContext actorContext = - (MockRaftActorContext) createActorContext(); + MockRaftActorContext actorContext = (MockRaftActorContext) createActorContext(); Map peerAddresses = new HashMap(); @@ -155,10 +156,7 @@ public class LeaderTest extends AbstractRaftActorBehaviorTest { }.get(); // this extracts the received message assertEquals("match", out); - } - - }; }}; } @@ -214,229 +212,360 @@ public class LeaderTest extends AbstractRaftActorBehaviorTest { } @Test - public void testSendInstallSnapshot() { - new LeaderTestKit(getSystem()) {{ + public void testSendAppendEntriesOnAnInProgressInstallSnapshot() throws Exception { + new JavaTestKit(getSystem()) {{ + ActorRef followerActor = getSystem().actorOf(Props.create(MessageCollectorActor.class)); - new Within(duration("1 seconds")) { - protected void run() { - ActorRef followerActor = getTestActor(); + Map peerAddresses = new HashMap(); + peerAddresses.put(followerActor.path().toString(), + followerActor.path().toString()); - Map peerAddresses = new HashMap(); - peerAddresses.put(followerActor.path().toString(), - followerActor.path().toString()); + MockRaftActorContext actorContext = + (MockRaftActorContext) createActorContext(leaderActor); + actorContext.setPeerAddresses(peerAddresses); + Map leadersSnapshot = new HashMap<>(); + leadersSnapshot.put("1", "A"); + leadersSnapshot.put("2", "B"); + leadersSnapshot.put("3", "C"); - MockRaftActorContext actorContext = - (MockRaftActorContext) createActorContext(getRef()); - actorContext.setPeerAddresses(peerAddresses); + //clears leaders log + actorContext.getReplicatedLog().removeFrom(0); + final int followersLastIndex = 2; + final int snapshotIndex = 3; + final int newEntryIndex = 4; + final int snapshotTerm = 1; + final int currentTerm = 2; - Map leadersSnapshot = new HashMap<>(); - leadersSnapshot.put("1", "A"); - leadersSnapshot.put("2", "B"); - leadersSnapshot.put("3", "C"); + // set the snapshot variables in replicatedlog + actorContext.getReplicatedLog().setSnapshotIndex(snapshotIndex); + actorContext.getReplicatedLog().setSnapshotTerm(snapshotTerm); + actorContext.setCommitIndex(followersLastIndex); + //set follower timeout to 2 mins, helps during debugging + actorContext.setConfigParams(new MockConfigParamsImpl(120000L, 10)); - //clears leaders log - actorContext.getReplicatedLog().removeFrom(0); + MockLeader leader = new MockLeader(actorContext); - final int followersLastIndex = 2; - final int snapshotIndex = 3; - final int newEntryIndex = 4; - final int snapshotTerm = 1; - final int currentTerm = 2; + // new entry + ReplicatedLogImplEntry entry = + new ReplicatedLogImplEntry(newEntryIndex, currentTerm, + new MockRaftActorContext.MockPayload("D")); - // set the snapshot variables in replicatedlog - actorContext.getReplicatedLog().setSnapshot( - toByteString(leadersSnapshot)); - actorContext.getReplicatedLog().setSnapshotIndex(snapshotIndex); - actorContext.getReplicatedLog().setSnapshotTerm(snapshotTerm); + //update follower timestamp + leader.markFollowerActive(followerActor.path().toString()); - MockLeader leader = new MockLeader(actorContext); - // set the follower info in leader - leader.addToFollowerToLog(followerActor.path().toString(), followersLastIndex, -1); + ByteString bs = toByteString(leadersSnapshot); + leader.setSnapshot(Optional.of(bs)); + leader.createFollowerToSnapshot(followerActor.path().toString(), bs); - // new entry - ReplicatedLogImplEntry entry = - new ReplicatedLogImplEntry(newEntryIndex, currentTerm, - new MockRaftActorContext.MockPayload("D")); + //send first chunk and no InstallSnapshotReply received yet + leader.getFollowerToSnapshot().getNextChunk(); + leader.getFollowerToSnapshot().incrementChunkIndex(); - // this should invoke a sendinstallsnapshot as followersLastIndex < snapshotIndex - RaftActorBehavior raftBehavior = leader.handleMessage( - senderActor, new Replicate(null, "state-id", entry)); + leader.handleMessage(leaderActor, new SendHeartBeat()); - assertTrue(raftBehavior instanceof Leader); + AppendEntriesMessages.AppendEntries aeproto = (AppendEntriesMessages.AppendEntries)MessageCollectorActor.getFirstMatching( + followerActor, AppendEntries.SERIALIZABLE_CLASS); - // we might receive some heartbeat messages, so wait till we SendInstallSnapshot - Boolean[] matches = new ReceiveWhile(Boolean.class, duration("2 seconds")) { - @Override - protected Boolean match(Object o) throws Exception { - if (o instanceof SendInstallSnapshot) { - return true; - } - return false; - } - }.get(); + assertNotNull("AppendEntries should be sent even if InstallSnapshotReply is not " + + "received", aeproto); - boolean sendInstallSnapshotReceived = false; - for (Boolean b: matches) { - sendInstallSnapshotReceived = b | sendInstallSnapshotReceived; - } + AppendEntries ae = (AppendEntries) SerializationUtils.fromSerializable(aeproto); + + assertTrue("AppendEntries should be sent with empty entries", ae.getEntries().isEmpty()); + + //InstallSnapshotReply received + leader.getFollowerToSnapshot().markSendStatus(true); + + leader.handleMessage(senderActor, new SendHeartBeat()); + + InstallSnapshotMessages.InstallSnapshot isproto = (InstallSnapshotMessages.InstallSnapshot) + MessageCollectorActor.getFirstMatching(followerActor, + InstallSnapshot.SERIALIZABLE_CLASS); + + assertNotNull("Installsnapshot should get called for sending the next chunk of snapshot", + isproto); + + InstallSnapshot is = (InstallSnapshot) SerializationUtils.fromSerializable(isproto); - assertTrue(sendInstallSnapshotReceived); + assertEquals(snapshotIndex, is.getLastIncludedIndex()); + }}; + } + + @Test + public void testSendAppendEntriesSnapshotScenario() { + new JavaTestKit(getSystem()) {{ + + ActorRef followerActor = getTestActor(); + + Map peerAddresses = new HashMap(); + peerAddresses.put(followerActor.path().toString(), + followerActor.path().toString()); + + MockRaftActorContext actorContext = + (MockRaftActorContext) createActorContext(getRef()); + actorContext.setPeerAddresses(peerAddresses); + + Map leadersSnapshot = new HashMap<>(); + leadersSnapshot.put("1", "A"); + leadersSnapshot.put("2", "B"); + leadersSnapshot.put("3", "C"); + + //clears leaders log + actorContext.getReplicatedLog().removeFrom(0); + + final int followersLastIndex = 2; + final int snapshotIndex = 3; + final int newEntryIndex = 4; + final int snapshotTerm = 1; + final int currentTerm = 2; + + // set the snapshot variables in replicatedlog + actorContext.getReplicatedLog().setSnapshotIndex(snapshotIndex); + actorContext.getReplicatedLog().setSnapshotTerm(snapshotTerm); + actorContext.setCommitIndex(followersLastIndex); + + Leader leader = new Leader(actorContext); + + // new entry + ReplicatedLogImplEntry entry = + new ReplicatedLogImplEntry(newEntryIndex, currentTerm, + new MockRaftActorContext.MockPayload("D")); + + //update follower timestamp + leader.markFollowerActive(followerActor.path().toString()); + + // this should invoke a sendinstallsnapshot as followersLastIndex < snapshotIndex + RaftActorBehavior raftBehavior = leader.handleMessage( + senderActor, new Replicate(null, "state-id", entry)); + + assertTrue(raftBehavior instanceof Leader); + + // we might receive some heartbeat messages, so wait till we InitiateInstallSnapshot + Boolean[] matches = new ReceiveWhile(Boolean.class, duration("2 seconds")) { + @Override + protected Boolean match(Object o) throws Exception { + if (o instanceof InitiateInstallSnapshot) { + return true; + } + return false; } - }; + }.get(); + + boolean initiateInitiateInstallSnapshot = false; + for (Boolean b: matches) { + initiateInitiateInstallSnapshot = b | initiateInitiateInstallSnapshot; + } + + assertTrue(initiateInitiateInstallSnapshot); }}; } @Test - public void testInstallSnapshot() { - new LeaderTestKit(getSystem()) {{ + public void testInitiateInstallSnapshot() throws Exception { + new JavaTestKit(getSystem()) {{ - new Within(duration("1 seconds")) { - protected void run() { - ActorRef followerActor = getTestActor(); + ActorRef leaderActor = getSystem().actorOf(Props.create(MessageCollectorActor.class)); - Map peerAddresses = new HashMap(); - peerAddresses.put(followerActor.path().toString(), - followerActor.path().toString()); + ActorRef followerActor = getTestActor(); - MockRaftActorContext actorContext = - (MockRaftActorContext) createActorContext(); - actorContext.setPeerAddresses(peerAddresses); + Map peerAddresses = new HashMap(); + peerAddresses.put(followerActor.path().toString(), + followerActor.path().toString()); - Map leadersSnapshot = new HashMap<>(); - leadersSnapshot.put("1", "A"); - leadersSnapshot.put("2", "B"); - leadersSnapshot.put("3", "C"); + MockRaftActorContext actorContext = + (MockRaftActorContext) createActorContext(leaderActor); + actorContext.setPeerAddresses(peerAddresses); - //clears leaders log - actorContext.getReplicatedLog().removeFrom(0); + Map leadersSnapshot = new HashMap<>(); + leadersSnapshot.put("1", "A"); + leadersSnapshot.put("2", "B"); + leadersSnapshot.put("3", "C"); - final int followersLastIndex = 2; - final int snapshotIndex = 3; - final int newEntryIndex = 4; - final int snapshotTerm = 1; - final int currentTerm = 2; + //clears leaders log + actorContext.getReplicatedLog().removeFrom(0); - // set the snapshot variables in replicatedlog - actorContext.getReplicatedLog().setSnapshot(toByteString(leadersSnapshot)); - actorContext.getReplicatedLog().setSnapshotIndex(snapshotIndex); - actorContext.getReplicatedLog().setSnapshotTerm(snapshotTerm); + final int followersLastIndex = 2; + final int snapshotIndex = 3; + final int newEntryIndex = 4; + final int snapshotTerm = 1; + final int currentTerm = 2; - actorContext.getTermInformation().update(currentTerm, leaderActor.path().toString()); + // set the snapshot variables in replicatedlog + actorContext.getReplicatedLog().setSnapshotIndex(snapshotIndex); + actorContext.getReplicatedLog().setSnapshotTerm(snapshotTerm); + actorContext.setLastApplied(3); + actorContext.setCommitIndex(followersLastIndex); - MockLeader leader = new MockLeader(actorContext); - // set the follower info in leader - leader.addToFollowerToLog(followerActor.path().toString(), followersLastIndex, -1); + Leader leader = new Leader(actorContext); + // set the snapshot as absent and check if capture-snapshot is invoked. + leader.setSnapshot(Optional.absent()); - // new entry - ReplicatedLogImplEntry entry = - new ReplicatedLogImplEntry(newEntryIndex, currentTerm, - new MockRaftActorContext.MockPayload("D")); + // new entry + ReplicatedLogImplEntry entry = + new ReplicatedLogImplEntry(newEntryIndex, currentTerm, + new MockRaftActorContext.MockPayload("D")); - RaftActorBehavior raftBehavior = leader.handleMessage(senderActor, new SendInstallSnapshot()); + actorContext.getReplicatedLog().append(entry); - assertTrue(raftBehavior instanceof Leader); + // this should invoke a sendinstallsnapshot as followersLastIndex < snapshotIndex + RaftActorBehavior raftBehavior = leader.handleMessage( + leaderActor, new InitiateInstallSnapshot()); - // check if installsnapshot gets called with the correct values. - final String out = - new ExpectMsg(duration("1 seconds"), "match hint") { - // do not put code outside this method, will run afterwards - protected String match(Object in) { - if (in instanceof InstallSnapshotMessages.InstallSnapshot) { - InstallSnapshot is = (InstallSnapshot) - SerializationUtils.fromSerializable(in); - if (is.getData() == null) { - return "InstallSnapshot data is null"; - } - if (is.getLastIncludedIndex() != snapshotIndex) { - return is.getLastIncludedIndex() + "!=" + snapshotIndex; - } - if (is.getLastIncludedTerm() != snapshotTerm) { - return is.getLastIncludedTerm() + "!=" + snapshotTerm; - } - if (is.getTerm() == currentTerm) { - return is.getTerm() + "!=" + currentTerm; - } + CaptureSnapshot cs = (CaptureSnapshot) MessageCollectorActor. + getFirstMatching(leaderActor, CaptureSnapshot.class); - return "match"; + assertNotNull(cs); - } else { - return "message mismatch:" + in.getClass(); - } + assertTrue(cs.isInstallSnapshotInitiated()); + assertEquals(3, cs.getLastAppliedIndex()); + assertEquals(1, cs.getLastAppliedTerm()); + assertEquals(4, cs.getLastIndex()); + assertEquals(2, cs.getLastTerm()); + }}; + } + + @Test + public void testInstallSnapshot() { + new JavaTestKit(getSystem()) {{ + + ActorRef followerActor = getTestActor(); + + Map peerAddresses = new HashMap(); + peerAddresses.put(followerActor.path().toString(), + followerActor.path().toString()); + + MockRaftActorContext actorContext = + (MockRaftActorContext) createActorContext(); + actorContext.setPeerAddresses(peerAddresses); + + + Map leadersSnapshot = new HashMap<>(); + leadersSnapshot.put("1", "A"); + leadersSnapshot.put("2", "B"); + leadersSnapshot.put("3", "C"); + + //clears leaders log + actorContext.getReplicatedLog().removeFrom(0); + + final int followersLastIndex = 2; + final int snapshotIndex = 3; + final int newEntryIndex = 4; + final int snapshotTerm = 1; + final int currentTerm = 2; + + // set the snapshot variables in replicatedlog + actorContext.getReplicatedLog().setSnapshotIndex(snapshotIndex); + actorContext.getReplicatedLog().setSnapshotTerm(snapshotTerm); + actorContext.getTermInformation().update(currentTerm, leaderActor.path().toString()); + actorContext.setCommitIndex(followersLastIndex); + + Leader leader = new Leader(actorContext); + + // new entry + ReplicatedLogImplEntry entry = + new ReplicatedLogImplEntry(newEntryIndex, currentTerm, + new MockRaftActorContext.MockPayload("D")); + + RaftActorBehavior raftBehavior = leader.handleMessage(senderActor, + new SendInstallSnapshot(toByteString(leadersSnapshot))); + + assertTrue(raftBehavior instanceof Leader); + + // check if installsnapshot gets called with the correct values. + final String out = + new ExpectMsg(duration("1 seconds"), "match hint") { + // do not put code outside this method, will run afterwards + protected String match(Object in) { + if (in instanceof InstallSnapshotMessages.InstallSnapshot) { + InstallSnapshot is = (InstallSnapshot) + SerializationUtils.fromSerializable(in); + if (is.getData() == null) { + return "InstallSnapshot data is null"; + } + if (is.getLastIncludedIndex() != snapshotIndex) { + return is.getLastIncludedIndex() + "!=" + snapshotIndex; + } + if (is.getLastIncludedTerm() != snapshotTerm) { + return is.getLastIncludedTerm() + "!=" + snapshotTerm; + } + if (is.getTerm() == currentTerm) { + return is.getTerm() + "!=" + currentTerm; } - }.get(); // this extracts the received message - assertEquals("match", out); - } - }; + return "match"; + + } else { + return "message mismatch:" + in.getClass(); + } + } + }.get(); // this extracts the received message + + assertEquals("match", out); }}; } @Test public void testHandleInstallSnapshotReplyLastChunk() { - new LeaderTestKit(getSystem()) {{ - new Within(duration("1 seconds")) { - protected void run() { - ActorRef followerActor = getTestActor(); + new JavaTestKit(getSystem()) {{ - Map peerAddresses = new HashMap(); - peerAddresses.put(followerActor.path().toString(), - followerActor.path().toString()); + ActorRef followerActor = getTestActor(); - MockRaftActorContext actorContext = - (MockRaftActorContext) createActorContext(); - actorContext.setPeerAddresses(peerAddresses); + Map peerAddresses = new HashMap(); + peerAddresses.put(followerActor.path().toString(), + followerActor.path().toString()); - final int followersLastIndex = 2; - final int snapshotIndex = 3; - final int newEntryIndex = 4; - final int snapshotTerm = 1; - final int currentTerm = 2; - - MockLeader leader = new MockLeader(actorContext); - // set the follower info in leader - leader.addToFollowerToLog(followerActor.path().toString(), followersLastIndex, -1); - - Map leadersSnapshot = new HashMap<>(); - leadersSnapshot.put("1", "A"); - leadersSnapshot.put("2", "B"); - leadersSnapshot.put("3", "C"); - - // set the snapshot variables in replicatedlog - actorContext.getReplicatedLog().setSnapshot( - toByteString(leadersSnapshot)); - actorContext.getReplicatedLog().setSnapshotIndex(snapshotIndex); - actorContext.getReplicatedLog().setSnapshotTerm(snapshotTerm); - actorContext.getTermInformation().update(currentTerm, leaderActor.path().toString()); - - ByteString bs = toByteString(leadersSnapshot); - leader.createFollowerToSnapshot(followerActor.path().toString(), bs); - while(!leader.getFollowerToSnapshot().isLastChunk(leader.getFollowerToSnapshot().getChunkIndex())) { - leader.getFollowerToSnapshot().getNextChunk(); - leader.getFollowerToSnapshot().incrementChunkIndex(); - } + final int followersLastIndex = 2; + final int snapshotIndex = 3; + final int newEntryIndex = 4; + final int snapshotTerm = 1; + final int currentTerm = 2; - //clears leaders log - actorContext.getReplicatedLog().removeFrom(0); + MockRaftActorContext actorContext = + (MockRaftActorContext) createActorContext(); + actorContext.setPeerAddresses(peerAddresses); + actorContext.setCommitIndex(followersLastIndex); - RaftActorBehavior raftBehavior = leader.handleMessage(senderActor, - new InstallSnapshotReply(currentTerm, followerActor.path().toString(), - leader.getFollowerToSnapshot().getChunkIndex(), true)); + MockLeader leader = new MockLeader(actorContext); - assertTrue(raftBehavior instanceof Leader); + Map leadersSnapshot = new HashMap<>(); + leadersSnapshot.put("1", "A"); + leadersSnapshot.put("2", "B"); + leadersSnapshot.put("3", "C"); - assertEquals(leader.mapFollowerToSnapshot.size(), 0); - assertEquals(leader.followerToLog.size(), 1); - assertNotNull(leader.followerToLog.get(followerActor.path().toString())); - FollowerLogInformation fli = leader.followerToLog.get(followerActor.path().toString()); - assertEquals(snapshotIndex, fli.getMatchIndex().get()); - assertEquals(snapshotIndex, fli.getMatchIndex().get()); - assertEquals(snapshotIndex + 1, fli.getNextIndex().get()); - } - }; + // set the snapshot variables in replicatedlog + + actorContext.getReplicatedLog().setSnapshotIndex(snapshotIndex); + actorContext.getReplicatedLog().setSnapshotTerm(snapshotTerm); + actorContext.getTermInformation().update(currentTerm, leaderActor.path().toString()); + + ByteString bs = toByteString(leadersSnapshot); + leader.setSnapshot(Optional.of(bs)); + leader.createFollowerToSnapshot(followerActor.path().toString(), bs); + while(!leader.getFollowerToSnapshot().isLastChunk(leader.getFollowerToSnapshot().getChunkIndex())) { + leader.getFollowerToSnapshot().getNextChunk(); + leader.getFollowerToSnapshot().incrementChunkIndex(); + } + + //clears leaders log + actorContext.getReplicatedLog().removeFrom(0); + + RaftActorBehavior raftBehavior = leader.handleMessage(senderActor, + new InstallSnapshotReply(currentTerm, followerActor.path().toString(), + leader.getFollowerToSnapshot().getChunkIndex(), true)); + + assertTrue(raftBehavior instanceof Leader); + + assertEquals(leader.mapFollowerToSnapshot.size(), 0); + assertEquals(leader.followerToLog.size(), 1); + assertNotNull(leader.followerToLog.get(followerActor.path().toString())); + FollowerLogInformation fli = leader.followerToLog.get(followerActor.path().toString()); + assertEquals(snapshotIndex, fli.getMatchIndex().get()); + assertEquals(snapshotIndex, fli.getMatchIndex().get()); + assertEquals(snapshotIndex + 1, fli.getNextIndex().get()); }}; } @@ -584,6 +713,7 @@ public class LeaderTest extends AbstractRaftActorBehaviorTest { followerActorContext.setCommitIndex(1); Leader leader = new Leader(leaderActorContext); + leader.markFollowerActive(followerActor.path().toString()); leader.handleMessage(leaderActor, new SendHeartBeat()); @@ -652,6 +782,7 @@ public class LeaderTest extends AbstractRaftActorBehaviorTest { followerActorContext.setCommitIndex(2); Leader leader = new Leader(leaderActorContext); + leader.markFollowerActive(followerActor.path().toString()); leader.handleMessage(leaderActor, new SendHeartBeat()); @@ -816,30 +947,6 @@ public class LeaderTest extends AbstractRaftActorBehaviorTest { } - private static class LeaderTestKit extends JavaTestKit { - - private LeaderTestKit(ActorSystem actorSystem) { - super(actorSystem); - } - - protected void waitForLogMessage(final Class logLevel, ActorRef subject, String logMessage){ - // Wait for a specific log message to show up - final boolean result = - new JavaTestKit.EventFilter(logLevel - ) { - @Override - protected Boolean run() { - return true; - } - }.from(subject.path().toString()) - .message(logMessage) - .occurrences(1).exec(); - - Assert.assertEquals(true, result); - - } - } - class MockLeader extends Leader { FollowerToSnapshot fts; @@ -848,14 +955,6 @@ public class LeaderTest extends AbstractRaftActorBehaviorTest { super(context); } - public void addToFollowerToLog(String followerId, long nextIndex, long matchIndex) { - FollowerLogInformation followerLogInformation = - new FollowerLogInformationImpl(followerId, - new AtomicLong(nextIndex), - new AtomicLong(matchIndex)); - followerToLog.put(followerId, followerLogInformation); - } - public FollowerToSnapshot getFollowerToSnapshot() { return fts; } @@ -866,4 +965,26 @@ public class LeaderTest extends AbstractRaftActorBehaviorTest { } } + + private class MockConfigParamsImpl extends DefaultConfigParamsImpl { + + private long electionTimeOutIntervalMillis; + private int snapshotChunkSize; + + public MockConfigParamsImpl(long electionTimeOutIntervalMillis, int snapshotChunkSize) { + super(); + this.electionTimeOutIntervalMillis = electionTimeOutIntervalMillis; + this.snapshotChunkSize = snapshotChunkSize; + } + + @Override + public FiniteDuration getElectionTimeOutInterval() { + return new FiniteDuration(electionTimeOutIntervalMillis, TimeUnit.MILLISECONDS); + } + + @Override + public int getSnapshotChunkSize() { + return snapshotChunkSize; + } + } } diff --git a/opendaylight/md-sal/sal-akka-raft/src/test/resources/application.conf b/opendaylight/md-sal/sal-akka-raft/src/test/resources/application.conf index 8a45108f8b..818ddf7d85 100644 --- a/opendaylight/md-sal/sal-akka-raft/src/test/resources/application.conf +++ b/opendaylight/md-sal/sal-akka-raft/src/test/resources/application.conf @@ -7,7 +7,7 @@ akka { actor { # enable to test serialization only. - serialize-messages = on + serialize-messages = off serializers { java = "akka.serialization.JavaSerializer" diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/AbstractRuntimeCodeGenerator.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/AbstractRuntimeCodeGenerator.java index 1fa54be200..eba5b8756b 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/AbstractRuntimeCodeGenerator.java +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/AbstractRuntimeCodeGenerator.java @@ -8,17 +8,11 @@ package org.opendaylight.controller.sal.binding.codegen.impl; import com.google.common.base.Supplier; - -import java.util.Map; -import java.util.WeakHashMap; - +import com.google.common.collect.Iterables; import javassist.ClassPool; import javassist.CtClass; import javassist.CtMethod; import javassist.NotFoundException; - -import javax.annotation.concurrent.GuardedBy; - import org.eclipse.xtext.xbase.lib.Extension; import org.opendaylight.controller.sal.binding.api.rpc.RpcRouter; import org.opendaylight.controller.sal.binding.codegen.RpcIsNotRoutedException; @@ -31,6 +25,10 @@ import org.opendaylight.yangtools.yang.binding.RpcService; import org.opendaylight.yangtools.yang.binding.annotations.RoutingContext; import org.opendaylight.yangtools.yang.binding.util.ClassLoaderUtils; +import javax.annotation.concurrent.GuardedBy; +import java.util.Map; +import java.util.WeakHashMap; + abstract class AbstractRuntimeCodeGenerator implements org.opendaylight.controller.sal.binding.codegen.RuntimeCodeGenerator, NotificationInvokerFactory { @GuardedBy("this") private final Map, RuntimeGeneratedInvokerPrototype> invokerClasses = new WeakHashMap<>(); @@ -174,6 +172,10 @@ abstract class AbstractRuntimeCodeGenerator implements org.opendaylight.controll } }); + if (Iterables.isEmpty(metadata.getContexts())) { + throw new RpcIsNotRoutedException("Service doesn't have routing context associated."); + } + synchronized (utils) { final T instance = ClassLoaderUtils.withClassLoader(serviceType.getClassLoader(), routerSupplier(serviceType, metadata)); return new RpcRouterCodegenInstance(name, serviceType, instance, metadata.getContexts()); diff --git a/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/sal/binding/test/AugmentationVerifier.java b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/sal/binding/test/AugmentationVerifier.java index 227354c41e..c8129e6eca 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/sal/binding/test/AugmentationVerifier.java +++ b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/sal/binding/test/AugmentationVerifier.java @@ -7,9 +7,7 @@ */ package org.opendaylight.controller.sal.binding.test; -import junit.framework.Assert; - - +import static org.junit.Assert.assertNotNull; import org.opendaylight.yangtools.yang.binding.Augmentable; import org.opendaylight.yangtools.yang.binding.Augmentation; @@ -28,8 +26,8 @@ public class AugmentationVerifier> { public static > void assertHasAugmentation(T object, Class> augmentation) { - Assert.assertNotNull(object); - Assert.assertNotNull("Augmentation " + augmentation.getSimpleName() + " is not present.", object.getAugmentation(augmentation)); + assertNotNull(object); + assertNotNull("Augmentation " + augmentation.getSimpleName() + " is not present.", object.getAugmentation(augmentation)); } public static > AugmentationVerifier from(T obj) { diff --git a/opendaylight/md-sal/sal-binding-dom-it/src/test/java/org/opendaylight/controller/sal/binding/test/connect/dom/CrossBrokerRpcTest.java b/opendaylight/md-sal/sal-binding-dom-it/src/test/java/org/opendaylight/controller/sal/binding/test/connect/dom/CrossBrokerRpcTest.java index 4cc3780c6f..ba75d578fb 100644 --- a/opendaylight/md-sal/sal-binding-dom-it/src/test/java/org/opendaylight/controller/sal/binding/test/connect/dom/CrossBrokerRpcTest.java +++ b/opendaylight/md-sal/sal-binding-dom-it/src/test/java/org/opendaylight/controller/sal/binding/test/connect/dom/CrossBrokerRpcTest.java @@ -7,10 +7,10 @@ */ package org.opendaylight.controller.sal.binding.test.connect.dom; -import static junit.framework.Assert.assertEquals; -import static junit.framework.Assert.assertNotNull; -import static junit.framework.Assert.assertNotSame; -import static junit.framework.Assert.assertTrue; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNotSame; +import static org.junit.Assert.assertTrue; import java.math.BigInteger; import java.util.Collections; diff --git a/opendaylight/md-sal/sal-binding-dom-it/src/test/java/org/opendaylight/controller/sal/binding/test/connect/dom/DOMRpcServiceTestBugfix560.java b/opendaylight/md-sal/sal-binding-dom-it/src/test/java/org/opendaylight/controller/sal/binding/test/connect/dom/DOMRpcServiceTestBugfix560.java index 6686a83a2e..7d616ca62c 100644 --- a/opendaylight/md-sal/sal-binding-dom-it/src/test/java/org/opendaylight/controller/sal/binding/test/connect/dom/DOMRpcServiceTestBugfix560.java +++ b/opendaylight/md-sal/sal-binding-dom-it/src/test/java/org/opendaylight/controller/sal/binding/test/connect/dom/DOMRpcServiceTestBugfix560.java @@ -7,9 +7,9 @@ */ package org.opendaylight.controller.sal.binding.test.connect.dom; -import static junit.framework.Assert.assertNotNull; -import static junit.framework.Assert.assertTrue; -import static junit.framework.Assert.fail; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; import java.io.InputStream; import java.util.Collections; diff --git a/opendaylight/md-sal/sal-binding-dom-it/src/test/java/org/opendaylight/controller/sal/binding/test/connect/dom/MessageCapturingFlowService.java b/opendaylight/md-sal/sal-binding-dom-it/src/test/java/org/opendaylight/controller/sal/binding/test/connect/dom/MessageCapturingFlowService.java index df287791ef..47e79650fe 100644 --- a/opendaylight/md-sal/sal-binding-dom-it/src/test/java/org/opendaylight/controller/sal/binding/test/connect/dom/MessageCapturingFlowService.java +++ b/opendaylight/md-sal/sal-binding-dom-it/src/test/java/org/opendaylight/controller/sal/binding/test/connect/dom/MessageCapturingFlowService.java @@ -7,7 +7,7 @@ */ package org.opendaylight.controller.sal.binding.test.connect.dom; -import static junit.framework.Assert.assertNotNull; +import static org.junit.Assert.assertNotNull; import java.util.concurrent.Future; diff --git a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/NormalizedNodeToNodeCodecTest.java b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/NormalizedNodeToNodeCodecTest.java index 6de1083cbe..5d5318f19a 100644 --- a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/NormalizedNodeToNodeCodecTest.java +++ b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/NormalizedNodeToNodeCodecTest.java @@ -26,8 +26,8 @@ import org.opendaylight.yangtools.yang.model.api.SchemaContext; import java.util.List; -import static junit.framework.Assert.assertEquals; -import static junit.framework.Assert.assertNotNull; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; public class NormalizedNodeToNodeCodecTest { diff --git a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/NodeIdentifierFactoryTest.java b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/NodeIdentifierFactoryTest.java index 4da7d8c483..13dfff3a8a 100644 --- a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/NodeIdentifierFactoryTest.java +++ b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/NodeIdentifierFactoryTest.java @@ -10,7 +10,7 @@ package org.opendaylight.controller.cluster.datastore.node.utils; -import junit.framework.Assert; +import static org.junit.Assert.assertTrue; import org.junit.Test; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; @@ -22,8 +22,7 @@ public class NodeIdentifierFactoryTest { NodeIdentifierFactory .getArgument("AugmentationIdentifier{childNames=[(urn:opendaylight:flow:table:statistics?revision=2013-12-15)flow-table-statistics]}"); - Assert - .assertTrue(argument instanceof YangInstanceIdentifier.AugmentationIdentifier); + assertTrue(argument instanceof YangInstanceIdentifier.AugmentationIdentifier); } diff --git a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/QNameFactoryTest.java b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/QNameFactoryTest.java index 76d4ceb2f5..2ae83bd6c6 100644 --- a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/QNameFactoryTest.java +++ b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/QNameFactoryTest.java @@ -4,9 +4,9 @@ import org.junit.Test; import org.opendaylight.controller.cluster.datastore.util.TestModel; import org.opendaylight.yangtools.yang.common.QName; -import static junit.framework.Assert.assertTrue; -import static junit.framework.TestCase.assertEquals; +import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; public class QNameFactoryTest { diff --git a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/xml/codec/XmlUtilsTest.java b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/xml/codec/XmlUtilsTest.java index 0688bfbc5c..60dbcb0516 100644 --- a/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/xml/codec/XmlUtilsTest.java +++ b/opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/xml/codec/XmlUtilsTest.java @@ -8,11 +8,16 @@ package org.opendaylight.controller.xml.codec; - import com.google.common.collect.ImmutableList; import com.google.common.collect.Lists; import com.google.common.io.ByteSource; -import junit.framework.Assert; +import java.io.IOException; +import java.io.InputStream; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import javax.xml.parsers.DocumentBuilderFactory; +import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.opendaylight.yangtools.yang.common.QName; @@ -27,15 +32,6 @@ import org.opendaylight.yangtools.yang.model.api.RpcDefinition; import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl; -import javax.xml.parsers.DocumentBuilderFactory; - -import java.io.IOException; -import java.io.InputStream; -import java.util.ArrayList; -import java.util.Iterator; -import java.util.List; - - public class XmlUtilsTest { private static final DocumentBuilderFactory BUILDERFACTORY; diff --git a/opendaylight/md-sal/sal-distributed-datastore/pom.xml b/opendaylight/md-sal/sal-distributed-datastore/pom.xml index d7e7d56d49..bd42a9cdd9 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/pom.xml +++ b/opendaylight/md-sal/sal-distributed-datastore/pom.xml @@ -80,7 +80,6 @@ org.opendaylight.controller sal-inmemory-datastore - 1.2.0-SNAPSHOT @@ -131,7 +130,6 @@ org.opendaylight.controller sal-clustering-commons - 1.2.0-SNAPSHOT @@ -164,7 +162,6 @@ org.slf4j slf4j-simple - ${slf4j.version} test diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/ConfigurationImpl.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/ConfigurationImpl.java index 1a0a5dd659..061e1ab448 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/ConfigurationImpl.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/ConfigurationImpl.java @@ -13,12 +13,6 @@ import com.google.common.base.Preconditions; import com.typesafe.config.Config; import com.typesafe.config.ConfigFactory; import com.typesafe.config.ConfigObject; -import org.opendaylight.controller.cluster.datastore.shardstrategy.DefaultShardStrategy; -import org.opendaylight.controller.cluster.datastore.shardstrategy.ModuleShardStrategy; -import org.opendaylight.controller.cluster.datastore.shardstrategy.ShardStrategy; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - import java.io.File; import java.util.ArrayList; import java.util.Collections; @@ -27,6 +21,11 @@ import java.util.LinkedHashSet; import java.util.List; import java.util.Map; import java.util.Set; +import org.opendaylight.controller.cluster.datastore.shardstrategy.DefaultShardStrategy; +import org.opendaylight.controller.cluster.datastore.shardstrategy.ModuleShardStrategy; +import org.opendaylight.controller.cluster.datastore.shardstrategy.ShardStrategy; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; public class ConfigurationImpl implements Configuration { @@ -40,15 +39,15 @@ public class ConfigurationImpl implements Configuration { // Look up maps to speed things up // key = memberName, value = list of shardNames - private Map> memberShardNames = new HashMap<>(); + private final Map> memberShardNames = new HashMap<>(); // key = shardName, value = list of replicaNames (replicaNames are the same as memberNames) - private Map> shardReplicaNames = new HashMap<>(); + private final Map> shardReplicaNames = new HashMap<>(); - public ConfigurationImpl(String moduleShardsConfigPath, + public ConfigurationImpl(final String moduleShardsConfigPath, - String modulesConfigPath){ + final String modulesConfigPath){ Preconditions.checkNotNull(moduleShardsConfigPath, "moduleShardsConfigPath should not be null"); Preconditions.checkNotNull(modulesConfigPath, "modulesConfigPath should not be null"); @@ -80,7 +79,7 @@ public class ConfigurationImpl implements Configuration { readModules(modulesConfig); } - @Override public List getMemberShardNames(String memberName){ + @Override public List getMemberShardNames(final String memberName){ Preconditions.checkNotNull(memberName, "memberName should not be null"); @@ -88,7 +87,7 @@ public class ConfigurationImpl implements Configuration { return memberShardNames.get(memberName); } - List shards = new ArrayList(); + List shards = new ArrayList<>(); for(ModuleShard ms : moduleShards){ for(Shard s : ms.getShards()){ for(String m : s.getReplicas()){ @@ -105,7 +104,7 @@ public class ConfigurationImpl implements Configuration { } - @Override public Optional getModuleNameFromNameSpace(String nameSpace) { + @Override public Optional getModuleNameFromNameSpace(final String nameSpace) { Preconditions.checkNotNull(nameSpace, "nameSpace should not be null"); @@ -125,7 +124,7 @@ public class ConfigurationImpl implements Configuration { return map; } - @Override public List getShardNamesFromModuleName(String moduleName) { + @Override public List getShardNamesFromModuleName(final String moduleName) { Preconditions.checkNotNull(moduleName, "moduleName should not be null"); @@ -139,10 +138,10 @@ public class ConfigurationImpl implements Configuration { } } - return Collections.EMPTY_LIST; + return Collections.emptyList(); } - @Override public List getMembersFromShardName(String shardName) { + @Override public List getMembersFromShardName(final String shardName) { Preconditions.checkNotNull(shardName, "shardName should not be null"); @@ -159,8 +158,8 @@ public class ConfigurationImpl implements Configuration { } } } - shardReplicaNames.put(shardName, Collections.EMPTY_LIST); - return Collections.EMPTY_LIST; + shardReplicaNames.put(shardName, Collections.emptyList()); + return Collections.emptyList(); } @Override public Set getAllShardNames() { @@ -175,7 +174,7 @@ public class ConfigurationImpl implements Configuration { - private void readModules(Config modulesConfig) { + private void readModules(final Config modulesConfig) { List modulesConfigObjectList = modulesConfig.getObjectList("modules"); @@ -186,7 +185,7 @@ public class ConfigurationImpl implements Configuration { } } - private void readModuleShards(Config moduleShardsConfig) { + private void readModuleShards(final Config moduleShardsConfig) { List moduleShardsConfigObjectList = moduleShardsConfig.getObjectList("module-shards"); @@ -214,7 +213,7 @@ public class ConfigurationImpl implements Configuration { private final String moduleName; private final List shards; - public ModuleShard(String moduleName, List shards) { + public ModuleShard(final String moduleName, final List shards) { this.moduleName = moduleName; this.shards = shards; } @@ -232,7 +231,7 @@ public class ConfigurationImpl implements Configuration { private final String name; private final List replicas; - Shard(String name, List replicas) { + Shard(final String name, final List replicas) { this.name = name; this.replicas = replicas; } @@ -252,7 +251,7 @@ public class ConfigurationImpl implements Configuration { private final String nameSpace; private final ShardStrategy shardStrategy; - Module(String name, String nameSpace, String shardStrategy) { + Module(final String name, final String nameSpace, final String shardStrategy) { this.name = name; this.nameSpace = nameSpace; if(ModuleShardStrategy.NAME.equals(shardStrategy)){ @@ -280,11 +279,11 @@ public class ConfigurationImpl implements Configuration { private final ConfigObject configObject; - ConfigObjectWrapper(ConfigObject configObject){ + ConfigObjectWrapper(final ConfigObject configObject){ this.configObject = configObject; } - public String stringValue(String name){ + public String stringValue(final String name){ return configObject.get(name).unwrapped().toString(); } } diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/TransactionProxy.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/TransactionProxy.java index 40880d9075..d93bae22e0 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/TransactionProxy.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/TransactionProxy.java @@ -236,6 +236,18 @@ public class TransactionProxy implements DOMStoreReadWriteTransaction { return recordedOperationFutures; } + @VisibleForTesting + boolean hasTransactionContext() { + for(TransactionFutureCallback txFutureCallback : txFutureCallbackMap.values()) { + TransactionContext transactionContext = txFutureCallback.getTransactionContext(); + if(transactionContext != null) { + return true; + } + } + + return false; + } + @Override public CheckedFuture>, ReadFailedException> read( final YangInstanceIdentifier path) { @@ -640,29 +652,42 @@ public class TransactionProxy implements DOMStoreReadWriteTransaction { // respect to #addTxOperationOnComplete to handle timing issues and ensure no // TransactionOperation is missed and that they are processed in the order they occurred. synchronized(txOperationsOnComplete) { + // Store the new TransactionContext locally until we've completed invoking the + // TransactionOperations. This avoids thread timing issues which could cause + // out-of-order TransactionOperations. Eg, on a modification operation, if the + // TransactionContext is non-null, then we directly call the TransactionContext. + // However, at the same time, the code may be executing the cached + // TransactionOperations. So to avoid thus timing, we don't publish the + // TransactionContext until after we've executed all cached TransactionOperations. + TransactionContext localTransactionContext; if(failure != null) { LOG.debug("Tx {} Creating NoOpTransaction because of error: {}", identifier, failure.getMessage()); - transactionContext = new NoOpTransactionContext(failure, identifier); + localTransactionContext = new NoOpTransactionContext(failure, identifier); } else if (response.getClass().equals(CreateTransactionReply.SERIALIZABLE_CLASS)) { - createValidTransactionContext(CreateTransactionReply.fromSerializable(response)); + localTransactionContext = createValidTransactionContext( + CreateTransactionReply.fromSerializable(response)); } else { IllegalArgumentException exception = new IllegalArgumentException(String.format( "Invalid reply type %s for CreateTransaction", response.getClass())); - transactionContext = new NoOpTransactionContext(exception, identifier); + localTransactionContext = new NoOpTransactionContext(exception, identifier); } for(TransactionOperation oper: txOperationsOnComplete) { - oper.invoke(transactionContext); + oper.invoke(localTransactionContext); } txOperationsOnComplete.clear(); + + // We're done invoking the TransactionOperations so we can now publish the + // TransactionContext. + transactionContext = localTransactionContext; } } - private void createValidTransactionContext(CreateTransactionReply reply) { + private TransactionContext createValidTransactionContext(CreateTransactionReply reply) { String transactionPath = reply.getTransactionPath(); LOG.debug("Tx {} Received transaction actor path {}", identifier, transactionPath); @@ -683,7 +708,7 @@ public class TransactionProxy implements DOMStoreReadWriteTransaction { // Check if TxActor is created in the same node boolean isTxActorLocal = actorContext.isLocalPath(transactionPath); - transactionContext = new TransactionContextImpl(transactionPath, transactionActor, identifier, + return new TransactionContextImpl(transactionPath, transactionActor, identifier, actorContext, schemaContext, isTxActorLocal, reply.getVersion()); } } diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CanCommitTransactionReply.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CanCommitTransactionReply.java index 9c8909c2dd..4d121bae0a 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CanCommitTransactionReply.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CanCommitTransactionReply.java @@ -11,12 +11,12 @@ package org.opendaylight.controller.cluster.datastore.messages; import org.opendaylight.controller.protobuff.messages.cohort3pc.ThreePhaseCommitCohortMessages; public class CanCommitTransactionReply implements SerializableMessage { - public static Class SERIALIZABLE_CLASS = + public static final Class SERIALIZABLE_CLASS = ThreePhaseCommitCohortMessages.CanCommitTransactionReply.class; private final Boolean canCommit; - public CanCommitTransactionReply(Boolean canCommit) { + public CanCommitTransactionReply(final Boolean canCommit) { this.canCommit = canCommit; } @@ -29,7 +29,7 @@ public class CanCommitTransactionReply implements SerializableMessage { return ThreePhaseCommitCohortMessages.CanCommitTransactionReply.newBuilder().setCanCommit(canCommit).build(); } - public static CanCommitTransactionReply fromSerializable(Object message) { + public static CanCommitTransactionReply fromSerializable(final Object message) { return new CanCommitTransactionReply( ((ThreePhaseCommitCohortMessages.CanCommitTransactionReply) message).getCanCommit()); } diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CloseDataChangeListenerRegistration.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CloseDataChangeListenerRegistration.java index a54ee6209c..f711d6f7b5 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CloseDataChangeListenerRegistration.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CloseDataChangeListenerRegistration.java @@ -11,7 +11,8 @@ package org.opendaylight.controller.cluster.datastore.messages; import org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages; public class CloseDataChangeListenerRegistration implements SerializableMessage { - public static final Class SERIALIZABLE_CLASS = ListenerRegistrationMessages.CloseDataChangeListenerRegistration.class; + public static final Class SERIALIZABLE_CLASS = + ListenerRegistrationMessages.CloseDataChangeListenerRegistration.class; @Override public Object toSerializable() { return ListenerRegistrationMessages.CloseDataChangeListenerRegistration.newBuilder().build(); diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CloseDataChangeListenerRegistrationReply.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CloseDataChangeListenerRegistrationReply.java index faf73c87eb..9d8225c23a 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CloseDataChangeListenerRegistrationReply.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CloseDataChangeListenerRegistrationReply.java @@ -11,7 +11,8 @@ package org.opendaylight.controller.cluster.datastore.messages; import org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages; public class CloseDataChangeListenerRegistrationReply implements SerializableMessage{ - public static Class SERIALIZABLE_CLASS = ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply.class; + public static final Class SERIALIZABLE_CLASS = + ListenerRegistrationMessages.CloseDataChangeListenerRegistrationReply.class; @Override public Object toSerializable() { diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CloseTransaction.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CloseTransaction.java index 451e39cf6a..c73111f2db 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CloseTransaction.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CloseTransaction.java @@ -11,7 +11,8 @@ package org.opendaylight.controller.cluster.datastore.messages; import org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages; public class CloseTransaction implements SerializableMessage{ - public static final Class SERIALIZABLE_CLASS = ShardTransactionMessages.CloseTransaction.class; + public static final Class SERIALIZABLE_CLASS = + ShardTransactionMessages.CloseTransaction.class; @Override public Object toSerializable() { return ShardTransactionMessages.CloseTransaction.newBuilder().build(); diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CloseTransactionChain.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CloseTransactionChain.java index 74de6c5aea..7db39b77a3 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CloseTransactionChain.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CloseTransactionChain.java @@ -11,11 +11,11 @@ package org.opendaylight.controller.cluster.datastore.messages; import org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages; public class CloseTransactionChain implements SerializableMessage { - public static final Class SERIALIZABLE_CLASS = + public static final Class SERIALIZABLE_CLASS = ShardTransactionChainMessages.CloseTransactionChain.class; private final String transactionChainId; - public CloseTransactionChain(String transactionChainId){ + public CloseTransactionChain(final String transactionChainId){ this.transactionChainId = transactionChainId; } @@ -25,7 +25,7 @@ public class CloseTransactionChain implements SerializableMessage { .setTransactionChainId(transactionChainId).build(); } - public static CloseTransactionChain fromSerializable(Object message){ + public static CloseTransactionChain fromSerializable(final Object message){ ShardTransactionChainMessages.CloseTransactionChain closeTransactionChain = (ShardTransactionChainMessages.CloseTransactionChain) message; diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CloseTransactionChainReply.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CloseTransactionChainReply.java index 23699b7be6..c001ae185a 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CloseTransactionChainReply.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CloseTransactionChainReply.java @@ -11,7 +11,8 @@ package org.opendaylight.controller.cluster.datastore.messages; import org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages; public class CloseTransactionChainReply implements SerializableMessage { - public static final Class SERIALIZABLE_CLASS = ShardTransactionChainMessages.CloseTransactionChainReply.class; + public static final Class SERIALIZABLE_CLASS = + ShardTransactionChainMessages.CloseTransactionChainReply.class; @Override public Object toSerializable() { return ShardTransactionChainMessages.CloseTransactionChainReply.newBuilder().build(); diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CloseTransactionReply.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CloseTransactionReply.java index 666d182aaf..124eeb2235 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CloseTransactionReply.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CloseTransactionReply.java @@ -11,7 +11,8 @@ package org.opendaylight.controller.cluster.datastore.messages; import org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages; public class CloseTransactionReply implements SerializableMessage { - public static final Class SERIALIZABLE_CLASS = ShardTransactionMessages.CloseTransactionReply.class; + public static final Class SERIALIZABLE_CLASS = + ShardTransactionMessages.CloseTransactionReply.class; @Override public Object toSerializable() { return ShardTransactionMessages.CloseTransactionReply.newBuilder().build(); diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CreateTransactionReply.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CreateTransactionReply.java index 14620f15d9..83e68c9cb4 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CreateTransactionReply.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/CreateTransactionReply.java @@ -12,18 +12,19 @@ import org.opendaylight.controller.protobuff.messages.transaction.ShardTransacti public class CreateTransactionReply implements SerializableMessage { - public static final Class SERIALIZABLE_CLASS = ShardTransactionMessages.CreateTransactionReply.class; + public static final Class SERIALIZABLE_CLASS = + ShardTransactionMessages.CreateTransactionReply.class; private final String transactionPath; private final String transactionId; private final int version; - public CreateTransactionReply(String transactionPath, - String transactionId) { + public CreateTransactionReply(final String transactionPath, + final String transactionId) { this(transactionPath, transactionId, CreateTransaction.CURRENT_VERSION); } - public CreateTransactionReply(String transactionPath, - String transactionId, int version) { + public CreateTransactionReply(final String transactionPath, + final String transactionId, final int version) { this.transactionPath = transactionPath; this.transactionId = transactionId; this.version = version; @@ -42,6 +43,7 @@ public class CreateTransactionReply implements SerializableMessage { return version; } + @Override public Object toSerializable(){ return ShardTransactionMessages.CreateTransactionReply.newBuilder() .setTransactionActorPath(transactionPath) @@ -50,7 +52,7 @@ public class CreateTransactionReply implements SerializableMessage { .build(); } - public static CreateTransactionReply fromSerializable(Object serializable){ + public static CreateTransactionReply fromSerializable(final Object serializable){ ShardTransactionMessages.CreateTransactionReply o = (ShardTransactionMessages.CreateTransactionReply) serializable; return new CreateTransactionReply(o.getTransactionActorPath(), o.getTransactionId(), o.getMessageVersion()); } diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/DataChangedReply.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/DataChangedReply.java index cffe985d18..e10a407292 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/DataChangedReply.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/DataChangedReply.java @@ -11,7 +11,8 @@ package org.opendaylight.controller.cluster.datastore.messages; import org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages; public class DataChangedReply implements SerializableMessage { - public static final Class SERIALIZABLE_CLASS = DataChangeListenerMessages.DataChangedReply.class; + public static final Class SERIALIZABLE_CLASS = + DataChangeListenerMessages.DataChangedReply.class; @Override public Object toSerializable() { return DataChangeListenerMessages.DataChangedReply.newBuilder().build(); diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/DataExists.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/DataExists.java index d52daabd84..84b8df1676 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/DataExists.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/DataExists.java @@ -14,11 +14,12 @@ import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; public class DataExists implements SerializableMessage{ - public static final Class SERIALIZABLE_CLASS = ShardTransactionMessages.DataExists.class; + public static final Class SERIALIZABLE_CLASS = + ShardTransactionMessages.DataExists.class; private final YangInstanceIdentifier path; - public DataExists(YangInstanceIdentifier path) { + public DataExists(final YangInstanceIdentifier path) { this.path = path; } @@ -32,7 +33,7 @@ public class DataExists implements SerializableMessage{ InstanceIdentifierUtils.toSerializable(path)).build(); } - public static DataExists fromSerializable(Object serializable){ + public static DataExists fromSerializable(final Object serializable){ ShardTransactionMessages.DataExists o = (ShardTransactionMessages.DataExists) serializable; return new DataExists(InstanceIdentifierUtils.fromSerializable(o.getInstanceIdentifierPathArguments())); } diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/DataExistsReply.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/DataExistsReply.java index 04fafa10e2..24ca646454 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/DataExistsReply.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/DataExistsReply.java @@ -11,13 +11,12 @@ package org.opendaylight.controller.cluster.datastore.messages; import org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages; public class DataExistsReply implements SerializableMessage{ - - - public static final Class SERIALIZABLE_CLASS = ShardTransactionMessages.DataExistsReply.class; + public static final Class SERIALIZABLE_CLASS = + ShardTransactionMessages.DataExistsReply.class; private final boolean exists; - public DataExistsReply(boolean exists) { + public DataExistsReply(final boolean exists) { this.exists = exists; } @@ -30,7 +29,7 @@ public class DataExistsReply implements SerializableMessage{ .setExists(exists).build(); } - public static DataExistsReply fromSerializable(Object serializable){ + public static DataExistsReply fromSerializable(final Object serializable){ ShardTransactionMessages.DataExistsReply o = (ShardTransactionMessages.DataExistsReply) serializable; return new DataExistsReply(o.getExists()); } diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/DeleteData.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/DeleteData.java index 6d3051c8c7..81bc1026e4 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/DeleteData.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/DeleteData.java @@ -14,11 +14,11 @@ import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; public class DeleteData implements SerializableMessage { - public static final Class SERIALIZABLE_CLASS = ShardTransactionMessages.DeleteData.class; + public static final Class SERIALIZABLE_CLASS = ShardTransactionMessages.DeleteData.class; private final YangInstanceIdentifier path; - public DeleteData(YangInstanceIdentifier path) { + public DeleteData(final YangInstanceIdentifier path) { this.path = path; } @@ -31,7 +31,7 @@ public class DeleteData implements SerializableMessage { .setInstanceIdentifierPathArguments(InstanceIdentifierUtils.toSerializable(path)).build(); } - public static DeleteData fromSerializable(Object serializable){ + public static DeleteData fromSerializable(final Object serializable){ ShardTransactionMessages.DeleteData o = (ShardTransactionMessages.DeleteData) serializable; return new DeleteData(InstanceIdentifierUtils.fromSerializable(o.getInstanceIdentifierPathArguments())); } diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/DeleteDataReply.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/DeleteDataReply.java index 8e2a7b7295..2e02664e1d 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/DeleteDataReply.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/DeleteDataReply.java @@ -11,7 +11,8 @@ package org.opendaylight.controller.cluster.datastore.messages; import org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages; public class DeleteDataReply implements SerializableMessage{ - public static final Class SERIALIZABLE_CLASS = ShardTransactionMessages.DeleteDataReply.class; + public static final Class SERIALIZABLE_CLASS = + ShardTransactionMessages.DeleteDataReply.class; @Override public Object toSerializable() { return ShardTransactionMessages.DeleteDataReply.newBuilder().build(); diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/MergeDataReply.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/MergeDataReply.java index 81b1c3bbb1..92d6d72847 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/MergeDataReply.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/MergeDataReply.java @@ -11,7 +11,8 @@ package org.opendaylight.controller.cluster.datastore.messages; import org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages; public class MergeDataReply implements SerializableMessage{ - public static final Class SERIALIZABLE_CLASS = ShardTransactionMessages.MergeDataReply.class; + public static final Class SERIALIZABLE_CLASS = + ShardTransactionMessages.MergeDataReply.class; @Override public Object toSerializable() { diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/PreCommitTransaction.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/PreCommitTransaction.java index dae4cec3c3..3cec7e74a6 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/PreCommitTransaction.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/PreCommitTransaction.java @@ -12,7 +12,8 @@ import org.opendaylight.controller.protobuff.messages.cohort3pc.ThreePhaseCommit public class PreCommitTransaction implements SerializableMessage{ - public static final Class SERIALIZABLE_CLASS = ThreePhaseCommitCohortMessages.PreCommitTransaction.class; + public static final Class SERIALIZABLE_CLASS = + ThreePhaseCommitCohortMessages.PreCommitTransaction.class; @Override public Object toSerializable() { diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/PreCommitTransactionReply.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/PreCommitTransactionReply.java index fc07bfcb4b..d158049409 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/PreCommitTransactionReply.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/PreCommitTransactionReply.java @@ -12,7 +12,8 @@ import org.opendaylight.controller.protobuff.messages.cohort3pc.ThreePhaseCommit public class PreCommitTransactionReply implements SerializableMessage{ - public static final Class SERIALIZABLE_CLASS = ThreePhaseCommitCohortMessages.PreCommitTransactionReply.class; + public static final Class SERIALIZABLE_CLASS = + ThreePhaseCommitCohortMessages.PreCommitTransactionReply.class; @Override public Object toSerializable() { diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/PrimaryFound.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/PrimaryFound.java index a2f6701524..a5565020ed 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/PrimaryFound.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/PrimaryFound.java @@ -10,10 +10,10 @@ package org.opendaylight.controller.cluster.datastore.messages; public class PrimaryFound implements SerializableMessage { - public static final Class SERIALIZABLE_CLASS = PrimaryFound.class; + public static final Class SERIALIZABLE_CLASS = PrimaryFound.class; private final String primaryPath; - public PrimaryFound(String primaryPath) { + public PrimaryFound(final String primaryPath) { this.primaryPath = primaryPath; } @@ -22,13 +22,19 @@ public class PrimaryFound implements SerializableMessage { } @Override - public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } PrimaryFound that = (PrimaryFound) o; - if (!primaryPath.equals(that.primaryPath)) return false; + if (!primaryPath.equals(that.primaryPath)) { + return false; + } return true; } @@ -51,7 +57,7 @@ public class PrimaryFound implements SerializableMessage { return this; } - public static PrimaryFound fromSerializable(Object message){ + public static PrimaryFound fromSerializable(final Object message){ return (PrimaryFound) message; } } diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/PrimaryNotFound.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/PrimaryNotFound.java index 731a5364db..b47c91b6e5 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/PrimaryNotFound.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/PrimaryNotFound.java @@ -11,11 +11,11 @@ package org.opendaylight.controller.cluster.datastore.messages; import com.google.common.base.Preconditions; public class PrimaryNotFound implements SerializableMessage { - public static final Class SERIALIZABLE_CLASS = PrimaryNotFound.class; + public static final Class SERIALIZABLE_CLASS = PrimaryNotFound.class; private final String shardName; - public PrimaryNotFound(String shardName){ + public PrimaryNotFound(final String shardName){ Preconditions.checkNotNull(shardName, "shardName should not be null"); @@ -23,13 +23,19 @@ public class PrimaryNotFound implements SerializableMessage { } @Override - public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } PrimaryNotFound that = (PrimaryNotFound) o; - if (shardName != null ? !shardName.equals(that.shardName) : that.shardName != null) return false; + if (shardName != null ? !shardName.equals(that.shardName) : that.shardName != null) { + return false; + } return true; } @@ -44,7 +50,7 @@ public class PrimaryNotFound implements SerializableMessage { return this; } - public static PrimaryNotFound fromSerializable(Object message){ + public static PrimaryNotFound fromSerializable(final Object message){ return (PrimaryNotFound) message; } } diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/ReadData.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/ReadData.java index d743d99fcc..a8a3e7d071 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/ReadData.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/ReadData.java @@ -13,10 +13,11 @@ import org.opendaylight.controller.protobuff.messages.transaction.ShardTransacti import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; public class ReadData { - public static final Class SERIALIZABLE_CLASS = ShardTransactionMessages.ReadData.class; + public static final Class SERIALIZABLE_CLASS = + ShardTransactionMessages.ReadData.class; private final YangInstanceIdentifier path; - public ReadData(YangInstanceIdentifier path) { + public ReadData(final YangInstanceIdentifier path) { this.path = path; } @@ -30,7 +31,7 @@ public class ReadData { .build(); } - public static ReadData fromSerializable(Object serializable){ + public static ReadData fromSerializable(final Object serializable){ ShardTransactionMessages.ReadData o = (ShardTransactionMessages.ReadData) serializable; return new ReadData(InstanceIdentifierUtils.fromSerializable(o.getInstanceIdentifierPathArguments())); } diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/ReadyTransaction.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/ReadyTransaction.java index 3a51d9850b..581caefd04 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/ReadyTransaction.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/ReadyTransaction.java @@ -11,7 +11,8 @@ package org.opendaylight.controller.cluster.datastore.messages; import org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages; public class ReadyTransaction implements SerializableMessage{ - public static final Class SERIALIZABLE_CLASS = ShardTransactionMessages.ReadyTransaction.class; + public static final Class SERIALIZABLE_CLASS = + ShardTransactionMessages.ReadyTransaction.class; @Override public Object toSerializable() { diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/RegisterChangeListenerReply.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/RegisterChangeListenerReply.java index 8d980d283d..bbfbbaa80b 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/RegisterChangeListenerReply.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/RegisterChangeListenerReply.java @@ -13,10 +13,11 @@ import akka.actor.ActorSystem; import org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages; public class RegisterChangeListenerReply implements SerializableMessage{ - public static final Class SERIALIZABLE_CLASS = ListenerRegistrationMessages.RegisterChangeListenerReply.class; + public static final Class SERIALIZABLE_CLASS = + ListenerRegistrationMessages.RegisterChangeListenerReply.class; private final ActorPath listenerRegistrationPath; - public RegisterChangeListenerReply(ActorPath listenerRegistrationPath) { + public RegisterChangeListenerReply(final ActorPath listenerRegistrationPath) { this.listenerRegistrationPath = listenerRegistrationPath; } @@ -30,7 +31,7 @@ public class RegisterChangeListenerReply implements SerializableMessage{ .setListenerRegistrationPath(listenerRegistrationPath.toString()).build(); } - public static RegisterChangeListenerReply fromSerializable(ActorSystem actorSystem,Object serializable){ + public static RegisterChangeListenerReply fromSerializable(final ActorSystem actorSystem,final Object serializable){ ListenerRegistrationMessages.RegisterChangeListenerReply o = (ListenerRegistrationMessages.RegisterChangeListenerReply) serializable; return new RegisterChangeListenerReply( actorSystem.actorFor(o.getListenerRegistrationPath()).path() diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/WriteDataReply.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/WriteDataReply.java index 5404fb6510..876105de18 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/WriteDataReply.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/messages/WriteDataReply.java @@ -11,7 +11,8 @@ package org.opendaylight.controller.cluster.datastore.messages; import org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages; public class WriteDataReply implements SerializableMessage{ - public static final Class SERIALIZABLE_CLASS = ShardTransactionMessages.WriteDataReply.class; + public static final Class SERIALIZABLE_CLASS = + ShardTransactionMessages.WriteDataReply.class; @Override public Object toSerializable() { return ShardTransactionMessages.WriteDataReply.newBuilder().build(); diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/modification/MergeModification.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/modification/MergeModification.java index 24c4c6c50a..2f9d77660a 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/modification/MergeModification.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/modification/MergeModification.java @@ -20,18 +20,19 @@ import org.opendaylight.yangtools.yang.model.api.SchemaContext; * MergeModification stores all the parameters required to merge data into the specified path */ public class MergeModification extends WriteModification { + private static final long serialVersionUID = 1L; - public MergeModification(YangInstanceIdentifier path, NormalizedNode data, - SchemaContext schemaContext) { + public MergeModification(final YangInstanceIdentifier path, final NormalizedNode data, + final SchemaContext schemaContext) { super(path, data, schemaContext); } @Override - public void apply(DOMStoreWriteTransaction transaction) { + public void apply(final DOMStoreWriteTransaction transaction) { transaction.merge(path, data); } - public static MergeModification fromSerializable(Object serializable, SchemaContext schemaContext) { + public static MergeModification fromSerializable(final Object serializable, final SchemaContext schemaContext) { PersistentMessages.Modification o = (PersistentMessages.Modification) serializable; Decoded decoded = new NormalizedNodeToNodeCodec(schemaContext).decode(o.getPath(), o.getData()); return new MergeModification(decoded.getDecodedPath(), decoded.getDecodedNode(), schemaContext); diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/modification/WriteModification.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/modification/WriteModification.java index 53cc35a88b..b2964086fd 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/modification/WriteModification.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/modification/WriteModification.java @@ -21,22 +21,22 @@ import org.opendaylight.yangtools.yang.model.api.SchemaContext; * WriteModification stores all the parameters required to write data to the specified path */ public class WriteModification extends AbstractModification { - - protected final NormalizedNode data; + private static final long serialVersionUID = 1L; + protected final NormalizedNode data; private final SchemaContext schemaContext; - public WriteModification(YangInstanceIdentifier path, NormalizedNode data, SchemaContext schemaContext) { + public WriteModification(final YangInstanceIdentifier path, final NormalizedNode data, final SchemaContext schemaContext) { super(path); this.data = data; this.schemaContext = schemaContext; } @Override - public void apply(DOMStoreWriteTransaction transaction) { + public void apply(final DOMStoreWriteTransaction transaction) { transaction.write(path, data); } - public NormalizedNode getData() { + public NormalizedNode getData() { return data; } @@ -51,7 +51,7 @@ public class WriteModification extends AbstractModification { .build(); } - public static WriteModification fromSerializable(Object serializable, SchemaContext schemaContext) { + public static WriteModification fromSerializable(final Object serializable, final SchemaContext schemaContext) { PersistentMessages.Modification o = (PersistentMessages.Modification) serializable; Decoded decoded = new NormalizedNodeToNodeCodec(schemaContext).decode(o.getPath(), o.getData()); return new WriteModification(decoded.getDecodedPath(), decoded.getDecodedNode(), schemaContext); diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/shardstrategy/ShardStrategyFactory.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/shardstrategy/ShardStrategyFactory.java index f4ab8fab6f..62fb65482b 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/shardstrategy/ShardStrategyFactory.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/shardstrategy/ShardStrategyFactory.java @@ -10,26 +10,25 @@ package org.opendaylight.controller.cluster.datastore.shardstrategy; import com.google.common.base.Optional; import com.google.common.base.Preconditions; -import org.opendaylight.controller.cluster.datastore.Configuration; -import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; - import java.util.Map; import java.util.concurrent.ConcurrentHashMap; +import org.opendaylight.controller.cluster.datastore.Configuration; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; public class ShardStrategyFactory { private static Map moduleNameToStrategyMap = - new ConcurrentHashMap(); + new ConcurrentHashMap<>(); private static final String UNKNOWN_MODULE_NAME = "unknown"; private static Configuration configuration; - public static void setConfiguration(Configuration configuration){ + public static void setConfiguration(final Configuration configuration){ ShardStrategyFactory.configuration = configuration; moduleNameToStrategyMap = configuration.getModuleNameToShardStrategyMap(); } - public static ShardStrategy getStrategy(YangInstanceIdentifier path) { + public static ShardStrategy getStrategy(final YangInstanceIdentifier path) { Preconditions.checkState(configuration != null, "configuration should not be missing"); Preconditions.checkNotNull(path, "path should not be null"); @@ -44,7 +43,7 @@ public class ShardStrategyFactory { } - private static String getModuleName(YangInstanceIdentifier path) { + private static String getModuleName(final YangInstanceIdentifier path) { String namespace = path.getPathArguments().iterator().next().getNodeType().getNamespace().toASCIIString(); Optional optional = diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/ConfigurationImplTest.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/ConfigurationImplTest.java index 8c253596b8..afc060318c 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/ConfigurationImplTest.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/ConfigurationImplTest.java @@ -1,17 +1,15 @@ package org.opendaylight.controller.cluster.datastore; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; import com.typesafe.config.ConfigFactory; -import junit.framework.Assert; -import org.junit.BeforeClass; -import org.junit.Test; - import java.io.File; import java.util.List; import java.util.Set; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; public class ConfigurationImplTest { diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/DataChangeListenerProxyTest.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/DataChangeListenerProxyTest.java index c79d762035..55250dd5e9 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/DataChangeListenerProxyTest.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/DataChangeListenerProxyTest.java @@ -3,6 +3,11 @@ package org.opendaylight.controller.cluster.datastore; import akka.actor.ActorRef; import akka.actor.Props; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; import org.junit.Assert; import org.junit.Test; import org.opendaylight.controller.cluster.datastore.messages.DataChanged; @@ -17,18 +22,12 @@ import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; - public class DataChangeListenerProxyTest extends AbstractActorTest { private static class MockDataChangedEvent implements AsyncDataChangeEvent> { - Map> createdData = new HashMap(); - Map> updatedData = new HashMap(); - Map> originalData = new HashMap(); + Map> createdData = new HashMap<>(); + Map> updatedData = new HashMap<>(); + Map> originalData = new HashMap<>(); @@ -88,7 +87,7 @@ public class DataChangeListenerProxyTest extends AbstractActorTest { Assert.assertTrue(messages instanceof List); - List listMessages = (List) messages; + List listMessages = (List) messages; Assert.assertEquals(1, listMessages.size()); diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/DistributedDataStoreIntegrationTest.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/DistributedDataStoreIntegrationTest.java index 25915b198c..12c566d33d 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/DistributedDataStoreIntegrationTest.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/DistributedDataStoreIntegrationTest.java @@ -77,10 +77,7 @@ public class DistributedDataStoreIntegrationTest extends AbstractActorTest { DOMStoreThreePhaseCommitCohort cohort = writeTx.ready(); - Boolean canCommit = cohort.canCommit().get(5, TimeUnit.SECONDS); - assertEquals("canCommit", true, canCommit); - cohort.preCommit().get(5, TimeUnit.SECONDS); - cohort.commit().get(5, TimeUnit.SECONDS); + doCommit(cohort); // Verify the data in the store @@ -131,10 +128,7 @@ public class DistributedDataStoreIntegrationTest extends AbstractActorTest { // 5. Commit the Tx - Boolean canCommit = cohort.canCommit().get(5, TimeUnit.SECONDS); - assertEquals("canCommit", true, canCommit); - cohort.preCommit().get(5, TimeUnit.SECONDS); - cohort.commit().get(5, TimeUnit.SECONDS); + doCommit(cohort); // 6. Verify the data in the store @@ -219,9 +213,7 @@ public class DistributedDataStoreIntegrationTest extends AbstractActorTest { // Wait for the Tx commit to complete. - assertEquals("canCommit", true, txCohort.get().canCommit().get(5, TimeUnit.SECONDS)); - txCohort.get().preCommit().get(5, TimeUnit.SECONDS); - txCohort.get().commit().get(5, TimeUnit.SECONDS); + doCommit(txCohort.get()); // Verify the data in the store @@ -552,10 +544,8 @@ public class DistributedDataStoreIntegrationTest extends AbstractActorTest { @Test public void testTransactionChain() throws Exception{ - System.setProperty("shard.persistent", "true"); new IntegrationTestKit(getSystem()) {{ - DistributedDataStore dataStore = - setupDistributedDataStore("transactionChainIntegrationTest", "test-1"); + DistributedDataStore dataStore = setupDistributedDataStore("testTransactionChain", "test-1"); // 1. Create a Tx chain and write-only Tx @@ -637,13 +627,6 @@ public class DistributedDataStoreIntegrationTest extends AbstractActorTest { assertEquals("Data node", outerNode, optional.get()); cleanup(dataStore); - } - - private void doCommit(final DOMStoreThreePhaseCommitCohort cohort1) throws Exception { - Boolean canCommit = cohort1.canCommit().get(5, TimeUnit.SECONDS); - assertEquals("canCommit", true, canCommit); - cohort1.preCommit().get(5, TimeUnit.SECONDS); - cohort1.commit().get(5, TimeUnit.SECONDS); }}; } @@ -653,7 +636,10 @@ public class DistributedDataStoreIntegrationTest extends AbstractActorTest { DistributedDataStore dataStore = setupDistributedDataStore("testChangeListenerRegistration", "test-1"); - MockDataChangeListener listener = new MockDataChangeListener(3); + testWriteTransaction(dataStore, TestModel.TEST_PATH, + ImmutableNodes.containerNode(TestModel.TEST_QNAME)); + + MockDataChangeListener listener = new MockDataChangeListener(1); ListenerRegistration listenerReg = dataStore.registerChangeListener(TestModel.TEST_PATH, listener, @@ -661,8 +647,13 @@ public class DistributedDataStoreIntegrationTest extends AbstractActorTest { assertNotNull("registerChangeListener returned null", listenerReg); - testWriteTransaction(dataStore, TestModel.TEST_PATH, - ImmutableNodes.containerNode(TestModel.TEST_QNAME)); + // Wait for the initial notification + + listener.waitForChangeEvents(TestModel.TEST_PATH); + + listener.reset(2); + + // Write 2 updates. testWriteTransaction(dataStore, TestModel.OUTER_LIST_PATH, ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME).build()); @@ -672,7 +663,9 @@ public class DistributedDataStoreIntegrationTest extends AbstractActorTest { testWriteTransaction(dataStore, listPath, ImmutableNodes.mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1)); - listener.waitForChangeEvents(TestModel.TEST_PATH, TestModel.OUTER_LIST_PATH, listPath ); + // Wait for the 2 updates. + + listener.waitForChangeEvents(TestModel.OUTER_LIST_PATH, listPath); listenerReg.close(); @@ -747,10 +740,7 @@ public class DistributedDataStoreIntegrationTest extends AbstractActorTest { // 4. Commit the Tx - Boolean canCommit = cohort.canCommit().get(5, TimeUnit.SECONDS); - assertEquals("canCommit", true, canCommit); - cohort.preCommit().get(5, TimeUnit.SECONDS); - cohort.commit().get(5, TimeUnit.SECONDS); + doCommit(cohort); // 5. Verify the data in the store @@ -761,6 +751,13 @@ public class DistributedDataStoreIntegrationTest extends AbstractActorTest { assertEquals("Data node", nodeToWrite, optional.get()); } + void doCommit(final DOMStoreThreePhaseCommitCohort cohort) throws Exception { + Boolean canCommit = cohort.canCommit().get(5, TimeUnit.SECONDS); + assertEquals("canCommit", true, canCommit); + cohort.preCommit().get(5, TimeUnit.SECONDS); + cohort.commit().get(5, TimeUnit.SECONDS); + } + void cleanup(DistributedDataStore dataStore) { dataStore.getActorContext().getShardManager().tell(PoisonPill.getInstance(), null); } diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/ShardTest.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/ShardTest.java index c6bb0d6b37..e5b5643297 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/ShardTest.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/ShardTest.java @@ -1,5 +1,16 @@ package org.opendaylight.controller.cluster.datastore; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.inOrder; +import static org.mockito.Mockito.mock; +import static org.opendaylight.controller.cluster.datastore.messages.CreateTransaction.CURRENT_VERSION; import akka.actor.ActorRef; import akka.actor.PoisonPill; import akka.actor.Props; @@ -16,6 +27,16 @@ import com.google.common.util.concurrent.Futures; import com.google.common.util.concurrent.ListenableFuture; import com.google.common.util.concurrent.MoreExecutors; import com.google.common.util.concurrent.Uninterruptibles; +import java.io.IOException; +import java.util.Collections; +import java.util.HashSet; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicReference; import org.junit.After; import org.junit.Before; import org.junit.Test; @@ -80,29 +101,6 @@ import scala.concurrent.Await; import scala.concurrent.Future; import scala.concurrent.duration.FiniteDuration; -import java.io.IOException; -import java.util.Collections; -import java.util.HashSet; -import java.util.Map; -import java.util.Set; -import java.util.concurrent.CountDownLatch; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.atomic.AtomicInteger; -import java.util.concurrent.atomic.AtomicReference; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; -import static org.mockito.Mockito.doAnswer; -import static org.mockito.Mockito.doReturn; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.mock; -import static org.opendaylight.controller.cluster.datastore.messages.CreateTransaction.CURRENT_VERSION; - public class ShardTest extends AbstractActorTest { @@ -308,6 +306,7 @@ public class ShardTest extends AbstractActorTest { }}; } + @SuppressWarnings("serial") @Test public void testPeerAddressResolved() throws Exception { new ShardTestKit(getSystem()) {{ @@ -509,7 +508,7 @@ public class ShardTest extends AbstractActorTest { shard.tell(PoisonPill.getInstance(), ActorRef.noSender()); } - private CompositeModificationPayload newPayload(Modification... mods) { + private CompositeModificationPayload newPayload(final Modification... mods) { MutableCompositeModification compMod = new MutableCompositeModification(); for(Modification mod: mods) { compMod.addModification(mod); @@ -518,15 +517,15 @@ public class ShardTest extends AbstractActorTest { return new CompositeModificationPayload(compMod.toSerializable()); } - private DOMStoreThreePhaseCommitCohort setupMockWriteTransaction(String cohortName, - InMemoryDOMDataStore dataStore, YangInstanceIdentifier path, NormalizedNode data, - MutableCompositeModification modification) { + private DOMStoreThreePhaseCommitCohort setupMockWriteTransaction(final String cohortName, + final InMemoryDOMDataStore dataStore, final YangInstanceIdentifier path, final NormalizedNode data, + final MutableCompositeModification modification) { return setupMockWriteTransaction(cohortName, dataStore, path, data, modification, null); } - private DOMStoreThreePhaseCommitCohort setupMockWriteTransaction(String cohortName, - InMemoryDOMDataStore dataStore, YangInstanceIdentifier path, NormalizedNode data, - MutableCompositeModification modification, + private DOMStoreThreePhaseCommitCohort setupMockWriteTransaction(final String cohortName, + final InMemoryDOMDataStore dataStore, final YangInstanceIdentifier path, final NormalizedNode data, + final MutableCompositeModification modification, final Function> preCommit) { DOMStoreWriteTransaction tx = dataStore.newWriteOnlyTransaction(); @@ -536,14 +535,14 @@ public class ShardTest extends AbstractActorTest { doAnswer(new Answer>() { @Override - public ListenableFuture answer(InvocationOnMock invocation) { + public ListenableFuture answer(final InvocationOnMock invocation) { return realCohort.canCommit(); } }).when(cohort).canCommit(); doAnswer(new Answer>() { @Override - public ListenableFuture answer(InvocationOnMock invocation) throws Throwable { + public ListenableFuture answer(final InvocationOnMock invocation) throws Throwable { if(preCommit != null) { return preCommit.apply(realCohort); } else { @@ -554,14 +553,14 @@ public class ShardTest extends AbstractActorTest { doAnswer(new Answer>() { @Override - public ListenableFuture answer(InvocationOnMock invocation) throws Throwable { + public ListenableFuture answer(final InvocationOnMock invocation) throws Throwable { return realCohort.commit(); } }).when(cohort).commit(); doAnswer(new Answer>() { @Override - public ListenableFuture answer(InvocationOnMock invocation) throws Throwable { + public ListenableFuture answer(final InvocationOnMock invocation) throws Throwable { return realCohort.abort(); } }).when(cohort).abort(); @@ -658,12 +657,12 @@ public class ShardTest extends AbstractActorTest { class OnFutureComplete extends OnComplete { private final Class expRespType; - OnFutureComplete(Class expRespType) { + OnFutureComplete(final Class expRespType) { this.expRespType = expRespType; } @Override - public void onComplete(Throwable error, Object resp) { + public void onComplete(final Throwable error, final Object resp) { if(error != null) { caughtEx.set(new AssertionError(getClass().getSimpleName() + " failure", error)); } else { @@ -676,7 +675,7 @@ public class ShardTest extends AbstractActorTest { } } - void onSuccess(Object resp) throws Exception { + void onSuccess(final Object resp) throws Exception { } } @@ -686,7 +685,7 @@ public class ShardTest extends AbstractActorTest { } @Override - public void onComplete(Throwable error, Object resp) { + public void onComplete(final Throwable error, final Object resp) { super.onComplete(error, resp); commitLatch.countDown(); } @@ -695,13 +694,13 @@ public class ShardTest extends AbstractActorTest { class OnCanCommitFutureComplete extends OnFutureComplete { private final String transactionID; - OnCanCommitFutureComplete(String transactionID) { + OnCanCommitFutureComplete(final String transactionID) { super(CanCommitTransactionReply.SERIALIZABLE_CLASS); this.transactionID = transactionID; } @Override - void onSuccess(Object resp) throws Exception { + void onSuccess(final Object resp) throws Exception { CanCommitTransactionReply canCommitReply = CanCommitTransactionReply.fromSerializable(resp); assertEquals("Can commit", true, canCommitReply.getCanCommit()); @@ -828,7 +827,7 @@ public class ShardTest extends AbstractActorTest { final CountDownLatch latch = new CountDownLatch(1); canCommitFuture.onComplete(new OnComplete() { @Override - public void onComplete(Throwable t, Object resp) { + public void onComplete(final Throwable t, final Object resp) { latch.countDown(); } }, getSystem().dispatcher()); @@ -948,7 +947,7 @@ public class ShardTest extends AbstractActorTest { new AbortTransaction(transactionID).toSerializable(), timeout); abortFuture.onComplete(new OnComplete() { @Override - public void onComplete(Throwable e, Object resp) { + public void onComplete(final Throwable e, final Object resp) { abortComplete.countDown(); } }, getSystem().dispatcher()); @@ -1195,7 +1194,7 @@ public class ShardTest extends AbstractActorTest { final CountDownLatch latch = new CountDownLatch(1); canCommitFuture.onComplete(new OnComplete() { @Override - public void onComplete(Throwable t, Object resp) { + public void onComplete(final Throwable t, final Object resp) { latch.countDown(); } }, getSystem().dispatcher()); @@ -1220,7 +1219,8 @@ public class ShardTest extends AbstractActorTest { testCreateSnapshot(false, "testCreateSnapshotWithNonPersistentData"); } - public void testCreateSnapshot(boolean persistent, final String shardActorName) throws IOException, InterruptedException { + @SuppressWarnings("serial") + public void testCreateSnapshot(final boolean persistent, final String shardActorName) throws IOException, InterruptedException { final DatastoreContext dataStoreContext = DatastoreContext.newBuilder(). shardJournalRecoveryLogBatchSize(3).shardSnapshotBatchCount(5000).persistent(persistent).build(); @@ -1232,7 +1232,7 @@ public class ShardTest extends AbstractActorTest { return new Shard(shardID, Collections.emptyMap(), dataStoreContext, SCHEMA_CONTEXT) { @Override - protected void commitSnapshot(long sequenceNumber) { + protected void commitSnapshot(final long sequenceNumber) { super.commitSnapshot(sequenceNumber); latch.get().countDown(); } @@ -1275,7 +1275,7 @@ public class ShardTest extends AbstractActorTest { commitTransaction(putTransaction); - NormalizedNode expected = readStore(store); + NormalizedNode expected = readStore(store); DOMStoreWriteTransaction writeTransaction = store.newWriteOnlyTransaction(); @@ -1284,7 +1284,7 @@ public class ShardTest extends AbstractActorTest { commitTransaction(writeTransaction); - NormalizedNode actual = readStore(store); + NormalizedNode actual = readStore(store); assertEquals(expected, actual); @@ -1325,7 +1325,7 @@ public class ShardTest extends AbstractActorTest { } - private NormalizedNode readStore(InMemoryDOMDataStore store) throws ReadFailedException { + private NormalizedNode readStore(final InMemoryDOMDataStore store) throws ReadFailedException { DOMStoreReadTransaction transaction = store.newReadOnlyTransaction(); CheckedFuture>, ReadFailedException> read = transaction.read(YangInstanceIdentifier.builder().build()); @@ -1339,7 +1339,7 @@ public class ShardTest extends AbstractActorTest { return normalizedNode; } - private void commitTransaction(DOMStoreWriteTransaction transaction) { + private void commitTransaction(final DOMStoreWriteTransaction transaction) { DOMStoreThreePhaseCommitCohort commitCohort = transaction.ready(); ListenableFuture future = commitCohort.preCommit(); @@ -1355,13 +1355,13 @@ public class ShardTest extends AbstractActorTest { return new AsyncDataChangeListener>() { @Override public void onDataChanged( - AsyncDataChangeEvent> change) { + final AsyncDataChangeEvent> change) { } }; } - static NormalizedNode readStore(TestActorRef shard, YangInstanceIdentifier id) + static NormalizedNode readStore(final TestActorRef shard, final YangInstanceIdentifier id) throws ExecutionException, InterruptedException { DOMStoreReadTransaction transaction = shard.underlyingActor().getDataStore().newReadOnlyTransaction(); @@ -1376,7 +1376,7 @@ public class ShardTest extends AbstractActorTest { return node; } - private void writeToStore(TestActorRef shard, YangInstanceIdentifier id, NormalizedNode node) + private void writeToStore(final TestActorRef shard, final YangInstanceIdentifier id, final NormalizedNode node) throws ExecutionException, InterruptedException { DOMStoreWriteTransaction transaction = shard.underlyingActor().getDataStore().newWriteOnlyTransaction(); @@ -1387,10 +1387,11 @@ public class ShardTest extends AbstractActorTest { commitCohort.commit().get(); } + @SuppressWarnings("serial") private static final class DelegatingShardCreator implements Creator { private final Creator delegate; - DelegatingShardCreator(Creator delegate) { + DelegatingShardCreator(final Creator delegate) { this.delegate = delegate; } diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/ShardTransactionFailureTest.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/ShardTransactionFailureTest.java index 45b00f5f31..5781c19b25 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/ShardTransactionFailureTest.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/ShardTransactionFailureTest.java @@ -10,6 +10,12 @@ package org.opendaylight.controller.cluster.datastore; +import akka.actor.ActorRef; +import akka.actor.Props; +import akka.pattern.AskTimeoutException; +import akka.testkit.TestActorRef; +import com.google.common.util.concurrent.ListeningExecutorService; +import com.google.common.util.concurrent.MoreExecutors; import java.util.Collections; import java.util.concurrent.TimeUnit; import org.junit.BeforeClass; @@ -29,12 +35,6 @@ import org.opendaylight.yangtools.yang.model.api.SchemaContext; import scala.concurrent.Await; import scala.concurrent.Future; import scala.concurrent.duration.Duration; -import akka.actor.ActorRef; -import akka.actor.Props; -import akka.pattern.AskTimeoutException; -import akka.testkit.TestActorRef; -import com.google.common.util.concurrent.ListeningExecutorService; -import com.google.common.util.concurrent.MoreExecutors; /** * Covers negative test cases @@ -66,7 +66,7 @@ public class ShardTransactionFailureTest extends AbstractActorTest { } private ActorRef createShard(){ - return getSystem().actorOf(Shard.props(SHARD_IDENTIFIER, Collections.EMPTY_MAP, datastoreContext, + return getSystem().actorOf(Shard.props(SHARD_IDENTIFIER, Collections.emptyMap(), datastoreContext, TestModel.createTestContext())); } diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/ShardTransactionTest.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/ShardTransactionTest.java index c869be82d2..4ccc9430ac 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/ShardTransactionTest.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/ShardTransactionTest.java @@ -4,6 +4,13 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; +import akka.actor.ActorRef; +import akka.actor.Props; +import akka.actor.Terminated; +import akka.testkit.JavaTestKit; +import akka.testkit.TestActorRef; +import com.google.common.util.concurrent.ListeningExecutorService; +import com.google.common.util.concurrent.MoreExecutors; import java.util.Collections; import java.util.concurrent.TimeUnit; import org.junit.BeforeClass; @@ -39,13 +46,6 @@ import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes; import org.opendaylight.yangtools.yang.model.api.SchemaContext; import scala.concurrent.duration.Duration; -import akka.actor.ActorRef; -import akka.actor.Props; -import akka.actor.Terminated; -import akka.testkit.JavaTestKit; -import akka.testkit.TestActorRef; -import com.google.common.util.concurrent.ListeningExecutorService; -import com.google.common.util.concurrent.MoreExecutors; public class ShardTransactionTest extends AbstractActorTest { private static ListeningExecutorService storeExecutor = @@ -71,7 +71,7 @@ public class ShardTransactionTest extends AbstractActorTest { private ActorRef createShard(){ return getSystem().actorOf(Shard.props(SHARD_IDENTIFIER, - Collections.EMPTY_MAP, datastoreContext, TestModel.createTestContext())); + Collections.emptyMap(), datastoreContext, TestModel.createTestContext())); } @Test diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/shardstrategy/DefaultShardStrategyTest.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/shardstrategy/DefaultShardStrategyTest.java index d3ba9b1c15..c065782af5 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/shardstrategy/DefaultShardStrategyTest.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/shardstrategy/DefaultShardStrategyTest.java @@ -1,6 +1,6 @@ package org.opendaylight.controller.cluster.datastore.shardstrategy; -import junit.framework.Assert; +import org.junit.Assert; import org.junit.Test; import org.opendaylight.controller.md.cluster.datastore.model.TestModel; diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/shardstrategy/ModuleShardStrategyTest.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/shardstrategy/ModuleShardStrategyTest.java index 3394cdc959..b895b75fcd 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/shardstrategy/ModuleShardStrategyTest.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/shardstrategy/ModuleShardStrategyTest.java @@ -1,5 +1,6 @@ package org.opendaylight.controller.cluster.datastore.shardstrategy; +import static org.junit.Assert.assertEquals; import org.junit.BeforeClass; import org.junit.Rule; import org.junit.Test; @@ -10,8 +11,6 @@ import org.opendaylight.controller.md.cluster.datastore.model.CarsModel; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; -import static junit.framework.Assert.assertEquals; - public class ModuleShardStrategyTest { @Rule public ExpectedException expectedEx = ExpectedException.none(); diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/shardstrategy/ShardStrategyFactoryTest.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/shardstrategy/ShardStrategyFactoryTest.java index ab74ba811a..10e832780d 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/shardstrategy/ShardStrategyFactoryTest.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/shardstrategy/ShardStrategyFactoryTest.java @@ -1,5 +1,7 @@ package org.opendaylight.controller.cluster.datastore.shardstrategy; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; import org.junit.BeforeClass; import org.junit.Rule; import org.junit.Test; @@ -9,9 +11,6 @@ import org.opendaylight.controller.md.cluster.datastore.model.CarsModel; import org.opendaylight.controller.md.cluster.datastore.model.TestModel; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; -import static junit.framework.Assert.assertNotNull; -import static junit.framework.Assert.assertTrue; - public class ShardStrategyFactoryTest { @Rule diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/utils/MockConfiguration.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/utils/MockConfiguration.java index 06c5767bd0..4ef7d65857 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/utils/MockConfiguration.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/utils/MockConfiguration.java @@ -9,43 +9,42 @@ package org.opendaylight.controller.cluster.datastore.utils; import com.google.common.base.Optional; -import org.opendaylight.controller.cluster.datastore.Configuration; -import org.opendaylight.controller.cluster.datastore.shardstrategy.ShardStrategy; - import java.util.Arrays; import java.util.Collections; import java.util.List; import java.util.Map; import java.util.Set; +import org.opendaylight.controller.cluster.datastore.Configuration; +import org.opendaylight.controller.cluster.datastore.shardstrategy.ShardStrategy; public class MockConfiguration implements Configuration{ - @Override public List getMemberShardNames(String memberName) { + @Override public List getMemberShardNames(final String memberName) { return Arrays.asList("default"); } @Override public Optional getModuleNameFromNameSpace( - String nameSpace) { + final String nameSpace) { return Optional.absent(); } @Override public Map getModuleNameToShardStrategyMap() { - return Collections.EMPTY_MAP; + return Collections.emptyMap(); } @Override public List getShardNamesFromModuleName( - String moduleName) { - return Collections.EMPTY_LIST; + final String moduleName) { + return Collections.emptyList(); } - @Override public List getMembersFromShardName(String shardName) { + @Override public List getMembersFromShardName(final String shardName) { if("default".equals(shardName)) { return Arrays.asList("member-1", "member-2"); } else if("astronauts".equals(shardName)){ return Arrays.asList("member-2", "member-3"); } - return Collections.EMPTY_LIST; + return Collections.emptyList(); } @Override public Set getAllShardNames() { diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/utils/MockDataChangeListener.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/utils/MockDataChangeListener.java index f2f49d1bf3..5bbdcae93c 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/utils/MockDataChangeListener.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/utils/MockDataChangeListener.java @@ -9,6 +9,10 @@ package org.opendaylight.controller.cluster.datastore.utils; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; +import com.google.common.collect.Lists; +import com.google.common.util.concurrent.Uninterruptibles; +import java.util.Collections; import java.util.List; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; @@ -16,8 +20,6 @@ import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent; import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeListener; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; -import com.google.common.collect.Lists; -import com.google.common.util.concurrent.Uninterruptibles; /** * A mock DataChangeListener implementation. @@ -27,14 +29,21 @@ import com.google.common.util.concurrent.Uninterruptibles; public class MockDataChangeListener implements AsyncDataChangeListener> { - private final List>> - changeList = Lists.newArrayList(); - private final CountDownLatch changeLatch; - private final int expChangeEventCount; + private final List>> changeList = + Collections.synchronizedList(Lists.>>newArrayList()); + + private volatile CountDownLatch changeLatch; + private int expChangeEventCount; public MockDataChangeListener(int expChangeEventCount) { + reset(expChangeEventCount); + } + + public void reset(int expChangeEventCount) { changeLatch = new CountDownLatch(expChangeEventCount); this.expChangeEventCount = expChangeEventCount; + changeList.clear(); } @Override @@ -44,8 +53,13 @@ public class MockDataChangeListener implements } public void waitForChangeEvents(YangInstanceIdentifier... expPaths) { - assertEquals("Change notifications complete", true, - Uninterruptibles.awaitUninterruptibly(changeLatch, 5, TimeUnit.SECONDS)); + boolean done = Uninterruptibles.awaitUninterruptibly(changeLatch, 5, TimeUnit.SECONDS); + if(!done) { + fail(String.format("Missing change notifications. Expected: %d. Actual: %d", + expChangeEventCount, (expChangeEventCount - changeLatch.getCount()))); + } + + assertEquals("Change notifications complete", true, done); for(int i = 0; i < expPaths.length; i++) { assertTrue(String.format("Change %d does not contain %s", (i+1), expPaths[i]), diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/utils/TestUtils.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/utils/TestUtils.java index 3bad468950..a2c44b0630 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/utils/TestUtils.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/utils/TestUtils.java @@ -11,13 +11,12 @@ package org.opendaylight.controller.cluster.datastore.utils; import akka.actor.ActorRef; import akka.actor.ActorSystem; import akka.actor.Props; -import junit.framework.Assert; - import java.util.List; +import org.junit.Assert; public class TestUtils { - public static void assertFirstSentMessage(ActorSystem actorSystem, ActorRef actorRef, Class clazz){ + public static void assertFirstSentMessage(final ActorSystem actorSystem, final ActorRef actorRef, final Class clazz){ ActorContext testContext = new ActorContext(actorSystem, actorSystem.actorOf( Props.create(DoNothingActor.class)), new MockClusterWrapper(), new MockConfiguration()); Object messages = testContext @@ -27,7 +26,7 @@ public class TestUtils { Assert.assertTrue(messages instanceof List); - List listMessages = (List) messages; + List listMessages = (List) messages; Assert.assertEquals(1, listMessages.size()); diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/md/cluster/datastore/model/CarsModel.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/md/cluster/datastore/model/CarsModel.java index 6860872b75..93b552a6da 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/md/cluster/datastore/model/CarsModel.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/md/cluster/datastore/model/CarsModel.java @@ -31,7 +31,7 @@ public class CarsModel { public static final QName CAR_PRICE_QNAME = QName.create(CAR_QNAME, "price"); - public static NormalizedNode create(){ + public static NormalizedNode create(){ // Create a list builder CollectionNodeBuilder cars = @@ -63,7 +63,7 @@ public class CarsModel { } - public static NormalizedNode emptyContainer(){ + public static NormalizedNode emptyContainer(){ return ImmutableContainerNodeBuilder.create() .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(BASE_QNAME)) .build(); diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/md/cluster/datastore/model/PeopleModel.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/md/cluster/datastore/model/PeopleModel.java index e637920e78..a7cb14f0b3 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/md/cluster/datastore/model/PeopleModel.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/md/cluster/datastore/model/PeopleModel.java @@ -30,7 +30,7 @@ public class PeopleModel { - public static NormalizedNode create(){ + public static NormalizedNode create(){ // Create a list builder CollectionNodeBuilder cars = @@ -62,7 +62,7 @@ public class PeopleModel { } - public static NormalizedNode emptyContainer(){ + public static NormalizedNode emptyContainer(){ return ImmutableContainerNodeBuilder.create() .withNodeIdentifier( new YangInstanceIdentifier.NodeIdentifier(BASE_QNAME)) diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/md/cluster/datastore/model/SampleModelsTest.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/md/cluster/datastore/model/SampleModelsTest.java index 2300f9d130..b814bc392e 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/md/cluster/datastore/model/SampleModelsTest.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/md/cluster/datastore/model/SampleModelsTest.java @@ -8,7 +8,7 @@ package org.opendaylight.controller.md.cluster.datastore.model; -import junit.framework.Assert; +import org.junit.Assert; import org.junit.Test; import org.opendaylight.controller.cluster.datastore.node.NormalizedNodeToNodeCodec; import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages; diff --git a/opendaylight/md-sal/sal-dom-api/src/main/java/org/opendaylight/controller/md/sal/dom/api/DOMDataBroker.java b/opendaylight/md-sal/sal-dom-api/src/main/java/org/opendaylight/controller/md/sal/dom/api/DOMDataBroker.java index fdb864059f..4632ed8a6f 100644 --- a/opendaylight/md-sal/sal-dom-api/src/main/java/org/opendaylight/controller/md/sal/dom/api/DOMDataBroker.java +++ b/opendaylight/md-sal/sal-dom-api/src/main/java/org/opendaylight/controller/md/sal/dom/api/DOMDataBroker.java @@ -14,7 +14,7 @@ import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; /** - * Data Broker which provides data transaction and data change listener fuctionality + * Data Broker which provides data transaction and data change listener functionality * using {@link NormalizedNode} data format. * * This interface is type capture of generic interfaces and returns type captures diff --git a/opendaylight/md-sal/sal-dom-broker/src/test/java/org/opendaylight/controller/sal/dom/broker/BackwardsCompatibleMountPointManagerTest.java b/opendaylight/md-sal/sal-dom-broker/src/test/java/org/opendaylight/controller/sal/dom/broker/BackwardsCompatibleMountPointManagerTest.java index 05c4793218..e876ccb306 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/test/java/org/opendaylight/controller/sal/dom/broker/BackwardsCompatibleMountPointManagerTest.java +++ b/opendaylight/md-sal/sal-dom-broker/src/test/java/org/opendaylight/controller/sal/dom/broker/BackwardsCompatibleMountPointManagerTest.java @@ -8,14 +8,14 @@ package org.opendaylight.controller.sal.dom.broker; -import static junit.framework.Assert.fail; +import static org.junit.Assert.fail; import static org.mockito.Matchers.any; import static org.mockito.Mockito.doAnswer; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; - +import com.google.common.base.Optional; import org.junit.Before; import org.junit.Test; import org.mockito.Mock; @@ -36,8 +36,6 @@ import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import com.google.common.base.Optional; - public class BackwardsCompatibleMountPointManagerTest { private static final Logger log = LoggerFactory.getLogger(BackwardsCompatibleMountPointManagerTest.class); @@ -106,7 +104,7 @@ public class BackwardsCompatibleMountPointManagerTest { private DOMMountPoint mockMountPoint() { final DOMMountPoint mock = mock(DOMMountPoint.class); - doAnswer(new Answer() { + doAnswer(new Answer() { @Override public Object answer(final InvocationOnMock invocation) throws Throwable { return Optional.of(mock(((Class) invocation.getArguments()[0]))); diff --git a/opendaylight/md-sal/sal-dom-broker/src/test/java/org/opendaylight/controller/sal/dom/broker/BackwardsCompatibleMountPointTest.java b/opendaylight/md-sal/sal-dom-broker/src/test/java/org/opendaylight/controller/sal/dom/broker/BackwardsCompatibleMountPointTest.java index 91ae0c24dd..cb1a99b4c0 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/test/java/org/opendaylight/controller/sal/dom/broker/BackwardsCompatibleMountPointTest.java +++ b/opendaylight/md-sal/sal-dom-broker/src/test/java/org/opendaylight/controller/sal/dom/broker/BackwardsCompatibleMountPointTest.java @@ -8,15 +8,14 @@ package org.opendaylight.controller.sal.dom.broker; -import static junit.framework.Assert.fail; import static org.junit.Assert.assertEquals; +import static org.junit.Assert.fail; import static org.mockito.Matchers.any; import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; - import com.google.common.base.Optional; import com.google.common.util.concurrent.ListenableFuture; import java.util.AbstractMap; @@ -38,6 +37,7 @@ import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +@Deprecated public class BackwardsCompatibleMountPointTest { private static final Logger log = LoggerFactory.getLogger(BackwardsCompatibleMountPointManagerTest.class); @@ -147,7 +147,7 @@ public class BackwardsCompatibleMountPointTest { } private NormalizedNode mockNormalizedNode() { - final NormalizedNode mock = mock(NormalizedNode.class); + final NormalizedNode mock = mock(NormalizedNode.class); doReturn("mockNormalizedNode").when(mock).toString(); return mock; } diff --git a/opendaylight/md-sal/sal-dom-spi/src/main/java/org/opendaylight/controller/md/sal/dom/spi/ForwardingDOMDataBroker.java b/opendaylight/md-sal/sal-dom-spi/src/main/java/org/opendaylight/controller/md/sal/dom/spi/ForwardingDOMDataBroker.java new file mode 100644 index 0000000000..e42cf10f7e --- /dev/null +++ b/opendaylight/md-sal/sal-dom-spi/src/main/java/org/opendaylight/controller/md/sal/dom/spi/ForwardingDOMDataBroker.java @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2014 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.md.sal.dom.spi; + +import com.google.common.collect.ForwardingObject; +import javax.annotation.Nonnull; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener; +import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker; +import org.opendaylight.controller.md.sal.dom.api.DOMDataChangeListener; +import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction; +import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction; +import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction; +import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain; +import org.opendaylight.yangtools.concepts.ListenerRegistration; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; + +/** + * Utility {@link DOMDataBroker} implementation which forwards all interface + * method invocation to a delegate instance. + */ +public abstract class ForwardingDOMDataBroker extends ForwardingObject implements DOMDataBroker { + @Override + protected abstract @Nonnull DOMDataBroker delegate(); + + @Override + public ListenerRegistration registerDataChangeListener(final LogicalDatastoreType store, + final YangInstanceIdentifier path, final DOMDataChangeListener listener, + final DataChangeScope triggeringScope) { + return delegate().registerDataChangeListener(store, path, listener, triggeringScope); + } + + @Override + public DOMDataReadOnlyTransaction newReadOnlyTransaction() { + return delegate().newReadOnlyTransaction(); + } + + @Override + public DOMDataReadWriteTransaction newReadWriteTransaction() { + return delegate().newReadWriteTransaction(); + } + + @Override + public DOMDataWriteTransaction newWriteOnlyTransaction() { + return delegate().newWriteOnlyTransaction(); + } + + @Override + public DOMTransactionChain createTransactionChain(final TransactionChainListener listener) { + return delegate().createTransactionChain(listener); + } +} diff --git a/opendaylight/md-sal/sal-dom-spi/src/main/java/org/opendaylight/controller/md/sal/dom/spi/ForwardingDOMDataReadOnlyTransaction.java b/opendaylight/md-sal/sal-dom-spi/src/main/java/org/opendaylight/controller/md/sal/dom/spi/ForwardingDOMDataReadOnlyTransaction.java new file mode 100644 index 0000000000..dcec6c3fab --- /dev/null +++ b/opendaylight/md-sal/sal-dom-spi/src/main/java/org/opendaylight/controller/md/sal/dom/spi/ForwardingDOMDataReadOnlyTransaction.java @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2014 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.md.sal.dom.spi; + +import com.google.common.base.Optional; +import com.google.common.collect.ForwardingObject; +import com.google.common.util.concurrent.CheckedFuture; +import javax.annotation.Nonnull; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException; +import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; + +/** + * Utility {@link DOMDataReadOnlyTransaction} implementation which forwards all interface + * method invocation to a delegate instance. + */ +public abstract class ForwardingDOMDataReadOnlyTransaction extends ForwardingObject implements DOMDataReadOnlyTransaction { + @Override + protected abstract @Nonnull DOMDataReadOnlyTransaction delegate(); + + @Override + public CheckedFuture>, ReadFailedException> read(final LogicalDatastoreType store, final YangInstanceIdentifier path) { + return delegate().read(store, path); + } + + @Override + public CheckedFuture exists(final LogicalDatastoreType store, final YangInstanceIdentifier path) { + return delegate().exists(store, path); + } + + @Override + public Object getIdentifier() { + return delegate().getIdentifier(); + } + + @Override + public void close() { + delegate().close(); + } +} diff --git a/opendaylight/md-sal/sal-dom-spi/src/main/java/org/opendaylight/controller/md/sal/dom/spi/ForwardingDOMDataReadWriteTransaction.java b/opendaylight/md-sal/sal-dom-spi/src/main/java/org/opendaylight/controller/md/sal/dom/spi/ForwardingDOMDataReadWriteTransaction.java new file mode 100644 index 0000000000..923bef76f3 --- /dev/null +++ b/opendaylight/md-sal/sal-dom-spi/src/main/java/org/opendaylight/controller/md/sal/dom/spi/ForwardingDOMDataReadWriteTransaction.java @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2014 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.md.sal.dom.spi; + +import com.google.common.base.Optional; +import com.google.common.collect.ForwardingObject; +import com.google.common.util.concurrent.CheckedFuture; +import com.google.common.util.concurrent.ListenableFuture; +import javax.annotation.Nonnull; +import org.opendaylight.controller.md.sal.common.api.TransactionStatus; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException; +import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException; +import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction; +import org.opendaylight.yangtools.yang.common.RpcResult; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; + +/** + * Utility {@link DOMDataReadWriteTransaction} implementation which forwards all interface + * method invocation to a delegate instance. + */ +public abstract class ForwardingDOMDataReadWriteTransaction extends ForwardingObject implements DOMDataReadWriteTransaction { + @Override + protected abstract @Nonnull DOMDataReadWriteTransaction delegate(); + + @Override + public CheckedFuture>, ReadFailedException> read(final LogicalDatastoreType store, final YangInstanceIdentifier path) { + return delegate().read(store, path); + } + + @Override + public CheckedFuture exists(final LogicalDatastoreType store, final YangInstanceIdentifier path) { + return delegate().exists(store, path); + } + + @Override + public Object getIdentifier() { + return delegate().getIdentifier(); + } + + @Override + public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode data) { + delegate().put(store, path, data); + } + + @Override + public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode data) { + delegate().merge(store, path, data); + } + + @Override + public boolean cancel() { + return delegate().cancel(); + } + + @Override + public void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path) { + delegate().delete(store, path); + } + + @Override + public CheckedFuture submit() { + return delegate().submit(); + } + + @Override + @Deprecated + public ListenableFuture> commit() { + return delegate().commit(); + } +} diff --git a/opendaylight/md-sal/sal-dom-spi/src/main/java/org/opendaylight/controller/md/sal/dom/spi/ForwardingDOMDataWriteTransaction.java b/opendaylight/md-sal/sal-dom-spi/src/main/java/org/opendaylight/controller/md/sal/dom/spi/ForwardingDOMDataWriteTransaction.java new file mode 100644 index 0000000000..2afb4786ce --- /dev/null +++ b/opendaylight/md-sal/sal-dom-spi/src/main/java/org/opendaylight/controller/md/sal/dom/spi/ForwardingDOMDataWriteTransaction.java @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2014 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.md.sal.dom.spi; + +import com.google.common.collect.ForwardingObject; +import com.google.common.util.concurrent.CheckedFuture; +import com.google.common.util.concurrent.ListenableFuture; +import javax.annotation.Nonnull; +import org.opendaylight.controller.md.sal.common.api.TransactionStatus; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException; +import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction; +import org.opendaylight.yangtools.yang.common.RpcResult; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; + +/** + * Utility {@link DOMDataWriteTransaction} implementation which forwards all interface + * method invocation to a delegate instance. + */ +public abstract class ForwardingDOMDataWriteTransaction extends ForwardingObject implements DOMDataWriteTransaction { + @Override + protected abstract @Nonnull DOMDataWriteTransaction delegate(); + + @Override + public Object getIdentifier() { + return delegate().getIdentifier(); + } + + @Override + public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode data) { + delegate().put(store, path, data); + } + + @Override + public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode data) { + delegate().merge(store, path, data); + } + + @Override + public boolean cancel() { + return delegate().cancel(); + } + + @Override + public void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path) { + delegate().delete(store, path); + } + + @Override + public CheckedFuture submit() { + return delegate().submit(); + } + + @Override + @Deprecated + public ListenableFuture> commit() { + return delegate().commit(); + } +} diff --git a/opendaylight/md-sal/sal-dom-spi/src/main/java/org/opendaylight/controller/md/sal/dom/spi/ForwardingDOMTransactionChain.java b/opendaylight/md-sal/sal-dom-spi/src/main/java/org/opendaylight/controller/md/sal/dom/spi/ForwardingDOMTransactionChain.java new file mode 100644 index 0000000000..e709e6713a --- /dev/null +++ b/opendaylight/md-sal/sal-dom-spi/src/main/java/org/opendaylight/controller/md/sal/dom/spi/ForwardingDOMTransactionChain.java @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2014 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.md.sal.dom.spi; + +import com.google.common.collect.ForwardingObject; +import javax.annotation.Nonnull; +import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction; +import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction; +import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction; +import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain; + +/** + * Utility {@link DOMTransactionChain} implementation which forwards all interface + * method invocation to a delegate instance. + */ +public abstract class ForwardingDOMTransactionChain extends ForwardingObject implements DOMTransactionChain { + @Override + protected abstract @Nonnull DOMTransactionChain delegate(); + + @Override + public void close() { + delegate().close(); + } + + @Override + public DOMDataReadOnlyTransaction newReadOnlyTransaction() { + return delegate().newReadOnlyTransaction(); + } + + @Override + public DOMDataReadWriteTransaction newReadWriteTransaction() { + return delegate().newReadWriteTransaction(); + } + + @Override + public DOMDataWriteTransaction newWriteOnlyTransaction() { + return delegate().newWriteOnlyTransaction(); + } +} diff --git a/opendaylight/md-sal/sal-dom-xsql-config/pom.xml b/opendaylight/md-sal/sal-dom-xsql-config/pom.xml index e8919d0ee1..d2d864cd4f 100644 --- a/opendaylight/md-sal/sal-dom-xsql-config/pom.xml +++ b/opendaylight/md-sal/sal-dom-xsql-config/pom.xml @@ -15,7 +15,6 @@ 1.2.0-SNAPSHOT sal-dom-xsql-config - org.opendaylight.controller Configuration files for md-sal jar diff --git a/opendaylight/md-sal/sal-dom-xsql/pom.xml b/opendaylight/md-sal/sal-dom-xsql/pom.xml index f5898a2bb9..c7fd20248d 100644 --- a/opendaylight/md-sal/sal-dom-xsql/pom.xml +++ b/opendaylight/md-sal/sal-dom-xsql/pom.xml @@ -35,7 +35,6 @@ org.opendaylight.controller yang-jmx-generator-plugin - ${config.version} org.opendaylight.yangtools diff --git a/opendaylight/md-sal/sal-netconf-connector/src/main/java/org/opendaylight/controller/sal/connect/netconf/util/NetconfMessageTransformUtil.java b/opendaylight/md-sal/sal-netconf-connector/src/main/java/org/opendaylight/controller/sal/connect/netconf/util/NetconfMessageTransformUtil.java index 893a45aaa2..2e5f8078a3 100644 --- a/opendaylight/md-sal/sal-netconf-connector/src/main/java/org/opendaylight/controller/sal/connect/netconf/util/NetconfMessageTransformUtil.java +++ b/opendaylight/md-sal/sal-netconf-connector/src/main/java/org/opendaylight/controller/sal/connect/netconf/util/NetconfMessageTransformUtil.java @@ -43,6 +43,7 @@ import org.opendaylight.yangtools.yang.data.impl.SimpleNodeTOImpl; import org.opendaylight.yangtools.yang.data.impl.util.CompositeNodeBuilder; import org.opendaylight.yangtools.yang.model.api.DataNodeContainer; import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; +import org.opendaylight.yangtools.yang.model.api.RpcDefinition; import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.w3c.dom.Document; import org.w3c.dom.Element; @@ -344,9 +345,14 @@ public class NetconfMessageTransformUtil { Preconditions.checkNotNull(rpcName); Preconditions.checkNotNull(schemaContext); - final NodeContainerProxy rpcBodyProxy = new NodeContainerProxy(rpcName, schemaContext.getChildNodes()); - return new NodeContainerProxy(NETCONF_RPC_QNAME, Sets.newHashSet(rpcBodyProxy)); + for (final RpcDefinition rpcDefinition : schemaContext.getOperations()) { + if(rpcDefinition.getQName().equals(rpcName)) { + final NodeContainerProxy rpcBodyProxy = new NodeContainerProxy(rpcName, rpcDefinition.getInput().getChildNodes()); + return new NodeContainerProxy(NETCONF_RPC_QNAME, Sets.newHashSet(rpcBodyProxy)); + } + } + throw new IllegalArgumentException("Rpc " + rpcName + " not found in schema context " + schemaContext + ". Unable to invoke Rpc"); } public static CompositeNodeTOImpl wrap(final QName name, final Node node) { diff --git a/opendaylight/md-sal/sal-netconf-connector/src/test/java/org/opendaylight/controller/sal/connect/netconf/NetconfDeviceTest.java b/opendaylight/md-sal/sal-netconf-connector/src/test/java/org/opendaylight/controller/sal/connect/netconf/NetconfDeviceTest.java index 218ec0be8d..cbddac2caf 100644 --- a/opendaylight/md-sal/sal-netconf-connector/src/test/java/org/opendaylight/controller/sal/connect/netconf/NetconfDeviceTest.java +++ b/opendaylight/md-sal/sal-netconf-connector/src/test/java/org/opendaylight/controller/sal/connect/netconf/NetconfDeviceTest.java @@ -17,7 +17,6 @@ import static org.mockito.Mockito.mock; import static org.mockito.Mockito.timeout; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; - import com.google.common.base.Optional; import com.google.common.collect.HashMultimap; import com.google.common.collect.Lists; @@ -134,7 +133,7 @@ public class NetconfDeviceTest { // Make fallback attempt to fail due to empty resolved sources final MissingSchemaSourceException schemaResolutionException = new MissingSchemaSourceException("fail first", TEST_SID); - doAnswer(new Answer() { + doAnswer(new Answer() { @Override public Object answer(final InvocationOnMock invocation) throws Throwable { if(((Collection) invocation.getArguments()[0]).size() == 2) { @@ -158,7 +157,7 @@ public class NetconfDeviceTest { private SchemaSourceRegistry getSchemaRegistry() { final SchemaSourceRegistry mock = mock(SchemaSourceRegistry.class); - final SchemaSourceRegistration mockReg = mock(SchemaSourceRegistration.class); + final SchemaSourceRegistration mockReg = mock(SchemaSourceRegistration.class); doNothing().when(mockReg).close(); doReturn(mockReg).when(mock).registerSchemaSource(any(org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceProvider.class), any(PotentialSchemaSource.class)); return mock; diff --git a/opendaylight/md-sal/sal-netconf-connector/src/test/java/org/opendaylight/controller/sal/connect/netconf/NetconfStateSchemasTest.java b/opendaylight/md-sal/sal-netconf-connector/src/test/java/org/opendaylight/controller/sal/connect/netconf/NetconfStateSchemasTest.java index 3f9c8caa0e..ccae5d4be8 100644 --- a/opendaylight/md-sal/sal-netconf-connector/src/test/java/org/opendaylight/controller/sal/connect/netconf/NetconfStateSchemasTest.java +++ b/opendaylight/md-sal/sal-netconf-connector/src/test/java/org/opendaylight/controller/sal/connect/netconf/NetconfStateSchemasTest.java @@ -2,7 +2,7 @@ package org.opendaylight.controller.sal.connect.netconf; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertThat; -import static org.junit.matchers.JUnitMatchers.hasItem; +import static org.hamcrest.CoreMatchers.hasItem; import java.util.Set; import org.junit.Test; diff --git a/opendaylight/md-sal/sal-netconf-connector/src/test/java/org/opendaylight/controller/sal/connect/netconf/NetconfToNotificationTest.java b/opendaylight/md-sal/sal-netconf-connector/src/test/java/org/opendaylight/controller/sal/connect/netconf/NetconfToNotificationTest.java index 127b0cbfcd..5d19188b12 100644 --- a/opendaylight/md-sal/sal-netconf-connector/src/test/java/org/opendaylight/controller/sal/connect/netconf/NetconfToNotificationTest.java +++ b/opendaylight/md-sal/sal-netconf-connector/src/test/java/org/opendaylight/controller/sal/connect/netconf/NetconfToNotificationTest.java @@ -1,14 +1,12 @@ package org.opendaylight.controller.sal.connect.netconf; -import static junit.framework.Assert.assertEquals; -import static junit.framework.Assert.assertNotNull; -import static junit.framework.Assert.assertTrue; - +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; import java.io.InputStream; import java.util.Collections; import java.util.List; import java.util.Set; - import javax.xml.parsers.DocumentBuilderFactory; import org.junit.Before; import org.junit.Test; diff --git a/opendaylight/md-sal/sal-netconf-connector/src/test/java/org/opendaylight/controller/sal/connect/netconf/NetconfToRpcRequestTest.java b/opendaylight/md-sal/sal-netconf-connector/src/test/java/org/opendaylight/controller/sal/connect/netconf/NetconfToRpcRequestTest.java index e744e11bc9..bbb5038caf 100644 --- a/opendaylight/md-sal/sal-netconf-connector/src/test/java/org/opendaylight/controller/sal/connect/netconf/NetconfToRpcRequestTest.java +++ b/opendaylight/md-sal/sal-netconf-connector/src/test/java/org/opendaylight/controller/sal/connect/netconf/NetconfToRpcRequestTest.java @@ -1,8 +1,8 @@ package org.opendaylight.controller.sal.connect.netconf; -import static junit.framework.Assert.assertEquals; -import static junit.framework.Assert.assertNotNull; -import static junit.framework.Assert.assertTrue; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; import java.io.InputStream; import java.util.Collections; @@ -253,37 +253,4 @@ public class NetconfToRpcRequestTest { assertEquals(streamName.getLocalName(), "stream-name"); } - @Test - public void testNoSchemaContextToRpcRequest() throws Exception { - final String exampleNamespace = "http://example.net/me/my-own/1.0"; - final String exampleRevision = "2014-07-22"; - final QName myOwnMethodRpcQName = QName.create(exampleNamespace, exampleRevision, "my-own-method"); - - final CompositeNodeBuilder rootBuilder = ImmutableCompositeNode.builder(); - rootBuilder.setQName(myOwnMethodRpcQName); - - final CompositeNodeBuilder inputBuilder = ImmutableCompositeNode.builder(); - inputBuilder.setQName(QName.create(exampleNamespace, exampleRevision, "input")); - inputBuilder.addLeaf(QName.create(exampleNamespace, exampleRevision, "my-first-parameter"), "14"); - inputBuilder.addLeaf(QName.create(exampleNamespace, exampleRevision, "another-parameter"), "fred"); - - rootBuilder.add(inputBuilder.toInstance()); - final ImmutableCompositeNode root = rootBuilder.toInstance(); - - final NetconfMessage message = messageTransformer.toRpcRequest(myOwnMethodRpcQName, root); - assertNotNull(message); - - final Document xmlDoc = message.getDocument(); - final org.w3c.dom.Node rpcChild = xmlDoc.getFirstChild(); - assertEquals(rpcChild.getLocalName(), "rpc"); - - final org.w3c.dom.Node myOwnMethodNode = rpcChild.getFirstChild(); - assertEquals(myOwnMethodNode.getLocalName(), "my-own-method"); - - final org.w3c.dom.Node firstParamNode = myOwnMethodNode.getFirstChild(); - assertEquals(firstParamNode.getLocalName(), "my-first-parameter"); - - final org.w3c.dom.Node secParamNode = firstParamNode.getNextSibling(); - assertEquals(secParamNode.getLocalName(), "another-parameter"); - } } diff --git a/opendaylight/md-sal/sal-netconf-connector/src/test/java/org/opendaylight/controller/sal/connect/netconf/listener/NetconfSessionCapabilitiesTest.java b/opendaylight/md-sal/sal-netconf-connector/src/test/java/org/opendaylight/controller/sal/connect/netconf/listener/NetconfSessionCapabilitiesTest.java index 80bb08f5af..ae7d9c28ac 100644 --- a/opendaylight/md-sal/sal-netconf-connector/src/test/java/org/opendaylight/controller/sal/connect/netconf/listener/NetconfSessionCapabilitiesTest.java +++ b/opendaylight/md-sal/sal-netconf-connector/src/test/java/org/opendaylight/controller/sal/connect/netconf/listener/NetconfSessionCapabilitiesTest.java @@ -1,12 +1,12 @@ package org.opendaylight.controller.sal.connect.netconf.listener; +import static org.hamcrest.CoreMatchers.hasItem; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertThat; import com.google.common.collect.Lists; import java.util.List; import org.junit.Test; -import org.junit.matchers.JUnitMatchers; import org.opendaylight.controller.sal.connect.netconf.util.NetconfMessageTransformUtil; import org.opendaylight.yangtools.yang.common.QName; @@ -35,12 +35,12 @@ public class NetconfSessionCapabilitiesTest { final NetconfSessionCapabilities merged = sessionCaps1.replaceModuleCaps(sessionCaps2); assertCaps(merged, 2, 2 + 1 /*Preserved monitoring*/); for (final QName qName : sessionCaps2.getModuleBasedCaps()) { - assertThat(merged.getModuleBasedCaps(), JUnitMatchers.hasItem(qName)); + assertThat(merged.getModuleBasedCaps(), hasItem(qName)); } - assertThat(merged.getModuleBasedCaps(), JUnitMatchers.hasItem(NetconfMessageTransformUtil.IETF_NETCONF_MONITORING)); + assertThat(merged.getModuleBasedCaps(), hasItem(NetconfMessageTransformUtil.IETF_NETCONF_MONITORING)); - assertThat(merged.getNonModuleCaps(), JUnitMatchers.hasItem("urn:ietf:params:netconf:base:1.0")); - assertThat(merged.getNonModuleCaps(), JUnitMatchers.hasItem("urn:ietf:params:netconf:capability:rollback-on-error:1.0")); + assertThat(merged.getNonModuleCaps(), hasItem("urn:ietf:params:netconf:base:1.0")); + assertThat(merged.getNonModuleCaps(), hasItem("urn:ietf:params:netconf:capability:rollback-on-error:1.0")); } @Test diff --git a/opendaylight/md-sal/sal-netconf-connector/src/test/java/org/opendaylight/controller/sal/connect/netconf/sal/tx/NetconfDeviceWriteOnlyTxTest.java b/opendaylight/md-sal/sal-netconf-connector/src/test/java/org/opendaylight/controller/sal/connect/netconf/sal/tx/NetconfDeviceWriteOnlyTxTest.java index a65e426d59..0607e4b6da 100644 --- a/opendaylight/md-sal/sal-netconf-connector/src/test/java/org/opendaylight/controller/sal/connect/netconf/sal/tx/NetconfDeviceWriteOnlyTxTest.java +++ b/opendaylight/md-sal/sal-netconf-connector/src/test/java/org/opendaylight/controller/sal/connect/netconf/sal/tx/NetconfDeviceWriteOnlyTxTest.java @@ -1,6 +1,6 @@ package org.opendaylight.controller.sal.connect.netconf.sal.tx; -import static junit.framework.Assert.fail; +import static org.junit.Assert.fail; import static org.mockito.Matchers.any; import static org.mockito.Matchers.eq; import static org.mockito.Mockito.doReturn; diff --git a/opendaylight/md-sal/sal-remoterpc-connector/src/test/java/org/opendaylight/controller/remote/rpc/utils/LatestEntryRoutingLogicTest.java b/opendaylight/md-sal/sal-remoterpc-connector/src/test/java/org/opendaylight/controller/remote/rpc/utils/LatestEntryRoutingLogicTest.java index cd031a1d0a..f74bfc3cff 100644 --- a/opendaylight/md-sal/sal-remoterpc-connector/src/test/java/org/opendaylight/controller/remote/rpc/utils/LatestEntryRoutingLogicTest.java +++ b/opendaylight/md-sal/sal-remoterpc-connector/src/test/java/org/opendaylight/controller/remote/rpc/utils/LatestEntryRoutingLogicTest.java @@ -8,14 +8,13 @@ package org.opendaylight.controller.remote.rpc.utils; - +import static org.junit.Assert.assertTrue; import akka.actor.ActorRef; import akka.actor.ActorSystem; import akka.japi.Pair; import akka.testkit.JavaTestKit; import akka.testkit.TestProbe; import com.typesafe.config.ConfigFactory; -import junit.framework.Assert; import org.junit.AfterClass; import org.junit.BeforeClass; import org.junit.Test; @@ -23,7 +22,6 @@ import org.junit.Test; import java.util.ArrayList; import java.util.List; - public class LatestEntryRoutingLogicTest { static ActorSystem system; @@ -52,6 +50,6 @@ public class LatestEntryRoutingLogicTest { pairList.add(new Pair(actor2, 3000L)); pairList.add(new Pair(actor3, 2000L)); RoutingLogic logic = new LatestEntryRoutingLogic(pairList); - Assert.assertTrue(logic.select().equals(actor2)); + assertTrue(logic.select().equals(actor2)); } } diff --git a/opendaylight/md-sal/sal-rest-docgen/src/test/java/org/opendaylight/controller/sal/rest/doc/impl/ApiDocGeneratorTest.java b/opendaylight/md-sal/sal-rest-docgen/src/test/java/org/opendaylight/controller/sal/rest/doc/impl/ApiDocGeneratorTest.java index 9165281f9d..02c5137fe9 100644 --- a/opendaylight/md-sal/sal-rest-docgen/src/test/java/org/opendaylight/controller/sal/rest/doc/impl/ApiDocGeneratorTest.java +++ b/opendaylight/md-sal/sal-rest-docgen/src/test/java/org/opendaylight/controller/sal/rest/doc/impl/ApiDocGeneratorTest.java @@ -14,7 +14,6 @@ import java.util.Map.Entry; import java.util.Set; import java.util.TreeSet; import javax.ws.rs.core.UriInfo; -import junit.framework.Assert; import org.json.JSONException; import org.json.JSONObject; import org.junit.After; @@ -205,7 +204,7 @@ public class ApiDocGeneratorTest { if (m.getKey().getAbsolutePath().endsWith("toaster.yang")) { ApiDeclaration doc = generator.getSwaggerDocSpec(m.getValue(), "http://localhost:8080/restconf", "", schemaContext); - Assert.assertNotNull(doc); + assertNotNull(doc); // testing bugs.opendaylight.org bug 1290. UnionType model type. String jsonString = doc.getModels().toString(); diff --git a/opendaylight/netconf/config-netconf-connector/pom.xml b/opendaylight/netconf/config-netconf-connector/pom.xml index edba4e11da..2b3015243f 100644 --- a/opendaylight/netconf/config-netconf-connector/pom.xml +++ b/opendaylight/netconf/config-netconf-connector/pom.xml @@ -106,32 +106,7 @@ org.opendaylight.controller.netconf.confignetconfconnector.util, org.opendaylight.controller.netconf.confignetconfconnector.osgi, org.opendaylight.controller.netconf.confignetconfconnector.exception, - com.google.common.base, - com.google.common.collect, - javax.annotation, - javax.management, - javax.management.openmbean, - org.opendaylight.controller.config.api, - org.opendaylight.controller.config.api.jmx, - org.opendaylight.controller.config.yangjmxgenerator, - org.opendaylight.controller.config.yangjmxgenerator.attribute, - org.opendaylight.controller.netconf.api, - org.opendaylight.controller.netconf.mapping.api, - org.opendaylight.controller.netconf.util.mapping, - org.opendaylight.controller.netconf.util.xml, - org.opendaylight.controller.netconf.util.exception, - org.opendaylight.yangtools.yang.common, - org.opendaylight.yangtools.yang.model.api, - org.osgi.framework, - org.osgi.util.tracker, - org.slf4j, - org.w3c.dom, - com.google.common.io, - org.opendaylight.yangtools.yang.model.api.type, - org.opendaylight.yangtools.sal.binding.generator.spi, - org.opendaylight.yangtools.sal.binding.yang.types, - org.opendaylight.controller.config.util - + * diff --git a/opendaylight/netconf/config-netconf-connector/src/main/java/org/opendaylight/controller/netconf/confignetconfconnector/operations/runtimerpc/RuntimeRpcElementResolved.java b/opendaylight/netconf/config-netconf-connector/src/main/java/org/opendaylight/controller/netconf/confignetconfconnector/operations/runtimerpc/RuntimeRpcElementResolved.java index 7fd8928928..551da722c0 100644 --- a/opendaylight/netconf/config-netconf-connector/src/main/java/org/opendaylight/controller/netconf/confignetconfconnector/operations/runtimerpc/RuntimeRpcElementResolved.java +++ b/opendaylight/netconf/config-netconf-connector/src/main/java/org/opendaylight/controller/netconf/confignetconfconnector/operations/runtimerpc/RuntimeRpcElementResolved.java @@ -8,20 +8,23 @@ package org.opendaylight.controller.netconf.confignetconfconnector.operations.runtimerpc; -import com.google.common.base.Preconditions; -import com.google.common.base.Strings; -import com.google.common.collect.Maps; +import java.util.HashMap; +import java.util.Map; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import javax.management.ObjectName; import org.opendaylight.controller.config.api.jmx.ObjectNameUtil; import org.opendaylight.controller.netconf.api.xml.XmlNetconfConstants; import org.opendaylight.controller.netconf.confignetconfconnector.mapping.rpc.ModuleRpcs; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.rev130405.Modules; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.rev130405.modules.Module; -import javax.management.ObjectName; - -import java.util.HashMap; -import java.util.Map; -import java.util.regex.Matcher; -import java.util.regex.Pattern; +import com.google.common.annotations.VisibleForTesting; +import com.google.common.base.Preconditions; +import com.google.common.base.Strings; +import com.google.common.collect.Maps; /** * Represents parsed xpath to runtime bean instance @@ -46,6 +49,11 @@ public final class RuntimeRpcElementResolved { return moduleName; } + @VisibleForTesting + Map getAdditionalAttributes() { + return additionalAttributes; + } + public String getInstanceName() { return instanceName; } @@ -70,22 +78,45 @@ public final class RuntimeRpcElementResolved { return ObjectNameUtil.createRuntimeBeanName(moduleName, instanceName, additionalAttributesJavaNames); } + /** + * Pattern for an absolute instance identifier xpath pointing to a runtime bean instance e.g: + * 
+     * /modules/module[name=instanceName][type=moduleType]
+     *
+ * or + * 
+     * /a:modules/a:module[a:name=instanceName][a:type=moduleType]
+     *
+ */ private static final String xpathPatternBlueprint = - "/" + XmlNetconfConstants.MODULES_KEY - + "/" + XmlNetconfConstants.MODULE_KEY - + "\\[" - - + "(?type|name)" - + "='(?[^']+)'" - + "( and |\\]\\[)" - + "(?type|name)" - + "='(?[^']+)'" - - + "\\]" - + "(?.*)"; + "/" + getRegExForPrefixedName(Modules.QNAME.getLocalName())+ "/" + getRegExForPrefixedName(Module.QNAME.getLocalName()) + + + "\\[" + + "(?" + getRegExForPrefixedName(XmlNetconfConstants.TYPE_KEY) + "|" + getRegExForPrefixedName(XmlNetconfConstants.NAME_KEY) + ")" + + "=('|\")?(?[^'\"\\]]+)('|\")?" + + "( and |\\]\\[)" + + "(?" + getRegExForPrefixedName(XmlNetconfConstants.TYPE_KEY) + "|" + getRegExForPrefixedName(XmlNetconfConstants.NAME_KEY) + ")" + + "=('|\")?(?[^'\"\\]]+)('|\")?" + + "\\]" + + + "(?.*)"; + + /** + * Return reg ex that matches either the name with or without a prefix + */ + private static String getRegExForPrefixedName(final String name) { + return "([^:]+:)?" + name; + } private static final Pattern xpathPattern = Pattern.compile(xpathPatternBlueprint); - private static final String additionalPatternBlueprint = "(?.+)\\[(.+)='(?.+)'\\]"; + + /** + * Pattern for additional path elements inside xpath for instance identifier pointing to an inner runtime bean e.g: + * 
+     * /modules/module[name=instanceName and type=moduleType]/inner[key=b]
+     *
+ */ + private static final String additionalPatternBlueprint = getRegExForPrefixedName("(?.+)") + "\\[(?" + getRegExForPrefixedName("(.+)") + ")=('|\")?(?[^'\"\\]]+)('|\")?\\]"; private static final Pattern additionalPattern = Pattern.compile(additionalPatternBlueprint); public static RuntimeRpcElementResolved fromXpath(String xpath, String elementName, String namespace) { @@ -115,20 +146,19 @@ public final class RuntimeRpcElementResolved { PatternGroupResolver(String key1, String value1, String value2, String additional) { this.key1 = Preconditions.checkNotNull(key1); this.value1 = Preconditions.checkNotNull(value1); - this.value2 = Preconditions.checkNotNull(value2); - this.additional = Preconditions.checkNotNull(additional); } String getModuleName() { - return key1.equals(XmlNetconfConstants.TYPE_KEY) ? value1 : value2; + return key1.contains(XmlNetconfConstants.TYPE_KEY) ? value1 : value2; } String getInstanceName() { - return key1.equals(XmlNetconfConstants.NAME_KEY) ? value1 : value2; + return key1.contains(XmlNetconfConstants.NAME_KEY) ? value1 : value2; } + Map getAdditionalKeys(String elementName, String moduleName) { HashMap additionalAttributes = Maps.newHashMap(); @@ -141,7 +171,7 @@ public final class RuntimeRpcElementResolved { Preconditions .checkState( matcher.matches(), - "Attribute %s not in required form on rpc element %s, required format for additional attributes is %s", + "Attribute %s not in required form on rpc element %s, required format for additional attributes is: %s", additionalKeyValue, elementName, additionalPatternBlueprint); String name = matcher.group("additionalKey"); runtimeBeanYangName = name; diff --git a/opendaylight/netconf/config-netconf-connector/src/test/java/org/opendaylight/controller/netconf/confignetconfconnector/NetconfMappingTest.java b/opendaylight/netconf/config-netconf-connector/src/test/java/org/opendaylight/controller/netconf/confignetconfconnector/NetconfMappingTest.java index 641881cf9e..28849d0033 100644 --- a/opendaylight/netconf/config-netconf-connector/src/test/java/org/opendaylight/controller/netconf/confignetconfconnector/NetconfMappingTest.java +++ b/opendaylight/netconf/config-netconf-connector/src/test/java/org/opendaylight/controller/netconf/confignetconfconnector/NetconfMappingTest.java @@ -55,10 +55,10 @@ import org.custommonkey.xmlunit.NodeTestException; import org.custommonkey.xmlunit.NodeTester; import org.custommonkey.xmlunit.XMLAssert; import org.custommonkey.xmlunit.XMLUnit; +import org.hamcrest.CoreMatchers; import org.junit.Before; import org.junit.Ignore; import org.junit.Test; -import org.junit.matchers.JUnitMatchers; import org.mockito.Mock; import org.mockito.MockitoAnnotations; import org.opendaylight.controller.config.api.ConflictingVersionException; @@ -569,7 +569,7 @@ public class NetconfMappingTest extends AbstractConfigTest { } private void assertContainsString(String string, String substring) { - assertThat(string, JUnitMatchers.containsString(substring)); + assertThat(string, CoreMatchers.containsString(substring)); } private void checkEnum(final Document response) throws Exception { diff --git a/opendaylight/netconf/config-netconf-connector/src/test/java/org/opendaylight/controller/netconf/confignetconfconnector/operations/runtimerpc/RuntimeRpcElementResolvedTest.java b/opendaylight/netconf/config-netconf-connector/src/test/java/org/opendaylight/controller/netconf/confignetconfconnector/operations/runtimerpc/RuntimeRpcElementResolvedTest.java new file mode 100644 index 0000000000..816e118f39 --- /dev/null +++ b/opendaylight/netconf/config-netconf-connector/src/test/java/org/opendaylight/controller/netconf/confignetconfconnector/operations/runtimerpc/RuntimeRpcElementResolvedTest.java @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2014 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.netconf.confignetconfconnector.operations.runtimerpc; + +import static org.junit.Assert.assertEquals; + +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +@RunWith(Parameterized.class) +public class RuntimeRpcElementResolvedTest { + + private static final String MODULE_TYPE = "moduleType"; + private static final String INSTANCE_NAME = "instanceName"; + @Parameterized.Parameter(0) + public String xpath; + @Parameterized.Parameter(1) + public Map additional; + + @Parameterized.Parameters(name = "{index}: parsed({0}) contains moduleName:{1} and instanceName:{2}") + public static Collection data() { + return Arrays.asList(new Object[][] { + // With namespaces + { "/a:modules/a:module[a:name='instanceName'][a:type='moduleType']/b:listener-state[b:peer-id='127.0.0.1']", + new HashMap() {{ + put("listener-state", "127.0.0.1"); + }}}, + { "/a:modules/a:module[a:name='instanceName'][a:type='moduleType']", + null}, + + // Without namespaces + { "/modules/module[name=instanceName][type=moduleType]", null}, + { "/modules/module[type=moduleType][name='instanceName']", null}, + { "/modules/module[name=\'instanceName\'][type=\"moduleType\"]", null}, + { "/modules/module[type=moduleType and name=instanceName]", null}, + { "/modules/module[name=\"instanceName\" and type=moduleType]", null}, + { "/modules/module[type=\"moduleType\" and name=instanceName]", null}, + { "/modules/module[name=\'instanceName\' and type=\"moduleType\"]", null}, + + // With inner beans + { "/modules/module[name=instanceName and type=\"moduleType\"]/inner[key=b]", Collections.singletonMap("inner", "b")}, + { "/modules/module[name=instanceName and type=moduleType]/inner[key=b]", Collections.singletonMap("inner", "b")}, + { "/modules/module[name=instanceName and type=moduleType]/inner[key=\'b\']", Collections.singletonMap("inner", "b")}, + { "/modules/module[name=instanceName and type=moduleType]/inner[key=\"b\"]", Collections.singletonMap("inner", "b")}, + + { "/modules/module[name=instanceName and type=\"moduleType\"]/inner[key2=a]/inner2[key=b]", + new HashMap() {{ + put("inner", "a"); + put("inner2", "b"); + }} + }, + }); + } + + @Test + public void testFromXpath() throws Exception { + final RuntimeRpcElementResolved resolved = RuntimeRpcElementResolved.fromXpath(xpath, "element", "namespace"); + assertEquals(MODULE_TYPE, resolved.getModuleName()); + assertEquals(INSTANCE_NAME, resolved.getInstanceName()); + if (additional != null) { + assertEquals(additional, resolved.getAdditionalAttributes()); + } + } +} diff --git a/opendaylight/netconf/config-netconf-connector/src/test/java/org/opendaylight/controller/netconf/confignetconfconnector/osgi/NetconfOperationServiceImplTest.java b/opendaylight/netconf/config-netconf-connector/src/test/java/org/opendaylight/controller/netconf/confignetconfconnector/osgi/NetconfOperationServiceImplTest.java index 1e650c08b1..b051c6c1c6 100644 --- a/opendaylight/netconf/config-netconf-connector/src/test/java/org/opendaylight/controller/netconf/confignetconfconnector/osgi/NetconfOperationServiceImplTest.java +++ b/opendaylight/netconf/config-netconf-connector/src/test/java/org/opendaylight/controller/netconf/confignetconfconnector/osgi/NetconfOperationServiceImplTest.java @@ -24,7 +24,7 @@ import java.util.Set; import org.junit.Assert; import org.junit.Test; -import org.junit.matchers.JUnitMatchers; +import org.hamcrest.CoreMatchers; import org.opendaylight.controller.config.api.LookupRegistry; import org.opendaylight.controller.config.yangjmxgenerator.ModuleMXBeanEntry; import org.opendaylight.yangtools.yang.common.QName; @@ -72,11 +72,11 @@ public class NetconfOperationServiceImplTest { String message = e.getMessage(); Assert.assertThat( message, - JUnitMatchers + CoreMatchers .containsString("missing from config subsystem but present in yangstore: [(namespace?revision=1970-01-01)qname2]")); Assert.assertThat( message, - JUnitMatchers + CoreMatchers .containsString("All modules present in config: [(namespace?revision=1970-01-01)qname1]")); } } diff --git a/opendaylight/netconf/config-persister-impl/src/test/java/org/opendaylight/controller/netconf/persist/impl/PersisterAggregatorTest.java b/opendaylight/netconf/config-persister-impl/src/test/java/org/opendaylight/controller/netconf/persist/impl/PersisterAggregatorTest.java index cd646aeb07..bef1237f98 100644 --- a/opendaylight/netconf/config-persister-impl/src/test/java/org/opendaylight/controller/netconf/persist/impl/PersisterAggregatorTest.java +++ b/opendaylight/netconf/config-persister-impl/src/test/java/org/opendaylight/controller/netconf/persist/impl/PersisterAggregatorTest.java @@ -23,11 +23,11 @@ import java.util.Arrays; import java.util.List; import java.util.Properties; +import static org.hamcrest.CoreMatchers.containsString; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertThat; import static org.junit.Assert.fail; -import static org.junit.matchers.JUnitMatchers.containsString; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.opendaylight.controller.netconf.persist.impl.PersisterAggregator.PersisterWithConfiguration; diff --git a/opendaylight/netconf/config-persister-impl/src/test/java/org/opendaylight/controller/netconf/persist/impl/osgi/TestingExceptionHandler.java b/opendaylight/netconf/config-persister-impl/src/test/java/org/opendaylight/controller/netconf/persist/impl/osgi/TestingExceptionHandler.java index 3f04010015..c8140973eb 100644 --- a/opendaylight/netconf/config-persister-impl/src/test/java/org/opendaylight/controller/netconf/persist/impl/osgi/TestingExceptionHandler.java +++ b/opendaylight/netconf/config-persister-impl/src/test/java/org/opendaylight/controller/netconf/persist/impl/osgi/TestingExceptionHandler.java @@ -7,13 +7,13 @@ */ package org.opendaylight.controller.netconf.persist.impl.osgi; +import static org.hamcrest.CoreMatchers.containsString; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; import static org.junit.Assert.assertThat; import static org.junit.Assert.fail; -import org.junit.matchers.JUnitMatchers; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -49,7 +49,7 @@ final class TestingExceptionHandler implements Thread.UncaughtExceptionHandler { private void assertException(Throwable t, Class exType, String exMessageToContain) { assertEquals("Expected exception of type " + exType + " but was " + t, exType, t.getClass()); if(exMessageToContain!=null) { - assertThat(t.getMessage(), JUnitMatchers.containsString(exMessageToContain)); + assertThat(t.getMessage(), containsString(exMessageToContain)); } } diff --git a/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/NetconfClientDispatcherImplTest.java b/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/NetconfClientDispatcherImplTest.java index 5a2ec5656f..dfbb972e8c 100644 --- a/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/NetconfClientDispatcherImplTest.java +++ b/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/NetconfClientDispatcherImplTest.java @@ -21,7 +21,6 @@ import org.opendaylight.controller.netconf.client.NetconfClientDispatcherImpl; import org.opendaylight.controller.netconf.client.NetconfClientSessionListener; import org.opendaylight.controller.netconf.client.SimpleNetconfClientSessionListener; import org.opendaylight.controller.netconf.client.conf.NetconfClientConfiguration; -import org.opendaylight.controller.netconf.client.conf.NetconfClientConfigurationBuilder; import org.opendaylight.controller.netconf.client.conf.NetconfReconnectingClientConfiguration; import org.opendaylight.controller.netconf.client.conf.NetconfReconnectingClientConfigurationBuilder; import org.opendaylight.controller.netconf.nettyutil.handler.ssh.authentication.AuthenticationHandler; @@ -32,7 +31,6 @@ import org.opendaylight.protocol.framework.ReconnectStrategyFactory; import java.net.InetSocketAddress; import java.util.concurrent.Future; -import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import static org.mockito.Matchers.any; import static org.mockito.Mockito.doReturn; diff --git a/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/NetconfClientSessionNegotiatorFactoryTest.java b/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/NetconfClientSessionNegotiatorFactoryTest.java index 0557a0c268..95fdcccab8 100644 --- a/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/NetconfClientSessionNegotiatorFactoryTest.java +++ b/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/NetconfClientSessionNegotiatorFactoryTest.java @@ -13,13 +13,11 @@ import io.netty.channel.Channel; import io.netty.util.HashedWheelTimer; import io.netty.util.Timer; import io.netty.util.concurrent.Promise; -import org.apache.sshd.common.SessionListener; import org.junit.Test; import org.opendaylight.controller.netconf.util.messages.NetconfHelloMessageAdditionalHeader; import org.opendaylight.protocol.framework.SessionListenerFactory; import org.opendaylight.protocol.framework.SessionNegotiator; -import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; diff --git a/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/NetconfClientSessionNegotiatorTest.java b/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/NetconfClientSessionNegotiatorTest.java index 333e9deae4..9993f48a4d 100644 --- a/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/NetconfClientSessionNegotiatorTest.java +++ b/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/NetconfClientSessionNegotiatorTest.java @@ -8,22 +8,35 @@ package org.opendaylight.controller.netconf.client; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.anyObject; +import static org.mockito.Matchers.anyString; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; import com.google.common.base.Optional; -import io.netty.channel.*; +import io.netty.channel.Channel; +import io.netty.channel.ChannelFuture; +import io.netty.channel.ChannelHandler; +import io.netty.channel.ChannelHandlerContext; +import io.netty.channel.ChannelInboundHandlerAdapter; +import io.netty.channel.ChannelPipeline; +import io.netty.channel.ChannelProgressivePromise; import io.netty.handler.ssl.SslHandler; import io.netty.util.HashedWheelTimer; +import io.netty.util.Timer; import io.netty.util.concurrent.GenericFutureListener; import io.netty.util.concurrent.Promise; -import org.apache.mina.handler.demux.ExceptionHandler; +import java.util.Set; import org.junit.Before; import org.junit.Test; -import org.mockito.Mockito; import org.mockito.internal.util.collections.Sets; import org.mockito.invocation.InvocationOnMock; import org.mockito.stubbing.Answer; import org.opendaylight.controller.netconf.api.NetconfClientSessionPreferences; import org.opendaylight.controller.netconf.api.NetconfMessage; -import io.netty.util.Timer; import org.opendaylight.controller.netconf.nettyutil.handler.ChunkedFramingMechanismEncoder; import org.opendaylight.controller.netconf.nettyutil.handler.NetconfXMLToHelloMessageDecoder; import org.opendaylight.controller.netconf.nettyutil.handler.NetconfXMLToMessageDecoder; @@ -31,14 +44,8 @@ import org.opendaylight.controller.netconf.nettyutil.handler.exi.NetconfStartExi import org.opendaylight.controller.netconf.util.messages.NetconfHelloMessage; import org.opendaylight.controller.netconf.util.messages.NetconfHelloMessageAdditionalHeader; import org.opendaylight.controller.netconf.util.test.XmlFileLoader; -import org.opendaylight.controller.netconf.util.xml.XmlUtil; import org.openexi.proc.common.EXIOptions; import org.w3c.dom.Document; -import java.util.Set; -import static org.mockito.Matchers.any; -import static org.mockito.Matchers.anyObject; -import static org.mockito.Matchers.anyString; -import static org.mockito.Mockito.*; public class NetconfClientSessionNegotiatorTest { @@ -96,8 +103,8 @@ public class NetconfClientSessionNegotiatorTest { return pipeline; } - private NetconfClientSessionNegotiator createNetconfClientSessionNegotiator(Promise promise, - NetconfMessage startExi) { + private NetconfClientSessionNegotiator createNetconfClientSessionNegotiator(final Promise promise, + final NetconfMessage startExi) { ChannelProgressivePromise progressivePromise = mock(ChannelProgressivePromise.class); NetconfClientSessionPreferences preferences = new NetconfClientSessionPreferences(helloMessage, startExi); doReturn(progressivePromise).when(promise).setFailure(any(Throwable.class)); @@ -133,9 +140,9 @@ public class NetconfClientSessionNegotiatorTest { Set caps = Sets.newSet("exi:1.0"); NetconfHelloMessage helloMessage = NetconfHelloMessage.createServerHello(caps, 10); - doAnswer(new Answer() { + doAnswer(new Answer() { @Override - public Object answer(InvocationOnMock invocationOnMock) throws Throwable { + public Object answer(final InvocationOnMock invocationOnMock) throws Throwable { channelInboundHandlerAdapter = ((ChannelInboundHandlerAdapter) invocationOnMock.getArguments()[2]); return null; } diff --git a/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/NetconfClientSessionTest.java b/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/NetconfClientSessionTest.java index 4175190e14..731a3fe960 100644 --- a/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/NetconfClientSessionTest.java +++ b/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/NetconfClientSessionTest.java @@ -12,7 +12,6 @@ import com.google.common.collect.Lists; import io.netty.channel.Channel; import io.netty.channel.ChannelHandler; import io.netty.channel.ChannelPipeline; -import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.mockito.Mock; @@ -23,7 +22,6 @@ import org.opendaylight.controller.netconf.client.NetconfClientSessionListener; import org.opendaylight.controller.netconf.nettyutil.handler.NetconfEXICodec; import org.openexi.proc.common.EXIOptions; -import java.util.ArrayList; import java.util.Collection; import static org.junit.Assert.assertEquals; diff --git a/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/NetconfReconnectingClientConfigurationTest.java b/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/NetconfReconnectingClientConfigurationTest.java index e79a370ec7..a9754654d5 100644 --- a/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/NetconfReconnectingClientConfigurationTest.java +++ b/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/NetconfReconnectingClientConfigurationTest.java @@ -12,7 +12,6 @@ import com.google.common.base.Optional; import org.junit.Assert; import org.junit.Test; import org.mockito.Mockito; -import org.opendaylight.controller.config.yang.protocol.framework.NeverReconnectStrategyFactoryModule; import org.opendaylight.controller.netconf.client.NetconfClientSessionListener; import org.opendaylight.controller.netconf.client.SimpleNetconfClientSessionListener; import org.opendaylight.controller.netconf.client.conf.NetconfClientConfiguration; diff --git a/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/SimpleNetconfClientSessionListenerTest.java b/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/SimpleNetconfClientSessionListenerTest.java index e067cc225f..29b903f235 100644 --- a/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/SimpleNetconfClientSessionListenerTest.java +++ b/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/SimpleNetconfClientSessionListenerTest.java @@ -9,7 +9,6 @@ package org.opendaylight.controller.netconf.client; import io.netty.channel.*; import io.netty.util.concurrent.Future; -import io.netty.util.concurrent.Promise; import org.junit.Before; import org.junit.Test; import org.mockito.internal.util.collections.Sets; diff --git a/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/TcpClientChannelInitializerTest.java b/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/TcpClientChannelInitializerTest.java index e355cf45e7..369f0ed574 100644 --- a/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/TcpClientChannelInitializerTest.java +++ b/opendaylight/netconf/netconf-client/src/test/java/org/opendaylight/controller/netconf/client/TcpClientChannelInitializerTest.java @@ -13,7 +13,6 @@ import io.netty.channel.ChannelHandler; import io.netty.channel.ChannelPipeline; import io.netty.util.concurrent.Promise; import org.junit.Test; -import org.opendaylight.controller.netconf.nettyutil.AbstractChannelInitializer; import org.opendaylight.protocol.framework.SessionListenerFactory; import org.opendaylight.protocol.framework.SessionNegotiator; diff --git a/opendaylight/netconf/netconf-impl/src/main/java/org/opendaylight/controller/netconf/impl/mapping/operations/DefaultNetconfOperation.java b/opendaylight/netconf/netconf-impl/src/main/java/org/opendaylight/controller/netconf/impl/mapping/operations/DefaultNetconfOperation.java index 13d4ab290b..2646b7e26e 100644 --- a/opendaylight/netconf/netconf-impl/src/main/java/org/opendaylight/controller/netconf/impl/mapping/operations/DefaultNetconfOperation.java +++ b/opendaylight/netconf/netconf-impl/src/main/java/org/opendaylight/controller/netconf/impl/mapping/operations/DefaultNetconfOperation.java @@ -1,14 +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.netconf.impl.mapping.operations; - -import org.opendaylight.controller.netconf.impl.NetconfServerSession; - -public interface DefaultNetconfOperation { - void setNetconfSession(NetconfServerSession s); -} +/* + * 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.netconf.impl.mapping.operations; + +import org.opendaylight.controller.netconf.impl.NetconfServerSession; + +public interface DefaultNetconfOperation { + void setNetconfSession(NetconfServerSession s); +} diff --git a/opendaylight/netconf/netconf-impl/src/main/java/org/opendaylight/controller/netconf/impl/mapping/operations/DefaultStartExi.java b/opendaylight/netconf/netconf-impl/src/main/java/org/opendaylight/controller/netconf/impl/mapping/operations/DefaultStartExi.java index cccb1a3ac3..6de185ac1c 100644 --- a/opendaylight/netconf/netconf-impl/src/main/java/org/opendaylight/controller/netconf/impl/mapping/operations/DefaultStartExi.java +++ b/opendaylight/netconf/netconf-impl/src/main/java/org/opendaylight/controller/netconf/impl/mapping/operations/DefaultStartExi.java @@ -1,71 +1,71 @@ -/* - * 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.netconf.impl.mapping.operations; - -import org.opendaylight.controller.netconf.api.NetconfDocumentedException; -import org.opendaylight.controller.netconf.api.NetconfDocumentedException.ErrorSeverity; -import org.opendaylight.controller.netconf.api.NetconfDocumentedException.ErrorTag; -import org.opendaylight.controller.netconf.api.NetconfDocumentedException.ErrorType; -import org.opendaylight.controller.netconf.api.xml.XmlNetconfConstants; -import org.opendaylight.controller.netconf.api.NetconfMessage; -import org.opendaylight.controller.netconf.impl.NetconfServerSession; -import org.opendaylight.controller.netconf.mapping.api.NetconfOperationChainedExecution; -import org.opendaylight.controller.netconf.util.mapping.AbstractSingletonNetconfOperation; -import org.opendaylight.controller.netconf.util.xml.XmlElement; -import org.opendaylight.controller.netconf.util.xml.XmlUtil; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import org.w3c.dom.Document; -import org.w3c.dom.Element; -public class DefaultStartExi extends AbstractSingletonNetconfOperation implements DefaultNetconfOperation { - public static final String START_EXI = "start-exi"; - - private static final Logger logger = LoggerFactory.getLogger(DefaultStartExi.class); - private NetconfServerSession netconfSession; - - public DefaultStartExi(String netconfSessionIdForReporting) { - super(netconfSessionIdForReporting); - } - - @Override - public Document handle(Document message, - NetconfOperationChainedExecution subsequentOperation) throws NetconfDocumentedException { - logger.debug("Received start-exi message {} ", XmlUtil.toString(message)); - - try { - netconfSession.startExiCommunication(new NetconfMessage(message)); - } catch (IllegalArgumentException e) { - throw new NetconfDocumentedException("Failed to parse EXI parameters", ErrorType.protocol, - ErrorTag.operation_failed, ErrorSeverity.error); - } - - return super.handle(message, subsequentOperation); - } - - @Override - protected Element handleWithNoSubsequentOperations(Document document, XmlElement operationElement) throws NetconfDocumentedException { - Element getSchemaResult = document.createElementNS( XmlNetconfConstants.URN_IETF_PARAMS_XML_NS_NETCONF_BASE_1_0, XmlNetconfConstants.OK); - logger.trace("{} operation successful", START_EXI); - return getSchemaResult; - } - - @Override - protected String getOperationName() { - return START_EXI; - } - - @Override - protected String getOperationNamespace() { - return XmlNetconfConstants.URN_IETF_PARAMS_XML_NS_NETCONF_EXI_1_0; - } - - @Override - public void setNetconfSession(NetconfServerSession s) { - netconfSession = s; - } -} +/* + * 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.netconf.impl.mapping.operations; + +import org.opendaylight.controller.netconf.api.NetconfDocumentedException; +import org.opendaylight.controller.netconf.api.NetconfDocumentedException.ErrorSeverity; +import org.opendaylight.controller.netconf.api.NetconfDocumentedException.ErrorTag; +import org.opendaylight.controller.netconf.api.NetconfDocumentedException.ErrorType; +import org.opendaylight.controller.netconf.api.xml.XmlNetconfConstants; +import org.opendaylight.controller.netconf.api.NetconfMessage; +import org.opendaylight.controller.netconf.impl.NetconfServerSession; +import org.opendaylight.controller.netconf.mapping.api.NetconfOperationChainedExecution; +import org.opendaylight.controller.netconf.util.mapping.AbstractSingletonNetconfOperation; +import org.opendaylight.controller.netconf.util.xml.XmlElement; +import org.opendaylight.controller.netconf.util.xml.XmlUtil; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.w3c.dom.Document; +import org.w3c.dom.Element; +public class DefaultStartExi extends AbstractSingletonNetconfOperation implements DefaultNetconfOperation { + public static final String START_EXI = "start-exi"; + + private static final Logger logger = LoggerFactory.getLogger(DefaultStartExi.class); + private NetconfServerSession netconfSession; + + public DefaultStartExi(String netconfSessionIdForReporting) { + super(netconfSessionIdForReporting); + } + + @Override + public Document handle(Document message, + NetconfOperationChainedExecution subsequentOperation) throws NetconfDocumentedException { + logger.debug("Received start-exi message {} ", XmlUtil.toString(message)); + + try { + netconfSession.startExiCommunication(new NetconfMessage(message)); + } catch (IllegalArgumentException e) { + throw new NetconfDocumentedException("Failed to parse EXI parameters", ErrorType.protocol, + ErrorTag.operation_failed, ErrorSeverity.error); + } + + return super.handle(message, subsequentOperation); + } + + @Override + protected Element handleWithNoSubsequentOperations(Document document, XmlElement operationElement) throws NetconfDocumentedException { + Element getSchemaResult = document.createElementNS( XmlNetconfConstants.URN_IETF_PARAMS_XML_NS_NETCONF_BASE_1_0, XmlNetconfConstants.OK); + logger.trace("{} operation successful", START_EXI); + return getSchemaResult; + } + + @Override + protected String getOperationName() { + return START_EXI; + } + + @Override + protected String getOperationNamespace() { + return XmlNetconfConstants.URN_IETF_PARAMS_XML_NS_NETCONF_EXI_1_0; + } + + @Override + public void setNetconfSession(NetconfServerSession s) { + netconfSession = s; + } +} diff --git a/opendaylight/netconf/netconf-impl/src/main/java/org/opendaylight/controller/netconf/impl/mapping/operations/DefaultStopExi.java b/opendaylight/netconf/netconf-impl/src/main/java/org/opendaylight/controller/netconf/impl/mapping/operations/DefaultStopExi.java index 2a24ae32fa..233638d5b0 100644 --- a/opendaylight/netconf/netconf-impl/src/main/java/org/opendaylight/controller/netconf/impl/mapping/operations/DefaultStopExi.java +++ b/opendaylight/netconf/netconf-impl/src/main/java/org/opendaylight/controller/netconf/impl/mapping/operations/DefaultStopExi.java @@ -1,58 +1,58 @@ -/* - * 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.netconf.impl.mapping.operations; - -import org.opendaylight.controller.netconf.api.NetconfDocumentedException; -import org.opendaylight.controller.netconf.api.xml.XmlNetconfConstants; -import org.opendaylight.controller.netconf.impl.NetconfServerSession; -import org.opendaylight.controller.netconf.util.mapping.AbstractSingletonNetconfOperation; -import org.opendaylight.controller.netconf.util.xml.XmlElement; -import org.opendaylight.controller.netconf.util.xml.XmlUtil; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import org.w3c.dom.Document; -import org.w3c.dom.Element; - -public class DefaultStopExi extends AbstractSingletonNetconfOperation implements DefaultNetconfOperation { - - public static final String STOP_EXI = "stop-exi"; - private NetconfServerSession netconfSession; - - private static final Logger logger = LoggerFactory - .getLogger(DefaultStartExi.class); - - public DefaultStopExi(String netconfSessionIdForReporting) { - super(netconfSessionIdForReporting); - } - - @Override - protected Element handleWithNoSubsequentOperations(Document document, XmlElement operationElement) throws NetconfDocumentedException { - logger.debug("Received stop-exi message {} ", XmlUtil.toString(operationElement)); - - netconfSession.stopExiCommunication(); - - Element getSchemaResult = document.createElementNS( XmlNetconfConstants.URN_IETF_PARAMS_XML_NS_NETCONF_BASE_1_0, XmlNetconfConstants.OK); - logger.trace("{} operation successful", STOP_EXI); - return getSchemaResult; - } - - @Override - protected String getOperationName() { - return STOP_EXI; - } - - @Override - protected String getOperationNamespace() { - return XmlNetconfConstants.URN_IETF_PARAMS_XML_NS_NETCONF_EXI_1_0; - } - - @Override - public void setNetconfSession(NetconfServerSession s) { - this.netconfSession = s; - } -} +/* + * 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.netconf.impl.mapping.operations; + +import org.opendaylight.controller.netconf.api.NetconfDocumentedException; +import org.opendaylight.controller.netconf.api.xml.XmlNetconfConstants; +import org.opendaylight.controller.netconf.impl.NetconfServerSession; +import org.opendaylight.controller.netconf.util.mapping.AbstractSingletonNetconfOperation; +import org.opendaylight.controller.netconf.util.xml.XmlElement; +import org.opendaylight.controller.netconf.util.xml.XmlUtil; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.w3c.dom.Document; +import org.w3c.dom.Element; + +public class DefaultStopExi extends AbstractSingletonNetconfOperation implements DefaultNetconfOperation { + + public static final String STOP_EXI = "stop-exi"; + private NetconfServerSession netconfSession; + + private static final Logger logger = LoggerFactory + .getLogger(DefaultStartExi.class); + + public DefaultStopExi(String netconfSessionIdForReporting) { + super(netconfSessionIdForReporting); + } + + @Override + protected Element handleWithNoSubsequentOperations(Document document, XmlElement operationElement) throws NetconfDocumentedException { + logger.debug("Received stop-exi message {} ", XmlUtil.toString(operationElement)); + + netconfSession.stopExiCommunication(); + + Element getSchemaResult = document.createElementNS( XmlNetconfConstants.URN_IETF_PARAMS_XML_NS_NETCONF_BASE_1_0, XmlNetconfConstants.OK); + logger.trace("{} operation successful", STOP_EXI); + return getSchemaResult; + } + + @Override + protected String getOperationName() { + return STOP_EXI; + } + + @Override + protected String getOperationNamespace() { + return XmlNetconfConstants.URN_IETF_PARAMS_XML_NS_NETCONF_EXI_1_0; + } + + @Override + public void setNetconfSession(NetconfServerSession s) { + this.netconfSession = s; + } +} diff --git a/opendaylight/netconf/netconf-impl/src/test/java/org/opendaylight/controller/netconf/impl/AdditionalHeaderParserTest.java b/opendaylight/netconf/netconf-impl/src/test/java/org/opendaylight/controller/netconf/impl/AdditionalHeaderParserTest.java index c2dcd67921..444d4fe4ab 100644 --- a/opendaylight/netconf/netconf-impl/src/test/java/org/opendaylight/controller/netconf/impl/AdditionalHeaderParserTest.java +++ b/opendaylight/netconf/netconf-impl/src/test/java/org/opendaylight/controller/netconf/impl/AdditionalHeaderParserTest.java @@ -7,8 +7,7 @@ */ package org.opendaylight.controller.netconf.impl; -import junit.framework.Assert; - +import static org.junit.Assert.assertEquals; import org.junit.Test; import org.opendaylight.controller.netconf.util.messages.NetconfHelloMessageAdditionalHeader; @@ -18,18 +17,18 @@ public class AdditionalHeaderParserTest { public void testParsing() throws Exception { String s = "[netconf;10.12.0.102:48528;ssh;;;;;;]"; NetconfHelloMessageAdditionalHeader header = NetconfHelloMessageAdditionalHeader.fromString(s); - Assert.assertEquals("netconf", header.getUserName()); - Assert.assertEquals("10.12.0.102", header.getAddress()); - Assert.assertEquals("ssh", header.getTransport()); + assertEquals("netconf", header.getUserName()); + assertEquals("10.12.0.102", header.getAddress()); + assertEquals("ssh", header.getTransport()); } @Test public void testParsing2() throws Exception { String s = "[tomas;10.0.0.0/10000;tcp;1000;1000;;/home/tomas;;]"; NetconfHelloMessageAdditionalHeader header = NetconfHelloMessageAdditionalHeader.fromString(s); - Assert.assertEquals("tomas", header.getUserName()); - Assert.assertEquals("10.0.0.0", header.getAddress()); - Assert.assertEquals("tcp", header.getTransport()); + assertEquals("tomas", header.getUserName()); + assertEquals("10.0.0.0", header.getAddress()); + assertEquals("tcp", header.getTransport()); } @Test(expected = IllegalArgumentException.class) diff --git a/opendaylight/netconf/netconf-impl/src/test/java/org/opendaylight/controller/netconf/impl/ExiEncodeDecodeTest.java b/opendaylight/netconf/netconf-impl/src/test/java/org/opendaylight/controller/netconf/impl/ExiEncodeDecodeTest.java index 58c6566d91..b54b218033 100644 --- a/opendaylight/netconf/netconf-impl/src/test/java/org/opendaylight/controller/netconf/impl/ExiEncodeDecodeTest.java +++ b/opendaylight/netconf/netconf-impl/src/test/java/org/opendaylight/controller/netconf/impl/ExiEncodeDecodeTest.java @@ -7,7 +7,7 @@ */ package org.opendaylight.controller.netconf.impl; -import static junit.framework.Assert.assertNotNull; +import static org.junit.Assert.assertNotNull; import org.junit.Test; import org.opendaylight.controller.netconf.api.NetconfMessage; diff --git a/opendaylight/netconf/netconf-impl/src/test/java/org/opendaylight/controller/netconf/impl/mapping/operations/DefaultCloseSessionTest.java b/opendaylight/netconf/netconf-impl/src/test/java/org/opendaylight/controller/netconf/impl/mapping/operations/DefaultCloseSessionTest.java index ae3d65646f..d6b0201ab8 100644 --- a/opendaylight/netconf/netconf-impl/src/test/java/org/opendaylight/controller/netconf/impl/mapping/operations/DefaultCloseSessionTest.java +++ b/opendaylight/netconf/netconf-impl/src/test/java/org/opendaylight/controller/netconf/impl/mapping/operations/DefaultCloseSessionTest.java @@ -13,8 +13,6 @@ import org.opendaylight.controller.netconf.api.NetconfDocumentedException; import org.opendaylight.controller.netconf.util.xml.XmlElement; import org.opendaylight.controller.netconf.util.xml.XmlUtil; import org.w3c.dom.Document; -import org.w3c.dom.Element; - import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.doThrow; import static org.mockito.Mockito.mock; diff --git a/opendaylight/netconf/netconf-impl/src/test/java/org/opendaylight/controller/netconf/impl/mapping/operations/DefaultGetSchemaTest.java b/opendaylight/netconf/netconf-impl/src/test/java/org/opendaylight/controller/netconf/impl/mapping/operations/DefaultGetSchemaTest.java index b655e90f2b..4218176f1d 100644 --- a/opendaylight/netconf/netconf-impl/src/test/java/org/opendaylight/controller/netconf/impl/mapping/operations/DefaultGetSchemaTest.java +++ b/opendaylight/netconf/netconf-impl/src/test/java/org/opendaylight/controller/netconf/impl/mapping/operations/DefaultGetSchemaTest.java @@ -8,8 +8,13 @@ package org.opendaylight.controller.netconf.impl.mapping.operations; +import static org.junit.Assert.assertNotNull; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.anyString; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.mock; import com.google.common.base.Optional; -import junit.framework.Assert; import org.junit.Before; import org.junit.Test; import org.opendaylight.controller.netconf.api.NetconfDocumentedException; @@ -18,13 +23,6 @@ import org.opendaylight.controller.netconf.util.xml.XmlElement; import org.opendaylight.controller.netconf.util.xml.XmlUtil; import org.w3c.dom.Document; -import static org.junit.Assert.assertNotNull; -import static org.mockito.Matchers.any; -import static org.mockito.Matchers.anyString; -import static org.mockito.Mockito.doReturn; -import static org.mockito.Mockito.doThrow; -import static org.mockito.Mockito.mock; - public class DefaultGetSchemaTest { private CapabilityProvider cap; diff --git a/opendaylight/netconf/netconf-impl/src/test/java/org/opendaylight/controller/netconf/impl/osgi/NetconfImplActivatorTest.java b/opendaylight/netconf/netconf-impl/src/test/java/org/opendaylight/controller/netconf/impl/osgi/NetconfImplActivatorTest.java index b59ea884c5..9470e6d09c 100644 --- a/opendaylight/netconf/netconf-impl/src/test/java/org/opendaylight/controller/netconf/impl/osgi/NetconfImplActivatorTest.java +++ b/opendaylight/netconf/netconf-impl/src/test/java/org/opendaylight/controller/netconf/impl/osgi/NetconfImplActivatorTest.java @@ -9,18 +9,23 @@ package org.opendaylight.controller.netconf.impl.osgi; import java.util.Arrays; -import java.util.Collection; import java.util.Dictionary; import org.junit.Before; import org.junit.Test; import org.mockito.Mock; import org.mockito.MockitoAnnotations; -import org.opendaylight.controller.netconf.api.monitoring.NetconfMonitoringService; -import org.opendaylight.controller.netconf.mapping.api.NetconfOperationProvider; -import org.osgi.framework.*; +import org.osgi.framework.BundleContext; +import org.osgi.framework.Filter; +import org.osgi.framework.ServiceListener; +import org.osgi.framework.ServiceReference; +import org.osgi.framework.ServiceRegistration; import static org.mockito.Matchers.any; -import static org.mockito.Mockito.*; +import static org.mockito.Mockito.anyString; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; public class NetconfImplActivatorTest { diff --git a/opendaylight/netconf/netconf-it/src/test/java/org/opendaylight/controller/netconf/it/NetconfConfigPersisterITTest.java b/opendaylight/netconf/netconf-it/src/test/java/org/opendaylight/controller/netconf/it/NetconfConfigPersisterITTest.java index d8eb841a79..cc170358dd 100644 --- a/opendaylight/netconf/netconf-it/src/test/java/org/opendaylight/controller/netconf/it/NetconfConfigPersisterITTest.java +++ b/opendaylight/netconf/netconf-it/src/test/java/org/opendaylight/controller/netconf/it/NetconfConfigPersisterITTest.java @@ -7,7 +7,7 @@ */ package org.opendaylight.controller.netconf.it; -import static junit.framework.Assert.assertEquals; +import static org.junit.Assert.assertEquals; import static org.mockito.Matchers.any; import static org.mockito.Matchers.anyString; import static org.mockito.Mockito.doAnswer; diff --git a/opendaylight/netconf/netconf-monitoring/src/test/java/org/opendaylight/controller/netconf/monitoring/GetTest.java b/opendaylight/netconf/netconf-monitoring/src/test/java/org/opendaylight/controller/netconf/monitoring/GetTest.java index 5fceac06dd..5a744fda14 100644 --- a/opendaylight/netconf/netconf-monitoring/src/test/java/org/opendaylight/controller/netconf/monitoring/GetTest.java +++ b/opendaylight/netconf/netconf-monitoring/src/test/java/org/opendaylight/controller/netconf/monitoring/GetTest.java @@ -8,13 +8,12 @@ package org.opendaylight.controller.netconf.monitoring; -import static junit.framework.Assert.assertEquals; -import static junit.framework.Assert.assertTrue; -import static junit.framework.TestCase.fail; +import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.doThrow; - import java.util.Collections; import org.hamcrest.CoreMatchers; import org.junit.Before; diff --git a/opendaylight/netconf/netconf-monitoring/src/test/java/org/opendaylight/controller/netconf/monitoring/osgi/NetconfMonitoringActivatorTest.java b/opendaylight/netconf/netconf-monitoring/src/test/java/org/opendaylight/controller/netconf/monitoring/osgi/NetconfMonitoringActivatorTest.java index 40493569d6..b5b9f3c060 100644 --- a/opendaylight/netconf/netconf-monitoring/src/test/java/org/opendaylight/controller/netconf/monitoring/osgi/NetconfMonitoringActivatorTest.java +++ b/opendaylight/netconf/netconf-monitoring/src/test/java/org/opendaylight/controller/netconf/monitoring/osgi/NetconfMonitoringActivatorTest.java @@ -8,6 +8,12 @@ package org.opendaylight.controller.netconf.monitoring.osgi; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.anyString; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; import java.util.Arrays; import org.junit.Before; import org.junit.Test; @@ -18,10 +24,6 @@ import org.osgi.framework.Filter; import org.osgi.framework.ServiceListener; import org.osgi.framework.ServiceReference; -import static org.mockito.Matchers.any; -import static org.mockito.Matchers.anyString; -import static org.mockito.Mockito.*; - public class NetconfMonitoringActivatorTest { @Mock @@ -34,7 +36,7 @@ public class NetconfMonitoringActivatorTest { MockitoAnnotations.initMocks(this); doReturn(filter).when(context).createFilter(anyString()); doNothing().when(context).addServiceListener(any(ServiceListener.class), anyString()); - ServiceReference[] refs = new ServiceReference[2]; + ServiceReference[] refs = new ServiceReference[2]; doReturn(Arrays.asList(refs)).when(context).getServiceReferences(any(Class.class), anyString()); doReturn(refs).when(context).getServiceReferences(anyString(), anyString()); } diff --git a/opendaylight/netconf/netconf-monitoring/src/test/java/org/opendaylight/controller/netconf/monitoring/osgi/NetconfMonitoringServiceTrackerTest.java b/opendaylight/netconf/netconf-monitoring/src/test/java/org/opendaylight/controller/netconf/monitoring/osgi/NetconfMonitoringServiceTrackerTest.java index 2a53a6ce45..b992b0e44f 100644 --- a/opendaylight/netconf/netconf-monitoring/src/test/java/org/opendaylight/controller/netconf/monitoring/osgi/NetconfMonitoringServiceTrackerTest.java +++ b/opendaylight/netconf/netconf-monitoring/src/test/java/org/opendaylight/controller/netconf/monitoring/osgi/NetconfMonitoringServiceTrackerTest.java @@ -8,6 +8,12 @@ package org.opendaylight.controller.netconf.monitoring.osgi; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.anyString; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; import java.util.Hashtable; import org.junit.Before; import org.junit.Test; @@ -20,18 +26,14 @@ import org.osgi.framework.Filter; import org.osgi.framework.ServiceReference; import org.osgi.framework.ServiceRegistration; -import static org.mockito.Matchers.any; -import static org.mockito.Matchers.anyCollection; -import static org.mockito.Mockito.*; - public class NetconfMonitoringServiceTrackerTest { @Mock - private ServiceReference reference; + private ServiceReference reference; @Mock private BundleContext context; @Mock - private ServiceRegistration serviceRegistration; + private ServiceRegistration serviceRegistration; @Mock private Filter filter; @Mock diff --git a/opendaylight/netconf/netconf-netty-util/src/main/java/org/opendaylight/controller/netconf/nettyutil/handler/exi/EXIParameters.java b/opendaylight/netconf/netconf-netty-util/src/main/java/org/opendaylight/controller/netconf/nettyutil/handler/exi/EXIParameters.java index 531ba3ccb7..ccd7dead9f 100644 --- a/opendaylight/netconf/netconf-netty-util/src/main/java/org/opendaylight/controller/netconf/nettyutil/handler/exi/EXIParameters.java +++ b/opendaylight/netconf/netconf-netty-util/src/main/java/org/opendaylight/controller/netconf/nettyutil/handler/exi/EXIParameters.java @@ -48,18 +48,18 @@ public final class EXIParameters { final String alignmentTextContent = alignmentElement.getTextContent().trim(); switch (alignmentTextContent) { - case EXI_PARAMETER_BIT_PACKED: - options.setAlignmentType(AlignmentType.bitPacked); - break; - case EXI_PARAMETER_BYTE_ALIGNED: - options.setAlignmentType(AlignmentType.byteAligned); - break; - case EXI_PARAMETER_COMPRESSED: - options.setAlignmentType(AlignmentType.compress); - break; - case EXI_PARAMETER_PRE_COMPRESSION: - options.setAlignmentType(AlignmentType.preCompress); - break; + case EXI_PARAMETER_BIT_PACKED: + options.setAlignmentType(AlignmentType.bitPacked); + break; + case EXI_PARAMETER_BYTE_ALIGNED: + options.setAlignmentType(AlignmentType.byteAligned); + break; + case EXI_PARAMETER_COMPRESSED: + options.setAlignmentType(AlignmentType.compress); + break; + case EXI_PARAMETER_PRE_COMPRESSION: + options.setAlignmentType(AlignmentType.preCompress); + break; } } diff --git a/opendaylight/netconf/netconf-netty-util/src/test/java/org/opendaylight/controller/netconf/nettyutil/handler/ChunkedFramingMechanismEncoderTest.java b/opendaylight/netconf/netconf-netty-util/src/test/java/org/opendaylight/controller/netconf/nettyutil/handler/ChunkedFramingMechanismEncoderTest.java index 93475129d2..556bece43f 100644 --- a/opendaylight/netconf/netconf-netty-util/src/test/java/org/opendaylight/controller/netconf/nettyutil/handler/ChunkedFramingMechanismEncoderTest.java +++ b/opendaylight/netconf/netconf-netty-util/src/test/java/org/opendaylight/controller/netconf/nettyutil/handler/ChunkedFramingMechanismEncoderTest.java @@ -11,7 +11,6 @@ package org.opendaylight.controller.netconf.nettyutil.handler; import static org.junit.Assert.assertEquals; import static org.mockito.Matchers.anyObject; import static org.mockito.Mockito.doAnswer; - import com.google.common.collect.Lists; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; @@ -50,7 +49,7 @@ public class ChunkedFramingMechanismEncoderTest { @Test public void testEncode() throws Exception { final List chunks = Lists.newArrayList(); - doAnswer(new Answer() { + doAnswer(new Answer() { @Override public Object answer(final InvocationOnMock invocation) throws Throwable { chunks.add((ByteBuf) invocation.getArguments()[0]); diff --git a/opendaylight/netconf/netconf-netty-util/src/test/java/org/opendaylight/controller/netconf/nettyutil/handler/NetconfEXIHandlersTest.java b/opendaylight/netconf/netconf-netty-util/src/test/java/org/opendaylight/controller/netconf/nettyutil/handler/NetconfEXIHandlersTest.java index 4a8db176fe..8bc0fb8e82 100644 --- a/opendaylight/netconf/netconf-netty-util/src/test/java/org/opendaylight/controller/netconf/nettyutil/handler/NetconfEXIHandlersTest.java +++ b/opendaylight/netconf/netconf-netty-util/src/test/java/org/opendaylight/controller/netconf/nettyutil/handler/NetconfEXIHandlersTest.java @@ -8,15 +8,14 @@ package org.opendaylight.controller.netconf.nettyutil.handler; -import static org.junit.Assert.*; - +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertEquals; import com.google.common.collect.Lists; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; -import java.util.ArrayList; import java.util.Arrays; import java.util.List; import org.custommonkey.xmlunit.XMLUnit; diff --git a/opendaylight/netconf/netconf-netty-util/src/test/java/org/opendaylight/controller/netconf/nettyutil/handler/ssh/client/AsyncSshHandlerTest.java b/opendaylight/netconf/netconf-netty-util/src/test/java/org/opendaylight/controller/netconf/nettyutil/handler/ssh/client/AsyncSshHandlerTest.java index 212eabb290..b4c9e1e950 100644 --- a/opendaylight/netconf/netconf-netty-util/src/test/java/org/opendaylight/controller/netconf/nettyutil/handler/ssh/client/AsyncSshHandlerTest.java +++ b/opendaylight/netconf/netconf-netty-util/src/test/java/org/opendaylight/controller/netconf/nettyutil/handler/ssh/client/AsyncSshHandlerTest.java @@ -22,10 +22,17 @@ import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.mockito.Mockito.verifyZeroInteractions; - +import com.google.common.util.concurrent.FutureCallback; +import com.google.common.util.concurrent.Futures; +import com.google.common.util.concurrent.ListenableFuture; +import com.google.common.util.concurrent.SettableFuture; +import io.netty.buffer.ByteBuf; +import io.netty.buffer.Unpooled; +import io.netty.channel.Channel; +import io.netty.channel.ChannelHandlerContext; +import io.netty.channel.ChannelPromise; import java.io.IOException; import java.net.SocketAddress; - import org.apache.sshd.ClientChannel; import org.apache.sshd.ClientSession; import org.apache.sshd.SshClient; @@ -52,17 +59,6 @@ import org.mockito.invocation.InvocationOnMock; import org.mockito.stubbing.Answer; import org.opendaylight.controller.netconf.nettyutil.handler.ssh.authentication.AuthenticationHandler; -import com.google.common.util.concurrent.FutureCallback; -import com.google.common.util.concurrent.Futures; -import com.google.common.util.concurrent.ListenableFuture; -import com.google.common.util.concurrent.SettableFuture; - -import io.netty.buffer.ByteBuf; -import io.netty.buffer.Unpooled; -import io.netty.channel.Channel; -import io.netty.channel.ChannelHandlerContext; -import io.netty.channel.ChannelPromise; - public class AsyncSshHandlerTest { @Mock @@ -126,7 +122,7 @@ public class AsyncSshHandlerTest { private > ListenableFuture> stubAddListener(final T future) { final SettableFuture> listenerSettableFuture = SettableFuture.create(); - doAnswer(new Answer() { + doAnswer(new Answer() { @Override public Object answer(final InvocationOnMock invocation) throws Throwable { listenerSettableFuture.set((SshFutureListener) invocation.getArguments()[0]); diff --git a/opendaylight/netconf/netconf-util/src/main/java/org/opendaylight/controller/netconf/util/mapping/AbstractNetconfOperation.java b/opendaylight/netconf/netconf-util/src/main/java/org/opendaylight/controller/netconf/util/mapping/AbstractNetconfOperation.java index b6f5854aa3..b7ebc51b70 100644 --- a/opendaylight/netconf/netconf-util/src/main/java/org/opendaylight/controller/netconf/util/mapping/AbstractNetconfOperation.java +++ b/opendaylight/netconf/netconf-util/src/main/java/org/opendaylight/controller/netconf/util/mapping/AbstractNetconfOperation.java @@ -8,8 +8,8 @@ package org.opendaylight.controller.netconf.util.mapping; +import com.google.common.base.Optional; import java.util.Map; - import org.opendaylight.controller.netconf.api.NetconfDocumentedException; import org.opendaylight.controller.netconf.api.xml.XmlNetconfConstants; import org.opendaylight.controller.netconf.mapping.api.HandlingPriority; @@ -17,20 +17,15 @@ import org.opendaylight.controller.netconf.mapping.api.NetconfOperation; import org.opendaylight.controller.netconf.mapping.api.NetconfOperationChainedExecution; import org.opendaylight.controller.netconf.util.xml.XmlElement; import org.opendaylight.controller.netconf.util.xml.XmlUtil; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; import org.w3c.dom.Attr; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.w3c.dom.NodeList; -import com.google.common.base.Optional; - public abstract class AbstractNetconfOperation implements NetconfOperation { private final String netconfSessionIdForReporting; - private static final Logger logger = LoggerFactory.getLogger(AbstractNetconfOperation.class); - protected AbstractNetconfOperation(String netconfSessionIdForReporting) { + protected AbstractNetconfOperation(final String netconfSessionIdForReporting) { this.netconfSessionIdForReporting = netconfSessionIdForReporting; } @@ -39,7 +34,7 @@ public abstract class AbstractNetconfOperation implements NetconfOperation { } @Override - public HandlingPriority canHandle(Document message) throws NetconfDocumentedException { + public HandlingPriority canHandle(final Document message) throws NetconfDocumentedException { OperationNameAndNamespace operationNameAndNamespace = null; operationNameAndNamespace = new OperationNameAndNamespace(message); return canHandle(operationNameAndNamespace.getOperationName(), operationNameAndNamespace.getNamespace()); @@ -49,7 +44,7 @@ public abstract class AbstractNetconfOperation implements NetconfOperation { private final String operationName, namespace; private final XmlElement operationElement; - public OperationNameAndNamespace(Document message) throws NetconfDocumentedException { + public OperationNameAndNamespace(final Document message) throws NetconfDocumentedException { XmlElement requestElement = null; requestElement = getRequestElementWithCheck(message); operationElement = requestElement.getOnlyChildElement(); @@ -70,12 +65,12 @@ public abstract class AbstractNetconfOperation implements NetconfOperation { } } - protected static XmlElement getRequestElementWithCheck(Document message) throws NetconfDocumentedException { + protected static XmlElement getRequestElementWithCheck(final Document message) throws NetconfDocumentedException { return XmlElement.fromDomElementWithExpected(message.getDocumentElement(), XmlNetconfConstants.RPC_KEY, XmlNetconfConstants.URN_IETF_PARAMS_XML_NS_NETCONF_BASE_1_0); } - protected HandlingPriority canHandle(String operationName, String operationNamespace) { + protected HandlingPriority canHandle(final String operationName, final String operationNamespace) { return operationName.equals(getOperationName()) && operationNamespace.equals(getOperationNamespace()) ? getHandlingPriority() : HandlingPriority.CANNOT_HANDLE; @@ -92,8 +87,8 @@ public abstract class AbstractNetconfOperation implements NetconfOperation { protected abstract String getOperationName(); @Override - public Document handle(Document requestMessage, - NetconfOperationChainedExecution subsequentOperation) throws NetconfDocumentedException { + public Document handle(final Document requestMessage, + final NetconfOperationChainedExecution subsequentOperation) throws NetconfDocumentedException { XmlElement requestElement = getRequestElementWithCheck(requestMessage); diff --git a/opendaylight/netconf/netconf-util/src/test/java/org/opendaylight/controller/netconf/util/NetconfUtilTest.java b/opendaylight/netconf/netconf-util/src/test/java/org/opendaylight/controller/netconf/util/NetconfUtilTest.java index b8605d8230..47d0d4c7cc 100644 --- a/opendaylight/netconf/netconf-util/src/test/java/org/opendaylight/controller/netconf/util/NetconfUtilTest.java +++ b/opendaylight/netconf/netconf-util/src/test/java/org/opendaylight/controller/netconf/util/NetconfUtilTest.java @@ -7,14 +7,13 @@ */ package org.opendaylight.controller.netconf.util; +import static org.hamcrest.CoreMatchers.containsString; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.fail; import org.junit.Test; import org.opendaylight.controller.netconf.util.xml.XmlUtil; import org.w3c.dom.Document; -import static org.junit.Assert.assertThat; -import static org.junit.Assert.fail; -import static org.junit.matchers.JUnitMatchers.containsString; - public class NetconfUtilTest { @Test diff --git a/opendaylight/netconf/netconf-util/src/test/java/org/opendaylight/controller/netconf/util/messages/NetconfHelloMessageTest.java b/opendaylight/netconf/netconf-util/src/test/java/org/opendaylight/controller/netconf/util/messages/NetconfHelloMessageTest.java index c39ac8eb10..5a9d07f6b1 100644 --- a/opendaylight/netconf/netconf-util/src/test/java/org/opendaylight/controller/netconf/util/messages/NetconfHelloMessageTest.java +++ b/opendaylight/netconf/netconf-util/src/test/java/org/opendaylight/controller/netconf/util/messages/NetconfHelloMessageTest.java @@ -9,32 +9,32 @@ package org.opendaylight.controller.netconf.util.messages; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; import com.google.common.base.Optional; import java.util.Set; import org.junit.Before; import org.junit.Test; import org.mockito.internal.util.collections.Sets; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import org.opendaylight.controller.netconf.api.NetconfDocumentedException; public class NetconfHelloMessageTest { Set caps; @Before - public void setUp() throws Exception { + public void setUp() { caps = Sets.newSet("cap1"); } @Test - public void testConstructor() throws Exception { + public void testConstructor() throws NetconfDocumentedException { NetconfHelloMessageAdditionalHeader additionalHeader = new NetconfHelloMessageAdditionalHeader("name","host","1","transp","id"); NetconfHelloMessage message = NetconfHelloMessage.createClientHello(caps, Optional.of(additionalHeader)); - assertTrue(message.isHelloMessage(message)); + assertTrue(NetconfHelloMessage.isHelloMessage(message)); assertEquals(Optional.of(additionalHeader), message.getAdditionalHeader()); NetconfHelloMessage serverMessage = NetconfHelloMessage.createServerHello(caps, 100L); - assertTrue(serverMessage.isHelloMessage(serverMessage)); + assertTrue(NetconfHelloMessage.isHelloMessage(serverMessage)); } } diff --git a/opendaylight/netconf/netconf-util/src/test/java/org/opendaylight/controller/netconf/util/messages/NetconfMessageHeaderTest.java b/opendaylight/netconf/netconf-util/src/test/java/org/opendaylight/controller/netconf/util/messages/NetconfMessageHeaderTest.java index cca89aed59..d5ff3380d2 100644 --- a/opendaylight/netconf/netconf-util/src/test/java/org/opendaylight/controller/netconf/util/messages/NetconfMessageHeaderTest.java +++ b/opendaylight/netconf/netconf-util/src/test/java/org/opendaylight/controller/netconf/util/messages/NetconfMessageHeaderTest.java @@ -8,13 +8,12 @@ package org.opendaylight.controller.netconf.util.messages; -import com.google.common.base.Charsets; -import java.util.Arrays; -import org.junit.Test; - import static org.junit.Assert.assertArrayEquals; import static org.junit.Assert.assertEquals; +import com.google.common.base.Charsets; +import org.junit.Test; +@Deprecated public class NetconfMessageHeaderTest { @Test public void testGet() throws Exception { diff --git a/opendaylight/netconf/netconf-util/src/test/java/org/opendaylight/controller/netconf/util/osgi/NetconfConfigUtilTest.java b/opendaylight/netconf/netconf-util/src/test/java/org/opendaylight/controller/netconf/util/osgi/NetconfConfigUtilTest.java index 741d0d2452..ebee41145a 100644 --- a/opendaylight/netconf/netconf-util/src/test/java/org/opendaylight/controller/netconf/util/osgi/NetconfConfigUtilTest.java +++ b/opendaylight/netconf/netconf-util/src/test/java/org/opendaylight/controller/netconf/util/osgi/NetconfConfigUtilTest.java @@ -8,20 +8,18 @@ package org.opendaylight.controller.netconf.util.osgi; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.mockito.Matchers.anyString; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import com.google.common.base.Optional; import io.netty.channel.local.LocalAddress; import java.net.InetSocketAddress; import org.junit.Before; import org.junit.Test; -import org.opendaylight.controller.netconf.util.NetconfUtil; import org.osgi.framework.BundleContext; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; -import static org.mockito.Matchers.anyString; -import static org.mockito.Mockito.doReturn; -import static org.mockito.Mockito.mock; - public class NetconfConfigUtilTest { private BundleContext bundleContext; diff --git a/opendaylight/netconf/netconf-util/src/test/resources/netconfMessages/startExi.xml b/opendaylight/netconf/netconf-util/src/test/resources/netconfMessages/startExi.xml index e7a483e405..5e94ac6110 100644 --- a/opendaylight/netconf/netconf-util/src/test/resources/netconfMessages/startExi.xml +++ b/opendaylight/netconf/netconf-util/src/test/resources/netconfMessages/startExi.xml @@ -1,9 +1,9 @@ - - -pre-compression - - - - - - \ No newline at end of file + + +pre-compression + + + + + + diff --git a/opendaylight/netconf/netconf-util/src/test/resources/netconfMessages/stopExi.xml b/opendaylight/netconf/netconf-util/src/test/resources/netconfMessages/stopExi.xml index 6c0524a4fc..170c753993 100644 --- a/opendaylight/netconf/netconf-util/src/test/resources/netconfMessages/stopExi.xml +++ b/opendaylight/netconf/netconf-util/src/test/resources/netconfMessages/stopExi.xml @@ -1,3 +1,3 @@ - - - \ No newline at end of file + + + diff --git a/opendaylight/northbound/bundlescanner/implementation/src/test/java/org/opendaylight/controller/northbound/bundlescanner/internal/BundleScannerTest.java b/opendaylight/northbound/bundlescanner/implementation/src/test/java/org/opendaylight/controller/northbound/bundlescanner/internal/BundleScannerTest.java index 1c35404c80..13431fbd86 100644 --- a/opendaylight/northbound/bundlescanner/implementation/src/test/java/org/opendaylight/controller/northbound/bundlescanner/internal/BundleScannerTest.java +++ b/opendaylight/northbound/bundlescanner/implementation/src/test/java/org/opendaylight/controller/northbound/bundlescanner/internal/BundleScannerTest.java @@ -7,8 +7,6 @@ */ package org.opendaylight.controller.northbound.bundlescanner.internal; - - import java.io.File; import java.io.FileFilter; import java.net.MalformedURLException; @@ -37,8 +35,8 @@ import org.osgi.framework.Constants; import org.springframework.osgi.mock.MockBundle; import org.springframework.osgi.mock.MockBundleContext; -import static junit.framework.Assert.assertNotNull; import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; public class BundleScannerTest { diff --git a/opendaylight/northbound/topology/src/test/java/org/opendaylight/controller/topology/northbound/TopologyTest.java b/opendaylight/northbound/topology/src/test/java/org/opendaylight/controller/topology/northbound/TopologyTest.java index 298f32877a..bcfa2a9ee9 100644 --- a/opendaylight/northbound/topology/src/test/java/org/opendaylight/controller/topology/northbound/TopologyTest.java +++ b/opendaylight/northbound/topology/src/test/java/org/opendaylight/controller/topology/northbound/TopologyTest.java @@ -7,8 +7,6 @@ */ package org.opendaylight.controller.topology.northbound; - - import org.junit.Test; import org.opendaylight.controller.sal.core.Bandwidth; import org.opendaylight.controller.sal.core.ConstructionException; @@ -28,7 +26,7 @@ import java.util.HashSet; import java.util.List; import java.util.Set; -import static junit.framework.Assert.assertEquals; +import static org.junit.Assert.assertEquals; import static org.junit.Assert.fail; public class TopologyTest {