Make utility methods in IndexLifecycleTransition project-aware (elastic#128930)

nielsbauman · valeriy42 · commit 8612084cc461 · 2025-06-12T13:27:35.000+02:00
Modifies the methods to work with a project scope rather than a cluster
scope.
This is part of an iterative process to make ILM project-aware.
diff --git a/x-pack/plugin/ilm/src/main/java/org/elasticsearch/xpack/ilm/ExecuteStepsUpdateTask.java b/x-pack/plugin/ilm/src/main/java/org/elasticsearch/xpack/ilm/ExecuteStepsUpdateTask.java
@@ -198,7 +198,9 @@ private ClusterState executeWaitStep(ClusterState state, Step currentStep) {
             if (stepInfo == null) {
                 return state;
             }
-            return IndexLifecycleTransition.addStepInfoToClusterState(index, state, stepInfo);
+            return ClusterState.builder(state)
+                .putProjectMetadata(IndexLifecycleTransition.addStepInfoToProject(index, state.metadata().getProject(), stepInfo))
+                .build();
         }
     }
 
@@ -286,7 +288,12 @@ private ClusterState moveToErrorStep(final ClusterState state, Step.StepKey curr
             ),
             cause
         );
-        return IndexLifecycleTransition.moveClusterStateToErrorStep(index, state, cause, nowSupplier, policyStepsRegistry::getStep);
+        final var project = state.metadata().getProject();
+        return ClusterState.builder(state)
+            .putProjectMetadata(
+                IndexLifecycleTransition.moveIndexToErrorStep(index, project, cause, nowSupplier, policyStepsRegistry::getStep)
+            )
+            .build();
     }
 
     @Override
diff --git a/x-pack/plugin/ilm/src/main/java/org/elasticsearch/xpack/ilm/IndexLifecycleRunner.java b/x-pack/plugin/ilm/src/main/java/org/elasticsearch/xpack/ilm/IndexLifecycleRunner.java
@@ -657,13 +657,14 @@ private final class MoveToRetryFailedStepUpdateTask extends IndexLifecycleCluste
 
         @Override
         protected ClusterState doExecute(ClusterState currentState) {
-            return IndexLifecycleTransition.moveClusterStateToPreviouslyFailedStep(
-                currentState,
+            final var updatedProject = IndexLifecycleTransition.moveIndexToPreviouslyFailedStep(
+                currentState.metadata().getProject(),
                 index.getName(),
                 nowSupplier,
                 stepRegistry,
                 true
             );
+            return ClusterState.builder(currentState).putProjectMetadata(updatedProject).build();
         }
 
         @Override
diff --git a/x-pack/plugin/ilm/src/main/java/org/elasticsearch/xpack/ilm/IndexLifecycleService.java b/x-pack/plugin/ilm/src/main/java/org/elasticsearch/xpack/ilm/IndexLifecycleService.java
@@ -170,12 +170,12 @@ public ProjectMetadata moveIndexToStep(ProjectMetadata project, Index index, Ste
         return IndexLifecycleTransition.moveIndexToStep(index, project, newStepKey, nowSupplier, policyRegistry, true);
     }
 
-    public ClusterState moveClusterStateToPreviouslyFailedStep(ClusterState currentState, String[] indices) {
-        ClusterState newState = currentState;
+    public ProjectMetadata moveIndicesToPreviouslyFailedStep(ProjectMetadata currentProject, String[] indices) {
+        ProjectMetadata newProject = currentProject;
         for (String index : indices) {
-            newState = IndexLifecycleTransition.moveClusterStateToPreviouslyFailedStep(newState, index, nowSupplier, policyRegistry, false);
+            newProject = IndexLifecycleTransition.moveIndexToPreviouslyFailedStep(newProject, index, nowSupplier, policyRegistry, false);
         }
-        return newState;
+        return newProject;
     }
 
     // package private for testing
diff --git a/x-pack/plugin/ilm/src/main/java/org/elasticsearch/xpack/ilm/IndexLifecycleTransition.java b/x-pack/plugin/ilm/src/main/java/org/elasticsearch/xpack/ilm/IndexLifecycleTransition.java
@@ -12,21 +12,18 @@
 import org.elasticsearch.ElasticsearchException;
 import org.elasticsearch.action.support.TransportAction;
 import org.elasticsearch.client.internal.Client;
-import org.elasticsearch.cluster.ClusterState;
 import org.elasticsearch.cluster.metadata.IndexMetadata;
 import org.elasticsearch.cluster.metadata.LifecycleExecutionState;
 import org.elasticsearch.cluster.metadata.ProjectMetadata;
 import org.elasticsearch.common.Strings;
 import org.elasticsearch.common.settings.Settings;
-import org.elasticsearch.core.Nullable;
 import org.elasticsearch.index.Index;
 import org.elasticsearch.license.XPackLicenseState;
 import org.elasticsearch.xcontent.ToXContentObject;
 import org.elasticsearch.xpack.core.ilm.ErrorStep;
 import org.elasticsearch.xpack.core.ilm.IndexLifecycleMetadata;
 import org.elasticsearch.xpack.core.ilm.InitializePolicyContextStep;
 import org.elasticsearch.xpack.core.ilm.InitializePolicyException;
-import org.elasticsearch.xpack.core.ilm.LifecycleExecutionStateUtils;
 import org.elasticsearch.xpack.core.ilm.LifecyclePolicy;
 import org.elasticsearch.xpack.core.ilm.LifecyclePolicyMetadata;
 import org.elasticsearch.xpack.core.ilm.LifecycleSettings;
@@ -113,7 +110,7 @@ public static void validateTransition(
      * @param nowSupplier    The current-time supplier for updating when steps changed
      * @param stepRegistry   The steps registry to check a step-key's existence in the index's current policy
      * @param forcePhaseDefinitionRefresh Whether to force the phase JSON to be reread or not
-     * @return The updated cluster state where the index moved to <code>newStepKey</code>
+     * @return The updated project metadata where the index moved to <code>newStepKey</code>
      */
     static ProjectMetadata moveIndexToStep(
         Index index,
@@ -149,15 +146,15 @@ static ProjectMetadata moveIndexToStep(
      * Moves the given index into the ERROR step. The ERROR step will have the same phase and
      * action, but use the {@link ErrorStep#NAME} as the name in the lifecycle execution state.
      */
-    static ClusterState moveClusterStateToErrorStep(
+    static ProjectMetadata moveIndexToErrorStep(
         Index index,
-        ClusterState clusterState,
+        ProjectMetadata project,
         Exception cause,
         LongSupplier nowSupplier,
         BiFunction<IndexMetadata, Step.StepKey, Step> stepLookupFunction
     ) {
-        IndexMetadata idxMeta = clusterState.getMetadata().getProject().index(index);
-        IndexLifecycleMetadata ilmMeta = clusterState.metadata().getProject().custom(IndexLifecycleMetadata.TYPE);
+        IndexMetadata idxMeta = project.index(index);
+        IndexLifecycleMetadata ilmMeta = project.custom(IndexLifecycleMetadata.TYPE);
         LifecyclePolicyMetadata policyMetadata = ilmMeta.getPolicyMetadatas().get(idxMeta.getLifecyclePolicyName());
         LifecycleExecutionState currentState = idxMeta.getLifecycleExecutionState();
         Step.StepKey currentStep;
@@ -204,22 +201,21 @@ static ClusterState moveClusterStateToErrorStep(
             );
         }
 
-        return LifecycleExecutionStateUtils.newClusterStateWithLifecycleState(clusterState, idxMeta.getIndex(), failedState.build());
+        return project.withLifecycleState(idxMeta.getIndex(), failedState.build());
     }
 
     /**
      * Move the given index's execution state back to a step that had previously failed. If this is
      * an automatic retry ({@code isAutomaticRetry}), the retry count is incremented.
      */
-    static ClusterState moveClusterStateToPreviouslyFailedStep(
-        ClusterState currentState,
+    static ProjectMetadata moveIndexToPreviouslyFailedStep(
+        ProjectMetadata project,
         String index,
         LongSupplier nowSupplier,
         PolicyStepsRegistry stepRegistry,
         boolean isAutomaticRetry
     ) {
-        ClusterState newState;
-        IndexMetadata indexMetadata = currentState.metadata().getProject().index(index);
+        IndexMetadata indexMetadata = project.index(index);
         if (indexMetadata == null) {
             throw new IllegalArgumentException("index [" + index + "] does not exist");
         }
@@ -229,7 +225,7 @@ static ClusterState moveClusterStateToPreviouslyFailedStep(
         if (currentStepKey != null && ErrorStep.NAME.equals(currentStepKey.name()) && Strings.isNullOrEmpty(failedStep) == false) {
             Step.StepKey nextStepKey = new Step.StepKey(currentStepKey.phase(), currentStepKey.action(), failedStep);
             validateTransition(indexMetadata, currentStepKey, nextStepKey, stepRegistry);
-            IndexLifecycleMetadata ilmMeta = currentState.metadata().getProject().custom(IndexLifecycleMetadata.TYPE);
+            IndexLifecycleMetadata ilmMeta = project.custom(IndexLifecycleMetadata.TYPE);
 
             LifecyclePolicyMetadata policyMetadata = ilmMeta.getPolicyMetadatas().get(indexMetadata.getLifecyclePolicyName());
 
@@ -259,17 +255,12 @@ static ClusterState moveClusterStateToPreviouslyFailedStep(
                 // manual retries don't update the retry count
                 retryStepState.setFailedStepRetryCount(lifecycleState.failedStepRetryCount());
             }
-            newState = LifecycleExecutionStateUtils.newClusterStateWithLifecycleState(
-                currentState,
-                indexMetadata.getIndex(),
-                retryStepState.build()
-            );
+            return project.withLifecycleState(indexMetadata.getIndex(), retryStepState.build());
         } else {
             throw new IllegalArgumentException(
                 "cannot retry an action for an index [" + index + "] that has not encountered an error when running a Lifecycle Policy"
             );
         }
-        return newState;
     }
 
     /**
@@ -413,53 +404,31 @@ public static LifecycleExecutionState moveStateToNextActionAndUpdateCachedPhase(
     }
 
     /**
-     * Conditionally updates cluster state with new step info. The new cluster state is only
-     * built if the step info has changed, otherwise the same old <code>clusterState</code> is
+     * Conditionally updates project metadata with new step info. The new project metadata is only
+     * built if the step info has changed, otherwise the same old <code>project</code> is
      * returned
-     *
-     * @param index        the index to modify
-     * @param clusterState the cluster state to modify
-     * @param stepInfo     the new step info to update
-     * @return Updated cluster state with <code>stepInfo</code> if changed, otherwise the same cluster state
-     * if no changes to step info exist
      */
-    static ClusterState addStepInfoToClusterState(Index index, ClusterState clusterState, ToXContentObject stepInfo) {
-        IndexMetadata indexMetadata = clusterState.getMetadata().getProject().index(index);
+    static ProjectMetadata addStepInfoToProject(Index index, ProjectMetadata project, ToXContentObject stepInfo) {
+        IndexMetadata indexMetadata = project.index(index);
         if (indexMetadata == null) {
             // This index doesn't exist anymore, we can't do anything
-            return clusterState;
+            return project;
         }
         LifecycleExecutionState lifecycleState = indexMetadata.getLifecycleExecutionState();
         final String stepInfoString = Strings.toString(stepInfo);
         if (stepInfoString.equals(lifecycleState.stepInfo())) {
-            return clusterState;
+            return project;
         }
         LifecycleExecutionState.Builder newState = LifecycleExecutionState.builder(lifecycleState);
         newState.setStepInfo(stepInfoString);
-        return LifecycleExecutionStateUtils.newClusterStateWithLifecycleState(clusterState, indexMetadata.getIndex(), newState.build());
+        return project.withLifecycleState(index, newState.build());
     }
 
     /**
      * Remove the ILM policy from the given indices, this removes the lifecycle setting as well as
      * any lifecycle execution state that may be present in the index metadata
      */
-    public static ClusterState removePolicyForIndexes(final Index[] indices, ClusterState currentState, List<String> failedIndexes) {
-        final ProjectMetadata currentProject = currentState.metadata().getProject();
-        final ProjectMetadata.Builder updatedProject = removePolicyForIndexes(indices, currentProject, failedIndexes);
-
-        if (updatedProject == null) {
-            return currentState;
-        } else {
-            return ClusterState.builder(currentState).putProjectMetadata(updatedProject).build();
-        }
-    }
-
-    /**
-     * @return If one or more policies were removed, then a new builder representing the changed project state.
-     *         Otherwise {@code null} (if no changes were made)
-     */
-    @Nullable
-    private static ProjectMetadata.Builder removePolicyForIndexes(
+    public static ProjectMetadata removePolicyForIndexes(
         final Index[] indices,
         ProjectMetadata currentProject,
         List<String> failedIndexes
@@ -481,7 +450,7 @@ private static ProjectMetadata.Builder removePolicyForIndexes(
             }
         }
 
-        return newProject;
+        return newProject == null ? currentProject : newProject.build();
     }
 
     /**
diff --git a/x-pack/plugin/ilm/src/main/java/org/elasticsearch/xpack/ilm/MoveToErrorStepUpdateTask.java b/x-pack/plugin/ilm/src/main/java/org/elasticsearch/xpack/ilm/MoveToErrorStepUpdateTask.java
@@ -57,14 +57,17 @@ public MoveToErrorStepUpdateTask(
 
     @Override
     protected ClusterState doExecute(ClusterState currentState) throws Exception {
-        IndexMetadata idxMeta = currentState.getMetadata().getProject().index(index);
+        final var project = currentState.getMetadata().getProject();
+        IndexMetadata idxMeta = project.index(index);
         if (idxMeta == null) {
             // Index must have been since deleted, ignore it
             return currentState;
         }
         LifecycleExecutionState lifecycleState = idxMeta.getLifecycleExecutionState();
         if (policy.equals(idxMeta.getLifecyclePolicyName()) && currentStepKey.equals(Step.getCurrentStepKey(lifecycleState))) {
-            return IndexLifecycleTransition.moveClusterStateToErrorStep(index, currentState, cause, nowSupplier, stepLookupFunction);
+            return ClusterState.builder(currentState)
+                .putProjectMetadata(IndexLifecycleTransition.moveIndexToErrorStep(index, project, cause, nowSupplier, stepLookupFunction))
+                .build();
         } else {
             // either the policy has changed or the step is now
             // not the same as when we submitted the update task. In
diff --git a/x-pack/plugin/ilm/src/main/java/org/elasticsearch/xpack/ilm/SetStepInfoUpdateTask.java b/x-pack/plugin/ilm/src/main/java/org/elasticsearch/xpack/ilm/SetStepInfoUpdateTask.java
@@ -46,14 +46,17 @@ ToXContentObject getStepInfo() {
 
     @Override
     protected ClusterState doExecute(ClusterState currentState) throws IOException {
-        IndexMetadata idxMeta = currentState.getMetadata().getProject().index(index);
+        final var project = currentState.metadata().getProject();
+        IndexMetadata idxMeta = project.index(index);
         if (idxMeta == null) {
             // Index must have been since deleted, ignore it
             return currentState;
         }
         LifecycleExecutionState lifecycleState = idxMeta.getLifecycleExecutionState();
         if (policy.equals(idxMeta.getLifecyclePolicyName()) && Objects.equals(currentStepKey, Step.getCurrentStepKey(lifecycleState))) {
-            return IndexLifecycleTransition.addStepInfoToClusterState(index, currentState, stepInfo);
+            return ClusterState.builder(currentState)
+                .putProjectMetadata(IndexLifecycleTransition.addStepInfoToProject(index, project, stepInfo))
+                .build();
         } else {
             // either the policy has changed or the step is now
             // not the same as when we submitted the update task. In
diff --git a/x-pack/plugin/ilm/src/main/java/org/elasticsearch/xpack/ilm/action/TransportRemoveIndexLifecyclePolicyAction.java b/x-pack/plugin/ilm/src/main/java/org/elasticsearch/xpack/ilm/action/TransportRemoveIndexLifecyclePolicyAction.java
@@ -70,7 +70,9 @@ protected void masterOperation(Task task, Request request, ClusterState state, A
 
             @Override
             public ClusterState execute(ClusterState currentState) throws Exception {
-                return IndexLifecycleTransition.removePolicyForIndexes(indices, currentState, failedIndexes);
+                final var project = currentState.metadata().getProject();
+                final var updatedProject = IndexLifecycleTransition.removePolicyForIndexes(indices, project, failedIndexes);
+                return ClusterState.builder(currentState).putProjectMetadata(updatedProject).build();
             }
 
             @Override
diff --git a/x-pack/plugin/ilm/src/main/java/org/elasticsearch/xpack/ilm/action/TransportRetryAction.java b/x-pack/plugin/ilm/src/main/java/org/elasticsearch/xpack/ilm/action/TransportRetryAction.java
@@ -74,7 +74,9 @@ protected void masterOperation(
         submitUnbatchedTask("ilm-re-run", new AckedClusterStateUpdateTask(request, listener) {
             @Override
             public ClusterState execute(ClusterState currentState) {
-                return indexLifecycleService.moveClusterStateToPreviouslyFailedStep(currentState, request.indices());
+                final var project = state.metadata().getProject();
+                final var updatedProject = indexLifecycleService.moveIndicesToPreviouslyFailedStep(project, request.indices());
+                return ClusterState.builder(currentState).putProjectMetadata(updatedProject).build();
             }
 
             @Override
diff --git a/x-pack/plugin/ilm/src/main/java/org/elasticsearch/xpack/ilm/package-info.java b/x-pack/plugin/ilm/src/main/java/org/elasticsearch/xpack/ilm/package-info.java
@@ -90,7 +90,7 @@
  * successfully (see {@link org.elasticsearch.xpack.ilm.IndexLifecycleRunner#onErrorMaybeRetryFailedStep}). In order to see all retryable
  * steps see {@link org.elasticsearch.xpack.core.ilm.Step#isRetryable()}.
  * For steps that are not retryable the failed step can manually be retried using
- * {@link org.elasticsearch.xpack.ilm.IndexLifecycleService#moveClusterStateToPreviouslyFailedStep}.
+ * {@link org.elasticsearch.xpack.ilm.IndexLifecycleService#moveIndicesToPreviouslyFailedStep}.
  *
  */
 package org.elasticsearch.xpack.ilm;
diff --git a/x-pack/plugin/ilm/src/test/java/org/elasticsearch/xpack/ilm/IndexLifecycleRunnerTests.java b/x-pack/plugin/ilm/src/test/java/org/elasticsearch/xpack/ilm/IndexLifecycleRunnerTests.java
@@ -917,40 +917,6 @@ private static LifecyclePolicy createPolicy(String policyName, StepKey safeStep,
         return newTestLifecyclePolicy(policyName, phases);
     }
 
-    public static void assertClusterStateOnNextStep(
-        ClusterState oldClusterState,
-        Index index,
-        StepKey currentStep,
-        StepKey nextStep,
-        ClusterState newClusterState,
-        long now
-    ) {
-        assertNotSame(oldClusterState, newClusterState);
-        Metadata newMetadata = newClusterState.metadata();
-        assertNotSame(oldClusterState.metadata(), newMetadata);
-        IndexMetadata newIndexMetadata = newMetadata.getProject().getIndexSafe(index);
-        assertNotSame(oldClusterState.metadata().getProject().index(index), newIndexMetadata);
-        LifecycleExecutionState newLifecycleState = newClusterState.metadata().getProject().index(index).getLifecycleExecutionState();
-        LifecycleExecutionState oldLifecycleState = oldClusterState.metadata().getProject().index(index).getLifecycleExecutionState();
-        assertNotSame(oldLifecycleState, newLifecycleState);
-        assertEquals(nextStep.phase(), newLifecycleState.phase());
-        assertEquals(nextStep.action(), newLifecycleState.action());
-        assertEquals(nextStep.name(), newLifecycleState.step());
-        if (currentStep.phase().equals(nextStep.phase())) {
-            assertEquals(oldLifecycleState.phaseTime(), newLifecycleState.phaseTime());
-        } else {
-            assertEquals(now, newLifecycleState.phaseTime().longValue());
-        }
-        if (currentStep.action().equals(nextStep.action())) {
-            assertEquals(oldLifecycleState.actionTime(), newLifecycleState.actionTime());
-        } else {
-            assertEquals(now, newLifecycleState.actionTime().longValue());
-        }
-        assertEquals(now, newLifecycleState.stepTime().longValue());
-        assertEquals(null, newLifecycleState.failedStep());
-        assertEquals(null, newLifecycleState.stepInfo());
-    }
-
     private static IndexMetadata createIndex(String name) {
         return IndexMetadata.builder(name).settings(randomIndexSettings()).build();
     }
diff --git a/x-pack/plugin/ilm/src/test/java/org/elasticsearch/xpack/ilm/IndexLifecycleTransitionTests.java b/x-pack/plugin/ilm/src/test/java/org/elasticsearch/xpack/ilm/IndexLifecycleTransitionTests.java

Original file line number	Diff line number	Diff line change
`@@ -198,7 +198,9 @@ private ClusterState executeWaitStep(ClusterState state, Step currentStep) {`
`198`	`198`	`if (stepInfo == null) {`
`199`	`199`	`return state;`
`200`	`200`	`}`
`201`		`- return IndexLifecycleTransition.addStepInfoToClusterState(index, state, stepInfo);`
	`201`	`+ return ClusterState.builder(state)`
	`202`	`+ .putProjectMetadata(IndexLifecycleTransition.addStepInfoToProject(index, state.metadata().getProject(), stepInfo))`
	`203`	`+ .build();`
`202`	`204`	`}`
`203`	`205`	`}`
`204`	`206`
`@@ -286,7 +288,12 @@ private ClusterState moveToErrorStep(final ClusterState state, Step.StepKey curr`
`286`	`288`	`),`
`287`	`289`	`cause`
`288`	`290`	`);`
`289`		`- return IndexLifecycleTransition.moveClusterStateToErrorStep(index, state, cause, nowSupplier, policyStepsRegistry::getStep);`
	`291`	`+ final var project = state.metadata().getProject();`
	`292`	`+ return ClusterState.builder(state)`
	`293`	`+ .putProjectMetadata(`
	`294`	`+ IndexLifecycleTransition.moveIndexToErrorStep(index, project, cause, nowSupplier, policyStepsRegistry::getStep)`
	`295`	`+ )`
	`296`	`+ .build();`
`290`	`297`	`}`
`291`	`298`
`292`	`299`	`@Override`
Original file line number	Diff line number	Diff line change
`@@ -170,12 +170,12 @@ public ProjectMetadata moveIndexToStep(ProjectMetadata project, Index index, Ste`
`170`	`170`	`return IndexLifecycleTransition.moveIndexToStep(index, project, newStepKey, nowSupplier, policyRegistry, true);`
`171`	`171`	`}`
`172`	`172`
`173`		`- public ClusterState moveClusterStateToPreviouslyFailedStep(ClusterState currentState, String[] indices) {`
`174`		`- ClusterState newState = currentState;`
	`173`	`+ public ProjectMetadata moveIndicesToPreviouslyFailedStep(ProjectMetadata currentProject, String[] indices) {`
	`174`	`+ ProjectMetadata newProject = currentProject;`
`175`	`175`	`for (String index : indices) {`
`176`		`- newState = IndexLifecycleTransition.moveClusterStateToPreviouslyFailedStep(newState, index, nowSupplier, policyRegistry, false);`
	`176`	`+ newProject = IndexLifecycleTransition.moveIndexToPreviouslyFailedStep(newProject, index, nowSupplier, policyRegistry, false);`
`177`	`177`	`}`
`178`		`- return newState;`
	`178`	`+ return newProject;`
`179`	`179`	`}`
`180`	`180`
`181`	`181`	`// package private for testing`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,9 @@ protected void masterOperation(Task task, Request request, ClusterState state, A`
`70`	`70`
`71`	`71`	`@Override`
`72`	`72`	`public ClusterState execute(ClusterState currentState) throws Exception {`
`73`		`- return IndexLifecycleTransition.removePolicyForIndexes(indices, currentState, failedIndexes);`
	`73`	`+ final var project = currentState.metadata().getProject();`
	`74`	`+ final var updatedProject = IndexLifecycleTransition.removePolicyForIndexes(indices, project, failedIndexes);`
	`75`	`+ return ClusterState.builder(currentState).putProjectMetadata(updatedProject).build();`
`74`	`76`	`}`
`75`	`77`
`76`	`78`	`@Override`
Original file line number	Diff line number	Diff line change
`@@ -90,7 +90,7 @@`
`90`	`90`	`* successfully (see {@link org.elasticsearch.xpack.ilm.IndexLifecycleRunner#onErrorMaybeRetryFailedStep}). In order to see all retryable`
`91`	`91`	`* steps see {@link org.elasticsearch.xpack.core.ilm.Step#isRetryable()}.`
`92`	`92`	`* For steps that are not retryable the failed step can manually be retried using`
`93`		`- * {@link org.elasticsearch.xpack.ilm.IndexLifecycleService#moveClusterStateToPreviouslyFailedStep}.`
	`93`	`+ * {@link org.elasticsearch.xpack.ilm.IndexLifecycleService#moveIndicesToPreviouslyFailedStep}.`
`94`	`94`	`*`
`95`	`95`	`*/`
`96`	`96`	`package org.elasticsearch.xpack.ilm;`