AU: Class to perform delta updates.

src/platform/update_engine/utils.h

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CHROMEOS_PLATFORM_UPDATE_ENGINE_UTILS_H__
 #define CHROMEOS_PLATFORM_UPDATE_ENGINE_UTILS_H__
 
+#include <errno.h>
 #include <algorithm>
 #include <set>
 #include <string>
 #include <vector>
 #include "update_engine/action.h"
 #include "update_engine/action_processor.h"
 
 namespace chromeos_update_engine {
 
 namespace utils {
 
 // Writes the data passed to path. The file at path will be overwritten if it
 // exists. Returns true on success, false otherwise.
 bool WriteFile(const char* path, const char* data, int data_len);
 
-// Calls write() repeatedly until all count bytes at buf are written to
-// fd or an error occurs. Returns true on success.
-bool WriteAll(int fd, const void *buf, size_t count);
+// Calls write() or pwrite() repeatedly until all count bytes at buf are
+// written to fd or an error occurs. Returns true on success.
+bool WriteAll(int fd, const void* buf, size_t count);
+bool PWriteAll(int fd, const void* buf, size_t count, off_t offset);
+
+// Calls pread() repeatedly until count bytes are read, or EOF is reached.
+// Returns number of bytes read in *bytes_read. Returns true on success.
+bool PReadAll(int fd, void* buf, size_t count, off_t offset,
+              ssize_t* out_bytes_read);
 
 // Returns the entire contents of the file at path. Returns true on success.
 bool ReadFile(const std::string& path, std::vector<char>* out);
 bool ReadFileToString(const std::string& path, std::string* out);
 
 std::string ErrnoNumberAsString(int err);
 
 // Strips duplicate slashes, and optionally removes all trailing slashes.
 // Does not compact /./ or /../.
 std::string NormalizePath(const std::string& path, bool strip_trailing_slash);
@@ skipping 12 matching lines @@
 // Calls mkstemp() with the template passed. Returns the filename in the
 // out param filename. If fd is non-NULL, the file fd returned by mkstemp
 // is not close()d and is returned in the out param 'fd'. However, if
 // fd is NULL, the fd from mkstemp() will be closed.
 // The last six chars of the template must be XXXXXX.
 // Returns true on success.
 bool MakeTempFile(const std::string& filename_template,
                   std::string* filename,
                   int* fd);
 
+// Calls mkdtemp() with the tempate passed. Returns the generated dirname
+// in the dirname param. Returns TRUE on success. dirname must not be NULL.
+bool MakeTempDirectory(const std::string& dirname_template,
+                       std::string* dirname);
+
 // Deletes a directory and all its contents synchronously. Returns true
 // on success. This may be called with a regular file--it will just unlink it.
 // This WILL cross filesystem boundaries.
 bool RecursiveUnlinkDir(const std::string& path);
 
 // Synchronously mount or unmount a filesystem. Return true on success.
 // Mounts as ext3 with default options.
-bool MountFilesystem(const std::string& device, const std::string& mountpoint);
+bool MountFilesystem(const std::string& device, const std::string& mountpoint,
+                     unsigned long flags);
 bool UnmountFilesystem(const std::string& mountpoint);
 
 // Log a string in hex to LOG(INFO). Useful for debugging.
 void HexDumpArray(const unsigned char* const arr, const size_t length);
 inline void HexDumpString(const std::string& str) {
   HexDumpArray(reinterpret_cast<const unsigned char*>(str.data()), str.size());
 }
 inline void HexDumpVector(const std::vector<char>& vect) {
   HexDumpArray(reinterpret_cast<const unsigned char*>(&vect[0]), vect.size());
 }
@@ skipping 68 matching lines @@
     if (fd_ && (*fd_ >= 0)) {
       close(*fd_);
       *fd_ = -1;
     }
   }
  private:
   int* fd_;
   bool should_close_;
 };
 
+// Utility class to delete a file when it goes out of scope.
+class ScopedPathUnlinker {
+ public:
+  explicit ScopedPathUnlinker(const std::string& path) : path_(path) {}
+  ~ScopedPathUnlinker() {
+    if (unlink(path_.c_str()) < 0) {
+      std::string err_message = strerror(errno);
+      LOG(ERROR) << "Unable to unlink path " << path_ << ": " << err_message;
+    }
+  }
+ private:
+  const std::string path_;

[Daniel Erat, 2010/04/23 17:47:25]

DISALLOW_COPY_AND_ASSIGN

[adlr, 2010/04/23 20:50:17]

Done (for all in this file)

+};
+
+// Utility class to delete an empty directory when it goes out of scope.
+class ScopedDirRemover {
+ public:
+  explicit ScopedDirRemover(const std::string& path) : path_(path) {}
+  ~ScopedDirRemover() {
+    if (rmdir(path_.c_str()) < 0)
+      PLOG(ERROR) << "Unable to remove dir " << path_;
+  }
+ private:
+  const std::string path_;

[Daniel Erat, 2010/04/23 17:47:25]

DISALLOW_COPY_AND_ASSIGN

[adlr, 2010/04/23 20:50:17]

Done.

+};
+
 // A little object to call ActionComplete on the ActionProcessor when
 // it's destructed.
 class ScopedActionCompleter {
  public:
   explicit ScopedActionCompleter(ActionProcessor* processor,
                                  AbstractAction* action)
       : processor_(processor),
         action_(action),
         success_(false),
         should_complete_(true) {}
@@ skipping 53 matching lines @@
     bool _success = (_x);                                                      \
     if (!_success) {                                                           \
       LOG(ERROR) << #_x " failed.";                                            \
       return;                                                                  \
     }                                                                          \
   } while (0)
 
 
 
 #endif  // CHROMEOS_PLATFORM_UPDATE_ENGINE_UTILS_H__