Java RaftRPC类代码示例

import org.opendaylight.controller.cluster.raft.messages.RaftRPC; //导入依赖的package包/类
protected void assertStateChangesToFollowerWhenRaftRPCHasNewerTerm(final MockRaftActorContext actorContext,
        final ActorRef actorRef, final RaftRPC rpc) {

    Payload payload = new MockRaftActorContext.MockPayload("");
    setLastLogEntry(actorContext, 1, 0, payload);
    actorContext.getTermInformation().update(1, "test");

    RaftActorBehavior origBehavior = createBehavior(actorContext);
    RaftActorBehavior raftBehavior = origBehavior.handleMessage(actorRef, rpc);

    assertEquals("New raft state", RaftState.Follower, raftBehavior.state());
    assertEquals("New election term", rpc.getTerm(), actorContext.getTermInformation().getCurrentTerm());

    origBehavior.close();
    raftBehavior.close();
}
 

import org.opendaylight.controller.cluster.raft.messages.RaftRPC; //导入依赖的package包/类
@Override
public RaftActorBehavior handleMessage(final ActorRef sender, final Object message) {
    if (message instanceof ElectionTimeout || message instanceof TimeoutNow) {
        return handleElectionTimeout(message);
    }

    if (appendEntriesMessageAssembler.handleMessage(message, actor())) {
        return this;
    }

    if (!(message instanceof RaftRPC)) {
        // The rest of the processing requires the message to be a RaftRPC
        return null;
    }

    final RaftRPC rpc = (RaftRPC) message;
    // If RPC request or response contains term T > currentTerm:
    // set currentTerm = T, convert to follower (§5.1)
    // This applies to all RPC messages and responses
    if (rpc.getTerm() > context.getTermInformation().getCurrentTerm()) {
        log.info("{}: Term {} in \"{}\" message is greater than follower's term {} - updating term",
            logName(), rpc.getTerm(), rpc, context.getTermInformation().getCurrentTerm());

        context.getTermInformation().updateAndPersist(rpc.getTerm(), null);
    }

    if (rpc instanceof InstallSnapshot) {
        handleInstallSnapshot(sender, (InstallSnapshot) rpc);
        restartLastLeaderMessageTimer();
        scheduleElection(electionDuration());
        return this;
    }

    if (!(rpc instanceof RequestVote) || canGrantVote((RequestVote) rpc)) {
        restartLastLeaderMessageTimer();
        scheduleElection(electionDuration());
    }

    return super.handleMessage(sender, rpc);
}
 

import org.opendaylight.controller.cluster.raft.messages.RaftRPC; //导入依赖的package包/类
@Override
protected void assertStateChangesToFollowerWhenRaftRPCHasNewerTerm(final MockRaftActorContext actorContext,
        final ActorRef actorRef, final RaftRPC rpc) {
    super.assertStateChangesToFollowerWhenRaftRPCHasNewerTerm(actorContext, actorRef, rpc);
    if (rpc instanceof RequestVote) {
        assertEquals("New votedFor", ((RequestVote)rpc).getCandidateId(),
                actorContext.getTermInformation().getVotedFor());
    } else {
        assertEquals("New votedFor", null, actorContext.getTermInformation().getVotedFor());
    }
}
 

import org.opendaylight.controller.cluster.raft.messages.RaftRPC; //导入依赖的package包/类
@Test
public void testElectionScheduledWhenAnyRaftRPCReceived() {
    MockRaftActorContext context = createActorContext();
    follower = createBehavior(context);
    follower.handleMessage(leaderActor, new RaftRPC() {
        private static final long serialVersionUID = 1L;

        @Override
        public long getTerm() {
            return 100;
        }
    });
    verify(follower).scheduleElection(any(FiniteDuration.class));
}
 

import org.opendaylight.controller.cluster.raft.messages.RaftRPC; //导入依赖的package包/类
@Override
protected void assertStateChangesToFollowerWhenRaftRPCHasNewerTerm(final MockRaftActorContext actorContext,
        final ActorRef actorRef, final RaftRPC rpc) {
    super.assertStateChangesToFollowerWhenRaftRPCHasNewerTerm(actorContext, actorRef, rpc);

    String expVotedFor = rpc instanceof RequestVote ? ((RequestVote)rpc).getCandidateId() : null;
    assertEquals("New votedFor", expVotedFor, actorContext.getTermInformation().getVotedFor());
}
 

import org.opendaylight.controller.cluster.raft.messages.RaftRPC; //导入依赖的package包/类
@Override
public RaftActorBehavior handleMessage(ActorRef sender, Object message) {
    if (message instanceof ElectionTimeout) {
        log.debug("{}: Received ElectionTimeout", logName());

        if (votesRequired == 0) {
            // If there are no peers then we should be a Leader
            // We wait for the election timeout to occur before declare
            // ourselves the leader. This gives enough time for a leader
            // who we do not know about (as a peer)
            // to send a message to the candidate

            return internalSwitchBehavior(RaftState.Leader);
        }

        startNewTerm();
        scheduleElection(electionDuration());
        return this;
    }

    if (message instanceof RaftRPC) {

        RaftRPC rpc = (RaftRPC) message;

        log.debug("{}: RaftRPC message received {}, my term is {}", logName(), rpc,
                    context.getTermInformation().getCurrentTerm());

        // If RPC request or response contains term T > currentTerm:
        // set currentTerm = T, convert to follower (§5.1)
        // This applies to all RPC messages and responses
        if (rpc.getTerm() > context.getTermInformation().getCurrentTerm()) {
            log.info("{}: Term {} in \"{}\" message is greater than Candidate's term {} - switching to Follower",
                    logName(), rpc.getTerm(), rpc, context.getTermInformation().getCurrentTerm());

            context.getTermInformation().updateAndPersist(rpc.getTerm(), null);

            // The raft paper does not say whether or not a Candidate can/should process a RequestVote in
            // this case but doing so gains quicker convergence when the sender's log is more up-to-date.
            if (message instanceof RequestVote) {
                super.handleMessage(sender, message);
            }

            return internalSwitchBehavior(RaftState.Follower);
        }
    }

    return super.handleMessage(sender, message);
}
 

import org.opendaylight.controller.cluster.raft.messages.RaftRPC; //导入依赖的package包/类
@Override
public RaftActorBehavior handleMessage(final ActorRef sender, final Object message) {
    Preconditions.checkNotNull(sender, "sender should not be null");

    if (appendEntriesMessageSlicer.handleMessage(message)) {
        return this;
    }

    if (message instanceof RaftRPC) {
        RaftRPC rpc = (RaftRPC) message;
        // If RPC request or response contains term T > currentTerm:
        // set currentTerm = T, convert to follower (§5.1)
        // This applies to all RPC messages and responses
        if (rpc.getTerm() > context.getTermInformation().getCurrentTerm()) {
            log.info("{}: Term {} in \"{}\" message is greater than leader's term {} - switching to Follower",
                    logName(), rpc.getTerm(), rpc, context.getTermInformation().getCurrentTerm());

            context.getTermInformation().updateAndPersist(rpc.getTerm(), null);

            // This is a special case. Normally when stepping down as leader we don't process and reply to the
            // RaftRPC as per raft. But if we're in the process of transferring leadership and we get a
            // RequestVote, process the RequestVote before switching to Follower. This enables the requesting
            // candidate node to be elected the leader faster and avoids us possibly timing out in the Follower
            // state and starting a new election and grabbing leadership back before the other candidate node can
            // start a new election due to lack of responses. This case would only occur if there isn't a majority
            // of other nodes available that can elect the requesting candidate. Since we're transferring
            // leadership, we should make every effort to get the requesting node elected.
            if (message instanceof RequestVote && context.getRaftActorLeadershipTransferCohort() != null) {
                log.debug("{}: Leadership transfer in progress - processing RequestVote", logName());
                super.handleMessage(sender, message);
            }

            return internalSwitchBehavior(RaftState.Follower);
        }
    }

    if (message instanceof SendHeartBeat) {
        beforeSendHeartbeat();
        sendHeartBeat();
        scheduleHeartBeat(context.getConfigParams().getHeartBeatInterval());
    } else if (message instanceof SendInstallSnapshot) {
        SendInstallSnapshot sendInstallSnapshot = (SendInstallSnapshot) message;
        setSnapshot(new SnapshotHolder(sendInstallSnapshot.getSnapshot(), sendInstallSnapshot.getSnapshotBytes()));
        sendInstallSnapshot();
    } else if (message instanceof Replicate) {
        replicate((Replicate) message);
    } else if (message instanceof InstallSnapshotReply) {
        handleInstallSnapshotReply((InstallSnapshotReply) message);
    } else if (message instanceof CheckConsensusReached) {
        possiblyUpdateCommitIndex();
    } else {
        return super.handleMessage(sender, message);
    }

    return this;
}
 

import org.opendaylight.controller.cluster.raft.messages.RaftRPC; //导入依赖的package包/类
@Override
protected void assertStateChangesToFollowerWhenRaftRPCHasNewerTerm(final MockRaftActorContext actorContext,
        final ActorRef actorRef, final RaftRPC rpc) {
    super.assertStateChangesToFollowerWhenRaftRPCHasNewerTerm(actorContext, actorRef, rpc);
    assertEquals("New votedFor", null, actorContext.getTermInformation().getVotedFor());
}