Include in-progress snapshot for a policy with get SLM policy… (#45245)

This commit adds the "in_progress" key to the SLM get policy API,
returning a policy that looks like:

```json
{
  "daily-snapshots" : {
    "version" : 1,
    "modified_date" : "2019-08-05T18:41:48.778Z",
    "modified_date_millis" : 1565030508778,
    "policy" : {
      "name" : "<production-snap-{now/d}>",
      "schedule" : "0 30 1 * * ?",
      "repository" : "repo",
      "config" : {
        "indices" : [
          "foo-*",
          "important"
        ],
        "ignore_unavailable" : true,
        "include_global_state" : false
      },
      "retention" : {
        "expire_after" : "10m"
      }
    },
    "last_success" : {
      "snapshot_name" : "production-snap-2019.08.05-oxctmnobqye3luim4uejhg",
      "time_string" : "2019-08-05T18:42:23.257Z",
      "time" : 1565030543257
    },
    "next_execution" : "2019-08-06T01:30:00.000Z",
    "next_execution_millis" : 1565055000000,
    "in_progress" : {
      "name" : "production-snap-2019.08.05-oxctmnobqye3luim4uejhg",
      "uuid" : "t8Idqt6JQxiZrzp0Vt7z6g",
      "state" : "STARTED",
      "start_time" : "2019-08-05T18:42:22.998Z",
      "start_time_millis" : 1565030542998
    }
  }
}
```

These are only visible while the snapshot is being taken (or failed),
since it reads from the cluster state rather than from the repository
itself.

Author: dakrone

client/rest-high-level/src/main/java/org/elasticsearch/client/slm/SnapshotLifecyclePolicyMetadata.java

@@ -21,10 +21,12 @@
 
 import org.elasticsearch.common.Nullable;
 import org.elasticsearch.common.ParseField;
+import org.elasticsearch.common.Strings;
 import org.elasticsearch.common.xcontent.ConstructingObjectParser;
 import org.elasticsearch.common.xcontent.ToXContentObject;
 import org.elasticsearch.common.xcontent.XContentBuilder;
 import org.elasticsearch.common.xcontent.XContentParser;
+import org.elasticsearch.snapshots.SnapshotId;
 
 import java.io.IOException;
 import java.util.Objects;
@@ -39,6 +41,7 @@ public class SnapshotLifecyclePolicyMetadata implements ToXContentObject {
     static final ParseField LAST_FAILURE = new ParseField("last_failure");
     static final ParseField NEXT_EXECUTION_MILLIS = new ParseField("next_execution_millis");
     static final ParseField NEXT_EXECUTION = new ParseField("next_execution");
+    static final ParseField SNAPSHOT_IN_PROGRESS = new ParseField("in_progress");
 
     private final SnapshotLifecyclePolicy policy;
     private final long version;
@@ -48,6 +51,8 @@ public class SnapshotLifecyclePolicyMetadata implements ToXContentObject {
     private final SnapshotInvocationRecord lastSuccess;
     @Nullable
     private final SnapshotInvocationRecord lastFailure;
+    @Nullable
+    private final SnapshotInProgress snapshotInProgress;
 
     @SuppressWarnings("unchecked")
     public static final ConstructingObjectParser<SnapshotLifecyclePolicyMetadata, String> PARSER =
@@ -59,8 +64,9 @@ public class SnapshotLifecyclePolicyMetadata implements ToXContentObject {
                 SnapshotInvocationRecord lastSuccess = (SnapshotInvocationRecord) a[3];
                 SnapshotInvocationRecord lastFailure = (SnapshotInvocationRecord) a[4];
                 long nextExecution = (long) a[5];
+                SnapshotInProgress sip = (SnapshotInProgress) a[6];
 
-                return new SnapshotLifecyclePolicyMetadata(policy, version, modifiedDate, lastSuccess, lastFailure, nextExecution);
+                return new SnapshotLifecyclePolicyMetadata(policy, version, modifiedDate, lastSuccess, lastFailure, nextExecution, sip);
             });
 
     static {
@@ -70,6 +76,7 @@ public class SnapshotLifecyclePolicyMetadata implements ToXContentObject {
         PARSER.declareObject(ConstructingObjectParser.optionalConstructorArg(), SnapshotInvocationRecord::parse, LAST_SUCCESS);
         PARSER.declareObject(ConstructingObjectParser.optionalConstructorArg(), SnapshotInvocationRecord::parse, LAST_FAILURE);
         PARSER.declareLong(ConstructingObjectParser.constructorArg(), NEXT_EXECUTION_MILLIS);
+        PARSER.declareObject(ConstructingObjectParser.optionalConstructorArg(), SnapshotInProgress::parse, SNAPSHOT_IN_PROGRESS);
     }
 
     public static SnapshotLifecyclePolicyMetadata parse(XContentParser parser, String id) {
@@ -78,13 +85,15 @@ public static SnapshotLifecyclePolicyMetadata parse(XContentParser parser, Strin
 
     public SnapshotLifecyclePolicyMetadata(SnapshotLifecyclePolicy policy, long version, long modifiedDate,
                                            SnapshotInvocationRecord lastSuccess, SnapshotInvocationRecord lastFailure,
-                                           long nextExecution) {
+                                           long nextExecution,
+                                           @Nullable SnapshotInProgress snapshotInProgress) {
         this.policy = policy;
         this.version = version;
         this.modifiedDate = modifiedDate;
         this.lastSuccess = lastSuccess;
         this.lastFailure = lastFailure;
         this.nextExecution = nextExecution;
+        this.snapshotInProgress = snapshotInProgress;
     }
 
     public SnapshotLifecyclePolicy getPolicy() {
@@ -115,6 +124,11 @@ public long getNextExecution() {
         return this.nextExecution;
     }
 
+    @Nullable
+    public SnapshotInProgress getSnapshotInProgress() {
+        return this.snapshotInProgress;
+    }
+
     @Override
     public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
         builder.startObject();
@@ -128,6 +142,9 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
             builder.field(LAST_FAILURE.getPreferredName(), lastFailure);
         }
         builder.timeField(NEXT_EXECUTION_MILLIS.getPreferredName(), NEXT_EXECUTION.getPreferredName(), nextExecution);
+        if (snapshotInProgress != null) {
+            builder.field(SNAPSHOT_IN_PROGRESS.getPreferredName(), snapshotInProgress);
+        }
         builder.endObject();
         return builder;
     }
@@ -154,4 +171,84 @@ public boolean equals(Object obj) {
             Objects.equals(nextExecution, other.nextExecution);
     }
 
+    public static class SnapshotInProgress implements ToXContentObject {
+        private static final ParseField NAME = new ParseField("name");
+        private static final ParseField UUID = new ParseField("uuid");
+        private static final ParseField STATE = new ParseField("state");
+        private static final ParseField START_TIME = new ParseField("start_time_millis");
+        private static final ParseField FAILURE = new ParseField("failure");
+
+        private static final ConstructingObjectParser<SnapshotInProgress, Void> PARSER =
+            new ConstructingObjectParser<>("snapshot_in_progress", true, a -> {
+                SnapshotId id = new SnapshotId((String) a[0], (String) a[1]);
+                String state = (String) a[2];
+                long start = (long) a[3];
+                String failure = (String) a[4];
+                return new SnapshotInProgress(id, state, start, failure);
+            });
+
+        static {
+            PARSER.declareString(ConstructingObjectParser.constructorArg(), NAME);
+            PARSER.declareString(ConstructingObjectParser.constructorArg(), UUID);
+            PARSER.declareString(ConstructingObjectParser.constructorArg(), STATE);
+            PARSER.declareLong(ConstructingObjectParser.constructorArg(), START_TIME);
+            PARSER.declareString(ConstructingObjectParser.optionalConstructorArg(), FAILURE);
+        }
+
+        private final SnapshotId snapshotId;
+        private final String state;
+        private final long startTime;
+        private final String failure;
+
+        public SnapshotInProgress(SnapshotId snapshotId, String state, long startTime, @Nullable String failure) {
+            this.snapshotId = snapshotId;
+            this.state = state;
+            this.startTime = startTime;
+            this.failure = failure;
+        }
+
+        private static SnapshotInProgress parse(XContentParser parser, String name) {
+            return PARSER.apply(parser, null);
+        }
+
+        @Override
+        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+            builder.startObject();
+            builder.field(NAME.getPreferredName(), snapshotId.getName());
+            builder.field(UUID.getPreferredName(), snapshotId.getUUID());
+            builder.field(STATE.getPreferredName(), state);
+            builder.timeField(START_TIME.getPreferredName(), "start_time", startTime);
+            if (failure != null) {
+                builder.field(FAILURE.getPreferredName(), failure);
+            }
+            builder.endObject();
+            return builder;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(snapshotId, state, startTime, failure);
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (obj == null) {
+                return false;
+            }
+
+            if (obj.getClass() != getClass()) {
+                return false;
+            }
+            SnapshotInProgress other = (SnapshotInProgress) obj;
+            return Objects.equals(snapshotId, other.snapshotId) &&
+                Objects.equals(state, other.state) &&
+                startTime == other.startTime &&
+                Objects.equals(failure, other.failure);
+        }
+
+        @Override
+        public String toString() {
+            return Strings.toString(this);
+        }
+    }
 }

client/rest-high-level/src/test/java/org/elasticsearch/client/documentation/ILMDocumentationIT.java

@@ -854,6 +854,8 @@ public void onFailure(Exception e) {
         long nextPolicyExecutionDate = policyMeta.getNextExecution();
         SnapshotInvocationRecord lastSuccess = policyMeta.getLastSuccess();
         SnapshotInvocationRecord lastFailure = policyMeta.getLastFailure();
+        SnapshotLifecyclePolicyMetadata.SnapshotInProgress inProgress =
+            policyMeta.getSnapshotInProgress();
         SnapshotLifecyclePolicy retrievedPolicy = policyMeta.getPolicy(); // <2>
         String id = retrievedPolicy.getId();
         String snapshotNameFormat = retrievedPolicy.getName();

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

@@ -47,6 +47,8 @@
 public class SnapshotLifecyclePolicy extends AbstractDiffable<SnapshotLifecyclePolicy>
     implements Writeable, Diffable<SnapshotLifecyclePolicy>, ToXContentObject {
 
+    public static final String POLICY_ID_METADATA_FIELD = "policy";
+
     private final String id;
     private final String name;
     private final String schedule;
@@ -59,7 +61,6 @@ public class SnapshotLifecyclePolicy extends AbstractDiffable<SnapshotLifecycleP
     private static final ParseField CONFIG = new ParseField("config");
     private static final IndexNameExpressionResolver.DateMathExpressionResolver DATE_MATH_RESOLVER =
         new IndexNameExpressionResolver.DateMathExpressionResolver();
-    private static final String POLICY_ID_METADATA_FIELD = "policy";
     private static final String METADATA_FIELD_NAME = "metadata";
 
     @SuppressWarnings("unchecked")

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

@@ -6,13 +6,17 @@
 
 package org.elasticsearch.xpack.core.slm;
 
+import org.elasticsearch.cluster.SnapshotsInProgress;
 import org.elasticsearch.common.Nullable;
+import org.elasticsearch.common.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.ToXContentFragment;
+import org.elasticsearch.common.xcontent.ToXContentObject;
 import org.elasticsearch.common.xcontent.XContentBuilder;
+import org.elasticsearch.snapshots.SnapshotId;
 
 import java.io.IOException;
 import java.util.Objects;
@@ -24,21 +28,27 @@
  */
 public class SnapshotLifecyclePolicyItem implements ToXContentFragment, Writeable {
 
+    private static final ParseField SNAPSHOT_IN_PROGRESS = new ParseField("in_progress");
+
     private final SnapshotLifecyclePolicy policy;
     private final long version;
     private final long modifiedDate;
+    @Nullable
+    private final SnapshotInProgress snapshotInProgress;
 
     @Nullable
     private final SnapshotInvocationRecord lastSuccess;
 
     @Nullable
     private final SnapshotInvocationRecord lastFailure;
-    public SnapshotLifecyclePolicyItem(SnapshotLifecyclePolicyMetadata policyMetadata) {
+    public SnapshotLifecyclePolicyItem(SnapshotLifecyclePolicyMetadata policyMetadata,
+                                       @Nullable SnapshotInProgress snapshotInProgress) {
         this.policy = policyMetadata.getPolicy();
         this.version = policyMetadata.getVersion();
         this.modifiedDate = policyMetadata.getModifiedDate();
         this.lastSuccess = policyMetadata.getLastSuccess();
         this.lastFailure = policyMetadata.getLastFailure();
+        this.snapshotInProgress = snapshotInProgress;
     }
 
     public SnapshotLifecyclePolicyItem(StreamInput in) throws IOException {
@@ -47,17 +57,20 @@ public SnapshotLifecyclePolicyItem(StreamInput in) throws IOException {
         this.modifiedDate = in.readVLong();
         this.lastSuccess = in.readOptionalWriteable(SnapshotInvocationRecord::new);
         this.lastFailure = in.readOptionalWriteable(SnapshotInvocationRecord::new);
+        this.snapshotInProgress = in.readOptionalWriteable(SnapshotInProgress::new);
     }
 
     // For testing
 
     SnapshotLifecyclePolicyItem(SnapshotLifecyclePolicy policy, long version, long modifiedDate,
-                                SnapshotInvocationRecord lastSuccess, SnapshotInvocationRecord lastFailure) {
+                                SnapshotInvocationRecord lastSuccess, SnapshotInvocationRecord lastFailure,
+                                @Nullable SnapshotInProgress snapshotInProgress) {
         this.policy = policy;
         this.version = version;
         this.modifiedDate = modifiedDate;
         this.lastSuccess = lastSuccess;
         this.lastFailure = lastFailure;
+        this.snapshotInProgress = snapshotInProgress;
     }
     public SnapshotLifecyclePolicy getPolicy() {
         return policy;
@@ -79,13 +92,19 @@ public SnapshotInvocationRecord getLastFailure() {
         return lastFailure;
     }
 
+    @Nullable
+    public SnapshotInProgress getSnapshotInProgress() {
+        return this.snapshotInProgress;
+    }
+
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         policy.writeTo(out);
         out.writeVLong(version);
         out.writeVLong(modifiedDate);
         out.writeOptionalWriteable(lastSuccess);
         out.writeOptionalWriteable(lastFailure);
+        out.writeOptionalWriteable(snapshotInProgress);
     }
 
     @Override
@@ -106,7 +125,8 @@ public boolean equals(Object obj) {
             version == other.version &&
             modifiedDate == other.modifiedDate &&
             Objects.equals(lastSuccess, other.lastSuccess) &&
-            Objects.equals(lastFailure, other.lastFailure);
+            Objects.equals(lastFailure, other.lastFailure) &&
+            Objects.equals(snapshotInProgress, other.snapshotInProgress);
     }
 
     @Override
@@ -124,6 +144,9 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
         }
         builder.timeField(SnapshotLifecyclePolicyMetadata.NEXT_EXECUTION_MILLIS.getPreferredName(),
             SnapshotLifecyclePolicyMetadata.NEXT_EXECUTION.getPreferredName(), policy.calculateNextExecution());
+        if (snapshotInProgress != null) {
+            builder.field(SNAPSHOT_IN_PROGRESS.getPreferredName(), snapshotInProgress);
+        }
         builder.endObject();
         return builder;
     }
@@ -132,4 +155,84 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
     public String toString() {
         return Strings.toString(this);
     }
+
+    public static class SnapshotInProgress implements ToXContentObject, Writeable {
+        private static final ParseField NAME = new ParseField("name");
+        private static final ParseField UUID = new ParseField("uuid");
+        private static final ParseField STATE = new ParseField("state");
+        private static final ParseField START_TIME = new ParseField("start_time_millis");
+        private static final ParseField FAILURE = new ParseField("failure");
+
+        private final SnapshotId snapshotId;
+        private final SnapshotsInProgress.State state;
+        private final long startTime;
+        private final String failure;
+
+        public SnapshotInProgress(SnapshotId snapshotId, SnapshotsInProgress.State state, long startTime, @Nullable String failure) {
+            this.snapshotId = snapshotId;
+            this.state = state;
+            this.startTime = startTime;
+            this.failure = failure;
+        }
+
+        SnapshotInProgress(StreamInput in) throws IOException {
+            this.snapshotId = new SnapshotId(in);
+            this.state = in.readEnum(SnapshotsInProgress.State.class);
+            this.startTime = in.readVLong();
+            this.failure = in.readOptionalString();
+        }
+
+        public static SnapshotInProgress fromEntry(SnapshotsInProgress.Entry entry) {
+            return new SnapshotInProgress(entry.snapshot().getSnapshotId(),
+                entry.state(), entry.startTime(), entry.failure());
+        }
+
+        @Override
+        public void writeTo(StreamOutput out) throws IOException {
+            this.snapshotId.writeTo(out);
+            out.writeEnum(this.state);
+            out.writeVLong(this.startTime);
+            out.writeOptionalString(this.failure);
+        }
+
+        @Override
+        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+            builder.startObject();
+            builder.field(NAME.getPreferredName(), snapshotId.getName());
+            builder.field(UUID.getPreferredName(), snapshotId.getUUID());
+            builder.field(STATE.getPreferredName(), state);
+            builder.timeField(START_TIME.getPreferredName(), "start_time", startTime);
+            if (failure != null) {
+                builder.field(FAILURE.getPreferredName(), failure);
+            }
+            builder.endObject();
+            return builder;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(snapshotId, state, startTime, failure);
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (obj == null) {
+                return false;
+            }
+
+            if (obj.getClass() != getClass()) {
+                return false;
+            }
+            SnapshotInProgress other = (SnapshotInProgress) obj;
+            return Objects.equals(snapshotId, other.snapshotId) &&
+                Objects.equals(state, other.state) &&
+                startTime == other.startTime &&
+                Objects.equals(failure, other.failure);
+        }
+
+        @Override
+        public String toString() {
+            return Strings.toString(this);
+        }
+    }
 }