From 42e106fb226b767788859a32be86878b2ae10653 Mon Sep 17 00:00:00 2001 From: Michael Basnight Date: Mon, 17 Sep 2018 17:38:30 -0500 Subject: [PATCH] HLRC: split indices request converters (#33433) In an effort to encapsulate the different clients, the request converters are being shuffled around. This splits the IndicesClient request converters. --- .../elasticsearch/client/IndicesClient.java | 104 +- .../client/IndicesRequestConverters.java | 403 ++++++++ .../client/RequestConverters.java | 356 ------- .../client/IndicesRequestConvertersTests.java | 893 ++++++++++++++++++ .../client/RequestConvertersTests.java | 819 +--------------- 5 files changed, 1352 insertions(+), 1223 deletions(-) create mode 100644 client/rest-high-level/src/main/java/org/elasticsearch/client/IndicesRequestConverters.java create mode 100644 client/rest-high-level/src/test/java/org/elasticsearch/client/IndicesRequestConvertersTests.java diff --git a/client/rest-high-level/src/main/java/org/elasticsearch/client/IndicesClient.java b/client/rest-high-level/src/main/java/org/elasticsearch/client/IndicesClient.java index c4567e22e0b..3811ba78344 100644 --- a/client/rest-high-level/src/main/java/org/elasticsearch/client/IndicesClient.java +++ b/client/rest-high-level/src/main/java/org/elasticsearch/client/IndicesClient.java @@ -89,7 +89,7 @@ public final class IndicesClient { * @throws IOException in case there is a problem sending the request or parsing back the response */ public AcknowledgedResponse delete(DeleteIndexRequest deleteIndexRequest, RequestOptions options) throws IOException { - return restHighLevelClient.performRequestAndParseEntity(deleteIndexRequest, RequestConverters::deleteIndex, options, + return restHighLevelClient.performRequestAndParseEntity(deleteIndexRequest, IndicesRequestConverters::deleteIndex, options, AcknowledgedResponse::fromXContent, emptySet()); } @@ -102,7 +102,7 @@ public final class IndicesClient { * @param listener the listener to be notified upon request completion */ public void deleteAsync(DeleteIndexRequest deleteIndexRequest, RequestOptions options, ActionListener listener) { - restHighLevelClient.performRequestAsyncAndParseEntity(deleteIndexRequest, RequestConverters::deleteIndex, options, + restHighLevelClient.performRequestAsyncAndParseEntity(deleteIndexRequest, IndicesRequestConverters::deleteIndex, options, AcknowledgedResponse::fromXContent, listener, emptySet()); } @@ -116,7 +116,7 @@ public final class IndicesClient { * @throws IOException in case there is a problem sending the request or parsing back the response */ public CreateIndexResponse create(CreateIndexRequest createIndexRequest, RequestOptions options) throws IOException { - return restHighLevelClient.performRequestAndParseEntity(createIndexRequest, RequestConverters::createIndex, options, + return restHighLevelClient.performRequestAndParseEntity(createIndexRequest, IndicesRequestConverters::createIndex, options, CreateIndexResponse::fromXContent, emptySet()); } @@ -129,7 +129,7 @@ public final class IndicesClient { * @param listener the listener to be notified upon request completion */ public void createAsync(CreateIndexRequest createIndexRequest, RequestOptions options, ActionListener listener) { - restHighLevelClient.performRequestAsyncAndParseEntity(createIndexRequest, RequestConverters::createIndex, options, + restHighLevelClient.performRequestAsyncAndParseEntity(createIndexRequest, IndicesRequestConverters::createIndex, options, CreateIndexResponse::fromXContent, listener, emptySet()); } @@ -143,7 +143,7 @@ public final class IndicesClient { * @throws IOException in case there is a problem sending the request or parsing back the response */ public AcknowledgedResponse putMapping(PutMappingRequest putMappingRequest, RequestOptions options) throws IOException { - return restHighLevelClient.performRequestAndParseEntity(putMappingRequest, RequestConverters::putMapping, options, + return restHighLevelClient.performRequestAndParseEntity(putMappingRequest, IndicesRequestConverters::putMapping, options, AcknowledgedResponse::fromXContent, emptySet()); } @@ -157,7 +157,7 @@ public final class IndicesClient { */ public void putMappingAsync(PutMappingRequest putMappingRequest, RequestOptions options, ActionListener listener) { - restHighLevelClient.performRequestAsyncAndParseEntity(putMappingRequest, RequestConverters::putMapping, options, + restHighLevelClient.performRequestAsyncAndParseEntity(putMappingRequest, IndicesRequestConverters::putMapping, options, AcknowledgedResponse::fromXContent, listener, emptySet()); } @@ -171,7 +171,7 @@ public final class IndicesClient { * @throws IOException in case there is a problem sending the request or parsing back the response */ public GetMappingsResponse getMapping(GetMappingsRequest getMappingsRequest, RequestOptions options) throws IOException { - return restHighLevelClient.performRequestAndParseEntity(getMappingsRequest, RequestConverters::getMappings, options, + return restHighLevelClient.performRequestAndParseEntity(getMappingsRequest, IndicesRequestConverters::getMappings, options, GetMappingsResponse::fromXContent, emptySet()); } @@ -185,7 +185,7 @@ public final class IndicesClient { */ public void getMappingAsync(GetMappingsRequest getMappingsRequest, RequestOptions options, ActionListener listener) { - restHighLevelClient.performRequestAsyncAndParseEntity(getMappingsRequest, RequestConverters::getMappings, options, + restHighLevelClient.performRequestAsyncAndParseEntity(getMappingsRequest, IndicesRequestConverters::getMappings, options, GetMappingsResponse::fromXContent, listener, emptySet()); } @@ -200,7 +200,7 @@ public final class IndicesClient { */ public GetFieldMappingsResponse getFieldMapping(GetFieldMappingsRequest getFieldMappingsRequest, RequestOptions options) throws IOException { - return restHighLevelClient.performRequestAndParseEntity(getFieldMappingsRequest, RequestConverters::getFieldMapping, options, + return restHighLevelClient.performRequestAndParseEntity(getFieldMappingsRequest, IndicesRequestConverters::getFieldMapping, options, GetFieldMappingsResponse::fromXContent, emptySet()); } @@ -214,7 +214,7 @@ public final class IndicesClient { */ public void getFieldMappingAsync(GetFieldMappingsRequest getFieldMappingsRequest, RequestOptions options, ActionListener listener) { - restHighLevelClient.performRequestAsyncAndParseEntity(getFieldMappingsRequest, RequestConverters::getFieldMapping, options, + restHighLevelClient.performRequestAsyncAndParseEntity(getFieldMappingsRequest, IndicesRequestConverters::getFieldMapping, options, GetFieldMappingsResponse::fromXContent, listener, emptySet()); } @@ -228,7 +228,7 @@ public final class IndicesClient { * @throws IOException in case there is a problem sending the request or parsing back the response */ public AcknowledgedResponse updateAliases(IndicesAliasesRequest indicesAliasesRequest, RequestOptions options) throws IOException { - return restHighLevelClient.performRequestAndParseEntity(indicesAliasesRequest, RequestConverters::updateAliases, options, + return restHighLevelClient.performRequestAndParseEntity(indicesAliasesRequest, IndicesRequestConverters::updateAliases, options, AcknowledgedResponse::fromXContent, emptySet()); } @@ -242,7 +242,7 @@ public final class IndicesClient { */ public void updateAliasesAsync(IndicesAliasesRequest indicesAliasesRequest, RequestOptions options, ActionListener listener) { - restHighLevelClient.performRequestAsyncAndParseEntity(indicesAliasesRequest, RequestConverters::updateAliases, options, + restHighLevelClient.performRequestAsyncAndParseEntity(indicesAliasesRequest, IndicesRequestConverters::updateAliases, options, AcknowledgedResponse::fromXContent, listener, emptySet()); } @@ -256,7 +256,7 @@ public final class IndicesClient { * @throws IOException in case there is a problem sending the request or parsing back the response */ public OpenIndexResponse open(OpenIndexRequest openIndexRequest, RequestOptions options) throws IOException { - return restHighLevelClient.performRequestAndParseEntity(openIndexRequest, RequestConverters::openIndex, options, + return restHighLevelClient.performRequestAndParseEntity(openIndexRequest, IndicesRequestConverters::openIndex, options, OpenIndexResponse::fromXContent, emptySet()); } @@ -269,7 +269,7 @@ public final class IndicesClient { * @param listener the listener to be notified upon request completion */ public void openAsync(OpenIndexRequest openIndexRequest, RequestOptions options, ActionListener listener) { - restHighLevelClient.performRequestAsyncAndParseEntity(openIndexRequest, RequestConverters::openIndex, options, + restHighLevelClient.performRequestAsyncAndParseEntity(openIndexRequest, IndicesRequestConverters::openIndex, options, OpenIndexResponse::fromXContent, listener, emptySet()); } @@ -283,7 +283,7 @@ public final class IndicesClient { * @throws IOException in case there is a problem sending the request or parsing back the response */ public AcknowledgedResponse close(CloseIndexRequest closeIndexRequest, RequestOptions options) throws IOException { - return restHighLevelClient.performRequestAndParseEntity(closeIndexRequest, RequestConverters::closeIndex, options, + return restHighLevelClient.performRequestAndParseEntity(closeIndexRequest, IndicesRequestConverters::closeIndex, options, AcknowledgedResponse::fromXContent, emptySet()); } @@ -296,7 +296,7 @@ public final class IndicesClient { * @param listener the listener to be notified upon request completion */ public void closeAsync(CloseIndexRequest closeIndexRequest, RequestOptions options, ActionListener listener) { - restHighLevelClient.performRequestAsyncAndParseEntity(closeIndexRequest, RequestConverters::closeIndex, options, + restHighLevelClient.performRequestAsyncAndParseEntity(closeIndexRequest, IndicesRequestConverters::closeIndex, options, AcknowledgedResponse::fromXContent, listener, emptySet()); } @@ -311,7 +311,7 @@ public final class IndicesClient { * @throws IOException in case there is a problem sending the request */ public boolean existsAlias(GetAliasesRequest getAliasesRequest, RequestOptions options) throws IOException { - return restHighLevelClient.performRequest(getAliasesRequest, RequestConverters::existsAlias, options, + return restHighLevelClient.performRequest(getAliasesRequest, IndicesRequestConverters::existsAlias, options, RestHighLevelClient::convertExistsResponse, emptySet()); } @@ -324,7 +324,7 @@ public final class IndicesClient { * @param listener the listener to be notified upon request completion */ public void existsAliasAsync(GetAliasesRequest getAliasesRequest, RequestOptions options, ActionListener listener) { - restHighLevelClient.performRequestAsync(getAliasesRequest, RequestConverters::existsAlias, options, + restHighLevelClient.performRequestAsync(getAliasesRequest, IndicesRequestConverters::existsAlias, options, RestHighLevelClient::convertExistsResponse, listener, emptySet()); } @@ -337,7 +337,7 @@ public final class IndicesClient { * @throws IOException in case there is a problem sending the request or parsing back the response */ public RefreshResponse refresh(RefreshRequest refreshRequest, RequestOptions options) throws IOException { - return restHighLevelClient.performRequestAndParseEntity(refreshRequest, RequestConverters::refresh, options, + return restHighLevelClient.performRequestAndParseEntity(refreshRequest, IndicesRequestConverters::refresh, options, RefreshResponse::fromXContent, emptySet()); } @@ -349,7 +349,7 @@ public final class IndicesClient { * @param listener the listener to be notified upon request completion */ public void refreshAsync(RefreshRequest refreshRequest, RequestOptions options, ActionListener listener) { - restHighLevelClient.performRequestAsyncAndParseEntity(refreshRequest, RequestConverters::refresh, options, + restHighLevelClient.performRequestAsyncAndParseEntity(refreshRequest, IndicesRequestConverters::refresh, options, RefreshResponse::fromXContent, listener, emptySet()); } @@ -362,7 +362,7 @@ public final class IndicesClient { * @throws IOException in case there is a problem sending the request or parsing back the response */ public FlushResponse flush(FlushRequest flushRequest, RequestOptions options) throws IOException { - return restHighLevelClient.performRequestAndParseEntity(flushRequest, RequestConverters::flush, options, + return restHighLevelClient.performRequestAndParseEntity(flushRequest, IndicesRequestConverters::flush, options, FlushResponse::fromXContent, emptySet()); } @@ -374,7 +374,7 @@ public final class IndicesClient { * @param listener the listener to be notified upon request completion */ public void flushAsync(FlushRequest flushRequest, RequestOptions options, ActionListener listener) { - restHighLevelClient.performRequestAsyncAndParseEntity(flushRequest, RequestConverters::flush, options, + restHighLevelClient.performRequestAsyncAndParseEntity(flushRequest, IndicesRequestConverters::flush, options, FlushResponse::fromXContent, listener, emptySet()); } @@ -388,7 +388,7 @@ public final class IndicesClient { * @throws IOException in case there is a problem sending the request or parsing back the response */ public SyncedFlushResponse flushSynced(SyncedFlushRequest syncedFlushRequest, RequestOptions options) throws IOException { - return restHighLevelClient.performRequestAndParseEntity(syncedFlushRequest, RequestConverters::flushSynced, options, + return restHighLevelClient.performRequestAndParseEntity(syncedFlushRequest, IndicesRequestConverters::flushSynced, options, SyncedFlushResponse::fromXContent, emptySet()); } @@ -402,7 +402,7 @@ public final class IndicesClient { */ public void flushSyncedAsync(SyncedFlushRequest syncedFlushRequest, RequestOptions options, ActionListener listener) { - restHighLevelClient.performRequestAsyncAndParseEntity(syncedFlushRequest, RequestConverters::flushSynced, options, + restHighLevelClient.performRequestAsyncAndParseEntity(syncedFlushRequest, IndicesRequestConverters::flushSynced, options, SyncedFlushResponse::fromXContent, listener, emptySet()); } @@ -416,7 +416,7 @@ public final class IndicesClient { * @throws IOException in case there is a problem sending the request or parsing back the response */ public GetSettingsResponse getSettings(GetSettingsRequest getSettingsRequest, RequestOptions options) throws IOException { - return restHighLevelClient.performRequestAndParseEntity(getSettingsRequest, RequestConverters::getSettings, options, + return restHighLevelClient.performRequestAndParseEntity(getSettingsRequest, IndicesRequestConverters::getSettings, options, GetSettingsResponse::fromXContent, emptySet()); } @@ -430,7 +430,7 @@ public final class IndicesClient { */ public void getSettingsAsync(GetSettingsRequest getSettingsRequest, RequestOptions options, ActionListener listener) { - restHighLevelClient.performRequestAsyncAndParseEntity(getSettingsRequest, RequestConverters::getSettings, options, + restHighLevelClient.performRequestAsyncAndParseEntity(getSettingsRequest, IndicesRequestConverters::getSettings, options, GetSettingsResponse::fromXContent, listener, emptySet()); } @@ -444,7 +444,7 @@ public final class IndicesClient { * @throws IOException in case there is a problem sending the request or parsing back the response */ public GetIndexResponse get(GetIndexRequest getIndexRequest, RequestOptions options) throws IOException { - return restHighLevelClient.performRequestAndParseEntity(getIndexRequest, RequestConverters::getIndex, options, + return restHighLevelClient.performRequestAndParseEntity(getIndexRequest, IndicesRequestConverters::getIndex, options, GetIndexResponse::fromXContent, emptySet()); } @@ -458,7 +458,7 @@ public final class IndicesClient { */ public void getAsync(GetIndexRequest getIndexRequest, RequestOptions options, ActionListener listener) { - restHighLevelClient.performRequestAsyncAndParseEntity(getIndexRequest, RequestConverters::getIndex, options, + restHighLevelClient.performRequestAsyncAndParseEntity(getIndexRequest, IndicesRequestConverters::getIndex, options, GetIndexResponse::fromXContent, listener, emptySet()); } @@ -487,7 +487,7 @@ public final class IndicesClient { * @throws IOException in case there is a problem sending the request or parsing back the response */ public ForceMergeResponse forcemerge(ForceMergeRequest forceMergeRequest, RequestOptions options) throws IOException { - return restHighLevelClient.performRequestAndParseEntity(forceMergeRequest, RequestConverters::forceMerge, options, + return restHighLevelClient.performRequestAndParseEntity(forceMergeRequest, IndicesRequestConverters::forceMerge, options, ForceMergeResponse::fromXContent, emptySet()); } @@ -514,7 +514,7 @@ public final class IndicesClient { * @param listener the listener to be notified upon request completion */ public void forcemergeAsync(ForceMergeRequest forceMergeRequest, RequestOptions options, ActionListener listener) { - restHighLevelClient.performRequestAsyncAndParseEntity(forceMergeRequest, RequestConverters::forceMerge, options, + restHighLevelClient.performRequestAsyncAndParseEntity(forceMergeRequest, IndicesRequestConverters::forceMerge, options, ForceMergeResponse::fromXContent, listener, emptySet()); } @@ -529,7 +529,7 @@ public final class IndicesClient { */ public ClearIndicesCacheResponse clearCache(ClearIndicesCacheRequest clearIndicesCacheRequest, RequestOptions options) throws IOException { - return restHighLevelClient.performRequestAndParseEntity(clearIndicesCacheRequest, RequestConverters::clearCache, options, + return restHighLevelClient.performRequestAndParseEntity(clearIndicesCacheRequest, IndicesRequestConverters::clearCache, options, ClearIndicesCacheResponse::fromXContent, emptySet()); } @@ -543,7 +543,7 @@ public final class IndicesClient { */ public void clearCacheAsync(ClearIndicesCacheRequest clearIndicesCacheRequest, RequestOptions options, ActionListener listener) { - restHighLevelClient.performRequestAsyncAndParseEntity(clearIndicesCacheRequest, RequestConverters::clearCache, options, + restHighLevelClient.performRequestAsyncAndParseEntity(clearIndicesCacheRequest, IndicesRequestConverters::clearCache, options, ClearIndicesCacheResponse::fromXContent, listener, emptySet()); } @@ -559,7 +559,7 @@ public final class IndicesClient { public boolean exists(GetIndexRequest request, RequestOptions options) throws IOException { return restHighLevelClient.performRequest( request, - RequestConverters::indicesExist, + IndicesRequestConverters::indicesExist, options, RestHighLevelClient::convertExistsResponse, Collections.emptySet() @@ -577,7 +577,7 @@ public final class IndicesClient { public void existsAsync(GetIndexRequest request, RequestOptions options, ActionListener listener) { restHighLevelClient.performRequestAsync( request, - RequestConverters::indicesExist, + IndicesRequestConverters::indicesExist, options, RestHighLevelClient::convertExistsResponse, listener, @@ -595,7 +595,7 @@ public final class IndicesClient { * @throws IOException in case there is a problem sending the request or parsing back the response */ public ResizeResponse shrink(ResizeRequest resizeRequest, RequestOptions options) throws IOException { - return restHighLevelClient.performRequestAndParseEntity(resizeRequest, RequestConverters::shrink, options, + return restHighLevelClient.performRequestAndParseEntity(resizeRequest, IndicesRequestConverters::shrink, options, ResizeResponse::fromXContent, emptySet()); } @@ -608,7 +608,7 @@ public final class IndicesClient { * @param listener the listener to be notified upon request completion */ public void shrinkAsync(ResizeRequest resizeRequest, RequestOptions options, ActionListener listener) { - restHighLevelClient.performRequestAsyncAndParseEntity(resizeRequest, RequestConverters::shrink, options, + restHighLevelClient.performRequestAsyncAndParseEntity(resizeRequest, IndicesRequestConverters::shrink, options, ResizeResponse::fromXContent, listener, emptySet()); } @@ -622,7 +622,7 @@ public final class IndicesClient { * @throws IOException in case there is a problem sending the request or parsing back the response */ public ResizeResponse split(ResizeRequest resizeRequest, RequestOptions options) throws IOException { - return restHighLevelClient.performRequestAndParseEntity(resizeRequest, RequestConverters::split, options, + return restHighLevelClient.performRequestAndParseEntity(resizeRequest, IndicesRequestConverters::split, options, ResizeResponse::fromXContent, emptySet()); } @@ -635,7 +635,7 @@ public final class IndicesClient { * @param listener the listener to be notified upon request completion */ public void splitAsync(ResizeRequest resizeRequest, RequestOptions options, ActionListener listener) { - restHighLevelClient.performRequestAsyncAndParseEntity(resizeRequest, RequestConverters::split, options, + restHighLevelClient.performRequestAsyncAndParseEntity(resizeRequest, IndicesRequestConverters::split, options, ResizeResponse::fromXContent, listener, emptySet()); } @@ -649,7 +649,7 @@ public final class IndicesClient { * @throws IOException in case there is a problem sending the request or parsing back the response */ public RolloverResponse rollover(RolloverRequest rolloverRequest, RequestOptions options) throws IOException { - return restHighLevelClient.performRequestAndParseEntity(rolloverRequest, RequestConverters::rollover, options, + return restHighLevelClient.performRequestAndParseEntity(rolloverRequest, IndicesRequestConverters::rollover, options, RolloverResponse::fromXContent, emptySet()); } @@ -662,7 +662,7 @@ public final class IndicesClient { * @param listener the listener to be notified upon request completion */ public void rolloverAsync(RolloverRequest rolloverRequest, RequestOptions options, ActionListener listener) { - restHighLevelClient.performRequestAsyncAndParseEntity(rolloverRequest, RequestConverters::rollover, options, + restHighLevelClient.performRequestAsyncAndParseEntity(rolloverRequest, IndicesRequestConverters::rollover, options, RolloverResponse::fromXContent, listener, emptySet()); } @@ -676,7 +676,7 @@ public final class IndicesClient { * @throws IOException in case there is a problem sending the request or parsing back the response */ public GetAliasesResponse getAlias(GetAliasesRequest getAliasesRequest, RequestOptions options) throws IOException { - return restHighLevelClient.performRequestAndParseEntity(getAliasesRequest, RequestConverters::getAlias, options, + return restHighLevelClient.performRequestAndParseEntity(getAliasesRequest, IndicesRequestConverters::getAlias, options, GetAliasesResponse::fromXContent, singleton(RestStatus.NOT_FOUND.getStatus())); } @@ -689,7 +689,7 @@ public final class IndicesClient { * @param listener the listener to be notified upon request completion */ public void getAliasAsync(GetAliasesRequest getAliasesRequest, RequestOptions options, ActionListener listener) { - restHighLevelClient.performRequestAsyncAndParseEntity(getAliasesRequest, RequestConverters::getAlias, options, + restHighLevelClient.performRequestAsyncAndParseEntity(getAliasesRequest, IndicesRequestConverters::getAlias, options, GetAliasesResponse::fromXContent, listener, singleton(RestStatus.NOT_FOUND.getStatus())); } @@ -703,7 +703,7 @@ public final class IndicesClient { * @throws IOException in case there is a problem sending the request or parsing back the response */ public AcknowledgedResponse putSettings(UpdateSettingsRequest updateSettingsRequest, RequestOptions options) throws IOException { - return restHighLevelClient.performRequestAndParseEntity(updateSettingsRequest, RequestConverters::indexPutSettings, options, + return restHighLevelClient.performRequestAndParseEntity(updateSettingsRequest, IndicesRequestConverters::indexPutSettings, options, AcknowledgedResponse::fromXContent, emptySet()); } @@ -717,7 +717,7 @@ public final class IndicesClient { */ public void putSettingsAsync(UpdateSettingsRequest updateSettingsRequest, RequestOptions options, ActionListener listener) { - restHighLevelClient.performRequestAsyncAndParseEntity(updateSettingsRequest, RequestConverters::indexPutSettings, options, + restHighLevelClient.performRequestAsyncAndParseEntity(updateSettingsRequest, IndicesRequestConverters::indexPutSettings, options, AcknowledgedResponse::fromXContent, listener, emptySet()); } @@ -732,7 +732,7 @@ public final class IndicesClient { */ public AcknowledgedResponse putTemplate(PutIndexTemplateRequest putIndexTemplateRequest, RequestOptions options) throws IOException { - return restHighLevelClient.performRequestAndParseEntity(putIndexTemplateRequest, RequestConverters::putTemplate, options, + return restHighLevelClient.performRequestAndParseEntity(putIndexTemplateRequest, IndicesRequestConverters::putTemplate, options, AcknowledgedResponse::fromXContent, emptySet()); } @@ -746,7 +746,7 @@ public final class IndicesClient { */ public void putTemplateAsync(PutIndexTemplateRequest putIndexTemplateRequest, RequestOptions options, ActionListener listener) { - restHighLevelClient.performRequestAsyncAndParseEntity(putIndexTemplateRequest, RequestConverters::putTemplate, options, + restHighLevelClient.performRequestAsyncAndParseEntity(putIndexTemplateRequest, IndicesRequestConverters::putTemplate, options, AcknowledgedResponse::fromXContent, listener, emptySet()); } @@ -761,7 +761,7 @@ public final class IndicesClient { * @throws IOException in case there is a problem sending the request or parsing back the response */ public ValidateQueryResponse validateQuery(ValidateQueryRequest validateQueryRequest, RequestOptions options) throws IOException { - return restHighLevelClient.performRequestAndParseEntity(validateQueryRequest, RequestConverters::validateQuery, options, + return restHighLevelClient.performRequestAndParseEntity(validateQueryRequest, IndicesRequestConverters::validateQuery, options, ValidateQueryResponse::fromXContent, emptySet()); } @@ -776,7 +776,7 @@ public final class IndicesClient { */ public void validateQueryAsync(ValidateQueryRequest validateQueryRequest, RequestOptions options, ActionListener listener) { - restHighLevelClient.performRequestAsyncAndParseEntity(validateQueryRequest, RequestConverters::validateQuery, options, + restHighLevelClient.performRequestAsyncAndParseEntity(validateQueryRequest, IndicesRequestConverters::validateQuery, options, ValidateQueryResponse::fromXContent, listener, emptySet()); } @@ -791,7 +791,7 @@ public final class IndicesClient { */ public GetIndexTemplatesResponse getTemplate(GetIndexTemplatesRequest getIndexTemplatesRequest, RequestOptions options) throws IOException { - return restHighLevelClient.performRequestAndParseEntity(getIndexTemplatesRequest, RequestConverters::getTemplates, + return restHighLevelClient.performRequestAndParseEntity(getIndexTemplatesRequest, IndicesRequestConverters::getTemplates, options, GetIndexTemplatesResponse::fromXContent, emptySet()); } @@ -805,7 +805,7 @@ public final class IndicesClient { */ public void getTemplateAsync(GetIndexTemplatesRequest getIndexTemplatesRequest, RequestOptions options, ActionListener listener) { - restHighLevelClient.performRequestAsyncAndParseEntity(getIndexTemplatesRequest, RequestConverters::getTemplates, + restHighLevelClient.performRequestAsyncAndParseEntity(getIndexTemplatesRequest, IndicesRequestConverters::getTemplates, options, GetIndexTemplatesResponse::fromXContent, listener, emptySet()); } @@ -818,7 +818,7 @@ public final class IndicesClient { * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized */ public AnalyzeResponse analyze(AnalyzeRequest request, RequestOptions options) throws IOException { - return restHighLevelClient.performRequestAndParseEntity(request, RequestConverters::analyze, options, + return restHighLevelClient.performRequestAndParseEntity(request, IndicesRequestConverters::analyze, options, AnalyzeResponse::fromXContent, emptySet()); } @@ -833,7 +833,7 @@ public final class IndicesClient { */ public void analyzeAsync(AnalyzeRequest request, RequestOptions options, ActionListener listener) { - restHighLevelClient.performRequestAsyncAndParseEntity(request, RequestConverters::analyze, options, + restHighLevelClient.performRequestAsyncAndParseEntity(request, IndicesRequestConverters::analyze, options, AnalyzeResponse::fromXContent, listener, emptySet()); } } diff --git a/client/rest-high-level/src/main/java/org/elasticsearch/client/IndicesRequestConverters.java b/client/rest-high-level/src/main/java/org/elasticsearch/client/IndicesRequestConverters.java new file mode 100644 index 00000000000..740b87107c1 --- /dev/null +++ b/client/rest-high-level/src/main/java/org/elasticsearch/client/IndicesRequestConverters.java @@ -0,0 +1,403 @@ +/* + * Licensed to Elasticsearch under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch licenses this file to you under + * the Apache License, Version 2.0 (the "License"); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.elasticsearch.client; + +import org.apache.http.client.methods.HttpDelete; +import org.apache.http.client.methods.HttpGet; +import org.apache.http.client.methods.HttpHead; +import org.apache.http.client.methods.HttpPost; +import org.apache.http.client.methods.HttpPut; +import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest; +import org.elasticsearch.action.admin.indices.alias.get.GetAliasesRequest; +import org.elasticsearch.action.admin.indices.analyze.AnalyzeRequest; +import org.elasticsearch.action.admin.indices.cache.clear.ClearIndicesCacheRequest; +import org.elasticsearch.action.admin.indices.close.CloseIndexRequest; +import org.elasticsearch.action.admin.indices.create.CreateIndexRequest; +import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest; +import org.elasticsearch.action.admin.indices.flush.FlushRequest; +import org.elasticsearch.action.admin.indices.flush.SyncedFlushRequest; +import org.elasticsearch.action.admin.indices.forcemerge.ForceMergeRequest; +import org.elasticsearch.action.admin.indices.get.GetIndexRequest; +import org.elasticsearch.action.admin.indices.mapping.get.GetFieldMappingsRequest; +import org.elasticsearch.action.admin.indices.mapping.get.GetMappingsRequest; +import org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequest; +import org.elasticsearch.action.admin.indices.open.OpenIndexRequest; +import org.elasticsearch.action.admin.indices.refresh.RefreshRequest; +import org.elasticsearch.action.admin.indices.rollover.RolloverRequest; +import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest; +import org.elasticsearch.action.admin.indices.settings.put.UpdateSettingsRequest; +import org.elasticsearch.action.admin.indices.shrink.ResizeRequest; +import org.elasticsearch.action.admin.indices.shrink.ResizeType; +import org.elasticsearch.action.admin.indices.template.get.GetIndexTemplatesRequest; +import org.elasticsearch.action.admin.indices.template.put.PutIndexTemplateRequest; +import org.elasticsearch.action.admin.indices.validate.query.ValidateQueryRequest; +import org.elasticsearch.common.Strings; + +import java.io.IOException; +import java.util.Locale; + +public class IndicesRequestConverters { + static Request deleteIndex(DeleteIndexRequest deleteIndexRequest) { + String endpoint = RequestConverters.endpoint(deleteIndexRequest.indices()); + Request request = new Request(HttpDelete.METHOD_NAME, endpoint); + + RequestConverters.Params parameters = new RequestConverters.Params(request); + parameters.withTimeout(deleteIndexRequest.timeout()); + parameters.withMasterTimeout(deleteIndexRequest.masterNodeTimeout()); + parameters.withIndicesOptions(deleteIndexRequest.indicesOptions()); + return request; + } + + static Request openIndex(OpenIndexRequest openIndexRequest) { + String endpoint = RequestConverters.endpoint(openIndexRequest.indices(), "_open"); + Request request = new Request(HttpPost.METHOD_NAME, endpoint); + + RequestConverters.Params parameters = new RequestConverters.Params(request); + parameters.withTimeout(openIndexRequest.timeout()); + parameters.withMasterTimeout(openIndexRequest.masterNodeTimeout()); + parameters.withWaitForActiveShards(openIndexRequest.waitForActiveShards()); + parameters.withIndicesOptions(openIndexRequest.indicesOptions()); + return request; + } + + static Request closeIndex(CloseIndexRequest closeIndexRequest) { + String endpoint = RequestConverters.endpoint(closeIndexRequest.indices(), "_close"); + Request request = new Request(HttpPost.METHOD_NAME, endpoint); + + RequestConverters.Params parameters = new RequestConverters.Params(request); + parameters.withTimeout(closeIndexRequest.timeout()); + parameters.withMasterTimeout(closeIndexRequest.masterNodeTimeout()); + parameters.withIndicesOptions(closeIndexRequest.indicesOptions()); + return request; + } + + static Request createIndex(CreateIndexRequest createIndexRequest) throws IOException { + String endpoint = RequestConverters.endpoint(createIndexRequest.indices()); + Request request = new Request(HttpPut.METHOD_NAME, endpoint); + + RequestConverters.Params parameters = new RequestConverters.Params(request); + parameters.withTimeout(createIndexRequest.timeout()); + parameters.withMasterTimeout(createIndexRequest.masterNodeTimeout()); + parameters.withWaitForActiveShards(createIndexRequest.waitForActiveShards()); + + request.setEntity(RequestConverters.createEntity(createIndexRequest, RequestConverters.REQUEST_BODY_CONTENT_TYPE)); + return request; + } + + static Request updateAliases(IndicesAliasesRequest indicesAliasesRequest) throws IOException { + Request request = new Request(HttpPost.METHOD_NAME, "/_aliases"); + + RequestConverters.Params parameters = new RequestConverters.Params(request); + parameters.withTimeout(indicesAliasesRequest.timeout()); + parameters.withMasterTimeout(indicesAliasesRequest.masterNodeTimeout()); + + request.setEntity(RequestConverters.createEntity(indicesAliasesRequest, RequestConverters.REQUEST_BODY_CONTENT_TYPE)); + return request; + } + + static Request putMapping(PutMappingRequest putMappingRequest) throws IOException { + // The concreteIndex is an internal concept, not applicable to requests made over the REST API. + if (putMappingRequest.getConcreteIndex() != null) { + throw new IllegalArgumentException("concreteIndex cannot be set on PutMapping requests made over the REST API"); + } + + Request request = new Request(HttpPut.METHOD_NAME, RequestConverters.endpoint(putMappingRequest.indices(), "_mapping", + putMappingRequest.type())); + + RequestConverters.Params parameters = new RequestConverters.Params(request); + parameters.withTimeout(putMappingRequest.timeout()); + parameters.withMasterTimeout(putMappingRequest.masterNodeTimeout()); + + request.setEntity(RequestConverters.createEntity(putMappingRequest, RequestConverters.REQUEST_BODY_CONTENT_TYPE)); + return request; + } + + static Request getMappings(GetMappingsRequest getMappingsRequest) throws IOException { + String[] indices = getMappingsRequest.indices() == null ? Strings.EMPTY_ARRAY : getMappingsRequest.indices(); + String[] types = getMappingsRequest.types() == null ? Strings.EMPTY_ARRAY : getMappingsRequest.types(); + + Request request = new Request(HttpGet.METHOD_NAME, RequestConverters.endpoint(indices, "_mapping", types)); + + RequestConverters.Params parameters = new RequestConverters.Params(request); + parameters.withMasterTimeout(getMappingsRequest.masterNodeTimeout()); + parameters.withIndicesOptions(getMappingsRequest.indicesOptions()); + parameters.withLocal(getMappingsRequest.local()); + return request; + } + + static Request getFieldMapping(GetFieldMappingsRequest getFieldMappingsRequest) throws IOException { + String[] indices = getFieldMappingsRequest.indices() == null ? Strings.EMPTY_ARRAY : getFieldMappingsRequest.indices(); + String[] types = getFieldMappingsRequest.types() == null ? Strings.EMPTY_ARRAY : getFieldMappingsRequest.types(); + String[] fields = getFieldMappingsRequest.fields() == null ? Strings.EMPTY_ARRAY : getFieldMappingsRequest.fields(); + + String endpoint = new RequestConverters.EndpointBuilder().addCommaSeparatedPathParts(indices) + .addPathPartAsIs("_mapping").addCommaSeparatedPathParts(types) + .addPathPartAsIs("field").addCommaSeparatedPathParts(fields) + .build(); + + Request request = new Request(HttpGet.METHOD_NAME, endpoint); + + RequestConverters.Params parameters = new RequestConverters.Params(request); + parameters.withIndicesOptions(getFieldMappingsRequest.indicesOptions()); + parameters.withIncludeDefaults(getFieldMappingsRequest.includeDefaults()); + parameters.withLocal(getFieldMappingsRequest.local()); + return request; + } + + static Request refresh(RefreshRequest refreshRequest) { + String[] indices = refreshRequest.indices() == null ? Strings.EMPTY_ARRAY : refreshRequest.indices(); + Request request = new Request(HttpPost.METHOD_NAME, RequestConverters.endpoint(indices, "_refresh")); + + RequestConverters.Params parameters = new RequestConverters.Params(request); + parameters.withIndicesOptions(refreshRequest.indicesOptions()); + return request; + } + + static Request flush(FlushRequest flushRequest) { + String[] indices = flushRequest.indices() == null ? Strings.EMPTY_ARRAY : flushRequest.indices(); + Request request = new Request(HttpPost.METHOD_NAME, RequestConverters.endpoint(indices, "_flush")); + + RequestConverters.Params parameters = new RequestConverters.Params(request); + parameters.withIndicesOptions(flushRequest.indicesOptions()); + parameters.putParam("wait_if_ongoing", Boolean.toString(flushRequest.waitIfOngoing())); + parameters.putParam("force", Boolean.toString(flushRequest.force())); + return request; + } + + static Request flushSynced(SyncedFlushRequest syncedFlushRequest) { + String[] indices = syncedFlushRequest.indices() == null ? Strings.EMPTY_ARRAY : syncedFlushRequest.indices(); + Request request = new Request(HttpPost.METHOD_NAME, RequestConverters.endpoint(indices, "_flush/synced")); + RequestConverters.Params parameters = new RequestConverters.Params(request); + parameters.withIndicesOptions(syncedFlushRequest.indicesOptions()); + return request; + } + + static Request forceMerge(ForceMergeRequest forceMergeRequest) { + String[] indices = forceMergeRequest.indices() == null ? Strings.EMPTY_ARRAY : forceMergeRequest.indices(); + Request request = new Request(HttpPost.METHOD_NAME, RequestConverters.endpoint(indices, "_forcemerge")); + + RequestConverters.Params parameters = new RequestConverters.Params(request); + parameters.withIndicesOptions(forceMergeRequest.indicesOptions()); + parameters.putParam("max_num_segments", Integer.toString(forceMergeRequest.maxNumSegments())); + parameters.putParam("only_expunge_deletes", Boolean.toString(forceMergeRequest.onlyExpungeDeletes())); + parameters.putParam("flush", Boolean.toString(forceMergeRequest.flush())); + return request; + } + + static Request clearCache(ClearIndicesCacheRequest clearIndicesCacheRequest) { + String[] indices = clearIndicesCacheRequest.indices() == null ? Strings.EMPTY_ARRAY :clearIndicesCacheRequest.indices(); + Request request = new Request(HttpPost.METHOD_NAME, RequestConverters.endpoint(indices, "_cache/clear")); + + RequestConverters.Params parameters = new RequestConverters.Params(request); + parameters.withIndicesOptions(clearIndicesCacheRequest.indicesOptions()); + parameters.putParam("query", Boolean.toString(clearIndicesCacheRequest.queryCache())); + parameters.putParam("fielddata", Boolean.toString(clearIndicesCacheRequest.fieldDataCache())); + parameters.putParam("request", Boolean.toString(clearIndicesCacheRequest.requestCache())); + parameters.putParam("fields", String.join(",", clearIndicesCacheRequest.fields())); + return request; + } + + static Request existsAlias(GetAliasesRequest getAliasesRequest) { + if ((getAliasesRequest.indices() == null || getAliasesRequest.indices().length == 0) && + (getAliasesRequest.aliases() == null || getAliasesRequest.aliases().length == 0)) { + throw new IllegalArgumentException("existsAlias requires at least an alias or an index"); + } + String[] indices = getAliasesRequest.indices() == null ? Strings.EMPTY_ARRAY : getAliasesRequest.indices(); + String[] aliases = getAliasesRequest.aliases() == null ? Strings.EMPTY_ARRAY : getAliasesRequest.aliases(); + + Request request = new Request(HttpHead.METHOD_NAME, RequestConverters.endpoint(indices, "_alias", aliases)); + + RequestConverters.Params params = new RequestConverters.Params(request); + params.withIndicesOptions(getAliasesRequest.indicesOptions()); + params.withLocal(getAliasesRequest.local()); + return request; + } + + static Request split(ResizeRequest resizeRequest) throws IOException { + if (resizeRequest.getResizeType() != ResizeType.SPLIT) { + throw new IllegalArgumentException("Wrong resize type [" + resizeRequest.getResizeType() + "] for indices split request"); + } + return resize(resizeRequest); + } + + static Request shrink(ResizeRequest resizeRequest) throws IOException { + if (resizeRequest.getResizeType() != ResizeType.SHRINK) { + throw new IllegalArgumentException("Wrong resize type [" + resizeRequest.getResizeType() + "] for indices shrink request"); + } + return resize(resizeRequest); + } + + private static Request resize(ResizeRequest resizeRequest) throws IOException { + String endpoint = new RequestConverters.EndpointBuilder().addPathPart(resizeRequest.getSourceIndex()) + .addPathPartAsIs("_" + resizeRequest.getResizeType().name().toLowerCase(Locale.ROOT)) + .addPathPart(resizeRequest.getTargetIndexRequest().index()).build(); + Request request = new Request(HttpPut.METHOD_NAME, endpoint); + + RequestConverters.Params params = new RequestConverters.Params(request); + params.withTimeout(resizeRequest.timeout()); + params.withMasterTimeout(resizeRequest.masterNodeTimeout()); + params.withWaitForActiveShards(resizeRequest.getTargetIndexRequest().waitForActiveShards()); + + request.setEntity(RequestConverters.createEntity(resizeRequest, RequestConverters.REQUEST_BODY_CONTENT_TYPE)); + return request; + } + + static Request rollover(RolloverRequest rolloverRequest) throws IOException { + String endpoint = new RequestConverters.EndpointBuilder().addPathPart(rolloverRequest.getAlias()).addPathPartAsIs("_rollover") + .addPathPart(rolloverRequest.getNewIndexName()).build(); + Request request = new Request(HttpPost.METHOD_NAME, endpoint); + + RequestConverters.Params params = new RequestConverters.Params(request); + params.withTimeout(rolloverRequest.timeout()); + params.withMasterTimeout(rolloverRequest.masterNodeTimeout()); + params.withWaitForActiveShards(rolloverRequest.getCreateIndexRequest().waitForActiveShards()); + if (rolloverRequest.isDryRun()) { + params.putParam("dry_run", Boolean.TRUE.toString()); + } + + request.setEntity(RequestConverters.createEntity(rolloverRequest, RequestConverters.REQUEST_BODY_CONTENT_TYPE)); + return request; + } + + static Request getSettings(GetSettingsRequest getSettingsRequest) { + String[] indices = getSettingsRequest.indices() == null ? Strings.EMPTY_ARRAY : getSettingsRequest.indices(); + String[] names = getSettingsRequest.names() == null ? Strings.EMPTY_ARRAY : getSettingsRequest.names(); + + String endpoint = RequestConverters.endpoint(indices, "_settings", names); + Request request = new Request(HttpGet.METHOD_NAME, endpoint); + + RequestConverters.Params params = new RequestConverters.Params(request); + params.withIndicesOptions(getSettingsRequest.indicesOptions()); + params.withLocal(getSettingsRequest.local()); + params.withIncludeDefaults(getSettingsRequest.includeDefaults()); + params.withMasterTimeout(getSettingsRequest.masterNodeTimeout()); + + return request; + } + + static Request getIndex(GetIndexRequest getIndexRequest) { + String[] indices = getIndexRequest.indices() == null ? Strings.EMPTY_ARRAY : getIndexRequest.indices(); + + String endpoint = RequestConverters.endpoint(indices); + Request request = new Request(HttpGet.METHOD_NAME, endpoint); + + RequestConverters.Params params = new RequestConverters.Params(request); + params.withIndicesOptions(getIndexRequest.indicesOptions()); + params.withLocal(getIndexRequest.local()); + params.withIncludeDefaults(getIndexRequest.includeDefaults()); + params.withHuman(getIndexRequest.humanReadable()); + params.withMasterTimeout(getIndexRequest.masterNodeTimeout()); + + return request; + } + + static Request indicesExist(GetIndexRequest getIndexRequest) { + // this can be called with no indices as argument by transport client, not via REST though + if (getIndexRequest.indices() == null || getIndexRequest.indices().length == 0) { + throw new IllegalArgumentException("indices are mandatory"); + } + String endpoint = RequestConverters.endpoint(getIndexRequest.indices(), ""); + Request request = new Request(HttpHead.METHOD_NAME, endpoint); + + RequestConverters.Params params = new RequestConverters.Params(request); + params.withLocal(getIndexRequest.local()); + params.withHuman(getIndexRequest.humanReadable()); + params.withIndicesOptions(getIndexRequest.indicesOptions()); + params.withIncludeDefaults(getIndexRequest.includeDefaults()); + return request; + } + + static Request indexPutSettings(UpdateSettingsRequest updateSettingsRequest) throws IOException { + String[] indices = updateSettingsRequest.indices() == null ? Strings.EMPTY_ARRAY : updateSettingsRequest.indices(); + Request request = new Request(HttpPut.METHOD_NAME, RequestConverters.endpoint(indices, "_settings")); + + RequestConverters.Params parameters = new RequestConverters.Params(request); + parameters.withTimeout(updateSettingsRequest.timeout()); + parameters.withMasterTimeout(updateSettingsRequest.masterNodeTimeout()); + parameters.withIndicesOptions(updateSettingsRequest.indicesOptions()); + parameters.withPreserveExisting(updateSettingsRequest.isPreserveExisting()); + + request.setEntity(RequestConverters.createEntity(updateSettingsRequest, RequestConverters.REQUEST_BODY_CONTENT_TYPE)); + return request; + } + + static Request putTemplate(PutIndexTemplateRequest putIndexTemplateRequest) throws IOException { + String endpoint = new RequestConverters.EndpointBuilder().addPathPartAsIs("_template") + .addPathPart(putIndexTemplateRequest.name()).build(); + Request request = new Request(HttpPut.METHOD_NAME, endpoint); + RequestConverters.Params params = new RequestConverters.Params(request); + params.withMasterTimeout(putIndexTemplateRequest.masterNodeTimeout()); + if (putIndexTemplateRequest.create()) { + params.putParam("create", Boolean.TRUE.toString()); + } + if (Strings.hasText(putIndexTemplateRequest.cause())) { + params.putParam("cause", putIndexTemplateRequest.cause()); + } + request.setEntity(RequestConverters.createEntity(putIndexTemplateRequest, RequestConverters.REQUEST_BODY_CONTENT_TYPE)); + return request; + } + + static Request validateQuery(ValidateQueryRequest validateQueryRequest) throws IOException { + String[] indices = validateQueryRequest.indices() == null ? Strings.EMPTY_ARRAY : validateQueryRequest.indices(); + String[] types = validateQueryRequest.types() == null || indices.length <= 0 ? Strings.EMPTY_ARRAY : validateQueryRequest.types(); + String endpoint = RequestConverters.endpoint(indices, types, "_validate/query"); + Request request = new Request(HttpGet.METHOD_NAME, endpoint); + RequestConverters.Params params = new RequestConverters.Params(request); + params.withIndicesOptions(validateQueryRequest.indicesOptions()); + params.putParam("explain", Boolean.toString(validateQueryRequest.explain())); + params.putParam("all_shards", Boolean.toString(validateQueryRequest.allShards())); + params.putParam("rewrite", Boolean.toString(validateQueryRequest.rewrite())); + request.setEntity(RequestConverters.createEntity(validateQueryRequest, RequestConverters.REQUEST_BODY_CONTENT_TYPE)); + return request; + } + + static Request getAlias(GetAliasesRequest getAliasesRequest) { + String[] indices = getAliasesRequest.indices() == null ? Strings.EMPTY_ARRAY : getAliasesRequest.indices(); + String[] aliases = getAliasesRequest.aliases() == null ? Strings.EMPTY_ARRAY : getAliasesRequest.aliases(); + String endpoint = RequestConverters.endpoint(indices, "_alias", aliases); + Request request = new Request(HttpGet.METHOD_NAME, endpoint); + RequestConverters.Params params = new RequestConverters.Params(request); + params.withIndicesOptions(getAliasesRequest.indicesOptions()); + params.withLocal(getAliasesRequest.local()); + return request; + } + + static Request getTemplates(GetIndexTemplatesRequest getIndexTemplatesRequest) throws IOException { + String[] names = getIndexTemplatesRequest.names(); + String endpoint = new RequestConverters.EndpointBuilder().addPathPartAsIs("_template").addCommaSeparatedPathParts(names).build(); + Request request = new Request(HttpGet.METHOD_NAME, endpoint); + RequestConverters.Params params = new RequestConverters.Params(request); + params.withLocal(getIndexTemplatesRequest.local()); + params.withMasterTimeout(getIndexTemplatesRequest.masterNodeTimeout()); + return request; + } + + static Request analyze(AnalyzeRequest request) throws IOException { + RequestConverters.EndpointBuilder builder = new RequestConverters.EndpointBuilder(); + String index = request.index(); + if (index != null) { + builder.addPathPart(index); + } + builder.addPathPartAsIs("_analyze"); + Request req = new Request(HttpGet.METHOD_NAME, builder.build()); + req.setEntity(RequestConverters.createEntity(request, RequestConverters.REQUEST_BODY_CONTENT_TYPE)); + return req; + } +} diff --git a/client/rest-high-level/src/main/java/org/elasticsearch/client/RequestConverters.java b/client/rest-high-level/src/main/java/org/elasticsearch/client/RequestConverters.java index 840bc4f0c4d..8372f4b0fec 100644 --- a/client/rest-high-level/src/main/java/org/elasticsearch/client/RequestConverters.java +++ b/client/rest-high-level/src/main/java/org/elasticsearch/client/RequestConverters.java @@ -33,30 +33,7 @@ import org.elasticsearch.action.admin.cluster.health.ClusterHealthRequest; import org.elasticsearch.action.admin.cluster.storedscripts.DeleteStoredScriptRequest; import org.elasticsearch.action.admin.cluster.storedscripts.GetStoredScriptRequest; import org.elasticsearch.action.admin.cluster.storedscripts.PutStoredScriptRequest; -import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest; -import org.elasticsearch.action.admin.indices.alias.get.GetAliasesRequest; import org.elasticsearch.action.admin.indices.analyze.AnalyzeRequest; -import org.elasticsearch.action.admin.indices.cache.clear.ClearIndicesCacheRequest; -import org.elasticsearch.action.admin.indices.close.CloseIndexRequest; -import org.elasticsearch.action.admin.indices.create.CreateIndexRequest; -import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest; -import org.elasticsearch.action.admin.indices.flush.FlushRequest; -import org.elasticsearch.action.admin.indices.flush.SyncedFlushRequest; -import org.elasticsearch.action.admin.indices.forcemerge.ForceMergeRequest; -import org.elasticsearch.action.admin.indices.get.GetIndexRequest; -import org.elasticsearch.action.admin.indices.mapping.get.GetFieldMappingsRequest; -import org.elasticsearch.action.admin.indices.mapping.get.GetMappingsRequest; -import org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequest; -import org.elasticsearch.action.admin.indices.open.OpenIndexRequest; -import org.elasticsearch.action.admin.indices.refresh.RefreshRequest; -import org.elasticsearch.action.admin.indices.rollover.RolloverRequest; -import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest; -import org.elasticsearch.action.admin.indices.settings.put.UpdateSettingsRequest; -import org.elasticsearch.action.admin.indices.shrink.ResizeRequest; -import org.elasticsearch.action.admin.indices.shrink.ResizeType; -import org.elasticsearch.action.admin.indices.template.get.GetIndexTemplatesRequest; -import org.elasticsearch.action.admin.indices.template.put.PutIndexTemplateRequest; -import org.elasticsearch.action.admin.indices.validate.query.ValidateQueryRequest; import org.elasticsearch.action.bulk.BulkRequest; import org.elasticsearch.action.delete.DeleteRequest; import org.elasticsearch.action.explain.ExplainRequest; @@ -130,165 +107,6 @@ final class RequestConverters { return request; } - static Request deleteIndex(DeleteIndexRequest deleteIndexRequest) { - String endpoint = endpoint(deleteIndexRequest.indices()); - Request request = new Request(HttpDelete.METHOD_NAME, endpoint); - - Params parameters = new Params(request); - parameters.withTimeout(deleteIndexRequest.timeout()); - parameters.withMasterTimeout(deleteIndexRequest.masterNodeTimeout()); - parameters.withIndicesOptions(deleteIndexRequest.indicesOptions()); - return request; - } - - static Request openIndex(OpenIndexRequest openIndexRequest) { - String endpoint = endpoint(openIndexRequest.indices(), "_open"); - Request request = new Request(HttpPost.METHOD_NAME, endpoint); - - Params parameters = new Params(request); - parameters.withTimeout(openIndexRequest.timeout()); - parameters.withMasterTimeout(openIndexRequest.masterNodeTimeout()); - parameters.withWaitForActiveShards(openIndexRequest.waitForActiveShards()); - parameters.withIndicesOptions(openIndexRequest.indicesOptions()); - return request; - } - - static Request closeIndex(CloseIndexRequest closeIndexRequest) { - String endpoint = endpoint(closeIndexRequest.indices(), "_close"); - Request request = new Request(HttpPost.METHOD_NAME, endpoint); - - Params parameters = new Params(request); - parameters.withTimeout(closeIndexRequest.timeout()); - parameters.withMasterTimeout(closeIndexRequest.masterNodeTimeout()); - parameters.withIndicesOptions(closeIndexRequest.indicesOptions()); - return request; - } - - static Request createIndex(CreateIndexRequest createIndexRequest) throws IOException { - String endpoint = endpoint(createIndexRequest.indices()); - Request request = new Request(HttpPut.METHOD_NAME, endpoint); - - Params parameters = new Params(request); - parameters.withTimeout(createIndexRequest.timeout()); - parameters.withMasterTimeout(createIndexRequest.masterNodeTimeout()); - parameters.withWaitForActiveShards(createIndexRequest.waitForActiveShards()); - - request.setEntity(createEntity(createIndexRequest, REQUEST_BODY_CONTENT_TYPE)); - return request; - } - - static Request updateAliases(IndicesAliasesRequest indicesAliasesRequest) throws IOException { - Request request = new Request(HttpPost.METHOD_NAME, "/_aliases"); - - Params parameters = new Params(request); - parameters.withTimeout(indicesAliasesRequest.timeout()); - parameters.withMasterTimeout(indicesAliasesRequest.masterNodeTimeout()); - - request.setEntity(createEntity(indicesAliasesRequest, REQUEST_BODY_CONTENT_TYPE)); - return request; - } - - static Request putMapping(PutMappingRequest putMappingRequest) throws IOException { - // The concreteIndex is an internal concept, not applicable to requests made over the REST API. - if (putMappingRequest.getConcreteIndex() != null) { - throw new IllegalArgumentException("concreteIndex cannot be set on PutMapping requests made over the REST API"); - } - - Request request = new Request(HttpPut.METHOD_NAME, endpoint(putMappingRequest.indices(), "_mapping", putMappingRequest.type())); - - Params parameters = new Params(request); - parameters.withTimeout(putMappingRequest.timeout()); - parameters.withMasterTimeout(putMappingRequest.masterNodeTimeout()); - - request.setEntity(createEntity(putMappingRequest, REQUEST_BODY_CONTENT_TYPE)); - return request; - } - - static Request getMappings(GetMappingsRequest getMappingsRequest) throws IOException { - String[] indices = getMappingsRequest.indices() == null ? Strings.EMPTY_ARRAY : getMappingsRequest.indices(); - String[] types = getMappingsRequest.types() == null ? Strings.EMPTY_ARRAY : getMappingsRequest.types(); - - Request request = new Request(HttpGet.METHOD_NAME, endpoint(indices, "_mapping", types)); - - Params parameters = new Params(request); - parameters.withMasterTimeout(getMappingsRequest.masterNodeTimeout()); - parameters.withIndicesOptions(getMappingsRequest.indicesOptions()); - parameters.withLocal(getMappingsRequest.local()); - return request; - } - - static Request getFieldMapping(GetFieldMappingsRequest getFieldMappingsRequest) throws IOException { - String[] indices = getFieldMappingsRequest.indices() == null ? Strings.EMPTY_ARRAY : getFieldMappingsRequest.indices(); - String[] types = getFieldMappingsRequest.types() == null ? Strings.EMPTY_ARRAY : getFieldMappingsRequest.types(); - String[] fields = getFieldMappingsRequest.fields() == null ? Strings.EMPTY_ARRAY : getFieldMappingsRequest.fields(); - - String endpoint = new EndpointBuilder().addCommaSeparatedPathParts(indices) - .addPathPartAsIs("_mapping").addCommaSeparatedPathParts(types) - .addPathPartAsIs("field").addCommaSeparatedPathParts(fields) - .build(); - - Request request = new Request(HttpGet.METHOD_NAME, endpoint); - - Params parameters = new Params(request); - parameters.withIndicesOptions(getFieldMappingsRequest.indicesOptions()); - parameters.withIncludeDefaults(getFieldMappingsRequest.includeDefaults()); - parameters.withLocal(getFieldMappingsRequest.local()); - return request; - } - - static Request refresh(RefreshRequest refreshRequest) { - String[] indices = refreshRequest.indices() == null ? Strings.EMPTY_ARRAY : refreshRequest.indices(); - Request request = new Request(HttpPost.METHOD_NAME, endpoint(indices, "_refresh")); - - Params parameters = new Params(request); - parameters.withIndicesOptions(refreshRequest.indicesOptions()); - return request; - } - - static Request flush(FlushRequest flushRequest) { - String[] indices = flushRequest.indices() == null ? Strings.EMPTY_ARRAY : flushRequest.indices(); - Request request = new Request(HttpPost.METHOD_NAME, endpoint(indices, "_flush")); - - Params parameters = new Params(request); - parameters.withIndicesOptions(flushRequest.indicesOptions()); - parameters.putParam("wait_if_ongoing", Boolean.toString(flushRequest.waitIfOngoing())); - parameters.putParam("force", Boolean.toString(flushRequest.force())); - return request; - } - - static Request flushSynced(SyncedFlushRequest syncedFlushRequest) { - String[] indices = syncedFlushRequest.indices() == null ? Strings.EMPTY_ARRAY : syncedFlushRequest.indices(); - Request request = new Request(HttpPost.METHOD_NAME, endpoint(indices, "_flush/synced")); - Params parameters = new Params(request); - parameters.withIndicesOptions(syncedFlushRequest.indicesOptions()); - return request; - } - - static Request forceMerge(ForceMergeRequest forceMergeRequest) { - String[] indices = forceMergeRequest.indices() == null ? Strings.EMPTY_ARRAY : forceMergeRequest.indices(); - Request request = new Request(HttpPost.METHOD_NAME, endpoint(indices, "_forcemerge")); - - Params parameters = new Params(request); - parameters.withIndicesOptions(forceMergeRequest.indicesOptions()); - parameters.putParam("max_num_segments", Integer.toString(forceMergeRequest.maxNumSegments())); - parameters.putParam("only_expunge_deletes", Boolean.toString(forceMergeRequest.onlyExpungeDeletes())); - parameters.putParam("flush", Boolean.toString(forceMergeRequest.flush())); - return request; - } - - static Request clearCache(ClearIndicesCacheRequest clearIndicesCacheRequest) { - String[] indices = clearIndicesCacheRequest.indices() == null ? Strings.EMPTY_ARRAY :clearIndicesCacheRequest.indices(); - Request request = new Request(HttpPost.METHOD_NAME, endpoint(indices, "_cache/clear")); - - Params parameters = new Params(request); - parameters.withIndicesOptions(clearIndicesCacheRequest.indicesOptions()); - parameters.putParam("query", Boolean.toString(clearIndicesCacheRequest.queryCache())); - parameters.putParam("fielddata", Boolean.toString(clearIndicesCacheRequest.fieldDataCache())); - parameters.putParam("request", Boolean.toString(clearIndicesCacheRequest.requestCache())); - parameters.putParam("fields", String.join(",", clearIndicesCacheRequest.fields())); - return request; - } - static Request info() { return new Request(HttpGet.METHOD_NAME, "/"); } @@ -609,22 +427,6 @@ final class RequestConverters { return request; } - static Request existsAlias(GetAliasesRequest getAliasesRequest) { - if ((getAliasesRequest.indices() == null || getAliasesRequest.indices().length == 0) && - (getAliasesRequest.aliases() == null || getAliasesRequest.aliases().length == 0)) { - throw new IllegalArgumentException("existsAlias requires at least an alias or an index"); - } - String[] indices = getAliasesRequest.indices() == null ? Strings.EMPTY_ARRAY : getAliasesRequest.indices(); - String[] aliases = getAliasesRequest.aliases() == null ? Strings.EMPTY_ARRAY : getAliasesRequest.aliases(); - - Request request = new Request(HttpHead.METHOD_NAME, endpoint(indices, "_alias", aliases)); - - Params params = new Params(request); - params.withIndicesOptions(getAliasesRequest.indicesOptions()); - params.withLocal(getAliasesRequest.local()); - return request; - } - static Request explain(ExplainRequest explainRequest) throws IOException { Request request = new Request(HttpGet.METHOD_NAME, endpoint(explainRequest.index(), explainRequest.type(), explainRequest.id(), "_explain")); @@ -657,35 +459,6 @@ final class RequestConverters { return request; } - static Request split(ResizeRequest resizeRequest) throws IOException { - if (resizeRequest.getResizeType() != ResizeType.SPLIT) { - throw new IllegalArgumentException("Wrong resize type [" + resizeRequest.getResizeType() + "] for indices split request"); - } - return resize(resizeRequest); - } - - static Request shrink(ResizeRequest resizeRequest) throws IOException { - if (resizeRequest.getResizeType() != ResizeType.SHRINK) { - throw new IllegalArgumentException("Wrong resize type [" + resizeRequest.getResizeType() + "] for indices shrink request"); - } - return resize(resizeRequest); - } - - private static Request resize(ResizeRequest resizeRequest) throws IOException { - String endpoint = new EndpointBuilder().addPathPart(resizeRequest.getSourceIndex()) - .addPathPartAsIs("_" + resizeRequest.getResizeType().name().toLowerCase(Locale.ROOT)) - .addPathPart(resizeRequest.getTargetIndexRequest().index()).build(); - Request request = new Request(HttpPut.METHOD_NAME, endpoint); - - Params params = new Params(request); - params.withTimeout(resizeRequest.timeout()); - params.withMasterTimeout(resizeRequest.masterNodeTimeout()); - params.withWaitForActiveShards(resizeRequest.getTargetIndexRequest().waitForActiveShards()); - - request.setEntity(createEntity(resizeRequest, REQUEST_BODY_CONTENT_TYPE)); - return request; - } - static Request reindex(ReindexRequest reindexRequest) throws IOException { String endpoint = new EndpointBuilder().addPathPart("_reindex").build(); Request request = new Request(HttpPost.METHOD_NAME, endpoint); @@ -754,135 +527,6 @@ final class RequestConverters { return request; } - static Request rollover(RolloverRequest rolloverRequest) throws IOException { - String endpoint = new EndpointBuilder().addPathPart(rolloverRequest.getAlias()).addPathPartAsIs("_rollover") - .addPathPart(rolloverRequest.getNewIndexName()).build(); - Request request = new Request(HttpPost.METHOD_NAME, endpoint); - - Params params = new Params(request); - params.withTimeout(rolloverRequest.timeout()); - params.withMasterTimeout(rolloverRequest.masterNodeTimeout()); - params.withWaitForActiveShards(rolloverRequest.getCreateIndexRequest().waitForActiveShards()); - if (rolloverRequest.isDryRun()) { - params.putParam("dry_run", Boolean.TRUE.toString()); - } - - request.setEntity(createEntity(rolloverRequest, REQUEST_BODY_CONTENT_TYPE)); - return request; - } - - static Request getSettings(GetSettingsRequest getSettingsRequest) { - String[] indices = getSettingsRequest.indices() == null ? Strings.EMPTY_ARRAY : getSettingsRequest.indices(); - String[] names = getSettingsRequest.names() == null ? Strings.EMPTY_ARRAY : getSettingsRequest.names(); - - String endpoint = endpoint(indices, "_settings", names); - Request request = new Request(HttpGet.METHOD_NAME, endpoint); - - Params params = new Params(request); - params.withIndicesOptions(getSettingsRequest.indicesOptions()); - params.withLocal(getSettingsRequest.local()); - params.withIncludeDefaults(getSettingsRequest.includeDefaults()); - params.withMasterTimeout(getSettingsRequest.masterNodeTimeout()); - - return request; - } - - static Request getIndex(GetIndexRequest getIndexRequest) { - String[] indices = getIndexRequest.indices() == null ? Strings.EMPTY_ARRAY : getIndexRequest.indices(); - - String endpoint = endpoint(indices); - Request request = new Request(HttpGet.METHOD_NAME, endpoint); - - Params params = new Params(request); - params.withIndicesOptions(getIndexRequest.indicesOptions()); - params.withLocal(getIndexRequest.local()); - params.withIncludeDefaults(getIndexRequest.includeDefaults()); - params.withHuman(getIndexRequest.humanReadable()); - params.withMasterTimeout(getIndexRequest.masterNodeTimeout()); - - return request; - } - - static Request indicesExist(GetIndexRequest getIndexRequest) { - // this can be called with no indices as argument by transport client, not via REST though - if (getIndexRequest.indices() == null || getIndexRequest.indices().length == 0) { - throw new IllegalArgumentException("indices are mandatory"); - } - String endpoint = endpoint(getIndexRequest.indices(), ""); - Request request = new Request(HttpHead.METHOD_NAME, endpoint); - - Params params = new Params(request); - params.withLocal(getIndexRequest.local()); - params.withHuman(getIndexRequest.humanReadable()); - params.withIndicesOptions(getIndexRequest.indicesOptions()); - params.withIncludeDefaults(getIndexRequest.includeDefaults()); - return request; - } - - static Request indexPutSettings(UpdateSettingsRequest updateSettingsRequest) throws IOException { - String[] indices = updateSettingsRequest.indices() == null ? Strings.EMPTY_ARRAY : updateSettingsRequest.indices(); - Request request = new Request(HttpPut.METHOD_NAME, endpoint(indices, "_settings")); - - Params parameters = new Params(request); - parameters.withTimeout(updateSettingsRequest.timeout()); - parameters.withMasterTimeout(updateSettingsRequest.masterNodeTimeout()); - parameters.withIndicesOptions(updateSettingsRequest.indicesOptions()); - parameters.withPreserveExisting(updateSettingsRequest.isPreserveExisting()); - - request.setEntity(createEntity(updateSettingsRequest, REQUEST_BODY_CONTENT_TYPE)); - return request; - } - - static Request putTemplate(PutIndexTemplateRequest putIndexTemplateRequest) throws IOException { - String endpoint = new EndpointBuilder().addPathPartAsIs("_template").addPathPart(putIndexTemplateRequest.name()).build(); - Request request = new Request(HttpPut.METHOD_NAME, endpoint); - Params params = new Params(request); - params.withMasterTimeout(putIndexTemplateRequest.masterNodeTimeout()); - if (putIndexTemplateRequest.create()) { - params.putParam("create", Boolean.TRUE.toString()); - } - if (Strings.hasText(putIndexTemplateRequest.cause())) { - params.putParam("cause", putIndexTemplateRequest.cause()); - } - request.setEntity(createEntity(putIndexTemplateRequest, REQUEST_BODY_CONTENT_TYPE)); - return request; - } - - static Request validateQuery(ValidateQueryRequest validateQueryRequest) throws IOException { - String[] indices = validateQueryRequest.indices() == null ? Strings.EMPTY_ARRAY : validateQueryRequest.indices(); - String[] types = validateQueryRequest.types() == null || indices.length <= 0 ? Strings.EMPTY_ARRAY : validateQueryRequest.types(); - String endpoint = endpoint(indices, types, "_validate/query"); - Request request = new Request(HttpGet.METHOD_NAME, endpoint); - Params params = new Params(request); - params.withIndicesOptions(validateQueryRequest.indicesOptions()); - params.putParam("explain", Boolean.toString(validateQueryRequest.explain())); - params.putParam("all_shards", Boolean.toString(validateQueryRequest.allShards())); - params.putParam("rewrite", Boolean.toString(validateQueryRequest.rewrite())); - request.setEntity(createEntity(validateQueryRequest, REQUEST_BODY_CONTENT_TYPE)); - return request; - } - - static Request getAlias(GetAliasesRequest getAliasesRequest) { - String[] indices = getAliasesRequest.indices() == null ? Strings.EMPTY_ARRAY : getAliasesRequest.indices(); - String[] aliases = getAliasesRequest.aliases() == null ? Strings.EMPTY_ARRAY : getAliasesRequest.aliases(); - String endpoint = endpoint(indices, "_alias", aliases); - Request request = new Request(HttpGet.METHOD_NAME, endpoint); - Params params = new Params(request); - params.withIndicesOptions(getAliasesRequest.indicesOptions()); - params.withLocal(getAliasesRequest.local()); - return request; - } - - static Request getTemplates(GetIndexTemplatesRequest getIndexTemplatesRequest) throws IOException { - String[] names = getIndexTemplatesRequest.names(); - String endpoint = new EndpointBuilder().addPathPartAsIs("_template").addCommaSeparatedPathParts(names).build(); - Request request = new Request(HttpGet.METHOD_NAME, endpoint); - Params params = new Params(request); - params.withLocal(getIndexTemplatesRequest.local()); - params.withMasterTimeout(getIndexTemplatesRequest.masterNodeTimeout()); - return request; - } - static Request putScript(PutStoredScriptRequest putStoredScriptRequest) throws IOException { String endpoint = new EndpointBuilder().addPathPartAsIs("_scripts").addPathPart(putStoredScriptRequest.id()).build(); Request request = new Request(HttpPost.METHOD_NAME, endpoint); diff --git a/client/rest-high-level/src/test/java/org/elasticsearch/client/IndicesRequestConvertersTests.java b/client/rest-high-level/src/test/java/org/elasticsearch/client/IndicesRequestConvertersTests.java new file mode 100644 index 00000000000..e9704105499 --- /dev/null +++ b/client/rest-high-level/src/test/java/org/elasticsearch/client/IndicesRequestConvertersTests.java @@ -0,0 +1,893 @@ +/* + * Licensed to Elasticsearch under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch licenses this file to you under + * the Apache License, Version 2.0 (the "License"); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.elasticsearch.client; + +import org.apache.http.client.methods.HttpDelete; +import org.apache.http.client.methods.HttpGet; +import org.apache.http.client.methods.HttpHead; +import org.apache.http.client.methods.HttpPost; +import org.apache.http.client.methods.HttpPut; +import org.apache.lucene.util.LuceneTestCase; +import org.elasticsearch.action.ActionRequestValidationException; +import org.elasticsearch.action.admin.indices.alias.Alias; +import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest; +import org.elasticsearch.action.admin.indices.alias.get.GetAliasesRequest; +import org.elasticsearch.action.admin.indices.analyze.AnalyzeRequest; +import org.elasticsearch.action.admin.indices.cache.clear.ClearIndicesCacheRequest; +import org.elasticsearch.action.admin.indices.close.CloseIndexRequest; +import org.elasticsearch.action.admin.indices.create.CreateIndexRequest; +import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest; +import org.elasticsearch.action.admin.indices.flush.FlushRequest; +import org.elasticsearch.action.admin.indices.flush.SyncedFlushRequest; +import org.elasticsearch.action.admin.indices.forcemerge.ForceMergeRequest; +import org.elasticsearch.action.admin.indices.get.GetIndexRequest; +import org.elasticsearch.action.admin.indices.mapping.get.GetFieldMappingsRequest; +import org.elasticsearch.action.admin.indices.mapping.get.GetMappingsRequest; +import org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequest; +import org.elasticsearch.action.admin.indices.open.OpenIndexRequest; +import org.elasticsearch.action.admin.indices.refresh.RefreshRequest; +import org.elasticsearch.action.admin.indices.rollover.RolloverRequest; +import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest; +import org.elasticsearch.action.admin.indices.settings.put.UpdateSettingsRequest; +import org.elasticsearch.action.admin.indices.shrink.ResizeRequest; +import org.elasticsearch.action.admin.indices.shrink.ResizeType; +import org.elasticsearch.action.admin.indices.template.get.GetIndexTemplatesRequest; +import org.elasticsearch.action.admin.indices.template.put.PutIndexTemplateRequest; +import org.elasticsearch.action.admin.indices.validate.query.ValidateQueryRequest; +import org.elasticsearch.action.support.master.AcknowledgedRequest; +import org.elasticsearch.common.CheckedFunction; +import org.elasticsearch.common.Strings; +import org.elasticsearch.common.settings.Settings; +import org.elasticsearch.common.unit.TimeValue; +import org.elasticsearch.common.util.CollectionUtils; +import org.elasticsearch.index.RandomCreateIndexGenerator; +import org.elasticsearch.test.ESTestCase; +import org.junit.Assert; + +import java.io.IOException; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.StringJoiner; +import java.util.stream.Collectors; + +import static org.elasticsearch.index.RandomCreateIndexGenerator.randomAliases; +import static org.elasticsearch.index.RandomCreateIndexGenerator.randomCreateIndexRequest; +import static org.elasticsearch.index.RandomCreateIndexGenerator.randomIndexSettings; +import static org.elasticsearch.index.alias.RandomAliasActionsGenerator.randomAliasAction; +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.Matchers.nullValue; + +public class IndicesRequestConvertersTests extends ESTestCase { + + public void testAnalyzeRequest() throws Exception { + AnalyzeRequest indexAnalyzeRequest = new AnalyzeRequest() + .text("Here is some text") + .index("test_index") + .analyzer("test_analyzer"); + + Request request = IndicesRequestConverters.analyze(indexAnalyzeRequest); + assertThat(request.getEndpoint(), equalTo("/test_index/_analyze")); + RequestConvertersTests.assertToXContentBody(indexAnalyzeRequest, request.getEntity()); + + AnalyzeRequest analyzeRequest = new AnalyzeRequest() + .text("more text") + .analyzer("test_analyzer"); + assertThat(IndicesRequestConverters.analyze(analyzeRequest).getEndpoint(), equalTo("/_analyze")); + } + + public void testIndicesExist() { + String[] indices = RequestConvertersTests.randomIndicesNames(1, 10); + + GetIndexRequest getIndexRequest = new GetIndexRequest().indices(indices); + + Map expectedParams = new HashMap<>(); + RequestConvertersTests.setRandomIndicesOptions(getIndexRequest::indicesOptions, getIndexRequest::indicesOptions, expectedParams); + RequestConvertersTests.setRandomLocal(getIndexRequest, expectedParams); + RequestConvertersTests.setRandomHumanReadable(getIndexRequest, expectedParams); + RequestConvertersTests.setRandomIncludeDefaults(getIndexRequest, expectedParams); + + final Request request = IndicesRequestConverters.indicesExist(getIndexRequest); + + Assert.assertEquals(HttpHead.METHOD_NAME, request.getMethod()); + Assert.assertEquals("/" + String.join(",", indices), request.getEndpoint()); + Assert.assertThat(expectedParams, equalTo(request.getParameters())); + Assert.assertNull(request.getEntity()); + } + + public void testIndicesExistEmptyIndices() { + LuceneTestCase.expectThrows(IllegalArgumentException.class, () + -> IndicesRequestConverters.indicesExist(new GetIndexRequest())); + LuceneTestCase.expectThrows(IllegalArgumentException.class, () + -> IndicesRequestConverters.indicesExist(new GetIndexRequest().indices((String[]) null))); + } + + public void testCreateIndex() throws IOException { + CreateIndexRequest createIndexRequest = randomCreateIndexRequest(); + + Map expectedParams = new HashMap<>(); + RequestConvertersTests.setRandomTimeout(createIndexRequest::timeout, AcknowledgedRequest.DEFAULT_ACK_TIMEOUT, expectedParams); + RequestConvertersTests.setRandomMasterTimeout(createIndexRequest, expectedParams); + RequestConvertersTests.setRandomWaitForActiveShards(createIndexRequest::waitForActiveShards, expectedParams); + + Request request = IndicesRequestConverters.createIndex(createIndexRequest); + Assert.assertEquals("/" + createIndexRequest.index(), request.getEndpoint()); + Assert.assertEquals(expectedParams, request.getParameters()); + Assert.assertEquals(HttpPut.METHOD_NAME, request.getMethod()); + RequestConvertersTests.assertToXContentBody(createIndexRequest, request.getEntity()); + } + + public void testCreateIndexNullIndex() { + ActionRequestValidationException validationException = new CreateIndexRequest(null).validate(); + Assert.assertNotNull(validationException); + } + + public void testUpdateAliases() throws IOException { + IndicesAliasesRequest indicesAliasesRequest = new IndicesAliasesRequest(); + IndicesAliasesRequest.AliasActions aliasAction = randomAliasAction(); + indicesAliasesRequest.addAliasAction(aliasAction); + + Map expectedParams = new HashMap<>(); + RequestConvertersTests.setRandomTimeout(indicesAliasesRequest::timeout, AcknowledgedRequest.DEFAULT_ACK_TIMEOUT, expectedParams); + RequestConvertersTests.setRandomMasterTimeout(indicesAliasesRequest, expectedParams); + + Request request = IndicesRequestConverters.updateAliases(indicesAliasesRequest); + Assert.assertEquals("/_aliases", request.getEndpoint()); + Assert.assertEquals(expectedParams, request.getParameters()); + RequestConvertersTests.assertToXContentBody(indicesAliasesRequest, request.getEntity()); + } + + public void testPutMapping() throws IOException { + PutMappingRequest putMappingRequest = new PutMappingRequest(); + + String[] indices = RequestConvertersTests.randomIndicesNames(0, 5); + putMappingRequest.indices(indices); + + String type = ESTestCase.randomAlphaOfLengthBetween(3, 10); + putMappingRequest.type(type); + + Map expectedParams = new HashMap<>(); + + RequestConvertersTests.setRandomTimeout(putMappingRequest::timeout, AcknowledgedRequest.DEFAULT_ACK_TIMEOUT, expectedParams); + RequestConvertersTests.setRandomMasterTimeout(putMappingRequest, expectedParams); + + Request request = IndicesRequestConverters.putMapping(putMappingRequest); + StringJoiner endpoint = new StringJoiner("/", "/", ""); + String index = String.join(",", indices); + if (Strings.hasLength(index)) { + endpoint.add(index); + } + endpoint.add("_mapping"); + endpoint.add(type); + Assert.assertEquals(endpoint.toString(), request.getEndpoint()); + + Assert.assertEquals(expectedParams, request.getParameters()); + Assert.assertEquals(HttpPut.METHOD_NAME, request.getMethod()); + RequestConvertersTests.assertToXContentBody(putMappingRequest, request.getEntity()); + } + + public void testGetMapping() throws IOException { + GetMappingsRequest getMappingRequest = new GetMappingsRequest(); + + String[] indices = Strings.EMPTY_ARRAY; + if (ESTestCase.randomBoolean()) { + indices = RequestConvertersTests.randomIndicesNames(0, 5); + getMappingRequest.indices(indices); + } else if (ESTestCase.randomBoolean()) { + getMappingRequest.indices((String[]) null); + } + + String type = null; + if (ESTestCase.randomBoolean()) { + type = ESTestCase.randomAlphaOfLengthBetween(3, 10); + getMappingRequest.types(type); + } else if (ESTestCase.randomBoolean()) { + getMappingRequest.types((String[]) null); + } + + Map expectedParams = new HashMap<>(); + + RequestConvertersTests.setRandomIndicesOptions(getMappingRequest::indicesOptions, + getMappingRequest::indicesOptions, expectedParams); + RequestConvertersTests.setRandomMasterTimeout(getMappingRequest, expectedParams); + RequestConvertersTests.setRandomLocal(getMappingRequest, expectedParams); + + Request request = IndicesRequestConverters.getMappings(getMappingRequest); + StringJoiner endpoint = new StringJoiner("/", "/", ""); + String index = String.join(",", indices); + if (Strings.hasLength(index)) { + endpoint.add(index); + } + endpoint.add("_mapping"); + if (type != null) { + endpoint.add(type); + } + Assert.assertThat(endpoint.toString(), equalTo(request.getEndpoint())); + + Assert.assertThat(expectedParams, equalTo(request.getParameters())); + Assert.assertThat(HttpGet.METHOD_NAME, equalTo(request.getMethod())); + } + + public void testGetFieldMapping() throws IOException { + GetFieldMappingsRequest getFieldMappingsRequest = new GetFieldMappingsRequest(); + + String[] indices = Strings.EMPTY_ARRAY; + if (ESTestCase.randomBoolean()) { + indices = RequestConvertersTests.randomIndicesNames(0, 5); + getFieldMappingsRequest.indices(indices); + } else if (ESTestCase.randomBoolean()) { + getFieldMappingsRequest.indices((String[]) null); + } + + String type = null; + if (ESTestCase.randomBoolean()) { + type = ESTestCase.randomAlphaOfLengthBetween(3, 10); + getFieldMappingsRequest.types(type); + } else if (ESTestCase.randomBoolean()) { + getFieldMappingsRequest.types((String[]) null); + } + + String[] fields = null; + if (ESTestCase.randomBoolean()) { + fields = new String[ESTestCase.randomIntBetween(1, 5)]; + for (int i = 0; i < fields.length; i++) { + fields[i] = ESTestCase.randomAlphaOfLengthBetween(3, 10); + } + getFieldMappingsRequest.fields(fields); + } else if (ESTestCase.randomBoolean()) { + getFieldMappingsRequest.fields((String[]) null); + } + + Map expectedParams = new HashMap<>(); + + RequestConvertersTests.setRandomIndicesOptions(getFieldMappingsRequest::indicesOptions, getFieldMappingsRequest::indicesOptions, + expectedParams); + RequestConvertersTests.setRandomLocal(getFieldMappingsRequest::local, expectedParams); + + Request request = IndicesRequestConverters.getFieldMapping(getFieldMappingsRequest); + StringJoiner endpoint = new StringJoiner("/", "/", ""); + String index = String.join(",", indices); + if (Strings.hasLength(index)) { + endpoint.add(index); + } + endpoint.add("_mapping"); + if (type != null) { + endpoint.add(type); + } + endpoint.add("field"); + if (fields != null) { + endpoint.add(String.join(",", fields)); + } + Assert.assertThat(endpoint.toString(), equalTo(request.getEndpoint())); + + Assert.assertThat(expectedParams, equalTo(request.getParameters())); + Assert.assertThat(HttpGet.METHOD_NAME, equalTo(request.getMethod())); + } + + public void testDeleteIndex() { + String[] indices = RequestConvertersTests.randomIndicesNames(0, 5); + DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest(indices); + + Map expectedParams = new HashMap<>(); + RequestConvertersTests.setRandomTimeout(deleteIndexRequest::timeout, AcknowledgedRequest.DEFAULT_ACK_TIMEOUT, expectedParams); + RequestConvertersTests.setRandomMasterTimeout(deleteIndexRequest, expectedParams); + + RequestConvertersTests.setRandomIndicesOptions(deleteIndexRequest::indicesOptions, deleteIndexRequest::indicesOptions, + expectedParams); + + Request request = IndicesRequestConverters.deleteIndex(deleteIndexRequest); + Assert.assertEquals("/" + String.join(",", indices), request.getEndpoint()); + Assert.assertEquals(expectedParams, request.getParameters()); + Assert.assertEquals(HttpDelete.METHOD_NAME, request.getMethod()); + Assert.assertNull(request.getEntity()); + } + + public void testGetSettings() throws IOException { + String[] indicesUnderTest = ESTestCase.randomBoolean() ? null : RequestConvertersTests.randomIndicesNames(0, 5); + + GetSettingsRequest getSettingsRequest = new GetSettingsRequest().indices(indicesUnderTest); + + Map expectedParams = new HashMap<>(); + RequestConvertersTests.setRandomMasterTimeout(getSettingsRequest, expectedParams); + RequestConvertersTests.setRandomIndicesOptions(getSettingsRequest::indicesOptions, getSettingsRequest::indicesOptions, + expectedParams); + + RequestConvertersTests.setRandomLocal(getSettingsRequest, expectedParams); + + if (ESTestCase.randomBoolean()) { + // the request object will not have include_defaults present unless it is set to + // true + getSettingsRequest.includeDefaults(ESTestCase.randomBoolean()); + if (getSettingsRequest.includeDefaults()) { + expectedParams.put("include_defaults", Boolean.toString(true)); + } + } + + StringJoiner endpoint = new StringJoiner("/", "/", ""); + if (indicesUnderTest != null && indicesUnderTest.length > 0) { + endpoint.add(String.join(",", indicesUnderTest)); + } + endpoint.add("_settings"); + + if (ESTestCase.randomBoolean()) { + String[] names = ESTestCase.randomBoolean() ? null : new String[ESTestCase.randomIntBetween(0, 3)]; + if (names != null) { + for (int x = 0; x < names.length; x++) { + names[x] = ESTestCase.randomAlphaOfLengthBetween(3, 10); + } + } + getSettingsRequest.names(names); + if (names != null && names.length > 0) { + endpoint.add(String.join(",", names)); + } + } + + Request request = IndicesRequestConverters.getSettings(getSettingsRequest); + + Assert.assertThat(endpoint.toString(), equalTo(request.getEndpoint())); + Assert.assertThat(request.getParameters(), equalTo(expectedParams)); + Assert.assertThat(request.getMethod(), equalTo(HttpGet.METHOD_NAME)); + Assert.assertThat(request.getEntity(), nullValue()); + } + + public void testGetIndex() throws IOException { + String[] indicesUnderTest = ESTestCase.randomBoolean() ? null : RequestConvertersTests.randomIndicesNames(0, 5); + + GetIndexRequest getIndexRequest = new GetIndexRequest().indices(indicesUnderTest); + + Map expectedParams = new HashMap<>(); + RequestConvertersTests.setRandomMasterTimeout(getIndexRequest, expectedParams); + RequestConvertersTests.setRandomIndicesOptions(getIndexRequest::indicesOptions, getIndexRequest::indicesOptions, expectedParams); + RequestConvertersTests.setRandomLocal(getIndexRequest, expectedParams); + RequestConvertersTests.setRandomHumanReadable(getIndexRequest, expectedParams); + + if (ESTestCase.randomBoolean()) { + // the request object will not have include_defaults present unless it is set to + // true + getIndexRequest.includeDefaults(ESTestCase.randomBoolean()); + if (getIndexRequest.includeDefaults()) { + expectedParams.put("include_defaults", Boolean.toString(true)); + } + } + + StringJoiner endpoint = new StringJoiner("/", "/", ""); + if (indicesUnderTest != null && indicesUnderTest.length > 0) { + endpoint.add(String.join(",", indicesUnderTest)); + } + + Request request = IndicesRequestConverters.getIndex(getIndexRequest); + + Assert.assertThat(endpoint.toString(), equalTo(request.getEndpoint())); + Assert.assertThat(request.getParameters(), equalTo(expectedParams)); + Assert.assertThat(request.getMethod(), equalTo(HttpGet.METHOD_NAME)); + Assert.assertThat(request.getEntity(), nullValue()); + } + + public void testDeleteIndexEmptyIndices() { + String[] indices = ESTestCase.randomBoolean() ? null : Strings.EMPTY_ARRAY; + ActionRequestValidationException validationException = new DeleteIndexRequest(indices).validate(); + Assert.assertNotNull(validationException); + } + + public void testOpenIndex() { + String[] indices = RequestConvertersTests.randomIndicesNames(1, 5); + OpenIndexRequest openIndexRequest = new OpenIndexRequest(indices); + openIndexRequest.indices(indices); + + Map expectedParams = new HashMap<>(); + RequestConvertersTests.setRandomTimeout(openIndexRequest::timeout, AcknowledgedRequest.DEFAULT_ACK_TIMEOUT, expectedParams); + RequestConvertersTests.setRandomMasterTimeout(openIndexRequest, expectedParams); + RequestConvertersTests.setRandomIndicesOptions(openIndexRequest::indicesOptions, openIndexRequest::indicesOptions, expectedParams); + RequestConvertersTests.setRandomWaitForActiveShards(openIndexRequest::waitForActiveShards, expectedParams); + + Request request = IndicesRequestConverters.openIndex(openIndexRequest); + StringJoiner endpoint = new StringJoiner("/", "/", "").add(String.join(",", indices)).add("_open"); + Assert.assertThat(endpoint.toString(), equalTo(request.getEndpoint())); + Assert.assertThat(expectedParams, equalTo(request.getParameters())); + Assert.assertThat(request.getMethod(), equalTo(HttpPost.METHOD_NAME)); + Assert.assertThat(request.getEntity(), nullValue()); + } + + public void testOpenIndexEmptyIndices() { + String[] indices = ESTestCase.randomBoolean() ? null : Strings.EMPTY_ARRAY; + ActionRequestValidationException validationException = new OpenIndexRequest(indices).validate(); + Assert.assertNotNull(validationException); + } + + public void testCloseIndex() { + String[] indices = RequestConvertersTests.randomIndicesNames(1, 5); + CloseIndexRequest closeIndexRequest = new CloseIndexRequest(indices); + + Map expectedParams = new HashMap<>(); + RequestConvertersTests.setRandomTimeout(closeIndexRequest::timeout, AcknowledgedRequest.DEFAULT_ACK_TIMEOUT, expectedParams); + RequestConvertersTests.setRandomMasterTimeout(closeIndexRequest, expectedParams); + RequestConvertersTests.setRandomIndicesOptions(closeIndexRequest::indicesOptions, closeIndexRequest::indicesOptions, + expectedParams); + + Request request = IndicesRequestConverters.closeIndex(closeIndexRequest); + StringJoiner endpoint = new StringJoiner("/", "/", "").add(String.join(",", indices)).add("_close"); + Assert.assertThat(endpoint.toString(), equalTo(request.getEndpoint())); + Assert.assertThat(expectedParams, equalTo(request.getParameters())); + Assert.assertThat(request.getMethod(), equalTo(HttpPost.METHOD_NAME)); + Assert.assertThat(request.getEntity(), nullValue()); + } + + public void testCloseIndexEmptyIndices() { + String[] indices = ESTestCase.randomBoolean() ? null : Strings.EMPTY_ARRAY; + ActionRequestValidationException validationException = new CloseIndexRequest(indices).validate(); + Assert.assertNotNull(validationException); + } + + public void testRefresh() { + String[] indices = ESTestCase.randomBoolean() ? null : RequestConvertersTests.randomIndicesNames(0, 5); + RefreshRequest refreshRequest; + if (ESTestCase.randomBoolean()) { + refreshRequest = new RefreshRequest(indices); + } else { + refreshRequest = new RefreshRequest(); + refreshRequest.indices(indices); + } + Map expectedParams = new HashMap<>(); + RequestConvertersTests.setRandomIndicesOptions(refreshRequest::indicesOptions, refreshRequest::indicesOptions, expectedParams); + Request request = IndicesRequestConverters.refresh(refreshRequest); + StringJoiner endpoint = new StringJoiner("/", "/", ""); + if (indices != null && indices.length > 0) { + endpoint.add(String.join(",", indices)); + } + endpoint.add("_refresh"); + Assert.assertThat(request.getEndpoint(), equalTo(endpoint.toString())); + Assert.assertThat(request.getParameters(), equalTo(expectedParams)); + Assert.assertThat(request.getEntity(), nullValue()); + Assert.assertThat(request.getMethod(), equalTo(HttpPost.METHOD_NAME)); + } + + public void testFlush() { + String[] indices = ESTestCase.randomBoolean() ? null : RequestConvertersTests.randomIndicesNames(0, 5); + FlushRequest flushRequest; + if (ESTestCase.randomBoolean()) { + flushRequest = new FlushRequest(indices); + } else { + flushRequest = new FlushRequest(); + flushRequest.indices(indices); + } + Map expectedParams = new HashMap<>(); + RequestConvertersTests.setRandomIndicesOptions(flushRequest::indicesOptions, flushRequest::indicesOptions, expectedParams); + if (ESTestCase.randomBoolean()) { + flushRequest.force(ESTestCase.randomBoolean()); + } + expectedParams.put("force", Boolean.toString(flushRequest.force())); + if (ESTestCase.randomBoolean()) { + flushRequest.waitIfOngoing(ESTestCase.randomBoolean()); + } + expectedParams.put("wait_if_ongoing", Boolean.toString(flushRequest.waitIfOngoing())); + + Request request = IndicesRequestConverters.flush(flushRequest); + StringJoiner endpoint = new StringJoiner("/", "/", ""); + if (indices != null && indices.length > 0) { + endpoint.add(String.join(",", indices)); + } + endpoint.add("_flush"); + Assert.assertThat(request.getEndpoint(), equalTo(endpoint.toString())); + Assert.assertThat(request.getParameters(), equalTo(expectedParams)); + Assert.assertThat(request.getEntity(), nullValue()); + Assert.assertThat(request.getMethod(), equalTo(HttpPost.METHOD_NAME)); + } + + public void testSyncedFlush() { + String[] indices = ESTestCase.randomBoolean() ? null : RequestConvertersTests.randomIndicesNames(0, 5); + SyncedFlushRequest syncedFlushRequest; + if (ESTestCase.randomBoolean()) { + syncedFlushRequest = new SyncedFlushRequest(indices); + } else { + syncedFlushRequest = new SyncedFlushRequest(); + syncedFlushRequest.indices(indices); + } + Map expectedParams = new HashMap<>(); + RequestConvertersTests.setRandomIndicesOptions(syncedFlushRequest::indicesOptions, syncedFlushRequest::indicesOptions, + expectedParams); + Request request = IndicesRequestConverters.flushSynced(syncedFlushRequest); + StringJoiner endpoint = new StringJoiner("/", "/", ""); + if (indices != null && indices.length > 0) { + endpoint.add(String.join(",", indices)); + } + endpoint.add("_flush/synced"); + Assert.assertThat(request.getEndpoint(), equalTo(endpoint.toString())); + Assert.assertThat(request.getParameters(), equalTo(expectedParams)); + Assert.assertThat(request.getEntity(), nullValue()); + Assert.assertThat(request.getMethod(), equalTo(HttpPost.METHOD_NAME)); + } + + public void testForceMerge() { + String[] indices = ESTestCase.randomBoolean() ? null : RequestConvertersTests.randomIndicesNames(0, 5); + ForceMergeRequest forceMergeRequest; + if (ESTestCase.randomBoolean()) { + forceMergeRequest = new ForceMergeRequest(indices); + } else { + forceMergeRequest = new ForceMergeRequest(); + forceMergeRequest.indices(indices); + } + + Map expectedParams = new HashMap<>(); + RequestConvertersTests.setRandomIndicesOptions(forceMergeRequest::indicesOptions, forceMergeRequest::indicesOptions, + expectedParams); + if (ESTestCase.randomBoolean()) { + forceMergeRequest.maxNumSegments(ESTestCase.randomInt()); + } + expectedParams.put("max_num_segments", Integer.toString(forceMergeRequest.maxNumSegments())); + if (ESTestCase.randomBoolean()) { + forceMergeRequest.onlyExpungeDeletes(ESTestCase.randomBoolean()); + } + expectedParams.put("only_expunge_deletes", Boolean.toString(forceMergeRequest.onlyExpungeDeletes())); + if (ESTestCase.randomBoolean()) { + forceMergeRequest.flush(ESTestCase.randomBoolean()); + } + expectedParams.put("flush", Boolean.toString(forceMergeRequest.flush())); + + Request request = IndicesRequestConverters.forceMerge(forceMergeRequest); + StringJoiner endpoint = new StringJoiner("/", "/", ""); + if (indices != null && indices.length > 0) { + endpoint.add(String.join(",", indices)); + } + endpoint.add("_forcemerge"); + Assert.assertThat(request.getEndpoint(), equalTo(endpoint.toString())); + Assert.assertThat(request.getParameters(), equalTo(expectedParams)); + Assert.assertThat(request.getEntity(), nullValue()); + Assert.assertThat(request.getMethod(), equalTo(HttpPost.METHOD_NAME)); + } + + public void testClearCache() { + String[] indices = ESTestCase.randomBoolean() ? null : RequestConvertersTests.randomIndicesNames(0, 5); + ClearIndicesCacheRequest clearIndicesCacheRequest; + if (ESTestCase.randomBoolean()) { + clearIndicesCacheRequest = new ClearIndicesCacheRequest(indices); + } else { + clearIndicesCacheRequest = new ClearIndicesCacheRequest(); + clearIndicesCacheRequest.indices(indices); + } + Map expectedParams = new HashMap<>(); + RequestConvertersTests.setRandomIndicesOptions(clearIndicesCacheRequest::indicesOptions, clearIndicesCacheRequest::indicesOptions, + expectedParams); + if (ESTestCase.randomBoolean()) { + clearIndicesCacheRequest.queryCache(ESTestCase.randomBoolean()); + } + expectedParams.put("query", Boolean.toString(clearIndicesCacheRequest.queryCache())); + if (ESTestCase.randomBoolean()) { + clearIndicesCacheRequest.fieldDataCache(ESTestCase.randomBoolean()); + } + expectedParams.put("fielddata", Boolean.toString(clearIndicesCacheRequest.fieldDataCache())); + if (ESTestCase.randomBoolean()) { + clearIndicesCacheRequest.requestCache(ESTestCase.randomBoolean()); + } + expectedParams.put("request", Boolean.toString(clearIndicesCacheRequest.requestCache())); + if (ESTestCase.randomBoolean()) { + clearIndicesCacheRequest.fields(RequestConvertersTests.randomIndicesNames(1, 5)); + expectedParams.put("fields", String.join(",", clearIndicesCacheRequest.fields())); + } + + Request request = IndicesRequestConverters.clearCache(clearIndicesCacheRequest); + StringJoiner endpoint = new StringJoiner("/", "/", ""); + if (indices != null && indices.length > 0) { + endpoint.add(String.join(",", indices)); + } + endpoint.add("_cache/clear"); + Assert.assertThat(request.getEndpoint(), equalTo(endpoint.toString())); + Assert.assertThat(request.getParameters(), equalTo(expectedParams)); + Assert.assertThat(request.getEntity(), nullValue()); + Assert.assertThat(request.getMethod(), equalTo(HttpPost.METHOD_NAME)); + } + + public void testExistsAlias() { + GetAliasesRequest getAliasesRequest = new GetAliasesRequest(); + String[] indices = ESTestCase.randomBoolean() ? null : RequestConvertersTests.randomIndicesNames(0, 5); + getAliasesRequest.indices(indices); + // the HEAD endpoint requires at least an alias or an index + boolean hasIndices = indices != null && indices.length > 0; + String[] aliases; + if (hasIndices) { + aliases = ESTestCase.randomBoolean() ? null : RequestConvertersTests.randomIndicesNames(0, 5); + } else { + aliases = RequestConvertersTests.randomIndicesNames(1, 5); + } + getAliasesRequest.aliases(aliases); + Map expectedParams = new HashMap<>(); + RequestConvertersTests.setRandomLocal(getAliasesRequest, expectedParams); + RequestConvertersTests.setRandomIndicesOptions(getAliasesRequest::indicesOptions, getAliasesRequest::indicesOptions, + expectedParams); + + Request request = IndicesRequestConverters.existsAlias(getAliasesRequest); + StringJoiner expectedEndpoint = new StringJoiner("/", "/", ""); + if (indices != null && indices.length > 0) { + expectedEndpoint.add(String.join(",", indices)); + } + expectedEndpoint.add("_alias"); + if (aliases != null && aliases.length > 0) { + expectedEndpoint.add(String.join(",", aliases)); + } + Assert.assertEquals(HttpHead.METHOD_NAME, request.getMethod()); + Assert.assertEquals(expectedEndpoint.toString(), request.getEndpoint()); + Assert.assertEquals(expectedParams, request.getParameters()); + Assert.assertNull(request.getEntity()); + } + + public void testExistsAliasNoAliasNoIndex() { + { + GetAliasesRequest getAliasesRequest = new GetAliasesRequest(); + IllegalArgumentException iae = LuceneTestCase.expectThrows(IllegalArgumentException.class, + () -> IndicesRequestConverters.existsAlias(getAliasesRequest)); + Assert.assertEquals("existsAlias requires at least an alias or an index", iae.getMessage()); + } + { + GetAliasesRequest getAliasesRequest = new GetAliasesRequest((String[]) null); + getAliasesRequest.indices((String[]) null); + IllegalArgumentException iae = LuceneTestCase.expectThrows(IllegalArgumentException.class, + () -> IndicesRequestConverters.existsAlias(getAliasesRequest)); + Assert.assertEquals("existsAlias requires at least an alias or an index", iae.getMessage()); + } + } + + public void testSplit() throws IOException { + resizeTest(ResizeType.SPLIT, IndicesRequestConverters::split); + } + + public void testSplitWrongResizeType() { + ResizeRequest resizeRequest = new ResizeRequest("target", "source"); + resizeRequest.setResizeType(ResizeType.SHRINK); + IllegalArgumentException iae = LuceneTestCase.expectThrows(IllegalArgumentException.class, () + -> IndicesRequestConverters.split(resizeRequest)); + Assert.assertEquals("Wrong resize type [SHRINK] for indices split request", iae.getMessage()); + } + + public void testShrinkWrongResizeType() { + ResizeRequest resizeRequest = new ResizeRequest("target", "source"); + resizeRequest.setResizeType(ResizeType.SPLIT); + IllegalArgumentException iae = LuceneTestCase.expectThrows(IllegalArgumentException.class, () + -> IndicesRequestConverters.shrink(resizeRequest)); + Assert.assertEquals("Wrong resize type [SPLIT] for indices shrink request", iae.getMessage()); + } + + public void testShrink() throws IOException { + resizeTest(ResizeType.SHRINK, IndicesRequestConverters::shrink); + } + + private void resizeTest(ResizeType resizeType, CheckedFunction function) + throws IOException { + String[] indices = RequestConvertersTests.randomIndicesNames(2, 2); + ResizeRequest resizeRequest = new ResizeRequest(indices[0], indices[1]); + resizeRequest.setResizeType(resizeType); + Map expectedParams = new HashMap<>(); + RequestConvertersTests.setRandomMasterTimeout(resizeRequest, expectedParams); + RequestConvertersTests.setRandomTimeout(resizeRequest::timeout, resizeRequest.timeout(), expectedParams); + + if (ESTestCase.randomBoolean()) { + CreateIndexRequest createIndexRequest = new CreateIndexRequest(ESTestCase.randomAlphaOfLengthBetween(3, 10)); + if (ESTestCase.randomBoolean()) { + createIndexRequest.settings(randomIndexSettings()); + } + if (ESTestCase.randomBoolean()) { + randomAliases(createIndexRequest); + } + resizeRequest.setTargetIndex(createIndexRequest); + } + RequestConvertersTests.setRandomWaitForActiveShards(resizeRequest::setWaitForActiveShards, expectedParams); + + Request request = function.apply(resizeRequest); + Assert.assertEquals(HttpPut.METHOD_NAME, request.getMethod()); + String expectedEndpoint = "/" + resizeRequest.getSourceIndex() + "/_" + resizeType.name().toLowerCase(Locale.ROOT) + "/" + + resizeRequest.getTargetIndexRequest().index(); + Assert.assertEquals(expectedEndpoint, request.getEndpoint()); + Assert.assertEquals(expectedParams, request.getParameters()); + RequestConvertersTests.assertToXContentBody(resizeRequest, request.getEntity()); + } + + public void testRollover() throws IOException { + RolloverRequest rolloverRequest = new RolloverRequest(ESTestCase.randomAlphaOfLengthBetween(3, 10), + ESTestCase.randomBoolean() ? null : ESTestCase.randomAlphaOfLengthBetween(3, 10)); + Map expectedParams = new HashMap<>(); + RequestConvertersTests.setRandomTimeout(rolloverRequest::timeout, rolloverRequest.timeout(), expectedParams); + RequestConvertersTests.setRandomMasterTimeout(rolloverRequest, expectedParams); + if (ESTestCase.randomBoolean()) { + rolloverRequest.dryRun(ESTestCase.randomBoolean()); + if (rolloverRequest.isDryRun()) { + expectedParams.put("dry_run", "true"); + } + } + if (ESTestCase.randomBoolean()) { + rolloverRequest.addMaxIndexAgeCondition(new TimeValue(ESTestCase.randomNonNegativeLong())); + } + if (ESTestCase.randomBoolean()) { + String type = ESTestCase.randomAlphaOfLengthBetween(3, 10); + rolloverRequest.getCreateIndexRequest().mapping(type, RandomCreateIndexGenerator.randomMapping(type)); + } + if (ESTestCase.randomBoolean()) { + RandomCreateIndexGenerator.randomAliases(rolloverRequest.getCreateIndexRequest()); + } + if (ESTestCase.randomBoolean()) { + rolloverRequest.getCreateIndexRequest().settings(RandomCreateIndexGenerator.randomIndexSettings()); + } + RequestConvertersTests.setRandomWaitForActiveShards(rolloverRequest.getCreateIndexRequest()::waitForActiveShards, expectedParams); + + Request request = IndicesRequestConverters.rollover(rolloverRequest); + if (rolloverRequest.getNewIndexName() == null) { + Assert.assertEquals("/" + rolloverRequest.getAlias() + "/_rollover", request.getEndpoint()); + } else { + Assert.assertEquals("/" + rolloverRequest.getAlias() + "/_rollover/" + rolloverRequest.getNewIndexName(), + request.getEndpoint()); + } + Assert.assertEquals(HttpPost.METHOD_NAME, request.getMethod()); + RequestConvertersTests.assertToXContentBody(rolloverRequest, request.getEntity()); + Assert.assertEquals(expectedParams, request.getParameters()); + } + + public void testGetAlias() { + GetAliasesRequest getAliasesRequest = new GetAliasesRequest(); + + Map expectedParams = new HashMap<>(); + RequestConvertersTests.setRandomLocal(getAliasesRequest, expectedParams); + RequestConvertersTests.setRandomIndicesOptions(getAliasesRequest::indicesOptions, getAliasesRequest::indicesOptions, + expectedParams); + + String[] indices = ESTestCase.randomBoolean() ? null : RequestConvertersTests.randomIndicesNames(0, 2); + String[] aliases = ESTestCase.randomBoolean() ? null : RequestConvertersTests.randomIndicesNames(0, 2); + getAliasesRequest.indices(indices); + getAliasesRequest.aliases(aliases); + + Request request = IndicesRequestConverters.getAlias(getAliasesRequest); + StringJoiner expectedEndpoint = new StringJoiner("/", "/", ""); + + if (false == CollectionUtils.isEmpty(indices)) { + expectedEndpoint.add(String.join(",", indices)); + } + expectedEndpoint.add("_alias"); + + if (false == CollectionUtils.isEmpty(aliases)) { + expectedEndpoint.add(String.join(",", aliases)); + } + + Assert.assertEquals(HttpGet.METHOD_NAME, request.getMethod()); + Assert.assertEquals(expectedEndpoint.toString(), request.getEndpoint()); + Assert.assertEquals(expectedParams, request.getParameters()); + Assert.assertNull(request.getEntity()); + } + + public void testIndexPutSettings() throws IOException { + String[] indices = ESTestCase.randomBoolean() ? null : RequestConvertersTests.randomIndicesNames(0, 2); + UpdateSettingsRequest updateSettingsRequest = new UpdateSettingsRequest(indices); + Map expectedParams = new HashMap<>(); + RequestConvertersTests.setRandomMasterTimeout(updateSettingsRequest, expectedParams); + RequestConvertersTests.setRandomTimeout(updateSettingsRequest::timeout, AcknowledgedRequest.DEFAULT_ACK_TIMEOUT, expectedParams); + RequestConvertersTests.setRandomIndicesOptions(updateSettingsRequest::indicesOptions, updateSettingsRequest::indicesOptions, + expectedParams); + if (ESTestCase.randomBoolean()) { + updateSettingsRequest.setPreserveExisting(ESTestCase.randomBoolean()); + if (updateSettingsRequest.isPreserveExisting()) { + expectedParams.put("preserve_existing", "true"); + } + } + + Request request = IndicesRequestConverters.indexPutSettings(updateSettingsRequest); + StringJoiner endpoint = new StringJoiner("/", "/", ""); + if (indices != null && indices.length > 0) { + endpoint.add(String.join(",", indices)); + } + endpoint.add("_settings"); + Assert.assertThat(endpoint.toString(), equalTo(request.getEndpoint())); + Assert.assertEquals(HttpPut.METHOD_NAME, request.getMethod()); + RequestConvertersTests.assertToXContentBody(updateSettingsRequest, request.getEntity()); + Assert.assertEquals(expectedParams, request.getParameters()); + } + + public void testPutTemplateRequest() throws Exception { + Map names = new HashMap<>(); + names.put("log", "log"); + names.put("template#1", "template%231"); + names.put("-#template", "-%23template"); + names.put("foo^bar", "foo%5Ebar"); + + PutIndexTemplateRequest putTemplateRequest = new PutIndexTemplateRequest().name(ESTestCase.randomFrom(names.keySet())) + .patterns(Arrays.asList(ESTestCase.generateRandomStringArray(20, 100, false, false))); + if (ESTestCase.randomBoolean()) { + putTemplateRequest.order(ESTestCase.randomInt()); + } + if (ESTestCase.randomBoolean()) { + putTemplateRequest.version(ESTestCase.randomInt()); + } + if (ESTestCase.randomBoolean()) { + putTemplateRequest.settings(Settings.builder().put("setting-" + ESTestCase.randomInt(), ESTestCase.randomTimeValue())); + } + if (ESTestCase.randomBoolean()) { + putTemplateRequest.mapping("doc-" + ESTestCase.randomInt(), + "field-" + ESTestCase.randomInt(), "type=" + ESTestCase.randomFrom("text", "keyword")); + } + if (ESTestCase.randomBoolean()) { + putTemplateRequest.alias(new Alias("alias-" + ESTestCase.randomInt())); + } + Map expectedParams = new HashMap<>(); + if (ESTestCase.randomBoolean()) { + expectedParams.put("create", Boolean.TRUE.toString()); + putTemplateRequest.create(true); + } + if (ESTestCase.randomBoolean()) { + String cause = ESTestCase.randomUnicodeOfCodepointLengthBetween(1, 50); + putTemplateRequest.cause(cause); + expectedParams.put("cause", cause); + } + RequestConvertersTests.setRandomMasterTimeout(putTemplateRequest, expectedParams); + Request request = IndicesRequestConverters.putTemplate(putTemplateRequest); + Assert.assertThat(request.getEndpoint(), equalTo("/_template/" + names.get(putTemplateRequest.name()))); + Assert.assertThat(request.getParameters(), equalTo(expectedParams)); + RequestConvertersTests.assertToXContentBody(putTemplateRequest, request.getEntity()); + } + + public void testValidateQuery() throws Exception { + String[] indices = ESTestCase.randomBoolean() ? null : RequestConvertersTests.randomIndicesNames(0, 5); + String[] types = ESTestCase.randomBoolean() ? ESTestCase.generateRandomStringArray(5, 5, false, false) : null; + ValidateQueryRequest validateQueryRequest; + if (ESTestCase.randomBoolean()) { + validateQueryRequest = new ValidateQueryRequest(indices); + } else { + validateQueryRequest = new ValidateQueryRequest(); + validateQueryRequest.indices(indices); + } + validateQueryRequest.types(types); + Map expectedParams = new HashMap<>(); + RequestConvertersTests.setRandomIndicesOptions(validateQueryRequest::indicesOptions, validateQueryRequest::indicesOptions, + expectedParams); + validateQueryRequest.explain(ESTestCase.randomBoolean()); + validateQueryRequest.rewrite(ESTestCase.randomBoolean()); + validateQueryRequest.allShards(ESTestCase.randomBoolean()); + expectedParams.put("explain", Boolean.toString(validateQueryRequest.explain())); + expectedParams.put("rewrite", Boolean.toString(validateQueryRequest.rewrite())); + expectedParams.put("all_shards", Boolean.toString(validateQueryRequest.allShards())); + Request request = IndicesRequestConverters.validateQuery(validateQueryRequest); + StringJoiner endpoint = new StringJoiner("/", "/", ""); + if (indices != null && indices.length > 0) { + endpoint.add(String.join(",", indices)); + if (types != null && types.length > 0) { + endpoint.add(String.join(",", types)); + } + } + endpoint.add("_validate/query"); + Assert.assertThat(request.getEndpoint(), equalTo(endpoint.toString())); + Assert.assertThat(request.getParameters(), equalTo(expectedParams)); + RequestConvertersTests.assertToXContentBody(validateQueryRequest, request.getEntity()); + Assert.assertThat(request.getMethod(), equalTo(HttpGet.METHOD_NAME)); + } + + public void testGetTemplateRequest() throws Exception { + Map encodes = new HashMap<>(); + encodes.put("log", "log"); + encodes.put("1", "1"); + encodes.put("template#1", "template%231"); + encodes.put("template-*", "template-*"); + encodes.put("foo^bar", "foo%5Ebar"); + List names = ESTestCase.randomSubsetOf(1, encodes.keySet()); + GetIndexTemplatesRequest getTemplatesRequest = new GetIndexTemplatesRequest().names(names.toArray(new String[0])); + Map expectedParams = new HashMap<>(); + RequestConvertersTests.setRandomMasterTimeout(getTemplatesRequest, expectedParams); + RequestConvertersTests.setRandomLocal(getTemplatesRequest, expectedParams); + Request request = IndicesRequestConverters.getTemplates(getTemplatesRequest); + Assert.assertThat(request.getEndpoint(), + equalTo("/_template/" + names.stream().map(encodes::get).collect(Collectors.joining(",")))); + Assert.assertThat(request.getParameters(), equalTo(expectedParams)); + Assert.assertThat(request.getEntity(), nullValue()); + } +} diff --git a/client/rest-high-level/src/test/java/org/elasticsearch/client/RequestConvertersTests.java b/client/rest-high-level/src/test/java/org/elasticsearch/client/RequestConvertersTests.java index 4ef8e8542c9..6d073a7a60a 100644 --- a/client/rest-high-level/src/test/java/org/elasticsearch/client/RequestConvertersTests.java +++ b/client/rest-high-level/src/test/java/org/elasticsearch/client/RequestConvertersTests.java @@ -27,37 +27,12 @@ import org.apache.http.client.methods.HttpPost; import org.apache.http.client.methods.HttpPut; import org.apache.http.entity.ByteArrayEntity; import org.apache.http.util.EntityUtils; -import org.elasticsearch.action.ActionRequestValidationException; import org.elasticsearch.action.DocWriteRequest; import org.elasticsearch.action.admin.cluster.storedscripts.DeleteStoredScriptRequest; import org.elasticsearch.action.admin.cluster.storedscripts.GetStoredScriptRequest; import org.elasticsearch.action.admin.cluster.storedscripts.PutStoredScriptRequest; -import org.elasticsearch.action.admin.indices.alias.Alias; -import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest; -import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest.AliasActions; -import org.elasticsearch.action.admin.indices.alias.get.GetAliasesRequest; import org.elasticsearch.action.admin.indices.analyze.AnalyzeRequest; -import org.elasticsearch.action.admin.indices.cache.clear.ClearIndicesCacheRequest; -import org.elasticsearch.action.admin.indices.close.CloseIndexRequest; -import org.elasticsearch.action.admin.indices.create.CreateIndexRequest; -import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest; -import org.elasticsearch.action.admin.indices.flush.FlushRequest; -import org.elasticsearch.action.admin.indices.flush.SyncedFlushRequest; -import org.elasticsearch.action.admin.indices.forcemerge.ForceMergeRequest; import org.elasticsearch.action.admin.indices.get.GetIndexRequest; -import org.elasticsearch.action.admin.indices.mapping.get.GetFieldMappingsRequest; -import org.elasticsearch.action.admin.indices.mapping.get.GetMappingsRequest; -import org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequest; -import org.elasticsearch.action.admin.indices.open.OpenIndexRequest; -import org.elasticsearch.action.admin.indices.refresh.RefreshRequest; -import org.elasticsearch.action.admin.indices.rollover.RolloverRequest; -import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest; -import org.elasticsearch.action.admin.indices.settings.put.UpdateSettingsRequest; -import org.elasticsearch.action.admin.indices.shrink.ResizeRequest; -import org.elasticsearch.action.admin.indices.shrink.ResizeType; -import org.elasticsearch.action.admin.indices.template.get.GetIndexTemplatesRequest; -import org.elasticsearch.action.admin.indices.template.put.PutIndexTemplateRequest; -import org.elasticsearch.action.admin.indices.validate.query.ValidateQueryRequest; import org.elasticsearch.action.bulk.BulkRequest; import org.elasticsearch.action.bulk.BulkShardRequest; import org.elasticsearch.action.delete.DeleteRequest; @@ -81,22 +56,18 @@ import org.elasticsearch.action.support.replication.ReplicationRequest; import org.elasticsearch.action.update.UpdateRequest; import org.elasticsearch.client.RequestConverters.EndpointBuilder; import org.elasticsearch.common.CheckedBiConsumer; -import org.elasticsearch.common.CheckedFunction; import org.elasticsearch.common.Strings; import org.elasticsearch.common.bytes.BytesArray; import org.elasticsearch.common.bytes.BytesReference; import org.elasticsearch.common.io.Streams; import org.elasticsearch.common.lucene.uid.Versions; -import org.elasticsearch.common.settings.Settings; import org.elasticsearch.common.unit.TimeValue; -import org.elasticsearch.common.util.CollectionUtils; import org.elasticsearch.common.xcontent.ToXContent; import org.elasticsearch.common.xcontent.XContentBuilder; import org.elasticsearch.common.xcontent.XContentHelper; import org.elasticsearch.common.xcontent.XContentParser; import org.elasticsearch.common.xcontent.XContentType; import org.elasticsearch.common.xcontent.json.JsonXContent; -import org.elasticsearch.index.RandomCreateIndexGenerator; import org.elasticsearch.index.VersionType; import org.elasticsearch.index.query.QueryBuilders; import org.elasticsearch.index.query.TermQueryBuilder; @@ -141,16 +112,11 @@ import java.util.StringJoiner; import java.util.function.Consumer; import java.util.function.Function; import java.util.function.Supplier; -import java.util.stream.Collectors; import static java.util.Collections.emptyMap; import static java.util.Collections.singletonMap; import static org.elasticsearch.client.RequestConverters.REQUEST_BODY_CONTENT_TYPE; import static org.elasticsearch.client.RequestConverters.enforceSameContentType; -import static org.elasticsearch.index.RandomCreateIndexGenerator.randomAliases; -import static org.elasticsearch.index.RandomCreateIndexGenerator.randomCreateIndexRequest; -import static org.elasticsearch.index.RandomCreateIndexGenerator.randomIndexSettings; -import static org.elasticsearch.index.alias.RandomAliasActionsGenerator.randomAliasAction; import static org.elasticsearch.index.query.QueryBuilders.matchAllQuery; import static org.elasticsearch.search.RandomSearchRequestGenerator.randomSearchRequest; import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertToXContentEquivalent; @@ -261,30 +227,6 @@ public class RequestConvertersTests extends ESTestCase { getAndExistsTest(RequestConverters::exists, HttpHead.METHOD_NAME); } - public void testIndicesExist() { - String[] indices = randomIndicesNames(1, 10); - - GetIndexRequest getIndexRequest = new GetIndexRequest().indices(indices); - - Map expectedParams = new HashMap<>(); - setRandomIndicesOptions(getIndexRequest::indicesOptions, getIndexRequest::indicesOptions, expectedParams); - setRandomLocal(getIndexRequest, expectedParams); - setRandomHumanReadable(getIndexRequest, expectedParams); - setRandomIncludeDefaults(getIndexRequest, expectedParams); - - final Request request = RequestConverters.indicesExist(getIndexRequest); - - assertEquals(HttpHead.METHOD_NAME, request.getMethod()); - assertEquals("/" + String.join(",", indices), request.getEndpoint()); - assertThat(expectedParams, equalTo(request.getParameters())); - assertNull(request.getEntity()); - } - - public void testIndicesExistEmptyIndices() { - expectThrows(IllegalArgumentException.class, () -> RequestConverters.indicesExist(new GetIndexRequest())); - expectThrows(IllegalArgumentException.class, () -> RequestConverters.indicesExist(new GetIndexRequest().indices((String[]) null))); - } - private static void getAndExistsTest(Function requestConverter, String method) { String index = randomAlphaOfLengthBetween(3, 10); String type = randomAlphaOfLengthBetween(3, 10); @@ -343,41 +285,6 @@ public class RequestConvertersTests extends ESTestCase { assertEquals(method, request.getMethod()); } - public void testCreateIndex() throws IOException { - CreateIndexRequest createIndexRequest = randomCreateIndexRequest(); - - Map expectedParams = new HashMap<>(); - setRandomTimeout(createIndexRequest::timeout, AcknowledgedRequest.DEFAULT_ACK_TIMEOUT, expectedParams); - setRandomMasterTimeout(createIndexRequest, expectedParams); - setRandomWaitForActiveShards(createIndexRequest::waitForActiveShards, expectedParams); - - Request request = RequestConverters.createIndex(createIndexRequest); - assertEquals("/" + createIndexRequest.index(), request.getEndpoint()); - assertEquals(expectedParams, request.getParameters()); - assertEquals(HttpPut.METHOD_NAME, request.getMethod()); - assertToXContentBody(createIndexRequest, request.getEntity()); - } - - public void testCreateIndexNullIndex() { - ActionRequestValidationException validationException = new CreateIndexRequest(null).validate(); - assertNotNull(validationException); - } - - public void testUpdateAliases() throws IOException { - IndicesAliasesRequest indicesAliasesRequest = new IndicesAliasesRequest(); - AliasActions aliasAction = randomAliasAction(); - indicesAliasesRequest.addAliasAction(aliasAction); - - Map expectedParams = new HashMap<>(); - setRandomTimeout(indicesAliasesRequest::timeout, AcknowledgedRequest.DEFAULT_ACK_TIMEOUT, expectedParams); - setRandomMasterTimeout(indicesAliasesRequest, expectedParams); - - Request request = RequestConverters.updateAliases(indicesAliasesRequest); - assertEquals("/_aliases", request.getEndpoint()); - assertEquals(expectedParams, request.getParameters()); - assertToXContentBody(indicesAliasesRequest, request.getEntity()); - } - public void testReindex() throws IOException { ReindexRequest reindexRequest = new ReindexRequest(); reindexRequest.setSourceIndices("source_idx"); @@ -537,282 +444,6 @@ public class RequestConvertersTests extends ESTestCase { assertToXContentBody(deleteByQueryRequest, request.getEntity()); } - public void testPutMapping() throws IOException { - PutMappingRequest putMappingRequest = new PutMappingRequest(); - - String[] indices = randomIndicesNames(0, 5); - putMappingRequest.indices(indices); - - String type = randomAlphaOfLengthBetween(3, 10); - putMappingRequest.type(type); - - Map expectedParams = new HashMap<>(); - - setRandomTimeout(putMappingRequest::timeout, AcknowledgedRequest.DEFAULT_ACK_TIMEOUT, expectedParams); - setRandomMasterTimeout(putMappingRequest, expectedParams); - - Request request = RequestConverters.putMapping(putMappingRequest); - StringJoiner endpoint = new StringJoiner("/", "/", ""); - String index = String.join(",", indices); - if (Strings.hasLength(index)) { - endpoint.add(index); - } - endpoint.add("_mapping"); - endpoint.add(type); - assertEquals(endpoint.toString(), request.getEndpoint()); - - assertEquals(expectedParams, request.getParameters()); - assertEquals(HttpPut.METHOD_NAME, request.getMethod()); - assertToXContentBody(putMappingRequest, request.getEntity()); - } - - public void testGetMapping() throws IOException { - GetMappingsRequest getMappingRequest = new GetMappingsRequest(); - - String[] indices = Strings.EMPTY_ARRAY; - if (randomBoolean()) { - indices = randomIndicesNames(0, 5); - getMappingRequest.indices(indices); - } else if (randomBoolean()) { - getMappingRequest.indices((String[]) null); - } - - String type = null; - if (randomBoolean()) { - type = randomAlphaOfLengthBetween(3, 10); - getMappingRequest.types(type); - } else if (randomBoolean()) { - getMappingRequest.types((String[]) null); - } - - Map expectedParams = new HashMap<>(); - - setRandomIndicesOptions(getMappingRequest::indicesOptions, getMappingRequest::indicesOptions, expectedParams); - setRandomMasterTimeout(getMappingRequest, expectedParams); - setRandomLocal(getMappingRequest, expectedParams); - - Request request = RequestConverters.getMappings(getMappingRequest); - StringJoiner endpoint = new StringJoiner("/", "/", ""); - String index = String.join(",", indices); - if (Strings.hasLength(index)) { - endpoint.add(index); - } - endpoint.add("_mapping"); - if (type != null) { - endpoint.add(type); - } - assertThat(endpoint.toString(), equalTo(request.getEndpoint())); - - assertThat(expectedParams, equalTo(request.getParameters())); - assertThat(HttpGet.METHOD_NAME, equalTo(request.getMethod())); - } - - public void testGetFieldMapping() throws IOException { - GetFieldMappingsRequest getFieldMappingsRequest = new GetFieldMappingsRequest(); - - String[] indices = Strings.EMPTY_ARRAY; - if (randomBoolean()) { - indices = randomIndicesNames(0, 5); - getFieldMappingsRequest.indices(indices); - } else if (randomBoolean()) { - getFieldMappingsRequest.indices((String[]) null); - } - - String type = null; - if (randomBoolean()) { - type = randomAlphaOfLengthBetween(3, 10); - getFieldMappingsRequest.types(type); - } else if (randomBoolean()) { - getFieldMappingsRequest.types((String[]) null); - } - - String[] fields = null; - if (randomBoolean()) { - fields = new String[randomIntBetween(1, 5)]; - for (int i = 0; i < fields.length; i++) { - fields[i] = randomAlphaOfLengthBetween(3, 10); - } - getFieldMappingsRequest.fields(fields); - } else if (randomBoolean()) { - getFieldMappingsRequest.fields((String[]) null); - } - - Map expectedParams = new HashMap<>(); - - setRandomIndicesOptions(getFieldMappingsRequest::indicesOptions, getFieldMappingsRequest::indicesOptions, expectedParams); - setRandomLocal(getFieldMappingsRequest::local, expectedParams); - - Request request = RequestConverters.getFieldMapping(getFieldMappingsRequest); - StringJoiner endpoint = new StringJoiner("/", "/", ""); - String index = String.join(",", indices); - if (Strings.hasLength(index)) { - endpoint.add(index); - } - endpoint.add("_mapping"); - if (type != null) { - endpoint.add(type); - } - endpoint.add("field"); - if (fields != null) { - endpoint.add(String.join(",", fields)); - } - assertThat(endpoint.toString(), equalTo(request.getEndpoint())); - - assertThat(expectedParams, equalTo(request.getParameters())); - assertThat(HttpGet.METHOD_NAME, equalTo(request.getMethod())); - } - - public void testDeleteIndex() { - String[] indices = randomIndicesNames(0, 5); - DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest(indices); - - Map expectedParams = new HashMap<>(); - setRandomTimeout(deleteIndexRequest::timeout, AcknowledgedRequest.DEFAULT_ACK_TIMEOUT, expectedParams); - setRandomMasterTimeout(deleteIndexRequest, expectedParams); - - setRandomIndicesOptions(deleteIndexRequest::indicesOptions, deleteIndexRequest::indicesOptions, expectedParams); - - Request request = RequestConverters.deleteIndex(deleteIndexRequest); - assertEquals("/" + String.join(",", indices), request.getEndpoint()); - assertEquals(expectedParams, request.getParameters()); - assertEquals(HttpDelete.METHOD_NAME, request.getMethod()); - assertNull(request.getEntity()); - } - - public void testGetSettings() throws IOException { - String[] indicesUnderTest = randomBoolean() ? null : randomIndicesNames(0, 5); - - GetSettingsRequest getSettingsRequest = new GetSettingsRequest().indices(indicesUnderTest); - - Map expectedParams = new HashMap<>(); - setRandomMasterTimeout(getSettingsRequest, expectedParams); - setRandomIndicesOptions(getSettingsRequest::indicesOptions, getSettingsRequest::indicesOptions, expectedParams); - - setRandomLocal(getSettingsRequest, expectedParams); - - if (randomBoolean()) { - // the request object will not have include_defaults present unless it is set to - // true - getSettingsRequest.includeDefaults(randomBoolean()); - if (getSettingsRequest.includeDefaults()) { - expectedParams.put("include_defaults", Boolean.toString(true)); - } - } - - StringJoiner endpoint = new StringJoiner("/", "/", ""); - if (indicesUnderTest != null && indicesUnderTest.length > 0) { - endpoint.add(String.join(",", indicesUnderTest)); - } - endpoint.add("_settings"); - - if (randomBoolean()) { - String[] names = randomBoolean() ? null : new String[randomIntBetween(0, 3)]; - if (names != null) { - for (int x = 0; x < names.length; x++) { - names[x] = randomAlphaOfLengthBetween(3, 10); - } - } - getSettingsRequest.names(names); - if (names != null && names.length > 0) { - endpoint.add(String.join(",", names)); - } - } - - Request request = RequestConverters.getSettings(getSettingsRequest); - - assertThat(endpoint.toString(), equalTo(request.getEndpoint())); - assertThat(request.getParameters(), equalTo(expectedParams)); - assertThat(request.getMethod(), equalTo(HttpGet.METHOD_NAME)); - assertThat(request.getEntity(), nullValue()); - } - - public void testGetIndex() throws IOException { - String[] indicesUnderTest = randomBoolean() ? null : randomIndicesNames(0, 5); - - GetIndexRequest getIndexRequest = new GetIndexRequest().indices(indicesUnderTest); - - Map expectedParams = new HashMap<>(); - setRandomMasterTimeout(getIndexRequest, expectedParams); - setRandomIndicesOptions(getIndexRequest::indicesOptions, getIndexRequest::indicesOptions, expectedParams); - setRandomLocal(getIndexRequest, expectedParams); - setRandomHumanReadable(getIndexRequest, expectedParams); - - if (randomBoolean()) { - // the request object will not have include_defaults present unless it is set to - // true - getIndexRequest.includeDefaults(randomBoolean()); - if (getIndexRequest.includeDefaults()) { - expectedParams.put("include_defaults", Boolean.toString(true)); - } - } - - StringJoiner endpoint = new StringJoiner("/", "/", ""); - if (indicesUnderTest != null && indicesUnderTest.length > 0) { - endpoint.add(String.join(",", indicesUnderTest)); - } - - Request request = RequestConverters.getIndex(getIndexRequest); - - assertThat(endpoint.toString(), equalTo(request.getEndpoint())); - assertThat(request.getParameters(), equalTo(expectedParams)); - assertThat(request.getMethod(), equalTo(HttpGet.METHOD_NAME)); - assertThat(request.getEntity(), nullValue()); - } - - public void testDeleteIndexEmptyIndices() { - String[] indices = randomBoolean() ? null : Strings.EMPTY_ARRAY; - ActionRequestValidationException validationException = new DeleteIndexRequest(indices).validate(); - assertNotNull(validationException); - } - - public void testOpenIndex() { - String[] indices = randomIndicesNames(1, 5); - OpenIndexRequest openIndexRequest = new OpenIndexRequest(indices); - openIndexRequest.indices(indices); - - Map expectedParams = new HashMap<>(); - setRandomTimeout(openIndexRequest::timeout, AcknowledgedRequest.DEFAULT_ACK_TIMEOUT, expectedParams); - setRandomMasterTimeout(openIndexRequest, expectedParams); - setRandomIndicesOptions(openIndexRequest::indicesOptions, openIndexRequest::indicesOptions, expectedParams); - setRandomWaitForActiveShards(openIndexRequest::waitForActiveShards, expectedParams); - - Request request = RequestConverters.openIndex(openIndexRequest); - StringJoiner endpoint = new StringJoiner("/", "/", "").add(String.join(",", indices)).add("_open"); - assertThat(endpoint.toString(), equalTo(request.getEndpoint())); - assertThat(expectedParams, equalTo(request.getParameters())); - assertThat(request.getMethod(), equalTo(HttpPost.METHOD_NAME)); - assertThat(request.getEntity(), nullValue()); - } - - public void testOpenIndexEmptyIndices() { - String[] indices = randomBoolean() ? null : Strings.EMPTY_ARRAY; - ActionRequestValidationException validationException = new OpenIndexRequest(indices).validate(); - assertNotNull(validationException); - } - - public void testCloseIndex() { - String[] indices = randomIndicesNames(1, 5); - CloseIndexRequest closeIndexRequest = new CloseIndexRequest(indices); - - Map expectedParams = new HashMap<>(); - setRandomTimeout(closeIndexRequest::timeout, AcknowledgedRequest.DEFAULT_ACK_TIMEOUT, expectedParams); - setRandomMasterTimeout(closeIndexRequest, expectedParams); - setRandomIndicesOptions(closeIndexRequest::indicesOptions, closeIndexRequest::indicesOptions, expectedParams); - - Request request = RequestConverters.closeIndex(closeIndexRequest); - StringJoiner endpoint = new StringJoiner("/", "/", "").add(String.join(",", indices)).add("_close"); - assertThat(endpoint.toString(), equalTo(request.getEndpoint())); - assertThat(expectedParams, equalTo(request.getParameters())); - assertThat(request.getMethod(), equalTo(HttpPost.METHOD_NAME)); - assertThat(request.getEntity(), nullValue()); - } - - public void testCloseIndexEmptyIndices() { - String[] indices = randomBoolean() ? null : Strings.EMPTY_ARRAY; - ActionRequestValidationException validationException = new CloseIndexRequest(indices).validate(); - assertNotNull(validationException); - } - public void testIndex() throws IOException { String index = randomAlphaOfLengthBetween(3, 10); String type = randomAlphaOfLengthBetween(3, 10); @@ -886,161 +517,6 @@ public class RequestConvertersTests extends ESTestCase { } } - public void testRefresh() { - String[] indices = randomBoolean() ? null : randomIndicesNames(0, 5); - RefreshRequest refreshRequest; - if (randomBoolean()) { - refreshRequest = new RefreshRequest(indices); - } else { - refreshRequest = new RefreshRequest(); - refreshRequest.indices(indices); - } - Map expectedParams = new HashMap<>(); - setRandomIndicesOptions(refreshRequest::indicesOptions, refreshRequest::indicesOptions, expectedParams); - Request request = RequestConverters.refresh(refreshRequest); - StringJoiner endpoint = new StringJoiner("/", "/", ""); - if (indices != null && indices.length > 0) { - endpoint.add(String.join(",", indices)); - } - endpoint.add("_refresh"); - assertThat(request.getEndpoint(), equalTo(endpoint.toString())); - assertThat(request.getParameters(), equalTo(expectedParams)); - assertThat(request.getEntity(), nullValue()); - assertThat(request.getMethod(), equalTo(HttpPost.METHOD_NAME)); - } - - public void testFlush() { - String[] indices = randomBoolean() ? null : randomIndicesNames(0, 5); - FlushRequest flushRequest; - if (randomBoolean()) { - flushRequest = new FlushRequest(indices); - } else { - flushRequest = new FlushRequest(); - flushRequest.indices(indices); - } - Map expectedParams = new HashMap<>(); - setRandomIndicesOptions(flushRequest::indicesOptions, flushRequest::indicesOptions, expectedParams); - if (randomBoolean()) { - flushRequest.force(randomBoolean()); - } - expectedParams.put("force", Boolean.toString(flushRequest.force())); - if (randomBoolean()) { - flushRequest.waitIfOngoing(randomBoolean()); - } - expectedParams.put("wait_if_ongoing", Boolean.toString(flushRequest.waitIfOngoing())); - - Request request = RequestConverters.flush(flushRequest); - StringJoiner endpoint = new StringJoiner("/", "/", ""); - if (indices != null && indices.length > 0) { - endpoint.add(String.join(",", indices)); - } - endpoint.add("_flush"); - assertThat(request.getEndpoint(), equalTo(endpoint.toString())); - assertThat(request.getParameters(), equalTo(expectedParams)); - assertThat(request.getEntity(), nullValue()); - assertThat(request.getMethod(), equalTo(HttpPost.METHOD_NAME)); - } - - public void testSyncedFlush() { - String[] indices = randomBoolean() ? null : randomIndicesNames(0, 5); - SyncedFlushRequest syncedFlushRequest; - if (randomBoolean()) { - syncedFlushRequest = new SyncedFlushRequest(indices); - } else { - syncedFlushRequest = new SyncedFlushRequest(); - syncedFlushRequest.indices(indices); - } - Map expectedParams = new HashMap<>(); - setRandomIndicesOptions(syncedFlushRequest::indicesOptions, syncedFlushRequest::indicesOptions, expectedParams); - Request request = RequestConverters.flushSynced(syncedFlushRequest); - StringJoiner endpoint = new StringJoiner("/", "/", ""); - if (indices != null && indices.length > 0) { - endpoint.add(String.join(",", indices)); - } - endpoint.add("_flush/synced"); - assertThat(request.getEndpoint(), equalTo(endpoint.toString())); - assertThat(request.getParameters(), equalTo(expectedParams)); - assertThat(request.getEntity(), nullValue()); - assertThat(request.getMethod(), equalTo(HttpPost.METHOD_NAME)); - } - - public void testForceMerge() { - String[] indices = randomBoolean() ? null : randomIndicesNames(0, 5); - ForceMergeRequest forceMergeRequest; - if (randomBoolean()) { - forceMergeRequest = new ForceMergeRequest(indices); - } else { - forceMergeRequest = new ForceMergeRequest(); - forceMergeRequest.indices(indices); - } - - Map expectedParams = new HashMap<>(); - setRandomIndicesOptions(forceMergeRequest::indicesOptions, forceMergeRequest::indicesOptions, expectedParams); - if (randomBoolean()) { - forceMergeRequest.maxNumSegments(randomInt()); - } - expectedParams.put("max_num_segments", Integer.toString(forceMergeRequest.maxNumSegments())); - if (randomBoolean()) { - forceMergeRequest.onlyExpungeDeletes(randomBoolean()); - } - expectedParams.put("only_expunge_deletes", Boolean.toString(forceMergeRequest.onlyExpungeDeletes())); - if (randomBoolean()) { - forceMergeRequest.flush(randomBoolean()); - } - expectedParams.put("flush", Boolean.toString(forceMergeRequest.flush())); - - Request request = RequestConverters.forceMerge(forceMergeRequest); - StringJoiner endpoint = new StringJoiner("/", "/", ""); - if (indices != null && indices.length > 0) { - endpoint.add(String.join(",", indices)); - } - endpoint.add("_forcemerge"); - assertThat(request.getEndpoint(), equalTo(endpoint.toString())); - assertThat(request.getParameters(), equalTo(expectedParams)); - assertThat(request.getEntity(), nullValue()); - assertThat(request.getMethod(), equalTo(HttpPost.METHOD_NAME)); - } - - public void testClearCache() { - String[] indices = randomBoolean() ? null : randomIndicesNames(0, 5); - ClearIndicesCacheRequest clearIndicesCacheRequest; - if (randomBoolean()) { - clearIndicesCacheRequest = new ClearIndicesCacheRequest(indices); - } else { - clearIndicesCacheRequest = new ClearIndicesCacheRequest(); - clearIndicesCacheRequest.indices(indices); - } - Map expectedParams = new HashMap<>(); - setRandomIndicesOptions(clearIndicesCacheRequest::indicesOptions, clearIndicesCacheRequest::indicesOptions, expectedParams); - if (randomBoolean()) { - clearIndicesCacheRequest.queryCache(randomBoolean()); - } - expectedParams.put("query", Boolean.toString(clearIndicesCacheRequest.queryCache())); - if (randomBoolean()) { - clearIndicesCacheRequest.fieldDataCache(randomBoolean()); - } - expectedParams.put("fielddata", Boolean.toString(clearIndicesCacheRequest.fieldDataCache())); - if (randomBoolean()) { - clearIndicesCacheRequest.requestCache(randomBoolean()); - } - expectedParams.put("request", Boolean.toString(clearIndicesCacheRequest.requestCache())); - if (randomBoolean()) { - clearIndicesCacheRequest.fields(randomIndicesNames(1, 5)); - expectedParams.put("fields", String.join(",", clearIndicesCacheRequest.fields())); - } - - Request request = RequestConverters.clearCache(clearIndicesCacheRequest); - StringJoiner endpoint = new StringJoiner("/", "/", ""); - if (indices != null && indices.length > 0) { - endpoint.add(String.join(",", indices)); - } - endpoint.add("_cache/clear"); - assertThat(request.getEndpoint(), equalTo(endpoint.toString())); - assertThat(request.getParameters(), equalTo(expectedParams)); - assertThat(request.getEntity(), nullValue()); - assertThat(request.getMethod(), equalTo(HttpPost.METHOD_NAME)); - } - public void testUpdate() throws IOException { XContentType xContentType = randomFrom(XContentType.values()); @@ -1598,54 +1074,6 @@ public class RequestConvertersTests extends ESTestCase { assertEquals(new BytesArray(expectedBytes), new BytesArray(EntityUtils.toByteArray(actualEntity))); } - public void testExistsAlias() { - GetAliasesRequest getAliasesRequest = new GetAliasesRequest(); - String[] indices = randomBoolean() ? null : randomIndicesNames(0, 5); - getAliasesRequest.indices(indices); - // the HEAD endpoint requires at least an alias or an index - boolean hasIndices = indices != null && indices.length > 0; - String[] aliases; - if (hasIndices) { - aliases = randomBoolean() ? null : randomIndicesNames(0, 5); - } else { - aliases = randomIndicesNames(1, 5); - } - getAliasesRequest.aliases(aliases); - Map expectedParams = new HashMap<>(); - setRandomLocal(getAliasesRequest, expectedParams); - setRandomIndicesOptions(getAliasesRequest::indicesOptions, getAliasesRequest::indicesOptions, expectedParams); - - Request request = RequestConverters.existsAlias(getAliasesRequest); - StringJoiner expectedEndpoint = new StringJoiner("/", "/", ""); - if (indices != null && indices.length > 0) { - expectedEndpoint.add(String.join(",", indices)); - } - expectedEndpoint.add("_alias"); - if (aliases != null && aliases.length > 0) { - expectedEndpoint.add(String.join(",", aliases)); - } - assertEquals(HttpHead.METHOD_NAME, request.getMethod()); - assertEquals(expectedEndpoint.toString(), request.getEndpoint()); - assertEquals(expectedParams, request.getParameters()); - assertNull(request.getEntity()); - } - - public void testExistsAliasNoAliasNoIndex() { - { - GetAliasesRequest getAliasesRequest = new GetAliasesRequest(); - IllegalArgumentException iae = expectThrows(IllegalArgumentException.class, - () -> RequestConverters.existsAlias(getAliasesRequest)); - assertEquals("existsAlias requires at least an alias or an index", iae.getMessage()); - } - { - GetAliasesRequest getAliasesRequest = new GetAliasesRequest((String[]) null); - getAliasesRequest.indices((String[]) null); - IllegalArgumentException iae = expectThrows(IllegalArgumentException.class, - () -> RequestConverters.existsAlias(getAliasesRequest)); - assertEquals("existsAlias requires at least an alias or an index", iae.getMessage()); - } - } - public void testExplain() throws IOException { String index = randomAlphaOfLengthBetween(3, 10); String type = randomAlphaOfLengthBetween(3, 10); @@ -1749,245 +1177,6 @@ public class RequestConvertersTests extends ESTestCase { assertToXContentBody(spec, request.getEntity()); } - public void testSplit() throws IOException { - resizeTest(ResizeType.SPLIT, RequestConverters::split); - } - - public void testSplitWrongResizeType() { - ResizeRequest resizeRequest = new ResizeRequest("target", "source"); - resizeRequest.setResizeType(ResizeType.SHRINK); - IllegalArgumentException iae = expectThrows(IllegalArgumentException.class, () -> RequestConverters.split(resizeRequest)); - assertEquals("Wrong resize type [SHRINK] for indices split request", iae.getMessage()); - } - - public void testShrinkWrongResizeType() { - ResizeRequest resizeRequest = new ResizeRequest("target", "source"); - resizeRequest.setResizeType(ResizeType.SPLIT); - IllegalArgumentException iae = expectThrows(IllegalArgumentException.class, () -> RequestConverters.shrink(resizeRequest)); - assertEquals("Wrong resize type [SPLIT] for indices shrink request", iae.getMessage()); - } - - public void testShrink() throws IOException { - resizeTest(ResizeType.SHRINK, RequestConverters::shrink); - } - - private static void resizeTest(ResizeType resizeType, CheckedFunction function) - throws IOException { - String[] indices = randomIndicesNames(2, 2); - ResizeRequest resizeRequest = new ResizeRequest(indices[0], indices[1]); - resizeRequest.setResizeType(resizeType); - Map expectedParams = new HashMap<>(); - setRandomMasterTimeout(resizeRequest, expectedParams); - setRandomTimeout(resizeRequest::timeout, resizeRequest.timeout(), expectedParams); - - if (randomBoolean()) { - CreateIndexRequest createIndexRequest = new CreateIndexRequest(randomAlphaOfLengthBetween(3, 10)); - if (randomBoolean()) { - createIndexRequest.settings(randomIndexSettings()); - } - if (randomBoolean()) { - randomAliases(createIndexRequest); - } - resizeRequest.setTargetIndex(createIndexRequest); - } - setRandomWaitForActiveShards(resizeRequest::setWaitForActiveShards, expectedParams); - - Request request = function.apply(resizeRequest); - assertEquals(HttpPut.METHOD_NAME, request.getMethod()); - String expectedEndpoint = "/" + resizeRequest.getSourceIndex() + "/_" + resizeType.name().toLowerCase(Locale.ROOT) + "/" - + resizeRequest.getTargetIndexRequest().index(); - assertEquals(expectedEndpoint, request.getEndpoint()); - assertEquals(expectedParams, request.getParameters()); - assertToXContentBody(resizeRequest, request.getEntity()); - } - - public void testRollover() throws IOException { - RolloverRequest rolloverRequest = new RolloverRequest(randomAlphaOfLengthBetween(3, 10), - randomBoolean() ? null : randomAlphaOfLengthBetween(3, 10)); - Map expectedParams = new HashMap<>(); - setRandomTimeout(rolloverRequest::timeout, rolloverRequest.timeout(), expectedParams); - setRandomMasterTimeout(rolloverRequest, expectedParams); - if (randomBoolean()) { - rolloverRequest.dryRun(randomBoolean()); - if (rolloverRequest.isDryRun()) { - expectedParams.put("dry_run", "true"); - } - } - if (randomBoolean()) { - rolloverRequest.addMaxIndexAgeCondition(new TimeValue(randomNonNegativeLong())); - } - if (randomBoolean()) { - String type = randomAlphaOfLengthBetween(3, 10); - rolloverRequest.getCreateIndexRequest().mapping(type, RandomCreateIndexGenerator.randomMapping(type)); - } - if (randomBoolean()) { - RandomCreateIndexGenerator.randomAliases(rolloverRequest.getCreateIndexRequest()); - } - if (randomBoolean()) { - rolloverRequest.getCreateIndexRequest().settings(RandomCreateIndexGenerator.randomIndexSettings()); - } - setRandomWaitForActiveShards(rolloverRequest.getCreateIndexRequest()::waitForActiveShards, expectedParams); - - Request request = RequestConverters.rollover(rolloverRequest); - if (rolloverRequest.getNewIndexName() == null) { - assertEquals("/" + rolloverRequest.getAlias() + "/_rollover", request.getEndpoint()); - } else { - assertEquals("/" + rolloverRequest.getAlias() + "/_rollover/" + rolloverRequest.getNewIndexName(), request.getEndpoint()); - } - assertEquals(HttpPost.METHOD_NAME, request.getMethod()); - assertToXContentBody(rolloverRequest, request.getEntity()); - assertEquals(expectedParams, request.getParameters()); - } - - public void testGetAlias() { - GetAliasesRequest getAliasesRequest = new GetAliasesRequest(); - - Map expectedParams = new HashMap<>(); - setRandomLocal(getAliasesRequest, expectedParams); - setRandomIndicesOptions(getAliasesRequest::indicesOptions, getAliasesRequest::indicesOptions, expectedParams); - - String[] indices = randomBoolean() ? null : randomIndicesNames(0, 2); - String[] aliases = randomBoolean() ? null : randomIndicesNames(0, 2); - getAliasesRequest.indices(indices); - getAliasesRequest.aliases(aliases); - - Request request = RequestConverters.getAlias(getAliasesRequest); - StringJoiner expectedEndpoint = new StringJoiner("/", "/", ""); - - if (false == CollectionUtils.isEmpty(indices)) { - expectedEndpoint.add(String.join(",", indices)); - } - expectedEndpoint.add("_alias"); - - if (false == CollectionUtils.isEmpty(aliases)) { - expectedEndpoint.add(String.join(",", aliases)); - } - - assertEquals(HttpGet.METHOD_NAME, request.getMethod()); - assertEquals(expectedEndpoint.toString(), request.getEndpoint()); - assertEquals(expectedParams, request.getParameters()); - assertNull(request.getEntity()); - } - - public void testIndexPutSettings() throws IOException { - String[] indices = randomBoolean() ? null : randomIndicesNames(0, 2); - UpdateSettingsRequest updateSettingsRequest = new UpdateSettingsRequest(indices); - Map expectedParams = new HashMap<>(); - setRandomMasterTimeout(updateSettingsRequest, expectedParams); - setRandomTimeout(updateSettingsRequest::timeout, AcknowledgedRequest.DEFAULT_ACK_TIMEOUT, expectedParams); - setRandomIndicesOptions(updateSettingsRequest::indicesOptions, updateSettingsRequest::indicesOptions, expectedParams); - if (randomBoolean()) { - updateSettingsRequest.setPreserveExisting(randomBoolean()); - if (updateSettingsRequest.isPreserveExisting()) { - expectedParams.put("preserve_existing", "true"); - } - } - - Request request = RequestConverters.indexPutSettings(updateSettingsRequest); - StringJoiner endpoint = new StringJoiner("/", "/", ""); - if (indices != null && indices.length > 0) { - endpoint.add(String.join(",", indices)); - } - endpoint.add("_settings"); - assertThat(endpoint.toString(), equalTo(request.getEndpoint())); - assertEquals(HttpPut.METHOD_NAME, request.getMethod()); - assertToXContentBody(updateSettingsRequest, request.getEntity()); - assertEquals(expectedParams, request.getParameters()); - } - - public void testPutTemplateRequest() throws Exception { - Map names = new HashMap<>(); - names.put("log", "log"); - names.put("template#1", "template%231"); - names.put("-#template", "-%23template"); - names.put("foo^bar", "foo%5Ebar"); - - PutIndexTemplateRequest putTemplateRequest = new PutIndexTemplateRequest().name(randomFrom(names.keySet())) - .patterns(Arrays.asList(generateRandomStringArray(20, 100, false, false))); - if (randomBoolean()) { - putTemplateRequest.order(randomInt()); - } - if (randomBoolean()) { - putTemplateRequest.version(randomInt()); - } - if (randomBoolean()) { - putTemplateRequest.settings(Settings.builder().put("setting-" + randomInt(), randomTimeValue())); - } - if (randomBoolean()) { - putTemplateRequest.mapping("doc-" + randomInt(), "field-" + randomInt(), "type=" + randomFrom("text", "keyword")); - } - if (randomBoolean()) { - putTemplateRequest.alias(new Alias("alias-" + randomInt())); - } - Map expectedParams = new HashMap<>(); - if (randomBoolean()) { - expectedParams.put("create", Boolean.TRUE.toString()); - putTemplateRequest.create(true); - } - if (randomBoolean()) { - String cause = randomUnicodeOfCodepointLengthBetween(1, 50); - putTemplateRequest.cause(cause); - expectedParams.put("cause", cause); - } - setRandomMasterTimeout(putTemplateRequest, expectedParams); - Request request = RequestConverters.putTemplate(putTemplateRequest); - assertThat(request.getEndpoint(), equalTo("/_template/" + names.get(putTemplateRequest.name()))); - assertThat(request.getParameters(), equalTo(expectedParams)); - assertToXContentBody(putTemplateRequest, request.getEntity()); - } - - public void testValidateQuery() throws Exception { - String[] indices = randomBoolean() ? null : randomIndicesNames(0, 5); - String[] types = randomBoolean() ? generateRandomStringArray(5, 5, false, false) : null; - ValidateQueryRequest validateQueryRequest; - if (randomBoolean()) { - validateQueryRequest = new ValidateQueryRequest(indices); - } else { - validateQueryRequest = new ValidateQueryRequest(); - validateQueryRequest.indices(indices); - } - validateQueryRequest.types(types); - Map expectedParams = new HashMap<>(); - setRandomIndicesOptions(validateQueryRequest::indicesOptions, validateQueryRequest::indicesOptions, expectedParams); - validateQueryRequest.explain(randomBoolean()); - validateQueryRequest.rewrite(randomBoolean()); - validateQueryRequest.allShards(randomBoolean()); - expectedParams.put("explain", Boolean.toString(validateQueryRequest.explain())); - expectedParams.put("rewrite", Boolean.toString(validateQueryRequest.rewrite())); - expectedParams.put("all_shards", Boolean.toString(validateQueryRequest.allShards())); - Request request = RequestConverters.validateQuery(validateQueryRequest); - StringJoiner endpoint = new StringJoiner("/", "/", ""); - if (indices != null && indices.length > 0) { - endpoint.add(String.join(",", indices)); - if (types != null && types.length > 0) { - endpoint.add(String.join(",", types)); - } - } - endpoint.add("_validate/query"); - assertThat(request.getEndpoint(), equalTo(endpoint.toString())); - assertThat(request.getParameters(), equalTo(expectedParams)); - assertToXContentBody(validateQueryRequest, request.getEntity()); - assertThat(request.getMethod(), equalTo(HttpGet.METHOD_NAME)); - } - - public void testGetTemplateRequest() throws Exception { - Map encodes = new HashMap<>(); - encodes.put("log", "log"); - encodes.put("1", "1"); - encodes.put("template#1", "template%231"); - encodes.put("template-*", "template-*"); - encodes.put("foo^bar", "foo%5Ebar"); - List names = randomSubsetOf(1, encodes.keySet()); - GetIndexTemplatesRequest getTemplatesRequest = new GetIndexTemplatesRequest().names(names.toArray(new String[0])); - Map expectedParams = new HashMap<>(); - setRandomMasterTimeout(getTemplatesRequest, expectedParams); - setRandomLocal(getTemplatesRequest, expectedParams); - Request request = RequestConverters.getTemplates(getTemplatesRequest); - assertThat(request.getEndpoint(), equalTo("/_template/" + names.stream().map(encodes::get).collect(Collectors.joining(",")))); - assertThat(request.getParameters(), equalTo(expectedParams)); - assertThat(request.getEntity(), nullValue()); - } - public void testPutScript() throws Exception { PutStoredScriptRequest putStoredScriptRequest = new PutStoredScriptRequest(); @@ -2289,7 +1478,7 @@ public class RequestConvertersTests extends ESTestCase { } } - private static void setRandomIncludeDefaults(GetIndexRequest request, Map expectedParams) { + static void setRandomIncludeDefaults(GetIndexRequest request, Map expectedParams) { if (randomBoolean()) { boolean includeDefaults = randomBoolean(); request.includeDefaults(includeDefaults); @@ -2299,7 +1488,7 @@ public class RequestConvertersTests extends ESTestCase { } } - private static void setRandomHumanReadable(GetIndexRequest request, Map expectedParams) { + static void setRandomHumanReadable(GetIndexRequest request, Map expectedParams) { if (randomBoolean()) { boolean humanReadable = randomBoolean(); request.humanReadable(humanReadable); @@ -2309,7 +1498,7 @@ public class RequestConvertersTests extends ESTestCase { } } - private static void setRandomLocal(Consumer setter, Map expectedParams) { + static void setRandomLocal(Consumer setter, Map expectedParams) { if (randomBoolean()) { boolean local = randomBoolean(); setter.accept(local); @@ -2343,7 +1532,7 @@ public class RequestConvertersTests extends ESTestCase { } } - private static void setRandomWaitForActiveShards(Consumer setter, Map expectedParams) { + static void setRandomWaitForActiveShards(Consumer setter, Map expectedParams) { setRandomWaitForActiveShards(setter, ActiveShardCount.DEFAULT, expectedParams); }