Java Follower类代码示例

import org.opendaylight.controller.cluster.raft.behaviors.Follower; //导入依赖的package包/类
@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 SimpleReplicatedLogEntry(0, 1,
            new ServerConfigurationPayload(Arrays.asList(new ServerInfo(persistenceId, false)))));

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

import org.opendaylight.controller.cluster.raft.behaviors.Follower; //导入依赖的package包/类
private void onLeaderTransitioning(final LeaderTransitioning leaderTransitioning) {
    LOG.debug("{}: onLeaderTransitioning: {}", persistenceId(), leaderTransitioning);
    Optional<ActorRef> roleChangeNotifier = getRoleChangeNotifier();
    if (getRaftState() == RaftState.Follower && roleChangeNotifier.isPresent()
            && leaderTransitioning.getLeaderId().equals(getCurrentBehavior().getLeaderId())) {
        roleChangeNotifier.get().tell(newLeaderStateChanged(getId(), null,
            getCurrentBehavior().getLeaderPayloadVersion()), getSelf());
    }
}
 

import org.opendaylight.controller.cluster.raft.behaviors.Follower; //导入依赖的package包/类
private void switchBehavior(SwitchBehavior message) {
    if (!getRaftActorContext().getRaftPolicy().automaticElectionsEnabled()) {
        RaftState newState = message.getNewState();
        if (newState == RaftState.Leader || newState == RaftState.Follower) {
            switchBehavior(behaviorStateTracker.capture(getCurrentBehavior()),
                AbstractRaftActorBehavior.createBehavior(context, message.getNewState()));
            getRaftActorContext().getTermInformation().updateAndPersist(message.getNewTerm(), "");
        } else {
            LOG.warn("Switching to behavior : {} - not supported", newState);
        }
    }
}
 

import org.opendaylight.controller.cluster.raft.behaviors.Follower; //导入依赖的package包/类
protected void updateConfigParams(ConfigParams configParams) {

        // obtain the RaftPolicy for oldConfigParams and the updated one.
        String oldRaftPolicy = context.getConfigParams().getCustomRaftPolicyImplementationClass();
        String newRaftPolicy = configParams.getCustomRaftPolicyImplementationClass();

        LOG.debug("{}: RaftPolicy used with prev.config {}, RaftPolicy used with newConfig {}", persistenceId(),
            oldRaftPolicy, newRaftPolicy);
        context.setConfigParams(configParams);
        if (!Objects.equals(oldRaftPolicy, newRaftPolicy)) {
            // The RaftPolicy was modified. If the current behavior is Follower then re-initialize to Follower
            // but transfer the previous leaderId so it doesn't immediately try to schedule an election. This
            // avoids potential disruption. Otherwise, switch to Follower normally.
            RaftActorBehavior behavior = getCurrentBehavior();
            if (behavior != null && behavior.state() == RaftState.Follower) {
                String previousLeaderId = behavior.getLeaderId();
                short previousLeaderPayloadVersion = behavior.getLeaderPayloadVersion();

                LOG.debug("{}: Re-initializing to Follower with previous leaderId {}", persistenceId(),
                        previousLeaderId);

                changeCurrentBehavior(new Follower(context, previousLeaderId, previousLeaderPayloadVersion));
            } else {
                initializeBehavior();
            }
        }
    }
 

import org.opendaylight.controller.cluster.raft.behaviors.Follower; //导入依赖的package包/类
@VisibleForTesting
void initializeBehavior() {
    changeCurrentBehavior(new Follower(context));
}
 

import org.opendaylight.controller.cluster.raft.behaviors.Follower; //导入依赖的package包/类
@Test
public void testRaftActorRecoveryWithPersistenceDisabled() throws Exception {
    String persistenceId = factory.generateActorId("follower-");

    DefaultConfigParamsImpl config = new DefaultConfigParamsImpl();

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

    TestActorRef<MockRaftActor> ref = factory.createTestActor(MockRaftActor.props(persistenceId,
            ImmutableMap.<String, String>builder().put("member1", "address").build(),
            config, createProvider()), persistenceId);

    MockRaftActor mockRaftActor = ref.underlyingActor();

    mockRaftActor.waitForRecoveryComplete();

    mockRaftActor.waitForInitializeBehaviorComplete();

    assertEquals("getRaftState", RaftState.Follower, mockRaftActor.getRaftState());
}
 

import org.opendaylight.controller.cluster.raft.behaviors.Follower; //导入依赖的package包/类
@Test
public void testRaftRoleChangeNotifierWhenRaftActorHasPeers() throws Exception {
    ActorRef notifierActor = factory.createActor(MessageCollectorActor.props());
    MessageCollectorActor.waitUntilReady(notifierActor);

    DefaultConfigParamsImpl config = new DefaultConfigParamsImpl();
    long heartBeatInterval = 100;
    config.setHeartBeatInterval(FiniteDuration.create(heartBeatInterval, TimeUnit.MILLISECONDS));
    config.setElectionTimeoutFactor(1);

    String persistenceId = factory.generateActorId("notifier-");

    factory.createActor(MockRaftActor.builder().id(persistenceId)
            .peerAddresses(ImmutableMap.of("leader", "fake/path"))
            .config(config).roleChangeNotifier(notifierActor).props());

    List<RoleChanged> matches =  null;
    for (int i = 0; i < 5000 / heartBeatInterval; i++) {
        matches = MessageCollectorActor.getAllMatching(notifierActor, RoleChanged.class);
        assertNotNull(matches);
        if (matches.size() == 3) {
            break;
        }
        Uninterruptibles.sleepUninterruptibly(heartBeatInterval, TimeUnit.MILLISECONDS);
    }

    assertNotNull(matches);
    assertEquals(2, matches.size());

    // check if the notifier got a role change from null to Follower
    RoleChanged raftRoleChanged = matches.get(0);
    assertEquals(persistenceId, raftRoleChanged.getMemberId());
    assertNull(raftRoleChanged.getOldRole());
    assertEquals(RaftState.Follower.name(), raftRoleChanged.getNewRole());

    // check if the notifier got a role change from Follower to Candidate
    raftRoleChanged = matches.get(1);
    assertEquals(persistenceId, raftRoleChanged.getMemberId());
    assertEquals(RaftState.Follower.name(), raftRoleChanged.getOldRole());
    assertEquals(RaftState.Candidate.name(), raftRoleChanged.getNewRole());
}
 

import org.opendaylight.controller.cluster.raft.behaviors.Follower; //导入依赖的package包/类
@Test
public void testUpdateConfigParam() throws Exception {
    DefaultConfigParamsImpl emptyConfig = new DefaultConfigParamsImpl();
    String persistenceId = factory.generateActorId("follower-");
    ImmutableMap<String, String> peerAddresses =
        ImmutableMap.<String, String>builder().put("member1", "address").build();
    DataPersistenceProvider dataPersistenceProvider = mock(DataPersistenceProvider.class);

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

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

    setupNewFollower();
    RaftActorContext initialActorContext = new MockRaftActorContext();

    TestActorRef<MockLeaderRaftActor> leaderActor = actorFactory.createTestActor(
            MockLeaderRaftActor.props(ImmutableMap.<String, String>of(),
                    initialActorContext).withDispatcher(Dispatchers.DefaultDispatcherId()),
            actorFactory.generateActorId(LEADER_ID));

    MockLeaderRaftActor leaderRaftActor = leaderActor.underlyingActor();
    final RaftActorContext leaderActorContext = leaderRaftActor.getRaftActorContext();

    final ActorRef leaderCollectorActor = newLeaderCollectorActor(leaderRaftActor);

    leaderActor.tell(new AddServer(NEW_SERVER_ID, newFollowerRaftActor.path().toString(), false), testKit.getRef());

    AddServerReply addServerReply = testKit.expectMsgClass(JavaTestKit.duration("5 seconds"), AddServerReply.class);
    assertEquals("getStatus", ServerChangeStatus.OK, addServerReply.getStatus());
    assertEquals("getLeaderHint", LEADER_ID, addServerReply.getLeaderHint().get());

    // Verify ServerConfigurationPayload entry in leader's log

    expectFirstMatching(leaderCollectorActor, ApplyState.class);

    assertEquals("Leader journal last index", 0, leaderActorContext.getReplicatedLog().lastIndex());
    assertEquals("Leader commit index", 0, leaderActorContext.getCommitIndex());
    assertEquals("Leader last applied index", 0, leaderActorContext.getLastApplied());
    verifyServerConfigurationPayloadEntry(leaderActorContext.getReplicatedLog(), votingServer(LEADER_ID),
            nonVotingServer(NEW_SERVER_ID));

    // Verify ServerConfigurationPayload entry in the new follower

    expectFirstMatching(newFollowerCollectorActor, ApplyState.class);
    assertEquals("New follower journal last index", 0, newFollowerActorContext.getReplicatedLog().lastIndex());
    verifyServerConfigurationPayloadEntry(newFollowerActorContext.getReplicatedLog(), votingServer(LEADER_ID),
            nonVotingServer(NEW_SERVER_ID));

    // Verify new server config was applied in the new follower

    assertEquals("New follower peers", Sets.newHashSet(LEADER_ID), newFollowerActorContext.getPeerIds());

    assertNoneMatching(newFollowerCollectorActor, InstallSnapshot.class, 500);

    // Add another non-voting server.

    clearMessages(leaderCollectorActor);

    RaftActorContext follower2ActorContext = newFollowerContext(NEW_SERVER_ID2, followerActor);
    Follower newFollower2 = new Follower(follower2ActorContext);
    followerActor.underlyingActor().setBehavior(newFollower2);

    leaderActor.tell(new AddServer(NEW_SERVER_ID2, followerActor.path().toString(), false), testKit.getRef());

    addServerReply = testKit.expectMsgClass(JavaTestKit.duration("5 seconds"), AddServerReply.class);
    assertEquals("getStatus", ServerChangeStatus.OK, addServerReply.getStatus());
    assertEquals("getLeaderHint", java.util.Optional.of(LEADER_ID), addServerReply.getLeaderHint());

    expectFirstMatching(leaderCollectorActor, ApplyState.class);
    assertEquals("Leader journal last index", 1, leaderActorContext.getReplicatedLog().lastIndex());
    assertEquals("Leader commit index", 1, leaderActorContext.getCommitIndex());
    assertEquals("Leader last applied index", 1, leaderActorContext.getLastApplied());
    verifyServerConfigurationPayloadEntry(leaderActorContext.getReplicatedLog(),
            votingServer(LEADER_ID), nonVotingServer(NEW_SERVER_ID), nonVotingServer(NEW_SERVER_ID2));

    LOG.info("testAddServersAsNonVoting ending");
}
 

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

    setupNewFollower();
    RaftActorContext initialActorContext = new MockRaftActorContext();

    TestActorRef<MockLeaderRaftActor> leaderActor = actorFactory.createTestActor(
            MockLeaderRaftActor.props(ImmutableMap.<String, String>of(),
                    initialActorContext).withDispatcher(Dispatchers.DefaultDispatcherId()),
            actorFactory.generateActorId(LEADER_ID));

    MockLeaderRaftActor leaderRaftActor = leaderActor.underlyingActor();
    final RaftActorContext leaderActorContext = leaderRaftActor.getRaftActorContext();

    final ActorRef leaderCollectorActor = newLeaderCollectorActor(leaderRaftActor);

    RaftActorContext follower2ActorContext = newFollowerContext(NEW_SERVER_ID2, followerActor);
    Follower newFollower2 = new Follower(follower2ActorContext);
    followerActor.underlyingActor().setBehavior(newFollower2);

    MockNewFollowerRaftActor newFollowerRaftActorInstance = newFollowerRaftActor.underlyingActor();
    newFollowerRaftActorInstance.setDropMessageOfType(InstallSnapshot.class);

    leaderActor.tell(new AddServer(NEW_SERVER_ID, newFollowerRaftActor.path().toString(), true), testKit.getRef());

    // Wait for leader's install snapshot and capture it

    InstallSnapshot installSnapshot = expectFirstMatching(newFollowerCollectorActor, InstallSnapshot.class);

    // Send a second AddServer - should get queued
    JavaTestKit testKit2 = new JavaTestKit(getSystem());
    leaderActor.tell(new AddServer(NEW_SERVER_ID2, followerActor.path().toString(), false), testKit2.getRef());

    // Continue the first AddServer
    newFollowerRaftActorInstance.setDropMessageOfType(null);
    newFollowerRaftActor.tell(installSnapshot, leaderActor);

    // Verify both complete successfully
    AddServerReply addServerReply = testKit.expectMsgClass(JavaTestKit.duration("5 seconds"), AddServerReply.class);
    assertEquals("getStatus", ServerChangeStatus.OK, addServerReply.getStatus());

    addServerReply = testKit2.expectMsgClass(JavaTestKit.duration("5 seconds"), AddServerReply.class);
    assertEquals("getStatus", ServerChangeStatus.OK, addServerReply.getStatus());

    // Verify ServerConfigurationPayload entries in leader's log

    expectMatching(leaderCollectorActor, ApplyState.class, 2);
    assertEquals("Leader journal last index", 1, leaderActorContext.getReplicatedLog().lastIndex());
    assertEquals("Leader commit index", 1, leaderActorContext.getCommitIndex());
    assertEquals("Leader last applied index", 1, leaderActorContext.getLastApplied());
    verifyServerConfigurationPayloadEntry(leaderActorContext.getReplicatedLog(),
            votingServer(LEADER_ID), votingServer(NEW_SERVER_ID), nonVotingServer(NEW_SERVER_ID2));

    // Verify ServerConfigurationPayload entry in the new follower

    expectMatching(newFollowerCollectorActor, ApplyState.class, 2);
    assertEquals("New follower peers", Sets.newHashSet(LEADER_ID, NEW_SERVER_ID2),
           newFollowerActorContext.getPeerIds());

    LOG.info("testAddServerWithOperationInProgress ending");
}
 

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

    setupNewFollower();
    RaftActorContext initialActorContext = new MockRaftActorContext();

    TestActorRef<MockLeaderRaftActor> leaderActor = actorFactory.createTestActor(
            MockLeaderRaftActor.props(ImmutableMap.<String, String>of(),
                    initialActorContext).withDispatcher(Dispatchers.DefaultDispatcherId()),
            actorFactory.generateActorId(LEADER_ID));

    MockLeaderRaftActor leaderRaftActor = leaderActor.underlyingActor();
    RaftActorContext leaderActorContext = leaderRaftActor.getRaftActorContext();
    ((DefaultConfigParamsImpl)leaderActorContext.getConfigParams()).setElectionTimeoutFactor(100);

    final ActorRef leaderCollectorActor = newLeaderCollectorActor(leaderRaftActor);

    // Drop the commit message so the snapshot doesn't complete yet.
    leaderRaftActor.setDropMessageOfType(COMMIT_MESSAGE_CLASS);

    leaderActor.tell(new InitiateCaptureSnapshot(), leaderActor);

    leaderActor.tell(new AddServer(NEW_SERVER_ID, newFollowerRaftActor.path().toString(), true), testKit.getRef());

    Object commitMsg = expectFirstMatching(leaderCollectorActor, COMMIT_MESSAGE_CLASS);

    // Change the leader behavior to follower
    leaderActor.tell(new Follower(leaderActorContext), leaderActor);

    // Drop CaptureSnapshotReply in case install snapshot is incorrectly initiated after the prior
    // snapshot completes. This will prevent the invalid snapshot from completing and fail the
    // isCapturing assertion below.
    leaderRaftActor.setDropMessageOfType(CaptureSnapshotReply.class);

    // Complete the prior snapshot - this should be a no-op b/c it's no longer the leader
    leaderActor.tell(commitMsg, leaderActor);

    leaderActor.tell(new RaftActorServerConfigurationSupport.ServerOperationTimeout(NEW_SERVER_ID), leaderActor);

    AddServerReply addServerReply = testKit.expectMsgClass(JavaTestKit.duration("5 seconds"), AddServerReply.class);
    assertEquals("getStatus", ServerChangeStatus.NO_LEADER, addServerReply.getStatus());

    assertEquals("Leader peers size", 0, leaderActorContext.getPeerIds().size());
    assertEquals("isCapturing", false, leaderActorContext.getSnapshotManager().isCapturing());

    LOG.info("testAddServerWithLeaderChangeBeforePriorSnapshotComplete ending");
}
 

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

    setupNewFollower();
    RaftActorContext initialActorContext = new MockRaftActorContext();

    TestActorRef<MockLeaderRaftActor> leaderActor = actorFactory.createTestActor(
            MockLeaderRaftActor.props(ImmutableMap.<String, String>of(),
                    initialActorContext).withDispatcher(Dispatchers.DefaultDispatcherId()),
            actorFactory.generateActorId(LEADER_ID));

    MockLeaderRaftActor leaderRaftActor = leaderActor.underlyingActor();
    RaftActorContext leaderActorContext = leaderRaftActor.getRaftActorContext();

    ((DefaultConfigParamsImpl)leaderActorContext.getConfigParams()).setElectionTimeoutFactor(8);

    ActorRef leaderCollectorActor = newLeaderCollectorActor(leaderRaftActor);

    // Drop the UnInitializedFollowerSnapshotReply to delay it.
    leaderRaftActor.setDropMessageOfType(UnInitializedFollowerSnapshotReply.class);

    leaderActor.tell(new AddServer(NEW_SERVER_ID, newFollowerRaftActor.path().toString(), true), testKit.getRef());

    final UnInitializedFollowerSnapshotReply snapshotReply = expectFirstMatching(leaderCollectorActor,
            UnInitializedFollowerSnapshotReply.class);

    // Prevent election timeout when the leader switches to follower
    ((DefaultConfigParamsImpl)leaderActorContext.getConfigParams()).setElectionTimeoutFactor(100);

    // Change the leader behavior to follower
    leaderActor.tell(new Follower(leaderActorContext), leaderActor);

    // Send the captured UnInitializedFollowerSnapshotReply - should be a no-op
    leaderRaftActor.setDropMessageOfType(null);
    leaderActor.tell(snapshotReply, leaderActor);

    AddServerReply addServerReply = testKit.expectMsgClass(JavaTestKit.duration("5 seconds"), AddServerReply.class);
    assertEquals("getStatus", ServerChangeStatus.NO_LEADER, addServerReply.getStatus());

    assertEquals("Leader peers size", 0, leaderActorContext.getPeerIds().size());

    LOG.info("testAddServerWithLeaderChangeDuringInstallSnapshot ending");
}
 

import org.opendaylight.controller.cluster.raft.behaviors.Follower; //导入依赖的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.Follower; //导入依赖的package包/类
@Test
public void testChangeToVotingWithNoLeaderAndElectionTimeout() {
    LOG.info("testChangeToVotingWithNoLeaderAndElectionTimeout 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;

    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);

    DefaultConfigParamsImpl configParams1 = new DefaultConfigParamsImpl();
    configParams1.setHeartBeatInterval(new FiniteDuration(100, TimeUnit.MILLISECONDS));
    configParams1.setElectionTimeoutFactor(1);
    configParams1.setPeerAddressResolver(peerAddressResolver);
    ActorRef node1Collector = actorFactory.createActor(
            MessageCollectorActor.props(), actorFactory.generateActorId("collector"));
    TestActorRef<CollectingMockRaftActor> node1RaftActorRef = actorFactory.createTestActor(
            CollectingMockRaftActor.props(node1ID, ImmutableMap.<String, String>of(), configParams1,
                    PERSISTENT, node1Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), node1ID);
    final CollectingMockRaftActor node1RaftActor = node1RaftActorRef.underlyingActor();

    DefaultConfigParamsImpl configParams2 = new DefaultConfigParamsImpl();
    configParams2.setElectionTimeoutFactor(1000000);
    configParams2.setPeerAddressResolver(peerAddressResolver);
    ActorRef node2Collector = actorFactory.createActor(
            MessageCollectorActor.props(), actorFactory.generateActorId("collector"));
    TestActorRef<CollectingMockRaftActor> node2RaftActorRef = actorFactory.createTestActor(
            CollectingMockRaftActor.props(node2ID, ImmutableMap.<String, String>of(), configParams2,
                    PERSISTENT, node2Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), node2ID);
    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. But we'll drop
    // RequestVote messages in node2 which should cause node1 to time out and revert back to the previous
    // server config and fail with NO_LEADER. Note that node1 shouldn't forward the request to node2 b/c
    // node2 was previously voting.

    node2RaftActor.setDropMessageOfType(RequestVote.class);

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

    assertEquals("Server config", Sets.newHashSet(nonVotingServer(node1ID), votingServer(node2ID)),
            Sets.newHashSet(node1RaftActor.getRaftActorContext().getPeerServerInfo(true).getServerConfig()));
    assertEquals("getRaftState", RaftState.Follower, node1RaftActor.getRaftState());

    LOG.info("testChangeToVotingWithNoLeaderAndElectionTimeout ending");
}
 

import org.opendaylight.controller.cluster.raft.behaviors.Follower; //导入依赖的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");
}