github-mirrors/elasticsearch
1
0
Fork 0
mirror of https://github.com/elastic/elasticsearch.git synced 2025-04-24 23:27:25 -04:00
Code Issues Projects Releases Packages Wiki Activity

Bump compatible rest api version to 9/8 (#113151)

Browse source 
This commit bumps the REST API version from 8 to 9. This effectively removes all support for REST API 
compatibility with version 7 (though earlier commits already chipped away at some v7 support).

This also enables REST API compatibility support for version 8, providing support for v8 compatibility headers, 
i.e. "application/vnd.elasticsearch+json;compatible-with=8" and no-op support (no errors) to accept v9 
compatibility headers i.e. "application/vnd.elasticsearch+json;compatible-with=9".

see additional context in the GH PR #113151
This commit is contained in:
Jake Landis 2024-09-26 14:52:05 -05:00 • committed by GitHub
parent 1b5d75f537
commit 888188695a
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
52 changed files with 298 additions and 1520 deletions
Download patch file Download diff file Expand all files Collapse all files

4
build-tools-internal/src/test/java/org/elasticsearch/gradle/internal/test/rest/transform/header/InjectHeaderTests.java
View file

@ -26,9 +26,9 @@ public class InjectHeaderTests extends InjectFeatureTests {
private static final Map<String, String> headers = Map.of(
"Content-Type",
"application/vnd.elasticsearch+json;compatible-with=7",
"application/vnd.elasticsearch+json;compatible-with=8",
"Accept",
"application/vnd.elasticsearch+json;compatible-with=7"
"application/vnd.elasticsearch+json;compatible-with=8"
);
/**

11
libs/core/src/main/java/org/elasticsearch/core/RestApiVersion.java
View file

@ -22,14 +22,13 @@ public enum RestApiVersion {
V_8(8),
@UpdateForV9 // remove all references to V_7 then delete this annotation
V_7(7);
public final byte major;
@UpdateForV9
// We need to bump current and previous to V_9 and V_8, respectively
private static final RestApiVersion CURRENT = V_8;
private static final RestApiVersion PREVIOUS = V_7;
private static final RestApiVersion CURRENT = V_9;
private static final RestApiVersion PREVIOUS = V_8;
RestApiVersion(int major) {
this.major = (byte) major;
@ -67,8 +66,6 @@ public enum RestApiVersion {
};
}
@UpdateForV9
// Right now we return api version 8 for major version 9 until we bump the api version above
public static RestApiVersion forMajor(int major) {
switch (major) {
case 7 -> {
@ -78,7 +75,7 @@ public enum RestApiVersion {
return V_8;
}
case 9 -> {
return V_8;
return V_9;
}
default -> throw new IllegalArgumentException("Unknown REST API version " + major);
}

2
libs/x-content/src/main/java/org/elasticsearch/xcontent/MediaTypeRegistry.java
View file

@ -27,7 +27,7 @@ import java.util.regex.Pattern;
* A MediaType can have only one query parameter representation.
* For example "json" (case insensitive) maps back to a JSON media type.
*
* Additionally, a http header may optionally have parameters. For example "application/vnd.elasticsearch+json; compatible-with=7".
* Additionally, a http header may optionally have parameters. For example "application/vnd.elasticsearch+json; compatible-with=8".
* This class also allows to define a regular expression for valid values of charset.
*/
public class MediaTypeRegistry<T extends MediaType> {

32
libs/x-content/src/test/java/org/elasticsearch/xcontent/ParsedMediaTypeTests.java
View file

@ -30,19 +30,19 @@ public class ParsedMediaTypeTests extends ESTestCase {
assertThat(ParsedMediaType.parseMediaType("application/cbor").toMediaType(mediaTypeRegistry), equalTo(XContentType.CBOR));
assertThat(
ParsedMediaType.parseMediaType("application/vnd.elasticsearch+json;compatible-with=7").toMediaType(mediaTypeRegistry),
ParsedMediaType.parseMediaType("application/vnd.elasticsearch+json;compatible-with=8").toMediaType(mediaTypeRegistry),
equalTo(XContentType.VND_JSON)
);
assertThat(
ParsedMediaType.parseMediaType("application/vnd.elasticsearch+yaml;compatible-with=7").toMediaType(mediaTypeRegistry),
ParsedMediaType.parseMediaType("application/vnd.elasticsearch+yaml;compatible-with=8").toMediaType(mediaTypeRegistry),
equalTo(XContentType.VND_YAML)
);
assertThat(
ParsedMediaType.parseMediaType("application/vnd.elasticsearch+smile;compatible-with=7").toMediaType(mediaTypeRegistry),
ParsedMediaType.parseMediaType("application/vnd.elasticsearch+smile;compatible-with=8").toMediaType(mediaTypeRegistry),
equalTo(XContentType.VND_SMILE)
);
assertThat(
ParsedMediaType.parseMediaType("application/vnd.elasticsearch+cbor;compatible-with=7").toMediaType(mediaTypeRegistry),
ParsedMediaType.parseMediaType("application/vnd.elasticsearch+cbor;compatible-with=8").toMediaType(mediaTypeRegistry),
equalTo(XContentType.VND_CBOR)
);
}
@ -179,19 +179,19 @@ public class ParsedMediaTypeTests extends ESTestCase {
);
assertThat(
ParsedMediaType.parseMediaType(XContentType.VND_JSON, Map.of("compatible-with", "7")).toMediaType(mediaTypeRegistry),
ParsedMediaType.parseMediaType(XContentType.VND_JSON, Map.of("compatible-with", "8")).toMediaType(mediaTypeRegistry),
equalTo(XContentType.VND_JSON)
);
assertThat(
ParsedMediaType.parseMediaType(XContentType.VND_YAML, Map.of("compatible-with", "7")).toMediaType(mediaTypeRegistry),
ParsedMediaType.parseMediaType(XContentType.VND_YAML, Map.of("compatible-with", "8")).toMediaType(mediaTypeRegistry),
equalTo(XContentType.VND_YAML)
);
assertThat(
ParsedMediaType.parseMediaType(XContentType.VND_SMILE, Map.of("compatible-with", "7")).toMediaType(mediaTypeRegistry),
ParsedMediaType.parseMediaType(XContentType.VND_SMILE, Map.of("compatible-with", "8")).toMediaType(mediaTypeRegistry),
equalTo(XContentType.VND_SMILE)
);
assertThat(
ParsedMediaType.parseMediaType(XContentType.VND_CBOR, Map.of("compatible-with", "7")).toMediaType(mediaTypeRegistry),
ParsedMediaType.parseMediaType(XContentType.VND_CBOR, Map.of("compatible-with", "8")).toMediaType(mediaTypeRegistry),
equalTo(XContentType.VND_CBOR)
);
}
@ -215,20 +215,20 @@ public class ParsedMediaTypeTests extends ESTestCase {
);
assertThat(
ParsedMediaType.parseMediaType(XContentType.VND_JSON, Map.of("compatible-with", "7")).responseContentTypeHeader(),
equalTo("application/vnd.elasticsearch+json;compatible-with=7")
ParsedMediaType.parseMediaType(XContentType.VND_JSON, Map.of("compatible-with", "8")).responseContentTypeHeader(),
equalTo("application/vnd.elasticsearch+json;compatible-with=8")
);
assertThat(
ParsedMediaType.parseMediaType(XContentType.VND_YAML, Map.of("compatible-with", "7")).responseContentTypeHeader(),
equalTo("application/vnd.elasticsearch+yaml;compatible-with=7")
ParsedMediaType.parseMediaType(XContentType.VND_YAML, Map.of("compatible-with", "8")).responseContentTypeHeader(),
equalTo("application/vnd.elasticsearch+yaml;compatible-with=8")
);
assertThat(
ParsedMediaType.parseMediaType(XContentType.VND_SMILE, Map.of("compatible-with", "7")).responseContentTypeHeader(),
equalTo("application/vnd.elasticsearch+smile;compatible-with=7")
ParsedMediaType.parseMediaType(XContentType.VND_SMILE, Map.of("compatible-with", "8")).responseContentTypeHeader(),
equalTo("application/vnd.elasticsearch+smile;compatible-with=8")
);
assertThat(
ParsedMediaType.parseMediaType(XContentType.VND_CBOR, Map.of("compatible-with", "7")).responseContentTypeHeader(),
equalTo("application/vnd.elasticsearch+cbor;compatible-with=7")
ParsedMediaType.parseMediaType(XContentType.VND_CBOR, Map.of("compatible-with", "8")).responseContentTypeHeader(),
equalTo("application/vnd.elasticsearch+cbor;compatible-with=8")
);
assertThat(

67
modules/lang-mustache/src/test/java/org/elasticsearch/script/mustache/RestMultiSearchTemplateActionTests.java
View file

@ -1,67 +0,0 @@
/*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the "Elastic License
* 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
* Public License v 1"; you may not use this file except in compliance with, at
* your election, the "Elastic License 2.0", the "GNU Affero General Public
* License v3.0 only", or the "Server Side Public License, v 1".
*/
package org.elasticsearch.script.mustache;
import org.elasticsearch.common.bytes.BytesArray;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.test.rest.FakeRestRequest;
import org.elasticsearch.test.rest.RestActionTestCase;
import org.elasticsearch.xcontent.XContentType;
import org.junit.Before;
import org.mockito.Mockito;
import java.nio.charset.StandardCharsets;
import java.util.Collections;
import java.util.List;
import java.util.Map;
public final class RestMultiSearchTemplateActionTests extends RestActionTestCase {
final List<String> contentTypeHeader = Collections.singletonList(compatibleMediaType(XContentType.VND_JSON, RestApiVersion.V_7));
@Before
public void setUpAction() {
controller().registerHandler(new RestMultiSearchTemplateAction(Settings.EMPTY));
// todo how to workaround this? we get AssertionError without this
verifyingClient.setExecuteVerifier((actionType, request) -> Mockito.mock(MultiSearchTemplateResponse.class));
verifyingClient.setExecuteLocallyVerifier((actionType, request) -> Mockito.mock(MultiSearchTemplateResponse.class));
}
public void testTypeInPath() {
String content = """
{ "index": "some_index" }
{"source": {"query" : {"match_all" :{}}}}
""";
BytesArray bytesContent = new BytesArray(content.getBytes(StandardCharsets.UTF_8));
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(
Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader)
).withMethod(RestRequest.Method.GET).withPath("/some_index/some_type/_msearch/template").withContent(bytesContent, null).build();
dispatchRequest(request);
assertCriticalWarnings(RestMultiSearchTemplateAction.TYPES_DEPRECATION_MESSAGE);
}
public void testTypeInBody() {
String content = """
{ "index": "some_index", "type": "some_type" }\s
{"source": {"query" : {"match_all" :{}}}}\s
""";
BytesArray bytesContent = new BytesArray(content.getBytes(StandardCharsets.UTF_8));
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(
Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader)
).withPath("/some_index/_msearch/template").withContent(bytesContent, null).build();
dispatchRequest(request);
assertCriticalWarnings(RestMultiSearchTemplateAction.TYPES_DEPRECATION_MESSAGE);
}
}

56
modules/lang-mustache/src/test/java/org/elasticsearch/script/mustache/RestSearchTemplateActionTests.java
View file

@ -1,56 +0,0 @@
/*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the "Elastic License
* 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
* Public License v 1"; you may not use this file except in compliance with, at
* your election, the "Elastic License 2.0", the "GNU Affero General Public
* License v3.0 only", or the "Server Side Public License, v 1".
*/
package org.elasticsearch.script.mustache;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.search.RestSearchAction;
import org.elasticsearch.test.rest.FakeRestRequest;
import org.elasticsearch.test.rest.RestActionTestCase;
import org.junit.Before;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.mockito.Mockito.mock;
public final class RestSearchTemplateActionTests extends RestActionTestCase {
final List<String> contentTypeHeader = Collections.singletonList(randomCompatibleMediaType(RestApiVersion.V_7));
@Before
public void setUpAction() {
controller().registerHandler(new RestSearchTemplateAction(nf -> false));
verifyingClient.setExecuteVerifier((actionType, request) -> mock(SearchTemplateResponse.class));
verifyingClient.setExecuteLocallyVerifier((actionType, request) -> mock(SearchTemplateResponse.class));
}
public void testTypeInPath() {
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(
Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader)
).withMethod(RestRequest.Method.GET).withPath("/some_index/some_type/_search/template").build();
dispatchRequest(request);
assertCriticalWarnings(RestSearchAction.TYPES_DEPRECATION_MESSAGE);
}
public void testTypeParameter() {
Map<String, String> params = new HashMap<>();
params.put("type", "some_type");
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(
Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader)
).withMethod(RestRequest.Method.GET).withPath("/some_index/_search/template").withParams(params).build();
dispatchRequest(request);
assertCriticalWarnings(RestSearchAction.TYPES_DEPRECATION_MESSAGE);
}
}

30
modules/percolator/src/test/java/org/elasticsearch/percolator/PercolateQueryBuilderTests.java
View file

@ -21,7 +21,6 @@ import org.elasticsearch.common.bytes.BytesReference;
import org.elasticsearch.common.compress.CompressedXContent;
import org.elasticsearch.common.io.stream.BytesStreamOutput;
import org.elasticsearch.common.lucene.uid.Versions;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.index.get.GetResult;
import org.elasticsearch.index.mapper.MapperService;
import org.elasticsearch.index.query.QueryBuilder;
@ -32,9 +31,7 @@ import org.elasticsearch.plugins.Plugin;
import org.elasticsearch.test.AbstractQueryTestCase;
import org.elasticsearch.xcontent.XContentBuilder;
import org.elasticsearch.xcontent.XContentFactory;
import org.elasticsearch.xcontent.XContentParser;
import org.elasticsearch.xcontent.XContentType;
import org.elasticsearch.xcontent.json.JsonXContent;
import org.hamcrest.Matchers;
import java.io.IOException;
@ -379,31 +376,4 @@ public class PercolateQueryBuilderTests extends AbstractQueryTestCase<PercolateQ
ElasticsearchException e = expectThrows(ElasticsearchException.class, () -> queryBuilder.toQuery(searchExecutionContext));
assertEquals("[percolate] queries cannot be executed when 'search.allow_expensive_queries' is set to false.", e.getMessage());
}
public void testFromJsonWithDocumentType() throws IOException {
SearchExecutionContext searchExecutionContext = createSearchExecutionContext();
String queryAsString = Strings.format("""
{"percolate" : { "document": {}, "document_type":"%s", "field":"%s"}}
""", docType, queryField);
XContentParser parser = createParserWithCompatibilityFor(JsonXContent.jsonXContent, queryAsString, RestApiVersion.V_7);
QueryBuilder queryBuilder = parseQuery(parser);
queryBuilder.toQuery(searchExecutionContext);
assertCriticalWarnings(PercolateQueryBuilder.DOCUMENT_TYPE_DEPRECATION_MESSAGE);
}
public void testFromJsonWithType() throws IOException {
indexedDocumentIndex = randomAlphaOfLength(4);
indexedDocumentId = randomAlphaOfLength(4);
indexedDocumentVersion = Versions.MATCH_ANY;
documentSource = Collections.singletonList(randomSource(new HashSet<>()));
SearchExecutionContext searchExecutionContext = createSearchExecutionContext();
String queryAsString = Strings.format("""
{"percolate" : { "index": "%s", "type": "_doc", "id": "%s", "field":"%s"}}
""", indexedDocumentIndex, indexedDocumentId, queryField);
XContentParser parser = createParserWithCompatibilityFor(JsonXContent.jsonXContent, queryAsString, RestApiVersion.V_7);
QueryBuilder queryBuilder = parseQuery(parser);
rewriteAndFetch(queryBuilder, searchExecutionContext).toQuery(searchExecutionContext);
assertCriticalWarnings(PercolateQueryBuilder.TYPE_DEPRECATION_MESSAGE);
}
}

53
modules/reindex/src/test/java/org/elasticsearch/reindex/RestDeleteByQueryActionTests.java
View file

@ -1,53 +0,0 @@
/*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the "Elastic License
* 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
* Public License v 1"; you may not use this file except in compliance with, at
* your election, the "Elastic License 2.0", the "GNU Affero General Public
* License v3.0 only", or the "Server Side Public License, v 1".
*/
package org.elasticsearch.reindex;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.index.reindex.BulkByScrollResponse;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.search.RestSearchAction;
import org.elasticsearch.test.rest.FakeRestRequest;
import org.elasticsearch.test.rest.RestActionTestCase;
import org.elasticsearch.xcontent.XContentType;
import org.junit.Before;
import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import static org.mockito.Mockito.mock;
public final class RestDeleteByQueryActionTests extends RestActionTestCase {
final List<String> contentTypeHeader = Collections.singletonList(compatibleMediaType(XContentType.VND_JSON, RestApiVersion.V_7));
@Before
public void setUpAction() {
controller().registerHandler(new RestDeleteByQueryAction(nf -> false));
verifyingClient.setExecuteVerifier((actionType, request) -> mock(BulkByScrollResponse.class));
verifyingClient.setExecuteLocallyVerifier((actionType, request) -> mock(BulkByScrollResponse.class));
}
public void testTypeInPath() throws IOException {
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(
Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader)
).withMethod(RestRequest.Method.POST).withPath("/some_index/some_type/_delete_by_query").build();
// checks the type in the URL is propagated correctly to the request object
// only works after the request is dispatched, so its params are filled from url.
dispatchRequest(request);
// RestDeleteByQueryAction itself doesn't check for a deprecated type usage
// checking here for a deprecation from its internal search request
assertCriticalWarnings(RestSearchAction.TYPES_DEPRECATION_MESSAGE);
}
}

52
modules/reindex/src/test/java/org/elasticsearch/reindex/RestUpdateByQueryActionTests.java
View file

@ -1,52 +0,0 @@
/*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the "Elastic License
* 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
* Public License v 1"; you may not use this file except in compliance with, at
* your election, the "Elastic License 2.0", the "GNU Affero General Public
* License v3.0 only", or the "Server Side Public License, v 1".
*/
package org.elasticsearch.reindex;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.index.reindex.BulkByScrollResponse;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.search.RestSearchAction;
import org.elasticsearch.test.rest.FakeRestRequest;
import org.elasticsearch.test.rest.RestActionTestCase;
import org.elasticsearch.xcontent.XContentType;
import org.junit.Before;
import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import static org.mockito.Mockito.mock;
public final class RestUpdateByQueryActionTests extends RestActionTestCase {
final List<String> contentTypeHeader = Collections.singletonList(compatibleMediaType(XContentType.VND_JSON, RestApiVersion.V_7));
@Before
public void setUpAction() {
controller().registerHandler(new RestUpdateByQueryAction(nf -> false));
verifyingClient.setExecuteVerifier((actionType, request) -> mock(BulkByScrollResponse.class));
verifyingClient.setExecuteLocallyVerifier((actionType, request) -> mock(BulkByScrollResponse.class));
}
public void testTypeInPath() throws IOException {
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(
Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader)
).withMethod(RestRequest.Method.POST).withPath("/some_index/some_type/_update_by_query").build();
// checks the type in the URL is propagated correctly to the request object
// only works after the request is dispatched, so its params are filled from url.
dispatchRequest(request);
// RestUpdateByQueryAction itself doesn't check for a deprecated type usage
// checking here for a deprecation from its internal search request
assertCriticalWarnings(RestSearchAction.TYPES_DEPRECATION_MESSAGE);
}
}

1
rest-api-spec/build.gradle
View file

@ -57,4 +57,5 @@ tasks.named("precommit").configure {
tasks.named("yamlRestCompatTestTransform").configure({task ->
task.skipTest("indices.sort/10_basic/Index Sort", "warning does not exist for compatibility")
task.skipTest("search/330_fetch_fields/Test search rewrite", "warning does not exist for compatibility")
task.skipTestsByFilePattern("indices.create/synthetic_source*.yml", "@UpdateForV9 -> tests do not pass after bumping API version to 9 [ES-9597]")
})

9
server/src/main/java/org/elasticsearch/action/admin/cluster/node/capabilities/TransportNodesCapabilitiesAction.java
View file

@ -19,6 +19,7 @@ import org.elasticsearch.cluster.service.ClusterService;
import org.elasticsearch.common.io.stream.StreamInput;
import org.elasticsearch.common.io.stream.StreamOutput;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.core.UpdateForV9;
import org.elasticsearch.features.FeatureService;
import org.elasticsearch.injection.guice.Inject;
import org.elasticsearch.rest.RestController;
@ -151,6 +152,10 @@ public class TransportNodesCapabilitiesAction extends TransportNodesAction<
this.restApiVersion = restApiVersion;
}
@UpdateForV9 // 8.x blows up in a mixed cluster when trying to read RestApiVersion.forMajor(9)
// ./gradlew ":qa:mixed-cluster:v8.16.0#mixedClusterTest"
// -Dtests.class="org.elasticsearch.backwards.MixedClusterClientYamlTestSuiteIT"
// -Dtests.method="test {p0=capabilities/10_basic/Capabilities API}"
@Override
public void writeTo(StreamOutput out) throws IOException {
super.writeTo(out);
@ -159,7 +164,9 @@ public class TransportNodesCapabilitiesAction extends TransportNodesAction<
out.writeString(path);
out.writeCollection(parameters, StreamOutput::writeString);
out.writeCollection(capabilities, StreamOutput::writeString);
out.writeVInt(restApiVersion.major);
// Fixme: lies! all lies!
out.writeVInt(8);
// out.writeVInt(restApiVersion.major);
}
}
}

67
server/src/main/java/org/elasticsearch/rest/RestHandler.java
View file

@ -195,8 +195,9 @@ public interface RestHandler {
}
/**
* Marks that the route being built has been deprecated (for some reason -- the deprecationMessage), and notes the major
* version in which that deprecation occurred.
* Marks that the route being built has been deprecated (for some reason -- the deprecationMessage) for removal. Notes the last
* major version in which the path is fully supported without compatibility headers. If this path is being replaced by another
* then use {@link #replaces(Method, String, RestApiVersion)} instead.
* <p>
* For example:
* <pre> {@code
@ -205,41 +206,21 @@ public interface RestHandler {
* .build()}</pre>
*
* @param deprecationMessage the user-visible explanation of this deprecation
* @param deprecatedInVersion the major version in which the deprecation occurred
* @param lastFullySupportedVersion the last {@link RestApiVersion} (i.e. 7) for which this route is fully supported.
* The next major version (i.e. 8) will require compatibility header(s). (;compatible-with=7)
* The next major version (i.e. 9) will have no support whatsoever for this route.
* @return a reference to this object.
*/
public RouteBuilder deprecated(String deprecationMessage, RestApiVersion deprecatedInVersion) {
public RouteBuilder deprecated(String deprecationMessage, RestApiVersion lastFullySupportedVersion) {
assert this.replacedRoute == null;
this.restApiVersion = Objects.requireNonNull(deprecatedInVersion);
this.restApiVersion = Objects.requireNonNull(lastFullySupportedVersion);
this.deprecationMessage = Objects.requireNonNull(deprecationMessage);
return this;
}
/**
* Marks that the route being built has been deprecated (for some reason -- the deprecationMessage), and notes the major
* version in which that deprecation occurred.
* <p>
* For example:
* <pre> {@code
* Route.builder(GET, "_upgrade")
* .deprecated("The _upgrade API is no longer useful and will be removed.", RestApiVersion.V_7)
* .build()}</pre>
*
* @param deprecationMessage the user-visible explanation of this deprecation
* @param deprecationLevel the level at which to log the deprecation
* @param deprecatedInVersion the major version in which the deprecation occurred
* @return a reference to this object.
*/
public RouteBuilder deprecated(String deprecationMessage, Level deprecationLevel, RestApiVersion deprecatedInVersion) {
assert this.replacedRoute == null;
this.restApiVersion = Objects.requireNonNull(deprecatedInVersion);
this.deprecationMessage = Objects.requireNonNull(deprecationMessage);
this.deprecationLevel = deprecationLevel;
return this;
}
/**
* Marks that the route being built replaces another route, and notes the major version in which that replacement occurred.
* Marks that the route being built replaces another route, and notes the last major version in which the path is fully
* supported without compatibility headers.
* <p>
* For example:
* <pre> {@code
@ -248,12 +229,34 @@ public interface RestHandler {
*
* @param method the method being replaced
* @param path the path being replaced
* @param replacedInVersion the major version in which the replacement occurred
* @param lastFullySupportedVersion the last {@link RestApiVersion} (i.e. 7) for which this route is fully supported.
* The next major version (i.e. 8) will require compatibility header(s). (;compatible-with=7)
* The next major version (i.e. 9) will have no support whatsoever for this route.
* @return a reference to this object.
*/
public RouteBuilder replaces(Method method, String path, RestApiVersion replacedInVersion) {
public RouteBuilder replaces(Method method, String path, RestApiVersion lastFullySupportedVersion) {
assert this.deprecationMessage == null;
this.replacedRoute = new Route(method, path, replacedInVersion, null, null, null);
this.replacedRoute = new Route(method, path, lastFullySupportedVersion, null, null, null);
return this;
}
/**
* Marks that the route being built has been deprecated (for some reason -- the deprecationMessage), but will not be removed.
* <p>
* For example:
* <pre> {@code
* Route.builder(GET, "_upgrade")
* .deprecated("The _upgrade API is no longer useful but will not be removed.")
* .build()}</pre>
*
* @param deprecationMessage the user-visible explanation of this deprecation
* @return a reference to this object.
*/
public RouteBuilder deprecateAndKeep(String deprecationMessage) {
assert this.replacedRoute == null;
this.restApiVersion = RestApiVersion.current();
this.deprecationMessage = Objects.requireNonNull(deprecationMessage);
this.deprecationLevel = Level.WARN;
return this;
}

5
server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestPutIndexTemplateAction.java
View file

@ -9,7 +9,6 @@
package org.elasticsearch.rest.action.admin.indices;
import org.apache.logging.log4j.Level;
import org.elasticsearch.action.admin.indices.template.put.PutIndexTemplateRequest;
import org.elasticsearch.client.internal.node.NodeClient;
import org.elasticsearch.common.Strings;
@ -41,8 +40,8 @@ public class RestPutIndexTemplateAction extends BaseRestHandler {
@Override
public List<Route> routes() {
return List.of(
Route.builder(POST, "/_template/{name}").deprecated(DEPRECATION_WARNING, Level.WARN, DEPRECATION_VERSION).build(),
Route.builder(PUT, "/_template/{name}").deprecated(DEPRECATION_WARNING, Level.WARN, DEPRECATION_VERSION).build()
Route.builder(POST, "/_template/{name}").deprecateAndKeep(DEPRECATION_WARNING).build(),
Route.builder(PUT, "/_template/{name}").deprecateAndKeep(DEPRECATION_WARNING).build()
);
}

13
server/src/main/java/org/elasticsearch/rest/action/search/RestKnnSearchAction.java
View file

@ -11,7 +11,7 @@ package org.elasticsearch.rest.action.search;
import org.elasticsearch.action.search.SearchRequestBuilder;
import org.elasticsearch.client.internal.node.NodeClient;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.core.UpdateForV9;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestCancellableNodeClient;
@ -34,11 +34,18 @@ public class RestKnnSearchAction extends BaseRestHandler {
public RestKnnSearchAction() {}
@UpdateForV9 // these routes were ".deprecated" in RestApiVersion.V_8 which will require use of REST API compatibility headers to access
// this API in v9. It is unclear if this was intentional for v9, and the code has been updated to ".deprecateAndKeep" which will
// continue to emit deprecations warnings but will not require any special headers to access the API in v9.
// Please review and update the code and tests as needed. The original code remains commented out below for reference.
@Override
public List<Route> routes() {
return List.of(
Route.builder(GET, "{index}/_knn_search").deprecated(DEPRECATION_MESSAGE, RestApiVersion.V_8).build(),
Route.builder(POST, "{index}/_knn_search").deprecated(DEPRECATION_MESSAGE, RestApiVersion.V_8).build()
// Route.builder(GET, "{index}/_knn_search").deprecated(DEPRECATION_MESSAGE, RestApiVersion.V_8).build(),
// Route.builder(POST, "{index}/_knn_search").deprecated(DEPRECATION_MESSAGE, RestApiVersion.V_8).build()
Route.builder(GET, "{index}/_knn_search").deprecateAndKeep(DEPRECATION_MESSAGE).build(),
Route.builder(POST, "{index}/_knn_search").deprecateAndKeep(DEPRECATION_MESSAGE).build()
);
}

2
server/src/main/java/org/elasticsearch/search/aggregations/pipeline/MovAvgPipelineAggregationBuilder.java
View file

@ -16,6 +16,7 @@ import org.elasticsearch.common.io.stream.StreamInput;
import org.elasticsearch.common.io.stream.StreamOutput;
import org.elasticsearch.common.logging.DeprecationLogger;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.core.UpdateForV9;
import org.elasticsearch.index.query.CommonTermsQueryBuilder;
import org.elasticsearch.xcontent.ContextParser;
import org.elasticsearch.xcontent.ParseField;
@ -32,6 +33,7 @@ import java.util.Map;
*
* @deprecated Only for 7.x rest compat
*/
@UpdateForV9 // remove this since it's only for 7.x compat and 7.x compat will be removed in 9.0
@Deprecated
public class MovAvgPipelineAggregationBuilder extends AbstractPipelineAggregationBuilder<MovAvgPipelineAggregationBuilder> {
private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(CommonTermsQueryBuilder.class);

71
server/src/test/java/org/elasticsearch/action/admin/indices/rollover/RolloverRequestTests.java
View file

@ -21,7 +21,6 @@ import org.elasticsearch.common.io.stream.StreamInput;
import org.elasticsearch.common.unit.ByteSizeUnit;
import org.elasticsearch.common.unit.ByteSizeValue;
import org.elasticsearch.common.xcontent.XContentHelper;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.core.TimeValue;
import org.elasticsearch.index.mapper.MapperService;
import org.elasticsearch.indices.IndicesModule;
@ -30,9 +29,7 @@ import org.elasticsearch.test.XContentTestUtils;
import org.elasticsearch.xcontent.XContentBuilder;
import org.elasticsearch.xcontent.XContentFactory;
import org.elasticsearch.xcontent.XContentParseException;
import org.elasticsearch.xcontent.XContentParser;
import org.elasticsearch.xcontent.XContentType;
import org.elasticsearch.xcontent.json.JsonXContent;
import org.junit.Before;
import java.io.IOException;
@ -276,72 +273,4 @@ public class RolloverRequestTests extends ESTestCase {
);
}
}
public void testParsingWithType() throws Exception {
final XContentBuilder builder = XContentFactory.jsonBuilder()
.startObject()
.startObject("conditions")
.field("max_age", "10d")
.field("max_docs", 100)
.endObject()
.startObject("mappings")
.startObject("type1")
.startObject("properties")
.startObject("field1")
.field("type", "string")
.field("index", "not_analyzed")
.endObject()
.endObject()
.endObject()
.endObject()
.startObject("settings")
.field("number_of_shards", 10)
.endObject()
.startObject("aliases")
.startObject("alias1")
.endObject()
.endObject()
.endObject();
try (
XContentParser parser = createParserWithCompatibilityFor(
JsonXContent.jsonXContent,
BytesReference.bytes(builder).utf8ToString(),
RestApiVersion.V_7
)
) {
final RolloverRequest request = new RolloverRequest(randomAlphaOfLength(10), randomAlphaOfLength(10));
request.fromXContent(true, parser);
Map<String, Condition<?>> conditions = request.getConditions().getConditions();
assertThat(conditions.size(), equalTo(2));
assertThat(request.getCreateIndexRequest().mappings(), equalTo("""
{"_doc":{"properties":{"field1":{"index":"not_analyzed","type":"string"}}}}"""));
}
}
public void testTypedRequestWithoutIncludeTypeName() throws IOException {
final XContentBuilder builder = XContentFactory.jsonBuilder()
.startObject()
.startObject("mappings")
.startObject("_doc")
.startObject("properties")
.startObject("field1")
.field("type", "string")
.field("index", "not_analyzed")
.endObject()
.endObject()
.endObject()
.endObject()
.endObject();
try (
XContentParser parser = createParserWithCompatibilityFor(
JsonXContent.jsonXContent,
BytesReference.bytes(builder).utf8ToString(),
RestApiVersion.V_7
)
) {
final RolloverRequest request = new RolloverRequest(randomAlphaOfLength(10), randomAlphaOfLength(10));
expectThrows(IllegalArgumentException.class, () -> request.fromXContent(false, parser));
}
}
}

46
server/src/test/java/org/elasticsearch/action/search/MultiSearchRequestTests.java
View file

@ -471,52 +471,6 @@ public class MultiSearchRequestTests extends ESTestCase {
);
}
public void testEmptyFirstLine1() throws Exception {
MultiSearchRequest request = parseMultiSearchRequestFromString("""
{ "query": {"match_all": {}}}
{}
{ "query": {"match_all": {}}}
{ "query": {"match_all": {}}}
{}
{ "query": {"match_all": {}}}
""", RestApiVersion.V_7);
assertThat(request.requests().size(), equalTo(4));
for (SearchRequest searchRequest : request.requests()) {
assertThat(searchRequest.indices().length, equalTo(0));
assertThat(searchRequest.source().query(), instanceOf(MatchAllQueryBuilder.class));
}
assertCriticalWarnings(
"support for empty first line before any action metadata in msearch API is deprecated and will be removed "
+ "in the next major version"
);
}
public void testEmptyFirstLine2() throws Exception {
MultiSearchRequest request = parseMultiSearchRequestFromString("""
{}
{ "query": {"match_all": {}}}
{ "query": {"match_all": {}}}
{}
{ "query": {"match_all": {}}}
{ "query": {"match_all": {}}}
""", RestApiVersion.V_7);
assertThat(request.requests().size(), equalTo(4));
for (SearchRequest searchRequest : request.requests()) {
assertThat(searchRequest.indices().length, equalTo(0));
assertThat(searchRequest.source().query(), instanceOf(MatchAllQueryBuilder.class));
}
assertCriticalWarnings(
"support for empty first line before any action metadata in msearch API is deprecated and will be removed "
+ "in the next major version"
);
}
public void testTaskDescription() {
MultiSearchRequest request = new MultiSearchRequest();
request.add(new SearchRequest().preference("abc"));

6
server/src/test/java/org/elasticsearch/http/AbstractHttpServerTransportTests.java
View file

@ -420,15 +420,15 @@ public class AbstractHttpServerTransportTests extends ESTestCase {
}
public void testHandlingCompatibleVersionParsingErrors() {
// a compatible version exception (v7 on accept and v8 on content-type) should be handled gracefully
// a compatible version exception (v8 on accept and v9 on content-type) should be handled gracefully
final ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
try (
AbstractHttpServerTransport transport = failureAssertingtHttpServerTransport(clusterSettings, Set.of("Accept", "Content-Type"))
) {
Map<String, List<String>> headers = new HashMap<>();
headers.put("Accept", Collections.singletonList("aaa/bbb;compatible-with=7"));
headers.put("Content-Type", Collections.singletonList("aaa/bbb;compatible-with=8"));
headers.put("Accept", Collections.singletonList("aaa/bbb;compatible-with=8"));
headers.put("Content-Type", Collections.singletonList("aaa/bbb;compatible-with=9"));
FakeRestRequest.FakeHttpRequest fakeHttpRequest = new FakeRestRequest.FakeHttpRequest(
RestRequest.Method.GET,

32
server/src/test/java/org/elasticsearch/rest/RestCompatibleVersionHelperTests.java
View file

@ -10,7 +10,6 @@ package org.elasticsearch.rest;
import org.elasticsearch.ElasticsearchStatusException;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.core.UpdateForV9;
import org.elasticsearch.test.ESTestCase;
import org.elasticsearch.xcontent.ParsedMediaType;
import org.hamcrest.CustomTypeSafeMatcher;
@ -165,8 +164,6 @@ public class RestCompatibleVersionHelperTests extends ESTestCase {
assertThat(requestWith(acceptHeader(null), contentTypeHeader("application/json"), bodyPresent()), not(isCompatible()));
}
@UpdateForV9
@AwaitsFix(bugUrl = "this can be re-enabled once our rest api version is bumped to V_9")
public void testObsoleteVersion() {
ElasticsearchStatusException e = expectThrows(
ElasticsearchStatusException.class,
@ -213,14 +210,11 @@ public class RestCompatibleVersionHelperTests extends ESTestCase {
assertThat(
e.getMessage(),
equalTo(
"Content-Type version must be either version "
+ CURRENT_VERSION
+ " or "
+ PREVIOUS_VERSION
+ ", but found "
+ OBSOLETE_VERSION
+ ". "
+ "Content-Type="
"A compatible version is required on both Content-Type and Accept headers if either one has requested a "
+ "compatible version and the compatible versions must match. "
+ "Accept="
+ acceptHeader(PREVIOUS_VERSION)
+ ", Content-Type="
+ contentTypeHeader(OBSOLETE_VERSION)
)
);
@ -242,8 +236,8 @@ public class RestCompatibleVersionHelperTests extends ESTestCase {
assertThat(
requestWith(
acceptHeader("application/vnd.elasticsearch+json;compatible-with=7"),
contentTypeHeader("application/vnd.elasticsearch+cbor;compatible-with=7"),
acceptHeader("application/vnd.elasticsearch+json;compatible-with=8"),
contentTypeHeader("application/vnd.elasticsearch+cbor;compatible-with=8"),
bodyPresent()
),
isCompatible()
@ -253,8 +247,8 @@ public class RestCompatibleVersionHelperTests extends ESTestCase {
expectThrows(
ElasticsearchStatusException.class,
() -> requestWith(
acceptHeader("application/vnd.elasticsearch+json;compatible-with=7"),
contentTypeHeader("application/vnd.elasticsearch+cbor;compatible-with=8"),
acceptHeader("application/vnd.elasticsearch+json;compatible-with=8"),
contentTypeHeader("application/vnd.elasticsearch+cbor;compatible-with=9"),
bodyPresent()
)
);
@ -273,20 +267,20 @@ public class RestCompatibleVersionHelperTests extends ESTestCase {
// versioned
assertThat(
requestWith(
acceptHeader("text/vnd.elasticsearch+tab-separated-values;compatible-with=7"),
contentTypeHeader(7),
acceptHeader("text/vnd.elasticsearch+tab-separated-values;compatible-with=8"),
contentTypeHeader(8),
bodyNotPresent()
),
isCompatible()
);
assertThat(
requestWith(acceptHeader("text/vnd.elasticsearch+plain;compatible-with=7"), contentTypeHeader(7), bodyNotPresent()),
requestWith(acceptHeader("text/vnd.elasticsearch+plain;compatible-with=8"), contentTypeHeader(8), bodyNotPresent()),
isCompatible()
);
assertThat(
requestWith(acceptHeader("text/vnd.elasticsearch+csv;compatible-with=7"), contentTypeHeader(7), bodyNotPresent()),
requestWith(acceptHeader("text/vnd.elasticsearch+csv;compatible-with=8"), contentTypeHeader(8), bodyNotPresent()),
isCompatible()
);
}

69
server/src/test/java/org/elasticsearch/rest/action/admin/indices/RestCreateIndexActionTests.java
View file

@ -9,29 +9,15 @@
package org.elasticsearch.rest.action.admin.indices;
import org.elasticsearch.action.admin.indices.create.CreateIndexRequest;
import org.elasticsearch.client.internal.node.NodeClient;
import org.elasticsearch.common.bytes.BytesArray;
import org.elasticsearch.common.bytes.BytesReference;
import org.elasticsearch.common.xcontent.XContentHelper;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.test.ESTestCase;
import org.elasticsearch.test.rest.FakeRestRequest;
import org.elasticsearch.xcontent.XContentBuilder;
import org.elasticsearch.xcontent.XContentFactory;
import org.elasticsearch.xcontent.XContentType;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.elasticsearch.rest.BaseRestHandler.INCLUDE_TYPE_NAME_PARAMETER;
import static org.hamcrest.Matchers.equalTo;
import static org.mockito.Mockito.mock;
public class RestCreateIndexActionTests extends ESTestCase {
public void testPrepareTypelessRequest() throws IOException {
@ -99,59 +85,4 @@ public class RestCreateIndexActionTests extends ESTestCase {
Map<String, Object> source = RestCreateIndexAction.prepareMappings(contentAsMap);
assertEquals(contentAsMap, source);
}
public void testIncludeTypeName() throws IOException {
RestCreateIndexAction action = new RestCreateIndexAction();
List<String> compatibleMediaType = Collections.singletonList(randomCompatibleMediaType(RestApiVersion.V_7));
Map<String, String> params = new HashMap<>();
params.put(INCLUDE_TYPE_NAME_PARAMETER, randomFrom("true", "false"));
RestRequest deprecatedRequest = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(Map.of("Accept", compatibleMediaType))
.withMethod(RestRequest.Method.PUT)
.withPath("/some_index")
.withParams(params)
.build();
action.prepareRequest(deprecatedRequest, mock(NodeClient.class));
assertCriticalWarnings(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 void testTypeInMapping() throws IOException {
RestCreateIndexAction action = new RestCreateIndexAction();
List<String> contentTypeHeader = Collections.singletonList(compatibleMediaType(XContentType.VND_JSON, RestApiVersion.V_7));
String content = """
{
"mappings": {
"some_type": {
"properties": {
"field1": {
"type": "text"
}
}
}
}
}""";
Map<String, String> params = new HashMap<>();
params.put(RestCreateIndexAction.INCLUDE_TYPE_NAME_PARAMETER, "true");
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withMethod(RestRequest.Method.PUT)
.withHeaders(Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader))
.withPath("/some_index")
.withParams(params)
.withContent(new BytesArray(content), null)
.build();
CreateIndexRequest createIndexRequest = RestCreateIndexAction.prepareRequestV7(request);
// some_type is replaced with _doc
assertThat(createIndexRequest.mappings(), equalTo("""
{"_doc":{"properties":{"field1":{"type":"text"}}}}"""));
assertCriticalWarnings(RestCreateIndexAction.TYPES_DEPRECATION_MESSAGE);
}
}

64
server/src/test/java/org/elasticsearch/rest/action/admin/indices/RestGetIndicesActionTests.java
View file

@ -1,64 +0,0 @@
/*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the "Elastic License
* 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
* Public License v 1"; you may not use this file except in compliance with, at
* your election, the "Elastic License 2.0", the "GNU Affero General Public
* License v3.0 only", or the "Server Side Public License, v 1".
*/
package org.elasticsearch.rest.action.admin.indices;
import org.elasticsearch.client.internal.node.NodeClient;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.test.ESTestCase;
import org.elasticsearch.test.rest.FakeRestRequest;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.elasticsearch.rest.BaseRestHandler.INCLUDE_TYPE_NAME_PARAMETER;
import static org.mockito.Mockito.mock;
public final class RestGetIndicesActionTests extends ESTestCase {
final List<String> contentTypeHeader = Collections.singletonList(randomCompatibleMediaType(RestApiVersion.V_7));
/**
* 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()).withHeaders(
Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader)
).withMethod(RestRequest.Method.GET).withPath("/some_index").withParams(params).build();
RestGetIndicesAction handler = new RestGetIndicesAction();
handler.prepareRequest(request, mock(NodeClient.class));
assertCriticalWarnings(RestGetIndicesAction.TYPES_DEPRECATION_MESSAGE);
// the same request without the parameter should pass without warning
request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(
Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader)
).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()).withHeaders(
Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader)
).withMethod(RestRequest.Method.HEAD).withPath("/some_index").withParams(params).build();
RestGetIndicesAction handler = new RestGetIndicesAction();
handler.prepareRequest(request, mock(NodeClient.class));
}
}

76
server/src/test/java/org/elasticsearch/rest/action/admin/indices/RestPutIndexTemplateActionTests.java
View file

@ -1,76 +0,0 @@
/*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the "Elastic License
* 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
* Public License v 1"; you may not use this file except in compliance with, at
* your election, the "Elastic License 2.0", the "GNU Affero General Public
* License v3.0 only", or the "Server Side Public License, v 1".
*/
package org.elasticsearch.rest.action.admin.indices;
import org.elasticsearch.client.internal.node.NodeClient;
import org.elasticsearch.common.bytes.BytesReference;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.test.ESTestCase;
import org.elasticsearch.test.rest.FakeRestRequest;
import org.elasticsearch.xcontent.XContentBuilder;
import org.elasticsearch.xcontent.XContentFactory;
import org.elasticsearch.xcontent.XContentType;
import org.junit.Before;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.elasticsearch.rest.BaseRestHandler.INCLUDE_TYPE_NAME_PARAMETER;
import static org.mockito.Mockito.mock;
public final class RestPutIndexTemplateActionTests extends ESTestCase {
final List<String> contentTypeHeader = Collections.singletonList(compatibleMediaType(XContentType.VND_JSON, RestApiVersion.V_7));
private RestPutIndexTemplateAction action;
@Before
public void setUpAction() {
action = new RestPutIndexTemplateAction();
}
public void testIncludeTypeName() throws IOException {
XContentBuilder typedContent = XContentFactory.jsonBuilder()
.startObject()
.startObject("mappings")
.startObject("my_doc")
.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, String> params = new HashMap<>();
params.put(INCLUDE_TYPE_NAME_PARAMETER, "true");
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(
Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader)
)
.withMethod(RestRequest.Method.PUT)
.withParams(params)
.withPath("/_template/_some_template")
.withContent(BytesReference.bytes(typedContent), null)
.build();
action.prepareRequest(request, mock(NodeClient.class));
assertCriticalWarnings(RestPutIndexTemplateAction.TYPES_DEPRECATION_MESSAGE);
}
}

37
server/src/test/java/org/elasticsearch/rest/action/admin/indices/RestValidateQueryActionTests.java
View file

@ -19,10 +19,7 @@ import org.elasticsearch.client.internal.node.NodeClient;
import org.elasticsearch.common.bytes.BytesArray;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.util.concurrent.EsExecutors;
import org.elasticsearch.common.util.concurrent.ThreadContext;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.indices.breaker.NoneCircuitBreakerService;
import org.elasticsearch.rest.RestChannel;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.search.AbstractSearchTestCase;
@ -41,7 +38,6 @@ import org.junit.Before;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static java.util.Collections.emptyMap;
@ -159,37 +155,4 @@ public class RestValidateQueryActionTests extends AbstractSearchTestCase {
.withContent(new BytesArray(content), XContentType.JSON)
.build();
}
public void testTypeInPath() {
List<String> compatibleMediaType = Collections.singletonList(randomCompatibleMediaType(RestApiVersion.V_7));
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(Map.of("Accept", compatibleMediaType))
.withMethod(RestRequest.Method.GET)
.withPath("/some_index/some_type/_validate/query")
.build();
performRequest(request);
assertCriticalWarnings(RestValidateQueryAction.TYPES_DEPRECATION_MESSAGE);
}
public void testTypeParameter() {
List<String> compatibleMediaType = Collections.singletonList(randomCompatibleMediaType(RestApiVersion.V_7));
Map<String, String> params = new HashMap<>();
params.put("type", "some_type");
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(Map.of("Accept", compatibleMediaType))
.withMethod(RestRequest.Method.GET)
.withPath("_validate/query")
.withParams(params)
.build();
performRequest(request);
assertCriticalWarnings(RestValidateQueryAction.TYPES_DEPRECATION_MESSAGE);
}
private void performRequest(RestRequest request) {
RestChannel channel = new FakeRestChannel(request, false, 1);
ThreadContext threadContext = new ThreadContext(Settings.EMPTY);
controller.dispatchRequest(request, channel, threadContext);
}
}

49
server/src/test/java/org/elasticsearch/rest/action/document/RestDeleteActionTests.java
View file

@ -1,49 +0,0 @@
/*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the "Elastic License
* 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
* Public License v 1"; you may not use this file except in compliance with, at
* your election, the "Elastic License 2.0", the "GNU Affero General Public
* License v3.0 only", or the "Server Side Public License, v 1".
*/
package org.elasticsearch.rest.action.document;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.test.rest.FakeRestRequest;
import org.elasticsearch.test.rest.RestActionTestCase;
import org.junit.Before;
import org.mockito.Mockito;
import java.util.Collections;
import java.util.List;
import java.util.Map;
public final class RestDeleteActionTests extends RestActionTestCase {
final List<String> contentTypeHeader = Collections.singletonList(randomCompatibleMediaType(RestApiVersion.V_7));
@Before
public void setUpAction() {
controller().registerHandler(new RestDeleteAction());
verifyingClient.setExecuteVerifier((actionType, request) -> Mockito.mock(DeleteResponse.class));
verifyingClient.setExecuteLocallyVerifier((actionType, request) -> Mockito.mock(DeleteResponse.class));
}
public void testTypeInPath() {
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(Map.of("Accept", contentTypeHeader))
.withMethod(RestRequest.Method.DELETE)
.withPath("/some_index/some_type/some_id")
.build();
dispatchRequest(request);
assertCriticalWarnings(RestDeleteAction.TYPES_DEPRECATION_MESSAGE);
RestRequest validRequest = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(Map.of("Accept", contentTypeHeader))
.withMethod(RestRequest.Method.DELETE)
.withPath("/some_index/_doc/some_id")
.build();
dispatchRequest(validRequest);
}
}

51
server/src/test/java/org/elasticsearch/rest/action/document/RestGetActionTests.java
View file

@ -1,51 +0,0 @@
/*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the "Elastic License
* 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
* Public License v 1"; you may not use this file except in compliance with, at
* your election, the "Elastic License 2.0", the "GNU Affero General Public
* License v3.0 only", or the "Server Side Public License, v 1".
*/
package org.elasticsearch.rest.action.document;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.test.rest.FakeRestRequest;
import org.elasticsearch.test.rest.RestActionTestCase;
import org.junit.Before;
import org.mockito.Mockito;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import static org.hamcrest.Matchers.instanceOf;
public final class RestGetActionTests extends RestActionTestCase {
final List<String> contentTypeHeader = Collections.singletonList(randomCompatibleMediaType(RestApiVersion.V_7));
@Before
public void setUpAction() {
controller().registerHandler(new RestGetAction());
verifyingClient.setExecuteVerifier((actionType, request) -> {
assertThat(request, instanceOf(GetRequest.class));
return Mockito.mock(GetResponse.class);
});
}
public void testTypeInPath() {
testTypeInPath(RestRequest.Method.GET);
testTypeInPath(RestRequest.Method.HEAD);
}
private void testTypeInPath(RestRequest.Method method) {
FakeRestRequest.Builder deprecatedRequest = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(
Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader)
).withPath("/some_index/some_type/some_id");
dispatchRequest(deprecatedRequest.withMethod(method).build());
assertCriticalWarnings(RestGetAction.TYPES_DEPRECATION_MESSAGE);
}
}

40
server/src/test/java/org/elasticsearch/rest/action/document/RestGetSourceActionTests.java
View file

@ -14,7 +14,6 @@ import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.common.bytes.BytesArray;
import org.elasticsearch.common.bytes.BytesReference;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.index.get.GetResult;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.RestResponse;
@ -26,12 +25,6 @@ import org.junit.AfterClass;
import org.junit.Before;
import org.mockito.Mockito;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static java.util.Collections.emptyMap;
import static org.elasticsearch.index.seqno.SequenceNumbers.UNASSIGNED_SEQ_NO;
import static org.elasticsearch.rest.RestStatus.OK;
@ -43,7 +36,6 @@ public final class RestGetSourceActionTests extends RestActionTestCase {
private static RestRequest request = new FakeRestRequest();
private static FakeRestChannel channel = new FakeRestChannel(request, true, 0);
private static RestGetSourceResponseListener listener = new RestGetSourceResponseListener(channel, request);
private final List<String> compatibleMediaType = Collections.singletonList(randomCompatibleMediaType(RestApiVersion.V_7));
@Before
public void setUpAction() {
@ -89,36 +81,4 @@ public final class RestGetSourceActionTests extends RestActionTestCase {
assertThat(exception.getMessage(), equalTo("Source not found [index1]/[1]"));
}
/**
* test deprecation is logged if type is used in path
*/
public void testTypeInPath() {
for (RestRequest.Method method : Arrays.asList(RestRequest.Method.GET, RestRequest.Method.HEAD)) {
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(Map.of("Accept", compatibleMediaType))
.withMethod(method)
.withPath("/some_index/some_type/id/_source")
.build();
dispatchRequest(request);
assertCriticalWarnings(RestGetSourceAction.TYPES_DEPRECATION_MESSAGE);
}
}
/**
* test deprecation is logged if type is used as parameter
*/
public void testTypeParameter() {
Map<String, String> params = new HashMap<>();
params.put("type", "some_type");
for (RestRequest.Method method : Arrays.asList(RestRequest.Method.GET, RestRequest.Method.HEAD)) {
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(Map.of("Accept", compatibleMediaType))
.withMethod(method)
.withPath("/some_index/_source/id")
.withParams(params)
.build();
dispatchRequest(request);
assertCriticalWarnings(RestGetSourceAction.TYPES_DEPRECATION_MESSAGE);
}
}
}

37
server/src/test/java/org/elasticsearch/rest/action/document/RestIndexActionTests.java
View file

@ -19,7 +19,6 @@ import org.elasticsearch.cluster.ClusterState;
import org.elasticsearch.cluster.node.DiscoveryNodeUtils;
import org.elasticsearch.cluster.node.DiscoveryNodes;
import org.elasticsearch.common.bytes.BytesArray;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.index.shard.ShardId;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.document.RestIndexAction.AutoIdHandler;
@ -29,18 +28,12 @@ import org.elasticsearch.test.rest.RestActionTestCase;
import org.elasticsearch.xcontent.XContentType;
import org.junit.Before;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicReference;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.instanceOf;
public final class RestIndexActionTests extends RestActionTestCase {
final List<String> contentTypeHeader = Collections.singletonList(randomCompatibleMediaType(RestApiVersion.V_7));
private final AtomicReference<ClusterState> clusterStateSupplier = new AtomicReference<>();
@Before
@ -85,34 +78,4 @@ public final class RestIndexActionTests extends RestActionTestCase {
dispatchRequest(autoIdRequest);
assertThat(executeCalled.get(), equalTo(true));
}
public void testTypeInPath() {
// using CompatibleRestIndexAction
RestRequest deprecatedRequest = new FakeRestRequest.Builder(xContentRegistry()).withMethod(RestRequest.Method.PUT)
.withHeaders(Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader))
.withPath("/some_index/some_type/some_id")
.build();
dispatchRequest(deprecatedRequest);
assertCriticalWarnings(RestIndexAction.TYPES_DEPRECATION_MESSAGE);
}
public void testCreateWithTypeInPath() {
// using CompatibleCreateHandler
RestRequest deprecatedRequest = new FakeRestRequest.Builder(xContentRegistry()).withMethod(RestRequest.Method.PUT)
.withHeaders(Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader))
.withPath("/some_index/some_type/some_id/_create")
.build();
dispatchRequest(deprecatedRequest);
assertCriticalWarnings(RestIndexAction.TYPES_DEPRECATION_MESSAGE);
}
public void testAutoIdWithType() {
// using CompatibleAutoIdHandler
RestRequest deprecatedRequest = new FakeRestRequest.Builder(xContentRegistry()).withMethod(RestRequest.Method.POST)
.withHeaders(Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader))
.withPath("/some_index/some_type/")
.build();
dispatchRequest(deprecatedRequest);
assertCriticalWarnings(RestIndexAction.TYPES_DEPRECATION_MESSAGE);
}
}

77
server/src/test/java/org/elasticsearch/rest/action/document/RestMultiGetActionTests.java
View file

@ -1,77 +0,0 @@
/*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the "Elastic License
* 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
* Public License v 1"; you may not use this file except in compliance with, at
* your election, the "Elastic License 2.0", the "GNU Affero General Public
* License v3.0 only", or the "Server Side Public License, v 1".
*/
package org.elasticsearch.rest.action.document;
import org.elasticsearch.action.get.MultiGetRequest;
import org.elasticsearch.action.get.MultiGetResponse;
import org.elasticsearch.common.bytes.BytesReference;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.test.rest.FakeRestRequest;
import org.elasticsearch.test.rest.RestActionTestCase;
import org.elasticsearch.xcontent.XContentBuilder;
import org.elasticsearch.xcontent.XContentFactory;
import org.elasticsearch.xcontent.XContentType;
import org.junit.Before;
import org.mockito.Mockito;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import static org.hamcrest.Matchers.instanceOf;
public final class RestMultiGetActionTests extends RestActionTestCase {
XContentType VND_TYPE = randomVendorType();
List<String> contentTypeHeader = Collections.singletonList(compatibleMediaType(VND_TYPE, RestApiVersion.V_7));
@Before
public void setUpAction() {
controller().registerHandler(new RestMultiGetAction(Settings.EMPTY));
verifyingClient.setExecuteVerifier((actionType, request) -> {
assertThat(request, instanceOf(MultiGetRequest.class));
return Mockito.mock(MultiGetResponse.class);
});
}
public void testTypeInPath() {
RestRequest deprecatedRequest = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(
Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader)
).withMethod(RestRequest.Method.GET).withPath("some_index/some_type/_mget").build();
dispatchRequest(deprecatedRequest);
assertCriticalWarnings(RestMultiGetAction.TYPES_DEPRECATION_MESSAGE);
}
public void testTypeInBody() throws Exception {
XContentBuilder content = XContentFactory.contentBuilder(VND_TYPE)
.startObject()
.startArray("docs")
.startObject()
.field("_index", "some_index")
.field("_type", "_doc")
.field("_id", "2")
.endObject()
.startObject()
.field("_index", "test")
.field("_id", "2")
.endObject()
.endArray()
.endObject();
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withPath("_mget")
.withHeaders(Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader))
.withContent(BytesReference.bytes(content), null)
.build();
dispatchRequest(request);
assertCriticalWarnings(RestMultiGetAction.TYPES_DEPRECATION_MESSAGE);
}
}

83
server/src/test/java/org/elasticsearch/rest/action/document/RestMultiTermVectorsActionTests.java
View file

@ -1,83 +0,0 @@
/*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the "Elastic License
* 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
* Public License v 1"; you may not use this file except in compliance with, at
* your election, the "Elastic License 2.0", the "GNU Affero General Public
* License v3.0 only", or the "Server Side Public License, v 1".
*/
package org.elasticsearch.rest.action.document;
import org.elasticsearch.action.termvectors.MultiTermVectorsResponse;
import org.elasticsearch.common.bytes.BytesReference;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.test.rest.FakeRestRequest;
import org.elasticsearch.test.rest.RestActionTestCase;
import org.elasticsearch.xcontent.XContentBuilder;
import org.elasticsearch.xcontent.XContentFactory;
import org.elasticsearch.xcontent.XContentType;
import org.junit.Before;
import org.mockito.Mockito;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public final class RestMultiTermVectorsActionTests extends RestActionTestCase {
final List<String> contentTypeHeader = Collections.singletonList(compatibleMediaType(XContentType.VND_JSON, RestApiVersion.V_7));
@Before
public void setUpAction() {
controller().registerHandler(new RestMultiTermVectorsAction());
verifyingClient.setExecuteVerifier((actionType, request) -> Mockito.mock(MultiTermVectorsResponse.class));
verifyingClient.setExecuteLocallyVerifier((actionType, request) -> Mockito.mock(MultiTermVectorsResponse.class));
}
public void testTypeInPath() {
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(
Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader)
).withMethod(RestRequest.Method.POST).withPath("/some_index/some_type/_mtermvectors").build();
dispatchRequest(request);
assertCriticalWarnings(RestMultiTermVectorsAction.TYPES_DEPRECATION_MESSAGE);
}
public void testTypeParameter() {
Map<String, String> params = new HashMap<>();
params.put("type", "some_type");
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(
Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader)
).withPath("/some_index/_mtermvectors").withParams(params).build();
dispatchRequest(request);
assertCriticalWarnings(RestMultiTermVectorsAction.TYPES_DEPRECATION_MESSAGE);
}
public void testTypeInBody() throws IOException {
XContentBuilder content = XContentFactory.jsonBuilder()
.startObject()
.startArray("docs")
.startObject()
.field("_type", "some_type")
.field("_id", 1)
.endObject()
.endArray()
.endObject();
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(
Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader)
)
.withMethod(RestRequest.Method.POST)
.withPath("/some_index/_mtermvectors")
.withContent(BytesReference.bytes(content), null)
.build();
dispatchRequest(request);
assertCriticalWarnings(RestTermVectorsAction.TYPES_DEPRECATION_MESSAGE);
}
}

63
server/src/test/java/org/elasticsearch/rest/action/document/RestTermVectorsActionTests.java
View file

@ -1,63 +0,0 @@
/*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the "Elastic License
* 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
* Public License v 1"; you may not use this file except in compliance with, at
* your election, the "Elastic License 2.0", the "GNU Affero General Public
* License v3.0 only", or the "Server Side Public License, v 1".
*/
package org.elasticsearch.rest.action.document;
import org.elasticsearch.action.termvectors.TermVectorsResponse;
import org.elasticsearch.common.bytes.BytesReference;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.test.rest.FakeRestRequest;
import org.elasticsearch.test.rest.RestActionTestCase;
import org.elasticsearch.xcontent.XContentBuilder;
import org.elasticsearch.xcontent.XContentFactory;
import org.elasticsearch.xcontent.XContentType;
import org.junit.Before;
import org.mockito.Mockito;
import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.Map;
public final class RestTermVectorsActionTests extends RestActionTestCase {
final List<String> contentTypeHeader = Collections.singletonList(compatibleMediaType(XContentType.VND_JSON, RestApiVersion.V_7));
@Before
public void setUpAction() {
controller().registerHandler(new RestTermVectorsAction());
// todo how to workaround this? we get AssertionError without this
verifyingClient.setExecuteVerifier((actionType, request) -> Mockito.mock(TermVectorsResponse.class));
verifyingClient.setExecuteLocallyVerifier((actionType, request) -> Mockito.mock(TermVectorsResponse.class));
}
public void testTypeInPath() {
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(
Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader)
).withMethod(RestRequest.Method.POST).withPath("/some_index/some_type/some_id/_termvectors").build();
dispatchRequest(request);
assertCriticalWarnings(RestTermVectorsAction.TYPES_DEPRECATION_MESSAGE);
}
public void testTypeInBody() throws IOException {
XContentBuilder content = XContentFactory.jsonBuilder().startObject().field("_type", "some_type").field("_id", 1).endObject();
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(
Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader)
)
.withMethod(RestRequest.Method.GET)
.withPath("/some_index/_termvectors/some_id")
.withContent(BytesReference.bytes(content), null)
.build();
dispatchRequest(request);
assertCriticalWarnings(RestTermVectorsAction.TYPES_DEPRECATION_MESSAGE);
}
}

18
server/src/test/java/org/elasticsearch/rest/action/document/RestUpdateActionTests.java
View file

@ -13,7 +13,6 @@ import org.elasticsearch.action.ActionRequestValidationException;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.internal.node.NodeClient;
import org.elasticsearch.common.bytes.BytesArray;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.index.VersionType;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.test.rest.FakeRestRequest;
@ -22,17 +21,13 @@ import org.elasticsearch.xcontent.XContentType;
import org.junit.Before;
import org.mockito.Mockito;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.hamcrest.CoreMatchers.containsString;
import static org.mockito.Mockito.mock;
public final class RestUpdateActionTests extends RestActionTestCase {
final List<String> contentTypeHeader = Collections.singletonList(randomCompatibleMediaType(RestApiVersion.V_7));
private RestUpdateAction action;
@Before
@ -76,17 +71,4 @@ public final class RestUpdateActionTests extends RestActionTestCase {
)
);
}
public void testTypeInPath() {
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(
Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader)
).withMethod(RestRequest.Method.POST).withPath("/some_index/some_type/some_id/_update").build();
dispatchRequest(request);
assertCriticalWarnings(RestUpdateAction.TYPES_DEPRECATION_MESSAGE);
RestRequest validRequest = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(
Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader)
).withMethod(RestRequest.Method.DELETE).withPath("/some_index/_update/some_id").build();
dispatchRequest(validRequest);
}
}

65
server/src/test/java/org/elasticsearch/rest/action/search/RestCountActionTests.java
View file

@ -1,65 +0,0 @@
/*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the "Elastic License
* 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
* Public License v 1"; you may not use this file except in compliance with, at
* your election, the "Elastic License 2.0", the "GNU Affero General Public
* License v3.0 only", or the "Server Side Public License, v 1".
*/
package org.elasticsearch.rest.action.search;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.RestRequest.Method;
import org.elasticsearch.test.rest.FakeRestRequest;
import org.elasticsearch.test.rest.RestActionTestCase;
import org.junit.Before;
import org.mockito.Mockito;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.hamcrest.Matchers.instanceOf;
public final class RestCountActionTests extends RestActionTestCase {
final List<String> contentTypeHeader = Collections.singletonList(randomCompatibleMediaType(RestApiVersion.V_7));
@Before
public void setUpAction() {
controller().registerHandler(new RestCountAction());
verifyingClient.setExecuteVerifier((actionType, request) -> {
assertThat(request, instanceOf(SearchRequest.class));
return Mockito.mock(SearchResponse.class);
});
}
public void testTypeInPath() {
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(Map.of("Accept", contentTypeHeader))
.withMethod(Method.POST)
.withPath("/some_index/some_type/_count")
.build();
dispatchRequest(request);
assertCriticalWarnings(RestCountAction.TYPES_DEPRECATION_MESSAGE);
}
public void testTypeParameter() {
Map<String, String> params = new HashMap<>();
params.put("type", "some_type");
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(Map.of("Accept", contentTypeHeader))
.withMethod(Method.GET)
.withPath("/some_index/_count")
.withParams(params)
.build();
dispatchRequest(request);
assertCriticalWarnings(RestCountAction.TYPES_DEPRECATION_MESSAGE);
}
}

51
server/src/test/java/org/elasticsearch/rest/action/search/RestExplainActionTests.java
View file

@ -1,51 +0,0 @@
/*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the "Elastic License
* 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
* Public License v 1"; you may not use this file except in compliance with, at
* your election, the "Elastic License 2.0", the "GNU Affero General Public
* License v3.0 only", or the "Server Side Public License, v 1".
*/
package org.elasticsearch.rest.action.search;
import org.elasticsearch.action.explain.ExplainResponse;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.test.rest.FakeRestRequest;
import org.elasticsearch.test.rest.RestActionTestCase;
import org.elasticsearch.xcontent.XContentType;
import org.junit.Before;
import org.mockito.Mockito;
import java.util.Collections;
import java.util.List;
import java.util.Map;
public final class RestExplainActionTests extends RestActionTestCase {
final List<String> contentTypeHeader = Collections.singletonList(compatibleMediaType(XContentType.VND_JSON, RestApiVersion.V_7));
@Before
public void setUpAction() {
RestExplainAction action = new RestExplainAction();
controller().registerHandler(action);
verifyingClient.setExecuteVerifier((actionType, request) -> Mockito.mock(ExplainResponse.class));
verifyingClient.setExecuteLocallyVerifier((actionType, request) -> Mockito.mock(ExplainResponse.class));
}
public void testTypeInPath() {
RestRequest deprecatedRequest = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(Map.of("Accept", contentTypeHeader))
.withMethod(RestRequest.Method.GET)
.withPath("/some_index/some_type/some_id/_explain")
.build();
dispatchRequest(deprecatedRequest);
assertCriticalWarnings(RestExplainAction.TYPES_DEPRECATION_MESSAGE);
RestRequest validRequest = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(Map.of("Accept", contentTypeHeader))
.withMethod(RestRequest.Method.GET)
.withPath("/some_index/_explain/some_id")
.build();
dispatchRequest(validRequest);
}
}

65
server/src/test/java/org/elasticsearch/rest/action/search/RestMultiSearchActionTests.java
View file

@ -1,65 +0,0 @@
/*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the "Elastic License
* 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
* Public License v 1"; you may not use this file except in compliance with, at
* your election, the "Elastic License 2.0", the "GNU Affero General Public
* License v3.0 only", or the "Server Side Public License, v 1".
*/
package org.elasticsearch.rest.action.search;
import org.elasticsearch.action.search.MultiSearchResponse;
import org.elasticsearch.common.bytes.BytesArray;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.test.rest.FakeRestRequest;
import org.elasticsearch.test.rest.RestActionTestCase;
import org.elasticsearch.usage.UsageService;
import org.elasticsearch.xcontent.XContentType;
import org.junit.Before;
import java.nio.charset.StandardCharsets;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import static org.mockito.Mockito.mock;
public final class RestMultiSearchActionTests extends RestActionTestCase {
final List<String> contentTypeHeader = Collections.singletonList(compatibleMediaType(XContentType.VND_JSON, RestApiVersion.V_7));
@Before
public void setUpAction() {
RestMultiSearchAction action = new RestMultiSearchAction(Settings.EMPTY, new UsageService().getSearchUsageHolder(), nf -> false);
controller().registerHandler(action);
verifyingClient.setExecuteVerifier((actionType, request) -> mock(MultiSearchResponse.class));
verifyingClient.setExecuteLocallyVerifier((actionType, request) -> mock(MultiSearchResponse.class));
}
public void testTypeInPath() {
String content = "{ \"index\": \"some_index\" } \n {} \n";
BytesArray bytesContent = new BytesArray(content.getBytes(StandardCharsets.UTF_8));
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(
Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader)
).withMethod(RestRequest.Method.GET).withPath("/some_index/some_type/_msearch").withContent(bytesContent, null).build();
dispatchRequest(request);
assertCriticalWarnings(RestMultiSearchAction.TYPES_DEPRECATION_MESSAGE);
}
public void testTypeInBody() {
String content = "{ \"index\": \"some_index\", \"type\": \"some_type\" } \n {} \n";
BytesArray bytesContent = new BytesArray(content.getBytes(StandardCharsets.UTF_8));
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(
Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader)
).withMethod(RestRequest.Method.POST).withPath("/some_index/_msearch").withContent(bytesContent, null).build();
dispatchRequest(request);
assertCriticalWarnings(RestMultiSearchAction.TYPES_DEPRECATION_MESSAGE);
}
}

53
server/src/test/java/org/elasticsearch/rest/action/search/RestSearchActionTests.java
View file

@ -11,7 +11,6 @@ package org.elasticsearch.rest.action.search;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.search.SearchType;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.suggest.SuggestBuilder;
@ -23,7 +22,6 @@ import org.elasticsearch.test.rest.RestActionTestCase;
import org.elasticsearch.usage.UsageService;
import org.junit.Before;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@ -31,8 +29,6 @@ import java.util.Map;
import static org.mockito.Mockito.mock;
public final class RestSearchActionTests extends RestActionTestCase {
final List<String> contentTypeHeader = Collections.singletonList(randomCompatibleMediaType(RestApiVersion.V_7));
private RestSearchAction action;
@Before
@ -43,27 +39,6 @@ public final class RestSearchActionTests extends RestActionTestCase {
verifyingClient.setExecuteLocallyVerifier((actionType, request) -> mock(SearchResponse.class));
}
public void testTypeInPath() {
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(
Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader)
).withMethod(RestRequest.Method.GET).withPath("/some_index/some_type/_search").build();
dispatchRequest(request);
assertCriticalWarnings(RestSearchAction.TYPES_DEPRECATION_MESSAGE);
}
public void testTypeParameter() {
Map<String, String> params = new HashMap<>();
params.put("type", "some_type");
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(
Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader)
).withMethod(RestRequest.Method.GET).withPath("/some_index/_search").withParams(params).build();
dispatchRequest(request);
assertCriticalWarnings(RestSearchAction.TYPES_DEPRECATION_MESSAGE);
}
/**
* The "enable_fields_emulation" flag on search requests is a no-op but should not raise an error
*/
@ -71,9 +46,10 @@ public final class RestSearchActionTests extends RestActionTestCase {
Map<String, String> params = new HashMap<>();
params.put("enable_fields_emulation", "true");
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(
Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader)
).withMethod(RestRequest.Method.GET).withPath("/some_index/_search").withParams(params).build();
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withMethod(RestRequest.Method.GET)
.withPath("/some_index/_search")
.withParams(params)
.build();
action.handleRequest(request, new FakeRestChannel(request, false, 1), verifyingClient);
}
@ -83,9 +59,10 @@ public final class RestSearchActionTests extends RestActionTestCase {
Map<String, String> params = new HashMap<>();
params.put("rest_total_hits_as_int", "true");
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(
Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader)
).withMethod(RestRequest.Method.GET).withPath("/some_index/_search").withParams(params).build();
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withMethod(RestRequest.Method.GET)
.withPath("/some_index/_search")
.withParams(params)
.build();
SearchRequest searchRequest = new SearchRequest();
searchRequest.source(new SearchSourceBuilder().trackTotalHitsUpTo(100));
@ -100,9 +77,10 @@ public final class RestSearchActionTests extends RestActionTestCase {
Map<String, String> params = new HashMap<>();
params.put("search_type", randomFrom(SearchType.values()).name());
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(
Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader)
).withMethod(RestRequest.Method.GET).withPath("/some_index/_search").withParams(params).build();
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withMethod(RestRequest.Method.GET)
.withPath("/some_index/_search")
.withParams(params)
.build();
SearchRequest searchRequest = new SearchRequest();
KnnSearchBuilder knnSearch = new KnnSearchBuilder("vector", new float[] { 1, 1, 1 }, 10, 100, null);
@ -126,9 +104,10 @@ public final class RestSearchActionTests extends RestActionTestCase {
Map<String, String> params = new HashMap<>();
params.put("search_type", "some_search_type");
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(
Map.of("Content-Type", contentTypeHeader, "Accept", contentTypeHeader)
).withMethod(RestRequest.Method.GET).withPath("/some_index/_search").withParams(params).build();
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withMethod(RestRequest.Method.GET)
.withPath("/some_index/_search")
.withParams(params)
.build();
Exception ex = expectThrows(IllegalArgumentException.class, () -> action.prepareRequest(request, verifyingClient));
assertEquals("No search type for [some_search_type]", ex.getMessage());

62
server/src/test/java/org/elasticsearch/search/SearchModuleTests.java
View file

@ -18,12 +18,10 @@ import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.xcontent.LoggingDeprecationHandler;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.index.query.AbstractQueryBuilder;
import org.elasticsearch.index.query.CommonTermsQueryBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryRewriteContext;
import org.elasticsearch.index.query.SearchExecutionContext;
import org.elasticsearch.index.query.TermQueryBuilder;
import org.elasticsearch.index.query.TypeQueryV7Builder;
import org.elasticsearch.index.query.functionscore.GaussDecayFunctionBuilder;
import org.elasticsearch.plugins.SearchPlugin;
import org.elasticsearch.search.aggregations.AggregationBuilder;
@ -33,7 +31,6 @@ import org.elasticsearch.search.aggregations.BaseAggregationBuilder;
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
import org.elasticsearch.search.aggregations.bucket.terms.heuristic.ChiSquare;
import org.elasticsearch.search.aggregations.pipeline.AbstractPipelineAggregationBuilder;
import org.elasticsearch.search.aggregations.pipeline.MovAvgPipelineAggregationBuilder;
import org.elasticsearch.search.aggregations.pipeline.PipelineAggregator;
import org.elasticsearch.search.aggregations.support.AggregationContext;
import org.elasticsearch.search.aggregations.support.CoreValuesSourceType;
@ -60,7 +57,6 @@ import org.elasticsearch.search.suggest.term.TermSuggestionBuilder;
import org.elasticsearch.test.ESTestCase;
import org.elasticsearch.xcontent.ConstructingObjectParser;
import org.elasticsearch.xcontent.NamedXContentRegistry;
import org.elasticsearch.xcontent.ParseField;
import org.elasticsearch.xcontent.XContentBuilder;
import org.elasticsearch.xcontent.XContentParser;
@ -301,7 +297,6 @@ public class SearchModuleTests extends ESTestCase {
List<String> allSupportedQueries = new ArrayList<>();
Collections.addAll(allSupportedQueries, NON_DEPRECATED_QUERIES);
Collections.addAll(allSupportedQueries, DEPRECATED_QUERIES);
Collections.addAll(allSupportedQueries, REST_COMPATIBLE_QUERIES);
SearchModule module = new SearchModule(Settings.EMPTY, emptyList());
@ -471,11 +466,6 @@ public class SearchModuleTests extends ESTestCase {
// add here deprecated queries to make sure we log a deprecation warnings when they are used
private static final String[] DEPRECATED_QUERIES = new String[] { "field_masking_span", "geo_polygon" };
private static final String[] REST_COMPATIBLE_QUERIES = new String[] {
TypeQueryV7Builder.NAME_V7.getPreferredName(),
CommonTermsQueryBuilder.NAME_V7.getPreferredName() };
private static final String[] REST_COMPATIBLE_AGGREGATIONS = new String[] {
MovAvgPipelineAggregationBuilder.NAME_V7.getPreferredName() };
/**
* Dummy test {@link AggregationBuilder} used to test registering aggregation builders.
@ -692,58 +682,6 @@ public class SearchModuleTests extends ESTestCase {
}
}
static class CompatQueryBuilder extends DummyQueryBuilder {
public static final String NAME = "compat_name";
public static final ParseField NAME_OLD = new ParseField(NAME).forRestApiVersion(
RestApiVersion.equalTo(RestApiVersion.minimumSupported())
);
@Override
public String getWriteableName() {
return NAME;
}
}
public void testRegisterRestApiCompatibleQuery() {
SearchPlugin registerCompatQuery = new SearchPlugin() {
@Override
public List<SearchPlugin.QuerySpec<?>> getQueries() {
return singletonList(
new QuerySpec<>(
CompatQueryBuilder.NAME_OLD,
(streamInput) -> new CompatQueryBuilder(),
CompatQueryBuilder::fromXContent
)
);
}
};
final SearchModule searchModule = new SearchModule(Settings.EMPTY, singletonList(registerCompatQuery));
// all entries can be used for current and previous versions except for compatible entry
assertThat(searchModule.getNamedXContents().stream().filter(e ->
// filter out compatible entry
e.name.match(CompatQueryBuilder.NAME_OLD.getPreferredName(), LoggingDeprecationHandler.INSTANCE) == false)
.filter(e -> RestApiVersion.minimumSupported().matches(e.restApiCompatibility))
.filter(e -> RestApiVersion.current().matches(e.restApiCompatibility))
.collect(toSet()),
// -1 because of the registered in the test
hasSize(searchModule.getNamedXContents().size() - REST_COMPATIBLE_QUERIES.length - REST_COMPATIBLE_AGGREGATIONS.length - 1)
);
final List<NamedXContentRegistry.Entry> compatEntry = searchModule.getNamedXContents()
.stream()
.filter(
e -> e.categoryClass.equals(QueryBuilder.class)
&& RestApiVersion.minimumSupported().matches(e.name.getForRestApiVersion()) // v7 compatbile
&& RestApiVersion.current().matches(e.name.getForRestApiVersion()) == false
) // but not v8 compatible
.collect(toList());
assertThat(compatEntry, hasSize(REST_COMPATIBLE_QUERIES.length + 1));// +1 because of registered in the test
assertTrue(RestApiVersion.minimumSupported().matches(compatEntry.get(0).restApiCompatibility));
assertFalse(RestApiVersion.current().matches(compatEntry.get(0).restApiCompatibility));
}
public void testDefaultMaxNestedDepth() {
new SearchModule(Settings.EMPTY, emptyList());
assertEquals(

9
test/framework/src/main/java/org/elasticsearch/test/ESTestCase.java
View file

@ -1658,6 +1658,15 @@ public abstract class ESTestCase extends LuceneTestCase {
}
public String compatibleMediaType(XContentType type, RestApiVersion version) {
if (type.canonical().equals(type)) {
throw new IllegalArgumentException(
"Compatible header is only supported for vendor content types."
+ " You requested "
+ type.name()
+ "but likely want VND_"
+ type.name()
);
}
return type.toParsedMediaType()
.responseContentTypeHeader(Map.of(MediaType.COMPATIBLE_WITH_PARAMETER_NAME, String.valueOf(version.major)));
}

9
test/framework/src/main/java/org/elasticsearch/test/rest/ESRestTestCase.java
View file

@ -1179,7 +1179,14 @@ public abstract class ESRestTestCase extends ESTestCase {
// We hit a version of ES that doesn't serialize DeleteDataStreamAction.Request#wildcardExpressionsOriginallySpecified field
// or that doesn't support data streams so it's safe to ignore
int statusCode = ee.getResponse().getStatusLine().getStatusCode();
if (statusCode < 404 || statusCode > 405) {
if (statusCode == 400) {
// the test cluster likely does not include the data streams module so we can ignore this error code
// additionally there is an implementation gotcha that cause response code to be 400 or 405 dependent on if
// "_data_stream/*" matches a registered index pattern such as {a}/{b} but not for the HTTP verb.
// Prior to v9 POST {index}/{type} was registered as a compatible index pattern so the request would partially match
// and return a 405, but without that pattern registered at all the return value is a 400.
return;
} else if (statusCode < 404 || statusCode > 405) {
throw ee;
}
}

9
x-pack/plugin/frozen-indices/src/main/java/org/elasticsearch/xpack/frozen/rest/action/RestFreezeIndexAction.java
View file

@ -13,6 +13,7 @@ import org.elasticsearch.action.support.IndicesOptions;
import org.elasticsearch.client.internal.node.NodeClient;
import org.elasticsearch.common.Strings;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.core.UpdateForV9;
import org.elasticsearch.protocol.xpack.frozen.FreezeRequest;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestRequest;
@ -37,11 +38,17 @@ public final class RestFreezeIndexAction extends BaseRestHandler {
private static final String UNFREEZE_DEPRECATED = "Frozen indices are deprecated because they provide no benefit given improvements "
+ "in heap memory utilization. They will be removed in a future release.";
@UpdateForV9
// these routes were ".deprecated" in RestApiVersion.V_8 which will require use of REST API compatibility headers to access
// this API in v9. It is unclear if this was intentional for v9, and the code has been updated to ".deprecateAndKeep" which will
// continue to emit deprecations warnings but will not require any special headers to access the API in v9.
// Please review and update the code and tests as needed. The original code remains commented out below for reference.
@Override
public List<Route> routes() {
return List.of(
Route.builder(POST, "/{index}/_freeze").deprecated(FREEZE_REMOVED, RestApiVersion.V_7).build(),
Route.builder(POST, "/{index}/_unfreeze").deprecated(UNFREEZE_DEPRECATED, RestApiVersion.V_8).build()
// Route.builder(POST, "/{index}/_unfreeze").deprecated(UNFREEZE_DEPRECATED, RestApiVersion.V_8).build()
Route.builder(POST, "/{index}/_unfreeze").deprecateAndKeep(UNFREEZE_DEPRECATED).build()
);
}

61
x-pack/plugin/graph/src/test/java/org/elasticsearch/xpack/graph/rest/action/RestGraphActionTests.java
View file

@ -1,61 +0,0 @@
/*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the Elastic License
* 2.0; you may not use this file except in compliance with the Elastic License
* 2.0.
*/
package org.elasticsearch.xpack.graph.rest.action;
import org.elasticsearch.common.bytes.BytesArray;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.core.Tuple;
import org.elasticsearch.protocol.xpack.graph.GraphExploreRequest;
import org.elasticsearch.protocol.xpack.graph.GraphExploreResponse;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.test.rest.FakeRestRequest;
import org.elasticsearch.test.rest.RestActionTestCase;
import org.elasticsearch.xcontent.XContentType;
import org.junit.Before;
import org.mockito.Mockito;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import static org.hamcrest.Matchers.instanceOf;
public final class RestGraphActionTests extends RestActionTestCase {
private final List<String> compatibleMediaType = Collections.singletonList(randomCompatibleMediaType(RestApiVersion.V_7));
@Before
public void setUpAction() {
controller().registerHandler(new RestGraphAction());
verifyingClient.setExecuteVerifier((actionType, request) -> {
assertThat(request, instanceOf(GraphExploreRequest.class));
return Mockito.mock(GraphExploreResponse.class);
});
}
public void testTypeInPath() {
for (Tuple<RestRequest.Method, String> methodAndPath : List.of(
Tuple.tuple(RestRequest.Method.GET, "/some_index/some_type/_graph/explore"),
Tuple.tuple(RestRequest.Method.POST, "/some_index/some_type/_graph/explore"),
Tuple.tuple(RestRequest.Method.GET, "/some_index/some_type/_xpack/graph/_explore"),
Tuple.tuple(RestRequest.Method.POST, "/some_index/some_type/_xpack/graph/_explore")
)) {
RestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(
Map.of(
"Accept",
compatibleMediaType,
"Content-Type",
Collections.singletonList(compatibleMediaType(XContentType.VND_JSON, RestApiVersion.V_7))
)
).withMethod(methodAndPath.v1()).withPath(methodAndPath.v2()).withContent(new BytesArray("{}"), null).build();
dispatchRequest(request);
assertCriticalWarnings(RestGraphAction.TYPES_DEPRECATION_MESSAGE);
}
}
}

15
x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/rest/inference/RestDeleteTrainedModelAction.java
View file

@ -8,8 +8,8 @@ package org.elasticsearch.xpack.ml.rest.inference;
import org.elasticsearch.action.support.master.AcknowledgedRequest;
import org.elasticsearch.client.internal.node.NodeClient;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.core.TimeValue;
import org.elasticsearch.core.UpdateForV9;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.Scope;
@ -28,11 +28,20 @@ import static org.elasticsearch.xpack.ml.MachineLearning.BASE_PATH;
@ServerlessScope(Scope.PUBLIC)
public class RestDeleteTrainedModelAction extends BaseRestHandler {
@UpdateForV9
// one or more routes use ".replaces" with RestApiVersion.V_8 which will require use of REST API compatibility headers to access
// that route in v9. It is unclear if this was intentional for v9, and the code has been updated to ".deprecateAndKeep" which will
// continue to emit deprecations warnings but will not require any special headers to access the API in v9.
// Please review and update the code and tests as needed. The original code remains commented out below for reference.
@Override
public List<Route> routes() {
return List.of(
Route.builder(DELETE, BASE_PATH + "trained_models/{" + TrainedModelConfig.MODEL_ID + "}")
.replaces(DELETE, BASE_PATH + "inference/{" + TrainedModelConfig.MODEL_ID + "}", RestApiVersion.V_8)
// Route.builder(DELETE, BASE_PATH + "trained_models/{" + TrainedModelConfig.MODEL_ID + "}")
// .replaces(DELETE, BASE_PATH + "inference/{" + TrainedModelConfig.MODEL_ID + "}", RestApiVersion.V_8)
// .build()
new Route(DELETE, BASE_PATH + "trained_models/{" + TrainedModelConfig.MODEL_ID + "}"),
Route.builder(DELETE, BASE_PATH + "inference/{" + TrainedModelConfig.MODEL_ID + "}")
.deprecateAndKeep("Use the trained_models API instead.")
.build()
);
}

19
x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/rest/inference/RestGetTrainedModelsAction.java
View file

@ -11,7 +11,7 @@ import org.elasticsearch.cluster.metadata.Metadata;
import org.elasticsearch.common.Strings;
import org.elasticsearch.common.logging.DeprecationCategory;
import org.elasticsearch.common.logging.DeprecationLogger;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.core.UpdateForV9;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestChannel;
import org.elasticsearch.rest.RestRequest;
@ -49,13 +49,24 @@ public class RestGetTrainedModelsAction extends BaseRestHandler {
private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(RestGetTrainedModelsAction.class);
private static final String INCLUDE_MODEL_DEFINITION = "include_model_definition";
@UpdateForV9
// one or more routes use ".replaces" with RestApiVersion.V_8 which will require use of REST API compatibility headers to access
// that route in v9. It is unclear if this was intentional for v9, and the code has been updated to ".deprecateAndKeep" which will
// continue to emit deprecations warnings but will not require any special headers to access the API in v9.
// Please review and update the code and tests as needed. The original code remains commented out below for reference.
@Override
public List<Route> routes() {
return List.of(
Route.builder(GET, BASE_PATH + "trained_models/{" + TrainedModelConfig.MODEL_ID + "}")
.replaces(GET, BASE_PATH + "inference/{" + TrainedModelConfig.MODEL_ID + "}", RestApiVersion.V_8)
// Route.builder(GET, BASE_PATH + "trained_models/{" + TrainedModelConfig.MODEL_ID + "}")
// .replaces(GET, BASE_PATH + "inference/{" + TrainedModelConfig.MODEL_ID + "}", RestApiVersion.V_8)
// .build(),
// Route.builder(GET, BASE_PATH + "trained_models").replaces(GET, BASE_PATH + "inference", RestApiVersion.V_8).build()
new Route(GET, BASE_PATH + "trained_models/{" + TrainedModelConfig.MODEL_ID + "}"),
Route.builder(GET, BASE_PATH + "inference/{" + TrainedModelConfig.MODEL_ID + "}")
.deprecateAndKeep("Use the trained_models API instead.")
.build(),
Route.builder(GET, BASE_PATH + "trained_models").replaces(GET, BASE_PATH + "inference", RestApiVersion.V_8).build()
new Route(GET, BASE_PATH + "trained_models"),
Route.builder(GET, BASE_PATH + "inference").deprecateAndKeep("Use the trained_models API instead.").build()
);
}

23
x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/rest/inference/RestGetTrainedModelsStatsAction.java
View file

@ -9,7 +9,7 @@ package org.elasticsearch.xpack.ml.rest.inference;
import org.elasticsearch.client.internal.node.NodeClient;
import org.elasticsearch.cluster.metadata.Metadata;
import org.elasticsearch.common.Strings;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.core.UpdateForV9;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.Scope;
@ -30,15 +30,26 @@ import static org.elasticsearch.xpack.ml.MachineLearning.BASE_PATH;
@ServerlessScope(Scope.PUBLIC)
public class RestGetTrainedModelsStatsAction extends BaseRestHandler {
@UpdateForV9
// one or more routes use ".replaces" with RestApiVersion.V_8 which will require use of REST API compatibility headers to access
// that route in v9. It is unclear if this was intentional for v9, and the code has been updated to ".deprecateAndKeep" which will
// continue to emit deprecations warnings but will not require any special headers to access the API in v9.
// Please review and update the code and tests as needed. The original code remains commented out below for reference.
@Override
public List<Route> routes() {
return List.of(
Route.builder(GET, BASE_PATH + "trained_models/{" + TrainedModelConfig.MODEL_ID + "}/_stats")
.replaces(GET, BASE_PATH + "inference/{" + TrainedModelConfig.MODEL_ID + "}/_stats", RestApiVersion.V_8)
// Route.builder(GET, BASE_PATH + "trained_models/{" + TrainedModelConfig.MODEL_ID + "}/_stats")
// .replaces(GET, BASE_PATH + "inference/{" + TrainedModelConfig.MODEL_ID + "}/_stats", RestApiVersion.V_8)
// .build(),
// Route.builder(GET, BASE_PATH + "trained_models/_stats")
// .replaces(GET, BASE_PATH + "inference/_stats", RestApiVersion.V_8)
// .build()
new Route(GET, BASE_PATH + "trained_models/{" + TrainedModelConfig.MODEL_ID + "}/_stats"),
Route.builder(GET, BASE_PATH + "inference/{" + TrainedModelConfig.MODEL_ID + "}/_stats")
.deprecateAndKeep("Use the trained_models API instead.")
.build(),
Route.builder(GET, BASE_PATH + "trained_models/_stats")
.replaces(GET, BASE_PATH + "inference/_stats", RestApiVersion.V_8)
.build()
new Route(GET, BASE_PATH + "trained_models/_stats"),
Route.builder(GET, BASE_PATH + "inference/_stats").deprecateAndKeep("Use the trained_models API instead.").build()
);
}

25
x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/rest/inference/RestInferTrainedModelDeploymentAction.java
View file

@ -10,8 +10,8 @@ package org.elasticsearch.xpack.ml.rest.inference;
import org.elasticsearch.action.ActionListener;
import org.elasticsearch.client.internal.node.NodeClient;
import org.elasticsearch.common.ValidationException;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.core.TimeValue;
import org.elasticsearch.core.UpdateForV9;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestCancellableNodeClient;
@ -37,11 +37,29 @@ public class RestInferTrainedModelDeploymentAction extends BaseRestHandler {
return "xpack_ml_infer_trained_models_deployment_action";
}
@UpdateForV9 // these routes were ".deprecated" in RestApiVersion.V_8 which will require use of REST API compatibility headers to access
// this API in v9. It is unclear if this was intentional for v9, and the code has been updated to ".deprecateAndKeep" which will
// continue to emit deprecations warnings but will not require any special headers to access the API in v9.
// Please review and update the code and tests as needed. The original code remains commented out below for reference.
@Override
public List<Route> routes() {
return Collections.singletonList(
// Route.builder(POST, PATH)
// .deprecated(
// "["
// + POST.name()
// + " "
// + PATH
// + "] is deprecated! Use ["
// + POST.name()
// + " "
// + RestInferTrainedModelAction.PATH
// + "] instead.",
// RestApiVersion.V_8
// )
// .build()
Route.builder(POST, PATH)
.deprecated(
.deprecateAndKeep(
"["
+ POST.name()
+ " "
@ -50,8 +68,7 @@ public class RestInferTrainedModelDeploymentAction extends BaseRestHandler {
+ POST.name()
+ " "
+ RestInferTrainedModelAction.PATH
+ "] instead.",
RestApiVersion.V_8
+ "] instead."
)
.build()
);

15
x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/rest/inference/RestPutTrainedModelAction.java
View file

@ -7,7 +7,7 @@
package org.elasticsearch.xpack.ml.rest.inference;
import org.elasticsearch.client.internal.node.NodeClient;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.core.UpdateForV9;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.Scope;
@ -27,11 +27,20 @@ import static org.elasticsearch.xpack.ml.MachineLearning.BASE_PATH;
@ServerlessScope(Scope.PUBLIC)
public class RestPutTrainedModelAction extends BaseRestHandler {
@UpdateForV9
// one or more routes use ".replaces" with RestApiVersion.V_8 which will require use of REST API compatibility headers to access
// that route in v9. It is unclear if this was intentional for v9, and the code has been updated to ".deprecateAndKeep" which will
// continue to emit deprecations warnings but will not require any special headers to access the API in v9.
// Please review and update the code and tests as needed. The original code remains commented out below for reference.
@Override
public List<Route> routes() {
return List.of(
Route.builder(PUT, BASE_PATH + "trained_models/{" + TrainedModelConfig.MODEL_ID + "}")
.replaces(PUT, BASE_PATH + "inference/{" + TrainedModelConfig.MODEL_ID + "}", RestApiVersion.V_8)
// Route.builder(PUT, BASE_PATH + "trained_models/{" + TrainedModelConfig.MODEL_ID + "}")
// .replaces(PUT, BASE_PATH + "inference/{" + TrainedModelConfig.MODEL_ID + "}", RestApiVersion.V_8)
// .build()
new Route(PUT, BASE_PATH + "trained_models/{" + TrainedModelConfig.MODEL_ID + "}"),
Route.builder(PUT, BASE_PATH + "inference/{" + TrainedModelConfig.MODEL_ID + "}")
.deprecateAndKeep("Use the trained_models API instead.")
.build()
);
}

8
x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/rest/job/RestPostDataAction.java
View file

@ -8,6 +8,7 @@ package org.elasticsearch.xpack.ml.rest.job;
import org.elasticsearch.client.internal.node.NodeClient;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.core.UpdateForV9;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.RestStatus;
@ -27,12 +28,17 @@ public class RestPostDataAction extends BaseRestHandler {
private static final String DEFAULT_RESET_START = "";
private static final String DEFAULT_RESET_END = "";
@UpdateForV9 // these routes were ".deprecated" in RestApiVersion.V_8 which will require use of REST API compatibility headers to access
// this API in v9. It is unclear if this was intentional for v9, and the code has been updated to ".deprecateAndKeep" which will
// continue to emit deprecations warnings but will not require any special headers to access the API in v9.
// Please review and update the code and tests as needed. The original code remains commented out below for reference.
@Override
public List<Route> routes() {
final String msg = "Posting data directly to anomaly detection jobs is deprecated, "
+ "in a future major version it will be compulsory to use a datafeed";
return List.of(
Route.builder(POST, BASE_PATH + "anomaly_detectors/{" + Job.ID + "}/_data").deprecated(msg, RestApiVersion.V_8).build(),
// Route.builder(POST, BASE_PATH + "anomaly_detectors/{" + Job.ID + "}/_data").deprecated(msg, RestApiVersion.V_8).build(),
Route.builder(POST, BASE_PATH + "anomaly_detectors/{" + Job.ID + "}/_data").deprecateAndKeep(msg).build(),
Route.builder(POST, PRE_V7_BASE_PATH + "anomaly_detectors/{" + Job.ID + "}/_data").deprecated(msg, RestApiVersion.V_7).build()
);
}

17
x-pack/plugin/security/qa/audit/src/javaRestTest/java/org/elasticsearch/xpack/security/audit/AuditIT.java
View file

@ -8,9 +8,7 @@
package org.elasticsearch.xpack.security.audit;
import org.elasticsearch.client.Request;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.Response;
import org.elasticsearch.client.WarningsHandler;
import org.elasticsearch.common.bytes.BytesReference;
import org.elasticsearch.common.io.Streams;
import org.elasticsearch.common.settings.SecureString;
@ -81,14 +79,14 @@ public class AuditIT extends ESRestTestCase {
}
public void testAuditAuthenticationSuccess() throws Exception {
final Request request = new Request("GET", randomFrom("/_security/_authenticate", "/_xpack/security/_authenticate"));
final Request request = new Request("GET", "/_security/_authenticate");
executeAndVerifyAudit(request, AuditLevel.AUTHENTICATION_SUCCESS, event -> {
assertThat(event, hasEntry(LoggingAuditTrail.AUTHENTICATION_TYPE_FIELD_NAME, "REALM"));
});
}
public void testAuditAuthenticationFailure() throws Exception {
final Request request = new Request("GET", randomFrom("/_security/_authenticate", "/_xpack/security/_authenticate"));
final Request request = new Request("GET", "/_security/_authenticate");
String basicAuth = basicAuthHeaderValue(API_USER, new SecureString(new char[0]));
request.setOptions(request.getOptions().toBuilder().addHeader("Authorization", basicAuth).addParameter("ignore", "401"));
executeAndVerifyAudit(request, AuditLevel.AUTHENTICATION_FAILED, event -> {});
@ -96,7 +94,7 @@ public class AuditIT extends ESRestTestCase {
public void testFilteringOfRequestBodies() throws Exception {
final String username = randomAlphaOfLength(4) + randomIntBetween(100, 999);
final Request request = new Request(randomFrom("PUT", "POST"), randomFrom("/_security/user/", "/_xpack/security/user/") + username);
final Request request = new Request(randomFrom("PUT", "POST"), "/_security/user/" + username);
final String password = randomAlphaOfLength(4) + randomIntBetween(10, 99) + randomAlphaOfLength(4);
request.setJsonEntity("{ \"password\":\"" + password + "\", \"roles\":[\"superuser\"] }");
executeAndVerifyAudit(request, AuditLevel.AUTHENTICATION_SUCCESS, event -> {
@ -141,15 +139,6 @@ public class AuditIT extends ESRestTestCase {
}
private static Response executeRequest(Request request) throws IOException {
if (request.getEndpoint().startsWith("/_xpack/security/")) {
final RequestOptions options = request.getOptions()
.toBuilder()
.addHeader("Content-Type", "application/json; compatible-with=7")
.addHeader("Accept", "application/json; compatible-with=7")
.setWarningsHandler(WarningsHandler.PERMISSIVE)
.build();
request.setOptions(options);
}
return client().performRequest(request);
}

11
x-pack/plugin/text-structure/src/main/java/org/elasticsearch/xpack/textstructure/rest/RestFindStructureAction.java
View file

@ -8,7 +8,7 @@ package org.elasticsearch.xpack.textstructure.rest;
import org.elasticsearch.ElasticsearchParseException;
import org.elasticsearch.client.internal.node.NodeClient;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.core.UpdateForV9;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.Scope;
@ -27,10 +27,17 @@ import static org.elasticsearch.xpack.textstructure.TextStructurePlugin.BASE_PAT
@ServerlessScope(Scope.INTERNAL)
public class RestFindStructureAction extends BaseRestHandler {
@UpdateForV9
// one or more routes use ".replaces" with RestApiVersion.V_8 which will require use of REST API compatibility headers to access
// that route in v9. It is unclear if this was intentional for v9, and the code has been updated to ".deprecateAndKeep" which will
// continue to emit deprecations warnings but will not require any special headers to access the API in v9.
// Please review and update the code and tests as needed. The original code remains commented out below for reference.
@Override
public List<Route> routes() {
return List.of(
Route.builder(POST, BASE_PATH + "find_structure").replaces(POST, "/_ml/find_file_structure", RestApiVersion.V_8).build()
// Route.builder(POST, BASE_PATH + "find_structure").replaces(POST, "/_ml/find_file_structure", RestApiVersion.V_8).build()
new Route(POST, BASE_PATH + "find_structure"),
Route.builder(POST, "/_ml/find_file_structure").deprecateAndKeep("Use the _text_structure API instead.").build()
);
}

20
x-pack/qa/full-cluster-restart/src/javaRestTest/java/org/elasticsearch/xpack/restart/MLModelDeploymentFullClusterRestartIT.java
View file

@ -16,10 +16,12 @@ import org.elasticsearch.client.ResponseException;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.util.concurrent.ThreadContext;
import org.elasticsearch.common.xcontent.support.XContentMapValues;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.core.Strings;
import org.elasticsearch.core.UpdateForV9;
import org.elasticsearch.test.rest.RestTestLegacyFeatures;
import org.elasticsearch.upgrades.FullClusterRestartUpgradeStatus;
import org.elasticsearch.xcontent.XContentType;
import org.elasticsearch.xpack.core.ml.inference.assignment.AllocationStatus;
import org.junit.Before;
@ -195,14 +197,30 @@ public class MLModelDeploymentFullClusterRestartIT extends AbstractXpackFullClus
}
private Response startDeployment(String modelId, String waitForState) throws IOException {
String inferenceThreadParamName = "threads_per_allocation";
String modelThreadParamName = "number_of_allocations";
String compatibleHeader = null;
if (isRunningAgainstOldCluster()) {
compatibleHeader = compatibleMediaType(XContentType.VND_JSON, RestApiVersion.V_8);
inferenceThreadParamName = "inference_threads";
modelThreadParamName = "model_threads";
}
Request request = new Request(
"POST",
"/_ml/trained_models/"
+ modelId
+ "/deployment/_start?timeout=40s&wait_for="
+ waitForState
+ "&inference_threads=1&model_threads=1"
+ "&"
+ inferenceThreadParamName
+ "=1&"
+ modelThreadParamName
+ "=1"
);
if (compatibleHeader != null) {
request.setOptions(request.getOptions().toBuilder().addHeader("Accept", compatibleHeader).build());
}
request.setOptions(request.getOptions().toBuilder().setWarningsHandler(PERMISSIVE).build());
var response = client().performRequest(request);
assertOK(response);

18
x-pack/qa/repository-old-versions/src/test/java/org/elasticsearch/oldrepos/OldRepositoryAccessIT.java
View file

@ -370,14 +370,10 @@ public class OldRepositoryAccessIT extends ESRestTestCase {
Version oldVersion,
int numberOfShards
) throws IOException {
RequestOptions v7RequestOptions = RequestOptions.DEFAULT.toBuilder()
.addHeader("Content-Type", "application/vnd.elasticsearch+json;compatible-with=7")
.addHeader("Accept", "application/vnd.elasticsearch+json;compatible-with=7")
.build();
RequestOptions randomRequestOptions = randomBoolean() ? RequestOptions.DEFAULT : v7RequestOptions;
RequestOptions requestOptions = RequestOptions.DEFAULT;
// run a search against the index
SearchResponse searchResponse = search(index, null, randomRequestOptions);
SearchResponse searchResponse = search(index, null, requestOptions);
try {
logger.info(searchResponse);
// check hit count
@ -404,7 +400,7 @@ public class OldRepositoryAccessIT extends ESRestTestCase {
SearchSourceBuilder.searchSource()
.query(QueryBuilders.matchQuery("val", num))
.runtimeMappings(Map.of("val", Map.of("type", "long"))),
randomRequestOptions
requestOptions
);
try {
logger.info(searchResponse);
@ -422,7 +418,7 @@ public class OldRepositoryAccessIT extends ESRestTestCase {
SearchSourceBuilder.searchSource()
.query(QueryBuilders.matchAllQuery())
.sort(SortBuilders.fieldSort("val").order(SortOrder.DESC)),
randomRequestOptions
requestOptions
);
try {
logger.info(searchResponse);
@ -439,7 +435,7 @@ public class OldRepositoryAccessIT extends ESRestTestCase {
searchResponse = search(
index,
SearchSourceBuilder.searchSource().query(QueryBuilders.matchQuery("test", "test" + num)),
randomRequestOptions
requestOptions
);
try {
logger.info(searchResponse);
@ -456,7 +452,7 @@ public class OldRepositoryAccessIT extends ESRestTestCase {
searchResponse = search(
index,
SearchSourceBuilder.searchSource().query(QueryBuilders.termQuery("_type", randomType)),
randomRequestOptions
requestOptions
);
try {
logger.info(searchResponse);
@ -482,7 +478,7 @@ public class OldRepositoryAccessIT extends ESRestTestCase {
searchResponse = search(
index,
SearchSourceBuilder.searchSource().query(QueryBuilders.rangeQuery("create_date").from("2020-02-01")),
randomRequestOptions
requestOptions
);
try {
logger.info(searchResponse);

20
x-pack/qa/rolling-upgrade/src/test/java/org/elasticsearch/upgrades/MLModelDeploymentsUpgradeIT.java
View file

@ -12,8 +12,10 @@ import org.elasticsearch.Version;
import org.elasticsearch.client.Request;
import org.elasticsearch.client.Response;
import org.elasticsearch.common.xcontent.support.XContentMapValues;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.core.Strings;
import org.elasticsearch.core.UpdateForV9;
import org.elasticsearch.xcontent.XContentType;
import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;
@ -242,14 +244,30 @@ public class MLModelDeploymentsUpgradeIT extends AbstractUpgradeTestCase {
}
private Response startDeployment(String modelId, String waitForState) throws IOException {
String inferenceThreadParamName = "threads_per_allocation";
String modelThreadParamName = "number_of_allocations";
String compatibleHeader = null;
if (CLUSTER_TYPE.equals(ClusterType.OLD) || CLUSTER_TYPE.equals(ClusterType.MIXED)) {
compatibleHeader = compatibleMediaType(XContentType.VND_JSON, RestApiVersion.V_8);
inferenceThreadParamName = "inference_threads";
modelThreadParamName = "model_threads";
}
Request request = new Request(
"POST",
"/_ml/trained_models/"
+ modelId
+ "/deployment/_start?timeout=40s&wait_for="
+ waitForState
+ "&inference_threads=1&model_threads=1"
+ "&"
+ inferenceThreadParamName
+ "=1&"
+ modelThreadParamName
+ "=1"
);
if (compatibleHeader != null) {
request.setOptions(request.getOptions().toBuilder().addHeader("Accept", compatibleHeader).build());
}
request.setOptions(request.getOptions().toBuilder().setWarningsHandler(PERMISSIVE).build());
var response = client().performRequest(request);
assertOK(response);

20
x-pack/qa/rolling-upgrade/src/test/java/org/elasticsearch/upgrades/MlAssignmentPlannerUpgradeIT.java
View file

@ -12,11 +12,13 @@ import org.elasticsearch.client.Request;
import org.elasticsearch.client.Response;
import org.elasticsearch.common.unit.ByteSizeValue;
import org.elasticsearch.common.xcontent.support.XContentMapValues;
import org.elasticsearch.core.RestApiVersion;
import org.elasticsearch.core.Strings;
import org.elasticsearch.core.UpdateForV9;
import org.elasticsearch.logging.LogManager;
import org.elasticsearch.logging.Logger;
import org.elasticsearch.test.rest.RestTestLegacyFeatures;
import org.elasticsearch.xcontent.XContentType;
import java.io.IOException;
import java.util.ArrayList;
@ -278,14 +280,30 @@ public class MlAssignmentPlannerUpgradeIT extends AbstractUpgradeTestCase {
}
private Response startDeployment(String modelId, String waitForState) throws IOException {
String inferenceThreadParamName = "threads_per_allocation";
String modelThreadParamName = "number_of_allocations";
String compatibleHeader = null;
if (CLUSTER_TYPE.equals(ClusterType.OLD) || CLUSTER_TYPE.equals(ClusterType.MIXED)) {
compatibleHeader = compatibleMediaType(XContentType.VND_JSON, RestApiVersion.V_8);
inferenceThreadParamName = "inference_threads";
modelThreadParamName = "model_threads";
}
Request request = new Request(
"POST",
"/_ml/trained_models/"
+ modelId
+ "/deployment/_start?timeout=40s&wait_for="
+ waitForState
+ "&inference_threads=1&model_threads=1"
+ "&"
+ inferenceThreadParamName
+ "=1&"
+ modelThreadParamName
+ "=1"
);
if (compatibleHeader != null) {
request.setOptions(request.getOptions().toBuilder().addHeader("Accept", compatibleHeader).build());
}
request.setOptions(request.getOptions().toBuilder().setWarningsHandler(PERMISSIVE).build());
var response = client().performRequest(request);
assertOK(response);