Cross-project search index expression rewriting

server/src/main/java/org/elasticsearch/ElasticsearchException.java

@@ -80,7 +80,7 @@
 import static org.elasticsearch.cluster.metadata.IndexMetadata.INDEX_UUID_NA_VALUE;
 import static org.elasticsearch.common.xcontent.XContentParserUtils.ensureExpectedToken;
 import static org.elasticsearch.common.xcontent.XContentParserUtils.ensureFieldName;
-import static org.elasticsearch.search.crossproject.IndexExpressionsRewriter.NO_MATCHING_PROJECT_EXCEPTION_VERSION;
+import static org.elasticsearch.search.crossproject.CrossProjectIndexExpressionsRewriter.NO_MATCHING_PROJECT_EXCEPTION_VERSION;
 
 /**
  * A base class for all elasticsearch exceptions.

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

@@ -80,6 +80,15 @@ default ResolvedIndexExpressions getResolvedIndexExpressions() {
         default boolean allowsRemoteIndices() {
             return false;
         }
+
+        /**
+         * Determines whether the request type allows cross-project processing. Cross-project processing entails cross-project search
+         * index resolution and error handling. Note: this method only determines in the request _supports_ cross-project.
+         * Whether cross-project processing is actually performed is determined by {@link IndicesOptions}.
+         */
+        default boolean allowsCrossProject() {
+            return false;
+        }
     }
 
     /**

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

@@ -10,8 +10,12 @@
 package org.elasticsearch.action;
 
 import org.elasticsearch.ElasticsearchException;
+import org.elasticsearch.common.io.stream.StreamInput;
+import org.elasticsearch.common.io.stream.StreamOutput;
+import org.elasticsearch.common.io.stream.Writeable;
 import org.elasticsearch.core.Nullable;
 
+import java.io.IOException;
 import java.util.Set;
 
 /**
@@ -40,7 +44,21 @@
  *                         and failure info
  * @param remoteExpressions the remote expressions that replace the original
  */
-public record ResolvedIndexExpression(String original, LocalExpressions localExpressions, Set<String> remoteExpressions) {
+public record ResolvedIndexExpression(String original, LocalExpressions localExpressions, Set<String> remoteExpressions)
+    implements
+        Writeable {
+
+    public ResolvedIndexExpression(StreamInput in) throws IOException {
+        this(in.readString(), new LocalExpressions(in), in.readCollectionAsImmutableSet(StreamInput::readString));
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        out.writeString(original);
+        localExpressions.writeTo(out);
+        out.writeStringCollection(remoteExpressions);
+    }
+
     /**
      * Indicates if a local index resolution attempt was successful or failed.
      * Failures can be due to concrete resources not being visible (either missing or not visible due to indices options)
@@ -62,13 +80,28 @@ public record LocalExpressions(
         Set<String> expressions,
         LocalIndexResolutionResult localIndexResolutionResult,
         @Nullable ElasticsearchException exception
-    ) {
+    ) implements Writeable {
         public LocalExpressions {
             assert localIndexResolutionResult != LocalIndexResolutionResult.SUCCESS || exception == null
                 : "If the local resolution result is SUCCESS, exception must be null";
         }
 
         // Singleton for the case where all expressions in a ResolvedIndexExpression instance are remote
         public static final LocalExpressions NONE = new LocalExpressions(Set.of(), LocalIndexResolutionResult.NONE, null);
+
+        public LocalExpressions(StreamInput in) throws IOException {
+            this(
+                in.readCollectionAsImmutableSet(StreamInput::readString),
+                in.readEnum(LocalIndexResolutionResult.class),
+                ElasticsearchException.readException(in)
+            );
+        }
+
+        @Override
+        public void writeTo(StreamOutput out) throws IOException {
+            out.writeStringCollection(expressions);
+            out.writeEnum(localIndexResolutionResult);
+            ElasticsearchException.writeException(exception, out);
+        }
     }
 }

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

@@ -9,8 +9,13 @@
 
 package org.elasticsearch.action;
 
+import org.elasticsearch.TransportVersion;
 import org.elasticsearch.action.ResolvedIndexExpression.LocalExpressions;
+import org.elasticsearch.common.io.stream.StreamInput;
+import org.elasticsearch.common.io.stream.StreamOutput;
+import org.elasticsearch.common.io.stream.Writeable;
 
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
@@ -20,50 +25,78 @@
 /**
  * A collection of {@link ResolvedIndexExpression}.
  */
-public record ResolvedIndexExpressions(List<ResolvedIndexExpression> expressions) {
+public record ResolvedIndexExpressions(List<ResolvedIndexExpression> expressions) implements Writeable {
+    public static final TransportVersion RESOLVED_INDEX_EXPRESSIONS = TransportVersion.fromName("resolved_index_expressions");
+
+    public ResolvedIndexExpressions(StreamInput in) throws IOException {
+        this(in.readCollectionAsImmutableList(ResolvedIndexExpression::new));
+    }
 
     public List<String> getLocalIndicesList() {
         return expressions.stream().flatMap(e -> e.localExpressions().expressions().stream()).toList();
     }
 
+    public List<String> getRemoteIndicesList() {
+        return expressions.stream().flatMap(e -> e.remoteExpressions().stream()).toList();
+    }
+
     public static Builder builder() {
         return new Builder();
     }
 
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        out.writeCollection(expressions);
+    }
+
     public static final class Builder {
         private final List<ResolvedIndexExpression> expressions = new ArrayList<>();
 
         /**
+         * Add a new resolved expression.
          * @param original         the original expression that was resolved -- may be blank for "access all" cases
          * @param localExpressions is a HashSet as an optimization -- the set needs to be mutable, and we want to avoid copying it.
          *                         May be empty.
          */
-        public void addLocalExpressions(
+        public void addExpressions(
             String original,
             HashSet<String> localExpressions,
-            ResolvedIndexExpression.LocalIndexResolutionResult resolutionResult
+            ResolvedIndexExpression.LocalIndexResolutionResult resolutionResult,
+            Set<String> remoteExpressions
         ) {
             Objects.requireNonNull(original);
             Objects.requireNonNull(localExpressions);
             Objects.requireNonNull(resolutionResult);
+            Objects.requireNonNull(remoteExpressions);
             expressions.add(
-                new ResolvedIndexExpression(original, new LocalExpressions(localExpressions, resolutionResult, null), new HashSet<>())
+                new ResolvedIndexExpression(original, new LocalExpressions(localExpressions, resolutionResult, null), remoteExpressions)
             );
         }
 
+        public void addRemoteExpressions(String original, Set<String> remoteExpressions) {
+            Objects.requireNonNull(original);
+            Objects.requireNonNull(remoteExpressions);
+            expressions.add(new ResolvedIndexExpression(original, LocalExpressions.NONE, remoteExpressions));
+        }
+
         /**
          * Exclude the given expressions from the local expressions of all prior added {@link ResolvedIndexExpression}.
          */
         public void excludeFromLocalExpressions(Set<String> expressionsToExclude) {
             Objects.requireNonNull(expressionsToExclude);
             if (expressionsToExclude.isEmpty() == false) {
                 for (ResolvedIndexExpression prior : expressions) {
-                    prior.localExpressions().expressions().removeAll(expressionsToExclude);
+                    final Set<String> localExpressions = prior.localExpressions().expressions();
+                    if (localExpressions.isEmpty()) {
+                        continue;
+                    }
+                    localExpressions.removeAll(expressionsToExclude);
                 }
             }
         }
 
         public ResolvedIndexExpressions build() {
+            // TODO make all sets on `expressions` immutable
             return new ResolvedIndexExpressions(expressions);
         }
     }