Add shard explain info to ReactiveReason about unassigned shards

docs/changelog/88590.yaml

@@ -0,0 +1,6 @@
+pr: 88590
+summary: Add shard explain info to `ReactiveReason` about unassigned shards
+area: Autoscaling
+type: enhancement
+issues:
+ - 85243

x-pack/plugin/autoscaling/src/internalClusterTest/java/org/elasticsearch/xpack/autoscaling/storage/ReactiveStorageIT.java

@@ -17,6 +17,7 @@
 import org.elasticsearch.cluster.metadata.IndexMetadata;
 import org.elasticsearch.cluster.node.DiscoveryNodeRole;
 import org.elasticsearch.cluster.routing.allocation.DataTier;
+import org.elasticsearch.cluster.routing.allocation.decider.Decision;
 import org.elasticsearch.common.settings.ClusterSettings;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.core.Tuple;
@@ -39,6 +40,8 @@
 
 import static org.elasticsearch.index.store.Store.INDEX_STORE_STATS_REFRESH_INTERVAL_SETTING;
 import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertAcked;
+import static org.elasticsearch.xpack.autoscaling.storage.ReactiveStorageDeciderService.AllocationState.MAX_AMOUNT_OF_SHARD_DECISIONS;
+import static org.hamcrest.CoreMatchers.startsWith;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.is;
 import static org.hamcrest.Matchers.notNullValue;
@@ -105,6 +108,30 @@ public void testScaleUp() throws InterruptedException {
  response.results().get(policyName).requiredCapacity().node().storage().getBytes(),
  equalTo(maxShardSize + ReactiveStorageDeciderService.NODE_DISK_OVERHEAD + LOW_WATERMARK_BYTES)
  );
+ var reactiveReason = (ReactiveStorageDeciderService.ReactiveReason) response.results()
+ .get(policyName)
+ .results()
+ .get("reactive_storage")
+ .reason();
+ assertEquals(
+ reactiveReason.assignedShardIds().stream().limit(MAX_AMOUNT_OF_SHARD_DECISIONS).collect(Collectors.toSet()),
+ reactiveReason.assignedNodeDecisions().keySet()
+ );
+ NodeDecision canRemainNodeDecision = reactiveReason.assignedNodeDecisions()
+ .get(reactiveReason.assignedShardIds().first())
+ .canRemainDecision();
+ Decision decision = canRemainNodeDecision.decision()
+ .getDecisions()
+ .stream()
+ .filter(d -> d.type() == Decision.Type.NO)
+ .findFirst()
+ .orElseThrow(() -> new IllegalStateException("Unable to find NO can_remain decision"));
+ assertEquals(Decision.Type.NO, decision.type());
+ assertEquals("disk_threshold", decision.label());
+ assertThat(
+ decision.getExplanation(),
+ startsWith("the shard cannot remain on this node because it is above the high watermark cluster setting")
+ );
  }
 
  public void testScaleFromEmptyWarmMove() throws Exception {

x-pack/plugin/autoscaling/src/main/java/org/elasticsearch/xpack/autoscaling/storage/NodeDecision.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+package org.elasticsearch.xpack.autoscaling.storage;
+
+import org.elasticsearch.cluster.node.DiscoveryNode;
+import org.elasticsearch.cluster.routing.allocation.decider.Decision;
+import org.elasticsearch.common.io.stream.StreamInput;
+import org.elasticsearch.common.io.stream.StreamOutput;
+import org.elasticsearch.common.io.stream.Writeable;
+import org.elasticsearch.xcontent.ToXContentObject;
+import org.elasticsearch.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.Objects;
+
+import static org.elasticsearch.cluster.routing.allocation.AbstractAllocationDecision.discoveryNodeToXContent;
+
+class NodeDecision implements ToXContentObject, Writeable {
+
+ private final DiscoveryNode node;
+ private final Decision decision;
+
+ NodeDecision(DiscoveryNode node, Decision decision) {
+ this.node = node;
+ this.decision = decision;
+ }
+
+ NodeDecision(StreamInput in) throws IOException {
+ node = new DiscoveryNode(in);
+ decision = Decision.readFrom(in);
+ }
+
+ @Override
+ public void writeTo(StreamOutput out) throws IOException {
+ node.writeTo(out);
+ decision.writeTo(out);
+ }
+
+ DiscoveryNode node() {
+ return node;
+ }
+
+ Decision decision() {
+ return decision;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ return o instanceof NodeDecision that && Objects.equals(node, that.node) && Objects.equals(decision, that.decision);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(node, decision);
+ }
+
+ @Override
+ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+ builder.startObject();
+ discoveryNodeToXContent(node, false, builder);
+ {
+ builder.startArray("deciders");
+ decision.toXContent(builder, params);
+ builder.endArray();
+ }
+ builder.endObject();
+ return builder;
+ }
+
+}

x-pack/plugin/autoscaling/src/main/java/org/elasticsearch/xpack/autoscaling/storage/NodeDecisions.java

@@ -0,0 +1,74 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+package org.elasticsearch.xpack.autoscaling.storage;
+
+import org.elasticsearch.common.io.stream.StreamInput;
+import org.elasticsearch.common.io.stream.StreamOutput;
+import org.elasticsearch.common.io.stream.Writeable;
+import org.elasticsearch.core.Nullable;
+import org.elasticsearch.xcontent.ToXContentObject;
+import org.elasticsearch.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Objects;
+
+class NodeDecisions implements ToXContentObject, Writeable {
+
+ private final List<NodeDecision> canAllocateDecisions;
+ @Nullable
+ private final NodeDecision canRemainDecision;
+
+ NodeDecisions(List<NodeDecision> canAllocateDecisions, @Nullable NodeDecision canRemainDecision) {
+ this.canAllocateDecisions = canAllocateDecisions;
+ this.canRemainDecision = canRemainDecision;
+ }
+
+ NodeDecisions(StreamInput in) throws IOException {
+ canAllocateDecisions = in.readList(NodeDecision::new);
+ canRemainDecision = in.readOptionalWriteable(NodeDecision::new);
+ }
+
+ List<NodeDecision> canAllocateDecisions() {
+ return canAllocateDecisions;
+ }
+
+ @Nullable
+ NodeDecision canRemainDecision() {
+ return canRemainDecision;
+ }
+
+ @Override
+ public void writeTo(StreamOutput out) throws IOException {
+ out.writeList(canAllocateDecisions);
+ out.writeOptionalWriteable(canRemainDecision);
+ }
+
+ @Override
+ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+ builder.startObject();
+ builder.xContentList("can_allocate_decisions", canAllocateDecisions);
+ if (canRemainDecision != null) {
+ builder.field("can_remain_decision", canRemainDecision);
+ }
+ builder.endObject();
+ return null;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o == null || getClass() != o.getClass()) return false;
+ NodeDecisions that = (NodeDecisions) o;
+ return Objects.equals(canAllocateDecisions, that.canAllocateDecisions) && Objects.equals(canRemainDecision, that.canRemainDecision);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(canAllocateDecisions, canRemainDecision);
+ }
+}