Change HealthMetadata to ClusterState.Custom (#88736)

Metadata.Custom persists across a full cluster restart which is unnecessary for HealthMetadata since the master will always reset the health metadata upon election. For this reason ClusterState.Custom is more suitable.

server/src/internalClusterTest/java/org/elasticsearch/health/HealthMetadataServiceIT.java

@@ -50,7 +50,7 @@ public class HealthMetadataServiceIT extends ESIntegTestCase {
 
             String electedMaster = internalCluster.getMasterName();
             {
-                HealthMetadata.Disk diskMetadata = HealthMetadata.getHealthCustomMetadata(internalCluster.clusterService().state())
+                HealthMetadata.Disk diskMetadata = HealthMetadata.getFromClusterState(internalCluster.clusterService().state())
                     .getDiskMetadata();
                 assertThat(diskMetadata.describeHighWatermark(), equalTo(watermarkByNode.get(electedMaster)));
             }
@@ -60,7 +60,7 @@ public class HealthMetadataServiceIT extends ESIntegTestCase {
             ensureStableCluster(numberOfNodes - 1);
             electedMaster = internalCluster.getMasterName();
             {
-                HealthMetadata.Disk diskMetadata = HealthMetadata.getHealthCustomMetadata(internalCluster.clusterService().state())
+                HealthMetadata.Disk diskMetadata = HealthMetadata.getFromClusterState(internalCluster.clusterService().state())
                     .getDiskMetadata();
                 assertThat(diskMetadata.describeHighWatermark(), equalTo(watermarkByNode.get(electedMaster)));
             }
@@ -89,7 +89,7 @@ public class HealthMetadataServiceIT extends ESIntegTestCase {
 
             ensureStableCluster(numberOfNodes);
             {
-                HealthMetadata.Disk diskMetadata = HealthMetadata.getHealthCustomMetadata(internalCluster.clusterService().state())
+                HealthMetadata.Disk diskMetadata = HealthMetadata.getFromClusterState(internalCluster.clusterService().state())
                     .getDiskMetadata();
                 assertThat(diskMetadata.describeHighWatermark(), equalTo(initialWatermark));
             }
@@ -112,7 +112,7 @@ public class HealthMetadataServiceIT extends ESIntegTestCase {
                 )
                 .actionGet();
             assertBusy(() -> {
-                HealthMetadata.Disk diskMetadata = HealthMetadata.getHealthCustomMetadata(internalCluster.clusterService().state())
+                HealthMetadata.Disk diskMetadata = HealthMetadata.getFromClusterState(internalCluster.clusterService().state())
                     .getDiskMetadata();
                 assertThat(diskMetadata.describeHighWatermark(), equalTo(updatedHighWatermark));
                 assertThat(diskMetadata.describeFloodStageWatermark(), equalTo(updatedFloodStageWatermark));

server/src/main/java/org/elasticsearch/health/metadata/HealthMetadata.java

@@ -12,41 +12,27 @@ import org.elasticsearch.Version;
 import org.elasticsearch.cluster.AbstractNamedDiffable;
 import org.elasticsearch.cluster.ClusterState;
 import org.elasticsearch.cluster.NamedDiff;
-import org.elasticsearch.cluster.metadata.Metadata;
 import org.elasticsearch.common.io.stream.StreamInput;
 import org.elasticsearch.common.io.stream.StreamOutput;
 import org.elasticsearch.common.io.stream.Writeable;
 import org.elasticsearch.common.unit.ByteSizeValue;
 import org.elasticsearch.common.unit.RelativeByteSizeValue;
-import org.elasticsearch.xcontent.ConstructingObjectParser;
 import org.elasticsearch.xcontent.ParseField;
 import org.elasticsearch.xcontent.ToXContentFragment;
 import org.elasticsearch.xcontent.XContentBuilder;
-import org.elasticsearch.xcontent.XContentParser;
 
 import java.io.IOException;
-import java.util.EnumSet;
 import java.util.Objects;
 
 /**
  * A cluster state entry that contains a list of all the thresholds used to determine if a node is healthy.
  */
-public final class HealthMetadata extends AbstractNamedDiffable<Metadata.Custom> implements Metadata.Custom {
+public final class HealthMetadata extends AbstractNamedDiffable<ClusterState.Custom> implements ClusterState.Custom {
 
     public static final String TYPE = "health";
 
-    public static final ConstructingObjectParser<HealthMetadata, Void> PARSER = new ConstructingObjectParser<>(
-        TYPE,
-        true,
-        args -> new HealthMetadata((Disk) args[0])
-    );
-
     private static final ParseField DISK_METADATA = new ParseField(Disk.TYPE);
 
-    static {
-        PARSER.declareObject(ConstructingObjectParser.constructorArg(), (p, c) -> Disk.fromXContent(p), DISK_METADATA);
-    }
-
     private final Disk diskMetadata;
 
     public HealthMetadata(Disk diskMetadata) {
@@ -72,8 +58,8 @@ public final class HealthMetadata extends AbstractNamedDiffable<Metadata.Custom>
         diskMetadata.writeTo(out);
     }
 
-    public static NamedDiff<Metadata.Custom> readDiffFrom(StreamInput in) throws IOException {
-        return readDiffFrom(Metadata.Custom.class, TYPE, in);
+    public static NamedDiff<ClusterState.Custom> readDiffFrom(StreamInput in) throws IOException {
+        return readDiffFrom(ClusterState.Custom.class, TYPE, in);
     }
 
     @Override
@@ -84,12 +70,8 @@ public final class HealthMetadata extends AbstractNamedDiffable<Metadata.Custom>
         return builder;
     }
 
-    public static HealthMetadata fromXContent(XContentParser parser) throws IOException {
-        return PARSER.parse(parser, null);
-    }
-
-    public static HealthMetadata getHealthCustomMetadata(ClusterState clusterState) {
-        return clusterState.getMetadata().custom(HealthMetadata.TYPE);
+    public static HealthMetadata getFromClusterState(ClusterState clusterState) {
+        return clusterState.custom(HealthMetadata.TYPE);
     }
 
     @Override
@@ -97,11 +79,6 @@ public final class HealthMetadata extends AbstractNamedDiffable<Metadata.Custom>
         return true;
     }
 
-    @Override
-    public EnumSet<Metadata.XContentContext> context() {
-        return Metadata.API_AND_GATEWAY;
-    }
-
     public Disk getDiskMetadata() {
         return diskMetadata;
     }
@@ -137,24 +114,6 @@ public final class HealthMetadata extends AbstractNamedDiffable<Metadata.Custom>
         private static final ParseField FROZEN_FLOOD_STAGE_WATERMARK_FIELD = new ParseField("frozen_flood_stage_watermark");
         private static final ParseField FROZEN_FLOOD_STAGE_MAX_HEADROOM_FIELD = new ParseField("frozen_flood_stage_max_headroom");
 
-        public static final ConstructingObjectParser<Disk, Void> PARSER = new ConstructingObjectParser<>(
-            TYPE,
-            true,
-            (args) -> new Disk(
-                RelativeByteSizeValue.parseRelativeByteSizeValue((String) args[0], HIGH_WATERMARK_FIELD.getPreferredName()),
-                RelativeByteSizeValue.parseRelativeByteSizeValue((String) args[1], FLOOD_STAGE_WATERMARK_FIELD.getPreferredName()),
-                RelativeByteSizeValue.parseRelativeByteSizeValue((String) args[2], FROZEN_FLOOD_STAGE_WATERMARK_FIELD.getPreferredName()),
-                ByteSizeValue.parseBytesSizeValue((String) args[3], FROZEN_FLOOD_STAGE_MAX_HEADROOM_FIELD.getPreferredName())
-            )
-        );
-
-        static {
-            PARSER.declareString(ConstructingObjectParser.constructorArg(), HIGH_WATERMARK_FIELD);
-            PARSER.declareString(ConstructingObjectParser.constructorArg(), FLOOD_STAGE_WATERMARK_FIELD);
-            PARSER.declareString(ConstructingObjectParser.constructorArg(), FROZEN_FLOOD_STAGE_WATERMARK_FIELD);
-            PARSER.declareString(ConstructingObjectParser.constructorArg(), FROZEN_FLOOD_STAGE_MAX_HEADROOM_FIELD);
-        }
-
         Disk(StreamInput in) throws IOException {
             this(
                 RelativeByteSizeValue.parseRelativeByteSizeValue(in.readString(), HIGH_WATERMARK_FIELD.getPreferredName()),
@@ -164,10 +123,6 @@ public final class HealthMetadata extends AbstractNamedDiffable<Metadata.Custom>
             );
         }
 
-        static Disk fromXContent(XContentParser parser) throws IOException {
-            return PARSER.parse(parser, null);
-        }
-
         @Override
         public void writeTo(StreamOutput out) throws IOException {
             out.writeString(describeHighWatermark());
@@ -255,39 +210,39 @@ public final class HealthMetadata extends AbstractNamedDiffable<Metadata.Custom>
 
             private Builder() {}
 
-            Disk.Builder highWatermark(RelativeByteSizeValue highWatermark) {
+            Builder highWatermark(RelativeByteSizeValue highWatermark) {
                 this.highWatermark = highWatermark;
                 return this;
             }
 
-            Disk.Builder highWatermark(String highWatermark, String setting) {
+            Builder highWatermark(String highWatermark, String setting) {
                 return highWatermark(RelativeByteSizeValue.parseRelativeByteSizeValue(highWatermark, setting));
             }
 
-            Disk.Builder floodStageWatermark(RelativeByteSizeValue floodStageWatermark) {
+            Builder floodStageWatermark(RelativeByteSizeValue floodStageWatermark) {
                 this.floodStageWatermark = floodStageWatermark;
                 return this;
             }
 
-            public Disk.Builder floodStageWatermark(String floodStageWatermark, String setting) {
+            public Builder floodStageWatermark(String floodStageWatermark, String setting) {
                 return floodStageWatermark(RelativeByteSizeValue.parseRelativeByteSizeValue(floodStageWatermark, setting));
             }
 
-            Disk.Builder frozenFloodStageWatermark(RelativeByteSizeValue frozenFloodStageWatermark) {
+            Builder frozenFloodStageWatermark(RelativeByteSizeValue frozenFloodStageWatermark) {
                 this.frozenFloodStageWatermark = frozenFloodStageWatermark;
                 return this;
             }
 
-            Disk.Builder frozenFloodStageWatermark(String frozenFloodStageWatermark, String setting) {
+            Builder frozenFloodStageWatermark(String frozenFloodStageWatermark, String setting) {
                 return frozenFloodStageWatermark(RelativeByteSizeValue.parseRelativeByteSizeValue(frozenFloodStageWatermark, setting));
             }
 
-            Disk.Builder frozenFloodStageMaxHeadroom(ByteSizeValue frozenFloodStageMaxHeadroom) {
+            Builder frozenFloodStageMaxHeadroom(ByteSizeValue frozenFloodStageMaxHeadroom) {
                 this.frozenFloodStageMaxHeadroom = frozenFloodStageMaxHeadroom;
                 return this;
             }
 
-            Disk.Builder frozenFloodStageMaxHeadroom(String frozenFloodStageMaxHeadroom, String setting) {
+            Builder frozenFloodStageMaxHeadroom(String frozenFloodStageMaxHeadroom, String setting) {
                 return frozenFloodStageMaxHeadroom(ByteSizeValue.parseBytesSizeValue(frozenFloodStageMaxHeadroom, setting));
             }
 

server/src/main/java/org/elasticsearch/health/metadata/HealthMetadataService.java

@@ -18,15 +18,12 @@ import org.elasticsearch.cluster.ClusterStateTaskConfig;
 import org.elasticsearch.cluster.ClusterStateTaskExecutor;
 import org.elasticsearch.cluster.ClusterStateTaskListener;
 import org.elasticsearch.cluster.NamedDiff;
-import org.elasticsearch.cluster.metadata.Metadata;
 import org.elasticsearch.cluster.service.ClusterService;
 import org.elasticsearch.common.Priority;
 import org.elasticsearch.common.io.stream.NamedWriteableRegistry;
 import org.elasticsearch.common.settings.ClusterSettings;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.core.Nullable;
-import org.elasticsearch.xcontent.NamedXContentRegistry;
-import org.elasticsearch.xcontent.ParseField;
 
 import java.util.List;
 
@@ -137,15 +134,9 @@ public class HealthMetadataService {
         clusterService.submitStateUpdateTask(source, task, config, executor);
     }
 
-    public static List<NamedXContentRegistry.Entry> getNamedXContentParsers() {
-        return List.of(
-            new NamedXContentRegistry.Entry(Metadata.Custom.class, new ParseField(HealthMetadata.TYPE), HealthMetadata::fromXContent)
-        );
-    }
-
     public static List<NamedWriteableRegistry.Entry> getNamedWriteables() {
         return List.of(
-            new NamedWriteableRegistry.Entry(Metadata.Custom.class, HealthMetadata.TYPE, HealthMetadata::new),
+            new NamedWriteableRegistry.Entry(ClusterState.Custom.class, HealthMetadata.TYPE, HealthMetadata::new),
             new NamedWriteableRegistry.Entry(NamedDiff.class, HealthMetadata.TYPE, HealthMetadata::readDiffFrom)
         );
     }
@@ -196,7 +187,7 @@ public class HealthMetadataService {
 
         @Override
         ClusterState execute(ClusterState clusterState) {
-            HealthMetadata initialHealthMetadata = HealthMetadata.getHealthCustomMetadata(clusterState);
+            HealthMetadata initialHealthMetadata = HealthMetadata.getFromClusterState(clusterState);
             assert initialHealthMetadata != null : "health metadata should have been initialized";
             HealthMetadata.Disk.Builder builder = HealthMetadata.Disk.newBuilder(initialHealthMetadata.getDiskMetadata());
             if (CLUSTER_ROUTING_ALLOCATION_HIGH_DISK_WATERMARK_SETTING.getKey().equals(setting)) {
@@ -214,7 +205,7 @@ public class HealthMetadataService {
             final var finalHealthMetadata = new HealthMetadata(builder.build());
             return finalHealthMetadata.equals(initialHealthMetadata)
                 ? clusterState
-                : clusterState.copyAndUpdateMetadata(b -> b.putCustom(HealthMetadata.TYPE, finalHealthMetadata));
+                : clusterState.copyAndUpdate(b -> b.putCustom(HealthMetadata.TYPE, finalHealthMetadata));
         }
     }
 
@@ -232,7 +223,7 @@ public class HealthMetadataService {
 
         @Override
         ClusterState execute(ClusterState clusterState) {
-            HealthMetadata initialHealthMetadata = HealthMetadata.getHealthCustomMetadata(clusterState);
+            HealthMetadata initialHealthMetadata = HealthMetadata.getFromClusterState(clusterState);
             final var finalHealthMetadata = new HealthMetadata(
                 new HealthMetadata.Disk(
                     CLUSTER_ROUTING_ALLOCATION_HIGH_DISK_WATERMARK_SETTING.get(settings),
@@ -243,7 +234,7 @@ public class HealthMetadataService {
             );
             return finalHealthMetadata.equals(initialHealthMetadata)
                 ? clusterState
-                : clusterState.copyAndUpdateMetadata(b -> b.putCustom(HealthMetadata.TYPE, finalHealthMetadata));
+                : clusterState.copyAndUpdate(b -> b.putCustom(HealthMetadata.TYPE, finalHealthMetadata));
         }
     }
 }

server/src/main/java/org/elasticsearch/node/Node.java

@@ -509,9 +509,6 @@ public class Node implements Closeable {
             Stream<NamedXContentRegistry.Entry> healthNodeTaskNamedXContentParsers = HealthNode.isEnabled()
                 ? HealthNodeTaskExecutor.getNamedXContentParsers().stream()
                 : Stream.empty();
-            Stream<NamedXContentRegistry.Entry> healthMetadataNamedXContentParsers = HealthNode.isEnabled()
-                ? HealthMetadataService.getNamedXContentParsers().stream()
-                : Stream.empty();
             NamedXContentRegistry xContentRegistry = new NamedXContentRegistry(
                 Stream.of(
                     NetworkModule.getNamedXContents().stream(),
@@ -520,8 +517,7 @@ public class Node implements Closeable {
                     pluginsService.flatMap(Plugin::getNamedXContent),
                     ClusterModule.getNamedXWriteables().stream(),
                     SystemIndexMigrationExecutor.getNamedXContentParsers().stream(),
-                    healthNodeTaskNamedXContentParsers,
-                    healthMetadataNamedXContentParsers
+                    healthNodeTaskNamedXContentParsers
                 ).flatMap(Function.identity()).collect(toList())
             );
             final List<SystemIndices.Feature> features = pluginsService.filterPlugins(SystemIndexPlugin.class).stream().map(plugin -> {

server/src/test/java/org/elasticsearch/health/metadata/HealthMetadataSerializationTests.java

@@ -8,23 +8,21 @@
 
 package org.elasticsearch.health.metadata;
 
+import org.elasticsearch.cluster.ClusterState;
 import org.elasticsearch.cluster.Diff;
-import org.elasticsearch.cluster.metadata.Metadata;
 import org.elasticsearch.common.io.stream.NamedWriteableRegistry;
 import org.elasticsearch.common.io.stream.Writeable;
 import org.elasticsearch.common.unit.ByteSizeValue;
 import org.elasticsearch.common.unit.RatioValue;
 import org.elasticsearch.common.unit.RelativeByteSizeValue;
-import org.elasticsearch.test.SimpleDiffableSerializationTestCase;
-import org.elasticsearch.xcontent.XContentParser;
+import org.elasticsearch.test.SimpleDiffableWireSerializationTestCase;
 
-import java.io.IOException;
 import java.util.List;
 
-public class HealthMetadataSerializationTests extends SimpleDiffableSerializationTestCase<Metadata.Custom> {
+public class HealthMetadataSerializationTests extends SimpleDiffableWireSerializationTestCase<ClusterState.Custom> {
 
     @Override
-    protected Metadata.Custom makeTestChanges(Metadata.Custom testInstance) {
+    protected ClusterState.Custom makeTestChanges(ClusterState.Custom testInstance) {
         if (randomBoolean()) {
             return testInstance;
         }
@@ -32,29 +30,24 @@ public class HealthMetadataSerializationTests extends SimpleDiffableSerializatio
     }
 
     @Override
-    protected Writeable.Reader<Diff<Metadata.Custom>> diffReader() {
+    protected Writeable.Reader<Diff<ClusterState.Custom>> diffReader() {
         return HealthMetadata::readDiffFrom;
     }
 
     @Override
-    protected Metadata.Custom doParseInstance(XContentParser parser) throws IOException {
-        return HealthMetadata.fromXContent(parser);
-    }
-
-    @Override
-    protected Writeable.Reader<Metadata.Custom> instanceReader() {
+    protected Writeable.Reader<ClusterState.Custom> instanceReader() {
         return HealthMetadata::new;
     }
 
     @Override
     protected NamedWriteableRegistry getNamedWriteableRegistry() {
         return new NamedWriteableRegistry(
-            List.of(new NamedWriteableRegistry.Entry(Metadata.Custom.class, HealthMetadata.TYPE, HealthMetadata::new))
+            List.of(new NamedWriteableRegistry.Entry(ClusterState.Custom.class, HealthMetadata.TYPE, HealthMetadata::new))
         );
     }
 
     @Override
-    protected Metadata.Custom createTestInstance() {
+    protected ClusterState.Custom createTestInstance() {
         return randomHealthMetadata();
     }