AU: Implement exponential back off for 500 and 503 HTTP response codes.

update_attempter.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/update_attempter.h"
 
 // From 'man clock_gettime': feature test macro: _POSIX_C_SOURCE >= 199309L
 #ifndef _POSIX_C_SOURCE
 #define _POSIX_C_SOURCE 199309L
 #endif  // _POSIX_C_SOURCE
 #include <time.h>
 
 #include <tr1/memory>
 #include <string>
 #include <vector>
 
 #include <glib.h>
+#include <metrics/metrics_library.h>
 
-#include "metrics/metrics_library.h"
 #include "update_engine/dbus_service.h"
 #include "update_engine/download_action.h"
 #include "update_engine/filesystem_copier_action.h"
 #include "update_engine/libcurl_http_fetcher.h"
 #include "update_engine/omaha_request_action.h"
 #include "update_engine/omaha_request_params.h"
 #include "update_engine/omaha_response_handler_action.h"
 #include "update_engine/postinstall_runner_action.h"
 #include "update_engine/set_bootable_flag_action.h"
+#include "update_engine/update_check_scheduler.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 using std::tr1::shared_ptr;
 using std::string;
 using std::vector;
 
 namespace chromeos_update_engine {
 
-namespace {
-
-const int kTimeoutOnce = 7 * 60;  // at 7 minutes
-const int kTimeoutPeriodic = 45 * 60;  // every 45 minutes
-const int kTimeoutFuzz = 10 * 60;  // +/- 5 minutes
-
-gboolean CheckForUpdatePeriodically(void* arg) {
-  UpdateAttempter* update_attempter = reinterpret_cast<UpdateAttempter*>(arg);
-  update_attempter->Update("", "");
-  update_attempter->SchedulePeriodicUpdateCheck(kTimeoutPeriodic);
-  return FALSE;  // Don't run again.
-}
-
-}  // namespace {}
-
 const char* kUpdateCompletedMarker = "/tmp/update_engine_autoupdate_completed";
 
 const char* UpdateStatusToString(UpdateStatus status) {
   switch (status) {
     case UPDATE_STATUS_IDLE:
       return "UPDATE_STATUS_IDLE";
     case UPDATE_STATUS_CHECKING_FOR_UPDATE:
       return "UPDATE_STATUS_CHECKING_FOR_UPDATE";
     case UPDATE_STATUS_UPDATE_AVAILABLE:
       return "UPDATE_STATUS_UPDATE_AVAILABLE";
@@ skipping 34 matching lines @@
     return kActionCodeSetBootableFlagError;
 
   return code;
 }
 
 UpdateAttempter::UpdateAttempter(PrefsInterface* prefs,
                                  MetricsLibraryInterface* metrics_lib)
     : dbus_service_(NULL),
       prefs_(prefs),
       metrics_lib_(metrics_lib),
+      update_check_scheduler_(NULL),
+      http_response_code_(0),
       priority_(utils::kProcessPriorityNormal),
       manage_priority_source_(NULL),
       download_active_(false),
       status_(UPDATE_STATUS_IDLE),
       download_progress_(0.0),
       last_checked_time_(0),
       new_version_("0.0.0.0"),
       new_size_(0) {
   if (utils::FileExists(kUpdateCompletedMarker))
     status_ = UPDATE_STATUS_UPDATED_NEED_REBOOT;
 }
 
 UpdateAttempter::~UpdateAttempter() {
   CleanupPriorityManagement();
 }
 
 void UpdateAttempter::Update(const std::string& app_version,
                              const std::string& omaha_url) {
   if (status_ == UPDATE_STATUS_UPDATED_NEED_REBOOT) {
     LOG(INFO) << "Not updating b/c we already updated and we're waiting for "
               << "reboot";
     return;
   }
   if (status_ != UPDATE_STATUS_IDLE) {
     // Update in progress. Do nothing
     return;
   }
+  http_response_code_ = 0;
   if (!omaha_request_params_.Init(app_version, omaha_url)) {
     LOG(ERROR) << "Unable to initialize Omaha request device params.";
     return;
   }
   CHECK(!processor_.IsRunning());
   processor_.set_delegate(this);
 
   // Actions:
   shared_ptr<OmahaRequestAction> update_check_action(
       new OmahaRequestAction(prefs_,
@@ skipping 120 matching lines @@
     // Report the time it took to update the system.
     int64_t update_time = time(NULL) - last_checked_time_;
     metrics_lib_->SendToUMA("Installer.UpdateTime",
                             static_cast<int>(update_time),  // sample
                             1,  // min = 1 second
                             20 * 60,  // max = 20 minutes
                             50);  // buckets
     return;
   }
 
-  LOG(INFO) << "Update failed.";
-  if (ScheduleErrorEventAction())
+  if (ScheduleErrorEventAction()) {
     return;
+  }
+  LOG(INFO) << "No update.";
   SetStatusAndNotify(UPDATE_STATUS_IDLE);
 }
 
 void UpdateAttempter::ProcessingStopped(const ActionProcessor* processor) {
   // Reset process priority back to normal.
   CleanupPriorityManagement();
   download_progress_ = 0.0;
   SetStatusAndNotify(UPDATE_STATUS_IDLE);
   actions_.clear();
   error_event_.reset(NULL);
 }
 
 // Called whenever an action has finished processing, either successfully
 // or otherwise.
 void UpdateAttempter::ActionCompleted(ActionProcessor* processor,
                                       AbstractAction* action,
                                       ActionExitCode code) {
-  // Reset download progress regardless of whether or not the download action
-  // succeeded.
+  // Reset download progress regardless of whether or not the download
+  // action succeeded. Also, get the response code from HTTP request
+  // actions (update download as well as the initial update check
+  // actions).
   const string type = action->Type();
-  if (type == DownloadAction::StaticType())
+  if (type == DownloadAction::StaticType()) {
     download_progress_ = 0.0;
+    DownloadAction* download_action = dynamic_cast<DownloadAction*>(action);
+    http_response_code_ = download_action->GetHTTPResponseCode();
+  } else if (type == OmahaRequestAction::StaticType()) {
+    OmahaRequestAction* omaha_request_action =
+        dynamic_cast<OmahaRequestAction*>(action);
+    // If the request is not an event, then it's the update-check.
+    if (!omaha_request_action->IsEvent()) {
+      http_response_code_ = omaha_request_action->GetHTTPResponseCode();
+    }
+  }
   if (code != kActionCodeSuccess) {
     // On failure, schedule an error event to be sent to Omaha.
     CreatePendingErrorEvent(action, code);
     return;
   }
   // Find out which action completed.
   if (type == OmahaResponseHandlerAction::StaticType()) {
     // Note that the status will be updated to DOWNLOADING when some
     // bytes get actually downloaded from the server and the
     // BytesReceived callback is invoked. This avoids notifying the
@@ skipping 58 matching lines @@
   *last_checked_time = last_checked_time_;
   *progress = download_progress_;
   *current_operation = UpdateStatusToString(status_);
   *new_version = new_version_;
   *new_size = new_size_;
   return true;
 }
 
 void UpdateAttempter::SetStatusAndNotify(UpdateStatus status) {
   status_ = status;
+  if (update_check_scheduler_) {
+    update_check_scheduler_->SetUpdateStatus(status_);
+  }
   if (!dbus_service_)
     return;
   last_notify_time_ = TimeTicks::Now();
   update_engine_service_emit_status_update(
       dbus_service_,
       last_checked_time_,
       download_progress_,
       UpdateStatusToString(status_),
       new_version_.c_str(),
       new_size_);
@@ skipping 20 matching lines @@
   code = GetErrorCodeForAction(action, code);
   error_event_.reset(new OmahaEvent(OmahaEvent::kTypeUpdateComplete,
                                     OmahaEvent::kResultError,
                                     code));
 }
 
 bool UpdateAttempter::ScheduleErrorEventAction() {
   if (error_event_.get() == NULL)
     return false;
 
+  LOG(INFO) << "Update failed -- reporting the error event.";
   shared_ptr<OmahaRequestAction> error_event_action(
       new OmahaRequestAction(prefs_,
                              omaha_request_params_,
                              error_event_.release(),  // Pass ownership.
                              new LibcurlHttpFetcher));
   actions_.push_back(shared_ptr<AbstractAction>(error_event_action));
   processor_.EnqueueAction(error_event_action.get());
   SetStatusAndNotify(UPDATE_STATUS_REPORTING_ERROR_EVENT);
   processor_.StartProcessing();
   return true;
 }
 
-void UpdateAttempter::InitiatePeriodicUpdateChecks() {
-  if (!utils::IsOfficialBuild()) {
-    LOG(WARNING) << "Non-official build: periodic update checks disabled.";
-    return;
-  }
-  if (utils::IsRemovableDevice(utils::RootDevice(utils::BootDevice()))) {
-    LOG(WARNING) << "Removable device boot: periodic update checks disabled.";
-    return;
-  }
-  // Kick off periodic update checks. The first check is scheduled
-  // |kTimeoutOnce| seconds from now. Subsequent checks are scheduled
-  // at |kTimeoutPeriodic|-second intervals.
-  SchedulePeriodicUpdateCheck(kTimeoutOnce);
-}
-
-void UpdateAttempter::SchedulePeriodicUpdateCheck(int seconds) {
-  seconds = utils::FuzzInt(seconds, kTimeoutFuzz);
-  g_timeout_add_seconds(seconds, CheckForUpdatePeriodically, this);
-  LOG(INFO) << "Next update check in " << seconds << " seconds.";
-}
-
 void UpdateAttempter::SetPriority(utils::ProcessPriority priority) {
   if (priority_ == priority) {
     return;
   }
   if (utils::SetProcessPriority(priority)) {
     priority_ = priority;
     LOG(INFO) << "Process priority = " << priority_;
   }
 }
 
@@ skipping 31 matching lines @@
     SetPriority(utils::kProcessPriorityNormal);
     return true;
   }
   // Set the priority to high and let GLib destroy the timeout source.
   SetPriority(utils::kProcessPriorityHigh);
   manage_priority_source_ = NULL;
   return false;
 }
 
 }  // namespace chromeos_update_engine