AU: Timestamp logs at startup.

main.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 <string>
-#include <tr1/memory>
 #include <vector>
 
 #include <base/at_exit.h>
 #include <base/command_line.h>
+#include <base/file_util.h>
 #include <base/logging.h>
 #include <base/string_util.h>
 #include <gflags/gflags.h>
 #include <glib.h>
 #include <metrics/metrics_library.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 
 #include "update_engine/dbus_constants.h"
 #include "update_engine/dbus_service.h"
 #include "update_engine/prefs.h"
 #include "update_engine/subprocess.h"
 #include "update_engine/terminator.h"
 #include "update_engine/update_attempter.h"
 #include "update_engine/update_check_scheduler.h"
 
 extern "C" {
 #include "update_engine/update_engine.dbusserver.h"
 }
 
 DEFINE_bool(logtostderr, false,
             "Write logs to stderr instead of to a file in log_dir.");
 DEFINE_bool(foreground, false,
             "Don't daemon()ize; run in foreground.");
 
 using std::string;
-using std::tr1::shared_ptr;
 using std::vector;
 
 namespace chromeos_update_engine {
 
 gboolean UpdateBootFlags(void* arg) {
   UpdateAttempter* attempter = reinterpret_cast<UpdateAttempter*>(arg);
   if (attempter->status() == UPDATE_STATUS_UPDATED_NEED_REBOOT) {
     // Don't update the flags if there's an update that's just been applied and
     // we're waiting for reboot because we may end up reverting the update.
     return FALSE;  // Don't call this callback again.
@@ skipping 40 matching lines @@
     g_error_free(error);
     LOG(FATAL) << "Got result code " << request_name_ret
                << " from requesting name, but expected "
                << DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER;
   }
   dbus_g_connection_register_g_object(bus,
                                       "/org/chromium/UpdateEngine",
                                       G_OBJECT(service));
 }
 
+void SetupLogSymlink(const string& symlink_path, const string& log_path) {
+  // TODO(petkov): To ensure a smooth transition between non-timestamped and
+  // timestamped logs, move an existing log to start the first timestamped
+  // one. This code can go away once all clients are switched to this version or
+  // we stop caring about the old-style logs.
+  if (utils::FileExists(symlink_path.c_str()) &&
+      !utils::IsSymlink(symlink_path.c_str())) {
+    file_util::ReplaceFile(FilePath(symlink_path), FilePath(log_path));
+  }
+  file_util::Delete(FilePath(symlink_path), true);
+  if (symlink(log_path.c_str(), symlink_path.c_str()) == -1) {
+    PLOG(ERROR) << "Unable to create symlink " << symlink_path
+                << " pointing at " << log_path;
+  }
+}
+
+string GetTimeAsString(time_t utime) {
+  struct tm tm;
+  CHECK(localtime_r(&utime, &tm) == &tm);
+  char str[16];
+  CHECK(strftime(str, sizeof(str), "%Y%m%d-%H%M%S", &tm) == 15);
+  return str;
+}
+
+string SetupLogFile(const string& kLogsRoot) {
+  const string kLogSymlink = kLogsRoot + "/update_engine.log";
+  const string kLogsDir = kLogsRoot + "/update_engine";
+  const string kLogPath =
+      StringPrintf("%s/update_engine.%s",
+                   kLogsDir.c_str(),
+                   GetTimeAsString(::time(NULL)).c_str());
+  mkdir(kLogsDir.c_str(), 0755);
+  SetupLogSymlink(kLogSymlink, kLogPath);
+  return kLogSymlink;
+}
+
+void SetupLogging() {
+  // Log to stderr initially.
+  logging::InitLogging(NULL,
+                       logging::LOG_ONLY_TO_SYSTEM_DEBUG_LOG,
+                       logging::DONT_LOCK_LOG_FILE,
+                       logging::APPEND_TO_OLD_LOG_FILE);
+  if (FLAGS_logtostderr) {
+    return;
+  }
+  const string log_file = SetupLogFile("/var/log");
+  logging::InitLogging(log_file.c_str(),
+                       logging::LOG_ONLY_TO_FILE,
+                       logging::DONT_LOCK_LOG_FILE,
+                       logging::APPEND_TO_OLD_LOG_FILE);
+}
 }  // namespace {}
-
 }  // namespace chromeos_update_engine
 
-#include "update_engine/subprocess.h"
-
 int main(int argc, char** argv) {
   ::g_type_init();
   g_thread_init(NULL);
   dbus_g_thread_init();
   base::AtExitManager exit_manager;  // Required for base/rand_util.h.
   chromeos_update_engine::Terminator::Init();
   chromeos_update_engine::Subprocess::Init();
   google::ParseCommandLineFlags(&argc, &argv, true);
   CommandLine::Init(argc, argv);
-  logging::InitLogging("/var/log/update_engine.log",
-                       (FLAGS_logtostderr ?
-                        logging::LOG_ONLY_TO_SYSTEM_DEBUG_LOG :
-                        logging::LOG_ONLY_TO_FILE),
-                       logging::DONT_LOCK_LOG_FILE,
-                       logging::APPEND_TO_OLD_LOG_FILE);
+  chromeos_update_engine::SetupLogging();
   if (!FLAGS_foreground)
     PLOG_IF(FATAL, daemon(0, 0) == 1) << "daemon() failed";
 
   LOG(INFO) << "Chrome OS Update Engine starting";
 
   // Ensure that all written files have safe permissions.
   // This is a mask, so we _block_ execute for the owner, and ALL
   // permissions for other users.
   // Done _after_ log file creation.
   umask(S_IXUSR | S_IRWXG | S_IRWXO);
@@ skipping 34 matching lines @@
   g_main_loop_run(loop);
 
   // Cleanup:
   g_main_loop_unref(loop);
   update_attempter.set_dbus_service(NULL);
   g_object_unref(G_OBJECT(service));
 
   LOG(INFO) << "Chrome OS Update Engine terminating";
   return 0;
 }