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=fde56a9a21e1145895282d0a97fe8dd736e4807e;hb=HEAD;hp=d0cedce83a1d0787317e03c50e62537be511a774;hpb=a4fcc7debbd036c6e1df8c88df1c0268c62e76e4;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 d0cedce83a..fde56a9a21 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,9 +5,9 @@ * 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.assertNotNull; import static org.junit.Assert.assertNotSame; @@ -15,7 +15,6 @@ import static org.junit.Assert.assertNull; import static org.junit.Assert.assertSame; import static org.junit.Assert.assertTrue; import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.anyObject; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.ArgumentMatchers.same; import static org.mockito.Mockito.doReturn; @@ -24,6 +23,7 @@ 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 static org.mockito.Mockito.when; import akka.actor.ActorRef; import akka.actor.PoisonPill; @@ -38,18 +38,15 @@ import akka.persistence.SnapshotOffer; 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 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.Optional; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; import org.junit.After; @@ -61,6 +58,8 @@ 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; @@ -138,22 +137,20 @@ public class RaftActorTest extends AbstractActorTest { // log entry. config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); - ImmutableMap peerAddresses = ImmutableMap.builder() - .put("member1", "address").build(); + Map peerAddresses = Map.of("member1", "address"); ActorRef followerActor = factory.createActor(MockRaftActor.props(persistenceId, peerAddresses, config), persistenceId); kit.watch(followerActor); - List snapshotUnappliedEntries = new ArrayList<>(); - ReplicatedLogEntry entry1 = new SimpleReplicatedLogEntry(4, 1, new MockRaftActorContext.MockPayload("E")); - snapshotUnappliedEntries.add(entry1); + List snapshotUnappliedEntries = List.of( + new SimpleReplicatedLogEntry(4, 1, new MockRaftActorContext.MockPayload("E"))); int lastAppliedDuringSnapshotCapture = 3; int lastIndexDuringSnapshotCapture = 4; // 4 messages as part of snapshot, which are applied to state - MockSnapshotState snapshotState = new MockSnapshotState(Arrays.asList( + MockSnapshotState snapshotState = new MockSnapshotState(List.of( new MockRaftActorContext.MockPayload("A"), new MockRaftActorContext.MockPayload("B"), new MockRaftActorContext.MockPayload("C"), @@ -164,13 +161,9 @@ public class RaftActorTest extends AbstractActorTest { InMemorySnapshotStore.addSnapshot(persistenceId, snapshot); // 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); final int lastAppliedToState = 5; final int lastIndex = 7; @@ -196,7 +189,7 @@ public class RaftActorTest extends AbstractActorTest { mockRaftActor.waitForRecoveryComplete(); RaftActorContext context = mockRaftActor.getRaftActorContext(); - assertEquals("Journal log size", snapshotUnappliedEntries.size() + entries.size(), + assertEquals("Journal log size", snapshotUnappliedEntries.size() + 3, context.getReplicatedLog().size()); assertEquals("Journal data size", 10, context.getReplicatedLog().dataSize()); assertEquals("Last index", lastIndex, context.getReplicatedLog().lastIndex()); @@ -220,8 +213,7 @@ public class RaftActorTest extends AbstractActorTest { config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); TestActorRef ref = factory.createTestActor(MockRaftActor.props(persistenceId, - ImmutableMap.builder().put("member1", "address").build(), - config, createProvider()), persistenceId); + Map.of("member1", "address"), config, createProvider()), persistenceId); MockRaftActor mockRaftActor = ref.underlyingActor(); @@ -243,8 +235,7 @@ public class RaftActorTest extends AbstractActorTest { InMemoryJournal.addWriteMessagesCompleteLatch(persistenceId, 1); TestActorRef ref = factory.createTestActor(MockRaftActor.props(persistenceId, - ImmutableMap.builder().put("member1", "address").build(), - config, createProvider()) + Map.of("member1", "address"), config, createProvider()) .withDispatcher(Dispatchers.DefaultDispatcherId()), persistenceId); InMemoryJournal.waitForWriteMessagesComplete(persistenceId); @@ -255,8 +246,7 @@ public class RaftActorTest extends AbstractActorTest { factory.killActor(ref, kit); config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); - ref = factory.createTestActor(MockRaftActor.props(persistenceId, - ImmutableMap.builder().put("member1", "address").build(), config, + ref = factory.createTestActor(MockRaftActor.props(persistenceId, Map.of("member1", "address"), config, createProvider()).withDispatcher(Dispatchers.DefaultDispatcherId()), factory.generateActorId("follower-")); @@ -281,7 +271,7 @@ public class RaftActorTest extends AbstractActorTest { config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); TestActorRef mockActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, - Collections.emptyMap(), config), persistenceId); + Map.of(), config), persistenceId); MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); @@ -292,7 +282,7 @@ public class RaftActorTest extends AbstractActorTest { mockRaftActor.setRaftActorRecoverySupport(mockSupport); Snapshot snapshot = Snapshot.create(ByteState.of(new byte[]{1}), - Collections.emptyList(), 3, 1, 3, 1, -1, null, null); + List.of(), 3, 1, 3, 1, -1, null, null); SnapshotOffer snapshotOffer = new SnapshotOffer(new SnapshotMetadata("test", 6, 12345), snapshot); mockRaftActor.handleRecover(snapshotOffer); @@ -333,29 +323,29 @@ public class RaftActorTest extends AbstractActorTest { // Wait for akka's recovery to complete so it doesn't interfere. mockRaftActor.waitForRecoveryComplete(); - ApplySnapshot applySnapshot = new ApplySnapshot(mock(Snapshot.class)); - doReturn(true).when(mockSupport).handleSnapshotMessage(same(applySnapshot), any(ActorRef.class)); + ApplySnapshot applySnapshot = new ApplySnapshot( + Snapshot.create(null, null, 0, 0, 0, 0, 0, persistenceId, null)); + when(mockSupport.handleSnapshotMessage(same(applySnapshot), any(ActorRef.class))).thenReturn(true); mockRaftActor.handleCommand(applySnapshot); - CaptureSnapshotReply captureSnapshotReply = new CaptureSnapshotReply(ByteState.empty(), - java.util.Optional.empty()); - doReturn(true).when(mockSupport).handleSnapshotMessage(same(captureSnapshotReply), any(ActorRef.class)); + CaptureSnapshotReply captureSnapshotReply = new CaptureSnapshotReply(ByteState.empty(), Optional.empty()); + when(mockSupport.handleSnapshotMessage(same(captureSnapshotReply), any(ActorRef.class))).thenReturn(true); mockRaftActor.handleCommand(captureSnapshotReply); SaveSnapshotSuccess saveSnapshotSuccess = new SaveSnapshotSuccess(new SnapshotMetadata("", 0L, 0L)); - doReturn(true).when(mockSupport).handleSnapshotMessage(same(saveSnapshotSuccess), any(ActorRef.class)); + when(mockSupport.handleSnapshotMessage(same(saveSnapshotSuccess), any(ActorRef.class))).thenReturn(true); mockRaftActor.handleCommand(saveSnapshotSuccess); SaveSnapshotFailure saveSnapshotFailure = new SaveSnapshotFailure(new SnapshotMetadata("", 0L, 0L), new Throwable()); - doReturn(true).when(mockSupport).handleSnapshotMessage(same(saveSnapshotFailure), any(ActorRef.class)); + when(mockSupport.handleSnapshotMessage(same(saveSnapshotFailure), any(ActorRef.class))).thenReturn(true); mockRaftActor.handleCommand(saveSnapshotFailure); - doReturn(true).when(mockSupport).handleSnapshotMessage(same(RaftActorSnapshotMessageSupport.COMMIT_SNAPSHOT), - any(ActorRef.class)); + when(mockSupport.handleSnapshotMessage(same(RaftActorSnapshotMessageSupport.COMMIT_SNAPSHOT), + any(ActorRef.class))).thenReturn(true); mockRaftActor.handleCommand(RaftActorSnapshotMessageSupport.COMMIT_SNAPSHOT); - doReturn(true).when(mockSupport).handleSnapshotMessage(same(GetSnapshot.INSTANCE), any(ActorRef.class)); + when(mockSupport.handleSnapshotMessage(same(GetSnapshot.INSTANCE), any(ActorRef.class))).thenReturn(true); mockRaftActor.handleCommand(GetSnapshot.INSTANCE); verify(mockSupport).handleSnapshotMessage(same(applySnapshot), any(ActorRef.class)); @@ -379,7 +369,7 @@ public class RaftActorTest extends AbstractActorTest { DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); TestActorRef mockActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, - Collections.emptyMap(), config, dataPersistenceProvider), persistenceId); + Map.of(), config, dataPersistenceProvider), persistenceId); MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); @@ -387,7 +377,7 @@ public class RaftActorTest extends AbstractActorTest { mockRaftActor.waitUntilLeader(); - mockRaftActor.onReceiveCommand(new ApplyJournalEntries(10)); + mockRaftActor.handleCommand(new ApplyJournalEntries(10)); verify(dataPersistenceProvider).persistAsync(any(ApplyJournalEntries.class), any(Procedure.class)); } @@ -403,7 +393,7 @@ public class RaftActorTest extends AbstractActorTest { DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); TestActorRef mockActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, - Collections.emptyMap(), config, dataPersistenceProvider), persistenceId); + Map.of(), config, dataPersistenceProvider), persistenceId); MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); @@ -414,7 +404,7 @@ public class RaftActorTest extends AbstractActorTest { final Identifier id = new MockIdentifier("apply-state"); 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 @@ -516,7 +506,7 @@ public class RaftActorTest extends AbstractActorTest { String persistenceId = factory.generateActorId("notifier-"); factory.createActor(MockRaftActor.builder().id(persistenceId) - .peerAddresses(ImmutableMap.of("leader", "fake/path")) + .peerAddresses(Map.of("leader", "fake/path")) .config(config).roleChangeNotifier(notifierActor).props()); List matches = null; @@ -558,8 +548,7 @@ public class RaftActorTest extends AbstractActorTest { DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); - Map peerAddresses = new HashMap<>(); - peerAddresses.put(follower1Id, followerActor1.path().toString()); + Map peerAddresses = Map.of(follower1Id, followerActor1.path().toString()); TestActorRef mockActorRef = factory.createTestActor( MockRaftActor.props(persistenceId, peerAddresses, config, dataPersistenceProvider), persistenceId); @@ -586,33 +575,33 @@ public class RaftActorTest extends AbstractActorTest { leaderActor.getRaftActorContext().getSnapshotManager().capture( new SimpleReplicatedLogEntry(6, 1, new MockRaftActorContext.MockPayload("x")), 4); - verify(leaderActor.snapshotCohortDelegate).createSnapshot(anyObject(), anyObject()); + verify(leaderActor.snapshotCohortDelegate).createSnapshot(any(), any()); assertEquals(8, leaderActor.getReplicatedLog().size()); assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); //fake snapshot on index 5 - leaderActor.onReceiveCommand(new AppendEntriesReply(follower1Id, 1, true, 5, 1, (short)0)); + leaderActor.handleCommand(new AppendEntriesReply(follower1Id, 1, true, 5, 1, (short)0)); assertEquals(8, leaderActor.getReplicatedLog().size()); //fake snapshot on index 6 assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); - leaderActor.onReceiveCommand(new AppendEntriesReply(follower1Id, 1, true, 6, 1, (short)0)); + leaderActor.handleCommand(new AppendEntriesReply(follower1Id, 1, true, 6, 1, (short)0)); assertEquals(8, leaderActor.getReplicatedLog().size()); assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); assertEquals(8, leaderActor.getReplicatedLog().size()); - MockSnapshotState snapshotState = new MockSnapshotState(Arrays.asList( + MockSnapshotState snapshotState = new MockSnapshotState(List.of( 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(snapshotState, java.util.Optional.empty(), + leaderActor.getRaftActorContext().getSnapshotManager().persist(snapshotState, Optional.empty(), Runtime.getRuntime().totalMemory()); assertTrue(leaderActor.getRaftActorContext().getSnapshotManager().isCapturing()); @@ -629,7 +618,7 @@ public class RaftActorTest extends AbstractActorTest { 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)); + leaderActor.handleCommand(new AppendEntriesReply(follower1Id, 1, true, 7, 1, (short)0)); assertEquals(2, leaderActor.getReplicatedLog().size()); assertEquals(8, leaderActor.getReplicatedLog().lastIndex()); } @@ -647,8 +636,7 @@ public class RaftActorTest extends AbstractActorTest { DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); - Map peerAddresses = new HashMap<>(); - peerAddresses.put(leaderId, leaderActor1.path().toString()); + Map peerAddresses = Map.of(leaderId, leaderActor1.path().toString()); TestActorRef mockActorRef = factory.createTestActor( MockRaftActor.props(persistenceId, peerAddresses, config, dataPersistenceProvider), persistenceId); @@ -676,35 +664,35 @@ public class RaftActorTest extends AbstractActorTest { followerActor.getRaftActorContext().getSnapshotManager().capture( new SimpleReplicatedLogEntry(5, 1, new MockRaftActorContext.MockPayload("D")), 4); - verify(followerActor.snapshotCohortDelegate).createSnapshot(anyObject(), anyObject()); + verify(followerActor.snapshotCohortDelegate).createSnapshot(any(), any()); assertEquals(6, followerActor.getReplicatedLog().size()); //fake snapshot on index 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)); + List entries = List.of( + 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()); //fake snapshot on index 7 assertEquals(RaftState.Follower, followerActor.getCurrentBehavior().state()); - entries = Arrays.asList((ReplicatedLogEntry) new SimpleReplicatedLogEntry(7, 1, + entries = List.of(new SimpleReplicatedLogEntry(7, 1, new MockRaftActorContext.MockPayload("foo-7"))); - followerActor.onReceiveCommand(new AppendEntries(1, leaderId, 6, 1, entries, 6, 6, (short) 0)); + followerActor.handleCommand(new AppendEntries(1, leaderId, 6, 1, entries, 6, 6, (short) 0)); assertEquals(8, followerActor.getReplicatedLog().size()); assertEquals(RaftState.Follower, followerActor.getCurrentBehavior().state()); - ByteString snapshotBytes = fromObject(Arrays.asList( + ByteString snapshotBytes = fromObject(List.of( 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(ByteState.of(snapshotBytes.toByteArray()), - java.util.Optional.empty())); + followerActor.handleCommand(new CaptureSnapshotReply(ByteState.of(snapshotBytes.toByteArray()), + Optional.empty())); assertTrue(followerActor.getRaftActorContext().getSnapshotManager().isCapturing()); // The commit is needed to complete the snapshot creation process @@ -714,10 +702,9 @@ 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 SimpleReplicatedLogEntry(8, 1, - new MockRaftActorContext.MockPayload("foo-7"))); + entries = List.of(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)); + followerActor.handleCommand(new AppendEntries(1, leaderId, 7, 1, entries, 7, 7, (short) 0)); // 7 and 8, as lastapplied is 7 assertEquals(2, followerActor.getReplicatedLog().size()); @@ -738,9 +725,9 @@ public class RaftActorTest extends AbstractActorTest { DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); - Map peerAddresses = new HashMap<>(); - peerAddresses.put(follower1Id, followerActor1.path().toString()); - peerAddresses.put(follower2Id, followerActor2.path().toString()); + Map peerAddresses = Map.of( + follower1Id, followerActor1.path().toString(), + follower2Id, followerActor2.path().toString()); TestActorRef mockActorRef = factory.createTestActor( MockRaftActor.props(persistenceId, peerAddresses, config, dataPersistenceProvider), persistenceId); @@ -767,17 +754,17 @@ public class RaftActorTest extends AbstractActorTest { assertEquals(5, leaderActor.getReplicatedLog().size()); assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); - leaderActor.onReceiveCommand(new AppendEntriesReply(follower1Id, 1, true, 9, 1, (short) 0)); + 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.onReceiveCommand(new AppendEntriesReply(follower2Id, 1, true, 0, 1, (short)0)); + 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.onReceiveCommand(SendHeartBeat.INSTANCE); + 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()), @@ -785,25 +772,25 @@ public class RaftActorTest extends AbstractActorTest { //reply from a slow follower does not initiate a fake snapshot - leaderActor.onReceiveCommand(new AppendEntriesReply(follower2Id, 1, true, 9, 1, (short)0)); + 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( + ByteString snapshotBytes = fromObject(List.of( 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(ByteState.of(snapshotBytes.toByteArray()), - java.util.Optional.empty())); + 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.onReceiveCommand(new AppendEntriesReply(follower2Id, 1, true, 5, 1, (short) 0)); + leaderActor.handleCommand(new AppendEntriesReply(follower2Id, 1, true, 5, 1, (short) 0)); assertEquals(0, leaderActor.getReplicatedLog().size()); } @@ -817,7 +804,7 @@ public class RaftActorTest extends AbstractActorTest { DataPersistenceProvider dataPersistenceProvider = createProvider(); - Map peerAddresses = ImmutableMap.builder().put("member1", "address").build(); + Map peerAddresses = Map.of("member1", "address"); TestActorRef mockActorRef = factory.createTestActor( MockRaftActor.props(persistenceId, peerAddresses, config, dataPersistenceProvider), persistenceId); @@ -843,7 +830,7 @@ public class RaftActorTest extends AbstractActorTest { // Now send a CaptureSnapshotReply mockActorRef.tell(new CaptureSnapshotReply(ByteState.of(fromObject("foo").toByteArray()), - java.util.Optional.empty()), mockActorRef); + Optional.empty()), mockActorRef); // Trimming log in this scenario is a no-op assertEquals(-1, leaderActor.getReplicatedLog().getSnapshotIndex()); @@ -861,7 +848,7 @@ public class RaftActorTest extends AbstractActorTest { DataPersistenceProvider dataPersistenceProvider = createProvider(); - Map peerAddresses = ImmutableMap.builder().put("member1", "address").build(); + Map peerAddresses = Map.of("member1", "address"); TestActorRef mockActorRef = factory.createTestActor( MockRaftActor.props(persistenceId, peerAddresses, config, dataPersistenceProvider), persistenceId); @@ -884,7 +871,7 @@ public class RaftActorTest extends AbstractActorTest { // Now send a CaptureSnapshotReply mockActorRef.tell(new CaptureSnapshotReply(ByteState.of(fromObject("foo").toByteArray()), - java.util.Optional.empty()), mockActorRef); + Optional.empty()), mockActorRef); // Trimming log in this scenario is a no-op assertEquals(3, leaderActor.getReplicatedLog().getSnapshotIndex()); @@ -907,7 +894,7 @@ public class RaftActorTest extends AbstractActorTest { DataPersistenceProvider dataPersistenceProvider = createProvider(); - Map peerAddresses = ImmutableMap.builder().build(); + Map peerAddresses = Map.of(); TestActorRef mockActorRef = factory.createTestActor( MockRaftActor.props(persistenceId, peerAddresses, config, dataPersistenceProvider), persistenceId); @@ -961,8 +948,7 @@ public class RaftActorTest extends AbstractActorTest { public void testUpdateConfigParam() { DefaultConfigParamsImpl emptyConfig = new DefaultConfigParamsImpl(); String persistenceId = factory.generateActorId("follower-"); - ImmutableMap peerAddresses = - ImmutableMap.builder().put("member1", "address").build(); + Map peerAddresses = Map.of("member1", "address"); DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); TestActorRef actorRef = factory.createTestActor( @@ -1027,7 +1013,7 @@ public class RaftActorTest extends AbstractActorTest { new MockRaftActorContext.MockPayload("C"))); TestActorRef raftActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, - ImmutableMap.builder().put("member1", "address").build(), config) + Map.of("member1", "address"), config) .withDispatcher(Dispatchers.DefaultDispatcherId()), persistenceId); MockRaftActor mockRaftActor = raftActorRef.underlyingActor(); @@ -1039,10 +1025,10 @@ public class RaftActorTest extends AbstractActorTest { ArgumentCaptor replyActor = ArgumentCaptor.forClass(ActorRef.class); verify(mockRaftActor.snapshotCohortDelegate, timeout(5000)).createSnapshot(replyActor.capture(), - eq(java.util.Optional.empty())); + eq(Optional.empty())); byte[] stateSnapshot = new byte[]{1,2,3}; - replyActor.getValue().tell(new CaptureSnapshotReply(ByteState.of(stateSnapshot), java.util.Optional.empty()), + replyActor.getValue().tell(new CaptureSnapshotReply(ByteState.of(stateSnapshot), Optional.empty()), ActorRef.noSender()); GetSnapshotReply reply = kit.expectMsgClass(GetSnapshotReply.class); @@ -1079,7 +1065,7 @@ public class RaftActorTest extends AbstractActorTest { raftActorRef.tell(GetSnapshot.INSTANCE, kit.getRef()); reply = kit.expectMsgClass(GetSnapshotReply.class); - verify(mockRaftActor.snapshotCohortDelegate, never()).createSnapshot(anyObject(), anyObject()); + verify(mockRaftActor.snapshotCohortDelegate, never()).createSnapshot(any(), any()); assertEquals("getId", persistenceId, reply.getId()); replySnapshot = reply.getSnapshot(); @@ -1103,13 +1089,13 @@ public class RaftActorTest extends AbstractActorTest { DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); config.setCustomRaftPolicyImplementationClass(DisableElectionsRaftPolicy.class.getName()); - List snapshotUnappliedEntries = new ArrayList<>(); - snapshotUnappliedEntries.add(new SimpleReplicatedLogEntry(4, 1, new MockRaftActorContext.MockPayload("E"))); + List snapshotUnappliedEntries = List.of( + new SimpleReplicatedLogEntry(4, 1, new MockRaftActorContext.MockPayload("E"))); int snapshotLastApplied = 3; int snapshotLastIndex = 4; - MockSnapshotState snapshotState = new MockSnapshotState(Arrays.asList( + MockSnapshotState snapshotState = new MockSnapshotState(List.of( new MockRaftActorContext.MockPayload("A"), new MockRaftActorContext.MockPayload("B"), new MockRaftActorContext.MockPayload("C"), @@ -1150,7 +1136,7 @@ public class RaftActorTest extends AbstractActorTest { // Test with data persistence disabled - snapshot = Snapshot.create(EmptyState.INSTANCE, Collections.emptyList(), + snapshot = Snapshot.create(EmptyState.INSTANCE, List.of(), -1, -1, -1, -1, 5, "member-1", null); persistenceId = factory.generateActorId("test-actor-"); @@ -1180,9 +1166,9 @@ public class RaftActorTest extends AbstractActorTest { DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); config.setCustomRaftPolicyImplementationClass(DisableElectionsRaftPolicy.class.getName()); - List state = Arrays.asList(new MockRaftActorContext.MockPayload("A")); + List state = List.of(new MockRaftActorContext.MockPayload("A")); Snapshot snapshot = Snapshot.create(ByteState.of(fromObject(state).toByteArray()), - Arrays.asList(), 5, 2, 5, 2, 2, "member-1", null); + List.of(), 5, 2, 5, 2, 2, "member-1", null); InMemoryJournal.addEntry(persistenceId, 1, new SimpleReplicatedLogEntry(0, 1, new MockRaftActorContext.MockPayload("B"))); @@ -1218,7 +1204,7 @@ public class RaftActorTest extends AbstractActorTest { String persistenceId = factory.generateActorId("test-actor-"); InMemoryJournal.addEntry(persistenceId, 1, new SimpleReplicatedLogEntry(0, 1, - new ServerConfigurationPayload(Arrays.asList(new ServerInfo(persistenceId, false))))); + new ServerConfigurationPayload(List.of(new ServerInfo(persistenceId, false))))); TestActorRef raftActorRef = factory.createTestActor(MockRaftActor.builder().id(persistenceId) .config(config).props().withDispatcher(Dispatchers.DefaultDispatcherId()), persistenceId); @@ -1252,7 +1238,7 @@ public class RaftActorTest extends AbstractActorTest { mockRaftActor.waitForInitializeBehaviorComplete(); - raftActorRef.tell(new AppendEntries(1L, "leader", 0L, 1L, Collections.emptyList(), + raftActorRef.tell(new AppendEntries(1L, "leader", 0L, 1L, List.of(), 0L, -1L, (short)1), ActorRef.noSender()); LeaderStateChanged leaderStateChange = MessageCollectorActor.expectFirstMatching( notifierActor, LeaderStateChanged.class); @@ -1285,7 +1271,7 @@ public class RaftActorTest extends AbstractActorTest { doReturn(true).when(mockPersistenceProvider).isRecoveryApplicable(); TestActorRef leaderActorRef = factory.createTestActor( - MockRaftActor.props(leaderId, ImmutableMap.of(followerId, followerActor.path().toString()), config, + MockRaftActor.props(leaderId, Map.of(followerId, followerActor.path().toString()), config, mockPersistenceProvider), leaderId); MockRaftActor leaderActor = leaderActorRef.underlyingActor(); leaderActor.waitForInitializeBehaviorComplete(); @@ -1303,7 +1289,7 @@ public class RaftActorTest extends AbstractActorTest { assertEquals("isPersistencePending", true, logEntry.isPersistencePending()); assertEquals("getCommitIndex", -1, leaderActor.getRaftActorContext().getCommitIndex()); - leaderActor.onReceiveCommand(new AppendEntriesReply(followerId, 1, true, 0, 1, (short)0)); + leaderActor.handleCommand(new AppendEntriesReply(followerId, 1, true, 0, 1, (short)0)); assertEquals("getCommitIndex", -1, leaderActor.getRaftActorContext().getCommitIndex()); ArgumentCaptor callbackCaptor = ArgumentCaptor.forClass(Procedure.class); @@ -1327,7 +1313,7 @@ public class RaftActorTest extends AbstractActorTest { config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS)); TestActorRef leaderActorRef = factory.createTestActor( - MockRaftActor.props(leaderId, ImmutableMap.of(followerId, followerActor.path().toString()), config), + MockRaftActor.props(leaderId, Map.of(followerId, followerActor.path().toString()), config), leaderId); MockRaftActor leaderActor = leaderActorRef.underlyingActor(); leaderActor.waitForInitializeBehaviorComplete(); @@ -1340,7 +1326,7 @@ public class RaftActorTest extends AbstractActorTest { MessageCollectorActor.expectFirstMatching(followerActor, AppendEntries.class); MessageCollectorActor.clearMessages(followerActor); - leaderActor.onReceiveCommand(new AppendEntriesReply(followerId, 1, true, -1, -1, (short)0)); + leaderActor.handleCommand(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); @@ -1352,4 +1338,67 @@ public class RaftActorTest extends AbstractActorTest { 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(Map.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(); + } }