Merge ShardSearchTransportRequest and ShardSearchLocalRequest (#46996) (#47081)

This change merges the `ShardSearchTransportRequest` and `ShardSearchLocalRequest`
into a single `ShardSearchRequest` that can be used to create a SearchContext.

Relates #46523

server/src/main/java/org/elasticsearch/action/admin/indices/validate/query/TransportValidateQueryAction.java

@@ -46,7 +46,7 @@ import org.elasticsearch.indices.IndexClosedException;
 import org.elasticsearch.search.SearchService;
 import org.elasticsearch.search.internal.AliasFilter;
 import org.elasticsearch.search.internal.SearchContext;
-import org.elasticsearch.search.internal.ShardSearchLocalRequest;
+import org.elasticsearch.search.internal.ShardSearchRequest;
 import org.elasticsearch.tasks.Task;
 import org.elasticsearch.threadpool.ThreadPool;
 import org.elasticsearch.transport.TransportService;
@@ -194,7 +194,7 @@ public class TransportValidateQueryAction extends TransportBroadcastAction<
         boolean valid;
         String explanation = null;
         String error = null;
-        ShardSearchLocalRequest shardSearchLocalRequest = new ShardSearchLocalRequest(request.shardId(), request.types(),
+        ShardSearchRequest shardSearchLocalRequest = new ShardSearchRequest(request.shardId(), request.types(),
             request.nowInMillis(), request.filteringAliases());
         SearchContext searchContext = searchService.createSearchContext(shardSearchLocalRequest, SearchService.NO_TIMEOUT);
         try {

server/src/main/java/org/elasticsearch/action/explain/TransportExplainAction.java

@@ -45,7 +45,7 @@ import org.elasticsearch.index.shard.ShardId;
 import org.elasticsearch.search.SearchService;
 import org.elasticsearch.search.internal.AliasFilter;
 import org.elasticsearch.search.internal.SearchContext;
-import org.elasticsearch.search.internal.ShardSearchLocalRequest;
+import org.elasticsearch.search.internal.ShardSearchRequest;
 import org.elasticsearch.search.rescore.RescoreContext;
 import org.elasticsearch.search.rescore.Rescorer;
 import org.elasticsearch.tasks.Task;
@@ -116,7 +116,7 @@ public class TransportExplainAction extends TransportSingleShardAction<ExplainRe
         } else {
             types = new String[] { request.type() };
         }
-        ShardSearchLocalRequest shardSearchLocalRequest = new ShardSearchLocalRequest(shardId,
+        ShardSearchRequest shardSearchLocalRequest = new ShardSearchRequest(shardId,
                 types, request.nowInMillis, request.filteringAlias());
         SearchContext context = searchService.createSearchContext(shardSearchLocalRequest, SearchService.NO_TIMEOUT);
         Engine.GetResult result = null;

server/src/main/java/org/elasticsearch/action/search/AbstractSearchAsyncAction.java

@@ -36,7 +36,7 @@ import org.elasticsearch.search.SearchShardTarget;
 import org.elasticsearch.search.internal.AliasFilter;
 import org.elasticsearch.search.internal.InternalSearchResponse;
 import org.elasticsearch.search.internal.SearchContext;
-import org.elasticsearch.search.internal.ShardSearchTransportRequest;
+import org.elasticsearch.search.internal.ShardSearchRequest;
 import org.elasticsearch.transport.Transport;
 
 import java.util.Collections;
@@ -335,14 +335,14 @@ abstract class AbstractSearchAsyncAction<Result extends SearchPhaseResult> exten
     }
 
     @Override
-    public final ShardSearchTransportRequest buildShardSearchRequest(SearchShardIterator shardIt) {
+    public final ShardSearchRequest buildShardSearchRequest(SearchShardIterator shardIt) {
         AliasFilter filter = aliasFilter.get(shardIt.shardId().getIndex().getUUID());
         assert filter != null;
         float indexBoost = concreteIndexBoosts.getOrDefault(shardIt.shardId().getIndex().getUUID(), DEFAULT_INDEX_BOOST);
         String indexName = shardIt.shardId().getIndex().getName();
         final String[] routings = indexRoutings.getOrDefault(indexName, Collections.emptySet())
             .toArray(new String[0]);
-        return new ShardSearchTransportRequest(shardIt.getOriginalIndices(), request, shardIt.shardId(), getNumShards(),
+        return new ShardSearchRequest(shardIt.getOriginalIndices(), request, shardIt.shardId(), getNumShards(),
             filter, indexBoost, timeProvider.getAbsoluteStartMillis(), shardIt.getClusterAlias(), routings);
     }
 

server/src/main/java/org/elasticsearch/action/search/SearchPhaseContext.java

@@ -23,7 +23,7 @@ import org.elasticsearch.action.OriginalIndices;
 import org.elasticsearch.common.Nullable;
 import org.elasticsearch.search.SearchShardTarget;
 import org.elasticsearch.search.internal.InternalSearchResponse;
-import org.elasticsearch.search.internal.ShardSearchTransportRequest;
+import org.elasticsearch.search.internal.ShardSearchRequest;
 import org.elasticsearch.transport.Transport;
 
 import java.util.concurrent.Executor;
@@ -109,7 +109,7 @@ interface SearchPhaseContext extends Executor {
     /**
      * Builds an request for the initial search phase.
      */
-    ShardSearchTransportRequest buildShardSearchRequest(SearchShardIterator shardIt);
+    ShardSearchRequest buildShardSearchRequest(SearchShardIterator shardIt);
 
     /**
      * Processes the phase transition from on phase to another. This method handles all errors that happen during the initial run execution

server/src/main/java/org/elasticsearch/action/search/SearchTransportService.java

@@ -41,7 +41,6 @@ import org.elasticsearch.search.fetch.ShardFetchRequest;
 import org.elasticsearch.search.fetch.ShardFetchSearchRequest;
 import org.elasticsearch.search.internal.InternalScrollSearchRequest;
 import org.elasticsearch.search.internal.ShardSearchRequest;
-import org.elasticsearch.search.internal.ShardSearchTransportRequest;
 import org.elasticsearch.search.query.QuerySearchRequest;
 import org.elasticsearch.search.query.QuerySearchResult;
 import org.elasticsearch.search.query.ScrollQuerySearchResult;
@@ -109,7 +108,7 @@ public class SearchTransportService {
             TransportRequestOptions.EMPTY, new ActionListenerResponseHandler<>(listener, SearchFreeContextResponse::new));
     }
 
-    public void sendCanMatch(Transport.Connection connection, final ShardSearchTransportRequest request, SearchTask task, final
+    public void sendCanMatch(Transport.Connection connection, final ShardSearchRequest request, SearchTask task, final
                             ActionListener<SearchService.CanMatchResponse> listener) {
         transportService.sendChildRequest(connection, QUERY_CAN_MATCH_NAME, request, task,
             TransportRequestOptions.EMPTY, new ActionListenerResponseHandler<>(listener, SearchService.CanMatchResponse::new));
@@ -120,13 +119,13 @@ public class SearchTransportService {
             TransportRequestOptions.EMPTY, new ActionListenerResponseHandler<>(listener, (in) -> TransportResponse.Empty.INSTANCE));
     }
 
-    public void sendExecuteDfs(Transport.Connection connection, final ShardSearchTransportRequest request, SearchTask task,
+    public void sendExecuteDfs(Transport.Connection connection, final ShardSearchRequest request, SearchTask task,
                                final SearchActionListener<DfsSearchResult> listener) {
         transportService.sendChildRequest(connection, DFS_ACTION_NAME, request, task,
                 new ConnectionCountingHandler<>(listener, DfsSearchResult::new, clientConnections, connection.getNode().getId()));
     }
 
-    public void sendExecuteQuery(Transport.Connection connection, final ShardSearchTransportRequest request, SearchTask task,
+    public void sendExecuteQuery(Transport.Connection connection, final ShardSearchRequest request, SearchTask task,
                                  final SearchActionListener<SearchPhaseResult> listener) {
         // we optimize this and expect a QueryFetchSearchResult if we only have a single shard in the search request
         // this used to be the QUERY_AND_FETCH which doesn't exist anymore.
@@ -306,7 +305,7 @@ public class SearchTransportService {
         TransportActionProxy.registerProxyAction(transportService, CLEAR_SCROLL_CONTEXTS_ACTION_NAME,
             (in) -> TransportResponse.Empty.INSTANCE);
 
-        transportService.registerRequestHandler(DFS_ACTION_NAME, ThreadPool.Names.SAME, ShardSearchTransportRequest::new,
+        transportService.registerRequestHandler(DFS_ACTION_NAME, ThreadPool.Names.SAME, ShardSearchRequest::new,
             (request, channel, task) -> {
                 searchService.executeDfsPhase(request, (SearchTask) task, new ActionListener<SearchPhaseResult>() {
                     @Override
@@ -330,7 +329,7 @@ public class SearchTransportService {
             });
         TransportActionProxy.registerProxyAction(transportService, DFS_ACTION_NAME, DfsSearchResult::new);
 
-        transportService.registerRequestHandler(QUERY_ACTION_NAME, ThreadPool.Names.SAME, ShardSearchTransportRequest::new,
+        transportService.registerRequestHandler(QUERY_ACTION_NAME, ThreadPool.Names.SAME, ShardSearchRequest::new,
             (request, channel, task) -> {
                 searchService.executeQueryPhase(request, (SearchTask) task, new ChannelActionListener<>(
                     channel, QUERY_ACTION_NAME, request));
@@ -374,7 +373,7 @@ public class SearchTransportService {
         TransportActionProxy.registerProxyAction(transportService, FETCH_ID_ACTION_NAME, FetchSearchResult::new);
 
         // this is cheap, it does not fetch during the rewrite phase, so we can let it quickly execute on a networking thread
-        transportService.registerRequestHandler(QUERY_CAN_MATCH_NAME, ThreadPool.Names.SAME, ShardSearchTransportRequest::new,
+        transportService.registerRequestHandler(QUERY_CAN_MATCH_NAME, ThreadPool.Names.SAME, ShardSearchRequest::new,
             (request, channel, task) -> {
                 searchService.canMatch(request, new ChannelActionListener<>(channel, QUERY_CAN_MATCH_NAME, request));
             });

server/src/main/java/org/elasticsearch/search/internal/ShardSearchLocalRequest.java

@@ -1,282 +0,0 @@
-/*
- * Licensed to Elasticsearch under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package org.elasticsearch.search.internal;
-
-import org.elasticsearch.Version;
-import org.elasticsearch.action.search.SearchRequest;
-import org.elasticsearch.action.search.SearchType;
-import org.elasticsearch.common.Nullable;
-import org.elasticsearch.common.Strings;
-import org.elasticsearch.common.bytes.BytesArray;
-import org.elasticsearch.common.bytes.BytesReference;
-import org.elasticsearch.common.io.stream.BytesStreamOutput;
-import org.elasticsearch.common.io.stream.StreamInput;
-import org.elasticsearch.common.io.stream.StreamOutput;
-import org.elasticsearch.index.query.QueryRewriteContext;
-import org.elasticsearch.index.query.Rewriteable;
-import org.elasticsearch.index.shard.ShardId;
-import org.elasticsearch.search.Scroll;
-import org.elasticsearch.search.builder.SearchSourceBuilder;
-
-import java.io.IOException;
-
-/**
- * Shard level search request that gets created and consumed on the local node.
- * Used directly by api that need to create a search context within their execution.
- *
- * Source structure:
- * <pre>
- * {
- *  from : 0, size : 20, (optional, can be set on the request)
- *  sort : { "name.first" : {}, "name.last" : { reverse : true } }
- *  fields : [ "name.first", "name.last" ]
- *  query : { ... }
- *  aggs : {
- *      "agg1" : {
- *          terms : { ... }
- *      }
- *  }
- * }
- * </pre>
- */
-public class ShardSearchLocalRequest implements ShardSearchRequest {
-    private final String clusterAlias;
-    private final ShardId shardId;
-    private final int numberOfShards;
-    private final SearchType searchType;
-    private final Scroll scroll;
-    private final String[] types;
-    private final float indexBoost;
-    private final Boolean requestCache;
-    private final long nowInMillis;
-    private final boolean allowPartialSearchResults;
-    private final String[] indexRoutings;
-    private final String preference;
-    //these are the only two mutable fields, as they are subject to rewriting
-    private AliasFilter aliasFilter;
-    private SearchSourceBuilder source;
-
-    public ShardSearchLocalRequest(SearchRequest searchRequest, ShardId shardId, int numberOfShards, AliasFilter aliasFilter,
-                                   float indexBoost, long nowInMillis, @Nullable String clusterAlias, String[] indexRoutings) {
-        this(shardId, numberOfShards, searchRequest.searchType(), searchRequest.source(), searchRequest.types(),
-            searchRequest.requestCache(), aliasFilter, indexBoost, searchRequest.allowPartialSearchResults(), indexRoutings,
-            searchRequest.preference(), searchRequest.scroll(), nowInMillis, clusterAlias);
-        // If allowPartialSearchResults is unset (ie null), the cluster-level default should have been substituted
-        // at this stage. Any NPEs in the above are therefore an error in request preparation logic.
-        assert searchRequest.allowPartialSearchResults() != null;
-    }
-
-    public ShardSearchLocalRequest(ShardId shardId, String[] types, long nowInMillis, AliasFilter aliasFilter) {
-        this(shardId, -1, null, null, types, null, aliasFilter, 1.0f, false, Strings.EMPTY_ARRAY, null, null, nowInMillis, null);
-    }
-
-    private ShardSearchLocalRequest(ShardId shardId, int numberOfShards, SearchType searchType, SearchSourceBuilder source, String[] types,
-                                    Boolean requestCache, AliasFilter aliasFilter, float indexBoost, boolean allowPartialSearchResults,
-                                    String[] indexRoutings, String preference, Scroll scroll, long nowInMillis,
-                                    @Nullable String clusterAlias) {
-        this.shardId = shardId;
-        this.numberOfShards = numberOfShards;
-        this.searchType = searchType;
-        this.source = source;
-        this.types = types;
-        this.requestCache = requestCache;
-        this.aliasFilter = aliasFilter;
-        this.indexBoost = indexBoost;
-        this.allowPartialSearchResults = allowPartialSearchResults;
-        this.indexRoutings = indexRoutings;
-        this.preference = preference;
-        this.scroll = scroll;
-        this.nowInMillis = nowInMillis;
-        this.clusterAlias = clusterAlias;
-    }
-
-    ShardSearchLocalRequest(StreamInput in) throws IOException {
-        shardId = new ShardId(in);
-        searchType = SearchType.fromId(in.readByte());
-        numberOfShards = in.readVInt();
-        scroll = in.readOptionalWriteable(Scroll::new);
-        source = in.readOptionalWriteable(SearchSourceBuilder::new);
-        types = in.readStringArray();
-        aliasFilter = new AliasFilter(in);
-        indexBoost = in.readFloat();
-        nowInMillis = in.readVLong();
-        requestCache = in.readOptionalBoolean();
-        clusterAlias = in.readOptionalString();
-        if (in.getVersion().onOrAfter(Version.V_7_0_0)) {
-            allowPartialSearchResults = in.readBoolean();
-        } else if (in.getVersion().onOrAfter(Version.V_6_3_0)) {
-            allowPartialSearchResults = in.readOptionalBoolean();
-        } else {
-            allowPartialSearchResults = false;
-        }
-        if (in.getVersion().onOrAfter(Version.V_6_4_0)) {
-            indexRoutings = in.readStringArray();
-            preference = in.readOptionalString();
-        } else {
-            indexRoutings = Strings.EMPTY_ARRAY;
-            preference = null;
-        }
-    }
-
-    protected final void innerWriteTo(StreamOutput out, boolean asKey) throws IOException {
-        shardId.writeTo(out);
-        out.writeByte(searchType.id());
-        if (!asKey) {
-            out.writeVInt(numberOfShards);
-        }
-        out.writeOptionalWriteable(scroll);
-        out.writeOptionalWriteable(source);
-        out.writeStringArray(types);
-        aliasFilter.writeTo(out);
-        out.writeFloat(indexBoost);
-        if (asKey == false) {
-            out.writeVLong(nowInMillis);
-        }
-        out.writeOptionalBoolean(requestCache);
-        out.writeOptionalString(clusterAlias);
-        if (out.getVersion().onOrAfter(Version.V_7_0_0)) {
-            out.writeBoolean(allowPartialSearchResults);
-        } else if (out.getVersion().onOrAfter(Version.V_6_3_0)) {
-            out.writeOptionalBoolean(allowPartialSearchResults);
-        }
-        if (asKey == false) {
-            if (out.getVersion().onOrAfter(Version.V_6_4_0)) {
-                out.writeStringArray(indexRoutings);
-                out.writeOptionalString(preference);
-            }
-        }
-    }
-
-    @Override
-    public ShardId shardId() {
-        return shardId;
-    }
-
-    @Override
-    public String[] types() {
-        return types;
-    }
-
-    @Override
-    public SearchSourceBuilder source() {
-        return source;
-    }
-
-    @Override
-    public AliasFilter getAliasFilter() {
-        return aliasFilter;
-    }
-
-    @Override
-    public void setAliasFilter(AliasFilter aliasFilter) {
-        this.aliasFilter = aliasFilter;
-    }
-
-    @Override
-    public void source(SearchSourceBuilder source) {
-        this.source = source;
-    }
-
-    @Override
-    public int numberOfShards() {
-        return numberOfShards;
-    }
-
-    @Override
-    public SearchType searchType() {
-        return searchType;
-    }
-
-    @Override
-    public float indexBoost() {
-        return indexBoost;
-    }
-
-    @Override
-    public long nowInMillis() {
-        return nowInMillis;
-    }
-
-    @Override
-    public Boolean requestCache() {
-        return requestCache;
-    }
-
-    @Override
-    public boolean allowPartialSearchResults() {
-        return allowPartialSearchResults;
-    }
-
-    @Override
-    public Scroll scroll() {
-        return scroll;
-    }
-
-    @Override
-    public String[] indexRoutings() {
-        return indexRoutings;
-    }
-
-    @Override
-    public String preference() {
-        return preference;
-    }
-
-    @Override
-    public BytesReference cacheKey() throws IOException {
-        BytesStreamOutput out = new BytesStreamOutput();
-        this.innerWriteTo(out, true);
-        // copy it over, most requests are small, we might as well copy to make sure we are not sliced...
-        // we could potentially keep it without copying, but then pay the price of extra unused bytes up to a page
-        return new BytesArray(out.bytes().toBytesRef(), true);// do a deep copy
-    }
-
-    @Override
-    public String getClusterAlias() {
-        return clusterAlias;
-    }
-
-    @Override
-    public Rewriteable<Rewriteable> getRewriteable() {
-        return new RequestRewritable(this);
-    }
-
-    static class RequestRewritable implements Rewriteable<Rewriteable> {
-
-        final ShardSearchRequest request;
-
-        RequestRewritable(ShardSearchRequest request) {
-            this.request = request;
-        }
-
-        @Override
-        public Rewriteable rewrite(QueryRewriteContext ctx) throws IOException {
-            SearchSourceBuilder newSource = request.source() == null ? null : Rewriteable.rewrite(request.source(), ctx);
-            AliasFilter newAliasFilter = Rewriteable.rewrite(request.getAliasFilter(), ctx);
-            if (newSource == request.source() && newAliasFilter == request.getAliasFilter()) {
-                return this;
-            } else {
-                request.source(newSource);
-                request.setAliasFilter(newAliasFilter);
-                return new RequestRewritable(request);
-            }
-        }
-    }
-}

server/src/main/java/org/elasticsearch/search/internal/ShardSearchRequest.java

@@ -19,74 +19,310 @@
 
 package org.elasticsearch.search.internal;
 
+import org.elasticsearch.action.IndicesRequest;
+import org.elasticsearch.action.OriginalIndices;
 import org.elasticsearch.action.search.SearchRequest;
+import org.elasticsearch.action.search.SearchTask;
 import org.elasticsearch.action.search.SearchType;
+import org.elasticsearch.action.support.IndicesOptions;
 import org.elasticsearch.cluster.metadata.AliasMetaData;
 import org.elasticsearch.cluster.metadata.IndexMetaData;
 import org.elasticsearch.common.CheckedFunction;
 import org.elasticsearch.common.Nullable;
+import org.elasticsearch.common.Strings;
+import org.elasticsearch.common.bytes.BytesArray;
 import org.elasticsearch.common.bytes.BytesReference;
 import org.elasticsearch.common.collect.ImmutableOpenMap;
+import org.elasticsearch.common.io.stream.BytesStreamOutput;
+import org.elasticsearch.common.io.stream.StreamInput;
+import org.elasticsearch.common.io.stream.StreamOutput;
 import org.elasticsearch.index.Index;
 import org.elasticsearch.index.query.BoolQueryBuilder;
 import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.index.query.QueryRewriteContext;
 import org.elasticsearch.index.query.Rewriteable;
 import org.elasticsearch.index.shard.ShardId;
 import org.elasticsearch.indices.AliasFilterParsingException;
 import org.elasticsearch.indices.InvalidAliasNameException;
 import org.elasticsearch.search.Scroll;
 import org.elasticsearch.search.builder.SearchSourceBuilder;
+import org.elasticsearch.tasks.Task;
+import org.elasticsearch.tasks.TaskId;
+import org.elasticsearch.transport.TransportRequest;
 
 import java.io.IOException;
+import java.util.Map;
 import java.util.function.Function;
 
 /**
  * Shard level request that represents a search.
- * It provides all the methods that the {@link org.elasticsearch.search.internal.SearchContext} needs.
+ * It provides all the methods that the {@link SearchContext} needs.
  * Provides a cache key based on its content that can be used to cache shard level response.
  */
-public interface ShardSearchRequest {
+public class ShardSearchRequest extends TransportRequest implements IndicesRequest {
+    private final String clusterAlias;
+    private final ShardId shardId;
+    private final int numberOfShards;
+    private final SearchType searchType;
+    private final Scroll scroll;
+    private final String[] types;
+    private final float indexBoost;
+    private final Boolean requestCache;
+    private final long nowInMillis;
+    private final boolean allowPartialSearchResults;
+    private final String[] indexRoutings;
+    private final String preference;
+    private final OriginalIndices originalIndices;
 
-    ShardId shardId();
+    //these are the only two mutable fields, as they are subject to rewriting
+    private AliasFilter aliasFilter;
+    private SearchSourceBuilder source;
 
-    String[] types();
+    public ShardSearchRequest(OriginalIndices originalIndices,
+                              SearchRequest searchRequest,
+                              ShardId shardId,
+                              int numberOfShards,
+                              AliasFilter aliasFilter,
+                              float indexBoost,
+                              long nowInMillis,
+                              @Nullable String clusterAlias,
+                              String[] indexRoutings) {
+        this(originalIndices,
+            shardId,
+            numberOfShards,
+            searchRequest.searchType(),
+            searchRequest.source(),
+            searchRequest.types(),
+            searchRequest.requestCache(),
+            aliasFilter,
+            indexBoost,
+            searchRequest.allowPartialSearchResults(),
+            indexRoutings,
+            searchRequest.preference(),
+            searchRequest.scroll(),
+            nowInMillis,
+            clusterAlias);
+        // If allowPartialSearchResults is unset (ie null), the cluster-level default should have been substituted
+        // at this stage. Any NPEs in the above are therefore an error in request preparation logic.
+        assert searchRequest.allowPartialSearchResults() != null;
+    }
 
-    SearchSourceBuilder source();
+    public ShardSearchRequest(ShardId shardId,
+                              String[] types,
+                              long nowInMillis,
+                              AliasFilter aliasFilter) {
+        this(OriginalIndices.NONE, shardId, -1, null, null, types, null,
+            aliasFilter, 1.0f, false, Strings.EMPTY_ARRAY, null, null, nowInMillis, null);
+    }
 
-    AliasFilter getAliasFilter();
+    private ShardSearchRequest(OriginalIndices originalIndices,
+                               ShardId shardId,
+                               int numberOfShards,
+                               SearchType searchType,
+                               SearchSourceBuilder source,
+                               String[] types,
+                               Boolean requestCache,
+                               AliasFilter aliasFilter,
+                               float indexBoost,
+                               boolean allowPartialSearchResults,
+                               String[] indexRoutings,
+                               String preference,
+                               Scroll scroll,
+                               long nowInMillis,
+                               @Nullable String clusterAlias) {
+        this.shardId = shardId;
+        this.numberOfShards = numberOfShards;
+        this.searchType = searchType;
+        this.source = source;
+        this.types = types;
+        this.requestCache = requestCache;
+        this.aliasFilter = aliasFilter;
+        this.indexBoost = indexBoost;
+        this.allowPartialSearchResults = allowPartialSearchResults;
+        this.indexRoutings = indexRoutings;
+        this.preference = preference;
+        this.scroll = scroll;
+        this.nowInMillis = nowInMillis;
+        this.clusterAlias = clusterAlias;
+        this.originalIndices = originalIndices;
+    }
 
-    void setAliasFilter(AliasFilter filter);
+    public ShardSearchRequest(StreamInput in) throws IOException {
+        super(in);
+        shardId = new ShardId(in);
+        searchType = SearchType.fromId(in.readByte());
+        numberOfShards = in.readVInt();
+        scroll = in.readOptionalWriteable(Scroll::new);
+        source = in.readOptionalWriteable(SearchSourceBuilder::new);
+        types = in.readStringArray();
+        aliasFilter = new AliasFilter(in);
+        indexBoost = in.readFloat();
+        nowInMillis = in.readVLong();
+        requestCache = in.readOptionalBoolean();
+        clusterAlias = in.readOptionalString();
+        allowPartialSearchResults = in.readBoolean();
+        indexRoutings = in.readStringArray();
+        preference = in.readOptionalString();
+        originalIndices = OriginalIndices.readOriginalIndices(in);
+    }
 
-    void source(SearchSourceBuilder source);
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        super.writeTo(out);
+        innerWriteTo(out, false);
+        OriginalIndices.writeOriginalIndices(originalIndices, out);
+    }
 
-    int numberOfShards();
+    protected final void innerWriteTo(StreamOutput out, boolean asKey) throws IOException {
+        shardId.writeTo(out);
+        out.writeByte(searchType.id());
+        if (!asKey) {
+            out.writeVInt(numberOfShards);
+        }
+        out.writeOptionalWriteable(scroll);
+        out.writeOptionalWriteable(source);
+        out.writeStringArray(types);
+        aliasFilter.writeTo(out);
+        out.writeFloat(indexBoost);
+        if (asKey == false) {
+            out.writeVLong(nowInMillis);
+        }
+        out.writeOptionalBoolean(requestCache);
+        out.writeOptionalString(clusterAlias);
+        out.writeBoolean(allowPartialSearchResults);
+        if (asKey == false) {
+            out.writeStringArray(indexRoutings);
+            out.writeOptionalString(preference);
+        }
+    }
 
-    SearchType searchType();
+    @Override
+    public String[] indices() {
+        if (originalIndices == null) {
+            return null;
+        }
+        return originalIndices.indices();
+    }
 
-    float indexBoost();
+    @Override
+    public IndicesOptions indicesOptions() {
+        if (originalIndices == null) {
+            return null;
+        }
+        return originalIndices.indicesOptions();
+    }
 
-    long nowInMillis();
+    public ShardId shardId() {
+        return shardId;
+    }
 
-    Boolean requestCache();
+    public String[] types() {
+        return types;
+    }
 
-    boolean allowPartialSearchResults();
+    public SearchSourceBuilder source() {
+        return source;
+    }
 
-    Scroll scroll();
+    public AliasFilter getAliasFilter() {
+        return aliasFilter;
+    }
 
-    /**
-     * Returns the routing values resolved by the coordinating node for the index pointed by {@link #shardId()}.
-     */
-    String[] indexRoutings();
+    public void setAliasFilter(AliasFilter aliasFilter) {
+        this.aliasFilter = aliasFilter;
+    }
 
-    /**
-     * Returns the preference of the original {@link SearchRequest#preference()}.
-     */
-    String preference();
+    public void source(SearchSourceBuilder source) {
+        this.source = source;
+    }
+
+    public int numberOfShards() {
+        return numberOfShards;
+    }
+
+    public SearchType searchType() {
+        return searchType;
+    }
+
+    public float indexBoost() {
+        return indexBoost;
+    }
+
+    public long nowInMillis() {
+        return nowInMillis;
+    }
+
+    public Boolean requestCache() {
+        return requestCache;
+    }
+
+    public boolean allowPartialSearchResults() {
+        return allowPartialSearchResults;
+    }
+
+    public Scroll scroll() {
+        return scroll;
+    }
+
+    public String[] indexRoutings() {
+        return indexRoutings;
+    }
+
+    public String preference() {
+        return preference;
+    }
 
     /**
      * Returns the cache key for this shard search request, based on its content
      */
-    BytesReference cacheKey() throws IOException;
+    public BytesReference cacheKey() throws IOException {
+        BytesStreamOutput out = new BytesStreamOutput();
+        this.innerWriteTo(out, true);
+        // copy it over, most requests are small, we might as well copy to make sure we are not sliced...
+        // we could potentially keep it without copying, but then pay the price of extra unused bytes up to a page
+        return new BytesArray(out.bytes().toBytesRef(), true);// do a deep copy
+    }
+
+    public String getClusterAlias() {
+        return clusterAlias;
+    }
+
+    @Override
+    public Task createTask(long id, String type, String action, TaskId parentTaskId, Map<String, String> headers) {
+        return new SearchTask(id, type, action, getDescription(), parentTaskId, headers);
+    }
+
+    @Override
+    public String getDescription() {
+        // Shard id is enough here, the request itself can be found by looking at the parent task description
+        return "shardId[" + shardId() + "]";
+    }
+
+    public Rewriteable<Rewriteable> getRewriteable() {
+        return new RequestRewritable(this);
+    }
+
+    static class RequestRewritable implements Rewriteable<Rewriteable> {
+
+        final ShardSearchRequest request;
+
+        RequestRewritable(ShardSearchRequest request) {
+            this.request = request;
+        }
+
+        @Override
+        public Rewriteable rewrite(QueryRewriteContext ctx) throws IOException {
+            SearchSourceBuilder newSource = request.source() == null ? null : Rewriteable.rewrite(request.source(), ctx);
+            AliasFilter newAliasFilter = Rewriteable.rewrite(request.getAliasFilter(), ctx);
+            if (newSource == request.source() && newAliasFilter == request.getAliasFilter()) {
+                return this;
+            } else {
+                request.source(newSource);
+                request.setAliasFilter(newAliasFilter);
+                return new RequestRewritable(request);
+            }
+        }
+    }
 
     /**
      * Returns the filter associated with listed filtering aliases.
@@ -94,8 +330,8 @@ public interface ShardSearchRequest {
      * The list of filtering aliases should be obtained by calling MetaData.filteringAliases.
      * Returns {@code null} if no filtering is required.</p>
      */
-    static QueryBuilder parseAliasFilter(CheckedFunction<byte[], QueryBuilder, IOException> filterParser,
-                                         IndexMetaData metaData, String... aliasNames) {
+    public static QueryBuilder parseAliasFilter(CheckedFunction<byte[], QueryBuilder, IOException> filterParser,
+                                                IndexMetaData metaData, String... aliasNames) {
         if (aliasNames == null || aliasNames.length == 0) {
             return null;
         }
@@ -139,13 +375,4 @@ public interface ShardSearchRequest {
             return combined;
         }
     }
-
-    /**
-     * Returns the cluster alias in case the request is part of a cross-cluster search request, <code>null</code> otherwise.
-     */
-    @Nullable
-    String getClusterAlias();
-
-    Rewriteable<Rewriteable> getRewriteable();
-
 }

server/src/main/java/org/elasticsearch/search/internal/ShardSearchTransportRequest.java

@@ -1,191 +0,0 @@
-/*
- * Licensed to Elasticsearch under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package org.elasticsearch.search.internal;
-
-import org.elasticsearch.action.IndicesRequest;
-import org.elasticsearch.action.OriginalIndices;
-import org.elasticsearch.action.search.SearchRequest;
-import org.elasticsearch.action.search.SearchTask;
-import org.elasticsearch.action.search.SearchType;
-import org.elasticsearch.action.support.IndicesOptions;
-import org.elasticsearch.common.Nullable;
-import org.elasticsearch.common.bytes.BytesReference;
-import org.elasticsearch.common.io.stream.StreamInput;
-import org.elasticsearch.common.io.stream.StreamOutput;
-import org.elasticsearch.index.query.Rewriteable;
-import org.elasticsearch.index.shard.ShardId;
-import org.elasticsearch.search.Scroll;
-import org.elasticsearch.search.builder.SearchSourceBuilder;
-import org.elasticsearch.tasks.Task;
-import org.elasticsearch.tasks.TaskId;
-import org.elasticsearch.transport.TransportRequest;
-
-import java.io.IOException;
-import java.util.Map;
-
-/**
- * Shard level search request that represents an actual search sent from the coordinating node to the nodes holding
- * the shards where the query needs to be executed. Holds the same info as {@link org.elasticsearch.search.internal.ShardSearchLocalRequest}
- * but gets sent over the transport and holds also the indices coming from the original request that generated it, plus its headers and
- * context.
- */
-public class ShardSearchTransportRequest extends TransportRequest implements ShardSearchRequest, IndicesRequest {
-
-    private final OriginalIndices originalIndices;
-    private final ShardSearchLocalRequest shardSearchLocalRequest;
-
-    public ShardSearchTransportRequest(OriginalIndices originalIndices, SearchRequest searchRequest, ShardId shardId, int numberOfShards,
-                                       AliasFilter aliasFilter, float indexBoost, long nowInMillis,
-                                       @Nullable String clusterAlias, String[] indexRoutings) {
-        this.shardSearchLocalRequest = new ShardSearchLocalRequest(searchRequest, shardId, numberOfShards, aliasFilter, indexBoost,
-            nowInMillis, clusterAlias, indexRoutings);
-        this.originalIndices = originalIndices;
-    }
-
-    public ShardSearchTransportRequest(StreamInput in) throws IOException {
-        super(in);
-        shardSearchLocalRequest = new ShardSearchLocalRequest(in);
-        originalIndices = OriginalIndices.readOriginalIndices(in);
-    }
-
-    @Override
-    public void writeTo(StreamOutput out) throws IOException {
-        super.writeTo(out);
-        shardSearchLocalRequest.innerWriteTo(out, false);
-        OriginalIndices.writeOriginalIndices(originalIndices, out);
-    }
-
-    @Override
-    public String[] indices() {
-        if (originalIndices == null) {
-            return null;
-        }
-        return originalIndices.indices();
-    }
-
-    @Override
-    public IndicesOptions indicesOptions() {
-        if (originalIndices == null) {
-            return null;
-        }
-        return originalIndices.indicesOptions();
-    }
-
-    @Override
-    public ShardId shardId() {
-        return shardSearchLocalRequest.shardId();
-    }
-
-    @Override
-    public String[] types() {
-        return shardSearchLocalRequest.types();
-    }
-
-    @Override
-    public SearchSourceBuilder source() {
-        return shardSearchLocalRequest.source();
-    }
-
-    @Override
-    public AliasFilter getAliasFilter() {
-        return shardSearchLocalRequest.getAliasFilter();
-    }
-
-    @Override
-    public void setAliasFilter(AliasFilter filter) {
-        shardSearchLocalRequest.setAliasFilter(filter);
-    }
-
-    @Override
-    public void source(SearchSourceBuilder source) {
-        shardSearchLocalRequest.source(source);
-    }
-
-    @Override
-    public int numberOfShards() {
-        return shardSearchLocalRequest.numberOfShards();
-    }
-
-    @Override
-    public SearchType searchType() {
-        return shardSearchLocalRequest.searchType();
-    }
-
-    @Override
-    public float indexBoost() {
-        return shardSearchLocalRequest.indexBoost();
-    }
-
-    @Override
-    public long nowInMillis() {
-        return shardSearchLocalRequest.nowInMillis();
-    }
-
-    @Override
-    public Boolean requestCache() {
-        return shardSearchLocalRequest.requestCache();
-    }
-
-    @Override
-    public boolean allowPartialSearchResults() {
-        return shardSearchLocalRequest.allowPartialSearchResults();
-    }
-
-    @Override
-    public Scroll scroll() {
-        return shardSearchLocalRequest.scroll();
-    }
-
-    @Override
-    public String[] indexRoutings() {
-        return shardSearchLocalRequest.indexRoutings();
-    }
-
-    @Override
-    public String preference() {
-        return shardSearchLocalRequest.preference();
-    }
-
-    @Override
-    public BytesReference cacheKey() throws IOException {
-        return shardSearchLocalRequest.cacheKey();
-    }
-
-    @Override
-    public Task createTask(long id, String type, String action, TaskId parentTaskId, Map<String, String> headers) {
-        return new SearchTask(id, type, action, getDescription(), parentTaskId, headers);
-    }
-
-    @Override
-    public String getDescription() {
-        // Shard id is enough here, the request itself can be found by looking at the parent task description
-        return "shardId[" + shardSearchLocalRequest.shardId() + "]";
-    }
-
-    @Override
-    public String getClusterAlias() {
-        return shardSearchLocalRequest.getClusterAlias();
-    }
-
-    @Override
-    public Rewriteable<Rewriteable> getRewriteable() {
-        return shardSearchLocalRequest.getRewriteable();
-    }
-}

server/src/test/java/org/elasticsearch/action/search/AbstractSearchAsyncActionTests.java

@@ -33,7 +33,7 @@ import org.elasticsearch.search.SearchPhaseResult;
 import org.elasticsearch.search.SearchShardTarget;
 import org.elasticsearch.search.internal.AliasFilter;
 import org.elasticsearch.search.internal.InternalSearchResponse;
-import org.elasticsearch.search.internal.ShardSearchTransportRequest;
+import org.elasticsearch.search.internal.ShardSearchRequest;
 import org.elasticsearch.test.ESTestCase;
 import org.elasticsearch.transport.Transport;
 
@@ -146,7 +146,7 @@ public class AbstractSearchAsyncActionTests extends ESTestCase {
         String clusterAlias = randomBoolean() ? null : randomAlphaOfLengthBetween(5, 10);
         SearchShardIterator iterator = new SearchShardIterator(clusterAlias, new ShardId(new Index("name", "foo"), 1),
             Collections.emptyList(), new OriginalIndices(new String[] {"name", "name1"}, IndicesOptions.strictExpand()));
-        ShardSearchTransportRequest shardSearchTransportRequest = action.buildShardSearchRequest(iterator);
+        ShardSearchRequest shardSearchTransportRequest = action.buildShardSearchRequest(iterator);
         assertEquals(IndicesOptions.strictExpand(), shardSearchTransportRequest.indicesOptions());
         assertArrayEquals(new String[] {"name", "name1"}, shardSearchTransportRequest.indices());
         assertEquals(new MatchAllQueryBuilder(), shardSearchTransportRequest.getAliasFilter().getQueryBuilder());

server/src/test/java/org/elasticsearch/action/search/CanMatchPreFilterSearchPhaseTests.java

@@ -30,7 +30,7 @@ import org.elasticsearch.search.SearchPhaseResult;
 import org.elasticsearch.search.SearchService;
 import org.elasticsearch.search.SearchShardTarget;
 import org.elasticsearch.search.internal.AliasFilter;
-import org.elasticsearch.search.internal.ShardSearchTransportRequest;
+import org.elasticsearch.search.internal.ShardSearchRequest;
 import org.elasticsearch.test.ESTestCase;
 import org.elasticsearch.transport.Transport;
 
@@ -60,7 +60,7 @@ public class CanMatchPreFilterSearchPhaseTests extends ESTestCase {
 
         SearchTransportService searchTransportService = new SearchTransportService(null, null) {
             @Override
-            public void sendCanMatch(Transport.Connection connection, ShardSearchTransportRequest request, SearchTask task,
+            public void sendCanMatch(Transport.Connection connection, ShardSearchRequest request, SearchTask task,
                                      ActionListener<SearchService.CanMatchResponse> listener) {
                 new Thread(() -> listener.onResponse(new SearchService.CanMatchResponse(request.shardId().id() == 0 ? shard1 :
                     shard2))).start();
@@ -117,7 +117,7 @@ public class CanMatchPreFilterSearchPhaseTests extends ESTestCase {
         final boolean shard1 = randomBoolean();
         SearchTransportService searchTransportService = new SearchTransportService(null, null) {
             @Override
-            public void sendCanMatch(Transport.Connection connection, ShardSearchTransportRequest request, SearchTask task,
+            public void sendCanMatch(Transport.Connection connection, ShardSearchRequest request, SearchTask task,
                                      ActionListener<SearchService.CanMatchResponse> listener) {
                 boolean throwException = request.shardId().id() != 0;
                 if (throwException && randomBoolean()) {
@@ -185,7 +185,7 @@ public class CanMatchPreFilterSearchPhaseTests extends ESTestCase {
                     @Override
                     public void sendCanMatch(
                             Transport.Connection connection,
-                            ShardSearchTransportRequest request,
+                            ShardSearchRequest request,
                             SearchTask task,
                             ActionListener<SearchService.CanMatchResponse> listener) {
                         listener.onResponse(new SearchService.CanMatchResponse(randomBoolean()));

server/src/test/java/org/elasticsearch/action/search/MockSearchPhaseContext.java

@@ -24,7 +24,7 @@ import org.elasticsearch.action.OriginalIndices;
 import org.elasticsearch.common.Nullable;
 import org.elasticsearch.search.SearchShardTarget;
 import org.elasticsearch.search.internal.InternalSearchResponse;
-import org.elasticsearch.search.internal.ShardSearchTransportRequest;
+import org.elasticsearch.search.internal.ShardSearchRequest;
 import org.elasticsearch.transport.Transport;
 import org.junit.Assert;
 
@@ -111,7 +111,7 @@ public final class MockSearchPhaseContext implements SearchPhaseContext {
     }
 
     @Override
-    public ShardSearchTransportRequest buildShardSearchRequest(SearchShardIterator shardIt) {
+    public ShardSearchRequest buildShardSearchRequest(SearchShardIterator shardIt) {
         Assert.fail("should not be called");
         return null;
     }

server/src/test/java/org/elasticsearch/index/SearchSlowLogTests.java

@@ -21,24 +21,18 @@ package org.elasticsearch.index;
 
 import org.elasticsearch.Version;
 import org.elasticsearch.action.search.SearchTask;
-import org.elasticsearch.action.search.SearchType;
 import org.elasticsearch.cluster.metadata.IndexMetaData;
-import org.elasticsearch.common.bytes.BytesReference;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.unit.TimeValue;
 import org.elasticsearch.common.util.BigArrays;
 import org.elasticsearch.index.query.QueryBuilders;
-import org.elasticsearch.index.query.Rewriteable;
 import org.elasticsearch.index.shard.ShardId;
-import org.elasticsearch.search.Scroll;
 import org.elasticsearch.search.builder.SearchSourceBuilder;
-import org.elasticsearch.search.internal.AliasFilter;
 import org.elasticsearch.search.internal.SearchContext;
 import org.elasticsearch.search.internal.ShardSearchRequest;
 import org.elasticsearch.tasks.Task;
 import org.elasticsearch.test.ESSingleNodeTestCase;
 import org.elasticsearch.test.TestSearchContext;
-import org.elasticsearch.threadpool.ThreadPool;
 import org.hamcrest.Matchers;
 
 import java.io.IOException;
@@ -59,103 +53,12 @@ public class SearchSlowLogTests extends ESSingleNodeTestCase {
     protected SearchContext createSearchContext(IndexService indexService) {
        return createSearchContext(indexService, new String[]{});
     }
+
     protected SearchContext createSearchContext(IndexService indexService, String ... groupStats) {
         BigArrays bigArrays = indexService.getBigArrays();
-        ThreadPool threadPool = indexService.getThreadPool();
+        final ShardSearchRequest request =
+            new ShardSearchRequest(new ShardId(indexService.index(), 0), new String[0], 0L, null);
         return new TestSearchContext(bigArrays, indexService) {
-            final ShardSearchRequest request = new ShardSearchRequest() {
-                private SearchSourceBuilder searchSourceBuilder;
-                @Override
-                public ShardId shardId() {
-                    return new ShardId(indexService.index(), 0);
-                }
-
-                @Override
-                public String[] types() {
-                    return new String[0];
-                }
-
-                @Override
-                public SearchSourceBuilder source() {
-                    return searchSourceBuilder;
-                }
-
-                @Override
-                public AliasFilter getAliasFilter() {
-                    return new AliasFilter(QueryBuilders.matchAllQuery(), "foo");
-                }
-
-                @Override
-                public void setAliasFilter(AliasFilter filter) {
-
-                }
-
-                @Override
-                public void source(SearchSourceBuilder source) {
-                    searchSourceBuilder = source;
-                }
-
-                @Override
-                public int numberOfShards() {
-                    return 0;
-                }
-
-                @Override
-                public SearchType searchType() {
-                    return null;
-                }
-
-                @Override
-                public float indexBoost() {
-                    return 1.0f;
-                }
-
-                @Override
-                public long nowInMillis() {
-                    return 0;
-                }
-
-                @Override
-                public Boolean requestCache() {
-                    return null;
-                }
-
-                @Override
-                public boolean allowPartialSearchResults() {
-                    return true;
-                }
-
-                @Override
-                public Scroll scroll() {
-                    return null;
-                }
-
-                @Override
-                public String[] indexRoutings() {
-                    return null;
-                }
-
-                @Override
-                public String preference() {
-                    return null;
-                }
-
-                @Override
-                public BytesReference cacheKey() {
-                    return null;
-                }
-
-                @Override
-                public Rewriteable getRewriteable() {
-                    return null;
-                }
-
-                @Override
-                public String getClusterAlias() {
-                    return null;
-                }
-            };
-
             @Override
             public List<String> groupStats() {
                 return Arrays.asList(groupStats);

server/src/test/java/org/elasticsearch/index/query/InnerHitBuilderTests.java

@@ -35,7 +35,7 @@ import org.elasticsearch.search.builder.SearchSourceBuilder;
 import org.elasticsearch.search.fetch.subphase.DocValueFieldsContext.FieldAndFormat;
 import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
 import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilderTests;
-import org.elasticsearch.search.internal.ShardSearchLocalRequest;
+import org.elasticsearch.search.internal.ShardSearchRequest;
 import org.elasticsearch.search.sort.SortBuilder;
 import org.elasticsearch.search.sort.SortBuilders;
 import org.elasticsearch.search.sort.SortOrder;
@@ -99,7 +99,7 @@ public class InnerHitBuilderTests extends ESTestCase {
      *
      * This is necessary to ensure because we use the serialized BytesReference
      * of this builder as part of the cacheKey in
-     * {@link ShardSearchLocalRequest} (via
+     * {@link ShardSearchRequest} (via
      * {@link SearchSourceBuilder#collapse(org.elasticsearch.search.collapse.CollapseBuilder)})
      */
     public void testSerializationOrder() throws Exception {

server/src/test/java/org/elasticsearch/search/SearchServiceTests.java

@@ -73,8 +73,7 @@ import org.elasticsearch.search.fetch.FetchSearchResult;
 import org.elasticsearch.search.fetch.ShardFetchRequest;
 import org.elasticsearch.search.internal.AliasFilter;
 import org.elasticsearch.search.internal.SearchContext;
-import org.elasticsearch.search.internal.ShardSearchLocalRequest;
-import org.elasticsearch.search.internal.ShardSearchTransportRequest;
+import org.elasticsearch.search.internal.ShardSearchRequest;
 import org.elasticsearch.search.suggest.SuggestBuilder;
 import org.elasticsearch.test.ESSingleNodeTestCase;
 
@@ -271,7 +270,7 @@ public class SearchServiceTests extends ESSingleNodeTestCase {
                         PlainActionFuture<SearchPhaseResult> result = new PlainActionFuture<>();
                         final boolean useScroll = randomBoolean();
                         service.executeQueryPhase(
-                            new ShardSearchLocalRequest(useScroll ? scrollSearchRequest : searchRequest,
+                            new ShardSearchRequest(OriginalIndices.NONE, useScroll ? scrollSearchRequest : searchRequest,
                                 indexShard.shardId(), 1,
                                 new AliasFilter(null, Strings.EMPTY_ARRAY), 1.0f, -1, null, null),
                             new SearchTask(123L, "", "", "", null, Collections.emptyMap()), result);
@@ -319,7 +318,8 @@ public class SearchServiceTests extends ESSingleNodeTestCase {
         final IndexShard indexShard = indexService.getShard(0);
         SearchRequest searchRequest = new SearchRequest().allowPartialSearchResults(true);
         final SearchContext contextWithDefaultTimeout = service.createContext(
-                new ShardSearchLocalRequest(
+                new ShardSearchRequest(
+                        OriginalIndices.NONE,
                         searchRequest,
                         indexShard.shardId(),
                         1,
@@ -337,7 +337,8 @@ public class SearchServiceTests extends ESSingleNodeTestCase {
         final long seconds = randomIntBetween(6, 10);
         searchRequest.source(new SearchSourceBuilder().timeout(TimeValue.timeValueSeconds(seconds)));
         final SearchContext context = service.createContext(
-                new ShardSearchLocalRequest(
+                new ShardSearchRequest(
+                        OriginalIndices.NONE,
                         searchRequest,
                         indexShard.shardId(),
                         1,
@@ -371,12 +372,14 @@ public class SearchServiceTests extends ESSingleNodeTestCase {
         for (int i = 0; i < indexService.getIndexSettings().getMaxDocvalueFields(); i++) {
             searchSourceBuilder.docValueField("field" + i);
         }
-        try (SearchContext context = service.createContext(new ShardSearchLocalRequest(searchRequest, indexShard.shardId(), 1,
-            new AliasFilter(null, Strings.EMPTY_ARRAY), 1.0f, -1, null, null))) {
+        try (SearchContext context = service.createContext(
+            new ShardSearchRequest(OriginalIndices.NONE, searchRequest, indexShard.shardId(), 1,
+                new AliasFilter(null, Strings.EMPTY_ARRAY), 1.0f, -1, null, null))
+        ) {
             assertNotNull(context);
             searchSourceBuilder.docValueField("one_field_too_much");
             IllegalArgumentException ex = expectThrows(IllegalArgumentException.class,
-                    () -> service.createContext(new ShardSearchLocalRequest(searchRequest, indexShard.shardId(), 1,
+                    () -> service.createContext(new ShardSearchRequest(OriginalIndices.NONE, searchRequest, indexShard.shardId(), 1,
                         new AliasFilter(null, Strings.EMPTY_ARRAY), 1.0f, -1, null, null)));
             assertEquals(
                     "Trying to retrieve too many docvalue_fields. Must be less than or equal to: [100] but was [101]. "
@@ -404,13 +407,14 @@ public class SearchServiceTests extends ESSingleNodeTestCase {
             searchSourceBuilder.scriptField("field" + i,
                     new Script(ScriptType.INLINE, MockScriptEngine.NAME, CustomScriptPlugin.DUMMY_SCRIPT, Collections.emptyMap()));
         }
-        try (SearchContext context = service.createContext(new ShardSearchLocalRequest(searchRequest, indexShard.shardId(), 1,
-            new AliasFilter(null, Strings.EMPTY_ARRAY), 1.0f, -1, null, null))) {
+        try (SearchContext context = service.createContext(new ShardSearchRequest(OriginalIndices.NONE, searchRequest,
+                indexShard.shardId(), 1, new AliasFilter(null, Strings.EMPTY_ARRAY),
+                1.0f, -1, null, null))) {
             assertNotNull(context);
             searchSourceBuilder.scriptField("anotherScriptField",
                     new Script(ScriptType.INLINE, MockScriptEngine.NAME, CustomScriptPlugin.DUMMY_SCRIPT, Collections.emptyMap()));
             IllegalArgumentException ex = expectThrows(IllegalArgumentException.class,
-                    () -> service.createContext(new ShardSearchLocalRequest(searchRequest, indexShard.shardId(), 1,
+                    () -> service.createContext(new ShardSearchRequest(OriginalIndices.NONE, searchRequest, indexShard.shardId(), 1,
                         new AliasFilter(null, Strings.EMPTY_ARRAY), 1.0f, -1, null, null)));
             assertEquals(
                     "Trying to retrieve too many script_fields. Must be less than or equal to: [" + maxScriptFields + "] but was ["
@@ -433,8 +437,9 @@ public class SearchServiceTests extends ESSingleNodeTestCase {
         searchSourceBuilder.scriptField("field" + 0,
                 new Script(ScriptType.INLINE, MockScriptEngine.NAME, CustomScriptPlugin.DUMMY_SCRIPT, Collections.emptyMap()));
         searchSourceBuilder.size(0);
-        try (SearchContext context = service.createContext(new ShardSearchLocalRequest(searchRequest, indexShard.shardId(), 1,
-            new AliasFilter(null, Strings.EMPTY_ARRAY), 1.0f, -1, null, null))) {
+        try (SearchContext context = service.createContext(new ShardSearchRequest(OriginalIndices.NONE,
+            searchRequest, indexShard.shardId(), 1, new AliasFilter(null, Strings.EMPTY_ARRAY),
+                1.0f, -1, null, null))) {
                 assertEquals(0, context.scriptFields().fields().size());
         }
     }
@@ -532,11 +537,11 @@ public class SearchServiceTests extends ESSingleNodeTestCase {
         }
     }
 
-    private static class ShardScrollRequestTest extends ShardSearchLocalRequest {
+    private static class ShardScrollRequestTest extends ShardSearchRequest {
         private Scroll scroll;
 
         ShardScrollRequestTest(ShardId shardId) {
-            super(new SearchRequest().allowPartialSearchResults(true),
+            super(OriginalIndices.NONE, new SearchRequest().allowPartialSearchResults(true),
                 shardId, 1, new AliasFilter(null, Strings.EMPTY_ARRAY), 1f, -1, null, null);
             this.scroll = new Scroll(TimeValue.timeValueMinutes(1));
         }
@@ -554,28 +559,28 @@ public class SearchServiceTests extends ESSingleNodeTestCase {
         final IndexService indexService = indicesService.indexServiceSafe(resolveIndex("index"));
         final IndexShard indexShard = indexService.getShard(0);
         SearchRequest searchRequest = new SearchRequest().allowPartialSearchResults(true);
-        assertTrue(service.canMatch(new ShardSearchLocalRequest(searchRequest, indexShard.shardId(), 1,
+        assertTrue(service.canMatch(new ShardSearchRequest(OriginalIndices.NONE, searchRequest, indexShard.shardId(), 1,
             new AliasFilter(null, Strings.EMPTY_ARRAY), 1f, -1, null, null)));
 
         searchRequest.source(new SearchSourceBuilder());
-        assertTrue(service.canMatch(new ShardSearchLocalRequest(searchRequest, indexShard.shardId(), 1,
+        assertTrue(service.canMatch(new ShardSearchRequest(OriginalIndices.NONE, searchRequest, indexShard.shardId(), 1,
             new AliasFilter(null, Strings.EMPTY_ARRAY), 1f, -1, null, null)));
 
         searchRequest.source(new SearchSourceBuilder().query(new MatchAllQueryBuilder()));
-        assertTrue(service.canMatch(new ShardSearchLocalRequest(searchRequest, indexShard.shardId(), 1,
+        assertTrue(service.canMatch(new ShardSearchRequest(OriginalIndices.NONE, searchRequest, indexShard.shardId(), 1,
             new AliasFilter(null, Strings.EMPTY_ARRAY), 1f, -1, null, null)));
 
         searchRequest.source(new SearchSourceBuilder().query(new MatchNoneQueryBuilder())
             .aggregation(new TermsAggregationBuilder("test", ValueType.STRING).minDocCount(0)));
-        assertTrue(service.canMatch(new ShardSearchLocalRequest(searchRequest, indexShard.shardId(), 1,
+        assertTrue(service.canMatch(new ShardSearchRequest(OriginalIndices.NONE, searchRequest, indexShard.shardId(), 1,
             new AliasFilter(null, Strings.EMPTY_ARRAY), 1f, -1,  null, null)));
         searchRequest.source(new SearchSourceBuilder().query(new MatchNoneQueryBuilder())
             .aggregation(new GlobalAggregationBuilder("test")));
-        assertTrue(service.canMatch(new ShardSearchLocalRequest(searchRequest, indexShard.shardId(), 1,
+        assertTrue(service.canMatch(new ShardSearchRequest(OriginalIndices.NONE, searchRequest, indexShard.shardId(), 1,
             new AliasFilter(null, Strings.EMPTY_ARRAY), 1f, -1, null, null)));
 
         searchRequest.source(new SearchSourceBuilder().query(new MatchNoneQueryBuilder()));
-        assertFalse(service.canMatch(new ShardSearchLocalRequest(searchRequest, indexShard.shardId(), 1,
+        assertFalse(service.canMatch(new ShardSearchRequest(OriginalIndices.NONE, searchRequest, indexShard.shardId(), 1,
             new AliasFilter(null, Strings.EMPTY_ARRAY), 1f, -1, null, null)));
     }
 
@@ -624,7 +629,7 @@ public class SearchServiceTests extends ESSingleNodeTestCase {
             iae.getMessage());
         assertFalse(service.getIndicesService().indexServiceSafe(index).getIndexSettings().isSearchThrottled());
         SearchRequest searchRequest = new SearchRequest().allowPartialSearchResults(false);
-        ShardSearchLocalRequest req = new ShardSearchLocalRequest(searchRequest, new ShardId(index, 0), 1,
+        ShardSearchRequest req = new ShardSearchRequest(OriginalIndices.NONE, searchRequest, new ShardId(index, 0), 1,
             new AliasFilter(null, Strings.EMPTY_ARRAY), 1f, -1, null, null);
         Thread currentThread = Thread.currentThread();
         // we still make sure can match is executed on the network thread
@@ -666,7 +671,7 @@ public class SearchServiceTests extends ESSingleNodeTestCase {
         String clusterAlias = randomBoolean() ? null : randomAlphaOfLengthBetween(3, 10);
         SearchRequest searchRequest = new SearchRequest();
         searchRequest.allowPartialSearchResults(randomBoolean());
-        ShardSearchTransportRequest request = new ShardSearchTransportRequest(OriginalIndices.NONE, searchRequest, shardId,
+        ShardSearchRequest request = new ShardSearchRequest(OriginalIndices.NONE, searchRequest, shardId,
             indexService.numberOfShards(), AliasFilter.EMPTY, 1f, nowInMillis, clusterAlias, Strings.EMPTY_ARRAY);
         try (DefaultSearchContext searchContext = service.createSearchContext(request, new TimeValue(System.currentTimeMillis()))) {
             SearchShardTarget searchShardTarget = searchContext.shardTarget();
@@ -694,7 +699,7 @@ public class SearchServiceTests extends ESSingleNodeTestCase {
 
         NullPointerException e = expectThrows(NullPointerException.class,
             () -> service.createContext(
-                new ShardSearchLocalRequest(shardId, null, 0, null) {
+                new ShardSearchRequest(shardId, null, 0, null) {
                     @Override
                     public SearchType searchType() {
                         // induce an artificial NPE

server/src/test/java/org/elasticsearch/search/internal/ShardSearchRequestTests.java

@@ -50,15 +50,15 @@ import static org.hamcrest.Matchers.containsString;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.nullValue;
 
-public class ShardSearchTransportRequestTests extends AbstractSearchTestCase {
+public class ShardSearchRequestTests extends AbstractSearchTestCase {
     private IndexMetaData baseMetaData = IndexMetaData.builder("test").settings(Settings.builder()
         .put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT).build())
         .numberOfShards(1).numberOfReplicas(1).build();
 
     public void testSerialization() throws Exception {
-        ShardSearchTransportRequest shardSearchTransportRequest = createShardSearchTransportRequest();
-        ShardSearchTransportRequest deserializedRequest =
-            copyWriteable(shardSearchTransportRequest, namedWriteableRegistry, ShardSearchTransportRequest::new);
+        ShardSearchRequest shardSearchTransportRequest = createShardSearchRequest();
+        ShardSearchRequest deserializedRequest =
+            copyWriteable(shardSearchTransportRequest, namedWriteableRegistry, ShardSearchRequest::new);
         assertEquals(deserializedRequest.scroll(), shardSearchTransportRequest.scroll());
         assertEquals(deserializedRequest.getAliasFilter(), shardSearchTransportRequest.getAliasFilter());
         assertArrayEquals(deserializedRequest.indices(), shardSearchTransportRequest.indices());
@@ -81,9 +81,9 @@ public class ShardSearchTransportRequestTests extends AbstractSearchTestCase {
 
     public void testAllowPartialResultsSerializationPre7_0_0() throws IOException {
         Version version = VersionUtils.randomVersionBetween(random(), Version.V_6_0_0, VersionUtils.getPreviousVersion(Version.V_7_0_0));
-        ShardSearchTransportRequest shardSearchTransportRequest = createShardSearchTransportRequest();
-        ShardSearchTransportRequest deserializedRequest =
-            copyWriteable(shardSearchTransportRequest, namedWriteableRegistry, ShardSearchTransportRequest::new, version);
+        ShardSearchRequest shardSearchTransportRequest = createShardSearchRequest();
+        ShardSearchRequest deserializedRequest =
+            copyWriteable(shardSearchTransportRequest, namedWriteableRegistry, ShardSearchRequest::new, version);
         if (version.before(Version.V_6_3_0)) {
             assertFalse(deserializedRequest.allowPartialSearchResults());
         } else {
@@ -91,7 +91,7 @@ public class ShardSearchTransportRequestTests extends AbstractSearchTestCase {
         }
     }
 
-    private ShardSearchTransportRequest createShardSearchTransportRequest() throws IOException {
+    private ShardSearchRequest createShardSearchRequest() throws IOException {
         SearchRequest searchRequest = createSearchRequest();
         ShardId shardId = new ShardId(randomAlphaOfLengthBetween(2, 10), randomAlphaOfLengthBetween(2, 10), randomInt());
         final AliasFilter filteringAliases;
@@ -102,7 +102,7 @@ public class ShardSearchTransportRequestTests extends AbstractSearchTestCase {
             filteringAliases = new AliasFilter(null, Strings.EMPTY_ARRAY);
         }
         final String[] routings = generateRandomStringArray(5, 10, false, true);
-        return new ShardSearchTransportRequest(new OriginalIndices(searchRequest), searchRequest, shardId,
+        return new ShardSearchRequest(new OriginalIndices(searchRequest), searchRequest, shardId,
             randomIntBetween(1, 100), filteringAliases, randomBoolean() ? 1.0f : randomFloat(),
             Math.abs(randomLong()), randomAlphaOfLengthBetween(3, 10), routings);
     }

server/src/test/java/org/elasticsearch/search/slice/SliceBuilderTests.java

@@ -30,10 +30,9 @@ import org.apache.lucene.search.Query;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.store.RAMDirectory;
 import org.elasticsearch.Version;
-import org.elasticsearch.action.IndicesRequest;
+import org.elasticsearch.action.OriginalIndices;
+import org.elasticsearch.action.search.SearchRequest;
 import org.elasticsearch.action.search.SearchShardIterator;
-import org.elasticsearch.action.search.SearchType;
-import org.elasticsearch.action.support.IndicesOptions;
 import org.elasticsearch.cluster.ClusterState;
 import org.elasticsearch.cluster.metadata.IndexMetaData;
 import org.elasticsearch.cluster.metadata.MetaData;
@@ -43,24 +42,18 @@ import org.elasticsearch.cluster.routing.ShardIterator;
 import org.elasticsearch.cluster.service.ClusterService;
 import org.elasticsearch.common.Nullable;
 import org.elasticsearch.common.Strings;
-import org.elasticsearch.common.bytes.BytesReference;
 import org.elasticsearch.common.io.stream.NamedWriteableRegistry;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.xcontent.XContentBuilder;
 import org.elasticsearch.common.xcontent.XContentFactory;
 import org.elasticsearch.common.xcontent.XContentParser;
 import org.elasticsearch.common.xcontent.XContentType;
-import org.elasticsearch.index.Index;
 import org.elasticsearch.index.IndexSettings;
 import org.elasticsearch.index.fielddata.IndexNumericFieldData;
 import org.elasticsearch.index.mapper.IdFieldMapper;
 import org.elasticsearch.index.mapper.MappedFieldType;
 import org.elasticsearch.index.query.QueryShardContext;
-import org.elasticsearch.index.query.Rewriteable;
 import org.elasticsearch.index.shard.ShardId;
-import org.elasticsearch.search.Scroll;
-import org.elasticsearch.search.builder.SearchSourceBuilder;
-import org.elasticsearch.search.internal.AliasFilter;
 import org.elasticsearch.search.internal.ShardSearchRequest;
 import org.elasticsearch.test.ESTestCase;
 
@@ -84,120 +77,6 @@ import static org.mockito.Mockito.when;
 public class SliceBuilderTests extends ESTestCase {
     private static final int MAX_SLICE = 20;
 
-    static class ShardSearchRequestTest implements IndicesRequest, ShardSearchRequest {
-        private final String[] indices;
-        private final int shardId;
-        private final String[] indexRoutings;
-        private final String preference;
-
-        ShardSearchRequestTest(String index, int shardId, String[] indexRoutings, String preference) {
-            this.indices = new String[] { index };
-            this.shardId = shardId;
-            this.indexRoutings = indexRoutings;
-            this.preference = preference;
-        }
-
-        @Override
-        public String[] indices() {
-            return indices;
-        }
-
-        @Override
-        public IndicesOptions indicesOptions() {
-            return null;
-        }
-
-        @Override
-        public ShardId shardId() {
-            return new ShardId(new Index(indices[0], indices[0]), shardId);
-        }
-
-        @Override
-        public String[] types() {
-            return new String[0];
-        }
-
-        @Override
-        public SearchSourceBuilder source() {
-            return null;
-        }
-
-        @Override
-        public AliasFilter getAliasFilter() {
-            return null;
-        }
-
-        @Override
-        public void setAliasFilter(AliasFilter filter) {
-
-        }
-
-        @Override
-        public void source(SearchSourceBuilder source) {
-
-        }
-
-        @Override
-        public int numberOfShards() {
-            return 0;
-        }
-
-        @Override
-        public SearchType searchType() {
-            return null;
-        }
-
-        @Override
-        public float indexBoost() {
-            return 0;
-        }
-
-        @Override
-        public long nowInMillis() {
-            return 0;
-        }
-
-        @Override
-        public Boolean requestCache() {
-            return null;
-        }
-
-        @Override
-        public boolean allowPartialSearchResults() {
-            return true;
-        }
-
-        @Override
-        public Scroll scroll() {
-            return null;
-        }
-
-        @Override
-        public String[] indexRoutings() {
-            return indexRoutings;
-        }
-
-        @Override
-        public String preference() {
-            return preference;
-        }
-
-        @Override
-        public BytesReference cacheKey() {
-            return null;
-        }
-
-        @Override
-        public String getClusterAlias() {
-            return null;
-        }
-
-        @Override
-        public Rewriteable<Rewriteable> getRewriteable() {
-            return null;
-        }
-    }
-
     private static SliceBuilder randomSliceBuilder() {
         int max = randomIntBetween(2, MAX_SLICE);
         int id = randomIntBetween(1, max - 1);
@@ -233,7 +112,8 @@ public class SliceBuilderTests extends ESTestCase {
     }
 
     private ShardSearchRequest createRequest(int shardId, String[] routings, String preference) {
-        return new ShardSearchRequestTest("index", shardId, routings, preference);
+        return new ShardSearchRequest(OriginalIndices.NONE, new SearchRequest().preference(preference).allowPartialSearchResults(true),
+            new ShardId("index", "index", shardId), 1, null, 0f, System.currentTimeMillis(), null, routings);
     }
 
     private QueryShardContext createShardContext(Version indexVersionCreated, IndexReader reader,

x-pack/plugin/frozen-indices/src/test/java/org/elasticsearch/index/engine/FrozenIndexTests.java

@@ -6,6 +6,7 @@
 package org.elasticsearch.index.engine;
 
 import org.elasticsearch.action.ActionListener;
+import org.elasticsearch.action.OriginalIndices;
 import org.elasticsearch.action.admin.cluster.state.ClusterStateResponse;
 import org.elasticsearch.action.admin.indices.stats.IndicesStatsResponse;
 import org.elasticsearch.action.delete.DeleteResponse;
@@ -36,7 +37,7 @@ import org.elasticsearch.rest.RestStatus;
 import org.elasticsearch.search.SearchService;
 import org.elasticsearch.search.builder.SearchSourceBuilder;
 import org.elasticsearch.search.internal.AliasFilter;
-import org.elasticsearch.search.internal.ShardSearchLocalRequest;
+import org.elasticsearch.search.internal.ShardSearchRequest;
 import org.elasticsearch.test.ESSingleNodeTestCase;
 import org.elasticsearch.xpack.core.XPackClient;
 import org.elasticsearch.xpack.frozen.FrozenIndices;
@@ -254,17 +255,17 @@ public class FrozenIndexTests extends ESSingleNodeTestCase {
             assertFalse(indexService.getIndexSettings().isSearchThrottled());
             SearchService searchService = getInstanceFromNode(SearchService.class);
             SearchRequest searchRequest = new SearchRequest().allowPartialSearchResults(true);
-            assertTrue(searchService.canMatch(new ShardSearchLocalRequest(searchRequest, shard.shardId(), 1,
+            assertTrue(searchService.canMatch(new ShardSearchRequest(OriginalIndices.NONE, searchRequest, shard.shardId(), 1,
                 new AliasFilter(null, Strings.EMPTY_ARRAY), 1f, -1, null, null)));
 
             SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
             searchRequest.source(sourceBuilder);
             sourceBuilder.query(QueryBuilders.rangeQuery("field").gte("2010-01-03||+2d").lte("2010-01-04||+2d/d"));
-            assertTrue(searchService.canMatch(new ShardSearchLocalRequest(searchRequest, shard.shardId(), 1,
+            assertTrue(searchService.canMatch(new ShardSearchRequest(OriginalIndices.NONE, searchRequest, shard.shardId(), 1,
                 new AliasFilter(null, Strings.EMPTY_ARRAY), 1f, -1, null, null)));
 
             sourceBuilder.query(QueryBuilders.rangeQuery("field").gt("2010-01-06T02:00").lt("2010-01-07T02:00"));
-            assertFalse(searchService.canMatch(new ShardSearchLocalRequest(searchRequest, shard.shardId(), 1,
+            assertFalse(searchService.canMatch(new ShardSearchRequest(OriginalIndices.NONE, searchRequest, shard.shardId(), 1,
                 new AliasFilter(null, Strings.EMPTY_ARRAY), 1f, -1, null, null)));
         }
 
@@ -279,17 +280,17 @@ public class FrozenIndexTests extends ESSingleNodeTestCase {
             assertTrue(indexService.getIndexSettings().isSearchThrottled());
             SearchService searchService = getInstanceFromNode(SearchService.class);
             SearchRequest searchRequest = new SearchRequest().allowPartialSearchResults(true);
-            assertTrue(searchService.canMatch(new ShardSearchLocalRequest(searchRequest, shard.shardId(), 1,
+            assertTrue(searchService.canMatch(new ShardSearchRequest(OriginalIndices.NONE, searchRequest, shard.shardId(), 1,
                 new AliasFilter(null, Strings.EMPTY_ARRAY), 1f, -1, null, null)));
 
             SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
             sourceBuilder.query(QueryBuilders.rangeQuery("field").gte("2010-01-03||+2d").lte("2010-01-04||+2d/d"));
             searchRequest.source(sourceBuilder);
-            assertTrue(searchService.canMatch(new ShardSearchLocalRequest(searchRequest, shard.shardId(), 1,
+            assertTrue(searchService.canMatch(new ShardSearchRequest(OriginalIndices.NONE, searchRequest, shard.shardId(), 1,
                 new AliasFilter(null, Strings.EMPTY_ARRAY), 1f, -1, null, null)));
 
             sourceBuilder.query(QueryBuilders.rangeQuery("field").gt("2010-01-06T02:00").lt("2010-01-07T02:00"));
-            assertFalse(searchService.canMatch(new ShardSearchLocalRequest(searchRequest, shard.shardId(), 1,
+            assertFalse(searchService.canMatch(new ShardSearchRequest(OriginalIndices.NONE, searchRequest, shard.shardId(), 1,
                 new AliasFilter(null, Strings.EMPTY_ARRAY), 1f, -1, null, null)));
 
             IndicesStatsResponse response = client().admin().indices().prepareStats("index").clear().setRefresh(true).get();

x-pack/plugin/security/src/test/java/org/elasticsearch/xpack/security/authz/IndicesAndAliasesResolverTests.java

@@ -47,7 +47,7 @@ import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.index.Index;
 import org.elasticsearch.index.IndexNotFoundException;
 import org.elasticsearch.protocol.xpack.graph.GraphExploreRequest;
-import org.elasticsearch.search.internal.ShardSearchTransportRequest;
+import org.elasticsearch.search.internal.ShardSearchRequest;
 import org.elasticsearch.test.ESTestCase;
 import org.elasticsearch.transport.TransportRequest;
 import org.elasticsearch.xpack.core.graph.action.GraphExploreAction;
@@ -197,7 +197,7 @@ public class IndicesAndAliasesResolverTests extends ESTestCase {
     public void testDashIndicesAreAllowedInShardLevelRequests() {
         //indices with names starting with '-' or '+' can be created up to version  2.x and can be around in 5.x
         //aliases with names starting with '-' or '+' can be created up to version 5.x and can be around in 6.x
-        ShardSearchTransportRequest request = mock(ShardSearchTransportRequest.class);
+        ShardSearchRequest request = mock(ShardSearchRequest.class);
         when(request.indices()).thenReturn(new String[]{"-index10", "-index20", "+index30"});
         List<String> indices = resolveIndices(request, buildAuthorizedIndices(userDashIndices, SearchAction.NAME))
                 .getLocal();
@@ -207,7 +207,7 @@ public class IndicesAndAliasesResolverTests extends ESTestCase {
     }
 
     public void testWildcardsAreNotAllowedInShardLevelRequests() {
-        ShardSearchTransportRequest request = mock(ShardSearchTransportRequest.class);
+        ShardSearchRequest request = mock(ShardSearchRequest.class);
         when(request.indices()).thenReturn(new String[]{"index*"});
         IllegalStateException illegalStateException = expectThrows(IllegalStateException.class,
                 () -> resolveIndices(request, buildAuthorizedIndices(userDashIndices, SearchAction.NAME))
@@ -217,7 +217,7 @@ public class IndicesAndAliasesResolverTests extends ESTestCase {
     }
 
     public void testAllIsNotAllowedInShardLevelRequests() {
-        ShardSearchTransportRequest request = mock(ShardSearchTransportRequest.class);
+        ShardSearchRequest request = mock(ShardSearchRequest.class);
         if (randomBoolean()) {
             when(request.indices()).thenReturn(new String[]{"_all"});
         } else {