AU: fix new style full updates

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 1203 matching lines @@
 
       TEST_AND_RETURN_FALSE(BzipCompress(buf, &buf_compressed));
       const bool compress = buf_compressed.size() < buf.size();
       const vector<char>& use_buf = compress ? buf_compressed : buf;
       if (compress) {
         op->set_type(DeltaArchiveManifest_InstallOperation_Type_REPLACE_BZ);
       } else {
         op->set_type(DeltaArchiveManifest_InstallOperation_Type_REPLACE);
       }
       op->set_data_offset(*data_file_size);
+      TEST_AND_RETURN_FALSE(utils::WriteAll(fd, &use_buf[0], use_buf.size()));
       *data_file_size += use_buf.size();
       op->set_data_length(use_buf.size());
       Extent* dst_extent = op->add_dst_extents();
       dst_extent->set_start_block(offset / kBlockSize);
       dst_extent->set_num_blocks(chunk_size / kBlockSize);
     }
   }
 
   return true;
 }
@@ skipping 40 matching lines @@
 
   const string kTempFileTemplate("/tmp/CrAU_temp_data.XXXXXX");
   string temp_file_path;
   off_t data_file_size = 0;
 
   LOG(INFO) << "Reading files...";
 
   vector<DeltaArchiveManifest_InstallOperation> kernel_ops;
 
   vector<Vertex::Index> final_order;
-  if (!old_image.empty()) {
-    // Delta update
+  {
     int fd;
     TEST_AND_RETURN_FALSE(
         utils::MakeTempFile(kTempFileTemplate, &temp_file_path, &fd));
     TEST_AND_RETURN_FALSE(fd >= 0);
     ScopedFdCloser fd_closer(&fd);
+    if (!old_image.empty()) {
+      // Delta update
 
-    TEST_AND_RETURN_FALSE(DeltaReadFiles(&graph,
-                                         &blocks,
-                                         old_root,
-                                         new_root,
-                                         fd,
-                                         &data_file_size));
-    LOG(INFO) << "done reading normal files";
-    CheckGraph(graph);
+      TEST_AND_RETURN_FALSE(DeltaReadFiles(&graph,
+                                           &blocks,
+                                           old_root,
+                                           new_root,
+                                           fd,
+                                           &data_file_size));
+      LOG(INFO) << "done reading normal files";
+      CheckGraph(graph);
 
-    graph.resize(graph.size() + 1);
-    TEST_AND_RETURN_FALSE(ReadUnwrittenBlocks(blocks,
+      graph.resize(graph.size() + 1);
+      TEST_AND_RETURN_FALSE(ReadUnwrittenBlocks(blocks,
+                                                fd,
+                                                &data_file_size,
+                                                new_image,
+                                                &graph.back()));
+
+      // Read kernel partition
+      TEST_AND_RETURN_FALSE(DeltaCompressKernelPartition(old_kernel_part,
+                                                         new_kernel_part,
+                                                         &kernel_ops,
+                                                         fd,
+                                                         &data_file_size));
+
+      LOG(INFO) << "done reading kernel";
+      CheckGraph(graph);
+
+      LOG(INFO) << "Creating edges...";
+      CreateEdges(&graph, blocks);
+      LOG(INFO) << "Done creating edges";
+      CheckGraph(graph);
+
+      TEST_AND_RETURN_FALSE(ConvertGraphToDag(&graph,
+                                              new_root,
                                               fd,
                                               &data_file_size,
-                                              new_image,
-                                              &graph.back()));
-
-    // Read kernel partition
-    TEST_AND_RETURN_FALSE(DeltaCompressKernelPartition(old_kernel_part,
-                                                       new_kernel_part,
-                                                       &kernel_ops,
-                                                       fd,
-                                                       &data_file_size));
-
-    LOG(INFO) << "done reading kernel";
-    CheckGraph(graph);
-
-    LOG(INFO) << "Creating edges...";
-    CreateEdges(&graph, blocks);
-    LOG(INFO) << "Done creating edges";
-    CheckGraph(graph);
-
-    TEST_AND_RETURN_FALSE(ConvertGraphToDag(&graph,
-                                            new_root,
-                                            fd,
-                                            &data_file_size,
-                                            &final_order));
-  } else {
-    // Full update
-    int fd = 0;
-    TEST_AND_RETURN_FALSE(ReadFullUpdateFromDisk(&graph,
-                                                 new_kernel_part,
-                                                 new_image,
-                                                 fd,
-                                                 &data_file_size,
-                                                 kFullUpdateChunkSize,
-                                                 &kernel_ops,
-                                                 &final_order));
+                                              &final_order));
+    } else {
+      // Full update
+      TEST_AND_RETURN_FALSE(ReadFullUpdateFromDisk(&graph,
+                                                   new_kernel_part,
+                                                   new_image,
+                                                   fd,
+                                                   &data_file_size,
+                                                   kFullUpdateChunkSize,
+                                                   &kernel_ops,
+                                                   &final_order));
+    }
   }
 
   // Convert to protobuf Manifest object
   DeltaArchiveManifest manifest;
   CheckGraph(graph);
   InstallOperationsToManifest(graph, final_order, kernel_ops, &manifest);
 
   CheckGraph(graph);
   manifest.set_block_size(kBlockSize);
 
@@ skipping 126 matching lines @@
     LOG(INFO) << "Signing the update...";
     vector<char> signature_blob;
     TEST_AND_RETURN_FALSE(PayloadSigner::SignPayload(output_path,
                                                      private_key_path,
                                                      &signature_blob));
     TEST_AND_RETURN_FALSE(writer.Write(&signature_blob[0],
                                        signature_blob.size()) ==
                           static_cast<ssize_t>(signature_blob.size()));
   }
 
+  LOG(INFO) << "final dump";
+  graph_utils::DumpGraph(graph);
   ReportPayloadUsage(graph, manifest);
 
   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