Allow ILM move-to-step without action or name (#75435)

* Allow ILM move-to-step without `action` or `name`

This commit enhances ILM's move-to-step API to allow dropping the `name`, or dropping both the
`action` and `name`. For example:

```json
POST /_ilm/move/foo-1
{
  "current_step": {
    "phase": "hot",
    "action": "rollover",
    "name": "check-rollover-ready"
  },
  "next_step": {
    "phase": "warm",
    "action": "forcemerge"
  }
}
```

Will move to the first step in the `forcemerge` action in the `warm` phase (without having to know
the specific step name).

Another example:

```json
POST /_ilm/move/foo-1
{
  "current_step": {
    "phase": "hot",
    "action": "rollover",
    "name": "check-rollover-ready"
  },
  "next_step": {
    "phase": "warm"
  }
}
```

Will move to the first step in the `warm` phase (without having to know the specific action name).

Bear in mind that the execution order is still entirely an implementation detail, so "first" in the
above sentences means the first step that ILM would execute.

Resolves #58128

* Apply Andrei's wording change (thanks!)

Co-authored-by: Andrei Dan <[email protected]>

* Log index and policy name when the concrete step key can't be resolved

Co-authored-by: Andrei Dan <[email protected]>

Author: dakrone

docs/reference/ilm/apis/move-to-step.asciidoc

@@ -36,6 +36,12 @@ The request will fail if the current step does not match the step currently
 being executed for the index. This is to prevent the index from being moved from
 an unexpected step into the next step.
 
+When specifying the target (`next_step`) to which the index will be moved, either the `name` or both
+the `action` and `name` fields are optional. If only the phase is specified, the index will move to
+the first step of the first action in the target phase. If the phase and action are specified, the index will move to
+the first step of the specified action in the specified phase. Only actions specified in the ILM
+policy are considered valid, an index cannot move to a step that is not part of its policy.
+
 [[ilm-move-to-step-path-params]]
 ==== {api-path-parms-title}
 
@@ -152,14 +158,16 @@ POST _ilm/move/my-index-000001
   },
   "next_step": { <2>
     "phase": "warm",
-    "action": "forcemerge",
-    "name": "forcemerge"
+    "action": "forcemerge", <3>
+    "name": "forcemerge" <4>
   }
 }
 --------------------------------------------------
 // TEST[continued]
 <1> The step that the index is expected to be in
 <2> The step that you want to execute
+<3> The optional action to which the index will be moved
+<4> The optional step name to which the index will be moved
 
 If the request succeeds, you receive the following result:
 

x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/ilm/action/MoveToStepAction.java

@@ -7,18 +7,21 @@
  */
 package org.elasticsearch.xpack.core.ilm.action;
 
+import org.elasticsearch.Version;
 import org.elasticsearch.action.ActionRequestValidationException;
 import org.elasticsearch.action.ActionType;
 import org.elasticsearch.action.support.master.AcknowledgedRequest;
 import org.elasticsearch.action.support.master.AcknowledgedResponse;
-import org.elasticsearch.common.xcontent.ParseField;
 import org.elasticsearch.common.Strings;
 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.xcontent.ConstructingObjectParser;
+import org.elasticsearch.common.xcontent.ParseField;
 import org.elasticsearch.common.xcontent.ToXContentObject;
 import org.elasticsearch.common.xcontent.XContentBuilder;
 import org.elasticsearch.common.xcontent.XContentParser;
+import org.elasticsearch.core.Nullable;
 import org.elasticsearch.xpack.core.ilm.Step.StepKey;
 
 import java.io.IOException;
@@ -39,19 +42,22 @@ public static class Request extends AcknowledgedRequest<Request> implements ToXC
             new ConstructingObjectParser<>("move_to_step_request", false,
                 (a, index) -> {
                     StepKey currentStepKey = (StepKey) a[0];
-                    StepKey nextStepKey = (StepKey) a[1];
+                    PartialStepKey nextStepKey = (PartialStepKey) a[1];
                     return new Request(index, currentStepKey, nextStepKey);
                 });
+
         static {
+            // The current step uses the strict parser (meaning it requires all three parts of a stepkey)
             PARSER.declareObject(ConstructingObjectParser.constructorArg(), (p, name) -> StepKey.parse(p), CURRENT_KEY_FIELD);
-            PARSER.declareObject(ConstructingObjectParser.constructorArg(), (p, name) -> StepKey.parse(p), NEXT_KEY_FIELD);
+            // The target step uses the parser that allows specifying only the phase, or the phase and action
+            PARSER.declareObject(ConstructingObjectParser.constructorArg(), (p, name) -> PartialStepKey.parse(p), NEXT_KEY_FIELD);
         }
 
         private String index;
         private StepKey currentStepKey;
-        private StepKey nextStepKey;
+        private PartialStepKey nextStepKey;
 
-        public Request(String index, StepKey currentStepKey, StepKey nextStepKey) {
+        public Request(String index, StepKey currentStepKey, PartialStepKey nextStepKey) {
             this.index = index;
             this.currentStepKey = currentStepKey;
             this.nextStepKey = nextStepKey;
@@ -61,7 +67,12 @@ public Request(StreamInput in) throws IOException {
             super(in);
             this.index = in.readString();
             this.currentStepKey = new StepKey(in);
-            this.nextStepKey = new StepKey(in);
+            if (in.getVersion().onOrAfter(Version.V_8_0_0)) {
+                this.nextStepKey = new PartialStepKey(in);
+            } else {
+                StepKey spec = new StepKey(in);
+                this.nextStepKey = new PartialStepKey(spec.getPhase(), spec.getAction(), spec.getName());
+            }
         }
 
         public Request() {
@@ -75,7 +86,7 @@ public StepKey getCurrentStepKey() {
             return currentStepKey;
         }
 
-        public StepKey getNextStepKey() {
+        public PartialStepKey getNextStepKey() {
             return nextStepKey;
         }
 
@@ -93,7 +104,14 @@ public void writeTo(StreamOutput out) throws IOException {
             super.writeTo(out);
             out.writeString(index);
             currentStepKey.writeTo(out);
-            nextStepKey.writeTo(out);
+            if (out.getVersion().onOrAfter(Version.V_8_0_0)) {
+                nextStepKey.writeTo(out);
+            } else {
+                String action = nextStepKey.getAction();
+                String name = nextStepKey.getName();
+                StepKey key = new StepKey(nextStepKey.getPhase(), action == null ? "" : action, name == null ? "" : name);
+                key.writeTo(out);
+            }
         }
 
         @Override
@@ -126,5 +144,110 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
                 .field(NEXT_KEY_FIELD.getPreferredName(), nextStepKey)
                 .endObject();
         }
+
+        /**
+         * A PartialStepKey is like a {@link StepKey}, however, the action and step name are optional.
+         */
+        public static class PartialStepKey implements Writeable, ToXContentObject {
+            private final String phase;
+            private final String action;
+            private final String name;
+
+            public static final ParseField PHASE_FIELD = new ParseField("phase");
+            public static final ParseField ACTION_FIELD = new ParseField("action");
+            public static final ParseField NAME_FIELD = new ParseField("name");
+            private static final ConstructingObjectParser<PartialStepKey, Void> PARSER =
+                new ConstructingObjectParser<>("step_specification",
+                    a -> new PartialStepKey((String) a[0], (String) a[1], (String) a[2]));
+            static {
+                PARSER.declareString(ConstructingObjectParser.constructorArg(), PHASE_FIELD);
+                PARSER.declareString(ConstructingObjectParser.optionalConstructorArg(), ACTION_FIELD);
+                PARSER.declareString(ConstructingObjectParser.optionalConstructorArg(), NAME_FIELD);
+            }
+
+            public PartialStepKey(String phase, @Nullable String action, @Nullable String name) {
+                this.phase = phase;
+                this.action = action;
+                this.name = name;
+                if (name != null && action == null) {
+                    throw new IllegalArgumentException("phase; phase and action; or phase, action, and step must be provided, " +
+                        "but a step name was specified without a corresponding action");
+                }
+            }
+
+            public PartialStepKey(StreamInput in) throws IOException {
+                this.phase = in.readString();
+                this.action = in.readOptionalString();
+                this.name = in.readOptionalString();
+                if (name != null && action == null) {
+                    throw new IllegalArgumentException("phase; phase and action; or phase, action, and step must be provided, " +
+                        "but a step name was specified without a corresponding action");
+                }
+            }
+
+            public static PartialStepKey parse(XContentParser parser) {
+                return PARSER.apply(parser, null);
+            }
+
+            @Override
+            public void writeTo(StreamOutput out) throws IOException {
+                out.writeString(phase);
+                out.writeOptionalString(action);
+                out.writeOptionalString(name);
+            }
+
+            @Nullable
+            public String getPhase() {
+                return phase;
+            }
+
+            @Nullable
+            public String getAction() {
+                return action;
+            }
+
+            @Nullable
+            public String getName() {
+                return name;
+            }
+
+            @Override
+            public int hashCode() {
+                return Objects.hash(phase, action, name);
+            }
+
+            @Override
+            public boolean equals(Object obj) {
+                if (obj == null) {
+                    return false;
+                }
+                if (getClass() != obj.getClass()) {
+                    return false;
+                }
+                PartialStepKey other = (PartialStepKey) obj;
+                return Objects.equals(phase, other.phase) &&
+                    Objects.equals(action, other.action) &&
+                    Objects.equals(name, other.name);
+            }
+
+            @Override
+            public String toString() {
+                return Strings.toString(this);
+            }
+
+            @Override
+            public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+                builder.startObject();
+                builder.field(PHASE_FIELD.getPreferredName(), phase);
+                if (action != null) {
+                    builder.field(ACTION_FIELD.getPreferredName(), action);
+                }
+                if (name != null) {
+                    builder.field(NAME_FIELD.getPreferredName(), name);
+                }
+                builder.endObject();
+                return builder;
+            }
+        }
     }
 }

x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/ilm/action/MoveToStepRequestTests.java

@@ -27,7 +27,7 @@ public void setup() {
 
     @Override
     protected Request createTestInstance() {
-        return new Request(index, stepKeyTests.createTestInstance(), stepKeyTests.createTestInstance());
+        return new Request(index, stepKeyTests.createTestInstance(), randomStepSpecification());
     }
 
     @Override
@@ -49,7 +49,7 @@ protected boolean supportsUnknownFields() {
     protected Request mutateInstance(Request request) {
         String index = request.getIndex();
         StepKey currentStepKey = request.getCurrentStepKey();
-        StepKey nextStepKey = request.getNextStepKey();
+        Request.PartialStepKey nextStepKey = request.getNextStepKey();
 
         switch (between(0, 2)) {
             case 0:
@@ -59,12 +59,24 @@ protected Request mutateInstance(Request request) {
                 currentStepKey = stepKeyTests.mutateInstance(currentStepKey);
                 break;
             case 2:
-                nextStepKey = stepKeyTests.mutateInstance(nextStepKey);
+                nextStepKey = randomValueOtherThan(nextStepKey, MoveToStepRequestTests::randomStepSpecification);
                 break;
             default:
                 throw new AssertionError("Illegal randomisation branch");
         }
 
         return new Request(index, currentStepKey, nextStepKey);
     }
+
+    private static Request.PartialStepKey randomStepSpecification() {
+        if (randomBoolean()) {
+            StepKey key = stepKeyTests.createTestInstance();
+            return new Request.PartialStepKey(key.getPhase(), key.getAction(), key.getName());
+        } else {
+            String phase = randomAlphaOfLength(10);
+            String action = randomBoolean() ? null : randomAlphaOfLength(6);
+            String name = action == null ? null : (randomBoolean() ? null : randomAlphaOfLength(6));
+            return new Request.PartialStepKey(phase, action, name);
+        }
+    }
 }