Projected Views

server/src/internalClusterTest/java/org/opensearch/action/admin/indices/view/ViewIT.java

@@ -0,0 +1,80 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.indices.view;
+
+import org.opensearch.action.search.SearchRequest;
+import org.opensearch.action.search.SearchResponse;
+import org.opensearch.index.IndexNotFoundException;
+import org.opensearch.test.BackgroundIndexer;
+import org.opensearch.test.OpenSearchIntegTestCase;
+import org.opensearch.test.OpenSearchIntegTestCase.ClusterScope;
+import org.opensearch.test.OpenSearchIntegTestCase.Scope;
+
+import java.util.List;
+
+import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertHitCount;
+import static org.hamcrest.Matchers.is;
+
+@ClusterScope(scope = Scope.TEST, numDataNodes = 2)
+public class ViewIT extends OpenSearchIntegTestCase {
+
+    private int createIndexWithDocs(final String indexName) throws Exception {
+        createIndex(indexName);
+        ensureGreen(indexName);
+
+        final int numOfDocs = scaledRandomIntBetween(0, 200);
+        try (final BackgroundIndexer indexer = new BackgroundIndexer(indexName, "_doc", client(), numOfDocs)) {
+            waitForDocs(numOfDocs, indexer);
+        }
+
+        refresh(indexName);
+        assertHitCount(client().prepareSearch(indexName).setSize(0).get(), numOfDocs);
+        return numOfDocs;
+    }
+
+    private CreateViewAction.Response createView(final String name, final String indexPattern) throws Exception {
+        final CreateViewAction.Request request = new CreateViewAction.Request(
+            name,
+            null,
+            List.of(new CreateViewAction.Request.Target(indexPattern))
+        );
+        final CreateViewAction.Response response = client().admin().indices().createView(request).actionGet();
+        performRemoteStoreTestAction();
+        return response;
+    }
+
+    private SearchResponse searchView(final String viewName) throws Exception {
+        final SearchViewAction.Request request = SearchViewAction.createRequestWith(viewName, new SearchRequest());
+        final SearchResponse response = client().admin().indices().searchView(request).actionGet();
+        return response;
+    }
+
+    public void testBasicOperations() throws Exception {
+        final String indexInView1 = "index-1";
+        final String indexInView2 = "index-2";
+        final String indexNotInView = "another-index-1";
+
+        final int indexInView1DocCount = createIndexWithDocs(indexInView1);
+        final int indexInView2DocCount = createIndexWithDocs(indexInView2);
+        createIndexWithDocs(indexNotInView);
+
+        logger.info("Testing view with no matches");
+        createView("no-matches", "this-pattern-will-match-nothing");
+        final IndexNotFoundException ex = assertThrows(IndexNotFoundException.class, () -> searchView("no-matches"));
+        assertThat(ex.getMessage(), is("no such index [this-pattern-will-match-nothing]"));
+
+        logger.info("Testing view with exact index match");
+        createView("only-index-1", "index-1");
+        assertHitCount(searchView("only-index-1"), indexInView1DocCount);
+
+        logger.info("Testing view with wildcard matches");
+        createView("both-indices", "index-*");
+        assertHitCount(searchView("both-indices"), indexInView1DocCount + indexInView2DocCount);
+    }
+}

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

@@ -224,6 +224,8 @@
 import org.opensearch.action.admin.indices.upgrade.post.UpgradeSettingsAction;
 import org.opensearch.action.admin.indices.validate.query.TransportValidateQueryAction;
 import org.opensearch.action.admin.indices.validate.query.ValidateQueryAction;
+import org.opensearch.action.admin.indices.view.CreateViewAction;
+import org.opensearch.action.admin.indices.view.SearchViewAction;
 import org.opensearch.action.bulk.BulkAction;
 import org.opensearch.action.bulk.TransportBulkAction;
 import org.opensearch.action.bulk.TransportShardBulkAction;
@@ -409,6 +411,7 @@
 import org.opensearch.rest.action.admin.indices.RestUpgradeAction;
 import org.opensearch.rest.action.admin.indices.RestUpgradeStatusAction;
 import org.opensearch.rest.action.admin.indices.RestValidateQueryAction;
+import org.opensearch.rest.action.admin.indices.RestViewAction;
 import org.opensearch.rest.action.cat.AbstractCatAction;
 import org.opensearch.rest.action.cat.RestAliasAction;
 import org.opensearch.rest.action.cat.RestAllocationAction;
@@ -721,6 +724,10 @@ public <Request extends ActionRequest, Response extends ActionResponse> void reg
         actions.register(ResolveIndexAction.INSTANCE, ResolveIndexAction.TransportAction.class);
         actions.register(DataStreamsStatsAction.INSTANCE, DataStreamsStatsAction.TransportAction.class);
 
+        // Views:
+        actions.register(CreateViewAction.INSTANCE, CreateViewAction.TransportAction.class);
+        actions.register(SearchViewAction.INSTANCE, SearchViewAction.TransportAction.class);
+
         // Persistent tasks:
         actions.register(StartPersistentTaskAction.INSTANCE, StartPersistentTaskAction.TransportAction.class);
         actions.register(UpdatePersistentTaskStatusAction.INSTANCE, UpdatePersistentTaskStatusAction.TransportAction.class);
@@ -915,6 +922,10 @@ public void initRestHandlers(Supplier<DiscoveryNodes> nodesInCluster) {
         registerHandler.accept(new RestResolveIndexAction());
         registerHandler.accept(new RestDataStreamsStatsAction());
 
+        // View API
+        registerHandler.accept(new RestViewAction.CreateViewHandler());
+        registerHandler.accept(new RestViewAction.SearchViewHandler());
+
         // CAT API
         registerHandler.accept(new RestAllocationAction());
         registerHandler.accept(new RestCatSegmentReplicationAction());

server/src/main/java/org/opensearch/action/admin/indices/view/CreateViewAction.java

@@ -0,0 +1,276 @@
+package org.opensearch.action.admin.indices.view;
+
+import org.opensearch.action.ActionRequestValidationException;
+import org.opensearch.action.ActionType;
+import org.opensearch.action.ValidateActions;
+import org.opensearch.action.support.ActionFilters;
+import org.opensearch.action.support.clustermanager.ClusterManagerNodeRequest;
+import org.opensearch.action.support.clustermanager.TransportClusterManagerNodeAction;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.block.ClusterBlockException;
+import org.opensearch.cluster.block.ClusterBlockLevel;
+import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
+import org.opensearch.cluster.metadata.View;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.common.inject.Inject;
+import org.opensearch.core.ParseField;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.action.ActionResponse;
+import org.opensearch.core.common.Strings;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.common.io.stream.Writeable;
+import org.opensearch.core.common.util.CollectionUtils;
+import org.opensearch.core.xcontent.ConstructingObjectParser;
+import org.opensearch.core.xcontent.ToXContentObject;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.core.xcontent.XContentParser;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.TransportService;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+/** Action to create a view */
+public class CreateViewAction extends ActionType<CreateViewAction.Response> {
+
+    public static final CreateViewAction INSTANCE = new CreateViewAction();
+    public static final String NAME = "cluster:admin:views:create";
+
+    private CreateViewAction() {
+        super(NAME, CreateViewAction.Response::new);
+    }
+
+    /**
+     * Request for Creating View
+     */
+    @ExperimentalApi
+    public static class Request extends ClusterManagerNodeRequest<Request> {
+        private final String name;
+        private final String description;
+        private final List<Target> targets;
+
+        public Request(final String name, final String description, final List<Target> targets) {
+            this.name = name;
+            this.description = Objects.requireNonNullElse(description, "");
+            this.targets = targets;
+        }
+
+        public Request(final StreamInput in) throws IOException {
+            super(in);
+            this.name = in.readString();
+            this.description = in.readString();
+            this.targets = in.readList(Target::new);
+        }
+
+        public String getName() {
+            return name;
+        }
+
+        public String getDescription() {
+            return description;
+        }
+
+        public List<Target> getTargets() {
+            return new ArrayList<>(targets);
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            Request that = (Request) o;
+            return name.equals(that.name) && description.equals(that.description) && targets.equals(that.targets);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(name, description, targets);
+        }
+
+        @Override
+        public ActionRequestValidationException validate() {
+            ActionRequestValidationException validationException = null;
+            if (Strings.isNullOrEmpty(name)) {
+                validationException = ValidateActions.addValidationError("Name is cannot be empty or null", validationException);
+            }
+            if (CollectionUtils.isEmpty(targets)) {
+                validationException = ValidateActions.addValidationError("targets cannot be empty", validationException);
+            } else {
+                for (final Target target : targets) {
+                    validationException = target.validate();
+                }
+            }
+
+            return validationException;
+        }
+
+        @Override
+        public void writeTo(final StreamOutput out) throws IOException {
+            super.writeTo(out);
+            out.writeString(name);
+            out.writeString(description);
+            out.writeList(targets);
+        }
+
+        /** View target representation for create requests */
+        @ExperimentalApi
+        public static class Target implements Writeable {
+            public final String indexPattern;
+
+            public Target(final String indexPattern) {
+                this.indexPattern = indexPattern;
+            }
+
+            public Target(final StreamInput in) throws IOException {
+                this.indexPattern = in.readString();
+            }
+
+            public String getIndexPattern() {
+                return indexPattern;
+            }
+
+            @Override
+            public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+                Target that = (Target) o;
+                return indexPattern.equals(that.indexPattern);
+            }
+
+            @Override
+            public int hashCode() {
+                return Objects.hash(indexPattern);
+            }
+
+            @Override
+            public void writeTo(StreamOutput out) throws IOException {
+                out.writeString(indexPattern);
+            }
+
+            public ActionRequestValidationException validate() {
+                ActionRequestValidationException validationException = null;
+
+                if (Strings.isNullOrEmpty(indexPattern)) {
+                    validationException = ValidateActions.addValidationError("index pattern cannot be empty or null", validationException);
+                }
+
+                return validationException;
+            }
+
+            private static final ConstructingObjectParser<Target, Void> PARSER = new ConstructingObjectParser<>(
+                "target",
+                args -> new Target((String) args[0])
+            );
+            static {
+                PARSER.declareString(ConstructingObjectParser.constructorArg(), View.Target.INDEX_PATTERN_FIELD);
+            }
+
+            public static Target fromXContent(final XContentParser parser) throws IOException {
+                return PARSER.parse(parser, null);
+            }
+        }
+
+        @SuppressWarnings("unchecked")
+        private static final ConstructingObjectParser<Request, Void> PARSER = new ConstructingObjectParser<>(
+            "create_view_request",
+            args -> new Request((String) args[0], (String) args[1], (List<Target>) args[2])
+        );
+
+        static {
+            PARSER.declareString(ConstructingObjectParser.constructorArg(), View.NAME_FIELD);
+            PARSER.declareString(ConstructingObjectParser.optionalConstructorArg(), View.DESCRIPTION_FIELD);
+            PARSER.declareObjectArray(ConstructingObjectParser.constructorArg(), (p, c) -> Target.fromXContent(p), View.TARGETS_FIELD);
+        }
+
+        public static Request fromXContent(final XContentParser parser) throws IOException {
+            return PARSER.parse(parser, null);
+        }
+    }
+
+    /** Response for view creation */
+    @ExperimentalApi
+    public static class Response extends ActionResponse implements ToXContentObject {
+
+        private final View createdView;
+
+        public Response(final View createdView) {
+            this.createdView = createdView;
+        }
+
+        public Response(final StreamInput in) throws IOException {
+            super(in);
+            this.createdView = new View(in);
+        }
+
+        @Override
+        public void writeTo(final StreamOutput out) throws IOException {
+            this.createdView.writeTo(out);
+        }
+
+        @Override
+        public XContentBuilder toXContent(final XContentBuilder builder, final Params params) throws IOException {
+            builder.startObject();
+            builder.field("view", createdView);
+            builder.endObject();
+            return builder;
+        }
+
+        private static final ConstructingObjectParser<Response, Void> PARSER = new ConstructingObjectParser<>(
+            "create_view_response",
+            args -> new Response((View) args[0])
+        );
+        static {
+            PARSER.declareObject(ConstructingObjectParser.constructorArg(), View.PARSER, new ParseField("view"));
+        }
+
+        public static Response fromXContent(final XContentParser parser) throws IOException {
+            return PARSER.parse(parser, null);
+        }
+    }
+
+    /**
+     * Transport Action for creating a View
+     */
+    public static class TransportAction extends TransportClusterManagerNodeAction<Request, Response> {
+
+        private final ViewService viewService;
+
+        @Inject
+        public TransportAction(
+            final TransportService transportService,
+            final ClusterService clusterService,
+            final ThreadPool threadPool,
+            final ActionFilters actionFilters,
+            final IndexNameExpressionResolver indexNameExpressionResolver,
+            final ViewService viewService
+        ) {
+            super(NAME, transportService, clusterService, threadPool, actionFilters, Request::new, indexNameExpressionResolver);
+            this.viewService = viewService;
+        }
+
+        @Override
+        protected String executor() {
+            return ThreadPool.Names.MANAGEMENT;
+        }
+
+        @Override
+        protected Response read(final StreamInput in) throws IOException {
+            return new Response(in);
+        }
+
+        @Override
+        protected void clusterManagerOperation(final Request request, final ClusterState state, final ActionListener<Response> listener)
+            throws Exception {
+            viewService.createView(request, listener);
+        }
+
+        @Override
+        protected ClusterBlockException checkBlock(final Request request, final ClusterState state) {
+            return state.blocks().globalBlockedException(ClusterBlockLevel.METADATA_WRITE);
+        }
+    }
+}