Java Leader类代码示例

import org.opendaylight.controller.cluster.raft.behaviors.Leader; //导入依赖的package包/类
@Test
public void testPauseLeaderTimeout() {
    pauseLeaderFunction = input -> null;
    setup("testPauseLeaderTimeout");

    Leader leader = new Leader(mockRaftActor.getRaftActorContext()) {
        @Override
        public void transferLeadership(RaftActorLeadershipTransferCohort leadershipTransferCohort) {
            leadershipTransferCohort.transferComplete();
        }
    };
    mockRaftActor.setCurrentBehavior(leader);

    cohort.init();
    verify(onComplete, timeout(2000)).onSuccess(mockRaftActor.self());
}
 

import org.opendaylight.controller.cluster.raft.behaviors.Leader; //导入依赖的package包/类
/**
 * This method is invoked to perform the leadership transfer.
 */
@VisibleForTesting
void doTransfer() {
    RaftActorBehavior behavior = raftActor.getCurrentBehavior();
    // Sanity check...
    if (behavior instanceof Leader) {
        isTransferring = true;
        ((Leader)behavior).transferLeadership(this);
    } else {
        LOG.debug("{}: No longer the leader - skipping transfer", raftActor.persistenceId());
        finish(true);
    }
}
 

import org.opendaylight.controller.cluster.raft.behaviors.Leader; //导入依赖的package包/类
@Test
public void testRealSnapshotWhenReplicatedToAllIndexNotInReplicatedLog() throws Exception {
    String persistenceId = factory.generateActorId("leader-");
    DefaultConfigParamsImpl config = new DefaultConfigParamsImpl();
    config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS));
    config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS));
    config.setSnapshotBatchCount(5);

    DataPersistenceProvider dataPersistenceProvider = createProvider();

    Map<String, String> peerAddresses = ImmutableMap.<String, String>builder().put("member1", "address").build();

    TestActorRef<MockRaftActor> mockActorRef = factory.createTestActor(
            MockRaftActor.props(persistenceId, peerAddresses, config, dataPersistenceProvider), persistenceId);

    MockRaftActor leaderActor = mockActorRef.underlyingActor();
    leaderActor.getRaftActorContext().setCommitIndex(3);
    leaderActor.getRaftActorContext().setLastApplied(3);
    leaderActor.getRaftActorContext().getTermInformation().update(1, persistenceId);
    leaderActor.getReplicatedLog().setSnapshotIndex(3);

    leaderActor.waitForInitializeBehaviorComplete();
    Leader leader = new Leader(leaderActor.getRaftActorContext());
    leaderActor.setCurrentBehavior(leader);
    leader.setReplicatedToAllIndex(3);
    assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state());

    // Persist another entry (this will cause a CaptureSnapshot to be triggered
    leaderActor.persistData(mockActorRef, new MockIdentifier("x"),
            new MockRaftActorContext.MockPayload("duh"), false);

    // Now send a CaptureSnapshotReply
    mockActorRef.tell(new CaptureSnapshotReply(ByteState.of(fromObject("foo").toByteArray()),
            java.util.Optional.empty()), mockActorRef);

    // Trimming log in this scenario is a no-op
    assertEquals(3, leaderActor.getReplicatedLog().getSnapshotIndex());
    assertTrue(leaderActor.getRaftActorContext().getSnapshotManager().isCapturing());
    assertEquals(3, leader.getReplicatedToAllIndex());
}
 

import org.opendaylight.controller.cluster.raft.behaviors.Leader; //导入依赖的package包/类
@Test
public void testReplicateWithBatchHint() throws Exception {
    final String leaderId = factory.generateActorId("leader-");
    final String followerId = factory.generateActorId("follower-");

    final ActorRef followerActor = factory.createActor(MessageCollectorActor.props());

    DefaultConfigParamsImpl config = new DefaultConfigParamsImpl();
    config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS));
    config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS));

    TestActorRef<MockRaftActor> leaderActorRef = factory.createTestActor(
            MockRaftActor.props(leaderId, ImmutableMap.of(followerId, followerActor.path().toString()), config),
                leaderId);
    MockRaftActor leaderActor = leaderActorRef.underlyingActor();
    leaderActor.waitForInitializeBehaviorComplete();

    leaderActor.getRaftActorContext().getTermInformation().update(1, leaderId);

    Leader leader = new Leader(leaderActor.getRaftActorContext());
    leaderActor.setCurrentBehavior(leader);

    MessageCollectorActor.expectFirstMatching(followerActor, AppendEntries.class);
    MessageCollectorActor.clearMessages(followerActor);

    leaderActor.onReceiveCommand(new AppendEntriesReply(followerId, 1, true, -1, -1, (short)0));

    leaderActor.persistData(leaderActorRef, new MockIdentifier("1"), new MockPayload("1"), true);
    MessageCollectorActor.assertNoneMatching(followerActor, AppendEntries.class, 500);

    leaderActor.persistData(leaderActorRef, new MockIdentifier("2"), new MockPayload("2"), true);
    MessageCollectorActor.assertNoneMatching(followerActor, AppendEntries.class, 500);

    leaderActor.persistData(leaderActorRef, new MockIdentifier("3"), new MockPayload("3"), false);
    AppendEntries appendEntries = MessageCollectorActor.expectFirstMatching(followerActor, AppendEntries.class);
    assertEquals("AppendEntries size", 3, appendEntries.getEntries().size());
}
 

import org.opendaylight.controller.cluster.raft.behaviors.Leader; //导入依赖的package包/类
@Override
protected void handleNonRaftCommand(Object message) {
    if(message instanceof KeyValue){
        if(isLeader()) {
            persistData(getSender(), new PayloadIdentifier(persistIdentifier++), (Payload) message, false);
        } else {
            if(getLeader() != null) {
                getLeader().forward(message, getContext());
            }
        }

    } else if (message instanceof PrintState) {
        if(LOG.isDebugEnabled()) {
            LOG.debug("State of the node:{} has entries={}, {}",
                getId(), state.size(), getReplicatedLogState());
        }

    } else if (message instanceof PrintRole) {
        if(LOG.isDebugEnabled()) {
            if (getRaftState() == RaftState.Leader || getRaftState() == RaftState.IsolatedLeader) {
                final String followers = ((Leader)this.getCurrentBehavior()).printFollowerStates();
                LOG.debug("{} = {}, Peers={}, followers={}", getId(), getRaftState(),
                    getRaftActorContext().getPeerIds(), followers);
            } else {
                LOG.debug("{} = {}, Peers={}", getId(), getRaftState(),
                    getRaftActorContext().getPeerIds());
            }


        }

    } else {
        super.handleNonRaftCommand(message);
    }
}
 

import org.opendaylight.controller.cluster.raft.behaviors.Leader; //导入依赖的package包/类
@Test
public void testRealSnapshotWhenReplicatedToAllIndexMinusOne() throws Exception {
    String persistenceId = factory.generateActorId("leader-");
    DefaultConfigParamsImpl config = new DefaultConfigParamsImpl();
    config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS));
    config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS));
    config.setSnapshotBatchCount(5);

    DataPersistenceProvider dataPersistenceProvider = createProvider();

    Map<String, String> peerAddresses = ImmutableMap.<String, String>builder().put("member1", "address").build();

    TestActorRef<MockRaftActor> mockActorRef = factory.createTestActor(
            MockRaftActor.props(persistenceId, peerAddresses, config, dataPersistenceProvider), persistenceId);

    MockRaftActor leaderActor = mockActorRef.underlyingActor();
    leaderActor.getRaftActorContext().setCommitIndex(3);
    leaderActor.getRaftActorContext().setLastApplied(3);
    leaderActor.getRaftActorContext().getTermInformation().update(1, persistenceId);

    leaderActor.waitForInitializeBehaviorComplete();
    for (int i = 0; i < 4; i++) {
        leaderActor.getReplicatedLog().append(new SimpleReplicatedLogEntry(i, 1,
                new MockRaftActorContext.MockPayload("A")));
    }

    Leader leader = new Leader(leaderActor.getRaftActorContext());
    leaderActor.setCurrentBehavior(leader);
    assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state());

    // Simulate an install snaphost to a follower.
    leaderActor.getRaftActorContext().getSnapshotManager().captureToInstall(
            leaderActor.getReplicatedLog().last(), -1, "member1");

    // Now send a CaptureSnapshotReply
    mockActorRef.tell(new CaptureSnapshotReply(ByteState.of(fromObject("foo").toByteArray()),
            java.util.Optional.empty()), mockActorRef);

    // Trimming log in this scenario is a no-op
    assertEquals(-1, leaderActor.getReplicatedLog().getSnapshotIndex());
    assertTrue(leaderActor.getRaftActorContext().getSnapshotManager().isCapturing());
    assertEquals(-1, leader.getReplicatedToAllIndex());
}
 

import org.opendaylight.controller.cluster.raft.behaviors.Leader; //导入依赖的package包/类
@SuppressWarnings({ "unchecked", "rawtypes" })
@Test
public void testReplicateWithPersistencePending() throws Exception {
    final String leaderId = factory.generateActorId("leader-");
    final String followerId = factory.generateActorId("follower-");

    final ActorRef followerActor = factory.createActor(MessageCollectorActor.props());

    DefaultConfigParamsImpl config = new DefaultConfigParamsImpl();
    config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS));
    config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS));

    DataPersistenceProvider mockPersistenceProvider = mock(DataPersistenceProvider.class);
    doReturn(true).when(mockPersistenceProvider).isRecoveryApplicable();

    TestActorRef<MockRaftActor> leaderActorRef = factory.createTestActor(
            MockRaftActor.props(leaderId, ImmutableMap.of(followerId, followerActor.path().toString()), config,
                    mockPersistenceProvider), leaderId);
    MockRaftActor leaderActor = leaderActorRef.underlyingActor();
    leaderActor.waitForInitializeBehaviorComplete();

    leaderActor.getRaftActorContext().getTermInformation().update(1, leaderId);

    Leader leader = new Leader(leaderActor.getRaftActorContext());
    leaderActor.setCurrentBehavior(leader);

    leaderActor.persistData(leaderActorRef, new MockIdentifier("1"), new MockRaftActorContext.MockPayload("1"),
            false);

    ReplicatedLogEntry logEntry = leaderActor.getReplicatedLog().get(0);
    assertNotNull("ReplicatedLogEntry not found", logEntry);
    assertEquals("isPersistencePending", true, logEntry.isPersistencePending());
    assertEquals("getCommitIndex", -1, leaderActor.getRaftActorContext().getCommitIndex());

    leaderActor.onReceiveCommand(new AppendEntriesReply(followerId, 1, true, 0, 1, (short)0));
    assertEquals("getCommitIndex", -1, leaderActor.getRaftActorContext().getCommitIndex());

    ArgumentCaptor<Procedure> callbackCaptor = ArgumentCaptor.forClass(Procedure.class);
    verify(mockPersistenceProvider).persistAsync(eq(logEntry), callbackCaptor.capture());

    callbackCaptor.getValue().apply(logEntry);

    assertEquals("getCommitIndex", 0, leaderActor.getRaftActorContext().getCommitIndex());
    assertEquals("getLastApplied", 0, leaderActor.getRaftActorContext().getLastApplied());
}
 

import org.opendaylight.controller.cluster.raft.behaviors.Leader; //导入依赖的package包/类
@Test
public void testRemoveServer() throws Exception {
    LOG.info("testRemoveServer starting");

    DefaultConfigParamsImpl configParams = new DefaultConfigParamsImpl();
    configParams.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS));
    configParams.setCustomRaftPolicyImplementationClass(DisableElectionsRaftPolicy.class.getName());

    final String follower1ActorId = actorFactory.generateActorId(FOLLOWER_ID);
    final String follower1ActorPath = actorFactory.createTestActorPath(follower1ActorId);
    final String follower2ActorId = actorFactory.generateActorId(FOLLOWER_ID2);
    final String follower2ActorPath = actorFactory.createTestActorPath(follower2ActorId);
    RaftActorContext initialActorContext = new MockRaftActorContext();

    final String downNodeId = "downNode";
    TestActorRef<MockLeaderRaftActor> leaderActor = actorFactory.createTestActor(MockLeaderRaftActor.props(
            ImmutableMap.of(FOLLOWER_ID, follower1ActorPath, FOLLOWER_ID2, follower2ActorPath, downNodeId, ""),
                    initialActorContext).withDispatcher(Dispatchers.DefaultDispatcherId()),
            actorFactory.generateActorId(LEADER_ID));

    final ActorRef leaderCollector = newLeaderCollectorActor(leaderActor.underlyingActor());

    ActorRef follower1Collector = actorFactory.createActor(
            MessageCollectorActor.props(), actorFactory.generateActorId("collector"));
    final TestActorRef<CollectingMockRaftActor> follower1Actor = actorFactory.createTestActor(
            CollectingMockRaftActor.props(FOLLOWER_ID, ImmutableMap.of(LEADER_ID, leaderActor.path().toString(),
                    FOLLOWER_ID2, follower2ActorPath, downNodeId, ""), configParams, NO_PERSISTENCE,
                    follower1Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), follower1ActorId);

    ActorRef follower2Collector = actorFactory.createActor(
            MessageCollectorActor.props(), actorFactory.generateActorId("collector"));
    final TestActorRef<CollectingMockRaftActor> follower2Actor = actorFactory.createTestActor(
            CollectingMockRaftActor.props(FOLLOWER_ID2, ImmutableMap.of(LEADER_ID, leaderActor.path().toString(),
                    FOLLOWER_ID, follower1ActorPath, downNodeId, ""), configParams, NO_PERSISTENCE,
                    follower2Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), follower2ActorId);

    leaderActor.underlyingActor().waitForInitializeBehaviorComplete();
    follower1Actor.underlyingActor().waitForInitializeBehaviorComplete();
    follower2Actor.underlyingActor().waitForInitializeBehaviorComplete();

    leaderActor.tell(new RemoveServer(FOLLOWER_ID), testKit.getRef());
    RemoveServerReply removeServerReply = testKit.expectMsgClass(JavaTestKit.duration("5 seconds"),
            RemoveServerReply.class);
    assertEquals("getStatus", ServerChangeStatus.OK, removeServerReply.getStatus());

    ApplyState applyState = MessageCollectorActor.expectFirstMatching(leaderCollector, ApplyState.class);
    assertEquals(0L, applyState.getReplicatedLogEntry().getIndex());
    verifyServerConfigurationPayloadEntry(leaderActor.underlyingActor().getRaftActorContext().getReplicatedLog(),
            votingServer(LEADER_ID), votingServer(FOLLOWER_ID2), votingServer(downNodeId));

    applyState = MessageCollectorActor.expectFirstMatching(follower2Collector, ApplyState.class);
    assertEquals(0L, applyState.getReplicatedLogEntry().getIndex());
    verifyServerConfigurationPayloadEntry(leaderActor.underlyingActor().getRaftActorContext().getReplicatedLog(),
            votingServer(LEADER_ID), votingServer(FOLLOWER_ID2), votingServer(downNodeId));

    RaftActorBehavior currentBehavior = leaderActor.underlyingActor().getCurrentBehavior();
    assertTrue("Expected Leader", currentBehavior instanceof Leader);
    assertEquals("Follower ids size", 2, ((Leader)currentBehavior).getFollowerIds().size());

    MessageCollectorActor.expectFirstMatching(follower1Collector, ServerRemoved.class);

    LOG.info("testRemoveServer ending");
}
 

import org.opendaylight.controller.cluster.raft.behaviors.Leader; //导入依赖的package包/类
@Test
public void testChangeLeaderToNonVoting() {
    LOG.info("testChangeLeaderToNonVoting starting");

    DefaultConfigParamsImpl configParams = new DefaultConfigParamsImpl();
    configParams.setHeartBeatInterval(new FiniteDuration(500, TimeUnit.MILLISECONDS));

    final String follower1ActorId = actorFactory.generateActorId(FOLLOWER_ID);
    final String follower1ActorPath = actorFactory.createTestActorPath(follower1ActorId);
    final String follower2ActorId = actorFactory.generateActorId(FOLLOWER_ID2);
    final String follower2ActorPath = actorFactory.createTestActorPath(follower2ActorId);

    TestActorRef<MockLeaderRaftActor> leaderActor = actorFactory.createTestActor(
            MockLeaderRaftActor.props(ImmutableMap.of(FOLLOWER_ID, follower1ActorPath,
                    FOLLOWER_ID2, follower2ActorPath), new MockRaftActorContext())
                    .withDispatcher(Dispatchers.DefaultDispatcherId()), actorFactory.generateActorId(LEADER_ID));
    ActorRef leaderCollector = newLeaderCollectorActor(leaderActor.underlyingActor());

    ActorRef follower1Collector = actorFactory.createActor(
            MessageCollectorActor.props(), actorFactory.generateActorId("collector"));
    final TestActorRef<CollectingMockRaftActor> follower1RaftActor = actorFactory.createTestActor(
            CollectingMockRaftActor.props(FOLLOWER_ID, ImmutableMap.of(LEADER_ID, leaderActor.path().toString(),
                    FOLLOWER_ID2, follower2ActorPath), configParams, NO_PERSISTENCE, follower1Collector)
                    .withDispatcher(Dispatchers.DefaultDispatcherId()), follower1ActorId);

    ActorRef follower2Collector = actorFactory.createActor(
            MessageCollectorActor.props(), actorFactory.generateActorId("collector"));
    final TestActorRef<CollectingMockRaftActor> follower2RaftActor = actorFactory.createTestActor(
            CollectingMockRaftActor.props(FOLLOWER_ID2, ImmutableMap.of(LEADER_ID, leaderActor.path().toString(),
                    FOLLOWER_ID, follower1ActorPath), configParams, NO_PERSISTENCE, follower2Collector)
                    .withDispatcher(Dispatchers.DefaultDispatcherId()), follower2ActorId);

    // Send ChangeServersVotingStatus message

    leaderActor.tell(new ChangeServersVotingStatus(ImmutableMap.of(LEADER_ID, false)), testKit.getRef());
    ServerChangeReply reply = testKit.expectMsgClass(JavaTestKit.duration("5 seconds"), ServerChangeReply.class);
    assertEquals("getStatus", ServerChangeStatus.OK, reply.getStatus());

    MessageCollectorActor.expectFirstMatching(leaderCollector, ApplyState.class);
    verifyServerConfigurationPayloadEntry(leaderActor.underlyingActor().getRaftActorContext().getReplicatedLog(),
            nonVotingServer(LEADER_ID), votingServer(FOLLOWER_ID), votingServer(FOLLOWER_ID2));

    MessageCollectorActor.expectFirstMatching(follower1Collector, ApplyState.class);
    verifyServerConfigurationPayloadEntry(follower1RaftActor.underlyingActor().getRaftActorContext()
            .getReplicatedLog(), nonVotingServer(LEADER_ID), votingServer(FOLLOWER_ID), votingServer(FOLLOWER_ID2));

    MessageCollectorActor.expectFirstMatching(follower2Collector, ApplyState.class);
    verifyServerConfigurationPayloadEntry(follower2RaftActor.underlyingActor().getRaftActorContext()
            .getReplicatedLog(), nonVotingServer(LEADER_ID), votingServer(FOLLOWER_ID), votingServer(FOLLOWER_ID2));

    verifyRaftState(RaftState.Leader, follower1RaftActor.underlyingActor(), follower2RaftActor.underlyingActor());
    verifyRaftState(RaftState.Follower, leaderActor.underlyingActor());

    MessageCollectorActor.expectMatching(leaderCollector, AppendEntries.class, 2);

    LOG.info("testChangeLeaderToNonVoting ending");
}
 

import org.opendaylight.controller.cluster.raft.behaviors.Leader; //导入依赖的package包/类
@Test
public void testChangeToVotingWithNoLeaderAndForwardedToOtherNodeAfterElectionTimeout() {
    LOG.info("testChangeToVotingWithNoLeaderAndForwardedToOtherNodeAfterElectionTimeout starting");

    final String node1ID = "node1";
    final String node2ID = "node2";

    final PeerAddressResolver peerAddressResolver = peerId -> peerId.equals(node1ID)
            ? actorFactory.createTestActorPath(node1ID) : peerId.equals(node2ID)
                    ? actorFactory.createTestActorPath(node2ID) : null;

    DefaultConfigParamsImpl configParams = new DefaultConfigParamsImpl();
    configParams.setHeartBeatInterval(new FiniteDuration(100, TimeUnit.MILLISECONDS));
    configParams.setElectionTimeoutFactor(3);
    configParams.setPeerAddressResolver(peerAddressResolver);

    ServerConfigurationPayload persistedServerConfig = new ServerConfigurationPayload(Arrays.asList(
            new ServerInfo(node1ID, false), new ServerInfo(node2ID, false)));
    SimpleReplicatedLogEntry persistedServerConfigEntry = new SimpleReplicatedLogEntry(0, 1, persistedServerConfig);

    InMemoryJournal.addEntry(node1ID, 1, new UpdateElectionTerm(1, "node1"));
    InMemoryJournal.addEntry(node1ID, 2, persistedServerConfigEntry);
    InMemoryJournal.addEntry(node2ID, 1, new UpdateElectionTerm(1, "node1"));
    InMemoryJournal.addEntry(node2ID, 2, persistedServerConfigEntry);
    InMemoryJournal.addEntry(node2ID, 3, new SimpleReplicatedLogEntry(1, 1,
            new MockRaftActorContext.MockPayload("2")));
    InMemoryJournal.addEntry(node2ID, 4, new ApplyJournalEntries(1));

    ActorRef node1Collector = actorFactory.createActor(
            MessageCollectorActor.props(), actorFactory.generateActorId("collector"));
    TestActorRef<CollectingMockRaftActor> node1RaftActorRef = actorFactory.createTestActor(
            CollectingMockRaftActor.props(node1ID, ImmutableMap.<String, String>of(), configParams,
                    PERSISTENT, node1Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), node1ID);
    final CollectingMockRaftActor node1RaftActor = node1RaftActorRef.underlyingActor();

    ActorRef node2Collector = actorFactory.createActor(
            MessageCollectorActor.props(), actorFactory.generateActorId("collector"));
    TestActorRef<CollectingMockRaftActor> node2RaftActorRef = actorFactory.createTestActor(
            CollectingMockRaftActor.props(node2ID, ImmutableMap.<String, String>of(), configParams,
                    PERSISTENT, node2Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), node2ID);
    final CollectingMockRaftActor node2RaftActor = node2RaftActorRef.underlyingActor();

    // Send a ChangeServersVotingStatus message to node1 to change mode1 to voting. This should cause
    // node1 to try to elect itself as leader in order to apply the new server config. However node1's log
    // is behind node2's so node2 should not grant node1's vote. This should cause node1 to time out and
    // forward the request to node2.

    ChangeServersVotingStatus changeServers = new ChangeServersVotingStatus(
            ImmutableMap.of(node1ID, true, node2ID, true));
    node1RaftActorRef.tell(changeServers, testKit.getRef());
    ServerChangeReply reply = testKit.expectMsgClass(JavaTestKit.duration("5 seconds"), ServerChangeReply.class);
    assertEquals("getStatus", ServerChangeStatus.OK, reply.getStatus());

    MessageCollectorActor.expectFirstMatching(node2Collector, ApplyJournalEntries.class);
    verifyServerConfigurationPayloadEntry(node2RaftActor.getRaftActorContext().getReplicatedLog(),
            votingServer(node1ID), votingServer(node2ID));
    assertEquals("getRaftState", RaftState.Leader, node2RaftActor.getRaftState());

    MessageCollectorActor.expectFirstMatching(node1Collector, ApplyJournalEntries.class);
    verifyServerConfigurationPayloadEntry(node1RaftActor.getRaftActorContext().getReplicatedLog(),
            votingServer(node1ID), votingServer(node2ID));
    assertEquals("isVotingMember", true, node1RaftActor.getRaftActorContext().isVotingMember());
    assertEquals("getRaftState", RaftState.Follower, node1RaftActor.getRaftState());

    LOG.info("testChangeToVotingWithNoLeaderAndForwardedToOtherNodeAfterElectionTimeout ending");
}
 

import org.opendaylight.controller.cluster.raft.behaviors.Leader; //导入依赖的package包/类
@Test
public void testChangeToVotingWithNoLeaderAndOtherLeaderElected() {
    LOG.info("testChangeToVotingWithNoLeaderAndOtherLeaderElected starting");

    DefaultConfigParamsImpl configParams = new DefaultConfigParamsImpl();
    configParams.setHeartBeatInterval(new FiniteDuration(100, TimeUnit.MILLISECONDS));
    configParams.setElectionTimeoutFactor(100000);

    final String node1ID = "node1";
    final String node2ID = "node2";

    configParams.setPeerAddressResolver(peerId -> peerId.equals(node1ID)
            ? actorFactory.createTestActorPath(node1ID) : peerId.equals(node2ID)
                    ? actorFactory.createTestActorPath(node2ID) : null);

    ServerConfigurationPayload persistedServerConfig = new ServerConfigurationPayload(Arrays.asList(
            new ServerInfo(node1ID, false), new ServerInfo(node2ID, true)));
    SimpleReplicatedLogEntry persistedServerConfigEntry = new SimpleReplicatedLogEntry(0, 1, persistedServerConfig);

    InMemoryJournal.addEntry(node1ID, 1, new UpdateElectionTerm(1, "node1"));
    InMemoryJournal.addEntry(node1ID, 2, persistedServerConfigEntry);
    InMemoryJournal.addEntry(node2ID, 1, new UpdateElectionTerm(1, "node1"));
    InMemoryJournal.addEntry(node2ID, 2, persistedServerConfigEntry);

    ActorRef node1Collector = actorFactory.createActor(
            MessageCollectorActor.props(), actorFactory.generateActorId("collector"));
    TestActorRef<CollectingMockRaftActor> node1RaftActorRef = actorFactory.createTestActor(
            CollectingMockRaftActor.props(node1ID, ImmutableMap.<String, String>of(), configParams,
                    PERSISTENT, node1Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), node1ID);
    final CollectingMockRaftActor node1RaftActor = node1RaftActorRef.underlyingActor();

    ActorRef node2Collector = actorFactory.createActor(
            MessageCollectorActor.props(), actorFactory.generateActorId("collector"));
    TestActorRef<CollectingMockRaftActor> node2RaftActorRef = actorFactory.createTestActor(
            CollectingMockRaftActor.props(node2ID, ImmutableMap.<String, String>of(), configParams,
                    PERSISTENT, node2Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), node2ID);
    CollectingMockRaftActor node2RaftActor = node2RaftActorRef.underlyingActor();

    // Send a ChangeServersVotingStatus message to node1 to change node1 to voting. This should cause
    // node1 to try to elect itself as leader in order to apply the new server config. But we'll drop
    // RequestVote messages in node2 and make it the leader so node1 should forward the server change
    // request to node2 when node2 is elected.

    node2RaftActor.setDropMessageOfType(RequestVote.class);

    ChangeServersVotingStatus changeServers = new ChangeServersVotingStatus(ImmutableMap.of(node1ID, true,
            node2ID, true));
    node1RaftActorRef.tell(changeServers, testKit.getRef());

    MessageCollectorActor.expectFirstMatching(node2Collector, RequestVote.class);

    node2RaftActorRef.tell(TimeoutNow.INSTANCE, ActorRef.noSender());

    ServerChangeReply reply = testKit.expectMsgClass(JavaTestKit.duration("5 seconds"), ServerChangeReply.class);
    assertEquals("getStatus", ServerChangeStatus.OK, reply.getStatus());

    MessageCollectorActor.expectFirstMatching(node1Collector, ApplyJournalEntries.class);
    verifyServerConfigurationPayloadEntry(node1RaftActor.getRaftActorContext().getReplicatedLog(),
            votingServer(node1ID), votingServer(node2ID));
    assertEquals("isVotingMember", true, node1RaftActor.getRaftActorContext().isVotingMember());
    assertEquals("getRaftState", RaftState.Follower, node1RaftActor.getRaftState());

    MessageCollectorActor.expectFirstMatching(node2Collector, ApplyJournalEntries.class);
    verifyServerConfigurationPayloadEntry(node2RaftActor.getRaftActorContext().getReplicatedLog(),
            votingServer(node1ID), votingServer(node2ID));
    assertEquals("getRaftState", RaftState.Leader, node2RaftActor.getRaftState());

    LOG.info("testChangeToVotingWithNoLeaderAndOtherLeaderElected ending");
}
 

import org.opendaylight.controller.cluster.raft.behaviors.Leader; //导入依赖的package包/类
@Override
protected void initializeBehavior() {
    changeCurrentBehavior(new Leader(getRaftActorContext()));
    initializeBehaviorComplete.countDown();
}
 

import org.opendaylight.controller.cluster.raft.behaviors.Leader; //导入依赖的package包/类
@Test
public void testSwitchBehavior() {
    String persistenceId = factory.generateActorId("leader-");
    DefaultConfigParamsImpl config = new DefaultConfigParamsImpl();
    config.setCustomRaftPolicyImplementationClass(DisableElectionsRaftPolicy.class.getName());
    config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS));
    config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS));
    config.setSnapshotBatchCount(5);

    DataPersistenceProvider dataPersistenceProvider = createProvider();

    Map<String, String> peerAddresses = ImmutableMap.<String, String>builder().build();

    TestActorRef<MockRaftActor> 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());
}