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=48b555faff286c0393cb2c6ec39030c651751822;hp=bc6257b67d50c85b6c6cb2eb6e165d87e216ebbb;hb=93e6f3bfc003d4ce2d968761dff963615a0b799d;hpb=47b382cfd70014ff286c5a107da964f23f1df467 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 bc6257b67d..48b555faff 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,9 +1,19 @@ +/* + * Copyright (c) 2014, 2015 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + package org.opendaylight.controller.cluster.raft; +import static org.junit.Assert.assertArrayEquals; import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; 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; @@ -11,18 +21,21 @@ import static org.mockito.Matchers.eq; import static org.mockito.Matchers.same; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.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.PoisonPill; import akka.actor.Props; +import akka.actor.Status.Failure; import akka.actor.Terminated; +import akka.dispatch.Dispatchers; import akka.japi.Procedure; import akka.persistence.SaveSnapshotFailure; import akka.persistence.SaveSnapshotSuccess; import akka.persistence.SnapshotMetadata; import akka.persistence.SnapshotOffer; -import akka.persistence.SnapshotSelectionCriteria; import akka.testkit.JavaTestKit; import akka.testkit.TestActorRef; import com.google.common.base.Optional; @@ -37,37 +50,51 @@ import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; -import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import org.apache.commons.lang3.SerializationUtils; import org.junit.After; 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.DeleteEntries; -import org.opendaylight.controller.cluster.raft.RaftActor.UpdateElectionTerm; +import org.opendaylight.controller.cluster.raft.MockRaftActorContext.MockPayload; +import org.opendaylight.controller.cluster.raft.ServerConfigurationPayload.ServerInfo; import org.opendaylight.controller.cluster.raft.base.messages.ApplyJournalEntries; -import org.opendaylight.controller.cluster.raft.base.messages.ApplyLogEntries; import org.opendaylight.controller.cluster.raft.base.messages.ApplySnapshot; import org.opendaylight.controller.cluster.raft.base.messages.ApplyState; +import org.opendaylight.controller.cluster.raft.base.messages.CaptureSnapshot; import org.opendaylight.controller.cluster.raft.base.messages.CaptureSnapshotReply; +import org.opendaylight.controller.cluster.raft.base.messages.DeleteEntries; +import org.opendaylight.controller.cluster.raft.base.messages.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.base.messages.UpdateElectionTerm; import org.opendaylight.controller.cluster.raft.behaviors.Follower; import org.opendaylight.controller.cluster.raft.behaviors.Leader; import org.opendaylight.controller.cluster.raft.behaviors.RaftActorBehavior; +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.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 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 { + static final Logger TEST_LOG = LoggerFactory.getLogger(RaftActorTest.class); + private TestActorFactory factory; @Before @@ -93,8 +120,11 @@ public class RaftActorTest extends AbstractActorTest { kit.waitUntilLeader(); } + @Test public void testRaftActorRecoveryWithPersistenceEnabled() throws Exception { + TEST_LOG.info("testRaftActorRecoveryWithPersistenceEnabled starting"); + new JavaTestKit(getSystem()) {{ String persistenceId = factory.generateActorId("follower-"); @@ -105,9 +135,9 @@ public class RaftActorTest extends AbstractActorTest { // log entry. config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + ImmutableMap peerAddresses = ImmutableMap.builder().put("member1", "address").build(); ActorRef followerActor = factory.createActor(MockRaftActor.props(persistenceId, - ImmutableMap.builder().put("member1", "address").build(), - Optional.of(config)), persistenceId); + peerAddresses, config), persistenceId); watch(followerActor); @@ -160,8 +190,7 @@ public class RaftActorTest extends AbstractActorTest { //reinstate the actor TestActorRef ref = factory.createTestActor( - MockRaftActor.props(persistenceId, Collections.emptyMap(), - Optional.of(config))); + MockRaftActor.props(persistenceId, peerAddresses, config)); MockRaftActor mockRaftActor = ref.underlyingActor(); @@ -180,6 +209,8 @@ public class RaftActorTest extends AbstractActorTest { assertEquals("getRaftState", RaftState.Follower, mockRaftActor.getRaftState()); }}; + + TEST_LOG.info("testRaftActorRecoveryWithPersistenceEnabled ending"); } @Test @@ -193,7 +224,7 @@ public class RaftActorTest extends AbstractActorTest { TestActorRef ref = factory.createTestActor(MockRaftActor.props(persistenceId, ImmutableMap.builder().put("member1", "address").build(), - Optional.of(config), new NonPersistentDataProvider()), persistenceId); + config, new NonPersistentDataProvider()), persistenceId); MockRaftActor mockRaftActor = ref.underlyingActor(); @@ -205,6 +236,48 @@ public class RaftActorTest extends AbstractActorTest { }}; } + @Test + public void testUpdateElectionTermPersistedWithPersistenceDisabled() throws Exception { + new JavaTestKit(getSystem()) {{ + String persistenceId = factory.generateActorId("follower-"); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + config.setHeartBeatInterval(new FiniteDuration(100, TimeUnit.MILLISECONDS)); + config.setElectionTimeoutFactor(1); + + InMemoryJournal.addWriteMessagesCompleteLatch(persistenceId, 1); + + TestActorRef ref = factory.createTestActor(MockRaftActor.props(persistenceId, + ImmutableMap.builder().put("member1", "address").build(), + config, new NonPersistentDataProvider()). + withDispatcher(Dispatchers.DefaultDispatcherId()), persistenceId); + + InMemoryJournal.waitForWriteMessagesComplete(persistenceId); + List entries = InMemoryJournal.get(persistenceId, UpdateElectionTerm.class); + assertEquals("UpdateElectionTerm entries", 1, entries.size()); + UpdateElectionTerm updateEntry = entries.get(0); + + factory.killActor(ref, this); + + 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()), + 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 testRaftActorForwardsToRaftActorRecoverySupport() { String persistenceId = factory.generateActorId("leader-"); @@ -214,7 +287,7 @@ public class RaftActorTest extends AbstractActorTest { config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); TestActorRef mockActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config)), persistenceId); + Collections.emptyMap(), config), persistenceId); MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); @@ -235,107 +308,82 @@ public class RaftActorTest extends AbstractActorTest { ApplyJournalEntries applyJournalEntries = new ApplyJournalEntries(2); mockRaftActor.handleRecover(applyJournalEntries); - ApplyLogEntries applyLogEntries = new ApplyLogEntries(0); - mockRaftActor.handleRecover(applyLogEntries); - DeleteEntries deleteEntries = new DeleteEntries(1); mockRaftActor.handleRecover(deleteEntries); + org.opendaylight.controller.cluster.raft.RaftActor.DeleteEntries deprecatedDeleteEntries = + new org.opendaylight.controller.cluster.raft.RaftActor.DeleteEntries(1); + mockRaftActor.handleRecover(deprecatedDeleteEntries); + UpdateElectionTerm updateElectionTerm = new UpdateElectionTerm(5, "member2"); mockRaftActor.handleRecover(updateElectionTerm); - verify(mockSupport).handleRecoveryMessage(same(snapshotOffer)); - verify(mockSupport).handleRecoveryMessage(same(logEntry)); - verify(mockSupport).handleRecoveryMessage(same(applyJournalEntries)); - verify(mockSupport).handleRecoveryMessage(same(applyLogEntries)); - verify(mockSupport).handleRecoveryMessage(same(deleteEntries)); - verify(mockSupport).handleRecoveryMessage(same(updateElectionTerm)); - } - - @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(); - - mockRaftActor.getRaftActorContext().getTermInformation().updateAndPersist(10, "foobar"); - - assertEquals("Persist called", true, persistLatch.await(5, TimeUnit.SECONDS)); - } - }; + org.opendaylight.controller.cluster.raft.RaftActor.UpdateElectionTerm deprecatedUpdateElectionTerm = + new org.opendaylight.controller.cluster.raft.RaftActor.UpdateElectionTerm(6, "member3"); + mockRaftActor.handleRecover(deprecatedUpdateElectionTerm); + + 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(deprecatedDeleteEntries), any(PersistentDataProvider.class)); + verify(mockSupport).handleRecoveryMessage(same(updateElectionTerm), any(PersistentDataProvider.class)); + verify(mockSupport).handleRecoveryMessage(same(deprecatedUpdateElectionTerm), any(PersistentDataProvider.class)); } @Test - public void testAddingReplicatedLogEntryCallsDataPersistence() 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(); - - MockRaftActorContext.MockReplicatedLogEntry logEntry = new MockRaftActorContext.MockReplicatedLogEntry(10, 10, mock(Payload.class)); - - mockRaftActor.getRaftActorContext().getReplicatedLog().appendAndPersist(logEntry); - - verify(dataPersistenceProvider).persist(eq(logEntry), any(Procedure.class)); - } - }; - } - - @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)); - - DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); + public void testRaftActorForwardsToRaftActorSnapshotMessageSupport() { + String persistenceId = factory.generateActorId("leader-"); - TestActorRef mockActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config), dataPersistenceProvider), persistenceId); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); - MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); + config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); - mockRaftActor.waitForInitializeBehaviorComplete(); + RaftActorSnapshotMessageSupport mockSupport = mock(RaftActorSnapshotMessageSupport.class); - mockRaftActor.waitUntilLeader(); + TestActorRef mockActorRef = factory.createTestActor(MockRaftActor.builder().id(persistenceId). + config(config).snapshotMessageSupport(mockSupport).props()); - mockRaftActor.getReplicatedLog().appendAndPersist(new MockRaftActorContext.MockReplicatedLogEntry(1, 0, mock(Payload.class))); + MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); - mockRaftActor.getRaftActorContext().getReplicatedLog().removeFromAndPersist(0); + // Wait for akka's recovery to complete so it doesn't interfere. + mockRaftActor.waitForRecoveryComplete(); - verify(dataPersistenceProvider, times(3)).persist(anyObject(), any(Procedure.class)); - } - }; + ApplySnapshot applySnapshot = new ApplySnapshot(mock(Snapshot.class)); + 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]); + doReturn(true).when(mockSupport).handleSnapshotMessage(same(captureSnapshotReply), any(ActorRef.class)); + mockRaftActor.handleCommand(captureSnapshotReply); + + SaveSnapshotSuccess saveSnapshotSuccess = new SaveSnapshotSuccess(new SnapshotMetadata("", 0L, 0L)); + doReturn(true).when(mockSupport).handleSnapshotMessage(same(saveSnapshotSuccess), any(ActorRef.class)); + mockRaftActor.handleCommand(saveSnapshotSuccess); + + SaveSnapshotFailure saveSnapshotFailure = new SaveSnapshotFailure(new SnapshotMetadata("", 0L, 0L), new Throwable()); + doReturn(true).when(mockSupport).handleSnapshotMessage(same(saveSnapshotFailure), any(ActorRef.class)); + mockRaftActor.handleCommand(saveSnapshotFailure); + + doReturn(true).when(mockSupport).handleSnapshotMessage(same(RaftActorSnapshotMessageSupport.COMMIT_SNAPSHOT), + any(ActorRef.class)); + mockRaftActor.handleCommand(RaftActorSnapshotMessageSupport.COMMIT_SNAPSHOT); + + 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(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)); + verify(mockSupport).handleSnapshotMessage(same(RaftActorSnapshotMessageSupport.COMMIT_SNAPSHOT), + any(ActorRef.class)); + verify(mockSupport).handleSnapshotMessage(same(GetSnapshot.INSTANCE), any(ActorRef.class)); } @Test @@ -351,7 +399,7 @@ public class RaftActorTest extends AbstractActorTest { DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); TestActorRef mockActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config), dataPersistenceProvider), persistenceId); + Collections.emptyMap(), config, dataPersistenceProvider), persistenceId); MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); @@ -361,119 +409,13 @@ public class RaftActorTest extends AbstractActorTest { mockRaftActor.onReceiveCommand(new ApplyJournalEntries(10)); - verify(dataPersistenceProvider, times(2)).persist(anyObject(), any(Procedure.class)); + verify(dataPersistenceProvider).persist(any(ApplyJournalEntries.class), any(Procedure.class)); } }; } - @Test - public void testCaptureSnapshotReplyCallsDataPersistence() 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(); - - ByteString snapshotBytes = fromObject(Arrays.asList( - new MockRaftActorContext.MockPayload("A"), - new MockRaftActorContext.MockPayload("B"), - new MockRaftActorContext.MockPayload("C"), - new MockRaftActorContext.MockPayload("D"))); - - RaftActorContext raftActorContext = mockRaftActor.getRaftActorContext(); - - raftActorContext.getSnapshotManager().capture( - new MockRaftActorContext.MockReplicatedLogEntry(1, -1, - new MockRaftActorContext.MockPayload("D")), -1); - - mockRaftActor.setCurrentBehavior(new Leader(raftActorContext)); - - mockRaftActor.onReceiveCommand(new CaptureSnapshotReply(snapshotBytes.toByteArray())); - - verify(dataPersistenceProvider).saveSnapshot(anyObject()); - - } - }; - } - - @Test - public void testSaveSnapshotSuccessCallsDataPersistence() 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, - ImmutableMap.of("leader", "fake/path"), Optional.of(config), dataPersistenceProvider), persistenceId); - - MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); - - mockRaftActor.waitForInitializeBehaviorComplete(); - MockRaftActorContext.MockReplicatedLogEntry lastEntry = new MockRaftActorContext.MockReplicatedLogEntry(1, 4, mock(Payload.class)); - - 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); - - ByteString snapshotBytes = fromObject(Arrays.asList( - new MockRaftActorContext.MockPayload("A"), - new MockRaftActorContext.MockPayload("B"), - new MockRaftActorContext.MockPayload("C"), - new MockRaftActorContext.MockPayload("D"))); - - RaftActorContext raftActorContext = mockRaftActor.getRaftActorContext(); - mockRaftActor.setCurrentBehavior(new Follower(raftActorContext)); - - long replicatedToAllIndex = 1; - - mockRaftActor.getRaftActorContext().getSnapshotManager().capture(lastEntry, replicatedToAllIndex); - - verify(mockRaftActor.snapshotCohortDelegate).createSnapshot(any(ActorRef.class)); - - mockRaftActor.onReceiveCommand(new CaptureSnapshotReply(snapshotBytes.toByteArray())); - - mockRaftActor.onReceiveCommand(new SaveSnapshotSuccess(new SnapshotMetadata("foo", 100, 100))); - - verify(dataPersistenceProvider).deleteSnapshots(any(SnapshotSelectionCriteria.class)); - - verify(dataPersistenceProvider).deleteMessages(100); - - assertEquals(3, mockRaftActor.getReplicatedLog().size()); - assertEquals(1, mockRaftActor.getCurrentBehavior().getReplicatedToAllIndex()); - - assertNotNull(mockRaftActor.getReplicatedLog().get(2)); - assertNotNull(mockRaftActor.getReplicatedLog().get(3)); - assertNotNull(mockRaftActor.getReplicatedLog().get(4)); - - // 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)); - - } - }; - } - @Test public void testApplyState() throws Exception { @@ -488,7 +430,7 @@ public class RaftActorTest extends AbstractActorTest { DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class); TestActorRef mockActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config), dataPersistenceProvider), persistenceId); + Collections.emptyMap(), config, dataPersistenceProvider), persistenceId); MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); @@ -497,109 +439,10 @@ public class RaftActorTest extends AbstractActorTest { ReplicatedLogEntry entry = new MockRaftActorContext.MockReplicatedLogEntry(1, 5, new MockRaftActorContext.MockPayload("F")); - mockRaftActor.onReceiveCommand(new ApplyState(mockActorRef, "apply-state", entry)); - - verify(mockRaftActor.actorDelegate).applyState(eq(mockActorRef), eq("apply-state"), anyObject()); - - } - }; - } - - @Test - public void testApplySnapshot() throws Exception { - new JavaTestKit(getSystem()) { - { - String persistenceId = factory.generateActorId("leader-"); - - DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); - - config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); - - DataPersistenceProviderMonitor dataPersistenceProviderMonitor = new DataPersistenceProviderMonitor(); - - TestActorRef mockActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config), dataPersistenceProviderMonitor), persistenceId); - - MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); - - mockRaftActor.waitForInitializeBehaviorComplete(); - - ReplicatedLog oldReplicatedLog = mockRaftActor.getReplicatedLog(); - - oldReplicatedLog.append(new MockRaftActorContext.MockReplicatedLogEntry(1, 0, mock(Payload.class))); - oldReplicatedLog.append(new MockRaftActorContext.MockReplicatedLogEntry(1, 1, mock(Payload.class))); - oldReplicatedLog.append( - new MockRaftActorContext.MockReplicatedLogEntry(1, 2, - mock(Payload.class))); - - ByteString snapshotBytes = fromObject(Arrays.asList( - new MockRaftActorContext.MockPayload("A"), - new MockRaftActorContext.MockPayload("B"), - new MockRaftActorContext.MockPayload("C"), - new MockRaftActorContext.MockPayload("D"))); - - Snapshot snapshot = mock(Snapshot.class); - - doReturn(snapshotBytes.toByteArray()).when(snapshot).getState(); - - doReturn(3L).when(snapshot).getLastAppliedIndex(); - - mockRaftActor.onReceiveCommand(new ApplySnapshot(snapshot)); - - verify(mockRaftActor.snapshotCohortDelegate).applySnapshot(eq(snapshot.getState())); - - assertTrue("The replicatedLog should have changed", - oldReplicatedLog != mockRaftActor.getReplicatedLog()); + final Identifier id = new MockIdentifier("apply-state"); + mockRaftActor.onReceiveCommand(new ApplyState(mockActorRef, id, entry)); - assertEquals("lastApplied should be same as in the snapshot", - (Long) 3L, mockRaftActor.getLastApplied()); - - assertEquals(0, mockRaftActor.getReplicatedLog().size()); - - } - }; - } - - @Test - public void testSaveSnapshotFailure() throws Exception { - new JavaTestKit(getSystem()) { - { - String persistenceId = factory.generateActorId("leader-"); - - DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); - - config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); - - DataPersistenceProviderMonitor dataPersistenceProviderMonitor = new DataPersistenceProviderMonitor(); - - TestActorRef mockActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config), dataPersistenceProviderMonitor), persistenceId); - - MockRaftActor mockRaftActor = mockActorRef.underlyingActor(); - - mockRaftActor.waitForInitializeBehaviorComplete(); - - ByteString snapshotBytes = fromObject(Arrays.asList( - new MockRaftActorContext.MockPayload("A"), - new MockRaftActorContext.MockPayload("B"), - new MockRaftActorContext.MockPayload("C"), - new MockRaftActorContext.MockPayload("D"))); - - RaftActorContext raftActorContext = mockRaftActor.getRaftActorContext(); - - mockRaftActor.setCurrentBehavior(new Leader(raftActorContext)); - - raftActorContext.getSnapshotManager().capture( - new MockRaftActorContext.MockReplicatedLogEntry(1, 1, - new MockRaftActorContext.MockPayload("D")), 1); - - mockRaftActor.onReceiveCommand(new CaptureSnapshotReply(snapshotBytes.toByteArray())); - - mockRaftActor.onReceiveCommand(new SaveSnapshotFailure(new SnapshotMetadata("foobar", 10L, 1234L), - new Exception())); - - assertEquals("Snapshot index should not have advanced because save snapshot failed", -1, - mockRaftActor.getReplicatedLog().getSnapshotIndex()); + verify(mockRaftActor.actorDelegate).applyState(eq(mockActorRef), eq(id), anyObject()); } }; @@ -619,9 +462,10 @@ public class RaftActorTest extends AbstractActorTest { String persistenceId = factory.generateActorId("notifier-"); - TestActorRef raftActorRef = factory.createTestActor(MockRaftActor.props(persistenceId, - Collections.emptyMap(), Optional.of(config), notifierActor, - new NonPersistentDataProvider()), persistenceId); + TestActorRef raftActorRef = factory.createTestActor(MockRaftActor.builder().id(persistenceId). + config(config).roleChangeNotifier(notifierActor).dataPersistenceProvider( + new NonPersistentDataProvider()).props().withDispatcher(Dispatchers.DefaultDispatcherId()), + persistenceId); List matches = MessageCollectorActor.expectMatching(notifierActor, RoleChanged.class, 3); @@ -648,20 +492,23 @@ public class RaftActorTest extends AbstractActorTest { notifierActor, LeaderStateChanged.class); assertEquals(raftRoleChanged.getMemberId(), leaderStateChange.getLeaderId()); + assertEquals(MockRaftActor.PAYLOAD_VERSION, leaderStateChange.getLeaderPayloadVersion()); notifierActor.underlyingActor().clear(); MockRaftActor raftActor = raftActorRef.underlyingActor(); final String newLeaderId = "new-leader"; + final short newLeaderVersion = 6; Follower follower = new Follower(raftActor.getRaftActorContext()) { @Override public RaftActorBehavior handleMessage(ActorRef sender, Object message) { - leaderId = newLeaderId; + setLeaderId(newLeaderId); + setLeaderPayloadVersion(newLeaderVersion); return this; } }; - raftActor.changeCurrentBehavior(follower); + raftActor.newBehavior(follower); leaderStateChange = MessageCollectorActor.expectFirstMatching(notifierActor, LeaderStateChanged.class); assertEquals(persistenceId, leaderStateChange.getMemberId()); @@ -678,6 +525,15 @@ public class RaftActorTest extends AbstractActorTest { leaderStateChange = MessageCollectorActor.expectFirstMatching(notifierActor, LeaderStateChanged.class); assertEquals(persistenceId, leaderStateChange.getMemberId()); assertEquals(newLeaderId, leaderStateChange.getLeaderId()); + assertEquals(newLeaderVersion, leaderStateChange.getLeaderPayloadVersion()); + + notifierActor.underlyingActor().clear(); + + raftActor.handleCommand("any"); + + Uninterruptibles.sleepUninterruptibly(505, TimeUnit.MILLISECONDS); + leaderStateChange = MessageCollectorActor.getFirstMatching(notifierActor, LeaderStateChanged.class); + assertNull(leaderStateChange); }}; } @@ -694,8 +550,9 @@ public class RaftActorTest extends AbstractActorTest { String persistenceId = factory.generateActorId("notifier-"); - factory.createActor(MockRaftActor.props(persistenceId, - ImmutableMap.of("leader", "fake/path"), Optional.of(config), notifierActor), persistenceId); + 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++) { @@ -707,6 +564,7 @@ public class RaftActorTest extends AbstractActorTest { Uninterruptibles.sleepUninterruptibly(heartBeatInterval, TimeUnit.MILLISECONDS); } + assertNotNull(matches); assertEquals(2, matches.size()); // check if the notifier got a role change from null to Follower @@ -744,8 +602,7 @@ public class RaftActorTest extends AbstractActorTest { peerAddresses.put(follower1Id, followerActor1.path().toString()); TestActorRef mockActorRef = factory.createTestActor( - MockRaftActor.props(persistenceId, peerAddresses, - Optional.of(config), dataPersistenceProvider), persistenceId); + MockRaftActor.props(persistenceId, peerAddresses, config, dataPersistenceProvider), persistenceId); MockRaftActor leaderActor = mockActorRef.underlyingActor(); @@ -776,13 +633,13 @@ public class RaftActorTest extends AbstractActorTest { assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); //fake snapshot on index 5 - leaderActor.onReceiveCommand(new AppendEntriesReply(follower1Id, 1, true, 5, 1)); + leaderActor.onReceiveCommand(new AppendEntriesReply(follower1Id, 1, true, 5, 1, (short)0)); assertEquals(8, leaderActor.getReplicatedLog().size()); //fake snapshot on index 6 assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); - leaderActor.onReceiveCommand(new AppendEntriesReply(follower1Id, 1, true, 6, 1)); + leaderActor.onReceiveCommand(new AppendEntriesReply(follower1Id, 1, true, 6, 1, (short)0)); assertEquals(8, leaderActor.getReplicatedLog().size()); assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); @@ -796,13 +653,13 @@ public class RaftActorTest extends AbstractActorTest { new MockRaftActorContext.MockPayload("foo-3"), new MockRaftActorContext.MockPayload("foo-4"))); - leaderActor.getRaftActorContext().getSnapshotManager().persist(new NonPersistentDataProvider() - , snapshotBytes.toByteArray(), leader, Runtime.getRuntime().totalMemory()); + leaderActor.getRaftActorContext().getSnapshotManager().persist(snapshotBytes.toByteArray(), + Runtime.getRuntime().totalMemory()); - assertFalse(leaderActor.getRaftActorContext().getSnapshotManager().isCapturing()); + assertTrue(leaderActor.getRaftActorContext().getSnapshotManager().isCapturing()); // The commit is needed to complete the snapshot creation process - leaderActor.getRaftActorContext().getSnapshotManager().commit(new NonPersistentDataProvider(), -1); + leaderActor.getRaftActorContext().getSnapshotManager().commit(-1); // capture snapshot reply should remove the snapshotted entries only assertEquals(3, leaderActor.getReplicatedLog().size()); @@ -813,7 +670,7 @@ public class RaftActorTest extends AbstractActorTest { new ReplicatedLogImplEntry(8, 1, new MockRaftActorContext.MockPayload("foo-8"))); //fake snapshot on index 7, since lastApplied = 7 , we would keep the last applied - leaderActor.onReceiveCommand(new AppendEntriesReply(follower1Id, 1, true, 7, 1)); + leaderActor.onReceiveCommand(new AppendEntriesReply(follower1Id, 1, true, 7, 1, (short)0)); assertEquals(2, leaderActor.getReplicatedLog().size()); assertEquals(8, leaderActor.getReplicatedLog().lastIndex()); @@ -842,8 +699,7 @@ public class RaftActorTest extends AbstractActorTest { peerAddresses.put(leaderId, leaderActor1.path().toString()); TestActorRef mockActorRef = factory.createTestActor( - MockRaftActor.props(persistenceId, peerAddresses, - Optional.of(config), dataPersistenceProvider), persistenceId); + MockRaftActor.props(persistenceId, peerAddresses, config, dataPersistenceProvider), persistenceId); MockRaftActor followerActor = mockActorRef.underlyingActor(); followerActor.getRaftActorContext().setCommitIndex(4); @@ -879,7 +735,7 @@ public class RaftActorTest extends AbstractActorTest { (ReplicatedLogEntry) new MockRaftActorContext.MockReplicatedLogEntry(1, 6, new MockRaftActorContext.MockPayload("foo-6")) ); - followerActor.onReceiveCommand(new AppendEntries(1, leaderId, 5, 1, entries, 5, 5)); + followerActor.onReceiveCommand(new AppendEntries(1, leaderId, 5, 1, entries, 5, 5, (short)0)); assertEquals(7, followerActor.getReplicatedLog().size()); //fake snapshot on index 7 @@ -890,7 +746,7 @@ public class RaftActorTest extends AbstractActorTest { (ReplicatedLogEntry) new MockRaftActorContext.MockReplicatedLogEntry(1, 7, new MockRaftActorContext.MockPayload("foo-7")) ); - followerActor.onReceiveCommand(new AppendEntries(1, leaderId, 6, 1, entries, 6, 6)); + followerActor.onReceiveCommand(new AppendEntries(1, leaderId, 6, 1, entries, 6, 6, (short) 0)); assertEquals(8, followerActor.getReplicatedLog().size()); assertEquals(RaftState.Follower, followerActor.getCurrentBehavior().state()); @@ -903,10 +759,10 @@ public class RaftActorTest extends AbstractActorTest { new MockRaftActorContext.MockPayload("foo-3"), new MockRaftActorContext.MockPayload("foo-4"))); followerActor.onReceiveCommand(new CaptureSnapshotReply(snapshotBytes.toByteArray())); - assertFalse(followerActor.getRaftActorContext().getSnapshotManager().isCapturing()); + assertTrue(followerActor.getRaftActorContext().getSnapshotManager().isCapturing()); // The commit is needed to complete the snapshot creation process - followerActor.getRaftActorContext().getSnapshotManager().commit(new NonPersistentDataProvider(), -1); + followerActor.getRaftActorContext().getSnapshotManager().commit(-1); // capture snapshot reply should remove the snapshotted entries only till replicatedToAllIndex assertEquals(3, followerActor.getReplicatedLog().size()); //indexes 5,6,7 left in the log @@ -918,7 +774,7 @@ public class RaftActorTest extends AbstractActorTest { new MockRaftActorContext.MockPayload("foo-7")) ); // send an additional entry 8 with leaderCommit = 7 - followerActor.onReceiveCommand(new AppendEntries(1, leaderId, 7, 1, entries, 7, 7)); + followerActor.onReceiveCommand(new AppendEntries(1, leaderId, 7, 1, entries, 7, 7, (short) 0)); // 7 and 8, as lastapplied is 7 assertEquals(2, followerActor.getReplicatedLog().size()); @@ -951,8 +807,7 @@ public class RaftActorTest extends AbstractActorTest { peerAddresses.put(follower2Id, followerActor2.path().toString()); TestActorRef mockActorRef = factory.createTestActor( - MockRaftActor.props(persistenceId, peerAddresses, - Optional.of(config), dataPersistenceProvider), persistenceId); + MockRaftActor.props(persistenceId, peerAddresses, config, dataPersistenceProvider), persistenceId); MockRaftActor leaderActor = mockActorRef.underlyingActor(); leaderActor.getRaftActorContext().setCommitIndex(9); @@ -976,17 +831,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)); + leaderActor.onReceiveCommand(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)); + leaderActor.onReceiveCommand(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(new SendHeartBeat()); + leaderActor.onReceiveCommand(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()) @@ -994,7 +849,7 @@ 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)); + leaderActor.onReceiveCommand(new AppendEntriesReply(follower2Id, 1, true, 9, 1, (short)0)); assertEquals("Fake snapshot should not happen when Initiate is in progress", 5, leaderActor.getReplicatedLog().size()); ByteString snapshotBytes = fromObject(Arrays.asList( @@ -1004,12 +859,12 @@ public class RaftActorTest extends AbstractActorTest { new MockRaftActorContext.MockPayload("foo-3"), new MockRaftActorContext.MockPayload("foo-4"))); leaderActor.onReceiveCommand(new CaptureSnapshotReply(snapshotBytes.toByteArray())); - assertFalse(leaderActor.getRaftActorContext().getSnapshotManager().isCapturing()); + 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)); + leaderActor.onReceiveCommand(new AppendEntriesReply(follower2Id, 1, true, 5, 1, (short) 0)); assertEquals(0, leaderActor.getReplicatedLog().size()); } }; @@ -1026,11 +881,10 @@ public class RaftActorTest extends AbstractActorTest { DataPersistenceProvider dataPersistenceProvider = new NonPersistentDataProvider(); - Map peerAddresses = new HashMap<>(); + Map peerAddresses = ImmutableMap.builder().put("member1", "address").build(); TestActorRef mockActorRef = factory.createTestActor( - MockRaftActor.props(persistenceId, peerAddresses, - Optional.of(config), dataPersistenceProvider), persistenceId); + MockRaftActor.props(persistenceId, peerAddresses, config, dataPersistenceProvider), persistenceId); MockRaftActor leaderActor = mockActorRef.underlyingActor(); leaderActor.getRaftActorContext().setCommitIndex(3); @@ -1048,15 +902,16 @@ public class RaftActorTest extends AbstractActorTest { leaderActor.setCurrentBehavior(leader); assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); - // Persist another entry (this will cause a CaptureSnapshot to be triggered - leaderActor.persistData(mockActorRef, "x", new MockRaftActorContext.MockPayload("duh")); + // Simulate an install snaphost to a follower. + leaderActor.getRaftActorContext().getSnapshotManager().captureToInstall( + leaderActor.getReplicatedLog().last(), -1, "member1"); // Now send a CaptureSnapshotReply mockActorRef.tell(new CaptureSnapshotReply(fromObject("foo").toByteArray()), mockActorRef); // Trimming log in this scenario is a no-op assertEquals(-1, leaderActor.getReplicatedLog().getSnapshotIndex()); - assertFalse(leaderActor.getRaftActorContext().getSnapshotManager().isCapturing()); + assertTrue(leaderActor.getRaftActorContext().getSnapshotManager().isCapturing()); assertEquals(-1, leader.getReplicatedToAllIndex()); }}; @@ -1073,11 +928,10 @@ public class RaftActorTest extends AbstractActorTest { DataPersistenceProvider dataPersistenceProvider = new NonPersistentDataProvider(); - Map peerAddresses = new HashMap<>(); + Map peerAddresses = ImmutableMap.builder().put("member1", "address").build(); TestActorRef mockActorRef = factory.createTestActor( - MockRaftActor.props(persistenceId, peerAddresses, - Optional.of(config), dataPersistenceProvider), persistenceId); + MockRaftActor.props(persistenceId, peerAddresses, config, dataPersistenceProvider), persistenceId); MockRaftActor leaderActor = mockActorRef.underlyingActor(); leaderActor.getRaftActorContext().setCommitIndex(3); @@ -1092,20 +946,96 @@ public class RaftActorTest extends AbstractActorTest { assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); // Persist another entry (this will cause a CaptureSnapshot to be triggered - leaderActor.persistData(mockActorRef, "x", new MockRaftActorContext.MockPayload("duh")); + leaderActor.persistData(mockActorRef, new MockIdentifier("x"), + new MockRaftActorContext.MockPayload("duh")); // Now send a CaptureSnapshotReply mockActorRef.tell(new CaptureSnapshotReply(fromObject("foo").toByteArray()), mockActorRef); // Trimming log in this scenario is a no-op assertEquals(3, leaderActor.getReplicatedLog().getSnapshotIndex()); - assertFalse(leaderActor.getRaftActorContext().getSnapshotManager().isCapturing()); + assertTrue(leaderActor.getRaftActorContext().getSnapshotManager().isCapturing()); assertEquals(3, leader.getReplicatedToAllIndex()); }}; } - private ByteString fromObject(Object snapshot) throws Exception { + @Test + public void testRaftActorOnRecoverySnapshot() throws Exception { + TEST_LOG.info("testRaftActorOnRecoverySnapshot"); + + 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 + config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + + ImmutableMap peerAddresses = ImmutableMap.builder().put("member1", "address").build(); + + // Create mock ReplicatedLogEntry + ReplicatedLogEntry replLogEntry = new MockRaftActorContext.MockReplicatedLogEntry(1,1, + new MockRaftActorContext.MockPayload("F", 1)); + + InMemoryJournal.addEntry(persistenceId, 1, replLogEntry); + + TestActorRef ref = factory.createTestActor( + MockRaftActor.props(persistenceId, peerAddresses, config)); + + MockRaftActor mockRaftActor = ref.underlyingActor(); + + mockRaftActor.waitForRecoveryComplete(); + + mockRaftActor.waitForInitializeBehaviorComplete(); + + verify(mockRaftActor.snapshotCohortDelegate, timeout(5000)).createSnapshot(any(ActorRef.class)); + }}; + } + + @Test + public void testSwitchBehavior(){ + String persistenceId = factory.generateActorId("leader-"); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + config.setCustomRaftPolicyImplementationClass("org.opendaylight.controller.cluster.raft.policy.DisableElectionsRaftPolicy"); + config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS)); + config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS)); + config.setSnapshotBatchCount(5); + + DataPersistenceProvider dataPersistenceProvider = new NonPersistentDataProvider(); + + Map peerAddresses = ImmutableMap.builder().build(); + + TestActorRef mockActorRef = factory.createTestActor( + MockRaftActor.props(persistenceId, peerAddresses, config, dataPersistenceProvider), persistenceId); + + MockRaftActor leaderActor = mockActorRef.underlyingActor(); + + leaderActor.waitForRecoveryComplete(); + + leaderActor.handleCommand(new SwitchBehavior(RaftState.Follower, 100)); + + assertEquals(100, leaderActor.getRaftActorContext().getTermInformation().getCurrentTerm()); + assertEquals(RaftState.Follower, leaderActor.getCurrentBehavior().state()); + + leaderActor.handleCommand(new SwitchBehavior(RaftState.Leader, 110)); + + assertEquals(110, leaderActor.getRaftActorContext().getTermInformation().getCurrentTerm()); + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); + + leaderActor.handleCommand(new SwitchBehavior(RaftState.Candidate, 125)); + + assertEquals(110, leaderActor.getRaftActorContext().getTermInformation().getCurrentTerm()); + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); + + leaderActor.handleCommand(new SwitchBehavior(RaftState.IsolatedLeader, 125)); + + assertEquals(110, leaderActor.getRaftActorContext().getTermInformation().getCurrentTerm()); + assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state()); + } + + public static ByteString fromObject(Object snapshot) throws Exception { ByteArrayOutputStream b = null; ObjectOutputStream o = null; try { @@ -1125,4 +1055,316 @@ public class RaftActorTest extends AbstractActorTest { } } + @Test + public void testUpdateConfigParam() throws Exception { + 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()); + } + + @Test + public void testGetSnapshot() throws Exception { + TEST_LOG.info("testGetSnapshot starting"); + + JavaTestKit kit = new JavaTestKit(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 MockRaftActorContext.MockReplicatedLogEntry(term, 0, + new MockRaftActorContext.MockPayload("A"))); + InMemoryJournal.addEntry(persistenceId, seqN++, new MockRaftActorContext.MockReplicatedLogEntry(term, 1, + new MockRaftActorContext.MockPayload("B"))); + InMemoryJournal.addEntry(persistenceId, seqN++, new ApplyJournalEntries(1)); + InMemoryJournal.addEntry(persistenceId, seqN++, new MockRaftActorContext.MockReplicatedLogEntry(term, 2, + 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(); + + // Wait for snapshot after recovery + verify(mockRaftActor.snapshotCohortDelegate, timeout(5000)).createSnapshot(any(ActorRef.class)); + + 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()); + + byte[] stateSnapshot = new byte[]{1,2,3}; + replyActor.getValue().tell(new CaptureSnapshotReply(stateSnapshot), ActorRef.noSender()); + + GetSnapshotReply reply = kit.expectMsgClass(GetSnapshotReply.class); + + assertEquals("getId", persistenceId, reply.getId()); + Snapshot replySnapshot = SerializationUtils.deserialize(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("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)); + 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)); + + // 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(ActorRef.class)); + + assertEquals("getId", persistenceId, reply.getId()); + replySnapshot = SerializationUtils.deserialize(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("getUnAppliedEntries size", 0, replySnapshot.getUnAppliedEntries().size()); + + TEST_LOG.info("testGetSnapshot ending"); + } + + @Test + public void testRestoreFromSnapshot() throws Exception { + TEST_LOG.info("testRestoreFromSnapshot starting"); + + String persistenceId = factory.generateActorId("test-actor-"); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + config.setCustomRaftPolicyImplementationClass(DisableElectionsRaftPolicy.class.getName()); + + List snapshotUnappliedEntries = new ArrayList<>(); + snapshotUnappliedEntries.add(new MockRaftActorContext.MockReplicatedLogEntry(1, 4, + new MockRaftActorContext.MockPayload("E"))); + + int snapshotLastApplied = 3; + int snapshotLastIndex = 4; + + List state = Arrays.asList( + new MockRaftActorContext.MockPayload("A"), + new MockRaftActorContext.MockPayload("B"), + new MockRaftActorContext.MockPayload("C"), + new MockRaftActorContext.MockPayload("D")); + ByteString stateBytes = fromObject(state); + + Snapshot snapshot = Snapshot.create(stateBytes.toByteArray(), snapshotUnappliedEntries, + snapshotLastIndex, 1, snapshotLastApplied, 1, 1, "member-1"); + + InMemorySnapshotStore.addSnapshotSavedLatch(persistenceId); + + TestActorRef raftActorRef = factory.createTestActor(MockRaftActor.builder().id(persistenceId). + config(config).restoreFromSnapshot(SerializationUtils.serialize(snapshot)).props(). + withDispatcher(Dispatchers.DefaultDispatcherId()), persistenceId); + MockRaftActor mockRaftActor = raftActorRef.underlyingActor(); + + mockRaftActor.waitForRecoveryComplete(); + + 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()); + assertArrayEquals("getState", snapshot.getState(), savedSnapshot.getState()); + assertEquals("getUnAppliedEntries", snapshot.getUnAppliedEntries(), savedSnapshot.getUnAppliedEntries()); + + verify(mockRaftActor.snapshotCohortDelegate, timeout(5000)).applySnapshot(any(byte[].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("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"); + + persistenceId = factory.generateActorId("test-actor-"); + + raftActorRef = factory.createTestActor(MockRaftActor.builder().id(persistenceId). + config(config).restoreFromSnapshot(SerializationUtils.serialize(snapshot)). + persistent(Optional.of(Boolean.FALSE)).props(). + withDispatcher(Dispatchers.DefaultDispatcherId()), persistenceId); + mockRaftActor = raftActorRef.underlyingActor(); + + mockRaftActor.waitForRecoveryComplete(); + assertEquals("snapshot committed", true, + Uninterruptibles.awaitUninterruptibly(mockRaftActor.snapshotCommitted, 5, TimeUnit.SECONDS)); + + 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 testRestoreFromSnapshotWithRecoveredData() throws Exception { + TEST_LOG.info("testRestoreFromSnapshotWithRecoveredData starting"); + + String persistenceId = factory.generateActorId("test-actor-"); + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + 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"); + + InMemoryJournal.addEntry(persistenceId, 1, new MockRaftActorContext.MockReplicatedLogEntry(1, 0, + new MockRaftActorContext.MockPayload("B"))); + + TestActorRef raftActorRef = factory.createTestActor(MockRaftActor.builder().id(persistenceId). + config(config).restoreFromSnapshot(SerializationUtils.serialize(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)); + + 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()); + + TEST_LOG.info("testRestoreFromSnapshotWithRecoveredData ending"); + } + + @Test + public void testNonVotingOnRecovery() throws Exception { + TEST_LOG.info("testNonVotingOnRecovery starting"); + + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + config.setElectionTimeoutFactor(1); + config.setHeartBeatInterval(FiniteDuration.create(1, TimeUnit.MILLISECONDS)); + + String persistenceId = factory.generateActorId("test-actor-"); + InMemoryJournal.addEntry(persistenceId, 1, new MockRaftActorContext.MockReplicatedLogEntry(1, 0, + new ServerConfigurationPayload(Arrays.asList(new ServerInfo(persistenceId, false))))); + + TestActorRef raftActorRef = factory.createTestActor(MockRaftActor.builder().id(persistenceId). + config(config).props().withDispatcher(Dispatchers.DefaultDispatcherId()), persistenceId); + MockRaftActor mockRaftActor = raftActorRef.underlyingActor(); + + mockRaftActor.waitForInitializeBehaviorComplete(); + + // Sleep a bit and verify it didn't get an election timeout and schedule an election. + + Uninterruptibles.sleepUninterruptibly(400, TimeUnit.MILLISECONDS); + assertEquals("getRaftState", RaftState.Follower, mockRaftActor.getRaftState()); + + TEST_LOG.info("testNonVotingOnRecovery ending"); + } + + @Test + public void testLeaderTransitioning() throws Exception { + TEST_LOG.info("testLeaderTransitioning starting"); + + TestActorRef notifierActor = factory.createTestActor( + Props.create(MessageCollectorActor.class)); + + DefaultConfigParamsImpl config = new DefaultConfigParamsImpl(); + config.setCustomRaftPolicyImplementationClass(DisableElectionsRaftPolicy.class.getName()); + + String persistenceId = factory.generateActorId("test-actor-"); + + TestActorRef raftActorRef = factory.createTestActor(MockRaftActor.builder().id(persistenceId). + config(config).roleChangeNotifier(notifierActor).props().withDispatcher(Dispatchers.DefaultDispatcherId()), persistenceId); + MockRaftActor mockRaftActor = raftActorRef.underlyingActor(); + + mockRaftActor.waitForInitializeBehaviorComplete(); + + 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()); + + MessageCollectorActor.clearMessages(notifierActor); + + raftActorRef.tell(LeaderTransitioning.INSTANCE, ActorRef.noSender()); + + leaderStateChange = MessageCollectorActor.expectFirstMatching(notifierActor, LeaderStateChanged.class); + assertEquals("getMemberId", persistenceId, leaderStateChange.getMemberId()); + assertEquals("getLeaderId", null, leaderStateChange.getLeaderId()); + + TEST_LOG.info("testLeaderTransitioning ending"); + } }