org.elasticsearch.cluster.block.ClusterBlockException Java Examples

@Override
protected ClusterBlockException checkBlock(UpdateSettingsRequest request, ClusterState state) {
    // allow for dedicated changes to the metadata blocks, so we don't block those to allow to "re-enable" it
    ClusterBlockException globalBlock = state.blocks().globalBlockedException(ClusterBlockLevel.METADATA_WRITE);
    if (globalBlock != null) {
        return globalBlock;
    }

    // always allow removing of archived settings, so filter them out before doing further block checks
    Settings settings = request.settings().filter(k -> k.startsWith(ARCHIVED_SETTINGS_PREFIX + "*") == false);

    if (settings.size() == 1 &&  // we have to allow resetting these settings otherwise users can't unblock an index
        IndexMetaData.INDEX_BLOCKS_METADATA_SETTING.exists(settings)
        || IndexMetaData.INDEX_READ_ONLY_SETTING.exists(settings)
        || IndexMetaData.INDEX_BLOCKS_READ_ONLY_ALLOW_DELETE_SETTING.exists(settings)) {
        return null;
    }
    return state.blocks().indicesBlockedException(ClusterBlockLevel.METADATA_WRITE, indexNameExpressionResolver.concreteIndexNames(state, request));
}
 

/**
 * リトライ対象例外が続き_リトライ5回目でリトライ対象外の例外が発生した場合、EsClientExceptionが投げられること.
 */
@Test(expected = EsClientException.class)
public void リトライ対象例外が続き_リトライ5回目でリトライ対象外の例外が発生した場合_EsClientExceptionが投げられること() {

    TestRequest requestMock = Mockito.spy(new TestRequest());

    ClusterBlockException toBeThrown = Mockito.mock(ClusterBlockException.class);
    IndexMissingException toBeThrown2 = Mockito.mock(IndexMissingException.class);
    Mockito.doThrow(toBeThrown) // 初回
            .doThrow(toBeThrown) // リトライ1回目
            .doThrow(toBeThrown) // リトライ2回目
            .doThrow(toBeThrown) // リトライ3回目
            .doThrow(toBeThrown) // リトライ4回目
            .doThrow(toBeThrown2) // リトライ5回目
            .when(requestMock)
            .doProcess();

    try {
        requestMock.doRequest();
        fail("Should not return");
    } finally {
        // doProcessが6回呼び出されるはず
        Mockito.verify(requestMock, Mockito.times(6)).doProcess();
        Mockito.verify(requestMock, Mockito.times(0)).onParticularError(Mockito.any(ElasticsearchException.class));
    }
}
 

/**
 * Executes the request and fails if the request has not been blocked by a specific {@link ClusterBlock}.
 *
 * @param builder the request builder
 * @param expectedBlock the expected block
 */
public static void assertBlocked(ActionRequestBuilder builder, ClusterBlock expectedBlock) {
    try {
        builder.get();
        fail("Request executed with success but a ClusterBlockException was expected");
    } catch (ClusterBlockException e) {
        assertThat(e.blocks().size(), greaterThan(0));
        assertThat(e.status(), equalTo(RestStatus.FORBIDDEN));

        if (expectedBlock != null) {
            boolean found = false;
            for (ClusterBlock clusterBlock : e.blocks()) {
                if (clusterBlock.id() == expectedBlock.id()) {
                    found = true;
                    break;
                }
            }
            assertThat("Request should have been blocked by [" + expectedBlock + "] instead of " + e.blocks(), found, equalTo(true));
        }
    }
}
 

/**
 * リトライ対象例外が続き_リトライ5回目でもNGな場合_EsNoResponseExceptionが投げられること.
 */
@Test(expected = EsClientException.EsNoResponseException.class)
public void リトライ対象例外が続き_リトライ5回目でもNGな場合_EsNoResponseExceptionが投げられること() {

    TestRequest requestMock = Mockito.spy(new TestRequest());

    ClusterBlockException toBeThrown = Mockito.mock(ClusterBlockException.class);
    Mockito.doThrow(toBeThrown) // 初回
            .doThrow(toBeThrown) // リトライ1回目
            .doThrow(toBeThrown) // リトライ2回目
            .doThrow(toBeThrown) // リトライ3回目
            .doThrow(toBeThrown) // リトライ4回目
            .doThrow(toBeThrown) // リトライ5回目
            .when(requestMock)
            .doProcess();

    try {
        requestMock.doRequest();
        fail("Should not return");
    } finally {
        // doProcessが6回呼び出されるはず
        Mockito.verify(requestMock, Mockito.times(6)).doProcess();
        Mockito.verify(requestMock, Mockito.times(0)).onParticularError(Mockito.any(ElasticsearchException.class));
    }
}
 

/**
 * リトライ対象例外が続き_リトライ5回目でリトライ対象外の例外が発生した場合、EsClientExceptionが投げられること.
 */
@Test(expected = EsClientException.class)
public void リトライ対象例外が続き_リトライ5回目でリトライ対象外の例外が発生した場合_EsClientExceptionが投げられること() {

    TestRequest requestMock = Mockito.spy(new TestRequest());

    ClusterBlockException toBeThrown = Mockito.mock(ClusterBlockException.class);
    IndexNotFoundException toBeThrown2 = new IndexNotFoundException("abc");
    Mockito.doThrow(toBeThrown) // 初回
            .doThrow(toBeThrown) // リトライ1回目
            .doThrow(toBeThrown) // リトライ2回目
            .doThrow(toBeThrown) // リトライ3回目
            .doThrow(toBeThrown) // リトライ4回目
            .doThrow(toBeThrown2) // リトライ5回目
            .when(requestMock)
            .doProcess();

    try {
        requestMock.doRequest();
        fail("Should not return");
    } finally {
        // doProcessが6回呼び出されるはず
        Mockito.verify(requestMock, Mockito.times(6)).doProcess();
        Mockito.verify(requestMock, Mockito.times(0)).onParticularError(Mockito.any(ElasticsearchException.class));
    }
}
 

/**
 * Get the number of documents in the search index for a given search query
 * 
 * @param q
 *            the query
 * @return the count of all documents in the index which matches with the query
 */
public long count(final QueryBuilder q, final String indexName) {
    while (true) try {
        return countInternal(q, indexName);
    } catch (NoNodeAvailableException | IllegalStateException | ClusterBlockException | SearchPhaseExecutionException e) {
        Data.logger.info("ElasticsearchClient count failed with " + e.getMessage() + ", retrying to connect node...");
        try {Thread.sleep(1000);} catch (InterruptedException ee) {}
        connect();
    }
}
 

@Override
protected ClusterBlockException checkBlock(CreateTableRequest request, ClusterState state) {
    if (request.getCreateIndexRequest() != null) {
        CreateIndexRequest createIndexRequest = request.getCreateIndexRequest();
        return transportCreateIndexAction.checkBlock(createIndexRequest, state);
    } else if (request.getPutIndexTemplateRequest() != null) {
        PutIndexTemplateRequest putIndexTemplateRequest = request.getPutIndexTemplateRequest();
        return transportPutIndexTemplateAction.checkBlock(putIndexTemplateRequest, state);
    } else {
        throw new IllegalStateException("Unknown table request");
    }
}
 

@Override
protected ClusterBlockException checkRequestBlock(ClusterState state, InternalRequest request) {
    if (request.concreteIndex() != null) {
        return super.checkRequestBlock(state, request);
    }
    return null;
}
 

@Override
protected ClusterBlockException checkBlock(SwapRelationsRequest request, ClusterState state) {
    Set<String> affectedIndices = new HashSet<>();
    for (RelationNameSwap swapAction : request.swapActions()) {
        affectedIndices.addAll(Arrays.asList(indexNameExpressionResolver.concreteIndexNames(
            state, IndicesOptions.LENIENT_EXPAND_OPEN, swapAction.source().indexNameOrAlias())));
        affectedIndices.addAll(Arrays.asList(indexNameExpressionResolver.concreteIndexNames(
            state, IndicesOptions.LENIENT_EXPAND_OPEN, swapAction.target().indexNameOrAlias())));
    }
    for (RelationName dropRelation : request.dropRelations()) {
        affectedIndices.addAll(Arrays.asList(indexNameExpressionResolver.concreteIndexNames(
            state, IndicesOptions.LENIENT_EXPAND_OPEN, dropRelation.indexNameOrAlias())));
    }
    return state.blocks().indicesBlockedException(ClusterBlockLevel.METADATA_READ, affectedIndices.toArray(new String[0]));
}
 

private AsyncSingleAction(Request request, ActionListener<Response> listener) {
    this.listener = listener;

    ClusterState clusterState = clusterService.state();
    if (logger.isTraceEnabled()) {
        logger.trace("executing [{}] based on cluster state version [{}]", request, clusterState.version());
    }
    nodes = clusterState.nodes();
    ClusterBlockException blockException = checkGlobalBlock(clusterState);
    if (blockException != null) {
        throw blockException;
    }

    String concreteSingleIndex;
    if (resolveIndex(request)) {
        concreteSingleIndex = indexNameExpressionResolver.concreteSingleIndex(clusterState, request);
    } else {
        concreteSingleIndex = request.index();
    }
    this.internalRequest = new InternalRequest(request, concreteSingleIndex);
    resolveRequest(clusterState, internalRequest);

    blockException = checkRequestBlock(clusterState, internalRequest);
    if (blockException != null) {
        throw blockException;
    }

    this.shardIt = shards(clusterState, internalRequest);
}
 

@Override
protected ClusterBlockException checkBlock(ClusterUpdateSettingsRequest request, ClusterState state) {
    // allow for dedicated changes to the metadata blocks, so we don't block those to allow to "re-enable" it
    if (request.transientSettings().size() + request.persistentSettings().size() == 1) {
        // only one setting
        if (MetaData.SETTING_READ_ONLY_SETTING.exists(request.persistentSettings())
            || MetaData.SETTING_READ_ONLY_SETTING.exists(request.transientSettings())
            || MetaData.SETTING_READ_ONLY_ALLOW_DELETE_SETTING.exists(request.transientSettings())
            || MetaData.SETTING_READ_ONLY_ALLOW_DELETE_SETTING.exists(request.persistentSettings())) {
            // one of the settings above as the only setting in the request means - resetting the block!
            return null;
        }
    }
    return state.blocks().globalBlockedException(ClusterBlockLevel.METADATA_WRITE);
}
 

@Test(expected = ClusterBlockException.class)
public void testClusterBlock() throws Exception {
    BulkRequestBuilder brb = client("1").prepareBulk();
    XContentBuilder builder = jsonBuilder().startObject().field("field1", "value1").endObject();
    String jsonString = builder.string();
    IndexRequestBuilder irb = client("1").prepareIndex("test", "test", "1").setSource(jsonString);
    brb.add(irb);
    brb.execute().actionGet();
}
 

public Map<String, Map<String, Object>> readMapBulk(final String indexName, final Collection<String> ids) {
    while (true) try {
        return readMapBulkInternal(indexName, ids);
    } catch (NoNodeAvailableException | IllegalStateException | ClusterBlockException | SearchPhaseExecutionException e) {
        Data.logger.info("ElasticsearchClient readMapBulk failed with " + e.getMessage() + ", retrying to connect node...");
        try {Thread.sleep(1000);} catch (InterruptedException ee) {}
        connect();
        continue;
    }
}
 

/**
 * Read a json document from the search index for a given id.
 * Elasticsearch reads the '_source' field and parses the content as json.
 * 
 * @param id
 *            the unique identifier of a document
 * @return the document as json, matched on a Map<String, Object> object instance
 */
public Map<String, Object> readMap(final String indexName, final String id) {
    while (true) try {
        return readMapInternal(indexName, id);
    } catch (NoNodeAvailableException | IllegalStateException | ClusterBlockException | SearchPhaseExecutionException e) {
        Data.logger.info("ElasticsearchClient readMap failed with " + e.getMessage() + ", retrying to connect node...");
        try {Thread.sleep(1000);} catch (InterruptedException ee) {}
        connect();
        continue;
    }
}
 

private void handleBlockException(ClusterBlockException blockException) {
    if (blockException.retryable()) {
        logger.trace("cluster is blocked, scheduling a retry", blockException);
        retry(blockException);
    } else {
        finishAsFailed(blockException);
    }
}
 

@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);

}
 

@Override
protected ClusterBlockException checkBlock(PutRepositoryRequest request, ClusterState state) {
    return state.blocks().globalBlockedException(ClusterBlockLevel.METADATA_WRITE);
}
 

@Override
protected ClusterBlockException checkRequestBlock(ClusterState state, FieldStatsRequest request, String[] concreteIndices) {
    return state.blocks().indicesBlockedException(ClusterBlockLevel.READ, concreteIndices);
}
 

@Override
protected ClusterBlockException checkBlock(AlterUserRequest request, ClusterState state) {
    return state.blocks().globalBlockedException(ClusterBlockLevel.METADATA_WRITE);
}
 

@Override
protected ClusterBlockException checkBlock(GetIndexTemplatesRequest request, ClusterState state) {
    return state.blocks().globalBlockedException(ClusterBlockLevel.METADATA_READ);
}
 

@Override
protected ClusterBlockException checkBlock(VerifyRepositoryRequest request, ClusterState state) {
    return state.blocks().globalBlockedException(ClusterBlockLevel.METADATA_READ);
}
 

protected ClusterBlockException checkGlobalBlock(ClusterState state) {
    return state.blocks().globalBlockedException(ClusterBlockLevel.READ);
}
 

@Override
protected ClusterBlockException checkRequestBlock(ClusterState state, ValidateQueryRequest countRequest, String[] concreteIndices) {
    return state.blocks().indicesBlockedException(ClusterBlockLevel.READ, concreteIndices);
}
 

@Override
protected ClusterBlockException checkGlobalBlock(ClusterState state, ValidateQueryRequest request) {
    return state.blocks().globalBlockedException(ClusterBlockLevel.READ);
}
 

@Override
protected ClusterBlockException checkBlock(DeleteRepositoryRequest request, ClusterState state) {
    return state.blocks().globalBlockedException(ClusterBlockLevel.METADATA_WRITE);
}
 

@Override
protected ClusterBlockException checkGlobalBlock(ClusterState state, FieldStatsRequest request) {
    return state.blocks().globalBlockedException(ClusterBlockLevel.READ);
}
 

@Override
protected ClusterBlockException checkBlock(GetWarmersRequest request, ClusterState state) {
    return state.blocks().indicesBlockedException(ClusterBlockLevel.METADATA_READ, indexNameExpressionResolver.concreteIndices(state, request));
}
 

@Override
protected ClusterBlockException checkBlock(DeleteIndexRequest request, ClusterState state) {
    return state.blocks().indicesBlockedException(ClusterBlockLevel.METADATA_WRITE, indexNameExpressionResolver.concreteIndices(state, request));
}
 

@Override
protected ClusterBlockException checkBlock(PendingClusterTasksRequest request, ClusterState state) {
    return state.blocks().globalBlockedException(ClusterBlockLevel.METADATA_READ);
}
 

@Override
protected ClusterBlockException checkBlock(ResizeRequest request, ClusterState state) {
    return state.blocks().indexBlockedException(ClusterBlockLevel.METADATA_WRITE, request.getTargetIndexRequest().index());
}