Fix transition for mounted index from searchable_snapshot to another action

Not that searchable_snapshot can precede other actions in the same phase
(eg. in frozen it is followed by `migrate`) we need to allow the mounted
index to resume executing the ILM policy starting with a step that's part
of a new action (ie. migrate).

This adds support to resume the execution of the mounted index from another
action.

With older versions the execution would resume from the PhaseCompleteStep
as it was the last action in a phase, which was handled as a special case
in the `CopyExecutionStateStep`. This commit generalises the `CopyExecutionStateStep`
to be able to resume from any `StepKey`.

Author: andreidan

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

@@ -21,8 +21,7 @@
 /**
  * Copies the execution state data from one index to another, typically after a
  * new index has been created. As part of the execution state copy it will set the target index
- * "current step" to the provided step name (part of the same phase and action as the current step's, unless
- * the "complete" step is configured in which case the action will be changed to "complete" as well)
+ * "current step" to the provided target next step {@link org.elasticsearch.xpack.core.ilm.Step.StepKey}.
  *
  * Useful for actions such as shrink.
  */
@@ -32,20 +31,20 @@ public class CopyExecutionStateStep extends ClusterStateActionStep {
     private static final Logger logger = LogManager.getLogger(CopyExecutionStateStep.class);
 
     private final String targetIndexPrefix;
-    private final String targetNextStepName;
+    private final StepKey targetNextStepKey;
 
-    public CopyExecutionStateStep(StepKey key, StepKey nextStepKey, String targetIndexPrefix, String targetNextStepName) {
+    public CopyExecutionStateStep(StepKey key, StepKey nextStepKey, String targetIndexPrefix, StepKey targetNextStepKey) {
         super(key, nextStepKey);
         this.targetIndexPrefix = targetIndexPrefix;
-        this.targetNextStepName = targetNextStepName;
+        this.targetNextStepKey = targetNextStepKey;
     }
 
     String getTargetIndexPrefix() {
         return targetIndexPrefix;
     }
 
-    String getTargetNextStepName() {
-        return targetNextStepName;
+    StepKey getTargetNextStepKey() {
+        return targetNextStepKey;
     }
 
     @Override
@@ -69,20 +68,17 @@ public ClusterState performAction(Index index, ClusterState clusterState) {
                 "] to [" + targetIndexName + "] as target index does not exist");
         }
 
+        String phase = targetNextStepKey.getPhase();
+        String action = targetNextStepKey.getAction();
+        String step = targetNextStepKey.getName();
         LifecycleExecutionState lifecycleState = LifecycleExecutionState.fromIndexMetadata(indexMetadata);
-        String phase = lifecycleState.getPhase();
-        String action = lifecycleState.getAction();
         long lifecycleDate = lifecycleState.getLifecycleDate();
 
         LifecycleExecutionState.Builder relevantTargetCustomData = LifecycleExecutionState.builder();
         relevantTargetCustomData.setIndexCreationDate(lifecycleDate);
+        relevantTargetCustomData.setAction(action);
         relevantTargetCustomData.setPhase(phase);
-        relevantTargetCustomData.setStep(targetNextStepName);
-        if (targetNextStepName.equals(PhaseCompleteStep.NAME)) {
-            relevantTargetCustomData.setAction(PhaseCompleteStep.NAME);
-        } else {
-            relevantTargetCustomData.setAction(action);
-        }
+        relevantTargetCustomData.setStep(step);
         relevantTargetCustomData.setSnapshotRepository(lifecycleState.getSnapshotRepository());
         relevantTargetCustomData.setSnapshotName(lifecycleState.getSnapshotName());
         relevantTargetCustomData.setSnapshotIndexName(lifecycleState.getSnapshotIndexName());
@@ -107,11 +103,11 @@ public boolean equals(Object o) {
         }
         CopyExecutionStateStep that = (CopyExecutionStateStep) o;
         return Objects.equals(targetIndexPrefix, that.targetIndexPrefix) &&
-            Objects.equals(targetNextStepName, that.targetNextStepName);
+            Objects.equals(targetNextStepKey, that.targetNextStepKey);
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(super.hashCode(), targetIndexPrefix, targetNextStepName);
+        return Objects.hash(super.hashCode(), targetIndexPrefix, targetNextStepKey);
     }
 }

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

@@ -245,10 +245,8 @@ public List<Step> toSteps(Client client, String phase, StepKey nextStepKey) {
             client, getRestoredIndexPrefix(mountSnapshotKey), getConcreteStorageType(mountSnapshotKey));
         WaitForIndexColorStep waitForGreenIndexHealthStep = new WaitForIndexColorStep(waitForGreenRestoredIndexKey,
             copyMetadataKey, ClusterHealthStatus.GREEN, getRestoredIndexPrefix(waitForGreenRestoredIndexKey));
-        // a policy with only the cold phase will have a null "nextStepKey", hence the "null" nextStepKey passed in below when that's the
-        // case
         CopyExecutionStateStep copyMetadataStep = new CopyExecutionStateStep(copyMetadataKey, copyLifecyclePolicySettingKey,
-            getRestoredIndexPrefix(copyMetadataKey), nextStepKey != null ? nextStepKey.getName() : "null");
+            getRestoredIndexPrefix(copyMetadataKey), nextStepKey);
         CopySettingsStep copySettingsStep = new CopySettingsStep(copyLifecyclePolicySettingKey, dataStreamCheckBranchingKey,
             getRestoredIndexPrefix(copyLifecyclePolicySettingKey), LifecycleSettings.LIFECYCLE_NAME);
         BranchingStep isDataStreamBranchingStep = new BranchingStep(dataStreamCheckBranchingKey, swapAliasesKey, replaceDataStreamIndexKey,

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

@@ -184,7 +184,7 @@ public List<Step> toSteps(Client client, String phase, Step.StepKey nextStepKey)
             SHRUNKEN_INDEX_PREFIX);
         ShrunkShardsAllocatedStep allocated = new ShrunkShardsAllocatedStep(enoughShardsKey, copyMetadataKey, SHRUNKEN_INDEX_PREFIX);
         CopyExecutionStateStep copyMetadata = new CopyExecutionStateStep(copyMetadataKey, dataStreamCheckBranchingKey,
-            SHRUNKEN_INDEX_PREFIX, ShrunkenIndexCheckStep.NAME);
+            SHRUNKEN_INDEX_PREFIX, isShrunkIndexKey);
         // by the time we get to this step we have 2 indices, the source and the shrunken one. we now need to choose an index
         // swapping strategy such that the shrunken index takes the place of the source index (which is also deleted).
         // if the source index is part of a data stream it's a matter of replacing it with the shrunken index one in the data stream and

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

@@ -26,16 +26,16 @@ protected CopyExecutionStateStep createRandomInstance() {
         StepKey stepKey = randomStepKey();
         StepKey nextStepKey = randomStepKey();
         String shrunkIndexPrefix = randomAlphaOfLength(10);
-        String nextStepName = randomStepKey().getName();
-        return new CopyExecutionStateStep(stepKey, nextStepKey, shrunkIndexPrefix, nextStepName);
+        StepKey targetNextStepKey = randomStepKey();
+        return new CopyExecutionStateStep(stepKey, nextStepKey, shrunkIndexPrefix, targetNextStepKey);
     }
 
     @Override
     protected CopyExecutionStateStep mutateInstance(CopyExecutionStateStep instance) {
         StepKey key = instance.getKey();
         StepKey nextKey = instance.getNextStepKey();
         String shrunkIndexPrefix = instance.getTargetIndexPrefix();
-        String nextStepName = instance.getTargetNextStepName();
+        StepKey targetNextStepKey = instance.getTargetNextStepKey();
 
         switch (between(0, 2)) {
             case 0:
@@ -48,19 +48,20 @@ protected CopyExecutionStateStep mutateInstance(CopyExecutionStateStep instance)
                 shrunkIndexPrefix += randomAlphaOfLength(5);
                 break;
             case 3:
-                nextStepName = randomAlphaOfLengthBetween(1, 10);
+                targetNextStepKey = new StepKey(targetNextStepKey.getPhase(), targetNextStepKey.getAction(),
+                    targetNextStepKey.getName() + randomAlphaOfLength(5));
                 break;
             default:
                 throw new AssertionError("Illegal randomisation branch");
         }
 
-        return new CopyExecutionStateStep(key, nextKey, shrunkIndexPrefix, nextStepName);
+        return new CopyExecutionStateStep(key, nextKey, shrunkIndexPrefix, targetNextStepKey);
     }
 
     @Override
     protected CopyExecutionStateStep copyInstance(CopyExecutionStateStep instance) {
         return new CopyExecutionStateStep(instance.getKey(), instance.getNextStepKey(), instance.getTargetIndexPrefix(),
-            instance.getTargetNextStepName());
+            instance.getTargetNextStepKey());
     }
 
     public void testPerformAction() {
@@ -89,10 +90,11 @@ public void testPerformAction() {
         LifecycleExecutionState newIndexData = LifecycleExecutionState
             .fromIndexMetadata(newClusterState.metadata().index(step.getTargetIndexPrefix() + indexName));
 
+        StepKey targetNextStepKey = step.getTargetNextStepKey();
         assertEquals(newIndexData.getLifecycleDate(), oldIndexData.getLifecycleDate());
-        assertEquals(newIndexData.getPhase(), oldIndexData.getPhase());
-        assertEquals(newIndexData.getAction(), oldIndexData.getAction());
-        assertEquals(newIndexData.getStep(), step.getTargetNextStepName());
+        assertEquals(newIndexData.getPhase(), targetNextStepKey.getPhase());
+        assertEquals(newIndexData.getAction(), targetNextStepKey.getAction());
+        assertEquals(newIndexData.getStep(), targetNextStepKey.getName());
         assertEquals(newIndexData.getSnapshotRepository(), oldIndexData.getSnapshotRepository());
         assertEquals(newIndexData.getSnapshotName(), oldIndexData.getSnapshotName());
     }