Java TransportChannel.sendResponse方法代码示例

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包/类
@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(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(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(BlobStartPrefixSyncRequest request, TransportChannel channel) throws Exception {
    BlobRecoveryStatus status = onGoingRecoveries.get(request.recoveryId());
    if (status == null) {
        throw new IllegalBlobRecoveryStateException(
            "could not retrieve BlobRecoveryStatus"
        );
    }
    if (status.canceled()) {
        throw new IndexShardClosedException(status.shardId());
    }
    BlobStartPrefixResponse response = new BlobStartPrefixResponse();
    response.existingDigests = status.blobShard.currentDigests(request.prefix());
    channel.sendResponse(response);
}
 

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(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包/类
@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 ReplicaOperationRequest request, final TransportChannel channel) throws Exception {
    try {
        ActionResponse response = shardOperationOnReplica(request);
        channel.sendResponse(response);
    } catch (Throwable t) {
        logger.error(t.getMessage(), t);
        channel.sendResponse(t);
    }
}
 

import org.elasticsearch.transport.TransportChannel; //导入方法依赖的package包/类
@Override
public void messageReceived(PreShardSyncedFlushRequest request, TransportChannel channel) throws Exception {
    channel.sendResponse(performPreSyncedFlush(request));
}
 

import org.elasticsearch.transport.TransportChannel; //导入方法依赖的package包/类
@Override
public void messageReceived(ShardRoutingEntry request, TransportChannel channel) throws Exception {
    shardStartedOnMaster(request);
    channel.sendResponse(TransportResponse.Empty.INSTANCE);
}
 

import org.elasticsearch.transport.TransportChannel; //导入方法依赖的package包/类
@Override
public void messageReceived(final StartRecoveryRequest request, final TransportChannel channel) throws Exception {
    RecoveryResponse response = recover(request);
    channel.sendResponse(response);
}
 

import org.elasticsearch.transport.TransportChannel; //导入方法依赖的package包/类
@Override
public void messageReceived(UpdateIndexShardRestoreStatusRequest request, final TransportChannel channel) throws Exception {
    updateRestoreStateOnMaster(request);
    channel.sendResponse(TransportResponse.Empty.INSTANCE);
}
 

import org.elasticsearch.transport.TransportChannel; //导入方法依赖的package包/类
@Override
public void messageReceived(NodeMappingRefreshRequest request, TransportChannel channel) throws Exception {
    metaDataMappingService.refreshMapping(request.index(), request.indexUUID());
    channel.sendResponse(TransportResponse.Empty.INSTANCE);
}