X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-akka-raft%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fraft%2FRaftActorTest.java;h=ce7dd98fc44276d7c5ea6db959dd838f002b9fb6;hb=5b685df28d9ea19494ffc5a998e7059ab15a118e;hp=da0493fe225137469a524e004204de257ff2aed3;hpb=fa96da71c5ab10973a9f93c2e8b35494b96fd7ed;p=controller.git diff --git a/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/RaftActorTest.java b/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/RaftActorTest.java index da0493fe22..ce7dd98fc4 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 @@ -5,20 +5,18 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ - package org.opendaylight.controller.cluster.raft; -import static org.junit.Assert.assertArrayEquals; +import static org.awaitility.Awaitility.await; import static org.junit.Assert.assertEquals; 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.Matchers.same; +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.never; @@ -28,7 +26,6 @@ import static org.mockito.Mockito.verify; import akka.actor.ActorRef; import akka.actor.PoisonPill; -import akka.actor.Props; import akka.actor.Status.Failure; import akka.actor.Terminated; import akka.dispatch.Dispatchers; @@ -37,23 +34,25 @@ import akka.persistence.SaveSnapshotFailure; import akka.persistence.SaveSnapshotSuccess; import akka.persistence.SnapshotMetadata; import akka.persistence.SnapshotOffer; -import akka.testkit.JavaTestKit; +import akka.protobuf.ByteString; import akka.testkit.TestActorRef; +import akka.testkit.javadsl.TestKit; import com.google.common.base.Optional; import com.google.common.collect.ImmutableMap; import com.google.common.util.concurrent.Uninterruptibles; -import com.google.protobuf.ByteString; import java.io.ByteArrayOutputStream; 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.ExecutorService; +import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; -import org.apache.commons.lang3.SerializationUtils; import org.junit.After; import org.junit.Before; import org.junit.Test; @@ -63,10 +62,12 @@ import org.opendaylight.controller.cluster.NonPersistentDataProvider; import org.opendaylight.controller.cluster.PersistentDataProvider; import org.opendaylight.controller.cluster.notifications.LeaderStateChanged; import org.opendaylight.controller.cluster.notifications.RoleChanged; +import org.opendaylight.controller.cluster.raft.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.CaptureSnapshot; 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; @@ -79,9 +80,13 @@ 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.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; @@ -90,7 +95,6 @@ import org.opendaylight.controller.cluster.raft.utils.MessageCollectorActor; import org.opendaylight.yangtools.concepts.Identifier; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import scala.concurrent.duration.Duration; import scala.concurrent.duration.FiniteDuration; public class RaftActorTest extends AbstractActorTest { @@ -105,7 +109,7 @@ public class RaftActorTest extends AbstractActorTest { } @After - public void tearDown() throws Exception { + public void tearDown() { factory.close(); InMemoryJournal.clear(); InMemorySnapshotStore.clear(); @@ -124,10 +128,10 @@ public class RaftActorTest extends AbstractActorTest { @Test - public void testRaftActorRecoveryWithPersistenceEnabled() throws Exception { + public void testRaftActorRecoveryWithPersistenceEnabled() { TEST_LOG.info("testRaftActorRecoveryWithPersistenceEnabled starting"); - JavaTestKit kit = new JavaTestKit(getSystem()); + TestKit kit = new TestKit(getSystem()); String persistenceId = factory.generateActorId("follower-"); DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); @@ -145,33 +149,28 @@ public class RaftActorTest extends AbstractActorTest { kit.watch(followerActor); List snapshotUnappliedEntries = new ArrayList<>(); - ReplicatedLogEntry entry1 = new MockRaftActorContext.MockReplicatedLogEntry(1, 4, - new MockRaftActorContext.MockPayload("E")); + ReplicatedLogEntry entry1 = new SimpleReplicatedLogEntry(4, 1, 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( + MockSnapshotState snapshotState = new MockSnapshotState(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); + Snapshot snapshot = Snapshot.create(snapshotState, snapshotUnappliedEntries, lastIndexDuringSnapshotCapture, 1, + lastAppliedDuringSnapshotCapture, 1, -1, null, null); 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)); + 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); @@ -187,7 +186,7 @@ public class RaftActorTest extends AbstractActorTest { // kill the actor followerActor.tell(PoisonPill.getInstance(), null); - kit.expectMsgClass(JavaTestKit.duration("5 seconds"), Terminated.class); + kit.expectMsgClass(Duration.ofSeconds(5), Terminated.class); kit.unwatch(followerActor); @@ -216,7 +215,7 @@ public class RaftActorTest extends AbstractActorTest { } @Test - public void testRaftActorRecoveryWithPersistenceDisabled() throws Exception { + public void testRaftActorRecoveryWithPersistenceDisabled() { String persistenceId = factory.generateActorId("follower-"); DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); @@ -225,7 +224,7 @@ public class RaftActorTest extends AbstractActorTest { TestActorRef ref = factory.createTestActor(MockRaftActor.props(persistenceId, ImmutableMap.builder().put("member1", "address").build(), - config, new NonPersistentDataProvider()), persistenceId); + config, createProvider()), persistenceId); MockRaftActor mockRaftActor = ref.underlyingActor(); @@ -237,8 +236,8 @@ public class RaftActorTest extends AbstractActorTest { } @Test - public void testUpdateElectionTermPersistedWithPersistenceDisabled() throws Exception { - final JavaTestKit kit = new JavaTestKit(getSystem()); + 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)); @@ -248,7 +247,7 @@ public class RaftActorTest extends AbstractActorTest { TestActorRef ref = factory.createTestActor(MockRaftActor.props(persistenceId, ImmutableMap.builder().put("member1", "address").build(), - config, new NonPersistentDataProvider()) + config, createProvider()) .withDispatcher(Dispatchers.DefaultDispatcherId()), persistenceId); InMemoryJournal.waitForWriteMessagesComplete(persistenceId); @@ -261,7 +260,7 @@ public class RaftActorTest extends AbstractActorTest { config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); ref = factory.createTestActor(MockRaftActor.props(persistenceId, ImmutableMap.builder().put("member1", "address").build(), config, - new NonPersistentDataProvider()).withDispatcher(Dispatchers.DefaultDispatcherId()), + createProvider()).withDispatcher(Dispatchers.DefaultDispatcherId()), factory.generateActorId("follower-")); MockRaftActor actor = ref.underlyingActor(); @@ -293,14 +292,14 @@ public class RaftActorTest extends AbstractActorTest { mockRaftActor.waitForRecoveryComplete(); RaftActorRecoverySupport mockSupport = mock(RaftActorRecoverySupport.class); - mockRaftActor.setRaftActorRecoverySupport(mockSupport ); + mockRaftActor.setRaftActorRecoverySupport(mockSupport); - Snapshot snapshot = Snapshot.create(new byte[]{1}, Collections.emptyList(), 3, 1, 3, 1); + 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); - MockRaftActorContext.MockReplicatedLogEntry logEntry = new MockRaftActorContext.MockReplicatedLogEntry(1, - 1, new MockRaftActorContext.MockPayload("1", 5)); + ReplicatedLogEntry logEntry = new SimpleReplicatedLogEntry(1, 1, new MockRaftActorContext.MockPayload("1", 5)); mockRaftActor.handleRecover(logEntry); ApplyJournalEntries applyJournalEntries = new ApplyJournalEntries(2); @@ -341,11 +340,8 @@ public class RaftActorTest extends AbstractActorTest { doReturn(true).when(mockSupport).handleSnapshotMessage(same(applySnapshot), any(ActorRef.class)); mockRaftActor.handleCommand(applySnapshot); - CaptureSnapshot captureSnapshot = new CaptureSnapshot(1, 1, 1, 1, 0, 1, null); - doReturn(true).when(mockSupport).handleSnapshotMessage(same(captureSnapshot), any(ActorRef.class)); - mockRaftActor.handleCommand(captureSnapshot); - - CaptureSnapshotReply captureSnapshotReply = new CaptureSnapshotReply(new byte[0]); + CaptureSnapshotReply captureSnapshotReply = new CaptureSnapshotReply(ByteState.empty(), + java.util.Optional.empty()); doReturn(true).when(mockSupport).handleSnapshotMessage(same(captureSnapshotReply), any(ActorRef.class)); mockRaftActor.handleCommand(captureSnapshotReply); @@ -366,7 +362,6 @@ public class RaftActorTest extends AbstractActorTest { mockRaftActor.handleCommand(GetSnapshot.INSTANCE); verify(mockSupport).handleSnapshotMessage(same(applySnapshot), any(ActorRef.class)); - verify(mockSupport).handleSnapshotMessage(same(captureSnapshot), 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)); @@ -401,7 +396,7 @@ public class RaftActorTest extends AbstractActorTest { } @Test - public void testApplyState() throws Exception { + public void testApplyState() { String persistenceId = factory.generateActorId("leader-"); DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); @@ -417,19 +412,17 @@ public class RaftActorTest extends AbstractActorTest { mockRaftActor.waitForInitializeBehaviorComplete(); - ReplicatedLogEntry entry = new MockRaftActorContext.MockReplicatedLogEntry(1, 5, - new MockRaftActorContext.MockPayload("F")); + ReplicatedLogEntry entry = new SimpleReplicatedLogEntry(5, 1, new MockRaftActorContext.MockPayload("F")); final Identifier id = new MockIdentifier("apply-state"); - mockRaftActor.onReceiveCommand(new ApplyState(mockActorRef, id, entry)); + mockRaftActor.getRaftActorContext().getApplyStateConsumer().accept(new ApplyState(mockActorRef, id, entry)); - verify(mockRaftActor.actorDelegate).applyState(eq(mockActorRef), eq(id), anyObject()); + verify(mockRaftActor.actorDelegate).applyState(eq(mockActorRef), eq(id), any()); } @Test public void testRaftRoleChangeNotifierWhenRaftActorHasNoPeers() throws Exception { - TestActorRef notifierActor = factory.createTestActor( - Props.create(MessageCollectorActor.class)); + ActorRef notifierActor = factory.createActor(MessageCollectorActor.props()); MessageCollectorActor.waitUntilReady(notifierActor); DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); @@ -441,7 +434,7 @@ public class RaftActorTest extends AbstractActorTest { final TestActorRef raftActorRef = factory.createTestActor(MockRaftActor.builder() .id(persistenceId).config(config).roleChangeNotifier(notifierActor).dataPersistenceProvider( - new NonPersistentDataProvider()).props().withDispatcher(Dispatchers.DefaultDispatcherId()), + createProvider()).props().withDispatcher(Dispatchers.DefaultDispatcherId()), persistenceId); List matches = MessageCollectorActor.expectMatching(notifierActor, RoleChanged.class, 3); @@ -471,14 +464,14 @@ public class RaftActorTest extends AbstractActorTest { assertEquals(raftRoleChanged.getMemberId(), leaderStateChange.getLeaderId()); assertEquals(MockRaftActor.PAYLOAD_VERSION, leaderStateChange.getLeaderPayloadVersion()); - notifierActor.underlyingActor().clear(); + MessageCollectorActor.clearMessages(notifierActor); MockRaftActor raftActor = raftActorRef.underlyingActor(); final String newLeaderId = "new-leader"; final short newLeaderVersion = 6; Follower follower = new Follower(raftActor.getRaftActorContext()) { @Override - public RaftActorBehavior handleMessage(ActorRef sender, Object message) { + public RaftActorBehavior handleMessage(final ActorRef sender, final Object message) { setLeaderId(newLeaderId); setLeaderPayloadVersion(newLeaderVersion); return this; @@ -495,7 +488,7 @@ public class RaftActorTest extends AbstractActorTest { assertEquals(RaftState.Leader.name(), raftRoleChanged.getOldRole()); assertEquals(RaftState.Follower.name(), raftRoleChanged.getNewRole()); - notifierActor.underlyingActor().clear(); + MessageCollectorActor.clearMessages(notifierActor); raftActor.handleCommand("any"); @@ -504,7 +497,7 @@ public class RaftActorTest extends AbstractActorTest { assertEquals(newLeaderId, leaderStateChange.getLeaderId()); assertEquals(newLeaderVersion, leaderStateChange.getLeaderPayloadVersion()); - notifierActor.underlyingActor().clear(); + MessageCollectorActor.clearMessages(notifierActor); raftActor.handleCommand("any"); @@ -515,7 +508,7 @@ public class RaftActorTest extends AbstractActorTest { @Test public void testRaftRoleChangeNotifierWhenRaftActorHasPeers() throws Exception { - ActorRef notifierActor = factory.createActor(Props.create(MessageCollectorActor.class)); + ActorRef notifierActor = factory.createActor(MessageCollectorActor.props()); MessageCollectorActor.waitUntilReady(notifierActor); DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); @@ -560,8 +553,7 @@ public class RaftActorTest extends AbstractActorTest { final String persistenceId = factory.generateActorId("leader-"); final String follower1Id = factory.generateActorId("follower-"); - ActorRef followerActor1 = - factory.createActor(Props.create(MessageCollectorActor.class)); + ActorRef followerActor1 = factory.createActor(MessageCollectorActor.props()); DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); @@ -595,9 +587,9 @@ public class RaftActorTest extends AbstractActorTest { assertEquals(8, leaderActor.getReplicatedLog().size()); leaderActor.getRaftActorContext().getSnapshotManager().capture( - new MockRaftActorContext.MockReplicatedLogEntry(1, 6, new MockRaftActorContext.MockPayload("x")), 4); + new SimpleReplicatedLogEntry(6, 1, new MockRaftActorContext.MockPayload("x")), 4); - verify(leaderActor.snapshotCohortDelegate).createSnapshot(any(ActorRef.class)); + verify(leaderActor.snapshotCohortDelegate).createSnapshot(any(), any()); assertEquals(8, leaderActor.getReplicatedLog().size()); @@ -616,14 +608,14 @@ public class RaftActorTest extends AbstractActorTest { assertEquals(8, leaderActor.getReplicatedLog().size()); - ByteString snapshotBytes = fromObject(Arrays.asList( + 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"))); - leaderActor.getRaftActorContext().getSnapshotManager().persist(snapshotBytes.toByteArray(), + leaderActor.getRaftActorContext().getSnapshotManager().persist(snapshotState, java.util.Optional.empty(), Runtime.getRuntime().totalMemory()); assertTrue(leaderActor.getRaftActorContext().getSnapshotManager().isCapturing()); @@ -637,7 +629,7 @@ public class RaftActorTest extends AbstractActorTest { // add another non-replicated entry leaderActor.getReplicatedLog().append( - new ReplicatedLogImplEntry(8, 1, new MockRaftActorContext.MockPayload("foo-8"))); + new SimpleReplicatedLogEntry(8, 1, new MockRaftActorContext.MockPayload("foo-8"))); //fake snapshot on index 7, since lastApplied = 7 , we would keep the last applied leaderActor.onReceiveCommand(new AppendEntriesReply(follower1Id, 1, true, 7, 1, (short)0)); @@ -650,9 +642,7 @@ public class RaftActorTest extends AbstractActorTest { final String persistenceId = factory.generateActorId("follower-"); final String leaderId = factory.generateActorId("leader-"); - - ActorRef leaderActor1 = - factory.createActor(Props.create(MessageCollectorActor.class)); + ActorRef leaderActor1 = factory.createActor(MessageCollectorActor.props()); DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); @@ -687,30 +677,23 @@ public class RaftActorTest extends AbstractActorTest { //snapshot on 4 followerActor.getRaftActorContext().getSnapshotManager().capture( - new MockRaftActorContext.MockReplicatedLogEntry(1, 5, - new MockRaftActorContext.MockPayload("D")), 4); + new SimpleReplicatedLogEntry(5, 1, new MockRaftActorContext.MockPayload("D")), 4); - verify(followerActor.snapshotCohortDelegate).createSnapshot(any(ActorRef.class)); + verify(followerActor.snapshotCohortDelegate).createSnapshot(any(), any()); assertEquals(6, followerActor.getReplicatedLog().size()); //fake snapshot on index 6 - List entries = - Arrays.asList( - (ReplicatedLogEntry) new MockRaftActorContext.MockReplicatedLogEntry(1, 6, - new MockRaftActorContext.MockPayload("foo-6")) - ); + List entries = Arrays.asList( + (ReplicatedLogEntry) new SimpleReplicatedLogEntry(6, 1, new MockRaftActorContext.MockPayload("foo-6"))); followerActor.onReceiveCommand(new AppendEntries(1, leaderId, 5, 1, entries, 5, 5, (short)0)); assertEquals(7, followerActor.getReplicatedLog().size()); //fake snapshot on index 7 assertEquals(RaftState.Follower, followerActor.getCurrentBehavior().state()); - entries = - Arrays.asList( - (ReplicatedLogEntry) new MockRaftActorContext.MockReplicatedLogEntry(1, 7, - new MockRaftActorContext.MockPayload("foo-7")) - ); + entries = Arrays.asList((ReplicatedLogEntry) new SimpleReplicatedLogEntry(7, 1, + new MockRaftActorContext.MockPayload("foo-7"))); followerActor.onReceiveCommand(new AppendEntries(1, leaderId, 6, 1, entries, 6, 6, (short) 0)); assertEquals(8, followerActor.getReplicatedLog().size()); @@ -723,7 +706,8 @@ public class RaftActorTest extends AbstractActorTest { new MockRaftActorContext.MockPayload("foo-2"), new MockRaftActorContext.MockPayload("foo-3"), new MockRaftActorContext.MockPayload("foo-4"))); - followerActor.onReceiveCommand(new CaptureSnapshotReply(snapshotBytes.toByteArray())); + followerActor.onReceiveCommand(new CaptureSnapshotReply(ByteState.of(snapshotBytes.toByteArray()), + java.util.Optional.empty())); assertTrue(followerActor.getRaftActorContext().getSnapshotManager().isCapturing()); // The commit is needed to complete the snapshot creation process @@ -733,11 +717,8 @@ public class RaftActorTest extends AbstractActorTest { assertEquals(3, followerActor.getReplicatedLog().size()); //indexes 5,6,7 left in the log assertEquals(7, followerActor.getReplicatedLog().lastIndex()); - entries = - Arrays.asList( - (ReplicatedLogEntry) new MockRaftActorContext.MockReplicatedLogEntry(1, 8, - new MockRaftActorContext.MockPayload("foo-7")) - ); + entries = Arrays.asList((ReplicatedLogEntry) new SimpleReplicatedLogEntry(8, 1, + new MockRaftActorContext.MockPayload("foo-7"))); // send an additional entry 8 with leaderCommit = 7 followerActor.onReceiveCommand(new AppendEntries(1, leaderId, 7, 1, entries, 7, 7, (short) 0)); @@ -751,8 +732,8 @@ public class RaftActorTest extends AbstractActorTest { final String follower1Id = factory.generateActorId("follower-"); final String follower2Id = factory.generateActorId("follower-"); - final ActorRef followerActor1 = factory.createActor(Props.create(MessageCollectorActor.class), follower1Id); - final ActorRef followerActor2 = factory.createActor(Props.create(MessageCollectorActor.class), follower2Id); + final ActorRef followerActor1 = factory.createActor(MessageCollectorActor.props(), follower1Id); + final ActorRef followerActor2 = factory.createActor(MessageCollectorActor.props(), follower2Id); DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); @@ -817,7 +798,8 @@ public class RaftActorTest extends AbstractActorTest { new MockRaftActorContext.MockPayload("foo-2"), new MockRaftActorContext.MockPayload("foo-3"), new MockRaftActorContext.MockPayload("foo-4"))); - leaderActor.onReceiveCommand(new CaptureSnapshotReply(snapshotBytes.toByteArray())); + leaderActor.onReceiveCommand(new CaptureSnapshotReply(ByteState.of(snapshotBytes.toByteArray()), + java.util.Optional.empty())); assertTrue(leaderActor.getRaftActorContext().getSnapshotManager().isCapturing()); assertEquals("Real snapshot didn't clear the log till replicatedToAllIndex", 0, @@ -836,7 +818,7 @@ public class RaftActorTest extends AbstractActorTest { config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS)); config.setSnapshotBatchCount(5); - DataPersistenceProvider dataPersistenceProvider = new NonPersistentDataProvider(); + DataPersistenceProvider dataPersistenceProvider = createProvider(); Map peerAddresses = ImmutableMap.builder().put("member1", "address").build(); @@ -850,7 +832,7 @@ public class RaftActorTest extends AbstractActorTest { leaderActor.waitForInitializeBehaviorComplete(); for (int i = 0; i < 4; i++) { - leaderActor.getReplicatedLog().append(new MockRaftActorContext.MockReplicatedLogEntry(1, i, + leaderActor.getReplicatedLog().append(new SimpleReplicatedLogEntry(i, 1, new MockRaftActorContext.MockPayload("A"))); } @@ -863,7 +845,8 @@ public class RaftActorTest extends AbstractActorTest { leaderActor.getReplicatedLog().last(), -1, "member1"); // Now send a CaptureSnapshotReply - mockActorRef.tell(new CaptureSnapshotReply(fromObject("foo").toByteArray()), mockActorRef); + mockActorRef.tell(new CaptureSnapshotReply(ByteState.of(fromObject("foo").toByteArray()), + java.util.Optional.empty()), mockActorRef); // Trimming log in this scenario is a no-op assertEquals(-1, leaderActor.getReplicatedLog().getSnapshotIndex()); @@ -879,7 +862,7 @@ public class RaftActorTest extends AbstractActorTest { config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS)); config.setSnapshotBatchCount(5); - DataPersistenceProvider dataPersistenceProvider = new NonPersistentDataProvider(); + DataPersistenceProvider dataPersistenceProvider = createProvider(); Map peerAddresses = ImmutableMap.builder().put("member1", "address").build(); @@ -900,10 +883,11 @@ public class RaftActorTest extends AbstractActorTest { // Persist another entry (this will cause a CaptureSnapshot to be triggered leaderActor.persistData(mockActorRef, new MockIdentifier("x"), - new MockRaftActorContext.MockPayload("duh")); + new MockRaftActorContext.MockPayload("duh"), false); // Now send a CaptureSnapshotReply - mockActorRef.tell(new CaptureSnapshotReply(fromObject("foo").toByteArray()), mockActorRef); + mockActorRef.tell(new CaptureSnapshotReply(ByteState.of(fromObject("foo").toByteArray()), + java.util.Optional.empty()), mockActorRef); // Trimming log in this scenario is a no-op assertEquals(3, leaderActor.getReplicatedLog().getSnapshotIndex()); @@ -911,6 +895,10 @@ public class RaftActorTest extends AbstractActorTest { assertEquals(3, leader.getReplicatedToAllIndex()); } + private static DataPersistenceProvider createProvider() { + return new NonPersistentDataProvider(Runnable::run); + } + @Test public void testSwitchBehavior() { String persistenceId = factory.generateActorId("leader-"); @@ -920,7 +908,7 @@ public class RaftActorTest extends AbstractActorTest { config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS)); config.setSnapshotBatchCount(5); - DataPersistenceProvider dataPersistenceProvider = new NonPersistentDataProvider(); + DataPersistenceProvider dataPersistenceProvider = createProvider(); Map peerAddresses = ImmutableMap.builder().build(); @@ -952,7 +940,7 @@ public class RaftActorTest extends AbstractActorTest { assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); } - public static ByteString fromObject(Object snapshot) throws Exception { + public static ByteString fromObject(final Object snapshot) throws Exception { ByteArrayOutputStream bos = null; ObjectOutputStream os = null; try { @@ -973,7 +961,7 @@ public class RaftActorTest extends AbstractActorTest { } @Test - public void testUpdateConfigParam() throws Exception { + public void testUpdateConfigParam() { DefaultConfigParamsImpl emptyConfig = new DefaultConfigParamsImpl(); String persistenceId = factory.generateActorId("follower-"); ImmutableMap peerAddresses = @@ -1021,10 +1009,10 @@ public class RaftActorTest extends AbstractActorTest { } @Test - public void testGetSnapshot() throws Exception { + public void testGetSnapshot() { TEST_LOG.info("testGetSnapshot starting"); - final JavaTestKit kit = new JavaTestKit(getSystem()); + final TestKit kit = new TestKit(getSystem()); String persistenceId = factory.generateActorId("test-actor-"); DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); @@ -1033,12 +1021,12 @@ public class RaftActorTest extends AbstractActorTest { long term = 3; long seqN = 1; InMemoryJournal.addEntry(persistenceId, seqN++, new UpdateElectionTerm(term, "member-1")); - InMemoryJournal.addEntry(persistenceId, seqN++, new MockRaftActorContext.MockReplicatedLogEntry(term, 0, + InMemoryJournal.addEntry(persistenceId, seqN++, new SimpleReplicatedLogEntry(0, term, new MockRaftActorContext.MockPayload("A"))); - InMemoryJournal.addEntry(persistenceId, seqN++, new MockRaftActorContext.MockReplicatedLogEntry(term, 1, + InMemoryJournal.addEntry(persistenceId, seqN++, new SimpleReplicatedLogEntry(1, term, new MockRaftActorContext.MockPayload("B"))); InMemoryJournal.addEntry(persistenceId, seqN++, new ApplyJournalEntries(1)); - InMemoryJournal.addEntry(persistenceId, seqN++, new MockRaftActorContext.MockReplicatedLogEntry(term, 2, + InMemoryJournal.addEntry(persistenceId, seqN++, new SimpleReplicatedLogEntry(2, term, new MockRaftActorContext.MockPayload("C"))); TestActorRef raftActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, @@ -1053,36 +1041,39 @@ public class RaftActorTest extends AbstractActorTest { raftActorRef.tell(GetSnapshot.INSTANCE, kit.getRef()); ArgumentCaptor replyActor = ArgumentCaptor.forClass(ActorRef.class); - verify(mockRaftActor.snapshotCohortDelegate, timeout(5000)).createSnapshot(replyActor.capture()); + verify(mockRaftActor.snapshotCohortDelegate, timeout(5000)).createSnapshot(replyActor.capture(), + eq(java.util.Optional.empty())); byte[] stateSnapshot = new byte[]{1,2,3}; - replyActor.getValue().tell(new CaptureSnapshotReply(stateSnapshot), ActorRef.noSender()); + replyActor.getValue().tell(new CaptureSnapshotReply(ByteState.of(stateSnapshot), java.util.Optional.empty()), + ActorRef.noSender()); GetSnapshotReply reply = kit.expectMsgClass(GetSnapshotReply.class); assertEquals("getId", persistenceId, reply.getId()); - Snapshot replySnapshot = SerializationUtils.deserialize(reply.getSnapshot()); + 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()); - assertArrayEquals("getState", stateSnapshot, replySnapshot.getState()); + 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( - Duration.create(200, TimeUnit.MILLISECONDS)); + 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(Duration.create(30, TimeUnit.SECONDS)); + mockRaftActor.getSnapshotMessageSupport().setSnapshotReplyActorTimeout( + FiniteDuration.create(30, TimeUnit.SECONDS)); // Test with persistence disabled. @@ -1091,24 +1082,24 @@ public class RaftActorTest extends AbstractActorTest { raftActorRef.tell(GetSnapshot.INSTANCE, kit.getRef()); reply = kit.expectMsgClass(GetSnapshotReply.class); - verify(mockRaftActor.snapshotCohortDelegate, never()).createSnapshot(any(ActorRef.class)); + verify(mockRaftActor.snapshotCohortDelegate, never()).createSnapshot(any(), any()); assertEquals("getId", persistenceId, reply.getId()); - replySnapshot = SerializationUtils.deserialize(reply.getSnapshot()); + 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 length", 0, replySnapshot.getState().length); + assertEquals("getState type", EmptyState.INSTANCE, replySnapshot.getState()); assertEquals("getUnAppliedEntries size", 0, replySnapshot.getUnAppliedEntries().size()); TEST_LOG.info("testGetSnapshot ending"); } @Test - public void testRestoreFromSnapshot() throws Exception { + public void testRestoreFromSnapshot() { TEST_LOG.info("testRestoreFromSnapshot starting"); String persistenceId = factory.generateActorId("test-actor-"); @@ -1116,26 +1107,24 @@ public class RaftActorTest extends AbstractActorTest { config.setCustomRaftPolicyImplementationClass(DisableElectionsRaftPolicy.class.getName()); List snapshotUnappliedEntries = new ArrayList<>(); - snapshotUnappliedEntries.add(new MockRaftActorContext.MockReplicatedLogEntry(1, 4, - new MockRaftActorContext.MockPayload("E"))); + snapshotUnappliedEntries.add(new SimpleReplicatedLogEntry(4, 1, new MockRaftActorContext.MockPayload("E"))); int snapshotLastApplied = 3; int snapshotLastIndex = 4; - List state = Arrays.asList( + MockSnapshotState snapshotState = new MockSnapshotState(Arrays.asList( new MockRaftActorContext.MockPayload("A"), new MockRaftActorContext.MockPayload("B"), new MockRaftActorContext.MockPayload("C"), - new MockRaftActorContext.MockPayload("D")); - ByteString stateBytes = fromObject(state); + new MockRaftActorContext.MockPayload("D"))); - Snapshot snapshot = Snapshot.create(stateBytes.toByteArray(), snapshotUnappliedEntries, - snapshotLastIndex, 1, snapshotLastApplied, 1, 1, "member-1"); + Snapshot snapshot = Snapshot.create(snapshotState, snapshotUnappliedEntries, + snapshotLastIndex, 1, snapshotLastApplied, 1, 1, "member-1", null); InMemorySnapshotStore.addSnapshotSavedLatch(persistenceId); TestActorRef raftActorRef = factory.createTestActor(MockRaftActor.builder().id(persistenceId) - .config(config).restoreFromSnapshot(SerializationUtils.serialize(snapshot)).props() + .config(config).restoreFromSnapshot(snapshot).props() .withDispatcher(Dispatchers.DefaultDispatcherId()), persistenceId); MockRaftActor mockRaftActor = raftActorRef.underlyingActor(); @@ -1148,29 +1137,29 @@ public class RaftActorTest extends AbstractActorTest { assertEquals("getLastAppliedTerm", snapshot.getLastAppliedTerm(), savedSnapshot.getLastAppliedTerm()); assertEquals("getLastIndex", snapshot.getLastIndex(), savedSnapshot.getLastIndex()); assertEquals("getLastTerm", snapshot.getLastTerm(), savedSnapshot.getLastTerm()); - assertArrayEquals("getState", snapshot.getState(), savedSnapshot.getState()); + assertEquals("getState", snapshot.getState(), savedSnapshot.getState()); assertEquals("getUnAppliedEntries", snapshot.getUnAppliedEntries(), savedSnapshot.getUnAppliedEntries()); - verify(mockRaftActor.snapshotCohortDelegate, timeout(5000)).applySnapshot(any(byte[].class)); + verify(mockRaftActor.snapshotCohortDelegate, timeout(5000)).applySnapshot(any(Snapshot.State.class)); 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", state, mockRaftActor.getState()); + assertEquals("Recovered state", snapshotState.getState(), mockRaftActor.getState()); assertEquals("Current term", 1L, context.getTermInformation().getCurrentTerm()); assertEquals("Voted for", "member-1", context.getTermInformation().getVotedFor()); // Test with data persistence disabled - snapshot = Snapshot.create(new byte[0], Collections.emptyList(), - -1, -1, -1, -1, 5, "member-1"); + snapshot = Snapshot.create(EmptyState.INSTANCE, Collections.emptyList(), + -1, -1, -1, -1, 5, "member-1", null); persistenceId = factory.generateActorId("test-actor-"); raftActorRef = factory.createTestActor(MockRaftActor.builder().id(persistenceId) - .config(config).restoreFromSnapshot(SerializationUtils.serialize(snapshot)) + .config(config).restoreFromSnapshot(snapshot) .persistent(Optional.of(Boolean.FALSE)).props() .withDispatcher(Dispatchers.DefaultDispatcherId()), persistenceId); mockRaftActor = raftActorRef.underlyingActor(); @@ -1195,21 +1184,21 @@ public class RaftActorTest extends AbstractActorTest { config.setCustomRaftPolicyImplementationClass(DisableElectionsRaftPolicy.class.getName()); List state = Arrays.asList(new MockRaftActorContext.MockPayload("A")); - Snapshot snapshot = Snapshot.create(fromObject(state).toByteArray(), Arrays.asList(), - 5, 2, 5, 2, 2, "member-1"); + Snapshot snapshot = Snapshot.create(ByteState.of(fromObject(state).toByteArray()), + Arrays.asList(), 5, 2, 5, 2, 2, "member-1", null); - InMemoryJournal.addEntry(persistenceId, 1, new MockRaftActorContext.MockReplicatedLogEntry(1, 0, + InMemoryJournal.addEntry(persistenceId, 1, new SimpleReplicatedLogEntry(0, 1, new MockRaftActorContext.MockPayload("B"))); TestActorRef raftActorRef = factory.createTestActor(MockRaftActor.builder().id(persistenceId) - .config(config).restoreFromSnapshot(SerializationUtils.serialize(snapshot)).props() + .config(config).restoreFromSnapshot(snapshot).props() .withDispatcher(Dispatchers.DefaultDispatcherId()), persistenceId); MockRaftActor mockRaftActor = raftActorRef.underlyingActor(); mockRaftActor.waitForRecoveryComplete(); Uninterruptibles.sleepUninterruptibly(500, TimeUnit.MILLISECONDS); - verify(mockRaftActor.snapshotCohortDelegate, never()).applySnapshot(any(byte[].class)); + verify(mockRaftActor.snapshotCohortDelegate, never()).applySnapshot(any(Snapshot.State.class)); RaftActorContext context = mockRaftActor.getRaftActorContext(); assertEquals("Journal log size", 1, context.getReplicatedLog().size()); @@ -1223,7 +1212,7 @@ public class RaftActorTest extends AbstractActorTest { } @Test - public void testNonVotingOnRecovery() throws Exception { + public void testNonVotingOnRecovery() { TEST_LOG.info("testNonVotingOnRecovery starting"); DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); @@ -1231,7 +1220,7 @@ public class RaftActorTest extends AbstractActorTest { config.setHeartBeatInterval(FiniteDuration.create(1, TimeUnit.MILLISECONDS)); String persistenceId = factory.generateActorId("test-actor-"); - InMemoryJournal.addEntry(persistenceId, 1, new MockRaftActorContext.MockReplicatedLogEntry(1, 0, + InMemoryJournal.addEntry(persistenceId, 1, new SimpleReplicatedLogEntry(0, 1, new ServerConfigurationPayload(Arrays.asList(new ServerInfo(persistenceId, false))))); TestActorRef raftActorRef = factory.createTestActor(MockRaftActor.builder().id(persistenceId) @@ -1249,11 +1238,10 @@ public class RaftActorTest extends AbstractActorTest { } @Test - public void testLeaderTransitioning() throws Exception { + public void testLeaderTransitioning() { TEST_LOG.info("testLeaderTransitioning starting"); - TestActorRef notifierActor = factory.createTestActor( - Props.create(MessageCollectorActor.class)); + ActorRef notifierActor = factory.createActor(MessageCollectorActor.props()); DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); config.setCustomRaftPolicyImplementationClass(DisableElectionsRaftPolicy.class.getName()); @@ -1275,7 +1263,7 @@ public class RaftActorTest extends AbstractActorTest { MessageCollectorActor.clearMessages(notifierActor); - raftActorRef.tell(LeaderTransitioning.INSTANCE, ActorRef.noSender()); + raftActorRef.tell(new LeaderTransitioning("leader"), ActorRef.noSender()); leaderStateChange = MessageCollectorActor.expectFirstMatching(notifierActor, LeaderStateChanged.class); assertEquals("getMemberId", persistenceId, leaderStateChange.getMemberId()); @@ -1290,7 +1278,7 @@ public class RaftActorTest extends AbstractActorTest { final String leaderId = factory.generateActorId("leader-"); final String followerId = factory.generateActorId("follower-"); - final ActorRef followerActor = factory.createActor(Props.create(MessageCollectorActor.class)); + final ActorRef followerActor = factory.createActor(MessageCollectorActor.props()); DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); @@ -1310,7 +1298,8 @@ public class RaftActorTest extends AbstractActorTest { Leader leader = new Leader(leaderActor.getRaftActorContext()); leaderActor.setCurrentBehavior(leader); - leaderActor.persistData(leaderActorRef, new MockIdentifier("1"), new MockRaftActorContext.MockPayload("1")); + leaderActor.persistData(leaderActorRef, new MockIdentifier("1"), new MockRaftActorContext.MockPayload("1"), + false); ReplicatedLogEntry logEntry = leaderActor.getReplicatedLog().get(0); assertNotNull("ReplicatedLogEntry not found", logEntry); @@ -1328,4 +1317,106 @@ public class RaftActorTest extends AbstractActorTest { assertEquals("getCommitIndex", 0, leaderActor.getRaftActorContext().getCommitIndex()); assertEquals("getLastApplied", 0, leaderActor.getRaftActorContext().getLastApplied()); } + + @Test + public void testReplicateWithBatchHint() throws Exception { + final String leaderId = factory.generateActorId("leader-"); + final String followerId = factory.generateActorId("follower-"); + + final ActorRef followerActor = factory.createActor(MessageCollectorActor.props()); + + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS)); + + 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); + + Leader leader = new Leader(leaderActor.getRaftActorContext()); + leaderActor.setCurrentBehavior(leader); + + MessageCollectorActor.expectFirstMatching(followerActor, AppendEntries.class); + MessageCollectorActor.clearMessages(followerActor); + + leaderActor.onReceiveCommand(new AppendEntriesReply(followerId, 1, true, -1, -1, (short)0)); + + leaderActor.persistData(leaderActorRef, new MockIdentifier("1"), new MockPayload("1"), true); + MessageCollectorActor.assertNoneMatching(followerActor, AppendEntries.class, 500); + + 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 + @SuppressWarnings("checkstyle:illegalcatch") + public void testApplyStateRace() throws Exception { + final String leaderId = factory.generateActorId("leader-"); + final String followerId = factory.generateActorId("follower-"); + + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS)); + config.setCustomRaftPolicyImplementationClass(DisableElectionsRaftPolicy.class.getName()); + + ActorRef mockFollowerActorRef = factory.createActor(MessageCollectorActor.props()); + + 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"))); + + TestActorRef leaderActorRef = factory.createTestActor( + builder.props(), leaderId); + MockRaftActor leaderActor = leaderActorRef.underlyingActor(); + leaderActor.waitForInitializeBehaviorComplete(); + + leaderActor.getRaftActorContext().getTermInformation().update(1, leaderId); + Leader leader = new Leader(leaderActor.getRaftActorContext()); + leaderActor.setCurrentBehavior(leader); + + final ExecutorService executorService = Executors.newSingleThreadExecutor(); + + 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"); + } + }); + + 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); + + 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(); + } }