Java TransportChannel类代码示例

import org.elasticsearch.transport.TransportChannel; //导入依赖的package包/类
@Override
public void messageReceived(PingRequest request, TransportChannel channel) throws Exception {
    // if we are not the node we are supposed to be pinged, send an exception
    // this can happen when a kill -9 is sent, and another node is started using the same port
    if (!localNode.equals(request.targetNode())) {
        throw new IllegalStateException("Got pinged as node " + request.targetNode() + "], but I am node " + localNode );
    }

    // PingRequest will have clusterName set to null if it came from a node of version <1.4.0
    if (request.clusterName != null && !request.clusterName.equals(clusterName)) {
        // Don't introduce new exception for bwc reasons
        throw new IllegalStateException("Got pinged with cluster name [" + request.clusterName + "], but I'm part of cluster ["
            + clusterName + "]");
    }

    notifyPingReceived(request);

    channel.sendResponse(new PingResponse());
}
 

import org.elasticsearch.transport.TransportChannel; //导入依赖的package包/类
@Override
public void messageReceived(T request, TransportChannel channel, Task task) throws Exception {
    synchronized (InterceptingTransportService.this) {
        if (actions.contains(action)) {
            List<TransportRequest> requestList = requests.get(action);
            if (requestList == null) {
                requestList = new ArrayList<>();
                requestList.add(request);
                requests.put(action, requestList);
            } else {
                requestList.add(request);
            }
        }
    }
    requestHandler.messageReceived(request, channel, task);
}
 

import org.elasticsearch.transport.TransportChannel; //导入依赖的package包/类
@Override
public void messageReceived(final PingRequest request, final TransportChannel channel) throws Exception {
    if (indexingProxyService.isRunning(request.getIndex())) {
        channel.sendResponse(new PingResponse(true, true));
    } else {
        indexingProxyService.startRequestSender(request.getIndex(), 0, wrap(response -> {
            channel.sendResponse(new PingResponse(true, false));
        }, e -> {
            try {
                channel.sendResponse(e);
            } catch (final IOException e1) {
                throw new ElasticsearchException("Failed to write a response.", e1);
            }
        }));
    }
}
 

import org.elasticsearch.transport.TransportChannel; //导入依赖的package包/类
@Override
public void messageReceived(PullFullClusterStateRequest request, final TransportChannel channel) throws Exception {
    ClusterStateWithDLSN clusterStateWithDLSN = clusterStateOpLog.getLatestClusterState();
    if (!clusterStateWithDLSN.state().getClusterName().equals(request.clusterName)) {
       throw new java.lang.Exception("master cluster name is [" + clusterStateWithDLSN.state().getClusterName() + "], request cluster name is [" + request.clusterName + "]");
    }
    if (!clusterStateWithDLSN.state().nodes().localNodeMaster()) {
        throw new java.lang.Exception("current node is no longer master node");
    }
    BytesStreamOutput bStream = new BytesStreamOutput();
    try (StreamOutput stream = CompressorFactory.defaultCompressor().streamOutput(bStream)) {
        clusterStateWithDLSN.writeTo(stream);
    }
    BytesReference fullStateBytes = bStream.bytes();
    channel.sendResponse(new org.elasticsearch.transport.BytesTransportResponse(fullStateBytes));
}
 

import org.elasticsearch.transport.TransportChannel; //导入依赖的package包/类
@Override
public void messageReceived(PingRequest request, TransportChannel channel) throws Exception {
    
    // PingRequest will have clusterName set to null if it came from a node of version <1.4.0
    if (request.clusterName != null && !request.clusterName.equals(clusterName)) {
        // Don't introduce new exception for bwc reasons
        throw new IllegalStateException("Got pinged with cluster name [" + request.clusterName + "], but I'm part of cluster [" + clusterName + "]");
    }
    
    // if we are not the node we are supposed to be pinged, send an exception
    // this can happen when a kill -9 is sent, and another node is started using the same port
    if (!localNode.equals(request.pingNode)) {
        logger.warn("Got pinged as node [{}], but I am node [{}], cluster name is equal, it means I am restarted, so rejoin the cluster now", request.pingNode, localNode);
        joinClusterAction.joinElectedMaster(request.masterNode);
        throw new NodeIdNotMatchException(localNode, request.pingNode);
    }
    
    if (request.isDeadNode) {
        logger.warn("master ping me as a dead node, so that I should rejoin the cluster");
        joinClusterAction.joinElectedMaster(request.masterNode);
    }
    channel.sendResponse(new PingResponse(clusterStateOpLog.getDumpedDlsn()));
}
 

import org.elasticsearch.transport.TransportChannel; //导入依赖的package包/类
/**
 * this is method is called on the recovery source node
 * the target is requesting the head of a file it got a PutReplicaChunkRequest for.
 */
@Override
public void messageReceived(final GetBlobHeadRequest request, TransportChannel channel) throws Exception {

    final BlobTransferStatus transferStatus = blobTransferTarget.getActiveTransfer(request.transferId);
    assert transferStatus != null :
        "Received GetBlobHeadRequest for transfer" + request.transferId.toString() + "but don't have an activeTransfer with that id";

    final DiscoveryNode recipientNode = clusterService.state().getNodes().get(request.senderNodeId);
    final long bytesToSend = request.endPos;

    blobTransferTarget.gotAGetBlobHeadRequest(request.transferId);

    channel.sendResponse(TransportResponse.Empty.INSTANCE);

    threadPool.generic().execute(
        new PutHeadChunkRunnable(
            transferStatus.digestBlob(), bytesToSend, transportService, blobTransferTarget,
            recipientNode, request.transferId)
    );
}
 

import org.elasticsearch.transport.TransportChannel; //导入依赖的package包/类
@Override
public void messageReceived(final FileFlushRequest request, final TransportChannel channel) throws Exception {
    new ConfigFileWriter().execute(wrap(response -> {
        try {
            channel.sendResponse(new FileFlushResponse(true));
        } catch (final IOException e) {
            throw new ElasticsearchException("Failed to write a response.", e);
        }
    }, e -> {
        logger.error("Failed to flush config files.", e);
        try {
            channel.sendResponse(e);
        } catch (final IOException e1) {
            throw new ElasticsearchException("Failed to write a response.", e1);
        }
    }));
}
 

import org.elasticsearch.transport.TransportChannel; //导入依赖的package包/类
@Override
public void messageReceived(RecoveryPrepareForTranslogOperationsRequest request, TransportChannel channel) throws Exception {
    try (RecoveryRef recoveryRef = onGoingRecoveries.getRecoverySafe(request.recoveryId(), request.shardId()
    )) {
        recoveryRef.target().prepareForTranslogOperations(request.totalTranslogOps(), request.getMaxUnsafeAutoIdTimestamp());
    }
    channel.sendResponse(TransportResponse.Empty.INSTANCE);
}
 

import org.elasticsearch.transport.TransportChannel; //导入依赖的package包/类
@Override
public void messageReceived(UnicastPingRequest request, TransportChannel channel) throws Exception {
    if (request.pingResponse.clusterName().equals(clusterName)) {
        channel.sendResponse(handlePingRequest(request));
    } else {
        throw new IllegalStateException(
            String.format(
                Locale.ROOT,
                "mismatched cluster names; request: [%s], local: [%s]",
                request.pingResponse.clusterName().value(),
                clusterName.value()));
    }
}
 

import org.elasticsearch.transport.TransportChannel; //导入依赖的package包/类
@Override
public void messageReceived(VerifyNodeRepositoryRequest request, TransportChannel channel) throws Exception {
    DiscoveryNode localNode = clusterService.state().nodes().getLocalNode();
    try {
        doVerify(request.repository, request.verificationToken, localNode);
    } catch (Exception ex) {
        logger.warn((Supplier<?>) () -> new ParameterizedMessage("[{}] failed to verify repository", request.repository), ex);
        throw ex;
    }
    channel.sendResponse(TransportResponse.Empty.INSTANCE);
}
 

import org.elasticsearch.transport.TransportChannel; //导入依赖的package包/类
@Override
public void messageReceived(ShardEntry request, TransportChannel channel) throws Exception {
    logger.debug("{} received shard started for [{}]", request.shardId, request);
    clusterService.submitStateUpdateTask(
        "shard-started",
        request,
        ClusterStateTaskConfig.build(Priority.URGENT),
        shardStartedClusterStateTaskExecutor,
        shardStartedClusterStateTaskExecutor);
    channel.sendResponse(TransportResponse.Empty.INSTANCE);
}
 

import org.elasticsearch.transport.TransportChannel; //导入依赖的package包/类
@Override
public void messageReceived(final BanParentTaskRequest request, final TransportChannel channel) throws Exception {
    if (request.ban) {
        logger.debug("Received ban for the parent [{}] on the node [{}], reason: [{}]", request.parentTaskId,
            clusterService.localNode().getId(), request.reason);
        taskManager.setBan(request.parentTaskId, request.reason);
    } else {
        logger.debug("Removing ban for the parent [{}] on the node [{}]", request.parentTaskId,
            clusterService.localNode().getId());
        taskManager.removeBan(request.parentTaskId);
    }
    channel.sendResponse(TransportResponse.Empty.INSTANCE);
}
 

import org.elasticsearch.transport.TransportChannel; //导入依赖的package包/类
@Override
public void messageReceived(final NodeRequest request, TransportChannel channel) throws Exception {
    List<ShardRouting> shards = request.getShards();
    final int totalShards = shards.size();
    if (logger.isTraceEnabled()) {
        logger.trace("[{}] executing operation on [{}] shards", actionName, totalShards);
    }
    final Object[] shardResultOrExceptions = new Object[totalShards];

    int shardIndex = -1;
    for (final ShardRouting shardRouting : shards) {
        shardIndex++;
        onShardOperation(request, shardResultOrExceptions, shardIndex, shardRouting);
    }

    List<BroadcastShardOperationFailedException> accumulatedExceptions = new ArrayList<>();
    List<ShardOperationResult> results = new ArrayList<>();
    for (int i = 0; i < totalShards; i++) {
        if (shardResultOrExceptions[i] instanceof BroadcastShardOperationFailedException) {
            accumulatedExceptions.add((BroadcastShardOperationFailedException) shardResultOrExceptions[i]);
        } else {
            results.add((ShardOperationResult) shardResultOrExceptions[i]);
        }
    }

    channel.sendResponse(new NodeResponse(request.getNodeId(), totalShards, results, accumulatedExceptions));
}
 

import org.elasticsearch.transport.TransportChannel; //导入依赖的package包/类
AsyncReplicaAction(ReplicaRequest request, String targetAllocationID, TransportChannel channel, ReplicationTask task) {
    this.request = request;
    this.channel = channel;
    this.task = task;
    this.targetAllocationID = targetAllocationID;
    final ShardId shardId = request.shardId();
    assert shardId != null : "request shardId must be set";
    this.replica = getIndexShard(shardId);
}
 

import org.elasticsearch.transport.TransportChannel; //导入依赖的package包/类
@Override
public void messageReceived(final Request request, final TransportChannel channel) throws Exception {
    if (logger.isTraceEnabled()) {
        logger.trace("executing [{}] on shard [{}]", request, request.internalShardId);
    }
    Response response = shardOperation(request, request.internalShardId);
    channel.sendResponse(response);
}