Java ActorSelection.forward方法代码示例

import akka.actor.ActorSelection; //导入方法依赖的package包/类
private void handleCanCommitTransaction(final CanCommitTransaction canCommit) {
    LOG.debug("{}: Can committing transaction {}", persistenceId(), canCommit.getTransactionId());

    if (isLeader()) {
        commitCoordinator.handleCanCommit(canCommit.getTransactionId(), getSender(), this);
    } else {
        ActorSelection leader = getLeader();
        if (leader == null) {
            messageRetrySupport.addMessageToRetry(canCommit, getSender(),
                    "Could not canCommit transaction " + canCommit.getTransactionId());
        } else {
            LOG.debug("{}: Forwarding CanCommitTransaction to leader {}", persistenceId(), leader);
            leader.forward(canCommit, getContext());
        }
    }
}
 

import akka.actor.ActorSelection; //导入方法依赖的package包/类
@SuppressWarnings("checkstyle:IllegalCatch")
private void handleReadyLocalTransaction(final ReadyLocalTransaction message) {
    LOG.debug("{}: handleReadyLocalTransaction for {}", persistenceId(), message.getTransactionId());

    boolean isLeaderActive = isLeaderActive();
    if (isLeader() && isLeaderActive) {
        try {
            commitCoordinator.handleReadyLocalTransaction(message, getSender(), this);
        } catch (Exception e) {
            LOG.error("{}: Error handling ReadyLocalTransaction for Tx {}", persistenceId(),
                    message.getTransactionId(), e);
            getSender().tell(new Failure(e), getSelf());
        }
    } else {
        ActorSelection leader = getLeader();
        if (!isLeaderActive || leader == null) {
            messageRetrySupport.addMessageToRetry(message, getSender(),
                    "Could not process ready local transaction " + message.getTransactionId());
        } else {
            LOG.debug("{}: Forwarding ReadyLocalTransaction to leader {}", persistenceId(), leader);
            message.setRemoteVersion(getCurrentBehavior().getLeaderPayloadVersion());
            leader.forward(message, getContext());
        }
    }
}
 

import akka.actor.ActorSelection; //导入方法依赖的package包/类
private void handleForwardedReadyTransaction(final ForwardedReadyTransaction forwardedReady) {
    LOG.debug("{}: handleForwardedReadyTransaction for {}", persistenceId(), forwardedReady.getTransactionId());

    boolean isLeaderActive = isLeaderActive();
    if (isLeader() && isLeaderActive) {
        commitCoordinator.handleForwardedReadyTransaction(forwardedReady, getSender(), this);
    } else {
        ActorSelection leader = getLeader();
        if (!isLeaderActive || leader == null) {
            messageRetrySupport.addMessageToRetry(forwardedReady, getSender(),
                    "Could not process forwarded ready transaction " + forwardedReady.getTransactionId());
        } else {
            LOG.debug("{}: Forwarding ForwardedReadyTransaction to leader {}", persistenceId(), leader);

            ReadyLocalTransaction readyLocal = new ReadyLocalTransaction(forwardedReady.getTransactionId(),
                    forwardedReady.getTransaction().getSnapshot(), forwardedReady.isDoImmediateCommit());
            readyLocal.setRemoteVersion(getCurrentBehavior().getLeaderPayloadVersion());
            leader.forward(readyLocal, getContext());
        }
    }
}
 

import akka.actor.ActorSelection; //导入方法依赖的package包/类
private void handleCommitTransaction(final CommitTransaction commit) {
    if (isLeader()) {
        commitCoordinator.handleCommit(commit.getTransactionId(), getSender(), this);
    } else {
        ActorSelection leader = getLeader();
        if (leader == null) {
            messageRetrySupport.addMessageToRetry(commit, getSender(),
                    "Could not commit transaction " + commit.getTransactionId());
        } else {
            LOG.debug("{}: Forwarding CommitTransaction to leader {}", persistenceId(), leader);
            leader.forward(commit, getContext());
        }
    }
}
 

import akka.actor.ActorSelection; //导入方法依赖的package包/类
private void handleBatchedModifications(final BatchedModifications batched) {
    // This message is sent to prepare the modifications transaction directly on the Shard as an
    // optimization to avoid the extra overhead of a separate ShardTransaction actor. On the last
    // BatchedModifications message, the caller sets the ready flag in the message indicating
    // modifications are complete. The reply contains the cohort actor path (this actor) for the caller
    // to initiate the 3-phase commit. This also avoids the overhead of sending an additional
    // ReadyTransaction message.

    // If we're not the leader then forward to the leader. This is a safety measure - we shouldn't
    // normally get here if we're not the leader as the front-end (TransactionProxy) should determine
    // the primary/leader shard. However with timing and caching on the front-end, there's a small
    // window where it could have a stale leader during leadership transitions.
    //
    boolean isLeaderActive = isLeaderActive();
    if (isLeader() && isLeaderActive) {
        handleBatchedModificationsLocal(batched, getSender());
    } else {
        ActorSelection leader = getLeader();
        if (!isLeaderActive || leader == null) {
            messageRetrySupport.addMessageToRetry(batched, getSender(),
                    "Could not process BatchedModifications " + batched.getTransactionId());
        } else {
            // If this is not the first batch and leadership changed in between batched messages,
            // we need to reconstruct previous BatchedModifications from the transaction
            // DataTreeModification, honoring the max batched modification count, and forward all the
            // previous BatchedModifications to the new leader.
            Collection<BatchedModifications> newModifications = commitCoordinator
                    .createForwardedBatchedModifications(batched,
                            datastoreContext.getShardBatchedModificationCount());

            LOG.debug("{}: Forwarding {} BatchedModifications to leader {}", persistenceId(),
                    newModifications.size(), leader);

            for (BatchedModifications bm : newModifications) {
                leader.forward(bm, getContext());
            }
        }
    }
}