Include size of snapshot in snapshot metadata

server/src/main/java/org/elasticsearch/action/admin/cluster/snapshots/status/SnapshotIndexShardStatus.java

@@ -74,8 +74,8 @@ private SnapshotIndexShardStatus() {
                 throw new IllegalArgumentException("Unknown stage type " + indexShardStatus.getStage());
         }
         this.stats = new SnapshotStats(indexShardStatus.getStartTime(), indexShardStatus.getTotalTime(),
-                                        indexShardStatus.getNumberOfFiles(), indexShardStatus.getProcessedFiles(),
-                                        indexShardStatus.getTotalSize(), indexShardStatus.getProcessedSize());
+            indexShardStatus.getIncrementalFileCount(), indexShardStatus.getTotalFileCount(), indexShardStatus.getProcessedFileCount(),
+            indexShardStatus.getIncrementalSize(), indexShardStatus.getTotalSize(), indexShardStatus.getProcessedSize());
         this.failure = indexShardStatus.getFailure();
         this.nodeId = nodeId;
     }

server/src/main/java/org/elasticsearch/action/admin/cluster/snapshots/status/SnapshotStats.java

@@ -19,6 +19,7 @@
 
 package org.elasticsearch.action.admin.cluster.snapshots.status;
 
+import org.elasticsearch.Version;
 import org.elasticsearch.common.io.stream.StreamInput;
 import org.elasticsearch.common.io.stream.StreamOutput;
 import org.elasticsearch.common.io.stream.Streamable;
@@ -34,19 +35,25 @@ public class SnapshotStats implements Streamable, ToXContentFragment {
 
     private long startTime;
     private long time;
-    private int numberOfFiles;
-    private int processedFiles;
+    private int incrementalFileCount;
+    private int totalFileCount;
+    private int processedFileCount;
+    private long incrementalSize;
     private long totalSize;
     private long processedSize;
 
     SnapshotStats() {
     }
 
-    SnapshotStats(long startTime, long time, int numberOfFiles, int processedFiles, long totalSize, long processedSize) {
+    SnapshotStats(long startTime, long time,
+                  int incrementalFileCount, int totalFileCount, int processedFileCount,
+                  long incrementalSize, long totalSize, long processedSize) {
         this.startTime = startTime;
         this.time = time;
-        this.numberOfFiles = numberOfFiles;
-        this.processedFiles = processedFiles;
+        this.incrementalFileCount = incrementalFileCount;
+        this.totalFileCount = totalFileCount;
+        this.processedFileCount = processedFileCount;
+        this.incrementalSize = incrementalSize;
         this.totalSize = totalSize;
         this.processedSize = processedSize;
     }
@@ -66,17 +73,31 @@ public long getTime() {
     }
 
     /**
-     * Returns number of files in the snapshot
+     * Returns incremental file count of the snapshot
      */
-    public int getNumberOfFiles() {
-        return numberOfFiles;
+    public int getIncrementalFileCount() {
+        return incrementalFileCount;
+    }
+
+    /**
+     * Returns total number of files in the snapshot
+     */
+    public int getTotalFileCount() {
+        return totalFileCount;
     }
 
     /**
      * Returns number of files in the snapshot that were processed so far
      */
-    public int getProcessedFiles() {
-        return processedFiles;
+    public int getProcessedFileCount() {
+        return processedFileCount;
+    }
+
+    /**
+     * Return incremental files size of the snapshot
+     */
+    public long getIncrementalSize() {
+        return incrementalSize;
     }
 
     /**
@@ -105,29 +126,45 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeVLong(startTime);
         out.writeVLong(time);
 
-        out.writeVInt(numberOfFiles);
-        out.writeVInt(processedFiles);
+        out.writeVInt(totalFileCount);
+        out.writeVInt(processedFileCount);
 
         out.writeVLong(totalSize);
         out.writeVLong(processedSize);
+
+        if (out.getVersion().onOrAfter(Version.V_7_0_0_alpha1)) {
+            out.writeVInt(incrementalFileCount);
+            out.writeVLong(incrementalSize);
+        }
     }
 
     @Override
     public void readFrom(StreamInput in) throws IOException {
         startTime = in.readVLong();
         time = in.readVLong();
 
-        numberOfFiles = in.readVInt();
-        processedFiles = in.readVInt();
+        totalFileCount = in.readVInt();
+        processedFileCount = in.readVInt();
 
         totalSize = in.readVLong();
         processedSize = in.readVLong();
+
+        if (in.getVersion().onOrAfter(Version.V_7_0_0_alpha1)) {
+            incrementalFileCount = in.readVInt();
+            incrementalSize = in.readVLong();
+        } else {
+            incrementalFileCount = totalFileCount;
+            incrementalSize = totalSize;
+        }
     }
 
     static final class Fields {
         static final String STATS = "stats";
-        static final String NUMBER_OF_FILES = "number_of_files";
-        static final String PROCESSED_FILES = "processed_files";
+        static final String INCREMENTAL_FILE_COUNT = "incremental_file_count";
+        static final String TOTAL_FILE_COUNT = "total_file_count";
+        static final String PROCESSED_FILE_COUNT = "processed_file_count";
+        static final String INCREMENTAL_SIZE_IN_BYTES = "incremental_size_in_bytes";
+        static final String INCREMENTAL_SIZE = "incremental_size";
         static final String TOTAL_SIZE_IN_BYTES = "total_size_in_bytes";
         static final String TOTAL_SIZE = "total_size";
         static final String PROCESSED_SIZE_IN_BYTES = "processed_size_in_bytes";
@@ -140,8 +177,10 @@ static final class Fields {
     @Override
     public XContentBuilder toXContent(XContentBuilder builder, ToXContent.Params params) throws IOException {
         builder.startObject(Fields.STATS);
-        builder.field(Fields.NUMBER_OF_FILES, getNumberOfFiles());
-        builder.field(Fields.PROCESSED_FILES, getProcessedFiles());
+        builder.field(Fields.INCREMENTAL_FILE_COUNT, getIncrementalFileCount());
+        builder.field(Fields.TOTAL_FILE_COUNT, getTotalFileCount());
+        builder.field(Fields.PROCESSED_FILE_COUNT, getProcessedFileCount());
+        builder.humanReadableField(Fields.INCREMENTAL_SIZE_IN_BYTES, Fields.INCREMENTAL_SIZE, new ByteSizeValue(getIncrementalSize()));
         builder.humanReadableField(Fields.TOTAL_SIZE_IN_BYTES, Fields.TOTAL_SIZE, new ByteSizeValue(getTotalSize()));
         builder.humanReadableField(Fields.PROCESSED_SIZE_IN_BYTES, Fields.PROCESSED_SIZE, new ByteSizeValue(getProcessedSize()));
         builder.field(Fields.START_TIME_IN_MILLIS, getStartTime());
@@ -151,13 +190,14 @@ public XContentBuilder toXContent(XContentBuilder builder, ToXContent.Params par
     }
 
     void add(SnapshotStats stats) {
-        numberOfFiles += stats.numberOfFiles;
-        processedFiles += stats.processedFiles;
+        incrementalFileCount += stats.incrementalFileCount;
+        totalFileCount += stats.totalFileCount;
+        processedFileCount += stats.processedFileCount;
 
+        incrementalSize += stats.incrementalSize;
         totalSize += stats.totalSize;
         processedSize += stats.processedSize;
 
-
         if (startTime == 0) {
             // First time here
             startTime = stats.startTime;

server/src/main/java/org/elasticsearch/index/snapshots/IndexShardSnapshotStatus.java

@@ -60,31 +60,39 @@ public enum Stage {
     private final AtomicReference<Stage> stage;
     private long startTime;
     private long totalTime;
-    private int numberOfFiles;
-    private int processedFiles;
+    private int incrementalFileCount;
+    private int totalFileCount;
+    private int processedFileCount;
     private long totalSize;
+    private long incrementalSize;
     private long processedSize;
     private long indexVersion;
     private String failure;
 
     private IndexShardSnapshotStatus(final Stage stage, final long startTime, final long totalTime,
-                                     final int numberOfFiles, final int processedFiles, final long totalSize, final long processedSize,
+                                     final int incrementalFileCount, final int totalFileCount, final int processedFileCount,
+                                     final long incrementalSize, final long totalSize, final long processedSize,
                                      final long indexVersion, final String failure) {
         this.stage = new AtomicReference<>(Objects.requireNonNull(stage));
         this.startTime = startTime;
         this.totalTime = totalTime;
-        this.numberOfFiles = numberOfFiles;
-        this.processedFiles = processedFiles;
+        this.incrementalFileCount = incrementalFileCount;
+        this.totalFileCount = totalFileCount;
+        this.processedFileCount = processedFileCount;
         this.totalSize = totalSize;
         this.processedSize = processedSize;
+        this.incrementalSize = incrementalSize;
         this.indexVersion = indexVersion;
         this.failure = failure;
     }
 
-    public synchronized Copy moveToStarted(final long startTime, final int numberOfFiles, final long totalSize) {
+    public synchronized Copy moveToStarted(final long startTime, final int incrementalFileCount, final int totalFileCount,
+                                           final long incrementalSize, final long totalSize) {
         if (stage.compareAndSet(Stage.INIT, Stage.STARTED)) {
             this.startTime = startTime;
-            this.numberOfFiles = numberOfFiles;
+            this.incrementalFileCount = incrementalFileCount;
+            this.totalFileCount = totalFileCount;
+            this.incrementalSize = incrementalSize;
             this.totalSize = totalSize;
         } else {
             throw new IllegalStateException("Unable to move the shard snapshot status to [STARTED]: " +
@@ -135,7 +143,7 @@ public boolean isAborted() {
      * Increments number of processed files
      */
     public synchronized void addProcessedFile(long size) {
-        processedFiles++;
+        processedFileCount++;
         processedSize += size;
     }
 
@@ -146,25 +154,30 @@ public synchronized void addProcessedFile(long size) {
      * @return a  {@link IndexShardSnapshotStatus.Copy}
      */
     public synchronized IndexShardSnapshotStatus.Copy asCopy() {
-        return new IndexShardSnapshotStatus.Copy(stage.get(), startTime, totalTime, numberOfFiles, processedFiles, totalSize, processedSize,
-                                                 indexVersion, failure);
+        return new IndexShardSnapshotStatus.Copy(stage.get(), startTime, totalTime,
+            incrementalFileCount, totalFileCount, processedFileCount,
+            incrementalSize, totalSize, processedSize,
+            indexVersion, failure);
     }
 
     public static IndexShardSnapshotStatus newInitializing() {
-        return new IndexShardSnapshotStatus(Stage.INIT, 0L, 0L, 0, 0, 0, 0, 0, null);
+        return new IndexShardSnapshotStatus(Stage.INIT, 0L, 0L, 0, 0, 0, 0, 0, 0, 0, null);
     }
 
     public static IndexShardSnapshotStatus newFailed(final String failure) {
         assert failure != null : "expecting non null failure for a failed IndexShardSnapshotStatus";
         if (failure == null) {
             throw new IllegalArgumentException("A failure description is required for a failed IndexShardSnapshotStatus");
         }
-        return new IndexShardSnapshotStatus(Stage.FAILURE, 0L, 0L, 0, 0, 0, 0, 0, failure);
+        return new IndexShardSnapshotStatus(Stage.FAILURE, 0L, 0L, 0, 0, 0, 0, 0, 0, 0, failure);
     }
 
-    public static IndexShardSnapshotStatus newDone(final long startTime, final long totalTime, final int files, final long size) {
+    public static IndexShardSnapshotStatus newDone(final long startTime, final long totalTime,
+                                                   final int incrementalFileCount, final int fileCount,
+                                                   final long incrementalSize, final long size) {
         // The snapshot is done which means the number of processed files is the same as total
-        return new IndexShardSnapshotStatus(Stage.DONE, startTime, totalTime, files, files, size, size, 0, null);
+        return new IndexShardSnapshotStatus(Stage.DONE, startTime, totalTime, incrementalFileCount, fileCount, incrementalFileCount,
+            incrementalSize, size, incrementalSize, 0, null);
     }
 
     /**
@@ -175,23 +188,28 @@ public static class Copy {
         private final Stage stage;
         private final long startTime;
         private final long totalTime;
-        private final int numberOfFiles;
-        private final int processedFiles;
+        private final int incrementalFileCount;
+        private final int totalFileCount;
+        private final int processedFileCount;
         private final long totalSize;
         private final long processedSize;
+        private final long incrementalSize;
         private final long indexVersion;
         private final String failure;
 
         public Copy(final Stage stage, final long startTime, final long totalTime,
-                    final int numberOfFiles, final int processedFiles, final long totalSize, final long processedSize,
+                    final int incrementalFileCount, final int totalFileCount, final int processedFileCount,
+                    final long incrementalSize, final long totalSize, final long processedSize,
                     final long indexVersion, final String failure) {
             this.stage = stage;
             this.startTime = startTime;
             this.totalTime = totalTime;
-            this.numberOfFiles = numberOfFiles;
-            this.processedFiles = processedFiles;
+            this.incrementalFileCount = incrementalFileCount;
+            this.totalFileCount = totalFileCount;
+            this.processedFileCount = processedFileCount;
             this.totalSize = totalSize;
             this.processedSize = processedSize;
+            this.incrementalSize = incrementalSize;
             this.indexVersion = indexVersion;
             this.failure = failure;
         }
@@ -208,12 +226,20 @@ public long getTotalTime() {
             return totalTime;
         }
 
-        public int getNumberOfFiles() {
-            return numberOfFiles;
+        public int getIncrementalFileCount() {
+            return incrementalFileCount;
         }
 
-        public int getProcessedFiles() {
-            return processedFiles;
+        public int getTotalFileCount() {
+            return totalFileCount;
+        }
+
+        public int getProcessedFileCount() {
+            return processedFileCount;
+        }
+
+        public long getIncrementalSize() {
+            return incrementalSize;
         }
 
         public long getTotalSize() {
@@ -238,8 +264,10 @@ public String toString() {
                 "stage=" + stage +
                 ", startTime=" + startTime +
                 ", totalTime=" + totalTime +
-                ", numberOfFiles=" + numberOfFiles +
-                ", processedFiles=" + processedFiles +
+                ", incrementalFileCount=" + incrementalFileCount +
+                ", totalFileCount=" + totalFileCount +
+                ", processedFileCount=" + processedFileCount +
+                ", incrementalSize=" + incrementalSize +
                 ", totalSize=" + totalSize +
                 ", processedSize=" + processedSize +
                 ", indexVersion=" + indexVersion +