Refactor DataStreamLifecycle creation code (#138780)

We currently have several methods for creating `DataStreamLifecycle` and corresponding `DataStreamLifecycle.Template` objects. These methods need to specify all fields of those objects, which results in a lot of changed lines when adding a new field.

To avoid those extra changed lines, we convert most usages to using builders, which don't require passing `null` values to have default values for fields.

Author: nielsbauman

modules/data-streams/src/test/java/org/elasticsearch/datastreams/MetadataIndexTemplateServiceTests.java

@@ -151,12 +151,12 @@ public void testLifecycleComposition() {
         // One lifecycle results in this lifecycle as the final
         {
             ResettableValue<List<DataStreamLifecycle.DownsamplingRound>> downsamplingRounds = randomDownsampling();
-            DataStreamLifecycle.Template lifecycle = DataStreamLifecycle.createDataLifecycleTemplate(
-                true,
-                randomRetention(),
-                downsamplingRounds,
-                randomResettable(() -> randomSamplingMethod(downsamplingRounds.get()))
-            );
+            DataStreamLifecycle.Template lifecycle = DataStreamLifecycle.dataLifecycleBuilder()
+                .enabled(true)
+                .dataRetention(randomRetention())
+                .downsamplingRounds(downsamplingRounds)
+                .downsamplingMethod(randomResettable(() -> randomSamplingMethod(downsamplingRounds.get())))
+                .buildTemplate();
             List<DataStreamLifecycle.Template> lifecycles = List.of(lifecycle);
             DataStreamLifecycle result = composeDataLifecycles(lifecycles).build();
             // Defaults to true
@@ -169,12 +169,12 @@ public void testLifecycleComposition() {
         // Enabled is always true unless it's explicitly set to false
         {
             List<DataStreamLifecycle.DownsamplingRound> downsamplingRounds = randomRounds();
-            DataStreamLifecycle.Template lifecycle = DataStreamLifecycle.createDataLifecycleTemplate(
-                false,
-                randomPositiveTimeValue(),
-                downsamplingRounds,
-                randomSamplingMethod(downsamplingRounds)
-            );
+            DataStreamLifecycle.Template lifecycle = DataStreamLifecycle.dataLifecycleBuilder()
+                .enabled(false)
+                .dataRetention(randomPositiveTimeValue())
+                .downsamplingRounds(downsamplingRounds)
+                .downsamplingMethod(randomSamplingMethod(downsamplingRounds))
+                .buildTemplate();
             List<DataStreamLifecycle.Template> lifecycles = List.of(lifecycle, DataStreamLifecycle.Template.DATA_DEFAULT);
             DataStreamLifecycle result = composeDataLifecycles(lifecycles).build();
             assertThat(result.enabled(), equalTo(true));
@@ -185,20 +185,22 @@ public void testLifecycleComposition() {
         // If both lifecycles have all properties, then the latest one overwrites all the others
         {
             DownsampleConfig.SamplingMethod downsamplingMethod1 = randomFrom(DownsampleConfig.SamplingMethod.LAST_VALUE);
-            DataStreamLifecycle.Template lifecycle1 = DataStreamLifecycle.createDataLifecycleTemplate(
-                false,
-                randomPositiveTimeValue(),
-                randomRounds(),
-                downsamplingMethod1
-            );
-            DataStreamLifecycle.Template lifecycle2 = DataStreamLifecycle.createDataLifecycleTemplate(
-                true,
-                randomPositiveTimeValue(),
-                randomRounds(),
-                downsamplingMethod1 == DownsampleConfig.SamplingMethod.LAST_VALUE
-                    ? DownsampleConfig.SamplingMethod.AGGREGATE
-                    : DownsampleConfig.SamplingMethod.LAST_VALUE
-            );
+            DataStreamLifecycle.Template lifecycle1 = DataStreamLifecycle.dataLifecycleBuilder()
+                .enabled(false)
+                .dataRetention(randomPositiveTimeValue())
+                .downsamplingRounds(randomRounds())
+                .downsamplingMethod(downsamplingMethod1)
+                .buildTemplate();
+            DataStreamLifecycle.Template lifecycle2 = DataStreamLifecycle.dataLifecycleBuilder()
+                .enabled(true)
+                .dataRetention(randomPositiveTimeValue())
+                .downsamplingRounds(randomRounds())
+                .downsamplingMethod(
+                    downsamplingMethod1 == DownsampleConfig.SamplingMethod.LAST_VALUE
+                        ? DownsampleConfig.SamplingMethod.AGGREGATE
+                        : DownsampleConfig.SamplingMethod.LAST_VALUE
+                )
+                .buildTemplate();
             List<DataStreamLifecycle.Template> lifecycles = List.of(lifecycle1, lifecycle2);
             DataStreamLifecycle result = composeDataLifecycles(lifecycles).build();
             assertThat(result.enabled(), equalTo(lifecycle2.enabled()));

modules/data-streams/src/test/java/org/elasticsearch/datastreams/action/GetDataStreamsResponseTests.java

@@ -154,7 +154,7 @@ public void testResponseIlmAndDataStreamLifecycleRepresentation() throws Excepti
                 .setGeneration(3)
                 .setAllowCustomRouting(true)
                 .setIndexMode(IndexMode.STANDARD)
-                .setLifecycle(DataStreamLifecycle.createDataLifecycle(false, null, null, null))
+                .setLifecycle(DataStreamLifecycle.dataLifecycleBuilder().enabled(false).build())
                 .setDataStreamOptions(DataStreamOptions.FAILURE_STORE_ENABLED)
                 .setFailureIndices(DataStream.DataStreamIndices.failureIndicesBuilder(failureStores).build())
                 .build();

modules/data-streams/src/test/java/org/elasticsearch/datastreams/lifecycle/DataStreamLifecycleFixtures.java

@@ -148,12 +148,12 @@ static DataStreamLifecycle.Template randomDataLifecycleTemplate() {
         ResettableValue<List<DataStreamLifecycle.DownsamplingRound>> downsampling = randomResettable(
             DataStreamLifecycleFixtures::randomDownsamplingRounds
         );
-        return DataStreamLifecycle.createDataLifecycleTemplate(
-            frequently(),
-            randomResettable(ESTestCase::randomTimeValue),
-            downsampling,
-            randomResettable(() -> randomSamplingMethod(downsampling.get()))
-        );
+        return DataStreamLifecycle.dataLifecycleBuilder()
+            .enabled(frequently())
+            .dataRetention(randomResettable(ESTestCase::randomTimeValue))
+            .downsamplingRounds(downsampling)
+            .downsamplingMethod(randomResettable(() -> randomSamplingMethod(downsampling.get())))
+            .buildTemplate();
     }
 
     public static <T> ResettableValue<T> randomResettable(Supplier<T> supplier) {

server/src/main/java/org/elasticsearch/cluster/metadata/DataStreamLifecycle.java

@@ -36,13 +36,10 @@
 import org.elasticsearch.xcontent.XContentParser;
 
 import java.io.IOException;
-import java.util.Arrays;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Objects;
-import java.util.function.Function;
-import java.util.stream.Collectors;
 
 import static org.elasticsearch.xcontent.ConstructingObjectParser.constructorArg;
 
@@ -97,8 +94,8 @@ public static boolean isDataStreamsLifecycleOnlyMode(final Settings settings) {
         Setting.Property.NodeScope
     );
 
-    public static final DataStreamLifecycle DEFAULT_DATA_LIFECYCLE = DataStreamLifecycle.createDataLifecycle(null, null, null, null);
-    public static final DataStreamLifecycle DEFAULT_FAILURE_LIFECYCLE = DataStreamLifecycle.createFailuresLifecycle(null, null);
+    public static final DataStreamLifecycle DEFAULT_DATA_LIFECYCLE = dataLifecycleBuilder().build();
+    public static final DataStreamLifecycle DEFAULT_FAILURE_LIFECYCLE = failuresLifecycleBuilder().build();
 
     public static final String DATA_STREAM_LIFECYCLE_ORIGIN = "data_stream_lifecycle";
 
@@ -163,9 +160,8 @@ public static boolean isDataStreamsLifecycleOnlyMode(final Settings settings) {
     private final DownsampleConfig.SamplingMethod downsamplingMethod;
 
     /**
-     * This constructor is visible for testing, please use
-     * {@link DataStreamLifecycle#createDataLifecycle(Boolean, TimeValue, List, DownsampleConfig.SamplingMethod)} or
-     * {@link DataStreamLifecycle#createFailuresLifecycle(Boolean, TimeValue)}.
+     * This constructor is visible for testing, please use {@link DataStreamLifecycle#dataLifecycleBuilder()} or
+     * {@link DataStreamLifecycle#failuresLifecycleBuilder()}.
      */
     DataStreamLifecycle(
         LifecycleType lifecycleType,
@@ -188,27 +184,6 @@ public static boolean isDataStreamsLifecycleOnlyMode(final Settings settings) {
         this.downsamplingMethod = downsamplingMethod;
     }
 
-    /**
-     * This factory method creates a lifecycle applicable for the data index component of a data stream. This
-     * means it supports all configuration applicable for backing indices.
-     */
-    public static DataStreamLifecycle createDataLifecycle(
-        @Nullable Boolean enabled,
-        @Nullable TimeValue dataRetention,
-        @Nullable List<DownsamplingRound> downsamplingRounds,
-        @Nullable DownsampleConfig.SamplingMethod downsamplingMethod
-    ) {
-        return new DataStreamLifecycle(LifecycleType.DATA, enabled, dataRetention, downsamplingRounds, downsamplingMethod);
-    }
-
-    /**
-     * This factory method creates a lifecycle applicable for the failures index component of a data stream. This
-     * means it supports only enabling and retention.
-     */
-    public static DataStreamLifecycle createFailuresLifecycle(@Nullable Boolean enabled, @Nullable TimeValue dataRetention) {
-        return new DataStreamLifecycle(LifecycleType.FAILURES, enabled, dataRetention, null, null);
-    }
-
     /**
      * Returns true, if this data stream lifecycle configuration is enabled, false otherwise
      */
@@ -671,52 +646,6 @@ public String toString() {
         }
     }
 
-    /**
-     * This factory method creates a lifecycle template applicable for the data index component of a data stream. This
-     * means it supports all configuration applicable for backing indices.
-     */
-    public static Template createDataLifecycleTemplate(
-        boolean enabled,
-        TimeValue dataRetention,
-        List<DataStreamLifecycle.DownsamplingRound> downsamplingRounds,
-        DownsampleConfig.SamplingMethod downsamplingMethod
-    ) {
-        return new Template(
-            LifecycleType.DATA,
-            enabled,
-            ResettableValue.create(dataRetention),
-            ResettableValue.create(downsamplingRounds),
-            ResettableValue.create(downsamplingMethod)
-        );
-    }
-
-    /**
-     * This factory method creates a lifecycle template applicable for the data index component of a data stream. This
-     * means it supports all configuration applicable for backing indices.
-     */
-    public static Template createDataLifecycleTemplate(
-        boolean enabled,
-        ResettableValue<TimeValue> dataRetention,
-        ResettableValue<List<DataStreamLifecycle.DownsamplingRound>> downsamplingRounds,
-        ResettableValue<DownsampleConfig.SamplingMethod> downsamplingMethod
-    ) {
-        return new Template(LifecycleType.DATA, enabled, dataRetention, downsamplingRounds, downsamplingMethod);
-    }
-
-    /**
-     * This factory method creates a lifecycle template applicable for the failures index component of a data stream. This
-     * means it supports only setting the enabled and the retention.
-     */
-    public static Template createFailuresLifecycleTemplate(boolean enabled, TimeValue dataRetention) {
-        return new Template(
-            LifecycleType.FAILURES,
-            enabled,
-            ResettableValue.create(dataRetention),
-            ResettableValue.undefined(),
-            ResettableValue.undefined()
-        );
-    }
-
     /**
      * Represents the template configuration of a lifecycle. It supports explicitly resettable values
      * to allow value reset during template composition.
@@ -729,22 +658,6 @@ public record Template(
         ResettableValue<DownsampleConfig.SamplingMethod> downsamplingMethod
     ) implements ToXContentObject, Writeable {
 
-        Template(
-            LifecycleType lifecycleType,
-            boolean enabled,
-            TimeValue dataRetention,
-            List<DataStreamLifecycle.DownsamplingRound> downsamplingRounds,
-            DownsampleConfig.SamplingMethod downsamplingMethod
-        ) {
-            this(
-                lifecycleType,
-                enabled,
-                ResettableValue.create(dataRetention),
-                ResettableValue.create(downsamplingRounds),
-                ResettableValue.create(downsamplingMethod)
-            );
-        }
-
         public Template {
             if (lifecycleType == LifecycleType.FAILURES && downsamplingRounds.get() != null) {
                 throw new IllegalArgumentException(DOWNSAMPLING_NOT_SUPPORTED_ERROR_MESSAGE);
@@ -756,13 +669,7 @@ public record Template(
             }
         }
 
-        public static final DataStreamLifecycle.Template DATA_DEFAULT = new DataStreamLifecycle.Template(
-            LifecycleType.DATA,
-            true,
-            ResettableValue.undefined(),
-            ResettableValue.undefined(),
-            ResettableValue.undefined()
-        );
+        public static final DataStreamLifecycle.Template DATA_DEFAULT = dataLifecycleBuilder().enabled(true).buildTemplate();
 
         @SuppressWarnings("unchecked")
         public static final ConstructingObjectParser<DataStreamLifecycle.Template, LifecycleType> PARSER = new ConstructingObjectParser<>(
@@ -974,12 +881,9 @@ public static Builder failuresLifecycleBuilder() {
     public static class Builder {
         private final LifecycleType lifecycleType;
         private boolean enabled = true;
-        @Nullable
-        private TimeValue dataRetention = null;
-        @Nullable
-        private List<DownsamplingRound> downsamplingRounds = null;
-        @Nullable
-        private DownsampleConfig.SamplingMethod downsamplingMethod = null;
+        private ResettableValue<TimeValue> dataRetention = ResettableValue.undefined();
+        private ResettableValue<List<DownsamplingRound>> downsamplingRounds = ResettableValue.undefined();
+        private ResettableValue<DownsampleConfig.SamplingMethod> downsamplingMethod = ResettableValue.undefined();
 
         private Builder(LifecycleType lifecycleType) {
             this.lifecycleType = lifecycleType;
@@ -988,17 +892,17 @@ private Builder(LifecycleType lifecycleType) {
         private Builder(DataStreamLifecycle.Template template) {
             lifecycleType = template.lifecycleType();
             enabled = template.enabled();
-            dataRetention = template.dataRetention().get();
-            downsamplingRounds = template.downsamplingRounds().get();
-            downsamplingMethod = template.downsamplingMethod().get();
+            dataRetention = template.dataRetention();
+            downsamplingRounds = template.downsamplingRounds();
+            downsamplingMethod = template.downsamplingMethod();
         }
 
         private Builder(DataStreamLifecycle lifecycle) {
             lifecycleType = lifecycle.lifecycleType;
             enabled = lifecycle.enabled();
-            dataRetention = lifecycle.dataRetention();
-            downsamplingRounds = lifecycle.downsamplingRounds();
-            downsamplingMethod = lifecycle.downsamplingMethod();
+            dataRetention = ResettableValue.create(lifecycle.dataRetention());
+            downsamplingRounds = ResettableValue.create(lifecycle.downsamplingRounds());
+            downsamplingMethod = ResettableValue.create(lifecycle.downsamplingMethod());
         }
 
         public Builder composeTemplate(DataStreamLifecycle.Template template) {
@@ -1017,42 +921,42 @@ public Builder enabled(boolean enabled) {
 
         public Builder dataRetention(ResettableValue<TimeValue> dataRetention) {
             if (dataRetention.isDefined()) {
-                this.dataRetention = dataRetention.get();
+                this.dataRetention = dataRetention;
             }
             return this;
         }
 
         public Builder dataRetention(@Nullable TimeValue dataRetention) {
-            this.dataRetention = dataRetention;
+            this.dataRetention = ResettableValue.create(dataRetention);
             return this;
         }
 
         public Builder downsamplingRounds(ResettableValue<List<DownsamplingRound>> downsampling) {
             if (downsampling.isDefined()) {
-                this.downsamplingRounds = downsampling.get();
+                this.downsamplingRounds = downsampling;
             }
             return this;
         }
 
         public Builder downsamplingRounds(@Nullable List<DownsamplingRound> downsampling) {
-            this.downsamplingRounds = downsampling;
+            this.downsamplingRounds = ResettableValue.create(downsampling);
             return this;
         }
 
         public Builder downsamplingMethod(ResettableValue<DownsampleConfig.SamplingMethod> downsamplingMethod) {
             if (downsamplingMethod.isDefined()) {
-                this.downsamplingMethod = downsamplingMethod.get();
+                this.downsamplingMethod = downsamplingMethod;
             }
             return this;
         }
 
         public Builder downsamplingMethod(@Nullable DownsampleConfig.SamplingMethod downsamplingMethod) {
-            this.downsamplingMethod = downsamplingMethod;
+            this.downsamplingMethod = ResettableValue.create(downsamplingMethod);
             return this;
         }
 
         public DataStreamLifecycle build() {
-            return new DataStreamLifecycle(lifecycleType, enabled, dataRetention, downsamplingRounds, downsamplingMethod);
+            return new DataStreamLifecycle(lifecycleType, enabled, dataRetention.get(), downsamplingRounds.get(), downsamplingMethod.get());
         }
 
         public Template buildTemplate() {
@@ -1065,26 +969,22 @@ public Template buildTemplate() {
      * Visible for testing
      */
     enum LifecycleType implements Writeable {
-        DATA("data", (byte) 0),
-        FAILURES("failures", (byte) 1);
+        DATA("data"),
+        FAILURES("failures");
 
         private final String label;
-        private final byte id;
-        private static final Map<Byte, LifecycleType> REGISTRY = Arrays.stream(LifecycleType.values())
-            .collect(Collectors.toMap(l -> l.id, Function.identity()));
 
-        LifecycleType(String label, byte id) {
+        LifecycleType(String label) {
             this.label = label;
-            this.id = id;
         }
 
         @Override
         public void writeTo(StreamOutput out) throws IOException {
-            out.write(id);
+            out.writeEnum(this);
         }
 
         public static LifecycleType read(StreamInput in) throws IOException {
-            return REGISTRY.get(in.readByte());
+            return in.readEnum(LifecycleType.class);
         }
     }
 }

server/src/test/java/org/elasticsearch/action/datastreams/GetDataStreamActionTests.java

@@ -107,7 +107,7 @@ private static GetDataStreamAction.Response.DataStreamInfo newDataStreamInfo(boo
 
     private static DataStream newDataStreamInstance(boolean isSystem, TimeValue retention) {
         List<Index> indices = List.of(new Index(randomAlphaOfLength(10), randomAlphaOfLength(10)));
-        DataStreamLifecycle lifecycle = DataStreamLifecycle.createDataLifecycle(true, retention, null, null);
+        DataStreamLifecycle lifecycle = DataStreamLifecycle.dataLifecycleBuilder().enabled(true).dataRetention(retention).build();
         Settings settings = randomSettings();
         CompressedXContent mappings = randomMappings();
         return DataStream.builder(randomAlphaOfLength(50), indices)