honeymoose/OpenSearch
1
0
Fork 0
mirror of https://github.com/honeymoose/OpenSearch.git synced 2025-03-25 09:28:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

RestHandlers declare handled routes (#52123)

Browse Source 
This commit changes how RestHandlers are registered with the
RestController so that a RestHandler no longer needs to register itself
with the RestController. Instead the RestHandler interface has new
methods which when called provide information about the routes
(method and path combinations) that are handled by the handler
including any deprecated and/or replaced combinations.

This change also makes the publication of RestHandlers safe since they
no longer publish a reference to themselves within their constructors.

Closes #51622

Co-authored-by: Jason Tedor <jason@tedor.me>

Backport of #51950
This commit is contained in:
Jay Modi 2020-02-09 22:48:32 -07:00 committed by GitHub
parent 8c0b49cd32
commit 3edadfefd0
396 changed files with 4239 additions and 2301 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
client/client-benchmark-noop-api-plugin/src/main/java/org/elasticsearch/plugin/noop/NoopPlugin.java
View File

@ -55,7 +55,7 @@ public class NoopPlugin extends Plugin implements ActionPlugin {
IndexScopedSettings indexScopedSettings, SettingsFilter settingsFilter, IndexNameExpressionResolver indexNameExpressionResolver,
Supplier<DiscoveryNodes> nodesInCluster) {
return Arrays.asList(
new RestNoopBulkAction(restController),
new RestNoopSearchAction(restController));
new RestNoopBulkAction(),
new RestNoopSearchAction());
}
}

20
client/client-benchmark-noop-api-plugin/src/main/java/org/elasticsearch/plugin/noop/action/bulk/RestNoopBulkAction.java
View File

@ -32,26 +32,30 @@ import org.elasticsearch.index.shard.ShardId;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.BytesRestResponse;
import org.elasticsearch.rest.RestChannel;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.RestResponse;
import org.elasticsearch.rest.action.RestBuilderListener;
import java.io.IOException;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.POST;
import static org.elasticsearch.rest.RestRequest.Method.PUT;
import static org.elasticsearch.rest.RestStatus.OK;
public class RestNoopBulkAction extends BaseRestHandler {
public RestNoopBulkAction(RestController controller) {
controller.registerHandler(POST, "/_noop_bulk", this);
controller.registerHandler(PUT, "/_noop_bulk", this);
controller.registerHandler(POST, "/{index}/_noop_bulk", this);
controller.registerHandler(PUT, "/{index}/_noop_bulk", this);
controller.registerHandler(POST, "/{index}/{type}/_noop_bulk", this);
controller.registerHandler(PUT, "/{index}/{type}/_noop_bulk", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(POST, "/_noop_bulk"),
new Route(PUT, "/_noop_bulk"),
new Route(POST, "/{index}/_noop_bulk"),
new Route(PUT, "/{index}/_noop_bulk"),
new Route(POST, "/{index}/{type}/_noop_bulk"),
new Route(PUT, "/{index}/{type}/_noop_bulk")));
}
@Override

21
client/client-benchmark-noop-api-plugin/src/main/java/org/elasticsearch/plugin/noop/action/search/RestNoopSearchAction.java
View File

@ -21,22 +21,27 @@ package org.elasticsearch.plugin.noop.action.search;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestStatusToXContentListener;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
import static org.elasticsearch.rest.RestRequest.Method.POST;
public class RestNoopSearchAction extends BaseRestHandler {
public RestNoopSearchAction(RestController controller) {
controller.registerHandler(GET, "/_noop_search", this);
controller.registerHandler(POST, "/_noop_search", this);
controller.registerHandler(GET, "/{index}/_noop_search", this);
controller.registerHandler(POST, "/{index}/_noop_search", this);
controller.registerHandler(GET, "/{index}/{type}/_noop_search", this);
controller.registerHandler(POST, "/{index}/{type}/_noop_search", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_noop_search"),
new Route(POST, "/_noop_search"),
new Route(GET, "/{index}/_noop_search"),
new Route(POST, "/{index}/_noop_search"),
new Route(GET, "/{index}/{type}/_noop_search"),
new Route(POST, "/{index}/{type}/_noop_search")));
}
@Override

9
modules/ingest-common/src/main/java/org/elasticsearch/ingest/common/GrokProcessorGetAction.java
View File

@ -32,15 +32,16 @@ import org.elasticsearch.common.io.stream.StreamOutput;
import org.elasticsearch.common.xcontent.ToXContentObject;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import org.elasticsearch.tasks.Task;
import org.elasticsearch.transport.TransportService;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import static java.util.Collections.singletonList;
import static org.elasticsearch.ingest.common.IngestCommonPlugin.GROK_PATTERNS;
import static org.elasticsearch.rest.RestRequest.Method.GET;
@ -116,8 +117,10 @@ public class GrokProcessorGetAction extends ActionType<GrokProcessorGetAction.Re
}
public static class RestAction extends BaseRestHandler {
RestAction(RestController controller) {
controller.registerHandler(GET, "/_ingest/processor/grok", this);
@Override
public List<Route> routes() {
return singletonList(new Route(GET, "/_ingest/processor/grok"));
}
@Override

2
modules/ingest-common/src/main/java/org/elasticsearch/ingest/common/IngestCommonPlugin.java
View File

@ -102,7 +102,7 @@ public class IngestCommonPlugin extends Plugin implements ActionPlugin, IngestPl
IndexScopedSettings indexScopedSettings, SettingsFilter settingsFilter,
IndexNameExpressionResolver indexNameExpressionResolver,
Supplier<DiscoveryNodes> nodesInCluster) {
return Arrays.asList(new GrokProcessorGetAction.RestAction(restController));
return Collections.singletonList(new GrokProcessorGetAction.RestAction());
}
@Override

6
modules/lang-mustache/src/main/java/org/elasticsearch/script/mustache/MustachePlugin.java
View File

@ -59,8 +59,8 @@ public class MustachePlugin extends Plugin implements ScriptPlugin, ActionPlugin
IndexScopedSettings indexScopedSettings, SettingsFilter settingsFilter, IndexNameExpressionResolver indexNameExpressionResolver,
Supplier<DiscoveryNodes> nodesInCluster) {
return Arrays.asList(
new RestSearchTemplateAction(restController),
new RestMultiSearchTemplateAction(settings, restController),
new RestRenderSearchTemplateAction(restController));
new RestSearchTemplateAction(),
new RestMultiSearchTemplateAction(settings),
new RestRenderSearchTemplateAction());
}
}

28
modules/lang-mustache/src/main/java/org/elasticsearch/script/mustache/RestMultiSearchTemplateAction.java
View File

@ -24,18 +24,19 @@ import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.logging.DeprecationLogger;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import org.elasticsearch.rest.action.search.RestMultiSearchAction;
import org.elasticsearch.rest.action.search.RestSearchAction;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
import static org.elasticsearch.rest.RestRequest.Method.POST;
@ -49,7 +50,7 @@ public class RestMultiSearchTemplateAction extends BaseRestHandler {
static {
final Set<String> responseParams = new HashSet<>(
Arrays.asList(RestSearchAction.TYPED_KEYS_PARAM, RestSearchAction.TOTAL_HITS_AS_INT_PARAM)
asList(RestSearchAction.TYPED_KEYS_PARAM, RestSearchAction.TOTAL_HITS_AS_INT_PARAM)
);
RESPONSE_PARAMS = Collections.unmodifiableSet(responseParams);
}
@ -57,17 +58,20 @@ public class RestMultiSearchTemplateAction extends BaseRestHandler {
private final boolean allowExplicitIndex;
public RestMultiSearchTemplateAction(Settings settings, RestController controller) {
public RestMultiSearchTemplateAction(Settings settings) {
this.allowExplicitIndex = MULTI_ALLOW_EXPLICIT_INDEX.get(settings);
}
controller.registerHandler(GET, "/_msearch/template", this);
controller.registerHandler(POST, "/_msearch/template", this);
controller.registerHandler(GET, "/{index}/_msearch/template", this);
controller.registerHandler(POST, "/{index}/_msearch/template", this);
// Deprecated typed endpoints.
controller.registerHandler(GET, "/{index}/{type}/_msearch/template", this);
controller.registerHandler(POST, "/{index}/{type}/_msearch/template", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_msearch/template"),
new Route(POST, "/_msearch/template"),
new Route(GET, "/{index}/_msearch/template"),
new Route(POST, "/{index}/_msearch/template"),
// Deprecated typed endpoints.
new Route(GET, "/{index}/{type}/_msearch/template"),
new Route(POST, "/{index}/{type}/_msearch/template")));
}
@Override

16
modules/lang-mustache/src/main/java/org/elasticsearch/script/mustache/RestRenderSearchTemplateAction.java
View File

@ -22,23 +22,27 @@ package org.elasticsearch.script.mustache;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.xcontent.XContentParser;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import org.elasticsearch.script.ScriptType;
import java.io.IOException;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
import static org.elasticsearch.rest.RestRequest.Method.POST;
public class RestRenderSearchTemplateAction extends BaseRestHandler {
public RestRenderSearchTemplateAction(RestController controller) {
controller.registerHandler(GET, "/_render/template", this);
controller.registerHandler(POST, "/_render/template", this);
controller.registerHandler(GET, "/_render/template/{id}", this);
controller.registerHandler(POST, "/_render/template/{id}", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_render/template"),
new Route(POST, "/_render/template"),
new Route(GET, "/_render/template/{id}"),
new Route(POST, "/_render/template/{id}")));
}
@Override

23
modules/lang-mustache/src/main/java/org/elasticsearch/script/mustache/RestSearchTemplateAction.java
View File

@ -23,7 +23,6 @@ import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.xcontent.XContentParser;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestStatusToXContentListener;
import org.elasticsearch.rest.action.search.RestSearchAction;
@ -32,8 +31,11 @@ import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
import static org.elasticsearch.rest.RestRequest.Method.POST;
@ -46,15 +48,16 @@ public class RestSearchTemplateAction extends BaseRestHandler {
RESPONSE_PARAMS = Collections.unmodifiableSet(responseParams);
}
public RestSearchTemplateAction(RestController controller) {
controller.registerHandler(GET, "/_search/template", this);
controller.registerHandler(POST, "/_search/template", this);
controller.registerHandler(GET, "/{index}/_search/template", this);
controller.registerHandler(POST, "/{index}/_search/template", this);
// Deprecated typed endpoints.
controller.registerHandler(GET, "/{index}/{type}/_search/template", this);
controller.registerHandler(POST, "/{index}/{type}/_search/template", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_search/template"),
new Route(POST, "/_search/template"),
new Route(GET, "/{index}/_search/template"),
new Route(POST, "/{index}/_search/template"),
// Deprecated typed endpoints.
new Route(GET, "/{index}/{type}/_search/template"),
new Route(POST, "/{index}/{type}/_search/template")));
}
@Override

2
modules/lang-mustache/src/test/java/org/elasticsearch/script/mustache/RestMultiSearchTemplateActionTests.java
View File

@ -32,7 +32,7 @@ public class RestMultiSearchTemplateActionTests extends RestActionTestCase {
@Before
public void setUpAction() {
new RestMultiSearchTemplateAction(Settings.EMPTY, controller());
controller().registerHandler(new RestMultiSearchTemplateAction(Settings.EMPTY));
}
public void testTypeInPath() {

2
modules/lang-mustache/src/test/java/org/elasticsearch/script/mustache/RestSearchTemplateActionTests.java
View File

@ -31,7 +31,7 @@ public class RestSearchTemplateActionTests extends RestActionTestCase {
@Before
public void setUpAction() {
new RestSearchTemplateAction(controller());
controller().registerHandler(new RestSearchTemplateAction());
}
public void testTypeInPath() {

4
modules/lang-painless/src/main/java/org/elasticsearch/painless/PainlessPlugin.java
View File

@ -142,8 +142,8 @@ public final class PainlessPlugin extends Plugin implements ScriptPlugin, Extens
IndexNameExpressionResolver indexNameExpressionResolver,
Supplier<DiscoveryNodes> nodesInCluster) {
List<RestHandler> handlers = new ArrayList<>();
handlers.add(new PainlessExecuteAction.RestAction(restController));
handlers.add(new PainlessContextAction.RestAction(restController));
handlers.add(new PainlessExecuteAction.RestAction());
handlers.add(new PainlessContextAction.RestAction());
return handlers;
}
}

7
modules/lang-painless/src/main/java/org/elasticsearch/painless/action/PainlessContextAction.java
View File

@ -37,7 +37,6 @@ import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.painless.PainlessScriptEngine;
import org.elasticsearch.painless.lookup.PainlessLookup;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import org.elasticsearch.script.ScriptContext;
@ -52,6 +51,7 @@ import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
import static java.util.Collections.singletonList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
/**
@ -194,8 +194,9 @@ public class PainlessContextAction extends ActionType<PainlessContextAction.Resp
public static class RestAction extends BaseRestHandler {
public RestAction(RestController controller) {
controller.registerHandler(GET, "/_scripts/painless/_context", this);
@Override
public List<Route> routes() {
return singletonList(new Route(GET, "/_scripts/painless/_context"));
}
@Override

12
modules/lang-painless/src/main/java/org/elasticsearch/painless/action/PainlessExecuteAction.java
View File

@ -69,7 +69,6 @@ import org.elasticsearch.index.query.QueryShardContext;
import org.elasticsearch.index.shard.ShardId;
import org.elasticsearch.indices.IndicesService;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import org.elasticsearch.script.FilterScript;
@ -84,9 +83,12 @@ import org.elasticsearch.transport.TransportService;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.action.ValidateActions.addValidationError;
import static org.elasticsearch.rest.RestRequest.Method.GET;
import static org.elasticsearch.rest.RestRequest.Method.POST;
@ -584,9 +586,11 @@ public class PainlessExecuteAction extends ActionType<PainlessExecuteAction.Resp
public static class RestAction extends BaseRestHandler {
public RestAction(RestController controller) {
controller.registerHandler(GET, "/_scripts/painless/_execute", this);
controller.registerHandler(POST, "/_scripts/painless/_execute", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_scripts/painless/_execute"),
new Route(POST, "/_scripts/painless/_execute")));
}
@Override

3
modules/rank-eval/src/main/java/org/elasticsearch/index/rankeval/RankEvalPlugin.java
View File

@ -36,6 +36,7 @@ import org.elasticsearch.rest.RestHandler;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.function.Supplier;
@ -50,7 +51,7 @@ public class RankEvalPlugin extends Plugin implements ActionPlugin {
public List<RestHandler> getRestHandlers(Settings settings, RestController restController, ClusterSettings clusterSettings,
IndexScopedSettings indexScopedSettings, SettingsFilter settingsFilter, IndexNameExpressionResolver indexNameExpressionResolver,
Supplier<DiscoveryNodes> nodesInCluster) {
return Arrays.asList(new RestRankEvalAction(restController));
return Collections.singletonList(new RestRankEvalAction());
}
@Override

16
modules/rank-eval/src/main/java/org/elasticsearch/index/rankeval/RestRankEvalAction.java
View File

@ -25,12 +25,14 @@ import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.Strings;
import org.elasticsearch.common.xcontent.XContentParser;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
import static org.elasticsearch.rest.RestRequest.Method.POST;
@ -90,11 +92,13 @@ public class RestRankEvalAction extends BaseRestHandler {
public static String ENDPOINT = "_rank_eval";
public RestRankEvalAction(RestController controller) {
controller.registerHandler(GET, "/" + ENDPOINT, this);
controller.registerHandler(POST, "/" + ENDPOINT, this);
controller.registerHandler(GET, "/{index}/" + ENDPOINT, this);
controller.registerHandler(POST, "/{index}/" + ENDPOINT, this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/" + ENDPOINT),
new Route(POST, "/" + ENDPOINT),
new Route(GET, "/{index}/" + ENDPOINT),
new Route(POST, "/{index}/" + ENDPOINT)));
}
@Override

8
modules/reindex/src/main/java/org/elasticsearch/index/reindex/ReindexPlugin.java
View File

@ -74,10 +74,10 @@ public class ReindexPlugin extends Plugin implements ActionPlugin {
IndexScopedSettings indexScopedSettings, SettingsFilter settingsFilter, IndexNameExpressionResolver indexNameExpressionResolver,
Supplier<DiscoveryNodes> nodesInCluster) {
return Arrays.asList(
new RestReindexAction(restController),
new RestUpdateByQueryAction(restController),
new RestDeleteByQueryAction(restController),
new RestRethrottleAction(restController, nodesInCluster));
new RestReindexAction(),
new RestUpdateByQueryAction(),
new RestDeleteByQueryAction(),
new RestRethrottleAction(nodesInCluster));
}
@Override

15
modules/reindex/src/main/java/org/elasticsearch/index/reindex/RestDeleteByQueryAction.java
View File

@ -20,22 +20,29 @@
package org.elasticsearch.index.reindex;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.POST;
public class RestDeleteByQueryAction extends AbstractBulkByQueryRestHandler<DeleteByQueryRequest, DeleteByQueryAction> {
public RestDeleteByQueryAction(RestController controller) {
public RestDeleteByQueryAction() {
super(DeleteByQueryAction.INSTANCE);
controller.registerHandler(POST, "/{index}/_delete_by_query", this);
controller.registerHandler(POST, "/{index}/{type}/_delete_by_query", this);
}
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(POST, "/{index}/_delete_by_query"),
new Route(POST, "/{index}/{type}/_delete_by_query")));
}
@Override

11
modules/reindex/src/main/java/org/elasticsearch/index/reindex/RestReindexAction.java
View File

@ -21,11 +21,12 @@ package org.elasticsearch.index.reindex;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.xcontent.XContentParser;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import java.io.IOException;
import java.util.List;
import static java.util.Collections.singletonList;
import static org.elasticsearch.common.unit.TimeValue.parseTimeValue;
import static org.elasticsearch.rest.RestRequest.Method.POST;
@ -34,9 +35,13 @@ import static org.elasticsearch.rest.RestRequest.Method.POST;
*/
public class RestReindexAction extends AbstractBaseReindexRestHandler<ReindexRequest, ReindexAction> {
public RestReindexAction(RestController controller) {
public RestReindexAction() {
super(ReindexAction.INSTANCE);
controller.registerHandler(POST, "/_reindex", this);
}
@Override
public List<Route> routes() {
return singletonList(new Route(POST, "/_reindex"));
}
@Override

17
modules/reindex/src/main/java/org/elasticsearch/index/reindex/RestRethrottleAction.java
View File

@ -22,23 +22,30 @@ package org.elasticsearch.index.reindex;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.cluster.node.DiscoveryNodes;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.tasks.TaskId;
import java.util.List;
import java.util.function.Supplier;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.POST;
import static org.elasticsearch.rest.action.admin.cluster.RestListTasksAction.listTasksResponseListener;
public class RestRethrottleAction extends BaseRestHandler {
private final Supplier<DiscoveryNodes> nodesInCluster;
public RestRethrottleAction(RestController controller, Supplier<DiscoveryNodes> nodesInCluster) {
public RestRethrottleAction(Supplier<DiscoveryNodes> nodesInCluster) {
this.nodesInCluster = nodesInCluster;
controller.registerHandler(POST, "/_update_by_query/{taskId}/_rethrottle", this);
controller.registerHandler(POST, "/_delete_by_query/{taskId}/_rethrottle", this);
controller.registerHandler(POST, "/_reindex/{taskId}/_rethrottle", this);
}
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(POST, "/_update_by_query/{taskId}/_rethrottle"),
new Route(POST, "/_delete_by_query/{taskId}/_rethrottle"),
new Route(POST, "/_reindex/{taskId}/_rethrottle")));
}
@Override

16
modules/reindex/src/main/java/org/elasticsearch/index/reindex/RestUpdateByQueryAction.java
View File

@ -22,7 +22,6 @@ package org.elasticsearch.index.reindex;
import org.elasticsearch.ElasticsearchParseException;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.xcontent.LoggingDeprecationHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.script.Script;
import org.elasticsearch.script.ScriptType;
@ -31,17 +30,26 @@ import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.POST;
import static org.elasticsearch.script.Script.DEFAULT_SCRIPT_LANG;
public class RestUpdateByQueryAction extends AbstractBulkByQueryRestHandler<UpdateByQueryRequest, UpdateByQueryAction> {
public RestUpdateByQueryAction(RestController controller) {
public RestUpdateByQueryAction() {
super(UpdateByQueryAction.INSTANCE);
controller.registerHandler(POST, "/{index}/_update_by_query", this);
controller.registerHandler(POST, "/{index}/{type}/_update_by_query", this);
}
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(POST, "/{index}/_update_by_query"),
new Route(POST, "/{index}/{type}/_update_by_query")));
}
@Override

3
modules/reindex/src/test/java/org/elasticsearch/index/reindex/RestDeleteByQueryActionTests.java
View File

@ -35,7 +35,8 @@ public class RestDeleteByQueryActionTests extends RestActionTestCase {
@Before
public void setUpAction() {
action = new RestDeleteByQueryAction(controller());
action = new RestDeleteByQueryAction();
controller().registerHandler(action);
}
public void testTypeInPath() throws IOException {

3
modules/reindex/src/test/java/org/elasticsearch/index/reindex/RestReindexActionTests.java
View File

@ -40,7 +40,8 @@ public class RestReindexActionTests extends RestActionTestCase {
@Before
public void setUpAction() {
action = new RestReindexAction(controller());
action = new RestReindexAction();
controller().registerHandler(action);
}
public void testPipelineQueryParameterIsError() throws IOException {

3
modules/reindex/src/test/java/org/elasticsearch/index/reindex/RestUpdateByQueryActionTests.java
View File

@ -36,7 +36,8 @@ public class RestUpdateByQueryActionTests extends RestActionTestCase {
@Before
public void setUpAction() {
action = new RestUpdateByQueryAction(controller());
action = new RestUpdateByQueryAction();
controller().registerHandler(action);
}
public void testTypeInPath() throws IOException {

13
plugins/examples/rest-handler/src/main/java/org/elasticsearch/example/resthandler/ExampleCatAction.java
View File

@ -21,11 +21,14 @@ package org.elasticsearch.example.resthandler;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.Table;
import org.elasticsearch.rest.BytesRestResponse;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.cat.AbstractCatAction;
import org.elasticsearch.rest.action.cat.RestTable;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
import static org.elasticsearch.rest.RestRequest.Method.POST;
@ -34,9 +37,11 @@ import static org.elasticsearch.rest.RestRequest.Method.POST;
*/
public class ExampleCatAction extends AbstractCatAction {
ExampleCatAction(final RestController controller) {
controller.registerHandler(GET, "/_cat/example", this);
controller.registerHandler(POST, "/_cat/example", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_cat/example"),
new Route(POST, "/_cat/example")));
}
@Override

2
plugins/examples/rest-handler/src/main/java/org/elasticsearch/example/resthandler/ExampleRestHandlerPlugin.java
View File

@ -46,6 +46,6 @@ public class ExampleRestHandlerPlugin extends Plugin implements ActionPlugin {
final IndexNameExpressionResolver indexNameExpressionResolver,
final Supplier<DiscoveryNodes> nodesInCluster) {
return singletonList(new ExampleCatAction(restController));
return singletonList(new ExampleCatAction());
}
}

7
plugins/repository-s3/src/test/java/org/elasticsearch/repositories/s3/RepositoryCredentialsTests.java
View File

@ -26,8 +26,8 @@ import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.cluster.metadata.RepositoryMetaData;
import org.elasticsearch.common.SuppressForbidden;
import org.elasticsearch.cluster.service.ClusterService;
import org.elasticsearch.common.SuppressForbidden;
import org.elasticsearch.common.settings.MockSecureSettings;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.settings.SettingsFilter;
@ -36,7 +36,6 @@ import org.elasticsearch.plugins.Plugin;
import org.elasticsearch.plugins.PluginsService;
import org.elasticsearch.repositories.RepositoriesService;
import org.elasticsearch.rest.AbstractRestChannel;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.RestResponse;
import org.elasticsearch.rest.action.admin.cluster.RestGetRepositoriesAction;
@ -58,7 +57,6 @@ import static org.hamcrest.Matchers.instanceOf;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.not;
import static org.hamcrest.Matchers.notNullValue;
import static org.mockito.Mockito.mock;
@SuppressForbidden(reason = "test requires to set a System property to allow insecure settings when running in IDE")
public class RepositoryCredentialsTests extends ESSingleNodeTestCase {
@ -224,8 +222,7 @@ public class RepositoryCredentialsTests extends ESSingleNodeTestCase {
final RestRequest fakeRestRequest = new FakeRestRequest();
fakeRestRequest.params().put("repository", repositoryName);
final RestGetRepositoriesAction action =
new RestGetRepositoriesAction(mock(RestController.class), getInstanceFromNode(SettingsFilter.class));
final RestGetRepositoriesAction action = new RestGetRepositoriesAction(getInstanceFromNode(SettingsFilter.class));
final CountDownLatch latch = new CountDownLatch(1);
final AtomicReference<AssertionError> error = new AtomicReference<>();

2
qa/die-with-dignity/src/main/java/org/elasticsearch/DieWithDignityPlugin.java
View File

@ -49,7 +49,7 @@ public class DieWithDignityPlugin extends Plugin implements ActionPlugin {
final SettingsFilter settingsFilter,
final IndexNameExpressionResolver indexNameExpressionResolver,
final Supplier<DiscoveryNodes> nodesInCluster) {
return Collections.singletonList(new RestDieWithDignityAction(restController));
return Collections.singletonList(new RestDieWithDignityAction());
}
}

13
qa/die-with-dignity/src/main/java/org/elasticsearch/RestDieWithDignityAction.java
View File

@ -21,13 +21,20 @@ package org.elasticsearch;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import java.util.List;
import static java.util.Collections.singletonList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
public class RestDieWithDignityAction extends BaseRestHandler {
RestDieWithDignityAction(final RestController restController) {
restController.registerHandler(RestRequest.Method.GET, "/_die_with_dignity", this);
RestDieWithDignityAction() {}
@Override
public List<Route> routes() {
return singletonList(new Route(GET, "/_die_with_dignity"));
}
@Override

18
qa/smoke-test-http/src/test/java/org/elasticsearch/http/TestDeprecationHeaderRestAction.java
View File

@ -28,7 +28,6 @@ import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentParser;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.BytesRestResponse;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.RestStatus;
@ -38,6 +37,9 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static java.util.Collections.singletonList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
/**
* Enables testing {@code DeprecationRestHandler} via integration tests by guaranteeing a deprecated REST endpoint.
* <p>
@ -75,11 +77,14 @@ public class TestDeprecationHeaderRestAction extends BaseRestHandler {
private final Settings settings;
public TestDeprecationHeaderRestAction(Settings settings, RestController controller) {
public TestDeprecationHeaderRestAction(Settings settings) {
this.settings = settings;
}
controller.registerAsDeprecatedHandler(RestRequest.Method.GET, "/_test_cluster/deprecated_settings", this,
DEPRECATED_ENDPOINT, deprecationLogger);
@Override
public List<DeprecatedRoute> deprecatedRoutes() {
return singletonList(
new DeprecatedRoute(GET, "/_test_cluster/deprecated_settings", DEPRECATED_ENDPOINT, deprecationLogger));
}
@Override
@ -87,6 +92,11 @@ public class TestDeprecationHeaderRestAction extends BaseRestHandler {
return "test_deprecation_header_action";
}
@Override
public List<Route> routes() {
return Collections.emptyList();
}
@SuppressWarnings("unchecked") // List<String> casts
@Override
public RestChannelConsumer prepareRequest(RestRequest request, NodeClient client) throws IOException {

2
qa/smoke-test-http/src/test/java/org/elasticsearch/http/TestDeprecationPlugin.java
View File

@ -47,7 +47,7 @@ public class TestDeprecationPlugin extends Plugin implements ActionPlugin, Searc
public List<RestHandler> getRestHandlers(Settings settings, RestController restController, ClusterSettings clusterSettings,
IndexScopedSettings indexScopedSettings, SettingsFilter settingsFilter, IndexNameExpressionResolver indexNameExpressionResolver,
Supplier<DiscoveryNodes> nodesInCluster) {
return Collections.singletonList(new TestDeprecationHeaderRestAction(settings, restController));
return Collections.singletonList(new TestDeprecationHeaderRestAction(settings));
}
@Override

2
qa/smoke-test-http/src/test/java/org/elasticsearch/http/TestResponseHeaderPlugin.java
View File

@ -40,6 +40,6 @@ public class TestResponseHeaderPlugin extends Plugin implements ActionPlugin {
public List<RestHandler> getRestHandlers(Settings settings, RestController restController, ClusterSettings clusterSettings,
IndexScopedSettings indexScopedSettings, SettingsFilter settingsFilter, IndexNameExpressionResolver indexNameExpressionResolver,
Supplier<DiscoveryNodes> nodesInCluster) {
return singletonList(new TestResponseHeaderRestAction(restController));
return singletonList(new TestResponseHeaderRestAction());
}
}

11
qa/smoke-test-http/src/test/java/org/elasticsearch/http/TestResponseHeaderRestAction.java
View File

@ -21,15 +21,20 @@ package org.elasticsearch.http;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.BytesRestResponse;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.RestResponse;
import org.elasticsearch.rest.RestStatus;
import java.util.List;
import static java.util.Collections.singletonList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
public class TestResponseHeaderRestAction extends BaseRestHandler {
public TestResponseHeaderRestAction(RestController controller) {
controller.registerHandler(RestRequest.Method.GET, "/_protected", this);
@Override
public List<Route> routes() {
return singletonList(new Route(GET, "/_protected"));
}
@Override

231
server/src/main/java/org/elasticsearch/action/ActionModule.java
View File

@ -323,6 +323,8 @@ import org.elasticsearch.rest.action.document.RestDeleteAction;
import org.elasticsearch.rest.action.document.RestGetAction;
import org.elasticsearch.rest.action.document.RestGetSourceAction;
import org.elasticsearch.rest.action.document.RestIndexAction;
import org.elasticsearch.rest.action.document.RestIndexAction.AutoIdHandler;
import org.elasticsearch.rest.action.document.RestIndexAction.CreateHandler;
import org.elasticsearch.rest.action.document.RestMultiGetAction;
import org.elasticsearch.rest.action.document.RestMultiTermVectorsAction;
import org.elasticsearch.rest.action.document.RestTermVectorsAction;
@ -567,148 +569,151 @@ public class ActionModule extends AbstractModule {
public void initRestHandlers(Supplier<DiscoveryNodes> nodesInCluster) {
List<AbstractCatAction> catActions = new ArrayList<>();
Consumer<RestHandler> registerHandler = a -> {
if (a instanceof AbstractCatAction) {
catActions.add((AbstractCatAction) a);
Consumer<RestHandler> registerHandler = handler -> {
if (handler instanceof AbstractCatAction) {
catActions.add((AbstractCatAction) handler);
}
restController.registerHandler(handler);
};
registerHandler.accept(new RestAddVotingConfigExclusionAction(restController));
registerHandler.accept(new RestClearVotingConfigExclusionsAction(restController));
registerHandler.accept(new RestMainAction(restController));
registerHandler.accept(new RestNodesInfoAction(restController, settingsFilter));
registerHandler.accept(new RestRemoteClusterInfoAction(restController));
registerHandler.accept(new RestNodesStatsAction(restController));
registerHandler.accept(new RestNodesUsageAction(restController));
registerHandler.accept(new RestNodesHotThreadsAction(restController));
registerHandler.accept(new RestClusterAllocationExplainAction(restController));
registerHandler.accept(new RestClusterStatsAction(restController));
registerHandler.accept(new RestClusterStateAction(restController, settingsFilter));
registerHandler.accept(new RestClusterHealthAction(restController));
registerHandler.accept(new RestClusterUpdateSettingsAction(restController));
registerHandler.accept(new RestClusterGetSettingsAction(settings, restController, clusterSettings, settingsFilter));
registerHandler.accept(new RestClusterRerouteAction(restController, settingsFilter));
registerHandler.accept(new RestClusterSearchShardsAction(restController));
registerHandler.accept(new RestPendingClusterTasksAction(restController));
registerHandler.accept(new RestPutRepositoryAction(restController));
registerHandler.accept(new RestGetRepositoriesAction(restController, settingsFilter));
registerHandler.accept(new RestDeleteRepositoryAction(restController));
registerHandler.accept(new RestVerifyRepositoryAction(restController));
registerHandler.accept(new RestCleanupRepositoryAction(restController));
registerHandler.accept(new RestGetSnapshotsAction(restController));
registerHandler.accept(new RestCreateSnapshotAction(restController));
registerHandler.accept(new RestRestoreSnapshotAction(restController));
registerHandler.accept(new RestDeleteSnapshotAction(restController));
registerHandler.accept(new RestSnapshotsStatusAction(restController));
registerHandler.accept(new RestGetIndicesAction(restController));
registerHandler.accept(new RestIndicesStatsAction(restController));
registerHandler.accept(new RestIndicesSegmentsAction(restController));
registerHandler.accept(new RestIndicesShardStoresAction(restController));
registerHandler.accept(new RestGetAliasesAction(restController));
registerHandler.accept(new RestIndexDeleteAliasesAction(restController));
registerHandler.accept(new RestIndexPutAliasAction(restController));
registerHandler.accept(new RestIndicesAliasesAction(restController));
registerHandler.accept(new RestCreateIndexAction(restController));
registerHandler.accept(new RestResizeHandler.RestShrinkIndexAction(restController));
registerHandler.accept(new RestResizeHandler.RestSplitIndexAction(restController));
registerHandler.accept(new RestResizeHandler.RestCloneIndexAction(restController));
registerHandler.accept(new RestRolloverIndexAction(restController));
registerHandler.accept(new RestDeleteIndexAction(restController));
registerHandler.accept(new RestCloseIndexAction(restController));
registerHandler.accept(new RestOpenIndexAction(restController));
registerHandler.accept(new RestAddVotingConfigExclusionAction());
registerHandler.accept(new RestClearVotingConfigExclusionsAction());
registerHandler.accept(new RestMainAction());
registerHandler.accept(new RestNodesInfoAction(settingsFilter));
registerHandler.accept(new RestRemoteClusterInfoAction());
registerHandler.accept(new RestNodesStatsAction());
registerHandler.accept(new RestNodesUsageAction());
registerHandler.accept(new RestNodesHotThreadsAction());
registerHandler.accept(new RestClusterAllocationExplainAction());
registerHandler.accept(new RestClusterStatsAction());
registerHandler.accept(new RestClusterStateAction(settingsFilter));
registerHandler.accept(new RestClusterHealthAction());
registerHandler.accept(new RestClusterUpdateSettingsAction());
registerHandler.accept(new RestClusterGetSettingsAction(settings, clusterSettings, settingsFilter));
registerHandler.accept(new RestClusterRerouteAction(settingsFilter));
registerHandler.accept(new RestClusterSearchShardsAction());
registerHandler.accept(new RestPendingClusterTasksAction());
registerHandler.accept(new RestPutRepositoryAction());
registerHandler.accept(new RestGetRepositoriesAction(settingsFilter));
registerHandler.accept(new RestDeleteRepositoryAction());
registerHandler.accept(new RestVerifyRepositoryAction());
registerHandler.accept(new RestCleanupRepositoryAction());
registerHandler.accept(new RestGetSnapshotsAction());
registerHandler.accept(new RestCreateSnapshotAction());
registerHandler.accept(new RestRestoreSnapshotAction());
registerHandler.accept(new RestDeleteSnapshotAction());
registerHandler.accept(new RestSnapshotsStatusAction());
registerHandler.accept(new RestGetIndicesAction());
registerHandler.accept(new RestIndicesStatsAction());
registerHandler.accept(new RestIndicesSegmentsAction());
registerHandler.accept(new RestIndicesShardStoresAction());
registerHandler.accept(new RestGetAliasesAction());
registerHandler.accept(new RestIndexDeleteAliasesAction());
registerHandler.accept(new RestIndexPutAliasAction());
registerHandler.accept(new RestIndicesAliasesAction());
registerHandler.accept(new RestCreateIndexAction());
registerHandler.accept(new RestResizeHandler.RestShrinkIndexAction());
registerHandler.accept(new RestResizeHandler.RestSplitIndexAction());
registerHandler.accept(new RestResizeHandler.RestCloneIndexAction());
registerHandler.accept(new RestRolloverIndexAction());
registerHandler.accept(new RestDeleteIndexAction());
registerHandler.accept(new RestCloseIndexAction());
registerHandler.accept(new RestOpenIndexAction());
registerHandler.accept(new RestUpdateSettingsAction(restController));
registerHandler.accept(new RestGetSettingsAction(restController));
registerHandler.accept(new RestUpdateSettingsAction());
registerHandler.accept(new RestGetSettingsAction());
registerHandler.accept(new RestAnalyzeAction(restController));
registerHandler.accept(new RestGetIndexTemplateAction(restController));
registerHandler.accept(new RestPutIndexTemplateAction(restController));
registerHandler.accept(new RestDeleteIndexTemplateAction(restController));
registerHandler.accept(new RestAnalyzeAction());
registerHandler.accept(new RestGetIndexTemplateAction());
registerHandler.accept(new RestPutIndexTemplateAction());
registerHandler.accept(new RestDeleteIndexTemplateAction());
registerHandler.accept(new RestPutMappingAction(restController));
registerHandler.accept(new RestGetMappingAction(restController));
registerHandler.accept(new RestGetFieldMappingAction(restController));
registerHandler.accept(new RestPutMappingAction());
registerHandler.accept(new RestGetMappingAction());
registerHandler.accept(new RestGetFieldMappingAction());
registerHandler.accept(new RestRefreshAction(restController));
registerHandler.accept(new RestFlushAction(restController));
registerHandler.accept(new RestSyncedFlushAction(restController));
registerHandler.accept(new RestForceMergeAction(restController));
registerHandler.accept(new RestUpgradeAction(restController));
registerHandler.accept(new RestUpgradeStatusAction(restController));
registerHandler.accept(new RestClearIndicesCacheAction(restController));
registerHandler.accept(new RestRefreshAction());
registerHandler.accept(new RestFlushAction());
registerHandler.accept(new RestSyncedFlushAction());
registerHandler.accept(new RestForceMergeAction());
registerHandler.accept(new RestUpgradeAction());
registerHandler.accept(new RestUpgradeStatusAction());
registerHandler.accept(new RestClearIndicesCacheAction());
registerHandler.accept(new RestIndexAction(restController, clusterService));
registerHandler.accept(new RestGetAction(restController));
registerHandler.accept(new RestGetSourceAction(restController));
registerHandler.accept(new RestMultiGetAction(settings, restController));
registerHandler.accept(new RestDeleteAction(restController));
registerHandler.accept(new RestCountAction(restController));
registerHandler.accept(new RestTermVectorsAction(restController));
registerHandler.accept(new RestMultiTermVectorsAction(restController));
registerHandler.accept(new RestBulkAction(settings, restController));
registerHandler.accept(new RestUpdateAction(restController));
registerHandler.accept(new RestIndexAction());
registerHandler.accept(new CreateHandler());
registerHandler.accept(new AutoIdHandler(clusterService));
registerHandler.accept(new RestGetAction());
registerHandler.accept(new RestGetSourceAction());
registerHandler.accept(new RestMultiGetAction(settings));
registerHandler.accept(new RestDeleteAction());
registerHandler.accept(new RestCountAction());
registerHandler.accept(new RestTermVectorsAction());
registerHandler.accept(new RestMultiTermVectorsAction());
registerHandler.accept(new RestBulkAction(settings));
registerHandler.accept(new RestUpdateAction());
registerHandler.accept(new RestSearchAction(restController));
registerHandler.accept(new RestSearchScrollAction(restController));
registerHandler.accept(new RestClearScrollAction(restController));
registerHandler.accept(new RestMultiSearchAction(settings, restController));
registerHandler.accept(new RestSearchAction());
registerHandler.accept(new RestSearchScrollAction());
registerHandler.accept(new RestClearScrollAction());
registerHandler.accept(new RestMultiSearchAction(settings));
registerHandler.accept(new RestValidateQueryAction(restController));
registerHandler.accept(new RestValidateQueryAction());
registerHandler.accept(new RestExplainAction(restController));
registerHandler.accept(new RestExplainAction());
registerHandler.accept(new RestRecoveryAction(restController));
registerHandler.accept(new RestRecoveryAction());
registerHandler.accept(new RestReloadSecureSettingsAction(restController));
registerHandler.accept(new RestReloadSecureSettingsAction());
// Scripts API
registerHandler.accept(new RestGetStoredScriptAction(restController));
registerHandler.accept(new RestPutStoredScriptAction(restController));
registerHandler.accept(new RestDeleteStoredScriptAction(restController));
registerHandler.accept(new RestGetScriptContextAction(restController));
registerHandler.accept(new RestGetScriptLanguageAction(restController));
registerHandler.accept(new RestGetStoredScriptAction());
registerHandler.accept(new RestPutStoredScriptAction());
registerHandler.accept(new RestDeleteStoredScriptAction());
registerHandler.accept(new RestGetScriptContextAction());
registerHandler.accept(new RestGetScriptLanguageAction());
registerHandler.accept(new RestFieldCapabilitiesAction(restController));
registerHandler.accept(new RestFieldCapabilitiesAction());
// Tasks API
registerHandler.accept(new RestListTasksAction(restController, nodesInCluster));
registerHandler.accept(new RestGetTaskAction(restController));
registerHandler.accept(new RestCancelTasksAction(restController, nodesInCluster));
registerHandler.accept(new RestListTasksAction(nodesInCluster));
registerHandler.accept(new RestGetTaskAction());
registerHandler.accept(new RestCancelTasksAction(nodesInCluster));
// Ingest API
registerHandler.accept(new RestPutPipelineAction(restController));
registerHandler.accept(new RestGetPipelineAction(restController));
registerHandler.accept(new RestDeletePipelineAction(restController));
registerHandler.accept(new RestSimulatePipelineAction(restController));
registerHandler.accept(new RestPutPipelineAction());
registerHandler.accept(new RestGetPipelineAction());
registerHandler.accept(new RestDeletePipelineAction());
registerHandler.accept(new RestSimulatePipelineAction());
// CAT API
registerHandler.accept(new RestAllocationAction(restController));
registerHandler.accept(new RestShardsAction(restController));
registerHandler.accept(new RestMasterAction(restController));
registerHandler.accept(new RestNodesAction(restController));
registerHandler.accept(new RestTasksAction(restController, nodesInCluster));
registerHandler.accept(new RestIndicesAction(restController));
registerHandler.accept(new RestSegmentsAction(restController));
registerHandler.accept(new RestAllocationAction());
registerHandler.accept(new RestShardsAction());
registerHandler.accept(new RestMasterAction());
registerHandler.accept(new RestNodesAction());
registerHandler.accept(new RestTasksAction(nodesInCluster));
registerHandler.accept(new RestIndicesAction());
registerHandler.accept(new RestSegmentsAction());
// Fully qualified to prevent interference with rest.action.count.RestCountAction
registerHandler.accept(new org.elasticsearch.rest.action.cat.RestCountAction(restController));
registerHandler.accept(new org.elasticsearch.rest.action.cat.RestCountAction());
// Fully qualified to prevent interference with rest.action.indices.RestRecoveryAction
registerHandler.accept(new RestCatRecoveryAction(restController));
registerHandler.accept(new RestHealthAction(restController));
registerHandler.accept(new org.elasticsearch.rest.action.cat.RestPendingClusterTasksAction(restController));
registerHandler.accept(new RestAliasAction(restController));
registerHandler.accept(new RestThreadPoolAction(restController));
registerHandler.accept(new RestPluginsAction(restController));
registerHandler.accept(new RestFielddataAction(restController));
registerHandler.accept(new RestNodeAttrsAction(restController));
registerHandler.accept(new RestRepositoriesAction(restController));
registerHandler.accept(new RestSnapshotAction(restController));
registerHandler.accept(new RestTemplatesAction(restController));
registerHandler.accept(new RestCatRecoveryAction());
registerHandler.accept(new RestHealthAction());
registerHandler.accept(new org.elasticsearch.rest.action.cat.RestPendingClusterTasksAction());
registerHandler.accept(new RestAliasAction());
registerHandler.accept(new RestThreadPoolAction());
registerHandler.accept(new RestPluginsAction());
registerHandler.accept(new RestFielddataAction());
registerHandler.accept(new RestNodeAttrsAction());
registerHandler.accept(new RestRepositoriesAction());
registerHandler.accept(new RestSnapshotAction());
registerHandler.accept(new RestTemplatesAction());
for (ActionPlugin plugin : actionPlugins) {
for (RestHandler handler : plugin.getRestHandlers(settings, restController, clusterSettings, indexScopedSettings,
settingsFilter, indexNameExpressionResolver, nodesInCluster)) {
registerHandler.accept(handler);
}
}
registerHandler.accept(new RestCatAction(restController, catActions));
registerHandler.accept(new RestCatAction(catActions));
}
@Override

2
server/src/main/java/org/elasticsearch/common/collect/MapBuilder.java
View File

@ -34,7 +34,7 @@ public class MapBuilder<K, V> {
return new MapBuilder<>(map);
}
private Map<K, V> map = new HashMap<>();
private final Map<K, V> map;
public MapBuilder() {
this.map = new HashMap<>();

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

@ -18,6 +18,7 @@
*/
package org.elasticsearch.rest;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.lucene.search.spell.LevenshteinDistance;
@ -81,6 +82,12 @@ public abstract class BaseRestHandler implements RestHandler {
*/
public abstract String getName();
/**
* {@inheritDoc}
*/
@Override
public abstract List<Route> routes();
@Override
public final void handleRequest(RestRequest request, RestChannel channel, NodeClient client) throws Exception {
// prepare the request for execution; has the side effect of touching the request parameters

18
server/src/main/java/org/elasticsearch/rest/RestController.java
View File

@ -98,7 +98,7 @@ public class RestController implements HttpServerTransport.Dispatcher {
* @param deprecationMessage The message to log and send as a header in the response
* @param logger The existing deprecation logger to use
*/
public void registerAsDeprecatedHandler(RestRequest.Method method, String path, RestHandler handler,
protected void registerAsDeprecatedHandler(RestRequest.Method method, String path, RestHandler handler,
String deprecationMessage, DeprecationLogger logger) {
assert (handler instanceof DeprecationRestHandler) == false;
@ -130,7 +130,7 @@ public class RestController implements HttpServerTransport.Dispatcher {
* @param deprecatedPath <em>Deprecated</em> path to handle (e.g., "/_optimize")
* @param logger The existing deprecation logger to use
*/
public void registerWithDeprecatedHandler(RestRequest.Method method, String path, RestHandler handler,
protected void registerWithDeprecatedHandler(RestRequest.Method method, String path, RestHandler handler,
RestRequest.Method deprecatedMethod, String deprecatedPath,
DeprecationLogger logger) {
// e.g., [POST /_optimize] is deprecated! Use [POST /_forcemerge] instead.
@ -148,7 +148,7 @@ public class RestController implements HttpServerTransport.Dispatcher {
* @param handler The handler to actually execute
* @param method GET, POST, etc.
*/
public void registerHandler(RestRequest.Method method, String path, RestHandler handler) {
protected void registerHandler(RestRequest.Method method, String path, RestHandler handler) {
if (handler instanceof BaseRestHandler) {
usageService.addRestHandler((BaseRestHandler) handler);
}
@ -157,6 +157,18 @@ public class RestController implements HttpServerTransport.Dispatcher {
(mHandlers, newMHandler) -> mHandlers.addMethods(maybeWrappedHandler, method));
}
/**
* Registers a REST handler with the controller. The REST handler declares the {@code method}
* and {@code path} combinations.
*/
public void registerHandler(final RestHandler restHandler) {
restHandler.routes().forEach(route -> registerHandler(route.getMethod(), route.getPath(), restHandler));
restHandler.deprecatedRoutes().forEach(route ->
registerAsDeprecatedHandler(route.getMethod(), route.getPath(), restHandler, route.getDeprecationMessage(), route.getLogger()));
restHandler.replacedRoutes().forEach(route -> registerWithDeprecatedHandler(route.getMethod(), route.getPath(),
restHandler, route.getDeprecatedMethod(), route.getDeprecatedPath(), route.getLogger()));
}
@Override
public void dispatchRequest(RestRequest request, RestChannel channel, ThreadContext threadContext) {
if (request.rawPath().equals("/favicon.ico")) {

102
server/src/main/java/org/elasticsearch/rest/RestHandler.java
View File

@ -20,7 +20,12 @@
package org.elasticsearch.rest;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.logging.DeprecationLogger;
import org.elasticsearch.common.xcontent.XContent;
import org.elasticsearch.rest.RestRequest.Method;
import java.util.Collections;
import java.util.List;
/**
* Handler for REST requests
@ -59,4 +64,101 @@ public interface RestHandler {
default boolean allowsUnsafeBuffers() {
return false;
}
/**
* The list of {@link Route}s that this RestHandler is responsible for handling.
*/
default List<Route> routes() {
return Collections.emptyList();
}
/**
* A list of routes handled by this RestHandler that are deprecated and do not have a direct
* replacement. If changing the {@code path} or {@code method} of a route,
* use {@link #replacedRoutes()}.
*/
default List<DeprecatedRoute> deprecatedRoutes() {
return Collections.emptyList();
}
/**
* A list of routes handled by this RestHandler that have had their {@code path} and/or
* {@code method} changed. The pre-existing {@code route} will be registered
* as deprecated alongside the updated {@code route}.
*/
default List<ReplacedRoute> replacedRoutes() {
return Collections.emptyList();
}
class Route {
private final String path;
private final Method method;
public Route(Method method, String path) {
this.path = path;
this.method = method;
}
public String getPath() {
return path;
}
public Method getMethod() {
return method;
}
}
/**
* Represents an API that has been deprecated and is slated for removal.
*/
class DeprecatedRoute extends Route {
private final String deprecationMessage;
private final DeprecationLogger logger;
public DeprecatedRoute(Method method, String path, String deprecationMessage, DeprecationLogger logger) {
super(method, path);
this.deprecationMessage = deprecationMessage;
this.logger = logger;
}
public String getDeprecationMessage() {
return deprecationMessage;
}
public DeprecationLogger getLogger() {
return logger;
}
}
/**
* Represents an API that has had its {@code path} or {@code method} changed. Holds both the
* new and previous {@code path} and {@code method} combination.
*/
class ReplacedRoute extends Route {
private final String deprecatedPath;
private final Method deprecatedMethod;
private final DeprecationLogger logger;
public ReplacedRoute(Method method, String path, Method deprecatedMethod, String deprecatedPath, DeprecationLogger logger) {
super(method, path);
this.deprecatedMethod = deprecatedMethod;
this.deprecatedPath = deprecatedPath;
this.logger = logger;
}
public String getDeprecatedPath() {
return deprecatedPath;
}
public Method getDeprecatedMethod() {
return deprecatedMethod;
}
public DeprecationLogger getLogger() {
return logger;
}
}
}

16
server/src/main/java/org/elasticsearch/rest/action/RestFieldCapabilitiesAction.java
View File

@ -24,21 +24,25 @@ import org.elasticsearch.action.support.IndicesOptions;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.Strings;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import java.io.IOException;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
import static org.elasticsearch.rest.RestRequest.Method.POST;
public class RestFieldCapabilitiesAction extends BaseRestHandler {
public RestFieldCapabilitiesAction(RestController controller) {
controller.registerHandler(GET, "/_field_caps", this);
controller.registerHandler(POST, "/_field_caps", this);
controller.registerHandler(GET, "/{index}/_field_caps", this);
controller.registerHandler(POST, "/{index}/_field_caps", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_field_caps"),
new Route(POST, "/_field_caps"),
new Route(GET, "/{index}/_field_caps"),
new Route(POST, "/{index}/_field_caps")));
}
@Override

13
server/src/main/java/org/elasticsearch/rest/action/RestMainAction.java
View File

@ -26,20 +26,25 @@ import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.BytesRestResponse;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.RestResponse;
import org.elasticsearch.rest.RestStatus;
import java.io.IOException;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
import static org.elasticsearch.rest.RestRequest.Method.HEAD;
public class RestMainAction extends BaseRestHandler {
public RestMainAction(RestController controller) {
controller.registerHandler(GET, "/", this);
controller.registerHandler(HEAD, "/", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/"),
new Route(HEAD, "/")));
}
@Override

14
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestAddVotingConfigExclusionAction.java
View File

@ -25,25 +25,29 @@ import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.Strings;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Collections.singletonList;
import static org.elasticsearch.rest.RestRequest.Method.POST;
public class RestAddVotingConfigExclusionAction extends BaseRestHandler {
private static final TimeValue DEFAULT_TIMEOUT = TimeValue.timeValueSeconds(30L);
public RestAddVotingConfigExclusionAction(RestController controller) {
controller.registerHandler(RestRequest.Method.POST, "/_cluster/voting_config_exclusions/{node_name}", this);
}
@Override
public String getName() {
return "add_voting_config_exclusions_action";
}
@Override
public List<Route> routes() {
return singletonList(new Route(POST, "/_cluster/voting_config_exclusions/{node_name}"));
}
@Override
protected RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
AddVotingConfigExclusionsRequest votingConfigExclusionsRequest = resolveVotingConfigExclusionsRequest(request);

14
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestCancelTasksAction.java
View File

@ -24,13 +24,15 @@ import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.cluster.node.DiscoveryNodes;
import org.elasticsearch.common.Strings;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.tasks.TaskId;
import java.io.IOException;
import java.util.List;
import java.util.function.Supplier;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.POST;
import static org.elasticsearch.rest.action.admin.cluster.RestListTasksAction.listTasksResponseListener;
@ -38,10 +40,8 @@ import static org.elasticsearch.rest.action.admin.cluster.RestListTasksAction.li
public class RestCancelTasksAction extends BaseRestHandler {
private final Supplier<DiscoveryNodes> nodesInCluster;
public RestCancelTasksAction(RestController controller, Supplier<DiscoveryNodes> nodesInCluster) {
public RestCancelTasksAction(Supplier<DiscoveryNodes> nodesInCluster) {
this.nodesInCluster = nodesInCluster;
controller.registerHandler(POST, "/_tasks/_cancel", this);
controller.registerHandler(POST, "/_tasks/{task_id}/_cancel", this);
}
@Override
@ -49,6 +49,12 @@ public class RestCancelTasksAction extends BaseRestHandler {
return "cancel_tasks_action";
}
@Override
public List<Route> routes() {
return unmodifiableList(asList(new Route(POST, "/_tasks/_cancel"),
new Route(POST, "/_tasks/{task_id}/_cancel")));
}
@Override
public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
final String[] nodesIds = Strings.splitStringByCommaToArray(request.param("nodes"));

8
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestCleanupRepositoryAction.java
View File

@ -22,12 +22,13 @@ package org.elasticsearch.rest.action.admin.cluster;
import org.elasticsearch.action.admin.cluster.repositories.cleanup.CleanupRepositoryRequest;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Collections.singletonList;
import static org.elasticsearch.client.Requests.cleanupRepositoryRequest;
import static org.elasticsearch.rest.RestRequest.Method.POST;
@ -36,8 +37,9 @@ import static org.elasticsearch.rest.RestRequest.Method.POST;
*/
public class RestCleanupRepositoryAction extends BaseRestHandler {
public RestCleanupRepositoryAction(RestController controller) {
controller.registerHandler(POST, "/_snapshot/{repository}/_cleanup", this);
@Override
public List<Route> routes() {
return singletonList(new Route(POST, "/_snapshot/{repository}/_cleanup"));
}
@Override

10
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestClearVotingConfigExclusionsAction.java
View File

@ -23,16 +23,20 @@ import org.elasticsearch.action.admin.cluster.configuration.ClearVotingConfigExc
import org.elasticsearch.action.admin.cluster.configuration.ClearVotingConfigExclusionsRequest;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Collections.singletonList;
import static org.elasticsearch.rest.RestRequest.Method.DELETE;
public class RestClearVotingConfigExclusionsAction extends BaseRestHandler {
public RestClearVotingConfigExclusionsAction(RestController controller) {
controller.registerHandler(RestRequest.Method.DELETE, "/_cluster/voting_config_exclusions", this);
@Override
public List<Route> routes() {
return singletonList(new Route(DELETE, "/_cluster/voting_config_exclusions"));
}
@Override

15
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestClusterAllocationExplainAction.java
View File

@ -27,22 +27,29 @@ import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentParser;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.BytesRestResponse;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.RestResponse;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.rest.action.RestBuilderListener;
import java.io.IOException;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
import static org.elasticsearch.rest.RestRequest.Method.POST;
/**
* Class handling cluster allocation explanation at the REST level
*/
public class RestClusterAllocationExplainAction extends BaseRestHandler {
public RestClusterAllocationExplainAction(RestController controller) {
controller.registerHandler(RestRequest.Method.GET, "/_cluster/allocation/explain", this);
controller.registerHandler(RestRequest.Method.POST, "/_cluster/allocation/explain", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_cluster/allocation/explain"),
new Route(POST, "/_cluster/allocation/explain")));
}
@Override

13
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestClusterGetSettingsAction.java
View File

@ -32,29 +32,34 @@ import org.elasticsearch.common.xcontent.ToXContent;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.BytesRestResponse;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.RestResponse;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.rest.action.RestBuilderListener;
import java.io.IOException;
import java.util.List;
import java.util.Set;
import static java.util.Collections.singletonList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
public class RestClusterGetSettingsAction extends BaseRestHandler {
private final Settings settings;
private final ClusterSettings clusterSettings;
private final SettingsFilter settingsFilter;
public RestClusterGetSettingsAction(Settings settings, RestController controller, ClusterSettings clusterSettings,
SettingsFilter settingsFilter) {
public RestClusterGetSettingsAction(Settings settings, ClusterSettings clusterSettings, SettingsFilter settingsFilter) {
this.settings = settings;
this.clusterSettings = clusterSettings;
controller.registerHandler(RestRequest.Method.GET, "/_cluster/settings", this);
this.settingsFilter = settingsFilter;
}
@Override
public List<Route> routes() {
return singletonList(new Route(GET, "/_cluster/settings"));
}
@Override
public String getName() {
return "cluster_get_settings_action";

12
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestClusterHealthAction.java
View File

@ -27,22 +27,26 @@ import org.elasticsearch.cluster.health.ClusterHealthStatus;
import org.elasticsearch.common.Priority;
import org.elasticsearch.common.Strings;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestStatusToXContentListener;
import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.Locale;
import java.util.Set;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.client.Requests.clusterHealthRequest;
import static org.elasticsearch.rest.RestRequest.Method.GET;
public class RestClusterHealthAction extends BaseRestHandler {
public RestClusterHealthAction(RestController controller) {
controller.registerHandler(RestRequest.Method.GET, "/_cluster/health", this);
controller.registerHandler(RestRequest.Method.GET, "/_cluster/health/{index}", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(new Route(GET, "/_cluster/health"),
new Route(GET, "/_cluster/health/{index}")));
}
@Override

13
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestClusterRerouteAction.java
View File

@ -31,7 +31,6 @@ import org.elasticsearch.common.settings.SettingsFilter;
import org.elasticsearch.common.xcontent.ObjectParser;
import org.elasticsearch.common.xcontent.ObjectParser.ValueType;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
@ -39,8 +38,12 @@ import java.io.IOException;
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import static java.util.Collections.singletonList;
import static org.elasticsearch.rest.RestRequest.Method.POST;
public class RestClusterRerouteAction extends BaseRestHandler {
private static final ObjectParser<ClusterRerouteRequest, Void> PARSER = new ObjectParser<>("cluster_reroute");
static {
@ -54,9 +57,13 @@ public class RestClusterRerouteAction extends BaseRestHandler {
private final SettingsFilter settingsFilter;
public RestClusterRerouteAction(RestController controller, SettingsFilter settingsFilter) {
public RestClusterRerouteAction(SettingsFilter settingsFilter) {
this.settingsFilter = settingsFilter;
controller.registerHandler(RestRequest.Method.POST, "/_cluster/reroute", this);
}
@Override
public List<Route> routes() {
return singletonList(new Route(POST, "/_cluster/reroute"));
}
@Override

16
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestClusterSearchShardsAction.java
View File

@ -25,22 +25,26 @@ import org.elasticsearch.client.Requests;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.Strings;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
import static org.elasticsearch.rest.RestRequest.Method.POST;
public class RestClusterSearchShardsAction extends BaseRestHandler {
public RestClusterSearchShardsAction(RestController controller) {
controller.registerHandler(GET, "/_search_shards", this);
controller.registerHandler(POST, "/_search_shards", this);
controller.registerHandler(GET, "/{index}/_search_shards", this);
controller.registerHandler(POST, "/{index}/_search_shards", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_search_shards"),
new Route(POST, "/_search_shards"),
new Route(GET, "/{index}/_search_shards"),
new Route(POST, "/{index}/_search_shards")));
}
@Override

20
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestClusterStateAction.java
View File

@ -31,7 +31,6 @@ import org.elasticsearch.common.settings.SettingsFilter;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.BytesRestResponse;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.RestResponse;
import org.elasticsearch.rest.RestStatus;
@ -41,17 +40,18 @@ import java.io.IOException;
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
public class RestClusterStateAction extends BaseRestHandler {
private final SettingsFilter settingsFilter;
public RestClusterStateAction(RestController controller, SettingsFilter settingsFilter) {
controller.registerHandler(RestRequest.Method.GET, "/_cluster/state", this);
controller.registerHandler(RestRequest.Method.GET, "/_cluster/state/{metric}", this);
controller.registerHandler(RestRequest.Method.GET, "/_cluster/state/{metric}/{indices}", this);
public RestClusterStateAction(SettingsFilter settingsFilter) {
this.settingsFilter = settingsFilter;
}
@ -60,6 +60,14 @@ public class RestClusterStateAction extends BaseRestHandler {
return "cluster_state_action";
}
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_cluster/state"),
new Route(GET, "/_cluster/state/{metric}"),
new Route(GET, "/_cluster/state/{metric}/{indices}")));
}
@Override
public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
final ClusterStateRequest clusterStateRequest = Requests.clusterStateRequest();

14
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestClusterStatsAction.java
View File

@ -22,17 +22,23 @@ package org.elasticsearch.rest.action.admin.cluster;
import org.elasticsearch.action.admin.cluster.stats.ClusterStatsRequest;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestActions.NodesResponseRestListener;
import java.io.IOException;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
public class RestClusterStatsAction extends BaseRestHandler {
public RestClusterStatsAction(RestController controller) {
controller.registerHandler(RestRequest.Method.GET, "/_cluster/stats", this);
controller.registerHandler(RestRequest.Method.GET, "/_cluster/stats/nodes/{nodeId}", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_cluster/stats"),
new Route(GET, "/_cluster/stats/nodes/{nodeId}")));
}
@Override

10
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestClusterUpdateSettingsAction.java
View File

@ -25,21 +25,25 @@ import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.xcontent.XContentParser;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.Set;
import static java.util.Collections.singletonList;
import static org.elasticsearch.rest.RestRequest.Method.PUT;
public class RestClusterUpdateSettingsAction extends BaseRestHandler {
private static final String PERSISTENT = "persistent";
private static final String TRANSIENT = "transient";
public RestClusterUpdateSettingsAction(RestController controller) {
controller.registerHandler(RestRequest.Method.PUT, "/_cluster/settings", this);
@Override
public List<Route> routes() {
return singletonList(new Route(PUT, "/_cluster/settings"));
}
@Override

12
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestCreateSnapshotAction.java
View File

@ -22,12 +22,14 @@ package org.elasticsearch.rest.action.admin.cluster;
import org.elasticsearch.action.admin.cluster.snapshots.create.CreateSnapshotRequest;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.client.Requests.createSnapshotRequest;
import static org.elasticsearch.rest.RestRequest.Method.POST;
import static org.elasticsearch.rest.RestRequest.Method.PUT;
@ -37,9 +39,11 @@ import static org.elasticsearch.rest.RestRequest.Method.PUT;
*/
public class RestCreateSnapshotAction extends BaseRestHandler {
public RestCreateSnapshotAction(RestController controller) {
controller.registerHandler(PUT, "/_snapshot/{repository}/{snapshot}", this);
controller.registerHandler(POST, "/_snapshot/{repository}/{snapshot}", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(PUT, "/_snapshot/{repository}/{snapshot}"),
new Route(POST, "/_snapshot/{repository}/{snapshot}")));
}
@Override

8
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestDeleteRepositoryAction.java
View File

@ -22,12 +22,13 @@ package org.elasticsearch.rest.action.admin.cluster;
import org.elasticsearch.action.admin.cluster.repositories.delete.DeleteRepositoryRequest;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Collections.singletonList;
import static org.elasticsearch.client.Requests.deleteRepositoryRequest;
import static org.elasticsearch.rest.RestRequest.Method.DELETE;
@ -36,8 +37,9 @@ import static org.elasticsearch.rest.RestRequest.Method.DELETE;
*/
public class RestDeleteRepositoryAction extends BaseRestHandler {
public RestDeleteRepositoryAction(RestController controller) {
controller.registerHandler(DELETE, "/_snapshot/{repository}", this);
@Override
public List<Route> routes() {
return singletonList(new Route(DELETE, "/_snapshot/{repository}"));
}
@Override

8
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestDeleteSnapshotAction.java
View File

@ -22,12 +22,13 @@ package org.elasticsearch.rest.action.admin.cluster;
import org.elasticsearch.action.admin.cluster.snapshots.delete.DeleteSnapshotRequest;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Collections.singletonList;
import static org.elasticsearch.client.Requests.deleteSnapshotRequest;
import static org.elasticsearch.rest.RestRequest.Method.DELETE;
@ -36,8 +37,9 @@ import static org.elasticsearch.rest.RestRequest.Method.DELETE;
*/
public class RestDeleteSnapshotAction extends BaseRestHandler {
public RestDeleteSnapshotAction(RestController controller) {
controller.registerHandler(DELETE, "/_snapshot/{repository}/{snapshot}", this);
@Override
public List<Route> routes() {
return singletonList(new Route(DELETE, "/_snapshot/{repository}/{snapshot}"));
}
@Override

8
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestDeleteStoredScriptAction.java
View File

@ -21,18 +21,20 @@ package org.elasticsearch.rest.action.admin.cluster;
import org.elasticsearch.action.admin.cluster.storedscripts.DeleteStoredScriptRequest;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Collections.singletonList;
import static org.elasticsearch.rest.RestRequest.Method.DELETE;
public class RestDeleteStoredScriptAction extends BaseRestHandler {
public RestDeleteStoredScriptAction(RestController controller) {
controller.registerHandler(DELETE, "/_scripts/{id}", this);
@Override
public List<Route> routes() {
return singletonList(new Route(DELETE, "/_scripts/{id}"));
}
@Override

15
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestGetRepositoriesAction.java
View File

@ -25,13 +25,15 @@ import org.elasticsearch.common.Strings;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.settings.SettingsFilter;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import java.util.Set;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.client.Requests.getRepositoryRequest;
import static org.elasticsearch.rest.RestRequest.Method.GET;
@ -42,9 +44,7 @@ public class RestGetRepositoriesAction extends BaseRestHandler {
private final SettingsFilter settingsFilter;
public RestGetRepositoriesAction(RestController controller, SettingsFilter settingsFilter) {
controller.registerHandler(GET, "/_snapshot", this);
controller.registerHandler(GET, "/_snapshot/{repository}", this);
public RestGetRepositoriesAction(SettingsFilter settingsFilter) {
this.settingsFilter = settingsFilter;
}
@ -53,6 +53,13 @@ public class RestGetRepositoriesAction extends BaseRestHandler {
return "get_repositories_action";
}
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_snapshot"),
new Route(GET, "/_snapshot/{repository}")));
}
@Override
public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
final String[] repositories = request.paramAsStringArray("repository", Strings.EMPTY_ARRAY);

11
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestGetScriptContextAction.java
View File

@ -22,20 +22,21 @@ package org.elasticsearch.rest.action.admin.cluster;
import org.elasticsearch.action.admin.cluster.storedscripts.GetScriptContextAction;
import org.elasticsearch.action.admin.cluster.storedscripts.GetScriptContextRequest;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.inject.Inject;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Collections.singletonList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
public class RestGetScriptContextAction extends BaseRestHandler {
@Inject
public RestGetScriptContextAction(RestController controller) {
controller.registerHandler(GET, "/_script_context", this);
@Override
public List<Route> routes() {
return singletonList(new Route(GET, "/_script_context"));
}
@Override public String getName() {

11
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestGetScriptLanguageAction.java
View File

@ -22,20 +22,21 @@ package org.elasticsearch.rest.action.admin.cluster;
import org.elasticsearch.action.admin.cluster.storedscripts.GetScriptLanguageAction;
import org.elasticsearch.action.admin.cluster.storedscripts.GetScriptLanguageRequest;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.inject.Inject;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Collections.singletonList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
public class RestGetScriptLanguageAction extends BaseRestHandler {
@Inject
public RestGetScriptLanguageAction(RestController controller) {
controller.registerHandler(GET, "/_script_language", this);
@Override
public List<Route> routes() {
return singletonList(new Route(GET, "/_script_language"));
}
@Override public String getName() {

8
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestGetSnapshotsAction.java
View File

@ -23,12 +23,13 @@ import org.elasticsearch.action.admin.cluster.snapshots.get.GetSnapshotsRequest;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.Strings;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Collections.singletonList;
import static org.elasticsearch.client.Requests.getSnapshotsRequest;
import static org.elasticsearch.rest.RestRequest.Method.GET;
@ -37,8 +38,9 @@ import static org.elasticsearch.rest.RestRequest.Method.GET;
*/
public class RestGetSnapshotsAction extends BaseRestHandler {
public RestGetSnapshotsAction(RestController controller) {
controller.registerHandler(GET, "/_snapshot/{repository}/{snapshot}", this);
@Override
public List<Route> routes() {
return singletonList(new Route(GET, "/_snapshot/{repository}/{snapshot}"));
}
@Override

8
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestGetStoredScriptAction.java
View File

@ -21,18 +21,20 @@ package org.elasticsearch.rest.action.admin.cluster;
import org.elasticsearch.action.admin.cluster.storedscripts.GetStoredScriptRequest;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestStatusToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Collections.singletonList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
public class RestGetStoredScriptAction extends BaseRestHandler {
public RestGetStoredScriptAction(RestController controller) {
controller.registerHandler(GET, "/_scripts/{id}", this);
@Override
public List<Route> routes() {
return singletonList(new Route(GET, "/_scripts/{id}"));
}
@Override

8
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestGetTaskAction.java
View File

@ -23,19 +23,21 @@ import org.elasticsearch.action.admin.cluster.node.tasks.get.GetTaskRequest;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import org.elasticsearch.tasks.TaskId;
import java.io.IOException;
import java.util.List;
import static java.util.Collections.singletonList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
public class RestGetTaskAction extends BaseRestHandler {
public RestGetTaskAction(RestController controller) {
controller.registerHandler(GET, "/_tasks/{task_id}", this);
@Override
public List<Route> routes() {
return singletonList(new Route(GET, "/_tasks/{task_id}"));
}
@Override

11
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestListTasksAction.java
View File

@ -30,7 +30,6 @@ import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.BytesRestResponse;
import org.elasticsearch.rest.RestChannel;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.RestResponse;
import org.elasticsearch.rest.RestStatus;
@ -39,8 +38,10 @@ import org.elasticsearch.rest.action.RestToXContentListener;
import org.elasticsearch.tasks.TaskId;
import java.io.IOException;
import java.util.List;
import java.util.function.Supplier;
import static java.util.Collections.singletonList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
@ -48,9 +49,13 @@ public class RestListTasksAction extends BaseRestHandler {
private final Supplier<DiscoveryNodes> nodesInCluster;
public RestListTasksAction(RestController controller, Supplier<DiscoveryNodes> nodesInCluster) {
public RestListTasksAction(Supplier<DiscoveryNodes> nodesInCluster) {
this.nodesInCluster = nodesInCluster;
controller.registerHandler(GET, "/_tasks", this);
}
@Override
public List<Route> routes() {
return singletonList(new Route(GET, "/_tasks"));
}
@Override

27
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestNodesHotThreadsAction.java
View File

@ -27,27 +27,32 @@ import org.elasticsearch.common.Strings;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.BytesRestResponse;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.RestResponse;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.rest.action.RestResponseListener;
import java.io.IOException;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
public class RestNodesHotThreadsAction extends BaseRestHandler {
public RestNodesHotThreadsAction(RestController controller) {
controller.registerHandler(RestRequest.Method.GET, "/_cluster/nodes/hotthreads", this);
controller.registerHandler(RestRequest.Method.GET, "/_cluster/nodes/hot_threads", this);
controller.registerHandler(RestRequest.Method.GET, "/_cluster/nodes/{nodeId}/hotthreads", this);
controller.registerHandler(RestRequest.Method.GET, "/_cluster/nodes/{nodeId}/hot_threads", this);
controller.registerHandler(RestRequest.Method.GET, "/_nodes/hotthreads", this);
controller.registerHandler(RestRequest.Method.GET, "/_nodes/hot_threads", this);
controller.registerHandler(RestRequest.Method.GET, "/_nodes/{nodeId}/hotthreads", this);
controller.registerHandler(RestRequest.Method.GET, "/_nodes/{nodeId}/hot_threads", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_cluster/nodes/hotthreads"),
new Route(GET, "/_cluster/nodes/hot_threads"),
new Route(GET, "/_cluster/nodes/{nodeId}/hotthreads"),
new Route(GET, "/_cluster/nodes/{nodeId}/hot_threads"),
new Route(GET, "/_nodes/hotthreads"),
new Route(GET, "/_nodes/hot_threads"),
new Route(GET, "/_nodes/{nodeId}/hotthreads"),
new Route(GET, "/_nodes/{nodeId}/hot_threads")));
}
@Override

24
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestNodesInfoAction.java
View File

@ -26,13 +26,15 @@ import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.settings.SettingsFilter;
import org.elasticsearch.common.util.set.Sets;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestActions.NodesResponseRestListener;
import java.io.IOException;
import java.util.List;
import java.util.Set;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
public class RestNodesInfoAction extends BaseRestHandler {
@ -50,17 +52,21 @@ public class RestNodesInfoAction extends BaseRestHandler {
private final SettingsFilter settingsFilter;
public RestNodesInfoAction(RestController controller, SettingsFilter settingsFilter) {
controller.registerHandler(GET, "/_nodes", this);
// this endpoint is used for metrics, not for node IDs, like /_nodes/fs
controller.registerHandler(GET, "/_nodes/{nodeId}", this);
controller.registerHandler(GET, "/_nodes/{nodeId}/{metrics}", this);
// added this endpoint to be aligned with stats
controller.registerHandler(GET, "/_nodes/{nodeId}/info/{metrics}", this);
public RestNodesInfoAction(SettingsFilter settingsFilter) {
this.settingsFilter = settingsFilter;
}
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_nodes"),
// this endpoint is used for metrics, not for node IDs, like /_nodes/fs
new Route(GET, "/_nodes/{nodeId}"),
new Route(GET, "/_nodes/{nodeId}/{metrics}"),
// added this endpoint to be aligned with stats
new Route(GET, "/_nodes/{nodeId}/info/{metrics}")));
}
@Override
public String getName() {
return "nodes_info_action";

23
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestNodesStatsAction.java
View File

@ -25,33 +25,34 @@ import org.elasticsearch.action.admin.indices.stats.CommonStatsFlags.Flag;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.Strings;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestActions.NodesResponseRestListener;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.function.Consumer;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
public class RestNodesStatsAction extends BaseRestHandler {
public RestNodesStatsAction(RestController controller) {
controller.registerHandler(GET, "/_nodes/stats", this);
controller.registerHandler(GET, "/_nodes/{nodeId}/stats", this);
controller.registerHandler(GET, "/_nodes/stats/{metric}", this);
controller.registerHandler(GET, "/_nodes/{nodeId}/stats/{metric}", this);
controller.registerHandler(GET, "/_nodes/stats/{metric}/{index_metric}", this);
controller.registerHandler(GET, "/_nodes/{nodeId}/stats/{metric}/{index_metric}", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_nodes/stats"),
new Route(GET, "/_nodes/{nodeId}/stats"),
new Route(GET, "/_nodes/stats/{metric}"),
new Route(GET, "/_nodes/{nodeId}/stats/{metric}"),
new Route(GET, "/_nodes/stats/{metric}/{index_metric}"),
new Route(GET, "/_nodes/{nodeId}/stats/{metric}/{index_metric}")));
}
static final Map<String, Consumer<NodesStatsRequest>> METRICS;

19
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestNodesUsageAction.java
View File

@ -23,11 +23,9 @@ import org.elasticsearch.action.admin.cluster.node.usage.NodesUsageRequest;
import org.elasticsearch.action.admin.cluster.node.usage.NodesUsageResponse;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.Strings;
import org.elasticsearch.common.inject.Inject;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.BytesRestResponse;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.RestResponse;
import org.elasticsearch.rest.RestStatus;
@ -35,20 +33,23 @@ import org.elasticsearch.rest.action.RestActions;
import org.elasticsearch.rest.action.RestBuilderListener;
import java.io.IOException;
import java.util.List;
import java.util.Locale;
import java.util.Set;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
public class RestNodesUsageAction extends BaseRestHandler {
@Inject
public RestNodesUsageAction(RestController controller) {
controller.registerHandler(GET, "/_nodes/usage", this);
controller.registerHandler(GET, "/_nodes/{nodeId}/usage", this);
controller.registerHandler(GET, "/_nodes/usage/{metric}", this);
controller.registerHandler(GET, "/_nodes/{nodeId}/usage/{metric}", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_nodes/usage"),
new Route(GET, "/_nodes/{nodeId}/usage"),
new Route(GET, "/_nodes/usage/{metric}"),
new Route(GET, "/_nodes/{nodeId}/usage/{metric}")));
}
@Override

10
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestPendingClusterTasksAction.java
View File

@ -22,16 +22,20 @@ package org.elasticsearch.rest.action.admin.cluster;
import org.elasticsearch.action.admin.cluster.tasks.PendingClusterTasksRequest;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Collections.singletonList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
public class RestPendingClusterTasksAction extends BaseRestHandler {
public RestPendingClusterTasksAction(RestController controller) {
controller.registerHandler(RestRequest.Method.GET, "/_cluster/pending_tasks", this);
@Override
public List<Route> routes() {
return singletonList(new Route(GET, "/_cluster/pending_tasks"));
}
@Override

12
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestPutRepositoryAction.java
View File

@ -23,12 +23,14 @@ import org.elasticsearch.action.admin.cluster.repositories.put.PutRepositoryRequ
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.xcontent.XContentParser;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.client.Requests.putRepositoryRequest;
import static org.elasticsearch.rest.RestRequest.Method.POST;
import static org.elasticsearch.rest.RestRequest.Method.PUT;
@ -38,9 +40,11 @@ import static org.elasticsearch.rest.RestRequest.Method.PUT;
*/
public class RestPutRepositoryAction extends BaseRestHandler {
public RestPutRepositoryAction(RestController controller) {
controller.registerHandler(PUT, "/_snapshot/{repository}", this);
controller.registerHandler(POST, "/_snapshot/{repository}", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(POST, "/_snapshot/{repository}"),
new Route(PUT, "/_snapshot/{repository}")));
}
@Override

16
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestPutStoredScriptAction.java
View File

@ -23,23 +23,27 @@ import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.bytes.BytesReference;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import org.elasticsearch.script.StoredScriptSource;
import java.io.IOException;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.POST;
import static org.elasticsearch.rest.RestRequest.Method.PUT;
public class RestPutStoredScriptAction extends BaseRestHandler {
public RestPutStoredScriptAction(RestController controller) {
controller.registerHandler(POST, "/_scripts/{id}", this);
controller.registerHandler(PUT, "/_scripts/{id}", this);
controller.registerHandler(POST, "/_scripts/{id}/{context}", this);
controller.registerHandler(PUT, "/_scripts/{id}/{context}", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(POST, "/_scripts/{id}"),
new Route(PUT, "/_scripts/{id}"),
new Route(POST, "/_scripts/{id}/{context}"),
new Route(PUT, "/_scripts/{id}/{context}")));
}
@Override

16
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestReloadSecureSettingsAction.java
View File

@ -30,7 +30,6 @@ import org.elasticsearch.common.xcontent.ObjectParser;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.BytesRestResponse;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.RestResponse;
import org.elasticsearch.rest.RestStatus;
@ -38,7 +37,10 @@ import org.elasticsearch.rest.action.RestActions;
import org.elasticsearch.rest.action.RestBuilderListener;
import java.io.IOException;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.POST;
public final class RestReloadSecureSettingsAction extends BaseRestHandler {
@ -51,16 +53,18 @@ public final class RestReloadSecureSettingsAction extends BaseRestHandler {
new ParseField("secure_settings_password"));
}
public RestReloadSecureSettingsAction(RestController controller) {
controller.registerHandler(POST, "/_nodes/reload_secure_settings", this);
controller.registerHandler(POST, "/_nodes/{nodeId}/reload_secure_settings", this);
}
@Override
public String getName() {
return "nodes_reload_action";
}
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(POST, "/_nodes/reload_secure_settings"),
new Route(POST, "/_nodes/{nodeId}/reload_secure_settings")));
}
@Override
public RestChannelConsumer prepareRequest(RestRequest request, NodeClient client) throws IOException {
final String[] nodesIds = Strings.splitStringByCommaToArray(request.param("nodeId"));

9
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestRemoteClusterInfoAction.java
View File

@ -23,16 +23,19 @@ import org.elasticsearch.action.admin.cluster.remote.RemoteInfoAction;
import org.elasticsearch.action.admin.cluster.remote.RemoteInfoRequest;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.util.List;
import static java.util.Collections.singletonList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
public final class RestRemoteClusterInfoAction extends BaseRestHandler {
public RestRemoteClusterInfoAction(RestController controller) {
controller.registerHandler(GET, "_remote/info", this);
@Override
public List<Route> routes() {
return singletonList(new Route(GET, "_remote/info"));
}
@Override

8
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestRestoreSnapshotAction.java
View File

@ -22,12 +22,13 @@ package org.elasticsearch.rest.action.admin.cluster;
import org.elasticsearch.action.admin.cluster.snapshots.restore.RestoreSnapshotRequest;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Collections.singletonList;
import static org.elasticsearch.client.Requests.restoreSnapshotRequest;
import static org.elasticsearch.rest.RestRequest.Method.POST;
@ -36,8 +37,9 @@ import static org.elasticsearch.rest.RestRequest.Method.POST;
*/
public class RestRestoreSnapshotAction extends BaseRestHandler {
public RestRestoreSnapshotAction(RestController controller) {
controller.registerHandler(POST, "/_snapshot/{repository}/{snapshot}/_restore", this);
@Override
public List<Route> routes() {
return singletonList(new Route(POST, "/_snapshot/{repository}/{snapshot}/_restore"));
}
@Override

14
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestSnapshotsStatusAction.java
View File

@ -23,12 +23,14 @@ import org.elasticsearch.action.admin.cluster.snapshots.status.SnapshotsStatusRe
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.Strings;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.client.Requests.snapshotsStatusRequest;
import static org.elasticsearch.rest.RestRequest.Method.GET;
@ -37,10 +39,12 @@ import static org.elasticsearch.rest.RestRequest.Method.GET;
*/
public class RestSnapshotsStatusAction extends BaseRestHandler {
public RestSnapshotsStatusAction(RestController controller) {
controller.registerHandler(GET, "/_snapshot/{repository}/{snapshot}/_status", this);
controller.registerHandler(GET, "/_snapshot/{repository}/_status", this);
controller.registerHandler(GET, "/_snapshot/_status", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_snapshot/{repository}/{snapshot}/_status"),
new Route(GET, "/_snapshot/{repository}/_status"),
new Route(GET, "/_snapshot/_status")));
}
@Override

8
server/src/main/java/org/elasticsearch/rest/action/admin/cluster/RestVerifyRepositoryAction.java
View File

@ -22,19 +22,21 @@ package org.elasticsearch.rest.action.admin.cluster;
import org.elasticsearch.action.admin.cluster.repositories.verify.VerifyRepositoryRequest;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Collections.singletonList;
import static org.elasticsearch.client.Requests.verifyRepositoryRequest;
import static org.elasticsearch.rest.RestRequest.Method.POST;
public class RestVerifyRepositoryAction extends BaseRestHandler {
public RestVerifyRepositoryAction(RestController controller) {
controller.registerHandler(POST, "/_snapshot/{repository}/_verify", this);
@Override
public List<Route> routes() {
return singletonList(new Route(POST, "/_snapshot/{repository}/_verify"));
}
@Override

16
server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestAnalyzeAction.java
View File

@ -23,12 +23,14 @@ import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.xcontent.XContentParser;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
import static org.elasticsearch.rest.RestRequest.Method.POST;
@ -46,11 +48,13 @@ public class RestAnalyzeAction extends BaseRestHandler {
public static final ParseField NORMALIZER = new ParseField("normalizer");
}
public RestAnalyzeAction(RestController controller) {
controller.registerHandler(GET, "/_analyze", this);
controller.registerHandler(GET, "/{index}/_analyze", this);
controller.registerHandler(POST, "/_analyze", this);
controller.registerHandler(POST, "/{index}/_analyze", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_analyze"),
new Route(POST, "/_analyze"),
new Route(GET, "/{index}/_analyze"),
new Route(POST, "/{index}/_analyze")));
}
@Override

12
server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestClearIndicesCacheAction.java
View File

@ -24,19 +24,23 @@ import org.elasticsearch.action.support.IndicesOptions;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.Strings;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.POST;
public class RestClearIndicesCacheAction extends BaseRestHandler {
public RestClearIndicesCacheAction(RestController controller) {
controller.registerHandler(POST, "/_cache/clear", this);
controller.registerHandler(POST, "/{index}/_cache/clear", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(POST, "/_cache/clear"),
new Route(POST, "/{index}/_cache/clear")));
}
@Override

14
server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestCloseIndexAction.java
View File

@ -25,17 +25,23 @@ import org.elasticsearch.action.support.IndicesOptions;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.Strings;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.POST;
public class RestCloseIndexAction extends BaseRestHandler {
public RestCloseIndexAction(RestController controller) {
controller.registerHandler(RestRequest.Method.POST, "/_close", this);
controller.registerHandler(RestRequest.Method.POST, "/{index}/_close", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(POST, "/_close"),
new Route(POST, "/{index}/_close")));
}
@Override

14
server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestCreateIndexAction.java
View File

@ -28,23 +28,27 @@ import org.elasticsearch.common.xcontent.LoggingDeprecationHandler;
import org.elasticsearch.common.xcontent.XContentHelper;
import org.elasticsearch.index.mapper.MapperService;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static java.util.Collections.singletonList;
import static java.util.Collections.singletonMap;
import static org.elasticsearch.rest.RestRequest.Method.PUT;
public class RestCreateIndexAction extends BaseRestHandler {
private static final DeprecationLogger deprecationLogger = new DeprecationLogger(
LogManager.getLogger(RestCreateIndexAction.class));
public static final String TYPES_DEPRECATION_MESSAGE = "[types removal] Using include_type_name in create " +
"index requests is deprecated. The parameter will be removed in the next major version.";
public RestCreateIndexAction(RestController controller) {
controller.registerHandler(RestRequest.Method.PUT, "/{index}", this);
@Override
public List<Route> routes() {
return singletonList(new Route(PUT, "/{index}"));
}
@Override
@ -93,7 +97,7 @@ public class RestCreateIndexAction extends BaseRestHandler {
"[" + MapperService.SINGLE_MAPPING_NAME + "] unless include_type_name is set to true.");
}
newSource.put("mappings", Collections.singletonMap(MapperService.SINGLE_MAPPING_NAME, mappings));
newSource.put("mappings", singletonMap(MapperService.SINGLE_MAPPING_NAME, mappings));
return newSource;
}
}

14
server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestDeleteIndexAction.java
View File

@ -24,17 +24,23 @@ import org.elasticsearch.action.support.IndicesOptions;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.Strings;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.DELETE;
public class RestDeleteIndexAction extends BaseRestHandler {
public RestDeleteIndexAction(RestController controller) {
controller.registerHandler(RestRequest.Method.DELETE, "/", this);
controller.registerHandler(RestRequest.Method.DELETE, "/{index}", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(DELETE, "/"),
new Route(DELETE, "/{index}")));
}
@Override

10
server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestDeleteIndexTemplateAction.java
View File

@ -21,16 +21,20 @@ package org.elasticsearch.rest.action.admin.indices;
import org.elasticsearch.action.admin.indices.template.delete.DeleteIndexTemplateRequest;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Collections.singletonList;
import static org.elasticsearch.rest.RestRequest.Method.DELETE;
public class RestDeleteIndexTemplateAction extends BaseRestHandler {
public RestDeleteIndexTemplateAction(RestController controller) {
controller.registerHandler(RestRequest.Method.DELETE, "/_template/{name}", this);
@Override
public List<Route> routes() {
return singletonList(new Route(DELETE, "/_template/{name}"));
}
@Override

17
server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestFlushAction.java
View File

@ -24,23 +24,26 @@ import org.elasticsearch.action.support.IndicesOptions;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.Strings;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
import static org.elasticsearch.rest.RestRequest.Method.POST;
public class RestFlushAction extends BaseRestHandler {
public RestFlushAction(RestController controller) {
controller.registerHandler(POST, "/_flush", this);
controller.registerHandler(POST, "/{index}/_flush", this);
controller.registerHandler(GET, "/_flush", this);
controller.registerHandler(GET, "/{index}/_flush", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_flush"),
new Route(POST, "/_flush"),
new Route(GET, "/{index}/_flush"),
new Route(POST, "/{index}/_flush")));
}
@Override

12
server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestForceMergeAction.java
View File

@ -26,21 +26,25 @@ import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.Strings;
import org.elasticsearch.common.logging.DeprecationLogger;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.POST;
public class RestForceMergeAction extends BaseRestHandler {
private static final DeprecationLogger deprecationLogger = new DeprecationLogger(LogManager.getLogger(RestForceMergeAction.class));
public RestForceMergeAction(final RestController controller) {
controller.registerHandler(POST, "/_forcemerge", this);
controller.registerHandler(POST, "/{index}/_forcemerge", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(POST, "/_forcemerge"),
new Route(POST, "/{index}/_forcemerge")));
}
@Override

23
server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestGetAliasesAction.java
View File

@ -33,7 +33,6 @@ import org.elasticsearch.common.xcontent.ToXContent;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.BytesRestResponse;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.RestResponse;
import org.elasticsearch.rest.RestStatus;
@ -47,6 +46,8 @@ import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
import static org.elasticsearch.rest.RestRequest.Method.HEAD;
@ -55,15 +56,17 @@ import static org.elasticsearch.rest.RestRequest.Method.HEAD;
*/
public class RestGetAliasesAction extends BaseRestHandler {
public RestGetAliasesAction(final RestController controller) {
controller.registerHandler(GET, "/_alias", this);
controller.registerHandler(GET, "/_aliases", this);
controller.registerHandler(GET, "/_alias/{name}", this);
controller.registerHandler(HEAD, "/_alias/{name}", this);
controller.registerHandler(GET, "/{index}/_alias", this);
controller.registerHandler(HEAD, "/{index}/_alias", this);
controller.registerHandler(GET, "/{index}/_alias/{name}", this);
controller.registerHandler(HEAD, "/{index}/_alias/{name}", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_alias"),
new Route(GET, "/_aliases"),
new Route(GET, "/_alias/{name}"),
new Route(HEAD, "/_alias/{name}"),
new Route(GET, "/{index}/_alias"),
new Route(HEAD, "/{index}/_alias"),
new Route(GET, "/{index}/_alias/{name}"),
new Route(HEAD, "/{index}/_alias/{name}")));
}
@Override

18
server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestGetFieldMappingAction.java
View File

@ -30,15 +30,17 @@ import org.elasticsearch.common.logging.DeprecationLogger;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.BytesRestResponse;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.RestResponse;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.rest.action.RestBuilderListener;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
import static org.elasticsearch.rest.RestStatus.NOT_FOUND;
import static org.elasticsearch.rest.RestStatus.OK;
@ -50,12 +52,14 @@ public class RestGetFieldMappingAction extends BaseRestHandler {
public static final String TYPES_DEPRECATION_MESSAGE = "[types removal] Using include_type_name in get " +
"field mapping requests is deprecated. The parameter will be removed in the next major version.";
public RestGetFieldMappingAction(RestController controller) {
controller.registerHandler(GET, "/_mapping/field/{fields}", this);
controller.registerHandler(GET, "/_mapping/{type}/field/{fields}", this);
controller.registerHandler(GET, "/{index}/_mapping/field/{fields}", this);
controller.registerHandler(GET, "/{index}/{type}/_mapping/field/{fields}", this);
controller.registerHandler(GET, "/{index}/_mapping/{type}/field/{fields}", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_mapping/field/{fields}"),
new Route(GET, "/_mapping/{type}/field/{fields}"),
new Route(GET, "/{index}/_mapping/field/{fields}"),
new Route(GET, "/{index}/{type}/_mapping/field/{fields}"),
new Route(GET, "/{index}/_mapping/{type}/field/{fields}")));
}
@Override

14
server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestGetIndexTemplateAction.java
View File

@ -28,15 +28,17 @@ import org.elasticsearch.common.logging.DeprecationLogger;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.util.set.Sets;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
import static org.elasticsearch.rest.RestRequest.Method.HEAD;
import static org.elasticsearch.rest.RestStatus.NOT_FOUND;
@ -54,10 +56,12 @@ public class RestGetIndexTemplateAction extends BaseRestHandler {
public static final String TYPES_DEPRECATION_MESSAGE = "[types removal]" +
" Specifying include_type_name in get index template requests is deprecated.";
public RestGetIndexTemplateAction(final RestController controller) {
controller.registerHandler(GET, "/_template", this);
controller.registerHandler(GET, "/_template/{name}", this);
controller.registerHandler(HEAD, "/_template/{name}", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_template"),
new Route(GET, "/_template/{name}"),
new Route(HEAD, "/_template/{name}")));
}
@Override

12
server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestGetIndicesAction.java
View File

@ -28,16 +28,18 @@ import org.elasticsearch.common.Strings;
import org.elasticsearch.common.logging.DeprecationLogger;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
import static org.elasticsearch.rest.RestRequest.Method.HEAD;
@ -54,9 +56,11 @@ public class RestGetIndicesAction extends BaseRestHandler {
.unmodifiableSet(Stream.concat(Collections.singleton(INCLUDE_TYPE_NAME_PARAMETER).stream(), Settings.FORMAT_PARAMS.stream())
.collect(Collectors.toSet()));
public RestGetIndicesAction(final RestController controller) {
controller.registerHandler(GET, "/{index}", this);
controller.registerHandler(HEAD, "/{index}", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/{index}"),
new Route(HEAD, "/{index}")));
}
@Override

25
server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestGetMappingAction.java
View File

@ -37,7 +37,6 @@ import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.indices.TypeMissingException;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.BytesRestResponse;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.RestResponse;
import org.elasticsearch.rest.RestStatus;
@ -53,6 +52,8 @@ import java.util.Set;
import java.util.SortedSet;
import java.util.stream.Collectors;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
import static org.elasticsearch.rest.RestRequest.Method.HEAD;
@ -62,16 +63,18 @@ public class RestGetMappingAction extends BaseRestHandler {
public static final String TYPES_DEPRECATION_MESSAGE = "[types removal] Using include_type_name in get" +
" mapping requests is deprecated. The parameter will be removed in the next major version.";
public RestGetMappingAction(final RestController controller) {
controller.registerHandler(GET, "/_mapping", this);
controller.registerHandler(GET, "/_mappings", this);
controller.registerHandler(GET, "/{index}/{type}/_mapping", this);
controller.registerHandler(GET, "/{index}/_mappings", this);
controller.registerHandler(GET, "/{index}/_mapping", this);
controller.registerHandler(GET, "/{index}/_mappings/{type}", this);
controller.registerHandler(GET, "/{index}/_mapping/{type}", this);
controller.registerHandler(HEAD, "/{index}/_mapping/{type}", this);
controller.registerHandler(GET, "/_mapping/{type}", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_mapping"),
new Route(GET, "/_mappings"),
new Route(GET, "/{index}/{type}/_mapping"),
new Route(GET, "/{index}/_mapping"),
new Route(GET, "/{index}/_mappings"),
new Route(GET, "/{index}/_mappings/{type}"),
new Route(GET, "/{index}/_mapping/{type}"),
new Route(HEAD, "/{index}/_mapping/{type}"),
new Route(GET, "/_mapping/{type}")));
}
@Override

18
server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestGetSettingsAction.java
View File

@ -24,22 +24,26 @@ import org.elasticsearch.action.support.IndicesOptions;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.Strings;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
public class RestGetSettingsAction extends BaseRestHandler {
public RestGetSettingsAction(RestController controller) {
controller.registerHandler(GET, "/_settings", this);
controller.registerHandler(GET, "/_settings/{name}", this);
controller.registerHandler(GET, "/{index}/_settings", this);
controller.registerHandler(GET, "/{index}/_settings/{name}", this);
controller.registerHandler(GET, "/{index}/_setting/{name}", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_settings"),
new Route(GET, "/_settings/{name}"),
new Route(GET, "/{index}/_settings"),
new Route(GET, "/{index}/_settings/{name}"),
new Route(GET, "/{index}/_setting/{name}")));
}
@Override

12
server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestIndexDeleteAliasesAction.java
View File

@ -23,19 +23,23 @@ import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest.AliasA
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.Strings;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.DELETE;
public class RestIndexDeleteAliasesAction extends BaseRestHandler {
public RestIndexDeleteAliasesAction(RestController controller) {
controller.registerHandler(DELETE, "/{index}/_alias/{name}", this);
controller.registerHandler(DELETE, "/{index}/_aliases/{name}", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(DELETE, "/{index}/_alias/{name}"),
new Route(DELETE, "/{index}/_aliases/{name}")));
}
@Override

32
server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestIndexPutAliasAction.java
View File

@ -24,32 +24,34 @@ import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.Strings;
import org.elasticsearch.common.xcontent.XContentParser;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.POST;
import static org.elasticsearch.rest.RestRequest.Method.PUT;
public class RestIndexPutAliasAction extends BaseRestHandler {
public RestIndexPutAliasAction(RestController controller) {
controller.registerHandler(PUT, "/{index}/_alias/{name}", this);
controller.registerHandler(PUT, "/_alias/{name}", this);
controller.registerHandler(PUT, "/{index}/_aliases/{name}", this);
controller.registerHandler(PUT, "/_aliases/{name}", this);
controller.registerHandler(PUT, "/{index}/_alias", this);
controller.registerHandler(PUT, "/_alias", this);
controller.registerHandler(POST, "/{index}/_alias/{name}", this);
controller.registerHandler(POST, "/_alias/{name}", this);
controller.registerHandler(POST, "/{index}/_aliases/{name}", this);
controller.registerHandler(POST, "/_aliases/{name}", this);
controller.registerHandler(PUT, "/{index}/_aliases", this);
//we cannot add POST for "/_aliases" because this is the _aliases api already defined in RestIndicesAliasesAction
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(POST, "/{index}/_alias/{name}"),
new Route(PUT, "/{index}/_alias/{name}"),
new Route(POST, "/_alias/{name}"),
new Route(PUT, "/_alias/{name}"),
new Route(POST, "/{index}/_aliases/{name}"),
new Route(PUT, "/{index}/_aliases/{name}"),
new Route(POST, "/_aliases/{name}"),
new Route(PUT, "/_aliases/{name}"),
new Route(PUT, "/{index}/_alias"),
new Route(PUT, "/{index}/_aliases"),
new Route(PUT, "/_alias")));
}
@Override

8
server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestIndicesAliasesAction.java
View File

@ -23,12 +23,13 @@ import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.xcontent.XContentParser;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Collections.singletonList;
import static org.elasticsearch.rest.RestRequest.Method.POST;
public class RestIndicesAliasesAction extends BaseRestHandler {
@ -38,8 +39,9 @@ public class RestIndicesAliasesAction extends BaseRestHandler {
return "indices_aliases_action";
}
public RestIndicesAliasesAction(RestController controller) {
controller.registerHandler(POST, "/_aliases", this);
@Override
public List<Route> routes() {
return singletonList(new Route(POST, "/_aliases"));
}
@Override

12
server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestIndicesSegmentsAction.java
View File

@ -24,19 +24,23 @@ import org.elasticsearch.action.support.IndicesOptions;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.Strings;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
public class RestIndicesSegmentsAction extends BaseRestHandler {
public RestIndicesSegmentsAction(RestController controller) {
controller.registerHandler(GET, "/_segments", this);
controller.registerHandler(GET, "/{index}/_segments", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_segments"),
new Route(GET, "/{index}/_segments")));
}
@Override

12
server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestIndicesShardStoresAction.java
View File

@ -28,13 +28,15 @@ import org.elasticsearch.common.Strings;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.BytesRestResponse;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.RestResponse;
import org.elasticsearch.rest.action.RestBuilderListener;
import java.io.IOException;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
import static org.elasticsearch.rest.RestStatus.OK;
@ -43,9 +45,11 @@ import static org.elasticsearch.rest.RestStatus.OK;
*/
public class RestIndicesShardStoresAction extends BaseRestHandler {
public RestIndicesShardStoresAction(RestController controller) {
controller.registerHandler(GET, "/_shard_stores", this);
controller.registerHandler(GET, "/{index}/_shard_stores", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_shard_stores"),
new Route(GET, "/{index}/_shard_stores")));
}
@Override

16
server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestIndicesStatsAction.java
View File

@ -26,28 +26,32 @@ import org.elasticsearch.action.support.IndicesOptions;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.Strings;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.function.Consumer;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
public class RestIndicesStatsAction extends BaseRestHandler {
public RestIndicesStatsAction(RestController controller) {
controller.registerHandler(GET, "/_stats", this);
controller.registerHandler(GET, "/_stats/{metric}", this);
controller.registerHandler(GET, "/{index}/_stats", this);
controller.registerHandler(GET, "/{index}/_stats/{metric}", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_stats"),
new Route(GET, "/_stats/{metric}"),
new Route(GET, "/{index}/_stats"),
new Route(GET, "/{index}/_stats/{metric}")));
}
@Override

14
server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestOpenIndexAction.java
View File

@ -25,17 +25,23 @@ import org.elasticsearch.action.support.IndicesOptions;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.Strings;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.POST;
public class RestOpenIndexAction extends BaseRestHandler {
public RestOpenIndexAction(RestController controller) {
controller.registerHandler(RestRequest.Method.POST, "/_open", this);
controller.registerHandler(RestRequest.Method.POST, "/{index}/_open", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(POST, "/_open"),
new Route(POST, "/{index}/_open")));
}
@Override

15
server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestPutIndexTemplateAction.java
View File

@ -26,15 +26,20 @@ import org.elasticsearch.common.Strings;
import org.elasticsearch.common.logging.DeprecationLogger;
import org.elasticsearch.common.xcontent.XContentHelper;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.POST;
import static org.elasticsearch.rest.RestRequest.Method.PUT;
public class RestPutIndexTemplateAction extends BaseRestHandler {
private static final DeprecationLogger deprecationLogger = new DeprecationLogger(
@ -43,9 +48,11 @@ public class RestPutIndexTemplateAction extends BaseRestHandler {
" Specifying include_type_name in put index template requests is deprecated."+
" The parameter will be removed in the next major version.";
public RestPutIndexTemplateAction(RestController controller) {
controller.registerHandler(RestRequest.Method.PUT, "/_template/{name}", this);
controller.registerHandler(RestRequest.Method.POST, "/_template/{name}", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(POST, "/_template/{name}"),
new Route(PUT, "/_template/{name}")));
}
@Override

44
server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestPutMappingAction.java
View File

@ -28,13 +28,15 @@ import org.elasticsearch.common.logging.DeprecationLogger;
import org.elasticsearch.common.xcontent.XContentHelper;
import org.elasticsearch.index.mapper.MapperService;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.client.Requests.putMappingRequest;
import static org.elasticsearch.index.mapper.MapperService.isMappingSourceTyped;
import static org.elasticsearch.rest.RestRequest.Method.POST;
@ -46,27 +48,25 @@ public class RestPutMappingAction extends BaseRestHandler {
public static final String TYPES_DEPRECATION_MESSAGE = "[types removal] Using include_type_name in put " +
"mapping requests is deprecated. The parameter will be removed in the next major version.";
public RestPutMappingAction(RestController controller) {
controller.registerHandler(PUT, "/{index}/_mapping/", this);
controller.registerHandler(PUT, "/{index}/{type}/_mapping", this);
controller.registerHandler(PUT, "/{index}/_mapping/{type}", this);
controller.registerHandler(PUT, "/_mapping/{type}", this);
controller.registerHandler(POST, "/{index}/_mapping/", this);
controller.registerHandler(POST, "/{index}/{type}/_mapping", this);
controller.registerHandler(POST, "/{index}/_mapping/{type}", this);
controller.registerHandler(POST, "/_mapping/{type}", this);
//register the same paths, but with plural form _mappings
controller.registerHandler(PUT, "/{index}/_mappings/", this);
controller.registerHandler(PUT, "/{index}/{type}/_mappings", this);
controller.registerHandler(PUT, "/{index}/_mappings/{type}", this);
controller.registerHandler(PUT, "/_mappings/{type}", this);
controller.registerHandler(POST, "/{index}/_mappings/", this);
controller.registerHandler(POST, "/{index}/{type}/_mappings", this);
controller.registerHandler(POST, "/{index}/_mappings/{type}", this);
controller.registerHandler(POST, "/_mappings/{type}", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(POST, "/{index}/_mapping/"),
new Route(PUT, "/{index}/_mapping/"),
new Route(POST, "/{index}/{type}/_mapping"),
new Route(PUT, "/{index}/{type}/_mapping"),
new Route(POST, "/{index}/_mapping/{type}"),
new Route(PUT, "/{index}/_mapping/{type}"),
new Route(POST, "/_mapping/{type}"),
new Route(PUT, "/_mapping/{type}"),
new Route(POST, "/{index}/_mappings/"),
new Route(PUT, "/{index}/_mappings/"),
new Route(POST, "/{index}/{type}/_mappings"),
new Route(PUT, "/{index}/{type}/_mappings"),
new Route(POST, "/{index}/_mappings/{type}"),
new Route(PUT, "/{index}/_mappings/{type}"),
new Route(POST, "/_mappings/{type}"),
new Route(PUT, "/_mappings/{type}")));
}
@Override

12
server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestRecoveryAction.java
View File

@ -24,12 +24,14 @@ import org.elasticsearch.action.support.IndicesOptions;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.Strings;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
/**
@ -37,9 +39,11 @@ import static org.elasticsearch.rest.RestRequest.Method.GET;
*/
public class RestRecoveryAction extends BaseRestHandler {
public RestRecoveryAction(RestController controller) {
controller.registerHandler(GET, "/_recovery", this);
controller.registerHandler(GET, "/{index}/_recovery", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_recovery"),
new Route(GET, "/{index}/_recovery")));
}
@Override

17
server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestRefreshAction.java
View File

@ -25,24 +25,27 @@ import org.elasticsearch.action.support.IndicesOptions;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.Strings;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.rest.action.RestToXContentListener;
import java.io.IOException;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static org.elasticsearch.rest.RestRequest.Method.GET;
import static org.elasticsearch.rest.RestRequest.Method.POST;
public class RestRefreshAction extends BaseRestHandler {
public RestRefreshAction(RestController controller) {
controller.registerHandler(POST, "/_refresh", this);
controller.registerHandler(POST, "/{index}/_refresh", this);
controller.registerHandler(GET, "/_refresh", this);
controller.registerHandler(GET, "/{index}/_refresh", this);
@Override
public List<Route> routes() {
return unmodifiableList(asList(
new Route(GET, "/_refresh"),
new Route(POST, "/_refresh"),
new Route(GET, "/{index}/_refresh"),
new Route(POST, "/{index}/_refresh")));
}
@Override

Some files were not shown because too many files have changed in this diff Show More