Wire project routing resolver for index resolution (#137170)

This PR wires the current project routing resolver implementation into
index resolution process. The behaviour expectation is that a qualified
index expresssion, such as `P1:foo` should behave the same way as an
unqualified expression plus project routing, i.e. `foo` and `_alias:P1`.

Author: ywangd

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

@@ -89,6 +89,11 @@ default boolean allowsRemoteIndices() {
         default boolean allowsCrossProject() {
             return false;
         }
+
+        @Nullable // if no routing is specified
+        default String getProjectRouting() {
+            return null;
+        }
     }
 
     /**

server/src/main/java/org/elasticsearch/action/admin/indices/resolve/ResolveIndexAction.java

@@ -98,6 +98,7 @@ public static class Request extends LegacyActionRequest implements IndicesReques
         private IndicesOptions indicesOptions = DEFAULT_INDICES_OPTIONS;
         private EnumSet<IndexMode> indexModes = EnumSet.noneOf(IndexMode.class);
         private ResolvedIndexExpressions resolvedIndexExpressions = null;
+        private String projectRouting;
 
         public Request(String[] names) {
             this.names = names;
@@ -109,11 +110,21 @@ public Request(String[] names, IndicesOptions indicesOptions) {
         }
 
         public Request(String[] names, IndicesOptions indicesOptions, @Nullable EnumSet<IndexMode> indexModes) {
+            this(names, indicesOptions, indexModes, null);
+        }
+
+        public Request(
+            String[] names,
+            IndicesOptions indicesOptions,
+            @Nullable EnumSet<IndexMode> indexModes,
+            @Nullable String projectRouting
+        ) {
             this.names = names;
             this.indicesOptions = indicesOptions;
             if (indexModes != null) {
                 this.indexModes = indexModes;
             }
+            this.projectRouting = projectRouting;
         }
 
         @Override
@@ -196,6 +207,11 @@ public boolean includeDataStreams() {
             // request must allow data streams because the index name expression resolver for the action handler assumes it
             return true;
         }
+
+        @Override
+        public String getProjectRouting() {
+            return projectRouting;
+        }
     }
 
     public static class ResolvedIndexAbstraction {
@@ -631,6 +647,7 @@ protected void doExecute(Task task, Request request, final ActionListener<Respon
                             }
                             final Exception ex = CrossProjectIndexResolutionValidator.validate(
                                 originalIndicesOptions,
+                                request.getProjectRouting(),
                                 localResolvedIndexExpressions,
                                 getResolvedExpressionsByRemote(remoteResponses)
                             );
@@ -668,6 +685,7 @@ protected void doExecute(Task task, Request request, final ActionListener<Respon
                     // `<alias-pattern-matching-origin-only>:index` also get deferred validation
                     final Exception ex = CrossProjectIndexResolutionValidator.validate(
                         originalIndicesOptions,
+                        request.getProjectRouting(),
                         localResolvedIndexExpressions,
                         Map.of()
                     );

server/src/main/java/org/elasticsearch/cluster/metadata/IndexAbstractionResolver.java

@@ -76,10 +76,8 @@ public ResolvedIndexExpressions resolveIndexAbstractions(
         final TargetProjects targetProjects,
         final boolean includeDataStreams
     ) {
-        assert targetProjects != TargetProjects.LOCAL_ONLY_FOR_CPS_DISABLED
-            : "cannot resolve indices cross project if target set is local only";
-        if (false == targetProjects.crossProject()) {
-            final String message = "cannot resolve indices cross project if target set is not cross project";
+        if (targetProjects == TargetProjects.LOCAL_ONLY_FOR_CPS_DISABLED) {
+            final String message = "cannot resolve indices cross project if target set is local only";
             assert false : message;
             throw new IllegalArgumentException(message);
         }

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

@@ -58,9 +58,9 @@ protected BaseRestHandler.RestChannelConsumer prepareRequest(RestRequest request
         String[] indices = Strings.splitStringByCommaToArray(request.param("name"));
         String modeParam = request.param("mode");
         final boolean crossProjectEnabled = settings != null && settings.getAsBoolean("serverless.cross_project.enabled", false);
+        String projectRouting = null;
         if (crossProjectEnabled) {
-            // accept but drop project_routing param until fully supported
-            request.param("project_routing");
+            projectRouting = request.param("project_routing");
         }
         IndicesOptions indicesOptions = IndicesOptions.fromRequest(request, ResolveIndexAction.Request.DEFAULT_INDICES_OPTIONS);
         if (crossProjectEnabled) {
@@ -75,7 +75,8 @@ protected BaseRestHandler.RestChannelConsumer prepareRequest(RestRequest request
                 ? null
                 : Arrays.stream(modeParam.split(","))
                     .map(IndexMode::fromString)
-                    .collect(() -> EnumSet.noneOf(IndexMode.class), EnumSet::add, EnumSet::addAll)
+                    .collect(() -> EnumSet.noneOf(IndexMode.class), EnumSet::add, EnumSet::addAll),
+            projectRouting
         );
         return channel -> client.admin().indices().resolveIndex(resolveRequest, new RestToXContentListener<>(channel));
     }

server/src/main/java/org/elasticsearch/search/crossproject/CrossProjectIndexExpressionsRewriter.java

@@ -94,11 +94,15 @@ public static IndexRewriteResult rewriteIndexExpression(
         @Nullable String originProjectAlias,
         Set<String> allProjectAliases
     ) {
-        assert originProjectAlias != null || allProjectAliases.isEmpty() == false
-            : "either origin project or linked projects must be in project target set";
-
         maybeThrowOnUnsupportedResource(indexExpression);
 
+        // Always 404 when no project is available for index resolution. This is matching error handling behaviour for resolving
+        // projects with qualified index patterns such as "missing-*:index".
+        if (originProjectAlias == null && allProjectAliases.isEmpty()) {
+            // TODO: add project_routing string to the exception message
+            throw new NoMatchingProjectException("no matching project after applying project routing");
+        }
+
         final boolean isQualified = RemoteClusterAware.isRemoteIndexName(indexExpression);
         final IndexRewriteResult rewrittenExpression;
         if (isQualified) {

server/src/main/java/org/elasticsearch/search/crossproject/CrossProjectIndexResolutionValidator.java

@@ -16,6 +16,8 @@
 import org.elasticsearch.action.ResolvedIndexExpression;
 import org.elasticsearch.action.ResolvedIndexExpressions;
 import org.elasticsearch.action.support.IndicesOptions;
+import org.elasticsearch.common.Strings;
+import org.elasticsearch.core.Nullable;
 import org.elasticsearch.index.IndexNotFoundException;
 import org.elasticsearch.rest.RestStatus;
 import org.elasticsearch.transport.RemoteClusterAware;
@@ -66,12 +68,14 @@ public class CrossProjectIndexResolutionValidator {
      * local and linked project resolution results when determining the appropriate error response.
      *
      * @param indicesOptions            Controls error behavior for missing indices
+     * @param projectRouting            The project routing string from the request, can be null if request does not specify it
      * @param localResolvedExpressions  Resolution results from the origin project
      * @param remoteResolvedExpressions Resolution results from linked projects
      * @return a {@link ElasticsearchException} if validation fails, null if validation passes
      */
     public static ElasticsearchException validate(
         IndicesOptions indicesOptions,
+        @Nullable String projectRouting,
         ResolvedIndexExpressions localResolvedExpressions,
         Map<String, ResolvedIndexExpressions> remoteResolvedExpressions
     ) {
@@ -80,19 +84,21 @@ public static ElasticsearchException validate(
             return null;
         }
 
+        final boolean hasProjectRouting = Strings.isEmpty(projectRouting) == false;
         logger.debug(
-            "Checking index existence for [{}] and [{}] with indices options [{}]",
+            "Checking index existence for [{}] and [{}] with indices options [{}]{}",
             localResolvedExpressions,
             remoteResolvedExpressions,
-            indicesOptions
+            indicesOptions,
+            hasProjectRouting ? " and project routing [" + projectRouting + "]" : ""
         );
 
         for (ResolvedIndexExpression localResolvedIndices : localResolvedExpressions.expressions()) {
             String originalExpression = localResolvedIndices.original();
             logger.debug("Checking replaced expression for original expression [{}]", originalExpression);
 
-            // Check if this is a qualified resource (project:index pattern)
-            boolean isQualifiedExpression = RemoteClusterAware.isRemoteIndexName(originalExpression);
+            // Check if this is a qualified resource (project:index pattern) or has project routing
+            boolean isQualifiedExpression = hasProjectRouting || RemoteClusterAware.isRemoteIndexName(originalExpression);
 
             Set<String> remoteExpressions = localResolvedIndices.remoteExpressions();
             ResolvedIndexExpression.LocalExpressions localExpressions = localResolvedIndices.localExpressions();

server/src/main/java/org/elasticsearch/search/crossproject/CrossProjectRoutingResolver.java

@@ -15,7 +15,6 @@
 import java.util.Set;
 import java.util.function.Predicate;
 import java.util.stream.IntStream;
-import java.util.stream.Stream;
 
 import static org.elasticsearch.rest.RestStatus.BAD_REQUEST;
 
@@ -24,7 +23,7 @@
  * Resolves a single entry _alias for a cross-project request specifying a project_routing.
  * We currently only support a single entry routing containing either a specific name, a prefix, a suffix, or a match-all (*).
  */
-public class CrossProjectRoutingResolver {
+public class CrossProjectRoutingResolver implements ProjectRoutingResolver {
     private static final String ALIAS = "_alias:";
     private static final String ORIGIN = "_origin";
     private static final int ALIAS_LENGTH = ALIAS.length();
@@ -60,39 +59,50 @@ public class CrossProjectRoutingResolver {
     );
 
     /**
-     * @param projectRouting the project_routing specified in the request object.
-     * @param originProject the project alias where this function is being called.
-     * @param candidateProjects the list of project aliases for the active request. This list must *NOT* contain the originProject entry.
-     * @return the filtered list of projects matching the projectRouting, or an empty list if none are found.
-     * @throws ElasticsearchStatusException if the projectRouting is null, empty, does not start with "_alias:", contains more than one
-     *                                      entry, or contains an '*' in the middle of a string.
+     * Filters the specified TargetProjects based on the provided project routing string
+     * @param projectRouting the project_routing specified in the request object
+     * @param targetProjects The target projects to be filtered
+     * @return A new TargetProjects instance containing only the projects that match the project routing.
+     *  @throws ElasticsearchStatusException if the projectRouting is null, empty, does not start with "_alias:", contains more than one
+     *                                       entry, or contains an '*' in the middle of a string.
      */
-    public List<ProjectRoutingInfo> resolve(
-        String projectRouting,
-        ProjectRoutingInfo originProject,
-        List<ProjectRoutingInfo> candidateProjects
-    ) {
+    @Override
+    public TargetProjects resolve(String projectRouting, TargetProjects targetProjects) {
+        assert targetProjects != TargetProjects.LOCAL_ONLY_FOR_CPS_DISABLED;
+        if (targetProjects.isEmpty()) {
+            return TargetProjects.EMPTY;
+        }
+
+        if (projectRouting == null || projectRouting.isEmpty() || ALIAS_MATCH_ALL.equalsIgnoreCase(projectRouting)) {
+            return targetProjects;
+        }
+
+        final var originProject = targetProjects.originProject();
+        assert originProject != null : "origin project must not be null";
+        // TODO: some of the assertions such as alias and non-overlapping could be enforced in TargetProjects constructor
         assert originProject.projectAlias().equalsIgnoreCase(ORIGIN) == false : "origin project alias must not be " + ORIGIN;
 
+        if (ALIAS_MATCH_ORIGIN.equalsIgnoreCase(projectRouting)) {
+            return new TargetProjects(originProject, List.of());
+        }
+
+        final var candidateProjects = targetProjects.linkedProjects();
+        assert candidateProjects != null : "candidate projects must not be null";
+
         var candidateProjectStream = candidateProjects.stream().peek(candidateProject -> {
             assert candidateProject.projectAlias().equalsIgnoreCase(ORIGIN) == false : "project alias must not be " + ORIGIN;
         }).filter(candidateProject -> {
             assert candidateProject.equals(originProject) == false : "origin project must not be in the candidateProjects list";
             return candidateProject.equals(originProject) == false; // assertions are disabled in prod, instead we should filter this out
         });
 
-        if (ALIAS_MATCH_ORIGIN.equalsIgnoreCase(projectRouting)) {
-            return List.of(originProject);
-        }
-
-        if (projectRouting == null || projectRouting.isEmpty() || ALIAS_MATCH_ALL.equalsIgnoreCase(projectRouting)) {
-            return Stream.concat(Stream.of(originProject), candidateProjectStream).toList();
-        }
-
         validateProjectRouting(projectRouting);
 
         var matchesSpecifiedRoute = createRoutingEntryFilter(projectRouting);
-        return Stream.concat(Stream.of(originProject), candidateProjectStream).filter(matchesSpecifiedRoute).toList();
+        return new TargetProjects(
+            matchesSpecifiedRoute.test(originProject) ? originProject : null,
+            candidateProjectStream.filter(matchesSpecifiedRoute).toList()
+        );
     }
 
     private static void validateProjectRouting(String projectRouting) {

server/src/main/java/org/elasticsearch/search/crossproject/ProjectRoutingResolver.java

@@ -0,0 +1,24 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the "Elastic License
+ * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+package org.elasticsearch.search.crossproject;
+
+/**
+ * Filter for the target projects based on the provided project routing string.
+ */
+public interface ProjectRoutingResolver {
+
+    /**
+     * Filters the specified TargetProjects based on the provided project routing string
+     * @param projectRouting the project_routing specified in the request object
+     * @param targetProjects The target projects to be filtered
+     * @return A new TargetProjects instance containing only the projects that match the project routing.
+     */
+    TargetProjects resolve(String projectRouting, TargetProjects targetProjects);
+}