X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-akka-raft%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fraft%2FRaftActorTest.java;h=96e04df15a803855a1b8dca4d71c20e29de4e613;hp=14bfd1d348b69dc76332fc35ec8f8f94dd80e8db;hb=refs%2Fchanges%2F09%2F83009%2F6;hpb=8360177d8f021df9078ac54919a816a73fbee0a0 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 14bfd1d348..96e04df15a 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,1508 +1,1421 @@ +/* + * 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.awaitility.Awaitility.await; import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotEquals; import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNotSame; import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertSame; 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.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.ArgumentMatchers.same; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.times; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.reset; +import static org.mockito.Mockito.timeout; 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.Status.Failure; 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.protobuf.ByteString; import akka.testkit.TestActorRef; -import akka.util.Timeout; -import com.google.common.base.Optional; +import akka.testkit.javadsl.TestKit; import com.google.common.collect.ImmutableMap; -import com.google.common.collect.Lists; 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.time.Duration; 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.Optional; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; -import javax.annotation.Nonnull; import org.junit.After; -import org.junit.Assert; import org.junit.Before; import org.junit.Test; +import org.mockito.ArgumentCaptor; import org.opendaylight.controller.cluster.DataPersistenceProvider; import org.opendaylight.controller.cluster.NonPersistentDataProvider; -import org.opendaylight.controller.cluster.datastore.DataPersistenceProviderMonitor; +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.RaftActor.UpdateElectionTerm; -import org.opendaylight.controller.cluster.raft.base.messages.ApplyJournalEntries; -import org.opendaylight.controller.cluster.raft.base.messages.ApplyLogEntries; +import org.opendaylight.controller.cluster.raft.AbstractRaftActorIntegrationTest.TestPersist; +import org.opendaylight.controller.cluster.raft.AbstractRaftActorIntegrationTest.TestRaftActor; +import org.opendaylight.controller.cluster.raft.MockRaftActor.MockSnapshotState; +import org.opendaylight.controller.cluster.raft.MockRaftActorContext.MockPayload; 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.CaptureSnapshotReply; +import org.opendaylight.controller.cluster.raft.base.messages.LeaderTransitioning; import org.opendaylight.controller.cluster.raft.base.messages.SendHeartBeat; +import org.opendaylight.controller.cluster.raft.base.messages.SwitchBehavior; import org.opendaylight.controller.cluster.raft.behaviors.Follower; import org.opendaylight.controller.cluster.raft.behaviors.Leader; import org.opendaylight.controller.cluster.raft.behaviors.RaftActorBehavior; -import org.opendaylight.controller.cluster.raft.client.messages.FindLeader; -import org.opendaylight.controller.cluster.raft.client.messages.FindLeaderReply; +import org.opendaylight.controller.cluster.raft.client.messages.GetSnapshot; +import org.opendaylight.controller.cluster.raft.client.messages.GetSnapshotReply; import org.opendaylight.controller.cluster.raft.messages.AppendEntries; import org.opendaylight.controller.cluster.raft.messages.AppendEntriesReply; -import org.opendaylight.controller.cluster.raft.protobuff.client.messages.Payload; +import org.opendaylight.controller.cluster.raft.persisted.ApplyJournalEntries; +import org.opendaylight.controller.cluster.raft.persisted.ByteState; +import org.opendaylight.controller.cluster.raft.persisted.DeleteEntries; +import org.opendaylight.controller.cluster.raft.persisted.EmptyState; +import org.opendaylight.controller.cluster.raft.persisted.ServerConfigurationPayload; +import org.opendaylight.controller.cluster.raft.persisted.ServerInfo; +import org.opendaylight.controller.cluster.raft.persisted.SimpleReplicatedLogEntry; +import org.opendaylight.controller.cluster.raft.persisted.Snapshot; +import org.opendaylight.controller.cluster.raft.persisted.UpdateElectionTerm; +import org.opendaylight.controller.cluster.raft.policy.DisableElectionsRaftPolicy; 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 scala.concurrent.Await; -import scala.concurrent.Future; -import scala.concurrent.duration.Duration; +import org.opendaylight.yangtools.concepts.Identifier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; import scala.concurrent.duration.FiniteDuration; public class RaftActorTest extends AbstractActorTest { + static final Logger TEST_LOG = LoggerFactory.getLogger(RaftActorTest.class); + private TestActorFactory factory; @Before - public void setUp(){ + public void setUp() { factory = new TestActorFactory(getSystem()); } @After - public void tearDown() throws Exception { + public void tearDown() { factory.close(); InMemoryJournal.clear(); InMemorySnapshotStore.clear(); } - public static class MockRaftActor extends RaftActor implements RaftActorRecoveryCohort, RaftActorSnapshotCohort { - - private final RaftActor actorDelegate; - private final RaftActorRecoveryCohort recoveryCohortDelegate; - private final RaftActorSnapshotCohort snapshotCohortDelegate; - private final CountDownLatch recoveryComplete = new CountDownLatch(1); - private final List state; - private ActorRef roleChangeNotifier; - private final CountDownLatch initializeBehaviorComplete = new CountDownLatch(1); - - 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.actorDelegate = mock(RaftActor.class); - this.recoveryCohortDelegate = mock(RaftActorRecoveryCohort.class); - this.snapshotCohortDelegate = mock(RaftActorSnapshotCohort.class); - if(dataPersistenceProvider == null){ - setPersistence(true); - } else { - setPersistence(dataPersistenceProvider); - } - } - - public void waitForRecoveryComplete() { - try { - assertEquals("Recovery complete", true, recoveryComplete.await(5, TimeUnit.SECONDS)); - } catch (InterruptedException e) { - e.printStackTrace(); - } - } - - public void waitForInitializeBehaviorComplete() { - try { - assertEquals("Behavior initialized", true, initializeBehaviorComplete.await(5, TimeUnit.SECONDS)); - } catch (InterruptedException e) { - e.printStackTrace(); - } - } + @Test + public void testConstruction() { + new RaftActorTestKit(getSystem(), "testConstruction").waitUntilLeader(); + } + @Test + public void testFindLeaderWhenLeaderIsSelf() { + RaftActorTestKit kit = new RaftActorTestKit(getSystem(), "testFindLeader"); + kit.waitUntilLeader(); + } - public void waitUntilLeader(){ - for(int i = 0;i < 10; i++){ - if(isLeader()){ - break; - } - Uninterruptibles.sleepUninterruptibly(100, TimeUnit.MILLISECONDS); - } - } - public List getState() { - return state; - } + @Test + public void testRaftActorRecoveryWithPersistenceEnabled() { + TEST_LOG.info("testRaftActorRecoveryWithPersistenceEnabled starting"); - public static Props props(final String id, final Map peerAddresses, - Optional config){ - return Props.create(new MockRaftActorCreator(peerAddresses, id, config, null, null)); - } + TestKit kit = new TestKit(getSystem()); + String persistenceId = factory.generateActorId("follower-"); - public static Props props(final String id, final Map peerAddresses, - Optional config, DataPersistenceProvider dataPersistenceProvider){ - return Props.create(new MockRaftActorCreator(peerAddresses, id, config, dataPersistenceProvider, null)); - } + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); - public static Props props(final String id, final Map peerAddresses, - Optional config, ActorRef roleChangeNotifier){ - return Props.create(new MockRaftActorCreator(peerAddresses, id, config, null, roleChangeNotifier)); - } + // 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)); - public static Props props(final String id, final Map peerAddresses, - Optional config, ActorRef roleChangeNotifier, - DataPersistenceProvider dataPersistenceProvider){ - return Props.create(new MockRaftActorCreator(peerAddresses, id, config, dataPersistenceProvider, roleChangeNotifier)); - } + ImmutableMap peerAddresses = ImmutableMap.builder() + .put("member1", "address").build(); + ActorRef followerActor = factory.createActor(MockRaftActor.props(persistenceId, + peerAddresses, config), persistenceId); + kit.watch(followerActor); - @Override protected void applyState(ActorRef clientActor, String identifier, Object data) { - actorDelegate.applyState(clientActor, identifier, data); - LOG.info("{}: applyState called", persistenceId()); - } + List snapshotUnappliedEntries = new ArrayList<>(); + ReplicatedLogEntry entry1 = new SimpleReplicatedLogEntry(4, 1, new MockRaftActorContext.MockPayload("E")); + snapshotUnappliedEntries.add(entry1); - @Override - @Nonnull - protected RaftActorRecoveryCohort getRaftActorRecoveryCohort() { - return this; - } + int lastAppliedDuringSnapshotCapture = 3; + int lastIndexDuringSnapshotCapture = 4; - @Override - protected RaftActorSnapshotCohort getRaftActorSnapshotCohort() { - return this; - } + // 4 messages as part of snapshot, which are applied to state + MockSnapshotState snapshotState = new MockSnapshotState(Arrays.asList( + new MockRaftActorContext.MockPayload("A"), + new MockRaftActorContext.MockPayload("B"), + new MockRaftActorContext.MockPayload("C"), + new MockRaftActorContext.MockPayload("D"))); - @Override - public void startLogRecoveryBatch(int maxBatchSize) { - } + Snapshot snapshot = Snapshot.create(snapshotState, snapshotUnappliedEntries, lastIndexDuringSnapshotCapture, 1, + lastAppliedDuringSnapshotCapture, 1, -1, null, null); + InMemorySnapshotStore.addSnapshot(persistenceId, snapshot); - @Override - public void appendRecoveredLogEntry(Payload data) { - state.add(data); - } + // add more entries after snapshot is taken + List entries = new ArrayList<>(); + ReplicatedLogEntry entry2 = new SimpleReplicatedLogEntry(5, 1, new MockRaftActorContext.MockPayload("F", 2)); + ReplicatedLogEntry entry3 = new SimpleReplicatedLogEntry(6, 1, new MockRaftActorContext.MockPayload("G", 3)); + ReplicatedLogEntry entry4 = new SimpleReplicatedLogEntry(7, 1, new MockRaftActorContext.MockPayload("H", 4)); + entries.add(entry2); + entries.add(entry3); + entries.add(entry4); - @Override - public void applyCurrentLogRecoveryBatch() { - } + final int lastAppliedToState = 5; + final int lastIndex = 7; - @Override - protected void onRecoveryComplete() { - actorDelegate.onRecoveryComplete(); - recoveryComplete.countDown(); - } + InMemoryJournal.addEntry(persistenceId, 5, entry2); + // 2 entries are applied to state besides the 4 entries in snapshot + InMemoryJournal.addEntry(persistenceId, 6, new ApplyJournalEntries(lastAppliedToState)); + InMemoryJournal.addEntry(persistenceId, 7, entry3); + InMemoryJournal.addEntry(persistenceId, 8, entry4); - @Override - protected void initializeBehavior() { - super.initializeBehavior(); - initializeBehaviorComplete.countDown(); - } + // kill the actor + followerActor.tell(PoisonPill.getInstance(), null); + kit.expectMsgClass(Duration.ofSeconds(5), Terminated.class); - @Override - public void applyRecoverySnapshot(byte[] bytes) { - recoveryCohortDelegate.applyRecoverySnapshot(bytes); - try { - Object data = toObject(bytes); - if (data instanceof List) { - state.addAll((List) data); - } - } catch (Exception e) { - e.printStackTrace(); - } - } + kit.unwatch(followerActor); - @Override - public void createSnapshot(ActorRef actorRef) { - LOG.info("{}: createSnapshot called", persistenceId()); - snapshotCohortDelegate.createSnapshot(actorRef); - } + //reinstate the actor + TestActorRef ref = factory.createTestActor( + MockRaftActor.props(persistenceId, peerAddresses, config)); - @Override - public void applySnapshot(byte [] snapshot) { - LOG.info("{}: applySnapshot called", persistenceId()); - snapshotCohortDelegate.applySnapshot(snapshot); - } + MockRaftActor mockRaftActor = ref.underlyingActor(); - @Override - protected void onStateChanged() { - actorDelegate.onStateChanged(); - } + mockRaftActor.waitForRecoveryComplete(); - @Override - protected Optional getRoleChangeNotifier() { - return Optional.fromNullable(roleChangeNotifier); - } + 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, mockRaftActor.getState().size()); - @Override public String persistenceId() { - return this.getId(); - } + mockRaftActor.waitForInitializeBehaviorComplete(); - private Object toObject(byte[] bs) throws ClassNotFoundException, IOException { - Object obj = null; - ByteArrayInputStream bis = null; - ObjectInputStream ois = null; - try { - bis = new ByteArrayInputStream(bs); - ois = new ObjectInputStream(bis); - obj = ois.readObject(); - } finally { - if (bis != null) { - bis.close(); - } - if (ois != null) { - ois.close(); - } - } - return obj; - } + assertEquals("getRaftState", RaftState.Follower, mockRaftActor.getRaftState()); - public ReplicatedLog getReplicatedLog(){ - return this.getRaftActorContext().getReplicatedLog(); - } + TEST_LOG.info("testRaftActorRecoveryWithPersistenceEnabled ending"); } + @Test + public void testRaftActorRecoveryWithPersistenceDisabled() { + String persistenceId = factory.generateActorId("follower-"); - public 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(); - - - } + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); - protected void waitUntilLeader(){ - waitUntilLeader(raftActor); - } + config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); - public static 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(); - } + TestActorRef ref = factory.createTestActor(MockRaftActor.props(persistenceId, + ImmutableMap.builder().put("member1", "address").build(), + config, createProvider()), persistenceId); + MockRaftActor mockRaftActor = ref.underlyingActor(); - Uninterruptibles.sleepUninterruptibly(50, TimeUnit.MILLISECONDS); - } + mockRaftActor.waitForRecoveryComplete(); - Assert.fail("Leader not found for actorRef " + actorRef.path()); - } + mockRaftActor.waitForInitializeBehaviorComplete(); + assertEquals("getRaftState", RaftState.Follower, mockRaftActor.getRaftState()); } - @Test - public void testConstruction() { - new RaftActorTestKit(getSystem(), "testConstruction").waitUntilLeader(); + public void testUpdateElectionTermPersistedWithPersistenceDisabled() { + final TestKit kit = new TestKit(getSystem()); + String persistenceId = factory.generateActorId("follower-"); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + config.setHeartBeatInterval(new FiniteDuration(100, TimeUnit.MILLISECONDS)); + config.setElectionTimeoutFactor(1); + + InMemoryJournal.addWriteMessagesCompleteLatch(persistenceId, 1); + + TestActorRef ref = factory.createTestActor(MockRaftActor.props(persistenceId, + ImmutableMap.builder().put("member1", "address").build(), + config, createProvider()) + .withDispatcher(Dispatchers.DefaultDispatcherId()), persistenceId); + + InMemoryJournal.waitForWriteMessagesComplete(persistenceId); + List entries = InMemoryJournal.get(persistenceId, UpdateElectionTerm.class); + assertEquals("UpdateElectionTerm entries", 1, entries.size()); + final UpdateElectionTerm updateEntry = entries.get(0); + + factory.killActor(ref, kit); + + config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + ref = factory.createTestActor(MockRaftActor.props(persistenceId, + ImmutableMap.builder().put("member1", "address").build(), config, + createProvider()).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()); } @Test - public void testFindLeaderWhenLeaderIsSelf(){ - RaftActorTestKit kit = new RaftActorTestKit(getSystem(), "testFindLeader"); - kit.waitUntilLeader(); - } + public void testRaftActorForwardsToRaftActorRecoverySupport() { + String persistenceId = factory.generateActorId("leader-"); - @Test - public void testRaftActorRecovery() throws Exception { - new JavaTestKit(getSystem()) {{ - 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 = factory.createActor(MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config)), persistenceId); - - watch(followerActor); - - List snapshotUnappliedEntries = new ArrayList<>(); - ReplicatedLogEntry entry1 = new MockRaftActorContext.MockReplicatedLogEntry(1, 4, - new MockRaftActorContext.MockPayload("E")); - snapshotUnappliedEntries.add(entry1); - - 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"))); - - Snapshot snapshot = Snapshot.create(snapshotBytes.toByteArray(), - snapshotUnappliedEntries, lastIndexDuringSnapshotCapture, 1, - lastAppliedDuringSnapshotCapture, 1); - 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", 2)); - ReplicatedLogEntry entry3 = new MockRaftActorContext.MockReplicatedLogEntry(1, 6, - new MockRaftActorContext.MockPayload("G", 3)); - ReplicatedLogEntry entry4 = new MockRaftActorContext.MockReplicatedLogEntry(1, 7, - new MockRaftActorContext.MockPayload("H", 4)); - entries.add(entry2); - entries.add(entry3); - entries.add(entry4); - - int lastAppliedToState = 5; - int lastIndex = 7; - - InMemoryJournal.addEntry(persistenceId, 5, entry2); - // 2 entries are applied to state besides the 4 entries in snapshot - 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); - expectMsgClass(duration("5 seconds"), Terminated.class); - - unwatch(followerActor); - - //reinstate the actor - TestActorRef ref = factory.createTestActor( - MockRaftActor.props(persistenceId, Collections.emptyMap(), - Optional.of(config))); - - ref.underlyingActor().waitForRecoveryComplete(); - - RaftActorContext context = ref.underlyingActor().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()); - }}; - } + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); - @Test - public void testRaftActorRecoveryWithPreLithuimApplyLogEntries() throws Exception { - new JavaTestKit(getSystem()) {{ - String persistenceId = factory.generateActorId("leader-"); - - DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); - config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); - - // Setup the persisted journal with some entries - ReplicatedLogEntry entry0 = new MockRaftActorContext.MockReplicatedLogEntry(1, 0, - new MockRaftActorContext.MockPayload("zero")); - ReplicatedLogEntry entry1 = new MockRaftActorContext.MockReplicatedLogEntry(1, 1, - new MockRaftActorContext.MockPayload("oen")); - ReplicatedLogEntry entry2 = new MockRaftActorContext.MockReplicatedLogEntry(1, 2, - new MockRaftActorContext.MockPayload("two")); - - long seqNr = 1; - InMemoryJournal.addEntry(persistenceId, seqNr++, entry0); - InMemoryJournal.addEntry(persistenceId, seqNr++, entry1); - InMemoryJournal.addEntry(persistenceId, seqNr++, new ApplyLogEntries(1)); - InMemoryJournal.addEntry(persistenceId, seqNr++, entry2); - - int lastAppliedToState = 1; - int lastIndex = 2; - - //reinstate the actor - TestActorRef leaderActor = factory.createTestActor( - MockRaftActor.props(persistenceId, Collections.emptyMap(), - Optional.of(config))); - - leaderActor.underlyingActor().waitForRecoveryComplete(); - - RaftActorContext context = leaderActor.underlyingActor().getRaftActorContext(); - assertEquals("Journal log size", 3, context.getReplicatedLog().size()); - assertEquals("Last index", lastIndex, context.getReplicatedLog().lastIndex()); - assertEquals("Last applied", lastAppliedToState, context.getLastApplied()); - assertEquals("Commit index", lastAppliedToState, context.getCommitIndex()); - }}; - } + config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); - /** - * This test verifies that when recovery is applicable (typically when persistence is true) the RaftActor does - * process recovery messages - * - * @throws Exception - */ + TestActorRef mockActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, + Collections.emptyMap(), config), persistenceId); - @Test - public void testHandleRecoveryWhenDataPersistenceRecoveryApplicable() throws Exception { - new JavaTestKit(getSystem()) { - { - String persistenceId = factory.generateActorId("leader-"); + 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)); + RaftActorRecoverySupport mockSupport = mock(RaftActorRecoverySupport.class); + mockRaftActor.setRaftActorRecoverySupport(mockSupport); - TestActorRef mockActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config)), persistenceId); + Snapshot snapshot = Snapshot.create(ByteState.of(new byte[]{1}), + Collections.emptyList(), 3, 1, 3, 1, -1, null, null); + SnapshotOffer snapshotOffer = new SnapshotOffer(new SnapshotMetadata("test", 6, 12345), snapshot); + mockRaftActor.handleRecover(snapshotOffer); - MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); + ReplicatedLogEntry logEntry = new SimpleReplicatedLogEntry(1, 1, new MockRaftActorContext.MockPayload("1", 5)); + mockRaftActor.handleRecover(logEntry); - // Wait for akka's recovery to complete so it doesn't interfere. - mockRaftActor.waitForRecoveryComplete(); + ApplyJournalEntries applyJournalEntries = new ApplyJournalEntries(2); + mockRaftActor.handleRecover(applyJournalEntries); - ByteString snapshotBytes = fromObject(Arrays.asList( - new MockRaftActorContext.MockPayload("A"), - new MockRaftActorContext.MockPayload("B"), - new MockRaftActorContext.MockPayload("C"), - new MockRaftActorContext.MockPayload("D"))); + DeleteEntries deleteEntries = new DeleteEntries(1); + mockRaftActor.handleRecover(deleteEntries); - Snapshot snapshot = Snapshot.create(snapshotBytes.toByteArray(), - Lists.newArrayList(), 3, 1, 3, 1); + UpdateElectionTerm updateElectionTerm = new UpdateElectionTerm(5, "member2"); + mockRaftActor.handleRecover(updateElectionTerm); - 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(deleteEntries), any(PersistentDataProvider.class)); + verify(mockSupport).handleRecoveryMessage(same(updateElectionTerm), any(PersistentDataProvider.class)); + } - verify(mockRaftActor.recoveryCohortDelegate).applyRecoverySnapshot(eq(snapshotBytes.toByteArray())); + @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", 1, replicatedLog.size()); + RaftActorSnapshotMessageSupport mockSupport = mock(RaftActorSnapshotMessageSupport.class); - mockRaftActor.onReceiveRecover(new ReplicatedLogImplEntry(1, 1, new MockRaftActorContext.MockPayload("A"))); + TestActorRef mockActorRef = factory.createTestActor(MockRaftActor.builder().id(persistenceId) + .config(config).snapshotMessageSupport(mockSupport).props()); - assertEquals("add replicated log entry", 2, replicatedLog.size()); + MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); - mockRaftActor.onReceiveRecover(new ApplyJournalEntries(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), any(ActorRef.class)); + mockRaftActor.handleCommand(applySnapshot); - // 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)); + CaptureSnapshotReply captureSnapshotReply = new CaptureSnapshotReply(ByteState.empty(), Optional.empty()); + doReturn(true).when(mockSupport).handleSnapshotMessage(same(captureSnapshotReply), any(ActorRef.class)); + mockRaftActor.handleCommand(captureSnapshotReply); - assertEquals("remove log entries", 1, replicatedLog.size()); + SaveSnapshotSuccess saveSnapshotSuccess = new SaveSnapshotSuccess(new SnapshotMetadata("", 0L, 0L)); + doReturn(true).when(mockSupport).handleSnapshotMessage(same(saveSnapshotSuccess), any(ActorRef.class)); + mockRaftActor.handleCommand(saveSnapshotSuccess); - mockRaftActor.onReceiveRecover(new UpdateElectionTerm(10, "foobar")); + SaveSnapshotFailure saveSnapshotFailure = new SaveSnapshotFailure(new SnapshotMetadata("", 0L, 0L), + new Throwable()); + doReturn(true).when(mockSupport).handleSnapshotMessage(same(saveSnapshotFailure), any(ActorRef.class)); + mockRaftActor.handleCommand(saveSnapshotFailure); - assertEquals("election term", 10, mockRaftActor.getRaftActorContext().getTermInformation().getCurrentTerm()); - assertEquals("voted for", "foobar", mockRaftActor.getRaftActorContext().getTermInformation().getVotedFor()); + doReturn(true).when(mockSupport).handleSnapshotMessage(same(RaftActorSnapshotMessageSupport.COMMIT_SNAPSHOT), + any(ActorRef.class)); + mockRaftActor.handleCommand(RaftActorSnapshotMessageSupport.COMMIT_SNAPSHOT); - mockRaftActor.onReceiveRecover(mock(RecoveryCompleted.class)); + doReturn(true).when(mockSupport).handleSnapshotMessage(same(GetSnapshot.INSTANCE), any(ActorRef.class)); + mockRaftActor.handleCommand(GetSnapshot.INSTANCE); - }}; + verify(mockSupport).handleSnapshotMessage(same(applySnapshot), any(ActorRef.class)); + verify(mockSupport).handleSnapshotMessage(same(captureSnapshotReply), any(ActorRef.class)); + verify(mockSupport).handleSnapshotMessage(same(saveSnapshotSuccess), any(ActorRef.class)); + verify(mockSupport).handleSnapshotMessage(same(saveSnapshotFailure), any(ActorRef.class)); + verify(mockSupport).handleSnapshotMessage(same(RaftActorSnapshotMessageSupport.COMMIT_SNAPSHOT), + any(ActorRef.class)); + verify(mockSupport).handleSnapshotMessage(same(GetSnapshot.INSTANCE), any(ActorRef.class)); } - /** - * This test verifies that when recovery is not applicable (typically when persistence is false) the RaftActor does - * not process recovery messages - * - * @throws Exception - */ + @SuppressWarnings("unchecked") @Test - public void testHandleRecoveryWhenDataPersistenceRecoveryNotApplicable() throws Exception { - new JavaTestKit(getSystem()) { - { - String persistenceId = factory.generateActorId("leader-"); - - DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); - - config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + public void testApplyJournalEntriesCallsDataPersistence() throws Exception { + String persistenceId = factory.generateActorId("leader-"); - TestActorRef mockActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config), new DataPersistenceProviderMonitor()), persistenceId); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); - MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); + config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); - // Wait for akka's recovery to complete so it doesn't interfere. - mockRaftActor.waitForRecoveryComplete(); + DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); - ByteString snapshotBytes = fromObject(Arrays.asList( - new MockRaftActorContext.MockPayload("A"), - new MockRaftActorContext.MockPayload("B"), - new MockRaftActorContext.MockPayload("C"), - new MockRaftActorContext.MockPayload("D"))); + TestActorRef mockActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, + Collections.emptyMap(), config, dataPersistenceProvider), persistenceId); - Snapshot snapshot = Snapshot.create(snapshotBytes.toByteArray(), - Lists.newArrayList(), 3, 1, 3, 1); + MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); - mockRaftActor.onReceiveRecover(new SnapshotOffer(new SnapshotMetadata(persistenceId, 100, 100), snapshot)); + mockRaftActor.waitForInitializeBehaviorComplete(); - verify(mockRaftActor.recoveryCohortDelegate, times(0)).applyRecoverySnapshot(any(byte[].class)); + mockRaftActor.waitUntilLeader(); - mockRaftActor.onReceiveRecover(new ReplicatedLogImplEntry(0, 1, new MockRaftActorContext.MockPayload("A"))); + mockRaftActor.handleCommand(new ApplyJournalEntries(10)); - ReplicatedLog replicatedLog = mockRaftActor.getReplicatedLog(); + verify(dataPersistenceProvider).persistAsync(any(ApplyJournalEntries.class), any(Procedure.class)); + } - assertEquals("add replicated log entry", 0, replicatedLog.size()); + @Test + public void testApplyState() { + String persistenceId = factory.generateActorId("leader-"); - mockRaftActor.onReceiveRecover(new ReplicatedLogImplEntry(1, 1, new MockRaftActorContext.MockPayload("A"))); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); - assertEquals("add replicated log entry", 0, replicatedLog.size()); + config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); - mockRaftActor.onReceiveRecover(new ApplyJournalEntries(1)); + DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); - assertEquals("commit index -1", -1, mockRaftActor.getRaftActorContext().getCommitIndex()); + TestActorRef mockActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, + Collections.emptyMap(), config, dataPersistenceProvider), persistenceId); - mockRaftActor.onReceiveRecover(new RaftActor.DeleteEntries(2)); + MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); - assertEquals("remove log entries", 0, replicatedLog.size()); + mockRaftActor.waitForInitializeBehaviorComplete(); - mockRaftActor.onReceiveRecover(new UpdateElectionTerm(10, "foobar")); + ReplicatedLogEntry entry = new SimpleReplicatedLogEntry(5, 1, new MockRaftActorContext.MockPayload("F")); - assertNotEquals("election term", 10, mockRaftActor.getRaftActorContext().getTermInformation().getCurrentTerm()); - assertNotEquals("voted for", "foobar", mockRaftActor.getRaftActorContext().getTermInformation().getVotedFor()); + final Identifier id = new MockIdentifier("apply-state"); + mockRaftActor.getRaftActorContext().getApplyStateConsumer().accept(new ApplyState(mockActorRef, id, entry)); - mockRaftActor.onReceiveRecover(mock(RecoveryCompleted.class)); - }}; + verify(mockRaftActor.actorDelegate).applyState(eq(mockActorRef), eq(id), any()); } - @Test - public void testUpdatingElectionTermCallsDataPersistence() throws Exception { - new JavaTestKit(getSystem()) { - { - 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); - - TestActorRef mockActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config), dataPersistenceProviderMonitor), persistenceId); - - MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); - - mockRaftActor.waitForInitializeBehaviorComplete(); + public void testRaftRoleChangeNotifierWhenRaftActorHasNoPeers() throws Exception { + ActorRef notifierActor = factory.createActor(MessageCollectorActor.props()); + MessageCollectorActor.waitUntilReady(notifierActor); - mockRaftActor.getRaftActorContext().getTermInformation().updateAndPersist(10, "foobar"); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + long heartBeatInterval = 100; + config.setHeartBeatInterval(FiniteDuration.create(heartBeatInterval, TimeUnit.MILLISECONDS)); + config.setElectionTimeoutFactor(20); - assertEquals("Persist called", true, persistLatch.await(5, TimeUnit.SECONDS)); - } - }; - } + String persistenceId = factory.generateActorId("notifier-"); - @Test - public void testAddingReplicatedLogEntryCallsDataPersistence() throws Exception { - new JavaTestKit(getSystem()) { - { - String persistenceId = factory.generateActorId("leader-"); + final TestActorRef raftActorRef = factory.createTestActor(MockRaftActor.builder() + .id(persistenceId).config(config).roleChangeNotifier(notifierActor).dataPersistenceProvider( + createProvider()).props().withDispatcher(Dispatchers.DefaultDispatcherId()), + persistenceId); - DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + List matches = MessageCollectorActor.expectMatching(notifierActor, RoleChanged.class, 3); - config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); - DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.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()); - TestActorRef mockActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config), dataPersistenceProvider), persistenceId); + // 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()); - MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); + // 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()); - mockRaftActor.waitForInitializeBehaviorComplete(); + LeaderStateChanged leaderStateChange = MessageCollectorActor.expectFirstMatching( + notifierActor, LeaderStateChanged.class); - MockRaftActorContext.MockReplicatedLogEntry logEntry = new MockRaftActorContext.MockReplicatedLogEntry(10, 10, mock(Payload.class)); + assertEquals(raftRoleChanged.getMemberId(), leaderStateChange.getLeaderId()); + assertEquals(MockRaftActor.PAYLOAD_VERSION, leaderStateChange.getLeaderPayloadVersion()); - mockRaftActor.getRaftActorContext().getReplicatedLog().appendAndPersist(logEntry); + MessageCollectorActor.clearMessages(notifierActor); - verify(dataPersistenceProvider).persist(eq(logEntry), any(Procedure.class)); + MockRaftActor raftActor = raftActorRef.underlyingActor(); + final String newLeaderId = "new-leader"; + final short newLeaderVersion = 6; + Follower follower = new Follower(raftActor.getRaftActorContext()) { + @Override + public RaftActorBehavior handleMessage(final ActorRef sender, final Object message) { + setLeaderId(newLeaderId); + setLeaderPayloadVersion(newLeaderVersion); + return this; } }; - } - @Test - public void testRemovingReplicatedLogEntryCallsDataPersistence() throws Exception { - new JavaTestKit(getSystem()) { - { - String persistenceId = factory.generateActorId("leader-"); - - DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); - - 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 = factory.createTestActor(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(); + MessageCollectorActor.clearMessages(notifierActor); - mockRaftActor.waitForInitializeBehaviorComplete(); + raftActor.handleCommand("any"); - mockRaftActor.waitUntilLeader(); + leaderStateChange = MessageCollectorActor.expectFirstMatching(notifierActor, LeaderStateChanged.class); + assertEquals(persistenceId, leaderStateChange.getMemberId()); + assertEquals(newLeaderId, leaderStateChange.getLeaderId()); + assertEquals(newLeaderVersion, leaderStateChange.getLeaderPayloadVersion()); - mockRaftActor.getReplicatedLog().appendAndPersist(new MockRaftActorContext.MockReplicatedLogEntry(1, 0, mock(Payload.class))); + MessageCollectorActor.clearMessages(notifierActor); - mockRaftActor.getRaftActorContext().getReplicatedLog().removeFromAndPersist(0); + raftActor.handleCommand("any"); - verify(dataPersistenceProvider, times(3)).persist(anyObject(), any(Procedure.class)); - } - }; + Uninterruptibles.sleepUninterruptibly(505, TimeUnit.MILLISECONDS); + leaderStateChange = MessageCollectorActor.getFirstMatching(notifierActor, LeaderStateChanged.class); + assertNull(leaderStateChange); } @Test - public void testApplyJournalEntriesCallsDataPersistence() throws Exception { - new JavaTestKit(getSystem()) { - { - String persistenceId = factory.generateActorId("leader-"); - - DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); - - config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); - - DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); - - TestActorRef mockActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config), dataPersistenceProvider), persistenceId); - - MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); - - mockRaftActor.waitForInitializeBehaviorComplete(); - - mockRaftActor.waitUntilLeader(); + public void testRaftRoleChangeNotifierWhenRaftActorHasPeers() throws Exception { + ActorRef notifierActor = factory.createActor(MessageCollectorActor.props()); + MessageCollectorActor.waitUntilReady(notifierActor); + + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + long heartBeatInterval = 100; + config.setHeartBeatInterval(FiniteDuration.create(heartBeatInterval, TimeUnit.MILLISECONDS)); + config.setElectionTimeoutFactor(1); + + String persistenceId = factory.generateActorId("notifier-"); + + factory.createActor(MockRaftActor.builder().id(persistenceId) + .peerAddresses(ImmutableMap.of("leader", "fake/path")) + .config(config).roleChangeNotifier(notifierActor).props()); + + 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); + } - mockRaftActor.onReceiveCommand(new ApplyJournalEntries(10)); + assertNotNull(matches); + assertEquals(2, matches.size()); - verify(dataPersistenceProvider, times(2)).persist(anyObject(), any(Procedure.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()); - } - - }; + // 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 { - new JavaTestKit(getSystem()) { - { - String persistenceId = factory.generateActorId("leader-"); + public void testFakeSnapshotsForLeaderWithInRealSnapshots() throws Exception { + final String persistenceId = factory.generateActorId("leader-"); + final String follower1Id = factory.generateActorId("follower-"); - DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + ActorRef followerActor1 = factory.createActor(MessageCollectorActor.props()); - config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS)); - DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); + DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); - TestActorRef mockActorRef = factory.createTestActor( - 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, config, dataPersistenceProvider), persistenceId); - mockRaftActor.waitForInitializeBehaviorComplete(); + MockRaftActor leaderActor = mockActorRef.underlyingActor(); - ByteString snapshotBytes = fromObject(Arrays.asList( - new MockRaftActorContext.MockPayload("A"), - new MockRaftActorContext.MockPayload("B"), - new MockRaftActorContext.MockPayload("C"), - new MockRaftActorContext.MockPayload("D"))); + leaderActor.getRaftActorContext().setCommitIndex(4); + leaderActor.getRaftActorContext().setLastApplied(4); + leaderActor.getRaftActorContext().getTermInformation().update(1, persistenceId); - RaftActorContext raftActorContext = mockRaftActor.getRaftActorContext(); + leaderActor.waitForInitializeBehaviorComplete(); - raftActorContext.getSnapshotManager().capture( - new MockRaftActorContext.MockReplicatedLogEntry(1, -1, - new MockRaftActorContext.MockPayload("D")), -1); + // create 8 entries in the log - 0 to 4 are applied and will get picked up as part of the capture snapshot - mockRaftActor.setCurrentBehavior(new Leader(raftActorContext)); + Leader leader = new Leader(leaderActor.getRaftActorContext()); + leaderActor.setCurrentBehavior(leader); + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); - mockRaftActor.onReceiveCommand(new CaptureSnapshotReply(snapshotBytes.toByteArray())); + MockRaftActorContext.MockReplicatedLogBuilder logBuilder = new MockRaftActorContext.MockReplicatedLogBuilder(); + leaderActor.getRaftActorContext().setReplicatedLog(logBuilder.createEntries(0, 8, 1).build()); - verify(dataPersistenceProvider).saveSnapshot(anyObject()); + assertEquals(8, leaderActor.getReplicatedLog().size()); - } - }; - } + leaderActor.getRaftActorContext().getSnapshotManager().capture( + new SimpleReplicatedLogEntry(6, 1, new MockRaftActorContext.MockPayload("x")), 4); - @Test - public void testSaveSnapshotSuccessCallsDataPersistence() throws Exception { - new JavaTestKit(getSystem()) { - { - String persistenceId = factory.generateActorId("leader-"); + verify(leaderActor.snapshotCohortDelegate).createSnapshot(any(), any()); - DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + assertEquals(8, leaderActor.getReplicatedLog().size()); - config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); + //fake snapshot on index 5 + leaderActor.handleCommand(new AppendEntriesReply(follower1Id, 1, true, 5, 1, (short)0)); - DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); + assertEquals(8, leaderActor.getReplicatedLog().size()); - TestActorRef mockActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, - ImmutableMap.of("leader", "fake/path"), Optional.of(config), dataPersistenceProvider), persistenceId); + //fake snapshot on index 6 + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); + leaderActor.handleCommand(new AppendEntriesReply(follower1Id, 1, true, 6, 1, (short)0)); + assertEquals(8, leaderActor.getReplicatedLog().size()); - MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); - mockRaftActor.waitForInitializeBehaviorComplete(); - MockRaftActorContext.MockReplicatedLogEntry lastEntry = new MockRaftActorContext.MockReplicatedLogEntry(1, 4, mock(Payload.class)); + assertEquals(8, leaderActor.getReplicatedLog().size()); - 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(lastEntry); + MockSnapshotState snapshotState = new MockSnapshotState(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"))); - ByteString snapshotBytes = fromObject(Arrays.asList( - new MockRaftActorContext.MockPayload("A"), - new MockRaftActorContext.MockPayload("B"), - new MockRaftActorContext.MockPayload("C"), - new MockRaftActorContext.MockPayload("D"))); + leaderActor.getRaftActorContext().getSnapshotManager().persist(snapshotState, Optional.empty(), + Runtime.getRuntime().totalMemory()); - RaftActorContext raftActorContext = mockRaftActor.getRaftActorContext(); - mockRaftActor.setCurrentBehavior(new Follower(raftActorContext)); + assertTrue(leaderActor.getRaftActorContext().getSnapshotManager().isCapturing()); - long replicatedToAllIndex = 1; + // The commit is needed to complete the snapshot creation process + leaderActor.getRaftActorContext().getSnapshotManager().commit(-1, -1); - mockRaftActor.getRaftActorContext().getSnapshotManager().capture(lastEntry, replicatedToAllIndex); + // capture snapshot reply should remove the snapshotted entries only + assertEquals(3, leaderActor.getReplicatedLog().size()); + assertEquals(7, leaderActor.getReplicatedLog().lastIndex()); - verify(mockRaftActor.snapshotCohortDelegate).createSnapshot(any(ActorRef.class)); + // add another non-replicated entry + leaderActor.getReplicatedLog().append( + new SimpleReplicatedLogEntry(8, 1, new MockRaftActorContext.MockPayload("foo-8"))); - mockRaftActor.onReceiveCommand(new CaptureSnapshotReply(snapshotBytes.toByteArray())); + //fake snapshot on index 7, since lastApplied = 7 , we would keep the last applied + leaderActor.handleCommand(new AppendEntriesReply(follower1Id, 1, true, 7, 1, (short)0)); + assertEquals(2, leaderActor.getReplicatedLog().size()); + assertEquals(8, leaderActor.getReplicatedLog().lastIndex()); + } - mockRaftActor.onReceiveCommand(new SaveSnapshotSuccess(new SnapshotMetadata("foo", 100, 100))); + @Test + public void testFakeSnapshotsForFollowerWithInRealSnapshots() throws Exception { + final String persistenceId = factory.generateActorId("follower-"); + final String leaderId = factory.generateActorId("leader-"); - verify(dataPersistenceProvider).deleteSnapshots(any(SnapshotSelectionCriteria.class)); + ActorRef leaderActor1 = factory.createActor(MessageCollectorActor.props()); - verify(dataPersistenceProvider).deleteMessages(100); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS)); - assertEquals(3, mockRaftActor.getReplicatedLog().size()); - assertEquals(1, mockRaftActor.getCurrentBehavior().getReplicatedToAllIndex()); + DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); - assertNotNull(mockRaftActor.getReplicatedLog().get(2)); - assertNotNull(mockRaftActor.getReplicatedLog().get(3)); - assertNotNull(mockRaftActor.getReplicatedLog().get(4)); + Map peerAddresses = new HashMap<>(); + peerAddresses.put(leaderId, leaderActor1.path().toString()); - // Index 2 will not be in the log because it was removed due to snapshotting - assertNull(mockRaftActor.getReplicatedLog().get(1)); - assertNull(mockRaftActor.getReplicatedLog().get(0)); + TestActorRef mockActorRef = factory.createTestActor( + MockRaftActor.props(persistenceId, peerAddresses, config, dataPersistenceProvider), persistenceId); - } - }; - } + MockRaftActor followerActor = mockActorRef.underlyingActor(); + followerActor.getRaftActorContext().setCommitIndex(4); + followerActor.getRaftActorContext().setLastApplied(4); + followerActor.getRaftActorContext().getTermInformation().update(1, persistenceId); - @Test - public void testApplyState() throws Exception { + followerActor.waitForInitializeBehaviorComplete(); - new JavaTestKit(getSystem()) { - { - String persistenceId = factory.generateActorId("leader-"); - DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + Follower follower = new Follower(followerActor.getRaftActorContext()); + followerActor.setCurrentBehavior(follower); + assertEquals(RaftState.Follower, followerActor.getCurrentBehavior().state()); - config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + // 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()); - DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); + // log has indices 0-5 + assertEquals(6, followerActor.getReplicatedLog().size()); - TestActorRef mockActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config), dataPersistenceProvider), persistenceId); + //snapshot on 4 + followerActor.getRaftActorContext().getSnapshotManager().capture( + new SimpleReplicatedLogEntry(5, 1, new MockRaftActorContext.MockPayload("D")), 4); - MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); + verify(followerActor.snapshotCohortDelegate).createSnapshot(any(), any()); - mockRaftActor.waitForInitializeBehaviorComplete(); + assertEquals(6, followerActor.getReplicatedLog().size()); - ReplicatedLogEntry entry = new MockRaftActorContext.MockReplicatedLogEntry(1, 5, - new MockRaftActorContext.MockPayload("F")); + //fake snapshot on index 6 + List entries = Arrays.asList( + (ReplicatedLogEntry) new SimpleReplicatedLogEntry(6, 1, new MockRaftActorContext.MockPayload("foo-6"))); + followerActor.handleCommand(new AppendEntries(1, leaderId, 5, 1, entries, 5, 5, (short)0)); + assertEquals(7, followerActor.getReplicatedLog().size()); - mockRaftActor.onReceiveCommand(new ApplyState(mockActorRef, "apply-state", entry)); + //fake snapshot on index 7 + assertEquals(RaftState.Follower, followerActor.getCurrentBehavior().state()); - verify(mockRaftActor.actorDelegate).applyState(eq(mockActorRef), eq("apply-state"), anyObject()); + entries = Arrays.asList((ReplicatedLogEntry) new SimpleReplicatedLogEntry(7, 1, + new MockRaftActorContext.MockPayload("foo-7"))); + followerActor.handleCommand(new AppendEntries(1, leaderId, 6, 1, entries, 6, 6, (short) 0)); + assertEquals(8, followerActor.getReplicatedLog().size()); - } - }; - } + assertEquals(RaftState.Follower, followerActor.getCurrentBehavior().state()); - @Test - public void testApplySnapshot() throws Exception { - new JavaTestKit(getSystem()) { - { - String persistenceId = factory.generateActorId("leader-"); - DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + 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.handleCommand(new CaptureSnapshotReply(ByteState.of(snapshotBytes.toByteArray()), + Optional.empty())); + assertTrue(followerActor.getRaftActorContext().getSnapshotManager().isCapturing()); - config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + // The commit is needed to complete the snapshot creation process + followerActor.getRaftActorContext().getSnapshotManager().commit(-1, -1); - DataPersistenceProviderMonitor dataPersistenceProviderMonitor = new DataPersistenceProviderMonitor(); + // 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()); - TestActorRef mockActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config), dataPersistenceProviderMonitor), persistenceId); + entries = Arrays.asList((ReplicatedLogEntry) new SimpleReplicatedLogEntry(8, 1, + new MockRaftActorContext.MockPayload("foo-7"))); + // send an additional entry 8 with leaderCommit = 7 + followerActor.handleCommand(new AppendEntries(1, leaderId, 7, 1, entries, 7, 7, (short) 0)); - MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); + // 7 and 8, as lastapplied is 7 + assertEquals(2, followerActor.getReplicatedLog().size()); + } - mockRaftActor.waitForInitializeBehaviorComplete(); + @Test + public void testFakeSnapshotsForLeaderWithInInitiateSnapshots() throws Exception { + final String persistenceId = factory.generateActorId("leader-"); + final String follower1Id = factory.generateActorId("follower-"); + final String follower2Id = factory.generateActorId("follower-"); + + 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)); + config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS)); + + DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); + + Map peerAddresses = new HashMap<>(); + peerAddresses.put(follower1Id, followerActor1.path().toString()); + peerAddresses.put(follower2Id, followerActor2.path().toString()); + + TestActorRef mockActorRef = factory.createTestActor( + MockRaftActor.props(persistenceId, peerAddresses, config, dataPersistenceProvider), persistenceId); + + MockRaftActor leaderActor = mockActorRef.underlyingActor(); + leaderActor.getRaftActorContext().setCommitIndex(9); + leaderActor.getRaftActorContext().setLastApplied(9); + leaderActor.getRaftActorContext().getTermInformation().update(1, persistenceId); + + leaderActor.waitForInitializeBehaviorComplete(); + + Leader leader = new Leader(leaderActor.getRaftActorContext()); + leaderActor.setCurrentBehavior(leader); + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); + + // 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()); + + leaderActor.handleCommand(new AppendEntriesReply(follower1Id, 1, true, 9, 1, (short) 0)); + assertEquals(5, leaderActor.getReplicatedLog().size()); + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); + + // set the 2nd follower nextIndex to 1 which has been snapshotted + leaderActor.handleCommand(new AppendEntriesReply(follower2Id, 1, true, 0, 1, (short)0)); + assertEquals(5, leaderActor.getReplicatedLog().size()); + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); + + // simulate a real snapshot + leaderActor.handleCommand(SendHeartBeat.INSTANCE); + 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()); + + + //reply from a slow follower does not initiate a fake snapshot + leaderActor.handleCommand(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("foo-0"), + new MockRaftActorContext.MockPayload("foo-1"), + new MockRaftActorContext.MockPayload("foo-2"), + new MockRaftActorContext.MockPayload("foo-3"), + new MockRaftActorContext.MockPayload("foo-4"))); + leaderActor.handleCommand(new CaptureSnapshotReply(ByteState.of(snapshotBytes.toByteArray()), + Optional.empty())); + 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.handleCommand(new AppendEntriesReply(follower2Id, 1, true, 5, 1, (short) 0)); + assertEquals(0, leaderActor.getReplicatedLog().size()); + } - ReplicatedLog oldReplicatedLog = mockRaftActor.getReplicatedLog(); + @Test + public void testRealSnapshotWhenReplicatedToAllIndexMinusOne() throws Exception { + 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); - 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))); + DataPersistenceProvider dataPersistenceProvider = createProvider(); - ByteString snapshotBytes = fromObject(Arrays.asList( - new MockRaftActorContext.MockPayload("A"), - new MockRaftActorContext.MockPayload("B"), - new MockRaftActorContext.MockPayload("C"), - new MockRaftActorContext.MockPayload("D"))); + Map peerAddresses = ImmutableMap.builder().put("member1", "address").build(); - Snapshot snapshot = mock(Snapshot.class); + TestActorRef mockActorRef = factory.createTestActor( + MockRaftActor.props(persistenceId, peerAddresses, config, dataPersistenceProvider), persistenceId); - doReturn(snapshotBytes.toByteArray()).when(snapshot).getState(); + MockRaftActor leaderActor = mockActorRef.underlyingActor(); + leaderActor.getRaftActorContext().setCommitIndex(3); + leaderActor.getRaftActorContext().setLastApplied(3); + leaderActor.getRaftActorContext().getTermInformation().update(1, persistenceId); - doReturn(3L).when(snapshot).getLastAppliedIndex(); + leaderActor.waitForInitializeBehaviorComplete(); + for (int i = 0; i < 4; i++) { + leaderActor.getReplicatedLog().append(new SimpleReplicatedLogEntry(i, 1, + new MockRaftActorContext.MockPayload("A"))); + } - mockRaftActor.onReceiveCommand(new ApplySnapshot(snapshot)); + Leader leader = new Leader(leaderActor.getRaftActorContext()); + leaderActor.setCurrentBehavior(leader); + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); - verify(mockRaftActor.snapshotCohortDelegate).applySnapshot(eq(snapshot.getState())); + // Simulate an install snaphost to a follower. + leaderActor.getRaftActorContext().getSnapshotManager().captureToInstall( + leaderActor.getReplicatedLog().last(), -1, "member1"); - assertTrue("The replicatedLog should have changed", - oldReplicatedLog != mockRaftActor.getReplicatedLog()); + // Now send a CaptureSnapshotReply + mockActorRef.tell(new CaptureSnapshotReply(ByteState.of(fromObject("foo").toByteArray()), + Optional.empty()), mockActorRef); - assertEquals("lastApplied should be same as in the snapshot", - (Long) 3L, mockRaftActor.getLastApplied()); + // Trimming log in this scenario is a no-op + assertEquals(-1, leaderActor.getReplicatedLog().getSnapshotIndex()); + assertTrue(leaderActor.getRaftActorContext().getSnapshotManager().isCapturing()); + assertEquals(-1, leader.getReplicatedToAllIndex()); + } - assertEquals(0, mockRaftActor.getReplicatedLog().size()); + @Test + public void testRealSnapshotWhenReplicatedToAllIndexNotInReplicatedLog() throws Exception { + 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); + + DataPersistenceProvider dataPersistenceProvider = createProvider(); + + Map peerAddresses = ImmutableMap.builder().put("member1", "address").build(); + + TestActorRef mockActorRef = factory.createTestActor( + MockRaftActor.props(persistenceId, peerAddresses, config, dataPersistenceProvider), persistenceId); + + MockRaftActor leaderActor = mockActorRef.underlyingActor(); + leaderActor.getRaftActorContext().setCommitIndex(3); + leaderActor.getRaftActorContext().setLastApplied(3); + leaderActor.getRaftActorContext().getTermInformation().update(1, persistenceId); + leaderActor.getReplicatedLog().setSnapshotIndex(3); + + leaderActor.waitForInitializeBehaviorComplete(); + Leader leader = new Leader(leaderActor.getRaftActorContext()); + leaderActor.setCurrentBehavior(leader); + leader.setReplicatedToAllIndex(3); + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); + + // Persist another entry (this will cause a CaptureSnapshot to be triggered + leaderActor.persistData(mockActorRef, new MockIdentifier("x"), + new MockRaftActorContext.MockPayload("duh"), false); + + // Now send a CaptureSnapshotReply + mockActorRef.tell(new CaptureSnapshotReply(ByteState.of(fromObject("foo").toByteArray()), + Optional.empty()), mockActorRef); + + // Trimming log in this scenario is a no-op + assertEquals(3, leaderActor.getReplicatedLog().getSnapshotIndex()); + assertTrue(leaderActor.getRaftActorContext().getSnapshotManager().isCapturing()); + assertEquals(3, leader.getReplicatedToAllIndex()); + } - } - }; + private static DataPersistenceProvider createProvider() { + return new NonPersistentDataProvider(Runnable::run); } @Test - public void testSaveSnapshotFailure() throws Exception { - new JavaTestKit(getSystem()) { - { - String persistenceId = factory.generateActorId("leader-"); + public void testSwitchBehavior() { + String persistenceId = factory.generateActorId("leader-"); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + config.setCustomRaftPolicyImplementationClass(DisableElectionsRaftPolicy.class.getName()); + config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS)); + config.setSnapshotBatchCount(5); - DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + DataPersistenceProvider dataPersistenceProvider = createProvider(); - config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + Map peerAddresses = ImmutableMap.builder().build(); - DataPersistenceProviderMonitor dataPersistenceProviderMonitor = new DataPersistenceProviderMonitor(); + TestActorRef mockActorRef = factory.createTestActor( + MockRaftActor.props(persistenceId, peerAddresses, config, dataPersistenceProvider), persistenceId); - TestActorRef mockActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config), dataPersistenceProviderMonitor), persistenceId); + MockRaftActor leaderActor = mockActorRef.underlyingActor(); - MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); + leaderActor.waitForRecoveryComplete(); - mockRaftActor.waitForInitializeBehaviorComplete(); + leaderActor.handleCommand(new SwitchBehavior(RaftState.Follower, 100)); - ByteString snapshotBytes = fromObject(Arrays.asList( - new MockRaftActorContext.MockPayload("A"), - new MockRaftActorContext.MockPayload("B"), - new MockRaftActorContext.MockPayload("C"), - new MockRaftActorContext.MockPayload("D"))); + assertEquals(100, leaderActor.getRaftActorContext().getTermInformation().getCurrentTerm()); + assertEquals(RaftState.Follower, leaderActor.getCurrentBehavior().state()); - RaftActorContext raftActorContext = mockRaftActor.getRaftActorContext(); + leaderActor.handleCommand(new SwitchBehavior(RaftState.Leader, 110)); - mockRaftActor.setCurrentBehavior(new Leader(raftActorContext)); + assertEquals(110, leaderActor.getRaftActorContext().getTermInformation().getCurrentTerm()); + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); - raftActorContext.getSnapshotManager().capture( - new MockRaftActorContext.MockReplicatedLogEntry(1, 1, - new MockRaftActorContext.MockPayload("D")), 1); + leaderActor.handleCommand(new SwitchBehavior(RaftState.Candidate, 125)); - mockRaftActor.onReceiveCommand(new CaptureSnapshotReply(snapshotBytes.toByteArray())); + assertEquals(110, leaderActor.getRaftActorContext().getTermInformation().getCurrentTerm()); + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); - mockRaftActor.onReceiveCommand(new SaveSnapshotFailure(new SnapshotMetadata("foobar", 10L, 1234L), - new Exception())); + leaderActor.handleCommand(new SwitchBehavior(RaftState.IsolatedLeader, 125)); - assertEquals("Snapshot index should not have advanced because save snapshot failed", -1, - mockRaftActor.getReplicatedLog().getSnapshotIndex()); + assertEquals(110, leaderActor.getRaftActorContext().getTermInformation().getCurrentTerm()); + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); + } + public static ByteString fromObject(final Object snapshot) throws Exception { + ByteArrayOutputStream bos = null; + ObjectOutputStream os = null; + try { + bos = new ByteArrayOutputStream(); + os = new ObjectOutputStream(bos); + os.writeObject(snapshot); + byte[] snapshotBytes = bos.toByteArray(); + return ByteString.copyFrom(snapshotBytes); + } finally { + if (os != null) { + os.flush(); + os.close(); } - }; + if (bos != null) { + bos.close(); + } + } } @Test - public void testRaftRoleChangeNotifierWhenRaftActorHasNoPeers() throws Exception { - new JavaTestKit(getSystem()) {{ - TestActorRef notifierActor = factory.createTestActor( - Props.create(MessageCollectorActor.class)); - MessageCollectorActor.waitUntilReady(notifierActor); - - DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); - long heartBeatInterval = 100; - config.setHeartBeatInterval(FiniteDuration.create(heartBeatInterval, TimeUnit.MILLISECONDS)); - config.setElectionTimeoutFactor(20); - - String persistenceId = factory.generateActorId("notifier-"); - - TestActorRef raftActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config), notifierActor, - new NonPersistentDataProvider()), persistenceId); + public void testUpdateConfigParam() { + DefaultConfigParamsImpl emptyConfig = new DefaultConfigParamsImpl(); + String persistenceId = factory.generateActorId("follower-"); + ImmutableMap peerAddresses = + ImmutableMap.builder().put("member1", "address").build(); + DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); + + TestActorRef actorRef = factory.createTestActor( + MockRaftActor.props(persistenceId, peerAddresses, emptyConfig, dataPersistenceProvider), persistenceId); + MockRaftActor mockRaftActor = actorRef.underlyingActor(); + mockRaftActor.waitForInitializeBehaviorComplete(); + + RaftActorBehavior behavior = mockRaftActor.getCurrentBehavior(); + mockRaftActor.updateConfigParams(emptyConfig); + assertSame("Same Behavior", behavior, mockRaftActor.getCurrentBehavior()); + assertEquals("Behavior State", RaftState.Follower, + mockRaftActor.getCurrentBehavior().state()); + + DefaultConfigParamsImpl disableConfig = new DefaultConfigParamsImpl(); + disableConfig.setCustomRaftPolicyImplementationClass( + "org.opendaylight.controller.cluster.raft.policy.DisableElectionsRaftPolicy"); + mockRaftActor.updateConfigParams(disableConfig); + assertNotSame("Different Behavior", behavior, mockRaftActor.getCurrentBehavior()); + assertEquals("Behavior State", RaftState.Follower, + mockRaftActor.getCurrentBehavior().state()); + + behavior = mockRaftActor.getCurrentBehavior(); + mockRaftActor.updateConfigParams(disableConfig); + assertSame("Same Behavior", behavior, mockRaftActor.getCurrentBehavior()); + assertEquals("Behavior State", RaftState.Follower, + mockRaftActor.getCurrentBehavior().state()); + + DefaultConfigParamsImpl defaultConfig = new DefaultConfigParamsImpl(); + defaultConfig.setCustomRaftPolicyImplementationClass( + "org.opendaylight.controller.cluster.raft.policy.DefaultRaftPolicy"); + mockRaftActor.updateConfigParams(defaultConfig); + assertNotSame("Different Behavior", behavior, mockRaftActor.getCurrentBehavior()); + assertEquals("Behavior State", RaftState.Follower, + mockRaftActor.getCurrentBehavior().state()); + + behavior = mockRaftActor.getCurrentBehavior(); + mockRaftActor.updateConfigParams(defaultConfig); + assertSame("Same Behavior", behavior, mockRaftActor.getCurrentBehavior()); + assertEquals("Behavior State", RaftState.Follower, + mockRaftActor.getCurrentBehavior().state()); + } - List matches = MessageCollectorActor.expectMatching(notifierActor, RoleChanged.class, 3); + @Test + public void testGetSnapshot() { + TEST_LOG.info("testGetSnapshot starting"); + + final TestKit kit = new TestKit(getSystem()); + + String persistenceId = factory.generateActorId("test-actor-"); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + config.setCustomRaftPolicyImplementationClass(DisableElectionsRaftPolicy.class.getName()); + + long term = 3; + long seqN = 1; + InMemoryJournal.addEntry(persistenceId, seqN++, new UpdateElectionTerm(term, "member-1")); + InMemoryJournal.addEntry(persistenceId, seqN++, new SimpleReplicatedLogEntry(0, term, + new MockRaftActorContext.MockPayload("A"))); + InMemoryJournal.addEntry(persistenceId, seqN++, new SimpleReplicatedLogEntry(1, term, + new MockRaftActorContext.MockPayload("B"))); + InMemoryJournal.addEntry(persistenceId, seqN++, new ApplyJournalEntries(1)); + InMemoryJournal.addEntry(persistenceId, seqN++, new SimpleReplicatedLogEntry(2, term, + new MockRaftActorContext.MockPayload("C"))); + + TestActorRef raftActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, + ImmutableMap.builder().put("member1", "address").build(), config) + .withDispatcher(Dispatchers.DefaultDispatcherId()), persistenceId); + MockRaftActor mockRaftActor = raftActorRef.underlyingActor(); + + mockRaftActor.waitForRecoveryComplete(); + + mockRaftActor.snapshotCohortDelegate = mock(RaftActorSnapshotCohort.class); + + raftActorRef.tell(GetSnapshot.INSTANCE, kit.getRef()); + + ArgumentCaptor replyActor = ArgumentCaptor.forClass(ActorRef.class); + verify(mockRaftActor.snapshotCohortDelegate, timeout(5000)).createSnapshot(replyActor.capture(), + eq(Optional.empty())); + + byte[] stateSnapshot = new byte[]{1,2,3}; + replyActor.getValue().tell(new CaptureSnapshotReply(ByteState.of(stateSnapshot), Optional.empty()), + ActorRef.noSender()); + + GetSnapshotReply reply = kit.expectMsgClass(GetSnapshotReply.class); + + assertEquals("getId", persistenceId, reply.getId()); + Snapshot replySnapshot = reply.getSnapshot(); + assertEquals("getElectionTerm", term, replySnapshot.getElectionTerm()); + assertEquals("getElectionVotedFor", "member-1", replySnapshot.getElectionVotedFor()); + assertEquals("getLastAppliedIndex", 1L, replySnapshot.getLastAppliedIndex()); + assertEquals("getLastAppliedTerm", term, replySnapshot.getLastAppliedTerm()); + assertEquals("getLastIndex", 2L, replySnapshot.getLastIndex()); + assertEquals("getLastTerm", term, replySnapshot.getLastTerm()); + assertEquals("getState", ByteState.of(stateSnapshot), replySnapshot.getState()); + assertEquals("getUnAppliedEntries size", 1, replySnapshot.getUnAppliedEntries().size()); + assertEquals("UnApplied entry index ", 2L, replySnapshot.getUnAppliedEntries().get(0).getIndex()); + + // Test with timeout + + mockRaftActor.getSnapshotMessageSupport().setSnapshotReplyActorTimeout( + FiniteDuration.create(200, TimeUnit.MILLISECONDS)); + reset(mockRaftActor.snapshotCohortDelegate); + + raftActorRef.tell(GetSnapshot.INSTANCE, kit.getRef()); + Failure failure = kit.expectMsgClass(akka.actor.Status.Failure.class); + assertEquals("Failure cause type", TimeoutException.class, failure.cause().getClass()); + + mockRaftActor.getSnapshotMessageSupport().setSnapshotReplyActorTimeout( + FiniteDuration.create(30, TimeUnit.SECONDS)); + + // Test with persistence disabled. + + mockRaftActor.setPersistence(false); + reset(mockRaftActor.snapshotCohortDelegate); + + raftActorRef.tell(GetSnapshot.INSTANCE, kit.getRef()); + reply = kit.expectMsgClass(GetSnapshotReply.class); + verify(mockRaftActor.snapshotCohortDelegate, never()).createSnapshot(any(), any()); + + assertEquals("getId", persistenceId, reply.getId()); + replySnapshot = reply.getSnapshot(); + assertEquals("getElectionTerm", term, replySnapshot.getElectionTerm()); + assertEquals("getElectionVotedFor", "member-1", replySnapshot.getElectionVotedFor()); + assertEquals("getLastAppliedIndex", -1L, replySnapshot.getLastAppliedIndex()); + assertEquals("getLastAppliedTerm", -1L, replySnapshot.getLastAppliedTerm()); + assertEquals("getLastIndex", -1L, replySnapshot.getLastIndex()); + assertEquals("getLastTerm", -1L, replySnapshot.getLastTerm()); + assertEquals("getState type", EmptyState.INSTANCE, replySnapshot.getState()); + assertEquals("getUnAppliedEntries size", 0, replySnapshot.getUnAppliedEntries().size()); + + TEST_LOG.info("testGetSnapshot ending"); + } + @Test + public void testRestoreFromSnapshot() { + TEST_LOG.info("testRestoreFromSnapshot starting"); - // 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()); + String persistenceId = factory.generateActorId("test-actor-"); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + config.setCustomRaftPolicyImplementationClass(DisableElectionsRaftPolicy.class.getName()); - // 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()); + List snapshotUnappliedEntries = new ArrayList<>(); + snapshotUnappliedEntries.add(new SimpleReplicatedLogEntry(4, 1, new MockRaftActorContext.MockPayload("E"))); - // 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()); + int snapshotLastApplied = 3; + int snapshotLastIndex = 4; - LeaderStateChanged leaderStateChange = MessageCollectorActor.expectFirstMatching( - notifierActor, LeaderStateChanged.class); + MockSnapshotState snapshotState = new MockSnapshotState(Arrays.asList( + new MockRaftActorContext.MockPayload("A"), + new MockRaftActorContext.MockPayload("B"), + new MockRaftActorContext.MockPayload("C"), + new MockRaftActorContext.MockPayload("D"))); - assertEquals(raftRoleChanged.getMemberId(), leaderStateChange.getLeaderId()); + Snapshot snapshot = Snapshot.create(snapshotState, snapshotUnappliedEntries, + snapshotLastIndex, 1, snapshotLastApplied, 1, 1, "member-1", null); - notifierActor.underlyingActor().clear(); + InMemorySnapshotStore.addSnapshotSavedLatch(persistenceId); - MockRaftActor raftActor = raftActorRef.underlyingActor(); - final String newLeaderId = "new-leader"; - Follower follower = new Follower(raftActor.getRaftActorContext()) { - @Override - public RaftActorBehavior handleMessage(ActorRef sender, Object message) { - leaderId = newLeaderId; - return this; - } - }; + TestActorRef raftActorRef = factory.createTestActor(MockRaftActor.builder().id(persistenceId) + .config(config).restoreFromSnapshot(snapshot).props() + .withDispatcher(Dispatchers.DefaultDispatcherId()), persistenceId); + MockRaftActor mockRaftActor = raftActorRef.underlyingActor(); - raftActor.changeCurrentBehavior(follower); + mockRaftActor.waitForRecoveryComplete(); - leaderStateChange = MessageCollectorActor.expectFirstMatching(notifierActor, LeaderStateChanged.class); - assertEquals(persistenceId, leaderStateChange.getMemberId()); - assertEquals(null, leaderStateChange.getLeaderId()); + Snapshot savedSnapshot = InMemorySnapshotStore.waitForSavedSnapshot(persistenceId, Snapshot.class); + assertEquals("getElectionTerm", snapshot.getElectionTerm(), savedSnapshot.getElectionTerm()); + assertEquals("getElectionVotedFor", snapshot.getElectionVotedFor(), savedSnapshot.getElectionVotedFor()); + assertEquals("getLastAppliedIndex", snapshot.getLastAppliedIndex(), savedSnapshot.getLastAppliedIndex()); + assertEquals("getLastAppliedTerm", snapshot.getLastAppliedTerm(), savedSnapshot.getLastAppliedTerm()); + assertEquals("getLastIndex", snapshot.getLastIndex(), savedSnapshot.getLastIndex()); + assertEquals("getLastTerm", snapshot.getLastTerm(), savedSnapshot.getLastTerm()); + assertEquals("getState", snapshot.getState(), savedSnapshot.getState()); + assertEquals("getUnAppliedEntries", snapshot.getUnAppliedEntries(), savedSnapshot.getUnAppliedEntries()); - raftRoleChanged = MessageCollectorActor.expectFirstMatching(notifierActor, RoleChanged.class); - assertEquals(RaftState.Leader.name(), raftRoleChanged.getOldRole()); - assertEquals(RaftState.Follower.name(), raftRoleChanged.getNewRole()); + verify(mockRaftActor.snapshotCohortDelegate, timeout(5000)).applySnapshot(any(Snapshot.State.class)); - notifierActor.underlyingActor().clear(); + RaftActorContext context = mockRaftActor.getRaftActorContext(); + assertEquals("Journal log size", 1, context.getReplicatedLog().size()); + assertEquals("Last index", snapshotLastIndex, context.getReplicatedLog().lastIndex()); + assertEquals("Last applied", snapshotLastApplied, context.getLastApplied()); + assertEquals("Commit index", snapshotLastApplied, context.getCommitIndex()); + assertEquals("Recovered state", snapshotState.getState(), mockRaftActor.getState()); + assertEquals("Current term", 1L, context.getTermInformation().getCurrentTerm()); + assertEquals("Voted for", "member-1", context.getTermInformation().getVotedFor()); - raftActor.handleCommand("any"); + // Test with data persistence disabled - leaderStateChange = MessageCollectorActor.expectFirstMatching(notifierActor, LeaderStateChanged.class); - assertEquals(persistenceId, leaderStateChange.getMemberId()); - assertEquals(newLeaderId, leaderStateChange.getLeaderId()); - }}; - } + snapshot = Snapshot.create(EmptyState.INSTANCE, Collections.emptyList(), + -1, -1, -1, -1, 5, "member-1", null); - @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); - - 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); - } + persistenceId = factory.generateActorId("test-actor-"); - assertEquals(2, matches.size()); + raftActorRef = factory.createTestActor(MockRaftActor.builder().id(persistenceId) + .config(config).restoreFromSnapshot(snapshot) + .persistent(Optional.of(Boolean.FALSE)).props() + .withDispatcher(Dispatchers.DefaultDispatcherId()), persistenceId); + mockRaftActor = raftActorRef.underlyingActor(); - // 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.waitForRecoveryComplete(); + assertEquals("snapshot committed", true, + Uninterruptibles.awaitUninterruptibly(mockRaftActor.snapshotCommitted, 5, TimeUnit.SECONDS)); - // 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()); + context = mockRaftActor.getRaftActorContext(); + assertEquals("Current term", 5L, context.getTermInformation().getCurrentTerm()); + assertEquals("Voted for", "member-1", context.getTermInformation().getVotedFor()); - }}; + TEST_LOG.info("testRestoreFromSnapshot ending"); } @Test - public void testFakeSnapshotsForLeaderWithInRealSnapshots() throws Exception { - new JavaTestKit(getSystem()) { - { - String persistenceId = factory.generateActorId("leader-"); - String follower1Id = factory.generateActorId("follower-"); - - ActorRef followerActor1 = - factory.createActor(Props.create(MessageCollectorActor.class)); + public void testRestoreFromSnapshotWithRecoveredData() throws Exception { + TEST_LOG.info("testRestoreFromSnapshotWithRecoveredData starting"); - DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); - config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); - config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS)); + String persistenceId = factory.generateActorId("test-actor-"); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + config.setCustomRaftPolicyImplementationClass(DisableElectionsRaftPolicy.class.getName()); - DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); + List state = Arrays.asList(new MockRaftActorContext.MockPayload("A")); + Snapshot snapshot = Snapshot.create(ByteState.of(fromObject(state).toByteArray()), + Arrays.asList(), 5, 2, 5, 2, 2, "member-1", null); - Map peerAddresses = new HashMap<>(); - peerAddresses.put(follower1Id, followerActor1.path().toString()); + InMemoryJournal.addEntry(persistenceId, 1, new SimpleReplicatedLogEntry(0, 1, + new MockRaftActorContext.MockPayload("B"))); - TestActorRef mockActorRef = factory.createTestActor( - MockRaftActor.props(persistenceId, peerAddresses, - Optional.of(config), dataPersistenceProvider), persistenceId); + TestActorRef raftActorRef = factory.createTestActor(MockRaftActor.builder().id(persistenceId) + .config(config).restoreFromSnapshot(snapshot).props() + .withDispatcher(Dispatchers.DefaultDispatcherId()), persistenceId); + MockRaftActor mockRaftActor = raftActorRef.underlyingActor(); - MockRaftActor leaderActor = mockActorRef.underlyingActor(); + mockRaftActor.waitForRecoveryComplete(); - leaderActor.getRaftActorContext().setCommitIndex(4); - leaderActor.getRaftActorContext().setLastApplied(4); - leaderActor.getRaftActorContext().getTermInformation().update(1, persistenceId); + Uninterruptibles.sleepUninterruptibly(500, TimeUnit.MILLISECONDS); + verify(mockRaftActor.snapshotCohortDelegate, never()).applySnapshot(any(Snapshot.State.class)); - leaderActor.waitForInitializeBehaviorComplete(); + RaftActorContext context = mockRaftActor.getRaftActorContext(); + assertEquals("Journal log size", 1, context.getReplicatedLog().size()); + assertEquals("Last index", 0, context.getReplicatedLog().lastIndex()); + assertEquals("Last applied", -1, context.getLastApplied()); + assertEquals("Commit index", -1, context.getCommitIndex()); + assertEquals("Current term", 0, context.getTermInformation().getCurrentTerm()); + assertEquals("Voted for", null, context.getTermInformation().getVotedFor()); - // create 8 entries in the log - 0 to 4 are applied and will get picked up as part of the capture snapshot + TEST_LOG.info("testRestoreFromSnapshotWithRecoveredData ending"); + } - Leader leader = new Leader(leaderActor.getRaftActorContext()); - leaderActor.setCurrentBehavior(leader); - assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); + @Test + public void testNonVotingOnRecovery() { + TEST_LOG.info("testNonVotingOnRecovery starting"); - MockRaftActorContext.MockReplicatedLogBuilder logBuilder = new MockRaftActorContext.MockReplicatedLogBuilder(); - leaderActor.getRaftActorContext().setReplicatedLog(logBuilder.createEntries(0, 8, 1).build()); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + config.setElectionTimeoutFactor(1); + config.setHeartBeatInterval(FiniteDuration.create(1, TimeUnit.MILLISECONDS)); - assertEquals(8, leaderActor.getReplicatedLog().size()); + String persistenceId = factory.generateActorId("test-actor-"); + InMemoryJournal.addEntry(persistenceId, 1, new SimpleReplicatedLogEntry(0, 1, + new ServerConfigurationPayload(Arrays.asList(new ServerInfo(persistenceId, false))))); - leaderActor.getRaftActorContext().getSnapshotManager() - .capture(new MockRaftActorContext.MockReplicatedLogEntry(1, 6, - new MockRaftActorContext.MockPayload("x")), 4); + TestActorRef raftActorRef = factory.createTestActor(MockRaftActor.builder().id(persistenceId) + .config(config).props().withDispatcher(Dispatchers.DefaultDispatcherId()), persistenceId); + MockRaftActor mockRaftActor = raftActorRef.underlyingActor(); - verify(leaderActor.snapshotCohortDelegate).createSnapshot(any(ActorRef.class)); + mockRaftActor.waitForInitializeBehaviorComplete(); - assertEquals(8, leaderActor.getReplicatedLog().size()); + // Sleep a bit and verify it didn't get an election timeout and schedule an election. - assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); - //fake snapshot on index 5 - leaderActor.onReceiveCommand(new AppendEntriesReply(follower1Id, 1, true, 5, 1)); + Uninterruptibles.sleepUninterruptibly(400, TimeUnit.MILLISECONDS); + assertEquals("getRaftState", RaftState.Follower, mockRaftActor.getRaftState()); - assertEquals(8, leaderActor.getReplicatedLog().size()); + TEST_LOG.info("testNonVotingOnRecovery ending"); + } - //fake snapshot on index 6 - assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); - leaderActor.onReceiveCommand(new AppendEntriesReply(follower1Id, 1, true, 6, 1)); - assertEquals(8, leaderActor.getReplicatedLog().size()); + @Test + public void testLeaderTransitioning() { + TEST_LOG.info("testLeaderTransitioning starting"); - assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); + ActorRef notifierActor = factory.createActor(MessageCollectorActor.props()); - assertEquals(8, leaderActor.getReplicatedLog().size()); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + config.setCustomRaftPolicyImplementationClass(DisableElectionsRaftPolicy.class.getName()); - 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"))); + String persistenceId = factory.generateActorId("test-actor-"); - leaderActor.getRaftActorContext().getSnapshotManager().persist(new NonPersistentDataProvider() - , snapshotBytes.toByteArray(), leader, Runtime.getRuntime().totalMemory()); + TestActorRef raftActorRef = factory.createTestActor(MockRaftActor.builder().id(persistenceId) + .config(config).roleChangeNotifier(notifierActor).props() + .withDispatcher(Dispatchers.DefaultDispatcherId()), persistenceId); + MockRaftActor mockRaftActor = raftActorRef.underlyingActor(); - assertFalse(leaderActor.getRaftActorContext().getSnapshotManager().isCapturing()); + mockRaftActor.waitForInitializeBehaviorComplete(); - // The commit is needed to complete the snapshot creation process - leaderActor.getRaftActorContext().getSnapshotManager().commit(new NonPersistentDataProvider(), -1); + raftActorRef.tell(new AppendEntries(1L, "leader", 0L, 1L, Collections.emptyList(), + 0L, -1L, (short)1), ActorRef.noSender()); + LeaderStateChanged leaderStateChange = MessageCollectorActor.expectFirstMatching( + notifierActor, LeaderStateChanged.class); + assertEquals("getLeaderId", "leader", leaderStateChange.getLeaderId()); - // capture snapshot reply should remove the snapshotted entries only - assertEquals(3, leaderActor.getReplicatedLog().size()); - assertEquals(7, leaderActor.getReplicatedLog().lastIndex()); + MessageCollectorActor.clearMessages(notifierActor); - // add another non-replicated entry - leaderActor.getReplicatedLog().append( - new ReplicatedLogImplEntry(8, 1, new MockRaftActorContext.MockPayload("foo-8"))); + raftActorRef.tell(new LeaderTransitioning("leader"), ActorRef.noSender()); - //fake snapshot on index 7, since lastApplied = 7 , we would keep the last applied - leaderActor.onReceiveCommand(new AppendEntriesReply(follower1Id, 1, true, 7, 1)); - assertEquals(2, leaderActor.getReplicatedLog().size()); - assertEquals(8, leaderActor.getReplicatedLog().lastIndex()); + leaderStateChange = MessageCollectorActor.expectFirstMatching(notifierActor, LeaderStateChanged.class); + assertEquals("getMemberId", persistenceId, leaderStateChange.getMemberId()); + assertEquals("getLeaderId", null, leaderStateChange.getLeaderId()); - } - }; + TEST_LOG.info("testLeaderTransitioning ending"); } + @SuppressWarnings({ "unchecked", "rawtypes" }) @Test - public void testFakeSnapshotsForFollowerWithInRealSnapshots() throws Exception { - new JavaTestKit(getSystem()) { - { - String persistenceId = factory.generateActorId("follower-"); - String leaderId = factory.generateActorId("leader-"); - - - 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); - - Map peerAddresses = new HashMap<>(); - peerAddresses.put(leaderId, leaderActor1.path().toString()); - - TestActorRef mockActorRef = factory.createTestActor( - MockRaftActor.props(persistenceId, peerAddresses, - Optional.of(config), dataPersistenceProvider), persistenceId); - - MockRaftActor followerActor = mockActorRef.underlyingActor(); - followerActor.getRaftActorContext().setCommitIndex(4); - followerActor.getRaftActorContext().setLastApplied(4); - followerActor.getRaftActorContext().getTermInformation().update(1, persistenceId); - - followerActor.waitForInitializeBehaviorComplete(); - + public void testReplicateWithPersistencePending() throws Exception { + final String leaderId = factory.generateActorId("leader-"); + final String followerId = factory.generateActorId("follower-"); - Follower follower = new Follower(followerActor.getRaftActorContext()); - followerActor.setCurrentBehavior(follower); - assertEquals(RaftState.Follower, followerActor.getCurrentBehavior().state()); + final ActorRef followerActor = factory.createActor(MessageCollectorActor.props()); - // 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()); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS)); - // log has indices 0-5 - assertEquals(6, followerActor.getReplicatedLog().size()); + DataPersistenceProvider mockPersistenceProvider = mock(DataPersistenceProvider.class); + doReturn(true).when(mockPersistenceProvider).isRecoveryApplicable(); - //snapshot on 4 - followerActor.getRaftActorContext().getSnapshotManager().capture( - new MockRaftActorContext.MockReplicatedLogEntry(1, 5, - new MockRaftActorContext.MockPayload("D")), 4); + TestActorRef leaderActorRef = factory.createTestActor( + MockRaftActor.props(leaderId, ImmutableMap.of(followerId, followerActor.path().toString()), config, + mockPersistenceProvider), leaderId); + MockRaftActor leaderActor = leaderActorRef.underlyingActor(); + leaderActor.waitForInitializeBehaviorComplete(); - verify(followerActor.snapshotCohortDelegate).createSnapshot(any(ActorRef.class)); + leaderActor.getRaftActorContext().getTermInformation().update(1, leaderId); - assertEquals(6, followerActor.getReplicatedLog().size()); + Leader leader = new Leader(leaderActor.getRaftActorContext()); + leaderActor.setCurrentBehavior(leader); - //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)); - assertEquals(7, followerActor.getReplicatedLog().size()); + leaderActor.persistData(leaderActorRef, new MockIdentifier("1"), new MockRaftActorContext.MockPayload("1"), + false); - //fake snapshot on index 7 - assertEquals(RaftState.Follower, followerActor.getCurrentBehavior().state()); + ReplicatedLogEntry logEntry = leaderActor.getReplicatedLog().get(0); + assertNotNull("ReplicatedLogEntry not found", logEntry); + assertEquals("isPersistencePending", true, logEntry.isPersistencePending()); + assertEquals("getCommitIndex", -1, leaderActor.getRaftActorContext().getCommitIndex()); - 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)); - assertEquals(8, followerActor.getReplicatedLog().size()); + leaderActor.handleCommand(new AppendEntriesReply(followerId, 1, true, 0, 1, (short)0)); + assertEquals("getCommitIndex", -1, leaderActor.getRaftActorContext().getCommitIndex()); - assertEquals(RaftState.Follower, followerActor.getCurrentBehavior().state()); + ArgumentCaptor callbackCaptor = ArgumentCaptor.forClass(Procedure.class); + verify(mockPersistenceProvider).persistAsync(eq(logEntry), callbackCaptor.capture()); + callbackCaptor.getValue().apply(logEntry); - 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())); - assertFalse(followerActor.getRaftActorContext().getSnapshotManager().isCapturing()); + assertEquals("getCommitIndex", 0, leaderActor.getRaftActorContext().getCommitIndex()); + assertEquals("getLastApplied", 0, leaderActor.getRaftActorContext().getLastApplied()); + } - // The commit is needed to complete the snapshot creation process - followerActor.getRaftActorContext().getSnapshotManager().commit(new NonPersistentDataProvider(), -1); + @Test + public void testReplicateWithBatchHint() throws Exception { + final String leaderId = factory.generateActorId("leader-"); + final String followerId = factory.generateActorId("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()); + final ActorRef followerActor = factory.createActor(MessageCollectorActor.props()); - 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)); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS)); - // 7 and 8, as lastapplied is 7 - assertEquals(2, followerActor.getReplicatedLog().size()); + TestActorRef leaderActorRef = factory.createTestActor( + MockRaftActor.props(leaderId, ImmutableMap.of(followerId, followerActor.path().toString()), config), + leaderId); + MockRaftActor leaderActor = leaderActorRef.underlyingActor(); + leaderActor.waitForInitializeBehaviorComplete(); - } - }; - } + leaderActor.getRaftActorContext().getTermInformation().update(1, leaderId); - @Test - public void testFakeSnapshotsForLeaderWithInInitiateSnapshots() throws Exception { - new JavaTestKit(getSystem()) { - { - String persistenceId = factory.generateActorId("leader-"); - String follower1Id = factory.generateActorId("follower-"); - String follower2Id = factory.generateActorId("follower-"); - - 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); - - Map peerAddresses = new HashMap<>(); - peerAddresses.put(follower1Id, followerActor1.path().toString()); - peerAddresses.put(follower2Id, followerActor2.path().toString()); - - TestActorRef mockActorRef = factory.createTestActor( - MockRaftActor.props(persistenceId, peerAddresses, - Optional.of(config), dataPersistenceProvider), persistenceId); - - MockRaftActor leaderActor = mockActorRef.underlyingActor(); - leaderActor.getRaftActorContext().setCommitIndex(9); - leaderActor.getRaftActorContext().setLastApplied(9); - leaderActor.getRaftActorContext().getTermInformation().update(1, persistenceId); - - leaderActor.waitForInitializeBehaviorComplete(); - - Leader leader = new Leader(leaderActor.getRaftActorContext()); - leaderActor.setCurrentBehavior(leader); - assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); - - // 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()); - - leaderActor.onReceiveCommand(new AppendEntriesReply(follower1Id, 1, true, 9, 1)); - assertEquals(5, leaderActor.getReplicatedLog().size()); - assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); - - // set the 2nd follower nextIndex to 1 which has been snapshotted - leaderActor.onReceiveCommand(new AppendEntriesReply(follower2Id, 1, true, 0, 1)); - assertEquals(5, leaderActor.getReplicatedLog().size()); - assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); - - // 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()); - - - //reply from a slow follower does not initiate a fake snapshot - leaderActor.onReceiveCommand(new AppendEntriesReply(follower2Id, 1, true, 9, 1)); - assertEquals("Fake snapshot should not happen when Initiate is in progress", 5, 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.onReceiveCommand(new CaptureSnapshotReply(snapshotBytes.toByteArray())); - assertFalse(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)); - 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); - - DataPersistenceProvider dataPersistenceProvider = new NonPersistentDataProvider(); - - Map peerAddresses = new HashMap<>(); - - TestActorRef mockActorRef = factory.createTestActor( - MockRaftActor.props(persistenceId, peerAddresses, - Optional.of(config), dataPersistenceProvider), persistenceId); - - MockRaftActor leaderActor = mockActorRef.underlyingActor(); - leaderActor.getRaftActorContext().setCommitIndex(3); - leaderActor.getRaftActorContext().setLastApplied(3); - leaderActor.getRaftActorContext().getTermInformation().update(1, persistenceId); - - leaderActor.waitForInitializeBehaviorComplete(); - for(int i=0;i< 4;i++) { - leaderActor.getReplicatedLog() - .append(new MockRaftActorContext.MockReplicatedLogEntry(1, i, - new MockRaftActorContext.MockPayload("A"))); - } + Leader leader = new Leader(leaderActor.getRaftActorContext()); + leaderActor.setCurrentBehavior(leader); - Leader leader = new Leader(leaderActor.getRaftActorContext()); - leaderActor.setCurrentBehavior(leader); - assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); + MessageCollectorActor.expectFirstMatching(followerActor, AppendEntries.class); + MessageCollectorActor.clearMessages(followerActor); - // Persist another entry (this will cause a CaptureSnapshot to be triggered - leaderActor.persistData(mockActorRef, "x", new MockRaftActorContext.MockPayload("duh")); + leaderActor.handleCommand(new AppendEntriesReply(followerId, 1, true, -1, -1, (short)0)); - // Now send a CaptureSnapshotReply - mockActorRef.tell(new CaptureSnapshotReply(fromObject("foo").toByteArray()), mockActorRef); + leaderActor.persistData(leaderActorRef, new MockIdentifier("1"), new MockPayload("1"), true); + MessageCollectorActor.assertNoneMatching(followerActor, AppendEntries.class, 500); - // Trimming log in this scenario is a no-op - assertEquals(-1, leaderActor.getReplicatedLog().getSnapshotIndex()); - assertFalse(leaderActor.getRaftActorContext().getSnapshotManager().isCapturing()); - assertEquals(-1, leader.getReplicatedToAllIndex()); + leaderActor.persistData(leaderActorRef, new MockIdentifier("2"), new MockPayload("2"), true); + MessageCollectorActor.assertNoneMatching(followerActor, AppendEntries.class, 500); - }}; + leaderActor.persistData(leaderActorRef, new MockIdentifier("3"), new MockPayload("3"), false); + AppendEntries appendEntries = MessageCollectorActor.expectFirstMatching(followerActor, AppendEntries.class); + assertEquals("AppendEntries size", 3, appendEntries.getEntries().size()); } @Test - 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); + @SuppressWarnings("checkstyle:illegalcatch") + public void testApplyStateRace() throws Exception { + final String leaderId = factory.generateActorId("leader-"); + final String followerId = factory.generateActorId("follower-"); - DataPersistenceProvider dataPersistenceProvider = new NonPersistentDataProvider(); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS)); + config.setCustomRaftPolicyImplementationClass(DisableElectionsRaftPolicy.class.getName()); - Map peerAddresses = new HashMap<>(); + ActorRef mockFollowerActorRef = factory.createActor(MessageCollectorActor.props()); - TestActorRef mockActorRef = factory.createTestActor( - MockRaftActor.props(persistenceId, peerAddresses, - Optional.of(config), dataPersistenceProvider), persistenceId); + TestRaftActor.Builder builder = TestRaftActor.newBuilder() + .id(leaderId) + .peerAddresses(ImmutableMap.of(followerId, + mockFollowerActorRef.path().toString())) + .config(config) + .collectorActor(factory.createActor( + MessageCollectorActor.props(), factory.generateActorId(leaderId + "-collector"))); - MockRaftActor leaderActor = mockActorRef.underlyingActor(); - leaderActor.getRaftActorContext().setCommitIndex(3); - leaderActor.getRaftActorContext().setLastApplied(3); - leaderActor.getRaftActorContext().getTermInformation().update(1, persistenceId); - leaderActor.getReplicatedLog().setSnapshotIndex(3); + TestActorRef leaderActorRef = factory.createTestActor( + builder.props(), leaderId); + MockRaftActor leaderActor = leaderActorRef.underlyingActor(); + leaderActor.waitForInitializeBehaviorComplete(); - leaderActor.waitForInitializeBehaviorComplete(); - Leader leader = new Leader(leaderActor.getRaftActorContext()); - leaderActor.setCurrentBehavior(leader); - leader.setReplicatedToAllIndex(3); - assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); + leaderActor.getRaftActorContext().getTermInformation().update(1, leaderId); + Leader leader = new Leader(leaderActor.getRaftActorContext()); + leaderActor.setCurrentBehavior(leader); - // Persist another entry (this will cause a CaptureSnapshot to be triggered - leaderActor.persistData(mockActorRef, "x", new MockRaftActorContext.MockPayload("duh")); + final ExecutorService executorService = Executors.newSingleThreadExecutor(); - // Now send a CaptureSnapshotReply - mockActorRef.tell(new CaptureSnapshotReply(fromObject("foo").toByteArray()), mockActorRef); + leaderActor.setPersistence(new PersistentDataProvider(leaderActor) { + @Override + public void persistAsync(final T entry, final Procedure procedure) { + // needs to be executed from another thread to simulate the persistence actor calling this callback + executorService.submit(() -> { + try { + procedure.apply(entry); + } catch (Exception e) { + TEST_LOG.info("Fail during async persist callback", e); + } + }, "persistence-callback"); + } + }); - // Trimming log in this scenario is a no-op - assertEquals(3, leaderActor.getReplicatedLog().getSnapshotIndex()); - assertFalse(leaderActor.getRaftActorContext().getSnapshotManager().isCapturing()); - assertEquals(3, leader.getReplicatedToAllIndex()); + leader.getFollower(followerId).setNextIndex(0); + leader.getFollower(followerId).setMatchIndex(-1); - }}; - } + // hitting this is flimsy so run multiple times to improve the chance of things + // blowing up while breaking actor containment + final TestPersist message = + new TestPersist(leaderActorRef, new MockIdentifier("1"), new MockPayload("1")); + for (int i = 0; i < 100; i++) { + leaderActorRef.tell(message, null); - private ByteString fromObject(Object snapshot) throws Exception { - ByteArrayOutputStream b = null; - ObjectOutputStream o = null; - try { - b = new ByteArrayOutputStream(); - o = new ObjectOutputStream(b); - o.writeObject(snapshot); - byte[] snapshotBytes = b.toByteArray(); - return ByteString.copyFrom(snapshotBytes); - } finally { - if (o != null) { - o.flush(); - o.close(); - } - if (b != null) { - b.close(); - } + AppendEntriesReply reply = + new AppendEntriesReply(followerId, 1, true, i, 1, (short) 5); + leaderActorRef.tell(reply, mockFollowerActorRef); } - } + await("Persistence callback.").atMost(5, TimeUnit.SECONDS).until(() -> leaderActor.getState().size() == 100); + executorService.shutdown(); + } }