ILM: add searchable snapshot action

docs/reference/ilm/apis/get-lifecycle.asciidoc

@@ -100,7 +100,9 @@ If the request succeeds, the body of the response contains the policy definition
         "delete": {
           "min_age": "30d",
           "actions": {
-            "delete": {}
+            "delete": {
+              "delete_searchable_snapshot": true
+            }
           }
         }
       }

docs/reference/ilm/update-lifecycle-policy.asciidoc

@@ -113,7 +113,9 @@ with its version bumped to 2.
         "delete": {
           "min_age": "10d",
           "actions": {
-            "delete": {}
+            "delete": {
+              "delete_searchable_snapshot": true
+            }
           }
         }
       }

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

@@ -51,6 +51,7 @@
 import org.elasticsearch.xpack.core.ilm.LifecycleType;
 import org.elasticsearch.xpack.core.ilm.ReadOnlyAction;
 import org.elasticsearch.xpack.core.ilm.RolloverAction;
+import org.elasticsearch.xpack.core.ilm.SearchableSnapshotAction;
 import org.elasticsearch.xpack.core.ilm.SetPriorityAction;
 import org.elasticsearch.xpack.core.ilm.ShrinkAction;
 import org.elasticsearch.xpack.core.ilm.TimeseriesLifecycleType;
@@ -476,6 +477,7 @@ public List<NamedWriteableRegistry.Entry> getNamedWriteables() {
             new NamedWriteableRegistry.Entry(LifecycleAction.class, SetPriorityAction.NAME, SetPriorityAction::new),
             new NamedWriteableRegistry.Entry(LifecycleAction.class, UnfollowAction.NAME, UnfollowAction::new),
             new NamedWriteableRegistry.Entry(LifecycleAction.class, WaitForSnapshotAction.NAME, WaitForSnapshotAction::new),
+            new NamedWriteableRegistry.Entry(LifecycleAction.class, SearchableSnapshotAction.NAME, SearchableSnapshotAction::new),
             // Transforms
             new NamedWriteableRegistry.Entry(XPackFeatureSet.Usage.class, XPackField.TRANSFORM, TransformFeatureSetUsage::new),
             new NamedWriteableRegistry.Entry(PersistentTaskParams.class, TransformField.TASK_NAME, TransformTaskParams::new),

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

@@ -33,8 +33,8 @@ public AsyncRetryDuringSnapshotActionStep(StepKey key, StepKey nextStepKey, Clie
     }
 
     @Override
-    public void performAction(IndexMetaData indexMetaData, ClusterState currentClusterState,
-                              ClusterStateObserver observer, Listener listener) {
+    public final void performAction(IndexMetaData indexMetaData, ClusterState currentClusterState,
+                                    ClusterStateObserver observer, Listener listener) {
         // Wrap the original listener to handle exceptions caused by ongoing snapshots
         SnapshotExceptionListener snapshotExceptionListener = new SnapshotExceptionListener(indexMetaData.getIndex(), listener, observer);
         performDuringNoSnapshot(indexMetaData, currentClusterState, snapshotExceptionListener);

x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/ilm/CleanupSnapshotStep.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;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+package org.elasticsearch.xpack.core.ilm;
+
+import org.elasticsearch.action.ActionListener;
+import org.elasticsearch.action.admin.cluster.snapshots.delete.DeleteSnapshotRequest;
+import org.elasticsearch.action.support.master.AcknowledgedResponse;
+import org.elasticsearch.client.Client;
+import org.elasticsearch.cluster.ClusterState;
+import org.elasticsearch.cluster.metadata.IndexMetaData;
+import org.elasticsearch.common.Strings;
+import org.elasticsearch.repositories.RepositoryMissingException;
+import org.elasticsearch.snapshots.SnapshotMissingException;
+
+import static org.elasticsearch.xpack.core.ilm.LifecycleExecutionState.fromIndexMetadata;
+
+/**
+ * Deletes the snapshot designated by the repository and snapshot name present in the lifecycle execution state.
+ */
+public class CleanupSnapshotStep extends AsyncRetryDuringSnapshotActionStep {
+    public static final String NAME = "cleanup-snapshot";
+
+    public CleanupSnapshotStep(StepKey key, StepKey nextStepKey, Client client) {
+        super(key, nextStepKey, client);
+    }
+
+    @Override
+    public boolean isRetryable() {
+        return true;
+    }
+
+    @Override
+    void performDuringNoSnapshot(IndexMetaData indexMetaData, ClusterState currentClusterState, Listener listener) {
+        final String indexName = indexMetaData.getIndex().getName();
+
+        LifecycleExecutionState lifecycleState = fromIndexMetadata(indexMetaData);
+        final String repositoryName = lifecycleState.getSnapshotRepository();
+        // if the snapshot information is missing from the ILM execution state there is nothing to delete so we move on
+        if (Strings.hasText(repositoryName) == false) {
+            listener.onResponse(true);
+            return;
+        }
+        final String snapshotName = lifecycleState.getSnapshotName();
+        if (Strings.hasText(snapshotName) == false) {
+            listener.onResponse(true);
+            return;
+        }
+        DeleteSnapshotRequest deleteSnapshotRequest = new DeleteSnapshotRequest(repositoryName, snapshotName);
+        getClient().admin().cluster().deleteSnapshot(deleteSnapshotRequest, new ActionListener<>() {
+
+            @Override
+            public void onResponse(AcknowledgedResponse acknowledgedResponse) {
+                listener.onResponse(true);
+            }
+
+            @Override
+            public void onFailure(Exception e) {
+                if (e instanceof SnapshotMissingException) {
+                    // during the happy flow we generate a snapshot name and that snapshot doesn't exist in the repository
+                    listener.onResponse(true);
+                } else {
+                    if (e instanceof RepositoryMissingException) {
+                        String policyName = indexMetaData.getSettings().get(LifecycleSettings.LIFECYCLE_NAME);
+                        listener.onFailure(new IllegalStateException("repository [" + repositoryName + "] is missing. [" + policyName +
+                            "] policy for index [" + indexName + "] cannot continue until the repository is created", e));
+                    } else {
+                        listener.onFailure(e);
+                    }
+                }
+            }
+        });
+    }
+}

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

@@ -19,23 +19,32 @@
 
 /**
  * Copies the execution state data from one index to another, typically after a
- * new index has been created. Useful for actions such as shrink.
+ * 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)
+ *
+ * Useful for actions such as shrink.
  */
 public class CopyExecutionStateStep extends ClusterStateActionStep {
     public static final String NAME = "copy-execution-state";
 
     private static final Logger logger = LogManager.getLogger(CopyExecutionStateStep.class);
 
-    private String shrunkIndexPrefix;
+    private final String targetIndexPrefix;
+    private final String targetNextStepName;
 
-
-    public CopyExecutionStateStep(StepKey key, StepKey nextStepKey, String shrunkIndexPrefix) {
+    public CopyExecutionStateStep(StepKey key, StepKey nextStepKey, String targetIndexPrefix, String targetNextStepName) {
         super(key, nextStepKey);
-        this.shrunkIndexPrefix = shrunkIndexPrefix;
+        this.targetIndexPrefix = targetIndexPrefix;
+        this.targetNextStepName = targetNextStepName;
+    }
+
+    String getTargetIndexPrefix() {
+        return targetIndexPrefix;
     }
 
-    String getShrunkIndexPrefix() {
-        return shrunkIndexPrefix;
+    String getTargetNextStepName() {
+        return targetNextStepName;
     }
 
     @Override
@@ -48,8 +57,8 @@ public ClusterState performAction(Index index, ClusterState clusterState) {
         }
         // get source index
         String indexName = indexMetaData.getIndex().getName();
-        // get target shrink index
-        String targetIndexName = shrunkIndexPrefix + indexName;
+        // get target index
+        String targetIndexName = targetIndexPrefix + indexName;
         IndexMetaData targetIndexMetaData = clusterState.metaData().index(targetIndexName);
 
         if (targetIndexMetaData == null) {
@@ -67,8 +76,14 @@ public ClusterState performAction(Index index, ClusterState clusterState) {
         LifecycleExecutionState.Builder relevantTargetCustomData = LifecycleExecutionState.builder();
         relevantTargetCustomData.setIndexCreationDate(lifecycleDate);
         relevantTargetCustomData.setPhase(phase);
-        relevantTargetCustomData.setAction(action);
-        relevantTargetCustomData.setStep(ShrunkenIndexCheckStep.NAME);
+        relevantTargetCustomData.setStep(targetNextStepName);
+        if (targetNextStepName.equals(PhaseCompleteStep.NAME)) {
+            relevantTargetCustomData.setAction(PhaseCompleteStep.NAME);
+        } else {
+            relevantTargetCustomData.setAction(action);
+        }
+        relevantTargetCustomData.setSnapshotRepository(lifecycleState.getSnapshotRepository());
+        relevantTargetCustomData.setSnapshotName(lifecycleState.getSnapshotName());
 
         MetaData.Builder newMetaData = MetaData.builder(clusterState.getMetaData())
             .put(IndexMetaData.builder(targetIndexMetaData)
@@ -79,15 +94,22 @@ public ClusterState performAction(Index index, ClusterState clusterState) {
 
     @Override
     public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-        if (!super.equals(o)) return false;
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        if (!super.equals(o)) {
+            return false;
+        }
         CopyExecutionStateStep that = (CopyExecutionStateStep) o;
-        return Objects.equals(shrunkIndexPrefix, that.shrunkIndexPrefix);
+        return Objects.equals(targetIndexPrefix, that.targetIndexPrefix) &&
+            Objects.equals(targetNextStepName, that.targetNextStepName);
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(super.hashCode(), shrunkIndexPrefix);
+        return Objects.hash(super.hashCode(), targetIndexPrefix, targetNextStepName);
     }
 }

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

@@ -0,0 +1,112 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+package org.elasticsearch.xpack.core.ilm;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.elasticsearch.cluster.ClusterState;
+import org.elasticsearch.cluster.metadata.IndexMetaData;
+import org.elasticsearch.cluster.metadata.MetaData;
+import org.elasticsearch.common.settings.Settings;
+import org.elasticsearch.index.Index;
+
+import java.util.Locale;
+import java.util.Objects;
+
+/**
+ * Copy the provided settings from the source to the target index.
+ * <p>
+ * The target index is derived from the source index using the provided prefix.
+ * This is useful for actions like shrink or searchable snapshot that create a new index and migrate the ILM execution from the source
+ * to the target index.
+ */
+public class CopySettingsStep extends ClusterStateActionStep {
+    public static final String NAME = "copy-settings";
+
+    private static final Logger logger = LogManager.getLogger(CopySettingsStep.class);
+
+    private final String[] settingsKeys;
+    private final String indexPrefix;
+
+    public CopySettingsStep(StepKey key, StepKey nextStepKey, String indexPrefix, String... settingsKeys) {
+        super(key, nextStepKey);
+        Objects.requireNonNull(indexPrefix);
+        Objects.requireNonNull(settingsKeys);
+        this.indexPrefix = indexPrefix;
+        this.settingsKeys = settingsKeys;
+    }
+
+    @Override
+    public boolean isRetryable() {
+        return true;
+    }
+
+    public String[] getSettingsKeys() {
+        return settingsKeys;
+    }
+
+    public String getIndexPrefix() {
+        return indexPrefix;
+    }
+
+    @Override
+    public ClusterState performAction(Index index, ClusterState clusterState) {
+        String sourceIndexName = index.getName();
+        IndexMetaData sourceIndexMetadata = clusterState.metaData().index(sourceIndexName);
+        String targetIndexName = indexPrefix + sourceIndexName;
+        IndexMetaData targetIndexMetadata = clusterState.metaData().index(targetIndexName);
+
+        if (sourceIndexMetadata == null) {
+            // Index must have been since deleted, ignore it
+            logger.debug("[{}] lifecycle action for index [{}] executed but index no longer exists", getKey().getAction(), sourceIndexName);
+            return clusterState;
+        }
+
+        if (targetIndexMetadata == null) {
+            String errorMessage = String.format(Locale.ROOT, "index [%s] is being referenced by ILM action [%s] on step [%s] but " +
+                "it doesn't exist", targetIndexName, getKey().getAction(), getKey().getName());
+            logger.debug(errorMessage);
+            throw new IllegalStateException(errorMessage);
+        }
+
+        if (settingsKeys == null || settingsKeys.length == 0) {
+            return clusterState;
+        }
+
+        Settings.Builder settings = Settings.builder().put(targetIndexMetadata.getSettings());
+        for (String key : settingsKeys) {
+            String value = sourceIndexMetadata.getSettings().get(key);
+            settings.put(key, value);
+        }
+
+        MetaData.Builder newMetaData = MetaData.builder(clusterState.getMetaData())
+            .put(IndexMetaData.builder(targetIndexMetadata)
+                .settingsVersion(targetIndexMetadata.getSettingsVersion() + 1)
+                .settings(settings));
+        return ClusterState.builder(clusterState).metaData(newMetaData).build();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        if (!super.equals(o)) {
+            return false;
+        }
+        CopySettingsStep that = (CopySettingsStep) o;
+        return Objects.equals(settingsKeys, that.settingsKeys) &&
+            Objects.equals(indexPrefix, that.indexPrefix);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(super.hashCode(), settingsKeys, indexPrefix);
+    }
+}