mirror of
https://github.com/honeymoose/OpenSearch.git
synced 2025-02-25 22:36:20 +00:00
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.
This commit is contained in:
Michael Basnight
GitHub
parent
e686909768
commit
42e106fb22
@ -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<AcknowledgedResponse> 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<CreateIndexResponse> 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<AcknowledgedResponse> 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<GetMappingsResponse> 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<GetFieldMappingsResponse> 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<AcknowledgedResponse> 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<OpenIndexResponse> 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<AcknowledgedResponse> 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<Boolean> 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<RefreshResponse> 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<FlushResponse> 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<SyncedFlushResponse> 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<GetSettingsResponse> 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<GetIndexResponse> 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<ForceMergeResponse> 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<ClearIndicesCacheResponse> 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<Boolean> 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<ResizeResponse> 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<ResizeResponse> 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<RolloverResponse> 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<GetAliasesResponse> 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<AcknowledgedResponse> 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<AcknowledgedResponse> 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<ValidateQueryResponse> 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<GetIndexTemplatesResponse> 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<AnalyzeResponse> listener) {
|
||||
restHighLevelClient.performRequestAsyncAndParseEntity(request, RequestConverters::analyze, options,
|
||||
restHighLevelClient.performRequestAsyncAndParseEntity(request, IndicesRequestConverters::analyze, options,
|
||||
AnalyzeResponse::fromXContent, listener, emptySet());
|
||||
}
|
||||
}
|
||||
|
||||
@ -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;
|
||||
}
|
||||
}
|
||||
@ -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);
|
||||
|
||||
@ -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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<ResizeRequest, Request, IOException> function)
|
||||
throws IOException {
|
||||
String[] indices = RequestConvertersTests.randomIndicesNames(2, 2);
|
||||
ResizeRequest resizeRequest = new ResizeRequest(indices[0], indices[1]);
|
||||
resizeRequest.setResizeType(resizeType);
|
||||
Map<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String> names = ESTestCase.randomSubsetOf(1, encodes.keySet());
|
||||
GetIndexTemplatesRequest getTemplatesRequest = new GetIndexTemplatesRequest().names(names.toArray(new String[0]));
|
||||
Map<String, String> 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());
|
||||
}
|
||||
}
|
||||
@ -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<String, String> 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<GetRequest, Request> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<ResizeRequest, Request, IOException> function)
|
||||
throws IOException {
|
||||
String[] indices = randomIndicesNames(2, 2);
|
||||
ResizeRequest resizeRequest = new ResizeRequest(indices[0], indices[1]);
|
||||
resizeRequest.setResizeType(resizeType);
|
||||
Map<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String, String> 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<String> names = randomSubsetOf(1, encodes.keySet());
|
||||
GetIndexTemplatesRequest getTemplatesRequest = new GetIndexTemplatesRequest().names(names.toArray(new String[0]));
|
||||
Map<String, String> 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<String, String> expectedParams) {
|
||||
static void setRandomIncludeDefaults(GetIndexRequest request, Map<String, String> 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<String, String> expectedParams) {
|
||||
static void setRandomHumanReadable(GetIndexRequest request, Map<String, String> expectedParams) {
|
||||
if (randomBoolean()) {
|
||||
boolean humanReadable = randomBoolean();
|
||||
request.humanReadable(humanReadable);
|
||||
@ -2309,7 +1498,7 @@ public class RequestConvertersTests extends ESTestCase {
|
||||
}
|
||||
}
|
||||
|
||||
private static void setRandomLocal(Consumer<Boolean> setter, Map<String, String> expectedParams) {
|
||||
static void setRandomLocal(Consumer<Boolean> setter, Map<String, String> expectedParams) {
|
||||
if (randomBoolean()) {
|
||||
boolean local = randomBoolean();
|
||||
setter.accept(local);
|
||||
@ -2343,7 +1532,7 @@ public class RequestConvertersTests extends ESTestCase {
|
||||
}
|
||||
}
|
||||
|
||||
private static void setRandomWaitForActiveShards(Consumer<ActiveShardCount> setter, Map<String, String> expectedParams) {
|
||||
static void setRandomWaitForActiveShards(Consumer<ActiveShardCount> setter, Map<String, String> expectedParams) {
|
||||
setRandomWaitForActiveShards(setter, ActiveShardCount.DEFAULT, expectedParams);
|
||||
}
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user