Add max_single_primary_size as a condition for the rollover index API

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

@@ -10,6 +10,7 @@
 import org.elasticsearch.action.admin.indices.rollover.Condition;
 import org.elasticsearch.action.admin.indices.rollover.MaxAgeCondition;
 import org.elasticsearch.action.admin.indices.rollover.MaxDocsCondition;
+import org.elasticsearch.action.admin.indices.rollover.MaxSinglePrimarySizeCondition;
 import org.elasticsearch.action.admin.indices.rollover.MaxSizeCondition;
 import org.elasticsearch.client.TimedRequest;
 import org.elasticsearch.client.indices.CreateIndexRequest;
@@ -94,6 +95,7 @@ public RolloverRequest addMaxIndexDocsCondition(long numDocs) {
         this.conditions.put(maxDocsCondition.name(), maxDocsCondition);
         return this;
     }
+
     /**
      * Adds a size-based condition to check if the index size is at least <code>size</code>.
      */
@@ -105,6 +107,19 @@ public RolloverRequest addMaxIndexSizeCondition(ByteSizeValue size) {
         this.conditions.put(maxSizeCondition.name(), maxSizeCondition);
         return this;
     }
+
+    /**
+     * Adds a size-based condition to check if the size of the largest primary shard is at least <code>size</code>.
+     */
+    public RolloverRequest addMaxSinglePrimarySizeCondition(ByteSizeValue size) {
+        MaxSinglePrimarySizeCondition maxSinglePrimarySizeCondition = new MaxSinglePrimarySizeCondition(size);
+        if (this.conditions.containsKey(maxSinglePrimarySizeCondition.name())) {
+            throw new IllegalArgumentException(maxSinglePrimarySizeCondition + " condition is already set");
+        }
+        this.conditions.put(maxSinglePrimarySizeCondition.name(), maxSinglePrimarySizeCondition);
+        return this;
+    }
+
     /**
      * Returns all set conditions
      */

client/rest-high-level/src/test/java/org/elasticsearch/client/IndicesClientIT.java

@@ -958,15 +958,17 @@ public void testRollover() throws IOException {
             rolloverRequest.getCreateIndexRequest().mapping(mappings, XContentType.JSON);
             rolloverRequest.dryRun(false);
             rolloverRequest.addMaxIndexSizeCondition(new ByteSizeValue(1, ByteSizeUnit.MB));
+            rolloverRequest.addMaxSinglePrimarySizeCondition(new ByteSizeValue(1, ByteSizeUnit.MB));
             RolloverResponse rolloverResponse = execute(rolloverRequest, highLevelClient().indices()::rollover,
                     highLevelClient().indices()::rolloverAsync);
             assertTrue(rolloverResponse.isRolledOver());
             assertFalse(rolloverResponse.isDryRun());
             Map<String, Boolean> conditionStatus = rolloverResponse.getConditionStatus();
-            assertEquals(3, conditionStatus.size());
+            assertEquals(4, conditionStatus.size());
             assertTrue(conditionStatus.get("[max_docs: 1]"));
             assertTrue(conditionStatus.get("[max_age: 1ms]"));
             assertFalse(conditionStatus.get("[max_size: 1mb]"));
+            assertFalse(conditionStatus.get("[max_single_primary_size: 1mb]"));
             assertEquals("test", rolloverResponse.getOldIndex());
             assertEquals("test_new", rolloverResponse.getNewIndex());
         }

client/rest-high-level/src/test/java/org/elasticsearch/client/documentation/IndicesClientDocumentationIT.java

@@ -1802,6 +1802,7 @@ public void testRolloverIndex() throws Exception {
         request.addMaxIndexAgeCondition(new TimeValue(7, TimeUnit.DAYS)); // <2>
         request.addMaxIndexDocsCondition(1000); // <3>
         request.addMaxIndexSizeCondition(new ByteSizeValue(5, ByteSizeUnit.GB)); // <4>
+        request.addMaxSinglePrimarySizeCondition(new ByteSizeValue(2, ByteSizeUnit.GB)); // <5>
         // end::rollover-index-request
 
         // tag::rollover-index-request-timeout
@@ -1848,7 +1849,7 @@ public void testRolloverIndex() throws Exception {
         assertEquals("index-2", newIndex);
         assertFalse(isRolledOver);
         assertTrue(isDryRun);
-        assertEquals(3, conditionStatus.size());
+        assertEquals(4, conditionStatus.size());
 
         // tag::rollover-index-execute-listener
         ActionListener<RolloverResponse> listener = new ActionListener<RolloverResponse>() {

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

@@ -11,6 +11,7 @@
 import org.elasticsearch.action.admin.indices.rollover.Condition;
 import org.elasticsearch.action.admin.indices.rollover.MaxAgeCondition;
 import org.elasticsearch.action.admin.indices.rollover.MaxDocsCondition;
+import org.elasticsearch.action.admin.indices.rollover.MaxSinglePrimarySizeCondition;
 import org.elasticsearch.action.admin.indices.rollover.MaxSizeCondition;
 import org.elasticsearch.common.unit.ByteSizeValue;
 import org.elasticsearch.common.unit.TimeValue;
@@ -36,12 +37,16 @@ public void testConstructorAndFieldAssignments() {
 
         // test assignment of conditions
         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};
+        MaxSizeCondition maxSizeCondition = new MaxSizeCondition(new ByteSizeValue(2000));
+        MaxSinglePrimarySizeCondition maxSinglePrimarySizeCondition = new MaxSinglePrimarySizeCondition(new ByteSizeValue(3000));
+        Condition<?>[] expectedConditions = new Condition<?>[]{
+            maxAgeCondition, maxDocsCondition, maxSizeCondition, maxSinglePrimarySizeCondition
+        };
         rolloverRequest.addMaxIndexAgeCondition(maxAgeCondition.value());
-        rolloverRequest.addMaxIndexSizeCondition(maxSizeCondition.value());
         rolloverRequest.addMaxIndexDocsCondition(maxDocsCondition.value());
+        rolloverRequest.addMaxIndexSizeCondition(maxSizeCondition.value());
+        rolloverRequest.addMaxSinglePrimarySizeCondition(maxSinglePrimarySizeCondition.value());
         List<Condition<?>> requestConditions = new ArrayList<>(rolloverRequest.getConditions().values());
         assertThat(requestConditions, containsInAnyOrder(expectedConditions));
     }

client/rest-high-level/src/test/java/org/elasticsearch/client/indices/rollover/RolloverResponseTests.java

@@ -11,6 +11,7 @@
 import org.elasticsearch.action.admin.indices.rollover.Condition;
 import org.elasticsearch.action.admin.indices.rollover.MaxAgeCondition;
 import org.elasticsearch.action.admin.indices.rollover.MaxDocsCondition;
+import org.elasticsearch.action.admin.indices.rollover.MaxSinglePrimarySizeCondition;
 import org.elasticsearch.action.admin.indices.rollover.MaxSizeCondition;
 import org.elasticsearch.common.unit.ByteSizeValue;
 import org.elasticsearch.common.unit.TimeValue;
@@ -32,8 +33,9 @@ public class RolloverResponseTests extends ESTestCase {
     private static final List<Supplier<Condition<?>>> conditionSuppliers = new ArrayList<>();
     static {
         conditionSuppliers.add(() -> new MaxAgeCondition(new TimeValue(randomNonNegativeLong())));
-        conditionSuppliers.add(() -> new MaxSizeCondition(new ByteSizeValue(randomNonNegativeLong())));
         conditionSuppliers.add(() -> new MaxDocsCondition(randomNonNegativeLong()));
+        conditionSuppliers.add(() -> new MaxSizeCondition(new ByteSizeValue(randomNonNegativeLong())));
+        conditionSuppliers.add(() -> new MaxSinglePrimarySizeCondition(new ByteSizeValue(randomNonNegativeLong())));
     }
 
     public void testFromXContent() throws IOException {

docs/java-rest/high-level/indices/rollover.asciidoc

@@ -24,6 +24,7 @@ The new index argument is optional, and can be set to null
 <2> Condition on the age of the index
 <3> Condition on the number of documents in the index
 <4> Condition on the size of the index
+<5> Condition on the size of the largest primary shard of the index
 
 ==== Optional arguments
 The following arguments can optionally be provided:

docs/reference/indices/rollover-index.asciidoc

@@ -18,7 +18,8 @@ POST /alias1/_rollover/my-index-000002
   "conditions": {
     "max_age":   "7d",
     "max_docs":  1000,
-    "max_size": "5gb"
+    "max_size": "5gb",
+    "max_single_primary_size": "2gb"
   }
 }
 ----
@@ -163,6 +164,16 @@ Replicas are not counted toward the maximum index size.
 
 TIP: To see the current index size, use the <<cat-indices, _cat indices>> API.
 The `pri.store.size` value shows the combined size of all primary shards.
+
+`max_single_primary_size`::
+(Optional, <<byte-units, byte units>>)
+Maximum primary shard size.
+This is the maximum size of the primary shards in the index. As with `max_size`,
+replicas are ignored.
+
+TIP: To see the current shard size, use the <<cat-shards, _cat shards>> API.
+The `store` value shows the size each shard, and `prirep` indicates whether a
+shard is a primary (`p`) or a replica (`r`).
 --
 
 include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=mappings]
@@ -192,7 +203,8 @@ POST /logs_write/_rollover <2>
   "conditions": {
     "max_age":   "7d",
     "max_docs":  1000,
-    "max_size":  "5gb"
+    "max_size":  "5gb",
+    "max_single_primary_size": "2gb"
   }
 }
 --------------------------------------------------
@@ -218,6 +230,7 @@ The API returns the following response:
     "[max_age: 7d]": false,
     "[max_docs: 1000]": true,
     "[max_size: 5gb]": false,
+    "[max_single_primary_size: 2gb]": false
   }
 }
 --------------------------------------------------
@@ -250,7 +263,8 @@ POST /my-data-stream/_rollover <2>
   "conditions" : {
     "max_age": "7d",
     "max_docs": 1000,
-    "max_size": "5gb"
+    "max_size": "5gb",
+    "max_single_primary_size": "2gb"
   }
 }
 --------------------------------------------------
@@ -284,6 +298,7 @@ The API returns the following response:
     "[max_age: 7d]": false,
     "[max_docs: 1000]": true,
     "[max_size: 5gb]": false,
+    "[max_single_primary_size: 2gb]": false
   }
 }
 --------------------------------------------------
@@ -329,7 +344,8 @@ POST /logs_write/_rollover
   "conditions" : {
     "max_age": "7d",
     "max_docs": 1000,
-    "max_size": "5gb"
+    "max_size": "5gb",
+    "max_single_primary_size": "2gb"
   },
   "settings": {
     "index.number_of_shards": 2
@@ -359,7 +375,8 @@ POST /my_alias/_rollover/my_new_index_name
   "conditions": {
     "max_age":   "7d",
     "max_docs":  1000,
-    "max_size": "5gb"
+    "max_size": "5gb",
+    "max_single_primary_size": "2gb"
   }
 }
 --------------------------------------------------
@@ -456,7 +473,8 @@ POST /logs_write/_rollover?dry_run
   "conditions" : {
     "max_age": "7d",
     "max_docs": 1000,
-    "max_size": "5gb"
+    "max_size": "5gb",
+    "max_single_primary_size": "2gb"
   }
 }
 --------------------------------------------------

rest-api-spec/src/main/resources/rest-api-spec/test/indices.rollover/35_max_single_primary_size_condition.yml

@@ -0,0 +1,58 @@
+---
+"Rollover with max_single_primary_size condition":
+  - skip:
+      version: " - 7.99.99"
+      reason: max_single_primary_size condition was introduced in 8.0.0
+
+  # create index with alias and replica
+  - do:
+      indices.create:
+        index: logs-1
+        wait_for_active_shards: 1
+        body:
+          aliases:
+            logs_search: {}
+
+  # index a document
+  - do:
+      index:
+        index: logs-1
+        id:    "1"
+        body:  { "foo": "hello world" }
+        refresh: true
+
+  # perform alias rollover with a large max_single_primary_size, no action.
+  - do:
+      indices.rollover:
+        alias: "logs_search"
+        wait_for_active_shards: 1
+        body:
+          conditions:
+            max_single_primary_size: 100mb
+
+  - match: { conditions: { "[max_single_primary_size: 100mb]": false } }
+  - match: { rolled_over: false }
+
+  # perform alias rollover with a small max_single_primary_size, got action.
+  - do:
+      indices.rollover:
+        alias: "logs_search"
+        wait_for_active_shards: 1
+        body:
+          conditions:
+            max_single_primary_size: 10b
+
+  - match: { conditions: { "[max_single_primary_size: 10b]": true } }
+  - match: { rolled_over: true }
+
+  # perform alias rollover on an empty index, no action.
+  - do:
+      indices.rollover:
+        alias: "logs_search"
+        wait_for_active_shards: 1
+        body:
+          conditions:
+            max_single_primary_size: 1b
+
+  - match: { conditions: { "[max_single_primary_size: 1b]": false } }
+  - match: { rolled_over: false }

server/src/internalClusterTest/java/org/elasticsearch/action/admin/indices/rollover/RolloverIT.java

@@ -434,6 +434,62 @@ public void testRolloverMaxSize() throws Exception {
         }
     }
 
+    public void testRolloverMaxSinglePrimarySize() throws Exception {
+        assertAcked(prepareCreate("test-1").addAlias(new Alias("test_alias")).get());
+        int numDocs = randomIntBetween(10, 20);
+        for (int i = 0; i < numDocs; i++) {
+            indexDoc("test-1", Integer.toString(i), "field", "foo-" + i);
+        }
+        flush("test-1");
+        refresh("test_alias");
+
+        // A large max_single_primary_size
+        {
+            final RolloverResponse response = client().admin().indices()
+                .prepareRolloverIndex("test_alias")
+                .addMaxSinglePrimarySizeCondition(new ByteSizeValue(randomIntBetween(100, 50 * 1024), ByteSizeUnit.MB))
+                .get();
+            assertThat(response.getOldIndex(), equalTo("test-1"));
+            assertThat(response.getNewIndex(), equalTo("test-000002"));
+            assertThat("No rollover with a large max_single_primary_size condition", response.isRolledOver(), equalTo(false));
+            final IndexMetadata oldIndex = client().admin().cluster().prepareState().get().getState().metadata().index("test-1");
+            assertThat(oldIndex.getRolloverInfos().size(), equalTo(0));
+        }
+
+        // A small max_single_primary_size
+        {
+            ByteSizeValue maxSinglePrimarySizeCondition = new ByteSizeValue(randomIntBetween(1, 20), ByteSizeUnit.BYTES);
+            long beforeTime = client().threadPool().absoluteTimeInMillis() - 1000L;
+            final RolloverResponse response = client().admin().indices()
+                .prepareRolloverIndex("test_alias")
+                .addMaxSinglePrimarySizeCondition(maxSinglePrimarySizeCondition)
+                .get();
+            assertThat(response.getOldIndex(), equalTo("test-1"));
+            assertThat(response.getNewIndex(), equalTo("test-000002"));
+            assertThat("Should rollover with a small max_single_primary_size condition", response.isRolledOver(), equalTo(true));
+            final IndexMetadata oldIndex = client().admin().cluster().prepareState().get().getState().metadata().index("test-1");
+            List<Condition<?>> metConditions = oldIndex.getRolloverInfos().get("test_alias").getMetConditions();
+            assertThat(metConditions.size(), equalTo(1));
+            assertThat(metConditions.get(0).toString(),
+                equalTo(new MaxSinglePrimarySizeCondition(maxSinglePrimarySizeCondition).toString()));
+            assertThat(oldIndex.getRolloverInfos().get("test_alias").getTime(),
+                is(both(greaterThanOrEqualTo(beforeTime)).and(lessThanOrEqualTo(client().threadPool().absoluteTimeInMillis() + 1000L))));
+        }
+
+        // An empty index
+        {
+            final RolloverResponse response = client().admin().indices()
+                .prepareRolloverIndex("test_alias")
+                .addMaxSinglePrimarySizeCondition(new ByteSizeValue(randomNonNegativeLong(), ByteSizeUnit.BYTES))
+                .get();
+            assertThat(response.getOldIndex(), equalTo("test-000002"));
+            assertThat(response.getNewIndex(), equalTo("test-000003"));
+            assertThat("No rollover with an empty index", response.isRolledOver(), equalTo(false));
+            final IndexMetadata oldIndex = client().admin().cluster().prepareState().get().getState().metadata().index("test-000002");
+            assertThat(oldIndex.getRolloverInfos().size(), equalTo(0));
+        }
+    }
+
     public void testRejectIfAliasFoundInTemplate() throws Exception {
         client().admin().indices().preparePutTemplate("logs")
             .setPatterns(Collections.singletonList("logs-*")).addAlias(new Alias("logs-write")).get();

server/src/main/java/org/elasticsearch/action/admin/indices/rollover/Condition.java

@@ -8,6 +8,7 @@
 
 package org.elasticsearch.action.admin.indices.rollover;
 
+import org.elasticsearch.Version;
 import org.elasticsearch.common.io.stream.NamedWriteable;
 import org.elasticsearch.common.unit.ByteSizeValue;
 import org.elasticsearch.common.xcontent.ToXContentFragment;
@@ -26,6 +27,14 @@ protected Condition(String name) {
         this.name = name;
     }
 
+    /**
+     * Checks if this condition is available in a specific version.
+     * This makes sure BWC when introducing a new condition which is not recognized by older versions.
+     */
+    boolean includedInVersion(Version version) {
+        return true;
+    }
+
     public abstract Result evaluate(Stats stats);
 
     @Override
@@ -66,11 +75,13 @@ public static class Stats {
         public final long numDocs;
         public final long indexCreated;
         public final ByteSizeValue indexSize;
+        public final ByteSizeValue maxSinglePrimarySize;
 
-        public Stats(long numDocs, long indexCreated, ByteSizeValue indexSize) {
+        public Stats(long numDocs, long indexCreated, ByteSizeValue indexSize, ByteSizeValue maxSinglePrimarySize) {
             this.numDocs = numDocs;
             this.indexCreated = indexCreated;
             this.indexSize = indexSize;
+            this.maxSinglePrimarySize = maxSinglePrimarySize;
         }
     }