<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>config-persister-features</artifactId>
- <version>${config.version}</version>
<classifier>features</classifier>
<type>xml</type>
<scope>runtime</scope>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>netconf-features</artifactId>
- <version>${netconf.version}</version>
<classifier>features</classifier>
<type>xml</type>
<scope>runtime</scope>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>config-features</artifactId>
- <version>${config.version}</version>
<classifier>features</classifier>
<type>xml</type>
<scope>runtime</scope>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>config-features</artifactId>
- <version>${config.version}</version>
<classifier>features</classifier>
<type>xml</type>
<scope>runtime</scope>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>features-odl-protocol-framework</artifactId>
- <version>${protocol-framework.version}</version>
<classifier>features</classifier>
<type>xml</type>
<scope>runtime</scope>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>config-features</artifactId>
- <version>${config.version}</version>
<classifier>features</classifier>
<type>xml</type>
<scope>runtime</scope>
<jsr305.api.version>2.0.1</jsr305.api.version>
<jsr311.api.version>1.1.1</jsr311.api.version>
<jsr311.v2.api.version>2.0</jsr311.v2.api.version>
- <junit.version>4.8.1</junit.version>
<karaf.branding.version>1.0.0-SNAPSHOT</karaf.branding.version>
<karaf.shell.version>3.0.0</karaf.shell.version>
<karaf.version>3.0.1</karaf.version>
<sonar.branch>${user.name}-private-view</sonar.branch>
<sonar.host.url>https://sonar.opendaylight.org/</sonar.host.url>
<!-- Sonar properties using jacoco to retrieve integration test results -->
+ <sonar-jacoco-listeners.version>2.4</sonar-jacoco-listeners.version>
<sonar.java.coveragePlugin>jacoco</sonar.java.coveragePlugin>
<sonar.language>java</sonar.language>
+ <sonar.jacoco.reportPath>target/code-coverage/jacoco.exec</sonar.jacoco.reportPath>
+ <sonar.jacoco.itReportPath>target/code-coverage/jacoco-it.exec</sonar.jacoco.itReportPath>
<sonar.skippedModules>org.openflow.openflowj,net.sf.jung2,org.opendaylight.controller.protobuff.messages</sonar.skippedModules>
<spifly.version>1.0.0</spifly.version>
<spring-osgi.version>1.2.1</spring-osgi.version>
<spring-security-karaf.version>3.1.4.RELEASE</spring-security-karaf.version>
<spring-security.version>3.1.3.RELEASE</spring-security.version>
<spring.version>3.1.3.RELEASE</spring.version>
- <sonar.skippedModules>org.openflow.openflowj,net.sf.jung2</sonar.skippedModules>
<statistics.northbound.version>0.4.2-SNAPSHOT</statistics.northbound.version>
<statisticsmanager.implementation.version>0.4.2-SNAPSHOT</statisticsmanager.implementation.version>
<statisticsmanager.version>0.5.1-SNAPSHOT</statisticsmanager.version>
<artifactId>filter-valve</artifactId>
<version>${filtervalve.version}</version>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>flow-management-compatibility</artifactId>
- <version>${mdsal.version}</version>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>flowprogrammer.northbound</artifactId>
<artifactId>sal-distributed-datastore</artifactId>
<version>${mdsal.version}</version>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal-clustering-commons</artifactId>
+ <version>${mdsal.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal-clustering-config</artifactId>
+ <version>${mdsal.version}</version>
+ </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>model-flow-base</artifactId>
<version>${mdsal.version}</version>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller.model</groupId>
- <artifactId>model-flow-management</artifactId>
- <version>${mdsal.version}</version>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller.model</groupId>
<artifactId>model-flow-service</artifactId>
<artifactId>slf4j-simple</artifactId>
<version>${slf4j.version}</version>
</dependency>
- <dependency>
- <groupId>junit</groupId>
- <artifactId>junit</artifactId>
- <version>${junit.version}</version>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>commons.logback_settings</artifactId>
<version>${yangtools.version}</version>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>config-features</artifactId>
+ <version>${config.version}</version>
+ <classifier>features</classifier>
+ <type>xml</type>
+ <scope>runtime</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>features-odl-protocol-framework</artifactId>
+ <version>${protocol-framework.version}</version>
+ <classifier>features</classifier>
+ <type>xml</type>
+ <scope>runtime</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>netconf-features</artifactId>
+ <version>${netconf.version}</version>
+ <classifier>features</classifier>
+ <type>xml</type>
+ <scope>runtime</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>config-persister-features</artifactId>
+ <version>${config.version}</version>
+ <classifier>features</classifier>
+ <type>xml</type>
+ <scope>runtime</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>config-netty-features</artifactId>
+ <version>${config.version}</version>
+ <classifier>features</classifier>
+ <type>xml</type>
+ <scope>runtime</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>features-adsal</artifactId>
+ <version>${sal.version}</version>
+ <classifier>features</classifier>
+ <type>xml</type>
+ <scope>runtime</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>mdsal-features</artifactId>
+ <version>${mdsal.version}</version>
+ <classifier>features</classifier>
+ <type>xml</type>
+ <scope>runtime</scope>
+ </dependency>
</dependencies>
</dependencyManagement>
+ <dependencies>
+ <!-- Sonar -->
+ <dependency>
+ <groupId>org.codehaus.sonar-plugins.java</groupId>
+ <artifactId>sonar-jacoco-listeners</artifactId>
+ <version>${sonar-jacoco-listeners.version}</version>
+ <scope>test</scope>
+ </dependency>
+ </dependencies>
+
<build>
<pluginManagement>
<plugins>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>${jacoco.version}</version>
+ <executions>
+ <execution>
+ <id>prepare-ut-agent</id>
+ <phase>process-test-classes</phase>
+ <goals>
+ <goal>prepare-agent</goal>
+ </goals>
+ <configuration>
+ <destFile>${sonar.jacoco.reportPath}</destFile>
+ <propertyName>jacoco.agent.ut.arg</propertyName>
+ </configuration>
+ </execution>
+ <execution>
+ <id>prepare-it-agent</id>
+ <phase>pre-integration-test</phase>
+ <goals>
+ <goal>prepare-agent</goal>
+ </goals>
+ <configuration>
+ <destFile>${sonar.jacoco.itReportPath}</destFile>
+ <propertyName>jacoco.agent.it.arg</propertyName>
+ </configuration>
+ </execution>
+ </executions>
</plugin>
<plugin>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>maven-failsafe-plugin</artifactId>
<version>${failsafe.version}</version>
<configuration>
- <argLine>${testvm.argLine}</argLine>
+ <argLine>${testvm.argLine} ${jacoco.agent.it.arg}</argLine>
<systemProperties>
<property>
<name>logback.configurationFile</name>
<value>logback.xml</value>
</property>
</systemProperties>
+ <!-- Specific to generate mapping between tests and covered code -->
+ <properties>
+ <property>
+ <name>listener</name>
+ <value>org.sonar.java.jacoco.JUnitListener</value>
+ </property>
+ </properties>
</configuration>
<executions>
<execution>
<artifactId>maven-surefire-plugin</artifactId>
<version>${surefire.version}</version>
<configuration>
- <argLine>${testvm.argLine}</argLine>
+ <argLine>${testvm.argLine} ${jacoco.agent.ut.arg}</argLine>
<systemProperties>
<property>
<name>logback.configurationFile</name>
<value>logback.xml</value>
</property>
</systemProperties>
+ <!-- Specific to generate mapping between tests and covered code -->
+ <properties>
+ <property>
+ <name>listener</name>
+ <value>org.sonar.java.jacoco.JUnitListener</value>
+ </property>
+ </properties>
</configuration>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>build-helper-maven-plugin</artifactId>
</plugin>
+ <plugin>
+ <groupId>org.jacoco</groupId>
+ <artifactId>jacoco-maven-plugin</artifactId>
+ </plugin>
</plugins>
</build>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
</plugin>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-surefire-plugin</artifactId>
- <configuration>
- <forkCount>1</forkCount>
- <reuseForks>false</reuseForks>
- <perCoreThreadCount>false</perCoreThreadCount>
- <threadCount>1</threadCount>
- </configuration>
- </plugin>
</plugins>
</build>
*/
package org.opendaylight.controller.config.manager.impl.runtimembean;
+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.internal.matchers.StringContains.containsString;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Maps;
import java.lang.management.ManagementFactory;
import java.util.Map;
import org.opendaylight.controller.config.manager.impl.jmx.HierarchicalRuntimeBeanRegistrationImpl;
import org.opendaylight.controller.config.manager.impl.jmx.RootRuntimeBeanRegistratorImpl;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Maps;
-
public class RuntimeBeanRegistratorImplTest extends
AbstractLockedPlatformMBeanServerTest {
static final String module1 = "module1";
assertEquals(0, baseJMXRegistrator.getRegisteredObjectNames().size());
}
- protected void checkExists(ObjectName on) throws Exception {
+ protected void checkExists(final ObjectName on) throws Exception {
platformMBeanServer.getMBeanInfo(on);
}
- protected void checkNotExists(ObjectName on) throws Exception {
+ protected void checkNotExists(final ObjectName on) throws Exception {
try {
platformMBeanServer.getMBeanInfo(on);
fail();
}
private HierarchicalRuntimeBeanRegistration createAdditional(
- HierarchicalRuntimeBeanRegistrationImpl rootRegistration)
+ final HierarchicalRuntimeBeanRegistrationImpl rootRegistration)
throws Exception {
HierarchicalRuntimeBeanRegistrationImpl registration = rootRegistration
*/
package org.opendaylight.controller.config.manager.testingservices.parallelapsp.test;
+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.internal.matchers.StringContains.containsString;
import java.util.Map;
+
import javax.management.ObjectName;
+
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
<capability>urn:opendaylight:params:xml:ns:yang:controller:netty:timer?module=netty-timer&revision=2013-11-19</capability>
</required-capabilities>
<configuration>
-
+
<data xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
<modules xmlns="urn:opendaylight:params:xml:ns:yang:controller:config">
<module>
<name>singleton</name>
</module>
</modules>
-
+
<services xmlns="urn:opendaylight:params:xml:ns:yang:controller:config">
<service>
<type xmlns:netty="urn:opendaylight:params:xml:ns:yang:controller:netty">netty:netty-threadgroup</type>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
</plugin>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-surefire-plugin</artifactId>
- <configuration>
- <forkCount>1</forkCount>
- <reuseForks>false</reuseForks>
- <perCoreThreadCount>false</perCoreThreadCount>
- <threadCount>1</threadCount>
- </configuration>
- </plugin>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
</execution>
</executions>
</plugin>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-surefire-plugin</artifactId>
- <configuration>
- <redirectTestOutputToFile>true</redirectTestOutputToFile>
- <parallel>classes</parallel>
- <forkCount>1C</forkCount>
- <reuseForks>false</reuseForks>
- <perCoreThreadCount>true</perCoreThreadCount>
- <threadCount>2</threadCount>
- </configuration>
- </plugin>
<plugin>
<groupId>org.codehaus.groovy.maven</groupId>
<artifactId>gmaven-plugin</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
-
- <build>
- <plugins>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-surefire-plugin</artifactId>
- <configuration>
- <forkCount>1</forkCount>
- <reuseForks>false</reuseForks>
- <perCoreThreadCount>false</perCoreThreadCount>
- </configuration>
- <executions>
- <execution>
- <id>default-test</id>
- <configuration>
- <skip>true</skip>
- </configuration>
- </execution>
- <execution>
- <id>integration-tests</id>
- <goals>
- <goal>test</goal>
- </goals>
- <phase>integration-test</phase>
- <configuration>
- <includes>
- <include>**/org/opendaylight/controller/config/yangjmxgenerator/it/*.java</include>
- </includes>
- <skip>false</skip>
- </configuration>
- </execution>
- </executions>
- </plugin>
- </plugins>
- </build>
</project>
<artifactId>yang-parser-impl</artifactId>
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>org.hamcrest</groupId>
- <artifactId>hamcrest-core</artifactId>
- <version>1.1</version>
- <scope>test</scope>
- </dependency>
</dependencies>
<build>
*/
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.assertTrue;
+import static org.mockito.Mockito.doReturn;
+
+import java.util.ArrayList;
+import java.util.Collection;
import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+
+import javax.management.openmbean.SimpleType;
+
import org.junit.Test;
import org.mockito.Mockito;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.JavaAttribute;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import javax.management.openmbean.SimpleType;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-
-import static junit.framework.Assert.assertNotNull;
-import static junit.framework.Assert.assertNull;
-import static org.hamcrest.CoreMatchers.is;
-
-import static org.junit.Assert.assertThat;
-import static org.mockito.Mockito.doReturn;
-
public class RuntimeBeanEntryTest extends AbstractYangTest {
public static final String PACKAGE_NAME = "packages.sis";
Map<String, RuntimeBeanEntry> runtimeBeans = RuntimeBeanEntry
.extractClassNameToRuntimeBeanMap(PACKAGE_NAME, caseNode, "test-name", new TypeProviderWrapper(new
TypeProviderImpl(context)), "test", jmxImplModule);
- assertThat(runtimeBeans.size(), is(1));
+ assertEquals(1, runtimeBeans.size());
RuntimeBeanEntry runtimeMXBean = runtimeBeans.get("testRuntimeMXBean");
- assertThat(runtimeMXBean.isRoot(), is(true));
- assertThat(runtimeMXBean.getYangName(), is("test-name"));
+ assertTrue(runtimeMXBean.isRoot());
+ assertEquals("test-name", runtimeMXBean.getYangName());
}
@Test
threadsJavaModule, modulesToSIEs, context,
new TypeProviderWrapper(new TypeProviderImpl(context)),
PACKAGE_NAME);
- assertThat(namesToMBEs.isEmpty(), is(false));
+ assertFalse(namesToMBEs.isEmpty());
// get threadfactory-naming bean
ModuleMXBeanEntry threadfactoryNamingMXBean = namesToMBEs
// get runtime beans
Collection<RuntimeBeanEntry> runtimeBeanEntries = threadfactoryNamingMXBean
.getRuntimeBeans();
- assertThat(runtimeBeanEntries.isEmpty(), is(false));
+ assertFalse(runtimeBeanEntries.isEmpty());
// get root runtime bean
RuntimeBeanEntry threadfactoryRuntimeBeanEntry = getRuntimeBeanEntryByJavaName(
runtimeBeanEntries, "NamingThreadFactoryRuntimeMXBean");
assertNotNull(threadfactoryRuntimeBeanEntry);
- assertThat(threadfactoryRuntimeBeanEntry.isRoot(), is(true));
+ assertTrue(threadfactoryRuntimeBeanEntry.isRoot());
// get thread runtime bean
RuntimeBeanEntry runtimeBeanEntry = getRuntimeBeanEntryByJavaName(
assertNotNull(runtimeBeanEntry);
// test thread runtime bean properties
- assertThat(runtimeBeanEntry.getJavaNamePrefix(),
- is(THREAD_RUNTIME_BEAN_JAVA_PREFIX));
- assertThat(runtimeBeanEntry.getPackageName(), is(PACKAGE_NAME));
- assertThat(runtimeBeanEntry.getFullyQualifiedName(runtimeBeanEntry
- .getJavaNameOfRuntimeMXBean()), is(PACKAGE_NAME + "."
- + THREAD_RUNTIME_BEAN_JAVA_NAME));
- assertThat(runtimeBeanEntry.getYangName(),
- is(THREAD_RUNTIME_BEAN_YANG_NAME));
+ assertEquals(THREAD_RUNTIME_BEAN_JAVA_PREFIX, runtimeBeanEntry.getJavaNamePrefix());
+ assertEquals(PACKAGE_NAME, runtimeBeanEntry.getPackageName());
+ assertEquals(PACKAGE_NAME + "." + THREAD_RUNTIME_BEAN_JAVA_NAME,
+ runtimeBeanEntry.getFullyQualifiedName(runtimeBeanEntry
+ .getJavaNameOfRuntimeMXBean()));
+ assertEquals(THREAD_RUNTIME_BEAN_YANG_NAME, runtimeBeanEntry.getYangName());
// get thread runtime bean rpcs
List<RuntimeBeanEntry.Rpc> rpcs = new ArrayList<RuntimeBeanEntry.Rpc>(
runtimeBeanEntry.getRpcs());
- assertThat(rpcs.size(), is(2));
+ assertEquals(2, rpcs.size());
// get sleep rpc and test it
RuntimeBeanEntry.Rpc rpc = getRpcByName(rpcs, SLEEP_RPC_NAME);
assertNotNull(rpc);
- assertThat(rpc.getYangName(), is(SLEEP_RPC_NAME));
+ assertEquals(SLEEP_RPC_NAME, rpc.getYangName());
- assertThat(((JavaAttribute)rpc.getReturnType()).getType().getFullyQualifiedName().endsWith(SLEEP_RPC_OUTPUT), is(true));
+ assertTrue(((JavaAttribute)rpc.getReturnType()).getType().getFullyQualifiedName().endsWith(SLEEP_RPC_OUTPUT));
// get sleep rpc input attribute and test it
List<JavaAttribute> attributes = rpc.getParameters();
- assertThat(attributes.size(), is(1));
+ assertEquals(1, attributes.size());
JavaAttribute attribute = attributes.get(0);
- assertThat(attribute.getAttributeYangName(), is(SLEEP_RPC_INPUT_NAME));
- assertThat(attribute.getType().getName(), is(SLEEP_RPC_INPUT_TYPE));
- assertThat(attribute.getLowerCaseCammelCase(), is(SLEEP_RPC_INPUT_NAME));
- assertThat(attribute.getUpperCaseCammelCase(), is("Millis"));
+ assertEquals(SLEEP_RPC_INPUT_NAME, attribute.getAttributeYangName());
+ assertEquals(SLEEP_RPC_INPUT_TYPE, attribute.getType().getName());
+ assertEquals(SLEEP_RPC_INPUT_NAME, attribute.getLowerCaseCammelCase());
+ assertEquals("Millis", attribute.getUpperCaseCammelCase());
assertNull(attribute.getNullableDefault());
assertNull(attribute.getNullableDescription());
- assertThat(attribute.getOpenType(), is(SimpleType.class));
+ assertTrue(attribute.getOpenType() instanceof SimpleType);
}
private RuntimeBeanEntry getRuntimeBeanEntryByJavaName(
final Collection<RuntimeBeanEntry> runtimeBeanEntries,
- String javaName) {
+ final String javaName) {
if (runtimeBeanEntries != null && !runtimeBeanEntries.isEmpty()) {
for (RuntimeBeanEntry runtimeBeanEntry : runtimeBeanEntries) {
if (runtimeBeanEntry.getJavaNameOfRuntimeMXBean().equals(
}
private RuntimeBeanEntry.Rpc getRpcByName(
- final List<RuntimeBeanEntry.Rpc> rpcs, String name) {
+ final List<RuntimeBeanEntry.Rpc> rpcs, final String name) {
if (rpcs != null && !rpcs.isEmpty()) {
for (RuntimeBeanEntry.Rpc rpc : rpcs) {
if (rpc.getName().equals(name)) {
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>config-netty-features</artifactId>
- <version>${config.version}</version>
<classifier>features</classifier>
<type>xml</type>
<scope>runtime</scope>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>features-adsal</artifactId>
- <version>${sal.version}</version>
<classifier>features</classifier>
<type>xml</type>
<scope>runtime</scope>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>mdsal-features</artifactId>
- <version>${mdsal.version}</version>
<classifier>features</classifier>
<type>xml</type>
<scope>runtime</scope>
<phase>generate-resources</phase>
<configuration>
<outputDirectory>${project.build.directory}/configuration</outputDirectory>
- <includeArtifactIds>sal-rest-connector-config,config-netty-config,md-sal-config,netconf-config,toaster-config,netconf-connector-config</includeArtifactIds>
- <includes>**\/*.xml</includes>
+ <includeArtifactIds>sal-rest-connector-config,config-netty-config,md-sal-config,netconf-config,toaster-config,netconf-connector-config,sal-clustering-config</includeArtifactIds>
+ <includes>**\/*.xml,**/*.conf</includes>
<excludeTransitive>true</excludeTransitive>
<ignorePermissions>false</ignorePermissions>
</configuration>
<artifactId>jeromq</artifactId>
<version>0.3.1</version>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-distributed-datastore</artifactId>
- </dependency>
-
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal-distributed-datastore</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal-clustering-config</artifactId>
+ </dependency>
</dependencies>
</profile>
<profile>
+++ /dev/null
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
- <modelVersion>4.0.0</modelVersion>
- <parent>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>compatibility-parent</artifactId>
- <version>1.1-SNAPSHOT</version>
- </parent>
- <artifactId>flow-management-compatibility</artifactId>
- <packaging>bundle</packaging>
-
- <dependencies>
- <dependency>
- <groupId>com.google.guava</groupId>
- <artifactId>guava</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>forwardingrulesmanager</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-common-util</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-compatibility</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller.model</groupId>
- <artifactId>model-flow-management</artifactId>
- </dependency>
- <dependency>
- <groupId>org.slf4j</groupId>
- <artifactId>slf4j-api</artifactId>
- </dependency>
- <dependency>
- <groupId>junit</groupId>
- <artifactId>junit</artifactId>
- <scope>test</scope>
- </dependency>
- <dependency>
- <groupId>org.mockito</groupId>
- <artifactId>mockito-all</artifactId>
- <scope>test</scope>
- </dependency>
-
- </dependencies>
-
- <build>
- <plugins>
- <plugin>
- <groupId>org.apache.felix</groupId>
- <artifactId>maven-bundle-plugin</artifactId>
- <extensions>true</extensions>
- <configuration>
- <instructions>
- <Bundle-Name>Forwarding Rules Manager Adapter for MD-SAL</Bundle-Name>
- </instructions>
- </configuration>
- </plugin>
- </plugins>
- </build>
- <scm>
- <connection>scm:git:ssh://git.opendaylight.org:29418/controller.git</connection>
- <developerConnection>scm:git:ssh://git.opendaylight.org:29418/controller.git</developerConnection>
- <tag>HEAD</tag>
- <url>https://wiki.opendaylight.org/view/OpenDaylight_Controller:MD-SAL</url>
- </scm>
-</project>
+++ /dev/null
-/**
- * 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.frm.compatibility;
-
-import java.text.MessageFormat;
-import java.util.ArrayList;
-import java.util.List;
-
-import org.opendaylight.controller.forwardingrulesmanager.FlowConfig;
-import org.opendaylight.controller.forwardingrulesmanager.IForwardingRulesManager;
-import org.opendaylight.controller.sal.compatibility.NodeMapping;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.Flows;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.FlowsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.Flow;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.FlowKey;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class ConfigurationReader implements FlowManagementReader {
-
- private final static Logger LOG = LoggerFactory.getLogger(ConfigurationReader.class);
-
- private IForwardingRulesManager manager;
-
- @Override
- public Flows readAllFlows() {
- List<FlowConfig> staticFlows = this.manager.getStaticFlows();
- List<Flow> flowMap = new ArrayList<Flow>(staticFlows.size());
-
- for (FlowConfig conf : staticFlows) {
- flowMap.add(FlowConfigMapping.toConfigurationFlow(conf));
- }
- final FlowsBuilder flowsBuilder = new FlowsBuilder();
- return (flowsBuilder.setFlow(flowMap)).build();
- }
-
- @Override
- public Flow readFlow(final FlowKey key) {
- try {
- final FlowConfig flowConf =
- this.manager.getStaticFlow(String.valueOf(key.getId()), NodeMapping.toADNode(key.getNode()));
- return FlowConfigMapping.toConfigurationFlow(flowConf);
- } catch (Exception e) {
- String errMsg = MessageFormat.format("readFlow by key {} fail", key);
- LOG.error(errMsg, e);
- throw new RuntimeException(errMsg, e);
- }
- }
-
- public IForwardingRulesManager getManager() {
- return this.manager;
- }
-
- public void setManager(final IForwardingRulesManager manager) {
- this.manager = manager;
- }
-}
+++ /dev/null
-/**
- * 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.frm.compatibility;
-
-import org.opendaylight.controller.forwardingrulesmanager.FlowConfig;
-import org.opendaylight.controller.forwardingrulesmanager.IForwardingRulesManager;
-import org.opendaylight.controller.md.sal.common.api.data.DataChangeListener;
-import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler;
-import org.opendaylight.controller.md.sal.common.api.data.DataModification;
-import org.opendaylight.controller.sal.binding.api.data.DataProviderService;
-import org.opendaylight.controller.sal.binding.api.data.RuntimeDataProvider;
-import org.opendaylight.controller.sal.common.util.Arguments;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.Flows;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.FlowKey;
-import org.opendaylight.yangtools.concepts.Registration;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.common.RpcResult;
-import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
-
-import com.google.common.base.Objects;
-import com.google.common.base.Preconditions;
-
-public class FRMRuntimeDataProvider implements RuntimeDataProvider, DataCommitHandler<InstanceIdentifier<? extends DataObject>,DataObject> {
-
- private final static InstanceIdentifier<Flows> FLOWS_PATH = InstanceIdentifier.<Flows> builder(Flows.class).toInstance();
-
- private final FlowManagementReader configuration = new ConfigurationReader();
- private DataChangeListener<InstanceIdentifier<? extends DataObject>, DataObject> changeListener;
- private DataProviderService dataService;
- private IForwardingRulesManager manager;
-
- public Registration init() {
- return this.dataService.registerCommitHandler(FRMRuntimeDataProvider.FLOWS_PATH, this);
- }
-
- @Override
- public DataObject readConfigurationData(final InstanceIdentifier<? extends DataObject> path) {
- return this.readFrom(this.configuration, path);
- }
-
- @Override
- public DataObject readOperationalData(final InstanceIdentifier<? extends DataObject> path) {
- return this.readFrom(this.configuration, path);
- }
-
- public DataObject readFrom(final FlowManagementReader store, final InstanceIdentifier<? extends DataObject> path) {
- if (Objects.equal(FRMRuntimeDataProvider.FLOWS_PATH, path)) {
- return store.readAllFlows();
- }
- if (FRMRuntimeDataProvider.FLOWS_PATH.contains(path)) {
- return store.readFlow(this.toFlowKey(path));
- }
- return null;
- }
-
- @Override
- public FlowCommitTransaction requestCommit(final DataModification<InstanceIdentifier<? extends DataObject>, DataObject> modification) {
- return new FlowCommitTransaction(this, modification);
- }
-
- public FlowKey toFlowKey(final InstanceIdentifier<? extends DataObject> identifier) {
- Preconditions.<InstanceIdentifier<? extends DataObject>> checkNotNull(identifier);
-
- Iterable<PathArgument> path = identifier.getPathArguments();
- PathArgument get = path.iterator().next();
- final Identifier itemKey = Arguments.<IdentifiableItem> checkInstanceOf(get, IdentifiableItem.class).getKey();
- return Arguments.<FlowKey> checkInstanceOf(itemKey, FlowKey.class);
- }
-
- public RpcResult<Void> finish(final FlowCommitTransaction transaction) {
- Iterable<FlowConfig> toRemove = transaction.getToRemove();
- for (final FlowConfig flow : toRemove) {
- this.manager.removeStaticFlow(flow.getName(), flow.getNode());
- }
- Iterable<FlowConfig> toUpdate = transaction.getToUpdate();
- for (final FlowConfig flow : toUpdate) {
- this.manager.removeStaticFlow(flow.getName(), flow.getNode());
- this.manager.addStaticFlow(flow);
- }
- return RpcResultBuilder.<Void> success().build();
- }
-
- public RpcResult<Void> rollback(final FlowCommitTransaction transaction) {
- return null;
- }
-
- public DataProviderService getDataService() {
- return this.dataService;
- }
-
- public void setDataService(final DataProviderService dataService) {
- this.dataService = dataService;
- }
-
- public DataChangeListener<InstanceIdentifier<? extends DataObject>, DataObject> getChangeListener() {
- return this.changeListener;
- }
-
- public void setChangeListener(final DataChangeListener<InstanceIdentifier<? extends DataObject>, DataObject> changeListener) {
- this.changeListener = changeListener;
- }
-
- public IForwardingRulesManager getManager() {
- return this.manager;
- }
-
- public void setManager(final IForwardingRulesManager manager) {
- this.manager = manager;
- }
-}
+++ /dev/null
-/**
- * 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.frm.compatibility;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map.Entry;
-import java.util.Set;
-
-import org.opendaylight.controller.forwardingrulesmanager.FlowConfig;
-import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler.DataCommitTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.DataModification;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.Flow;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.common.RpcResult;
-
-public class FlowCommitTransaction implements DataCommitTransaction<InstanceIdentifier<? extends DataObject>, DataObject> {
-
- private final DataModification<InstanceIdentifier<? extends DataObject>, DataObject> modification;
- private final HashSet<FlowConfig> toAdd = new HashSet<FlowConfig>();
- private final FRMRuntimeDataProvider flowManager;
- private Iterable<FlowConfig> toUpdate;
- private Iterable<FlowConfig> toRemove;
-
- public FlowCommitTransaction(
- final FRMRuntimeDataProvider flowManager,
- final DataModification<InstanceIdentifier<? extends DataObject>, DataObject> modification) {
- this.flowManager = flowManager;
- this.modification = modification;
- this.processModification();
- }
-
- @Override
- public RpcResult<Void> finish() throws IllegalStateException {
- return this.flowManager.finish(this);
- }
-
- @Override
- public RpcResult<Void> rollback() throws IllegalStateException {
- return this.flowManager.rollback(this);
- }
-
- public void processModification() {
- final Set<Entry<InstanceIdentifier<? extends DataObject>, DataObject>> updated =
- this.modification.getUpdatedConfigurationData().entrySet();
- final List<FlowConfig> forUpdate = new ArrayList<FlowConfig>(updated.size());
-
- if (updated != null && !(updated.isEmpty())) {
- for (Entry<InstanceIdentifier<? extends DataObject>, DataObject> entry : updated) {
- if (FlowConfigMapping.isFlowPath(entry.getKey())) {
- forUpdate.add(FlowConfigMapping.toFlowConfig((Flow) entry.getValue()));
- }
- }
- }
- this.toUpdate = Collections.unmodifiableCollection(forUpdate);
-
- final Set<InstanceIdentifier<? extends DataObject>> removedConfigurationData =
- this.modification.getRemovedConfigurationData();
- final List<FlowConfig> forRemove = new ArrayList<FlowConfig>(removedConfigurationData.size());
-
- if (removedConfigurationData != null && !(removedConfigurationData.isEmpty())) {
- for (InstanceIdentifier<? extends DataObject> data : removedConfigurationData) {
- if (FlowConfigMapping.isFlowPath(data)) {
- forRemove.add(FlowConfigMapping.toFlowConfig(data));
- }
- }
- }
- this.toRemove = Collections.unmodifiableCollection(forRemove);
- }
-
- @Override
- public DataModification<InstanceIdentifier<? extends DataObject>, DataObject> getModification() {
- return this.modification;
- }
-
- public FRMRuntimeDataProvider getFlowManager() {
- return this.flowManager;
- }
-
- public HashSet<FlowConfig> getToAdd() {
- return this.toAdd;
- }
-
- public Iterable<FlowConfig> getToUpdate() {
- return this.toUpdate;
- }
-
- public Iterable<FlowConfig> getToRemove() {
- return this.toRemove;
- }
-}
+++ /dev/null
-/**
- * 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.frm.compatibility;
-
-import java.text.MessageFormat;
-import java.util.Iterator;
-
-import org.opendaylight.controller.forwardingrulesmanager.FlowConfig;
-import org.opendaylight.controller.sal.compatibility.MDFlowMapping;
-import org.opendaylight.controller.sal.compatibility.NodeMapping;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.Flow;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.FlowBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.FlowKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.FlowAdded;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class FlowConfigMapping {
-
- private final static Logger LOG = LoggerFactory.getLogger(FlowConfigMapping.class);
-
- /* nodes/node/flow -> 0 / 1 / 2 */
- private static final int FLOW_KEY_IDENTIFIER_DEEP = 2;
-
- public static Flow toConfigurationFlow(final FlowConfig sourceCfg) {
- final FlowAdded source = MDFlowMapping.flowAdded(sourceCfg.getFlow());
- final FlowBuilder flowBuilder = new FlowBuilder();
- flowBuilder.setInstructions(source.getInstructions());
- flowBuilder.setCookie(source.getCookie());
- flowBuilder.setHardTimeout(source.getHardTimeout());
- flowBuilder.setIdleTimeout(source.getIdleTimeout());
- flowBuilder.setMatch(source.getMatch());
- flowBuilder.setNode(source.getNode());
-
- FlowKey flowKey =
- new FlowKey(Long.valueOf(sourceCfg.getName()), flowBuilder.getNode());
- flowBuilder.setKey(flowKey);
- return flowBuilder.build();
- }
-
- public static FlowConfig toFlowConfig(final Flow sourceCfg) {
- try {
- final FlowConfig flowConfig = new FlowConfig();
- flowConfig.setName(String.valueOf(sourceCfg.getId()));
- flowConfig.setNode(NodeMapping.toADNode(sourceCfg.getNode()));
- return flowConfig;
- } catch (Exception e) {
- String errMsg = MessageFormat.format("Convert from Flow {} to FlowConfig fail", sourceCfg);
- LOG.error(errMsg, e);
- throw new RuntimeException(errMsg, e);
- }
- }
-
- public static FlowConfig toFlowConfig(final InstanceIdentifier<? extends Object> identifier) {
- try {
- PathArgument pathArg = FlowConfigMapping.getSecondPathArgumentFromPath(identifier);
- if (pathArg != null) {
- final FlowConfig flowConfig = new FlowConfig();
- FlowKey key = ((IdentifiableItem<Flow, FlowKey>) pathArg).getKey();
- flowConfig.setName(String.valueOf(key.getId()));
- flowConfig.setNode(NodeMapping.toADNode(key.getNode()));
- return flowConfig;
- }
- return null;
- } catch (Exception e) {
- String errMsg = MessageFormat.format("Convert from InstanceIdentifier {} to FlowConfig fail", identifier);
- LOG.error(errMsg, e);
- throw new RuntimeException(errMsg, e);
- }
- }
-
- public static boolean isFlowPath(final InstanceIdentifier<? extends Object> path) {
- PathArgument pathArg = FlowConfigMapping.getSecondPathArgumentFromPath(path);
- if (pathArg == null) {
- return false;
- }
- if (pathArg instanceof IdentifiableItem<?,?>) {
- final Identifiable<?> key = ((IdentifiableItem<?, ? extends Identifiable<?>>) pathArg).getKey();
- if ((key instanceof FlowKey)) {
- return true;
- }
- }
- return false;
- }
-
- private static PathArgument getSecondPathArgumentFromPath(final InstanceIdentifier<? extends Object> path) {
- if (path != null && path.getPathArguments() != null) {
- Iterator<PathArgument> iterator = path.getPathArguments().iterator();
- int deep = 0;
- while (iterator.hasNext()) {
- PathArgument pathArg = iterator.next();
- if (deep == FlowConfigMapping.FLOW_KEY_IDENTIFIER_DEEP) {
- return pathArg;
- }
- deep++;
- }
- }
- return null;
- }
-}
+++ /dev/null
-/**
- * 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.frm.compatibility;
-
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.Flows;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.Flow;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.FlowKey;
-
-public interface FlowManagementReader {
-
- Flows readAllFlows();
-
- Flow readFlow(FlowKey key);
-
-}
+++ /dev/null
-/*
- * 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.frm.compatibility;
-
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ConsumerContext;
-import org.opendaylight.controller.sal.binding.api.data.DataBrokerService;
-import org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.Flows;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.Flow;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.FlowBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.FlowKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-public class SampleConsumer {
-
- ConsumerContext context;
-
- void addFlowExample() {
-
- DataBrokerService dataService = context.getSALService(DataBrokerService.class);
-
- DataModificationTransaction transaction = dataService.beginTransaction();
- Flow flow = createSampleFlow("foo", null);
- InstanceIdentifier<Flow> path = InstanceIdentifier.builder(Flows.class).child(Flow.class, flow.getKey())
- .toInstance();
- transaction.putConfigurationData(path, flow);
-
- transaction.commit();
-
- dataService.readConfigurationData(path);
- }
-
- Flow createSampleFlow(String name, NodeRef node) {
- FlowBuilder ret = new FlowBuilder();
- FlowKey key = new FlowKey(Long.parseLong(name), node);
- ret.setKey(key);
- return ret.build();
- }
-}
+++ /dev/null
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
- <modelVersion>4.0.0</modelVersion>
- <parent>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>compatibility-parent</artifactId>
- <version>1.1-SNAPSHOT</version>
- </parent>
- <artifactId>inventory-topology-compatibility</artifactId>
- <packaging>bundle</packaging>
-
- <dependencies>
- <dependency>
- <groupId>com.google.guava</groupId>
- <artifactId>guava</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>forwardingrulesmanager</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-util</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-common-util</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-compatibility</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>switchmanager</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>topologymanager</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller.model</groupId>
- <artifactId>model-flow-management</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller.model</groupId>
- <artifactId>model-topology</artifactId>
- </dependency>
- <dependency>
- <groupId>org.slf4j</groupId>
- <artifactId>slf4j-api</artifactId>
- </dependency>
- <dependency>
- <groupId>junit</groupId>
- <artifactId>junit</artifactId>
- <scope>test</scope>
- </dependency>
- <dependency>
- <groupId>org.mockito</groupId>
- <artifactId>mockito-all</artifactId>
- <scope>test</scope>
- </dependency>
- </dependencies>
-
- <build>
- <plugins>
- <plugin>
- <groupId>org.apache.felix</groupId>
- <artifactId>maven-bundle-plugin</artifactId>
- <extensions>true</extensions>
- <configuration>
- <instructions>
- <Bundle-Name>Forwarding Rules Manager Adapter
- for MD-SAL</Bundle-Name>
- </instructions>
- </configuration>
- </plugin>
- </plugins>
- </build>
- <scm>
- <connection>scm:git:ssh://git.opendaylight.org:29418/controller.git</connection>
- <developerConnection>scm:git:ssh://git.opendaylight.org:29418/controller.git</developerConnection>
- <tag>HEAD</tag>
- <url>https://wiki.opendaylight.org/view/OpenDaylight_Controller:MD-SAL</url>
- </scm>
-</project>
+++ /dev/null
-/**
- * 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.compatibility.inventory;
-
-import java.util.ArrayList;
-import java.util.Set;
-
-import org.opendaylight.controller.sal.binding.api.data.RuntimeDataProvider;
-import org.opendaylight.controller.sal.compatibility.InventoryMapping;
-import org.opendaylight.controller.switchmanager.ISwitchManager;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodesBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class InventoryReader implements RuntimeDataProvider {
- private static final Logger LOG = LoggerFactory.getLogger(InventoryReader.class);
- private ISwitchManager switchManager;
-
- public ISwitchManager getSwitchManager() {
- return switchManager;
- }
-
- public void setSwitchManager(final ISwitchManager switchManager) {
- this.switchManager = switchManager;
- }
-
- @Override
- public DataObject readConfigurationData(final InstanceIdentifier<? extends DataObject> path) {
- // Topology and Inventory are operational only
- return null;
- }
-
- @SuppressWarnings("unchecked")
- @Override
- public DataObject readOperationalData(final InstanceIdentifier<? extends DataObject> path) {
- final Class<? extends DataObject> type = path.getTargetType();
- if (Nodes.class.equals(type)) {
- return readNodes(((InstanceIdentifier<Nodes>) path));
- }
- if (Node.class.equals(type)) {
- return readNode(((InstanceIdentifier<Node>) path));
- }
- if (NodeConnector.class.equals(type)) {
- return readNodeConnector(((InstanceIdentifier<NodeConnector>) path));
- }
-
- LOG.debug("Unsupported type {}", type);
- return null;
- }
-
- private NodeConnector readNodeConnector(final InstanceIdentifier<NodeConnector> identifier) {
- return constructNodeConnector(InventoryMapping.toAdNodeConnector(identifier));
- }
-
- private Node readNode(final InstanceIdentifier<Node> identifier) {
- return constructNode(InventoryMapping.toAdNode(identifier));
- }
-
- private Node constructNode(final org.opendaylight.controller.sal.core.Node node) {
- final Set<org.opendaylight.controller.sal.core.NodeConnector> connectors = getSwitchManager().getNodeConnectors(node);
- final ArrayList<NodeConnector> tpList = new ArrayList<NodeConnector>(connectors.size());
- for (final org.opendaylight.controller.sal.core.NodeConnector connector : connectors) {
- tpList.add(constructNodeConnector(connector));
- }
-
- return new NodeBuilder()
- .setKey(InventoryMapping.toNodeKey(node))
- .setNodeConnector(tpList)
- .build();
- }
-
- private Nodes readNodes(final InstanceIdentifier<Nodes> identifier) {
- final Set<org.opendaylight.controller.sal.core.Node> nodes = getSwitchManager().getNodes();
- final ArrayList<Node> nodeList = new ArrayList<Node>(nodes.size());
- for (final org.opendaylight.controller.sal.core.Node node : nodes) {
- nodeList.add(constructNode(node));
- }
-
- return new NodesBuilder().setNode(nodeList).build();
- }
-
- private static NodeConnector constructNodeConnector(final org.opendaylight.controller.sal.core.NodeConnector connector) {
- return new NodeConnectorBuilder().setKey(InventoryMapping.toNodeConnectorKey(connector)).build();
- }
-}
+++ /dev/null
-/**
- * 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.compatibility.switchmanager;
-
-import java.net.InetAddress;
-import java.net.NetworkInterface;
-import java.net.SocketException;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Enumeration;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import org.opendaylight.controller.sal.binding.api.data.DataBrokerService;
-import org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction;
-import org.opendaylight.controller.sal.compatibility.NodeMapping;
-import org.opendaylight.controller.sal.core.Bandwidth;
-import org.opendaylight.controller.sal.core.ConstructionException;
-import org.opendaylight.controller.sal.core.Description;
-import org.opendaylight.controller.sal.core.ForwardingMode;
-import org.opendaylight.controller.sal.core.MacAddress;
-import org.opendaylight.controller.sal.core.NodeConnector;
-import org.opendaylight.controller.sal.core.Property;
-import org.opendaylight.controller.sal.core.Tier;
-import org.opendaylight.controller.sal.utils.Status;
-import org.opendaylight.controller.switchmanager.ISwitchManager;
-import org.opendaylight.controller.switchmanager.Subnet;
-import org.opendaylight.controller.switchmanager.Switch;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class CompatibleSwitchManager extends ConfigurableSwitchManager implements ISwitchManager {
- private static final Logger LOG = LoggerFactory.getLogger(CompatibleSwitchManager.class);
-
- private DataBrokerService _dataService;
-
- public DataBrokerService getDataService() {
- return this._dataService;
- }
-
- public void setDataService(final DataBrokerService dataService) {
- this._dataService = dataService;
- }
-
- @Override
- public Status addNodeConnectorProp(final NodeConnector nodeConnector, final Property prop) {
- final DataModificationTransaction it = getDataService().beginTransaction();
- final NodeConnectorRef path = NodeMapping.toNodeConnectorRef(nodeConnector);
- return null;
- }
-
- @Override
- public Property createProperty(final String propName, final String propValue) {
- try {
- if (propName.equalsIgnoreCase(Description.propertyName)) {
- return new Description(propValue);
- } else if (propName.equalsIgnoreCase(Tier.TierPropName)) {
- return new Tier(Integer.parseInt(propValue));
- } else if (propName.equalsIgnoreCase(Bandwidth.BandwidthPropName)) {
- return new Bandwidth(Long.parseLong(propValue));
- } else if (propName.equalsIgnoreCase(ForwardingMode.name)) {
- return new ForwardingMode(Integer.parseInt(propValue));
- } else if (propName.equalsIgnoreCase(MacAddress.name)) {
- return new MacAddress(propValue);
- } else {
- LOG.debug("Not able to create {} property", propName);
- }
- } catch (Exception e) {
- LOG.debug("createProperty caught exception {}", e.getMessage());
- }
-
- return null;
- }
-
- @Override
- public boolean doesNodeConnectorExist(final NodeConnector nc) {
- return (getDataService().readOperationalData(NodeMapping.toNodeConnectorRef(nc).getValue()) != null);
- }
-
- @Override
- public byte[] getControllerMAC() {
- final Enumeration<NetworkInterface> nis;
- try {
- nis = NetworkInterface.getNetworkInterfaces();
- } catch (SocketException e) {
- LOG.error("Failed to acquire list of interfaces, cannot determine controller MAC", e);
- return null;
- }
-
- while (nis.hasMoreElements()) {
- final NetworkInterface ni = nis.nextElement();
- try {
- return ni.getHardwareAddress();
- } catch (SocketException e) {
- LOG.error("Failed to acquire controller MAC from interface {}", ni, e);
- }
- }
-
- // This happens when running controller on windows VM, for example
- // Try parsing the OS command output
- LOG.warn("Failed to acquire controller MAC: No physical interface found");
- return null;
- }
-
- @Override
- public Map<String,Property> getControllerProperties() {
- return Collections.<String, Property>emptyMap();
- }
-
- @Override
- public Property getControllerProperty(final String propertyName) {
- return null;
- }
-
- @Override
- public List<Switch> getNetworkDevices() {
- final InstanceIdentifier<Nodes> path = InstanceIdentifier.builder(Nodes.class).toInstance();
- final Nodes data = ((Nodes) getDataService().readOperationalData(path));
- final ArrayList<Switch> ret = new ArrayList<>();
- for (final Node node : data.getNode()) {
- try {
- ret.add(toSwitch(node));
- } catch (ConstructionException e) {
- throw new IllegalStateException(String.format("Failed to create switch {}", node), e);
- }
- }
- return ret;
- }
-
- @Override
- public NodeConnector getNodeConnector(final org.opendaylight.controller.sal.core.Node node, final String nodeConnectorName) {
- final NodeConnectorKey key = new NodeConnectorKey(new NodeConnectorId(nodeConnectorName));
- try {
- return new NodeConnector(NodeMapping.MD_SAL_TYPE, key, node);
- } catch (ConstructionException e) {
- throw new IllegalStateException(String.format("Failed to create node connector for {} {}", node, nodeConnectorName), e);
- }
- }
-
- @Override
- public Property getNodeConnectorProp(final NodeConnector nodeConnector, final String propName) {
- return getNodeConnectorProps(nodeConnector).get(propName);
- }
-
- @Override
- public Map<String,Property> getNodeConnectorProps(final NodeConnector nodeConnector) {
- final NodeConnectorRef ref = NodeMapping.toNodeConnectorRef(nodeConnector);
- return toAdProperties(readNodeConnector(ref.getValue()));
- }
-
- @Override
- public Set<NodeConnector> getNodeConnectors(final org.opendaylight.controller.sal.core.Node node) {
- final Node data = this.readNode(NodeMapping.toNodeRef(node).getValue());
- final HashSet<NodeConnector> ret = new HashSet<>();
- for (final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector nc : data.getNodeConnector()) {
- try {
- ret.add(new NodeConnector(NodeMapping.MD_SAL_TYPE, nc.getKey(), node));
- } catch (ConstructionException e) {
- throw new IllegalStateException(String.format("Failed to create node {} connector", node, nc.getKey()), e);
- }
- }
- return ret;
- }
-
- @Override
- public String getNodeDescription(final org.opendaylight.controller.sal.core.Node node) {
- return ((Description) getNodeProps(node).get(Description.propertyName)).getValue();
- }
-
- @Override
- public byte[] getNodeMAC(final org.opendaylight.controller.sal.core.Node node) {
- return ((MacAddress) getNodeProps(node).get(MacAddress.name)).getMacAddress();
- }
-
- @Override
- public Property getNodeProp(final org.opendaylight.controller.sal.core.Node node, final String propName) {
- return getNodeProps(node).get(propName);
- }
-
- @Override
- public Map<String,Property> getNodeProps(final org.opendaylight.controller.sal.core.Node node) {
- final NodeRef ref = NodeMapping.toNodeRef(node);
- return toAdProperties(((Node) getDataService().readOperationalData(ref.getValue())));
- }
-
- @Override
- public Set<org.opendaylight.controller.sal.core.Node> getNodes() {
- final InstanceIdentifier<Nodes> path = InstanceIdentifier.builder(Nodes.class).toInstance();
- final Nodes data = ((Nodes) getDataService().readOperationalData(path));
- final HashSet<org.opendaylight.controller.sal.core.Node> ret = new HashSet<>();
- for (final Node node : data.getNode()) {
- try {
- ret.add(new org.opendaylight.controller.sal.core.Node(NodeMapping.MD_SAL_TYPE, node.getKey()));
- } catch (ConstructionException e) {
- throw new IllegalStateException(String.format("Failed to create node for {}", node), e);
- }
- }
- return ret;
- }
-
- private static Switch toSwitch(final Node node) throws ConstructionException {
- return new Switch(new org.opendaylight.controller.sal.core.Node(NodeMapping.MD_SAL_TYPE, node.getKey()));
- }
-
- @Override
- public Set<NodeConnector> getPhysicalNodeConnectors(final org.opendaylight.controller.sal.core.Node node) {
- final NodeRef ref = NodeMapping.toNodeRef(node);
- final Node data = readNode(ref.getValue());
- final HashSet<NodeConnector> ret = new HashSet<>();
- for (final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector nc : data.getNodeConnector()) {
- final FlowCapableNodeConnector flowConnector = nc.getAugmentation(FlowCapableNodeConnector.class);
- try {
- ret.add(new NodeConnector(NodeMapping.MD_SAL_TYPE, nc.getKey(), node));
- } catch (ConstructionException e) {
- throw new IllegalStateException(String.format("Failed to create connector for {} on node {}", nc.getKey(), node), e);
- }
- }
- return ret;
- }
-
- private static Map<String,Property> toAdProperties(final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector connector) {
- return Collections.emptyMap();
- }
-
- private static Map<String,Property> toAdProperties(final Node connector) {
- return Collections.emptyMap();
- }
-
- private Node readNode(final InstanceIdentifier<? extends Object> ref) {
- return (Node) getDataService().readOperationalData((ref));
- }
-
- private org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector readNodeConnector(final InstanceIdentifier<? extends Object> ref) {
- return ((org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector) getDataService().readOperationalData(ref));
- }
-
- @Override
- public List<NodeConnector> getSpanPorts(final org.opendaylight.controller.sal.core.Node node) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public Subnet getSubnetByNetworkAddress(final InetAddress networkAddress) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public Set<NodeConnector> getUpNodeConnectors(final org.opendaylight.controller.sal.core.Node node) {
- final Node data = readNode(NodeMapping.toNodeRef(node).getValue());
- final HashSet<NodeConnector> ret = new HashSet<>();
- for (final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector nc : data.getNodeConnector()) {
- final FlowCapableNodeConnector flowConn = nc.<FlowCapableNodeConnector>getAugmentation(FlowCapableNodeConnector.class);
- if (flowConn != null && flowConn.getState() != null && !flowConn.getState().isLinkDown()) {
- try {
- ret.add(new NodeConnector(NodeMapping.MD_SAL_TYPE, nc.getKey(), node));
- } catch (ConstructionException e) {
- throw new IllegalStateException(String.format("Failed to create node connector for node {} connector {}", node, nc), e);
- }
- }
- }
- return ret;
- }
-
- @Override
- public Boolean isNodeConnectorEnabled(final NodeConnector nodeConnector) {
- final NodeConnectorRef ref = NodeMapping.toNodeConnectorRef(nodeConnector);
- final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector data = readNodeConnector(ref.getValue());
- return true;
- }
-
- @Override
- public boolean isSpecial(final NodeConnector p) {
- final NodeConnectorRef ref = NodeMapping.toNodeConnectorRef(p);
- final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector data = readNodeConnector(ref.getValue());
- return true;
- }
-
- @Override
- public Status removeControllerProperty(final String propertyName) {
- return null;
- }
-
- @Override
- public Status removeNodeAllProps(final org.opendaylight.controller.sal.core.Node node) {
- return null;
- }
-
- @Override
- public Status removeNodeConnectorAllProps(final NodeConnector nodeConnector) {
- return null;
- }
-
- @Override
- public Status removeNodeConnectorProp(final NodeConnector nc, final String propName) {
- return null;
- }
-
- @Override
- public Status removeNodeProp(final org.opendaylight.controller.sal.core.Node node, final String propName) {
- return null;
- }
-
- @Override
- public Status removePortsFromSubnet(final String name, final List<String> nodeConnectors) {
- return null;
- }
-
- @Override
- public Status removeSubnet(final String name) {
- return null;
- }
-
- @Override
- public Status setControllerProperty(final Property property) {
- return null;
- }
-
- @Override
- public void setNodeProp(final org.opendaylight.controller.sal.core.Node node, final Property prop) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public Status addPortsToSubnet(final String name, final List<String> nodeConnectors) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public Set<Switch> getConfiguredNotConnectedSwitches() {
- return null;
- }
-}
+++ /dev/null
-/**
- * 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.compatibility.switchmanager;
-
-import java.util.List;
-
-import org.opendaylight.controller.sal.utils.Status;
-import org.opendaylight.controller.switchmanager.ISwitchManager;
-import org.opendaylight.controller.switchmanager.SpanConfig;
-import org.opendaylight.controller.switchmanager.SubnetConfig;
-import org.opendaylight.controller.switchmanager.SwitchConfig;
-
-/**
- * These methods should be backed by config subsystem.
- */
-public abstract class ConfigurableSwitchManager implements ISwitchManager {
- @Override
- public Status saveSwitchConfig() {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public Status removeSpanConfig(final SpanConfig cfgObject) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public Status addSubnet(final SubnetConfig configObject) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public final Status addSpanConfig(final SpanConfig configObject) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public final List<SpanConfig> getSpanConfigList() {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public final void updateSwitchConfig(final SwitchConfig cfgObject) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public final Status updateNodeConfig(final SwitchConfig switchConfig) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public final SubnetConfig getSubnetConfig(final String subnet) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public final Status removeNodeConfig(final String nodeId) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public final Status removeSubnet(final SubnetConfig configObject) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public final List<SubnetConfig> getSubnetsConfigList() {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public final SwitchConfig getSwitchConfig(final String nodeId) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public Status modifySubnet(final SubnetConfig configObject) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-}
+++ /dev/null
-/**
- * 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.compatibility.topology;
-
-import java.util.Iterator;
-
-import org.opendaylight.controller.sal.compatibility.InventoryMapping;
-import org.opendaylight.controller.sal.core.ConstructionException;
-import org.opendaylight.controller.sal.core.Edge;
-import org.opendaylight.controller.sal.core.NodeConnector;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.LinkId;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Link;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.LinkKey;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
-
-import com.google.common.base.Splitter;
-
-public class TopologyMapping {
- private static final String HEAD_TAIL_STRING = "::::";
- private static final Splitter HEAD_TAIL_SPLITTER = Splitter.on(HEAD_TAIL_STRING);
-
- public TopologyMapping(final TopologyKey path, final InstanceIdentifier<Topology> key) {
- // No-op for now. Multi-instance will require fixing InventoryMapping first.
- }
-
- public Edge toAdTopologyEdge(final InstanceIdentifier<Link> identifier) throws ConstructionException {
- @SuppressWarnings("unchecked")
- final LinkKey linkKey = ((KeyedInstanceIdentifier<Link, LinkKey>)identifier).getKey();
-
- final Iterator<String> it = HEAD_TAIL_SPLITTER.split(linkKey.getLinkId().getValue()).iterator();
- final NodeConnector tail = InventoryMapping.nodeConnectorFromId(it.next());
- final NodeConnector head = InventoryMapping.nodeConnectorFromId(it.next());
- return new Edge(tail, head);
- }
-
- public NodeConnector toAdTopologyNodeConnector(final InstanceIdentifier<TerminationPoint> identifier) {
- @SuppressWarnings("unchecked")
- final TerminationPointKey tpKey = ((KeyedInstanceIdentifier<TerminationPoint, TerminationPointKey>)identifier).getKey();
-
- return InventoryMapping.nodeConnectorFromId(tpKey.getTpId().getValue());
- }
-
- public org.opendaylight.controller.sal.core.Node toAdTopologyNode(final InstanceIdentifier<Node> identifier) {
- @SuppressWarnings("unchecked")
- final NodeKey nodeKey = ((KeyedInstanceIdentifier<Node, NodeKey>)identifier).getKey();
-
- return InventoryMapping.nodeFromNodeId(nodeKey.getNodeId().getValue());
- }
-
- public NodeKey toTopologyNodeKey(final org.opendaylight.controller.sal.core.Node node) {
- return new NodeKey(new NodeId(InventoryMapping.toNodeId(node)));
- }
-
- public TerminationPointKey toTopologyTerminationPointKey(final NodeConnector nc) {
- return new TerminationPointKey(new TpId(InventoryMapping.toNodeConnectorId(nc)));
- }
-
- public LinkKey toTopologyLinkKey(final Edge edge) {
- final TerminationPointKey sourceTp = toTopologyTerminationPointKey(edge.getTailNodeConnector());
- final TerminationPointKey destTp = toTopologyTerminationPointKey(edge.getHeadNodeConnector());
-
- final StringBuilder sb = new StringBuilder();
- sb.append(sourceTp.getTpId().toString());
- sb.append(HEAD_TAIL_STRING);
- sb.append(destTp.getTpId().toString());
- return new LinkKey(new LinkId(sb.toString()));
- }
-}
+++ /dev/null
-/**
- * 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.compatibility.topology;
-
-import java.util.ArrayList;
-import java.util.Map;
-import java.util.Set;
-
-import org.opendaylight.controller.sal.binding.api.data.RuntimeDataProvider;
-import org.opendaylight.controller.sal.core.ConstructionException;
-import org.opendaylight.controller.sal.core.Edge;
-import org.opendaylight.controller.sal.core.NodeConnector;
-import org.opendaylight.controller.sal.core.Property;
-import org.opendaylight.controller.switchmanager.ISwitchManager;
-import org.opendaylight.controller.topologymanager.ITopologyManager;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.link.attributes.DestinationBuilder;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.link.attributes.SourceBuilder;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyBuilder;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Link;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.LinkBuilder;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class TopologyReader implements RuntimeDataProvider {
- private static final Logger LOG = LoggerFactory.getLogger(TopologyReader.class);
- private final InstanceIdentifier<Topology> topologyPath;
- private final TopologyKey topologyKey;
- private final TopologyMapping mapping;
- private ITopologyManager topologyManager;
- private ISwitchManager switchManager;
-
- public ISwitchManager getSwitchManager() {
- return this.switchManager;
- }
-
- public void setSwitchManager(final ISwitchManager switchManager) {
- this.switchManager = switchManager;
- }
-
- public ITopologyManager getTopologyManager() {
- return this.topologyManager;
- }
-
- public void setTopologyManager(final ITopologyManager topologyManager) {
- this.topologyManager = topologyManager;
- }
-
- public TopologyKey getTopologyKey() {
- return this.topologyKey;
- }
-
- public TopologyMapping getMapping() {
- return this.mapping;
- }
-
- public TopologyReader() {
- this.topologyKey = new TopologyKey(new TopologyId("compatibility:ad-sal"));
- this.topologyPath = InstanceIdentifier.builder(NetworkTopology.class)
- .child(Topology.class, topologyKey)
- .toInstance();
- this.mapping = new TopologyMapping(topologyKey, topologyPath);
- }
-
- @Override
- public DataObject readConfigurationData(final InstanceIdentifier<? extends DataObject> path) {
- // Topology and Inventory are operational only
- return null;
- }
-
- @SuppressWarnings("unchecked")
- @Override
- public DataObject readOperationalData(final InstanceIdentifier<? extends DataObject> path) {
- if (!topologyPath.contains(path)) {
- return null;
- }
-
- final Class<? extends DataObject> type = path.getTargetType();
- if (Link.class.equals(type)) {
- return readLink((InstanceIdentifier<Link>) path);
- }
- if (Node.class.equals(type)) {
- return readNode((InstanceIdentifier<Node>) path);
- }
- if (TerminationPoint.class.equals(type)) {
- return readTerminationPoint((InstanceIdentifier<TerminationPoint>) path);
-
- }
- if (Topology.class.equals(type)) {
- return readTopology((InstanceIdentifier<Topology>) path);
- }
-
- LOG.debug("Unsupported type {}", type);
- return null;
- }
-
- private Link readLink(final InstanceIdentifier<Link> identifier) {
- final Edge edge;
- try {
- edge = this.mapping.toAdTopologyEdge(identifier);
- } catch (ConstructionException e) {
- throw new IllegalStateException(String.format("Failed to construct edge for link %s", identifier), e);
- }
-
- final Map<Edge,Set<Property>> edges;
- if (topologyManager != null) {
- edges = topologyManager.getEdges();
- } else {
- edges = null;
- }
-
- final Set<Property> properties;
- if (edges != null) {
- properties = edges.get(edge);
- } else {
- properties = null;
- }
-
- return constructLink(edge);
- }
-
- private TerminationPoint readTerminationPoint(final InstanceIdentifier<TerminationPoint> identifier) {
- return constructTerminationPoint(mapping.toAdTopologyNodeConnector(identifier));
- }
-
- private Node readNode(final InstanceIdentifier<Node> identifier) {
- return constructNode(mapping.toAdTopologyNode(identifier));
- }
-
- private Topology readTopology(final InstanceIdentifier<Topology> identifier) {
- final Set<org.opendaylight.controller.sal.core.Node> nodes = getSwitchManager().getNodes();
- final ArrayList<Node> nodeList = new ArrayList<Node>(nodes.size());
- for (final org.opendaylight.controller.sal.core.Node node : nodes) {
- nodeList.add(constructNode(node));
- }
-
- final Map<Edge,Set<Property>> edges = getTopologyManager().getEdges();
- final ArrayList<Link> linkList = new ArrayList<Link>(edges.size());
- for (final Edge edge : edges.keySet()) {
- linkList.add(constructLink(edge));
- }
-
- return new TopologyBuilder()
- .setKey(topologyKey)
- .setNode(nodeList)
- .setLink(linkList)
- .build();
- }
-
- private Link constructLink(final Edge edge) {
- final NodeConnector sourceNc = edge.getTailNodeConnector();
- final NodeConnector destNc = edge.getHeadNodeConnector();
-
- final LinkBuilder it = new LinkBuilder().setKey(mapping.toTopologyLinkKey(edge));
-
- it.setSource(new SourceBuilder()
- .setSourceNode(mapping.toTopologyNodeKey(sourceNc.getNode()).getNodeId())
- .setSourceTp(mapping.toTopologyTerminationPointKey(sourceNc).getTpId())
- .build());
-
- it.setDestination(new DestinationBuilder()
- .setDestNode(mapping.toTopologyNodeKey(destNc.getNode()).getNodeId())
- .setDestTp(mapping.toTopologyTerminationPointKey(destNc).getTpId())
- .build());
-
- return it.build();
- }
-
- private Node constructNode(final org.opendaylight.controller.sal.core.Node node) {
- final Set<NodeConnector> connectors = getSwitchManager().getNodeConnectors(node);
- final ArrayList<TerminationPoint> tpList = new ArrayList<TerminationPoint>(connectors.size());
- for (final NodeConnector connector : connectors) {
- tpList.add(constructTerminationPoint(connector));
- }
-
- return new NodeBuilder()
- .setKey(mapping.toTopologyNodeKey(node))
- .setTerminationPoint(tpList)
- .build();
- }
-
- private TerminationPoint constructTerminationPoint(final NodeConnector connector) {
- return new TerminationPointBuilder().setKey(mapping.toTopologyTerminationPointKey(connector)).build();
- }
-}
+++ /dev/null
-/**
- * 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.compatibility.topologymanager;
-
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-
-import org.opendaylight.controller.sal.compatibility.NodeMapping;
-import org.opendaylight.controller.sal.core.ConstructionException;
-import org.opendaylight.controller.sal.core.Edge;
-import org.opendaylight.controller.sal.core.NodeConnector;
-import org.opendaylight.controller.sal.core.Property;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.link.attributes.Destination;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.link.attributes.Source;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Link;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-public class AdSalTopologyMapping {
- private final InstanceIdentifier<Topology> topologyPath;
-
- public AdSalTopologyMapping(final TopologyKey topology) {
- this.topologyPath = InstanceIdentifier.builder(NetworkTopology.class)
- .child(Topology.class, topology).toInstance();
- }
-
- public InstanceIdentifier<Topology> getTopologyPath() {
- return topologyPath;
- }
-
- public InstanceIdentifier<TerminationPoint> toTerminationPoint(final NodeConnector connector) {
- return getTopologyPath().builder()
- .child(Node.class)
- .child(TerminationPoint.class, toTerminationPointKey(connector))
- .toInstance();
- }
-
- public Map<Edge,Set<Property>> toEdgePropertiesMap(final Iterable<Link> links) {
- final HashMap<Edge,Set<Property>> ret = new HashMap<>();
- for (final Link link : links) {
- try {
- ret.put(toEdge(link), toProperties(link));
- } catch (ConstructionException e) {
- throw new IllegalStateException(String.format("Failed to create edge properties for {}", link), e);
- }
- }
- return ret;
- }
-
- public static Set<Edge> toEdges(final Iterable<Link> links) throws ConstructionException {
- final HashSet<Edge> ret = new HashSet<Edge>();
- for (final Link link : links) {
- ret.add(toEdge(link));
- }
- return ret;
- }
-
- public static Edge toEdge(final Link link) throws ConstructionException {
- final NodeConnector tail = toNodeConnector(link.getSource());
- final NodeConnector head = toNodeConnector(link.getDestination());
- return new Edge(tail, head);
- }
-
- public static org.opendaylight.controller.sal.core.Node toAdNode(final Node node) throws ConstructionException {
- return toAdNode(node.getNodeId());
- }
-
- public static org.opendaylight.controller.sal.core.Node toAdNode(final NodeId node) throws ConstructionException {
- final NodeKey key = new NodeKey(
- new org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId(node));
- return new org.opendaylight.controller.sal.core.Node(NodeMapping.MD_SAL_TYPE, key);
- }
-
- public static NodeConnector toNodeConnector(final Source ref) throws ConstructionException {
- final org.opendaylight.controller.sal.core.Node adNode = toAdNode(ref.getSourceNode());
- final NodeConnectorKey key = new NodeConnectorKey(new NodeConnectorId(ref.getSourceTp()));
- return new NodeConnector(NodeMapping.MD_SAL_TYPE, key, adNode);
- }
-
- public static NodeConnector toNodeConnector(final Destination ref) throws ConstructionException {
- final org.opendaylight.controller.sal.core.Node adNode = toAdNode(ref.getDestNode());
- final NodeConnectorKey key = new NodeConnectorKey(new NodeConnectorId(ref.getDestTp()));
- return new NodeConnector(NodeMapping.MD_SAL_TYPE, key, adNode);
- }
-
- public TerminationPointKey toTerminationPointKey(final NodeConnector connector) {
- return null;
- }
-
- public Set<Property> toProperties(final Link link) {
- return null;
- }
-}
+++ /dev/null
-/**
- * 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.compatibility.topologymanager;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import org.opendaylight.controller.md.sal.binding.util.TypeSafeDataReader;
-import org.opendaylight.controller.sal.core.ConstructionException;
-import org.opendaylight.controller.sal.core.Edge;
-import org.opendaylight.controller.sal.core.Host;
-import org.opendaylight.controller.sal.core.NodeConnector;
-import org.opendaylight.controller.sal.core.Property;
-import org.opendaylight.controller.sal.core.UpdateType;
-import org.opendaylight.controller.sal.utils.Status;
-import org.opendaylight.controller.topologymanager.ITopologyManager;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Link;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-import com.google.common.base.Predicate;
-import com.google.common.collect.FluentIterable;
-
-@SuppressWarnings("all")
-public class CompatibleTopologyManager extends ConfigurableLinkManager implements ITopologyManager {
- private AdSalTopologyMapping topologyMapping;
- private TypeSafeDataReader dataReader;
-
- public TypeSafeDataReader getDataReader() {
- return dataReader;
- }
-
- public void setDataReader(final TypeSafeDataReader dataReader) {
- this.dataReader = dataReader;
- }
-
- public AdSalTopologyMapping getTopologyMapping() {
- return topologyMapping;
- }
-
- public void setTopologyMapping(final AdSalTopologyMapping topologyMapping) {
- this.topologyMapping = topologyMapping;
- }
-
- @Override
- public Map<Edge,Set<Property>> getEdges() {
- final Topology topology = getDataReader().readOperationalData(topologyMapping.getTopologyPath());
- return this.topologyMapping.toEdgePropertiesMap(topology.getLink());
- }
-
- @Override
- public Map<org.opendaylight.controller.sal.core.Node, Set<Edge>> getNodeEdges() {
- final Topology topology = getDataReader().readOperationalData(topologyMapping.getTopologyPath());
- final HashMap<org.opendaylight.controller.sal.core.Node, Set<Edge>> ret = new HashMap<>();
- for (final Node node : topology.getNode()) {
- try {
- ret.put(topologyMapping.toAdNode(node), topologyMapping.toEdges(
- FluentIterable.from(topology.getLink()).filter(new Predicate<Link>() {
- @Override
- public boolean apply(final Link input) {
- final NodeId nodeId = node.getNodeId();
- if (nodeId.equals(input.getSource().getSourceNode())) {
- return true;
- }
- if (nodeId.equals(input.getDestination().getDestNode())) {
- return true;
- }
-
- return false;
- }
- })));
- } catch (ConstructionException e) {
- throw new IllegalStateException(String.format("Failed to construct node for {}", node), e);
- }
- }
- return ret;
- }
-
- /**
- * Returns true if point is connected to link
- */
- private boolean isInternal(final TerminationPoint point) {
- final Topology topology = getDataReader().readConfigurationData(topologyMapping.getTopologyPath());
- final TpId tpId = point.getKey().getTpId();
- return FluentIterable.from(topology.getLink()).anyMatch(new Predicate<Link>() {
- @Override
- public boolean apply(final Link input) {
- if (tpId.equals(input.getSource().getSourceTp())) {
- return true;
- }
- if (tpId.equals(input.getDestination().getDestTp())) {
- return true;
- }
- return false;
- }
- });
- }
-
- @Override
- public Set<NodeConnector> getNodeConnectorWithHost() {
- return null;
- }
-
- @Override
- public Host getHostAttachedToNodeConnector(final NodeConnector p) {
- final InstanceIdentifier<TerminationPoint> tpPath = topologyMapping.toTerminationPoint(p);
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public List<Host> getHostsAttachedToNodeConnector(final NodeConnector p) {
- final Topology topology = getDataReader().readOperationalData(topologyMapping.getTopologyPath());
- throw new UnsupportedOperationException("Hosts not mapped yet");
- }
-
- @Override
- public Map<org.opendaylight.controller.sal.core.Node, Set<NodeConnector>> getNodesWithNodeConnectorHost() {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public boolean isInternal(final NodeConnector p) {
- final TerminationPoint connector = getDataReader()
- .readConfigurationData(topologyMapping.toTerminationPoint(p));
- return this.isInternal(connector);
- }
-
- @Override
- public void updateHostLink(final NodeConnector p, final Host h, final UpdateType t, final Set<Property> props) {
- // Update app defined topology
- }
-
- @Override
- public Status saveConfig() {
- // FIXME: commit configuration
- return null;
- }
-}
+++ /dev/null
-/**
- * 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.compatibility.topologymanager;
-
-import java.util.concurrent.ConcurrentMap;
-
-import org.opendaylight.controller.sal.utils.Status;
-import org.opendaylight.controller.topologymanager.ITopologyManager;
-import org.opendaylight.controller.topologymanager.TopologyUserLinkConfig;
-
-public abstract class ConfigurableLinkManager implements ITopologyManager {
- @Override
- public final Status addUserLink(final TopologyUserLinkConfig link) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public final Status deleteUserLink(final String linkName) {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-
- @Override
- public final ConcurrentMap<String,TopologyUserLinkConfig> getUserLinks() {
- throw new UnsupportedOperationException("TODO: auto-generated method stub");
- }
-}
<modules>
<module>sal-compatibility</module>
- <module>inventory-topology-compatibility</module>
- <module>flow-management-compatibility</module>
</modules>
<dependencies>
*/
package org.opendaylight.controller.sal.compatibility;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Objects;
+import com.google.common.base.Preconditions;
import java.math.BigInteger;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
-
import org.opendaylight.controller.sal.common.util.Arguments;
import org.opendaylight.controller.sal.core.AdvertisedBandwidth;
import org.opendaylight.controller.sal.core.Bandwidth;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Objects;
-import com.google.common.base.Preconditions;
-
public final class NodeMapping {
private static final Logger LOG = LoggerFactory
.getLogger(NodeMapping.class);
- /** openflow id prefix */
+ /**
+ * openflow id prefix
+ */
public static final String OPENFLOW_ID_PREFIX = "openflow:";
public final static String MD_SAL_TYPE = "MD_SAL_DEPRECATED";
}
public static org.opendaylight.controller.sal.core.Node toADNode(final NodeId id) throws ConstructionException {
- Long aDNodeId = openflowFullNodeIdToLong(NodeMapping.toADNodeId(id));
- return new org.opendaylight.controller.sal.core.Node(NodeIDType.OPENFLOW, aDNodeId);
+ String nodeId = NodeMapping.toADNodeId(id);
+ String nodeIdasNumber = nodeId.replaceFirst("^.*:", "");
+ if (isInteger(nodeIdasNumber)) {
+ Long aDNodeId = openflowFullNodeIdToLong(nodeIdasNumber);
+ return new org.opendaylight.controller.sal.core.Node(NodeIDType.OPENFLOW, aDNodeId);
+ } else {
+ return new org.opendaylight.controller.sal.core.Node(NodeIDType.PRODUCTION, nodeId);
+ }
}
/**
if (adNodeId == null) {
return null;
}
- return new BigInteger(adNodeId.replaceFirst("^.*:", "")).longValue();
+ return new BigInteger(adNodeId).longValue();
}
public static NodeId toNodeId(final InstanceIdentifier<?> id) {
}
/**
- * @param ncid nodeConnector identifier, e.g.: OF:21 or CTRL
- * @param node
+ * @param ncid nodeConnector identifier, e.g.: OF:21 or CTRL
+ * @param aDNode
* @return nodeConnector attached to given node
* @throws ConstructionException
*/
* @return
*/
private static NodeId toNodeId(org.opendaylight.controller.sal.core.Node aDNode) {
- return new NodeId(aDNode.getType() + ":" +String.valueOf(aDNode.getID()));
+ return new NodeId(aDNode.getType() + ":" + String.valueOf(aDNode.getID()));
}
public static String toNodeConnectorType(final NodeConnectorId ncId, final NodeId nodeId) {
public static NodeRef toNodeRef(final org.opendaylight.controller.sal.core.Node node) {
Preconditions.checkArgument(NodeIDType.OPENFLOW.equals(node.getType()));
final Long nodeId = Arguments.<Long>checkInstanceOf(node.getID(), Long.class);
- final NodeKey nodeKey = new NodeKey(new NodeId(OPENFLOW_ID_PREFIX+nodeId));
+ final NodeKey nodeKey = new NodeKey(new NodeId(OPENFLOW_ID_PREFIX + nodeId));
final InstanceIdentifier<Node> nodePath = InstanceIdentifier.builder(Nodes.class).child(NODE_CLASS, nodeKey).toInstance();
return new NodeRef(nodePath);
}
}
/**
- * @param id
+ * @param nodeRef
* @return node description in AD form, e.g.: OF|00:00:00:...:01
*/
private static Description toADDescription(NodeRef nodeRef) {
public static Buffers toADBuffers(final Long buffers) {
return new Buffers(buffers.intValue());
}
+
+
+ private static final boolean isInteger(String value) {
+ if (value.isEmpty()) return false;
+ for (int i = 0; i < value.length(); i++) {
+ if (i == 0 && value.charAt(i) == '-') {
+ if (value.length() == 1) return false;
+ else continue;
+ }
+ if (Character.digit(value.charAt(i), 10) < 0) return false;
+ }
+ return true;
+ }
}
} catch (ConstructionException e) {
Assert.fail("should succeed to construct Node: "+e.getMessage());
}
+
+ final String nodeUriPrefix = "opendaylight-inventory:nodes/node/";
+ nodeId = new NodeId(nodeUriPrefix + "iosv-2");
+ try {
+ observed = NodeMapping.toADNode(nodeId);
+ Assert.assertEquals("PR|opendaylight-inventory:nodes/node/iosv-2", observed.toString());
+ } catch (ConstructionException e) {
+ Assert.fail("should succeed to construct Node: "+e.getMessage());
+ }
+
}
/**
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-api</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller.model</groupId>
- <artifactId>model-flow-management</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller.model</groupId>
<artifactId>model-flow-service</artifactId>
<!--InMemory DOM DataStore-->
<module>sal-inmemory-datastore</module>
- <!--sal-protocolbuffer-encoding-->
- <module>sal-protocolbuffer-encoding</module>
+ <!--sal-protocolbuffer-encoding is now part of sal-clutering-commons-->
+ <module>sal-clustering-commons</module>
+
+ <!-- sal clustering configuration -->
+ <module>sal-clustering-config</module>
<!-- sal-distributed-datastore -->
<module>sal-distributed-datastore</module>
@Override
public List<ReplicatedLogEntry> getFrom(long logEntryIndex) {
+ return getFrom(logEntryIndex, journal.size());
+ }
+
+ @Override
+ public List<ReplicatedLogEntry> getFrom(long logEntryIndex, int max) {
int adjustedIndex = adjustedIndex(logEntryIndex);
int size = journal.size();
List<ReplicatedLogEntry> entries = new ArrayList<>(100);
if (adjustedIndex >= 0 && adjustedIndex < size) {
// physical index should be less than list size and >= 0
- entries.addAll(journal.subList(adjustedIndex, size));
+ int maxIndex = adjustedIndex + max;
+ if(maxIndex > size){
+ maxIndex = size;
+ }
+ entries.addAll(journal.subList(adjustedIndex, maxIndex));
}
return entries;
}
+
@Override
public long size() {
return journal.size();
* Since this is set to 100 milliseconds the Election timeout should be
* at least 200 milliseconds
*/
- protected static final FiniteDuration HEART_BEAT_INTERVAL =
+ public static final FiniteDuration HEART_BEAT_INTERVAL =
new FiniteDuration(100, TimeUnit.MILLISECONDS);
@Override
public FiniteDuration getElectionTimeOutInterval() {
// returns 2 times the heart beat interval
- return HEART_BEAT_INTERVAL.$times(2);
+ return getHeartBeatInterval().$times(2);
}
@Override
replicatedLog.lastIndex(), replicatedLog.snapshotIndex,
replicatedLog.snapshotTerm, replicatedLog.size());
currentBehavior = switchBehavior(RaftState.Follower);
+ onStateChanged();
}
}
RaftState state =
currentBehavior.handleMessage(getSender(), message);
+ RaftActorBehavior oldBehavior = currentBehavior;
currentBehavior = switchBehavior(state);
+ if(oldBehavior != currentBehavior){
+ onStateChanged();
+ }
}
}
String peerAddress = context.getPeerAddress(leaderId);
LOG.debug("getLeader leaderId = " + leaderId + " peerAddress = "
+ peerAddress);
+
+ if(peerAddress == null){
+ return null;
+ }
return context.actorSelection(peerAddress);
}
+ /**
+ *
+ * @return the current leader's id
+ */
+ protected String getLeaderId(){
+ return currentBehavior.getLeaderId();
+ }
+
protected RaftState getRaftState() {
return currentBehavior.state();
}
behavior = new Leader(context);
}
- onStateChanged();
+
return behavior;
}
*/
List<ReplicatedLogEntry> getFrom(long index);
+ /**
+ *
+ * @param index the index of the log entry
+ */
+ List<ReplicatedLogEntry> getFrom(long index, int max);
/**
*
// that has fallen too far behind with the log but yet is not
// eligible to receive a snapshot
entries =
- context.getReplicatedLog().getFrom(nextIndex);
+ context.getReplicatedLog().getFrom(nextIndex, 1);
}
followerActor.tell(
*/
package org.opendaylight.controller.cluster.raft;
+import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@Before
public void setUp() {
replicatedLogImpl = new MockAbstractReplicatedLogImpl();
+ // create a set of initial entries in the in-memory log
+ replicatedLogImpl.append(new MockReplicatedLogEntry(1, 0, new MockPayload("A")));
+ replicatedLogImpl.append(new MockReplicatedLogEntry(1, 1, new MockPayload("B")));
+ replicatedLogImpl.append(new MockReplicatedLogEntry(1, 2, new MockPayload("C")));
+ replicatedLogImpl.append(new MockReplicatedLogEntry(2, 3, new MockPayload("D")));
+
}
@After
@Test
public void testIndexOperations() {
- // create a set of initial entries in the in-memory log
- replicatedLogImpl.append(new MockReplicatedLogEntry(1, 0, new MockPayload("A")));
- replicatedLogImpl.append(new MockReplicatedLogEntry(1, 1, new MockPayload("B")));
- replicatedLogImpl.append(new MockReplicatedLogEntry(1, 2, new MockPayload("C")));
- replicatedLogImpl.append(new MockReplicatedLogEntry(2, 3, new MockPayload("D")));
// check if the values returned are correct, with snapshotIndex = -1
assertEquals("B", replicatedLogImpl.get(1).getData().toString());
}
+ @Test
+ public void testGetFromWithMax(){
+ List<ReplicatedLogEntry> from = replicatedLogImpl.getFrom(0, 1);
+ Assert.assertEquals(1, from.size());
+ Assert.assertEquals(1, from.get(0).getTerm());
+
+ from = replicatedLogImpl.getFrom(0, 20);
+ Assert.assertEquals(4, from.size());
+ Assert.assertEquals(2, from.get(3).getTerm());
+
+ from = replicatedLogImpl.getFrom(1, 2);
+ Assert.assertEquals(2, from.size());
+ Assert.assertEquals(1, from.get(1).getTerm());
+
+ }
+
// create a snapshot for test
public Map takeSnapshot(int numEntries) {
Map map = new HashMap(numEntries);
return entries;
}
+ @Override public List<ReplicatedLogEntry> getFrom(long index, int max) {
+ if(index >= log.size() || index < 0){
+ return Collections.EMPTY_LIST;
+ }
+ List<ReplicatedLogEntry> entries = new ArrayList<>();
+ int maxIndex = (int) index + max;
+ if(maxIndex > log.size()){
+ maxIndex = log.size();
+ }
+
+ for(int i=(int) index ; i < maxIndex ; i++) {
+ entries.add(get(i));
+ }
+ return entries;
+
+ }
+
@Override public long size() {
return log.size();
}
import junit.framework.Assert;
import org.junit.Before;
import org.junit.Test;
+import org.opendaylight.controller.cluster.raft.DefaultConfigParamsImpl;
import org.opendaylight.controller.cluster.raft.MockRaftActorContext;
import org.opendaylight.controller.cluster.raft.RaftActorContext;
import org.opendaylight.controller.cluster.raft.RaftState;
public void testThatAnElectionTimeoutIsTriggered(){
new JavaTestKit(getSystem()) {{
- new Within(duration("1 seconds")) {
+ new Within(DefaultConfigParamsImpl.HEART_BEAT_INTERVAL.$times(6)) {
protected void run() {
Candidate candidate = new Candidate(createActorContext(getTestActor()));
- final Boolean out = new ExpectMsg<Boolean>(duration("1 seconds"), "ElectionTimeout") {
+ final Boolean out = new ExpectMsg<Boolean>(DefaultConfigParamsImpl.HEART_BEAT_INTERVAL.$times(6), "ElectionTimeout") {
// do not put code outside this method, will run afterwards
protected Boolean match(Object in) {
if (in instanceof ElectionTimeout) {
import akka.testkit.JavaTestKit;
import junit.framework.Assert;
import org.junit.Test;
+import org.opendaylight.controller.cluster.raft.DefaultConfigParamsImpl;
import org.opendaylight.controller.cluster.raft.MockRaftActorContext;
import org.opendaylight.controller.cluster.raft.RaftActorContext;
import org.opendaylight.controller.cluster.raft.RaftState;
public void testThatAnElectionTimeoutIsTriggered(){
new JavaTestKit(getSystem()) {{
- new Within(duration("1 seconds")) {
+ new Within(DefaultConfigParamsImpl.HEART_BEAT_INTERVAL.$times(6)) {
protected void run() {
Follower follower = new Follower(createActorContext(getTestActor()));
- final Boolean out = new ExpectMsg<Boolean>(duration("1 seconds"), "ElectionTimeout") {
+ final Boolean out = new ExpectMsg<Boolean>(DefaultConfigParamsImpl.HEART_BEAT_INTERVAL.$times(6), "ElectionTimeout") {
// do not put code outside this method, will run afterwards
protected Boolean match(Object in) {
if (in instanceof ElectionTimeout) {
}
protected Map<InstanceIdentifier<?>, DataObject> toBinding(
+ InstanceIdentifier<?> path,
final Map<YangInstanceIdentifier, ? extends NormalizedNode<?, ?>> normalized) {
Map<InstanceIdentifier<?>, DataObject> newMap = new HashMap<>();
if (potential.isPresent()) {
Entry<InstanceIdentifier<? extends DataObject>, DataObject> binding = potential.get();
newMap.put(binding.getKey(), binding.getValue());
+ } else if (entry.getKey().getLastPathArgument() instanceof YangInstanceIdentifier.AugmentationIdentifier) {
+ DataObject bindingDataObject = getCodec().toBinding(path, entry.getValue());
+ if (bindingDataObject != null) {
+ newMap.put(path, bindingDataObject);
+ }
}
} catch (DeserializationException e) {
LOG.warn("Failed to transform {}, omitting it", entry, e);
}
}
- protected Set<InstanceIdentifier<?>> toBinding(
+ protected Set<InstanceIdentifier<?>> toBinding(InstanceIdentifier<?> path,
final Set<YangInstanceIdentifier> normalized) {
Set<InstanceIdentifier<?>> hashSet = new HashSet<>();
for (YangInstanceIdentifier normalizedPath : normalized) {
if (potential.isPresent()) {
InstanceIdentifier<? extends DataObject> binding = potential.get();
hashSet.add(binding);
+ } else if (normalizedPath.getLastPathArgument() instanceof YangInstanceIdentifier.AugmentationIdentifier) {
+ hashSet.add(path);
}
} catch (DeserializationException e) {
LOG.warn("Failed to transform {}, omitting it", normalizedPath, e);
@Override
public Map<InstanceIdentifier<?>, DataObject> getCreatedData() {
if (createdCache == null) {
- createdCache = Collections.unmodifiableMap(toBinding(domEvent.getCreatedData()));
+ createdCache = Collections.unmodifiableMap(toBinding(path, domEvent.getCreatedData()));
}
return createdCache;
}
@Override
public Map<InstanceIdentifier<?>, DataObject> getUpdatedData() {
if (updatedCache == null) {
- updatedCache = Collections.unmodifiableMap(toBinding(domEvent.getUpdatedData()));
+ updatedCache = Collections.unmodifiableMap(toBinding(path, domEvent.getUpdatedData()));
}
return updatedCache;
@Override
public Set<InstanceIdentifier<?>> getRemovedPaths() {
if (removedCache == null) {
- removedCache = Collections.unmodifiableSet(toBinding(domEvent.getRemovedPaths()));
+ removedCache = Collections.unmodifiableSet(toBinding(path, domEvent.getRemovedPaths()));
}
return removedCache;
}
@Override
public Map<InstanceIdentifier<?>, DataObject> getOriginalData() {
if (originalCache == null) {
- originalCache = Collections.unmodifiableMap(toBinding(domEvent.getOriginalData()));
+ originalCache = Collections.unmodifiableMap(toBinding(path, domEvent.getOriginalData()));
}
return originalCache;
--- /dev/null
+package org.opendaylight.controller.md.sal.binding.impl.test;
+
+import org.junit.Test;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.binding.test.AbstractDataChangeListenerTest;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.augment.rev140709.TreeComplexUsesAugment;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.augment.rev140709.TreeLeafOnlyUsesAugment;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.augment.rev140709.complex.from.grouping.ListViaUses;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.augment.rev140709.complex.from.grouping.ListViaUsesKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.Top;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.two.level.list.TopLevelList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.two.level.list.TopLevelListKey;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import static org.junit.Assert.assertTrue;
+import static org.opendaylight.controller.md.sal.binding.test.AssertCollections.assertContains;
+import static org.opendaylight.controller.md.sal.binding.test.AssertCollections.assertEmpty;
+import static org.opendaylight.controller.md.sal.test.model.util.ListsBindingUtils.top;
+import static org.opendaylight.controller.md.sal.test.model.util.ListsBindingUtils.TOP_FOO_KEY;
+import static org.opendaylight.controller.md.sal.test.model.util.ListsBindingUtils.topLevelList;
+import static org.opendaylight.controller.md.sal.test.model.util.ListsBindingUtils.leafOnlyUsesAugment;
+import static org.opendaylight.controller.md.sal.test.model.util.ListsBindingUtils.complexUsesAugment;
+
+public class Bug1418AugmentationTest extends AbstractDataChangeListenerTest{
+ private static final InstanceIdentifier<Top> TOP = InstanceIdentifier.create(Top.class);
+ private static final InstanceIdentifier<TopLevelList> TOP_FOO = TOP.child(TopLevelList.class, TOP_FOO_KEY);
+ private static final InstanceIdentifier<TreeLeafOnlyUsesAugment> SIMPLE_AUGMENT =
+ TOP.child(TopLevelList.class, TOP_FOO_KEY).augmentation(TreeLeafOnlyUsesAugment.class);
+ private static final InstanceIdentifier<TreeComplexUsesAugment> COMPLEX_AUGMENT =
+ TOP.child(TopLevelList.class, TOP_FOO_KEY).augmentation(TreeComplexUsesAugment.class);
+ private static final ListViaUsesKey LIST_VIA_USES_KEY =
+ new ListViaUsesKey("list key");
+ private static final ListViaUsesKey LIST_VIA_USES_KEY_MOD =
+ new ListViaUsesKey("list key modified");
+
+ @Test
+ public void leafOnlyAugmentationCreatedTest() {
+ TestListener listener = createListener(LogicalDatastoreType.CONFIGURATION, SIMPLE_AUGMENT,
+ AsyncDataBroker.DataChangeScope.SUBTREE);
+ WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
+ writeTx.put(LogicalDatastoreType.CONFIGURATION, TOP, top());
+ writeTx.put(LogicalDatastoreType.CONFIGURATION, TOP_FOO, topLevelList(new TopLevelListKey(TOP_FOO_KEY)));
+ writeTx.put(LogicalDatastoreType.CONFIGURATION, SIMPLE_AUGMENT, leafOnlyUsesAugment("test leaf"));
+ assertCommit(writeTx.submit());
+ assertTrue(listener.hasEvent());
+ AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> event = listener.event();
+ assertContains(event.getCreatedData(), SIMPLE_AUGMENT);
+ assertEmpty(event.getUpdatedData());
+ assertEmpty(event.getOriginalData());
+ assertEmpty(event.getRemovedPaths());
+ }
+
+ @Test
+ public void leafOnlyAugmentationUpdatedTest() {
+ WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
+ writeTx.put(LogicalDatastoreType.CONFIGURATION, TOP, top());
+ writeTx.put(LogicalDatastoreType.CONFIGURATION, TOP_FOO, topLevelList(new TopLevelListKey(TOP_FOO_KEY)));
+ writeTx.put(LogicalDatastoreType.CONFIGURATION, SIMPLE_AUGMENT, leafOnlyUsesAugment("test leaf"));
+ assertCommit(writeTx.submit());
+ TestListener listener = createListener(LogicalDatastoreType.CONFIGURATION, SIMPLE_AUGMENT,
+ AsyncDataBroker.DataChangeScope.SUBTREE);
+ writeTx = getDataBroker().newWriteOnlyTransaction();
+ writeTx.put(LogicalDatastoreType.CONFIGURATION, SIMPLE_AUGMENT, leafOnlyUsesAugment("test leaf changed"));
+ assertCommit(writeTx.submit());
+ assertTrue(listener.hasEvent());
+ AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> event = listener.event();
+ assertContains(event.getUpdatedData(), SIMPLE_AUGMENT);
+ assertContains(event.getOriginalData(), SIMPLE_AUGMENT);
+ assertEmpty(event.getCreatedData());
+ assertEmpty(event.getRemovedPaths());
+ }
+
+ @Test
+ public void leafOnlyAugmentationDeletedTest() {
+ WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
+ writeTx.put(LogicalDatastoreType.CONFIGURATION, TOP, top());
+ writeTx.put(LogicalDatastoreType.CONFIGURATION, TOP_FOO, topLevelList(new TopLevelListKey(TOP_FOO_KEY)));
+ writeTx.put(LogicalDatastoreType.CONFIGURATION, SIMPLE_AUGMENT, leafOnlyUsesAugment("test leaf"));
+ assertCommit(writeTx.submit());
+ TestListener listener = createListener(LogicalDatastoreType.CONFIGURATION, SIMPLE_AUGMENT,
+ AsyncDataBroker.DataChangeScope.SUBTREE);
+ writeTx = getDataBroker().newWriteOnlyTransaction();
+ writeTx.delete(LogicalDatastoreType.CONFIGURATION, SIMPLE_AUGMENT);
+ assertCommit(writeTx.submit());
+ assertTrue(listener.hasEvent());
+ AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> event = listener.event();
+ assertContains(event.getRemovedPaths(), SIMPLE_AUGMENT);
+ assertContains(event.getOriginalData(), SIMPLE_AUGMENT);
+ assertEmpty(event.getCreatedData());
+ assertEmpty(event.getUpdatedData());
+ }
+
+ @Test
+ public void complexAugmentationCreatedTest() {
+ TestListener listener = createListener(LogicalDatastoreType.CONFIGURATION, COMPLEX_AUGMENT,
+ AsyncDataBroker.DataChangeScope.SUBTREE);
+ WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
+ writeTx.put(LogicalDatastoreType.CONFIGURATION, TOP, top());
+ writeTx.put(LogicalDatastoreType.CONFIGURATION, TOP_FOO, topLevelList(new TopLevelListKey(TOP_FOO_KEY)));
+ writeTx.put(LogicalDatastoreType.CONFIGURATION, COMPLEX_AUGMENT, complexUsesAugment(LIST_VIA_USES_KEY));
+ assertCommit(writeTx.submit());
+ assertTrue(listener.hasEvent());
+ AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> event = listener.event();
+ assertContains(event.getCreatedData(), COMPLEX_AUGMENT);
+ assertContains(event.getCreatedData(), COMPLEX_AUGMENT.child(ListViaUses.class, LIST_VIA_USES_KEY));
+ assertEmpty(event.getUpdatedData());
+ assertEmpty(event.getOriginalData());
+ assertEmpty(event.getRemovedPaths());
+ }
+
+ @Test
+ public void complexAugmentationUpdatedTest() {
+ WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
+ writeTx.put(LogicalDatastoreType.CONFIGURATION, TOP, top());
+ writeTx.put(LogicalDatastoreType.CONFIGURATION, TOP_FOO, topLevelList(new TopLevelListKey(TOP_FOO_KEY)));
+ writeTx.put(LogicalDatastoreType.CONFIGURATION, COMPLEX_AUGMENT, complexUsesAugment(LIST_VIA_USES_KEY));
+ assertCommit(writeTx.submit());
+ TestListener listener = createListener(LogicalDatastoreType.CONFIGURATION, COMPLEX_AUGMENT,
+ AsyncDataBroker.DataChangeScope.SUBTREE);
+ writeTx = getDataBroker().newWriteOnlyTransaction();
+ writeTx.put(LogicalDatastoreType.CONFIGURATION, COMPLEX_AUGMENT, complexUsesAugment(LIST_VIA_USES_KEY_MOD));
+ assertCommit(writeTx.submit());
+ assertTrue(listener.hasEvent());
+ AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> event = listener.event();
+ assertContains(event.getUpdatedData(), COMPLEX_AUGMENT);
+ assertContains(event.getCreatedData(), COMPLEX_AUGMENT.child(ListViaUses.class, LIST_VIA_USES_KEY_MOD));
+ assertContains(event.getRemovedPaths(), COMPLEX_AUGMENT.child(ListViaUses.class, LIST_VIA_USES_KEY));
+ assertContains(event.getOriginalData(), COMPLEX_AUGMENT);
+ assertContains(event.getOriginalData(), COMPLEX_AUGMENT.child(ListViaUses.class, LIST_VIA_USES_KEY));
+ }
+}
<type>test-jar</type>
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller.model</groupId>
- <artifactId>model-flow-management</artifactId>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller.model</groupId>
<artifactId>model-flow-service</artifactId>
+++ /dev/null
-/*
- * 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.sal.binding.test.bugfix;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.Callable;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-
-import org.junit.Ignore;
-import org.junit.Test;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
-import org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction;
-import org.opendaylight.controller.sal.binding.test.AbstractDataServiceTest;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PopMplsActionCaseBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.pop.mpls.action._case.PopMplsActionBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.Flows;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.Flow;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.FlowBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.FlowKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.InstructionsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.ApplyActionsCaseBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.apply.actions._case.ApplyActionsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.VlanMatchBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._4.match.TcpMatchBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.vlan.match.fields.VlanIdBuilder;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.common.RpcResult;
-import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
-import com.google.common.util.concurrent.ListeningExecutorService;
-import com.google.common.util.concurrent.MoreExecutors;
-
-@SuppressWarnings("deprecation")
-public class DOMCodecBug01Test extends AbstractDataServiceTest {
-
- private static final long FLOW_ID = 1234;
- private static final String NODE_ID = "node:1";
-
- private static final NodeKey NODE_KEY = new NodeKey(new NodeId(NODE_ID));
-
- private static final InstanceIdentifier<Node> NODE_INSTANCE_ID_BA = InstanceIdentifier.builder(Nodes.class) //
- .child(Node.class, NODE_KEY).toInstance();
-
- private static final NodeRef NODE_REF = new NodeRef(NODE_INSTANCE_ID_BA);
-
- private static final FlowKey FLOW_KEY = new FlowKey(FLOW_ID, NODE_REF);
-
- private static final InstanceIdentifier<? extends DataObject> FLOW_INSTANCE_ID_BA = //
- InstanceIdentifier.builder(Flows.class) //
- .child(Flow.class, FLOW_KEY) //
- .toInstance();
-
-
-
- /**
- *
- * Testcase for https://bugs.opendaylight.org/show_bug.cgi?id=
- *
- * Cannot compile CoDec for
- * org.opendaylight.yang.gen.v1.urn.opendaylight.flow
- * .config.rev130819.flows.Flow
- *
- * When invoking following code in the consumer, user got an
- * IllegalStateException during creation of mapping between Java DTOs and
- * data-dom.
- *
- * Exception was compilation error which was caused by incorect generation
- * of code.
- *
- * Reported by Depthi V V
- *
- * @deprecated This test tests indirect generation, which should be tested
- * different way. the test creates conflicting transactions
- * and assumes correct commit - to test codec generation
- *
- */
- @Test
- @Ignore
- @Deprecated
- public void testIndirectGeneration() throws Exception {
-
- ExecutorService basePool = Executors.newFixedThreadPool(2);
- ListeningExecutorService listenablePool = MoreExecutors.listeningDecorator(basePool);
-
- createFlow();
-
- Object lock = new Object();
- CreateFlowTask task1 = new CreateFlowTask(lock);
- CreateFlowTask task2 = new CreateFlowTask(lock);
- CreateFlowTask task3 = new CreateFlowTask(lock);
-
- ListenableFuture<Void> task1Future = listenablePool.submit(task1);
- ListenableFuture<Void> task2Future = listenablePool.submit(task2);
- ListenableFuture<Void> task3Future = listenablePool.submit(task3);
-
-
- @SuppressWarnings("unchecked")
- ListenableFuture<List<Void>> compositeFuture = Futures.allAsList(task1Future,task2Future,task3Future);
-
- Thread.sleep(500);
- //lock.notifyAll();
- compositeFuture.get();
-
- verifyDataAreStoredProperly();
-
- DataModificationTransaction modification2 = baDataService.beginTransaction();
- modification2.removeConfigurationData(FLOW_INSTANCE_ID_BA);
-
- DataObject originalData = modification2.getOriginalConfigurationData().get(FLOW_INSTANCE_ID_BA);
- assertNotNull(originalData);
- RpcResult<TransactionStatus> ret2 = modification2.commit().get();
-
- assertNotNull(ret2);
- assertEquals(TransactionStatus.COMMITED, ret2.getResult());
-
- // Data are not in the store.
- assertNull(baDataService.readConfigurationData(FLOW_INSTANCE_ID_BA));
-
- }
-
- private void createFlow() throws Exception {
-
- DataModificationTransaction modification = baDataService.beginTransaction();
-
- FlowBuilder flow = new FlowBuilder();
- MatchBuilder match = new MatchBuilder();
- VlanMatchBuilder vlanBuilder = new VlanMatchBuilder();
- VlanIdBuilder vlanIdBuilder = new VlanIdBuilder();
- VlanId vlanId = new VlanId(10);
- vlanBuilder.setVlanId(vlanIdBuilder.setVlanId(vlanId).build());
- match.setVlanMatch(vlanBuilder.build());
-
- flow.setKey(FLOW_KEY);
- flow.setMatch(match.build());
- flow.setNode(NODE_REF);
- InstructionsBuilder instructions = new InstructionsBuilder();
- InstructionBuilder instruction = new InstructionBuilder();
-
- instruction.setOrder(10);
- ApplyActionsBuilder applyActions = new ApplyActionsBuilder();
- List<Action> actionList = new ArrayList<>();
- PopMplsActionBuilder popMplsAction = new PopMplsActionBuilder();
- popMplsAction.setEthernetType(34);
- actionList.add(new ActionBuilder().setAction(new PopMplsActionCaseBuilder().setPopMplsAction(popMplsAction.build()).build()).setOrder(10).build());
-
- applyActions.setAction(actionList );
-
- instruction.setInstruction(new ApplyActionsCaseBuilder().setApplyActions(applyActions.build()).build());
-
-
- List<Instruction> instructionList = Collections.<Instruction>singletonList(instruction.build());
- instructions.setInstruction(instructionList );
-
- flow.setInstructions(instructions.build());
- modification.putConfigurationData(FLOW_INSTANCE_ID_BA, flow.build());
- RpcResult<TransactionStatus> ret = modification.commit().get();
- assertNotNull(ret);
- assertEquals(TransactionStatus.COMMITED, ret.getResult());
- }
-
- private void createFlow2() throws Exception {
- DataModificationTransaction modification = baDataService.beginTransaction();
- long id = 123;
- FlowKey key = new FlowKey(id, new NodeRef(NODE_INSTANCE_ID_BA));
- InstanceIdentifier<?> path1;
- FlowBuilder flow = new FlowBuilder();
- flow.setKey(key);
- MatchBuilder match = new MatchBuilder();
- match.setLayer4Match(new TcpMatchBuilder().build());
- flow.setMatch(match.build());
-
- path1 = InstanceIdentifier.builder(Flows.class).child(Flow.class, key).toInstance();
- // DataObject cls = (DataObject) modification.readConfigurationData(path1);
- modification.putConfigurationData(path1, flow.build());
- modification.commit();
-
- }
-
- private class CreateFlowTask implements Callable<Void> {
-
- public CreateFlowTask(final Object startSync) {
- }
-
- @Override
- public Void call() {
- try {
- //startSyncObj ect.wait();
- //Thread.sleep(500);
- createFlow();
- createFlow2();
- } catch (Exception e) {
- throw new RuntimeException(e);
- }
- return null;
- }
- }
-
- private void verifyDataAreStoredProperly() {
- CompositeNode biFlows = biDataService.readConfigurationData(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.of(Flows.QNAME));
- assertNotNull(biFlows);
- CompositeNode biFlow = biFlows.getFirstCompositeByName(Flow.QNAME);
- assertNotNull(biFlow);
- }
-
-
-}
</parent>
<artifactId>sal-binding-it</artifactId>
- <properties>
- <sonar.jacoco.itReportPath>../sal-binding-broker/target/jacoco-it.exec</sonar.jacoco.itReportPath>
- <!-- Sonar jacoco plugin to get integration test coverage info -->
- <sonar.jacoco.reportPath>../sal-binding-broker/target/jacoco.exec</sonar.jacoco.reportPath>
- </properties>
-
<dependencies>
<dependency>
<groupId>ch.qos.logback</groupId>
<groupId>org.slf4j</groupId>
<artifactId>log4j-over-slf4j</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller.model</groupId>
- <artifactId>model-flow-management</artifactId>
- <scope>provided</scope>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller.model</groupId>
<artifactId>model-flow-service</artifactId>
</lifecycleMappingMetadata>
</configuration>
</plugin>
- <plugin>
- <groupId>org.jacoco</groupId>
- <artifactId>jacoco-maven-plugin</artifactId>
- <version>${jacoco.version}</version>
- <configuration>
- <destFile>../sal-binding-broker/target/jacoco-it.exec</destFile>
- <includes>
- <include>org.opendaylight.controller.*</include>
- </includes>
- </configuration>
- <executions>
- <execution>
- <id>pre-test</id>
- <goals>
- <goal>prepare-agent</goal>
- </goals>
- </execution>
- <execution>
- <id>post-test</id>
- <configuration>
- <skip>true</skip>
- </configuration>
- </execution>
- </executions>
- </plugin>
</plugins>
</pluginManagement>
<plugins>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-surefire-plugin</artifactId>
- <configuration>
- <reuseForks>false</reuseForks>
- </configuration>
- </plugin>
- <plugin>
- <groupId>org.jacoco</groupId>
- <artifactId>jacoco-maven-plugin</artifactId>
- <configuration>
- <includes>
- <include>org.opendaylight.controller.*</include>
- </includes>
- </configuration>
- <executions>
- <execution>
- <id>pre-test</id>
- <goals>
- <goal>prepare-agent</goal>
- </goals>
- </execution>
- <execution>
- <id>post-test</id>
- <goals>
- <goal>report</goal>
- </goals>
- <phase>test</phase>
- </execution>
- </executions>
- </plugin>
<plugin>
<groupId>org.ops4j.pax.exam</groupId>
<artifactId>maven-paxexam-plugin</artifactId>
<version>1.1-SNAPSHOT</version>
</parent>
- <artifactId>sal-protocolbuffer-encoding</artifactId>
+ <artifactId>sal-clustering-commons</artifactId>
<packaging>bundle</packaging>
# org.opendaylight.controller.protobuff.messages to properly exclude from sonar.
########################################################################################################
-protoc --proto_path=src/main/resources --java_out=src/main/java src/main/resources/*.proto
+protoc --proto_path=src/main/resources --proto_path=../sal-akka-raft/src/main/resources --java_out=src/main/java src/main/resources/*.proto
echo "Done generating Java source files."
-/*
- *
- * 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
- *
- */
-
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: CompositeModificationPayload.proto
-/*
- *
- * 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
- *
- */
-
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: Cohort.proto
-/*
- *
- * 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
- *
- */
-
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: Common.proto
-/*
- *
- * 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
- *
- */
-
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: SimpleNormalizedNode.proto
-/*
- *
- * 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
- *
- */
-
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: DataChangeListener.proto
-/*
- *
- * 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
- *
- */
-
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: Persistent.proto
-/*
- *
- * 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
- *
- */
-
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: ListenerRegistration.proto
-/*
- *
- * 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
- *
- */
-
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: ShardManager.proto
-/*
- *
- * 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
- *
- */
-
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: ShardTransactionChain.proto
-/*
- *
- * 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
- *
- */
-
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: ShardTransaction.proto
*/
com.google.protobuf.ByteString
getTransactionIdBytes();
+
+ // required int32 transactionType = 2;
+ /**
+ * <code>required int32 transactionType = 2;</code>
+ */
+ boolean hasTransactionType();
+ /**
+ * <code>required int32 transactionType = 2;</code>
+ */
+ int getTransactionType();
}
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.CreateTransaction}
transactionId_ = input.readBytes();
break;
}
+ case 16: {
+ bitField0_ |= 0x00000002;
+ transactionType_ = input.readInt32();
+ break;
+ }
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
}
}
+ // required int32 transactionType = 2;
+ public static final int TRANSACTIONTYPE_FIELD_NUMBER = 2;
+ private int transactionType_;
+ /**
+ * <code>required int32 transactionType = 2;</code>
+ */
+ public boolean hasTransactionType() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>required int32 transactionType = 2;</code>
+ */
+ public int getTransactionType() {
+ return transactionType_;
+ }
+
private void initFields() {
transactionId_ = "";
+ transactionType_ = 0;
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
memoizedIsInitialized = 0;
return false;
}
+ if (!hasTransactionType()) {
+ memoizedIsInitialized = 0;
+ return false;
+ }
memoizedIsInitialized = 1;
return true;
}
if (((bitField0_ & 0x00000001) == 0x00000001)) {
output.writeBytes(1, getTransactionIdBytes());
}
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ output.writeInt32(2, transactionType_);
+ }
getUnknownFields().writeTo(output);
}
size += com.google.protobuf.CodedOutputStream
.computeBytesSize(1, getTransactionIdBytes());
}
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeInt32Size(2, transactionType_);
+ }
size += getUnknownFields().getSerializedSize();
memoizedSerializedSize = size;
return size;
super.clear();
transactionId_ = "";
bitField0_ = (bitField0_ & ~0x00000001);
+ transactionType_ = 0;
+ bitField0_ = (bitField0_ & ~0x00000002);
return this;
}
to_bitField0_ |= 0x00000001;
}
result.transactionId_ = transactionId_;
+ if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+ to_bitField0_ |= 0x00000002;
+ }
+ result.transactionType_ = transactionType_;
result.bitField0_ = to_bitField0_;
onBuilt();
return result;
transactionId_ = other.transactionId_;
onChanged();
}
+ if (other.hasTransactionType()) {
+ setTransactionType(other.getTransactionType());
+ }
this.mergeUnknownFields(other.getUnknownFields());
return this;
}
return false;
}
+ if (!hasTransactionType()) {
+
+ return false;
+ }
return true;
}
return this;
}
+ // required int32 transactionType = 2;
+ private int transactionType_ ;
+ /**
+ * <code>required int32 transactionType = 2;</code>
+ */
+ public boolean hasTransactionType() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>required int32 transactionType = 2;</code>
+ */
+ public int getTransactionType() {
+ return transactionType_;
+ }
+ /**
+ * <code>required int32 transactionType = 2;</code>
+ */
+ public Builder setTransactionType(int value) {
+ bitField0_ |= 0x00000002;
+ transactionType_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>required int32 transactionType = 2;</code>
+ */
+ public Builder clearTransactionType() {
+ bitField0_ = (bitField0_ & ~0x00000002);
+ transactionType_ = 0;
+ onChanged();
+ return this;
+ }
+
// @@protoc_insertion_point(builder_scope:org.opendaylight.controller.mdsal.CreateTransaction)
}
java.lang.String[] descriptorData = {
"\n\026ShardTransaction.proto\022!org.opendaylig" +
"ht.controller.mdsal\032\014Common.proto\"\022\n\020Clo" +
- "seTransaction\"\027\n\025CloseTransactionReply\"*" +
+ "seTransaction\"\027\n\025CloseTransactionReply\"C" +
"\n\021CreateTransaction\022\025\n\rtransactionId\030\001 \002" +
- "(\t\"M\n\026CreateTransactionReply\022\034\n\024transact" +
- "ionActorPath\030\001 \002(\t\022\025\n\rtransactionId\030\002 \002(" +
- "\t\"\022\n\020ReadyTransaction\"*\n\025ReadyTransactio" +
- "nReply\022\021\n\tactorPath\030\001 \002(\t\"l\n\nDeleteData\022" +
- "^\n\037instanceIdentifierPathArguments\030\001 \002(\013" +
- "25.org.opendaylight.controller.mdsal.Ins",
- "tanceIdentifier\"\021\n\017DeleteDataReply\"j\n\010Re" +
- "adData\022^\n\037instanceIdentifierPathArgument" +
- "s\030\001 \002(\01325.org.opendaylight.controller.md" +
- "sal.InstanceIdentifier\"P\n\rReadDataReply\022" +
- "?\n\016normalizedNode\030\001 \001(\0132\'.org.opendaylig" +
- "ht.controller.mdsal.Node\"\254\001\n\tWriteData\022^" +
- "\n\037instanceIdentifierPathArguments\030\001 \002(\0132" +
- "5.org.opendaylight.controller.mdsal.Inst" +
- "anceIdentifier\022?\n\016normalizedNode\030\002 \002(\0132\'" +
- ".org.opendaylight.controller.mdsal.Node\"",
- "\020\n\016WriteDataReply\"\254\001\n\tMergeData\022^\n\037insta" +
+ "(\t\022\027\n\017transactionType\030\002 \002(\005\"M\n\026CreateTra" +
+ "nsactionReply\022\034\n\024transactionActorPath\030\001 " +
+ "\002(\t\022\025\n\rtransactionId\030\002 \002(\t\"\022\n\020ReadyTrans" +
+ "action\"*\n\025ReadyTransactionReply\022\021\n\tactor" +
+ "Path\030\001 \002(\t\"l\n\nDeleteData\022^\n\037instanceIden" +
+ "tifierPathArguments\030\001 \002(\01325.org.opendayl",
+ "ight.controller.mdsal.InstanceIdentifier" +
+ "\"\021\n\017DeleteDataReply\"j\n\010ReadData\022^\n\037insta" +
"nceIdentifierPathArguments\030\001 \002(\01325.org.o" +
"pendaylight.controller.mdsal.InstanceIde" +
- "ntifier\022?\n\016normalizedNode\030\002 \002(\0132\'.org.op" +
- "endaylight.controller.mdsal.Node\"\020\n\016Merg" +
- "eDataReplyBV\n:org.opendaylight.controlle" +
- "r.protobuff.messages.transactionB\030ShardT" +
- "ransactionMessages"
+ "ntifier\"P\n\rReadDataReply\022?\n\016normalizedNo" +
+ "de\030\001 \001(\0132\'.org.opendaylight.controller.m" +
+ "dsal.Node\"\254\001\n\tWriteData\022^\n\037instanceIdent" +
+ "ifierPathArguments\030\001 \002(\01325.org.opendayli" +
+ "ght.controller.mdsal.InstanceIdentifier\022" +
+ "?\n\016normalizedNode\030\002 \002(\0132\'.org.opendaylig",
+ "ht.controller.mdsal.Node\"\020\n\016WriteDataRep" +
+ "ly\"\254\001\n\tMergeData\022^\n\037instanceIdentifierPa" +
+ "thArguments\030\001 \002(\01325.org.opendaylight.con" +
+ "troller.mdsal.InstanceIdentifier\022?\n\016norm" +
+ "alizedNode\030\002 \002(\0132\'.org.opendaylight.cont" +
+ "roller.mdsal.Node\"\020\n\016MergeDataReplyBV\n:o" +
+ "rg.opendaylight.controller.protobuff.mes" +
+ "sages.transactionB\030ShardTransactionMessa" +
+ "ges"
};
com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
internal_static_org_opendaylight_controller_mdsal_CreateTransaction_fieldAccessorTable = new
com.google.protobuf.GeneratedMessage.FieldAccessorTable(
internal_static_org_opendaylight_controller_mdsal_CreateTransaction_descriptor,
- new java.lang.String[] { "TransactionId", });
+ new java.lang.String[] { "TransactionId", "TransactionType", });
internal_static_org_opendaylight_controller_mdsal_CreateTransactionReply_descriptor =
getDescriptor().getMessageTypes().get(3);
internal_static_org_opendaylight_controller_mdsal_CreateTransactionReply_fieldAccessorTable = new
message CreateTransaction{
required string transactionId = 1;
+ required int32 transactionType =2;
}
message CreateTransactionReply{
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ 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
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+
+ <modelVersion>4.0.0</modelVersion>
+ <parent>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal-parent</artifactId>
+ <version>1.1-SNAPSHOT</version>
+ </parent>
+ <artifactId>sal-clustering-config</artifactId>
+ <description>Configuration files for md-sal clustering</description>
+ <packaging>jar</packaging>
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>build-helper-maven-plugin</artifactId>
+ <executions>
+ <execution>
+ <id>attach-artifacts</id>
+ <goals>
+ <goal>attach-artifact</goal>
+ </goals>
+ <phase>package</phase>
+ <configuration>
+ <artifacts>
+ <artifact>
+ <file>${project.build.directory}/classes/initial/*.conf</file>
+ <type>xml</type>
+ <classifier>config</classifier>
+ </artifact>
+ </artifacts>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ </build>
+</project>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- vi: set et smarttab sw=4 tabstop=4: -->
+<!--
+ 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
+-->
+<snapshot>
+ <configuration>
+ <data xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
+ <modules xmlns="urn:opendaylight:params:xml:ns:yang:controller:config">
+ <module>
+ <type xmlns:prefix="urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:impl">prefix:dom-inmemory-data-broker</type>
+ <name>inmemory-data-broker</name>
+
+ <schema-service>
+ <type xmlns:dom="urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom">dom:schema-service</type>
+ <name>yang-schema-service</name>
+ </schema-service>
+
+ <config-data-store>
+ <type xmlns:config-dom-store-spi="urn:opendaylight:params:xml:ns:yang:controller:md:sal:core:spi:config-dom-store">config-dom-store-spi:config-dom-datastore</type>
+ <name>distributed-config-store-service</name>
+ </config-data-store>
+
+ <operational-data-store>
+ <type xmlns:operational-dom-store-spi="urn:opendaylight:params:xml:ns:yang:controller:md:sal:core:spi:operational-dom-store">operational-dom-store-spi:operational-dom-datastore</type>
+ <name>distributed-operational-store-service</name>
+ </operational-data-store>
+ </module>
+
+ <module>
+ <type xmlns:prefix="urn:opendaylight:params:xml:ns:yang:controller:config:distributed-datastore-provider">prefix:distributed-operational-datastore-provider</type>
+ <name>distributed-operational-store-module</name>
+ <schema-service>
+ <type xmlns:dom="urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom">dom:schema-service</type>
+ <name>yang-schema-service</name>
+ </schema-service>
+ </module>
+
+ <module>
+ <type xmlns:prefix="urn:opendaylight:params:xml:ns:yang:controller:config:distributed-datastore-provider">prefix:distributed-config-datastore-provider</type>
+ <name>distributed-config-store-module</name>
+ <schema-service>
+ <type xmlns:dom="urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom">dom:schema-service</type>
+ <name>yang-schema-service</name>
+ </schema-service>
+ </module>
+
+ <module>
+ <type xmlns:prefix="urn:opendaylight:params:xml:ns:yang:controller:config:remote-rpc-connector">prefix:remote-rpc-connector</type>
+ <name>remote-rpc-connector</name>
+ <dom-broker xmlns="urn:opendaylight:params:xml:ns:yang:controller:config:remote-rpc-connector">
+ <type xmlns:dom="urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom">dom:dom-broker-osgi-registry</type>
+ <name>dom-broker</name>
+ </dom-broker>
+ </module>
+
+ </modules>
+ <services xmlns="urn:opendaylight:params:xml:ns:yang:controller:config">
+
+ <service>
+ <type xmlns:config-dom-store-spi="urn:opendaylight:params:xml:ns:yang:controller:md:sal:core:spi:config-dom-store">config-dom-store-spi:config-dom-datastore</type>
+ <instance>
+ <name>distributed-config-store-service</name>
+ <provider>/modules/module[type='distributed-config-datastore-provider'][name='distributed-config-store-module']</provider>
+ </instance>
+ </service>
+ <service>
+ <type xmlns:operational-dom-store-spi="urn:opendaylight:params:xml:ns:yang:controller:md:sal:core:spi:operational-dom-store">operational-dom-store-spi:operational-dom-datastore</type>
+ <instance>
+ <name>distributed-operational-store-service</name>
+ <provider>/modules/module[type='distributed-operational-datastore-provider'][name='distributed-operational-store-module']</provider>
+ </instance>
+ </service>
+
+ </services>
+ </data>
+ </configuration>
+ <required-capabilities>
+ <capability>urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:impl?module=opendaylight-sal-dom-broker-impl&revision=2013-10-28</capability>
+ </required-capabilities>
+</snapshot>
--- /dev/null
+
+odl-cluster-data {
+ akka {
+ actor {
+ provider = "akka.cluster.ClusterActorRefProvider"
+ serializers {
+ java = "akka.serialization.JavaSerializer"
+ proto = "akka.remote.serialization.ProtobufSerializer"
+ }
+
+ serialization-bindings {
+ "com.google.protobuf.Message" = proto
+
+ }
+ }
+ remote {
+ log-remote-lifecycle-events = off
+ netty.tcp {
+ hostname = "<CHANGE_ME>"
+ port = 2550
+ maximum-frame-size = 2097152
+ send-buffer-size = 52428800
+ receive-buffer-size = 52428800
+ }
+ }
+
+ cluster {
+ seed-nodes = ["akka.tcp://opendaylight-cluster-data@<CHANGE_ME>:2550"]
+
+ auto-down-unreachable-after = 10s
+ }
+ }
+}
+
+odl-cluster-rpc {
+ akka {
+ actor {
+ provider = "akka.cluster.ClusterActorRefProvider"
+
+ }
+ remote {
+ log-remote-lifecycle-events = off
+ netty.tcp {
+ hostname = "<CHANGE_ME>"
+ port = 2551
+ }
+ }
+
+ cluster {
+ seed-nodes = ["akka.tcp://opendaylight-cluster-rpc@<CHANGE_ME>:2551"]
+
+ auto-down-unreachable-after = 10s
+ }
+ }
+}
--- /dev/null
+# This file describes which shards live on which members
+# The format for a module-shards is as follows,
+# {
+# name = "<friendly_name_of_the_module>"
+# shards = [
+# {
+# name="<any_name_that_is_unique_for_the_module>"
+# replicas = [
+# "<name_of_member_on_which_to_run>"
+# ]
+# ]
+# }
+#
+# For Helium we support only one shard per module. Beyond Helium
+# we will support more than 1
+# The replicas section is a collection of member names. This information
+# will be used to decide on which members replicas of a particular shard will be
+# located. Once replication is integrated with the distributed data store then
+# this section can have multiple entries.
+#
+#
+
+
+module-shards = [
+ {
+ name = "default"
+ shards = [
+ {
+ name="default"
+ replicas = [
+ "member-1"
+ ]
+ }
+ ]
+ },
+ {
+ name = "topology"
+ shards = [
+ {
+ name="topology"
+ replicas = [
+ "member-1"
+ ]
+ }
+ ]
+ },
+ {
+ name = "inventory"
+ shards = [
+ {
+ name="inventory"
+ replicas = [
+ "member-1"
+ ]
+ }
+ ]
+ },
+ {
+ name = "toaster"
+ shards = [
+ {
+ name="toaster"
+ replicas = [
+ "member-1"
+ ]
+ }
+ ]
+ }
+
+]
--- /dev/null
+# This file should describe all the modules that need to be placed in a separate shard
+# The format of the configuration is as follows
+# {
+# name = "<friendly_name_of_module>"
+# namespace = "<the yang namespace of the module>"
+# shard-strategy = "module"
+# }
+#
+# Note that at this time the only shard-strategy we support is module which basically
+# will put all the data of a single module in two shards (one for config and one for
+# operational data)
+
+modules = [
+ {
+ name = "inventory"
+ namespace = "urn:opendaylight:inventory"
+ shard-strategy = "module"
+ },
+
+ {
+ name = "topology"
+ namespace = "urn:TBD:params:xml:ns:yang:network-topology"
+ shard-strategy = "module"
+ },
+
+ {
+ name = "toaster"
+ namespace = "http://netconfcentral.org/ns/toaster"
+ shard-strategy = "module"
+ }
+
+]
--- /dev/null
+/*
+ * Copyright (c) 2014 Brocade Communications 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.common.api.data;
+
+import org.opendaylight.yangtools.yang.common.RpcError;
+import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
+
+import com.google.common.base.Function;
+
+/**
+ * A type of TransactionCommitFailedException that indicates a situation that would result in a
+ * threading deadlock. This can occur if a caller that submits a write transaction tries to perform
+ * a blocking call via one of the <code>get</code> methods on the returned ListenableFuture. Callers
+ * should process the commit result asynchronously (via Futures#addCallback) to ensure deadlock
+ * won't occur.
+ *
+ * @author Thomas Pantelis
+ */
+public class TransactionCommitDeadlockException extends TransactionCommitFailedException {
+
+ private static final long serialVersionUID = 1L;
+
+ private static final String DEADLOCK_MESSAGE =
+ "An attempt to block on a ListenableFuture via a get method from a write " +
+ "transaction submit was detected that would result in deadlock. The commit " +
+ "result must be obtained asynchronously, e.g. via Futures#addCallback, to avoid deadlock.";
+
+ public static Function<Void, Exception> DEADLOCK_EXECUTOR_FUNCTION = new Function<Void, Exception>() {
+ @Override
+ public Exception apply(Void notUsed) {
+ return new TransactionCommitDeadlockException( DEADLOCK_MESSAGE,
+ RpcResultBuilder.newError(ErrorType.APPLICATION, "lock-denied", DEADLOCK_MESSAGE));
+ }
+ };
+
+ public TransactionCommitDeadlockException(String message, final RpcError... errors) {
+ super(message, errors);
+ }
+}
<dependency>
<groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-protocolbuffer-encoding</artifactId>
+ <artifactId>sal-clustering-commons</artifactId>
<version>1.1-SNAPSHOT</version>
</dependency>
<Private-Package></Private-Package>
<Import-Package>!*snappy;!org.jboss.*;*</Import-Package>
<Embed-Dependency>
- sal-protocolbuffer-encoding;
+ sal-clustering-commons;
sal-akka-raft;
!sal*;
!*config-api*;
@Nullable @Override public ActorSystem apply(@Nullable Void aVoid) {
ActorSystem system =
- ActorSystem.create("opendaylight-cluster", ConfigFactory
- .load().getConfig("ODLCluster"));
+ ActorSystem.create("opendaylight-cluster-data", ConfigFactory
+ .load().getConfig("odl-cluster-data"));
system.actorOf(Props.create(TerminationMonitor.class), "termination-monitor");
return system;
}
}
@Override public void handleReceive(Object message) throws Exception {
- if(message.getClass().equals(DataChanged.SERIALIZABLE_CLASS)){
+ if(message instanceof DataChanged){
dataChanged(message);
} else if(message instanceof EnableNotification){
enableNotification((EnableNotification) message);
return;
}
- DataChanged reply = DataChanged.fromSerialize(schemaContext,message, pathId);
+ DataChanged reply = (DataChanged) message;
AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>>
change = reply.getChange();
this.listener.onDataChanged(change);
if(getSender() != null){
- getSender().tell(new DataChangedReply().toSerializable(), getSelf());
+ getSender().tell(new DataChangedReply(), getSelf());
}
}
@Override public void onDataChanged(
AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change) {
- dataChangeListenerActor.tell(new DataChanged(schemaContext,change).toSerializable(), null);
+ dataChangeListenerActor.tell(new DataChanged(schemaContext,change), null);
}
}
package org.opendaylight.controller.cluster.datastore;
-import java.util.concurrent.Executors;
-
import akka.actor.ActorRef;
import akka.actor.ActorSystem;
-
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
import org.opendaylight.controller.cluster.datastore.messages.RegisterChangeListener;
import org.opendaylight.controller.cluster.datastore.messages.RegisterChangeListenerReply;
import org.opendaylight.controller.cluster.datastore.messages.UpdateSchemaContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.util.concurrent.ListeningExecutorService;
-import com.google.common.util.concurrent.MoreExecutors;
+import java.util.concurrent.Executors;
/**
*
Object result = actorContext.executeLocalShardOperation(shardName,
new RegisterChangeListener(path, dataChangeListenerActor.path(),
- scope).toSerializable(),
+ scope),
ActorContext.ASK_DURATION
);
if (result != null) {
- RegisterChangeListenerReply reply = RegisterChangeListenerReply
- .fromSerializable(actorContext.getActorSystem(), result);
+ RegisterChangeListenerReply reply = (RegisterChangeListenerReply) result;
return new DataChangeListenerRegistrationProxy(actorContext
.actorSelection(reply.getListenerRegistrationPath()), listener,
dataChangeListenerActor);
import akka.event.LoggingAdapter;
import akka.japi.Creator;
import akka.serialization.Serialization;
-
+import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
-
import org.opendaylight.controller.cluster.datastore.jmx.mbeans.shard.ShardMBeanFactory;
import org.opendaylight.controller.cluster.datastore.jmx.mbeans.shard.ShardStats;
import org.opendaylight.controller.cluster.datastore.messages.CommitTransactionReply;
import org.opendaylight.controller.cluster.datastore.messages.UpdateSchemaContext;
import org.opendaylight.controller.cluster.datastore.modification.Modification;
import org.opendaylight.controller.cluster.datastore.modification.MutableCompositeModification;
+import org.opendaylight.controller.cluster.raft.ConfigParams;
+import org.opendaylight.controller.cluster.raft.DefaultConfigParamsImpl;
import org.opendaylight.controller.cluster.raft.RaftActor;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeListener;
import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStore;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import scala.concurrent.duration.FiniteDuration;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
/**
* A Shard represents a portion of the logical data tree <br/>
*/
public class Shard extends RaftActor {
+ private static final ConfigParams configParams = new ShardConfigParams();
+
public static final String DEFAULT_NAME = "default";
private final ListeningExecutorService storeExecutor =
private final List<ActorSelection> dataChangeListeners = new ArrayList<>();
private Shard(String name, Map<String, String> peerAddresses) {
- super(name, peerAddresses);
+ super(name, peerAddresses, Optional.of(configParams));
this.name = name;
} else if(getLeader() != null){
getLeader().forward(message, getContext());
}
- } else if (message.getClass().equals(RegisterChangeListener.SERIALIZABLE_CLASS)) {
- registerChangeListener(RegisterChangeListener.fromSerializable(getContext().system(), message));
+ } else if (message instanceof RegisterChangeListener) {
+ registerChangeListener((RegisterChangeListener) message);
} else if (message instanceof UpdateSchemaContext) {
updateSchemaContext((UpdateSchemaContext) message);
} else if (message instanceof ForwardedCommitTransaction) {
}
}
+ private ActorRef createTypedTransactionActor(CreateTransaction createTransaction,String transactionId){
+ if(createTransaction.getTransactionType()== TransactionProxy.TransactionType.READ_ONLY.ordinal()){
+ return getContext().actorOf(
+ ShardTransaction.props( store.newReadOnlyTransaction(), getSelf(), schemaContext), transactionId);
+
+ }else if (createTransaction.getTransactionType()== TransactionProxy.TransactionType.READ_WRITE.ordinal()){
+ return getContext().actorOf(
+ ShardTransaction.props( store.newReadWriteTransaction(), getSelf(), schemaContext), transactionId);
+
+
+ }else if (createTransaction.getTransactionType()== TransactionProxy.TransactionType.WRITE_ONLY.ordinal()){
+ return getContext().actorOf(
+ ShardTransaction.props( store.newWriteOnlyTransaction(), getSelf(), schemaContext), transactionId);
+ }else{
+ throw new IllegalArgumentException ("CreateTransaction message has unidentified transaction type="+createTransaction.getTransactionType()) ;
+ }
+ }
+
private void createTransaction(CreateTransaction createTransaction) {
- DOMStoreReadWriteTransaction transaction =
- store.newReadWriteTransaction();
+
String transactionId = "shard-" + createTransaction.getTransactionId();
LOG.info("Creating transaction : {} " , transactionId);
- ActorRef transactionActor = getContext().actorOf(
- ShardTransaction.props(transaction, getSelf(), schemaContext), transactionId);
+ ActorRef transactionActor = createTypedTransactionActor(createTransaction,transactionId);
getSender()
.tell(new CreateTransactionReply(Serialization.serializedActorPath(transactionActor), createTransaction.getTransactionId()).toSerializable(),
LOG.debug("registerDataChangeListener sending reply, listenerRegistrationPath = " + listenerRegistration.path().toString());
getSender()
- .tell(new RegisterChangeListenerReply(listenerRegistration.path()).toSerializable(),
+ .tell(new RegisterChangeListenerReply(listenerRegistration.path()),
getSelf());
}
for(ActorSelection dataChangeListener : dataChangeListeners){
dataChangeListener.tell(new EnableNotification(isLeader()), getSelf());
}
+
+ if(getLeaderId() != null){
+ shardMBean.setLeader(getLeaderId());
+ }
+
+ shardMBean.setRaftState(getRaftState().name());
}
@Override public String persistenceId() {
return this.name;
}
+
+
+ private static class ShardConfigParams extends DefaultConfigParamsImpl {
+ public static final FiniteDuration HEART_BEAT_INTERVAL =
+ new FiniteDuration(500, TimeUnit.MILLISECONDS);
+
+ @Override public FiniteDuration getHeartBeatInterval() {
+ return HEART_BEAT_INTERVAL;
+ }
+ }
}
--- /dev/null
+/*
+ *
+ * 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.datastore;
+
+import akka.actor.ActorRef;
+import akka.actor.PoisonPill;
+import akka.event.Logging;
+import akka.event.LoggingAdapter;
+import org.opendaylight.controller.cluster.datastore.messages.CloseTransaction;
+import org.opendaylight.controller.cluster.datastore.messages.CloseTransactionReply;
+import org.opendaylight.controller.cluster.datastore.messages.ReadData;
+import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadTransaction;
+import org.opendaylight.controller.sal.core.spi.data.DOMStoreTransactionChain;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+
+/**
+ * @author: syedbahm
+ * Date: 8/6/14
+ */
+public class ShardReadTransaction extends ShardTransaction {
+ private final DOMStoreReadTransaction transaction;
+ private final LoggingAdapter log =
+ Logging.getLogger(getContext().system(), this);
+
+ public ShardReadTransaction(DOMStoreReadTransaction transaction, ActorRef shardActor, SchemaContext schemaContext) {
+ super(shardActor, schemaContext);
+ this.transaction = transaction;
+
+ }
+
+ public ShardReadTransaction(DOMStoreTransactionChain transactionChain, DOMStoreReadTransaction transaction, ActorRef shardActor, SchemaContext schemaContext) {
+ super(transactionChain, shardActor, schemaContext);
+ this.transaction = transaction;
+ }
+
+ @Override
+ public void handleReceive(Object message) throws Exception {
+ if (ReadData.SERIALIZABLE_CLASS.equals(message.getClass())) {
+ readData(transaction,ReadData.fromSerializable(message));
+ } else {
+ super.handleReceive(message);
+ }
+ }
+ protected void closeTransaction(CloseTransaction message) {
+ transaction.close();
+ getSender().tell(new CloseTransactionReply().toSerializable(), getSelf());
+ getSelf().tell(PoisonPill.getInstance(), getSelf());
+ }
+
+}
--- /dev/null
+/*
+ *
+ * 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.datastore;
+
+import akka.actor.ActorRef;
+import akka.actor.PoisonPill;
+import akka.event.Logging;
+import akka.event.LoggingAdapter;
+import org.opendaylight.controller.cluster.datastore.messages.CloseTransaction;
+import org.opendaylight.controller.cluster.datastore.messages.CloseTransactionReply;
+import org.opendaylight.controller.cluster.datastore.messages.DeleteData;
+import org.opendaylight.controller.cluster.datastore.messages.MergeData;
+import org.opendaylight.controller.cluster.datastore.messages.ReadData;
+import org.opendaylight.controller.cluster.datastore.messages.ReadyTransaction;
+import org.opendaylight.controller.cluster.datastore.messages.WriteData;
+import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadWriteTransaction;
+import org.opendaylight.controller.sal.core.spi.data.DOMStoreTransactionChain;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+
+/**
+ * @author: syedbahm
+ * Date: 8/6/14
+ */
+public class ShardReadWriteTransaction extends ShardTransaction {
+ private final DOMStoreReadWriteTransaction transaction;
+ private final LoggingAdapter log =
+ Logging.getLogger(getContext().system(), this);
+ public ShardReadWriteTransaction(DOMStoreTransactionChain transactionChain, DOMStoreReadWriteTransaction transaction, ActorRef shardActor, SchemaContext schemaContext) {
+ super(transactionChain, shardActor, schemaContext);
+ this.transaction = transaction;
+ }
+
+ public ShardReadWriteTransaction(DOMStoreReadWriteTransaction transaction, ActorRef shardActor, SchemaContext schemaContext) {
+ super( shardActor, schemaContext);
+ this.transaction = transaction;
+ }
+
+ @Override
+ public void handleReceive(Object message) throws Exception {
+ if (ReadData.SERIALIZABLE_CLASS.equals(message.getClass())) {
+ readData(transaction,ReadData.fromSerializable(message));
+ }else if (WriteData.SERIALIZABLE_CLASS.equals(message.getClass())) {
+ writeData(transaction, WriteData.fromSerializable(message, schemaContext));
+ } else if (MergeData.SERIALIZABLE_CLASS.equals(message.getClass())) {
+ mergeData(transaction, MergeData.fromSerializable(message, schemaContext));
+ } else if (DeleteData.SERIALIZABLE_CLASS.equals(message.getClass())) {
+ deleteData(transaction,DeleteData.fromSerizalizable(message));
+ } else if (ReadyTransaction.SERIALIZABLE_CLASS.equals(message.getClass())) {
+ readyTransaction(transaction,new ReadyTransaction());
+ }else {
+ super.handleReceive(message);
+ }
+ }
+
+ protected void closeTransaction(CloseTransaction message) {
+ transaction.close();
+ getSender().tell(new CloseTransactionReply().toSerializable(), getSelf());
+ getSelf().tell(PoisonPill.getInstance(), getSelf());
+ }
+}
package org.opendaylight.controller.cluster.datastore;
import akka.actor.ActorRef;
-import akka.actor.PoisonPill;
import akka.actor.Props;
import akka.event.Logging;
import akka.event.LoggingAdapter;
import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import org.opendaylight.controller.cluster.datastore.messages.CloseTransaction;
-import org.opendaylight.controller.cluster.datastore.messages.CloseTransactionReply;
import org.opendaylight.controller.cluster.datastore.messages.DeleteData;
import org.opendaylight.controller.cluster.datastore.messages.DeleteDataReply;
import org.opendaylight.controller.cluster.datastore.messages.MergeData;
import org.opendaylight.controller.cluster.datastore.modification.MergeModification;
import org.opendaylight.controller.cluster.datastore.modification.MutableCompositeModification;
import org.opendaylight.controller.cluster.datastore.modification.WriteModification;
+import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadTransaction;
import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadWriteTransaction;
import org.opendaylight.controller.sal.core.spi.data.DOMStoreThreePhaseCommitCohort;
import org.opendaylight.controller.sal.core.spi.data.DOMStoreTransactionChain;
+import org.opendaylight.controller.sal.core.spi.data.DOMStoreWriteTransaction;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
* <li> {@link org.opendaylight.controller.cluster.datastore.messages.CloseTransaction}
* </p>
*/
-public class ShardTransaction extends AbstractUntypedActor {
-
- private final ActorRef shardActor;
- private final SchemaContext schemaContext;
-
- // FIXME : see below
- // If transactionChain is not null then this transaction is part of a
- // transactionChain. Not really clear as to what that buys us
- private final DOMStoreTransactionChain transactionChain;
-
- private final DOMStoreReadWriteTransaction transaction;
-
- private final MutableCompositeModification modification =
- new MutableCompositeModification();
-
- private final LoggingAdapter log =
- Logging.getLogger(getContext().system(), this);
-
- public ShardTransaction(DOMStoreReadWriteTransaction transaction,
- ActorRef shardActor, SchemaContext schemaContext) {
- this(null, transaction, shardActor, schemaContext);
- }
-
- public ShardTransaction(DOMStoreTransactionChain transactionChain, DOMStoreReadWriteTransaction transaction,
- ActorRef shardActor, SchemaContext schemaContext) {
- this.transactionChain = transactionChain;
- this.transaction = transaction;
- this.shardActor = shardActor;
- this.schemaContext = schemaContext;
- }
-
-
-
- public static Props props(final DOMStoreReadWriteTransaction transaction,
- final ActorRef shardActor, final SchemaContext schemaContext) {
- return Props.create(new Creator<ShardTransaction>() {
-
- @Override
- public ShardTransaction create() throws Exception {
- return new ShardTransaction(transaction, shardActor, schemaContext);
- }
- });
- }
-
- public static Props props(final DOMStoreTransactionChain transactionChain, final DOMStoreReadWriteTransaction transaction,
- final ActorRef shardActor, final SchemaContext schemaContext) {
- return Props.create(new Creator<ShardTransaction>() {
-
- @Override
- public ShardTransaction create() throws Exception {
- return new ShardTransaction(transactionChain, transaction, shardActor, schemaContext);
- }
- });
+public abstract class ShardTransaction extends AbstractUntypedActor {
+
+ private final ActorRef shardActor;
+ protected final SchemaContext schemaContext;
+
+ // FIXME : see below
+ // If transactionChain is not null then this transaction is part of a
+ // transactionChain. Not really clear as to what that buys us
+ private final DOMStoreTransactionChain transactionChain;
+
+
+ private final MutableCompositeModification modification =
+ new MutableCompositeModification();
+
+ private final LoggingAdapter log =
+ Logging.getLogger(getContext().system(), this);
+
+ protected ShardTransaction(
+ ActorRef shardActor, SchemaContext schemaContext) {
+ this(null, shardActor, schemaContext);
+ }
+
+ protected ShardTransaction(DOMStoreTransactionChain transactionChain,
+ ActorRef shardActor, SchemaContext schemaContext) {
+ this.transactionChain = transactionChain;
+ //this.transaction = transaction;
+ this.shardActor = shardActor;
+ this.schemaContext = schemaContext;
+ }
+
+
+
+ public static Props props(final DOMStoreReadTransaction transaction,
+ final ActorRef shardActor, final SchemaContext schemaContext) {
+ return Props.create(new Creator<ShardTransaction>() {
+
+ @Override
+ public ShardTransaction create() throws Exception {
+ return new ShardReadTransaction(transaction, shardActor, schemaContext);
+ }
+ });
+ }
+
+ public static Props props(final DOMStoreTransactionChain transactionChain, final DOMStoreReadTransaction transaction,
+ final ActorRef shardActor, final SchemaContext schemaContext) {
+ return Props.create(new Creator<ShardTransaction>() {
+
+ @Override
+ public ShardTransaction create() throws Exception {
+ return new ShardReadTransaction(transactionChain, transaction, shardActor, schemaContext);
+ }
+ });
+ }
+
+ public static Props props(final DOMStoreReadWriteTransaction transaction,
+ final ActorRef shardActor, final SchemaContext schemaContext) {
+ return Props.create(new Creator<ShardTransaction>() {
+
+ @Override
+ public ShardTransaction create() throws Exception {
+ return new ShardReadWriteTransaction(transaction, shardActor, schemaContext);
+ }
+ });
+ }
+
+ public static Props props(final DOMStoreTransactionChain transactionChain, final DOMStoreReadWriteTransaction transaction,
+ final ActorRef shardActor, final SchemaContext schemaContext) {
+ return Props.create(new Creator<ShardTransaction>() {
+
+ @Override
+ public ShardTransaction create() throws Exception {
+ return new ShardReadWriteTransaction(transactionChain, transaction, shardActor, schemaContext);
+ }
+ });
+ }
+
+
+ public static Props props(final DOMStoreWriteTransaction transaction,
+ final ActorRef shardActor, final SchemaContext schemaContext) {
+ return Props.create(new Creator<ShardTransaction>() {
+
+ @Override
+ public ShardTransaction create() throws Exception {
+ return new ShardWriteTransaction(transaction, shardActor, schemaContext);
+ }
+ });
+ }
+
+ public static Props props(final DOMStoreTransactionChain transactionChain, final DOMStoreWriteTransaction transaction,
+ final ActorRef shardActor, final SchemaContext schemaContext) {
+ return Props.create(new Creator<ShardTransaction>() {
+
+ @Override
+ public ShardTransaction create() throws Exception {
+ return new ShardWriteTransaction(transactionChain, transaction, shardActor, schemaContext);
+ }
+ });
+ }
+
+
+ @Override
+ public void handleReceive(Object message) throws Exception {
+ if (message.getClass().equals(CloseTransaction.SERIALIZABLE_CLASS)) {
+ closeTransaction(new CloseTransaction());
+ } else if (message instanceof GetCompositedModification) {
+ // This is here for testing only
+ getSender().tell(new GetCompositeModificationReply(
+ new ImmutableCompositeModification(modification)), getSelf());
+ }else{
+ throw new Exception ("ShardTransaction:handleRecieve received an unknown message"+message);
}
-
-
- @Override
- public void handleReceive(Object message) throws Exception {
- if (ReadData.SERIALIZABLE_CLASS.equals(message.getClass())) {
- readData(ReadData.fromSerializable(message));
- } else if (WriteData.SERIALIZABLE_CLASS.equals(message.getClass())) {
- writeData(WriteData.fromSerializable(message, schemaContext));
- } else if (MergeData.SERIALIZABLE_CLASS.equals(message.getClass())) {
- mergeData(MergeData.fromSerializable(message, schemaContext));
- } else if (DeleteData.SERIALIZABLE_CLASS.equals(message.getClass())) {
- deleteData(DeleteData.fromSerizalizable(message));
- } else if (ReadyTransaction.SERIALIZABLE_CLASS.equals(message.getClass())) {
- readyTransaction(new ReadyTransaction());
- } else if (message.getClass().equals(CloseTransaction.SERIALIZABLE_CLASS)) {
- closeTransaction(new CloseTransaction());
- } else if (message instanceof GetCompositedModification) {
- // This is here for testing only
- getSender().tell(new GetCompositeModificationReply(
- new ImmutableCompositeModification(modification)), getSelf());
- }else{
- throw new Exception ("Shard:handleRecieve received an unknown message"+message);
+ }
+
+ abstract protected void closeTransaction(CloseTransaction message);
+
+ protected void readData(DOMStoreReadTransaction transaction,ReadData message) {
+ final ActorRef sender = getSender();
+ final ActorRef self = getSelf();
+ final YangInstanceIdentifier path = message.getPath();
+ final ListenableFuture<Optional<NormalizedNode<?, ?>>> future =
+ transaction.read(path);
+
+ future.addListener(new Runnable() {
+ @Override
+ public void run() {
+ try {
+ Optional<NormalizedNode<?, ?>> optional = future.get();
+ if (optional.isPresent()) {
+ sender.tell(new ReadDataReply(schemaContext,optional.get()).toSerializable(), self);
+ } else {
+ sender.tell(new ReadDataReply(schemaContext,null).toSerializable(), self);
+ }
+ } catch (InterruptedException | ExecutionException e) {
+ log.error(e,
+ "An exception happened when reading data from path : "
+ + path.toString());
}
- }
- private void readData(ReadData message) {
- final ActorRef sender = getSender();
- final ActorRef self = getSelf();
- final YangInstanceIdentifier path = message.getPath();
- final ListenableFuture<Optional<NormalizedNode<?, ?>>> future =
- transaction.read(path);
-
- future.addListener(new Runnable() {
- @Override
- public void run() {
- try {
- Optional<NormalizedNode<?, ?>> optional = future.get();
- if (optional.isPresent()) {
- sender.tell(new ReadDataReply(schemaContext,optional.get()).toSerializable(), self);
- } else {
- sender.tell(new ReadDataReply(schemaContext,null).toSerializable(), self);
- }
- } catch (InterruptedException | ExecutionException e) {
- log.error(e,
- "An exception happened when reading data from path : "
- + path.toString());
- }
-
- }
- }, getContext().dispatcher());
- }
+ }
+ }, getContext().dispatcher());
+ }
- private void writeData(WriteData message) {
- modification.addModification(
- new WriteModification(message.getPath(), message.getData(),schemaContext));
- LOG.debug("writeData at path : " + message.getPath().toString());
- transaction.write(message.getPath(), message.getData());
- getSender().tell(new WriteDataReply().toSerializable(), getSelf());
- }
+ protected void writeData(DOMStoreWriteTransaction transaction, WriteData message) {
+ modification.addModification(
+ new WriteModification(message.getPath(), message.getData(),schemaContext));
+ LOG.debug("writeData at path : " + message.getPath().toString());
+ transaction.write(message.getPath(), message.getData());
+ getSender().tell(new WriteDataReply().toSerializable(), getSelf());
+ }
- private void mergeData(MergeData message) {
- modification.addModification(
- new MergeModification(message.getPath(), message.getData(), schemaContext));
- LOG.debug("mergeData at path : " + message.getPath().toString());
- transaction.merge(message.getPath(), message.getData());
- getSender().tell(new MergeDataReply().toSerializable(), getSelf());
- }
+ protected void mergeData(DOMStoreWriteTransaction transaction, MergeData message) {
+ modification.addModification(
+ new MergeModification(message.getPath(), message.getData(), schemaContext));
+ LOG.debug("mergeData at path : " + message.getPath().toString());
+ transaction.merge(message.getPath(), message.getData());
+ getSender().tell(new MergeDataReply().toSerializable(), getSelf());
+ }
- private void deleteData(DeleteData message) {
- modification.addModification(new DeleteModification(message.getPath()));
- transaction.delete(message.getPath());
- getSender().tell(new DeleteDataReply().toSerializable(), getSelf());
- }
+ protected void deleteData(DOMStoreWriteTransaction transaction, DeleteData message) {
+ modification.addModification(new DeleteModification(message.getPath()));
+ transaction.delete(message.getPath());
+ getSender().tell(new DeleteDataReply().toSerializable(), getSelf());
+ }
- private void readyTransaction(ReadyTransaction message) {
- DOMStoreThreePhaseCommitCohort cohort = transaction.ready();
- ActorRef cohortActor = getContext().actorOf(
- ThreePhaseCommitCohort.props(cohort, shardActor, modification), "cohort");
- getSender()
- .tell(new ReadyTransactionReply(cohortActor.path()).toSerializable(), getSelf());
+ protected void readyTransaction(DOMStoreWriteTransaction transaction, ReadyTransaction message) {
+ DOMStoreThreePhaseCommitCohort cohort = transaction.ready();
+ ActorRef cohortActor = getContext().actorOf(
+ ThreePhaseCommitCohort.props(cohort, shardActor, modification), "cohort");
+ getSender()
+ .tell(new ReadyTransactionReply(cohortActor.path()).toSerializable(), getSelf());
- }
-
- private void closeTransaction(CloseTransaction message) {
- transaction.close();
- getSender().tell(new CloseTransactionReply().toSerializable(), getSelf());
- getSelf().tell(PoisonPill.getInstance(), getSelf());
- }
+ }
- // These classes are in here for test purposes only
+ // These classes are in here for test purposes only
- static class GetCompositedModification {
+ static class GetCompositedModification {
- }
+ }
- static class GetCompositeModificationReply {
- private final CompositeModification modification;
+ static class GetCompositeModificationReply {
+ private final CompositeModification modification;
- GetCompositeModificationReply(CompositeModification modification) {
- this.modification = modification;
- }
+ GetCompositeModificationReply(CompositeModification modification) {
+ this.modification = modification;
+ }
- public CompositeModification getModification() {
- return modification;
- }
+ public CompositeModification getModification() {
+ return modification;
}
+ }
}
import org.opendaylight.controller.cluster.datastore.messages.CloseTransactionChainReply;
import org.opendaylight.controller.cluster.datastore.messages.CreateTransaction;
import org.opendaylight.controller.cluster.datastore.messages.CreateTransactionReply;
-import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadWriteTransaction;
import org.opendaylight.controller.sal.core.spi.data.DOMStoreTransactionChain;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
}
}
+ private ActorRef createTypedTransactionActor(CreateTransaction createTransaction,String transactionId){
+ if(createTransaction.getTransactionType()== TransactionProxy.TransactionType.READ_ONLY.ordinal()){
+ return getContext().actorOf(
+ ShardTransaction.props( chain.newReadOnlyTransaction(), getSelf(), schemaContext), transactionId);
+
+ }else if (createTransaction.getTransactionType()== TransactionProxy.TransactionType.READ_WRITE.ordinal()){
+ return getContext().actorOf(
+ ShardTransaction.props( chain.newReadWriteTransaction(), getSelf(), schemaContext), transactionId);
+
+
+ }else if (createTransaction.getTransactionType()== TransactionProxy.TransactionType.WRITE_ONLY.ordinal()){
+ return getContext().actorOf(
+ ShardTransaction.props( chain.newWriteOnlyTransaction(), getSelf(), schemaContext), transactionId);
+ }else{
+ throw new IllegalArgumentException ("CreateTransaction message has unidentified transaction type="+createTransaction.getTransactionType()) ;
+ }
+ }
+
private void createTransaction(CreateTransaction createTransaction) {
- DOMStoreReadWriteTransaction transaction =
- chain.newReadWriteTransaction();
- ActorRef transactionActor = getContext().actorOf(ShardTransaction
- .props(chain, transaction, getContext().parent(), schemaContext), "shard-" + createTransaction.getTransactionId());
+
+ ActorRef transactionActor = createTypedTransactionActor(createTransaction, "shard-" + createTransaction.getTransactionId());
getSender()
.tell(new CreateTransactionReply(transactionActor.path().toString(),createTransaction.getTransactionId()).toSerializable(),
getSelf());
--- /dev/null
+/*
+ *
+ * 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.datastore;
+
+import akka.actor.ActorRef;
+import akka.actor.PoisonPill;
+import akka.event.Logging;
+import akka.event.LoggingAdapter;
+import org.opendaylight.controller.cluster.datastore.messages.CloseTransaction;
+import org.opendaylight.controller.cluster.datastore.messages.CloseTransactionReply;
+import org.opendaylight.controller.cluster.datastore.messages.DeleteData;
+import org.opendaylight.controller.cluster.datastore.messages.MergeData;
+import org.opendaylight.controller.cluster.datastore.messages.ReadyTransaction;
+import org.opendaylight.controller.cluster.datastore.messages.WriteData;
+import org.opendaylight.controller.sal.core.spi.data.DOMStoreTransactionChain;
+import org.opendaylight.controller.sal.core.spi.data.DOMStoreWriteTransaction;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+
+/**
+ * @author: syedbahm
+ * Date: 8/6/14
+ */
+public class ShardWriteTransaction extends ShardTransaction {
+ private final DOMStoreWriteTransaction transaction;
+ private final LoggingAdapter log =
+ Logging.getLogger(getContext().system(), this);
+ public ShardWriteTransaction(DOMStoreWriteTransaction transaction, ActorRef shardActor, SchemaContext schemaContext) {
+ super( shardActor, schemaContext);
+ this.transaction = transaction;
+
+ }
+
+ public ShardWriteTransaction(DOMStoreTransactionChain transactionChain, DOMStoreWriteTransaction transaction, ActorRef shardActor, SchemaContext schemaContext) {
+ super(transactionChain, shardActor, schemaContext);
+ this.transaction = transaction;
+ }
+
+ @Override
+ public void handleReceive(Object message) throws Exception {
+ if (WriteData.SERIALIZABLE_CLASS.equals(message.getClass())) {
+ writeData(transaction, WriteData.fromSerializable(message, schemaContext));
+ } else if (MergeData.SERIALIZABLE_CLASS.equals(message.getClass())) {
+ mergeData(transaction, MergeData.fromSerializable(message, schemaContext));
+ } else if (DeleteData.SERIALIZABLE_CLASS.equals(message.getClass())) {
+ deleteData(transaction,DeleteData.fromSerizalizable(message));
+ } else if (ReadyTransaction.SERIALIZABLE_CLASS.equals(message.getClass())) {
+ readyTransaction(transaction,new ReadyTransaction());
+ }else {
+ super.handleReceive(message);
+ }
+ }
+
+ protected void closeTransaction(CloseTransaction message) {
+ transaction.close();
+ getSender().tell(new CloseTransactionReply().toSerializable(), getSelf());
+ getSelf().tell(PoisonPill.getInstance(), getSelf());
+ }
+}
CanCommitTransactionReply reply =
CanCommitTransactionReply.fromSerializable(response);
if (!reply.getCanCommit()) {
- System.out.println("**TOM - failed: false");
return false;
}
}
try {
Object response = actorContext.executeShardOperation(shardName,
- new CreateTransaction(identifier).toSerializable(),
+ new CreateTransaction(identifier,this.transactionType.ordinal() ).toSerializable(),
ActorContext.ASK_DURATION);
if (response.getClass()
.equals(CreateTransactionReply.SERIALIZABLE_CLASS)) {
private Long committedTransactionsCount;
private Long journalMessagesCount;
final private String shardName;
+ private String leader;
+ private String raftState;
ShardStats(String shardName){
this.shardName = shardName;
return journalMessagesCount;
}
+ @Override public String getLeader() {
+ return leader;
+ }
+
+ @Override public String getRaftState() {
+ return raftState;
+ }
public Long incrementCommittedTransactionCount() {
return committedTransactionsCount++;
}
+ public void setLeader(String leader){
+ this.leader = leader;
+ }
+
+ public void setRaftState(String raftState){
+ this.raftState = raftState;
+ }
@Override
String getShardName();
Long getCommittedTransactionsCount();
Long getJournalMessagesCount();
-
+ String getLeader();
+ String getRaftState();
}
public class CreateTransaction implements SerializableMessage {
public static Class SERIALIZABLE_CLASS = ShardTransactionMessages.CreateTransaction.class;
private final String transactionId;
+ private final int transactionType;
- public CreateTransaction(String transactionId){
+ public CreateTransaction(String transactionId, int transactionType){
this.transactionId = transactionId;
+ this.transactionType = transactionType;
}
public String getTransactionId() {
return transactionId;
}
+ public int getTransactionType() { return transactionType;}
+
@Override
public Object toSerializable() {
- return ShardTransactionMessages.CreateTransaction.newBuilder().setTransactionId(transactionId).build();
+ return ShardTransactionMessages.CreateTransaction.newBuilder().setTransactionId(transactionId).setTransactionType(transactionType).build();
}
public static CreateTransaction fromSerializable(Object message){
- return new CreateTransaction(((ShardTransactionMessages.CreateTransaction)message).getTransactionId());
+ ShardTransactionMessages.CreateTransaction createTransaction = (ShardTransactionMessages.CreateTransaction)message;
+ return new CreateTransaction(createTransaction.getTransactionId(),createTransaction.getTransactionType() );
}
}
import org.opendaylight.controller.cluster.datastore.Configuration;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import java.util.List;
+
public class ModuleShardStrategy implements ShardStrategy {
public static final String NAME = "module";
}
@Override public String findShard(YangInstanceIdentifier path) {
- return configuration.getShardNamesFromModuleName(moduleName).get(0);
+ List<String> shardNames =
+ configuration.getShardNamesFromModuleName(moduleName);
+ if(shardNames.size() == 0){
+ return DefaultShardStrategy.DEFAULT_SHARD;
+ }
+ return shardNames.get(0);
}
}
public interface ShardStrategy {
/**
* Find the name of the shard in which the data pointed to by the specified path belongs in
+ * <p>
+ * Should return the name of the default shard DefaultShardStrategy.DEFAULT_SHARD
+ * if no matching shard was found
*
* @param path The location of the data in the logical tree
* @return
-ODLCluster{
-actor {
- serializers {
- java = "akka.serialization.JavaSerializer"
- proto = "akka.remote.serialization.ProtobufSerializer"
- }
+odl-cluster-data {
+ akka {
+ cluster {
+ roles = [
+ "member-1"
+ ]
+ }
+ actor {
+ provider = "akka.cluster.ClusterActorRefProvider"
+ serializers {
+ java = "akka.serialization.JavaSerializer"
+ proto = "akka.remote.serialization.ProtobufSerializer"
+ }
+
+ serialization-bindings {
+ "com.google.protobuf.Message" = proto
+
+ }
+ }
+ remote {
+ log-remote-lifecycle-events = off
+ netty.tcp {
+ hostname = "127.0.0.1"
+ port = 2550
+ maximum-frame-size = 2097152
+ send-buffer-size = 52428800
+ receive-buffer-size = 52428800
+ }
+ }
- serialization-bindings {
- "com.google.protobuf.Message" = proto
+ cluster {
+ seed-nodes = ["akka.tcp://opendaylight-cluster-data@127.0.0.1:2550"]
- }
+ auto-down-unreachable-after = 10s
}
+ }
+}
+
+odl-cluster-rpc {
+ akka {
+ actor {
+ provider = "akka.cluster.ClusterActorRefProvider"
-}
\ No newline at end of file
+ }
+ remote {
+ log-remote-lifecycle-events = off
+ netty.tcp {
+ hostname = "127.0.0.1"
+ port = 2551
+ }
+ }
+
+ cluster {
+ seed-nodes = ["akka.tcp://opendaylight-cluster-rpc@127.0.0.1:2551"]
+
+ auto-down-unreachable-after = 10s
+ }
+ }
+}
modules = [
{
name = "inventory"
- namespace = "urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test:people"
+ namespace = "urn:opendaylight:inventory"
shard-strategy = "module"
}
]
import akka.actor.ActorRef;
import akka.actor.ActorSelection;
import akka.actor.Props;
+import akka.event.Logging;
import akka.testkit.JavaTestKit;
import junit.framework.Assert;
import org.junit.Test;
import java.util.Collections;
+import static junit.framework.Assert.assertEquals;
+
public class BasicIntegrationTest extends AbstractActorTest {
@Test
getRef());
- // Wait for Shard to become a Leader
- try {
- Thread.sleep(1000);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
+ // Wait for a specific log message to show up
+ final boolean result =
+ new JavaTestKit.EventFilter<Boolean>(Logging.Info.class
+ ) {
+ protected Boolean run() {
+ return true;
+ }
+ }.from(shard.path().toString())
+ .message("Switching from state Candidate to Leader")
+ .occurrences(1).exec();
+
+ assertEquals(true, result);
+
// 1. Create a TransactionChain
shard.tell(new CreateTransactionChain().toSerializable(), getRef());
final ActorSelection transactionChain =
- new ExpectMsg<ActorSelection>("CreateTransactionChainReply") {
+ new ExpectMsg<ActorSelection>(duration("1 seconds"), "CreateTransactionChainReply") {
protected ActorSelection match(Object in) {
if (in.getClass().equals(CreateTransactionChainReply.SERIALIZABLE_CLASS)) {
ActorPath transactionChainPath =
System.out.println("Successfully created transaction chain");
// 2. Create a Transaction on the TransactionChain
- transactionChain.tell(new CreateTransaction("txn-1").toSerializable(), getRef());
+ transactionChain.tell(new CreateTransaction("txn-1", TransactionProxy.TransactionType.WRITE_ONLY.ordinal() ).toSerializable(), getRef());
final ActorSelection transaction =
- new ExpectMsg<ActorSelection>("CreateTransactionReply") {
+ new ExpectMsg<ActorSelection>(duration("1 seconds"), "CreateTransactionReply") {
protected ActorSelection match(Object in) {
if (CreateTransactionReply.SERIALIZABLE_CLASS.equals(in.getClass())) {
CreateTransactionReply reply = CreateTransactionReply.fromSerializable(in);
ImmutableNodes.containerNode(TestModel.TEST_QNAME), TestModel.createTestContext()).toSerializable(),
getRef());
- Boolean writeDone = new ExpectMsg<Boolean>("WriteDataReply") {
+ Boolean writeDone = new ExpectMsg<Boolean>(duration("1 seconds"), "WriteDataReply") {
protected Boolean match(Object in) {
if (in.getClass().equals(WriteDataReply.SERIALIZABLE_CLASS)) {
return true;
transaction.tell(new ReadyTransaction().toSerializable(), getRef());
final ActorSelection cohort =
- new ExpectMsg<ActorSelection>("ReadyTransactionReply") {
+ new ExpectMsg<ActorSelection>(duration("1 seconds"), "ReadyTransactionReply") {
protected ActorSelection match(Object in) {
if (in.getClass().equals(ReadyTransactionReply.SERIALIZABLE_CLASS)) {
ActorPath cohortPath =
cohort.tell(new PreCommitTransaction().toSerializable(), getRef());
Boolean preCommitDone =
- new ExpectMsg<Boolean>("PreCommitTransactionReply") {
+ new ExpectMsg<Boolean>(duration("1 seconds"), "PreCommitTransactionReply") {
protected Boolean match(Object in) {
if (in.getClass().equals(PreCommitTransactionReply.SERIALIZABLE_CLASS)) {
return true;
Assert.assertEquals(1, listMessages.size());
- Assert.assertTrue(listMessages.get(0).getClass().equals(DataChanged.SERIALIZABLE_CLASS));
+ Assert.assertTrue(listMessages.get(0).getClass().equals(DataChanged.class));
}
}
subject.tell(new CloseDataChangeListenerRegistration().toSerializable(), getRef());
- final String out = new ExpectMsg<String>("match hint") {
+ final String out = new ExpectMsg<String>(duration("1 seconds"), "match hint") {
// do not put code outside this method, will run afterwards
protected String match(Object in) {
if (in.getClass().equals(CloseDataChangeListenerRegistrationReply.SERIALIZABLE_CLASS)) {
subject.tell(new EnableNotification(true), getRef());
subject.tell(
- new DataChanged(CompositeModel.createTestContext(),new MockDataChangedEvent()).toSerializable(),
+ new DataChanged(CompositeModel.createTestContext(),new MockDataChangedEvent()),
getRef());
final Boolean out = new ExpectMsg<Boolean>(duration("800 millis"), "dataChanged") {
// do not put code outside this method, will run afterwards
protected Boolean match(Object in) {
- if (in != null && in.getClass().equals(DataChangedReply.SERIALIZABLE_CLASS)) {
+ if (in != null && in.getClass().equals(DataChangedReply.class)) {
return true;
} else {
protected void run() {
subject.tell(
- new DataChanged(CompositeModel.createTestContext(),new MockDataChangedEvent()).toSerializable(),
+ new DataChanged(CompositeModel.createTestContext(),new MockDataChangedEvent()),
getRef());
expectNoMsg();
package org.opendaylight.controller.cluster.datastore;
import akka.actor.ActorSystem;
+import akka.event.Logging;
import akka.testkit.JavaTestKit;
-
import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import junit.framework.Assert;
+import org.apache.commons.io.FileUtils;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
+import java.io.File;
+import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import static junit.framework.Assert.assertEquals;
import static junit.framework.Assert.assertTrue;
+import static junit.framework.Assert.fail;
-public class DistributedDataStoreIntegrationTest{
+public class DistributedDataStoreIntegrationTest {
private static ActorSystem system;
@Before
- public void setUp() {
+ public void setUp() throws IOException {
+ File journal = new File("journal");
+
+ if(journal.exists()) {
+ FileUtils.deleteDirectory(journal);
+ }
+
+
System.setProperty("shard.persistent", "false");
system = ActorSystem.create("test");
}
@Test
public void integrationTest() throws Exception {
- Configuration configuration = new ConfigurationImpl("module-shards.conf", "modules.conf");
+ final Configuration configuration = new ConfigurationImpl("module-shards.conf", "modules.conf");
ShardStrategyFactory.setConfiguration(configuration);
- DistributedDataStore distributedDataStore =
- new DistributedDataStore(getSystem(), "config", new MockClusterWrapper(), configuration);
- distributedDataStore.onGlobalContextUpdated(TestModel.createTestContext());
- Thread.sleep(1500);
- DOMStoreReadWriteTransaction transaction =
- distributedDataStore.newReadWriteTransaction();
+ new JavaTestKit(getSystem()) {
+ {
+
+ new Within(duration("10 seconds")) {
+ protected void run() {
+ try {
+ final DistributedDataStore distributedDataStore =
+ new DistributedDataStore(getSystem(), "config", new MockClusterWrapper(), configuration);
+
+ distributedDataStore.onGlobalContextUpdated(TestModel.createTestContext());
+
+ // Wait for a specific log message to show up
+ final boolean result =
+ new JavaTestKit.EventFilter<Boolean>(Logging.Info.class
+ ) {
+ protected Boolean run() {
+ return true;
+ }
+ }.from("akka://test/user/shardmanager-config/member-1-shard-test-1-config")
+ .message("Switching from state Candidate to Leader")
+ .occurrences(1).exec();
+
+ assertEquals(true, result);
+
+ DOMStoreReadWriteTransaction transaction =
+ distributedDataStore.newReadWriteTransaction();
- transaction.write(TestModel.TEST_PATH, ImmutableNodes.containerNode(TestModel.TEST_QNAME));
+ transaction
+ .write(TestModel.TEST_PATH, ImmutableNodes
+ .containerNode(TestModel.TEST_QNAME));
- ListenableFuture<Optional<NormalizedNode<?, ?>>> future =
- transaction.read(TestModel.TEST_PATH);
+ ListenableFuture<Optional<NormalizedNode<?, ?>>>
+ future =
+ transaction.read(TestModel.TEST_PATH);
- Optional<NormalizedNode<?, ?>> optional = future.get();
+ Optional<NormalizedNode<?, ?>> optional =
+ future.get();
- Assert.assertTrue(optional.isPresent());
+ Assert.assertTrue("Node not found", optional.isPresent());
- NormalizedNode<?, ?> normalizedNode = optional.get();
+ NormalizedNode<?, ?> normalizedNode =
+ optional.get();
- assertEquals(TestModel.TEST_QNAME, normalizedNode.getNodeType());
+ assertEquals(TestModel.TEST_QNAME,
+ normalizedNode.getNodeType());
- DOMStoreThreePhaseCommitCohort ready = transaction.ready();
+ DOMStoreThreePhaseCommitCohort ready =
+ transaction.ready();
- ListenableFuture<Boolean> canCommit = ready.canCommit();
+ ListenableFuture<Boolean> canCommit =
+ ready.canCommit();
- assertTrue(canCommit.get(5, TimeUnit.SECONDS));
+ assertTrue(canCommit.get(5, TimeUnit.SECONDS));
- ListenableFuture<Void> preCommit = ready.preCommit();
+ ListenableFuture<Void> preCommit =
+ ready.preCommit();
- preCommit.get(5, TimeUnit.SECONDS);
+ preCommit.get(5, TimeUnit.SECONDS);
- ListenableFuture<Void> commit = ready.commit();
+ ListenableFuture<Void> commit = ready.commit();
+
+ commit.get(5, TimeUnit.SECONDS);
+ } catch (ExecutionException | TimeoutException | InterruptedException e){
+ fail(e.getMessage());
+ }
+ }
+ };
+ }
+ };
- commit.get(5, TimeUnit.SECONDS);
}
- @Test
+ //FIXME : Disabling test because it's flaky
+ //@Test
public void integrationTestWithMultiShardConfiguration()
throws ExecutionException, InterruptedException, TimeoutException {
- Configuration configuration = new ConfigurationImpl("module-shards.conf", "modules.conf");
+ final Configuration configuration = new ConfigurationImpl("module-shards.conf", "modules.conf");
ShardStrategyFactory.setConfiguration(configuration);
- DistributedDataStore distributedDataStore =
- new DistributedDataStore(getSystem(), "config", new MockClusterWrapper(), configuration);
+ new JavaTestKit(getSystem()) {
+ {
+
+ new Within(duration("10 seconds")) {
+ protected void run() {
+ try {
+ final DistributedDataStore distributedDataStore =
+ new DistributedDataStore(getSystem(), "config",
+ new MockClusterWrapper(), configuration);
+
+ distributedDataStore.onGlobalContextUpdated(
+ SchemaContextHelper.full());
+
+ // Wait for a specific log message to show up
+ final boolean result =
+ new JavaTestKit.EventFilter<Boolean>(
+ Logging.Info.class
+ ) {
+ protected Boolean run() {
+ return true;
+ }
+ }.from(
+ "akka://test/user/shardmanager-config/member-1-shard-cars-1-config")
+ .message(
+ "Switching from state Candidate to Leader")
+ .occurrences(1)
+ .exec();
+
+ Thread.sleep(1000);
+
+
+ DOMStoreReadWriteTransaction transaction =
+ distributedDataStore.newReadWriteTransaction();
- distributedDataStore.onGlobalContextUpdated(SchemaContextHelper.full());
+ transaction.write(CarsModel.BASE_PATH, CarsModel.emptyContainer());
+ transaction.write(PeopleModel.BASE_PATH, PeopleModel.emptyContainer());
- // This sleep is fragile - test can fail intermittently if all Shards aren't updated with
- // the SchemaContext in time. Is there any way we can make this deterministic?
- Thread.sleep(2000);
+ DOMStoreThreePhaseCommitCohort ready = transaction.ready();
- DOMStoreReadWriteTransaction transaction =
- distributedDataStore.newReadWriteTransaction();
+ ListenableFuture<Boolean> canCommit = ready.canCommit();
- transaction.write(CarsModel.BASE_PATH, CarsModel.emptyContainer());
- transaction.write(PeopleModel.BASE_PATH, PeopleModel.emptyContainer());
+ assertTrue(canCommit.get(5, TimeUnit.SECONDS));
- DOMStoreThreePhaseCommitCohort ready = transaction.ready();
+ ListenableFuture<Void> preCommit = ready.preCommit();
- ListenableFuture<Boolean> canCommit = ready.canCommit();
+ preCommit.get(5, TimeUnit.SECONDS);
- assertTrue(canCommit.get(5, TimeUnit.SECONDS));
+ ListenableFuture<Void> commit = ready.commit();
- ListenableFuture<Void> preCommit = ready.preCommit();
+ commit.get(5, TimeUnit.SECONDS);
- preCommit.get(5, TimeUnit.SECONDS);
+ assertEquals(true, result);
+ } catch(ExecutionException | TimeoutException | InterruptedException e){
+ fail(e.getMessage());
+ }
+ }
+ };
+ }
+ };
- ListenableFuture<Void> commit = ready.commit();
- commit.get(5, TimeUnit.SECONDS);
}
}
@org.junit.Test
public void testRegisterChangeListenerWhenShardIsLocal() throws Exception {
- mockActorContext.setExecuteLocalShardOperationResponse(new RegisterChangeListenerReply(doNothingActorRef.path()).toSerializable());
+ mockActorContext.setExecuteLocalShardOperationResponse(new RegisterChangeListenerReply(doNothingActorRef.path()));
ListenerRegistration registration =
distributedDataStore.registerChangeListener(TestModel.TEST_PATH, new AsyncDataChangeListener<YangInstanceIdentifier, NormalizedNode<?, ?>>() {
subject.tell(new FindPrimary(Shard.DEFAULT_NAME).toSerializable(), getRef());
- expectMsgClass(PrimaryFound.SERIALIZABLE_CLASS);
+ expectMsgClass(duration("1 seconds"), PrimaryFound.SERIALIZABLE_CLASS);
expectNoMsg();
}
subject.tell(new FindPrimary("astronauts").toSerializable(), getRef());
- final String out = new ExpectMsg<String>("primary found") {
+ final String out = new ExpectMsg<String>(duration("1 seconds"), "primary found") {
// do not put code outside this method, will run afterwards
protected String match(Object in) {
if (in.getClass().equals(PrimaryFound.SERIALIZABLE_CLASS)) {
subject.tell(new FindPrimary("astronauts").toSerializable(), getRef());
- expectMsgClass(PrimaryFound.SERIALIZABLE_CLASS);
+ expectMsgClass(duration("1 seconds"), PrimaryFound.SERIALIZABLE_CLASS);
MockClusterWrapper.sendMemberRemoved(subject, "member-2", getRef().path().toString());
subject.tell(new FindPrimary("astronauts").toSerializable(), getRef());
- expectMsgClass(PrimaryNotFound.SERIALIZABLE_CLASS);
+ expectMsgClass(duration("1 seconds"), PrimaryNotFound.SERIALIZABLE_CLASS);
expectNoMsg();
}
import akka.actor.ActorRef;
import akka.actor.Props;
+import akka.event.Logging;
import akka.testkit.JavaTestKit;
+import junit.framework.Assert;
import org.junit.Test;
import org.opendaylight.controller.cluster.datastore.messages.CreateTransaction;
import org.opendaylight.controller.cluster.datastore.messages.CreateTransactionChain;
getSystem().actorOf(props, "testCreateTransactionChain");
- // Wait for Shard to become a Leader
- try {
- Thread.sleep(1000);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
+ // Wait for a specific log message to show up
+ final boolean result =
+ new JavaTestKit.EventFilter<Boolean>(Logging.Info.class
+ ) {
+ protected Boolean run() {
+ return true;
+ }
+ }.from(subject.path().toString())
+ .message("Switching from state Candidate to Leader")
+ .occurrences(1).exec();
+
+ Assert.assertEquals(true, result);
new Within(duration("1 seconds")) {
protected void run() {
subject.tell(new CreateTransactionChain().toSerializable(), getRef());
- final String out = new ExpectMsg<String>("match hint") {
+ final String out = new ExpectMsg<String>(duration("1 seconds"), "match hint") {
// do not put code outside this method, will run afterwards
protected String match(Object in) {
if (in.getClass().equals(CreateTransactionChainReply.SERIALIZABLE_CLASS)){
getRef());
subject.tell(new RegisterChangeListener(TestModel.TEST_PATH,
- getRef().path(), AsyncDataBroker.DataChangeScope.BASE).toSerializable(),
+ getRef().path(), AsyncDataBroker.DataChangeScope.BASE),
getRef());
final Boolean notificationEnabled = new ExpectMsg<Boolean>("enable notification") {
assertFalse(notificationEnabled);
- final String out = new ExpectMsg<String>("match hint") {
+ final String out = new ExpectMsg<String>(duration("1 seconds"), "match hint") {
// do not put code outside this method, will run afterwards
protected String match(Object in) {
- if (in.getClass().equals(RegisterChangeListenerReply.SERIALIZABLE_CLASS)) {
+ if (in.getClass().equals(RegisterChangeListenerReply.class)) {
RegisterChangeListenerReply reply =
- RegisterChangeListenerReply.fromSerializable(getSystem(),in);
+ (RegisterChangeListenerReply) in;
return reply.getListenerRegistrationPath()
.toString();
} else {
getSystem().actorOf(props, "testCreateTransaction");
- // Wait for Shard to become a Leader
- try {
- Thread.sleep(1000);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
+ // Wait for a specific log message to show up
+ final boolean result =
+ new JavaTestKit.EventFilter<Boolean>(Logging.Info.class
+ ) {
+ protected Boolean run() {
+ return true;
+ }
+ }.from(subject.path().toString())
+ .message("Switching from state Candidate to Leader")
+ .occurrences(1).exec();
+ Assert.assertEquals(true, result);
new Within(duration("1 seconds")) {
protected void run() {
new UpdateSchemaContext(TestModel.createTestContext()),
getRef());
- subject.tell(new CreateTransaction("txn-1").toSerializable(),
+ subject.tell(new CreateTransaction("txn-1", TransactionProxy.TransactionType.READ_ONLY.ordinal() ).toSerializable(),
getRef());
- final String out = new ExpectMsg<String>("match hint") {
+ final String out = new ExpectMsg<String>(duration("1 seconds"), "match hint") {
// do not put code outside this method, will run afterwards
protected String match(Object in) {
if (in instanceof CreateTransactionReply) {
new Within(duration("1 seconds")) {
protected void run() {
- subject.tell(new CreateTransaction("txn-1").toSerializable(), getRef());
+ subject.tell(new CreateTransaction("txn-1", TransactionProxy.TransactionType.READ_ONLY.ordinal() ).toSerializable(), getRef());
- final String out = new ExpectMsg<String>("match hint") {
+ final String out = new ExpectMsg<String>(duration("1 seconds"), "match hint") {
// do not put code outside this method, will run afterwards
protected String match(Object in) {
if (in.getClass().equals(CreateTransactionReply.SERIALIZABLE_CLASS)) {
subject.tell(new CloseTransactionChain().toSerializable(), getRef());
- final String out = new ExpectMsg<String>("match hint") {
+ final String out = new ExpectMsg<String>(duration("1 seconds"), "match hint") {
// do not put code outside this method, will run afterwards
protected String match(Object in) {
if (in.getClass().equals(CloseTransactionChainReply.SERIALIZABLE_CLASS)) {
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 org.junit.Assert;
import org.junit.Test;
import org.opendaylight.controller.cluster.datastore.messages.CloseTransaction;
import org.opendaylight.controller.cluster.datastore.messages.CloseTransactionReply;
new JavaTestKit(getSystem()) {{
final ActorRef shard = getSystem().actorOf(Shard.props("config", Collections.EMPTY_MAP));
final Props props =
- ShardTransaction.props(store.newReadWriteTransaction(), shard, testSchemaContext);
+ ShardTransaction.props(store.newReadOnlyTransaction(), shard, testSchemaContext);
final ActorRef subject = getSystem().actorOf(props, "testReadData");
new Within(duration("1 seconds")) {
new ReadData(YangInstanceIdentifier.builder().build()).toSerializable(),
getRef());
- final String out = new ExpectMsg<String>("match hint") {
+ final String out = new ExpectMsg<String>(duration("1 seconds"), "match hint") {
// do not put code outside this method, will run afterwards
protected String match(Object in) {
if (in.getClass().equals(ReadDataReply.SERIALIZABLE_CLASS)) {
new JavaTestKit(getSystem()) {{
final ActorRef shard = getSystem().actorOf(Shard.props("config", Collections.EMPTY_MAP));
final Props props =
- ShardTransaction.props(store.newReadWriteTransaction(), shard, testSchemaContext);
+ ShardTransaction.props( store.newReadOnlyTransaction(), shard, testSchemaContext);
final ActorRef subject = getSystem().actorOf(props, "testReadDataWhenDataNotFound");
new Within(duration("1 seconds")) {
new ReadData(TestModel.TEST_PATH).toSerializable(),
getRef());
- final String out = new ExpectMsg<String>("match hint") {
+ final String out = new ExpectMsg<String>(duration("1 seconds"), "match hint") {
// do not put code outside this method, will run afterwards
protected String match(Object in) {
if (in.getClass().equals(ReadDataReply.SERIALIZABLE_CLASS)) {
getRef());
final CompositeModification compositeModification =
- new ExpectMsg<CompositeModification>("match hint") {
+ new ExpectMsg<CompositeModification>(duration("1 seconds"), "match hint") {
// do not put code outside this method, will run afterwards
protected CompositeModification match(Object in) {
if (in instanceof ShardTransaction.GetCompositeModificationReply) {
new JavaTestKit(getSystem()) {{
final ActorRef shard = getSystem().actorOf(Shard.props("config", Collections.EMPTY_MAP));
final Props props =
- ShardTransaction.props(store.newReadWriteTransaction(), shard, TestModel.createTestContext());
+ ShardTransaction.props(store.newWriteOnlyTransaction(), shard, TestModel.createTestContext());
final ActorRef subject =
getSystem().actorOf(props, "testWriteData");
ImmutableNodes.containerNode(TestModel.TEST_QNAME), TestModel.createTestContext()).toSerializable(),
getRef());
- final String out = new ExpectMsg<String>("match hint") {
+ final String out = new ExpectMsg<String>(duration("1 seconds"), "match hint") {
// do not put code outside this method, will run afterwards
protected String match(Object in) {
if (in.getClass().equals(WriteDataReply.SERIALIZABLE_CLASS)) {
new JavaTestKit(getSystem()) {{
final ActorRef shard = getSystem().actorOf(Shard.props("config", Collections.EMPTY_MAP));
final Props props =
- ShardTransaction.props(store.newReadWriteTransaction(), shard, TestModel.createTestContext());
+ ShardTransaction.props( store.newWriteOnlyTransaction(), shard, TestModel.createTestContext());
final ActorRef subject =
getSystem().actorOf(props, "testDeleteData");
subject.tell(new DeleteData(TestModel.TEST_PATH).toSerializable(), getRef());
- final String out = new ExpectMsg<String>("match hint") {
+ final String out = new ExpectMsg<String>(duration("1 seconds"), "match hint") {
// do not put code outside this method, will run afterwards
protected String match(Object in) {
if (in.getClass().equals(DeleteDataReply.SERIALIZABLE_CLASS)) {
new JavaTestKit(getSystem()) {{
final ActorRef shard = getSystem().actorOf(Shard.props("config", Collections.EMPTY_MAP));
final Props props =
- ShardTransaction.props(store.newReadWriteTransaction(), shard, TestModel.createTestContext());
+ ShardTransaction.props( store.newReadWriteTransaction(), shard, TestModel.createTestContext());
final ActorRef subject =
getSystem().actorOf(props, "testReadyTransaction");
subject.tell(new ReadyTransaction().toSerializable(), getRef());
- final String out = new ExpectMsg<String>("match hint") {
+ final String out = new ExpectMsg<String>(duration("1 seconds"), "match hint") {
// do not put code outside this method, will run afterwards
protected String match(Object in) {
if (in.getClass().equals(ReadyTransactionReply.SERIALIZABLE_CLASS)) {
subject.tell(new CloseTransaction().toSerializable(), getRef());
- final String out = new ExpectMsg<String>("match hint") {
+ final String out = new ExpectMsg<String>(duration("1 seconds"), "match hint") {
// do not put code outside this method, will run afterwards
protected String match(Object in) {
if (in.getClass().equals(CloseTransactionReply.SERIALIZABLE_CLASS)) {
assertEquals("match", out);
- final String termination = new ExpectMsg<String>("match hint") {
+ final String termination = new ExpectMsg<String>(duration("1 seconds"), "match hint") {
// do not put code outside this method, will run afterwards
protected String match(Object in) {
if (in instanceof Terminated) {
}};
}
+
+
+ @Test
+ public void testNegativePerformingWriteOperationOnReadTransaction() throws Exception {
+ try {
+
+ final ActorRef shard = getSystem().actorOf(Shard.props("config", Collections.EMPTY_MAP));
+ final Props props =
+ ShardTransaction.props(store.newReadOnlyTransaction(), shard, TestModel.createTestContext());
+ final TestActorRef subject = TestActorRef.apply(props,getSystem());
+
+ subject.receive(new DeleteData(TestModel.TEST_PATH).toSerializable(), ActorRef.noSender());
+ Assert.assertFalse(true);
+
+
+ } catch (Exception cs) {
+ assertEquals(cs.getClass().getSimpleName(), Exception.class.getSimpleName());
+ assertTrue(cs.getMessage().startsWith("ShardTransaction:handleRecieve received an unknown message"));
+ }
+ }
}
package org.opendaylight.controller.cluster.datastore.shardstrategy;
-import junit.framework.Assert;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import org.opendaylight.controller.cluster.datastore.Configuration;
import org.opendaylight.controller.cluster.datastore.ConfigurationImpl;
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
String shard = moduleShardStrategy.findShard(CarsModel.BASE_PATH);
- Assert.assertEquals("cars-1", shard);
+ assertEquals("cars-1", shard);
+ }
+
+ @Test
+ public void testFindShardWhenModuleConfigurationPresentInModulesButMissingInModuleShards() {
+
+ final QName BASE_QNAME = QName.create("urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test:missing", "2014-03-13",
+ "missing");
+
+ final YangInstanceIdentifier BASE_PATH = YangInstanceIdentifier.of(BASE_QNAME);
+
+ ModuleShardStrategy moduleShardStrategy =
+ new ModuleShardStrategy("missing", configuration);
+
+ String shard = moduleShardStrategy.findShard(BASE_PATH);
+
+ assertEquals(DefaultShardStrategy.DEFAULT_SHARD, shard);
+
}
}
akka {
+ loggers = [akka.testkit.TestEventListener]
actor {
serializers {
java = "akka.serialization.JavaSerializer"
shard-strategy = "module"
}
+ {
+ name = "missing"
+ namespace = "urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:missing"
+ shard-strategy = "module"
+ }
+
]
import java.util.concurrent.Executors;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitDeadlockException;
import org.opendaylight.controller.md.sal.dom.broker.impl.DOMDataBrokerImpl;
import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStore;
import org.opendaylight.controller.sal.core.spi.data.DOMStore;
+import org.opendaylight.yangtools.util.concurrent.DeadlockDetectingListeningExecutorService;
import com.google.common.collect.ImmutableMap;
import com.google.common.util.concurrent.ListeningExecutorService;
.<LogicalDatastoreType, DOMStore> builder().put(LogicalDatastoreType.OPERATIONAL, operStore)
.put(LogicalDatastoreType.CONFIGURATION, configStore).build();
- DOMDataBrokerImpl newDataBroker = new DOMDataBrokerImpl(datastores, MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor()));
+ DOMDataBrokerImpl newDataBroker = new DOMDataBrokerImpl(datastores,
+ new DeadlockDetectingListeningExecutorService(Executors.newSingleThreadExecutor(),
+ TransactionCommitDeadlockException.DEADLOCK_EXECUTOR_FUNCTION));
return newDataBroker;
}
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertEquals;
import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.OPERATIONAL;
+import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.After;
import org.junit.Before;
import org.junit.Test;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitDeadlockException;
+import org.opendaylight.controller.md.sal.dom.api.DOMDataChangeListener;
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadTransaction;
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.store.impl.InMemoryDOMDataStore;
import org.opendaylight.controller.md.sal.dom.store.impl.TestModel;
import org.opendaylight.controller.sal.core.spi.data.DOMStore;
+import org.opendaylight.yangtools.util.concurrent.DeadlockDetectingListeningExecutorService;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import com.google.common.base.Optional;
import com.google.common.collect.ImmutableMap;
+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.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
private SchemaContext schemaContext;
private DOMDataBrokerImpl domBroker;
+ private ListeningExecutorService executor;
@Before
public void setupStore() {
.put(OPERATIONAL, operStore) //
.build();
- ListeningExecutorService executor = MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor());
+ executor = new DeadlockDetectingListeningExecutorService(Executors.newSingleThreadExecutor(),
+ TransactionCommitDeadlockException.DEADLOCK_EXECUTOR_FUNCTION);
domBroker = new DOMDataBrokerImpl(stores, executor);
}
- @Test
+ @After
+ public void tearDown() {
+ if( executor != null ) {
+ executor.shutdownNow();
+ }
+ }
+
+ @Test(timeout=10000)
public void testTransactionIsolation() throws InterruptedException, ExecutionException {
assertNotNull(domBroker);
assertFalse(readTxContainer.get().isPresent());
}
- @Test
+ @Test(timeout=10000)
public void testTransactionCommit() throws InterruptedException, ExecutionException {
DOMDataReadWriteTransaction writeTx = domBroker.newReadWriteTransaction();
assertTrue(afterCommitRead.isPresent());
}
+ /**
+ * Tests a simple DataChangeListener notification after a write.
+ */
+ @Test
+ public void testDataChangeListener() throws Throwable {
+
+ final NormalizedNode<?, ?> testNode = ImmutableNodes.containerNode( TestModel.TEST_QNAME );
+
+ TestDOMDataChangeListener dcListener = new TestDOMDataChangeListener();
+
+ domBroker.registerDataChangeListener( OPERATIONAL, TestModel.TEST_PATH,
+ dcListener, DataChangeScope.BASE );
+
+ final DOMDataWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
+ assertNotNull( writeTx );
+
+ writeTx.put( OPERATIONAL, TestModel.TEST_PATH, testNode );
+
+ AtomicReference<Throwable> caughtEx = submitTxAsync( writeTx );
+
+ dcListener.waitForChange();
+
+ if( caughtEx.get() != null ) {
+ throw caughtEx.get();
+ }
+
+ NormalizedNode<?, ?> actualNode = dcListener.change.getCreatedData().get( TestModel.TEST_PATH );
+ assertEquals( "Created node", testNode, actualNode );
+ }
+
+ /**
+ * Tests a DataChangeListener that does an async submit of a write Tx in its onDataChanged method.
+ * This should succeed without deadlock.
+ */
+ @Test
+ public void testDataChangeListenerDoingAsyncWriteTxSubmit() throws Throwable {
+
+ final AtomicReference<Throwable> caughtCommitEx = new AtomicReference<>();
+ final CountDownLatch commitCompletedLatch = new CountDownLatch( 1 );
+
+ TestDOMDataChangeListener dcListener = new TestDOMDataChangeListener() {
+ @Override
+ public void onDataChanged( AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change ) {
+
+ DOMDataWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
+ writeTx.put( OPERATIONAL, TestModel.TEST2_PATH,
+ ImmutableNodes.containerNode( TestModel.TEST2_QNAME ) );
+ Futures.addCallback( writeTx.submit(), new FutureCallback<Void>() {
+ @Override
+ public void onSuccess( Void result ) {
+ commitCompletedLatch.countDown();
+ }
+
+ @Override
+ public void onFailure( Throwable t ) {
+ caughtCommitEx.set( t );
+ commitCompletedLatch.countDown();
+ }
+ } );
+
+ super.onDataChanged( change );
+ }
+ };
+
+ domBroker.registerDataChangeListener( OPERATIONAL, TestModel.TEST_PATH,
+ dcListener, DataChangeScope.BASE );
+
+ final DOMDataWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
+ assertNotNull( writeTx );
+
+ writeTx.put( OPERATIONAL, TestModel.TEST_PATH, ImmutableNodes.containerNode( TestModel.TEST_QNAME ) );
+
+ AtomicReference<Throwable> caughtEx = submitTxAsync( writeTx );
+
+ dcListener.waitForChange();
+
+ if( caughtEx.get() != null ) {
+ throw caughtEx.get();
+ }
+
+ assertTrue( "Commit Future was not invoked", commitCompletedLatch.await( 5, TimeUnit.SECONDS ) );
+
+ if( caughtCommitEx.get() != null ) {
+ throw caughtCommitEx.get();
+ }
+ }
+
+ /**
+ * Tests a DataChangeListener that does a blocking submit of a write Tx in its onDataChanged method.
+ * This should throw an exception and not deadlock.
+ */
+ @Test(expected=TransactionCommitDeadlockException.class)
+ public void testDataChangeListenerDoingBlockingWriteTxSubmit() throws Throwable {
+
+ final AtomicReference<Throwable> caughtCommitEx = new AtomicReference<>();
+
+ TestDOMDataChangeListener dcListener = new TestDOMDataChangeListener() {
+ @Override
+ public void onDataChanged( AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change ) {
+ DOMDataWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
+ writeTx.put( OPERATIONAL, TestModel.TEST2_PATH,
+ ImmutableNodes.containerNode( TestModel.TEST2_QNAME ) );
+ try {
+ writeTx.submit().get();
+ } catch( ExecutionException e ) {
+ caughtCommitEx.set( e.getCause() );
+ } catch( Exception e ) {
+ caughtCommitEx.set( e );
+ }
+ finally {
+ super.onDataChanged( change );
+ }
+ }
+ };
+
+ domBroker.registerDataChangeListener( OPERATIONAL, TestModel.TEST_PATH,
+ dcListener, DataChangeScope.BASE );
+
+ final DOMDataWriteTransaction writeTx = domBroker.newWriteOnlyTransaction();
+ assertNotNull( writeTx );
+
+ writeTx.put( OPERATIONAL, TestModel.TEST_PATH, ImmutableNodes.containerNode( TestModel.TEST_QNAME ) );
+
+ AtomicReference<Throwable> caughtEx = submitTxAsync( writeTx );
+ dcListener.waitForChange();
+ if( caughtEx.get() != null ) {
+ throw caughtEx.get();
+ }
+
+ if( caughtCommitEx.get() != null ) {
+ throw caughtCommitEx.get();
+ }
+ }
+
+ AtomicReference<Throwable> submitTxAsync( final DOMDataWriteTransaction writeTx ) {
+ final AtomicReference<Throwable> caughtEx = new AtomicReference<>();
+ new Thread() {
+ @Override
+ public void run() {
+
+ try {
+ writeTx.submit();
+ } catch( Throwable e ) {
+ caughtEx.set( e );
+ }
+ }
+
+ }.start();
+
+ return caughtEx;
+ }
+
+ static class TestDOMDataChangeListener implements DOMDataChangeListener {
+
+ volatile AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change;
+ private final CountDownLatch latch = new CountDownLatch( 1 );
+
+ @Override
+ public void onDataChanged( AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change ) {
+ this.change = change;
+ latch.countDown();
+ }
+
+ void waitForChange() throws InterruptedException {
+ assertTrue( "onDataChanged was not called", latch.await( 5, TimeUnit.SECONDS ) );
+ }
+ }
}
public static final QName TEST_QNAME = QName.create("urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test", "2014-03-13",
"test");
+ public static final QName TEST2_QNAME = QName.create("urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test", "2014-03-13",
+ "test2");
public static final QName OUTER_LIST_QNAME = QName.create(TEST_QNAME, "outer-list");
public static final QName INNER_LIST_QNAME = QName.create(TEST_QNAME, "inner-list");
public static final QName OUTER_CHOICE_QNAME = QName.create(TEST_QNAME, "outer-choice");
private static final String DATASTORE_TEST_YANG = "/odl-datastore-test.yang";
public static final YangInstanceIdentifier TEST_PATH = YangInstanceIdentifier.of(TEST_QNAME);
+ public static final YangInstanceIdentifier TEST2_PATH = YangInstanceIdentifier.of(TEST2_QNAME);
public static final YangInstanceIdentifier OUTER_LIST_PATH = YangInstanceIdentifier.builder(TEST_PATH).node(OUTER_LIST_QNAME).build();
public static final QName TWO_QNAME = QName.create(TEST_QNAME,"two");
public static final QName THREE_QNAME = QName.create(TEST_QNAME,"three");
}
}
}
+
+ container test2 {
+ }
}
\ No newline at end of file
import static org.opendaylight.controller.md.sal.dom.store.impl.DOMImmutableDataChangeEvent.builder;
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Multimap;
+
import java.util.Collection;
import java.util.Collections;
-import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map.Entry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.Multimap;
-
/**
* Resolve Data Change Events based on modifications and listeners
*
final Collection<Node> listeners, final NormalizedNode<?, ?> beforeData,
final NormalizedNode<?, ?> afterData) {
+ // FIXME: BUG-1493: check the listeners to prune unneeded changes:
+ // for subtrees, we have to do all
+ // for one, we need to expand children
+ // for base, we just report replacement
+
if (beforeData instanceof NormalizedNodeContainer<?, ?, ?>) {
// Node is container (contains child) and we have interested
// listeners registered for it, that means we need to do
final Collection<Node> listeners,
final NormalizedNodeContainer<?, PathArgument, NormalizedNode<PathArgument, ?>> beforeCont,
final NormalizedNodeContainer<?, PathArgument, NormalizedNode<PathArgument, ?>> afterCont) {
- final Set<PathArgument> alreadyProcessed = new HashSet<>();
final List<DOMImmutableDataChangeEvent> childChanges = new LinkedList<>();
- DataChangeScope potentialScope = DataChangeScope.BASE;
// We look at all children from before and compare it with after state.
for (NormalizedNode<PathArgument, ?> beforeChild : beforeCont.getValue()) {
- PathArgument childId = beforeChild.getIdentifier();
- alreadyProcessed.add(childId);
+ final PathArgument childId = beforeChild.getIdentifier();
+
YangInstanceIdentifier childPath = path.node(childId);
Collection<ListenerTree.Node> childListeners = getListenerChildrenWildcarded(listeners, childId);
Optional<NormalizedNode<PathArgument, ?>> afterChild = afterCont.getChild(childId);
if (childChange != NO_CHANGE) {
childChanges.add(childChange);
}
-
}
for (NormalizedNode<PathArgument, ?> afterChild : afterCont.getValue()) {
- PathArgument childId = afterChild.getIdentifier();
- if (!alreadyProcessed.contains(childId)) {
- // We did not processed that child already
- // and it was not present in previous loop, that means it is
- // created.
+ final PathArgument childId = afterChild.getIdentifier();
+
+ /*
+ * We have already iterated of the before-children, so have already
+ * emitted modify/delete events. This means the child has been
+ * created.
+ */
+ if (!beforeCont.getChild(childId).isPresent()) {
Collection<ListenerTree.Node> childListeners = getListenerChildrenWildcarded(listeners, childId);
YangInstanceIdentifier childPath = path.node(childId);
childChanges.add(resolveSameEventRecursivelly(childPath , childListeners, afterChild,
return NO_CHANGE;
}
- Builder eventBuilder = builder(potentialScope) //
+ Builder eventBuilder = builder(DataChangeScope.BASE) //
.setBefore(beforeCont) //
.setAfter(afterCont)
.addUpdated(path, beforeCont, afterCont);
* @param bundleContext
*/
public static final void createInstance(final BundleContext bundleContext) {
-
if(actorSystem == null) {
// Create an OSGi bundle classloader for actor system
BundleDelegatingClassLoader classLoader = new BundleDelegatingClassLoader(bundleContext.getBundle(),
synchronized (ActorSystemFactory.class) {
// Double check
if (actorSystem == null) {
- ActorSystem system = ActorSystem.create("opendaylight-rpc",
- ConfigFactory.load().getConfig("odl-cluster"), classLoader);
+ ActorSystem system = ActorSystem.create("opendaylight-cluster-rpc",
+ ConfigFactory.load().getConfig("odl-cluster-rpc"), classLoader);
actorSystem = system;
}
}
-odl-cluster{
+
+odl-cluster-data {
+ akka {
+ cluster {
+ roles = [
+ "member-1"
+ ]
+ }
+ actor {
+ provider = "akka.cluster.ClusterActorRefProvider"
+ serializers {
+ java = "akka.serialization.JavaSerializer"
+ proto = "akka.remote.serialization.ProtobufSerializer"
+ }
+
+ serialization-bindings {
+ "com.google.protobuf.Message" = proto
+
+ }
+ }
+ remote {
+ log-remote-lifecycle-events = off
+ netty.tcp {
+ hostname = "127.0.0.1"
+ port = 2550
+ maximum-frame-size = 2097152
+ send-buffer-size = 52428800
+ receive-buffer-size = 52428800
+ }
+ }
+
+ cluster {
+ seed-nodes = ["akka.tcp://opendaylight-cluster-data@127.0.0.1:2550"]
+
+ auto-down-unreachable-after = 10s
+ }
+ }
+}
+
+odl-cluster-rpc {
akka {
actor {
provider = "akka.cluster.ClusterActorRefProvider"
remote {
log-remote-lifecycle-events = off
netty.tcp {
- hostname = "192.168.141.141"
+ hostname = "127.0.0.1"
port = 2551
}
}
cluster {
- seed-nodes = ["akka.tcp://opendaylight-rpc@192.168.141.141:2551"]
+ seed-nodes = ["akka.tcp://opendaylight-cluster-rpc@127.0.0.1:2551"]
auto-down-unreachable-after = 10s
}
}
-}
\ No newline at end of file
+}
import com.google.common.base.Predicate;
import com.google.common.base.Splitter;
import com.google.common.base.Strings;
-import com.google.common.collect.BiMap;
-import com.google.common.collect.HashBiMap;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Iterables;
import java.io.UnsupportedEncodingException;
private static final Splitter SLASH_SPLITTER = Splitter.on('/');
- private final BiMap<URI, String> uriToModuleName = HashBiMap.<URI, String> create();
-
- private final Map<String, URI> moduleNameToUri = uriToModuleName.inverse();
-
private final AtomicReference<Map<QName, RpcDefinition>> qnameToRpc =
new AtomicReference<>(Collections.<QName, RpcDefinition>emptyMap());
public String findModuleNameByNamespace(final URI namespace) {
this.checkPreconditions();
- String moduleName = this.uriToModuleName.get(namespace);
- if (moduleName == null) {
- final Module module = this.findModuleByNamespace(namespace);
- if (module != null) {
- moduleName = module.getName();
- this.uriToModuleName.put(namespace, moduleName);
- }
- }
-
- return moduleName;
+ final Module module = this.findModuleByNamespace(namespace);
+ return module == null ? null : module.getName();
}
public String findModuleNameByNamespace(final DOMMountPoint mountPoint, final URI namespace) {
}
public URI findNamespaceByModuleName(final String moduleName) {
- URI namespace = this.moduleNameToUri.get(moduleName);
- if (namespace == null) {
- Module module = this.findModuleByName(moduleName);
- if (module != null) {
- URI _namespace = module.getNamespace();
- namespace = _namespace;
- this.uriToModuleName.put(namespace, moduleName);
- }
- }
- return namespace;
+ final Module module = this.findModuleByName(moduleName);
+ return module == null ? null : module.getNamespace();
}
public URI findNamespaceByModuleName(final DOMMountPoint mountPoint, final String moduleName) {
return globalSchema.getModules();
}
+ private static final CharSequence toRestconfIdentifier(final SchemaContext context, final QName qname) {
+ final Module schema = context.findModuleByNamespaceAndRevision(qname.getNamespace(), qname.getRevision());
+ return schema == null ? null : schema.getName() + ':' + qname.getLocalName();
+ }
+
public CharSequence toRestconfIdentifier(final QName qname) {
this.checkPreconditions();
- String module = this.uriToModuleName.get(qname.getNamespace());
- if (module == null) {
- final Module moduleSchema = globalSchema.findModuleByNamespaceAndRevision(qname.getNamespace(),
- qname.getRevision());
- if (moduleSchema == null) {
- return null;
- }
-
- this.uriToModuleName.put(qname.getNamespace(), moduleSchema.getName());
- module = moduleSchema.getName();
- }
-
- StringBuilder builder = new StringBuilder();
- builder.append(module);
- builder.append(":");
- builder.append(qname.getLocalName());
- return builder.toString();
+ return toRestconfIdentifier(globalSchema, qname);
}
public CharSequence toRestconfIdentifier(final DOMMountPoint mountPoint, final QName qname) {
return null;
}
- SchemaContext schemaContext = mountPoint.getSchemaContext();
-
- final Module moduleSchema = schemaContext.findModuleByNamespaceAndRevision(qname.getNamespace(),
- qname.getRevision());
- if (moduleSchema == null) {
- return null;
- }
-
- StringBuilder builder = new StringBuilder();
- builder.append(moduleSchema.getName());
- builder.append(":");
- builder.append(qname.getLocalName());
- return builder.toString();
+ return toRestconfIdentifier(mountPoint.getSchemaContext(), qname);
}
public Module getRestconfModule() {
final GroupingDefinition restconfGrouping = Iterables.getFirst(filteredGroups, null);
- List<DataSchemaNode> instanceDataChildrenByName = this.findInstanceDataChildrenByName(restconfGrouping,
+ List<DataSchemaNode> instanceDataChildrenByName = findInstanceDataChildrenByName(restconfGrouping,
Draft02.RestConfModule.ERRORS_CONTAINER_SCHEMA_NODE);
return Iterables.getFirst(instanceDataChildrenByName, null);
}
Iterable<GroupingDefinition> filteredGroups = Iterables.filter(groupings, GROUPING_FILTER);
final GroupingDefinition restconfGrouping = Iterables.getFirst(filteredGroups, null);
- List<DataSchemaNode> instanceDataChildrenByName = this.findInstanceDataChildrenByName(restconfGrouping,
+ List<DataSchemaNode> instanceDataChildrenByName = findInstanceDataChildrenByName(restconfGrouping,
Draft02.RestConfModule.RESTCONF_CONTAINER_SCHEMA_NODE);
final DataSchemaNode restconfContainer = Iterables.getFirst(instanceDataChildrenByName, null);
if (Objects.equal(schemaNodeName, Draft02.RestConfModule.OPERATIONS_CONTAINER_SCHEMA_NODE)) {
- List<DataSchemaNode> instances = this.findInstanceDataChildrenByName(
+ List<DataSchemaNode> instances = findInstanceDataChildrenByName(
((DataNodeContainer) restconfContainer), Draft02.RestConfModule.OPERATIONS_CONTAINER_SCHEMA_NODE);
return Iterables.getFirst(instances, null);
} else if (Objects.equal(schemaNodeName, Draft02.RestConfModule.STREAMS_CONTAINER_SCHEMA_NODE)) {
- List<DataSchemaNode> instances = this.findInstanceDataChildrenByName(
+ List<DataSchemaNode> instances = findInstanceDataChildrenByName(
((DataNodeContainer) restconfContainer), Draft02.RestConfModule.STREAMS_CONTAINER_SCHEMA_NODE);
return Iterables.getFirst(instances, null);
} else if (Objects.equal(schemaNodeName, Draft02.RestConfModule.STREAM_LIST_SCHEMA_NODE)) {
- List<DataSchemaNode> instances = this.findInstanceDataChildrenByName(
+ List<DataSchemaNode> instances = findInstanceDataChildrenByName(
((DataNodeContainer) restconfContainer), Draft02.RestConfModule.STREAMS_CONTAINER_SCHEMA_NODE);
final DataSchemaNode modules = Iterables.getFirst(instances, null);
- instances = this.findInstanceDataChildrenByName(((DataNodeContainer) modules),
+ instances = findInstanceDataChildrenByName(((DataNodeContainer) modules),
Draft02.RestConfModule.STREAM_LIST_SCHEMA_NODE);
return Iterables.getFirst(instances, null);
} else if (Objects.equal(schemaNodeName, Draft02.RestConfModule.MODULES_CONTAINER_SCHEMA_NODE)) {
- List<DataSchemaNode> instances = this.findInstanceDataChildrenByName(
+ List<DataSchemaNode> instances = findInstanceDataChildrenByName(
((DataNodeContainer) restconfContainer), Draft02.RestConfModule.MODULES_CONTAINER_SCHEMA_NODE);
return Iterables.getFirst(instances, null);
} else if (Objects.equal(schemaNodeName, Draft02.RestConfModule.MODULE_LIST_SCHEMA_NODE)) {
- List<DataSchemaNode> instances = this.findInstanceDataChildrenByName(
+ List<DataSchemaNode> instances = findInstanceDataChildrenByName(
((DataNodeContainer) restconfContainer), Draft02.RestConfModule.MODULES_CONTAINER_SCHEMA_NODE);
final DataSchemaNode modules = Iterables.getFirst(instances, null);
- instances = this.findInstanceDataChildrenByName(((DataNodeContainer) modules),
+ instances = findInstanceDataChildrenByName(((DataNodeContainer) modules),
Draft02.RestConfModule.MODULE_LIST_SCHEMA_NODE);
return Iterables.getFirst(instances, null);
} else if (Objects.equal(schemaNodeName, Draft02.RestConfModule.STREAMS_CONTAINER_SCHEMA_NODE)) {
- List<DataSchemaNode> instances = this.findInstanceDataChildrenByName(
+ List<DataSchemaNode> instances = findInstanceDataChildrenByName(
((DataNodeContainer) restconfContainer), Draft02.RestConfModule.STREAMS_CONTAINER_SCHEMA_NODE);
return Iterables.getFirst(instances, null);
}
}
}
- targetNode = this.findInstanceDataChildByNameAndNamespace(parentNode, nodeName, module.getNamespace());
+ targetNode = findInstanceDataChildByNameAndNamespace(parentNode, nodeName, module.getNamespace());
if (targetNode == null) {
throw new RestconfDocumentedException("URI has bad format. Possible reasons:\n" + " 1. \"" + head
+ "\" was not found in parent data node.\n" + " 2. \"" + head
ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE);
}
} else {
- final List<DataSchemaNode> potentialSchemaNodes = this.findInstanceDataChildrenByName(parentNode, nodeName);
+ final List<DataSchemaNode> potentialSchemaNodes = findInstanceDataChildrenByName(parentNode, nodeName);
if (potentialSchemaNodes.size() > 1) {
final StringBuilder strBuilder = new StringBuilder();
for (final DataSchemaNode potentialNodeSchema : potentialSchemaNodes) {
return new InstanceIdWithSchemaNode(builder.toInstance(), targetNode, mountPoint);
}
- public DataSchemaNode findInstanceDataChildByNameAndNamespace(final DataNodeContainer container, final String name,
+ public static DataSchemaNode findInstanceDataChildByNameAndNamespace(final DataNodeContainer container, final String name,
final URI namespace) {
Preconditions.<URI> checkNotNull(namespace);
- final List<DataSchemaNode> potentialSchemaNodes = this.findInstanceDataChildrenByName(container, name);
+ final List<DataSchemaNode> potentialSchemaNodes = findInstanceDataChildrenByName(container, name);
Predicate<DataSchemaNode> filter = new Predicate<DataSchemaNode>() {
@Override
return Iterables.getFirst(result, null);
}
- public List<DataSchemaNode> findInstanceDataChildrenByName(final DataNodeContainer container, final String name) {
+ public static List<DataSchemaNode> findInstanceDataChildrenByName(final DataNodeContainer container, final String name) {
Preconditions.<DataNodeContainer> checkNotNull(container);
Preconditions.<String> checkNotNull(name);
List<DataSchemaNode> instantiatedDataNodeContainers = new ArrayList<DataSchemaNode>();
- this.collectInstanceDataNodeContainers(instantiatedDataNodeContainers, container, name);
+ collectInstanceDataNodeContainers(instantiatedDataNodeContainers, container, name);
return instantiatedDataNodeContainers;
}
}
};
- private void collectInstanceDataNodeContainers(final List<DataSchemaNode> potentialSchemaNodes,
+ private static void collectInstanceDataNodeContainers(final List<DataSchemaNode> potentialSchemaNodes,
final DataNodeContainer container, final String name) {
Predicate<DataSchemaNode> filter = new Predicate<DataSchemaNode>() {
// Can't combine this loop with the filter above because the filter is
// lazily-applied by Iterables.filter.
for (final DataSchemaNode potentialNode : nodes) {
- if (this.isInstantiatedDataSchema(potentialNode)) {
+ if (isInstantiatedDataSchema(potentialNode)) {
potentialSchemaNodes.add(potentialNode);
}
}
final Iterable<ChoiceCaseNode> allCases = Iterables.<ChoiceCaseNode> concat(map);
for (final ChoiceCaseNode caze : allCases) {
- this.collectInstanceDataNodeContainers(potentialSchemaNodes, caze, name);
+ collectInstanceDataNodeContainers(potentialSchemaNodes, caze, name);
}
}
- public boolean isInstantiatedDataSchema(final DataSchemaNode node) {
+ public static boolean isInstantiatedDataSchema(final DataSchemaNode node) {
return node instanceof LeafSchemaNode || node instanceof LeafListSchemaNode
|| node instanceof ContainerSchemaNode || node instanceof ListSchemaNode
|| node instanceof AnyXmlSchemaNode;
}
private CharSequence convertToRestconfIdentifier(final NodeIdentifier argument, final ContainerSchemaNode node) {
- StringBuilder builder = new StringBuilder();
- builder.append("/");
- QName nodeType = argument.getNodeType();
- builder.append(this.toRestconfIdentifier(nodeType));
- return builder.toString();
+ return "/" + this.toRestconfIdentifier(argument.getNodeType());
}
private CharSequence convertToRestconfIdentifier(final NodeIdentifierWithPredicates argument,
final Map<QName, Object> keyValues = argument.getKeyValues();
StringBuilder builder = new StringBuilder();
- builder.append("/");
+ builder.append('/');
builder.append(nodeIdentifier);
- builder.append("/");
+ builder.append('/');
List<QName> keyDefinition = node.getKeyDefinition();
boolean hasElements = false;
if (!hasElements) {
hasElements = true;
} else {
- builder.append("/");
+ builder.append('/');
}
try {
for (int i = 0; i < identities.size(); i++) {
IdentityValue identityValue = identities.get(i);
URI validNamespace = resolveValidNamespace(identityValue.getNamespace(), mountPoint);
- DataSchemaNode node = ControllerContext.getInstance().findInstanceDataChildByNameAndNamespace(
+ DataSchemaNode node = ControllerContext.findInstanceDataChildByNameAndNamespace(
parentContainer, identityValue.getValue(), validNamespace);
if (node == null) {
logger.info("'{}' node was not found in {}", identityValue, parentContainer.getChildNodes());
Map<QName, Object> predicatesMap = new HashMap<>();
for (Predicate predicate : identityValue.getPredicates()) {
validNamespace = resolveValidNamespace(predicate.getName().getNamespace(), mountPoint);
- DataSchemaNode listKey = ControllerContext.getInstance()
+ DataSchemaNode listKey = ControllerContext
.findInstanceDataChildByNameAndNamespace(listNode, predicate.getName().getValue(),
validNamespace);
predicatesMap.put(listKey.getQName(), predicate.getValue());
}
result.add(pathArgument);
if (i < identities.size() - 1) { // last element in instance-identifier can be other than
- // DataNodeContainer
+ // DataNodeContainer
if (node instanceof DataNodeContainer) {
parentContainer = (DataNodeContainer) node;
} else {
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
+
import java.net.URI;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import javax.ws.rs.core.Response.Status;
import javax.ws.rs.core.UriBuilder;
import javax.ws.rs.core.UriInfo;
+
import org.apache.commons.lang3.StringUtils;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.InstanceIdentifierBuilder;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
-import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.composite.node.schema.cnsn.parser.CnSnToNormalizedNodeParserFactory;
-import org.opendaylight.yangtools.yang.data.composite.node.schema.cnsn.serializer.CnSnFromNormalizedNodeSerializerFactory;
import org.opendaylight.yangtools.yang.data.impl.ImmutableCompositeNode;
import org.opendaylight.yangtools.yang.data.impl.NodeFactory;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
private CompositeNode toStreamCompositeNode(final String streamName, final DataSchemaNode streamSchemaNode) {
final List<Node<?>> streamNodeValues = new ArrayList<Node<?>>();
- List<DataSchemaNode> instanceDataChildrenByName = this.controllerContext.findInstanceDataChildrenByName(
+ List<DataSchemaNode> instanceDataChildrenByName = ControllerContext.findInstanceDataChildrenByName(
((DataNodeContainer) streamSchemaNode), "name");
final DataSchemaNode nameSchemaNode = Iterables.getFirst(instanceDataChildrenByName, null);
streamNodeValues
- .add(NodeFactory.<String> createImmutableSimpleNode(nameSchemaNode.getQName(), null, streamName));
+ .add(NodeFactory.<String> createImmutableSimpleNode(nameSchemaNode.getQName(), null, streamName));
- instanceDataChildrenByName = this.controllerContext.findInstanceDataChildrenByName(
+ instanceDataChildrenByName = ControllerContext.findInstanceDataChildrenByName(
((DataNodeContainer) streamSchemaNode), "description");
final DataSchemaNode descriptionSchemaNode = Iterables.getFirst(instanceDataChildrenByName, null);
streamNodeValues.add(NodeFactory.<String> createImmutableSimpleNode(descriptionSchemaNode.getQName(), null,
"DESCRIPTION_PLACEHOLDER"));
- instanceDataChildrenByName = this.controllerContext.findInstanceDataChildrenByName(
+ instanceDataChildrenByName = ControllerContext.findInstanceDataChildrenByName(
((DataNodeContainer) streamSchemaNode), "replay-support");
final DataSchemaNode replaySupportSchemaNode = Iterables.getFirst(instanceDataChildrenByName, null);
streamNodeValues.add(NodeFactory.<Boolean> createImmutableSimpleNode(replaySupportSchemaNode.getQName(), null,
Boolean.valueOf(true)));
- instanceDataChildrenByName = this.controllerContext.findInstanceDataChildrenByName(
+ instanceDataChildrenByName = ControllerContext.findInstanceDataChildrenByName(
((DataNodeContainer) streamSchemaNode), "replay-log-creation-time");
final DataSchemaNode replayLogCreationTimeSchemaNode = Iterables.getFirst(instanceDataChildrenByName, null);
streamNodeValues.add(NodeFactory.<String> createImmutableSimpleNode(replayLogCreationTimeSchemaNode.getQName(),
null, ""));
- instanceDataChildrenByName = this.controllerContext.findInstanceDataChildrenByName(
+ instanceDataChildrenByName = ControllerContext.findInstanceDataChildrenByName(
((DataNodeContainer) streamSchemaNode), "events");
final DataSchemaNode eventsSchemaNode = Iterables.getFirst(instanceDataChildrenByName, null);
streamNodeValues.add(NodeFactory.<String> createImmutableSimpleNode(eventsSchemaNode.getQName(), null, ""));
private CompositeNode toModuleCompositeNode(final Module module, final DataSchemaNode moduleSchemaNode) {
final List<Node<?>> moduleNodeValues = new ArrayList<Node<?>>();
- List<DataSchemaNode> instanceDataChildrenByName = this.controllerContext.findInstanceDataChildrenByName(
+ List<DataSchemaNode> instanceDataChildrenByName = ControllerContext.findInstanceDataChildrenByName(
((DataNodeContainer) moduleSchemaNode), "name");
final DataSchemaNode nameSchemaNode = Iterables.getFirst(instanceDataChildrenByName, null);
moduleNodeValues.add(NodeFactory.<String> createImmutableSimpleNode(nameSchemaNode.getQName(), null,
module.getName()));
- instanceDataChildrenByName = this.controllerContext.findInstanceDataChildrenByName(
+ instanceDataChildrenByName = ControllerContext.findInstanceDataChildrenByName(
((DataNodeContainer) moduleSchemaNode), "revision");
final DataSchemaNode revisionSchemaNode = Iterables.getFirst(instanceDataChildrenByName, null);
Date _revision = module.getRevision();
moduleNodeValues.add(NodeFactory.<String> createImmutableSimpleNode(revisionSchemaNode.getQName(), null,
REVISION_FORMAT.format(_revision)));
- instanceDataChildrenByName = this.controllerContext.findInstanceDataChildrenByName(
+ instanceDataChildrenByName = ControllerContext.findInstanceDataChildrenByName(
((DataNodeContainer) moduleSchemaNode), "namespace");
final DataSchemaNode namespaceSchemaNode = Iterables.getFirst(instanceDataChildrenByName, null);
moduleNodeValues.add(NodeFactory.<String> createImmutableSimpleNode(namespaceSchemaNode.getQName(), null,
module.getNamespace().toString()));
- instanceDataChildrenByName = this.controllerContext.findInstanceDataChildrenByName(
+ instanceDataChildrenByName = ControllerContext.findInstanceDataChildrenByName(
((DataNodeContainer) moduleSchemaNode), "feature");
final DataSchemaNode featureSchemaNode = Iterables.getFirst(instanceDataChildrenByName, null);
for (final FeatureDefinition feature : module.getFeatures()) {
}
String payloadName = this.getName(payload);
- final DataSchemaNode schemaNode = this.controllerContext.findInstanceDataChildByNameAndNamespace(
+ final DataSchemaNode schemaNode = ControllerContext.findInstanceDataChildByNameAndNamespace(
parentSchema, payloadName, module.getNamespace());
value = this.normalizeNode(payload, schemaNode, mountPoint);
}
String payloadName = this.getName(payload);
- final DataSchemaNode schemaNode = this.controllerContext.findInstanceDataChildByNameAndNamespace(module,
+ final DataSchemaNode schemaNode = ControllerContext.findInstanceDataChildByNameAndNamespace(module,
payloadName, module.getNamespace());
final CompositeNode value = this.normalizeNode(payload, schemaNode, null);
final InstanceIdWithSchemaNode iiWithData = this.addLastIdentifierFromData(null, value, schemaNode);
private boolean representsMountPointRootData(final Node<?> data) {
URI namespace = this.namespace(data);
return (SchemaContext.NAME.getNamespace().equals(namespace) /*
- * || MOUNT_POINT_MODULE_NAME .equals( namespace .
- * toString( ) )
- */)
- && SchemaContext.NAME.getLocalName().equals(this.localName(data));
+ * || MOUNT_POINT_MODULE_NAME .equals( namespace .
+ * toString( ) )
+ */)
+ && SchemaContext.NAME.getLocalName().equals(this.localName(data));
}
private String addMountPointIdentifier(final String identifier) {
final List<NodeWrapper<?>> children = compositeNodeBuilder.getValues();
checkNodeMultiplicityAccordingToSchema(schema, children);
for (final NodeWrapper<? extends Object> child : children) {
- final List<DataSchemaNode> potentialSchemaNodes = this.controllerContext.findInstanceDataChildrenByName(
+ final List<DataSchemaNode> potentialSchemaNodes = ControllerContext.findInstanceDataChildrenByName(
schema, child.getLocalName());
if (potentialSchemaNodes.size() > 1 && child.getNamespace() == null) {
}
if (nodeBuilder.getNamespace() == null || Objects.equal(nodeBuilder.getNamespace(), validQName.getNamespace())
- || Objects.equal(nodeBuilder.getNamespace().toString(), moduleName) /*
- * || Note : this check is wrong -
- * can never be true as it compares
- * a URI with a String not sure what
- * the intention is so commented out
- * ... Objects . equal ( nodeBuilder
- * . getNamespace ( ) ,
- * MOUNT_POINT_MODULE_NAME )
- */) {
+ || Objects.equal(nodeBuilder.getNamespace().toString(), moduleName)) {
+ /*
+ * || Note : this check is wrong -
+ * can never be true as it compares
+ * a URI with a String not sure what
+ * the intention is so commented out
+ * ... Objects . equal ( nodeBuilder
+ * . getNamespace ( ) ,
+ * MOUNT_POINT_MODULE_NAME )
+ */
nodeBuilder.setQname(validQName);
}
}
private CompositeNode datastoreNormalizedNodeToCompositeNode(final NormalizedNode<?, ?> dataNode, final DataSchemaNode schema) {
- Iterable<Node<?>> nodes = null;
+ Node<?> nodes = null;
if (dataNode == null) {
throw new RestconfDocumentedException(new RestconfError(ErrorType.APPLICATION, ErrorTag.DATA_MISSING,
"No data was found."));
}
- if (schema instanceof ContainerSchemaNode && dataNode instanceof ContainerNode) {
- nodes = CnSnFromNormalizedNodeSerializerFactory.getInstance().getContainerNodeSerializer()
- .serialize((ContainerSchemaNode) schema, (ContainerNode) dataNode);
- } else if (schema instanceof ListSchemaNode && dataNode instanceof MapNode) {
- nodes = CnSnFromNormalizedNodeSerializerFactory.getInstance().getMapNodeSerializer()
- .serialize((ListSchemaNode) schema, (MapNode) dataNode);
- } else if (schema instanceof ListSchemaNode && dataNode instanceof MapEntryNode) {
- nodes = CnSnFromNormalizedNodeSerializerFactory.getInstance().getMapEntryNodeSerializer()
- .serialize((ListSchemaNode) schema, (MapEntryNode) dataNode);
- }
+ nodes = DataNormalizer.toLegacy(dataNode);
if (nodes != null) {
- if (nodes.iterator().hasNext()) {
- Node<?> nodeOldStruct = nodes.iterator().next();
- return (CompositeNode) nodeOldStruct;
+ if (nodes instanceof CompositeNode) {
+ return (CompositeNode) nodes;
} else {
LOG.error("The node " + dataNode.getNodeType() + " couldn't be transformed to compositenode.");
}
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
-import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.ImmutableCompositeNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapEntryNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapNodeBuilder;
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;
}
private NormalizedNode prepareCnDataForSlashesBehindMountPointTest() throws ParseException {
- CollectionNodeBuilder<MapEntryNode, MapNode> lst1 = ImmutableMapNodeBuilder.create();
- lst1.withNodeIdentifier(TestUtils.getNodeIdentifier("lst1", "test:module", "2014-01-09"));
- lst1.withChild(ImmutableMapEntryNodeBuilder
+ return ImmutableMapEntryNodeBuilder
.create()
.withNodeIdentifier(
TestUtils.getNodeIdentifierPredicate("lst1", "test:module", "2014-01-09", "lf11",
.withChild(
ImmutableLeafNodeBuilder.create()
.withNodeIdentifier(TestUtils.getNodeIdentifier("lf11", "test:module", "2014-01-09"))
- .withValue("GigabitEthernet0/0/0/0").build()).build());
+ .withValue("GigabitEthernet0/0/0/0").build()).build();
- return lst1.build();
}
/**
expectLeaf("depth3-leaf1", "depth3-leaf1-value")));
}
+ /**
+ * Tests behavior when invalid value of depth URI parameter
+ */
@Test
public void getDataWithInvalidDepthParameterTest() {
private void getDataWithInvalidDepthParameterTest(final UriInfo uriInfo) {
try {
+ QName qNameDepth1Cont = QName.create("urn:nested:module", "2014-06-3", "depth1-cont");
+ YangInstanceIdentifier ii = YangInstanceIdentifier.builder().node(qNameDepth1Cont).build();
+ NormalizedNode value = (NormalizedNode<?,?>)(Builders.containerBuilder().withNodeIdentifier(new NodeIdentifier(qNameDepth1Cont)).build());
+ when(brokerFacade.readConfigurationData(eq(ii))).thenReturn(value);
restconfImpl.readConfigurationData("nested-module:depth1-cont", uriInfo);
fail("Expected RestconfDocumentedException");
} catch (RestconfDocumentedException e) {
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
-import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.composite.node.schema.cnsn.parser.CnSnToNormalizedNodeParserFactory;
import org.opendaylight.yangtools.yang.data.impl.ImmutableCompositeNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapEntryNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.util.CompositeNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
static NormalizedNode prepareNormalizedNodeWithIetfInterfacesInterfacesData() throws ParseException {
String ietfInterfacesDate = "2013-07-04";
- CollectionNodeBuilder<MapEntryNode, MapNode> intface = ImmutableMapNodeBuilder.create();
String namespace = "urn:ietf:params:xml:ns:yang:ietf-interfaces";
- intface.withNodeIdentifier(getNodeIdentifier("interface", namespace, ietfInterfacesDate));
DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> mapEntryNode = ImmutableMapEntryNodeBuilder.create();
Map<String, Object> predicates = new HashMap<>();
.withNodeIdentifier(getNodeIdentifier("description", namespace, ietfInterfacesDate))
.withValue("some interface").build());
- intface.withChild(mapEntryNode.build());
-
- return intface.build();
+ return mapEntryNode.build();
}
}
*/
package org.opendaylight.controller.md.sal.test.model.util;
-import java.util.Arrays;
-
+import com.google.common.collect.ImmutableList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.augment.rev140709.TreeComplexUsesAugment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.augment.rev140709.TreeComplexUsesAugmentBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.augment.rev140709.TreeLeafOnlyUsesAugment;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.augment.rev140709.TreeLeafOnlyUsesAugmentBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.augment.rev140709.complex.from.grouping.ListViaUses;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.augment.rev140709.complex.from.grouping.ListViaUsesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.augment.rev140709.complex.from.grouping.ListViaUsesKey;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import com.google.common.collect.ImmutableList;
+import java.util.Arrays;
public class ListsBindingUtils {
return new TreeComplexUsesAugmentBuilder().setListViaUses(listViaUses.build()).build();
}
+ public static TreeLeafOnlyUsesAugment leafOnlyUsesAugment(String leafFromGroupingValue) {
+
+ return new TreeLeafOnlyUsesAugmentBuilder().setLeafFromGrouping(leafFromGroupingValue).build();
+ }
+
}
<groupId>org.opendaylight.controller.model</groupId>
<artifactId>model-flow-base</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller.model</groupId>
- <artifactId>model-flow-management</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller.model</groupId>
<artifactId>model-flow-service</artifactId>
LinkedHashMap<ConfigSnapshotHolder, EditAndCommitResponse> result = new LinkedHashMap<>();
// start pushing snapshots:
for (ConfigSnapshotHolder configSnapshotHolder : configs) {
- EditAndCommitResponse editAndCommitResponseWithRetries = pushConfigWithConflictingVersionRetries(configSnapshotHolder);
- logger.debug("Config snapshot pushed successfully: {}, result: {}", configSnapshotHolder, result);
- result.put(configSnapshotHolder, editAndCommitResponseWithRetries);
+ if(configSnapshotHolder != null) {
+ EditAndCommitResponse editAndCommitResponseWithRetries = pushConfigWithConflictingVersionRetries(configSnapshotHolder);
+ logger.debug("Config snapshot pushed successfully: {}, result: {}", configSnapshotHolder, result);
+ result.put(configSnapshotHolder, editAndCommitResponseWithRetries);
+ }
}
logger.debug("All configuration snapshots have been pushed successfully.");
return result;
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-data-impl</artifactId>
- <!-- <version>0.6.2-SNAPSHOT</version>-->
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-data-json</artifactId>
- <version>0.6.2-SNAPSHOT</version>
+ <artifactId>yang-data-composite-node</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.NodeSerializerDispatcher;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.DomUtils;
-import org.opendaylight.yangtools.yang.data.json.schema.cnsn.parser.CnSnToNormalizedNodeParserFactory;
+import org.opendaylight.yangtools.yang.data.composite.node.schema.cnsn.parser.CnSnToNormalizedNodeParserFactory;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
<build>
<plugins>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-surefire-plugin</artifactId>
- <configuration>
- <forkCount>1</forkCount>
- <reuseForks>false</reuseForks>
- <perCoreThreadCount>false</perCoreThreadCount>
- </configuration>
- <executions>
- <execution>
- <id>default-test</id>
- <configuration>
- <skip>true</skip>
- </configuration>
- </execution>
- <execution>
- <id>integration-tests</id>
- <goals>
- <goal>test</goal>
- </goals>
- <phase>integration-test</phase>
- <configuration>
- <skip>false</skip>
- <argLine>-Dlogback.configurationFile=${maven.test.dest}/logback.xml</argLine>
- </configuration>
- </execution>
- </executions>
- </plugin>
<plugin>
<groupId>org.ops4j.pax.exam</groupId>
<artifactId>maven-paxexam-plugin</artifactId>
Code Review / controller.git / commitdiff