RestHandlers declare handled routes (#52123)

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

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

@@ -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 RestNoopBulkAction(),
-                new RestNoopSearchAction(restController));
+                new RestNoopSearchAction());
     }
 }

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

@@ -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) {
+    @Override
-        controller.registerHandler(POST, "/_noop_bulk", this);
+    public List<Route> routes() {
-        controller.registerHandler(PUT, "/_noop_bulk", this);
+        return unmodifiableList(asList(
-        controller.registerHandler(POST, "/{index}/_noop_bulk", this);
+            new Route(POST, "/_noop_bulk"),
-        controller.registerHandler(PUT, "/{index}/_noop_bulk", this);
+            new Route(PUT, "/_noop_bulk"),
-        controller.registerHandler(POST, "/{index}/{type}/_noop_bulk", this);
+            new Route(POST, "/{index}/_noop_bulk"),
-        controller.registerHandler(PUT, "/{index}/{type}/_noop_bulk", this);
+            new Route(PUT, "/{index}/_noop_bulk"),
+            new Route(POST, "/{index}/{type}/_noop_bulk"),
+            new Route(PUT, "/{index}/{type}/_noop_bulk")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(GET, "/_noop_search", this);
+    public List<Route> routes() {
-        controller.registerHandler(POST, "/_noop_search", this);
+        return unmodifiableList(asList(
-        controller.registerHandler(GET, "/{index}/_noop_search", this);
+            new Route(GET, "/_noop_search"),
-        controller.registerHandler(POST, "/{index}/_noop_search", this);
+            new Route(POST, "/_noop_search"),
-        controller.registerHandler(GET, "/{index}/{type}/_noop_search", this);
+            new Route(GET, "/{index}/_noop_search"),
-        controller.registerHandler(POST, "/{index}/{type}/_noop_search", this);
+            new Route(POST, "/{index}/_noop_search"),
+            new Route(GET, "/{index}/{type}/_noop_search"),
+            new Route(POST, "/{index}/{type}/_noop_search")));
     }
 
     @Override

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

@@ -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

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

@@ -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

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

@@ -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 RestSearchTemplateAction(),
-                new RestMultiSearchTemplateAction(settings, restController),
+                new RestMultiSearchTemplateAction(settings),
-                new RestRenderSearchTemplateAction(restController));
+                new RestRenderSearchTemplateAction());
     }
 }

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

@@ -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);
+    @Override
-        controller.registerHandler(POST, "/_msearch/template", this);
+    public List<Route> routes() {
-        controller.registerHandler(GET, "/{index}/_msearch/template", this);
+        return unmodifiableList(asList(
-        controller.registerHandler(POST, "/{index}/_msearch/template", this);
+            new Route(GET, "/_msearch/template"),
-
+            new Route(POST, "/_msearch/template"),
-        // Deprecated typed endpoints.
+            new Route(GET, "/{index}/_msearch/template"),
-        controller.registerHandler(GET, "/{index}/{type}/_msearch/template", this);
+            new Route(POST, "/{index}/_msearch/template"),
-        controller.registerHandler(POST, "/{index}/{type}/_msearch/template", this);
+            // Deprecated typed endpoints.
+            new Route(GET, "/{index}/{type}/_msearch/template"),
+            new Route(POST, "/{index}/{type}/_msearch/template")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(GET, "/_render/template", this);
+    public List<Route> routes() {
-        controller.registerHandler(POST, "/_render/template", this);
+        return unmodifiableList(asList(
-        controller.registerHandler(GET, "/_render/template/{id}", this);
+            new Route(GET, "/_render/template"),
-        controller.registerHandler(POST, "/_render/template/{id}", this);
+            new Route(POST, "/_render/template"),
+            new Route(GET, "/_render/template/{id}"),
+            new Route(POST, "/_render/template/{id}")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(GET, "/_search/template", this);
+    public List<Route> routes() {
-        controller.registerHandler(POST, "/_search/template", this);
+        return unmodifiableList(asList(
-        controller.registerHandler(GET, "/{index}/_search/template", this);
+            new Route(GET, "/_search/template"),
-        controller.registerHandler(POST, "/{index}/_search/template", this);
+            new Route(POST, "/_search/template"),
-
+            new Route(GET, "/{index}/_search/template"),
-        // Deprecated typed endpoints.
+            new Route(POST, "/{index}/_search/template"),
-        controller.registerHandler(GET, "/{index}/{type}/_search/template", this);
+            // Deprecated typed endpoints.
-        controller.registerHandler(POST, "/{index}/{type}/_search/template", this);
+            new Route(GET, "/{index}/{type}/_search/template"),
+            new Route(POST, "/{index}/{type}/_search/template")));
     }
 
     @Override

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

@@ -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() {

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

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

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

@@ -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 PainlessExecuteAction.RestAction());
-        handlers.add(new PainlessContextAction.RestAction(restController));
+        handlers.add(new PainlessContextAction.RestAction());
         return handlers;
     }
 }

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

@@ -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) {
+        @Override
-            controller.registerHandler(GET, "/_scripts/painless/_context", this);
+        public List<Route> routes() {
+            return singletonList(new Route(GET, "/_scripts/painless/_context"));
         }
 
         @Override

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

@@ -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) {
+        @Override
-            controller.registerHandler(GET, "/_scripts/painless/_execute", this);
+        public List<Route> routes() {
-            controller.registerHandler(POST, "/_scripts/painless/_execute", this);
+            return unmodifiableList(asList(
+                new Route(GET, "/_scripts/painless/_execute"),
+                new Route(POST, "/_scripts/painless/_execute")));
         }
 
         @Override

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

@@ -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

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

@@ -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) {
+    @Override
-        controller.registerHandler(GET, "/" + ENDPOINT, this);
+    public List<Route> routes() {
-        controller.registerHandler(POST, "/" + ENDPOINT, this);
+        return unmodifiableList(asList(
-        controller.registerHandler(GET, "/{index}/" + ENDPOINT, this);
+            new Route(GET, "/" + ENDPOINT),
-        controller.registerHandler(POST, "/{index}/" + ENDPOINT, this);
+            new Route(POST, "/" + ENDPOINT),
+            new Route(GET, "/{index}/" + ENDPOINT),
+            new Route(POST, "/{index}/" + ENDPOINT)));
     }
 
     @Override

modules/reindex/src/main/java/org/elasticsearch/index/reindex/ReindexPlugin.java

@@ -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 RestReindexAction(),
-                new RestUpdateByQueryAction(restController),
+                new RestUpdateByQueryAction(),
-                new RestDeleteByQueryAction(restController),
+                new RestDeleteByQueryAction(),
-                new RestRethrottleAction(restController, nodesInCluster));
+                new RestRethrottleAction(nodesInCluster));
     }
 
     @Override

modules/reindex/src/main/java/org/elasticsearch/index/reindex/RestDeleteByQueryAction.java

@@ -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

modules/reindex/src/main/java/org/elasticsearch/index/reindex/RestReindexAction.java

@@ -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

modules/reindex/src/main/java/org/elasticsearch/index/reindex/RestRethrottleAction.java

@@ -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

modules/reindex/src/main/java/org/elasticsearch/index/reindex/RestUpdateByQueryAction.java

@@ -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

modules/reindex/src/test/java/org/elasticsearch/index/reindex/RestDeleteByQueryActionTests.java

@@ -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 {

modules/reindex/src/test/java/org/elasticsearch/index/reindex/RestReindexActionTests.java

@@ -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 {

modules/reindex/src/test/java/org/elasticsearch/index/reindex/RestUpdateByQueryActionTests.java

@@ -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  {

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

@@ -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) {
+    @Override
-        controller.registerHandler(GET, "/_cat/example", this);
+    public List<Route> routes() {
-        controller.registerHandler(POST, "/_cat/example", this);
+        return unmodifiableList(asList(
+            new Route(GET, "/_cat/example"),
+            new Route(POST, "/_cat/example")));
     }
 
     @Override

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

@@ -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());
     }
 }

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

@@ -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 =
+        final RestGetRepositoriesAction action = new RestGetRepositoriesAction(getInstanceFromNode(SettingsFilter.class));
-            new RestGetRepositoriesAction(mock(RestController.class), getInstanceFromNode(SettingsFilter.class));
 
         final CountDownLatch latch = new CountDownLatch(1);
         final AtomicReference<AssertionError> error = new AtomicReference<>();

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

@@ -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());
     }
 
 }

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

@@ -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) {
+    RestDieWithDignityAction() {}
-        restController.registerHandler(RestRequest.Method.GET, "/_die_with_dignity", this);
+
+    @Override
+    public List<Route> routes() {
+        return singletonList(new Route(GET, "/_die_with_dignity"));
     }
 
     @Override

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

@@ -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,
+    @Override
-                                               DEPRECATED_ENDPOINT, deprecationLogger);
+    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 {

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

@@ -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

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

@@ -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());
     }
 }

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

@@ -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) {
+    @Override
-        controller.registerHandler(RestRequest.Method.GET, "/_protected", this);
+    public List<Route> routes() {
+        return singletonList(new Route(GET, "/_protected"));
     }
 
     @Override

server/src/main/java/org/elasticsearch/action/ActionModule.java

@@ -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 -> {
+        Consumer<RestHandler> registerHandler = handler -> {
-            if (a instanceof AbstractCatAction) {
+            if (handler instanceof AbstractCatAction) {
-                catActions.add((AbstractCatAction) a);
+                catActions.add((AbstractCatAction) handler);
             }
+            restController.registerHandler(handler);
         };
-        registerHandler.accept(new RestAddVotingConfigExclusionAction(restController));
+        registerHandler.accept(new RestAddVotingConfigExclusionAction());
-        registerHandler.accept(new RestClearVotingConfigExclusionsAction(restController));
+        registerHandler.accept(new RestClearVotingConfigExclusionsAction());
-        registerHandler.accept(new RestMainAction(restController));
+        registerHandler.accept(new RestMainAction());
-        registerHandler.accept(new RestNodesInfoAction(restController, settingsFilter));
+        registerHandler.accept(new RestNodesInfoAction(settingsFilter));
-        registerHandler.accept(new RestRemoteClusterInfoAction(restController));
+        registerHandler.accept(new RestRemoteClusterInfoAction());
-        registerHandler.accept(new RestNodesStatsAction(restController));
+        registerHandler.accept(new RestNodesStatsAction());
-        registerHandler.accept(new RestNodesUsageAction(restController));
+        registerHandler.accept(new RestNodesUsageAction());
-        registerHandler.accept(new RestNodesHotThreadsAction(restController));
+        registerHandler.accept(new RestNodesHotThreadsAction());
-        registerHandler.accept(new RestClusterAllocationExplainAction(restController));
+        registerHandler.accept(new RestClusterAllocationExplainAction());
-        registerHandler.accept(new RestClusterStatsAction(restController));
+        registerHandler.accept(new RestClusterStatsAction());
-        registerHandler.accept(new RestClusterStateAction(restController, settingsFilter));
+        registerHandler.accept(new RestClusterStateAction(settingsFilter));
-        registerHandler.accept(new RestClusterHealthAction(restController));
+        registerHandler.accept(new RestClusterHealthAction());
-        registerHandler.accept(new RestClusterUpdateSettingsAction(restController));
+        registerHandler.accept(new RestClusterUpdateSettingsAction());
-        registerHandler.accept(new RestClusterGetSettingsAction(settings, restController, clusterSettings, settingsFilter));
+        registerHandler.accept(new RestClusterGetSettingsAction(settings, clusterSettings, settingsFilter));
-        registerHandler.accept(new RestClusterRerouteAction(restController, settingsFilter));
+        registerHandler.accept(new RestClusterRerouteAction(settingsFilter));
-        registerHandler.accept(new RestClusterSearchShardsAction(restController));
+        registerHandler.accept(new RestClusterSearchShardsAction());
-        registerHandler.accept(new RestPendingClusterTasksAction(restController));
+        registerHandler.accept(new RestPendingClusterTasksAction());
-        registerHandler.accept(new RestPutRepositoryAction(restController));
+        registerHandler.accept(new RestPutRepositoryAction());
-        registerHandler.accept(new RestGetRepositoriesAction(restController, settingsFilter));
+        registerHandler.accept(new RestGetRepositoriesAction(settingsFilter));
-        registerHandler.accept(new RestDeleteRepositoryAction(restController));
+        registerHandler.accept(new RestDeleteRepositoryAction());
-        registerHandler.accept(new RestVerifyRepositoryAction(restController));
+        registerHandler.accept(new RestVerifyRepositoryAction());
-        registerHandler.accept(new RestCleanupRepositoryAction(restController));
+        registerHandler.accept(new RestCleanupRepositoryAction());
-        registerHandler.accept(new RestGetSnapshotsAction(restController));
+        registerHandler.accept(new RestGetSnapshotsAction());
-        registerHandler.accept(new RestCreateSnapshotAction(restController));
+        registerHandler.accept(new RestCreateSnapshotAction());
-        registerHandler.accept(new RestRestoreSnapshotAction(restController));
+        registerHandler.accept(new RestRestoreSnapshotAction());
-        registerHandler.accept(new RestDeleteSnapshotAction(restController));
+        registerHandler.accept(new RestDeleteSnapshotAction());
-        registerHandler.accept(new RestSnapshotsStatusAction(restController));
+        registerHandler.accept(new RestSnapshotsStatusAction());
-        registerHandler.accept(new RestGetIndicesAction(restController));
+        registerHandler.accept(new RestGetIndicesAction());
-        registerHandler.accept(new RestIndicesStatsAction(restController));
+        registerHandler.accept(new RestIndicesStatsAction());
-        registerHandler.accept(new RestIndicesSegmentsAction(restController));
+        registerHandler.accept(new RestIndicesSegmentsAction());
-        registerHandler.accept(new RestIndicesShardStoresAction(restController));
+        registerHandler.accept(new RestIndicesShardStoresAction());
-        registerHandler.accept(new RestGetAliasesAction(restController));
+        registerHandler.accept(new RestGetAliasesAction());
-        registerHandler.accept(new RestIndexDeleteAliasesAction(restController));
+        registerHandler.accept(new RestIndexDeleteAliasesAction());
-        registerHandler.accept(new RestIndexPutAliasAction(restController));
+        registerHandler.accept(new RestIndexPutAliasAction());
-        registerHandler.accept(new RestIndicesAliasesAction(restController));
+        registerHandler.accept(new RestIndicesAliasesAction());
-        registerHandler.accept(new RestCreateIndexAction(restController));
+        registerHandler.accept(new RestCreateIndexAction());
-        registerHandler.accept(new RestResizeHandler.RestShrinkIndexAction(restController));
+        registerHandler.accept(new RestResizeHandler.RestShrinkIndexAction());
-        registerHandler.accept(new RestResizeHandler.RestSplitIndexAction(restController));
+        registerHandler.accept(new RestResizeHandler.RestSplitIndexAction());
-        registerHandler.accept(new RestResizeHandler.RestCloneIndexAction(restController));
+        registerHandler.accept(new RestResizeHandler.RestCloneIndexAction());
-        registerHandler.accept(new RestRolloverIndexAction(restController));
+        registerHandler.accept(new RestRolloverIndexAction());
-        registerHandler.accept(new RestDeleteIndexAction(restController));
+        registerHandler.accept(new RestDeleteIndexAction());
-        registerHandler.accept(new RestCloseIndexAction(restController));
+        registerHandler.accept(new RestCloseIndexAction());
-        registerHandler.accept(new RestOpenIndexAction(restController));
+        registerHandler.accept(new RestOpenIndexAction());
 
-        registerHandler.accept(new RestUpdateSettingsAction(restController));
+        registerHandler.accept(new RestUpdateSettingsAction());
-        registerHandler.accept(new RestGetSettingsAction(restController));
+        registerHandler.accept(new RestGetSettingsAction());
 
-        registerHandler.accept(new RestAnalyzeAction(restController));
+        registerHandler.accept(new RestAnalyzeAction());
-        registerHandler.accept(new RestGetIndexTemplateAction(restController));
+        registerHandler.accept(new RestGetIndexTemplateAction());
-        registerHandler.accept(new RestPutIndexTemplateAction(restController));
+        registerHandler.accept(new RestPutIndexTemplateAction());
-        registerHandler.accept(new RestDeleteIndexTemplateAction(restController));
+        registerHandler.accept(new RestDeleteIndexTemplateAction());
 
-        registerHandler.accept(new RestPutMappingAction(restController));
+        registerHandler.accept(new RestPutMappingAction());
-        registerHandler.accept(new RestGetMappingAction(restController));
+        registerHandler.accept(new RestGetMappingAction());
-        registerHandler.accept(new RestGetFieldMappingAction(restController));
+        registerHandler.accept(new RestGetFieldMappingAction());
 
-        registerHandler.accept(new RestRefreshAction(restController));
+        registerHandler.accept(new RestRefreshAction());
-        registerHandler.accept(new RestFlushAction(restController));
+        registerHandler.accept(new RestFlushAction());
-        registerHandler.accept(new RestSyncedFlushAction(restController));
+        registerHandler.accept(new RestSyncedFlushAction());
-        registerHandler.accept(new RestForceMergeAction(restController));
+        registerHandler.accept(new RestForceMergeAction());
-        registerHandler.accept(new RestUpgradeAction(restController));
+        registerHandler.accept(new RestUpgradeAction());
-        registerHandler.accept(new RestUpgradeStatusAction(restController));
+        registerHandler.accept(new RestUpgradeStatusAction());
-        registerHandler.accept(new RestClearIndicesCacheAction(restController));
+        registerHandler.accept(new RestClearIndicesCacheAction());
 
-        registerHandler.accept(new RestIndexAction(restController, clusterService));
+        registerHandler.accept(new RestIndexAction());
-        registerHandler.accept(new RestGetAction(restController));
+        registerHandler.accept(new CreateHandler());
-        registerHandler.accept(new RestGetSourceAction(restController));
+        registerHandler.accept(new AutoIdHandler(clusterService));
-        registerHandler.accept(new RestMultiGetAction(settings, restController));
+        registerHandler.accept(new RestGetAction());
-        registerHandler.accept(new RestDeleteAction(restController));
+        registerHandler.accept(new RestGetSourceAction());
-        registerHandler.accept(new RestCountAction(restController));
+        registerHandler.accept(new RestMultiGetAction(settings));
-        registerHandler.accept(new RestTermVectorsAction(restController));
+        registerHandler.accept(new RestDeleteAction());
-        registerHandler.accept(new RestMultiTermVectorsAction(restController));
+        registerHandler.accept(new RestCountAction());
-        registerHandler.accept(new RestBulkAction(settings, restController));
+        registerHandler.accept(new RestTermVectorsAction());
-        registerHandler.accept(new RestUpdateAction(restController));
+        registerHandler.accept(new RestMultiTermVectorsAction());
+        registerHandler.accept(new RestBulkAction(settings));
+        registerHandler.accept(new RestUpdateAction());
 
-        registerHandler.accept(new RestSearchAction(restController));
+        registerHandler.accept(new RestSearchAction());
-        registerHandler.accept(new RestSearchScrollAction(restController));
+        registerHandler.accept(new RestSearchScrollAction());
-        registerHandler.accept(new RestClearScrollAction(restController));
+        registerHandler.accept(new RestClearScrollAction());
-        registerHandler.accept(new RestMultiSearchAction(settings, restController));
+        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 RestGetStoredScriptAction());
-        registerHandler.accept(new RestPutStoredScriptAction(restController));
+        registerHandler.accept(new RestPutStoredScriptAction());
-        registerHandler.accept(new RestDeleteStoredScriptAction(restController));
+        registerHandler.accept(new RestDeleteStoredScriptAction());
-        registerHandler.accept(new RestGetScriptContextAction(restController));
+        registerHandler.accept(new RestGetScriptContextAction());
-        registerHandler.accept(new RestGetScriptLanguageAction(restController));
+        registerHandler.accept(new RestGetScriptLanguageAction());
 
-        registerHandler.accept(new RestFieldCapabilitiesAction(restController));
+        registerHandler.accept(new RestFieldCapabilitiesAction());
 
         // Tasks API
-        registerHandler.accept(new RestListTasksAction(restController, nodesInCluster));
+        registerHandler.accept(new RestListTasksAction(nodesInCluster));
-        registerHandler.accept(new RestGetTaskAction(restController));
+        registerHandler.accept(new RestGetTaskAction());
-        registerHandler.accept(new RestCancelTasksAction(restController, nodesInCluster));
+        registerHandler.accept(new RestCancelTasksAction(nodesInCluster));
 
         // Ingest API
-        registerHandler.accept(new RestPutPipelineAction(restController));
+        registerHandler.accept(new RestPutPipelineAction());
-        registerHandler.accept(new RestGetPipelineAction(restController));
+        registerHandler.accept(new RestGetPipelineAction());
-        registerHandler.accept(new RestDeletePipelineAction(restController));
+        registerHandler.accept(new RestDeletePipelineAction());
-        registerHandler.accept(new RestSimulatePipelineAction(restController));
+        registerHandler.accept(new RestSimulatePipelineAction());
 
         // CAT API
-        registerHandler.accept(new RestAllocationAction(restController));
+        registerHandler.accept(new RestAllocationAction());
-        registerHandler.accept(new RestShardsAction(restController));
+        registerHandler.accept(new RestShardsAction());
-        registerHandler.accept(new RestMasterAction(restController));
+        registerHandler.accept(new RestMasterAction());
-        registerHandler.accept(new RestNodesAction(restController));
+        registerHandler.accept(new RestNodesAction());
-        registerHandler.accept(new RestTasksAction(restController, nodesInCluster));
+        registerHandler.accept(new RestTasksAction(nodesInCluster));
-        registerHandler.accept(new RestIndicesAction(restController));
+        registerHandler.accept(new RestIndicesAction());
-        registerHandler.accept(new RestSegmentsAction(restController));
+        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 RestCatRecoveryAction());
-        registerHandler.accept(new RestHealthAction(restController));
+        registerHandler.accept(new RestHealthAction());
-        registerHandler.accept(new org.elasticsearch.rest.action.cat.RestPendingClusterTasksAction(restController));
+        registerHandler.accept(new org.elasticsearch.rest.action.cat.RestPendingClusterTasksAction());
-        registerHandler.accept(new RestAliasAction(restController));
+        registerHandler.accept(new RestAliasAction());
-        registerHandler.accept(new RestThreadPoolAction(restController));
+        registerHandler.accept(new RestThreadPoolAction());
-        registerHandler.accept(new RestPluginsAction(restController));
+        registerHandler.accept(new RestPluginsAction());
-        registerHandler.accept(new RestFielddataAction(restController));
+        registerHandler.accept(new RestFielddataAction());
-        registerHandler.accept(new RestNodeAttrsAction(restController));
+        registerHandler.accept(new RestNodeAttrsAction());
-        registerHandler.accept(new RestRepositoriesAction(restController));
+        registerHandler.accept(new RestRepositoriesAction());
-        registerHandler.accept(new RestSnapshotAction(restController));
+        registerHandler.accept(new RestSnapshotAction());
-        registerHandler.accept(new RestTemplatesAction(restController));
+        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

server/src/main/java/org/elasticsearch/common/collect/MapBuilder.java

@@ -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<>();

server/src/main/java/org/elasticsearch/rest/BaseRestHandler.java

@@ -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

server/src/main/java/org/elasticsearch/rest/RestController.java

@@ -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")) {

server/src/main/java/org/elasticsearch/rest/RestHandler.java

@@ -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;
+        }
+    }
 }

server/src/main/java/org/elasticsearch/rest/action/RestFieldCapabilitiesAction.java

@@ -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) {
+    @Override
-        controller.registerHandler(GET, "/_field_caps", this);
+    public List<Route> routes() {
-        controller.registerHandler(POST, "/_field_caps", this);
+        return unmodifiableList(asList(
-        controller.registerHandler(GET, "/{index}/_field_caps", this);
+            new Route(GET, "/_field_caps"),
-        controller.registerHandler(POST, "/{index}/_field_caps", this);
+            new Route(POST, "/_field_caps"),
+            new Route(GET, "/{index}/_field_caps"),
+            new Route(POST, "/{index}/_field_caps")));
     }
 
     @Override

server/src/main/java/org/elasticsearch/rest/action/RestMainAction.java

@@ -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);
+    @Override
-        controller.registerHandler(HEAD, "/", this);
+    public List<Route> routes() {
+        return unmodifiableList(asList(
+            new Route(GET, "/"),
+            new Route(HEAD, "/")));
     }
 
     @Override

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

@@ -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);

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

@@ -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"));

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

@@ -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) {
+    @Override
-        controller.registerHandler(POST, "/_snapshot/{repository}/_cleanup", this);
+    public List<Route> routes() {
+        return singletonList(new Route(POST, "/_snapshot/{repository}/_cleanup"));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(RestRequest.Method.DELETE, "/_cluster/voting_config_exclusions", this);
+    public List<Route> routes() {
+        return singletonList(new Route(DELETE, "/_cluster/voting_config_exclusions"));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(RestRequest.Method.GET, "/_cluster/allocation/explain", this);
+    public List<Route> routes() {
-        controller.registerHandler(RestRequest.Method.POST, "/_cluster/allocation/explain", this);
+        return unmodifiableList(asList(
+            new Route(GET, "/_cluster/allocation/explain"),
+            new Route(POST, "/_cluster/allocation/explain")));
     }
 
     @Override

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

@@ -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,
+    public RestClusterGetSettingsAction(Settings settings, ClusterSettings clusterSettings, SettingsFilter settingsFilter) {
-            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";

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

@@ -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) {
+    @Override
-        controller.registerHandler(RestRequest.Method.GET, "/_cluster/health", this);
+    public List<Route> routes() {
-        controller.registerHandler(RestRequest.Method.GET, "/_cluster/health/{index}", this);
+        return unmodifiableList(asList(new Route(GET, "/_cluster/health"),
+            new Route(GET, "/_cluster/health/{index}")));
     }
 
     @Override

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

@@ -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

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

@@ -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) {
+    @Override
-        controller.registerHandler(GET, "/_search_shards", this);
+    public List<Route> routes() {
-        controller.registerHandler(POST, "/_search_shards", this);
+        return unmodifiableList(asList(
-        controller.registerHandler(GET, "/{index}/_search_shards", this);
+            new Route(GET, "/_search_shards"),
-        controller.registerHandler(POST, "/{index}/_search_shards", this);
+            new Route(POST, "/_search_shards"),
+            new Route(GET, "/{index}/_search_shards"),
+            new Route(POST, "/{index}/_search_shards")));
     }
 
     @Override

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

@@ -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) {
+    public RestClusterStateAction(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);
-
         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();

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

@@ -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) {
+    @Override
-        controller.registerHandler(RestRequest.Method.GET, "/_cluster/stats", this);
+    public List<Route> routes() {
-        controller.registerHandler(RestRequest.Method.GET, "/_cluster/stats/nodes/{nodeId}", this);
+        return unmodifiableList(asList(
+            new Route(GET, "/_cluster/stats"),
+            new Route(GET, "/_cluster/stats/nodes/{nodeId}")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(RestRequest.Method.PUT, "/_cluster/settings", this);
+    public List<Route> routes() {
+        return singletonList(new Route(PUT, "/_cluster/settings"));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(PUT, "/_snapshot/{repository}/{snapshot}", this);
+    public List<Route> routes() {
-        controller.registerHandler(POST, "/_snapshot/{repository}/{snapshot}", this);
+        return unmodifiableList(asList(
+            new Route(PUT, "/_snapshot/{repository}/{snapshot}"),
+            new Route(POST, "/_snapshot/{repository}/{snapshot}")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(DELETE, "/_snapshot/{repository}", this);
+    public List<Route> routes() {
+        return singletonList(new Route(DELETE, "/_snapshot/{repository}"));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(DELETE, "/_snapshot/{repository}/{snapshot}", this);
+    public List<Route> routes() {
+        return singletonList(new Route(DELETE, "/_snapshot/{repository}/{snapshot}"));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(DELETE, "/_scripts/{id}", this);
+    public List<Route> routes() {
+        return singletonList(new Route(DELETE, "/_scripts/{id}"));
     }
 
     @Override

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

@@ -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) {
+    public RestGetRepositoriesAction(SettingsFilter settingsFilter) {
-        controller.registerHandler(GET, "/_snapshot", this);
-        controller.registerHandler(GET, "/_snapshot/{repository}", this);
         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);

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

@@ -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) {
+    @Override
-        controller.registerHandler(GET, "/_script_context", this);
+    public List<Route> routes() {
+        return singletonList(new Route(GET, "/_script_context"));
     }
 
     @Override public String getName() {

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

@@ -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) {
+    @Override
-        controller.registerHandler(GET, "/_script_language", this);
+    public List<Route> routes() {
+        return singletonList(new Route(GET, "/_script_language"));
     }
 
     @Override public String getName() {

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

@@ -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) {
+    @Override
-        controller.registerHandler(GET, "/_snapshot/{repository}/{snapshot}", this);
+    public List<Route> routes() {
+        return singletonList(new Route(GET, "/_snapshot/{repository}/{snapshot}"));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(GET, "/_scripts/{id}", this);
+    public List<Route> routes() {
+        return singletonList(new Route(GET, "/_scripts/{id}"));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(GET, "/_tasks/{task_id}", this);
+    public List<Route> routes() {
+        return singletonList(new Route(GET, "/_tasks/{task_id}"));
     }
 
     @Override

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

@@ -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

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

@@ -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) {
+    @Override
-        controller.registerHandler(RestRequest.Method.GET, "/_cluster/nodes/hotthreads", this);
+    public List<Route> routes() {
-        controller.registerHandler(RestRequest.Method.GET, "/_cluster/nodes/hot_threads", this);
+        return unmodifiableList(asList(
-        controller.registerHandler(RestRequest.Method.GET, "/_cluster/nodes/{nodeId}/hotthreads", this);
+            new Route(GET, "/_cluster/nodes/hotthreads"),
-        controller.registerHandler(RestRequest.Method.GET, "/_cluster/nodes/{nodeId}/hot_threads", this);
+            new Route(GET, "/_cluster/nodes/hot_threads"),
-
+            new Route(GET, "/_cluster/nodes/{nodeId}/hotthreads"),
-        controller.registerHandler(RestRequest.Method.GET, "/_nodes/hotthreads", this);
+            new Route(GET, "/_cluster/nodes/{nodeId}/hot_threads"),
-        controller.registerHandler(RestRequest.Method.GET, "/_nodes/hot_threads", this);
+            new Route(GET, "/_nodes/hotthreads"),
-        controller.registerHandler(RestRequest.Method.GET, "/_nodes/{nodeId}/hotthreads", this);
+            new Route(GET, "/_nodes/hot_threads"),
-        controller.registerHandler(RestRequest.Method.GET, "/_nodes/{nodeId}/hot_threads", this);
+            new Route(GET, "/_nodes/{nodeId}/hotthreads"),
+            new Route(GET, "/_nodes/{nodeId}/hot_threads")));
     }
 
     @Override

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

@@ -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) {
+    public RestNodesInfoAction(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);
-
         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";

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

@@ -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) {
+    @Override
-        controller.registerHandler(GET, "/_nodes/stats", this);
+    public List<Route> routes() {
-        controller.registerHandler(GET, "/_nodes/{nodeId}/stats", this);
+        return unmodifiableList(asList(
-
+            new Route(GET, "/_nodes/stats"),
-        controller.registerHandler(GET, "/_nodes/stats/{metric}", this);
+            new Route(GET, "/_nodes/{nodeId}/stats"),
-        controller.registerHandler(GET, "/_nodes/{nodeId}/stats/{metric}", this);
+            new Route(GET, "/_nodes/stats/{metric}"),
-
+            new Route(GET, "/_nodes/{nodeId}/stats/{metric}"),
-        controller.registerHandler(GET, "/_nodes/stats/{metric}/{index_metric}", this);
+            new Route(GET, "/_nodes/stats/{metric}/{index_metric}"),
-
+            new Route(GET, "/_nodes/{nodeId}/stats/{metric}/{index_metric}")));
-        controller.registerHandler(GET, "/_nodes/{nodeId}/stats/{metric}/{index_metric}", this);
     }
 
     static final Map<String, Consumer<NodesStatsRequest>> METRICS;

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

@@ -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
+    @Override
-    public RestNodesUsageAction(RestController controller) {
+    public List<Route> routes() {
-        controller.registerHandler(GET, "/_nodes/usage", this);
+        return unmodifiableList(asList(
-        controller.registerHandler(GET, "/_nodes/{nodeId}/usage", this);
+            new Route(GET, "/_nodes/usage"),
-
+            new Route(GET, "/_nodes/{nodeId}/usage"),
-        controller.registerHandler(GET, "/_nodes/usage/{metric}", this);
+            new Route(GET, "/_nodes/usage/{metric}"),
-        controller.registerHandler(GET, "/_nodes/{nodeId}/usage/{metric}", this);
+            new Route(GET, "/_nodes/{nodeId}/usage/{metric}")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(RestRequest.Method.GET, "/_cluster/pending_tasks", this);
+    public List<Route> routes() {
+        return singletonList(new Route(GET, "/_cluster/pending_tasks"));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(PUT, "/_snapshot/{repository}", this);
+    public List<Route> routes() {
-        controller.registerHandler(POST, "/_snapshot/{repository}", this);
+        return unmodifiableList(asList(
+            new Route(POST, "/_snapshot/{repository}"),
+            new Route(PUT, "/_snapshot/{repository}")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(POST, "/_scripts/{id}", this);
+    public List<Route> routes() {
-        controller.registerHandler(PUT, "/_scripts/{id}", this);
+        return unmodifiableList(asList(
-        controller.registerHandler(POST, "/_scripts/{id}/{context}", this);
+            new Route(POST, "/_scripts/{id}"),
-        controller.registerHandler(PUT, "/_scripts/{id}/{context}", this);
+            new Route(PUT, "/_scripts/{id}"),
+            new Route(POST, "/_scripts/{id}/{context}"),
+            new Route(PUT, "/_scripts/{id}/{context}")));
     }
 
     @Override

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

@@ -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"));

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

@@ -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) {
+    @Override
-        controller.registerHandler(GET, "_remote/info", this);
+    public List<Route> routes() {
+        return singletonList(new Route(GET, "_remote/info"));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(POST, "/_snapshot/{repository}/{snapshot}/_restore", this);
+    public List<Route> routes() {
+        return singletonList(new Route(POST, "/_snapshot/{repository}/{snapshot}/_restore"));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(GET, "/_snapshot/{repository}/{snapshot}/_status", this);
+    public List<Route> routes() {
-        controller.registerHandler(GET, "/_snapshot/{repository}/_status", this);
+        return unmodifiableList(asList(
-        controller.registerHandler(GET, "/_snapshot/_status", this);
+            new Route(GET, "/_snapshot/{repository}/{snapshot}/_status"),
+            new Route(GET, "/_snapshot/{repository}/_status"),
+            new Route(GET, "/_snapshot/_status")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(POST, "/_snapshot/{repository}/_verify", this);
+    public List<Route> routes() {
+        return singletonList(new Route(POST, "/_snapshot/{repository}/_verify"));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(GET, "/_analyze", this);
+    public List<Route> routes() {
-        controller.registerHandler(GET, "/{index}/_analyze", this);
+        return unmodifiableList(asList(
-        controller.registerHandler(POST, "/_analyze", this);
+            new Route(GET, "/_analyze"),
-        controller.registerHandler(POST, "/{index}/_analyze", this);
+            new Route(POST, "/_analyze"),
+            new Route(GET, "/{index}/_analyze"),
+            new Route(POST, "/{index}/_analyze")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(POST, "/_cache/clear", this);
+    public List<Route> routes() {
-        controller.registerHandler(POST, "/{index}/_cache/clear", this);
+        return unmodifiableList(asList(
+            new Route(POST, "/_cache/clear"),
+            new Route(POST, "/{index}/_cache/clear")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(RestRequest.Method.POST, "/_close", this);
+    public List<Route> routes() {
-        controller.registerHandler(RestRequest.Method.POST, "/{index}/_close", this);
+        return unmodifiableList(asList(
+            new Route(POST, "/_close"),
+            new Route(POST, "/{index}/_close")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(RestRequest.Method.PUT, "/{index}", this);
+    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;
     }
 }

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

@@ -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) {
+    @Override
-        controller.registerHandler(RestRequest.Method.DELETE, "/", this);
+    public List<Route> routes() {
-        controller.registerHandler(RestRequest.Method.DELETE, "/{index}", this);
+        return unmodifiableList(asList(
+            new Route(DELETE, "/"),
+            new Route(DELETE, "/{index}")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(RestRequest.Method.DELETE, "/_template/{name}", this);
+    public List<Route> routes() {
+        return singletonList(new Route(DELETE, "/_template/{name}"));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(POST, "/_flush", this);
+    public List<Route> routes() {
-        controller.registerHandler(POST, "/{index}/_flush", this);
+        return unmodifiableList(asList(
-
+            new Route(GET, "/_flush"),
-        controller.registerHandler(GET, "/_flush", this);
+            new Route(POST, "/_flush"),
-        controller.registerHandler(GET, "/{index}/_flush", this);
+            new Route(GET, "/{index}/_flush"),
+            new Route(POST, "/{index}/_flush")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(POST, "/_forcemerge", this);
+    public List<Route> routes() {
-        controller.registerHandler(POST, "/{index}/_forcemerge", this);
+        return unmodifiableList(asList(
+            new Route(POST, "/_forcemerge"),
+            new Route(POST, "/{index}/_forcemerge")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(GET, "/_alias", this);
+    public List<Route> routes() {
-        controller.registerHandler(GET, "/_aliases", this);
+        return unmodifiableList(asList(
-        controller.registerHandler(GET, "/_alias/{name}", this);
+            new Route(GET, "/_alias"),
-        controller.registerHandler(HEAD, "/_alias/{name}", this);
+            new Route(GET, "/_aliases"),
-        controller.registerHandler(GET, "/{index}/_alias", this);
+            new Route(GET, "/_alias/{name}"),
-        controller.registerHandler(HEAD, "/{index}/_alias", this);
+            new Route(HEAD, "/_alias/{name}"),
-        controller.registerHandler(GET, "/{index}/_alias/{name}", this);
+            new Route(GET, "/{index}/_alias"),
-        controller.registerHandler(HEAD, "/{index}/_alias/{name}", this);
+            new Route(HEAD, "/{index}/_alias"),
+            new Route(GET, "/{index}/_alias/{name}"),
+            new Route(HEAD, "/{index}/_alias/{name}")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(GET, "/_mapping/field/{fields}", this);
+    public List<Route> routes() {
-        controller.registerHandler(GET, "/_mapping/{type}/field/{fields}", this);
+        return unmodifiableList(asList(
-        controller.registerHandler(GET, "/{index}/_mapping/field/{fields}", this);
+            new Route(GET, "/_mapping/field/{fields}"),
-        controller.registerHandler(GET, "/{index}/{type}/_mapping/field/{fields}", this);
+            new Route(GET, "/_mapping/{type}/field/{fields}"),
-        controller.registerHandler(GET, "/{index}/_mapping/{type}/field/{fields}", this);
+            new Route(GET, "/{index}/_mapping/field/{fields}"),
+            new Route(GET, "/{index}/{type}/_mapping/field/{fields}"),
+            new Route(GET, "/{index}/_mapping/{type}/field/{fields}")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(GET, "/_template", this);
+    public List<Route> routes() {
-        controller.registerHandler(GET, "/_template/{name}", this);
+        return unmodifiableList(asList(
-        controller.registerHandler(HEAD, "/_template/{name}", this);
+            new Route(GET, "/_template"),
+            new Route(GET, "/_template/{name}"),
+            new Route(HEAD, "/_template/{name}")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(GET, "/{index}", this);
+    public List<Route> routes() {
-        controller.registerHandler(HEAD, "/{index}", this);
+        return unmodifiableList(asList(
+            new Route(GET, "/{index}"),
+            new Route(HEAD, "/{index}")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(GET, "/_mapping", this);
+    public List<Route> routes() {
-        controller.registerHandler(GET, "/_mappings", this);
+        return unmodifiableList(asList(
-        controller.registerHandler(GET, "/{index}/{type}/_mapping", this);
+            new Route(GET, "/_mapping"),
-        controller.registerHandler(GET, "/{index}/_mappings", this);
+            new Route(GET, "/_mappings"),
-        controller.registerHandler(GET, "/{index}/_mapping", this);
+            new Route(GET, "/{index}/{type}/_mapping"),
-        controller.registerHandler(GET, "/{index}/_mappings/{type}", this);
+            new Route(GET, "/{index}/_mapping"),
-        controller.registerHandler(GET, "/{index}/_mapping/{type}", this);
+            new Route(GET, "/{index}/_mappings"),
-        controller.registerHandler(HEAD, "/{index}/_mapping/{type}", this);
+            new Route(GET, "/{index}/_mappings/{type}"),
-        controller.registerHandler(GET, "/_mapping/{type}", this);
+            new Route(GET, "/{index}/_mapping/{type}"),
+            new Route(HEAD, "/{index}/_mapping/{type}"),
+            new Route(GET, "/_mapping/{type}")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(GET, "/_settings", this);
+    public List<Route> routes() {
-        controller.registerHandler(GET, "/_settings/{name}", this);
+        return unmodifiableList(asList(
-        controller.registerHandler(GET, "/{index}/_settings", this);
+            new Route(GET, "/_settings"),
-        controller.registerHandler(GET, "/{index}/_settings/{name}", this);
+            new Route(GET, "/_settings/{name}"),
-        controller.registerHandler(GET, "/{index}/_setting/{name}", this);
+            new Route(GET, "/{index}/_settings"),
+            new Route(GET, "/{index}/_settings/{name}"),
+            new Route(GET, "/{index}/_setting/{name}")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(DELETE, "/{index}/_alias/{name}", this);
+    public List<Route> routes() {
-        controller.registerHandler(DELETE, "/{index}/_aliases/{name}", this);
+        return unmodifiableList(asList(
+            new Route(DELETE, "/{index}/_alias/{name}"),
+            new Route(DELETE, "/{index}/_aliases/{name}")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(PUT, "/{index}/_alias/{name}", this);
+    public List<Route> routes() {
-        controller.registerHandler(PUT, "/_alias/{name}", this);
+        return unmodifiableList(asList(
-        controller.registerHandler(PUT, "/{index}/_aliases/{name}", this);
+            new Route(POST, "/{index}/_alias/{name}"),
-        controller.registerHandler(PUT, "/_aliases/{name}", this);
+            new Route(PUT, "/{index}/_alias/{name}"),
-        controller.registerHandler(PUT, "/{index}/_alias", this);
+            new Route(POST, "/_alias/{name}"),
-        controller.registerHandler(PUT, "/_alias", this);
+            new Route(PUT, "/_alias/{name}"),
-
+            new Route(POST, "/{index}/_aliases/{name}"),
-        controller.registerHandler(POST, "/{index}/_alias/{name}", this);
+            new Route(PUT, "/{index}/_aliases/{name}"),
-        controller.registerHandler(POST, "/_alias/{name}", this);
+            new Route(POST, "/_aliases/{name}"),
-        controller.registerHandler(POST, "/{index}/_aliases/{name}", this);
+            new Route(PUT, "/_aliases/{name}"),
-        controller.registerHandler(POST, "/_aliases/{name}", this);
+            new Route(PUT, "/{index}/_alias"),
-        controller.registerHandler(PUT, "/{index}/_aliases", this);
+            new Route(PUT, "/{index}/_aliases"),
-        //we cannot add POST for "/_aliases" because this is the _aliases api already defined in RestIndicesAliasesAction
+            new Route(PUT, "/_alias")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(POST, "/_aliases", this);
+    public List<Route> routes() {
+        return singletonList(new Route(POST, "/_aliases"));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(GET, "/_segments", this);
+    public List<Route> routes() {
-        controller.registerHandler(GET, "/{index}/_segments", this);
+        return unmodifiableList(asList(
+            new Route(GET, "/_segments"),
+            new Route(GET, "/{index}/_segments")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(GET, "/_shard_stores", this);
+    public List<Route> routes() {
-        controller.registerHandler(GET, "/{index}/_shard_stores", this);
+        return unmodifiableList(asList(
+            new Route(GET, "/_shard_stores"),
+            new Route(GET, "/{index}/_shard_stores")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(GET, "/_stats", this);
+    public List<Route> routes() {
-        controller.registerHandler(GET, "/_stats/{metric}", this);
+        return unmodifiableList(asList(
-        controller.registerHandler(GET, "/{index}/_stats", this);
+            new Route(GET, "/_stats"),
-        controller.registerHandler(GET, "/{index}/_stats/{metric}", this);
+            new Route(GET, "/_stats/{metric}"),
+            new Route(GET, "/{index}/_stats"),
+            new Route(GET, "/{index}/_stats/{metric}")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(RestRequest.Method.POST, "/_open", this);
+    public List<Route> routes() {
-        controller.registerHandler(RestRequest.Method.POST, "/{index}/_open", this);
+        return unmodifiableList(asList(
+            new Route(POST, "/_open"),
+            new Route(POST, "/{index}/_open")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(RestRequest.Method.PUT, "/_template/{name}", this);
+    public List<Route> routes() {
-        controller.registerHandler(RestRequest.Method.POST, "/_template/{name}", this);
+        return unmodifiableList(asList(
+            new Route(POST, "/_template/{name}"),
+            new Route(PUT, "/_template/{name}")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(PUT, "/{index}/_mapping/", this);
+    public List<Route> routes() {
-        controller.registerHandler(PUT, "/{index}/{type}/_mapping", this);
+        return unmodifiableList(asList(
-        controller.registerHandler(PUT, "/{index}/_mapping/{type}", this);
+            new Route(POST, "/{index}/_mapping/"),
-        controller.registerHandler(PUT, "/_mapping/{type}", this);
+            new Route(PUT, "/{index}/_mapping/"),
-
+            new Route(POST, "/{index}/{type}/_mapping"),
-        controller.registerHandler(POST, "/{index}/_mapping/", this);
+            new Route(PUT, "/{index}/{type}/_mapping"),
-        controller.registerHandler(POST, "/{index}/{type}/_mapping", this);
+            new Route(POST, "/{index}/_mapping/{type}"),
-        controller.registerHandler(POST, "/{index}/_mapping/{type}", this);
+            new Route(PUT, "/{index}/_mapping/{type}"),
-        controller.registerHandler(POST, "/_mapping/{type}", this);
+            new Route(POST, "/_mapping/{type}"),
-
+            new Route(PUT, "/_mapping/{type}"),
-        //register the same paths, but with plural form _mappings
+            new Route(POST, "/{index}/_mappings/"),
-        controller.registerHandler(PUT, "/{index}/_mappings/", this);
+            new Route(PUT, "/{index}/_mappings/"),
-        controller.registerHandler(PUT, "/{index}/{type}/_mappings", this);
+            new Route(POST, "/{index}/{type}/_mappings"),
-        controller.registerHandler(PUT, "/{index}/_mappings/{type}", this);
+            new Route(PUT, "/{index}/{type}/_mappings"),
-        controller.registerHandler(PUT, "/_mappings/{type}", this);
+            new Route(POST, "/{index}/_mappings/{type}"),
-
+            new Route(PUT, "/{index}/_mappings/{type}"),
-        controller.registerHandler(POST, "/{index}/_mappings/", this);
+            new Route(POST, "/_mappings/{type}"),
-        controller.registerHandler(POST, "/{index}/{type}/_mappings", this);
+            new Route(PUT, "/_mappings/{type}")));
-        controller.registerHandler(POST, "/{index}/_mappings/{type}", this);
-        controller.registerHandler(POST, "/_mappings/{type}", this);
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(GET, "/_recovery", this);
+    public List<Route> routes() {
-        controller.registerHandler(GET, "/{index}/_recovery", this);
+        return unmodifiableList(asList(
+            new Route(GET, "/_recovery"),
+            new Route(GET, "/{index}/_recovery")));
     }
 
     @Override

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

@@ -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) {
+    @Override
-        controller.registerHandler(POST, "/_refresh", this);
+    public List<Route> routes() {
-        controller.registerHandler(POST, "/{index}/_refresh", this);
+        return unmodifiableList(asList(
-
+            new Route(GET, "/_refresh"),
-        controller.registerHandler(GET, "/_refresh", this);
+            new Route(POST, "/_refresh"),
-        controller.registerHandler(GET, "/{index}/_refresh", this);
+            new Route(GET, "/{index}/_refresh"),
+            new Route(POST, "/{index}/_refresh")));
     }
 
     @Override