Add MinDocsCondition to Rollover API

CHANGELOG.md

@@ -77,6 +77,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ## [Unreleased 2.x]
 ### Added
+- Add MinDocsCondition to Rollover API ([#7243](https://github.com/opensearch-project/OpenSearch/pull/7243))
 - Add metrics for thread_pool task wait time ([#9681](https://github.com/opensearch-project/OpenSearch/pull/9681))
 - Async blob read support for S3 plugin ([#9694](https://github.com/opensearch-project/OpenSearch/pull/9694))
 

client/rest-high-level/src/main/java/org/opensearch/client/indices/rollover/RolloverRequest.java

@@ -35,6 +35,7 @@
 import org.opensearch.action.admin.indices.rollover.MaxAgeCondition;
 import org.opensearch.action.admin.indices.rollover.MaxDocsCondition;
 import org.opensearch.action.admin.indices.rollover.MaxSizeCondition;
+import org.opensearch.action.admin.indices.rollover.MinDocsCondition;
 import org.opensearch.client.TimedRequest;
 import org.opensearch.client.indices.CreateIndexRequest;
 import org.opensearch.common.unit.TimeValue;
@@ -131,6 +132,18 @@ public RolloverRequest addMaxIndexSizeCondition(ByteSizeValue size) {
         return this;
     }
 
+    /**
+     * Adds condition to check if the index has at least <code>numDocs</code> to perform rollover.
+     */
+    public RolloverRequest addMinIndexDocsCondition(long numDocs) {
+        MinDocsCondition minDocsCondition = new MinDocsCondition(numDocs);
+        if (this.conditions.containsKey(minDocsCondition.name())) {
+            throw new IllegalArgumentException(minDocsCondition.name() + " condition is already set");
+        }
+        this.conditions.put(minDocsCondition.name(), minDocsCondition);
+        return this;
+    }
+
     /**
      * Returns all set conditions
      */

client/rest-high-level/src/test/java/org/opensearch/client/indices/rollover/RolloverRequestTests.java

@@ -36,6 +36,7 @@
 import org.opensearch.action.admin.indices.rollover.MaxAgeCondition;
 import org.opensearch.action.admin.indices.rollover.MaxDocsCondition;
 import org.opensearch.action.admin.indices.rollover.MaxSizeCondition;
+import org.opensearch.action.admin.indices.rollover.MinDocsCondition;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.test.OpenSearchTestCase;
@@ -61,10 +62,12 @@ public void testConstructorAndFieldAssignments() {
         MaxAgeCondition maxAgeCondition = new MaxAgeCondition(new TimeValue(10));
         MaxSizeCondition maxSizeCondition = new MaxSizeCondition(new ByteSizeValue(2000));
         MaxDocsCondition maxDocsCondition = new MaxDocsCondition(10000L);
-        Condition<?>[] expectedConditions = new Condition<?>[] { maxAgeCondition, maxSizeCondition, maxDocsCondition };
+        MinDocsCondition minDocsCondition = new MinDocsCondition(1L);
+        Condition<?>[] expectedConditions = new Condition<?>[] { maxAgeCondition, maxSizeCondition, maxDocsCondition, minDocsCondition };
         rolloverRequest.addMaxIndexAgeCondition(maxAgeCondition.value());
         rolloverRequest.addMaxIndexSizeCondition(maxSizeCondition.value());
         rolloverRequest.addMaxIndexDocsCondition(maxDocsCondition.value());
+        rolloverRequest.addMinIndexDocsCondition(minDocsCondition.value());
         List<Condition<?>> requestConditions = new ArrayList<>(rolloverRequest.getConditions().values());
         assertThat(requestConditions, containsInAnyOrder(expectedConditions));
     }

server/src/main/java/org/opensearch/action/admin/indices/rollover/MinDocsCondition.java

@@ -0,0 +1,89 @@
+/*
+ * 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.
+ */
+
+/*
+ * 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.
+ */
+
+/*
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+package org.opensearch.action.admin.indices.rollover;
+
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.core.xcontent.XContentParser;
+
+import java.io.IOException;
+
+/**
+ * Condition for minimum index docs.
+ * Evaluates to <code>true</code> when the index has at least {@link #value} docs.
+ * If it evaluates to <code>false</code> then it prevents rollover
+ *
+ * @opensearch.internal
+ */
+public class MinDocsCondition extends Condition<Long> {
+    public static final String NAME = "min_docs";
+
+    public MinDocsCondition(Long value) {
+        super(NAME);
+        this.value = value;
+    }
+
+    public MinDocsCondition(StreamInput in) throws IOException {
+        super(NAME);
+        this.value = in.readLong();
+    }
+
+    @Override
+    public Result evaluate(final Stats stats) {
+        return new Result(this, this.value <= stats.numDocs);
+    }
+
+    @Override
+    public String getWriteableName() {
+        return NAME;
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        out.writeLong(value);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        return builder.field(NAME, value);
+    }
+
+    public static MinDocsCondition fromXContent(XContentParser parser) throws IOException {
+        if (parser.nextToken() == XContentParser.Token.VALUE_NUMBER) {
+            return new MinDocsCondition(parser.longValue());
+        } else {
+            throw new IllegalArgumentException("invalid token: " + parser.currentToken());
+        }
+    }
+}

server/src/main/java/org/opensearch/action/admin/indices/rollover/RolloverRequest.java

@@ -69,6 +69,7 @@ public class RolloverRequest extends AcknowledgedRequest<RolloverRequest> implem
     private static final ParseField MAX_AGE_CONDITION = new ParseField(MaxAgeCondition.NAME);
     private static final ParseField MAX_DOCS_CONDITION = new ParseField(MaxDocsCondition.NAME);
     private static final ParseField MAX_SIZE_CONDITION = new ParseField(MaxSizeCondition.NAME);
+    private static final ParseField MIN_DOCS_CONDITION = new ParseField(MinDocsCondition.NAME);
 
     static {
         CONDITION_PARSER.declareString(
@@ -86,6 +87,10 @@ public class RolloverRequest extends AcknowledgedRequest<RolloverRequest> implem
             ),
             MAX_SIZE_CONDITION
         );
+        CONDITION_PARSER.declareLong(
+            (conditions, value) -> conditions.put(MinDocsCondition.NAME, new MinDocsCondition(value)),
+            MIN_DOCS_CONDITION
+        );
 
         PARSER.declareField(
             (parser, request, context) -> CONDITION_PARSER.parse(parser, request.conditions, null),
@@ -239,6 +244,17 @@ public void addMaxIndexSizeCondition(ByteSizeValue size) {
         this.conditions.put(maxSizeCondition.name, maxSizeCondition);
     }
 
+    /**
+     * Adds condition to check if the index has at least <code>numDocs</code> to perform rollover.
+     */
+    public void addMinIndexDocsCondition(long numDocs) {
+        MinDocsCondition minDocsCondition = new MinDocsCondition(numDocs);
+        if (this.conditions.containsKey(minDocsCondition.name)) {
+            throw new IllegalArgumentException(minDocsCondition.name + " condition is already set");
+        }
+        this.conditions.put(minDocsCondition.name, minDocsCondition);
+    }
+
     public boolean isDryRun() {
         return dryRun;
     }

server/src/main/java/org/opensearch/action/admin/indices/rollover/RolloverRequestBuilder.java

@@ -77,6 +77,11 @@ public RolloverRequestBuilder addMaxIndexSizeCondition(ByteSizeValue size) {
         return this;
     }
 
+    public RolloverRequestBuilder addMinIndexDocsCondition(long docs) {
+        this.request.addMinIndexDocsCondition(docs);
+        return this;
+    }
+
     public RolloverRequestBuilder dryRun(boolean dryRun) {
         this.request.dryRun(dryRun);
         return this;

server/src/main/java/org/opensearch/action/admin/indices/rollover/TransportRolloverAction.java

@@ -185,7 +185,11 @@ public void onResponse(IndicesStatsResponse statsResponse) {
                     .stream()
                     .filter(condition -> conditionResults.get(condition.toString()))
                     .collect(Collectors.toList());
-                if (conditionResults.size() == 0 || metConditions.size() > 0) {
+                boolean hasMinDocsCondition = rolloverRequest.getConditions().containsKey(MinDocsCondition.NAME);
+                boolean metMinDocsCondition = hasMinDocsCondition
+                    ? conditionResults.get(rolloverRequest.getConditions().get(MinDocsCondition.NAME))
+                    : true;
+                if (conditionResults.size() == 0 || ((metConditions.size() - (hasMinDocsCondition ? 1 : 0)) > 0 && metMinDocsCondition)) {
                     clusterService.submitStateUpdateTask(
                         "rollover_index source [" + sourceIndexName + "] to target [" + rolloverIndexName + "]",
                         new ClusterStateUpdateTask() {

server/src/test/java/org/opensearch/action/admin/indices/rollover/ConditionTests.java

@@ -97,6 +97,20 @@ public void testMaxSize() {
         assertThat(result.matched, equalTo(true));
     }
 
+    public void testMinDocs() {
+        MinDocsCondition minDocsCondition = new MinDocsCondition(100L);
+
+        long minDocsMatch = randomIntBetween(100, 1000);
+        Condition.Result evaluate = minDocsCondition.evaluate(new Condition.Stats(minDocsMatch, 0, randomByteSize()));
+        assertThat(evaluate.condition, equalTo(minDocsCondition));
+        assertThat(evaluate.matched, equalTo(true));
+
+        long minDocsNotMatch = randomIntBetween(0, 99);
+        evaluate = minDocsCondition.evaluate(new Condition.Stats(0, minDocsNotMatch, randomByteSize()));
+        assertThat(evaluate.condition, equalTo(minDocsCondition));
+        assertThat(evaluate.matched, equalTo(false));
+    }
+
     public void testEqualsAndHashCode() {
         MaxDocsCondition maxDocsCondition = new MaxDocsCondition(randomLong());
         EqualsHashCodeTestUtils.checkEqualsAndHashCode(
@@ -118,6 +132,13 @@ public void testEqualsAndHashCode() {
             condition -> new MaxAgeCondition(condition.value),
             condition -> new MaxAgeCondition(new TimeValue(randomNonNegativeLong()))
         );
+
+        MinDocsCondition minDocsCondition = new MinDocsCondition(randomLong());
+        EqualsHashCodeTestUtils.checkEqualsAndHashCode(
+            minDocsCondition,
+            condition -> new MinDocsCondition(condition.value),
+            condition -> new MinDocsCondition(randomLong())
+        );
     }
 
     private static ByteSizeValue randomByteSize() {

server/src/test/java/org/opensearch/action/admin/indices/rollover/RolloverRequestTests.java

@@ -83,17 +83,20 @@ public void testConditionsParsing() throws Exception {
             .field("max_age", "10d")
             .field("max_docs", 100)
             .field("max_size", "45gb")
+            .field("min_docs", 1)
             .endObject()
             .endObject();
         request.fromXContent(createParser(builder));
         Map<String, Condition<?>> conditions = request.getConditions();
-        assertThat(conditions.size(), equalTo(3));
+        assertThat(conditions.size(), equalTo(4));
         MaxAgeCondition maxAgeCondition = (MaxAgeCondition) conditions.get(MaxAgeCondition.NAME);
         assertThat(maxAgeCondition.value.getMillis(), equalTo(TimeValue.timeValueHours(24 * 10).getMillis()));
         MaxDocsCondition maxDocsCondition = (MaxDocsCondition) conditions.get(MaxDocsCondition.NAME);
         assertThat(maxDocsCondition.value, equalTo(100L));
         MaxSizeCondition maxSizeCondition = (MaxSizeCondition) conditions.get(MaxSizeCondition.NAME);
         assertThat(maxSizeCondition.value.getBytes(), equalTo(ByteSizeUnit.GB.toBytes(45)));
+        MinDocsCondition minDocsCondition = (MinDocsCondition) conditions.get(MinDocsCondition.NAME);
+        assertThat(minDocsCondition.value, equalTo(1L));
     }
 
     public void testParsingWithIndexSettings() throws Exception {
@@ -213,6 +216,7 @@ public void testValidation() {
         conditionsGenerator.add((request) -> request.addMaxIndexDocsCondition(randomNonNegativeLong()));
         conditionsGenerator.add((request) -> request.addMaxIndexSizeCondition(new ByteSizeValue(randomNonNegativeLong())));
         conditionsGenerator.add((request) -> request.addMaxIndexAgeCondition(new TimeValue(randomNonNegativeLong())));
+        conditionsGenerator.add((request) -> request.addMinIndexDocsCondition(randomNonNegativeLong()));
     }
 
 }

server/src/test/java/org/opensearch/action/admin/indices/rollover/TransportRolloverActionTests.java

@@ -128,9 +128,12 @@ public void testEvaluateConditions() {
         MaxDocsCondition maxDocsCondition = new MaxDocsCondition(100L);
         MaxAgeCondition maxAgeCondition = new MaxAgeCondition(TimeValue.timeValueHours(2));
         MaxSizeCondition maxSizeCondition = new MaxSizeCondition(new ByteSizeValue(randomIntBetween(10, 100), ByteSizeUnit.MB));
+        MinDocsCondition minDocsCondition = new MinDocsCondition(10L);
+
+        long matchMaxDocsAndMatchMinDocs = randomIntBetween(100, 1000);
+        long notMatchMaxDocsAndMatchMinDocs = randomIntBetween(10, 99);
+        long notMatchMaxDocsAndNotMatchMinDocs = randomIntBetween(0, 9);
 
-        long matchMaxDocs = randomIntBetween(100, 1000);
-        long notMatchMaxDocs = randomIntBetween(0, 99);
         ByteSizeValue notMatchMaxSize = new ByteSizeValue(randomIntBetween(0, 9), ByteSizeUnit.MB);
         final Settings settings = Settings.builder()
             .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
@@ -142,26 +145,44 @@ public void testEvaluateConditions() {
             .creationDate(System.currentTimeMillis() - TimeValue.timeValueHours(3).getMillis())
             .settings(settings)
             .build();
-        final Set<Condition<?>> conditions = Sets.newHashSet(maxDocsCondition, maxAgeCondition, maxSizeCondition);
+        final Set<Condition<?>> conditions = Sets.newHashSet(maxDocsCondition, maxAgeCondition, maxSizeCondition, minDocsCondition);
         Map<String, Boolean> results = evaluateConditions(
             conditions,
-            new DocsStats(matchMaxDocs, 0L, ByteSizeUnit.MB.toBytes(120)),
+            new DocsStats(matchMaxDocsAndMatchMinDocs, 0L, ByteSizeUnit.MB.toBytes(120)),
             metadata
         );
-        assertThat(results.size(), equalTo(3));
+        assertThat(results.size(), equalTo(4));
         for (Boolean matched : results.values()) {
             assertThat(matched, equalTo(true));
         }
 
-        results = evaluateConditions(conditions, new DocsStats(notMatchMaxDocs, 0, notMatchMaxSize.getBytes()), metadata);
-        assertThat(results.size(), equalTo(3));
+        results = evaluateConditions(conditions, new DocsStats(notMatchMaxDocsAndMatchMinDocs, 0, notMatchMaxSize.getBytes()), metadata);
+        assertThat(results.size(), equalTo(4));
         for (Map.Entry<String, Boolean> entry : results.entrySet()) {
             if (entry.getKey().equals(maxAgeCondition.toString())) {
                 assertThat(entry.getValue(), equalTo(true));
             } else if (entry.getKey().equals(maxDocsCondition.toString())) {
                 assertThat(entry.getValue(), equalTo(false));
             } else if (entry.getKey().equals(maxSizeCondition.toString())) {
                 assertThat(entry.getValue(), equalTo(false));
+            } else if (entry.getKey().equals(minDocsCondition.toString())) {
+                assertThat(entry.getValue(), equalTo(true));
+            } else {
+                fail("unknown condition result found " + entry.getKey());
+            }
+        }
+
+        results = evaluateConditions(conditions, new DocsStats(notMatchMaxDocsAndNotMatchMinDocs, 0, notMatchMaxSize.getBytes()), metadata);
+        assertThat(results.size(), equalTo(4));
+        for (Map.Entry<String, Boolean> entry : results.entrySet()) {
+            if (entry.getKey().equals(maxAgeCondition.toString())) {
+                assertThat(entry.getValue(), equalTo(true));
+            } else if (entry.getKey().equals(maxSizeCondition.toString())) {
+                assertThat(entry.getValue(), equalTo(false));
+            } else if (entry.getKey().equals(maxDocsCondition.toString())) {
+                assertThat(entry.getValue(), equalTo(false));
+            } else if (entry.getKey().equals(minDocsCondition.toString())) {
+                assertThat(entry.getValue(), equalTo(false));
             } else {
                 fail("unknown condition result found " + entry.getKey());
             }
@@ -172,8 +193,9 @@ public void testEvaluateWithoutDocStats() {
         MaxDocsCondition maxDocsCondition = new MaxDocsCondition(randomNonNegativeLong());
         MaxAgeCondition maxAgeCondition = new MaxAgeCondition(TimeValue.timeValueHours(randomIntBetween(1, 3)));
         MaxSizeCondition maxSizeCondition = new MaxSizeCondition(new ByteSizeValue(randomNonNegativeLong()));
+        MinDocsCondition minDocsCondition = new MinDocsCondition(randomNonNegativeLong());
 
-        Set<Condition<?>> conditions = Sets.newHashSet(maxDocsCondition, maxAgeCondition, maxSizeCondition);
+        Set<Condition<?>> conditions = Sets.newHashSet(maxDocsCondition, maxAgeCondition, maxSizeCondition, minDocsCondition);
         final Settings settings = Settings.builder()
             .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
             .put(IndexMetadata.SETTING_INDEX_UUID, UUIDs.randomBase64UUID())
@@ -186,7 +208,7 @@ public void testEvaluateWithoutDocStats() {
             .settings(settings)
             .build();
         Map<String, Boolean> results = evaluateConditions(conditions, null, metadata);
-        assertThat(results.size(), equalTo(3));
+        assertThat(results.size(), equalTo(4));
 
         for (Map.Entry<String, Boolean> entry : results.entrySet()) {
             if (entry.getKey().equals(maxAgeCondition.toString())) {
@@ -195,6 +217,8 @@ public void testEvaluateWithoutDocStats() {
                 assertThat(entry.getValue(), equalTo(false));
             } else if (entry.getKey().equals(maxSizeCondition.toString())) {
                 assertThat(entry.getValue(), equalTo(false));
+            } else if (entry.getKey().equals(minDocsCondition.toString())) {
+                assertThat(entry.getValue(), equalTo(false));
             } else {
                 fail("unknown condition result found " + entry.getKey());
             }