Java InstallSnapshotReply类代码示例

import org.opendaylight.controller.cluster.raft.messages.InstallSnapshotReply; //导入依赖的package包/类
@Test
public void testHandleOutOfSequenceInstallSnapshot() {
    logStart("testHandleOutOfSequenceInstallSnapshot");

    MockRaftActorContext context = createActorContext();

    follower = createBehavior(context);

    ByteString bsSnapshot = createSnapshot();

    InstallSnapshot installSnapshot = new InstallSnapshot(1, "leader", 3, 1,
            getNextChunk(bsSnapshot, 10, 50), 3, 3);
    follower.handleMessage(leaderActor, installSnapshot);

    InstallSnapshotReply reply = MessageCollectorActor.expectFirstMatching(leaderActor,
            InstallSnapshotReply.class);

    assertEquals("isSuccess", false, reply.isSuccess());
    assertEquals("getChunkIndex", -1, reply.getChunkIndex());
    assertEquals("getTerm", 1, reply.getTerm());
    assertEquals("getFollowerId", context.getId(), reply.getFollowerId());

    assertNull("Expected null SnapshotTracker", follower.getSnapshotTracker());
}
 

import org.opendaylight.controller.cluster.raft.messages.InstallSnapshotReply; //导入依赖的package包/类
private void handleInstallSnapshot(final ActorRef sender, final InstallSnapshot installSnapshot) {

        log.debug("{}: handleInstallSnapshot: {}", logName(), installSnapshot);

        leaderId = installSnapshot.getLeaderId();

        if (snapshotTracker == null) {
            snapshotTracker = new SnapshotTracker(log, installSnapshot.getTotalChunks(), installSnapshot.getLeaderId(),
                    context);
        }

        updateInitialSyncStatus(installSnapshot.getLastIncludedIndex(), installSnapshot.getLeaderId());

        try {
            final InstallSnapshotReply reply = new InstallSnapshotReply(
                    currentTerm(), context.getId(), installSnapshot.getChunkIndex(), true);

            if (snapshotTracker.addChunk(installSnapshot.getChunkIndex(), installSnapshot.getData(),
                    installSnapshot.getLastChunkHashCode())) {

                log.info("{}: Snapshot installed from leader: {}", logName(), installSnapshot.getLeaderId());

                Snapshot snapshot = Snapshot.create(
                        context.getSnapshotManager().convertSnapshot(snapshotTracker.getSnapshotBytes()),
                        new ArrayList<>(),
                        installSnapshot.getLastIncludedIndex(),
                        installSnapshot.getLastIncludedTerm(),
                        installSnapshot.getLastIncludedIndex(),
                        installSnapshot.getLastIncludedTerm(),
                        context.getTermInformation().getCurrentTerm(),
                        context.getTermInformation().getVotedFor(),
                        installSnapshot.getServerConfig().orNull());

                ApplySnapshot.Callback applySnapshotCallback = new ApplySnapshot.Callback() {
                    @Override
                    public void onSuccess() {
                        log.debug("{}: handleInstallSnapshot returning: {}", logName(), reply);

                        sender.tell(reply, actor());
                    }

                    @Override
                    public void onFailure() {
                        sender.tell(new InstallSnapshotReply(currentTerm(), context.getId(), -1, false), actor());
                    }
                };

                actor().tell(new ApplySnapshot(snapshot, applySnapshotCallback), actor());

                closeSnapshotTracker();
            } else {
                log.debug("{}: handleInstallSnapshot returning: {}", logName(), reply);

                sender.tell(reply, actor());
            }
        } catch (IOException e) {
            log.debug("{}: Exception in InstallSnapshot of follower", logName(), e);

            sender.tell(new InstallSnapshotReply(currentTerm(), context.getId(),
                    -1, false), actor());

            closeSnapshotTracker();
        }
    }
 

import org.opendaylight.controller.cluster.raft.messages.InstallSnapshotReply; //导入依赖的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.InstallSnapshotReply; //导入依赖的package包/类
@Test
public void testHandleInstallSnapshotReplyLastChunk() throws Exception {
    logStart("testHandleInstallSnapshotReplyLastChunk");

    MockRaftActorContext actorContext = createActorContextWithFollower();

    final int commitIndex = 3;
    final int snapshotIndex = 2;
    final int snapshotTerm = 1;
    final int currentTerm = 2;

    actorContext.setCommitIndex(commitIndex);

    leader = new Leader(actorContext);
    actorContext.setCurrentBehavior(leader);

    leader.getFollower(FOLLOWER_ID).setMatchIndex(-1);
    leader.getFollower(FOLLOWER_ID).setNextIndex(0);

    // Ignore initial heartbeat.
    MessageCollectorActor.expectFirstMatching(followerActor, AppendEntries.class);

    Map<String, String> leadersSnapshot = new HashMap<>();
    leadersSnapshot.put("1", "A");
    leadersSnapshot.put("2", "B");
    leadersSnapshot.put("3", "C");

    // set the snapshot variables in replicatedlog

    actorContext.getReplicatedLog().setSnapshotIndex(snapshotIndex);
    actorContext.getReplicatedLog().setSnapshotTerm(snapshotTerm);
    actorContext.getTermInformation().update(currentTerm, leaderActor.path().toString());

    ByteString bs = toByteString(leadersSnapshot);
    leader.setSnapshot(new SnapshotHolder(Snapshot.create(ByteState.of(bs.toByteArray()),
            Collections.<ReplicatedLogEntry>emptyList(), commitIndex, snapshotTerm, commitIndex, snapshotTerm,
            -1, null, null), ByteSource.wrap(bs.toByteArray())));
    LeaderInstallSnapshotState fts = new LeaderInstallSnapshotState(
            actorContext.getConfigParams().getSnapshotChunkSize(), leader.logName());
    fts.setSnapshotBytes(ByteSource.wrap(bs.toByteArray()));
    leader.getFollower(FOLLOWER_ID).setLeaderInstallSnapshotState(fts);
    while (!fts.isLastChunk(fts.getChunkIndex())) {
        fts.getNextChunk();
        fts.incrementChunkIndex();
    }

    //clears leaders log
    actorContext.getReplicatedLog().removeFrom(0);

    RaftActorBehavior raftBehavior = leader.handleMessage(followerActor,
            new InstallSnapshotReply(currentTerm, FOLLOWER_ID, fts.getChunkIndex(), true));

    assertTrue(raftBehavior instanceof Leader);

    assertEquals(1, leader.followerLogSize());
    FollowerLogInformation fli = leader.getFollower(FOLLOWER_ID);
    assertNotNull(fli);
    assertNull(fli.getInstallSnapshotState());
    assertEquals(commitIndex, fli.getMatchIndex());
    assertEquals(commitIndex + 1, fli.getNextIndex());
    assertFalse(leader.hasSnapshot());
}
 

import org.opendaylight.controller.cluster.raft.messages.InstallSnapshotReply; //导入依赖的package包/类
@Test
public void testSendSnapshotfromInstallSnapshotReply() throws Exception {
    logStart("testSendSnapshotfromInstallSnapshotReply");

    MockRaftActorContext actorContext = createActorContextWithFollower();

    final int commitIndex = 3;
    final int snapshotIndex = 2;
    final int snapshotTerm = 1;
    final int currentTerm = 2;

    DefaultConfigParamsImpl configParams = new DefaultConfigParamsImpl() {
        @Override
        public int getSnapshotChunkSize() {
            return 50;
        }
    };
    configParams.setHeartBeatInterval(new FiniteDuration(9, TimeUnit.SECONDS));
    configParams.setIsolatedLeaderCheckInterval(new FiniteDuration(10, TimeUnit.SECONDS));

    actorContext.setConfigParams(configParams);
    actorContext.setCommitIndex(commitIndex);

    leader = new Leader(actorContext);
    actorContext.setCurrentBehavior(leader);

    leader.getFollower(FOLLOWER_ID).setMatchIndex(-1);
    leader.getFollower(FOLLOWER_ID).setNextIndex(0);

    Map<String, String> leadersSnapshot = new HashMap<>();
    leadersSnapshot.put("1", "A");
    leadersSnapshot.put("2", "B");
    leadersSnapshot.put("3", "C");

    // set the snapshot variables in replicatedlog
    actorContext.getReplicatedLog().setSnapshotIndex(snapshotIndex);
    actorContext.getReplicatedLog().setSnapshotTerm(snapshotTerm);
    actorContext.getTermInformation().update(currentTerm, leaderActor.path().toString());

    ByteString bs = toByteString(leadersSnapshot);
    Snapshot snapshot = Snapshot.create(ByteState.of(bs.toByteArray()),
            Collections.<ReplicatedLogEntry>emptyList(), commitIndex, snapshotTerm, commitIndex, snapshotTerm,
            -1, null, null);

    leader.handleMessage(leaderActor, new SendInstallSnapshot(snapshot, ByteSource.wrap(bs.toByteArray())));

    InstallSnapshot installSnapshot = MessageCollectorActor.expectFirstMatching(followerActor,
            InstallSnapshot.class);

    assertEquals(1, installSnapshot.getChunkIndex());
    assertEquals(3, installSnapshot.getTotalChunks());

    followerActor.underlyingActor().clear();
    leader.handleMessage(followerActor, new InstallSnapshotReply(actorContext.getTermInformation().getCurrentTerm(),
            FOLLOWER_ID, installSnapshot.getChunkIndex(), true));

    installSnapshot = MessageCollectorActor.expectFirstMatching(followerActor, InstallSnapshot.class);

    assertEquals(2, installSnapshot.getChunkIndex());
    assertEquals(3, installSnapshot.getTotalChunks());

    followerActor.underlyingActor().clear();
    leader.handleMessage(followerActor, new InstallSnapshotReply(actorContext.getTermInformation().getCurrentTerm(),
            FOLLOWER_ID, installSnapshot.getChunkIndex(), true));

    installSnapshot = MessageCollectorActor.expectFirstMatching(followerActor, InstallSnapshot.class);

    // Send snapshot reply one more time and make sure that a new snapshot message should not be sent to follower
    followerActor.underlyingActor().clear();
    leader.handleMessage(followerActor, new InstallSnapshotReply(actorContext.getTermInformation().getCurrentTerm(),
            FOLLOWER_ID, installSnapshot.getChunkIndex(), true));

    installSnapshot = MessageCollectorActor.getFirstMatching(followerActor, InstallSnapshot.class);

    assertNull(installSnapshot);
}
 

import org.opendaylight.controller.cluster.raft.messages.InstallSnapshotReply; //导入依赖的package包/类
@Test
public void testHandleInstallSnapshotReplyWithInvalidChunkIndex() throws Exception {
    logStart("testHandleInstallSnapshotReplyWithInvalidChunkIndex");

    MockRaftActorContext actorContext = createActorContextWithFollower();

    final int commitIndex = 3;
    final int snapshotIndex = 2;
    final int snapshotTerm = 1;
    final int currentTerm = 2;

    actorContext.setConfigParams(new DefaultConfigParamsImpl() {
        @Override
        public int getSnapshotChunkSize() {
            return 50;
        }
    });

    actorContext.setCommitIndex(commitIndex);

    leader = new Leader(actorContext);

    leader.getFollower(FOLLOWER_ID).setMatchIndex(-1);
    leader.getFollower(FOLLOWER_ID).setNextIndex(0);

    Map<String, String> leadersSnapshot = new HashMap<>();
    leadersSnapshot.put("1", "A");
    leadersSnapshot.put("2", "B");
    leadersSnapshot.put("3", "C");

    // set the snapshot variables in replicatedlog
    actorContext.getReplicatedLog().setSnapshotIndex(snapshotIndex);
    actorContext.getReplicatedLog().setSnapshotTerm(snapshotTerm);
    actorContext.getTermInformation().update(currentTerm, leaderActor.path().toString());

    ByteString bs = toByteString(leadersSnapshot);
    Snapshot snapshot = Snapshot.create(ByteState.of(bs.toByteArray()),
            Collections.<ReplicatedLogEntry>emptyList(), commitIndex, snapshotTerm, commitIndex, snapshotTerm,
            -1, null, null);

    Uninterruptibles.sleepUninterruptibly(1, TimeUnit.SECONDS);
    leader.handleMessage(leaderActor, new SendInstallSnapshot(snapshot, ByteSource.wrap(bs.toByteArray())));

    InstallSnapshot installSnapshot = MessageCollectorActor.expectFirstMatching(followerActor,
            InstallSnapshot.class);

    assertEquals(1, installSnapshot.getChunkIndex());
    assertEquals(3, installSnapshot.getTotalChunks());

    followerActor.underlyingActor().clear();

    leader.handleMessage(followerActor, new InstallSnapshotReply(actorContext.getTermInformation().getCurrentTerm(),
            FOLLOWER_ID, -1, false));

    Uninterruptibles.sleepUninterruptibly(actorContext.getConfigParams().getHeartBeatInterval().toMillis(),
            TimeUnit.MILLISECONDS);

    leader.handleMessage(leaderActor, SendHeartBeat.INSTANCE);

    installSnapshot = MessageCollectorActor.expectFirstMatching(followerActor, InstallSnapshot.class);

    assertEquals(1, installSnapshot.getChunkIndex());
    assertEquals(3, installSnapshot.getTotalChunks());
}
 

import org.opendaylight.controller.cluster.raft.messages.InstallSnapshotReply; //导入依赖的package包/类
@Test
public void testHandleSnapshotSendsPreviousChunksHashCodeWhenSendingNextChunk() throws Exception {
    logStart("testHandleSnapshotSendsPreviousChunksHashCodeWhenSendingNextChunk");

    MockRaftActorContext actorContext = createActorContextWithFollower();

    final int commitIndex = 3;
    final int snapshotIndex = 2;
    final int snapshotTerm = 1;
    final int currentTerm = 2;

    actorContext.setConfigParams(new DefaultConfigParamsImpl() {
        @Override
        public int getSnapshotChunkSize() {
            return 50;
        }
    });

    actorContext.setCommitIndex(commitIndex);

    leader = new Leader(actorContext);

    leader.getFollower(FOLLOWER_ID).setMatchIndex(-1);
    leader.getFollower(FOLLOWER_ID).setNextIndex(0);

    Map<String, String> leadersSnapshot = new HashMap<>();
    leadersSnapshot.put("1", "A");
    leadersSnapshot.put("2", "B");
    leadersSnapshot.put("3", "C");

    // set the snapshot variables in replicatedlog
    actorContext.getReplicatedLog().setSnapshotIndex(snapshotIndex);
    actorContext.getReplicatedLog().setSnapshotTerm(snapshotTerm);
    actorContext.getTermInformation().update(currentTerm, leaderActor.path().toString());

    ByteString bs = toByteString(leadersSnapshot);
    Snapshot snapshot = Snapshot.create(ByteState.of(bs.toByteArray()),
            Collections.<ReplicatedLogEntry>emptyList(), commitIndex, snapshotTerm, commitIndex, snapshotTerm,
            -1, null, null);

    leader.handleMessage(leaderActor, new SendInstallSnapshot(snapshot, ByteSource.wrap(bs.toByteArray())));

    InstallSnapshot installSnapshot = MessageCollectorActor.expectFirstMatching(followerActor,
            InstallSnapshot.class);

    assertEquals(1, installSnapshot.getChunkIndex());
    assertEquals(3, installSnapshot.getTotalChunks());
    assertEquals(LeaderInstallSnapshotState.INITIAL_LAST_CHUNK_HASH_CODE,
            installSnapshot.getLastChunkHashCode().get().intValue());

    final int hashCode = Arrays.hashCode(installSnapshot.getData());

    followerActor.underlyingActor().clear();

    leader.handleMessage(followerActor, new InstallSnapshotReply(installSnapshot.getTerm(),
            FOLLOWER_ID, 1, true));

    installSnapshot = MessageCollectorActor.expectFirstMatching(followerActor, InstallSnapshot.class);

    assertEquals(2, installSnapshot.getChunkIndex());
    assertEquals(3, installSnapshot.getTotalChunks());
    assertEquals(hashCode, installSnapshot.getLastChunkHashCode().get().intValue());
}
 

import org.opendaylight.controller.cluster.raft.messages.InstallSnapshotReply; //导入依赖的package包/类
private void handleInstallSnapshot(InstallSnapshot req) {
    sender().tell(new InstallSnapshotReply(req.getTerm(), followerId, req.getChunkIndex(), true), self());
}