<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>
<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>
<!--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) {
--- /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"
+ }
+
+]
@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.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) {
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;
+ }
+ }
}
CanCommitTransactionReply reply =
CanCommitTransactionReply.fromSerializable(response);
if (!reply.getCanCommit()) {
- System.out.println("**TOM - failed: false");
return false;
}
}
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();
}
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 =
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() {
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) {
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)) {
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 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) {
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)) {
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)) {
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) {
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"
+ }
+
]
* @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
+}
Code Review / controller.git / commitdiff