Make utility methods in IndexLifecycleTransition project-aware

nielsbauman · nielsbauman · commit 77f36679a63b · 2025-06-04T22:20:23.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
@@ -206,7 +206,11 @@ public ClusterState doExecute(final ClusterState currentState) throws IOExceptio
                         if (stepInfo == null) {
                             return state;
                         } else {
-                            return IndexLifecycleTransition.addStepInfoToClusterState(index, state, stepInfo);
+                            return ClusterState.builder(state)
+                                .putProjectMetadata(
+                                    IndexLifecycleTransition.addStepInfoToClusterState(index, state.metadata().getProject(), stepInfo)
+                                )
+                                .build();
                         }
                     }
                 }
@@ -293,7 +297,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.moveClusterStateToPreviouslyFailedStep(
+                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,18 @@ 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 moveClusterStateToPreviouslyFailedStep(ProjectMetadata currentProject, String[] indices) {
+        ProjectMetadata newProject = currentProject;
         for (String index : indices) {
-            newState = IndexLifecycleTransition.moveClusterStateToPreviouslyFailedStep(newState, index, nowSupplier, policyRegistry, false);
+            newProject = IndexLifecycleTransition.moveClusterStateToPreviouslyFailedStep(
+                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;
@@ -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 moveClusterStateToPreviouslyFailedStep(
+        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 addStepInfoToClusterState(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.addStepInfoToClusterState(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,11 @@ 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 updatedProject = indexLifecycleService.moveClusterStateToPreviouslyFailedStep(
+                    state.metadata().getProject(),
+                    request.indices()
+                );
+                return ClusterState.builder(currentState).putProjectMetadata(updatedProject).build();
             }
 
             @Override
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
@@ -916,40 +916,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
`@@ -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`