AU: fix report generation to handle invalid nodes and final rootfs op

delta_diff_generator.cc

 // Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "update_engine/delta_diff_generator.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <inttypes.h>
 #include <sys/stat.h>
@@ skipping 242 matching lines @@
 // In the future we might consider intelligent diffing between this data
 // and data in the previous image, but for now we just bzip2 compress it
 // and include it in the update.
 // Creates a new node in the graph to write these blocks and writes the
 // appropriate blob to blobs_fd. Reads and updates blobs_length;
 bool ReadUnwrittenBlocks(const vector<Block>& blocks,
                          int blobs_fd,
                          off_t* blobs_length,
                          const string& image_path,
                          Vertex* vertex) {
+  vertex->file_name = "<rootfs-non-file-data>";
+
   DeltaArchiveManifest_InstallOperation* out_op = &vertex->op;
   int image_fd = open(image_path.c_str(), O_RDONLY, 000);
   TEST_AND_RETURN_FALSE_ERRNO(image_fd >= 0);
   ScopedFdCloser image_fd_closer(&image_fd);
 
   string temp_file_path;
   TEST_AND_RETURN_FALSE(utils::MakeTempFile("/tmp/CrAU_temp_data.XXXXXX",
                                             &temp_file_path,
                                             NULL));
 
@@ skipping 188 matching lines @@
   "BSDIFF"
 };
 
 void ReportPayloadUsage(const Graph& graph,
                         const DeltaArchiveManifest& manifest) {
   vector<DeltaObject> objects;
   off_t total_size = 0;
 
   // Graph nodes with information about file names.
   for (Vertex::Index node = 0; node < graph.size(); node++) {
-    objects.push_back(DeltaObject(graph[node].file_name,
-                                  graph[node].op.type(),
-                                  graph[node].op.data_length()));
-    total_size += graph[node].op.data_length();
+    const Vertex& vertex = graph[node];
+    if (!vertex.valid) {
+      continue;
+    }
+    objects.push_back(DeltaObject(vertex.file_name,
+                                  vertex.op.type(),
+                                  vertex.op.data_length()));
+    total_size += vertex.op.data_length();
   }
 
-  // Final rootfs operation writing non-file-data.
-  const DeltaArchiveManifest_InstallOperation& final_op =
-      manifest.install_operations(manifest.install_operations_size() - 1);
-  objects.push_back(DeltaObject("<rootfs-final-operation>",
-                                final_op.type(),
-                                final_op.data_length()));
-  total_size += final_op.data_length();
-
   // Kernel install operations.
   for (int i = 0; i < manifest.kernel_install_operations_size(); ++i) {
     const DeltaArchiveManifest_InstallOperation& op =
         manifest.kernel_install_operations(i);
     objects.push_back(DeltaObject(StringPrintf("<kernel-operation-%d>", i),
                                   op.type(),
                                   op.data_length()));
     total_size += op.data_length();
   }
 
@@ skipping 991 matching lines @@
 
   LOG(INFO) << "All done. Successfully created delta file.";
   return true;
 }
 
 const char* const kBsdiffPath = "/usr/bin/bsdiff";
 const char* const kBspatchPath = "/usr/bin/bspatch";
 const char* const kDeltaMagic = "CrAU";
 
 };  // namespace chromeos_update_engine