no-mistakes(review): Reject generation-conflicting backing index name; use value equality in mapper

Author: Madhan

server/src/main/java/org/opensearch/action/admin/indices/datastream/ModifyDataStreamsAction.java

@@ -313,6 +313,26 @@ private static void addBackingIndex(
         CheckedFunction<IndexMetadata, MapperService, IOException> mapperServiceFactory
     ) throws IOException {
         final DataStream dataStream = validateDataStream(builder, dataStreamName);
+
+        // an index whose name matches this data stream's backing-index naming pattern with a generation counter greater than
+        // the stream's current generation cannot be added: it would collide with a future backing index produced by a rollover
+        // and make the metadata invalid (Metadata.Builder.validateDataStreams would later throw IllegalStateException -> HTTP 500)
+        final String backingIndexPrefix = DataStream.BACKING_INDEX_PREFIX + dataStreamName + "-";
+        if (indexName.startsWith(backingIndexPrefix)
+            && Metadata.NUMBER_PATTERN.matcher(indexName.substring(backingIndexPrefix.length())).matches()
+            && IndexMetadata.parseIndexNameCounter(indexName) > dataStream.getGeneration()) {
+            throw new IllegalArgumentException(
+                "cannot add index ["
+                    + indexName
+                    + "] to data stream ["
+                    + dataStreamName
+                    + "] because its name conflicts with a future backing index of the data stream "
+                    + "(current generation ["
+                    + dataStream.getGeneration()
+                    + "])"
+            );
+        }
+
         final IndexMetadata index = validateIndex(builder, indexName);
 
         // an index that is already a backing index of this data stream cannot be added again

server/src/main/java/org/opensearch/index/mapper/DataStreamFieldMapper.java

@@ -21,6 +21,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 
 /**
  * Field mapper for a datastream field
@@ -51,7 +52,7 @@ public static final class Builder extends MetadataFieldMapper.Builder {
         // The _data_stream_timestamp meta field can be enabled on a mapping update (e.g. when an existing index is
         // adapted into a data stream backing index) but, once enabled, it cannot be disabled again.
         final Parameter<Boolean> enabledParam = Parameter.boolParam("enabled", false, mapper -> toType(mapper).enabled, Defaults.ENABLED)
-            .setMergeValidator((previous, current) -> previous == current || (previous == false && current));
+            .setMergeValidator((previous, current) -> Objects.equals(previous, current) || (previous == false && current));
 
         final Parameter<TimestampField> timestampFieldParam = new Parameter<>(
             "timestamp_field",

server/src/test/java/org/opensearch/action/admin/indices/datastream/ModifyDataStreamsActionTests.java

@@ -248,6 +248,20 @@ public void testAddIndexBelongingToAnotherDataStreamFails() {
         assertThat(e.getMessage(), containsString("is already a backing index of data stream [other-data-stream]"));
     }
 
+    public void testAddIndexWithGenerationConflictNameFails() {
+        ClusterState cs = getClusterStateWithDataStreams(List.of(new Tuple<>(DATA_STREAM, 2)), List.of());
+        // an index whose name matches the backing-index naming pattern but with a counter greater than the stream's
+        // current generation would collide with a future rollover-created backing index; the request must be rejected with a
+        // 400 (IllegalArgumentException) up front rather than failing the cluster state build with a 500 (IllegalStateException)
+        String conflictingName = DataStream.getDefaultBackingIndexName(DATA_STREAM, 99);
+
+        IllegalArgumentException e = expectThrows(
+            IllegalArgumentException.class,
+            () -> modify(cs, List.of(DataStreamAction.addBackingIndex(DATA_STREAM, conflictingName)))
+        );
+        assertThat(e.getMessage(), containsString("conflicts with a future backing index"));
+    }
+
     public void testMultipleActionsAppliedAtomically() {
         ClusterState cs = getClusterStateWithDataStreams(List.of(new Tuple<>(DATA_STREAM, 3)), List.of("standalone-index"));
         String indexToRemove = DataStream.getDefaultBackingIndexName(DATA_STREAM, 1);