honeymoose
/
OpenSearch
mirror of https://github.com/honeymoose/OpenSearch.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[Remove] include_type_name from HLRC (#2397) 

Removes include_type_name from the high level reset client along with relevant
deprecated methods in IndicesClient. All tests are updated to remove the
parameter from the rest requests along with various toXContent methods that are
no longer required.

Signed-off-by: Nicholas Walter Knize <nknize@apache.org>
This commit is contained in:
Nick Knize 2022-03-08 11:30:27 -06:00 committed by GitHub
parent 63c75d1b1d
commit c3712a51b3
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
35 changed files with 65 additions and 1918 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

311
client/rest-high-level/src/main/java/org/opensearch/client/IndicesClient.java
View File

@ -361,60 +361,6 @@ public final class IndicesClient {
);
}
/**
* Creates an index using the Create Index API.
*
* @param createIndexRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @return the response
* @throws IOException in case there is a problem sending the request or parsing back the response
*
* @deprecated This method uses an old request object which still refers to types, a deprecated feature. The
* method {@link #create(CreateIndexRequest, RequestOptions)} should be used instead, which accepts a new
* request object.
*/
@Deprecated
public org.opensearch.action.admin.indices.create.CreateIndexResponse create(
org.opensearch.action.admin.indices.create.CreateIndexRequest createIndexRequest,
RequestOptions options
) throws IOException {
return restHighLevelClient.performRequestAndParseEntity(
createIndexRequest,
IndicesRequestConverters::createIndex,
options,
org.opensearch.action.admin.indices.create.CreateIndexResponse::fromXContent,
emptySet()
);
}
/**
* Asynchronously creates an index using the Create Index API.
*
* @param createIndexRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion
*
* @deprecated This method uses an old request object which still refers to types, a deprecated feature. The
* method {@link #createAsync(CreateIndexRequest, RequestOptions, ActionListener)} should be used instead,
* which accepts a new request object.
* @return cancellable that may be used to cancel the request
*/
@Deprecated
public Cancellable createAsync(
org.opensearch.action.admin.indices.create.CreateIndexRequest createIndexRequest,
RequestOptions options,
ActionListener<org.opensearch.action.admin.indices.create.CreateIndexResponse> listener
) {
return restHighLevelClient.performRequestAsyncAndParseEntity(
createIndexRequest,
IndicesRequestConverters::createIndex,
options,
org.opensearch.action.admin.indices.create.CreateIndexResponse::fromXContent,
listener,
emptySet()
);
}
/**
* Updates the mappings on an index using the Put Mapping API.
*
@ -497,60 +443,6 @@ public final class IndicesClient {
);
}
/**
* Retrieves the field mappings on an index or indices using the Get Field Mapping API.
*
* @param getFieldMappingsRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @return the response
* @throws IOException in case there is a problem sending the request or parsing back the response
*
* @deprecated This method uses old request and response objects which still refer to types, a deprecated feature.
* The method {@link #getFieldMapping(GetFieldMappingsRequest, RequestOptions)} should be used instead, which
* accepts a new request object.
*/
@Deprecated
public org.opensearch.action.admin.indices.mapping.get.GetFieldMappingsResponse getFieldMapping(
org.opensearch.action.admin.indices.mapping.get.GetFieldMappingsRequest getFieldMappingsRequest,
RequestOptions options
) throws IOException {
return restHighLevelClient.performRequestAndParseEntity(
getFieldMappingsRequest,
IndicesRequestConverters::getFieldMapping,
options,
org.opensearch.action.admin.indices.mapping.get.GetFieldMappingsResponse::fromXContent,
emptySet()
);
}
/**
* Asynchronously retrieves the field mappings on an index on indices using the Get Field Mapping API.
*
* @param getFieldMappingsRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion
*
* @deprecated This method uses old request and response objects which still refer to types, a deprecated feature.
* The method {@link #getFieldMappingAsync(GetFieldMappingsRequest, RequestOptions, ActionListener)} should be
* used instead, which accepts a new request object.
* @return cancellable that may be used to cancel the request
*/
@Deprecated
public Cancellable getFieldMappingAsync(
org.opensearch.action.admin.indices.mapping.get.GetFieldMappingsRequest getFieldMappingsRequest,
RequestOptions options,
ActionListener<org.opensearch.action.admin.indices.mapping.get.GetFieldMappingsResponse> listener
) {
return restHighLevelClient.performRequestAsyncAndParseEntity(
getFieldMappingsRequest,
IndicesRequestConverters::getFieldMapping,
options,
org.opensearch.action.admin.indices.mapping.get.GetFieldMappingsResponse::fromXContent,
listener,
emptySet()
);
}
/**
* Retrieves the field mappings on an index or indices using the Get Field Mapping API.
*
@ -1053,53 +945,6 @@ public final class IndicesClient {
);
}
/**
* Checks if the index (indices) exists or not.
*
* @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @return the response
* @throws IOException in case there is a problem sending the request
* @deprecated This method uses an old request object which still refers to types, a deprecated feature. The method
* {@link #exists(GetIndexRequest, RequestOptions)} should be used instead, which accepts a new request object.
*/
@Deprecated
public boolean exists(org.opensearch.action.admin.indices.get.GetIndexRequest request, RequestOptions options) throws IOException {
return restHighLevelClient.performRequest(
request,
IndicesRequestConverters::indicesExist,
options,
RestHighLevelClient::convertExistsResponse,
Collections.emptySet()
);
}
/**
* Asynchronously checks if the index (indices) exists or not.
*
* @param request the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion
* @deprecated This method uses an old request object which still refers to types, a deprecated feature. The method
* {@link #existsAsync(GetIndexRequest, RequestOptions, ActionListener)} should be used instead, which accepts a new request object.
* @return cancellable that may be used to cancel the request
*/
@Deprecated
public Cancellable existsAsync(
org.opensearch.action.admin.indices.get.GetIndexRequest request,
RequestOptions options,
ActionListener<Boolean> listener
) {
return restHighLevelClient.performRequestAsync(
request,
IndicesRequestConverters::indicesExist,
options,
RestHighLevelClient::convertExistsResponse,
listener,
Collections.emptySet()
);
}
/**
* Shrinks an index using the Shrink Index API.
*
@ -1392,59 +1237,6 @@ public final class IndicesClient {
);
}
/**
* Rolls over an index using the Rollover Index API.
*
* @param rolloverRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @return the response
* @throws IOException in case there is a problem sending the request or parsing back the response
*
* @deprecated This method uses deprecated request and response objects.
* The method {@link #rollover(RolloverRequest, RequestOptions)} should be used instead, which accepts a new request object.
*/
@Deprecated
public org.opensearch.action.admin.indices.rollover.RolloverResponse rollover(
org.opensearch.action.admin.indices.rollover.RolloverRequest rolloverRequest,
RequestOptions options
) throws IOException {
return restHighLevelClient.performRequestAndParseEntity(
rolloverRequest,
IndicesRequestConverters::rollover,
options,
org.opensearch.action.admin.indices.rollover.RolloverResponse::fromXContent,
emptySet()
);
}
/**
* Asynchronously rolls over an index using the Rollover Index API.
*
* @param rolloverRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion
*
* @deprecated This method uses deprecated request and response objects.
* The method {@link #rolloverAsync(RolloverRequest, RequestOptions, ActionListener)} should be used instead, which
* accepts a new request object.
* @return cancellable that may be used to cancel the request
*/
@Deprecated
public Cancellable rolloverAsync(
org.opensearch.action.admin.indices.rollover.RolloverRequest rolloverRequest,
RequestOptions options,
ActionListener<org.opensearch.action.admin.indices.rollover.RolloverResponse> listener
) {
return restHighLevelClient.performRequestAsyncAndParseEntity(
rolloverRequest,
IndicesRequestConverters::rollover,
options,
org.opensearch.action.admin.indices.rollover.RolloverResponse::fromXContent,
listener,
emptySet()
);
}
/**
* Gets one or more aliases using the Get Index Aliases API.
*
@ -1527,57 +1319,6 @@ public final class IndicesClient {
);
}
/**
* Puts an index template using the Index Templates API.
*
* @param putIndexTemplateRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @return the response
* @throws IOException in case there is a problem sending the request or parsing back the response
* @deprecated This old form of request allows types in mappings. Use {@link #putTemplate(PutIndexTemplateRequest, RequestOptions)}
* instead which introduces a new request object without types.
*/
@Deprecated
public AcknowledgedResponse putTemplate(
org.opensearch.action.admin.indices.template.put.PutIndexTemplateRequest putIndexTemplateRequest,
RequestOptions options
) throws IOException {
return restHighLevelClient.performRequestAndParseEntity(
putIndexTemplateRequest,
IndicesRequestConverters::putTemplate,
options,
AcknowledgedResponse::fromXContent,
emptySet()
);
}
/**
* Asynchronously puts an index template using the Index Templates API.
*
* @param putIndexTemplateRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion
* @deprecated This old form of request allows types in mappings.
* Use {@link #putTemplateAsync(PutIndexTemplateRequest, RequestOptions, ActionListener)}
* instead which introduces a new request object without types.
* @return cancellable that may be used to cancel the request
*/
@Deprecated
public Cancellable putTemplateAsync(
org.opensearch.action.admin.indices.template.put.PutIndexTemplateRequest putIndexTemplateRequest,
RequestOptions options,
ActionListener<AcknowledgedResponse> listener
) {
return restHighLevelClient.performRequestAsyncAndParseEntity(
putIndexTemplateRequest,
IndicesRequestConverters::putTemplate,
options,
AcknowledgedResponse::fromXContent,
listener,
emptySet()
);
}
/**
* Puts an index template using the Index Templates API.
*
@ -1749,31 +1490,6 @@ public final class IndicesClient {
);
}
/**
* Gets index templates using the Index Templates API. The mappings will be returned in a legacy deprecated format, where the
* mapping definition is nested under the type name.
*
* @param getIndexTemplatesRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @return the response
* @throws IOException in case there is a problem sending the request or parsing back the response
* @deprecated This method uses an old response object which still refers to types, a deprecated feature. Use
* {@link #getIndexTemplate(GetIndexTemplatesRequest, RequestOptions)} instead which returns a new response object
*/
@Deprecated
public org.opensearch.action.admin.indices.template.get.GetIndexTemplatesResponse getTemplate(
GetIndexTemplatesRequest getIndexTemplatesRequest,
RequestOptions options
) throws IOException {
return restHighLevelClient.performRequestAndParseEntity(
getIndexTemplatesRequest,
IndicesRequestConverters::getTemplatesWithDocumentTypes,
options,
org.opensearch.action.admin.indices.template.get.GetIndexTemplatesResponse::fromXContent,
emptySet()
);
}
/**
* Gets index templates using the Index Templates API
*
@ -1837,33 +1553,6 @@ public final class IndicesClient {
);
}
/**
* Asynchronously gets index templates using the Index Templates API. The mappings will be returned in a legacy deprecated format,
* where the mapping definition is nested under the type name.
*
* @param getIndexTemplatesRequest the request
* @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
* @param listener the listener to be notified upon request completion
* @deprecated This method uses an old response object which still refers to types, a deprecated feature. Use
* {@link #getIndexTemplateAsync(GetIndexTemplatesRequest, RequestOptions, ActionListener)} instead which returns a new response object
* @return cancellable that may be used to cancel the request
*/
@Deprecated
public Cancellable getTemplateAsync(
GetIndexTemplatesRequest getIndexTemplatesRequest,
RequestOptions options,
ActionListener<org.opensearch.action.admin.indices.template.get.GetIndexTemplatesResponse> listener
) {
return restHighLevelClient.performRequestAsyncAndParseEntity(
getIndexTemplatesRequest,
IndicesRequestConverters::getTemplatesWithDocumentTypes,
options,
org.opensearch.action.admin.indices.template.get.GetIndexTemplatesResponse::fromXContent,
listener,
emptySet()
);
}
/**
* Asynchronously gets index templates using the Index Templates API
*

142
client/rest-high-level/src/main/java/org/opensearch/client/IndicesRequestConverters.java
View File

@ -78,8 +78,6 @@ import org.opensearch.common.Strings;
import java.io.IOException;
import java.util.Locale;
import static org.opensearch.rest.BaseRestHandler.INCLUDE_TYPE_NAME_PARAMETER;
final class IndicesRequestConverters {
private IndicesRequestConverters() {}
@ -165,20 +163,6 @@ final class IndicesRequestConverters {
return request;
}
static Request createIndex(org.opensearch.action.admin.indices.create.CreateIndexRequest createIndexRequest) throws IOException {
String endpoint = RequestConverters.endpoint(createIndexRequest.indices());
Request request = new Request(HttpPut.METHOD_NAME, endpoint);
RequestConverters.Params parameters = new RequestConverters.Params();
parameters.withTimeout(createIndexRequest.timeout());
parameters.withMasterTimeout(createIndexRequest.masterNodeTimeout());
parameters.withWaitForActiveShards(createIndexRequest.waitForActiveShards());
parameters.putParam(INCLUDE_TYPE_NAME_PARAMETER, "true");
request.addParameters(parameters.asMap());
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");
@ -234,30 +218,6 @@ final class IndicesRequestConverters {
return request;
}
@Deprecated
static Request getFieldMapping(org.opensearch.action.admin.indices.mapping.get.GetFieldMappingsRequest getFieldMappingsRequest) {
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();
parameters.withIndicesOptions(getFieldMappingsRequest.indicesOptions());
parameters.withIncludeDefaults(getFieldMappingsRequest.includeDefaults());
parameters.withLocal(getFieldMappingsRequest.local());
parameters.putParam(INCLUDE_TYPE_NAME_PARAMETER, "true");
request.addParameters(parameters.asMap());
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"));
@ -415,27 +375,6 @@ final class IndicesRequestConverters {
return request;
}
@Deprecated
static Request rollover(org.opensearch.action.admin.indices.rollover.RolloverRequest rolloverRequest) throws IOException {
String endpoint = new RequestConverters.EndpointBuilder().addPathPart(rolloverRequest.getRolloverTarget())
.addPathPartAsIs("_rollover")
.addPathPart(rolloverRequest.getNewIndexName())
.build();
Request request = new Request(HttpPost.METHOD_NAME, endpoint);
RequestConverters.Params params = new RequestConverters.Params();
params.withTimeout(rolloverRequest.timeout());
params.withMasterTimeout(rolloverRequest.masterNodeTimeout());
params.withWaitForActiveShards(rolloverRequest.getCreateIndexRequest().waitForActiveShards());
if (rolloverRequest.isDryRun()) {
params.putParam("dry_run", Boolean.TRUE.toString());
}
params.putParam(INCLUDE_TYPE_NAME_PARAMETER, "true");
request.setEntity(RequestConverters.createEntity(rolloverRequest, RequestConverters.REQUEST_BODY_CONTENT_TYPE));
request.addParameters(params.asMap());
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();
@ -452,28 +391,6 @@ final class IndicesRequestConverters {
return request;
}
/**
* converter for the legacy server-side {@link org.opensearch.action.admin.indices.get.GetIndexRequest} that
* still supports types
*/
@Deprecated
static Request getIndex(org.opensearch.action.admin.indices.get.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();
params.withIndicesOptions(getIndexRequest.indicesOptions());
params.withLocal(getIndexRequest.local());
params.withIncludeDefaults(getIndexRequest.includeDefaults());
params.withHuman(getIndexRequest.humanReadable());
params.withMasterTimeout(getIndexRequest.masterNodeTimeout());
params.putParam(INCLUDE_TYPE_NAME_PARAMETER, "true");
request.addParameters(params.asMap());
return request;
}
static Request getIndex(GetIndexRequest getIndexRequest) {
String[] indices = getIndexRequest.indices() == null ? Strings.EMPTY_ARRAY : getIndexRequest.indices();
@ -490,28 +407,6 @@ final class IndicesRequestConverters {
return request;
}
/**
* converter for the legacy server-side {@link org.opensearch.action.admin.indices.get.GetIndexRequest} that
* still supports types
*/
@Deprecated
static Request indicesExist(org.opensearch.action.admin.indices.get.GetIndexRequest getIndexRequest) {
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();
params.withLocal(getIndexRequest.local());
params.withHuman(getIndexRequest.humanReadable());
params.withIndicesOptions(getIndexRequest.indicesOptions());
params.withIncludeDefaults(getIndexRequest.includeDefaults());
params.putParam(INCLUDE_TYPE_NAME_PARAMETER, "true");
request.addParameters(params.asMap());
return request;
}
static Request indicesExist(GetIndexRequest getIndexRequest) {
if (getIndexRequest.indices() == null || getIndexRequest.indices().length == 0) {
throw new IllegalArgumentException("indices are mandatory");
@ -542,31 +437,6 @@ final class IndicesRequestConverters {
return request;
}
/**
* @deprecated This uses the old form of PutIndexTemplateRequest which uses types.
* Use (@link {@link #putTemplate(PutIndexTemplateRequest)} instead
*/
@Deprecated
static Request putTemplate(org.opensearch.action.admin.indices.template.put.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();
params.withMasterTimeout(putIndexTemplateRequest.masterNodeTimeout());
if (putIndexTemplateRequest.create()) {
params.putParam("create", Boolean.TRUE.toString());
}
if (Strings.hasText(putIndexTemplateRequest.cause())) {
params.putParam("cause", putIndexTemplateRequest.cause());
}
params.putParam(INCLUDE_TYPE_NAME_PARAMETER, "true");
request.addParameters(params.asMap());
request.setEntity(RequestConverters.createEntity(putIndexTemplateRequest, RequestConverters.REQUEST_BODY_CONTENT_TYPE));
return request;
}
static Request putTemplate(PutIndexTemplateRequest putIndexTemplateRequest) throws IOException {
String endpoint = new RequestConverters.EndpointBuilder().addPathPartAsIs("_template")
.addPathPart(putIndexTemplateRequest.name())
@ -652,16 +522,7 @@ final class IndicesRequestConverters {
return request;
}
@Deprecated
static Request getTemplatesWithDocumentTypes(GetIndexTemplatesRequest getIndexTemplatesRequest) {
return getTemplates(getIndexTemplatesRequest, true);
}
static Request getTemplates(GetIndexTemplatesRequest getIndexTemplatesRequest) {
return getTemplates(getIndexTemplatesRequest, false);
}
private static Request getTemplates(GetIndexTemplatesRequest getIndexTemplatesRequest, boolean includeTypeName) {
final String endpoint = new RequestConverters.EndpointBuilder().addPathPartAsIs("_template")
.addCommaSeparatedPathParts(getIndexTemplatesRequest.names())
.build();
@ -669,9 +530,6 @@ final class IndicesRequestConverters {
final RequestConverters.Params params = new RequestConverters.Params();
params.withLocal(getIndexTemplatesRequest.isLocal());
params.withMasterTimeout(getIndexTemplatesRequest.getMasterNodeTimeout());
if (includeTypeName) {
params.putParam(INCLUDE_TYPE_NAME_PARAMETER, "true");
}
request.addParameters(params.asMap());
return request;
}

305
client/rest-high-level/src/test/java/org/opensearch/client/IndicesClientIT.java
View File

@ -122,14 +122,9 @@ import org.opensearch.common.xcontent.XContentType;
import org.opensearch.common.xcontent.json.JsonXContent;
import org.opensearch.common.xcontent.support.XContentMapValues;
import org.opensearch.index.IndexSettings;
import org.opensearch.index.mapper.MapperService;
import org.opensearch.index.query.QueryBuilder;
import org.opensearch.index.query.QueryBuilders;
import org.opensearch.rest.RestStatus;
import org.opensearch.rest.action.admin.indices.RestCreateIndexAction;
import org.opensearch.rest.action.admin.indices.RestGetIndexTemplateAction;
import org.opensearch.rest.action.admin.indices.RestPutIndexTemplateAction;
import org.opensearch.rest.action.admin.indices.RestRolloverIndexAction;
import java.io.IOException;
import java.util.Arrays;
@ -197,18 +192,6 @@ public class IndicesClientIT extends OpenSearchRestHighLevelClientTestCase {
}
}
public void testIndicesExistsWithTypes() throws IOException {
// Index present
String indexName = "test_index_exists_index_present";
createIndex(indexName, Settings.EMPTY);
org.opensearch.action.admin.indices.get.GetIndexRequest request = new org.opensearch.action.admin.indices.get.GetIndexRequest();
request.indices(indexName);
boolean response = execute(request, highLevelClient().indices()::exists, highLevelClient().indices()::existsAsync);
assertTrue(response);
}
@SuppressWarnings({ "unchecked", "rawtypes" })
public void testCreateIndex() throws IOException {
{
@ -273,74 +256,6 @@ public class IndicesClientIT extends OpenSearchRestHighLevelClientTestCase {
}
}
@SuppressWarnings({ "unchecked", "rawtypes" })
public void testCreateIndexWithTypes() throws IOException {
{
// Create index
String indexName = "plain_index";
assertFalse(indexExists(indexName));
org.opensearch.action.admin.indices.create.CreateIndexRequest createIndexRequest =
new org.opensearch.action.admin.indices.create.CreateIndexRequest(indexName);
org.opensearch.action.admin.indices.create.CreateIndexResponse createIndexResponse = execute(
createIndexRequest,
highLevelClient().indices()::create,
highLevelClient().indices()::createAsync,
expectWarningsOnce(RestCreateIndexAction.TYPES_DEPRECATION_MESSAGE)
);
assertTrue(createIndexResponse.isAcknowledged());
assertTrue(indexExists(indexName));
}
{
// Create index with mappings, aliases and settings
String indexName = "rich_index";
assertFalse(indexExists(indexName));
org.opensearch.action.admin.indices.create.CreateIndexRequest createIndexRequest =
new org.opensearch.action.admin.indices.create.CreateIndexRequest(indexName);
Alias alias = new Alias("alias_name");
alias.filter("{\"term\":{\"year\":2016}}");
alias.routing("1");
createIndexRequest.alias(alias);
Settings.Builder settings = Settings.builder();
settings.put(SETTING_NUMBER_OF_REPLICAS, 2);
createIndexRequest.settings(settings);
XContentBuilder mappingBuilder = JsonXContent.contentBuilder();
mappingBuilder.startObject().startObject("properties").startObject("field");
mappingBuilder.field("type", "text");
mappingBuilder.endObject().endObject().endObject();
createIndexRequest.mapping(MapperService.SINGLE_MAPPING_NAME, mappingBuilder);
org.opensearch.action.admin.indices.create.CreateIndexResponse createIndexResponse = execute(
createIndexRequest,
highLevelClient().indices()::create,
highLevelClient().indices()::createAsync,
expectWarningsOnce(RestCreateIndexAction.TYPES_DEPRECATION_MESSAGE)
);
assertTrue(createIndexResponse.isAcknowledged());
Map<String, Object> getIndexResponse = getAsMap(indexName);
assertEquals("2", XContentMapValues.extractValue(indexName + ".settings.index.number_of_replicas", getIndexResponse));
Map<String, Object> aliasData = (Map<String, Object>) XContentMapValues.extractValue(
indexName + ".aliases.alias_name",
getIndexResponse
);
assertNotNull(aliasData);
assertEquals("1", aliasData.get("index_routing"));
Map<String, Object> filter = (Map) aliasData.get("filter");
Map<String, Object> term = (Map) filter.get("term");
assertEquals(2016, term.get("year"));
assertEquals("text", XContentMapValues.extractValue(indexName + ".mappings.properties.field.type", getIndexResponse));
}
}
public void testGetSettings() throws IOException {
String indexName = "get_settings_index";
Settings basicSettings = Settings.builder().put("number_of_shards", 1).put("number_of_replicas", 0).build();
@ -1179,33 +1094,6 @@ public class IndicesClientIT extends OpenSearchRestHighLevelClientTestCase {
}
}
public void testRolloverWithTypes() throws IOException {
highLevelClient().indices().create(new CreateIndexRequest("test").alias(new Alias("alias")), RequestOptions.DEFAULT);
highLevelClient().index(new IndexRequest("test").id("1").source("field", "value"), RequestOptions.DEFAULT);
highLevelClient().index(
new IndexRequest("test").id("2").source("field", "value").setRefreshPolicy(WriteRequest.RefreshPolicy.WAIT_UNTIL),
RequestOptions.DEFAULT
);
org.opensearch.action.admin.indices.rollover.RolloverRequest rolloverRequest =
new org.opensearch.action.admin.indices.rollover.RolloverRequest("alias", "test_new");
rolloverRequest.addMaxIndexDocsCondition(1);
rolloverRequest.getCreateIndexRequest().mapping("_doc", "field2", "type=keyword");
org.opensearch.action.admin.indices.rollover.RolloverResponse rolloverResponse = execute(
rolloverRequest,
highLevelClient().indices()::rollover,
highLevelClient().indices()::rolloverAsync,
expectWarningsOnce(RestRolloverIndexAction.TYPES_DEPRECATION_MESSAGE)
);
assertTrue(rolloverResponse.isRolledOver());
assertFalse(rolloverResponse.isDryRun());
Map<String, Boolean> conditionStatus = rolloverResponse.getConditionStatus();
assertTrue(conditionStatus.get("[max_docs: 1]"));
assertEquals("test", rolloverResponse.getOldIndex());
assertEquals("test_new", rolloverResponse.getNewIndex());
}
public void testGetAlias() throws IOException {
{
createIndex("index1", Settings.EMPTY);
@ -1686,48 +1574,6 @@ public class IndicesClientIT extends OpenSearchRestHighLevelClientTestCase {
);
}
@SuppressWarnings("unchecked")
public void testPutTemplateWithNoTypesUsingTypedApi() throws Exception {
org.opensearch.action.admin.indices.template.put.PutIndexTemplateRequest putTemplateRequest =
new org.opensearch.action.admin.indices.template.put.PutIndexTemplateRequest().name("my-template")
.patterns(Arrays.asList("pattern-1", "name-*"))
.order(10)
.create(randomBoolean())
.settings(Settings.builder().put("number_of_shards", "3").put("number_of_replicas", "0"))
.mapping(
"my_doc_type",
// Note that the declared type is missing from the mapping
"{ "
+ "\"properties\":{"
+ "\"host_name\": {\"type\":\"keyword\"},"
+ "\"description\": {\"type\":\"text\"}"
+ "}"
+ "}",
XContentType.JSON
)
.alias(new Alias("alias-1").indexRouting("abc"))
.alias(new Alias("{index}-write").searchRouting("xyz"));
AcknowledgedResponse putTemplateResponse = execute(
putTemplateRequest,
highLevelClient().indices()::putTemplate,
highLevelClient().indices()::putTemplateAsync,
expectWarningsOnce(RestPutIndexTemplateAction.TYPES_DEPRECATION_MESSAGE)
);
assertThat(putTemplateResponse.isAcknowledged(), equalTo(true));
Map<String, Object> templates = getAsMap("/_template/my-template");
assertThat(templates.keySet(), hasSize(1));
assertThat(extractValue("my-template.order", templates), equalTo(10));
assertThat(extractRawValues("my-template.index_patterns", templates), contains("pattern-1", "name-*"));
assertThat(extractValue("my-template.settings.index.number_of_shards", templates), equalTo("3"));
assertThat(extractValue("my-template.settings.index.number_of_replicas", templates), equalTo("0"));
assertThat(extractValue("my-template.mappings.properties.host_name.type", templates), equalTo("keyword"));
assertThat(extractValue("my-template.mappings.properties.description.type", templates), equalTo("text"));
assertThat((Map<String, String>) extractValue("my-template.aliases.alias-1", templates), hasEntry("index_routing", "abc"));
assertThat((Map<String, String>) extractValue("my-template.aliases.{index}-write", templates), hasEntry("search_routing", "xyz"));
}
public void testPutTemplateBadRequests() throws Exception {
RestHighLevelClient client = highLevelClient();
@ -1809,157 +1655,6 @@ public class IndicesClientIT extends OpenSearchRestHighLevelClientTestCase {
assertFalse(response.isValid());
}
// Tests the deprecated form of the API that returns templates with doc types (using the server-side's GetIndexTemplateResponse)
public void testCRUDIndexTemplateWithTypes() throws Exception {
RestHighLevelClient client = highLevelClient();
org.opensearch.action.admin.indices.template.put.PutIndexTemplateRequest putTemplate1 =
new org.opensearch.action.admin.indices.template.put.PutIndexTemplateRequest().name("template-1")
.patterns(Arrays.asList("pattern-1", "name-1"))
.alias(new Alias("alias-1"));
assertThat(
execute(
putTemplate1,
client.indices()::putTemplate,
client.indices()::putTemplateAsync,
expectWarningsOnce(RestPutIndexTemplateAction.TYPES_DEPRECATION_MESSAGE)
).isAcknowledged(),
equalTo(true)
);
org.opensearch.action.admin.indices.template.put.PutIndexTemplateRequest putTemplate2 =
new org.opensearch.action.admin.indices.template.put.PutIndexTemplateRequest().name("template-2")
.patterns(Arrays.asList("pattern-2", "name-2"))
.mapping("custom_doc_type", "name", "type=text")
.settings(Settings.builder().put("number_of_shards", "2").put("number_of_replicas", "0"));
assertThat(
execute(
putTemplate2,
client.indices()::putTemplate,
client.indices()::putTemplateAsync,
expectWarningsOnce(RestPutIndexTemplateAction.TYPES_DEPRECATION_MESSAGE)
).isAcknowledged(),
equalTo(true)
);
org.opensearch.action.admin.indices.template.get.GetIndexTemplatesResponse getTemplate1 = execute(
new GetIndexTemplatesRequest("template-1"),
client.indices()::getTemplate,
client.indices()::getTemplateAsync,
expectWarningsOnce(RestGetIndexTemplateAction.TYPES_DEPRECATION_MESSAGE)
);
assertThat(getTemplate1.getIndexTemplates(), hasSize(1));
org.opensearch.cluster.metadata.IndexTemplateMetadata template1 = getTemplate1.getIndexTemplates().get(0);
assertThat(template1.name(), equalTo("template-1"));
assertThat(template1.patterns(), contains("pattern-1", "name-1"));
assertTrue(template1.aliases().containsKey("alias-1"));
// Check the typed version of the call
org.opensearch.action.admin.indices.template.get.GetIndexTemplatesResponse getTemplate2 = execute(
new GetIndexTemplatesRequest("template-2"),
client.indices()::getTemplate,
client.indices()::getTemplateAsync,
expectWarningsOnce(RestGetIndexTemplateAction.TYPES_DEPRECATION_MESSAGE)
);
assertThat(getTemplate2.getIndexTemplates(), hasSize(1));
org.opensearch.cluster.metadata.IndexTemplateMetadata template2 = getTemplate2.getIndexTemplates().get(0);
assertThat(template2.name(), equalTo("template-2"));
assertThat(template2.patterns(), contains("pattern-2", "name-2"));
assertTrue(template2.aliases().isEmpty());
assertThat(template2.settings().get("index.number_of_shards"), equalTo("2"));
assertThat(template2.settings().get("index.number_of_replicas"), equalTo("0"));
// Ugly deprecated form of API requires use of doc type to get at mapping object which is CompressedXContent
assertTrue(template2.mappings().containsKey("custom_doc_type"));
List<String> names = randomBoolean() ? Arrays.asList("*plate-1", "template-2") : Arrays.asList("template-*");
GetIndexTemplatesRequest getBothRequest = new GetIndexTemplatesRequest(names);
org.opensearch.action.admin.indices.template.get.GetIndexTemplatesResponse getBoth = execute(
getBothRequest,
client.indices()::getTemplate,
client.indices()::getTemplateAsync,
expectWarningsOnce(RestGetIndexTemplateAction.TYPES_DEPRECATION_MESSAGE)
);
assertThat(getBoth.getIndexTemplates(), hasSize(2));
assertThat(
getBoth.getIndexTemplates().stream().map(org.opensearch.cluster.metadata.IndexTemplateMetadata::getName).toArray(),
arrayContainingInAnyOrder("template-1", "template-2")
);
GetIndexTemplatesRequest getAllRequest = new GetIndexTemplatesRequest();
org.opensearch.action.admin.indices.template.get.GetIndexTemplatesResponse getAll = execute(
getAllRequest,
client.indices()::getTemplate,
client.indices()::getTemplateAsync,
expectWarningsOnce(RestGetIndexTemplateAction.TYPES_DEPRECATION_MESSAGE)
);
assertThat(getAll.getIndexTemplates().size(), greaterThanOrEqualTo(2));
assertThat(
getAll.getIndexTemplates()
.stream()
.map(org.opensearch.cluster.metadata.IndexTemplateMetadata::getName)
.collect(Collectors.toList()),
hasItems("template-1", "template-2")
);
assertTrue(
execute(new DeleteIndexTemplateRequest("template-1"), client.indices()::deleteTemplate, client.indices()::deleteTemplateAsync)
.isAcknowledged()
);
assertThat(
expectThrows(
OpenSearchException.class,
() -> execute(new GetIndexTemplatesRequest("template-1"), client.indices()::getTemplate, client.indices()::getTemplateAsync)
).status(),
equalTo(RestStatus.NOT_FOUND)
);
assertThat(
expectThrows(
OpenSearchException.class,
() -> execute(
new DeleteIndexTemplateRequest("template-1"),
client.indices()::deleteTemplate,
client.indices()::deleteTemplateAsync
)
).status(),
equalTo(RestStatus.NOT_FOUND)
);
assertThat(
execute(
new GetIndexTemplatesRequest("template-*"),
client.indices()::getTemplate,
client.indices()::getTemplateAsync,
expectWarningsOnce(RestGetIndexTemplateAction.TYPES_DEPRECATION_MESSAGE)
).getIndexTemplates(),
hasSize(1)
);
assertThat(
execute(
new GetIndexTemplatesRequest("template-*"),
client.indices()::getTemplate,
client.indices()::getTemplateAsync,
expectWarningsOnce(RestGetIndexTemplateAction.TYPES_DEPRECATION_MESSAGE)
).getIndexTemplates().get(0).name(),
equalTo("template-2")
);
assertTrue(
execute(new DeleteIndexTemplateRequest("template-*"), client.indices()::deleteTemplate, client.indices()::deleteTemplateAsync)
.isAcknowledged()
);
assertThat(
expectThrows(
OpenSearchException.class,
() -> execute(
new GetIndexTemplatesRequest("template-*"),
client.indices()::getTemplate,
client.indices()::getTemplateAsync,
expectWarningsOnce(RestGetIndexTemplateAction.TYPES_DEPRECATION_MESSAGE)
)
).status(),
equalTo(RestStatus.NOT_FOUND)
);
}
public void testCRUDIndexTemplate() throws Exception {
RestHighLevelClient client = highLevelClient();

247
client/rest-high-level/src/test/java/org/opensearch/client/IndicesRequestConvertersTests.java
View File

@ -96,7 +96,6 @@ import static org.opensearch.client.indices.RandomCreateIndexGenerator.randomMap
import static org.opensearch.index.RandomCreateIndexGenerator.randomAlias;
import static org.opensearch.index.RandomCreateIndexGenerator.randomIndexSettings;
import static org.opensearch.index.alias.RandomAliasActionsGenerator.randomAliasAction;
import static org.opensearch.rest.BaseRestHandler.INCLUDE_TYPE_NAME_PARAMETER;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.Matchers.nullValue;
@ -140,40 +139,6 @@ public class IndicesRequestConvertersTests extends OpenSearchTestCase {
);
}
public void testIndicesExistEmptyIndicesWithTypes() {
LuceneTestCase.expectThrows(
IllegalArgumentException.class,
() -> IndicesRequestConverters.indicesExist(new org.opensearch.action.admin.indices.get.GetIndexRequest())
);
LuceneTestCase.expectThrows(
IllegalArgumentException.class,
() -> IndicesRequestConverters.indicesExist(
new org.opensearch.action.admin.indices.get.GetIndexRequest().indices((String[]) null)
)
);
}
public void testIndicesExistWithTypes() {
String[] indices = RequestConvertersTests.randomIndicesNames(1, 10);
org.opensearch.action.admin.indices.get.GetIndexRequest getIndexRequest =
new org.opensearch.action.admin.indices.get.GetIndexRequest().indices(indices);
Map<String, String> expectedParams = new HashMap<>();
RequestConvertersTests.setRandomIndicesOptions(getIndexRequest::indicesOptions, getIndexRequest::indicesOptions, expectedParams);
RequestConvertersTests.setRandomLocal(getIndexRequest::local, expectedParams);
RequestConvertersTests.setRandomHumanReadable(getIndexRequest::humanReadable, expectedParams);
RequestConvertersTests.setRandomIncludeDefaults(getIndexRequest::includeDefaults, expectedParams);
expectedParams.put(INCLUDE_TYPE_NAME_PARAMETER, "true");
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 testCreateIndex() throws IOException {
CreateIndexRequest createIndexRequest = RandomCreateIndexGenerator.randomCreateIndexRequest();
@ -189,23 +154,6 @@ public class IndicesRequestConvertersTests extends OpenSearchTestCase {
RequestConvertersTests.assertToXContentBody(createIndexRequest, request.getEntity());
}
public void testCreateIndexWithTypes() throws IOException {
org.opensearch.action.admin.indices.create.CreateIndexRequest createIndexRequest = org.opensearch.index.RandomCreateIndexGenerator
.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);
expectedParams.put(INCLUDE_TYPE_NAME_PARAMETER, "true");
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() {
IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> new CreateIndexRequest(null));
assertEquals(e.getMessage(), "The index name cannot be null.");
@ -332,67 +280,6 @@ public class IndicesRequestConvertersTests extends OpenSearchTestCase {
Assert.assertThat(HttpGet.METHOD_NAME, equalTo(request.getMethod()));
}
public void testGetFieldMappingWithTypes() {
org.opensearch.action.admin.indices.mapping.get.GetFieldMappingsRequest getFieldMappingsRequest =
new org.opensearch.action.admin.indices.mapping.get.GetFieldMappingsRequest();
String[] indices = Strings.EMPTY_ARRAY;
if (randomBoolean()) {
indices = RequestConvertersTests.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<>();
RequestConvertersTests.setRandomIndicesOptions(
getFieldMappingsRequest::indicesOptions,
getFieldMappingsRequest::indicesOptions,
expectedParams
);
RequestConvertersTests.setRandomLocal(getFieldMappingsRequest::local, expectedParams);
expectedParams.put(INCLUDE_TYPE_NAME_PARAMETER, "true");
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 testPutDataStream() {
String name = randomAlphaOfLength(10);
CreateDataStreamRequest createDataStreamRequest = new CreateDataStreamRequest(name);
@ -525,41 +412,6 @@ public class IndicesRequestConvertersTests extends OpenSearchTestCase {
Assert.assertThat(request.getEntity(), nullValue());
}
public void testGetIndexWithTypes() throws IOException {
String[] indicesUnderTest = OpenSearchTestCase.randomBoolean() ? null : RequestConvertersTests.randomIndicesNames(0, 5);
org.opensearch.action.admin.indices.get.GetIndexRequest getIndexRequest =
new org.opensearch.action.admin.indices.get.GetIndexRequest().indices(indicesUnderTest);
Map<String, String> expectedParams = new HashMap<>();
RequestConvertersTests.setRandomMasterTimeout(getIndexRequest, expectedParams);
RequestConvertersTests.setRandomIndicesOptions(getIndexRequest::indicesOptions, getIndexRequest::indicesOptions, expectedParams);
RequestConvertersTests.setRandomLocal(getIndexRequest::local, expectedParams);
RequestConvertersTests.setRandomHumanReadable(getIndexRequest::humanReadable, expectedParams);
expectedParams.put(INCLUDE_TYPE_NAME_PARAMETER, "true");
if (OpenSearchTestCase.randomBoolean()) {
// the request object will not have include_defaults present unless it is set to
// true
getIndexRequest.includeDefaults(OpenSearchTestCase.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 = OpenSearchTestCase.randomBoolean() ? null : Strings.EMPTY_ARRAY;
ActionRequestValidationException validationException = new DeleteIndexRequest(indices).validate();
@ -906,51 +758,6 @@ public class IndicesRequestConvertersTests extends OpenSearchTestCase {
Assert.assertEquals(expectedParams, request.getParameters());
}
public void testRolloverWithTypes() throws IOException {
org.opensearch.action.admin.indices.rollover.RolloverRequest rolloverRequest =
new org.opensearch.action.admin.indices.rollover.RolloverRequest(
OpenSearchTestCase.randomAlphaOfLengthBetween(3, 10),
OpenSearchTestCase.randomBoolean() ? null : OpenSearchTestCase.randomAlphaOfLengthBetween(3, 10)
);
Map<String, String> expectedParams = new HashMap<>();
RequestConvertersTests.setRandomTimeout(rolloverRequest::timeout, rolloverRequest.timeout(), expectedParams);
RequestConvertersTests.setRandomMasterTimeout(rolloverRequest, expectedParams);
if (OpenSearchTestCase.randomBoolean()) {
rolloverRequest.dryRun(OpenSearchTestCase.randomBoolean());
if (rolloverRequest.isDryRun()) {
expectedParams.put("dry_run", "true");
}
}
expectedParams.put(INCLUDE_TYPE_NAME_PARAMETER, "true");
if (OpenSearchTestCase.randomBoolean()) {
rolloverRequest.addMaxIndexAgeCondition(new TimeValue(OpenSearchTestCase.randomNonNegativeLong()));
}
if (OpenSearchTestCase.randomBoolean()) {
String type = OpenSearchTestCase.randomAlphaOfLengthBetween(3, 10);
rolloverRequest.getCreateIndexRequest().mapping(type, org.opensearch.index.RandomCreateIndexGenerator.randomMapping(type));
}
if (OpenSearchTestCase.randomBoolean()) {
org.opensearch.index.RandomCreateIndexGenerator.randomAliases(rolloverRequest.getCreateIndexRequest());
}
if (OpenSearchTestCase.randomBoolean()) {
rolloverRequest.getCreateIndexRequest().settings(org.opensearch.index.RandomCreateIndexGenerator.randomIndexSettings());
}
RequestConvertersTests.setRandomWaitForActiveShards(rolloverRequest.getCreateIndexRequest()::waitForActiveShards, expectedParams);
Request request = IndicesRequestConverters.rollover(rolloverRequest);
if (rolloverRequest.getNewIndexName() == null) {
Assert.assertEquals("/" + rolloverRequest.getRolloverTarget() + "/_rollover", request.getEndpoint());
} else {
Assert.assertEquals(
"/" + rolloverRequest.getRolloverTarget() + "/_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();
@ -1015,57 +822,6 @@ public class IndicesRequestConvertersTests extends OpenSearchTestCase {
Assert.assertEquals(expectedParams, request.getParameters());
}
public void testPutTemplateRequestWithTypes() 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");
org.opensearch.action.admin.indices.template.put.PutIndexTemplateRequest putTemplateRequest =
new org.opensearch.action.admin.indices.template.put.PutIndexTemplateRequest().name(
OpenSearchTestCase.randomFrom(names.keySet())
).patterns(Arrays.asList(OpenSearchTestCase.generateRandomStringArray(20, 100, false, false)));
if (OpenSearchTestCase.randomBoolean()) {
putTemplateRequest.order(OpenSearchTestCase.randomInt());
}
if (OpenSearchTestCase.randomBoolean()) {
putTemplateRequest.version(OpenSearchTestCase.randomInt());
}
if (OpenSearchTestCase.randomBoolean()) {
putTemplateRequest.settings(
Settings.builder().put("setting-" + OpenSearchTestCase.randomInt(), OpenSearchTestCase.randomTimeValue())
);
}
Map<String, String> expectedParams = new HashMap<>();
if (OpenSearchTestCase.randomBoolean()) {
putTemplateRequest.mapping(
"doc-" + OpenSearchTestCase.randomInt(),
"field-" + OpenSearchTestCase.randomInt(),
"type=" + OpenSearchTestCase.randomFrom("text", "keyword")
);
}
expectedParams.put(INCLUDE_TYPE_NAME_PARAMETER, "true");
if (OpenSearchTestCase.randomBoolean()) {
putTemplateRequest.alias(new Alias("alias-" + OpenSearchTestCase.randomInt()));
}
if (OpenSearchTestCase.randomBoolean()) {
expectedParams.put("create", Boolean.TRUE.toString());
putTemplateRequest.create(true);
}
if (OpenSearchTestCase.randomBoolean()) {
String cause = OpenSearchTestCase.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 testPutTemplateRequest() throws Exception {
Map<String, String> names = new HashMap<>();
names.put("log", "log");
@ -1164,8 +920,7 @@ public class IndicesRequestConvertersTests extends OpenSearchTestCase {
RequestConvertersTests.setRandomMasterTimeout(getTemplatesRequest::setMasterNodeTimeout, expectedParams);
RequestConvertersTests.setRandomLocal(getTemplatesRequest::setLocal, expectedParams);
Request request = IndicesRequestConverters.getTemplatesWithDocumentTypes(getTemplatesRequest);
expectedParams.put(INCLUDE_TYPE_NAME_PARAMETER, "true");
Request request = IndicesRequestConverters.getTemplates(getTemplatesRequest);
Assert.assertThat(
request.getEndpoint(),
equalTo("/_template/" + names.stream().map(encodes::get).collect(Collectors.joining(",")))

7
client/rest-high-level/src/test/java/org/opensearch/client/indices/rollover/RolloverResponseTests.java
View File

@ -38,11 +38,8 @@ import org.opensearch.action.admin.indices.rollover.MaxDocsCondition;
import org.opensearch.action.admin.indices.rollover.MaxSizeCondition;
import org.opensearch.common.unit.ByteSizeValue;
import org.opensearch.common.unit.TimeValue;
import org.opensearch.common.xcontent.ToXContent;
import org.opensearch.common.xcontent.XContentBuilder;
import org.opensearch.test.OpenSearchTestCase;
import org.opensearch.rest.BaseRestHandler;
import org.opensearch.common.xcontent.ToXContent.Params;
import java.io.IOException;
import java.util.ArrayList;
@ -51,7 +48,6 @@ import java.util.List;
import java.util.Map;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.Collections;
import static org.opensearch.test.AbstractXContentTestCase.xContentTester;
@ -94,7 +90,6 @@ public class RolloverResponseTests extends OpenSearchTestCase {
}
private static void toXContent(RolloverResponse response, XContentBuilder builder) throws IOException {
Params params = new ToXContent.MapParams(Collections.singletonMap(BaseRestHandler.INCLUDE_TYPE_NAME_PARAMETER, "false"));
org.opensearch.action.admin.indices.rollover.RolloverResponse serverResponse =
new org.opensearch.action.admin.indices.rollover.RolloverResponse(
response.getOldIndex(),
@ -105,6 +100,6 @@ public class RolloverResponseTests extends OpenSearchTestCase {
response.isAcknowledged(),
response.isShardsAcknowledged()
);
serverResponse.toXContent(builder, params);
serverResponse.toXContent(builder, null);
}
}

96
modules/percolator/src/test/resources/rest-api-spec/test/11_basic_with_types.yml
View File

@ -1,96 +0,0 @@
---
"Test percolator basics via rest":
- do:
indices.create:
include_type_name: true
index: queries_index
body:
mappings:
queries_type:
properties:
query:
type: percolator
foo:
type: keyword
- do:
indices.create:
include_type_name: true
index: documents_index
body:
mappings:
documents_type:
properties:
foo:
type: keyword
- do:
index:
index: queries_index
type: queries_type
id: test_percolator
body:
query:
match_all: {}
- do:
index:
index: documents_index
type: documents_type
id: some_id
body:
foo: bar
- do:
indices.refresh: {}
- do:
search:
rest_total_hits_as_int: true
body:
- query:
percolate:
field: query
document:
document_type: queries_type
foo: bar
- match: { hits.total: 1 }
- do:
msearch:
rest_total_hits_as_int: true
body:
- index: queries_index
- query:
percolate:
field: query
document_type: queries_type
document:
foo: bar
- match: { responses.0.hits.total: 1 }
- do:
search:
rest_total_hits_as_int: true
body:
- query:
percolate:
field: query
index: documents_index
type: documents_type
id: some_id
- match: { hits.total: 1 }
- do:
msearch:
rest_total_hits_as_int: true
body:
- index: queries_index
- query:
percolate:
field: query
index: documents_index
type: documents_type
id: some_id
- match: { responses.0.hits.total: 1 }

1
qa/rolling-upgrade/src/test/resources/rest-api-spec/test/mixed_cluster/10_basic.yml
View File

@ -78,5 +78,4 @@
- do:
indices.get:
index: queries
include_type_name: false
- match: { queries.mappings.properties.id.type: "keyword" }

1
rest-api-spec/src/main/resources/rest-api-spec/test/field_caps/10_basic.yml
View File

@ -151,7 +151,6 @@ setup:
"Get date_nanos field caps":
- do:
indices.create:
include_type_name: false
index: test_nanos
body:
mappings:

17
rest-api-spec/src/main/resources/rest-api-spec/test/indices.create/10_basic.yml
View File

@ -112,20 +112,3 @@
properties:
"":
type: keyword
---
"Create index with explicit _doc type":
- do:
catch: bad_request
indices.create:
index: test_index
body:
mappings:
_doc:
properties:
field:
type: keyword
- match: { error.type: "illegal_argument_exception" }
- match: { error.reason: "The mapping definition cannot be nested under a type [_doc] unless include_type_name is set to true." }

48
rest-api-spec/src/main/resources/rest-api-spec/test/indices.get_template/11_basic_with_types.yml
View File

@ -1,48 +0,0 @@
setup:
- do:
indices.put_template:
include_type_name: true
name: test
body:
index_patterns: test-*
settings:
number_of_shards: 1
number_of_replicas: 0
mappings:
_doc:
properties:
field:
type: keyword
---
"Get template":
- do:
indices.get_template:
include_type_name: true
name: test
- match: {test.index_patterns: ["test-*"]}
- match: {test.settings: {index: {number_of_shards: '1', number_of_replicas: '0'}}}
- match: {test.mappings: {_doc: {properties: {field: {type: keyword}}}}}
---
"Get template with no mappings":
- do:
indices.put_template:
name: test_no_mappings
body:
index_patterns: test-*
settings:
number_of_shards: 1
number_of_replicas: 0
- do:
indices.get_template:
include_type_name: true
name: test_no_mappings
- match: {test_no_mappings.index_patterns: ["test-*"]}
- match: {test_no_mappings.settings: {index: {number_of_shards: '1', number_of_replicas: '0'}}}
- match: {test_no_mappings.mappings: {}}

17
rest-api-spec/src/main/resources/rest-api-spec/test/indices.put_template/10_basic.yml
View File

@ -226,20 +226,3 @@
indices.put_template:
name: test
body: {}
---
"Put template with explicit _doc type":
- do:
catch: bad_request
indices.put_template:
name: test
body:
index_patterns: test-*
mappings:
_doc:
properties:
field:
type: keyword
- match: { error.type: "illegal_argument_exception" }
- match: { error.reason: "The mapping definition cannot be nested under a type [_doc] unless include_type_name is set to true." }

74
rest-api-spec/src/main/resources/rest-api-spec/test/indices.put_template/11_basic_with_types.yml
View File

@ -1,74 +0,0 @@
---
"Put template":
- do:
indices.put_template:
include_type_name: true
name: test
body:
index_patterns: test-*
settings:
number_of_shards: 1
number_of_replicas: 0
mappings:
_doc:
properties:
field:
type: keyword
- do:
indices.get_template:
include_type_name: true
name: test
flat_settings: true
- match: {test.index_patterns: ["test-*"]}
- match: {test.settings: {index.number_of_shards: '1', index.number_of_replicas: '0'}}
- match: {test.mappings: {_doc: {properties: {field: {type: keyword}}}}}
---
"Put multiple template":
- do:
indices.put_template:
include_type_name: true
name: test
body:
index_patterns: [test-*, test2-*]
settings:
number_of_shards: 1
number_of_replicas: 0
mappings:
_doc:
properties:
field:
type: text
- do:
indices.get_template:
include_type_name: true
name: test
flat_settings: true
- match: {test.index_patterns: ["test-*", "test2-*"]}
- match: {test.settings: {index.number_of_shards: '1', index.number_of_replicas: '0'}}
- match: {test.mappings: {_doc: {properties: {field: {type: text}}}}}
---
"Put template with empty mappings":
- do:
indices.put_template:
include_type_name: true
name: test
body:
index_patterns: test-*
settings:
number_of_shards: 1
number_of_replicas: 0
mappings: {}
- do:
indices.get_template:
include_type_name: true
name: test
flat_settings: true
- match: {test.mappings: {}}

25
rest-api-spec/src/main/resources/rest-api-spec/test/indices.rollover/40_mapping.yml
View File

@ -37,28 +37,3 @@
- match: { conditions: { "[max_docs: 2]": true } }
- match: { rolled_over: true }
---
"Mappings with explicit _doc type":
- do:
indices.create:
index: logs-1
body:
aliases:
logs_search: {}
- do:
catch: bad_request
indices.rollover:
alias: "logs_search"
body:
conditions:
max_docs: 2
mappings:
_doc:
properties:
field:
type: keyword
- match: { error.caused_by.type: "illegal_argument_exception" }
- match: { error.caused_by.reason: "The mapping definition cannot be nested under a type [_doc] unless include_type_name is set to true." }

1
rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/280_geohash_grid.yml
View File

@ -1,7 +1,6 @@
setup:
- do:
indices.create:
include_type_name: false
index: test_1
body:
settings:

1
rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/290_geotile_grid.yml
View File

@ -4,7 +4,6 @@ setup:
reason: "added in 7.0.0"
- do:
indices.create:
include_type_name: false
index: test_1
body:
settings:

33
server/src/main/java/org/opensearch/action/admin/indices/create/CreateIndexRequest.java
View File

@ -53,7 +53,6 @@ import org.opensearch.common.settings.Settings;
import org.opensearch.common.xcontent.DeprecationHandler;
import org.opensearch.common.xcontent.LoggingDeprecationHandler;
import org.opensearch.common.xcontent.NamedXContentRegistry;
import org.opensearch.common.xcontent.ToXContentObject;
import org.opensearch.common.xcontent.XContentBuilder;
import org.opensearch.common.xcontent.XContentFactory;
import org.opensearch.common.xcontent.XContentHelper;
@ -61,7 +60,6 @@ import org.opensearch.common.xcontent.XContentParser;
import org.opensearch.common.xcontent.XContentType;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
@ -82,7 +80,7 @@ import static org.opensearch.common.settings.Settings.writeSettingsToStream;
* @see org.opensearch.client.Requests#createIndexRequest(String)
* @see CreateIndexResponse
*/
public class CreateIndexRequest extends AcknowledgedRequest<CreateIndexRequest> implements IndicesRequest, ToXContentObject {
public class CreateIndexRequest extends AcknowledgedRequest<CreateIndexRequest> implements IndicesRequest {
public static final ParseField MAPPINGS = new ParseField("mappings");
public static final ParseField SETTINGS = new ParseField("settings");
@ -483,33 +481,4 @@ public class CreateIndexRequest extends AcknowledgedRequest<CreateIndexRequest>
}
waitForActiveShards.writeTo(out);
}
@Override
public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject();
innerToXContent(builder, params);
builder.endObject();
return builder;
}
public XContentBuilder innerToXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(SETTINGS.getPreferredName());
settings.toXContent(builder, params);
builder.endObject();
builder.startObject(MAPPINGS.getPreferredName());
for (Map.Entry<String, String> entry : mappings.entrySet()) {
try (InputStream stream = new BytesArray(entry.getValue()).streamInput()) {
builder.rawField(entry.getKey(), stream, XContentType.JSON);
}
}
builder.endObject();
builder.startObject(ALIASES.getPreferredName());
for (Alias alias : aliases) {
alias.toXContent(builder, params);
}
builder.endObject();
return builder;
}
}

46
server/src/main/java/org/opensearch/action/admin/indices/mapping/get/GetFieldMappingsResponse.java
View File

@ -47,7 +47,6 @@ import org.opensearch.common.xcontent.XContentHelper;
import org.opensearch.common.xcontent.XContentParser;
import org.opensearch.common.xcontent.XContentType;
import org.opensearch.index.mapper.Mapper;
import org.opensearch.rest.BaseRestHandler;
import java.io.IOException;
import java.io.InputStream;
@ -58,8 +57,6 @@ import java.util.Objects;
import static java.util.Collections.unmodifiableMap;
import static org.opensearch.common.xcontent.ConstructingObjectParser.optionalConstructorArg;
import static org.opensearch.common.xcontent.XContentFactory.jsonBuilder;
import static org.opensearch.common.xcontent.XContentParserUtils.ensureExpectedToken;
import static org.opensearch.rest.BaseRestHandler.DEFAULT_INCLUDE_TYPE_NAME_POLICY;
/**
* Response object for {@link GetFieldMappingsRequest} API
@ -100,6 +97,7 @@ public class GetFieldMappingsResponse extends ActionResponse implements ToXConte
}, MAPPINGS, ObjectParser.ValueType.OBJECT);
}
// todo remove middle `type` level
private final Map<String, Map<String, Map<String, FieldMappingMetadata>>> mappings;
GetFieldMappingsResponse(Map<String, Map<String, Map<String, FieldMappingMetadata>>> mappings) {
@ -154,28 +152,18 @@ public class GetFieldMappingsResponse extends ActionResponse implements ToXConte
@Override
public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
boolean includeTypeName = params.paramAsBoolean(BaseRestHandler.INCLUDE_TYPE_NAME_PARAMETER, DEFAULT_INCLUDE_TYPE_NAME_POLICY);
builder.startObject();
for (Map.Entry<String, Map<String, Map<String, FieldMappingMetadata>>> indexEntry : mappings.entrySet()) {
builder.startObject(indexEntry.getKey());
builder.startObject(MAPPINGS.getPreferredName());
if (includeTypeName == false) {
Map<String, FieldMappingMetadata> mappings = null;
for (Map.Entry<String, Map<String, FieldMappingMetadata>> typeEntry : indexEntry.getValue().entrySet()) {
assert mappings == null;
mappings = typeEntry.getValue();
}
if (mappings != null) {
addFieldMappingsToBuilder(builder, params, mappings);
}
} else {
for (Map.Entry<String, Map<String, FieldMappingMetadata>> typeEntry : indexEntry.getValue().entrySet()) {
builder.startObject(typeEntry.getKey());
addFieldMappingsToBuilder(builder, params, typeEntry.getValue());
builder.endObject();
}
Map<String, FieldMappingMetadata> mappings = null;
for (Map.Entry<String, Map<String, FieldMappingMetadata>> typeEntry : indexEntry.getValue().entrySet()) {
assert mappings == null;
mappings = typeEntry.getValue();
}
if (mappings != null) {
addFieldMappingsToBuilder(builder, params, mappings);
}
builder.endObject();
@ -194,24 +182,6 @@ public class GetFieldMappingsResponse extends ActionResponse implements ToXConte
}
}
public static GetFieldMappingsResponse fromXContent(XContentParser parser) throws IOException {
ensureExpectedToken(XContentParser.Token.START_OBJECT, parser.nextToken(), parser);
final Map<String, Map<String, Map<String, FieldMappingMetadata>>> mappings = new HashMap<>();
if (parser.nextToken() == XContentParser.Token.FIELD_NAME) {
while (parser.currentToken() == XContentParser.Token.FIELD_NAME) {
final String index = parser.currentName();
final Map<String, Map<String, FieldMappingMetadata>> typeMappings = PARSER.parse(parser, index);
mappings.put(index, typeMappings);
parser.nextToken();
}
}
return new GetFieldMappingsResponse(mappings);
}
public static class FieldMappingMetadata implements ToXContentFragment {
public static final FieldMappingMetadata NULL = new FieldMappingMetadata("", BytesArray.EMPTY);

48
server/src/main/java/org/opensearch/action/admin/indices/rollover/RolloverRequest.java
View File

@ -43,8 +43,6 @@ import org.opensearch.common.io.stream.StreamOutput;
import org.opensearch.common.unit.ByteSizeValue;
import org.opensearch.common.unit.TimeValue;
import org.opensearch.common.xcontent.ObjectParser;
import org.opensearch.common.xcontent.ToXContentObject;
import org.opensearch.common.xcontent.XContentBuilder;
import org.opensearch.common.xcontent.XContentParser;
import org.opensearch.index.mapper.MapperService;
@ -60,9 +58,9 @@ import static org.opensearch.action.ValidateActions.addValidationError;
* Note: there is a new class with the same name for the Java HLRC that uses a typeless format.
* Any changes done to this class should also go to that client class.
*/
public class RolloverRequest extends AcknowledgedRequest<RolloverRequest> implements IndicesRequest, ToXContentObject {
public class RolloverRequest extends AcknowledgedRequest<RolloverRequest> implements IndicesRequest {
private static final ObjectParser<RolloverRequest, Boolean> PARSER = new ObjectParser<>("rollover");
private static final ObjectParser<RolloverRequest, Void> PARSER = new ObjectParser<>("rollover");
private static final ObjectParser<Map<String, Condition<?>>, Void> CONDITION_PARSER = new ObjectParser<>("conditions");
private static final ParseField CONDITIONS = new ParseField("conditions");
@ -97,24 +95,13 @@ public class RolloverRequest extends AcknowledgedRequest<RolloverRequest> implem
CreateIndexRequest.SETTINGS,
ObjectParser.ValueType.OBJECT
);
PARSER.declareField((parser, request, includeTypeName) -> {
if (includeTypeName) {
for (Map.Entry<String, Object> mappingsEntry : parser.map().entrySet()) {
request.createIndexRequest.mapping(mappingsEntry.getKey(), (Map<String, Object>) mappingsEntry.getValue());
}
} else {
// a type is not included, add a dummy _doc type
Map<String, Object> mappings = parser.map();
if (MapperService.isMappingSourceTyped(MapperService.SINGLE_MAPPING_NAME, mappings)) {
throw new IllegalArgumentException(
"The mapping definition cannot be nested under a type "
+ "["
+ MapperService.SINGLE_MAPPING_NAME
+ "] unless include_type_name is set to true."
);
}
request.createIndexRequest.mapping(MapperService.SINGLE_MAPPING_NAME, mappings);
PARSER.declareField((parser, request, context) -> {
// a type is not included, add a dummy _doc type
Map<String, Object> mappings = parser.map();
if (MapperService.isMappingSourceTyped(MapperService.SINGLE_MAPPING_NAME, mappings)) {
throw new IllegalArgumentException("The mapping definition cannot be nested under a type");
}
request.createIndexRequest.mapping(MapperService.SINGLE_MAPPING_NAME, mappings);
}, CreateIndexRequest.MAPPINGS, ObjectParser.ValueType.OBJECT);
PARSER.declareField(
(parser, request, context) -> request.createIndexRequest.aliases(parser.map()),
@ -273,23 +260,8 @@ public class RolloverRequest extends AcknowledgedRequest<RolloverRequest> implem
return createIndexRequest;
}
@Override
public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject();
createIndexRequest.innerToXContent(builder, params);
builder.startObject(CONDITIONS.getPreferredName());
for (Condition<?> condition : conditions.values()) {
condition.toXContent(builder, params);
}
builder.endObject();
builder.endObject();
return builder;
}
// param isTypeIncluded decides how mappings should be parsed from XContent
public void fromXContent(boolean isTypeIncluded, XContentParser parser) throws IOException {
PARSER.parse(parser, this, isTypeIncluded);
public void fromXContent(XContentParser parser) throws IOException {
PARSER.parse(parser, this, null);
}
}

38
server/src/main/java/org/opensearch/action/admin/indices/template/get/GetIndexTemplatesResponse.java
View File

@ -38,15 +38,13 @@ import org.opensearch.common.io.stream.StreamOutput;
import org.opensearch.common.xcontent.ToXContent;
import org.opensearch.common.xcontent.ToXContentObject;
import org.opensearch.common.xcontent.XContentBuilder;
import org.opensearch.common.xcontent.XContentParser;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import static java.util.Collections.singletonMap;
import static org.opensearch.rest.BaseRestHandler.DEFAULT_INCLUDE_TYPE_NAME_POLICY;
import static org.opensearch.rest.BaseRestHandler.INCLUDE_TYPE_NAME_PARAMETER;
public class GetIndexTemplatesResponse extends ActionResponse implements ToXContentObject {
@ -57,7 +55,7 @@ public class GetIndexTemplatesResponse extends ActionResponse implements ToXCont
int size = in.readVInt();
indexTemplates = new ArrayList<>();
for (int i = 0; i < size; i++) {
indexTemplates.add(0, IndexTemplateMetadata.readFrom(in));
indexTemplates.add(IndexTemplateMetadata.readFrom(in));
}
}
@ -77,32 +75,28 @@ public class GetIndexTemplatesResponse extends ActionResponse implements ToXCont
}
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
GetIndexTemplatesResponse that = (GetIndexTemplatesResponse) o;
return Objects.equals(indexTemplates, that.indexTemplates);
}
@Override
public int hashCode() {
return Objects.hash(indexTemplates);
}
@Override
public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
params = new ToXContent.DelegatingMapParams(singletonMap("reduce_mappings", "true"), params);
boolean includeTypeName = params.paramAsBoolean(INCLUDE_TYPE_NAME_PARAMETER, DEFAULT_INCLUDE_TYPE_NAME_POLICY);
builder.startObject();
for (IndexTemplateMetadata indexTemplateMetadata : getIndexTemplates()) {
if (includeTypeName) {
IndexTemplateMetadata.Builder.toXContentWithTypes(indexTemplateMetadata, builder, params);
} else {
IndexTemplateMetadata.Builder.toXContent(indexTemplateMetadata, builder, params);
}
IndexTemplateMetadata.Builder.toXContent(indexTemplateMetadata, builder, params);
}
builder.endObject();
return builder;
}
public static GetIndexTemplatesResponse fromXContent(XContentParser parser) throws IOException {
final List<IndexTemplateMetadata> templates = new ArrayList<>();
for (XContentParser.Token token = parser.nextToken(); token != XContentParser.Token.END_OBJECT; token = parser.nextToken()) {
if (token == XContentParser.Token.FIELD_NAME) {
final IndexTemplateMetadata templateMetadata = IndexTemplateMetadata.Builder.fromXContent(parser, parser.currentName());
templates.add(templateMetadata);
}
}
return new GetIndexTemplatesResponse(templates);
}
}

7
server/src/main/java/org/opensearch/rest/BaseRestHandler.java
View File

@ -80,13 +80,6 @@ public abstract class BaseRestHandler implements RestHandler {
@Deprecated
protected Logger logger = LogManager.getLogger(getClass());
/**
* Parameter that controls whether certain REST apis should include type names in their requests or responses.
* Note: Support for this parameter will be removed after the transition period to typeless APIs.
*/
public static final String INCLUDE_TYPE_NAME_PARAMETER = "include_type_name";
public static final boolean DEFAULT_INCLUDE_TYPE_NAME_POLICY = false;
public final long getUsageCount() {
return usageCount.sum();
}

23
server/src/main/java/org/opensearch/rest/action/admin/indices/RestCreateIndexAction.java
View File

@ -35,7 +35,6 @@ package org.opensearch.rest.action.admin.indices;
import org.opensearch.action.admin.indices.create.CreateIndexRequest;
import org.opensearch.action.support.ActiveShardCount;
import org.opensearch.client.node.NodeClient;
import org.opensearch.common.logging.DeprecationLogger;
import org.opensearch.common.xcontent.LoggingDeprecationHandler;
import org.opensearch.common.xcontent.XContentHelper;
import org.opensearch.index.mapper.MapperService;
@ -53,9 +52,6 @@ import static java.util.Collections.singletonMap;
import static org.opensearch.rest.RestRequest.Method.PUT;
public class RestCreateIndexAction extends BaseRestHandler {
private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(RestCreateIndexAction.class);
public static final String TYPES_DEPRECATION_MESSAGE = "[types removal] Using include_type_name in create "
+ "index requests is deprecated. The parameter will be removed in the next major version.";
@Override
public List<Route> routes() {
@ -69,17 +65,11 @@ public class RestCreateIndexAction extends BaseRestHandler {
@Override
public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
final boolean includeTypeName = request.paramAsBoolean(INCLUDE_TYPE_NAME_PARAMETER, DEFAULT_INCLUDE_TYPE_NAME_POLICY);
if (request.hasParam(INCLUDE_TYPE_NAME_PARAMETER)) {
deprecationLogger.deprecate("create_index_with_types", TYPES_DEPRECATION_MESSAGE);
}
CreateIndexRequest createIndexRequest = new CreateIndexRequest(request.param("index"));
if (request.hasContent()) {
Map<String, Object> sourceAsMap = XContentHelper.convertToMap(request.requiredContent(), false, request.getXContentType()).v2();
sourceAsMap = prepareMappings(sourceAsMap, includeTypeName);
sourceAsMap = prepareMappings(sourceAsMap);
createIndexRequest.source(sourceAsMap, LoggingDeprecationHandler.INSTANCE);
}
@ -89,8 +79,8 @@ public class RestCreateIndexAction extends BaseRestHandler {
return channel -> client.admin().indices().create(createIndexRequest, new RestToXContentListener<>(channel));
}
static Map<String, Object> prepareMappings(Map<String, Object> source, boolean includeTypeName) {
if (includeTypeName || source.containsKey("mappings") == false || (source.get("mappings") instanceof Map) == false) {
static Map<String, Object> prepareMappings(Map<String, Object> source) {
if (source.containsKey("mappings") == false || (source.get("mappings") instanceof Map) == false) {
return source;
}
@ -99,12 +89,7 @@ public class RestCreateIndexAction extends BaseRestHandler {
@SuppressWarnings("unchecked")
Map<String, Object> mappings = (Map<String, Object>) source.get("mappings");
if (MapperService.isMappingSourceTyped(MapperService.SINGLE_MAPPING_NAME, mappings)) {
throw new IllegalArgumentException(
"The mapping definition cannot be nested under a type "
+ "["
+ MapperService.SINGLE_MAPPING_NAME
+ "] unless include_type_name is set to true."
);
throw new IllegalArgumentException("The mapping definition cannot be nested under a type");
}
newSource.put("mappings", singletonMap(MapperService.SINGLE_MAPPING_NAME, mappings));

10
server/src/main/java/org/opensearch/rest/action/admin/indices/RestGetFieldMappingAction.java
View File

@ -63,8 +63,6 @@ public class RestGetFieldMappingAction extends BaseRestHandler {
private static final Logger logger = LogManager.getLogger(RestGetFieldMappingAction.class);
private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(logger.getName());
public static final String TYPES_DEPRECATION_MESSAGE = "[types removal] Using include_type_name in get "
+ "field mapping requests is deprecated. The parameter will be removed in the next major version.";
@Override
public List<Route> routes() {
@ -85,14 +83,6 @@ public class RestGetFieldMappingAction extends BaseRestHandler {
getMappingsRequest.indices(indices).fields(fields).includeDefaults(request.paramAsBoolean("include_defaults", false));
getMappingsRequest.indicesOptions(IndicesOptions.fromRequest(request, getMappingsRequest.indicesOptions()));
if (request.hasParam(INCLUDE_TYPE_NAME_PARAMETER)) {
boolean includeTypeName = request.paramAsBoolean(INCLUDE_TYPE_NAME_PARAMETER, DEFAULT_INCLUDE_TYPE_NAME_POLICY);
if (includeTypeName) {
throw new IllegalArgumentException(INCLUDE_TYPE_NAME_PARAMETER + " no longer supports the value [true].");
}
deprecationLogger.deprecate("get_field_mapping_with_types", TYPES_DEPRECATION_MESSAGE);
}
if (request.hasParam("local")) {
deprecationLogger.deprecate(
"get_field_mapping_local",

15
server/src/main/java/org/opensearch/rest/action/admin/indices/RestGetIndexTemplateAction.java
View File

@ -36,16 +36,13 @@ import org.opensearch.action.admin.indices.template.get.GetIndexTemplatesRequest
import org.opensearch.action.admin.indices.template.get.GetIndexTemplatesResponse;
import org.opensearch.client.node.NodeClient;
import org.opensearch.common.Strings;
import org.opensearch.common.logging.DeprecationLogger;
import org.opensearch.common.settings.Settings;
import org.opensearch.common.util.set.Sets;
import org.opensearch.rest.BaseRestHandler;
import org.opensearch.rest.RestRequest;
import org.opensearch.rest.RestStatus;
import org.opensearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.Set;
@ -61,13 +58,6 @@ import static org.opensearch.rest.RestStatus.OK;
*/
public class RestGetIndexTemplateAction extends BaseRestHandler {
private static final Set<String> RESPONSE_PARAMETERS = Collections.unmodifiableSet(
Sets.union(Collections.singleton(INCLUDE_TYPE_NAME_PARAMETER), Settings.FORMAT_PARAMS)
);
private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(RestGetIndexTemplateAction.class);
public static final String TYPES_DEPRECATION_MESSAGE = "[types removal]"
+ " Specifying include_type_name in get index template requests is deprecated.";
@Override
public List<Route> routes() {
return unmodifiableList(
@ -85,9 +75,6 @@ public class RestGetIndexTemplateAction extends BaseRestHandler {
final String[] names = Strings.splitStringByCommaToArray(request.param("name"));
final GetIndexTemplatesRequest getIndexTemplatesRequest = new GetIndexTemplatesRequest(names);
if (request.hasParam(INCLUDE_TYPE_NAME_PARAMETER)) {
deprecationLogger.deprecate("get_index_template_include_type_name", TYPES_DEPRECATION_MESSAGE);
}
getIndexTemplatesRequest.local(request.paramAsBoolean("local", getIndexTemplatesRequest.local()));
getIndexTemplatesRequest.masterNodeTimeout(request.paramAsTime("master_timeout", getIndexTemplatesRequest.masterNodeTimeout()));
@ -106,7 +93,7 @@ public class RestGetIndexTemplateAction extends BaseRestHandler {
@Override
protected Set<String> responseParams() {
return RESPONSE_PARAMETERS;
return Settings.FORMAT_PARAMS;
}
}

19
server/src/main/java/org/opensearch/rest/action/admin/indices/RestGetIndicesAction.java
View File

@ -36,18 +36,14 @@ import org.opensearch.action.admin.indices.get.GetIndexRequest;
import org.opensearch.action.support.IndicesOptions;
import org.opensearch.client.node.NodeClient;
import org.opensearch.common.Strings;
import org.opensearch.common.logging.DeprecationLogger;
import org.opensearch.common.settings.Settings;
import org.opensearch.rest.BaseRestHandler;
import org.opensearch.rest.RestRequest;
import org.opensearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
@ -59,15 +55,6 @@ import static org.opensearch.rest.RestRequest.Method.HEAD;
*/
public class RestGetIndicesAction extends BaseRestHandler {
private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(RestGetIndicesAction.class);
public static final String TYPES_DEPRECATION_MESSAGE = "[types removal] Using `include_type_name` in get indices requests"
+ " is deprecated. The parameter will be removed in the next major version.";
private static final Set<String> allowedResponseParameters = Collections.unmodifiableSet(
Stream.concat(Collections.singleton(INCLUDE_TYPE_NAME_PARAMETER).stream(), Settings.FORMAT_PARAMS.stream())
.collect(Collectors.toSet())
);
@Override
public List<Route> routes() {
return unmodifiableList(asList(new Route(GET, "/{index}"), new Route(HEAD, "/{index}")));
@ -81,10 +68,6 @@ public class RestGetIndicesAction extends BaseRestHandler {
@Override
public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
String[] indices = Strings.splitStringByCommaToArray(request.param("index"));
// starting with 7.0 we don't include types by default in the response to GET requests
if (request.hasParam(INCLUDE_TYPE_NAME_PARAMETER) && request.method().equals(GET)) {
deprecationLogger.deprecate("get_indices_with_types", TYPES_DEPRECATION_MESSAGE);
}
final GetIndexRequest getIndexRequest = new GetIndexRequest();
getIndexRequest.indices(indices);
getIndexRequest.indicesOptions(IndicesOptions.fromRequest(request, getIndexRequest.indicesOptions()));
@ -101,6 +84,6 @@ public class RestGetIndicesAction extends BaseRestHandler {
*/
@Override
protected Set<String> responseParams() {
return allowedResponseParameters;
return Settings.FORMAT_PARAMS;
}
}

7
server/src/main/java/org/opensearch/rest/action/admin/indices/RestGetMappingAction.java
View File

@ -32,8 +32,6 @@
package org.opensearch.rest.action.admin.indices;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.opensearch.OpenSearchTimeoutException;
import org.opensearch.action.ActionRunnable;
import org.opensearch.action.admin.indices.mapping.get.GetMappingsRequest;
@ -41,7 +39,6 @@ import org.opensearch.action.admin.indices.mapping.get.GetMappingsResponse;
import org.opensearch.action.support.IndicesOptions;
import org.opensearch.client.node.NodeClient;
import org.opensearch.common.Strings;
import org.opensearch.common.logging.DeprecationLogger;
import org.opensearch.common.unit.TimeValue;
import org.opensearch.common.xcontent.XContentBuilder;
import org.opensearch.rest.BaseRestHandler;
@ -61,10 +58,6 @@ import static java.util.Collections.unmodifiableList;
import static org.opensearch.rest.RestRequest.Method.GET;
public class RestGetMappingAction extends BaseRestHandler {
private static final Logger logger = LogManager.getLogger(RestGetMappingAction.class);
private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(logger.getName());
public static final String TYPES_DEPRECATION_MESSAGE = "[types removal] Using include_type_name in get"
+ " mapping requests is deprecated. The parameter will be removed in the next major version.";
private final ThreadPool threadPool;

11
server/src/main/java/org/opensearch/rest/action/admin/indices/RestPutIndexTemplateAction.java
View File

@ -53,11 +53,7 @@ import static org.opensearch.rest.RestRequest.Method.POST;
import static org.opensearch.rest.RestRequest.Method.PUT;
public class RestPutIndexTemplateAction extends BaseRestHandler {
private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(RestPutIndexTemplateAction.class);
public static final String TYPES_DEPRECATION_MESSAGE = "[types removal]"
+ " Specifying include_type_name in put index template requests is deprecated."
+ " The parameter will be removed in the next major version.";
@Override
public List<Route> routes() {
@ -71,12 +67,7 @@ public class RestPutIndexTemplateAction extends BaseRestHandler {
@Override
public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
boolean includeTypeName = request.paramAsBoolean(INCLUDE_TYPE_NAME_PARAMETER, DEFAULT_INCLUDE_TYPE_NAME_POLICY);
PutIndexTemplateRequest putRequest = new PutIndexTemplateRequest(request.param("name"));
if (request.hasParam(INCLUDE_TYPE_NAME_PARAMETER)) {
deprecationLogger.deprecate("put_index_template_with_types", TYPES_DEPRECATION_MESSAGE);
}
if (request.hasParam("template")) {
deprecationLogger.deprecate(
"put_index_template_deprecated_parameter",
@ -92,7 +83,7 @@ public class RestPutIndexTemplateAction extends BaseRestHandler {
putRequest.cause(request.param("cause", ""));
Map<String, Object> sourceAsMap = XContentHelper.convertToMap(request.requiredContent(), false, request.getXContentType()).v2();
sourceAsMap = RestCreateIndexAction.prepareMappings(sourceAsMap, includeTypeName);
sourceAsMap = RestCreateIndexAction.prepareMappings(sourceAsMap);
putRequest.source(sourceAsMap);
return channel -> client.admin().indices().putTemplate(putRequest, new RestToXContentListener<>(channel));

12
server/src/main/java/org/opensearch/rest/action/admin/indices/RestPutMappingAction.java
View File

@ -36,7 +36,6 @@ import org.opensearch.action.admin.indices.mapping.put.PutMappingRequest;
import org.opensearch.action.support.IndicesOptions;
import org.opensearch.client.node.NodeClient;
import org.opensearch.common.Strings;
import org.opensearch.common.logging.DeprecationLogger;
import org.opensearch.common.xcontent.XContentHelper;
import org.opensearch.index.mapper.MapperService;
import org.opensearch.rest.BaseRestHandler;
@ -54,9 +53,6 @@ import static org.opensearch.rest.RestRequest.Method.POST;
import static org.opensearch.rest.RestRequest.Method.PUT;
public class RestPutMappingAction extends BaseRestHandler {
private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(RestPutMappingAction.class);
public static final String TYPES_DEPRECATION_MESSAGE = "[types removal] Using include_type_name in put "
+ "mapping requests is deprecated. The parameter will be removed in the next major version.";
@Override
public List<Route> routes() {
@ -79,15 +75,9 @@ public class RestPutMappingAction extends BaseRestHandler {
public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
PutMappingRequest putMappingRequest = putMappingRequest(Strings.splitStringByCommaToArray(request.param("index")));
final boolean includeTypeName = request.paramAsBoolean(INCLUDE_TYPE_NAME_PARAMETER, DEFAULT_INCLUDE_TYPE_NAME_POLICY);
if (request.hasParam(INCLUDE_TYPE_NAME_PARAMETER)) {
deprecationLogger.deprecate("put_mapping_with_types", TYPES_DEPRECATION_MESSAGE);
}
Map<String, Object> sourceAsMap = XContentHelper.convertToMap(request.requiredContent(), false, request.getXContentType()).v2();
if (includeTypeName == false && MapperService.isMappingSourceTyped(MapperService.SINGLE_MAPPING_NAME, sourceAsMap)) {
if (MapperService.isMappingSourceTyped(MapperService.SINGLE_MAPPING_NAME, sourceAsMap)) {
throw new IllegalArgumentException("Types cannot be provided in put mapping requests");
}

5
server/src/main/java/org/opensearch/rest/action/admin/indices/RestRolloverIndexAction.java
View File

@ -65,12 +65,11 @@ public class RestRolloverIndexAction extends BaseRestHandler {
@Override
public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
final boolean includeTypeName = request.paramAsBoolean(INCLUDE_TYPE_NAME_PARAMETER, DEFAULT_INCLUDE_TYPE_NAME_POLICY);
if (request.hasParam(INCLUDE_TYPE_NAME_PARAMETER)) {
if (request.hasParam("include_type_name")) {
deprecationLogger.deprecate("index_rollover_with_types", TYPES_DEPRECATION_MESSAGE);
}
RolloverRequest rolloverIndexRequest = new RolloverRequest(request.param("index"), request.param("new_index"));
request.applyContentParser(parser -> rolloverIndexRequest.fromXContent(includeTypeName, parser));
request.applyContentParser(parser -> rolloverIndexRequest.fromXContent(parser));
rolloverIndexRequest.dryRun(request.paramAsBoolean("dry_run", false));
rolloverIndexRequest.timeout(request.paramAsTime("timeout", rolloverIndexRequest.timeout()));
rolloverIndexRequest.masterNodeTimeout(request.paramAsTime("master_timeout", rolloverIndexRequest.masterNodeTimeout()));

55
server/src/test/java/org/opensearch/action/admin/indices/create/CreateIndexRequestTests.java
View File

@ -35,11 +35,9 @@ package org.opensearch.action.admin.indices.create;
import org.opensearch.OpenSearchParseException;
import org.opensearch.action.admin.indices.alias.Alias;
import org.opensearch.common.Strings;
import org.opensearch.common.bytes.BytesReference;
import org.opensearch.common.collect.MapBuilder;
import org.opensearch.common.io.stream.BytesStreamOutput;
import org.opensearch.common.io.stream.StreamInput;
import org.opensearch.common.settings.Settings;
import org.opensearch.common.xcontent.LoggingDeprecationHandler;
import org.opensearch.common.xcontent.NamedXContentRegistry;
import org.opensearch.common.xcontent.XContentBuilder;
@ -47,16 +45,12 @@ import org.opensearch.common.xcontent.XContentFactory;
import org.opensearch.common.xcontent.XContentParser;
import org.opensearch.common.xcontent.XContentType;
import org.opensearch.common.xcontent.json.JsonXContent;
import org.opensearch.index.RandomCreateIndexGenerator;
import org.opensearch.test.OpenSearchTestCase;
import org.opensearch.test.hamcrest.OpenSearchAssertions;
import java.io.IOException;
import java.util.Map;
import java.util.Set;
import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_SHARDS;
import static org.opensearch.common.xcontent.ToXContent.EMPTY_PARAMS;
import static org.hamcrest.CoreMatchers.equalTo;
public class CreateIndexRequestTests extends OpenSearchTestCase {
@ -101,36 +95,6 @@ public class CreateIndexRequestTests extends OpenSearchTestCase {
assertEquals("unknown key [FOO_SHOULD_BE_ILLEGAL_HERE] for create index", e.getMessage());
}
public void testToXContent() throws IOException {
CreateIndexRequest request = new CreateIndexRequest("foo");
String mapping;
if (randomBoolean()) {
mapping = Strings.toString(JsonXContent.contentBuilder().startObject().startObject("my_type").endObject().endObject());
} else {
mapping = Strings.toString(JsonXContent.contentBuilder().startObject().endObject());
}
request.mapping("my_type", mapping, XContentType.JSON);
Alias alias = new Alias("test_alias");
alias.routing("1");
alias.filter("{\"term\":{\"year\":2016}}");
alias.writeIndex(true);
request.alias(alias);
Settings.Builder settings = Settings.builder();
settings.put(SETTING_NUMBER_OF_SHARDS, 10);
request.settings(settings);
String actualRequestBody = Strings.toString(request);
String expectedRequestBody = "{\"settings\":{\"index\":{\"number_of_shards\":\"10\"}},"
+ "\"mappings\":{\"my_type\":{\"my_type\":{}}},"
+ "\"aliases\":{\"test_alias\":{\"filter\":{\"term\":{\"year\":2016}},\"routing\":\"1\",\"is_write_index\":true}}}";
assertEquals(expectedRequestBody, actualRequestBody);
}
public void testMappingKeyedByType() throws IOException {
CreateIndexRequest request1 = new CreateIndexRequest("foo");
CreateIndexRequest request2 = new CreateIndexRequest("bar");
@ -196,25 +160,6 @@ public class CreateIndexRequestTests extends OpenSearchTestCase {
}
}
public void testToAndFromXContent() throws IOException {
final CreateIndexRequest createIndexRequest = RandomCreateIndexGenerator.randomCreateIndexRequest();
boolean humanReadable = randomBoolean();
final XContentType xContentType = randomFrom(XContentType.values());
BytesReference originalBytes = toShuffledXContent(createIndexRequest, xContentType, EMPTY_PARAMS, humanReadable);
CreateIndexRequest parsedCreateIndexRequest = new CreateIndexRequest();
parsedCreateIndexRequest.source(originalBytes, xContentType);
assertMappingsEqual(createIndexRequest.mappings(), parsedCreateIndexRequest.mappings());
assertAliasesEqual(createIndexRequest.aliases(), parsedCreateIndexRequest.aliases());
assertEquals(createIndexRequest.settings(), parsedCreateIndexRequest.settings());
BytesReference finalBytes = toShuffledXContent(parsedCreateIndexRequest, xContentType, EMPTY_PARAMS, humanReadable);
OpenSearchAssertions.assertToXContentEquivalent(originalBytes, finalBytes, xContentType);
}
public void testSettingsType() throws IOException {
XContentBuilder builder = XContentFactory.contentBuilder(randomFrom(XContentType.values()));
builder.startObject().startArray("settings").endArray().endObject();

74
server/src/test/java/org/opensearch/action/admin/indices/mapping/get/GetFieldMappingsResponseTests.java
View File

@ -37,22 +37,14 @@ import org.opensearch.common.bytes.BytesArray;
import org.opensearch.common.io.stream.BytesStreamOutput;
import org.opensearch.common.io.stream.StreamInput;
import org.opensearch.common.io.stream.Writeable;
import org.opensearch.common.xcontent.LoggingDeprecationHandler;
import org.opensearch.common.xcontent.ToXContent;
import org.opensearch.common.xcontent.XContentParser;
import org.opensearch.common.xcontent.XContentType;
import org.opensearch.test.AbstractSerializingTestCase;
import org.opensearch.test.AbstractWireSerializingTestCase;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Predicate;
import static org.opensearch.rest.BaseRestHandler.INCLUDE_TYPE_NAME_PARAMETER;
import static org.hamcrest.CoreMatchers.equalTo;
public class GetFieldMappingsResponseTests extends AbstractSerializingTestCase<GetFieldMappingsResponse> {
public class GetFieldMappingsResponseTests extends AbstractWireSerializingTestCase<GetFieldMappingsResponse> {
public void testManualSerialization() throws IOException {
Map<String, Map<String, Map<String, FieldMappingMetadata>>> mappings = new HashMap<>();
@ -71,51 +63,6 @@ public class GetFieldMappingsResponseTests extends AbstractSerializingTestCase<G
}
}
public void testManualJunkedJson() throws Exception {
// in fact random fields could be evaluated as proper mapping, while proper junk in this case is arrays and values
final String json = "{\"index1\":{\"mappings\":"
+ "{\"doctype0\":{\"field1\":{\"full_name\":\"my field\",\"mapping\":{\"type\":\"keyword\"}},"
+ "\"field0\":{\"full_name\":\"my field\",\"mapping\":{\"type\":\"keyword\"}}},"
// junk here
+ "\"junk1\": [\"field1\", {\"field2\":{}}],"
+ "\"junk2\": [{\"field3\":{}}],"
+ "\"junk3\": 42,"
+ "\"junk4\": \"Q\","
+ "\"doctype1\":{\"field1\":{\"full_name\":\"my field\",\"mapping\":{\"type\":\"keyword\"}},"
+ "\"field0\":{\"full_name\":\"my field\",\"mapping\":{\"type\":\"keyword\"}}}}},"
+ "\"index0\":{\"mappings\":"
+ "{\"doctype0\":{\"field1\":{\"full_name\":\"my field\",\"mapping\":{\"type\":\"keyword\"}},"
+ "\"field0\":{\"full_name\":\"my field\",\"mapping\":{\"type\":\"keyword\"}}},"
+ "\"doctype1\":{\"field1\":{\"full_name\":\"my field\",\"mapping\":{\"type\":\"keyword\"}},"
+ "\"field0\":{\"full_name\":\"my field\",\"mapping\":{\"type\":\"keyword\"}}}}}}";
final XContentParser parser = XContentType.JSON.xContent()
.createParser(xContentRegistry(), LoggingDeprecationHandler.INSTANCE, json.getBytes("UTF-8"));
final GetFieldMappingsResponse response = GetFieldMappingsResponse.fromXContent(parser);
FieldMappingMetadata fieldMappingMetadata = new FieldMappingMetadata("my field", new BytesArray("{\"type\":\"keyword\"}"));
Map<String, FieldMappingMetadata> fieldMapping = new HashMap<>();
fieldMapping.put("field0", fieldMappingMetadata);
fieldMapping.put("field1", fieldMappingMetadata);
Map<String, Map<String, FieldMappingMetadata>> typeMapping = new HashMap<>();
typeMapping.put("doctype0", fieldMapping);
typeMapping.put("doctype1", fieldMapping);
Map<String, Map<String, Map<String, FieldMappingMetadata>>> mappings = new HashMap<>();
mappings.put("index0", typeMapping);
mappings.put("index1", typeMapping);
final Map<String, Map<String, Map<String, FieldMappingMetadata>>> responseMappings = response.mappings();
assertThat(responseMappings, equalTo(mappings));
}
@Override
protected GetFieldMappingsResponse doParseInstance(XContentParser parser) throws IOException {
return GetFieldMappingsResponse.fromXContent(parser);
}
@Override
protected GetFieldMappingsResponse createTestInstance() {
return new GetFieldMappingsResponse(randomMapping());
@ -126,23 +73,6 @@ public class GetFieldMappingsResponseTests extends AbstractSerializingTestCase<G
return GetFieldMappingsResponse::new;
}
@Override
protected Predicate<String> getRandomFieldsExcludeFilter() {
// allow random fields at the level of `index` and `index.mappings.doctype.field`
// otherwise random field could be evaluated as index name or type name
return s -> false == (s.matches("(?<index>[^.]+)")
|| s.matches("(?<index>[^.]+)\\.mappings\\.(?<doctype>[^.]+)\\.(?<field>[^.]+)"));
}
/**
* For xContent roundtrip testing we force the xContent output to still contain types because the parser
* still expects them. The new typeless parsing is implemented in the client side GetFieldMappingsResponse.
*/
@Override
protected ToXContent.Params getToXContentParams() {
return new ToXContent.MapParams(Collections.singletonMap(INCLUDE_TYPE_NAME_PARAMETER, "true"));
}
private Map<String, Map<String, Map<String, FieldMappingMetadata>>> randomMapping() {
Map<String, Map<String, Map<String, FieldMappingMetadata>>> mappings = new HashMap<>();

39
server/src/test/java/org/opensearch/action/admin/indices/rollover/RolloverRequestTests.java
View File

@ -34,7 +34,6 @@ package org.opensearch.action.admin.indices.rollover;
import org.opensearch.action.ActionRequestValidationException;
import org.opensearch.action.admin.indices.create.CreateIndexRequest;
import org.opensearch.action.admin.indices.create.CreateIndexRequestTests;
import org.opensearch.common.bytes.BytesArray;
import org.opensearch.common.bytes.BytesReference;
import org.opensearch.common.io.stream.BytesStreamOutput;
@ -54,7 +53,6 @@ import org.opensearch.index.mapper.MapperService;
import org.opensearch.indices.IndicesModule;
import org.opensearch.test.OpenSearchTestCase;
import org.opensearch.test.XContentTestUtils;
import org.opensearch.test.hamcrest.OpenSearchAssertions;
import java.io.IOException;
import org.junit.Before;
@ -64,7 +62,6 @@ import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import static org.opensearch.common.xcontent.ToXContent.EMPTY_PARAMS;
import static org.hamcrest.Matchers.equalTo;
public class RolloverRequestTests extends OpenSearchTestCase {
@ -87,7 +84,7 @@ public class RolloverRequestTests extends OpenSearchTestCase {
.field("max_size", "45gb")
.endObject()
.endObject();
request.fromXContent(false, createParser(builder));
request.fromXContent(createParser(builder));
Map<String, Condition<?>> conditions = request.getConditions();
assertThat(conditions.size(), equalTo(3));
MaxAgeCondition maxAgeCondition = (MaxAgeCondition) conditions.get(MaxAgeCondition.NAME);
@ -107,7 +104,6 @@ public class RolloverRequestTests extends OpenSearchTestCase {
.field("max_docs", 100)
.endObject()
.startObject("mappings")
.startObject("type1")
.startObject("properties")
.startObject("field1")
.field("type", "string")
@ -115,7 +111,6 @@ public class RolloverRequestTests extends OpenSearchTestCase {
.endObject()
.endObject()
.endObject()
.endObject()
.startObject("settings")
.field("number_of_shards", 10)
.endObject()
@ -124,7 +119,7 @@ public class RolloverRequestTests extends OpenSearchTestCase {
.endObject()
.endObject()
.endObject();
request.fromXContent(true, createParser(builder));
request.fromXContent(createParser(builder));
Map<String, Condition<?>> conditions = request.getConditions();
assertThat(conditions.size(), equalTo(2));
assertThat(request.getCreateIndexRequest().mappings().size(), equalTo(1));
@ -145,8 +140,7 @@ public class RolloverRequestTests extends OpenSearchTestCase {
.endObject()
.endObject();
boolean includeTypeName = false;
request.fromXContent(includeTypeName, createParser(builder));
request.fromXContent(createParser(builder));
CreateIndexRequest createIndexRequest = request.getCreateIndexRequest();
String mapping = createIndexRequest.mappings().get(MapperService.SINGLE_MAPPING_NAME);
@ -182,27 +176,6 @@ public class RolloverRequestTests extends OpenSearchTestCase {
}
}
public void testToAndFromXContent() throws IOException {
RolloverRequest rolloverRequest = createTestItem();
final XContentType xContentType = randomFrom(XContentType.values());
boolean humanReadable = randomBoolean();
BytesReference originalBytes = toShuffledXContent(rolloverRequest, xContentType, EMPTY_PARAMS, humanReadable);
RolloverRequest parsedRolloverRequest = new RolloverRequest();
parsedRolloverRequest.fromXContent(true, createParser(xContentType.xContent(), originalBytes));
CreateIndexRequest createIndexRequest = rolloverRequest.getCreateIndexRequest();
CreateIndexRequest parsedCreateIndexRequest = parsedRolloverRequest.getCreateIndexRequest();
CreateIndexRequestTests.assertMappingsEqual(createIndexRequest.mappings(), parsedCreateIndexRequest.mappings());
CreateIndexRequestTests.assertAliasesEqual(createIndexRequest.aliases(), parsedCreateIndexRequest.aliases());
assertEquals(createIndexRequest.settings(), parsedCreateIndexRequest.settings());
assertEquals(rolloverRequest.getConditions(), parsedRolloverRequest.getConditions());
BytesReference finalBytes = toShuffledXContent(parsedRolloverRequest, xContentType, EMPTY_PARAMS, humanReadable);
OpenSearchAssertions.assertToXContentEquivalent(originalBytes, finalBytes, xContentType);
}
public void testUnknownFields() throws IOException {
final RolloverRequest request = new RolloverRequest();
XContentType xContentType = randomFrom(XContentType.values());
@ -215,7 +188,7 @@ public class RolloverRequestTests extends OpenSearchTestCase {
}
builder.endObject();
BytesReference mutated = XContentTestUtils.insertRandomFields(xContentType, BytesReference.bytes(builder), null, random());
expectThrows(XContentParseException.class, () -> request.fromXContent(false, createParser(xContentType.xContent(), mutated)));
expectThrows(XContentParseException.class, () -> request.fromXContent(createParser(xContentType.xContent(), mutated)));
}
public void testSameConditionCanOnlyBeAddedOnce() {
@ -244,8 +217,8 @@ public class RolloverRequestTests extends OpenSearchTestCase {
private static RolloverRequest createTestItem() throws IOException {
RolloverRequest rolloverRequest = new RolloverRequest();
if (randomBoolean()) {
String type = randomAlphaOfLengthBetween(3, 10);
rolloverRequest.getCreateIndexRequest().mapping(type, RandomCreateIndexGenerator.randomMapping(type));
rolloverRequest.getCreateIndexRequest()
.mapping(MapperService.SINGLE_MAPPING_NAME, RandomCreateIndexGenerator.randomMapping(MapperService.SINGLE_MAPPING_NAME));
}
if (randomBoolean()) {
RandomCreateIndexGenerator.randomAliases(rolloverRequest.getCreateIndexRequest());

32
server/src/test/java/org/opensearch/action/admin/indices/template/get/GetIndexTemplatesResponseTests.java
View File

@ -32,31 +32,23 @@
package org.opensearch.action.admin.indices.template.get;
import org.opensearch.action.admin.indices.mapping.get.GetFieldMappingsResponse;
import org.opensearch.cluster.metadata.AliasMetadata;
import org.opensearch.cluster.metadata.IndexTemplateMetadata;
import org.opensearch.common.io.stream.Writeable;
import org.opensearch.common.settings.Settings;
import org.opensearch.common.xcontent.ToXContent;
import org.opensearch.common.xcontent.XContentParser;
import org.opensearch.test.AbstractXContentTestCase;
import org.opensearch.test.AbstractWireSerializingTestCase;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import static org.opensearch.rest.BaseRestHandler.INCLUDE_TYPE_NAME_PARAMETER;
import static org.hamcrest.Matchers.equalTo;
public class GetIndexTemplatesResponseTests extends AbstractXContentTestCase<GetIndexTemplatesResponse> {
@Override
protected GetIndexTemplatesResponse doParseInstance(XContentParser parser) throws IOException {
return GetIndexTemplatesResponse.fromXContent(parser);
}
public class GetIndexTemplatesResponseTests extends AbstractWireSerializingTestCase<GetIndexTemplatesResponse> {
@Override
protected GetIndexTemplatesResponse createTestInstance() {
@ -80,7 +72,7 @@ public class GetIndexTemplatesResponseTests extends AbstractXContentTestCase<Get
}
if (randomBoolean()) {
try {
templateBuilder.putMapping("doc", "{\"doc\":{\"properties\":{\"type\":\"text\"}}}");
templateBuilder.putMapping("doc", "{\"properties\":{\"type\":\"text\"}}");
} catch (IOException ex) {
throw new UncheckedIOException(ex);
}
@ -91,20 +83,8 @@ public class GetIndexTemplatesResponseTests extends AbstractXContentTestCase<Get
}
@Override
protected boolean supportsUnknownFields() {
// We can not inject anything at the top level because a GetIndexTemplatesResponse is serialized as a map
// from template name to template content. IndexTemplateMetadataTests already covers situations where we
// inject arbitrary things inside the IndexTemplateMetadata.
return false;
}
/**
* For now, we only unit test the legacy typed responses. This will soon no longer be the case,
* as we introduce support for typeless xContent parsing in {@link GetFieldMappingsResponse}.
*/
@Override
protected ToXContent.Params getToXContentParams() {
return new ToXContent.MapParams(Collections.singletonMap(INCLUDE_TYPE_NAME_PARAMETER, "true"));
protected Writeable.Reader<GetIndexTemplatesResponse> instanceReader() {
return GetIndexTemplatesResponse::new;
}
@Override

70
server/src/test/java/org/opensearch/rest/action/admin/indices/RestCreateIndexActionTests.java
View File

@ -32,48 +32,16 @@
package org.opensearch.rest.action.admin.indices;
import org.opensearch.client.node.NodeClient;
import org.opensearch.common.bytes.BytesReference;
import org.opensearch.common.xcontent.XContentBuilder;
import org.opensearch.common.xcontent.XContentFactory;
import org.opensearch.common.xcontent.XContentHelper;
import org.opensearch.rest.RestRequest;
import org.opensearch.test.rest.FakeRestRequest;
import org.opensearch.test.rest.RestActionTestCase;
import org.junit.Before;
import org.opensearch.test.OpenSearchTestCase;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import static org.opensearch.rest.BaseRestHandler.INCLUDE_TYPE_NAME_PARAMETER;
import static org.mockito.Mockito.mock;
public class RestCreateIndexActionTests extends RestActionTestCase {
private RestCreateIndexAction action;
@Before
public void setupAction() {
action = new RestCreateIndexAction();
controller().registerHandler(action);
}
public void testIncludeTypeName() throws IOException {
Map<String, String> params = new HashMap<>();
params.put(INCLUDE_TYPE_NAME_PARAMETER, randomFrom("true", "false"));
RestRequest deprecatedRequest = new FakeRestRequest.Builder(xContentRegistry()).withMethod(RestRequest.Method.PUT)
.withPath("/some_index")
.withParams(params)
.build();
action.prepareRequest(deprecatedRequest, mock(NodeClient.class));
assertWarnings(RestCreateIndexAction.TYPES_DEPRECATION_MESSAGE);
RestRequest validRequest = new FakeRestRequest.Builder(xContentRegistry()).withMethod(RestRequest.Method.PUT)
.withPath("/some_index")
.build();
action.prepareRequest(validRequest, mock(NodeClient.class));
}
public class RestCreateIndexActionTests extends OpenSearchTestCase {
public void testPrepareTypelessRequest() throws IOException {
XContentBuilder content = XContentFactory.jsonBuilder()
@ -95,8 +63,7 @@ public class RestCreateIndexActionTests extends RestActionTestCase {
.endObject();
Map<String, Object> contentAsMap = XContentHelper.convertToMap(BytesReference.bytes(content), true, content.contentType()).v2();
boolean includeTypeName = false;
Map<String, Object> source = RestCreateIndexAction.prepareMappings(contentAsMap, includeTypeName);
Map<String, Object> source = RestCreateIndexAction.prepareMappings(contentAsMap);
XContentBuilder expectedContent = XContentFactory.jsonBuilder()
.startObject()
@ -126,34 +93,6 @@ public class RestCreateIndexActionTests extends RestActionTestCase {
assertEquals(expectedContentAsMap, source);
}
public void testPrepareTypedRequest() throws IOException {
XContentBuilder content = XContentFactory.jsonBuilder()
.startObject()
.startObject("mappings")
.startObject("type")
.startObject("properties")
.startObject("field1")
.field("type", "keyword")
.endObject()
.startObject("field2")
.field("type", "text")
.endObject()
.endObject()
.endObject()
.endObject()
.startObject("aliases")
.startObject("read_alias")
.endObject()
.endObject()
.endObject();
Map<String, Object> contentAsMap = XContentHelper.convertToMap(BytesReference.bytes(content), true, content.contentType()).v2();
boolean includeTypeName = true;
Map<String, Object> source = RestCreateIndexAction.prepareMappings(contentAsMap, includeTypeName);
assertEquals(contentAsMap, source);
}
public void testMalformedMappings() throws IOException {
XContentBuilder content = XContentFactory.jsonBuilder()
.startObject()
@ -166,8 +105,7 @@ public class RestCreateIndexActionTests extends RestActionTestCase {
Map<String, Object> contentAsMap = XContentHelper.convertToMap(BytesReference.bytes(content), true, content.contentType()).v2();
boolean includeTypeName = false;
Map<String, Object> source = RestCreateIndexAction.prepareMappings(contentAsMap, includeTypeName);
Map<String, Object> source = RestCreateIndexAction.prepareMappings(contentAsMap);
assertEquals(contentAsMap, source);
}
}

83
server/src/test/java/org/opensearch/rest/action/admin/indices/RestGetIndicesActionTests.java
View File

@ -1,83 +0,0 @@
/*
* SPDX-License-Identifier: Apache-2.0
*
* The OpenSearch Contributors require contributions made to
* this file be licensed under the Apache-2.0 license or a
* compatible open source license.
*/
/*
* 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.
*/
/*
* Modifications Copyright OpenSearch Contributors. See
* GitHub history for details.
*/
package org.opensearch.rest.action.admin.indices;
import org.opensearch.client.node.NodeClient;
import org.opensearch.rest.RestRequest;
import org.opensearch.test.rest.FakeRestRequest;
import org.opensearch.test.rest.RestActionTestCase;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import static org.opensearch.rest.BaseRestHandler.INCLUDE_TYPE_NAME_PARAMETER;
import static org.mockito.Mockito.mock;
public class RestGetIndicesActionTests extends RestActionTestCase {
/**
* Test that setting the "include_type_name" parameter raises a warning for the GET request
*/
public void testIncludeTypeNamesWarning() throws IOException {
Map<String, String> params = new HashMap<>();
params.put(INCLUDE_TYPE_NAME_PARAMETER, randomFrom("true", "false"));
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withMethod(RestRequest.Method.GET)
.withPath("/some_index")
.withParams(params)
.build();
RestGetIndicesAction handler = new RestGetIndicesAction();
handler.prepareRequest(request, mock(NodeClient.class));
assertWarnings(RestGetIndicesAction.TYPES_DEPRECATION_MESSAGE);
// the same request without the parameter should pass without warning
request = new FakeRestRequest.Builder(xContentRegistry()).withMethod(RestRequest.Method.GET).withPath("/some_index").build();
handler.prepareRequest(request, mock(NodeClient.class));
}
/**
* Test that setting the "include_type_name" parameter doesn't raises a warning if the HEAD method is used (indices.exists)
*/
public void testIncludeTypeNamesWarningExists() throws IOException {
Map<String, String> params = new HashMap<>();
params.put(INCLUDE_TYPE_NAME_PARAMETER, randomFrom("true", "false"));
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withMethod(RestRequest.Method.HEAD)
.withPath("/some_index")
.withParams(params)
.build();
RestGetIndicesAction handler = new RestGetIndicesAction();
handler.prepareRequest(request, mock(NodeClient.class));
}
}

63
test/framework/src/main/java/org/opensearch/test/rest/yaml/ClientYamlTestExecutionContext.java
View File

@ -39,7 +39,6 @@ import org.apache.http.entity.ContentType;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.lucene.util.BytesRef;
import org.opensearch.LegacyESVersion;
import org.opensearch.Version;
import org.opensearch.client.NodeSelector;
import org.opensearch.common.bytes.BytesReference;
@ -54,8 +53,6 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.opensearch.rest.BaseRestHandler.INCLUDE_TYPE_NAME_PARAMETER;
/**
* Execution context passed across the REST tests.
* Holds the REST client used to communicate with opensearch.
@ -121,10 +118,6 @@ public class ClientYamlTestExecutionContext {
}
}
if (esVersion().before(LegacyESVersion.V_7_0_0)) {
adaptRequestForOlderVersion(apiName, bodies, requestParams);
}
HttpEntity entity = createEntity(bodies, requestHeaders);
try {
response = callApiInternal(apiName, requestParams, entity, requestHeaders, nodeSelector);
@ -140,62 +133,6 @@ public class ClientYamlTestExecutionContext {
}
}
/**
* To allow tests to run against a mixed 7.x/6.x cluster, we make certain modifications to the
* request related to types.
*
* Specifically, we generally use typeless index creation and document writes in test set-up code.
* This functionality is supported in 7.x, but is not supported in 6.x (or is not the default
* behavior). Here we modify the request so that it will work against a 6.x node.
*/
private void adaptRequestForOlderVersion(String apiName, List<Map<String, Object>> bodies, Map<String, String> requestParams) {
// For index creations, we specify 'include_type_name=false' if it is not explicitly set. This
// allows us to omit the parameter in the test description, while still being able to communicate
// with 6.x nodes where include_type_name defaults to 'true'.
if (apiName.equals("indices.create") && requestParams.containsKey(INCLUDE_TYPE_NAME_PARAMETER) == false) {
requestParams.put(INCLUDE_TYPE_NAME_PARAMETER, "false");
}
// We add the type to the document API requests if it's not already included.
if ((apiName.equals("index") || apiName.equals("update") || apiName.equals("delete") || apiName.equals("get"))
&& requestParams.containsKey("type") == false) {
requestParams.put("type", "_doc");
}
// We also add the type to the bulk API requests if it's not already included. The type can either
// be on the request parameters or in the action metadata in the body of the request so we need to
// be sensitive to both scenarios.
if (apiName.equals("bulk") && requestParams.containsKey("type") == false) {
if (requestParams.containsKey("index")) {
requestParams.put("type", "_doc");
} else {
for (int i = 0; i < bodies.size(); i++) {
Map<String, Object> body = bodies.get(i);
Map<String, Object> actionMetadata;
if (body.containsKey("index")) {
actionMetadata = (Map<String, Object>) body.get("index");
i++;
} else if (body.containsKey("create")) {
actionMetadata = (Map<String, Object>) body.get("create");
i++;
} else if (body.containsKey("update")) {
actionMetadata = (Map<String, Object>) body.get("update");
i++;
} else if (body.containsKey("delete")) {
actionMetadata = (Map<String, Object>) body.get("delete");
} else {
// action metadata is malformed so leave it malformed since
// the test is probably testing for malformed action metadata
continue;
}
if (actionMetadata.containsKey("_type") == false) {
actionMetadata.put("_type", "_doc");
}
}
}
}
}
private HttpEntity createEntity(List<Map<String, Object>> bodies, Map<String, String> headers) throws IOException {
if (bodies.isEmpty()) {
return null;