listener) {
+ restHighLevelClient.performRequestAsyncAndParseEntity(getIndexRequest, IndicesRequestConverters::getIndex, options,
+ org.elasticsearch.action.admin.indices.get.GetIndexResponse::fromXContent, listener, emptySet());
+ }
+
/**
* Force merge one or more indices using the Force Merge API.
* See
@@ -1058,15 +1093,38 @@ public boolean exists(GetIndexRequest request, RequestOptions options) throws IO
);
}
+ /**
+ * Checks if the index (indices) exists or not.
+ * See
+ * Indices Exists API on elastic.co
+ * @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.elasticsearch.action.admin.indices.get.GetIndexRequest request, RequestOptions options) throws IOException {
+ return restHighLevelClient.performRequest(
+ request,
+ IndicesRequestConverters::indicesExist,
+ options,
+ RestHighLevelClient::convertExistsResponse,
+ Collections.emptySet()
+ );
+ }
+
/**
* Checks if the index (indices) exists or not.
*
* See
* Indices Exists API on elastic.co
- * @deprecated Prefer {@link #exists(GetIndexRequest, RequestOptions)}
+ * @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(GetIndexRequest request, Header... headers) throws IOException {
+ public boolean exists(org.elasticsearch.action.admin.indices.get.GetIndexRequest request, Header... headers) throws IOException {
return restHighLevelClient.performRequest(
request,
IndicesRequestConverters::indicesExist,
@@ -1095,15 +1153,40 @@ public void existsAsync(GetIndexRequest request, RequestOptions options, ActionL
);
}
+ /**
+ * Asynchronously checks if the index (indices) exists or not.
+ * See
+ * Indices Exists API on elastic.co
+ * @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.
+ */
+ @Deprecated
+ public void existsAsync(org.elasticsearch.action.admin.indices.get.GetIndexRequest request, RequestOptions options,
+ ActionListener listener) {
+ restHighLevelClient.performRequestAsync(
+ request,
+ IndicesRequestConverters::indicesExist,
+ options,
+ RestHighLevelClient::convertExistsResponse,
+ listener,
+ Collections.emptySet()
+ );
+ }
+
/**
* Asynchronously checks if the index (indices) exists or not.
*
* See
* Indices Exists API on elastic.co
- * @deprecated Prefer {@link #existsAsync(GetIndexRequest, RequestOptions, ActionListener)}
+ * @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.
*/
@Deprecated
- public void existsAsync(GetIndexRequest request, ActionListener listener, Header... headers) {
+ public void existsAsync(org.elasticsearch.action.admin.indices.get.GetIndexRequest request, ActionListener listener,
+ Header... headers) {
restHighLevelClient.performRequestAsync(
request,
IndicesRequestConverters::indicesExist,
diff --git a/client/rest-high-level/src/main/java/org/elasticsearch/client/IndicesRequestConverters.java b/client/rest-high-level/src/main/java/org/elasticsearch/client/IndicesRequestConverters.java
index d26f9babed889..13fc6a8e08bd3 100644
--- a/client/rest-high-level/src/main/java/org/elasticsearch/client/IndicesRequestConverters.java
+++ b/client/rest-high-level/src/main/java/org/elasticsearch/client/IndicesRequestConverters.java
@@ -33,8 +33,6 @@
import org.elasticsearch.action.admin.indices.flush.FlushRequest;
import org.elasticsearch.action.admin.indices.flush.SyncedFlushRequest;
import org.elasticsearch.action.admin.indices.forcemerge.ForceMergeRequest;
-import org.elasticsearch.action.admin.indices.get.GetIndexRequest;
-import org.elasticsearch.client.indices.GetFieldMappingsRequest;
import org.elasticsearch.action.admin.indices.open.OpenIndexRequest;
import org.elasticsearch.action.admin.indices.refresh.RefreshRequest;
import org.elasticsearch.action.admin.indices.rollover.RolloverRequest;
@@ -48,6 +46,8 @@
import org.elasticsearch.action.support.ActiveShardCount;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.FreezeIndexRequest;
+import org.elasticsearch.client.indices.GetFieldMappingsRequest;
+import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.client.indices.GetIndexTemplatesRequest;
import org.elasticsearch.client.indices.GetMappingsRequest;
import org.elasticsearch.client.indices.IndexTemplatesExistRequest;
@@ -151,6 +151,10 @@ static Request putMapping(PutMappingRequest putMappingRequest) throws IOExceptio
return request;
}
+ /**
+ * converter for the legacy server-side {@link org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequest} that still supports
+ * types
+ */
@Deprecated
static Request putMapping(org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequest putMappingRequest) throws IOException {
// The concreteIndex is an internal concept, not applicable to requests made over the REST API.
@@ -375,6 +379,28 @@ static Request getSettings(GetSettingsRequest getSettingsRequest) {
return request;
}
+ /**
+ * converter for the legacy server-side {@link org.elasticsearch.action.admin.indices.get.GetIndexRequest} that
+ * still supports types
+ */
+ @Deprecated
+ static Request getIndex(org.elasticsearch.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(request);
+ 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, Boolean.TRUE.toString());
+
+ return request;
+ }
+
static Request getIndex(GetIndexRequest getIndexRequest) {
String[] indices = getIndexRequest.indices() == null ? Strings.EMPTY_ARRAY : getIndexRequest.indices();
@@ -388,11 +414,33 @@ static Request getIndex(GetIndexRequest getIndexRequest) {
params.withHuman(getIndexRequest.humanReadable());
params.withMasterTimeout(getIndexRequest.masterNodeTimeout());
// Force "include_type_name" parameter since responses need to be compatible when coming from 7.0 nodes
- params.withIncludeTypeName(true);
+ params.putParam(INCLUDE_TYPE_NAME_PARAMETER, Boolean.FALSE.toString());
return request;
}
+ /**
+ * converter for the legacy server-side {@link org.elasticsearch.action.admin.indices.get.GetIndexRequest} that
+ * still supports types
+ */
+ @Deprecated
+ static Request indicesExist(org.elasticsearch.action.admin.indices.get.GetIndexRequest getIndexRequest) {
+ // this can be called with no indices as argument by transport client, not via REST though
+ if (getIndexRequest.indices() == null || getIndexRequest.indices().length == 0) {
+ throw new IllegalArgumentException("indices are mandatory");
+ }
+ String endpoint = RequestConverters.endpoint(getIndexRequest.indices(), "");
+ Request request = new Request(HttpHead.METHOD_NAME, endpoint);
+
+ RequestConverters.Params params = new RequestConverters.Params(request);
+ params.withLocal(getIndexRequest.local());
+ params.withHuman(getIndexRequest.humanReadable());
+ params.withIndicesOptions(getIndexRequest.indicesOptions());
+ params.withIncludeDefaults(getIndexRequest.includeDefaults());
+ params.putParam(INCLUDE_TYPE_NAME_PARAMETER, Boolean.TRUE.toString());
+ return request;
+ }
+
static Request indicesExist(GetIndexRequest getIndexRequest) {
// this can be called with no indices as argument by transport client, not via REST though
if (getIndexRequest.indices() == null || getIndexRequest.indices().length == 0) {
@@ -406,6 +454,7 @@ static Request indicesExist(GetIndexRequest getIndexRequest) {
params.withHuman(getIndexRequest.humanReadable());
params.withIndicesOptions(getIndexRequest.indicesOptions());
params.withIncludeDefaults(getIndexRequest.includeDefaults());
+ params.putParam(INCLUDE_TYPE_NAME_PARAMETER, Boolean.FALSE.toString());
return request;
}
diff --git a/client/rest-high-level/src/main/java/org/elasticsearch/client/indices/GetIndexRequest.java b/client/rest-high-level/src/main/java/org/elasticsearch/client/indices/GetIndexRequest.java
new file mode 100644
index 0000000000000..227b1b4d36abc
--- /dev/null
+++ b/client/rest-high-level/src/main/java/org/elasticsearch/client/indices/GetIndexRequest.java
@@ -0,0 +1,132 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.elasticsearch.client.indices;
+
+import org.elasticsearch.action.support.IndicesOptions;
+import org.elasticsearch.client.TimedRequest;
+import org.elasticsearch.common.util.ArrayUtils;
+
+/**
+ * A request to retrieve information about an index.
+ */
+public class GetIndexRequest extends TimedRequest {
+
+ public enum Feature {
+ ALIASES,
+ MAPPINGS,
+ SETTINGS;
+ }
+
+ static final Feature[] DEFAULT_FEATURES = new Feature[] { Feature.ALIASES, Feature.MAPPINGS, Feature.SETTINGS };
+ private Feature[] features = DEFAULT_FEATURES;
+ private boolean humanReadable = false;
+ private transient boolean includeDefaults = false;
+
+ private final String[] indices;
+ private IndicesOptions indicesOptions = IndicesOptions.fromOptions(false, false, true, true);
+ private boolean local = false;
+
+ public GetIndexRequest(String... indices) {
+ this.indices = indices;
+ }
+
+ /**
+ * The indices into which the mappings will be put.
+ */
+ public String[] indices() {
+ return indices;
+ }
+
+ public IndicesOptions indicesOptions() {
+ return indicesOptions;
+ }
+
+ public GetIndexRequest indicesOptions(IndicesOptions indicesOptions) {
+ this.indicesOptions = indicesOptions;
+ return this;
+ }
+
+ public final GetIndexRequest local(boolean local) {
+ this.local = local;
+ return this;
+ }
+
+ /**
+ * Return local information, do not retrieve the state from master node (default: false).
+ * @return true if local information is to be returned;
+ * false if information is to be retrieved from master node (default).
+ */
+ public final boolean local() {
+ return local;
+ }
+
+ public GetIndexRequest features(Feature... features) {
+ if (features == null) {
+ throw new IllegalArgumentException("features cannot be null");
+ } else {
+ this.features = features;
+ }
+ return this;
+ }
+
+ public GetIndexRequest addFeatures(Feature... features) {
+ if (this.features == DEFAULT_FEATURES) {
+ return features(features);
+ } else {
+ return features(ArrayUtils.concat(features(), features, Feature.class));
+ }
+ }
+
+ public Feature[] features() {
+ return features;
+ }
+
+ public GetIndexRequest humanReadable(boolean humanReadable) {
+ this.humanReadable = humanReadable;
+ return this;
+ }
+
+ public boolean humanReadable() {
+ return humanReadable;
+ }
+
+ /**
+ * Sets the value of "include_defaults".
+ *
+ * @param includeDefaults value of "include_defaults" to be set.
+ * @return this request
+ */
+ public GetIndexRequest includeDefaults(boolean includeDefaults) {
+ this.includeDefaults = includeDefaults;
+ return this;
+ }
+
+ /**
+ * Whether to return all default settings for each of the indices.
+ *
+ * @return true if defaults settings for each of the indices need to returned;
+ * false otherwise.
+ */
+ public boolean includeDefaults() {
+ return includeDefaults;
+ }
+
+
+}
diff --git a/client/rest-high-level/src/main/java/org/elasticsearch/client/indices/GetIndexResponse.java b/client/rest-high-level/src/main/java/org/elasticsearch/client/indices/GetIndexResponse.java
new file mode 100644
index 0000000000000..3d98f93df47d9
--- /dev/null
+++ b/client/rest-high-level/src/main/java/org/elasticsearch/client/indices/GetIndexResponse.java
@@ -0,0 +1,222 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.elasticsearch.client.indices;
+
+import org.apache.lucene.util.CollectionUtil;
+import org.elasticsearch.cluster.metadata.AliasMetaData;
+import org.elasticsearch.cluster.metadata.MappingMetaData;
+import org.elasticsearch.common.settings.Settings;
+import org.elasticsearch.common.xcontent.XContentParser;
+import org.elasticsearch.common.xcontent.XContentParser.Token;
+import org.elasticsearch.index.mapper.MapperService;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.elasticsearch.common.xcontent.XContentParserUtils.ensureExpectedToken;
+
+/**
+ * A client side response for a get index action.
+ */
+public class GetIndexResponse {
+
+ private Map mappings;
+ private Map> aliases;
+ private Map settings;
+ private Map defaultSettings;
+ private String[] indices;
+
+ GetIndexResponse(String[] indices,
+ Map mappings,
+ Map> aliases,
+ Map settings,
+ Map defaultSettings) {
+ this.indices = indices;
+ // to have deterministic order
+ Arrays.sort(indices);
+ if (mappings != null) {
+ this.mappings = mappings;
+ }
+ if (aliases != null) {
+ this.aliases = aliases;
+ }
+ if (settings != null) {
+ this.settings = settings;
+ }
+ if (defaultSettings != null) {
+ this.defaultSettings = defaultSettings;
+ }
+ }
+
+ public String[] getIndices() {
+ return indices;
+ }
+
+ public Map getMappings() {
+ return mappings;
+ }
+
+ public Map> getAliases() {
+ return aliases;
+ }
+
+ /**
+ * If the originating {@link GetIndexRequest} object was configured to include
+ * defaults, this will contain a mapping of index name to {@link Settings} objects.
+ * The returned {@link Settings} objects will contain only those settings taking
+ * effect as defaults. Any settings explicitly set on the index will be available
+ * via {@link #getSettings()}.
+ * See also {@link GetIndexRequest#includeDefaults(boolean)}
+ */
+ public Map getDefaultSettings() {
+ return defaultSettings;
+ }
+
+ public Map getSettings() {
+ return settings;
+ }
+
+ /**
+ * Returns the string value for the specified index and setting. If the includeDefaults flag was not set or set to
+ * false on the {@link GetIndexRequest}, this method will only return a value where the setting was explicitly set
+ * on the index. If the includeDefaults flag was set to true on the {@link GetIndexRequest}, this method will fall
+ * back to return the default value if the setting was not explicitly set.
+ */
+ public String getSetting(String index, String setting) {
+ Settings indexSettings = settings.get(index);
+ if (setting != null) {
+ if (indexSettings != null && indexSettings.hasValue(setting)) {
+ return indexSettings.get(setting);
+ } else {
+ Settings defaultIndexSettings = defaultSettings.get(index);
+ if (defaultIndexSettings != null) {
+ return defaultIndexSettings.get(setting);
+ } else {
+ return null;
+ }
+ }
+ } else {
+ return null;
+ }
+ }
+
+ private static List parseAliases(XContentParser parser) throws IOException {
+ List indexAliases = new ArrayList<>();
+ // We start at START_OBJECT since parseIndexEntry ensures that
+ while (parser.nextToken() != Token.END_OBJECT) {
+ ensureExpectedToken(Token.FIELD_NAME, parser.currentToken(), parser::getTokenLocation);
+ indexAliases.add(AliasMetaData.Builder.fromXContent(parser));
+ }
+ return indexAliases;
+ }
+
+ private static MappingMetaData parseMappings(XContentParser parser) throws IOException {
+ return new MappingMetaData(MapperService.SINGLE_MAPPING_NAME, parser.map());
+ }
+
+ private static IndexEntry parseIndexEntry(XContentParser parser) throws IOException {
+ List indexAliases = null;
+ MappingMetaData indexMappings = null;
+ Settings indexSettings = null;
+ Settings indexDefaultSettings = null;
+ // We start at START_OBJECT since fromXContent ensures that
+ while (parser.nextToken() != Token.END_OBJECT) {
+ ensureExpectedToken(Token.FIELD_NAME, parser.currentToken(), parser::getTokenLocation);
+ parser.nextToken();
+ if (parser.currentToken() == Token.START_OBJECT) {
+ switch (parser.currentName()) {
+ case "aliases":
+ indexAliases = parseAliases(parser);
+ break;
+ case "mappings":
+ indexMappings = parseMappings(parser);
+ break;
+ case "settings":
+ indexSettings = Settings.fromXContent(parser);
+ break;
+ case "defaults":
+ indexDefaultSettings = Settings.fromXContent(parser);
+ break;
+ default:
+ parser.skipChildren();
+ }
+ } else if (parser.currentToken() == Token.START_ARRAY) {
+ parser.skipChildren();
+ }
+ }
+ return new IndexEntry(indexAliases, indexMappings, indexSettings, indexDefaultSettings);
+ }
+
+ // This is just an internal container to make stuff easier for returning
+ private static class IndexEntry {
+ List indexAliases = new ArrayList<>();
+ MappingMetaData indexMappings;
+ Settings indexSettings = Settings.EMPTY;
+ Settings indexDefaultSettings = Settings.EMPTY;
+ IndexEntry(List indexAliases, MappingMetaData indexMappings, Settings indexSettings, Settings indexDefaultSettings) {
+ if (indexAliases != null) this.indexAliases = indexAliases;
+ if (indexMappings != null) this.indexMappings = indexMappings;
+ if (indexSettings != null) this.indexSettings = indexSettings;
+ if (indexDefaultSettings != null) this.indexDefaultSettings = indexDefaultSettings;
+ }
+ }
+
+ public static GetIndexResponse fromXContent(XContentParser parser) throws IOException {
+ Map> aliases = new HashMap<>();
+ Map mappings = new HashMap<>();
+ Map settings = new HashMap<>();
+ Map defaultSettings = new HashMap<>();
+ List indices = new ArrayList<>();
+
+ if (parser.currentToken() == null) {
+ parser.nextToken();
+ }
+ ensureExpectedToken(Token.START_OBJECT, parser.currentToken(), parser::getTokenLocation);
+ parser.nextToken();
+
+ while (!parser.isClosed()) {
+ if (parser.currentToken() == Token.START_OBJECT) {
+ // we assume this is an index entry
+ String indexName = parser.currentName();
+ indices.add(indexName);
+ IndexEntry indexEntry = parseIndexEntry(parser);
+ // make the order deterministic
+ CollectionUtil.timSort(indexEntry.indexAliases, Comparator.comparing(AliasMetaData::alias));
+ aliases.put(indexName, Collections.unmodifiableList(indexEntry.indexAliases));
+ mappings.put(indexName, indexEntry.indexMappings);
+ settings.put(indexName, indexEntry.indexSettings);
+ if (indexEntry.indexDefaultSettings.isEmpty() == false) {
+ defaultSettings.put(indexName, indexEntry.indexDefaultSettings);
+ }
+ } else if (parser.currentToken() == Token.START_ARRAY) {
+ parser.skipChildren();
+ } else {
+ parser.nextToken();
+ }
+ }
+ return new GetIndexResponse(indices.toArray(new String[0]), mappings, aliases, settings, defaultSettings);
+ }
+}
diff --git a/client/rest-high-level/src/test/java/org/elasticsearch/client/ClusterRequestConvertersTests.java b/client/rest-high-level/src/test/java/org/elasticsearch/client/ClusterRequestConvertersTests.java
index c78935464d9fc..963b4b783bdae 100644
--- a/client/rest-high-level/src/test/java/org/elasticsearch/client/ClusterRequestConvertersTests.java
+++ b/client/rest-high-level/src/test/java/org/elasticsearch/client/ClusterRequestConvertersTests.java
@@ -75,7 +75,7 @@ public void testClusterGetSettings() throws IOException {
public void testClusterHealth() {
ClusterHealthRequest healthRequest = new ClusterHealthRequest();
Map expectedParams = new HashMap<>();
- setRandomLocal(healthRequest, expectedParams);
+ setRandomLocal(healthRequest::local, expectedParams);
String timeoutType = randomFrom("timeout", "masterTimeout", "both", "none");
String timeout = randomTimeValue();
String masterTimeout = randomTimeValue();
diff --git a/client/rest-high-level/src/test/java/org/elasticsearch/client/CrudIT.java b/client/rest-high-level/src/test/java/org/elasticsearch/client/CrudIT.java
index 27e6221f0ec84..22beb25e0d658 100644
--- a/client/rest-high-level/src/test/java/org/elasticsearch/client/CrudIT.java
+++ b/client/rest-high-level/src/test/java/org/elasticsearch/client/CrudIT.java
@@ -27,7 +27,6 @@
import org.elasticsearch.action.admin.cluster.node.tasks.list.ListTasksRequest;
import org.elasticsearch.action.admin.cluster.node.tasks.list.ListTasksResponse;
import org.elasticsearch.action.admin.cluster.node.tasks.list.TaskGroup;
-import org.elasticsearch.action.admin.indices.get.GetIndexRequest;
import org.elasticsearch.action.bulk.BulkItemResponse;
import org.elasticsearch.action.bulk.BulkProcessor;
import org.elasticsearch.action.bulk.BulkRequest;
@@ -49,6 +48,7 @@
import org.elasticsearch.client.core.TermVectorsRequest;
import org.elasticsearch.client.core.TermVectorsResponse;
import org.elasticsearch.client.indices.CreateIndexRequest;
+import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.common.Strings;
import org.elasticsearch.common.bytes.BytesReference;
import org.elasticsearch.common.settings.Settings;
@@ -1209,7 +1209,7 @@ public void testUrlEncode() throws IOException {
assertEquals(docId, getResponse.getId());
}
- assertTrue(highLevelClient().indices().exists(new GetIndexRequest().indices(indexPattern, "index"), RequestOptions.DEFAULT));
+ assertTrue(highLevelClient().indices().exists(new GetIndexRequest(indexPattern, "index"), RequestOptions.DEFAULT));
}
public void testParamsEncode() throws IOException {
diff --git a/client/rest-high-level/src/test/java/org/elasticsearch/client/IndicesClientIT.java b/client/rest-high-level/src/test/java/org/elasticsearch/client/IndicesClientIT.java
index c549399d193a4..0aed9f3baaba0 100644
--- a/client/rest-high-level/src/test/java/org/elasticsearch/client/IndicesClientIT.java
+++ b/client/rest-high-level/src/test/java/org/elasticsearch/client/IndicesClientIT.java
@@ -39,10 +39,6 @@
import org.elasticsearch.action.admin.indices.flush.SyncedFlushRequest;
import org.elasticsearch.action.admin.indices.forcemerge.ForceMergeRequest;
import org.elasticsearch.action.admin.indices.forcemerge.ForceMergeResponse;
-import org.elasticsearch.action.admin.indices.get.GetIndexRequest;
-import org.elasticsearch.action.admin.indices.get.GetIndexResponse;
-import org.elasticsearch.client.indices.GetFieldMappingsRequest;
-import org.elasticsearch.client.indices.GetFieldMappingsResponse;
import org.elasticsearch.action.admin.indices.open.OpenIndexRequest;
import org.elasticsearch.action.admin.indices.open.OpenIndexResponse;
import org.elasticsearch.action.admin.indices.refresh.RefreshRequest;
@@ -70,6 +66,10 @@
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.FreezeIndexRequest;
+import org.elasticsearch.client.indices.GetFieldMappingsRequest;
+import org.elasticsearch.client.indices.GetFieldMappingsResponse;
+import org.elasticsearch.client.indices.GetIndexRequest;
+import org.elasticsearch.client.indices.GetIndexResponse;
import org.elasticsearch.client.indices.GetIndexTemplatesRequest;
import org.elasticsearch.client.indices.GetMappingsRequest;
import org.elasticsearch.client.indices.GetMappingsResponse;
@@ -79,6 +79,7 @@
import org.elasticsearch.cluster.metadata.AliasMetaData;
import org.elasticsearch.cluster.metadata.IndexMetaData;
import org.elasticsearch.cluster.metadata.IndexTemplateMetaData;
+import org.elasticsearch.cluster.metadata.MappingMetaData;
import org.elasticsearch.common.ValidationException;
import org.elasticsearch.common.bytes.BytesArray;
import org.elasticsearch.common.settings.Setting;
@@ -96,6 +97,7 @@
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.rest.action.admin.indices.RestCreateIndexAction;
import org.elasticsearch.rest.action.admin.indices.RestGetFieldMappingAction;
+import org.elasticsearch.rest.action.admin.indices.RestGetIndicesAction;
import org.elasticsearch.rest.action.admin.indices.RestGetMappingAction;
import org.elasticsearch.rest.action.admin.indices.RestPutMappingAction;
@@ -134,14 +136,11 @@ public void testIndicesExists() throws IOException {
String indexName = "test_index_exists_index_present";
createIndex(indexName, Settings.EMPTY);
- GetIndexRequest request = new GetIndexRequest();
- request.indices(indexName);
+ GetIndexRequest request = new GetIndexRequest(indexName);
boolean response = execute(
request,
highLevelClient().indices()::exists,
- highLevelClient().indices()::existsAsync,
- highLevelClient().indices()::exists,
highLevelClient().indices()::existsAsync
);
assertTrue(response);
@@ -151,14 +150,11 @@ public void testIndicesExists() throws IOException {
{
String indexName = "non_existent_index";
- GetIndexRequest request = new GetIndexRequest();
- request.indices(indexName);
+ GetIndexRequest request = new GetIndexRequest(indexName);
boolean response = execute(
request,
highLevelClient().indices()::exists,
- highLevelClient().indices()::existsAsync,
- highLevelClient().indices()::exists,
highLevelClient().indices()::existsAsync
);
assertFalse(response);
@@ -171,19 +167,34 @@ public void testIndicesExists() throws IOException {
String nonExistentIndex = "oranges";
- GetIndexRequest request = new GetIndexRequest();
- request.indices(existingIndex, nonExistentIndex);
+ GetIndexRequest request = new GetIndexRequest(existingIndex, nonExistentIndex);
boolean response = execute(
request,
highLevelClient().indices()::exists,
- highLevelClient().indices()::existsAsync,
- highLevelClient().indices()::exists,
highLevelClient().indices()::existsAsync
);
assertFalse(response);
}
+ }
+ public void testIndicesExistsWithTypes() throws IOException {
+ // Index present
+ String indexName = "test_index_exists_index_present";
+ createIndex(indexName, Settings.EMPTY);
+
+ org.elasticsearch.action.admin.indices.get.GetIndexRequest request
+ = new org.elasticsearch.action.admin.indices.get.GetIndexRequest();
+ request.indices(indexName);
+
+ boolean response = execute(
+ request,
+ highLevelClient().indices()::exists,
+ highLevelClient().indices()::existsAsync,
+ highLevelClient().indices()::exists,
+ highLevelClient().indices()::existsAsync
+ );
+ assertTrue(response);
}
@SuppressWarnings({"unchecked", "rawtypes"})
@@ -423,8 +434,7 @@ public void testGetIndex() throws IOException {
String mappings = "\"_doc\":{\"properties\":{\"field-1\":{\"type\":\"integer\"}}}";
createIndex(indexName, basicSettings, mappings);
- GetIndexRequest getIndexRequest = new GetIndexRequest()
- .indices(indexName).includeDefaults(false);
+ GetIndexRequest getIndexRequest = new GetIndexRequest(indexName).includeDefaults(false);
GetIndexResponse getIndexResponse =
execute(getIndexRequest, highLevelClient().indices()::get, highLevelClient().indices()::getAsync);
@@ -433,8 +443,12 @@ public void testGetIndex() throws IOException {
assertEquals("1", getIndexResponse.getSetting(indexName, SETTING_NUMBER_OF_SHARDS));
assertEquals("0", getIndexResponse.getSetting(indexName, SETTING_NUMBER_OF_REPLICAS));
assertNotNull(getIndexResponse.getMappings().get(indexName));
- assertNotNull(getIndexResponse.getMappings().get(indexName).get("_doc"));
- Object o = getIndexResponse.getMappings().get(indexName).get("_doc").getSourceAsMap().get("properties");
+ assertNotNull(getIndexResponse.getMappings().get(indexName));
+ MappingMetaData mappingMetaData = getIndexResponse.getMappings().get(indexName);
+ assertNotNull(mappingMetaData);
+ assertEquals("_doc", mappingMetaData.type());
+ assertEquals("{\"properties\":{\"field-1\":{\"type\":\"integer\"}}}", mappingMetaData.source().string());
+ Object o = mappingMetaData.getSourceAsMap().get("properties");
assertThat(o, instanceOf(Map.class));
//noinspection unchecked
assertThat(((Map) o).get("field-1"), instanceOf(Map.class));
@@ -443,6 +457,33 @@ public void testGetIndex() throws IOException {
assertEquals("integer", fieldMapping.get("type"));
}
+ @SuppressWarnings("unchecked")
+ public void testGetIndexWithTypes() throws IOException {
+ String indexName = "get_index_test";
+ Settings basicSettings = Settings.builder()
+ .put(SETTING_NUMBER_OF_SHARDS, 1)
+ .put(SETTING_NUMBER_OF_REPLICAS, 0)
+ .build();
+ String mappings = "\"_doc\":{\"properties\":{\"field-1\":{\"type\":\"integer\"}}}";
+ createIndex(indexName, basicSettings, mappings);
+
+ org.elasticsearch.action.admin.indices.get.GetIndexRequest getIndexRequest =
+ new org.elasticsearch.action.admin.indices.get.GetIndexRequest().indices(indexName).includeDefaults(false);
+ org.elasticsearch.action.admin.indices.get.GetIndexResponse getIndexResponse = execute(getIndexRequest,
+ highLevelClient().indices()::get, highLevelClient().indices()::getAsync,
+ expectWarnings(RestGetIndicesAction.TYPES_DEPRECATION_MESSAGE));
+
+ // default settings should be null
+ assertNull(getIndexResponse.getSetting(indexName, "index.refresh_interval"));
+ assertEquals("1", getIndexResponse.getSetting(indexName, SETTING_NUMBER_OF_SHARDS));
+ assertEquals("0", getIndexResponse.getSetting(indexName, SETTING_NUMBER_OF_REPLICAS));
+ assertNotNull(getIndexResponse.getMappings().get(indexName));
+ MappingMetaData mappingMetaData = getIndexResponse.getMappings().get(indexName).get("_doc");
+ assertNotNull(mappingMetaData);
+ assertEquals("_doc", mappingMetaData.type());
+ assertEquals("{\"properties\":{\"field-1\":{\"type\":\"integer\"}}}", mappingMetaData.source().string());
+ }
+
@SuppressWarnings("unchecked")
public void testGetIndexWithDefaults() throws IOException {
String indexName = "get_index_test";
@@ -453,19 +494,18 @@ public void testGetIndexWithDefaults() throws IOException {
String mappings = "\"_doc\":{\"properties\":{\"field-1\":{\"type\":\"integer\"}}}";
createIndex(indexName, basicSettings, mappings);
- GetIndexRequest getIndexRequest = new GetIndexRequest()
- .indices(indexName).includeDefaults(true);
+ GetIndexRequest getIndexRequest = new GetIndexRequest(indexName).includeDefaults(true);
GetIndexResponse getIndexResponse =
execute(getIndexRequest, highLevelClient().indices()::get, highLevelClient().indices()::getAsync);
assertNotNull(getIndexResponse.getSetting(indexName, "index.refresh_interval"));
assertEquals(IndexSettings.DEFAULT_REFRESH_INTERVAL,
- getIndexResponse.defaultSettings().get(indexName).getAsTime("index.refresh_interval", null));
+ getIndexResponse.getDefaultSettings().get(indexName).getAsTime("index.refresh_interval", null));
assertEquals("1", getIndexResponse.getSetting(indexName, SETTING_NUMBER_OF_SHARDS));
assertEquals("0", getIndexResponse.getSetting(indexName, SETTING_NUMBER_OF_REPLICAS));
assertNotNull(getIndexResponse.getMappings().get(indexName));
- assertNotNull(getIndexResponse.getMappings().get(indexName).get("_doc"));
- Object o = getIndexResponse.getMappings().get(indexName).get("_doc").getSourceAsMap().get("properties");
+ assertNotNull(getIndexResponse.getMappings().get(indexName));
+ Object o = getIndexResponse.getMappings().get(indexName).getSourceAsMap().get("properties");
assertThat(o, instanceOf(Map.class));
assertThat(((Map) o).get("field-1"), instanceOf(Map.class));
Map fieldMapping = (Map) ((Map) o).get("field-1");
@@ -476,7 +516,7 @@ public void testGetIndexNonExistentIndex() throws IOException {
String nonExistentIndex = "index_that_doesnt_exist";
assertFalse(indexExists(nonExistentIndex));
- GetIndexRequest getIndexRequest = new GetIndexRequest().indices(nonExistentIndex);
+ GetIndexRequest getIndexRequest = new GetIndexRequest(nonExistentIndex);
ElasticsearchException exception = expectThrows(ElasticsearchException.class,
() -> execute(getIndexRequest, highLevelClient().indices()::get, highLevelClient().indices()::getAsync));
assertEquals(RestStatus.NOT_FOUND, exception.status());
@@ -1564,7 +1604,6 @@ public void testCRUDIndexTemplate() throws Exception {
assertTrue(template2.aliases().isEmpty());
assertThat(template2.settings().get("index.number_of_shards"), equalTo("2"));
assertThat(template2.settings().get("index.number_of_replicas"), equalTo("0"));
-
List names = randomBoolean()
? Arrays.asList("*-1", "template-2")
: Arrays.asList("template-*");
diff --git a/client/rest-high-level/src/test/java/org/elasticsearch/client/IndicesRequestConvertersTests.java b/client/rest-high-level/src/test/java/org/elasticsearch/client/IndicesRequestConvertersTests.java
index 5ddaf873b9d65..e4909787146c4 100644
--- a/client/rest-high-level/src/test/java/org/elasticsearch/client/IndicesRequestConvertersTests.java
+++ b/client/rest-high-level/src/test/java/org/elasticsearch/client/IndicesRequestConvertersTests.java
@@ -36,7 +36,6 @@
import org.elasticsearch.action.admin.indices.flush.FlushRequest;
import org.elasticsearch.action.admin.indices.flush.SyncedFlushRequest;
import org.elasticsearch.action.admin.indices.forcemerge.ForceMergeRequest;
-import org.elasticsearch.action.admin.indices.get.GetIndexRequest;
import org.elasticsearch.action.admin.indices.open.OpenIndexRequest;
import org.elasticsearch.action.admin.indices.refresh.RefreshRequest;
import org.elasticsearch.action.admin.indices.rollover.RolloverRequest;
@@ -51,6 +50,7 @@
import org.elasticsearch.action.support.master.AcknowledgedRequest;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.GetFieldMappingsRequest;
+import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.client.indices.GetIndexTemplatesRequest;
import org.elasticsearch.client.indices.GetMappingsRequest;
import org.elasticsearch.client.indices.IndexTemplatesExistRequest;
@@ -103,13 +103,14 @@ public void testAnalyzeRequest() throws Exception {
public void testIndicesExist() {
String[] indices = RequestConvertersTests.randomIndicesNames(1, 10);
- GetIndexRequest getIndexRequest = new GetIndexRequest().indices(indices);
+ GetIndexRequest getIndexRequest = new GetIndexRequest(indices);
Map expectedParams = new HashMap<>();
+ expectedParams.put(INCLUDE_TYPE_NAME_PARAMETER, Boolean.FALSE.toString());
RequestConvertersTests.setRandomIndicesOptions(getIndexRequest::indicesOptions, getIndexRequest::indicesOptions, expectedParams);
- RequestConvertersTests.setRandomLocal(getIndexRequest, expectedParams);
- RequestConvertersTests.setRandomHumanReadable(getIndexRequest, expectedParams);
- RequestConvertersTests.setRandomIncludeDefaults(getIndexRequest, expectedParams);
+ RequestConvertersTests.setRandomLocal(getIndexRequest::local, expectedParams);
+ RequestConvertersTests.setRandomHumanReadable(getIndexRequest::humanReadable, expectedParams);
+ RequestConvertersTests.setRandomIncludeDefaults(getIndexRequest::includeDefaults, expectedParams);
final Request request = IndicesRequestConverters.indicesExist(getIndexRequest);
@@ -123,7 +124,35 @@ public void testIndicesExistEmptyIndices() {
LuceneTestCase.expectThrows(IllegalArgumentException.class, ()
-> IndicesRequestConverters.indicesExist(new GetIndexRequest()));
LuceneTestCase.expectThrows(IllegalArgumentException.class, ()
- -> IndicesRequestConverters.indicesExist(new GetIndexRequest().indices((String[]) null)));
+ -> IndicesRequestConverters.indicesExist(new GetIndexRequest((String[]) null)));
+ }
+
+ public void testIndicesExistEmptyIndicesWithTypes() {
+ LuceneTestCase.expectThrows(IllegalArgumentException.class,
+ () -> IndicesRequestConverters.indicesExist(new org.elasticsearch.action.admin.indices.get.GetIndexRequest()));
+ LuceneTestCase.expectThrows(IllegalArgumentException.class, () -> IndicesRequestConverters
+ .indicesExist(new org.elasticsearch.action.admin.indices.get.GetIndexRequest().indices((String[]) null)));
+ }
+
+ public void testIndicesExistWithTypes() {
+ String[] indices = RequestConvertersTests.randomIndicesNames(1, 10);
+
+ org.elasticsearch.action.admin.indices.get.GetIndexRequest getIndexRequest =
+ new org.elasticsearch.action.admin.indices.get.GetIndexRequest().indices(indices);
+
+ Map 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, Boolean.TRUE.toString());
+
+ 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 {
@@ -289,7 +318,7 @@ public void testGetMappingWithTypes() {
RequestConvertersTests.setRandomIndicesOptions(getMappingRequest::indicesOptions,
getMappingRequest::indicesOptions, expectedParams);
RequestConvertersTests.setRandomMasterTimeout(getMappingRequest, expectedParams);
- RequestConvertersTests.setRandomLocal(getMappingRequest, expectedParams);
+ RequestConvertersTests.setRandomLocal(getMappingRequest::local, expectedParams);
expectedParams.put(INCLUDE_TYPE_NAME_PARAMETER, "true");
Request request = IndicesRequestConverters.getMappings(getMappingRequest);
@@ -436,7 +465,7 @@ public void testGetSettings() throws IOException {
RequestConvertersTests.setRandomIndicesOptions(getSettingsRequest::indicesOptions, getSettingsRequest::indicesOptions,
expectedParams);
- RequestConvertersTests.setRandomLocal(getSettingsRequest, expectedParams);
+ RequestConvertersTests.setRandomLocal(getSettingsRequest::local, expectedParams);
if (ESTestCase.randomBoolean()) {
// the request object will not have include_defaults present unless it is set to
@@ -477,15 +506,50 @@ public void testGetSettings() throws IOException {
public void testGetIndex() throws IOException {
String[] indicesUnderTest = ESTestCase.randomBoolean() ? null : RequestConvertersTests.randomIndicesNames(0, 5);
- GetIndexRequest getIndexRequest = new GetIndexRequest().indices(indicesUnderTest);
+ GetIndexRequest getIndexRequest = new GetIndexRequest(indicesUnderTest);
Map expectedParams = new HashMap<>();
+ expectedParams.put(INCLUDE_TYPE_NAME_PARAMETER, Boolean.FALSE.toString());
RequestConvertersTests.setRandomMasterTimeout(getIndexRequest, expectedParams);
RequestConvertersTests.setRandomIndicesOptions(getIndexRequest::indicesOptions, getIndexRequest::indicesOptions, expectedParams);
- RequestConvertersTests.setRandomLocal(getIndexRequest, expectedParams);
- RequestConvertersTests.setRandomHumanReadable(getIndexRequest, expectedParams);
+ RequestConvertersTests.setRandomLocal(getIndexRequest::local, expectedParams);
+ RequestConvertersTests.setRandomHumanReadable(getIndexRequest::humanReadable, expectedParams);
+
+ if (ESTestCase.randomBoolean()) {
+ // the request object will not have include_defaults present unless it is set to
+ // true
+ getIndexRequest.includeDefaults(ESTestCase.randomBoolean());
+ if (getIndexRequest.includeDefaults()) {
+ expectedParams.put("include_defaults", Boolean.toString(true));
+ }
+ }
+
+ StringJoiner endpoint = new StringJoiner("/", "/", "");
+ if (indicesUnderTest != null && indicesUnderTest.length > 0) {
+ endpoint.add(String.join(",", indicesUnderTest));
+ }
+
+ Request request = IndicesRequestConverters.getIndex(getIndexRequest);
+
+ Assert.assertThat(endpoint.toString(), equalTo(request.getEndpoint()));
+ Assert.assertThat(request.getParameters(), equalTo(expectedParams));
+ Assert.assertThat(request.getMethod(), equalTo(HttpGet.METHOD_NAME));
+ Assert.assertThat(request.getEntity(), nullValue());
+ }
+
+ public void testGetIndexWithTypes() throws IOException {
+ String[] indicesUnderTest = ESTestCase.randomBoolean() ? null : RequestConvertersTests.randomIndicesNames(0, 5);
+
+ org.elasticsearch.action.admin.indices.get.GetIndexRequest getIndexRequest =
+ new org.elasticsearch.action.admin.indices.get.GetIndexRequest().indices(indicesUnderTest);
+
+ Map expectedParams = new HashMap<>();
+ RequestConvertersTests.setRandomMasterTimeout(getIndexRequest, expectedParams);
+ RequestConvertersTests.setRandomIndicesOptions(getIndexRequest::indicesOptions, getIndexRequest::indicesOptions, expectedParams);
+ RequestConvertersTests.setRandomLocal(getIndexRequest::local, expectedParams);
+ RequestConvertersTests.setRandomHumanReadable(getIndexRequest::humanReadable, expectedParams);
// Force "include_type_name" parameter since responses need to be compatible when coming from 7.0 nodes
- expectedParams.put(INCLUDE_TYPE_NAME_PARAMETER, "true");
+ expectedParams.put(INCLUDE_TYPE_NAME_PARAMETER, Boolean.TRUE.toString());
if (ESTestCase.randomBoolean()) {
// the request object will not have include_defaults present unless it is set to
@@ -737,7 +801,7 @@ public void testExistsAlias() {
}
getAliasesRequest.aliases(aliases);
Map expectedParams = new HashMap<>();
- RequestConvertersTests.setRandomLocal(getAliasesRequest, expectedParams);
+ RequestConvertersTests.setRandomLocal(getAliasesRequest::local, expectedParams);
RequestConvertersTests.setRandomIndicesOptions(getAliasesRequest::indicesOptions, getAliasesRequest::indicesOptions,
expectedParams);
@@ -872,7 +936,7 @@ public void testGetAlias() {
GetAliasesRequest getAliasesRequest = new GetAliasesRequest();
Map expectedParams = new HashMap<>();
- RequestConvertersTests.setRandomLocal(getAliasesRequest, expectedParams);
+ RequestConvertersTests.setRandomLocal(getAliasesRequest::local, expectedParams);
RequestConvertersTests.setRandomIndicesOptions(getAliasesRequest::indicesOptions, getAliasesRequest::indicesOptions,
expectedParams);
diff --git a/client/rest-high-level/src/test/java/org/elasticsearch/client/RequestConvertersTests.java b/client/rest-high-level/src/test/java/org/elasticsearch/client/RequestConvertersTests.java
index 4b15774568a6a..780b58750c89c 100644
--- a/client/rest-high-level/src/test/java/org/elasticsearch/client/RequestConvertersTests.java
+++ b/client/rest-high-level/src/test/java/org/elasticsearch/client/RequestConvertersTests.java
@@ -32,7 +32,6 @@
import org.elasticsearch.action.admin.cluster.storedscripts.GetStoredScriptRequest;
import org.elasticsearch.action.admin.cluster.storedscripts.PutStoredScriptRequest;
import org.elasticsearch.action.admin.indices.analyze.AnalyzeRequest;
-import org.elasticsearch.action.admin.indices.get.GetIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkShardRequest;
import org.elasticsearch.action.delete.DeleteRequest;
@@ -50,7 +49,6 @@
import org.elasticsearch.action.support.IndicesOptions;
import org.elasticsearch.action.support.WriteRequest;
import org.elasticsearch.action.support.master.AcknowledgedRequest;
-import org.elasticsearch.action.support.master.MasterNodeReadRequest;
import org.elasticsearch.action.support.master.MasterNodeRequest;
import org.elasticsearch.action.support.replication.ReplicationRequest;
import org.elasticsearch.action.update.UpdateRequest;
@@ -1763,20 +1761,20 @@ static IndicesOptions setRandomIndicesOptions(IndicesOptions indicesOptions, Map
return indicesOptions;
}
- static void setRandomIncludeDefaults(GetIndexRequest request, Map expectedParams) {
+ static void setRandomIncludeDefaults(Consumer setter, Map expectedParams) {
if (randomBoolean()) {
boolean includeDefaults = randomBoolean();
- request.includeDefaults(includeDefaults);
+ setter.accept(includeDefaults);
if (includeDefaults) {
expectedParams.put("include_defaults", String.valueOf(includeDefaults));
}
}
}
- static void setRandomHumanReadable(GetIndexRequest request, Map expectedParams) {
+ static void setRandomHumanReadable(Consumer setter, Map expectedParams) {
if (randomBoolean()) {
boolean humanReadable = randomBoolean();
- request.humanReadable(humanReadable);
+ setter.accept(humanReadable);
if (humanReadable) {
expectedParams.put("human", String.valueOf(humanReadable));
}
@@ -1793,10 +1791,6 @@ static void setRandomLocal(Consumer setter, Map expecte
}
}
- static void setRandomLocal(MasterNodeReadRequest request, Map expectedParams) {
- setRandomLocal(request::local, expectedParams);
- }
-
static void setRandomTimeout(TimedRequest request, TimeValue defaultTimeout, Map expectedParams) {
setRandomTimeout(s ->
request.setTimeout(TimeValue.parseTimeValue(s, request.getClass().getName() + ".timeout")),
diff --git a/client/rest-high-level/src/test/java/org/elasticsearch/client/SnapshotRequestConvertersTests.java b/client/rest-high-level/src/test/java/org/elasticsearch/client/SnapshotRequestConvertersTests.java
index ca86a9120422b..66720b70ee3a6 100644
--- a/client/rest-high-level/src/test/java/org/elasticsearch/client/SnapshotRequestConvertersTests.java
+++ b/client/rest-high-level/src/test/java/org/elasticsearch/client/SnapshotRequestConvertersTests.java
@@ -58,7 +58,7 @@ public void testGetRepositories() {
GetRepositoriesRequest getRepositoriesRequest = new GetRepositoriesRequest();
RequestConvertersTests.setRandomMasterTimeout(getRepositoriesRequest, expectedParams);
- RequestConvertersTests.setRandomLocal(getRepositoriesRequest, expectedParams);
+ RequestConvertersTests.setRandomLocal(getRepositoriesRequest::local, expectedParams);
if (randomBoolean()) {
String[] entries = new String[]{"a", "b", "c"};
diff --git a/client/rest-high-level/src/test/java/org/elasticsearch/client/documentation/IndicesClientDocumentationIT.java b/client/rest-high-level/src/test/java/org/elasticsearch/client/documentation/IndicesClientDocumentationIT.java
index c20389c24b10a..9c6d0d4effe08 100644
--- a/client/rest-high-level/src/test/java/org/elasticsearch/client/documentation/IndicesClientDocumentationIT.java
+++ b/client/rest-high-level/src/test/java/org/elasticsearch/client/documentation/IndicesClientDocumentationIT.java
@@ -38,10 +38,6 @@
import org.elasticsearch.action.admin.indices.flush.SyncedFlushRequest;
import org.elasticsearch.action.admin.indices.forcemerge.ForceMergeRequest;
import org.elasticsearch.action.admin.indices.forcemerge.ForceMergeResponse;
-import org.elasticsearch.action.admin.indices.get.GetIndexRequest;
-import org.elasticsearch.action.admin.indices.get.GetIndexResponse;
-import org.elasticsearch.client.indices.GetFieldMappingsRequest;
-import org.elasticsearch.client.indices.GetFieldMappingsResponse;
import org.elasticsearch.action.admin.indices.open.OpenIndexRequest;
import org.elasticsearch.action.admin.indices.open.OpenIndexResponse;
import org.elasticsearch.action.admin.indices.refresh.RefreshRequest;
@@ -73,6 +69,10 @@
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.FreezeIndexRequest;
+import org.elasticsearch.client.indices.GetFieldMappingsRequest;
+import org.elasticsearch.client.indices.GetFieldMappingsResponse;
+import org.elasticsearch.client.indices.GetIndexRequest;
+import org.elasticsearch.client.indices.GetIndexResponse;
import org.elasticsearch.client.indices.GetIndexTemplatesRequest;
import org.elasticsearch.client.indices.GetMappingsRequest;
import org.elasticsearch.client.indices.GetMappingsResponse;
@@ -81,9 +81,7 @@
import org.elasticsearch.client.indices.UnfreezeIndexRequest;
import org.elasticsearch.cluster.metadata.AliasMetaData;
import org.elasticsearch.cluster.metadata.IndexTemplateMetaData;
-import org.elasticsearch.cluster.metadata.AliasMetaData;
import org.elasticsearch.cluster.metadata.MappingMetaData;
-import org.elasticsearch.common.collect.ImmutableOpenMap;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.unit.ByteSizeUnit;
import org.elasticsearch.common.unit.ByteSizeValue;
@@ -140,8 +138,7 @@ public void testIndicesExist() throws IOException {
{
// tag::indices-exists-request
- GetIndexRequest request = new GetIndexRequest();
- request.indices("twitter"); // <1>
+ GetIndexRequest request = new GetIndexRequest("twitter"); // <1>
// end::indices-exists-request
IndicesOptions indicesOptions = IndicesOptions.strictExpand();
@@ -168,8 +165,7 @@ public void testIndicesExistAsync() throws Exception {
}
{
- GetIndexRequest request = new GetIndexRequest();
- request.indices("twitter");
+ GetIndexRequest request = new GetIndexRequest("twitter");
// tag::indices-exists-execute-listener
ActionListener listener = new ActionListener() {
@@ -1227,7 +1223,7 @@ public void testGetIndex() throws Exception {
}
// tag::get-index-request
- GetIndexRequest request = new GetIndexRequest().indices("index"); // <1>
+ GetIndexRequest request = new GetIndexRequest("index"); // <1>
// end::get-index-request
// tag::get-index-request-indicesOptions
@@ -1243,13 +1239,13 @@ public void testGetIndex() throws Exception {
// end::get-index-execute
// tag::get-index-response
- ImmutableOpenMap indexMappings = getIndexResponse.getMappings().get("index"); // <1>
- Map indexTypeMappings = indexMappings.get("_doc").getSourceAsMap(); // <2>
+ MappingMetaData indexMappings = getIndexResponse.getMappings().get("index"); // <1>
+ Map indexTypeMappings = indexMappings.getSourceAsMap(); // <2>
List indexAliases = getIndexResponse.getAliases().get("index"); // <3>
String numberOfShardsString = getIndexResponse.getSetting("index", "index.number_of_shards"); // <4>
Settings indexSettings = getIndexResponse.getSettings().get("index"); // <5>
Integer numberOfShards = indexSettings.getAsInt("index.number_of_shards", null); // <6>
- TimeValue time = getIndexResponse.defaultSettings().get("index")
+ TimeValue time = getIndexResponse.getDefaultSettings().get("index")
.getAsTime("index.refresh_interval", null); // <7>
// end::get-index-response
diff --git a/client/rest-high-level/src/test/java/org/elasticsearch/client/indices/GetIndexRequestTests.java b/client/rest-high-level/src/test/java/org/elasticsearch/client/indices/GetIndexRequestTests.java
new file mode 100644
index 0000000000000..46b64aab6d406
--- /dev/null
+++ b/client/rest-high-level/src/test/java/org/elasticsearch/client/indices/GetIndexRequestTests.java
@@ -0,0 +1,68 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.elasticsearch.client.indices;
+
+import org.elasticsearch.action.support.IndicesOptions;
+import org.elasticsearch.client.indices.GetIndexRequest.Feature;
+import org.elasticsearch.test.ESTestCase;
+
+public class GetIndexRequestTests extends ESTestCase {
+
+ public void testIndices() {
+ String[] indices = generateRandomStringArray(5, 5, false, true);
+ GetIndexRequest request = new GetIndexRequest(indices);
+ assertArrayEquals(indices, request.indices());
+ }
+
+ public void testFeatures() {
+ int numFeature = randomIntBetween(0, 3);
+ Feature[] features = new Feature[numFeature];
+ for (int i = 0; i < numFeature; i++) {
+ features[i] = randomFrom(GetIndexRequest.DEFAULT_FEATURES);
+ }
+ GetIndexRequest request = new GetIndexRequest().addFeatures(features);
+ assertArrayEquals(features, request.features());
+ }
+
+ public void testLocal() {
+ boolean local = randomBoolean();
+ GetIndexRequest request = new GetIndexRequest().local(local);
+ assertEquals(local, request.local());
+ }
+
+ public void testHumanReadable() {
+ boolean humanReadable = randomBoolean();
+ GetIndexRequest request = new GetIndexRequest().humanReadable(humanReadable);
+ assertEquals(humanReadable, request.humanReadable());
+ }
+
+ public void testIncludeDefaults() {
+ boolean includeDefaults = randomBoolean();
+ GetIndexRequest request = new GetIndexRequest().includeDefaults(includeDefaults);
+ assertEquals(includeDefaults, request.includeDefaults());
+ }
+
+ public void testIndicesOptions() {
+ IndicesOptions indicesOptions = IndicesOptions.fromOptions(randomBoolean(), randomBoolean(), randomBoolean(), randomBoolean());
+ GetIndexRequest request = new GetIndexRequest().indicesOptions(indicesOptions);
+ assertEquals(indicesOptions, request.indicesOptions());
+ }
+
+}
diff --git a/client/rest-high-level/src/test/java/org/elasticsearch/client/indices/GetIndexResponseTests.java b/client/rest-high-level/src/test/java/org/elasticsearch/client/indices/GetIndexResponseTests.java
new file mode 100644
index 0000000000000..19c25fd11f6ed
--- /dev/null
+++ b/client/rest-high-level/src/test/java/org/elasticsearch/client/indices/GetIndexResponseTests.java
@@ -0,0 +1,195 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.elasticsearch.client.indices;
+
+import org.apache.lucene.util.CollectionUtil;
+import org.elasticsearch.client.GetAliasesResponseTests;
+import org.elasticsearch.cluster.metadata.AliasMetaData;
+import org.elasticsearch.cluster.metadata.MappingMetaData;
+import org.elasticsearch.common.collect.ImmutableOpenMap;
+import org.elasticsearch.common.settings.IndexScopedSettings;
+import org.elasticsearch.common.settings.Settings;
+import org.elasticsearch.common.xcontent.ToXContent;
+import org.elasticsearch.common.xcontent.ToXContent.Params;
+import org.elasticsearch.common.xcontent.XContentBuilder;
+import org.elasticsearch.index.RandomCreateIndexGenerator;
+import org.elasticsearch.index.mapper.MapperService;
+import org.elasticsearch.rest.BaseRestHandler;
+import org.elasticsearch.test.ESTestCase;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+import static org.elasticsearch.test.AbstractXContentTestCase.xContentTester;
+
+public class GetIndexResponseTests extends ESTestCase {
+
+ // Because the client-side class does not have a toXContent method, we test xContent serialization by creating
+ // a random client object, converting it to a server object then serializing it to xContent, and finally
+ // parsing it back as a client object. We check equality between the original client object, and the parsed one.
+ public void testFromXContent() throws IOException {
+ xContentTester(
+ this::createParser,
+ GetIndexResponseTests::createTestInstance,
+ GetIndexResponseTests::toXContent,
+ GetIndexResponse::fromXContent)
+ .supportsUnknownFields(false)
+ .assertToXContentEquivalence(false)
+ .assertEqualsConsumer(GetIndexResponseTests::assertEqualInstances)
+ .test();
+ }
+
+ private static void assertEqualInstances(GetIndexResponse expected, GetIndexResponse actual) {
+ assertArrayEquals(expected.getIndices(), actual.getIndices());
+ assertEquals(expected.getMappings(), actual.getMappings());
+ assertEquals(expected.getSettings(), actual.getSettings());
+ assertEquals(expected.getDefaultSettings(), actual.getDefaultSettings());
+ assertEquals(expected.getAliases(), actual.getAliases());
+ }
+
+ private static GetIndexResponse createTestInstance() {
+ String[] indices = generateRandomStringArray(5, 5, false, false);
+ Map mappings = new HashMap<>();
+ Map> aliases = new HashMap<>();
+ Map settings = new HashMap<>();
+ Map defaultSettings = new HashMap<>();
+ IndexScopedSettings indexScopedSettings = IndexScopedSettings.DEFAULT_SCOPED_SETTINGS;
+ boolean includeDefaults = randomBoolean();
+ for (String index: indices) {
+ mappings.put(index, createMappingsForIndex());
+
+ List aliasMetaDataList = new ArrayList<>();
+ int aliasesNum = randomIntBetween(0, 3);
+ for (int i=0; i mappings = new HashMap<>();
+ mappings.put("field-" + i, randomFieldMapping());
+ if (randomBoolean()) {
+ mappings.put("field2-" + i, randomFieldMapping());
+ }
+
+ try {
+ String typeName = MapperService.SINGLE_MAPPING_NAME;
+ mmd = new MappingMetaData(typeName, mappings);
+ } catch (IOException e) {
+ fail("shouldn't have failed " + e);
+ }
+ }
+ }
+ return mmd;
+ }
+
+ // Not meant to be exhaustive
+ private static Map randomFieldMapping() {
+ Map mappings = new HashMap<>();
+ if (randomBoolean()) {
+ mappings.put("type", randomBoolean() ? "text" : "keyword");
+ mappings.put("index", "analyzed");
+ mappings.put("analyzer", "english");
+ } else if (randomBoolean()) {
+ mappings.put("type", randomFrom("integer", "float", "long", "double"));
+ mappings.put("index", Objects.toString(randomBoolean()));
+ } else if (randomBoolean()) {
+ mappings.put("type", "object");
+ mappings.put("dynamic", "strict");
+ Map properties = new HashMap<>();
+ Map props1 = new HashMap<>();
+ props1.put("type", randomFrom("text", "keyword"));
+ props1.put("analyzer", "keyword");
+ properties.put("subtext", props1);
+ Map props2 = new HashMap<>();
+ props2.put("type", "object");
+ Map prop2properties = new HashMap<>();
+ Map props3 = new HashMap<>();
+ props3.put("type", "integer");
+ props3.put("index", "false");
+ prop2properties.put("subsubfield", props3);
+ props2.put("properties", prop2properties);
+ mappings.put("properties", properties);
+ } else {
+ mappings.put("type", "keyword");
+ }
+ return mappings;
+ }
+
+ private static void toXContent(GetIndexResponse response, XContentBuilder builder) throws IOException {
+ // first we need to repackage from GetIndexResponse to org.elasticsearch.action.admin.indices.get.GetIndexResponse
+ ImmutableOpenMap.Builder> allMappings = ImmutableOpenMap.builder();
+ ImmutableOpenMap.Builder> aliases = ImmutableOpenMap.builder();
+ ImmutableOpenMap.Builder settings = ImmutableOpenMap.builder();
+ ImmutableOpenMap.Builder defaultSettings = ImmutableOpenMap.builder();
+
+ Map indexMappings = response.getMappings();
+ for (String index : response.getIndices()) {
+ MappingMetaData mmd = indexMappings.get(index);
+ ImmutableOpenMap.Builder typedMappings = ImmutableOpenMap.builder();
+ if (mmd != null) {
+ typedMappings.put(MapperService.SINGLE_MAPPING_NAME, mmd);
+ }
+ allMappings.put(index, typedMappings.build());
+ aliases.put(index, response.getAliases().get(index));
+ settings.put(index, response.getSettings().get(index));
+ defaultSettings.put(index, response.getDefaultSettings().get(index));
+ }
+
+ org.elasticsearch.action.admin.indices.get.GetIndexResponse serverResponse
+ = new org.elasticsearch.action.admin.indices.get.GetIndexResponse(
+ response.getIndices(),
+ allMappings.build(),
+ aliases.build(),
+ settings.build(),
+ defaultSettings.build());
+
+ // then we can call its toXContent method, forcing no output of types
+ Params params = new ToXContent.MapParams(Collections.singletonMap(BaseRestHandler.INCLUDE_TYPE_NAME_PARAMETER, "false"));
+ serverResponse.toXContent(builder, params);
+ }
+}
diff --git a/server/src/main/java/org/elasticsearch/action/admin/indices/get/GetIndexResponse.java b/server/src/main/java/org/elasticsearch/action/admin/indices/get/GetIndexResponse.java
index 43e02f69bfff0..ded9f81dd7c85 100644
--- a/server/src/main/java/org/elasticsearch/action/admin/indices/get/GetIndexResponse.java
+++ b/server/src/main/java/org/elasticsearch/action/admin/indices/get/GetIndexResponse.java
@@ -60,7 +60,7 @@ public class GetIndexResponse extends ActionResponse implements ToXContentObject
private ImmutableOpenMap defaultSettings = ImmutableOpenMap.of();
private String[] indices;
- GetIndexResponse(String[] indices,
+ public GetIndexResponse(String[] indices,
ImmutableOpenMap> mappings,
ImmutableOpenMap> aliases,
ImmutableOpenMap settings,
diff --git a/server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestGetIndicesAction.java b/server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestGetIndicesAction.java
index a2a539e8a8d6c..73435dec46c32 100644
--- a/server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestGetIndicesAction.java
+++ b/server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestGetIndicesAction.java
@@ -46,9 +46,8 @@
*/
public class RestGetIndicesAction extends BaseRestHandler {
- private static final DeprecationLogger deprecationLogger = new DeprecationLogger(
- LogManager.getLogger(RestGetIndicesAction.class));
- static final String TYPES_DEPRECATION_MESSAGE = "[types removal] The response format of get indices requests " +
+ private static final DeprecationLogger deprecationLogger = new DeprecationLogger(LogManager.getLogger(RestGetIndicesAction.class));
+ public static final String TYPES_DEPRECATION_MESSAGE = "[types removal] The response format of get indices requests " +
"will change in 7.0. Please start using the include_type_name parameter set to false to move to the new, " +
"typeless response format that will become the default.";
diff --git a/server/src/test/java/org/elasticsearch/action/admin/indices/get/GetIndexResponseTests.java b/server/src/test/java/org/elasticsearch/action/admin/indices/get/GetIndexResponseTests.java
index a4360fe941bad..7f61d2961949a 100644
--- a/server/src/test/java/org/elasticsearch/action/admin/indices/get/GetIndexResponseTests.java
+++ b/server/src/test/java/org/elasticsearch/action/admin/indices/get/GetIndexResponseTests.java
@@ -31,8 +31,10 @@
import org.elasticsearch.common.io.stream.StreamInput;
import org.elasticsearch.common.settings.IndexScopedSettings;
import org.elasticsearch.common.settings.Settings;
+import org.elasticsearch.common.xcontent.ToXContent;
import org.elasticsearch.common.xcontent.XContentParser;
import org.elasticsearch.index.RandomCreateIndexGenerator;
+import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.test.AbstractStreamableXContentTestCase;
import org.junit.Assert;
@@ -192,4 +194,13 @@ public void testCanOutput622Response() throws IOException {
Assert.assertEquals(TEST_6_3_0_RESPONSE_BYTES, base64OfResponse);
}
+
+ /**
+ * 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 GetIndexResponse.
+ */
+ @Override
+ protected ToXContent.Params getToXContentParams() {
+ return new ToXContent.MapParams(Collections.singletonMap(BaseRestHandler.INCLUDE_TYPE_NAME_PARAMETER, "true"));
+ }
}