Java ClusterBlocks.Builder方法代码示例

import org.elasticsearch.cluster.block.ClusterBlocks; //导入方法依赖的package包/类
public void testGlobalBlock() {
    Request request = new Request();
    PlainActionFuture<Response> listener = new PlainActionFuture<>();
    ClusterBlocks.Builder block = ClusterBlocks.builder()
            .addGlobalBlock(new ClusterBlock(1, "", false, true, RestStatus.SERVICE_UNAVAILABLE, ClusterBlockLevel.ALL));
    setState(clusterService, ClusterState.builder(clusterService.state()).blocks(block));
    try {
        action.new AsyncSingleAction(request, listener).start();
        listener.get();
        fail("expected ClusterBlockException");
    } catch (Exception e) {
        if (ExceptionsHelper.unwrap(e, ClusterBlockException.class) == null) {
            logger.info("expected ClusterBlockException  but got ", e);
            fail("expected ClusterBlockException");
        }
    }
}
 

import org.elasticsearch.cluster.block.ClusterBlocks; //导入方法依赖的package包/类
private void addNewIndex(ClusterState tribeState, ClusterBlocks.Builder blocks, MetaData.Builder metaData,
                         RoutingTable.Builder routingTable, IndexMetaData tribeIndex) {
    Settings tribeSettings = Settings.builder().put(tribeIndex.getSettings()).put(TRIBE_NAME_SETTING.getKey(), tribeName).build();
    metaData.put(IndexMetaData.builder(tribeIndex).settings(tribeSettings));
    routingTable.add(tribeState.routingTable().index(tribeIndex.getIndex()));
    if (Regex.simpleMatch(blockIndicesMetadata, tribeIndex.getIndex().getName())) {
        blocks.addIndexBlock(tribeIndex.getIndex().getName(), IndexMetaData.INDEX_METADATA_BLOCK);
    }
    if (Regex.simpleMatch(blockIndicesRead, tribeIndex.getIndex().getName())) {
        blocks.addIndexBlock(tribeIndex.getIndex().getName(), IndexMetaData.INDEX_READ_BLOCK);
    }
    if (Regex.simpleMatch(blockIndicesWrite, tribeIndex.getIndex().getName())) {
        blocks.addIndexBlock(tribeIndex.getIndex().getName(), IndexMetaData.INDEX_WRITE_BLOCK);
    }
}
 

import org.elasticsearch.cluster.block.ClusterBlocks; //导入方法依赖的package包/类
/**
 * Updates the cluster block only iff the setting exists in the given settings
 */
private static void maybeUpdateClusterBlock(String[] actualIndices, ClusterBlocks.Builder blocks, ClusterBlock block, Setting<Boolean> setting, Settings openSettings) {
    if (setting.exists(openSettings)) {
        final boolean updateReadBlock = setting.get(openSettings);
        for (String index : actualIndices) {
            if (updateReadBlock) {
                blocks.addIndexBlock(index, block);
            } else {
                blocks.removeIndexBlock(index, block);
            }
        }
    }
}
 

import org.elasticsearch.cluster.block.ClusterBlocks; //导入方法依赖的package包/类
public void testGlobalBlock() {
    Request request = new Request(new String[]{TEST_INDEX});
    PlainActionFuture<Response> listener = new PlainActionFuture<>();

    ClusterBlocks.Builder block = ClusterBlocks.builder()
            .addGlobalBlock(new ClusterBlock(1, "test-block", false, true, RestStatus.SERVICE_UNAVAILABLE, ClusterBlockLevel.ALL));
    setState(clusterService, ClusterState.builder(clusterService.state()).blocks(block));
    try {
        action.new AsyncAction(null, request, listener).start();
        fail("expected ClusterBlockException");
    } catch (ClusterBlockException expected) {
        assertEquals("blocked by: [SERVICE_UNAVAILABLE/1/test-block];", expected.getMessage());
    }
}
 

import org.elasticsearch.cluster.block.ClusterBlocks; //导入方法依赖的package包/类
public void testRequestBlock() {
    Request request = new Request(new String[]{TEST_INDEX});
    PlainActionFuture<Response> listener = new PlainActionFuture<>();

    ClusterBlocks.Builder block = ClusterBlocks.builder()
            .addIndexBlock(TEST_INDEX, new ClusterBlock(1, "test-block", false, true, RestStatus.SERVICE_UNAVAILABLE, ClusterBlockLevel.ALL));
    setState(clusterService, ClusterState.builder(clusterService.state()).blocks(block));
    try {
        action.new AsyncAction(null, request, listener).start();
        fail("expected ClusterBlockException");
    } catch (ClusterBlockException expected) {
        assertEquals("blocked by: [SERVICE_UNAVAILABLE/1/test-block];", expected.getMessage());
    }
}
 

import org.elasticsearch.cluster.block.ClusterBlocks; //导入方法依赖的package包/类
private void addNewIndex(ClusterState tribeState, ClusterBlocks.Builder blocks, MetaData.Builder metaData, RoutingTable.Builder routingTable, IndexMetaData tribeIndex) {
    Settings tribeSettings = Settings.builder().put(tribeIndex.getSettings()).put(TRIBE_NAME, tribeName).build();
    metaData.put(IndexMetaData.builder(tribeIndex).settings(tribeSettings));
    routingTable.add(tribeState.routingTable().index(tribeIndex.getIndex()));
    if (Regex.simpleMatch(blockIndicesMetadata, tribeIndex.getIndex())) {
        blocks.addIndexBlock(tribeIndex.getIndex(), IndexMetaData.INDEX_METADATA_BLOCK);
    }
    if (Regex.simpleMatch(blockIndicesRead, tribeIndex.getIndex())) {
        blocks.addIndexBlock(tribeIndex.getIndex(), IndexMetaData.INDEX_READ_BLOCK);
    }
    if (Regex.simpleMatch(blockIndicesWrite, tribeIndex.getIndex())) {
        blocks.addIndexBlock(tribeIndex.getIndex(), IndexMetaData.INDEX_WRITE_BLOCK);
    }
}
 

import org.elasticsearch.cluster.block.ClusterBlocks; //导入方法依赖的package包/类
private void removeIndex(ClusterBlocks.Builder blocks, MetaData.Builder metaData, RoutingTable.Builder routingTable,
                         IndexMetaData index) {
    metaData.remove(index.getIndex().getName());
    routingTable.remove(index.getIndex().getName());
    blocks.removeIndexBlocks(index.getIndex().getName());
}
 

import org.elasticsearch.cluster.block.ClusterBlocks; //导入方法依赖的package包/类
public Builder blocks(ClusterBlocks.Builder blocksBuilder) {
    return blocks(blocksBuilder.build());
}
 

import org.elasticsearch.cluster.block.ClusterBlocks; //导入方法依赖的package包/类
public void testBlocks() throws ExecutionException, InterruptedException {
    Request request = new Request();
    PlainActionFuture<TestResponse> listener = new PlainActionFuture<>();
    ReplicationTask task = maybeTask();
    TestAction action = new TestAction(Settings.EMPTY, "testActionWithBlocks",
            transportService, clusterService, shardStateAction, threadPool) {
        @Override
        protected ClusterBlockLevel globalBlockLevel() {
            return ClusterBlockLevel.WRITE;
        }
    };

    ClusterBlocks.Builder block = ClusterBlocks.builder()
        .addGlobalBlock(new ClusterBlock(1, "non retryable", false, true, RestStatus.SERVICE_UNAVAILABLE, ClusterBlockLevel.ALL));
    setState(clusterService, ClusterState.builder(clusterService.state()).blocks(block));
    TestAction.ReroutePhase reroutePhase = action.new ReroutePhase(task, request, listener);
    reroutePhase.run();
    assertListenerThrows("primary phase should fail operation", listener, ClusterBlockException.class);
    assertPhase(task, "failed");

    block = ClusterBlocks.builder()
        .addGlobalBlock(new ClusterBlock(1, "retryable", true, true, RestStatus.SERVICE_UNAVAILABLE, ClusterBlockLevel.ALL));
    setState(clusterService, ClusterState.builder(clusterService.state()).blocks(block));
    listener = new PlainActionFuture<>();
    reroutePhase = action.new ReroutePhase(task, new Request().timeout("5ms"), listener);
    reroutePhase.run();
    assertListenerThrows("failed to timeout on retryable block", listener, ClusterBlockException.class);
    assertPhase(task, "failed");
    assertFalse(request.isRetrySet.get());

    listener = new PlainActionFuture<>();
    reroutePhase = action.new ReroutePhase(task, request = new Request(), listener);
    reroutePhase.run();
    assertFalse("primary phase should wait on retryable block", listener.isDone());
    assertPhase(task, "waiting_for_retry");
    assertTrue(request.isRetrySet.get());

    block = ClusterBlocks.builder()
        .addGlobalBlock(new ClusterBlock(1, "non retryable", false, true, RestStatus.SERVICE_UNAVAILABLE, ClusterBlockLevel.ALL));
    setState(clusterService, ClusterState.builder(clusterService.state()).blocks(block));
    assertListenerThrows("primary phase should fail operation when moving from a retryable block to a non-retryable one", listener,
        ClusterBlockException.class);
    assertIndexShardUninitialized();

    action = new TestAction(Settings.EMPTY, "testActionWithNoBlocks", transportService, clusterService, shardStateAction, threadPool) {
        @Override
        protected ClusterBlockLevel globalBlockLevel() {
            return null;
        }
    };
    listener = new PlainActionFuture<>();
    reroutePhase = action.new ReroutePhase(task, new Request().timeout("5ms"), listener);
    reroutePhase.run();
    assertListenerThrows("should fail with an IndexNotFoundException when no blocks checked", listener, IndexNotFoundException.class);
}
 

import org.elasticsearch.cluster.block.ClusterBlocks; //导入方法依赖的package包/类
private void removeIndex(ClusterBlocks.Builder blocks, MetaData.Builder metaData, RoutingTable.Builder routingTable, IndexMetaData index) {
    metaData.remove(index.getIndex());
    routingTable.remove(index.getIndex());
    blocks.removeIndexBlocks(index.getIndex());
}