import org.elasticsearch.cluster.block.ClusterBlockLevel; //导入依赖的package包/类
@Override
protected void doExecute(MultiSearchRequest request, ActionListener<MultiSearchResponse> listener) {
    ClusterState clusterState = clusterService.state();
    clusterState.blocks().globalBlockedRaiseException(ClusterBlockLevel.READ);

    int maxConcurrentSearches = request.maxConcurrentSearchRequests();
    if (maxConcurrentSearches == 0) {
        maxConcurrentSearches = defaultMaxConcurrentSearches(availableProcessors, clusterState);
    }

    Queue<SearchRequestSlot> searchRequestSlots = new ConcurrentLinkedQueue<>();
    for (int i = 0; i < request.requests().size(); i++) {
        SearchRequest searchRequest = request.requests().get(i);
        searchRequestSlots.add(new SearchRequestSlot(searchRequest, i));
    }

    int numRequests = request.requests().size();
    final AtomicArray<MultiSearchResponse.Item> responses = new AtomicArray<>(numRequests);
    final AtomicInteger responseCounter = new AtomicInteger(numRequests);
    int numConcurrentSearches = Math.min(numRequests, maxConcurrentSearches);
    for (int i = 0; i < numConcurrentSearches; i++) {
        executeSearch(searchRequestSlots, responses, responseCounter, listener);
    }
}
 

import org.elasticsearch.cluster.block.ClusterBlockLevel; //导入依赖的package包/类
@Override
protected ClusterBlockException checkBlock(IndicesAliasesRequest request, ClusterState state) {
    Set<String> indices = new HashSet<>();
    for (AliasActions aliasAction : request.aliasActions()) {
        for (String index : aliasAction.indices()) {
            indices.add(index);
        }
    }
    return state.blocks().indicesBlockedException(ClusterBlockLevel.METADATA_WRITE, indices.toArray(new String[indices.size()]));
}
 

import org.elasticsearch.cluster.block.ClusterBlockLevel; //导入依赖的package包/类
@Override
protected ClusterBlockException checkBlock(PutMappingRequest request, ClusterState state) {
    String[] indices;
    if (request.getConcreteIndex() == null) {
        indices = indexNameExpressionResolver.concreteIndexNames(state, request);
    } else {
        indices = new String[] {request.getConcreteIndex().getName()};
    }
    return state.blocks().indicesBlockedException(ClusterBlockLevel.METADATA_WRITE, indices);
}
 

import org.elasticsearch.cluster.block.ClusterBlockLevel; //导入依赖的package包/类
@Override
protected ClusterBlockException checkBlock(RolloverRequest request, ClusterState state) {
    IndicesOptions indicesOptions = IndicesOptions.fromOptions(true, true,
        request.indicesOptions().expandWildcardsOpen(), request.indicesOptions().expandWildcardsClosed());
    return state.blocks().indicesBlockedException(ClusterBlockLevel.METADATA_WRITE,
        indexNameExpressionResolver.concreteIndexNames(state, indicesOptions, request.indices()));
}
 

import org.elasticsearch.cluster.block.ClusterBlockLevel; //导入依赖的package包/类
@Override
protected ClusterBlockException checkBlock(RestoreSnapshotRequest request, ClusterState state) {
    // Restoring a snapshot might change the global state and create/change an index,
    // so we need to check for METADATA_WRITE and WRITE blocks
    ClusterBlockException blockException = state.blocks().globalBlockedException(ClusterBlockLevel.METADATA_WRITE);
    if (blockException != null) {
        return blockException;
    }
    return state.blocks().globalBlockedException(ClusterBlockLevel.WRITE);

}
 

import org.elasticsearch.cluster.block.ClusterBlockLevel; //导入依赖的package包/类
@Override
protected ClusterBlockException checkBlock(CreateSnapshotRequest request, ClusterState state) {
    // We are reading the cluster metadata and indices - so we need to check both blocks
    ClusterBlockException clusterBlockException = state.blocks().globalBlockedException(ClusterBlockLevel.METADATA_READ);
    if (clusterBlockException != null) {
        return clusterBlockException;
    }
    return state.blocks().indicesBlockedException(ClusterBlockLevel.READ, indexNameExpressionResolver.concreteIndexNames(state, request));
}
 

import org.elasticsearch.cluster.block.ClusterBlockLevel; //导入依赖的package包/类
/**
 * Cluster level block to check before request execution. Returning null means that no blocks need to be checked.
 */
@Nullable
protected ClusterBlockLevel globalBlockLevel() {
    return null;
}
 

import org.elasticsearch.cluster.block.ClusterBlockLevel; //导入依赖的package包/类
private boolean handleBlockExceptions(ClusterState state) {
    ClusterBlockException blockException = state.blocks().globalBlockedException(ClusterBlockLevel.WRITE);
    if (blockException != null) {
        if (blockException.retryable()) {
            logger.trace("cluster is blocked, scheduling a retry", blockException);
            retry(blockException);
        } else {
            onFailure(blockException);
        }
        return true;
    }
    return false;
}
 

import org.elasticsearch.cluster.block.ClusterBlockLevel; //导入依赖的package包/类
@Override
protected void doExecute(final MultiSearchRequest request, final ActionListener<MultiSearchResponse> listener) {
    ClusterState clusterState = clusterService.state();
    clusterState.blocks().globalBlockedRaiseException(ClusterBlockLevel.READ);

    final AtomicArray<MultiSearchResponse.Item> responses = new AtomicArray<>(request.requests().size());
    final AtomicInteger counter = new AtomicInteger(responses.length());
    for (int i = 0; i < responses.length(); i++) {
        final int index = i;
        SearchRequest searchRequest = new SearchRequest(request.requests().get(i), request);
        searchAction.execute(searchRequest, new ActionListener<SearchResponse>() {
            @Override
            public void onResponse(SearchResponse searchResponse) {
                responses.set(index, new MultiSearchResponse.Item(searchResponse, null));
                if (counter.decrementAndGet() == 0) {
                    finishHim();
                }
            }

            @Override
            public void onFailure(Throwable e) {
                responses.set(index, new MultiSearchResponse.Item(null, e));
                if (counter.decrementAndGet() == 0) {
                    finishHim();
                }
            }

            private void finishHim() {
                listener.onResponse(new MultiSearchResponse(responses.toArray(new MultiSearchResponse.Item[responses.length()])));
            }
        });
    }
}
 

import org.elasticsearch.cluster.block.ClusterBlockLevel; //导入依赖的package包/类
public void testClosedIndexOnReroute() throws InterruptedException {
    final String index = "test";
    // no replicas in oder to skip the replication part
    setState(clusterService, new ClusterStateChanges(xContentRegistry(), threadPool).closeIndices(state(index, true,
        ShardRoutingState.UNASSIGNED), new CloseIndexRequest(index)));
    logger.debug("--> using initial state:\n{}", clusterService.state());
    Request request = new Request(new ShardId("test", "_na_", 0)).timeout("1ms");
    PlainActionFuture<TestResponse> listener = new PlainActionFuture<>();
    ReplicationTask task = maybeTask();

    ClusterBlockLevel indexBlockLevel = randomBoolean() ? ClusterBlockLevel.WRITE : null;
    TestAction action = new TestAction(Settings.EMPTY, "testActionWithBlocks", transportService,
            clusterService, shardStateAction, threadPool) {
        @Override
        protected ClusterBlockLevel indexBlockLevel() {
            return indexBlockLevel;
        }
    };
    TestAction.ReroutePhase reroutePhase = action.new ReroutePhase(task, request, listener);
    reroutePhase.run();
    if (indexBlockLevel == ClusterBlockLevel.WRITE) {
        assertListenerThrows("must throw block exception", listener, ClusterBlockException.class);
    } else {
        assertListenerThrows("must throw index closed exception", listener, IndexClosedException.class);
    }
    assertPhase(task, "failed");
    assertFalse(request.isRetrySet.get());
}
 

import org.elasticsearch.cluster.block.ClusterBlockLevel; //导入依赖的package包/类
@Override
protected ClusterBlockException checkBlock(IndicesAliasesRequest request, ClusterState state) {
    Set<String> indices = Sets.newHashSet();
    for (AliasActions aliasAction : request.aliasActions()) {
        for (String index : aliasAction.indices()) {
            indices.add(index);
        }
    }
    return state.blocks().indicesBlockedException(ClusterBlockLevel.METADATA_WRITE, indices.toArray(new String[indices.size()]));
}
 

import org.elasticsearch.cluster.block.ClusterBlockLevel; //导入依赖的package包/类
@Override
protected ClusterBlockException checkBlock(CreateSnapshotRequest request, ClusterState state) {
    // We are reading the cluster metadata and indices - so we need to check both blocks
    ClusterBlockException clusterBlockException = state.blocks().globalBlockedException(ClusterBlockLevel.METADATA_READ);
    if (clusterBlockException != null) {
        return clusterBlockException;
    }
    return state.blocks().indicesBlockedException(ClusterBlockLevel.READ, indexNameExpressionResolver.concreteIndices(state, request));
}
 

import org.elasticsearch.cluster.block.ClusterBlockLevel; //导入依赖的package包/类
@Override
protected ClusterBlockException checkBlock(IndicesExistsRequest request, ClusterState state) {
    //make sure through indices options that the concrete indices call never throws IndexMissingException
    IndicesOptions indicesOptions = IndicesOptions.fromOptions(true, true, request.indicesOptions().expandWildcardsOpen(), request.indicesOptions().expandWildcardsClosed());
    return state.blocks().indicesBlockedException(ClusterBlockLevel.METADATA_READ, indexNameExpressionResolver.concreteIndexNames(state, indicesOptions, request.indices()));
}
 

import org.elasticsearch.cluster.block.ClusterBlockLevel; //导入依赖的package包/类
@Override
protected ClusterBlockException checkBlock(TypesExistsRequest request, ClusterState state) {
    return state.blocks().indicesBlockedException(ClusterBlockLevel.METADATA_READ, indexNameExpressionResolver.concreteIndexNames(state, request));
}
 

import org.elasticsearch.cluster.block.ClusterBlockLevel; //导入依赖的package包/类
@Override
protected ClusterBlockException checkBlock(GetAliasesRequest request, ClusterState state) {
    return state.blocks().indicesBlockedException(ClusterBlockLevel.METADATA_READ, indexNameExpressionResolver.concreteIndexNames(state, request));
}
 

import org.elasticsearch.cluster.block.ClusterBlockLevel; //导入依赖的package包/类
@Override
protected ClusterBlockException checkRequestBlock(ClusterState state, IndicesStatsRequest request, String[] concreteIndices) {
    return state.blocks().indicesBlockedException(ClusterBlockLevel.METADATA_READ, concreteIndices);
}
 

import org.elasticsearch.cluster.block.ClusterBlockLevel; //导入依赖的package包/类
@Override
protected ClusterBlockLevel indexBlockLevel() {
    return ClusterBlockLevel.METADATA_WRITE;
}
 

import org.elasticsearch.cluster.block.ClusterBlockLevel; //导入依赖的package包/类
@Override
protected ClusterBlockException checkRequestBlock(ClusterState state, ForceMergeRequest request, String[] concreteIndices) {
    return state.blocks().indicesBlockedException(ClusterBlockLevel.METADATA_WRITE, concreteIndices);
}
 

import org.elasticsearch.cluster.block.ClusterBlockLevel; //导入依赖的package包/类
@Override
protected ClusterBlockException checkRequestBlock(ClusterState state, InternalRequest request) {
    return state.blocks().indexBlockedException(ClusterBlockLevel.METADATA_READ, request.concreteIndex());
}
 

import org.elasticsearch.cluster.block.ClusterBlockLevel; //导入依赖的package包/类
@Override
protected ClusterBlockException checkRequestBlock(ClusterState state, FieldStatsRequest request, String[] concreteIndices) {
    return state.blocks().indicesBlockedException(ClusterBlockLevel.READ, concreteIndices);
}