Java CloseIndexRequest类代码示例

import org.elasticsearch.action.admin.indices.close.CloseIndexRequest; //导入依赖的package包/类
/**
 * 索引的相关操作
 *
 * @param indicesAdminClient
 * @param indexName
 * @throws IOException
 */
private static void indexConfig(IndicesAdminClient indicesAdminClient, String indexName) throws IOException {
    //settings 设置
    String settings = getIndexSetting();
    // PUT /my_temp_index/_settings updatesettings
    showIndexSettings(indicesAdminClient,indexName);
    UpdateSettingsResponse updateSettingsResponse = indicesAdminClient.prepareUpdateSettings(indexName).setSettings(settings).execute().actionGet();
    log.info("更新 index setting:{}", updateSettingsResponse);


    //更新索引settings之前要关闭索引
    indicesAdminClient.close(new CloseIndexRequest().indices(indexName)).actionGet();
    //配置拼音自定义分析器
    indicesAdminClient.prepareUpdateSettings(indexName).setSettings(getIndexPinYinSetting()).execute().actionGet();
    //自定义分析器
    indicesAdminClient.prepareUpdateSettings(indexName).setSettings(getIndexDemoSetting()).execute().actionGet();
    //打开索引
    indicesAdminClient.open(new OpenIndexRequest().indices(indexName)).actionGet();

    //索引别名映射
    createAliasIndex(indicesAdminClient);

    showIndexSettings(indicesAdminClient,indexName);
}
 

import org.elasticsearch.action.admin.indices.close.CloseIndexRequest; //导入依赖的package包/类
@Override
public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
    CloseIndexRequest closeIndexRequest = new CloseIndexRequest(Strings.splitStringByCommaToArray(request.param("index")));
    closeIndexRequest.masterNodeTimeout(request.paramAsTime("master_timeout", closeIndexRequest.masterNodeTimeout()));
    closeIndexRequest.timeout(request.paramAsTime("timeout", closeIndexRequest.timeout()));
    closeIndexRequest.indicesOptions(IndicesOptions.fromRequest(request, closeIndexRequest.indicesOptions()));
    return channel -> client.admin().indices().close(closeIndexRequest, new AcknowledgedRestListener<>(channel));
}
 

import org.elasticsearch.action.admin.indices.close.CloseIndexRequest; //导入依赖的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.action.admin.indices.close.CloseIndexRequest; //导入依赖的package包/类
public void testCloseIndex() {
    interceptTransportActions(CloseIndexAction.NAME);

    CloseIndexRequest closeIndexRequest = new CloseIndexRequest(randomUniqueIndicesOrAliases());
    internalCluster().coordOnlyNodeClient().admin().indices().close(closeIndexRequest).actionGet();

    clearInterceptedActions();
    assertSameIndices(closeIndexRequest, CloseIndexAction.NAME);
}
 

import org.elasticsearch.action.admin.indices.close.CloseIndexRequest; //导入依赖的package包/类
@Override
public void handleRequest(final RestRequest request, final RestChannel channel, final Client client) {
    CloseIndexRequest closeIndexRequest = new CloseIndexRequest(Strings.splitStringByCommaToArray(request.param("index")));
    closeIndexRequest.masterNodeTimeout(request.paramAsTime("master_timeout", closeIndexRequest.masterNodeTimeout()));
    closeIndexRequest.timeout(request.paramAsTime("timeout", closeIndexRequest.timeout()));
    closeIndexRequest.indicesOptions(IndicesOptions.fromRequest(request, closeIndexRequest.indicesOptions()));
    client.admin().indices().close(closeIndexRequest, new AcknowledgedRestListener<CloseIndexResponse>(channel));
}
 

import org.elasticsearch.action.admin.indices.close.CloseIndexRequest; //导入依赖的package包/类
public void execute(final CloseIndexRequest request, final ActionListener<CloseIndexResponse> listener) {
    logger.debug("close index request {}", request);
    try {
        String indices = Strings.arrayToCommaDelimitedString(CloseIndexRequestAccessor.indices(request));

        RequestUriBuilder uriBuilder = new RequestUriBuilder(indices).addEndpoint("_close");
        uriBuilder.addIndicesOptions(request);

        uriBuilder.addQueryParameter("timeout", request.timeout().toString());
        uriBuilder.addQueryParameter("master_timeout", request.masterNodeTimeout().toString());

        indicesAdminClient.getHttpClient().submit(HttpClientRequest.createPost(uriBuilder.toString()))
                .flatMap(HANDLES_404)
                .flatMap(new Func1<HttpClientResponse<ByteBuf>, Observable<CloseIndexResponse>>() {
                    @Override
                    public Observable<CloseIndexResponse> call(final HttpClientResponse<ByteBuf> response) {
                        return response.getContent().flatMap(new Func1<ByteBuf, Observable<CloseIndexResponse>>() {
                            @Override
                            public Observable<CloseIndexResponse> call(ByteBuf byteBuf) {
                                return CloseIndexResponse.parse(byteBuf, response.getStatus().code());
                            }
                        });
                    }
                })
                .single()
                .subscribe(new ListenerCompleterObserver<>(listener));
    } catch (Exception e) {
        listener.onFailure(e);
    }
}
 

import org.elasticsearch.action.admin.indices.close.CloseIndexRequest; //导入依赖的package包/类
@Test
public void should_close_index() throws Exception {
    CloseIndexResponse closeIndexResponse = httpClient.admin().indices().close(new CloseIndexRequest(THE_INDEX)).get();
    Assertions.assertThat(closeIndexResponse.isAcknowledged()).isTrue();

    try {
        transportClient.admin().indices().recoveries(new RecoveryRequest(THE_INDEX)).actionGet();
        fail();
    } catch (IndexClosedException ignored) {

    }
}
 

import org.elasticsearch.action.admin.indices.close.CloseIndexRequest; //导入依赖的package包/类
@Test
public void should_open_index() throws Exception {
    CloseIndexResponse closeIndexResponse = transportClient.admin().indices().close(new CloseIndexRequest(THE_INDEX)).actionGet();
    Assertions.assertThat(closeIndexResponse.isAcknowledged()).isTrue();

    OpenIndexResponse openIndexResponse = httpClient.admin().indices().open(new OpenIndexRequest(THE_INDEX)).get();
    Assertions.assertThat(openIndexResponse.isAcknowledged()).isTrue();

    transportClient.admin().indices().recoveries(new RecoveryRequest(THE_INDEX)).actionGet();
}
 

import org.elasticsearch.action.admin.indices.close.CloseIndexRequest; //导入依赖的package包/类
@Test
public void should_fail_when_no_index_specified() throws Exception {
    CloseIndexResponse closeIndexResponse = transportClient.admin().indices().close(new CloseIndexRequest(THE_INDEX)).actionGet();
    Assertions.assertThat(closeIndexResponse.isAcknowledged()).isTrue();

    try {
        httpClient.admin().indices().open(new OpenIndexRequest()).get();
    } catch (Exception e) {
        Assertions.assertThat(e).hasMessageContaining("ActionRequestValidationException");
        Assertions.assertThat(e).hasMessageContaining("index is missing");
    }
}
 

import org.elasticsearch.action.admin.indices.close.CloseIndexRequest; //导入依赖的package包/类
@Override
protected XContentBuilder toXContent(CloseIndexRequest request, CloseIndexResponse response, XContentBuilder builder) throws IOException {
    return builder.startObject()
            .field(Fields.OK, true)
            .field(Fields.ACKNOWLEDGED, response.isAcknowledged())
            .endObject();
}
 

import org.elasticsearch.action.admin.indices.close.CloseIndexRequest; //导入依赖的package包/类
@Override
public ActionFuture<CloseIndexResponse> close(final CloseIndexRequest request) {
    return execute(CloseIndexAction.INSTANCE, request);
}
 

import org.elasticsearch.action.admin.indices.close.CloseIndexRequest; //导入依赖的package包/类
public ClusterState closeIndices(ClusterState state, CloseIndexRequest request) {
    return execute(transportCloseIndexAction, request, state);
}
 

import org.elasticsearch.action.admin.indices.close.CloseIndexRequest; //导入依赖的package包/类
public void close(CloseIndexRequest request, ActionListener<CloseIndexResponse> listener) {
    closeIndexActionHandler.execute(request, listener);
}
 

import org.elasticsearch.action.admin.indices.close.CloseIndexRequest; //导入依赖的package包/类
public CloseIndexRequestBuilder(Client client, JsonToString<JsonInput> jsonToString, StringToJson<JsonOutput> stringToJson) {
    super(client, new CloseIndexRequest(null), jsonToString, stringToJson);
}
 

import org.elasticsearch.action.admin.indices.close.CloseIndexRequest; //导入依赖的package包/类
@Override
protected ActionFuture<CloseIndexResponse> doExecute(CloseIndexRequest request) {
    return client.admin().indices().close(request);
}