Record most recent snapshot policy success/failure (#40619)

Keeping a record of the results of the successes and failures will aid
troubleshooting of policies and make users more confident that their
snapshots are being taken as expected.

This is the first step toward writing history in a more permanent
fashion.

Author: gwbrown

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

@@ -0,0 +1,111 @@
+/*
+ * 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.snapshotlifecycle;
+
+import org.elasticsearch.cluster.AbstractDiffable;
+import org.elasticsearch.cluster.Diffable;
+import org.elasticsearch.common.ParseField;
+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.ConstructingObjectParser;
+import org.elasticsearch.common.xcontent.ToXContentObject;
+import org.elasticsearch.common.xcontent.XContentBuilder;
+import org.elasticsearch.common.xcontent.XContentParser;
+
+import java.io.IOException;
+import java.util.Objects;
+
+/**
+ * Holds information about Snapshots kicked off by Snapshot Lifecycle Management in the cluster state, so that this information can be
+ * presented to the user. This class is used for both successes and failures as the structure of the data is very similar.
+ */
+public class SnapshotInvocationRecord extends AbstractDiffable<SnapshotInvocationRecord>
+    implements Writeable, ToXContentObject, Diffable<SnapshotInvocationRecord> {
+
+    static final ParseField SNAPSHOT_NAME = new ParseField("snapshot_name");
+    static final ParseField TIMESTAMP = new ParseField("time");
+    static final ParseField DETAILS = new ParseField("details");
+
+    private String snapshotName;
+    private long timestamp;
+    private String details;
+
+    public static final ConstructingObjectParser<SnapshotInvocationRecord, String> PARSER =
+        new ConstructingObjectParser<>("snapshot_policy_invocation_record", true,
+            a -> new SnapshotInvocationRecord((String) a[0], (long) a[1], (String) a[2]));
+
+    static {
+        PARSER.declareString(ConstructingObjectParser.constructorArg(), SNAPSHOT_NAME);
+        PARSER.declareLong(ConstructingObjectParser.constructorArg(), TIMESTAMP);
+        PARSER.declareString(ConstructingObjectParser.optionalConstructorArg(), DETAILS);
+    }
+
+    public static SnapshotInvocationRecord parse(XContentParser parser, String name) {
+        return PARSER.apply(parser, name);
+    }
+
+    public SnapshotInvocationRecord(String snapshotName, long timestamp, String details) {
+        this.snapshotName = Objects.requireNonNull(snapshotName, "snapshot name must be provided");
+        this.timestamp = timestamp;
+        this.details = details;
+    }
+
+    public SnapshotInvocationRecord(StreamInput in) throws IOException {
+        this.snapshotName = in.readString();
+        this.timestamp = in.readVLong();
+        this.details = in.readOptionalString();
+    }
+
+    public String getSnapshotName() {
+        return snapshotName;
+    }
+
+    public long getTimestamp() {
+        return timestamp;
+    }
+
+    public String getDetails() {
+        return details;
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        out.writeString(snapshotName);
+        out.writeVLong(timestamp);
+        out.writeOptionalString(details);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject();
+        {
+            builder.field(SNAPSHOT_NAME.getPreferredName(), snapshotName);
+            builder.timeField(TIMESTAMP.getPreferredName(), "time_string", timestamp);
+            if (Objects.nonNull(details)) {
+                builder.field(DETAILS.getPreferredName(), details);
+            }
+        }
+        builder.endObject();
+        return builder;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        SnapshotInvocationRecord that = (SnapshotInvocationRecord) o;
+        return getTimestamp() == that.getTimestamp() &&
+            Objects.equals(getSnapshotName(), that.getSnapshotName()) &&
+            Objects.equals(getDetails(), that.getDetails());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(getSnapshotName(), getTimestamp(), getDetails());
+    }
+}

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

@@ -73,7 +73,7 @@ public class SnapshotLifecyclePolicy extends AbstractDiffable<SnapshotLifecycleP
 
     public SnapshotLifecyclePolicy(final String id, final String name, final String schedule,
                                    final String repository, Map<String, Object> configuration) {
-        this.id = id;
+        this.id = Objects.requireNonNull(id);
         this.name = name;
         this.schedule = schedule;
         this.repository = repository;

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

@@ -8,6 +8,7 @@
 
 import org.elasticsearch.cluster.AbstractDiffable;
 import org.elasticsearch.cluster.Diffable;
+import org.elasticsearch.common.Nullable;
 import org.elasticsearch.common.ParseField;
 import org.elasticsearch.common.io.stream.StreamInput;
 import org.elasticsearch.common.io.stream.StreamOutput;
@@ -21,8 +22,10 @@
 import java.time.Instant;
 import java.time.ZoneOffset;
 import java.time.ZonedDateTime;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Optional;
 
 /**
  * {@code SnapshotLifecyclePolicyMetadata} encapsulates a {@link SnapshotLifecyclePolicy} as well as
@@ -37,18 +40,34 @@ public class SnapshotLifecyclePolicyMetadata extends AbstractDiffable<SnapshotLi
     static final ParseField VERSION = new ParseField("version");
     static final ParseField MODIFIED_DATE = new ParseField("modified_date");
     static final ParseField MODIFIED_DATE_STRING = new ParseField("modified_date_string");
+    static final ParseField LAST_SUCCESS = new ParseField("last_success");
+    static final ParseField LAST_FAILURE = new ParseField("last_failure");
 
     private final SnapshotLifecyclePolicy policy;
     private final Map<String, String> headers;
     private final long version;
     private final long modifiedDate;
+    @Nullable
+    private final SnapshotInvocationRecord lastSuccess;
+    @Nullable
+    private final SnapshotInvocationRecord lastFailure;
 
     @SuppressWarnings("unchecked")
     public static final ConstructingObjectParser<SnapshotLifecyclePolicyMetadata, String> PARSER =
         new ConstructingObjectParser<>("snapshot_policy_metadata",
             a -> {
                 SnapshotLifecyclePolicy policy = (SnapshotLifecyclePolicy) a[0];
-                return new SnapshotLifecyclePolicyMetadata(policy, (Map<String, String>) a[1], (long) a[2], (long) a[3]);
+                SnapshotInvocationRecord lastSuccess = (SnapshotInvocationRecord) a[5];
+                SnapshotInvocationRecord lastFailure = (SnapshotInvocationRecord) a[6];
+
+                return builder()
+                    .setPolicy(policy)
+                    .setHeaders((Map<String, String>) a[1])
+                    .setVersion((long) a[2])
+                    .setModifiedDate((long) a[3])
+                    .setLastSuccess(lastSuccess)
+                    .setLastFailure(lastFailure)
+                    .build();
             });
 
     static {
@@ -57,17 +76,22 @@ public class SnapshotLifecyclePolicyMetadata extends AbstractDiffable<SnapshotLi
         PARSER.declareLong(ConstructingObjectParser.constructorArg(), VERSION);
         PARSER.declareLong(ConstructingObjectParser.constructorArg(), MODIFIED_DATE);
         PARSER.declareString(ConstructingObjectParser.constructorArg(), MODIFIED_DATE_STRING);
+        PARSER.declareObject(ConstructingObjectParser.optionalConstructorArg(), SnapshotInvocationRecord::parse, LAST_SUCCESS);
+        PARSER.declareObject(ConstructingObjectParser.optionalConstructorArg(), SnapshotInvocationRecord::parse, LAST_FAILURE);
     }
 
     public static SnapshotLifecyclePolicyMetadata parse(XContentParser parser, String name) {
         return PARSER.apply(parser, name);
     }
 
-    public SnapshotLifecyclePolicyMetadata(SnapshotLifecyclePolicy policy, Map<String, String> headers, long version, long modifiedDate) {
+    SnapshotLifecyclePolicyMetadata(SnapshotLifecyclePolicy policy, Map<String, String> headers, long version, long modifiedDate,
+                                    SnapshotInvocationRecord lastSuccess, SnapshotInvocationRecord lastFailure) {
         this.policy = policy;
         this.headers = headers;
         this.version = version;
         this.modifiedDate = modifiedDate;
+        this.lastSuccess = lastSuccess;
+        this.lastFailure = lastFailure;
     }
 
     @SuppressWarnings("unchecked")
@@ -76,6 +100,8 @@ public SnapshotLifecyclePolicyMetadata(SnapshotLifecyclePolicy policy, Map<Strin
         this.headers = (Map<String, String>) in.readGenericValue();
         this.version = in.readVLong();
         this.modifiedDate = in.readVLong();
+        this.lastSuccess = in.readOptionalWriteable(SnapshotInvocationRecord::new);
+        this.lastFailure = in.readOptionalWriteable(SnapshotInvocationRecord::new);
     }
 
     @Override
@@ -84,6 +110,25 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeGenericValue(this.headers);
         out.writeVLong(this.version);
         out.writeVLong(this.modifiedDate);
+        out.writeOptionalWriteable(this.lastSuccess);
+        out.writeOptionalWriteable(this.lastFailure);
+    }
+
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    public static Builder builder(SnapshotLifecyclePolicyMetadata metadata) {
+        if (metadata == null) {
+            return builder();
+        }
+        return new Builder()
+            .setHeaders(metadata.getHeaders())
+            .setPolicy(metadata.getPolicy())
+            .setVersion(metadata.getVersion())
+            .setModifiedDate(metadata.getModifiedDate())
+            .setLastSuccess(metadata.getLastSuccess())
+            .setLastFailure(metadata.getLastFailure());
     }
 
     public Map<String, String> getHeaders() {
@@ -106,9 +151,24 @@ public long getModifiedDate() {
         return modifiedDate;
     }
 
+    private String dateToDateString(Long date) {
+        if (Objects.isNull(date)) {
+            return null;
+        }
+        ZonedDateTime dateTime = ZonedDateTime.ofInstant(Instant.ofEpochMilli(date), ZoneOffset.UTC);
+        return dateTime.toString();
+    }
+
     public String getModifiedDateString() {
-        ZonedDateTime modifiedDateTime = ZonedDateTime.ofInstant(Instant.ofEpochMilli(modifiedDate), ZoneOffset.UTC);
-        return modifiedDateTime.toString();
+        return dateToDateString(modifiedDate);
+    }
+
+    public SnapshotInvocationRecord getLastSuccess() {
+        return lastSuccess;
+    }
+
+    public SnapshotInvocationRecord getLastFailure() {
+        return lastFailure;
     }
 
     @Override
@@ -119,13 +179,19 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
         builder.field(VERSION.getPreferredName(), version);
         builder.field(MODIFIED_DATE.getPreferredName(), modifiedDate);
         builder.field(MODIFIED_DATE_STRING.getPreferredName(), getModifiedDateString());
+        if (Objects.nonNull(lastSuccess)) {
+            builder.field(LAST_SUCCESS.getPreferredName(), lastSuccess);
+        }
+        if (Objects.nonNull(lastFailure)) {
+            builder.field(LAST_FAILURE.getPreferredName(), lastFailure);
+        }
         builder.endObject();
         return builder;
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(policy, headers, version, modifiedDate);
+        return Objects.hash(policy, headers, version, modifiedDate, lastSuccess, lastFailure);
     }
 
     @Override
@@ -140,7 +206,9 @@ public boolean equals(Object obj) {
         return Objects.equals(policy, other.policy) &&
             Objects.equals(headers, other.headers) &&
             Objects.equals(version, other.version) &&
-            Objects.equals(modifiedDate, other.modifiedDate);
+            Objects.equals(modifiedDate, other.modifiedDate) &&
+            Objects.equals(lastSuccess, other.lastSuccess) &&
+            Objects.equals(lastFailure, other.lastFailure);
     }
 
     @Override
@@ -150,4 +218,58 @@ public String toString() {
         // should not emit them in case it accidentally gets logged.
         return super.toString();
     }
+
+    public static class Builder {
+
+        private Builder() {
+        }
+
+        private SnapshotLifecyclePolicy policy;
+        private Map<String, String> headers;
+        private long version = 1L;
+        private Long modifiedDate;
+        private SnapshotInvocationRecord lastSuccessDate;
+        private SnapshotInvocationRecord lastFailureDate;
+
+        public Builder setPolicy(SnapshotLifecyclePolicy policy) {
+            this.policy = policy;
+            return this;
+        }
+
+        public Builder setHeaders(Map<String, String> headers) {
+            this.headers = headers;
+            return this;
+        }
+
+        public Builder setVersion(long version) {
+            this.version = version;
+            return this;
+        }
+
+        public Builder setModifiedDate(long modifiedDate) {
+            this.modifiedDate = modifiedDate;
+            return this;
+        }
+
+        public Builder setLastSuccess(SnapshotInvocationRecord lastSuccessDate) {
+            this.lastSuccessDate = lastSuccessDate;
+            return this;
+        }
+
+        public Builder setLastFailure(SnapshotInvocationRecord lastFailureDate) {
+            this.lastFailureDate = lastFailureDate;
+            return this;
+        }
+
+        public SnapshotLifecyclePolicyMetadata build() {
+            return new SnapshotLifecyclePolicyMetadata(
+                Objects.requireNonNull(policy),
+                Optional.ofNullable(headers).orElse(new HashMap<>()),
+                version,
+                Objects.requireNonNull(modifiedDate, "modifiedDate must be set"),
+                lastSuccessDate,
+                lastFailureDate);
+        }
+    }
+
 }