summary |
shortlog |
log |
commit | commitdiff |
review |
tree
raw |
patch |
inline | side by side (from parent 1:
53f61d0)
testUnComittedEntryOnLeaderChange(org.opendaylight.controller.cluster.raft.PreLeaderScenarioTest) Time elapsed: 5.207 sec <<< FAILURE!
java.lang.AssertionError: Did not receive message of type class org.opendaylight.controller.cluster.raft.messages.AppendEntries
at org.opendaylight.controller.cluster.raft.utils.MessageCollectorActor.expectFirstMatching(MessageCollectorActor.java:147)
at org.opendaylight.controller.cluster.raft.utils.MessageCollectorActor.expectFirstMatching(MessageCollectorActor.java:125)
at org.opendaylight.controller.cluster.raft.PreLeaderScenarioTest.testUnComittedEntryOnLeaderChange(PreLeaderScenarioTest.java:56)
The MessageCollectorActor does receive the message but occasionally out of order
w.r.t the CLEAR_MESSAGES although the latter is sent prior. The problem is that
AppendEntries is a ControlMessage so can get delivered before CLEAR_MESSAGES thus
CLEAR_MESSAGES needs to also be a ControlMessage.
Another problem with many of the tests is that MessageCollectorActors are created
as TestActors and thus get the CallingThreadDispatcher by default which really isn't
desirable. Some of the tests specifically set the default fork-join dispatcher but
we should just create MessageCollectorActors as normal actors.
Change-Id: I455a500d39aae4c46fb33d59be24c6327a9d321d
Signed-off-by: Tom Pantelis <tompantelis@gmail.com>
25 files changed:
public static class TestRaftActor extends MockRaftActor {
public static class TestRaftActor extends MockRaftActor {
- private final TestActorRef<MessageCollectorActor> collectorActor;
+ private final ActorRef collectorActor;
private final Map<Class<?>, Predicate<?>> dropMessages = new ConcurrentHashMap<>();
private TestRaftActor(Builder builder) {
private final Map<Class<?>, Predicate<?>> dropMessages = new ConcurrentHashMap<>();
private TestRaftActor(Builder builder) {
}
public static class Builder extends AbstractBuilder<Builder, TestRaftActor> {
}
public static class Builder extends AbstractBuilder<Builder, TestRaftActor> {
- private TestActorRef<MessageCollectorActor> collectorActor;
+ private ActorRef collectorActor;
- public Builder collectorActor(TestActorRef<MessageCollectorActor> newCollectorActor) {
+ public Builder collectorActor(ActorRef newCollectorActor) {
this.collectorActor = newCollectorActor;
return this;
}
this.collectorActor = newCollectorActor;
return this;
}
}
protected TestActorRef<TestRaftActor> newTestRaftActor(String id, TestRaftActor.Builder builder) {
}
protected TestActorRef<TestRaftActor> newTestRaftActor(String id, TestRaftActor.Builder builder) {
- builder.collectorActor(factory.<MessageCollectorActor>createTestActor(
- MessageCollectorActor.props().withDispatcher(Dispatchers.DefaultDispatcherId()),
- factory.generateActorId(id + "-collector"))).id(id);
+ builder.collectorActor(factory.createActor(
+ MessageCollectorActor.props(), factory.generateActorId(id + "-collector"))).id(id);
InvalidActorNameException lastEx = null;
for (int i = 0; i < 10; i++) {
InvalidActorNameException lastEx = null;
for (int i = 0; i < 10; i++) {
import static org.opendaylight.controller.cluster.raft.utils.MessageCollectorActor.expectMatching;
import static org.opendaylight.controller.cluster.raft.utils.MessageCollectorActor.getAllMatching;
import static org.opendaylight.controller.cluster.raft.utils.MessageCollectorActor.expectMatching;
import static org.opendaylight.controller.cluster.raft.utils.MessageCollectorActor.getAllMatching;
-import akka.actor.Actor;
import akka.actor.ActorRef;
import akka.actor.ActorRef;
-import akka.actor.Props;
-import akka.testkit.TestActorRef;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import java.util.List;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import java.util.List;
* @author Thomas Pantelis
*/
public class IsolationScenarioTest extends AbstractRaftActorIntegrationTest {
* @author Thomas Pantelis
*/
public class IsolationScenarioTest extends AbstractRaftActorIntegrationTest {
- private TestActorRef<Actor> follower1NotifierActor;
- private TestActorRef<Actor> leaderNotifierActor;
+ private ActorRef follower1NotifierActor;
+ private ActorRef leaderNotifierActor;
/**
* Isolates the leader after all initial payload entries have been committed and applied on all nodes. While
/**
* Isolates the leader after all initial payload entries have been committed and applied on all nodes. While
private void createRaftActors() {
testLog.info("createRaftActors starting");
private void createRaftActors() {
testLog.info("createRaftActors starting");
- follower1NotifierActor = factory.createTestActor(Props.create(MessageCollectorActor.class),
+ follower1NotifierActor = factory.createActor(MessageCollectorActor.props(),
factory.generateActorId(follower1Id + "-notifier"));
DefaultConfigParamsImpl followerConfigParams = new DefaultConfigParamsImpl();
factory.generateActorId(follower1Id + "-notifier"));
DefaultConfigParamsImpl followerConfigParams = new DefaultConfigParamsImpl();
leaderConfigParams = newLeaderConfigParams();
leaderConfigParams.setIsolatedLeaderCheckInterval(new FiniteDuration(500, TimeUnit.MILLISECONDS));
leaderConfigParams = newLeaderConfigParams();
leaderConfigParams.setIsolatedLeaderCheckInterval(new FiniteDuration(500, TimeUnit.MILLISECONDS));
- leaderNotifierActor = factory.createTestActor(Props.create(MessageCollectorActor.class),
+ leaderNotifierActor = factory.createActor(MessageCollectorActor.props(),
factory.generateActorId(leaderId + "-notifier"));
leaderActor = newTestRaftActor(leaderId, TestRaftActor.newBuilder().peerAddresses(peerAddresses)
factory.generateActorId(leaderId + "-notifier"));
leaderActor = newTestRaftActor(leaderId, TestRaftActor.newBuilder().peerAddresses(peerAddresses)
import static org.opendaylight.controller.cluster.raft.utils.MessageCollectorActor.expectMatching;
import akka.actor.ActorRef;
import static org.opendaylight.controller.cluster.raft.utils.MessageCollectorActor.expectMatching;
import akka.actor.ActorRef;
-import akka.actor.Props;
import akka.actor.Status;
import akka.pattern.Patterns;
import akka.testkit.JavaTestKit;
import akka.actor.Status;
import akka.pattern.Patterns;
import akka.testkit.JavaTestKit;
public class LeadershipTransferIntegrationTest extends AbstractRaftActorIntegrationTest {
private final String follower3Id = factory.generateActorId("follower");
public class LeadershipTransferIntegrationTest extends AbstractRaftActorIntegrationTest {
private final String follower3Id = factory.generateActorId("follower");
- private TestActorRef<MessageCollectorActor> leaderNotifierActor;
- private TestActorRef<MessageCollectorActor> follower1NotifierActor;
- private TestActorRef<MessageCollectorActor> follower2NotifierActor;
- private TestActorRef<MessageCollectorActor> follower3NotifierActor;
+ private ActorRef leaderNotifierActor;
+ private ActorRef follower1NotifierActor;
+ private ActorRef follower2NotifierActor;
+ private ActorRef follower3NotifierActor;
private TestActorRef<TestRaftActor> follower3Actor;
private ActorRef follower3CollectorActor;
private ActorRef requestLeadershipResultCollectorActor;
private TestActorRef<TestRaftActor> follower3Actor;
private ActorRef follower3CollectorActor;
private ActorRef requestLeadershipResultCollectorActor;
InMemorySnapshotStore.addSnapshot(follower2Id, snapshot);
InMemorySnapshotStore.addSnapshot(follower3Id, snapshot);
InMemorySnapshotStore.addSnapshot(follower2Id, snapshot);
InMemorySnapshotStore.addSnapshot(follower3Id, snapshot);
- follower1NotifierActor = factory.createTestActor(Props.create(MessageCollectorActor.class),
+ follower1NotifierActor = factory.createActor(MessageCollectorActor.props(),
factory.generateActorId(follower1Id + "-notifier"));
follower1Actor = newTestRaftActor(follower1Id, TestRaftActor.newBuilder().peerAddresses(
ImmutableMap.of(leaderId, testActorPath(leaderId), follower2Id, testActorPath(follower2Id),
follower3Id, testActorPath(follower3Id)))
.config(newFollowerConfigParams()).roleChangeNotifier(follower1NotifierActor));
factory.generateActorId(follower1Id + "-notifier"));
follower1Actor = newTestRaftActor(follower1Id, TestRaftActor.newBuilder().peerAddresses(
ImmutableMap.of(leaderId, testActorPath(leaderId), follower2Id, testActorPath(follower2Id),
follower3Id, testActorPath(follower3Id)))
.config(newFollowerConfigParams()).roleChangeNotifier(follower1NotifierActor));
- follower2NotifierActor = factory.createTestActor(Props.create(MessageCollectorActor.class),
+ follower2NotifierActor = factory.createActor(MessageCollectorActor.props(),
factory.generateActorId(follower2Id + "-notifier"));
follower2Actor = newTestRaftActor(follower2Id,TestRaftActor.newBuilder().peerAddresses(
ImmutableMap.of(leaderId, testActorPath(leaderId), follower1Id, follower1Actor.path().toString(),
follower3Id, testActorPath(follower3Id)))
.config(newFollowerConfigParams()).roleChangeNotifier(follower2NotifierActor));
factory.generateActorId(follower2Id + "-notifier"));
follower2Actor = newTestRaftActor(follower2Id,TestRaftActor.newBuilder().peerAddresses(
ImmutableMap.of(leaderId, testActorPath(leaderId), follower1Id, follower1Actor.path().toString(),
follower3Id, testActorPath(follower3Id)))
.config(newFollowerConfigParams()).roleChangeNotifier(follower2NotifierActor));
- follower3NotifierActor = factory.createTestActor(Props.create(MessageCollectorActor.class),
+ follower3NotifierActor = factory.createActor(MessageCollectorActor.props(),
factory.generateActorId(follower3Id + "-notifier"));
follower3Actor = newTestRaftActor(follower3Id,TestRaftActor.newBuilder().peerAddresses(
ImmutableMap.of(leaderId, testActorPath(leaderId), follower1Id, follower1Actor.path().toString(),
factory.generateActorId(follower3Id + "-notifier"));
follower3Actor = newTestRaftActor(follower3Id,TestRaftActor.newBuilder().peerAddresses(
ImmutableMap.of(leaderId, testActorPath(leaderId), follower1Id, follower1Actor.path().toString(),
leaderConfigParams = newLeaderConfigParams();
leaderConfigParams.setElectionTimeoutFactor(3);
leaderConfigParams = newLeaderConfigParams();
leaderConfigParams.setElectionTimeoutFactor(3);
- leaderNotifierActor = factory.createTestActor(Props.create(MessageCollectorActor.class),
+ leaderNotifierActor = factory.createActor(MessageCollectorActor.props(),
factory.generateActorId(leaderId + "-notifier"));
leaderActor = newTestRaftActor(leaderId, TestRaftActor.newBuilder().peerAddresses(peerAddresses)
.config(leaderConfigParams).roleChangeNotifier(leaderNotifierActor));
factory.generateActorId(leaderId + "-notifier"));
leaderActor = newTestRaftActor(leaderId, TestRaftActor.newBuilder().peerAddresses(peerAddresses)
.config(leaderConfigParams).roleChangeNotifier(leaderNotifierActor));
verifyRaftState(raftActor, rs -> assertEquals("getRaftState", expState.toString(), rs.getRaftState()));
}
verifyRaftState(raftActor, rs -> assertEquals("getRaftState", expState.toString(), rs.getRaftState()));
}
- private static void verifyLeaderStateChangedMessages(final TestActorRef<MessageCollectorActor> notifierActor,
+ private static void verifyLeaderStateChangedMessages(final ActorRef notifierActor,
final String... expLeaderIds) {
List<LeaderStateChanged> leaderStateChanges = expectMatching(notifierActor, LeaderStateChanged.class,
expLeaderIds.length);
final String... expLeaderIds) {
List<LeaderStateChanged> leaderStateChanges = expectMatching(notifierActor, LeaderStateChanged.class,
expLeaderIds.length);
import static org.junit.Assert.assertEquals;
import akka.actor.ActorRef;
import static org.junit.Assert.assertEquals;
import akka.actor.ActorRef;
-import akka.dispatch.Dispatchers;
import com.google.common.base.Optional;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Sets;
import com.google.common.base.Optional;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Sets;
public void testFollowerLeaderStateChanges() {
testLog.info("testFollowerLeaderStateChanges");
public void testFollowerLeaderStateChanges() {
testLog.info("testFollowerLeaderStateChanges");
- ActorRef roleChangeNotifier = factory.<MessageCollectorActor>createTestActor(
- MessageCollectorActor.props().withDispatcher(Dispatchers.DefaultDispatcherId()),
- factory.generateActorId("roleChangeNotifier"));
+ ActorRef roleChangeNotifier = factory.createActor(
+ MessageCollectorActor.props(), factory.generateActorId("roleChangeNotifier"));
follower1Builder.roleChangeNotifier(roleChangeNotifier);
setupLeaderAndNonVotingFollower();
follower1Builder.roleChangeNotifier(roleChangeNotifier);
setupLeaderAndNonVotingFollower();
import static org.opendaylight.controller.cluster.raft.utils.MessageCollectorActor.expectFirstMatching;
import static org.opendaylight.controller.cluster.raft.utils.MessageCollectorActor.expectMatching;
import static org.opendaylight.controller.cluster.raft.utils.MessageCollectorActor.expectFirstMatching;
import static org.opendaylight.controller.cluster.raft.utils.MessageCollectorActor.expectMatching;
-import akka.actor.Actor;
import akka.actor.ActorRef;
import akka.actor.ActorRef;
-import akka.actor.Props;
-import akka.testkit.TestActorRef;
import com.google.common.collect.ImmutableMap;
import java.util.List;
import java.util.concurrent.TimeUnit;
import com.google.common.collect.ImmutableMap;
import java.util.List;
import java.util.concurrent.TimeUnit;
*/
public class PreLeaderScenarioTest extends AbstractRaftActorIntegrationTest {
*/
public class PreLeaderScenarioTest extends AbstractRaftActorIntegrationTest {
- private TestActorRef<Actor> follower1NotifierActor;
+ private ActorRef follower1NotifierActor;
private DefaultConfigParamsImpl followerConfigParams;
@Test
private DefaultConfigParamsImpl followerConfigParams;
@Test
private void createRaftActors() {
testLog.info("createRaftActors starting");
private void createRaftActors() {
testLog.info("createRaftActors starting");
- follower1NotifierActor = factory.createTestActor(Props.create(MessageCollectorActor.class),
+ follower1NotifierActor = factory.createActor(MessageCollectorActor.props(),
factory.generateActorId(follower1Id + "-notifier"));
followerConfigParams = newFollowerConfigParams();
factory.generateActorId(follower1Id + "-notifier"));
followerConfigParams = newFollowerConfigParams();
follower1Context = follower1Actor.underlyingActor().getRaftActorContext();
follower2Context = follower2Actor.underlyingActor().getRaftActorContext();
follower1Context = follower1Actor.underlyingActor().getRaftActorContext();
follower2Context = follower2Actor.underlyingActor().getRaftActorContext();
- testLog.info("createRaftActors ending");
+ testLog.info("createRaftActors ending - follower1: {}, follower2: {}", follower1Id, follower2Id);
actorFactory.generateActorId(FOLLOWER_ID));
private TestActorRef<MockNewFollowerRaftActor> newFollowerRaftActor;
actorFactory.generateActorId(FOLLOWER_ID));
private TestActorRef<MockNewFollowerRaftActor> newFollowerRaftActor;
- private TestActorRef<MessageCollectorActor> newFollowerCollectorActor;
+ private ActorRef newFollowerCollectorActor;
private RaftActorContext newFollowerActorContext;
private final JavaTestKit testKit = new JavaTestKit(getSystem());
private RaftActorContext newFollowerActorContext;
private final JavaTestKit testKit = new JavaTestKit(getSystem());
private void setupNewFollower() {
DefaultConfigParamsImpl configParams = newFollowerConfigParams();
private void setupNewFollower() {
DefaultConfigParamsImpl configParams = newFollowerConfigParams();
- newFollowerCollectorActor = actorFactory.createTestActor(
- MessageCollectorActor.props().withDispatcher(Dispatchers.DefaultDispatcherId()),
+ newFollowerCollectorActor = actorFactory.createActor(MessageCollectorActor.props(),
actorFactory.generateActorId(NEW_SERVER_ID + "Collector"));
newFollowerRaftActor = actorFactory.createTestActor(MockNewFollowerRaftActor.props(
configParams, newFollowerCollectorActor).withDispatcher(Dispatchers.DefaultDispatcherId()),
actorFactory.generateActorId(NEW_SERVER_ID + "Collector"));
newFollowerRaftActor = actorFactory.createTestActor(MockNewFollowerRaftActor.props(
configParams, newFollowerCollectorActor).withDispatcher(Dispatchers.DefaultDispatcherId()),
clearMessages(followerActor);
MockLeaderRaftActor leaderRaftActor = leaderActor.underlyingActor();
clearMessages(followerActor);
MockLeaderRaftActor leaderRaftActor = leaderActor.underlyingActor();
- final TestActorRef<MessageCollectorActor> leaderCollectorActor = newLeaderCollectorActor(leaderRaftActor);
+ final ActorRef leaderCollectorActor = newLeaderCollectorActor(leaderRaftActor);
leaderActor.tell(new AddServer(NEW_SERVER_ID, newFollowerRaftActor.path().toString(), true), testKit.getRef());
leaderActor.tell(new AddServer(NEW_SERVER_ID, newFollowerRaftActor.path().toString(), true), testKit.getRef());
MockLeaderRaftActor leaderRaftActor = leaderActor.underlyingActor();
final RaftActorContext leaderActorContext = leaderRaftActor.getRaftActorContext();
MockLeaderRaftActor leaderRaftActor = leaderActor.underlyingActor();
final RaftActorContext leaderActorContext = leaderRaftActor.getRaftActorContext();
- final TestActorRef<MessageCollectorActor> leaderCollectorActor = newLeaderCollectorActor(leaderRaftActor);
+ final ActorRef leaderCollectorActor = newLeaderCollectorActor(leaderRaftActor);
leaderActor.tell(new AddServer(NEW_SERVER_ID, newFollowerRaftActor.path().toString(), true), testKit.getRef());
leaderActor.tell(new AddServer(NEW_SERVER_ID, newFollowerRaftActor.path().toString(), true), testKit.getRef());
MockLeaderRaftActor leaderRaftActor = leaderActor.underlyingActor();
final RaftActorContext leaderActorContext = leaderRaftActor.getRaftActorContext();
MockLeaderRaftActor leaderRaftActor = leaderActor.underlyingActor();
final RaftActorContext leaderActorContext = leaderRaftActor.getRaftActorContext();
- final TestActorRef<MessageCollectorActor> leaderCollectorActor = newLeaderCollectorActor(leaderRaftActor);
+ final ActorRef leaderCollectorActor = newLeaderCollectorActor(leaderRaftActor);
leaderActor.tell(new AddServer(NEW_SERVER_ID, newFollowerRaftActor.path().toString(), false), testKit.getRef());
leaderActor.tell(new AddServer(NEW_SERVER_ID, newFollowerRaftActor.path().toString(), false), testKit.getRef());
MockLeaderRaftActor leaderRaftActor = leaderActor.underlyingActor();
final RaftActorContext leaderActorContext = leaderRaftActor.getRaftActorContext();
MockLeaderRaftActor leaderRaftActor = leaderActor.underlyingActor();
final RaftActorContext leaderActorContext = leaderRaftActor.getRaftActorContext();
- final TestActorRef<MessageCollectorActor> leaderCollectorActor = newLeaderCollectorActor(leaderRaftActor);
+ final ActorRef leaderCollectorActor = newLeaderCollectorActor(leaderRaftActor);
RaftActorContext follower2ActorContext = newFollowerContext(NEW_SERVER_ID2, followerActor);
Follower newFollower2 = new Follower(follower2ActorContext);
RaftActorContext follower2ActorContext = newFollowerContext(NEW_SERVER_ID2, followerActor);
Follower newFollower2 = new Follower(follower2ActorContext);
MockLeaderRaftActor leaderRaftActor = leaderActor.underlyingActor();
final RaftActorContext leaderActorContext = leaderRaftActor.getRaftActorContext();
MockLeaderRaftActor leaderRaftActor = leaderActor.underlyingActor();
final RaftActorContext leaderActorContext = leaderRaftActor.getRaftActorContext();
- TestActorRef<MessageCollectorActor> leaderCollectorActor = newLeaderCollectorActor(leaderRaftActor);
+ ActorRef leaderCollectorActor = newLeaderCollectorActor(leaderRaftActor);
// Drop commit message for now to delay snapshot completion
leaderRaftActor.setDropMessageOfType(String.class);
// Drop commit message for now to delay snapshot completion
leaderRaftActor.setDropMessageOfType(String.class);
RaftActorContext leaderActorContext = leaderRaftActor.getRaftActorContext();
((DefaultConfigParamsImpl)leaderActorContext.getConfigParams()).setElectionTimeoutFactor(100);
RaftActorContext leaderActorContext = leaderRaftActor.getRaftActorContext();
((DefaultConfigParamsImpl)leaderActorContext.getConfigParams()).setElectionTimeoutFactor(100);
- final TestActorRef<MessageCollectorActor> leaderCollectorActor = newLeaderCollectorActor(leaderRaftActor);
+ final ActorRef leaderCollectorActor = newLeaderCollectorActor(leaderRaftActor);
// Drop the commit message so the snapshot doesn't complete yet.
leaderRaftActor.setDropMessageOfType(COMMIT_MESSAGE_CLASS);
// Drop the commit message so the snapshot doesn't complete yet.
leaderRaftActor.setDropMessageOfType(COMMIT_MESSAGE_CLASS);
((DefaultConfigParamsImpl)leaderActorContext.getConfigParams()).setElectionTimeoutFactor(8);
((DefaultConfigParamsImpl)leaderActorContext.getConfigParams()).setElectionTimeoutFactor(8);
- TestActorRef<MessageCollectorActor> leaderCollectorActor = newLeaderCollectorActor(leaderRaftActor);
+ ActorRef leaderCollectorActor = newLeaderCollectorActor(leaderRaftActor);
// Drop the UnInitializedFollowerSnapshotReply to delay it.
leaderRaftActor.setDropMessageOfType(UnInitializedFollowerSnapshotReply.class);
// Drop the UnInitializedFollowerSnapshotReply to delay it.
leaderRaftActor.setDropMessageOfType(UnInitializedFollowerSnapshotReply.class);
MockLeaderRaftActor leaderRaftActor = leaderActor.underlyingActor();
final RaftActorContext leaderActorContext = leaderRaftActor.getRaftActorContext();
MockLeaderRaftActor leaderRaftActor = leaderActor.underlyingActor();
final RaftActorContext leaderActorContext = leaderRaftActor.getRaftActorContext();
- final TestActorRef<MessageCollectorActor> leaderCollectorActor = newLeaderCollectorActor(leaderRaftActor);
+ final ActorRef leaderCollectorActor = newLeaderCollectorActor(leaderRaftActor);
// Drop UnInitializedFollowerSnapshotReply initially
leaderRaftActor.setDropMessageOfType(UnInitializedFollowerSnapshotReply.class);
// Drop UnInitializedFollowerSnapshotReply initially
leaderRaftActor.setDropMessageOfType(UnInitializedFollowerSnapshotReply.class);
DefaultConfigParamsImpl configParams = new DefaultConfigParamsImpl();
configParams.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS));
DefaultConfigParamsImpl configParams = new DefaultConfigParamsImpl();
configParams.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS));
- TestActorRef<MessageCollectorActor> leaderActor = actorFactory.createTestActor(
- MessageCollectorActor.props().withDispatcher(Dispatchers.DefaultDispatcherId()),
- actorFactory.generateActorId(LEADER_ID));
+ ActorRef leaderActor = actorFactory.createActor(
+ MessageCollectorActor.props(), actorFactory.generateActorId(LEADER_ID));
TestActorRef<MockRaftActor> followerRaftActor = actorFactory.createTestActor(
MockRaftActor.builder().id(FOLLOWER_ID).peerAddresses(ImmutableMap.of(LEADER_ID,
TestActorRef<MockRaftActor> followerRaftActor = actorFactory.createTestActor(
MockRaftActor.builder().id(FOLLOWER_ID).peerAddresses(ImmutableMap.of(LEADER_ID,
DefaultConfigParamsImpl configParams = new DefaultConfigParamsImpl();
configParams.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS));
DefaultConfigParamsImpl configParams = new DefaultConfigParamsImpl();
configParams.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS));
- TestActorRef<MessageCollectorActor> leaderActor = actorFactory.createTestActor(
- MessageCollectorActor.props().withDispatcher(Dispatchers.DefaultDispatcherId()),
- actorFactory.generateActorId(LEADER_ID));
+ ActorRef leaderActor = actorFactory.createTestActor(
+ MessageCollectorActor.props(), actorFactory.generateActorId(LEADER_ID));
TestActorRef<MockRaftActor> followerRaftActor = actorFactory.createTestActor(
MockRaftActor.builder().id(FOLLOWER_ID).peerAddresses(ImmutableMap.of(LEADER_ID,
TestActorRef<MockRaftActor> followerRaftActor = actorFactory.createTestActor(
MockRaftActor.builder().id(FOLLOWER_ID).peerAddresses(ImmutableMap.of(LEADER_ID,
initialActorContext).withDispatcher(Dispatchers.DefaultDispatcherId()),
actorFactory.generateActorId(LEADER_ID));
initialActorContext).withDispatcher(Dispatchers.DefaultDispatcherId()),
actorFactory.generateActorId(LEADER_ID));
- final TestActorRef<MessageCollectorActor> leaderCollector =
- newLeaderCollectorActor(leaderActor.underlyingActor());
+ final ActorRef leaderCollector = newLeaderCollectorActor(leaderActor.underlyingActor());
- TestActorRef<MessageCollectorActor> follower1Collector = actorFactory.createTestActor(
- MessageCollectorActor.props().withDispatcher(Dispatchers.DefaultDispatcherId()),
- actorFactory.generateActorId("collector"));
+ ActorRef follower1Collector = actorFactory.createActor(
+ MessageCollectorActor.props(), actorFactory.generateActorId("collector"));
final TestActorRef<CollectingMockRaftActor> follower1Actor = actorFactory.createTestActor(
CollectingMockRaftActor.props(FOLLOWER_ID, ImmutableMap.of(LEADER_ID, leaderActor.path().toString(),
FOLLOWER_ID2, follower2ActorPath, downNodeId, ""), configParams, NO_PERSISTENCE,
follower1Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), follower1ActorId);
final TestActorRef<CollectingMockRaftActor> follower1Actor = actorFactory.createTestActor(
CollectingMockRaftActor.props(FOLLOWER_ID, ImmutableMap.of(LEADER_ID, leaderActor.path().toString(),
FOLLOWER_ID2, follower2ActorPath, downNodeId, ""), configParams, NO_PERSISTENCE,
follower1Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), follower1ActorId);
- TestActorRef<MessageCollectorActor> follower2Collector = actorFactory.createTestActor(
- MessageCollectorActor.props().withDispatcher(Dispatchers.DefaultDispatcherId()),
- actorFactory.generateActorId("collector"));
+ ActorRef follower2Collector = actorFactory.createActor(
+ MessageCollectorActor.props(), actorFactory.generateActorId("collector"));
final TestActorRef<CollectingMockRaftActor> follower2Actor = actorFactory.createTestActor(
CollectingMockRaftActor.props(FOLLOWER_ID2, ImmutableMap.of(LEADER_ID, leaderActor.path().toString(),
FOLLOWER_ID, follower1ActorPath, downNodeId, ""), configParams, NO_PERSISTENCE,
final TestActorRef<CollectingMockRaftActor> follower2Actor = actorFactory.createTestActor(
CollectingMockRaftActor.props(FOLLOWER_ID2, ImmutableMap.of(LEADER_ID, leaderActor.path().toString(),
FOLLOWER_ID, follower1ActorPath, downNodeId, ""), configParams, NO_PERSISTENCE,
initialActorContext).withDispatcher(Dispatchers.DefaultDispatcherId()),
actorFactory.generateActorId(LEADER_ID));
initialActorContext).withDispatcher(Dispatchers.DefaultDispatcherId()),
actorFactory.generateActorId(LEADER_ID));
- final TestActorRef<MessageCollectorActor> leaderCollector =
- newLeaderCollectorActor(leaderActor.underlyingActor());
+ final ActorRef leaderCollector = newLeaderCollectorActor(leaderActor.underlyingActor());
- final TestActorRef<MessageCollectorActor> followerCollector =
- actorFactory.createTestActor(MessageCollectorActor.props()
- .withDispatcher(Dispatchers.DefaultDispatcherId()), actorFactory.generateActorId("collector"));
+ final ActorRef followerCollector =
+ actorFactory.createActor(MessageCollectorActor.props(), actorFactory.generateActorId("collector"));
actorFactory.createTestActor(
CollectingMockRaftActor.props(FOLLOWER_ID, ImmutableMap.of(LEADER_ID, leaderActor.path().toString()),
configParams, NO_PERSISTENCE, followerCollector)
actorFactory.createTestActor(
CollectingMockRaftActor.props(FOLLOWER_ID, ImmutableMap.of(LEADER_ID, leaderActor.path().toString()),
configParams, NO_PERSISTENCE, followerCollector)
MockLeaderRaftActor.props(ImmutableMap.of(FOLLOWER_ID, follower1ActorPath,
FOLLOWER_ID2, follower2ActorPath), new MockRaftActorContext())
.withDispatcher(Dispatchers.DefaultDispatcherId()), actorFactory.generateActorId(LEADER_ID));
MockLeaderRaftActor.props(ImmutableMap.of(FOLLOWER_ID, follower1ActorPath,
FOLLOWER_ID2, follower2ActorPath), new MockRaftActorContext())
.withDispatcher(Dispatchers.DefaultDispatcherId()), actorFactory.generateActorId(LEADER_ID));
- TestActorRef<MessageCollectorActor> leaderCollector = newLeaderCollectorActor(leaderActor.underlyingActor());
+ ActorRef leaderCollector = newLeaderCollectorActor(leaderActor.underlyingActor());
- TestActorRef<MessageCollectorActor> follower1Collector = actorFactory.createTestActor(
- MessageCollectorActor.props().withDispatcher(Dispatchers.DefaultDispatcherId()),
- actorFactory.generateActorId("collector"));
+ ActorRef follower1Collector = actorFactory.createActor(
+ MessageCollectorActor.props(), actorFactory.generateActorId("collector"));
final TestActorRef<CollectingMockRaftActor> follower1RaftActor = actorFactory.createTestActor(
CollectingMockRaftActor.props(FOLLOWER_ID, ImmutableMap.of(LEADER_ID, leaderActor.path().toString(),
FOLLOWER_ID2, follower2ActorPath), configParams, NO_PERSISTENCE, follower1Collector)
.withDispatcher(Dispatchers.DefaultDispatcherId()), follower1ActorId);
final TestActorRef<CollectingMockRaftActor> follower1RaftActor = actorFactory.createTestActor(
CollectingMockRaftActor.props(FOLLOWER_ID, ImmutableMap.of(LEADER_ID, leaderActor.path().toString(),
FOLLOWER_ID2, follower2ActorPath), configParams, NO_PERSISTENCE, follower1Collector)
.withDispatcher(Dispatchers.DefaultDispatcherId()), follower1ActorId);
- TestActorRef<MessageCollectorActor> follower2Collector = actorFactory.createTestActor(
- MessageCollectorActor.props().withDispatcher(Dispatchers.DefaultDispatcherId()),
- actorFactory.generateActorId("collector"));
+ ActorRef follower2Collector = actorFactory.createActor(
+ MessageCollectorActor.props(), actorFactory.generateActorId("collector"));
final TestActorRef<CollectingMockRaftActor> follower2RaftActor = actorFactory.createTestActor(
CollectingMockRaftActor.props(FOLLOWER_ID2, ImmutableMap.of(LEADER_ID, leaderActor.path().toString(),
FOLLOWER_ID, follower1ActorPath), configParams, NO_PERSISTENCE, follower2Collector)
final TestActorRef<CollectingMockRaftActor> follower2RaftActor = actorFactory.createTestActor(
CollectingMockRaftActor.props(FOLLOWER_ID2, ImmutableMap.of(LEADER_ID, leaderActor.path().toString(),
FOLLOWER_ID, follower1ActorPath), configParams, NO_PERSISTENCE, follower2Collector)
MockLeaderRaftActor.props(ImmutableMap.of(FOLLOWER_ID, follower1ActorPath,
FOLLOWER_ID2, follower2ActorPath), new MockRaftActorContext())
.withDispatcher(Dispatchers.DefaultDispatcherId()), actorFactory.generateActorId(LEADER_ID));
MockLeaderRaftActor.props(ImmutableMap.of(FOLLOWER_ID, follower1ActorPath,
FOLLOWER_ID2, follower2ActorPath), new MockRaftActorContext())
.withDispatcher(Dispatchers.DefaultDispatcherId()), actorFactory.generateActorId(LEADER_ID));
- TestActorRef<MessageCollectorActor> leaderCollector = newLeaderCollectorActor(leaderActor.underlyingActor());
+ ActorRef leaderCollector = newLeaderCollectorActor(leaderActor.underlyingActor());
- TestActorRef<MessageCollectorActor> follower1Collector = actorFactory.createTestActor(
- MessageCollectorActor.props().withDispatcher(Dispatchers.DefaultDispatcherId()),
- actorFactory.generateActorId("collector"));
+ ActorRef follower1Collector = actorFactory.createActor(
+ MessageCollectorActor.props(), actorFactory.generateActorId("collector"));
final TestActorRef<CollectingMockRaftActor> follower1RaftActor = actorFactory.createTestActor(
CollectingMockRaftActor.props(FOLLOWER_ID, ImmutableMap.of(LEADER_ID, leaderActor.path().toString(),
FOLLOWER_ID2, follower2ActorPath), configParams, NO_PERSISTENCE, follower1Collector)
.withDispatcher(Dispatchers.DefaultDispatcherId()), follower1ActorId);
final TestActorRef<CollectingMockRaftActor> follower1RaftActor = actorFactory.createTestActor(
CollectingMockRaftActor.props(FOLLOWER_ID, ImmutableMap.of(LEADER_ID, leaderActor.path().toString(),
FOLLOWER_ID2, follower2ActorPath), configParams, NO_PERSISTENCE, follower1Collector)
.withDispatcher(Dispatchers.DefaultDispatcherId()), follower1ActorId);
- TestActorRef<MessageCollectorActor> follower2Collector = actorFactory.createTestActor(
- MessageCollectorActor.props().withDispatcher(Dispatchers.DefaultDispatcherId()),
- actorFactory.generateActorId("collector"));
+ ActorRef follower2Collector = actorFactory.createActor(
+ MessageCollectorActor.props(), actorFactory.generateActorId("collector"));
final TestActorRef<CollectingMockRaftActor> follower2RaftActor = actorFactory.createTestActor(
CollectingMockRaftActor.props(FOLLOWER_ID2, ImmutableMap.of(LEADER_ID, leaderActor.path().toString(),
FOLLOWER_ID, follower1ActorPath), configParams, NO_PERSISTENCE, follower2Collector)
final TestActorRef<CollectingMockRaftActor> follower2RaftActor = actorFactory.createTestActor(
CollectingMockRaftActor.props(FOLLOWER_ID2, ImmutableMap.of(LEADER_ID, leaderActor.path().toString(),
FOLLOWER_ID, follower1ActorPath), configParams, NO_PERSISTENCE, follower2Collector)
InMemoryJournal.addEntry(node2ID, 2, persistedServerConfigEntry);
InMemoryJournal.addEntry(node2ID, 3, new ApplyJournalEntries(0));
InMemoryJournal.addEntry(node2ID, 2, persistedServerConfigEntry);
InMemoryJournal.addEntry(node2ID, 3, new ApplyJournalEntries(0));
- TestActorRef<MessageCollectorActor> node1Collector = actorFactory.createTestActor(
- MessageCollectorActor.props().withDispatcher(Dispatchers.DefaultDispatcherId()),
- actorFactory.generateActorId("collector"));
+ ActorRef node1Collector = actorFactory.createActor(
+ MessageCollectorActor.props(), actorFactory.generateActorId("collector"));
TestActorRef<CollectingMockRaftActor> node1RaftActorRef = actorFactory.createTestActor(
CollectingMockRaftActor.props(node1ID, ImmutableMap.<String, String>of(), configParams,
PERSISTENT, node1Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), node1ID);
CollectingMockRaftActor node1RaftActor = node1RaftActorRef.underlyingActor();
TestActorRef<CollectingMockRaftActor> node1RaftActorRef = actorFactory.createTestActor(
CollectingMockRaftActor.props(node1ID, ImmutableMap.<String, String>of(), configParams,
PERSISTENT, node1Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), node1ID);
CollectingMockRaftActor node1RaftActor = node1RaftActorRef.underlyingActor();
- TestActorRef<MessageCollectorActor> node2Collector = actorFactory.createTestActor(
- MessageCollectorActor.props().withDispatcher(Dispatchers.DefaultDispatcherId()),
- actorFactory.generateActorId("collector"));
+ ActorRef node2Collector = actorFactory.createActor(
+ MessageCollectorActor.props(), actorFactory.generateActorId("collector"));
TestActorRef<CollectingMockRaftActor> node2RaftActorRef = actorFactory.createTestActor(
CollectingMockRaftActor.props(node2ID, ImmutableMap.<String, String>of(), configParams,
PERSISTENT, node2Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), node2ID);
TestActorRef<CollectingMockRaftActor> node2RaftActorRef = actorFactory.createTestActor(
CollectingMockRaftActor.props(node2ID, ImmutableMap.<String, String>of(), configParams,
PERSISTENT, node2Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), node2ID);
configParams1.setHeartBeatInterval(new FiniteDuration(100, TimeUnit.MILLISECONDS));
configParams1.setElectionTimeoutFactor(1);
configParams1.setPeerAddressResolver(peerAddressResolver);
configParams1.setHeartBeatInterval(new FiniteDuration(100, TimeUnit.MILLISECONDS));
configParams1.setElectionTimeoutFactor(1);
configParams1.setPeerAddressResolver(peerAddressResolver);
- TestActorRef<MessageCollectorActor> node1Collector = actorFactory.createTestActor(
- MessageCollectorActor.props().withDispatcher(Dispatchers.DefaultDispatcherId()),
- actorFactory.generateActorId("collector"));
+ ActorRef node1Collector = actorFactory.createActor(
+ MessageCollectorActor.props(), actorFactory.generateActorId("collector"));
TestActorRef<CollectingMockRaftActor> node1RaftActorRef = actorFactory.createTestActor(
CollectingMockRaftActor.props(node1ID, ImmutableMap.<String, String>of(), configParams1,
PERSISTENT, node1Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), node1ID);
TestActorRef<CollectingMockRaftActor> node1RaftActorRef = actorFactory.createTestActor(
CollectingMockRaftActor.props(node1ID, ImmutableMap.<String, String>of(), configParams1,
PERSISTENT, node1Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), node1ID);
DefaultConfigParamsImpl configParams2 = new DefaultConfigParamsImpl();
configParams2.setElectionTimeoutFactor(1000000);
configParams2.setPeerAddressResolver(peerAddressResolver);
DefaultConfigParamsImpl configParams2 = new DefaultConfigParamsImpl();
configParams2.setElectionTimeoutFactor(1000000);
configParams2.setPeerAddressResolver(peerAddressResolver);
- TestActorRef<MessageCollectorActor> node2Collector = actorFactory.createTestActor(
- MessageCollectorActor.props().withDispatcher(Dispatchers.DefaultDispatcherId()),
- actorFactory.generateActorId("collector"));
+ ActorRef node2Collector = actorFactory.createActor(
+ MessageCollectorActor.props(), actorFactory.generateActorId("collector"));
TestActorRef<CollectingMockRaftActor> node2RaftActorRef = actorFactory.createTestActor(
CollectingMockRaftActor.props(node2ID, ImmutableMap.<String, String>of(), configParams2,
PERSISTENT, node2Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), node2ID);
TestActorRef<CollectingMockRaftActor> node2RaftActorRef = actorFactory.createTestActor(
CollectingMockRaftActor.props(node2ID, ImmutableMap.<String, String>of(), configParams2,
PERSISTENT, node2Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), node2ID);
new MockRaftActorContext.MockPayload("2")));
InMemoryJournal.addEntry(node2ID, 4, new ApplyJournalEntries(1));
new MockRaftActorContext.MockPayload("2")));
InMemoryJournal.addEntry(node2ID, 4, new ApplyJournalEntries(1));
- TestActorRef<MessageCollectorActor> node1Collector = actorFactory.createTestActor(
- MessageCollectorActor.props().withDispatcher(Dispatchers.DefaultDispatcherId()),
- actorFactory.generateActorId("collector"));
+ ActorRef node1Collector = actorFactory.createActor(
+ MessageCollectorActor.props(), actorFactory.generateActorId("collector"));
TestActorRef<CollectingMockRaftActor> node1RaftActorRef = actorFactory.createTestActor(
CollectingMockRaftActor.props(node1ID, ImmutableMap.<String, String>of(), configParams,
PERSISTENT, node1Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), node1ID);
final CollectingMockRaftActor node1RaftActor = node1RaftActorRef.underlyingActor();
TestActorRef<CollectingMockRaftActor> node1RaftActorRef = actorFactory.createTestActor(
CollectingMockRaftActor.props(node1ID, ImmutableMap.<String, String>of(), configParams,
PERSISTENT, node1Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), node1ID);
final CollectingMockRaftActor node1RaftActor = node1RaftActorRef.underlyingActor();
- TestActorRef<MessageCollectorActor> node2Collector = actorFactory.createTestActor(
- MessageCollectorActor.props().withDispatcher(Dispatchers.DefaultDispatcherId()),
- actorFactory.generateActorId("collector"));
+ ActorRef node2Collector = actorFactory.createActor(
+ MessageCollectorActor.props(), actorFactory.generateActorId("collector"));
TestActorRef<CollectingMockRaftActor> node2RaftActorRef = actorFactory.createTestActor(
CollectingMockRaftActor.props(node2ID, ImmutableMap.<String, String>of(), configParams,
PERSISTENT, node2Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), node2ID);
TestActorRef<CollectingMockRaftActor> node2RaftActorRef = actorFactory.createTestActor(
CollectingMockRaftActor.props(node2ID, ImmutableMap.<String, String>of(), configParams,
PERSISTENT, node2Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), node2ID);
InMemoryJournal.addEntry(node2ID, 1, new UpdateElectionTerm(1, "node1"));
InMemoryJournal.addEntry(node2ID, 2, persistedServerConfigEntry);
InMemoryJournal.addEntry(node2ID, 1, new UpdateElectionTerm(1, "node1"));
InMemoryJournal.addEntry(node2ID, 2, persistedServerConfigEntry);
- TestActorRef<MessageCollectorActor> node1Collector = actorFactory.createTestActor(
- MessageCollectorActor.props().withDispatcher(Dispatchers.DefaultDispatcherId()),
- actorFactory.generateActorId("collector"));
+ ActorRef node1Collector = actorFactory.createActor(
+ MessageCollectorActor.props(), actorFactory.generateActorId("collector"));
TestActorRef<CollectingMockRaftActor> node1RaftActorRef = actorFactory.createTestActor(
CollectingMockRaftActor.props(node1ID, ImmutableMap.<String, String>of(), configParams,
PERSISTENT, node1Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), node1ID);
final CollectingMockRaftActor node1RaftActor = node1RaftActorRef.underlyingActor();
TestActorRef<CollectingMockRaftActor> node1RaftActorRef = actorFactory.createTestActor(
CollectingMockRaftActor.props(node1ID, ImmutableMap.<String, String>of(), configParams,
PERSISTENT, node1Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), node1ID);
final CollectingMockRaftActor node1RaftActor = node1RaftActorRef.underlyingActor();
- TestActorRef<MessageCollectorActor> node2Collector = actorFactory.createTestActor(
- MessageCollectorActor.props().withDispatcher(Dispatchers.DefaultDispatcherId()),
- actorFactory.generateActorId("collector"));
+ ActorRef node2Collector = actorFactory.createActor(
+ MessageCollectorActor.props(), actorFactory.generateActorId("collector"));
TestActorRef<CollectingMockRaftActor> node2RaftActorRef = actorFactory.createTestActor(
CollectingMockRaftActor.props(node2ID, ImmutableMap.<String, String>of(), configParams,
PERSISTENT, node2Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), node2ID);
TestActorRef<CollectingMockRaftActor> node2RaftActorRef = actorFactory.createTestActor(
CollectingMockRaftActor.props(node2ID, ImmutableMap.<String, String>of(), configParams,
PERSISTENT, node2Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), node2ID);
return new ServerInfo(id, false);
}
return new ServerInfo(id, false);
}
- private TestActorRef<MessageCollectorActor> newLeaderCollectorActor(MockLeaderRaftActor leaderRaftActor) {
+ private ActorRef newLeaderCollectorActor(MockLeaderRaftActor leaderRaftActor) {
return newCollectorActor(leaderRaftActor, LEADER_ID);
}
return newCollectorActor(leaderRaftActor, LEADER_ID);
}
- private TestActorRef<MessageCollectorActor> newCollectorActor(AbstractMockRaftActor raftActor, String id) {
- TestActorRef<MessageCollectorActor> collectorActor = actorFactory.createTestActor(
- MessageCollectorActor.props().withDispatcher(Dispatchers.DefaultDispatcherId()),
- actorFactory.generateActorId(id + "Collector"));
+ private ActorRef newCollectorActor(AbstractMockRaftActor raftActor, String id) {
+ ActorRef collectorActor = actorFactory.createTestActor(
+ MessageCollectorActor.props(), actorFactory.generateActorId(id + "Collector"));
raftActor.setCollectorActor(collectorActor);
return collectorActor;
}
raftActor.setCollectorActor(collectorActor);
return collectorActor;
}
}
abstract static class AbstractMockRaftActor extends MockRaftActor {
}
abstract static class AbstractMockRaftActor extends MockRaftActor {
- private volatile TestActorRef<MessageCollectorActor> collectorActor;
+ private volatile ActorRef collectorActor;
private volatile Class<?> dropMessageOfType;
AbstractMockRaftActor(String id, Map<String, String> peerAddresses, Optional<ConfigParams> config,
private volatile Class<?> dropMessageOfType;
AbstractMockRaftActor(String id, Map<String, String> peerAddresses, Optional<ConfigParams> config,
- boolean persistent, TestActorRef<MessageCollectorActor> collectorActor) {
+ boolean persistent, ActorRef collectorActor) {
super(builder().id(id).peerAddresses(peerAddresses).config(config.get())
.persistent(Optional.of(persistent)));
this.collectorActor = collectorActor;
super(builder().id(id).peerAddresses(peerAddresses).config(config.get())
.persistent(Optional.of(persistent)));
this.collectorActor = collectorActor;
this.dropMessageOfType = dropMessageOfType;
}
this.dropMessageOfType = dropMessageOfType;
}
- void setCollectorActor(TestActorRef<MessageCollectorActor> collectorActor) {
+ void setCollectorActor(ActorRef collectorActor) {
this.collectorActor = collectorActor;
}
this.collectorActor = collectorActor;
}
public static class CollectingMockRaftActor extends AbstractMockRaftActor {
CollectingMockRaftActor(String id, Map<String, String> peerAddresses, Optional<ConfigParams> config,
public static class CollectingMockRaftActor extends AbstractMockRaftActor {
CollectingMockRaftActor(String id, Map<String, String> peerAddresses, Optional<ConfigParams> config,
- boolean persistent, TestActorRef<MessageCollectorActor> collectorActor) {
+ boolean persistent, ActorRef collectorActor) {
super(id, peerAddresses, config, persistent, collectorActor);
snapshotCohortDelegate = new RaftActorSnapshotCohort() {
@Override
super(id, peerAddresses, config, persistent, collectorActor);
snapshotCohortDelegate = new RaftActorSnapshotCohort() {
@Override
}
public static Props props(final String id, final Map<String, String> peerAddresses,
}
public static Props props(final String id, final Map<String, String> peerAddresses,
- ConfigParams config, boolean persistent, TestActorRef<MessageCollectorActor> collectorActor) {
+ ConfigParams config, boolean persistent, ActorRef collectorActor) {
return Props.create(CollectingMockRaftActor.class, id, peerAddresses, Optional.of(config),
persistent, collectorActor);
return Props.create(CollectingMockRaftActor.class, id, peerAddresses, Optional.of(config),
persistent, collectorActor);
}
public static class MockNewFollowerRaftActor extends AbstractMockRaftActor {
}
public static class MockNewFollowerRaftActor extends AbstractMockRaftActor {
- public MockNewFollowerRaftActor(ConfigParams config, TestActorRef<MessageCollectorActor> collectorActor) {
+ public MockNewFollowerRaftActor(ConfigParams config, ActorRef collectorActor) {
super(NEW_SERVER_ID, Maps.<String, String>newHashMap(), Optional.of(config), NO_PERSISTENCE,
collectorActor);
setPersistence(false);
}
super(NEW_SERVER_ID, Maps.<String, String>newHashMap(), Optional.of(config), NO_PERSISTENCE,
collectorActor);
setPersistence(false);
}
- static Props props(ConfigParams config, TestActorRef<MessageCollectorActor> collectorActor) {
+ static Props props(ConfigParams config, ActorRef collectorActor) {
return Props.create(MockNewFollowerRaftActor.class, config, collectorActor);
}
}
return Props.create(MockNewFollowerRaftActor.class, config, collectorActor);
}
}
import akka.actor.ActorRef;
import akka.actor.PoisonPill;
import akka.actor.ActorRef;
import akka.actor.PoisonPill;
-import akka.actor.Props;
import akka.actor.Status.Failure;
import akka.actor.Terminated;
import akka.dispatch.Dispatchers;
import akka.actor.Status.Failure;
import akka.actor.Terminated;
import akka.dispatch.Dispatchers;
@Test
public void testRaftRoleChangeNotifierWhenRaftActorHasNoPeers() throws Exception {
@Test
public void testRaftRoleChangeNotifierWhenRaftActorHasNoPeers() throws Exception {
- TestActorRef<MessageCollectorActor> notifierActor = factory.createTestActor(
- Props.create(MessageCollectorActor.class));
+ ActorRef notifierActor = factory.createActor(MessageCollectorActor.props());
MessageCollectorActor.waitUntilReady(notifierActor);
DefaultConfigParamsImpl config = new DefaultConfigParamsImpl();
MessageCollectorActor.waitUntilReady(notifierActor);
DefaultConfigParamsImpl config = new DefaultConfigParamsImpl();
assertEquals(raftRoleChanged.getMemberId(), leaderStateChange.getLeaderId());
assertEquals(MockRaftActor.PAYLOAD_VERSION, leaderStateChange.getLeaderPayloadVersion());
assertEquals(raftRoleChanged.getMemberId(), leaderStateChange.getLeaderId());
assertEquals(MockRaftActor.PAYLOAD_VERSION, leaderStateChange.getLeaderPayloadVersion());
- notifierActor.underlyingActor().clear();
+ MessageCollectorActor.clearMessages(notifierActor);
MockRaftActor raftActor = raftActorRef.underlyingActor();
final String newLeaderId = "new-leader";
MockRaftActor raftActor = raftActorRef.underlyingActor();
final String newLeaderId = "new-leader";
assertEquals(RaftState.Leader.name(), raftRoleChanged.getOldRole());
assertEquals(RaftState.Follower.name(), raftRoleChanged.getNewRole());
assertEquals(RaftState.Leader.name(), raftRoleChanged.getOldRole());
assertEquals(RaftState.Follower.name(), raftRoleChanged.getNewRole());
- notifierActor.underlyingActor().clear();
+ MessageCollectorActor.clearMessages(notifierActor);
raftActor.handleCommand("any");
raftActor.handleCommand("any");
assertEquals(newLeaderId, leaderStateChange.getLeaderId());
assertEquals(newLeaderVersion, leaderStateChange.getLeaderPayloadVersion());
assertEquals(newLeaderId, leaderStateChange.getLeaderId());
assertEquals(newLeaderVersion, leaderStateChange.getLeaderPayloadVersion());
- notifierActor.underlyingActor().clear();
+ MessageCollectorActor.clearMessages(notifierActor);
raftActor.handleCommand("any");
raftActor.handleCommand("any");
@Test
public void testRaftRoleChangeNotifierWhenRaftActorHasPeers() throws Exception {
@Test
public void testRaftRoleChangeNotifierWhenRaftActorHasPeers() throws Exception {
- ActorRef notifierActor = factory.createActor(Props.create(MessageCollectorActor.class));
+ ActorRef notifierActor = factory.createActor(MessageCollectorActor.props());
MessageCollectorActor.waitUntilReady(notifierActor);
DefaultConfigParamsImpl config = new DefaultConfigParamsImpl();
MessageCollectorActor.waitUntilReady(notifierActor);
DefaultConfigParamsImpl config = new DefaultConfigParamsImpl();
final String persistenceId = factory.generateActorId("leader-");
final String follower1Id = factory.generateActorId("follower-");
final String persistenceId = factory.generateActorId("leader-");
final String follower1Id = factory.generateActorId("follower-");
- ActorRef followerActor1 =
- factory.createActor(Props.create(MessageCollectorActor.class));
+ ActorRef followerActor1 = factory.createActor(MessageCollectorActor.props());
DefaultConfigParamsImpl config = new DefaultConfigParamsImpl();
config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS));
DefaultConfigParamsImpl config = new DefaultConfigParamsImpl();
config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS));
final String persistenceId = factory.generateActorId("follower-");
final String leaderId = factory.generateActorId("leader-");
final String persistenceId = factory.generateActorId("follower-");
final String leaderId = factory.generateActorId("leader-");
-
- ActorRef leaderActor1 =
- factory.createActor(Props.create(MessageCollectorActor.class));
+ ActorRef leaderActor1 = factory.createActor(MessageCollectorActor.props());
DefaultConfigParamsImpl config = new DefaultConfigParamsImpl();
config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS));
DefaultConfigParamsImpl config = new DefaultConfigParamsImpl();
config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS));
final String follower1Id = factory.generateActorId("follower-");
final String follower2Id = factory.generateActorId("follower-");
final String follower1Id = factory.generateActorId("follower-");
final String follower2Id = factory.generateActorId("follower-");
- final ActorRef followerActor1 = factory.createActor(Props.create(MessageCollectorActor.class), follower1Id);
- final ActorRef followerActor2 = factory.createActor(Props.create(MessageCollectorActor.class), follower2Id);
+ final ActorRef followerActor1 = factory.createActor(MessageCollectorActor.props(), follower1Id);
+ final ActorRef followerActor2 = factory.createActor(MessageCollectorActor.props(), follower2Id);
DefaultConfigParamsImpl config = new DefaultConfigParamsImpl();
config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS));
DefaultConfigParamsImpl config = new DefaultConfigParamsImpl();
config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS));
public void testLeaderTransitioning() throws Exception {
TEST_LOG.info("testLeaderTransitioning starting");
public void testLeaderTransitioning() throws Exception {
TEST_LOG.info("testLeaderTransitioning starting");
- TestActorRef<MessageCollectorActor> notifierActor = factory.createTestActor(
- Props.create(MessageCollectorActor.class));
+ ActorRef notifierActor = factory.createActor(MessageCollectorActor.props());
DefaultConfigParamsImpl config = new DefaultConfigParamsImpl();
config.setCustomRaftPolicyImplementationClass(DisableElectionsRaftPolicy.class.getName());
DefaultConfigParamsImpl config = new DefaultConfigParamsImpl();
config.setCustomRaftPolicyImplementationClass(DisableElectionsRaftPolicy.class.getName());
final String leaderId = factory.generateActorId("leader-");
final String followerId = factory.generateActorId("follower-");
final String leaderId = factory.generateActorId("leader-");
final String followerId = factory.generateActorId("follower-");
- final ActorRef followerActor = factory.createActor(Props.create(MessageCollectorActor.class));
+ final ActorRef followerActor = factory.createActor(MessageCollectorActor.props());
DefaultConfigParamsImpl config = new DefaultConfigParamsImpl();
config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS));
DefaultConfigParamsImpl config = new DefaultConfigParamsImpl();
config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS));
final String leaderId = factory.generateActorId("leader-");
final String followerId = factory.generateActorId("follower-");
final String leaderId = factory.generateActorId("leader-");
final String followerId = factory.generateActorId("follower-");
- final ActorRef followerActor = factory.createActor(Props.create(MessageCollectorActor.class));
+ final ActorRef followerActor = factory.createActor(MessageCollectorActor.props());
DefaultConfigParamsImpl config = new DefaultConfigParamsImpl();
config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS));
DefaultConfigParamsImpl config = new DefaultConfigParamsImpl();
config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS));
import akka.actor.ActorRef;
import akka.persistence.SnapshotSelectionCriteria;
import akka.actor.ActorRef;
import akka.persistence.SnapshotSelectionCriteria;
-import akka.testkit.TestActorRef;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.Optional;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.Optional;
private TestActorFactory factory;
private TestActorFactory factory;
- private TestActorRef<MessageCollectorActor> actorRef;
+ private ActorRef actorRef;
@Before
public void setUp() {
@Before
public void setUp() {
snapshotManager = new SnapshotManager(mockRaftActorContext, LoggerFactory.getLogger(this.getClass()));
factory = new TestActorFactory(getSystem());
snapshotManager = new SnapshotManager(mockRaftActorContext, LoggerFactory.getLogger(this.getClass()));
factory = new TestActorFactory(getSystem());
- actorRef = factory.createTestActor(MessageCollectorActor.props(), factory.generateActorId("test-"));
+ actorRef = factory.createActor(MessageCollectorActor.props(), factory.generateActorId("test-"));
doReturn(actorRef).when(mockRaftActorContext).getActor();
snapshotManager.setCreateSnapshotConsumer(mockProcedure);
doReturn(actorRef).when(mockRaftActorContext).getActor();
snapshotManager.setCreateSnapshotConsumer(mockProcedure);
//
assertEquals(-1L, captureSnapshot.getReplicatedToAllIndex());
assertEquals(-1L, captureSnapshot.getReplicatedToAllTerm());
//
assertEquals(-1L, captureSnapshot.getReplicatedToAllIndex());
assertEquals(-1L, captureSnapshot.getReplicatedToAllTerm());
- actorRef.underlyingActor().clear();
+ MessageCollectorActor.clearMessages(actorRef);
}
@SuppressWarnings({ "rawtypes", "unchecked" })
}
@SuppressWarnings({ "rawtypes", "unchecked" })
assertEquals(-1L, captureSnapshot.getReplicatedToAllIndex());
assertEquals(-1L, captureSnapshot.getReplicatedToAllTerm());
assertEquals(-1L, captureSnapshot.getReplicatedToAllIndex());
assertEquals(-1L, captureSnapshot.getReplicatedToAllTerm());
- actorRef.underlyingActor().clear();
-
+ MessageCollectorActor.clearMessages(actorRef);
}
@SuppressWarnings({ "unchecked", "rawtypes" })
}
@SuppressWarnings({ "unchecked", "rawtypes" })
//
assertEquals(-1L, captureSnapshot.getReplicatedToAllIndex());
assertEquals(-1L, captureSnapshot.getReplicatedToAllTerm());
//
assertEquals(-1L, captureSnapshot.getReplicatedToAllIndex());
assertEquals(-1L, captureSnapshot.getReplicatedToAllTerm());
- actorRef.underlyingActor().clear();
-
+ MessageCollectorActor.clearMessages(actorRef);
dropMessagesToBehavior.clear();
}
dropMessagesToBehavior.clear();
}
public void clear() {
behaviorStateChangeLatch = null;
clearDropMessagesToBehavior();
messagesReceivedLatches.clear();
public void clear() {
behaviorStateChangeLatch = null;
clearDropMessagesToBehavior();
messagesReceivedLatches.clear();
+ clearMessages(getSelf());
}
void forwardCapturedMessageToBehavior(final Class<?> msgClass, final ActorRef sender) {
}
void forwardCapturedMessageToBehavior(final Class<?> msgClass, final ActorRef sender) {
import static org.junit.Assert.assertNull;
import akka.actor.ActorRef;
import static org.junit.Assert.assertNull;
import akka.actor.ActorRef;
-import akka.actor.Props;
-import akka.testkit.TestActorRef;
import com.google.protobuf.ByteString;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import com.google.protobuf.ByteString;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
protected final TestActorFactory actorFactory = new TestActorFactory(getSystem());
protected final TestActorFactory actorFactory = new TestActorFactory(getSystem());
- private final TestActorRef<MessageCollectorActor> behaviorActor = actorFactory.createTestActor(
- Props.create(MessageCollectorActor.class), actorFactory.generateActorId("behavior"));
+ private final ActorRef behaviorActor = actorFactory.createActor(
+ MessageCollectorActor.props(), actorFactory.generateActorId("behavior"));
RaftActorBehavior behavior;
RaftActorBehavior behavior;
handleAppendEntriesAddSameEntryToLogReply(behaviorActor);
}
handleAppendEntriesAddSameEntryToLogReply(behaviorActor);
}
- protected void handleAppendEntriesAddSameEntryToLogReply(final TestActorRef<MessageCollectorActor> replyActor) {
+ protected void handleAppendEntriesAddSameEntryToLogReply(final ActorRef replyActor) {
AppendEntriesReply reply = MessageCollectorActor.getFirstMatching(replyActor, AppendEntriesReply.class);
Assert.assertNull("Expected no AppendEntriesReply", reply);
}
AppendEntriesReply reply = MessageCollectorActor.getFirstMatching(replyActor, AppendEntriesReply.class);
Assert.assertNull("Expected no AppendEntriesReply", reply);
}
import static org.junit.Assert.assertTrue;
import akka.actor.ActorRef;
import static org.junit.Assert.assertTrue;
import akka.actor.ActorRef;
-import akka.actor.Props;
+import akka.dispatch.Dispatchers;
import akka.testkit.TestActorRef;
import com.google.common.base.Stopwatch;
import java.util.ArrayList;
import akka.testkit.TestActorRef;
import com.google.common.base.Stopwatch;
import java.util.ArrayList;
static final Logger LOG = LoggerFactory.getLogger(CandidateTest.class);
private final TestActorRef<MessageCollectorActor> candidateActor = actorFactory.createTestActor(
static final Logger LOG = LoggerFactory.getLogger(CandidateTest.class);
private final TestActorRef<MessageCollectorActor> candidateActor = actorFactory.createTestActor(
- Props.create(MessageCollectorActor.class), actorFactory.generateActorId("candidate"));
+ MessageCollectorActor.props().withDispatcher(Dispatchers.DefaultDispatcherId()),
+ actorFactory.generateActorId("candidate"));
- private TestActorRef<MessageCollectorActor>[] peerActors;
+ private ActorRef[] peerActors;
private RaftActorBehavior candidate;
private RaftActorBehavior candidate;
return new MockRaftActorContext("candidate", getSystem(), candidateActor);
}
return new MockRaftActorContext("candidate", getSystem(), candidateActor);
}
- @SuppressWarnings("unchecked")
private Map<String, String> setupPeers(final int count) {
Map<String, String> peerMap = new HashMap<>();
private Map<String, String> setupPeers(final int count) {
Map<String, String> peerMap = new HashMap<>();
- peerActors = new TestActorRef[count];
+ peerActors = new ActorRef[count];
for (int i = 0; i < count; i++) {
for (int i = 0; i < count; i++) {
- peerActors[i] = actorFactory.createTestActor(Props.create(MessageCollectorActor.class),
+ peerActors[i] = actorFactory.createActor(MessageCollectorActor.props(),
actorFactory.generateActorId("peer"));
peerMap.put("peer" + (i + 1), peerActors[i].path().toString());
}
actorFactory.generateActorId("peer"));
peerMap.put("peer" + (i + 1), peerActors[i].path().toString());
}
import static org.mockito.Mockito.verify;
import akka.actor.ActorRef;
import static org.mockito.Mockito.verify;
import akka.actor.ActorRef;
-import akka.actor.Props;
import akka.dispatch.Dispatchers;
import akka.testkit.JavaTestKit;
import akka.testkit.TestActorRef;
import akka.dispatch.Dispatchers;
import akka.testkit.JavaTestKit;
import akka.testkit.TestActorRef;
public class FollowerTest extends AbstractRaftActorBehaviorTest<Follower> {
public class FollowerTest extends AbstractRaftActorBehaviorTest<Follower> {
- private final TestActorRef<MessageCollectorActor> followerActor = actorFactory.createTestActor(
- Props.create(MessageCollectorActor.class), actorFactory.generateActorId("follower"));
+ private final ActorRef followerActor = actorFactory.createActor(
+ MessageCollectorActor.props(), actorFactory.generateActorId("follower"));
- private final TestActorRef<MessageCollectorActor> leaderActor = actorFactory.createTestActor(
- Props.create(MessageCollectorActor.class), actorFactory.generateActorId("leader"));
+ private final ActorRef leaderActor = actorFactory.createActor(
+ MessageCollectorActor.props(), actorFactory.generateActorId("leader"));
private Follower follower;
private Follower follower;
assertFalse(syncStatus.isInitialSyncDone());
// Clear all the messages
assertFalse(syncStatus.isInitialSyncDone());
// Clear all the messages
- followerActor.underlyingActor().clear();
+ MessageCollectorActor.clearMessages(followerActor);
context.setLastApplied(101);
context.setCommitIndex(101);
context.setLastApplied(101);
context.setCommitIndex(101);
assertTrue(syncStatus.isInitialSyncDone());
assertTrue(syncStatus.isInitialSyncDone());
- followerActor.underlyingActor().clear();
+ MessageCollectorActor.clearMessages(followerActor);
// Sending the same message again should not generate another message
// Sending the same message again should not generate another message
assertFalse(syncStatus.isInitialSyncDone());
// Clear all the messages
assertFalse(syncStatus.isInitialSyncDone());
// Clear all the messages
- followerActor.underlyingActor().clear();
+ MessageCollectorActor.clearMessages(followerActor);
context.setLastApplied(100);
setLastLogEntry(context, 1, 100,
context.setLastApplied(100);
setLastLogEntry(context, 1, 100,
assertFalse(syncStatus.isInitialSyncDone());
// Clear all the messages
assertFalse(syncStatus.isInitialSyncDone());
// Clear all the messages
- followerActor.underlyingActor().clear();
+ MessageCollectorActor.clearMessages(followerActor);
context.setLastApplied(101);
context.setCommitIndex(101);
context.setLastApplied(101);
context.setCommitIndex(101);
assertTrue(syncStatus.isInitialSyncDone());
// Clear all the messages
assertTrue(syncStatus.isInitialSyncDone());
// Clear all the messages
- followerActor.underlyingActor().clear();
+ MessageCollectorActor.clearMessages(followerActor);
context.setLastApplied(100);
setLastLogEntry(context, 1, 100,
context.setLastApplied(100);
setLastLogEntry(context, 1, 100,
entries = Arrays.asList(newReplicatedLogEntry(1, 1, "one"), newReplicatedLogEntry(1, 2, "two"));
entries = Arrays.asList(newReplicatedLogEntry(1, 1, "one"), newReplicatedLogEntry(1, 2, "two"));
- leaderActor.underlyingActor().clear();
+ MessageCollectorActor.clearMessages(leaderActor);
follower.handleMessage(leaderActor, new AppendEntries(1, "leader", 0, 1, entries, 2, -1, (short)0));
assertEquals("Next index", 3, log.last().getIndex() + 1);
follower.handleMessage(leaderActor, new AppendEntries(1, "leader", 0, 1, entries, 2, -1, (short)0));
assertEquals("Next index", 3, log.last().getIndex() + 1);
assertFalse(syncStatus.isInitialSyncDone());
// Clear all the messages
assertFalse(syncStatus.isInitialSyncDone());
// Clear all the messages
- followerActor.underlyingActor().clear();
+ MessageCollectorActor.clearMessages(followerActor);
context.setLastApplied(101);
context.setCommitIndex(101);
context.setLastApplied(101);
context.setCommitIndex(101);
- protected void handleAppendEntriesAddSameEntryToLogReply(final TestActorRef<MessageCollectorActor> replyActor) {
+ protected void handleAppendEntriesAddSameEntryToLogReply(final ActorRef replyActor) {
AppendEntriesReply reply = MessageCollectorActor.expectFirstMatching(replyActor, AppendEntriesReply.class);
assertEquals("isSuccess", true, reply.isSuccess());
}
AppendEntriesReply reply = MessageCollectorActor.expectFirstMatching(replyActor, AppendEntriesReply.class);
assertEquals("isSuccess", true, reply.isSuccess());
}
import static org.junit.Assert.assertEquals;
import akka.actor.ActorRef;
import static org.junit.Assert.assertEquals;
import akka.actor.ActorRef;
-import akka.actor.Props;
-import akka.testkit.TestActorRef;
import java.util.HashMap;
import java.util.Map;
import org.junit.After;
import java.util.HashMap;
import java.util.Map;
import org.junit.After;
public class IsolatedLeaderTest extends AbstractLeaderTest<IsolatedLeader> {
public class IsolatedLeaderTest extends AbstractLeaderTest<IsolatedLeader> {
- private final TestActorRef<MessageCollectorActor> leaderActor = actorFactory.createTestActor(
- Props.create(MessageCollectorActor.class), actorFactory.generateActorId("leader"));
+ private final ActorRef leaderActor = actorFactory.createActor(
+ MessageCollectorActor.props(), actorFactory.generateActorId("leader"));
- private final TestActorRef<MessageCollectorActor> senderActor = actorFactory.createTestActor(
- Props.create(MessageCollectorActor.class), actorFactory.generateActorId("sender"));
+ private final ActorRef senderActor = actorFactory.createActor(
+ MessageCollectorActor.props(), actorFactory.generateActorId("sender"));
private AbstractLeader isolatedLeader;
private AbstractLeader isolatedLeader;
leaderActorContext.setLastApplied(-1);
String nonVotingFollowerId = "nonvoting-follower";
leaderActorContext.setLastApplied(-1);
String nonVotingFollowerId = "nonvoting-follower";
- TestActorRef<ForwardMessageToBehaviorActor> nonVotingFollowerActor = actorFactory.createTestActor(
- Props.create(MessageCollectorActor.class), actorFactory.generateActorId(nonVotingFollowerId));
+ ActorRef nonVotingFollowerActor = actorFactory.createActor(
+ MessageCollectorActor.props(), actorFactory.generateActorId(nonVotingFollowerId));
leaderActorContext.addToPeers(nonVotingFollowerId, nonVotingFollowerActor.path().toString(),
VotingState.NON_VOTING);
leaderActorContext.addToPeers(nonVotingFollowerId, nonVotingFollowerActor.path().toString(),
VotingState.NON_VOTING);
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import akka.actor.Props;
-import akka.testkit.TestActorRef;
+import akka.actor.ActorRef;
import org.junit.After;
import org.junit.Test;
import org.opendaylight.controller.cluster.raft.AbstractActorTest;
import org.junit.After;
import org.junit.Test;
import org.opendaylight.controller.cluster.raft.AbstractActorTest;
public class SyncStatusTrackerTest extends AbstractActorTest {
protected final TestActorFactory actorFactory = new TestActorFactory(getSystem());
public class SyncStatusTrackerTest extends AbstractActorTest {
protected final TestActorFactory actorFactory = new TestActorFactory(getSystem());
- private final TestActorRef<MessageCollectorActor> listener = actorFactory.createTestActor(
- Props.create(MessageCollectorActor.class), actorFactory.generateActorId("listener"));
+ private final ActorRef listener = actorFactory.createActor(
+ MessageCollectorActor.props(), actorFactory.generateActorId("listener"));
@After
public void tearDown() {
@After
public void tearDown() {
return behaviorChanges;
}
return behaviorChanges;
}
+ clearMessages(getSelf());
behaviorChanges.clear();
}
}
behaviorChanges.clear();
}
}
import akka.actor.ActorRef;
import akka.actor.Props;
import akka.actor.UntypedActor;
import akka.actor.ActorRef;
import akka.actor.Props;
import akka.actor.UntypedActor;
+import akka.dispatch.ControlMessage;
import akka.pattern.Patterns;
import akka.util.Timeout;
import com.google.common.base.Predicate;
import akka.pattern.Patterns;
import akka.util.Timeout;
import com.google.common.base.Predicate;
public class MessageCollectorActor extends UntypedActor {
private static final String ARE_YOU_READY = "ARE_YOU_READY";
public static final String GET_ALL_MESSAGES = "messages";
public class MessageCollectorActor extends UntypedActor {
private static final String ARE_YOU_READY = "ARE_YOU_READY";
public static final String GET_ALL_MESSAGES = "messages";
- private static final String CLEAR_MESSAGES = "clear-messages";
+
+ private static final Object CLEAR_MESSAGES = new ControlMessage() {
+ @Override
+ public String toString() {
+ return "clear-messages";
+ }
+ };
private final List<Object> messages = new ArrayList<>();
private final List<Object> messages = new ArrayList<>();
} else if (GET_ALL_MESSAGES.equals(message)) {
getSender().tell(new ArrayList<>(messages), getSelf());
} else if (CLEAR_MESSAGES.equals(message)) {
} else if (GET_ALL_MESSAGES.equals(message)) {
getSender().tell(new ArrayList<>(messages), getSelf());
} else if (CLEAR_MESSAGES.equals(message)) {
} else if (message != null) {
messages.add(message);
}
}
} else if (message != null) {
messages.add(message);
}
}
- public void clear() {
- messages.clear();
- }
-
@SuppressWarnings({"unchecked", "checkstyle:illegalCatch"})
@SuppressWarnings({"unchecked", "checkstyle:illegalCatch"})
- private static List<Object> getAllMessages(final ActorRef actor) {
+ public static List<Object> getAllMessages(final ActorRef actor) {
FiniteDuration operationDuration = Duration.create(5, TimeUnit.SECONDS);
Timeout operationTimeout = new Timeout(operationDuration);
Future<Object> future = Patterns.ask(actor, GET_ALL_MESSAGES, operationTimeout);
FiniteDuration operationDuration = Duration.create(5, TimeUnit.SECONDS);
Timeout operationTimeout = new Timeout(operationDuration);
Future<Object> future = Patterns.ask(actor, GET_ALL_MESSAGES, operationTimeout);
Uninterruptibles.sleepUninterruptibly(50, TimeUnit.MILLISECONDS);
}
Uninterruptibles.sleepUninterruptibly(50, TimeUnit.MILLISECONDS);
}
- throw new AssertionError("Did not receive message of type " + clazz, lastEx);
+ throw new AssertionError(actor + ": Did not receive message of type " + clazz + ", Actual received was "
+ + getAllMessages(actor), lastEx);
}
@SuppressWarnings("checkstyle:IllegalCatch")
}
@SuppressWarnings("checkstyle:IllegalCatch")
import akka.actor.ActorRef;
import akka.actor.PoisonPill;
import akka.actor.Props;
import akka.actor.ActorRef;
import akka.actor.PoisonPill;
import akka.actor.Props;
-import akka.testkit.TestActorRef;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import org.junit.After;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import org.junit.After;
protected static final MemberName MEMBER_1 = MemberName.forName("member-1");
protected static int ID_COUNTER = 1;
protected static final MemberName MEMBER_1 = MemberName.forName("member-1");
protected static int ID_COUNTER = 1;
- protected static TestActorRef<MessageCollectorActor> mockShardActor;
+ protected static ActorRef mockShardActor;
protected static ShardIdentifier mockShardName;
protected final String shardMrgIDSuffix = "config" + ID_COUNTER++;
protected static ShardIdentifier mockShardName;
protected final String shardMrgIDSuffix = "config" + ID_COUNTER++;
if (mockShardActor == null) {
mockShardName = ShardIdentifier.create(Shard.DEFAULT_NAME, MEMBER_1, "config");
if (mockShardActor == null) {
mockShardName = ShardIdentifier.create(Shard.DEFAULT_NAME, MEMBER_1, "config");
- mockShardActor = TestActorRef.create(getSystem(), Props.create(MessageCollectorActor.class),
- mockShardName.toString());
+ mockShardActor = getSystem().actorOf(MessageCollectorActor.props(), mockShardName.toString());
- mockShardActor.underlyingActor().clear();
+ MessageCollectorActor.clearMessages(mockShardActor);
@Test
public void testOnDataChanged() throws Exception {
@Test
public void testOnDataChanged() throws Exception {
- final Props props = Props.create(MessageCollectorActor.class);
- final ActorRef actorRef = getSystem().actorOf(props);
+ final ActorRef actorRef = getSystem().actorOf(MessageCollectorActor.props());
DataChangeListenerProxy dataChangeListenerProxy = new DataChangeListenerProxy(
getSystem().actorSelection(actorRef.path()));
DataChangeListenerProxy dataChangeListenerProxy = new DataChangeListenerProxy(
getSystem().actorSelection(actorRef.path()));
package org.opendaylight.controller.cluster.datastore;
import akka.actor.ActorRef;
package org.opendaylight.controller.cluster.datastore;
import akka.actor.ActorRef;
-import akka.actor.Props;
import java.util.Arrays;
import java.util.Collection;
import org.junit.Assert;
import java.util.Arrays;
import java.util.Collection;
import org.junit.Assert;
@Test
public void testOnDataChanged() throws Exception {
@Test
public void testOnDataChanged() throws Exception {
- final Props props = Props.create(MessageCollectorActor.class);
- final ActorRef actorRef = getSystem().actorOf(props);
+ final ActorRef actorRef = getSystem().actorOf(MessageCollectorActor.props());
ForwardingDataTreeChangeListener forwardingListener = new ForwardingDataTreeChangeListener(
getSystem().actorSelection(actorRef.path()));
ForwardingDataTreeChangeListener forwardingListener = new ForwardingDataTreeChangeListener(
getSystem().actorSelection(actorRef.path()));
import static org.junit.Assert.assertNull;
import akka.actor.ActorRef;
import static org.junit.Assert.assertNull;
import akka.actor.ActorRef;
-import akka.actor.Props;
import akka.testkit.JavaTestKit;
import akka.testkit.TestActorRef;
import org.junit.Test;
import akka.testkit.JavaTestKit;
import akka.testkit.TestActorRef;
import org.junit.Test;
new JavaTestKit(getSystem()) {
{
String memberId = "testHandleRegisterRoleChangeListener";
new JavaTestKit(getSystem()) {
{
String memberId = "testHandleRegisterRoleChangeListener";
- ActorRef listenerActor = getSystem().actorOf(Props.create(MessageCollectorActor.class));
+ ActorRef listenerActor = getSystem().actorOf(MessageCollectorActor.props());
TestActorRef<RoleChangeNotifier> notifierTestActorRef = TestActorRef.create(getSystem(),
RoleChangeNotifier.getProps(memberId), memberId);
TestActorRef<RoleChangeNotifier> notifierTestActorRef = TestActorRef.create(getSystem(),
RoleChangeNotifier.getProps(memberId), memberId);
new JavaTestKit(getSystem()) {
{
String memberId = "testHandleRegisterRoleChangeListenerWithNotificationSet";
new JavaTestKit(getSystem()) {
{
String memberId = "testHandleRegisterRoleChangeListenerWithNotificationSet";
- ActorRef listenerActor = getSystem().actorOf(Props.create(MessageCollectorActor.class));
+ ActorRef listenerActor = getSystem().actorOf(MessageCollectorActor.props());
ActorRef shardActor = getTestActor();
TestActorRef<RoleChangeNotifier> notifierTestActorRef = TestActorRef.create(getSystem(),
ActorRef shardActor = getTestActor();
TestActorRef<RoleChangeNotifier> notifierTestActorRef = TestActorRef.create(getSystem(),
- final TestActorRef<MessageCollectorActor> listener =
- TestActorRef.create(getSystem(), Props.create(MessageCollectorActor.class));
+ final ActorRef listener = getSystem().actorOf(MessageCollectorActor.props());
shard.tell(new RegisterRoleChangeListener(), listener);
shard.tell(new RegisterRoleChangeListener(), listener);
@Test
public void testServerRemoved() throws Exception {
@Test
public void testServerRemoved() throws Exception {
- final TestActorRef<MessageCollectorActor> parent = actorFactory.createTestActor(MessageCollectorActor.props());
+ final TestActorRef<MessageCollectorActor> parent = actorFactory.createTestActor(MessageCollectorActor.props()
+ .withDispatcher(Dispatchers.DefaultDispatcherId()));
final ActorRef shard = parent.underlyingActor().context().actorOf(
newShardBuilder().props().withDispatcher(Dispatchers.DefaultDispatcherId()),
final ActorRef shard = parent.underlyingActor().context().actorOf(
newShardBuilder().props().withDispatcher(Dispatchers.DefaultDispatcherId()),
ShardIdentifier localId = newShardId(LOCAL_MEMBER_NAME);
TestActorRef<TestEntityOwnershipShard> leader = actorFactory.createTestActor(TestEntityOwnershipShard.props(
newShardBuilder(leaderId, peerMap(localId.toString()), PEER_MEMBER_1_NAME),
ShardIdentifier localId = newShardId(LOCAL_MEMBER_NAME);
TestActorRef<TestEntityOwnershipShard> leader = actorFactory.createTestActor(TestEntityOwnershipShard.props(
newShardBuilder(leaderId, peerMap(localId.toString()), PEER_MEMBER_1_NAME),
- actorFactory.createTestActor(MessageCollectorActor.props())), leaderId.toString());
+ actorFactory.createActor(MessageCollectorActor.props())), leaderId.toString());
final TestEntityOwnershipShard leaderShard = leader.underlyingActor();
TestActorRef<TestEntityOwnershipShard> local = actorFactory.createTestActor(TestEntityOwnershipShard.props(
final TestEntityOwnershipShard leaderShard = leader.underlyingActor();
TestActorRef<TestEntityOwnershipShard> local = actorFactory.createTestActor(TestEntityOwnershipShard.props(
TestActorRef<TestEntityOwnershipShard> peer1 = actorFactory.createTestActor(TestEntityOwnershipShard.props(
newShardBuilder(peerId1, peerMap(leaderId.toString(), peerId2.toString()), PEER_MEMBER_1_NAME),
TestActorRef<TestEntityOwnershipShard> peer1 = actorFactory.createTestActor(TestEntityOwnershipShard.props(
newShardBuilder(peerId1, peerMap(leaderId.toString(), peerId2.toString()), PEER_MEMBER_1_NAME),
- actorFactory.createTestActor(MessageCollectorActor.props())), peerId1.toString());
+ actorFactory.createActor(MessageCollectorActor.props())), peerId1.toString());
peer1.underlyingActor().startDroppingMessagesOfType(ElectionTimeout.class);
TestActorRef<TestEntityOwnershipShard> peer2 = actorFactory.createTestActor(TestEntityOwnershipShard.props(
peer1.underlyingActor().startDroppingMessagesOfType(ElectionTimeout.class);
TestActorRef<TestEntityOwnershipShard> peer2 = actorFactory.createTestActor(TestEntityOwnershipShard.props(
}
private static class TestEntityOwnershipShard extends EntityOwnershipShard {
}
private static class TestEntityOwnershipShard extends EntityOwnershipShard {
- private final TestActorRef<MessageCollectorActor> collectorActor;
+ private final ActorRef collectorActor;
private final Map<Class<?>, Predicate<?>> dropMessagesOfType = new ConcurrentHashMap<>();
private final Map<Class<?>, Predicate<?>> dropMessagesOfType = new ConcurrentHashMap<>();
- TestEntityOwnershipShard(final Builder builder, final TestActorRef<MessageCollectorActor> collectorActor) {
+ TestEntityOwnershipShard(final Builder builder, final ActorRef collectorActor) {
super(builder);
this.collectorActor = collectorActor;
}
super(builder);
this.collectorActor = collectorActor;
}
dropMessagesOfType.remove(msgClass);
}
dropMessagesOfType.remove(msgClass);
}
- TestActorRef<MessageCollectorActor> collectorActor() {
+ ActorRef collectorActor() {
return props(builder, null);
}
return props(builder, null);
}
- static Props props(final Builder builder, final TestActorRef<MessageCollectorActor> collectorActor) {
+ static Props props(final Builder builder, final ActorRef collectorActor) {
return Props.create(TestEntityOwnershipShard.class, builder, collectorActor)
.withDispatcher(Dispatchers.DefaultDispatcherId());
}
return Props.create(TestEntityOwnershipShard.class, builder, collectorActor)
.withDispatcher(Dispatchers.DefaultDispatcherId());
}
private ActorRef newMockShardActor(final ActorSystem system, final String shardName, final String memberName) {
String name = ShardIdentifier.create(shardName, MemberName.forName(memberName), "config").toString();
if (system == getSystem()) {
private ActorRef newMockShardActor(final ActorSystem system, final String shardName, final String memberName) {
String name = ShardIdentifier.create(shardName, MemberName.forName(memberName), "config").toString();
if (system == getSystem()) {
- return actorFactory.createActor(Props.create(MessageCollectorActor.class), name);
+ return actorFactory.createActor(MessageCollectorActor.props(), name);
- return system.actorOf(Props.create(MessageCollectorActor.class), name);
+ return system.actorOf(MessageCollectorActor.props(), name);
}
private Props newShardMgrProps() {
}
private Props newShardMgrProps() {
};
final ActorRef defaultShardActor = actorFactory.createActor(
};
final ActorRef defaultShardActor = actorFactory.createActor(
- Props.create(MessageCollectorActor.class), actorFactory.generateActorId("default"));
+ MessageCollectorActor.props(), actorFactory.generateActorId("default"));
final ActorRef topologyShardActor = actorFactory.createActor(
final ActorRef topologyShardActor = actorFactory.createActor(
- Props.create(MessageCollectorActor.class), actorFactory.generateActorId("topology"));
+ MessageCollectorActor.props(), actorFactory.generateActorId("topology"));
final Map<String, Entry<ActorRef, DatastoreContext>> shardInfoMap = Collections.synchronizedMap(
new HashMap<String, Entry<ActorRef, DatastoreContext>>());
final Map<String, Entry<ActorRef, DatastoreContext>> shardInfoMap = Collections.synchronizedMap(
new HashMap<String, Entry<ActorRef, DatastoreContext>>());
@Test
public void testFindPrimaryShardAsyncRemotePrimaryFound() throws Exception {
@Test
public void testFindPrimaryShardAsyncRemotePrimaryFound() throws Exception {
- TestActorRef<MessageCollectorActor> shardManager = TestActorRef.create(getSystem(),
- Props.create(MessageCollectorActor.class));
+ ActorRef shardManager = getSystem().actorOf(MessageCollectorActor.props());
DatastoreContext dataStoreContext = DatastoreContext.newBuilder()
.logicalStoreType(LogicalDatastoreType.CONFIGURATION)
DatastoreContext dataStoreContext = DatastoreContext.newBuilder()
.logicalStoreType(LogicalDatastoreType.CONFIGURATION)
@Test
public void testFindPrimaryShardAsyncLocalPrimaryFound() throws Exception {
@Test
public void testFindPrimaryShardAsyncLocalPrimaryFound() throws Exception {
- TestActorRef<MessageCollectorActor> shardManager = TestActorRef.create(getSystem(),
- Props.create(MessageCollectorActor.class));
+ ActorRef shardManager = getSystem().actorOf(MessageCollectorActor.props());
DatastoreContext dataStoreContext = DatastoreContext.newBuilder()
.logicalStoreType(LogicalDatastoreType.CONFIGURATION)
DatastoreContext dataStoreContext = DatastoreContext.newBuilder()
.logicalStoreType(LogicalDatastoreType.CONFIGURATION)
@SuppressWarnings("checkstyle:IllegalCatch")
private static void testFindPrimaryExceptions(final Object expectedException) throws Exception {
@SuppressWarnings("checkstyle:IllegalCatch")
private static void testFindPrimaryExceptions(final Object expectedException) throws Exception {
- TestActorRef<MessageCollectorActor> shardManager =
- TestActorRef.create(getSystem(), Props.create(MessageCollectorActor.class));
+ ActorRef shardManager = getSystem().actorOf(MessageCollectorActor.props());
DatastoreContext dataStoreContext = DatastoreContext.newBuilder()
.logicalStoreType(LogicalDatastoreType.CONFIGURATION)
DatastoreContext dataStoreContext = DatastoreContext.newBuilder()
.logicalStoreType(LogicalDatastoreType.CONFIGURATION)
public void testBroadcast() {
new JavaTestKit(getSystem()) {
{
public void testBroadcast() {
new JavaTestKit(getSystem()) {
{
- ActorRef shardActorRef1 = getSystem().actorOf(Props.create(MessageCollectorActor.class));
- ActorRef shardActorRef2 = getSystem().actorOf(Props.create(MessageCollectorActor.class));
+ ActorRef shardActorRef1 = getSystem().actorOf(MessageCollectorActor.props());
+ ActorRef shardActorRef2 = getSystem().actorOf(MessageCollectorActor.props());
TestActorRef<MockShardManager> shardManagerActorRef = TestActorRef.create(getSystem(),
MockShardManager.props());
TestActorRef<MockShardManager> shardManagerActorRef = TestActorRef.create(getSystem(),
MockShardManager.props());