X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-akka-raft%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fraft%2FRaftActorTest.java;h=56bfc21f23c2047a19d5a49c49861ae1bf6eca5e;hb=7873bfcd1735ce86a58c015b2865c7f3627fb121;hp=d999bb2ba1de79e59d65b5cd78614bc8b3fc2c7c;hpb=07871502ed4434908110afeeb77010782d503fda;p=controller.git diff --git a/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/RaftActorTest.java b/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/RaftActorTest.java index d999bb2ba1..ed4ea72c16 100644 --- a/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/RaftActorTest.java +++ b/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/RaftActorTest.java @@ -1,308 +1,97 @@ +/* + * Copyright (c) 2014, 2015 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + package org.opendaylight.controller.cluster.raft; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.anyObject; +import static org.mockito.Matchers.eq; +import static org.mockito.Matchers.same; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; import akka.actor.ActorRef; -import akka.actor.ActorSystem; import akka.actor.PoisonPill; import akka.actor.Props; import akka.actor.Terminated; -import akka.japi.Creator; +import akka.dispatch.Dispatchers; import akka.japi.Procedure; -import akka.pattern.Patterns; -import akka.persistence.RecoveryCompleted; import akka.persistence.SaveSnapshotFailure; import akka.persistence.SaveSnapshotSuccess; import akka.persistence.SnapshotMetadata; import akka.persistence.SnapshotOffer; -import akka.persistence.SnapshotSelectionCriteria; import akka.testkit.JavaTestKit; import akka.testkit.TestActorRef; -import akka.util.Timeout; import com.google.common.base.Optional; -import com.google.common.collect.Lists; +import com.google.common.collect.ImmutableMap; import com.google.common.util.concurrent.Uninterruptibles; import com.google.protobuf.ByteString; -import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; -import java.io.IOException; -import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; +import java.util.HashMap; import java.util.List; import java.util.Map; -import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; -import java.util.concurrent.TimeoutException; import org.junit.After; -import org.junit.Assert; +import org.junit.Before; import org.junit.Test; import org.opendaylight.controller.cluster.DataPersistenceProvider; -import org.opendaylight.controller.cluster.datastore.DataPersistenceProviderMonitor; +import org.opendaylight.controller.cluster.NonPersistentDataProvider; +import org.opendaylight.controller.cluster.PersistentDataProvider; +import org.opendaylight.controller.cluster.notifications.LeaderStateChanged; import org.opendaylight.controller.cluster.notifications.RoleChanged; +import org.opendaylight.controller.cluster.raft.base.messages.ApplyJournalEntries; import org.opendaylight.controller.cluster.raft.base.messages.ApplyLogEntries; import org.opendaylight.controller.cluster.raft.base.messages.ApplySnapshot; import org.opendaylight.controller.cluster.raft.base.messages.ApplyState; import org.opendaylight.controller.cluster.raft.base.messages.CaptureSnapshot; import org.opendaylight.controller.cluster.raft.base.messages.CaptureSnapshotReply; +import org.opendaylight.controller.cluster.raft.base.messages.DeleteEntries; +import org.opendaylight.controller.cluster.raft.base.messages.SendHeartBeat; +import org.opendaylight.controller.cluster.raft.base.messages.SwitchBehavior; +import org.opendaylight.controller.cluster.raft.base.messages.UpdateElectionTerm; import org.opendaylight.controller.cluster.raft.behaviors.Follower; import org.opendaylight.controller.cluster.raft.behaviors.Leader; -import org.opendaylight.controller.cluster.raft.client.messages.FindLeader; -import org.opendaylight.controller.cluster.raft.client.messages.FindLeaderReply; -import org.opendaylight.controller.cluster.raft.protobuff.client.messages.Payload; +import org.opendaylight.controller.cluster.raft.behaviors.RaftActorBehavior; +import org.opendaylight.controller.cluster.raft.messages.AppendEntries; +import org.opendaylight.controller.cluster.raft.messages.AppendEntriesReply; +import org.opendaylight.controller.cluster.raft.utils.InMemoryJournal; +import org.opendaylight.controller.cluster.raft.utils.InMemorySnapshotStore; import org.opendaylight.controller.cluster.raft.utils.MessageCollectorActor; -import org.opendaylight.controller.cluster.raft.utils.MockAkkaJournal; -import org.opendaylight.controller.cluster.raft.utils.MockSnapshotStore; -import scala.concurrent.Await; -import scala.concurrent.Future; -import scala.concurrent.duration.Duration; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; import scala.concurrent.duration.FiniteDuration; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; -import static org.mockito.Matchers.any; -import static org.mockito.Matchers.anyObject; -import static org.mockito.Matchers.eq; -import static org.mockito.Mockito.doReturn; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; public class RaftActorTest extends AbstractActorTest { + static final Logger TEST_LOG = LoggerFactory.getLogger(RaftActorTest.class); - @After - public void tearDown() { - MockAkkaJournal.clearJournal(); - MockSnapshotStore.setMockSnapshot(null); - } - - public static class MockRaftActor extends RaftActor { - - private final DataPersistenceProvider dataPersistenceProvider; - private final RaftActor delegate; - private final CountDownLatch recoveryComplete = new CountDownLatch(1); - private final List state; - private ActorRef roleChangeNotifier; - - public static final class MockRaftActorCreator implements Creator { - private static final long serialVersionUID = 1L; - private final Map peerAddresses; - private final String id; - private final Optional config; - private final DataPersistenceProvider dataPersistenceProvider; - private final ActorRef roleChangeNotifier; - - private MockRaftActorCreator(Map peerAddresses, String id, - Optional config, DataPersistenceProvider dataPersistenceProvider, - ActorRef roleChangeNotifier) { - this.peerAddresses = peerAddresses; - this.id = id; - this.config = config; - this.dataPersistenceProvider = dataPersistenceProvider; - this.roleChangeNotifier = roleChangeNotifier; - } - - @Override - public MockRaftActor create() throws Exception { - MockRaftActor mockRaftActor = new MockRaftActor(id, peerAddresses, config, - dataPersistenceProvider); - mockRaftActor.roleChangeNotifier = this.roleChangeNotifier; - return mockRaftActor; - } - } - - public MockRaftActor(String id, Map peerAddresses, Optional config, DataPersistenceProvider dataPersistenceProvider) { - super(id, peerAddresses, config); - state = new ArrayList<>(); - this.delegate = mock(RaftActor.class); - if(dataPersistenceProvider == null){ - this.dataPersistenceProvider = new PersistentDataProvider(); - } else { - this.dataPersistenceProvider = dataPersistenceProvider; - } - } - - public void waitForRecoveryComplete() { - try { - assertEquals("Recovery complete", true, recoveryComplete.await(5, TimeUnit.SECONDS)); - } catch (InterruptedException e) { - e.printStackTrace(); - } - } - - public List getState() { - return state; - } - - public static Props props(final String id, final Map peerAddresses, - Optional config){ - return Props.create(new MockRaftActorCreator(peerAddresses, id, config, null, null)); - } - - public static Props props(final String id, final Map peerAddresses, - Optional config, DataPersistenceProvider dataPersistenceProvider){ - return Props.create(new MockRaftActorCreator(peerAddresses, id, config, dataPersistenceProvider, null)); - } - - public static Props props(final String id, final Map peerAddresses, - Optional config, ActorRef roleChangeNotifier){ - return Props.create(new MockRaftActorCreator(peerAddresses, id, config, null, roleChangeNotifier)); - } - - @Override protected void applyState(ActorRef clientActor, String identifier, Object data) { - delegate.applyState(clientActor, identifier, data); - LOG.info("applyState called"); - } - - @Override - protected void startLogRecoveryBatch(int maxBatchSize) { - } - - @Override - protected void appendRecoveredLogEntry(Payload data) { - state.add(data); - } - - @Override - protected void applyCurrentLogRecoveryBatch() { - } - - @Override - protected void onRecoveryComplete() { - delegate.onRecoveryComplete(); - recoveryComplete.countDown(); - } - - @Override - protected void applyRecoverySnapshot(ByteString snapshot) { - delegate.applyRecoverySnapshot(snapshot); - try { - Object data = toObject(snapshot); - System.out.println("!!!!!applyRecoverySnapshot: "+data); - if (data instanceof List) { - state.addAll((List) data); - } - } catch (Exception e) { - e.printStackTrace(); - } - } - - @Override protected void createSnapshot() { - delegate.createSnapshot(); - } - - @Override protected void applySnapshot(ByteString snapshot) { - delegate.applySnapshot(snapshot); - } - - @Override protected void onStateChanged() { - delegate.onStateChanged(); - } - - @Override - protected DataPersistenceProvider persistence() { - return this.dataPersistenceProvider; - } - - @Override - protected Optional getRoleChangeNotifier() { - return Optional.fromNullable(roleChangeNotifier); - } - - @Override public String persistenceId() { - return this.getId(); - } - - private Object toObject(ByteString bs) throws ClassNotFoundException, IOException { - Object obj = null; - ByteArrayInputStream bis = null; - ObjectInputStream ois = null; - try { - bis = new ByteArrayInputStream(bs.toByteArray()); - ois = new ObjectInputStream(bis); - obj = ois.readObject(); - } finally { - if (bis != null) { - bis.close(); - } - if (ois != null) { - ois.close(); - } - } - return obj; - } - - public ReplicatedLog getReplicatedLog(){ - return this.getRaftActorContext().getReplicatedLog(); - } + private TestActorFactory factory; + @Before + public void setUp(){ + factory = new TestActorFactory(getSystem()); } - - private static class RaftActorTestKit extends JavaTestKit { - private final ActorRef raftActor; - - public RaftActorTestKit(ActorSystem actorSystem, String actorName) { - super(actorSystem); - - raftActor = this.getSystem().actorOf(MockRaftActor.props(actorName, - Collections.emptyMap(), Optional.absent()), actorName); - - } - - - public ActorRef getRaftActor() { - return raftActor; - } - - public boolean waitForLogMessage(final Class logEventClass, String message){ - // Wait for a specific log message to show up - return - new JavaTestKit.EventFilter(logEventClass - ) { - @Override - protected Boolean run() { - return true; - } - }.from(raftActor.path().toString()) - .message(message) - .occurrences(1).exec(); - - - } - - protected void waitUntilLeader(){ - waitUntilLeader(raftActor); - } - - protected void waitUntilLeader(ActorRef actorRef) { - FiniteDuration duration = Duration.create(100, TimeUnit.MILLISECONDS); - for(int i = 0; i < 20 * 5; i++) { - Future future = Patterns.ask(actorRef, new FindLeader(), new Timeout(duration)); - try { - FindLeaderReply resp = (FindLeaderReply) Await.result(future, duration); - if(resp.getLeaderActor() != null) { - return; - } - } catch(TimeoutException e) { - } catch(Exception e) { - System.err.println("FindLeader threw ex"); - e.printStackTrace(); - } - - - Uninterruptibles.sleepUninterruptibly(50, TimeUnit.MILLISECONDS); - } - - Assert.fail("Leader not found for actorRef " + actorRef.path()); - } - + @After + public void tearDown() throws Exception { + factory.close(); + InMemoryJournal.clear(); + InMemorySnapshotStore.clear(); } - @Test public void testConstruction() { new RaftActorTestKit(getSystem(), "testConstruction").waitUntilLeader(); @@ -315,18 +104,22 @@ public class RaftActorTest extends AbstractActorTest { } @Test - public void testRaftActorRecovery() throws Exception { + public void testRaftActorRecoveryWithPersistenceEnabled() throws Exception { + TEST_LOG.info("testRaftActorRecoveryWithPersistenceEnabled starting"); + new JavaTestKit(getSystem()) {{ - String persistenceId = "follower10"; + String persistenceId = factory.generateActorId("follower-"); DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + // Set the heartbeat interval high to essentially disable election otherwise the test // may fail if the actor is switched to Leader and the commitIndex is set to the last // log entry. config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); - ActorRef followerActor = getSystem().actorOf(MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config)), persistenceId); + ImmutableMap peerAddresses = ImmutableMap.builder().put("member1", "address").build(); + ActorRef followerActor = factory.createActor(MockRaftActor.props(persistenceId, + peerAddresses, Optional.of(config)), persistenceId); watch(followerActor); @@ -338,27 +131,26 @@ public class RaftActorTest extends AbstractActorTest { int lastAppliedDuringSnapshotCapture = 3; int lastIndexDuringSnapshotCapture = 4; - // 4 messages as part of snapshot, which are applied to state - ByteString snapshotBytes = fromObject(Arrays.asList( - new MockRaftActorContext.MockPayload("A"), - new MockRaftActorContext.MockPayload("B"), - new MockRaftActorContext.MockPayload("C"), - new MockRaftActorContext.MockPayload("D"))); + // 4 messages as part of snapshot, which are applied to state + ByteString snapshotBytes = fromObject(Arrays.asList( + new MockRaftActorContext.MockPayload("A"), + new MockRaftActorContext.MockPayload("B"), + new MockRaftActorContext.MockPayload("C"), + new MockRaftActorContext.MockPayload("D"))); Snapshot snapshot = Snapshot.create(snapshotBytes.toByteArray(), - snapshotUnappliedEntries, lastIndexDuringSnapshotCapture, 1 , + snapshotUnappliedEntries, lastIndexDuringSnapshotCapture, 1, lastAppliedDuringSnapshotCapture, 1); - MockSnapshotStore.setMockSnapshot(snapshot); - MockSnapshotStore.setPersistenceId(persistenceId); + InMemorySnapshotStore.addSnapshot(persistenceId, snapshot); // add more entries after snapshot is taken List entries = new ArrayList<>(); ReplicatedLogEntry entry2 = new MockRaftActorContext.MockReplicatedLogEntry(1, 5, - new MockRaftActorContext.MockPayload("F")); + new MockRaftActorContext.MockPayload("F", 2)); ReplicatedLogEntry entry3 = new MockRaftActorContext.MockReplicatedLogEntry(1, 6, - new MockRaftActorContext.MockPayload("G")); + new MockRaftActorContext.MockPayload("G", 3)); ReplicatedLogEntry entry4 = new MockRaftActorContext.MockReplicatedLogEntry(1, 7, - new MockRaftActorContext.MockPayload("H")); + new MockRaftActorContext.MockPayload("H", 4)); entries.add(entry2); entries.add(entry3); entries.add(entry4); @@ -366,11 +158,11 @@ public class RaftActorTest extends AbstractActorTest { int lastAppliedToState = 5; int lastIndex = 7; - MockAkkaJournal.addToJournal(5, entry2); + InMemoryJournal.addEntry(persistenceId, 5, entry2); // 2 entries are applied to state besides the 4 entries in snapshot - MockAkkaJournal.addToJournal(6, new ApplyLogEntries(lastAppliedToState)); - MockAkkaJournal.addToJournal(7, entry3); - MockAkkaJournal.addToJournal(8, entry4); + InMemoryJournal.addEntry(persistenceId, 6, new ApplyJournalEntries(lastAppliedToState)); + InMemoryJournal.addEntry(persistenceId, 7, entry3); + InMemoryJournal.addEntry(persistenceId, 8, entry4); // kill the actor followerActor.tell(PoisonPill.getInstance(), null); @@ -379,193 +171,237 @@ public class RaftActorTest extends AbstractActorTest { unwatch(followerActor); //reinstate the actor - TestActorRef ref = TestActorRef.create(getSystem(), - MockRaftActor.props(persistenceId, Collections.emptyMap(), - Optional.of(config))); + TestActorRef ref = factory.createTestActor( + MockRaftActor.props(persistenceId, peerAddresses, Optional.of(config))); + + MockRaftActor mockRaftActor = ref.underlyingActor(); - ref.underlyingActor().waitForRecoveryComplete(); + mockRaftActor.waitForRecoveryComplete(); - RaftActorContext context = ref.underlyingActor().getRaftActorContext(); + RaftActorContext context = mockRaftActor.getRaftActorContext(); assertEquals("Journal log size", snapshotUnappliedEntries.size() + entries.size(), context.getReplicatedLog().size()); + assertEquals("Journal data size", 10, context.getReplicatedLog().dataSize()); assertEquals("Last index", lastIndex, context.getReplicatedLog().lastIndex()); assertEquals("Last applied", lastAppliedToState, context.getLastApplied()); assertEquals("Commit index", lastAppliedToState, context.getCommitIndex()); - assertEquals("Recovered state size", 6, ref.underlyingActor().getState().size()); - }}; - } + assertEquals("Recovered state size", 6, mockRaftActor.getState().size()); - /** - * This test verifies that when recovery is applicable (typically when persistence is true) the RaftActor does - * process recovery messages - * - * @throws Exception - */ - - @Test - public void testHandleRecoveryWhenDataPersistenceRecoveryApplicable() throws Exception { - new JavaTestKit(getSystem()) { - { - String persistenceId = "testHandleRecoveryWhenDataPersistenceRecoveryApplicable"; + mockRaftActor.waitForInitializeBehaviorComplete(); - DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + assertEquals("getRaftState", RaftState.Follower, mockRaftActor.getRaftState()); + }}; - config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + TEST_LOG.info("testRaftActorRecoveryWithPersistenceEnabled ending"); + } - TestActorRef mockActorRef = TestActorRef.create(getSystem(), MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config)), persistenceId); + @Test + public void testRaftActorRecoveryWithPersistenceDisabled() throws Exception { + new JavaTestKit(getSystem()) {{ + String persistenceId = factory.generateActorId("follower-"); - MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); - // Wait for akka's recovery to complete so it doesn't interfere. - mockRaftActor.waitForRecoveryComplete(); + config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); - ByteString snapshotBytes = fromObject(Arrays.asList( - new MockRaftActorContext.MockPayload("A"), - new MockRaftActorContext.MockPayload("B"), - new MockRaftActorContext.MockPayload("C"), - new MockRaftActorContext.MockPayload("D"))); + TestActorRef ref = factory.createTestActor(MockRaftActor.props(persistenceId, + ImmutableMap.builder().put("member1", "address").build(), + Optional.of(config), new NonPersistentDataProvider()), persistenceId); - Snapshot snapshot = Snapshot.create(snapshotBytes.toByteArray(), - Lists.newArrayList(), 3, 1 ,3, 1); + MockRaftActor mockRaftActor = ref.underlyingActor(); - mockRaftActor.onReceiveRecover(new SnapshotOffer(new SnapshotMetadata(persistenceId, 100, 100), snapshot)); + mockRaftActor.waitForRecoveryComplete(); - verify(mockRaftActor.delegate).applyRecoverySnapshot(eq(snapshotBytes)); + mockRaftActor.waitForInitializeBehaviorComplete(); - mockRaftActor.onReceiveRecover(new ReplicatedLogImplEntry(0, 1, new MockRaftActorContext.MockPayload("A"))); + assertEquals("getRaftState", RaftState.Follower, mockRaftActor.getRaftState()); + }}; + } - ReplicatedLog replicatedLog = mockRaftActor.getReplicatedLog(); + @Test + public void testUpdateElectionTermPersistedWithPersistenceDisabled() throws Exception { + new JavaTestKit(getSystem()) {{ + String persistenceId = factory.generateActorId("follower-"); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + config.setHeartBeatInterval(new FiniteDuration(100, TimeUnit.MILLISECONDS)); + config.setElectionTimeoutFactor(1); - assertEquals("add replicated log entry", 1, replicatedLog.size()); + InMemoryJournal.addWriteMessagesCompleteLatch(persistenceId, 1); - mockRaftActor.onReceiveRecover(new ReplicatedLogImplEntry(1, 1, new MockRaftActorContext.MockPayload("A"))); + TestActorRef ref = factory.createTestActor(MockRaftActor.props(persistenceId, + ImmutableMap.builder().put("member1", "address").build(), + Optional.of(config), new NonPersistentDataProvider()). + withDispatcher(Dispatchers.DefaultDispatcherId()), persistenceId); - assertEquals("add replicated log entry", 2, replicatedLog.size()); + InMemoryJournal.waitForWriteMessagesComplete(persistenceId); + List entries = InMemoryJournal.get(persistenceId, UpdateElectionTerm.class); + assertEquals("UpdateElectionTerm entries", 1, entries.size()); + UpdateElectionTerm updateEntry = entries.get(0); - mockRaftActor.onReceiveRecover(new ApplyLogEntries(1)); + factory.killActor(ref, this); - assertEquals("commit index 1", 1, mockRaftActor.getRaftActorContext().getCommitIndex()); + config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + ref = factory.createTestActor(MockRaftActor.props(persistenceId, + ImmutableMap.builder().put("member1", "address").build(), + Optional.of(config), new NonPersistentDataProvider()). + withDispatcher(Dispatchers.DefaultDispatcherId()), + factory.generateActorId("follower-")); + + MockRaftActor actor = ref.underlyingActor(); + actor.waitForRecoveryComplete(); + + RaftActorContext newContext = actor.getRaftActorContext(); + assertEquals("electionTerm", updateEntry.getCurrentTerm(), + newContext.getTermInformation().getCurrentTerm()); + assertEquals("votedFor", updateEntry.getVotedFor(), newContext.getTermInformation().getVotedFor()); + + entries = InMemoryJournal.get(persistenceId, UpdateElectionTerm.class); + assertEquals("UpdateElectionTerm entries", 1, entries.size()); + }}; + } - // The snapshot had 4 items + we added 2 more items during the test - // We start removing from 5 and we should get 1 item in the replicated log - mockRaftActor.onReceiveRecover(new RaftActor.DeleteEntries(5)); + @Test + public void testRaftActorForwardsToRaftActorRecoverySupport() { + String persistenceId = factory.generateActorId("leader-"); - assertEquals("remove log entries", 1, replicatedLog.size()); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); - mockRaftActor.onReceiveRecover(new RaftActor.UpdateElectionTerm(10, "foobar")); + config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); - assertEquals("election term", 10, mockRaftActor.getRaftActorContext().getTermInformation().getCurrentTerm()); - assertEquals("voted for", "foobar", mockRaftActor.getRaftActorContext().getTermInformation().getVotedFor()); + TestActorRef mockActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, + Collections.emptyMap(), Optional.of(config)), persistenceId); - mockRaftActor.onReceiveRecover(mock(RecoveryCompleted.class)); + MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); - mockActorRef.tell(PoisonPill.getInstance(), getRef()); + // Wait for akka's recovery to complete so it doesn't interfere. + mockRaftActor.waitForRecoveryComplete(); - }}; - } + RaftActorRecoverySupport mockSupport = mock(RaftActorRecoverySupport.class); + mockRaftActor.setRaftActorRecoverySupport(mockSupport ); - /** - * This test verifies that when recovery is not applicable (typically when persistence is false) the RaftActor does - * not process recovery messages - * - * @throws Exception - */ - @Test - public void testHandleRecoveryWhenDataPersistenceRecoveryNotApplicable() throws Exception { - new JavaTestKit(getSystem()) { - { - String persistenceId = "testHandleRecoveryWhenDataPersistenceRecoveryNotApplicable"; + Snapshot snapshot = Snapshot.create(new byte[]{1}, Collections.emptyList(), 3, 1, 3, 1); + SnapshotOffer snapshotOffer = new SnapshotOffer(new SnapshotMetadata("test", 6, 12345), snapshot); + mockRaftActor.handleRecover(snapshotOffer); - DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + MockRaftActorContext.MockReplicatedLogEntry logEntry = new MockRaftActorContext.MockReplicatedLogEntry(1, + 1, new MockRaftActorContext.MockPayload("1", 5)); + mockRaftActor.handleRecover(logEntry); - config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + ApplyJournalEntries applyJournalEntries = new ApplyJournalEntries(2); + mockRaftActor.handleRecover(applyJournalEntries); - TestActorRef mockActorRef = TestActorRef.create(getSystem(), MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config), new DataPersistenceProviderMonitor()), persistenceId); + ApplyLogEntries applyLogEntries = new ApplyLogEntries(0); + mockRaftActor.handleRecover(applyLogEntries); - MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); + DeleteEntries deleteEntries = new DeleteEntries(1); + mockRaftActor.handleRecover(deleteEntries); - // Wait for akka's recovery to complete so it doesn't interfere. - mockRaftActor.waitForRecoveryComplete(); + org.opendaylight.controller.cluster.raft.RaftActor.DeleteEntries deprecatedDeleteEntries = + new org.opendaylight.controller.cluster.raft.RaftActor.DeleteEntries(1); + mockRaftActor.handleRecover(deprecatedDeleteEntries); - ByteString snapshotBytes = fromObject(Arrays.asList( - new MockRaftActorContext.MockPayload("A"), - new MockRaftActorContext.MockPayload("B"), - new MockRaftActorContext.MockPayload("C"), - new MockRaftActorContext.MockPayload("D"))); + UpdateElectionTerm updateElectionTerm = new UpdateElectionTerm(5, "member2"); + mockRaftActor.handleRecover(updateElectionTerm); - Snapshot snapshot = Snapshot.create(snapshotBytes.toByteArray(), - Lists.newArrayList(), 3, 1 ,3, 1); + org.opendaylight.controller.cluster.raft.RaftActor.UpdateElectionTerm deprecatedUpdateElectionTerm = + new org.opendaylight.controller.cluster.raft.RaftActor.UpdateElectionTerm(6, "member3"); + mockRaftActor.handleRecover(deprecatedUpdateElectionTerm); - mockRaftActor.onReceiveRecover(new SnapshotOffer(new SnapshotMetadata(persistenceId, 100, 100), snapshot)); + verify(mockSupport).handleRecoveryMessage(same(snapshotOffer), any(PersistentDataProvider.class)); + verify(mockSupport).handleRecoveryMessage(same(logEntry), any(PersistentDataProvider.class)); + verify(mockSupport).handleRecoveryMessage(same(applyJournalEntries), any(PersistentDataProvider.class)); + verify(mockSupport).handleRecoveryMessage(same(applyLogEntries), any(PersistentDataProvider.class)); + verify(mockSupport).handleRecoveryMessage(same(deleteEntries), any(PersistentDataProvider.class)); + verify(mockSupport).handleRecoveryMessage(same(deprecatedDeleteEntries), any(PersistentDataProvider.class)); + verify(mockSupport).handleRecoveryMessage(same(updateElectionTerm), any(PersistentDataProvider.class)); + verify(mockSupport).handleRecoveryMessage(same(deprecatedUpdateElectionTerm), any(PersistentDataProvider.class)); + } - verify(mockRaftActor.delegate, times(0)).applyRecoverySnapshot(any(ByteString.class)); + @Test + public void testRaftActorForwardsToRaftActorSnapshotMessageSupport() { + String persistenceId = factory.generateActorId("leader-"); - mockRaftActor.onReceiveRecover(new ReplicatedLogImplEntry(0, 1, new MockRaftActorContext.MockPayload("A"))); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); - ReplicatedLog replicatedLog = mockRaftActor.getReplicatedLog(); + config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); - assertEquals("add replicated log entry", 0, replicatedLog.size()); + RaftActorSnapshotMessageSupport mockSupport = mock(RaftActorSnapshotMessageSupport.class); - mockRaftActor.onReceiveRecover(new ReplicatedLogImplEntry(1, 1, new MockRaftActorContext.MockPayload("A"))); + TestActorRef mockActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, + Collections.emptyMap(), Optional.of(config), mockSupport), persistenceId); - assertEquals("add replicated log entry", 0, replicatedLog.size()); + MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); - mockRaftActor.onReceiveRecover(new ApplyLogEntries(1)); + // Wait for akka's recovery to complete so it doesn't interfere. + mockRaftActor.waitForRecoveryComplete(); - assertEquals("commit index -1", -1, mockRaftActor.getRaftActorContext().getCommitIndex()); + ApplySnapshot applySnapshot = new ApplySnapshot(mock(Snapshot.class)); + doReturn(true).when(mockSupport).handleSnapshotMessage(same(applySnapshot)); + mockRaftActor.handleCommand(applySnapshot); - mockRaftActor.onReceiveRecover(new RaftActor.DeleteEntries(2)); + CaptureSnapshot captureSnapshot = new CaptureSnapshot(1, 1, 1, 1, 0, 1, null); + doReturn(true).when(mockSupport).handleSnapshotMessage(same(captureSnapshot)); + mockRaftActor.handleCommand(captureSnapshot); - assertEquals("remove log entries", 0, replicatedLog.size()); + CaptureSnapshotReply captureSnapshotReply = new CaptureSnapshotReply(new byte[0]); + doReturn(true).when(mockSupport).handleSnapshotMessage(same(captureSnapshotReply)); + mockRaftActor.handleCommand(captureSnapshotReply); - mockRaftActor.onReceiveRecover(new RaftActor.UpdateElectionTerm(10, "foobar")); + SaveSnapshotSuccess saveSnapshotSuccess = new SaveSnapshotSuccess(mock(SnapshotMetadata.class)); + doReturn(true).when(mockSupport).handleSnapshotMessage(same(saveSnapshotSuccess)); + mockRaftActor.handleCommand(saveSnapshotSuccess); - assertNotEquals("election term", 10, mockRaftActor.getRaftActorContext().getTermInformation().getCurrentTerm()); - assertNotEquals("voted for", "foobar", mockRaftActor.getRaftActorContext().getTermInformation().getVotedFor()); + SaveSnapshotFailure saveSnapshotFailure = new SaveSnapshotFailure(mock(SnapshotMetadata.class), new Throwable()); + doReturn(true).when(mockSupport).handleSnapshotMessage(same(saveSnapshotFailure)); + mockRaftActor.handleCommand(saveSnapshotFailure); - mockRaftActor.onReceiveRecover(mock(RecoveryCompleted.class)); + doReturn(true).when(mockSupport).handleSnapshotMessage(same(RaftActorSnapshotMessageSupport.COMMIT_SNAPSHOT)); + mockRaftActor.handleCommand(RaftActorSnapshotMessageSupport.COMMIT_SNAPSHOT); - mockActorRef.tell(PoisonPill.getInstance(), getRef()); - }}; + verify(mockSupport).handleSnapshotMessage(same(applySnapshot)); + verify(mockSupport).handleSnapshotMessage(same(captureSnapshot)); + verify(mockSupport).handleSnapshotMessage(same(captureSnapshotReply)); + verify(mockSupport).handleSnapshotMessage(same(saveSnapshotSuccess)); + verify(mockSupport).handleSnapshotMessage(same(saveSnapshotFailure)); + verify(mockSupport).handleSnapshotMessage(same(RaftActorSnapshotMessageSupport.COMMIT_SNAPSHOT)); } - @Test - public void testUpdatingElectionTermCallsDataPersistence() throws Exception { + public void testApplyJournalEntriesCallsDataPersistence() throws Exception { new JavaTestKit(getSystem()) { { - String persistenceId = "testUpdatingElectionTermCallsDataPersistence"; + String persistenceId = factory.generateActorId("leader-"); DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); - CountDownLatch persistLatch = new CountDownLatch(1); - DataPersistenceProviderMonitor dataPersistenceProviderMonitor = new DataPersistenceProviderMonitor(); - dataPersistenceProviderMonitor.setPersistLatch(persistLatch); + DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); - TestActorRef mockActorRef = TestActorRef.create(getSystem(), MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config), dataPersistenceProviderMonitor), persistenceId); + TestActorRef mockActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, + Collections.emptyMap(), Optional.of(config), dataPersistenceProvider), persistenceId); MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); - mockRaftActor.getRaftActorContext().getTermInformation().updateAndPersist(10, "foobar"); + mockRaftActor.waitForInitializeBehaviorComplete(); + + mockRaftActor.waitUntilLeader(); - assertEquals("Persist called", true, persistLatch.await(5, TimeUnit.SECONDS)); + mockRaftActor.onReceiveCommand(new ApplyJournalEntries(10)); - mockActorRef.tell(PoisonPill.getInstance(), getRef()); + verify(dataPersistenceProvider).persist(any(ApplyJournalEntries.class), any(Procedure.class)); } + }; } @Test - public void testAddingReplicatedLogEntryCallsDataPersistence() throws Exception { + public void testApplyState() throws Exception { + new JavaTestKit(getSystem()) { { - String persistenceId = "testAddingReplicatedLogEntryCallsDataPersistence"; + String persistenceId = factory.generateActorId("leader-"); DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); @@ -573,344 +409,581 @@ public class RaftActorTest extends AbstractActorTest { DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); - TestActorRef mockActorRef = TestActorRef.create(getSystem(), MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config), dataPersistenceProvider), persistenceId); + TestActorRef mockActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, + Collections.emptyMap(), Optional.of(config), dataPersistenceProvider), persistenceId); MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); - MockRaftActorContext.MockReplicatedLogEntry logEntry = new MockRaftActorContext.MockReplicatedLogEntry(10, 10, mock(Payload.class)); + mockRaftActor.waitForInitializeBehaviorComplete(); - mockRaftActor.getRaftActorContext().getReplicatedLog().appendAndPersist(logEntry); + ReplicatedLogEntry entry = new MockRaftActorContext.MockReplicatedLogEntry(1, 5, + new MockRaftActorContext.MockPayload("F")); - verify(dataPersistenceProvider).persist(eq(logEntry), any(Procedure.class)); + mockRaftActor.onReceiveCommand(new ApplyState(mockActorRef, "apply-state", entry)); - mockActorRef.tell(PoisonPill.getInstance(), getRef()); + verify(mockRaftActor.actorDelegate).applyState(eq(mockActorRef), eq("apply-state"), anyObject()); } }; } @Test - public void testRemovingReplicatedLogEntryCallsDataPersistence() throws Exception { - new JavaTestKit(getSystem()) { - { - String persistenceId = "testRemovingReplicatedLogEntryCallsDataPersistence"; + public void testRaftRoleChangeNotifierWhenRaftActorHasNoPeers() throws Exception { + new JavaTestKit(getSystem()) {{ + TestActorRef notifierActor = factory.createTestActor( + Props.create(MessageCollectorActor.class)); + MessageCollectorActor.waitUntilReady(notifierActor); - DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + long heartBeatInterval = 100; + config.setHeartBeatInterval(FiniteDuration.create(heartBeatInterval, TimeUnit.MILLISECONDS)); + config.setElectionTimeoutFactor(20); - config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + String persistenceId = factory.generateActorId("notifier-"); - DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); + TestActorRef raftActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, + Collections.emptyMap(), Optional.of(config), notifierActor, + new NonPersistentDataProvider()).withDispatcher(Dispatchers.DefaultDispatcherId()), persistenceId); - TestActorRef mockActorRef = TestActorRef.create(getSystem(), MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config), dataPersistenceProvider), persistenceId); + List matches = MessageCollectorActor.expectMatching(notifierActor, RoleChanged.class, 3); - MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); - mockRaftActor.getReplicatedLog().appendAndPersist(new MockRaftActorContext.MockReplicatedLogEntry(1, 0, mock(Payload.class))); + // check if the notifier got a role change from null to Follower + RoleChanged raftRoleChanged = matches.get(0); + assertEquals(persistenceId, raftRoleChanged.getMemberId()); + assertNull(raftRoleChanged.getOldRole()); + assertEquals(RaftState.Follower.name(), raftRoleChanged.getNewRole()); - mockRaftActor.getRaftActorContext().getReplicatedLog().removeFromAndPersist(0); + // check if the notifier got a role change from Follower to Candidate + raftRoleChanged = matches.get(1); + assertEquals(persistenceId, raftRoleChanged.getMemberId()); + assertEquals(RaftState.Follower.name(), raftRoleChanged.getOldRole()); + assertEquals(RaftState.Candidate.name(), raftRoleChanged.getNewRole()); - verify(dataPersistenceProvider, times(2)).persist(anyObject(), any(Procedure.class)); + // check if the notifier got a role change from Candidate to Leader + raftRoleChanged = matches.get(2); + assertEquals(persistenceId, raftRoleChanged.getMemberId()); + assertEquals(RaftState.Candidate.name(), raftRoleChanged.getOldRole()); + assertEquals(RaftState.Leader.name(), raftRoleChanged.getNewRole()); - mockActorRef.tell(PoisonPill.getInstance(), getRef()); + LeaderStateChanged leaderStateChange = MessageCollectorActor.expectFirstMatching( + notifierActor, LeaderStateChanged.class); - } - }; - } + assertEquals(raftRoleChanged.getMemberId(), leaderStateChange.getLeaderId()); + assertEquals(MockRaftActor.PAYLOAD_VERSION, leaderStateChange.getLeaderPayloadVersion()); - @Test - public void testApplyLogEntriesCallsDataPersistence() throws Exception { - new JavaTestKit(getSystem()) { - { - String persistenceId = "testApplyLogEntriesCallsDataPersistence"; + notifierActor.underlyingActor().clear(); - DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + MockRaftActor raftActor = raftActorRef.underlyingActor(); + final String newLeaderId = "new-leader"; + final short newLeaderVersion = 6; + Follower follower = new Follower(raftActor.getRaftActorContext()) { + @Override + public RaftActorBehavior handleMessage(ActorRef sender, Object message) { + leaderId = newLeaderId; + setLeaderPayloadVersion(newLeaderVersion); + return this; + } + }; - config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + raftActor.newBehavior(follower); - DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); + leaderStateChange = MessageCollectorActor.expectFirstMatching(notifierActor, LeaderStateChanged.class); + assertEquals(persistenceId, leaderStateChange.getMemberId()); + assertEquals(null, leaderStateChange.getLeaderId()); - TestActorRef mockActorRef = TestActorRef.create(getSystem(), MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config), dataPersistenceProvider), persistenceId); + raftRoleChanged = MessageCollectorActor.expectFirstMatching(notifierActor, RoleChanged.class); + assertEquals(RaftState.Leader.name(), raftRoleChanged.getOldRole()); + assertEquals(RaftState.Follower.name(), raftRoleChanged.getNewRole()); - MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); + notifierActor.underlyingActor().clear(); + + raftActor.handleCommand("any"); - mockRaftActor.onReceiveCommand(new ApplyLogEntries(10)); + leaderStateChange = MessageCollectorActor.expectFirstMatching(notifierActor, LeaderStateChanged.class); + assertEquals(persistenceId, leaderStateChange.getMemberId()); + assertEquals(newLeaderId, leaderStateChange.getLeaderId()); + assertEquals(newLeaderVersion, leaderStateChange.getLeaderPayloadVersion()); - verify(dataPersistenceProvider, times(1)).persist(anyObject(), any(Procedure.class)); + notifierActor.underlyingActor().clear(); + + raftActor.handleCommand("any"); + + Uninterruptibles.sleepUninterruptibly(505, TimeUnit.MILLISECONDS); + leaderStateChange = MessageCollectorActor.getFirstMatching(notifierActor, LeaderStateChanged.class); + assertNull(leaderStateChange); + }}; + } + + @Test + public void testRaftRoleChangeNotifierWhenRaftActorHasPeers() throws Exception { + new JavaTestKit(getSystem()) {{ + ActorRef notifierActor = factory.createActor(Props.create(MessageCollectorActor.class)); + MessageCollectorActor.waitUntilReady(notifierActor); + + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + long heartBeatInterval = 100; + config.setHeartBeatInterval(FiniteDuration.create(heartBeatInterval, TimeUnit.MILLISECONDS)); + config.setElectionTimeoutFactor(1); - mockActorRef.tell(PoisonPill.getInstance(), getRef()); + String persistenceId = factory.generateActorId("notifier-"); + factory.createActor(MockRaftActor.props(persistenceId, + ImmutableMap.of("leader", "fake/path"), Optional.of(config), notifierActor), persistenceId); + + List matches = null; + for(int i = 0; i < 5000 / heartBeatInterval; i++) { + matches = MessageCollectorActor.getAllMatching(notifierActor, RoleChanged.class); + assertNotNull(matches); + if(matches.size() == 3) { + break; + } + Uninterruptibles.sleepUninterruptibly(heartBeatInterval, TimeUnit.MILLISECONDS); } - }; + + assertNotNull(matches); + assertEquals(2, matches.size()); + + // check if the notifier got a role change from null to Follower + RoleChanged raftRoleChanged = matches.get(0); + assertEquals(persistenceId, raftRoleChanged.getMemberId()); + assertNull(raftRoleChanged.getOldRole()); + assertEquals(RaftState.Follower.name(), raftRoleChanged.getNewRole()); + + // check if the notifier got a role change from Follower to Candidate + raftRoleChanged = matches.get(1); + assertEquals(persistenceId, raftRoleChanged.getMemberId()); + assertEquals(RaftState.Follower.name(), raftRoleChanged.getOldRole()); + assertEquals(RaftState.Candidate.name(), raftRoleChanged.getNewRole()); + + }}; } @Test - public void testCaptureSnapshotReplyCallsDataPersistence() throws Exception { + public void testFakeSnapshotsForLeaderWithInRealSnapshots() throws Exception { new JavaTestKit(getSystem()) { { - String persistenceId = "testCaptureSnapshotReplyCallsDataPersistence"; + String persistenceId = factory.generateActorId("leader-"); + String follower1Id = factory.generateActorId("follower-"); - DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + ActorRef followerActor1 = + factory.createActor(Props.create(MessageCollectorActor.class)); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS)); DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); - TestActorRef mockActorRef = TestActorRef.create(getSystem(), - MockRaftActor.props(persistenceId,Collections.emptyMap(), - Optional.of(config), dataPersistenceProvider), persistenceId); + Map peerAddresses = new HashMap<>(); + peerAddresses.put(follower1Id, followerActor1.path().toString()); - MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); + TestActorRef mockActorRef = factory.createTestActor( + MockRaftActor.props(persistenceId, peerAddresses, + Optional.of(config), dataPersistenceProvider), persistenceId); - ByteString snapshotBytes = fromObject(Arrays.asList( - new MockRaftActorContext.MockPayload("A"), - new MockRaftActorContext.MockPayload("B"), - new MockRaftActorContext.MockPayload("C"), - new MockRaftActorContext.MockPayload("D"))); + MockRaftActor leaderActor = mockActorRef.underlyingActor(); - mockRaftActor.onReceiveCommand(new CaptureSnapshot(-1,1,-1,1)); + leaderActor.getRaftActorContext().setCommitIndex(4); + leaderActor.getRaftActorContext().setLastApplied(4); + leaderActor.getRaftActorContext().getTermInformation().update(1, persistenceId); - RaftActorContext raftActorContext = mockRaftActor.getRaftActorContext(); + leaderActor.waitForInitializeBehaviorComplete(); - mockRaftActor.setCurrentBehavior(new Leader(raftActorContext)); + // create 8 entries in the log - 0 to 4 are applied and will get picked up as part of the capture snapshot - mockRaftActor.onReceiveCommand(new CaptureSnapshotReply(snapshotBytes)); + Leader leader = new Leader(leaderActor.getRaftActorContext()); + leaderActor.setCurrentBehavior(leader); + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); - verify(dataPersistenceProvider).saveSnapshot(anyObject()); + MockRaftActorContext.MockReplicatedLogBuilder logBuilder = new MockRaftActorContext.MockReplicatedLogBuilder(); + leaderActor.getRaftActorContext().setReplicatedLog(logBuilder.createEntries(0, 8, 1).build()); - mockActorRef.tell(PoisonPill.getInstance(), getRef()); + assertEquals(8, leaderActor.getReplicatedLog().size()); + + leaderActor.getRaftActorContext().getSnapshotManager() + .capture(new MockRaftActorContext.MockReplicatedLogEntry(1, 6, + new MockRaftActorContext.MockPayload("x")), 4); + + verify(leaderActor.snapshotCohortDelegate).createSnapshot(any(ActorRef.class)); + + assertEquals(8, leaderActor.getReplicatedLog().size()); + + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); + //fake snapshot on index 5 + leaderActor.onReceiveCommand(new AppendEntriesReply(follower1Id, 1, true, 5, 1, (short)0)); + + assertEquals(8, leaderActor.getReplicatedLog().size()); + + //fake snapshot on index 6 + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); + leaderActor.onReceiveCommand(new AppendEntriesReply(follower1Id, 1, true, 6, 1, (short)0)); + assertEquals(8, leaderActor.getReplicatedLog().size()); + + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); + + assertEquals(8, leaderActor.getReplicatedLog().size()); + + ByteString snapshotBytes = fromObject(Arrays.asList( + new MockRaftActorContext.MockPayload("foo-0"), + new MockRaftActorContext.MockPayload("foo-1"), + new MockRaftActorContext.MockPayload("foo-2"), + new MockRaftActorContext.MockPayload("foo-3"), + new MockRaftActorContext.MockPayload("foo-4"))); + + leaderActor.getRaftActorContext().getSnapshotManager().persist(snapshotBytes.toByteArray(), + leader, Runtime.getRuntime().totalMemory()); + + assertTrue(leaderActor.getRaftActorContext().getSnapshotManager().isCapturing()); + + // The commit is needed to complete the snapshot creation process + leaderActor.getRaftActorContext().getSnapshotManager().commit(-1, leader); + + // capture snapshot reply should remove the snapshotted entries only + assertEquals(3, leaderActor.getReplicatedLog().size()); + assertEquals(7, leaderActor.getReplicatedLog().lastIndex()); + + // add another non-replicated entry + leaderActor.getReplicatedLog().append( + new ReplicatedLogImplEntry(8, 1, new MockRaftActorContext.MockPayload("foo-8"))); + + //fake snapshot on index 7, since lastApplied = 7 , we would keep the last applied + leaderActor.onReceiveCommand(new AppendEntriesReply(follower1Id, 1, true, 7, 1, (short)0)); + assertEquals(2, leaderActor.getReplicatedLog().size()); + assertEquals(8, leaderActor.getReplicatedLog().lastIndex()); } }; } @Test - public void testSaveSnapshotSuccessCallsDataPersistence() throws Exception { + public void testFakeSnapshotsForFollowerWithInRealSnapshots() throws Exception { new JavaTestKit(getSystem()) { { - String persistenceId = "testSaveSnapshotSuccessCallsDataPersistence"; + String persistenceId = factory.generateActorId("follower-"); + String leaderId = factory.generateActorId("leader-"); - DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + ActorRef leaderActor1 = + factory.createActor(Props.create(MessageCollectorActor.class)); + + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS)); DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); - TestActorRef mockActorRef = TestActorRef.create(getSystem(), MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config), dataPersistenceProvider), persistenceId); + Map peerAddresses = new HashMap<>(); + peerAddresses.put(leaderId, leaderActor1.path().toString()); - MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); + TestActorRef mockActorRef = factory.createTestActor( + MockRaftActor.props(persistenceId, peerAddresses, + Optional.of(config), dataPersistenceProvider), persistenceId); - mockRaftActor.getReplicatedLog().append(new MockRaftActorContext.MockReplicatedLogEntry(1,0, mock(Payload.class))); - mockRaftActor.getReplicatedLog().append(new MockRaftActorContext.MockReplicatedLogEntry(1,1, mock(Payload.class))); - mockRaftActor.getReplicatedLog().append(new MockRaftActorContext.MockReplicatedLogEntry(1,2, mock(Payload.class))); - mockRaftActor.getReplicatedLog().append(new MockRaftActorContext.MockReplicatedLogEntry(1,3, mock(Payload.class))); - mockRaftActor.getReplicatedLog().append(new MockRaftActorContext.MockReplicatedLogEntry(1,4, mock(Payload.class))); + MockRaftActor followerActor = mockActorRef.underlyingActor(); + followerActor.getRaftActorContext().setCommitIndex(4); + followerActor.getRaftActorContext().setLastApplied(4); + followerActor.getRaftActorContext().getTermInformation().update(1, persistenceId); - ByteString snapshotBytes = fromObject(Arrays.asList( - new MockRaftActorContext.MockPayload("A"), - new MockRaftActorContext.MockPayload("B"), - new MockRaftActorContext.MockPayload("C"), - new MockRaftActorContext.MockPayload("D"))); + followerActor.waitForInitializeBehaviorComplete(); + + + Follower follower = new Follower(followerActor.getRaftActorContext()); + followerActor.setCurrentBehavior(follower); + assertEquals(RaftState.Follower, followerActor.getCurrentBehavior().state()); - RaftActorContext raftActorContext = mockRaftActor.getRaftActorContext(); - mockRaftActor.setCurrentBehavior(new Follower(raftActorContext)); + // create 6 entries in the log - 0 to 4 are applied and will get picked up as part of the capture snapshot + MockRaftActorContext.MockReplicatedLogBuilder logBuilder = new MockRaftActorContext.MockReplicatedLogBuilder(); + followerActor.getRaftActorContext().setReplicatedLog(logBuilder.createEntries(0, 6, 1).build()); - mockRaftActor.onReceiveCommand(new CaptureSnapshot(-1, 1, 2, 1)); + // log has indices 0-5 + assertEquals(6, followerActor.getReplicatedLog().size()); - verify(mockRaftActor.delegate).createSnapshot(); + //snapshot on 4 + followerActor.getRaftActorContext().getSnapshotManager().capture( + new MockRaftActorContext.MockReplicatedLogEntry(1, 5, + new MockRaftActorContext.MockPayload("D")), 4); - mockRaftActor.onReceiveCommand(new CaptureSnapshotReply(snapshotBytes)); + verify(followerActor.snapshotCohortDelegate).createSnapshot(any(ActorRef.class)); - mockRaftActor.onReceiveCommand(new SaveSnapshotSuccess(new SnapshotMetadata("foo", 100, 100))); + assertEquals(6, followerActor.getReplicatedLog().size()); - verify(dataPersistenceProvider).deleteSnapshots(any(SnapshotSelectionCriteria.class)); + //fake snapshot on index 6 + List entries = + Arrays.asList( + (ReplicatedLogEntry) new MockRaftActorContext.MockReplicatedLogEntry(1, 6, + new MockRaftActorContext.MockPayload("foo-6")) + ); + followerActor.onReceiveCommand(new AppendEntries(1, leaderId, 5, 1, entries, 5, 5, (short)0)); + assertEquals(7, followerActor.getReplicatedLog().size()); - verify(dataPersistenceProvider).deleteMessages(100); + //fake snapshot on index 7 + assertEquals(RaftState.Follower, followerActor.getCurrentBehavior().state()); - assertEquals(2, mockRaftActor.getReplicatedLog().size()); + entries = + Arrays.asList( + (ReplicatedLogEntry) new MockRaftActorContext.MockReplicatedLogEntry(1, 7, + new MockRaftActorContext.MockPayload("foo-7")) + ); + followerActor.onReceiveCommand(new AppendEntries(1, leaderId, 6, 1, entries, 6, 6, (short) 0)); + assertEquals(8, followerActor.getReplicatedLog().size()); - assertNotNull(mockRaftActor.getReplicatedLog().get(3)); - assertNotNull(mockRaftActor.getReplicatedLog().get(4)); + assertEquals(RaftState.Follower, followerActor.getCurrentBehavior().state()); - // Index 2 will not be in the log because it was removed due to snapshotting - assertNull(mockRaftActor.getReplicatedLog().get(2)); - mockActorRef.tell(PoisonPill.getInstance(), getRef()); + ByteString snapshotBytes = fromObject(Arrays.asList( + new MockRaftActorContext.MockPayload("foo-0"), + new MockRaftActorContext.MockPayload("foo-1"), + new MockRaftActorContext.MockPayload("foo-2"), + new MockRaftActorContext.MockPayload("foo-3"), + new MockRaftActorContext.MockPayload("foo-4"))); + followerActor.onReceiveCommand(new CaptureSnapshotReply(snapshotBytes.toByteArray())); + assertTrue(followerActor.getRaftActorContext().getSnapshotManager().isCapturing()); + + // The commit is needed to complete the snapshot creation process + followerActor.getRaftActorContext().getSnapshotManager().commit(-1, follower); + + // capture snapshot reply should remove the snapshotted entries only till replicatedToAllIndex + assertEquals(3, followerActor.getReplicatedLog().size()); //indexes 5,6,7 left in the log + assertEquals(7, followerActor.getReplicatedLog().lastIndex()); + + entries = + Arrays.asList( + (ReplicatedLogEntry) new MockRaftActorContext.MockReplicatedLogEntry(1, 8, + new MockRaftActorContext.MockPayload("foo-7")) + ); + // send an additional entry 8 with leaderCommit = 7 + followerActor.onReceiveCommand(new AppendEntries(1, leaderId, 7, 1, entries, 7, 7, (short) 0)); + + // 7 and 8, as lastapplied is 7 + assertEquals(2, followerActor.getReplicatedLog().size()); } }; } @Test - public void testApplyState() throws Exception { - + public void testFakeSnapshotsForLeaderWithInInitiateSnapshots() throws Exception { new JavaTestKit(getSystem()) { { - String persistenceId = "testApplyState"; + String persistenceId = factory.generateActorId("leader-"); + String follower1Id = factory.generateActorId("follower-"); + String follower2Id = factory.generateActorId("follower-"); - DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + ActorRef followerActor1 = + factory.createActor(Props.create(MessageCollectorActor.class), follower1Id); + ActorRef followerActor2 = + factory.createActor(Props.create(MessageCollectorActor.class), follower2Id); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS)); DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); - TestActorRef mockActorRef = TestActorRef.create(getSystem(), MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config), dataPersistenceProvider), persistenceId); + Map peerAddresses = new HashMap<>(); + peerAddresses.put(follower1Id, followerActor1.path().toString()); + peerAddresses.put(follower2Id, followerActor2.path().toString()); - MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); + TestActorRef mockActorRef = factory.createTestActor( + MockRaftActor.props(persistenceId, peerAddresses, + Optional.of(config), dataPersistenceProvider), persistenceId); - ReplicatedLogEntry entry = new MockRaftActorContext.MockReplicatedLogEntry(1, 5, - new MockRaftActorContext.MockPayload("F")); + MockRaftActor leaderActor = mockActorRef.underlyingActor(); + leaderActor.getRaftActorContext().setCommitIndex(9); + leaderActor.getRaftActorContext().setLastApplied(9); + leaderActor.getRaftActorContext().getTermInformation().update(1, persistenceId); - mockRaftActor.onReceiveCommand(new ApplyState(mockActorRef, "apply-state", entry)); + leaderActor.waitForInitializeBehaviorComplete(); - verify(mockRaftActor.delegate).applyState(eq(mockActorRef), eq("apply-state"), anyObject()); + Leader leader = new Leader(leaderActor.getRaftActorContext()); + leaderActor.setCurrentBehavior(leader); + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); - mockActorRef.tell(PoisonPill.getInstance(), getRef()); + // create 5 entries in the log + MockRaftActorContext.MockReplicatedLogBuilder logBuilder = new MockRaftActorContext.MockReplicatedLogBuilder(); + leaderActor.getRaftActorContext().setReplicatedLog(logBuilder.createEntries(5, 10, 1).build()); - } - }; - } + //set the snapshot index to 4 , 0 to 4 are snapshotted + leaderActor.getRaftActorContext().getReplicatedLog().setSnapshotIndex(4); + //setting replicatedToAllIndex = 9, for the log to clear + leader.setReplicatedToAllIndex(9); + assertEquals(5, leaderActor.getReplicatedLog().size()); + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); - @Test - public void testApplySnapshot() throws Exception { - new JavaTestKit(getSystem()) { - { - String persistenceId = "testApplySnapshot"; + leaderActor.onReceiveCommand(new AppendEntriesReply(follower1Id, 1, true, 9, 1, (short) 0)); + assertEquals(5, leaderActor.getReplicatedLog().size()); + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); - DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + // set the 2nd follower nextIndex to 1 which has been snapshotted + leaderActor.onReceiveCommand(new AppendEntriesReply(follower2Id, 1, true, 0, 1, (short)0)); + assertEquals(5, leaderActor.getReplicatedLog().size()); + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); - config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + // simulate a real snapshot + leaderActor.onReceiveCommand(new SendHeartBeat()); + assertEquals(5, leaderActor.getReplicatedLog().size()); + assertEquals(String.format("expected to be Leader but was %s. Current Leader = %s ", + leaderActor.getCurrentBehavior().state(), leaderActor.getLeaderId()) + , RaftState.Leader, leaderActor.getCurrentBehavior().state()); - DataPersistenceProviderMonitor dataPersistenceProviderMonitor = new DataPersistenceProviderMonitor(); - TestActorRef mockActorRef = TestActorRef.create(getSystem(), MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config), dataPersistenceProviderMonitor), persistenceId); - - MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); - - ReplicatedLog oldReplicatedLog = mockRaftActor.getReplicatedLog(); - - oldReplicatedLog.append(new MockRaftActorContext.MockReplicatedLogEntry(1,0,mock(Payload.class))); - oldReplicatedLog.append(new MockRaftActorContext.MockReplicatedLogEntry(1,1,mock(Payload.class))); - oldReplicatedLog.append( - new MockRaftActorContext.MockReplicatedLogEntry(1, 2, - mock(Payload.class))); + //reply from a slow follower does not initiate a fake snapshot + leaderActor.onReceiveCommand(new AppendEntriesReply(follower2Id, 1, true, 9, 1, (short)0)); + assertEquals("Fake snapshot should not happen when Initiate is in progress", 5, leaderActor.getReplicatedLog().size()); ByteString snapshotBytes = fromObject(Arrays.asList( - new MockRaftActorContext.MockPayload("A"), - new MockRaftActorContext.MockPayload("B"), - new MockRaftActorContext.MockPayload("C"), - new MockRaftActorContext.MockPayload("D"))); + new MockRaftActorContext.MockPayload("foo-0"), + new MockRaftActorContext.MockPayload("foo-1"), + new MockRaftActorContext.MockPayload("foo-2"), + new MockRaftActorContext.MockPayload("foo-3"), + new MockRaftActorContext.MockPayload("foo-4"))); + leaderActor.onReceiveCommand(new CaptureSnapshotReply(snapshotBytes.toByteArray())); + assertTrue(leaderActor.getRaftActorContext().getSnapshotManager().isCapturing()); + + assertEquals("Real snapshot didn't clear the log till replicatedToAllIndex", 0, leaderActor.getReplicatedLog().size()); + + //reply from a slow follower after should not raise errors + leaderActor.onReceiveCommand(new AppendEntriesReply(follower2Id, 1, true, 5, 1, (short) 0)); + assertEquals(0, leaderActor.getReplicatedLog().size()); + } + }; + } + + @Test + public void testRealSnapshotWhenReplicatedToAllIndexMinusOne() throws Exception { + new JavaTestKit(getSystem()) {{ + String persistenceId = factory.generateActorId("leader-"); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS)); + config.setSnapshotBatchCount(5); - Snapshot snapshot = mock(Snapshot.class); + DataPersistenceProvider dataPersistenceProvider = new NonPersistentDataProvider(); - doReturn(snapshotBytes.toByteArray()).when(snapshot).getState(); + Map peerAddresses = ImmutableMap.builder().put("member1", "address").build(); - doReturn(3L).when(snapshot).getLastAppliedIndex(); + TestActorRef mockActorRef = factory.createTestActor( + MockRaftActor.props(persistenceId, peerAddresses, + Optional.of(config), dataPersistenceProvider), persistenceId); - mockRaftActor.onReceiveCommand(new ApplySnapshot(snapshot)); + MockRaftActor leaderActor = mockActorRef.underlyingActor(); + leaderActor.getRaftActorContext().setCommitIndex(3); + leaderActor.getRaftActorContext().setLastApplied(3); + leaderActor.getRaftActorContext().getTermInformation().update(1, persistenceId); - verify(mockRaftActor.delegate).applySnapshot(eq(snapshotBytes)); + leaderActor.waitForInitializeBehaviorComplete(); + for(int i=0;i< 4;i++) { + leaderActor.getReplicatedLog() + .append(new MockRaftActorContext.MockReplicatedLogEntry(1, i, + new MockRaftActorContext.MockPayload("A"))); + } - assertTrue("The replicatedLog should have changed", - oldReplicatedLog != mockRaftActor.getReplicatedLog()); + Leader leader = new Leader(leaderActor.getRaftActorContext()); + leaderActor.setCurrentBehavior(leader); + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); - assertEquals("lastApplied should be same as in the snapshot", - (Long) 3L, mockRaftActor.getLastApplied()); + // Simulate an install snaphost to a follower. + leaderActor.getRaftActorContext().getSnapshotManager().captureToInstall( + leaderActor.getReplicatedLog().last(), -1, "member1"); - assertEquals(0, mockRaftActor.getReplicatedLog().size()); + // Now send a CaptureSnapshotReply + mockActorRef.tell(new CaptureSnapshotReply(fromObject("foo").toByteArray()), mockActorRef); - mockActorRef.tell(PoisonPill.getInstance(), getRef()); + // Trimming log in this scenario is a no-op + assertEquals(-1, leaderActor.getReplicatedLog().getSnapshotIndex()); + assertTrue(leaderActor.getRaftActorContext().getSnapshotManager().isCapturing()); + assertEquals(-1, leader.getReplicatedToAllIndex()); - } - }; + }}; } @Test - public void testSaveSnapshotFailure() throws Exception { - new JavaTestKit(getSystem()) { - { - String persistenceId = "testSaveSnapshotFailure"; + public void testRealSnapshotWhenReplicatedToAllIndexNotInReplicatedLog() throws Exception { + new JavaTestKit(getSystem()) {{ + String persistenceId = factory.generateActorId("leader-"); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS)); + config.setSnapshotBatchCount(5); - DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + DataPersistenceProvider dataPersistenceProvider = new NonPersistentDataProvider(); - config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + Map peerAddresses = ImmutableMap.builder().put("member1", "address").build(); - DataPersistenceProviderMonitor dataPersistenceProviderMonitor = new DataPersistenceProviderMonitor(); + TestActorRef mockActorRef = factory.createTestActor( + MockRaftActor.props(persistenceId, peerAddresses, + Optional.of(config), dataPersistenceProvider), persistenceId); - TestActorRef mockActorRef = TestActorRef.create(getSystem(), MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config), dataPersistenceProviderMonitor), persistenceId); + MockRaftActor leaderActor = mockActorRef.underlyingActor(); + leaderActor.getRaftActorContext().setCommitIndex(3); + leaderActor.getRaftActorContext().setLastApplied(3); + leaderActor.getRaftActorContext().getTermInformation().update(1, persistenceId); + leaderActor.getReplicatedLog().setSnapshotIndex(3); - MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); + leaderActor.waitForInitializeBehaviorComplete(); + Leader leader = new Leader(leaderActor.getRaftActorContext()); + leaderActor.setCurrentBehavior(leader); + leader.setReplicatedToAllIndex(3); + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); - ByteString snapshotBytes = fromObject(Arrays.asList( - new MockRaftActorContext.MockPayload("A"), - new MockRaftActorContext.MockPayload("B"), - new MockRaftActorContext.MockPayload("C"), - new MockRaftActorContext.MockPayload("D"))); + // Persist another entry (this will cause a CaptureSnapshot to be triggered + leaderActor.persistData(mockActorRef, "x", new MockRaftActorContext.MockPayload("duh")); - RaftActorContext raftActorContext = mockRaftActor.getRaftActorContext(); + // Now send a CaptureSnapshotReply + mockActorRef.tell(new CaptureSnapshotReply(fromObject("foo").toByteArray()), mockActorRef); - mockRaftActor.setCurrentBehavior(new Leader(raftActorContext)); + // Trimming log in this scenario is a no-op + assertEquals(3, leaderActor.getReplicatedLog().getSnapshotIndex()); + assertTrue(leaderActor.getRaftActorContext().getSnapshotManager().isCapturing()); + assertEquals(3, leader.getReplicatedToAllIndex()); - mockRaftActor.onReceiveCommand(new CaptureSnapshot(-1,1,-1,1)); + }}; + } - mockRaftActor.onReceiveCommand(new CaptureSnapshotReply(snapshotBytes)); + @Test + public void testSwitchBehavior(){ + String persistenceId = factory.generateActorId("leader-"); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + config.setCustomRaftPolicyImplementationClass("org.opendaylight.controller.cluster.raft.policy.DisableElectionsRaftPolicy"); + config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS)); + config.setSnapshotBatchCount(5); - mockRaftActor.onReceiveCommand(new SaveSnapshotFailure(new SnapshotMetadata("foobar", 10L, 1234L), - new Exception())); + DataPersistenceProvider dataPersistenceProvider = new NonPersistentDataProvider(); - assertEquals("Snapshot index should not have advanced because save snapshot failed", -1, - mockRaftActor.getReplicatedLog().getSnapshotIndex()); + Map peerAddresses = ImmutableMap.builder().build(); - mockActorRef.tell(PoisonPill.getInstance(), getRef()); + TestActorRef mockActorRef = factory.createTestActor( + MockRaftActor.props(persistenceId, peerAddresses, + Optional.of(config), dataPersistenceProvider), persistenceId); - } - }; - } + MockRaftActor leaderActor = mockActorRef.underlyingActor(); - @Test - public void testRaftRoleChangeNotifier() throws Exception { - new JavaTestKit(getSystem()) {{ - ActorRef notifierActor = getSystem().actorOf(Props.create(MessageCollectorActor.class)); - DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); - String id = "testRaftRoleChangeNotifier"; + leaderActor.waitForRecoveryComplete(); - TestActorRef mockActorRef = TestActorRef.create(getSystem(), MockRaftActor.props(id, - Collections.emptyMap(), Optional.of(config), notifierActor), id); + leaderActor.handleCommand(new SwitchBehavior(RaftState.Follower, 100)); - // sleeping for a minimum of 2 seconds, if it spans more its fine. - Uninterruptibles.sleepUninterruptibly(2, TimeUnit.SECONDS); + assertEquals(100, leaderActor.getRaftActorContext().getTermInformation().getCurrentTerm()); + assertEquals(RaftState.Follower, leaderActor.getCurrentBehavior().state()); - List matches = MessageCollectorActor.getAllMatching(notifierActor, RoleChanged.class); - assertNotNull(matches); - assertEquals(3, matches.size()); + leaderActor.handleCommand(new SwitchBehavior(RaftState.Leader, 110)); - // check if the notifier got a role change from null to Follower - RoleChanged raftRoleChanged = (RoleChanged) matches.get(0); - assertEquals(id, raftRoleChanged.getMemberId()); - assertNull(raftRoleChanged.getOldRole()); - assertEquals(RaftState.Follower.name(), raftRoleChanged.getNewRole()); + assertEquals(110, leaderActor.getRaftActorContext().getTermInformation().getCurrentTerm()); + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); - // check if the notifier got a role change from Follower to Candidate - raftRoleChanged = (RoleChanged) matches.get(1); - assertEquals(id, raftRoleChanged.getMemberId()); - assertEquals(RaftState.Follower.name(), raftRoleChanged.getOldRole()); - assertEquals(RaftState.Candidate.name(), raftRoleChanged.getNewRole()); + leaderActor.handleCommand(new SwitchBehavior(RaftState.Candidate, 125)); - // check if the notifier got a role change from Candidate to Leader - raftRoleChanged = (RoleChanged) matches.get(2); - assertEquals(id, raftRoleChanged.getMemberId()); - assertEquals(RaftState.Candidate.name(), raftRoleChanged.getOldRole()); - assertEquals(RaftState.Leader.name(), raftRoleChanged.getNewRole()); - }}; + assertEquals(110, leaderActor.getRaftActorContext().getTermInformation().getCurrentTerm()); + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); + + leaderActor.handleCommand(new SwitchBehavior(RaftState.IsolatedLeader, 125)); + + assertEquals(110, leaderActor.getRaftActorContext().getTermInformation().getCurrentTerm()); + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); } - private ByteString fromObject(Object snapshot) throws Exception { + public static ByteString fromObject(Object snapshot) throws Exception { ByteArrayOutputStream b = null; ObjectOutputStream o = null; try { @@ -929,4 +1002,5 @@ public class RaftActorTest extends AbstractActorTest { } } } + }