AU: Fall back to full updates after a number of failed delta update attempts.

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 "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/prefs_interface.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 {
 
+const int UpdateAttempter::kMaxDeltaUpdateFailures = 3;
+
 const char* kUpdateCompletedMarker =
     "/var/run/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:
@@ skipping 45 matching lines @@
       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) {
+      new_size_(0),
+      is_full_update_(false) {
   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;
   }
+  DisableDeltaUpdateIfNeeded();
   CHECK(!processor_->IsRunning());
   processor_->set_delegate(this);
 
   // Actions:
   shared_ptr<OmahaRequestAction> update_check_action(
       new OmahaRequestAction(prefs_,
                              omaha_request_params_,
                              NULL,
                              new LibcurlHttpFetcher));
   shared_ptr<OmahaResponseHandlerAction> response_handler_action(
@@ skipping 105 matching lines @@
 
   if (status_ == UPDATE_STATUS_REPORTING_ERROR_EVENT) {
     LOG(INFO) << "Error event sent.";
     SetStatusAndNotify(UPDATE_STATUS_IDLE);
     return;
   }
 
   if (code == kActionCodeSuccess) {
     SetStatusAndNotify(UPDATE_STATUS_UPDATED_NEED_REBOOT);
     utils::WriteFile(kUpdateCompletedMarker, "", 0);
+    prefs_->SetInt64(kPrefsDeltaUpdateFailures, 0);
 
     // 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;
   }
@@ skipping 36 matching lines @@
       http_response_code_ = omaha_request_action->GetHTTPResponseCode();
       // Forward the server-dictated poll interval to the update check
       // scheduler, if any.
       if (update_check_scheduler_) {
         update_check_scheduler_->set_poll_interval(
             omaha_request_action->GetOutputObject().poll_interval);
       }
     }
   }
   if (code != kActionCodeSuccess) {
+    // If this was a delta update attempt and the current state is at or past
+    // the download phase, count the failure in case a switch to full update
+    // becomes necessary. Ignore network transfer timeouts and failures.
+    if (status_ >= UPDATE_STATUS_DOWNLOADING &&
+        !is_full_update_ &&
+        code != kActionCodeDownloadTransferError) {
+      MarkDeltaUpdateFailure();
+    }
     // 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
     // user that a download has started in cases when the server and
     // the client are unable to initiate the download.
     OmahaResponseHandlerAction* omaha_response_handler_action =
         dynamic_cast<OmahaResponseHandlerAction*>(action);
     CHECK(omaha_response_handler_action);
     const InstallPlan& plan = omaha_response_handler_action->install_plan();
     last_checked_time_ = time(NULL);
     // TODO(adlr): put version in InstallPlan
     new_version_ = "0.0.0.0";
     new_size_ = plan.size;
+    is_full_update_ = plan.is_full_update;
     SetupPriorityManagement();
   } else if (type == DownloadAction::StaticType()) {
     SetStatusAndNotify(UPDATE_STATUS_FINALIZING);
   }
 }
 
 // Stop updating. An attempt will be made to record status to the disk
 // so that updates can be resumed later.
 void UpdateAttempter::Terminate() {
   // TODO(adlr): implement this method.
@@ skipping 144 matching lines @@
   if (utils::ComparePriorities(priority_, utils::kProcessPriorityNormal) < 0) {
     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;
 }
 
+void UpdateAttempter::DisableDeltaUpdateIfNeeded() {
+  int64_t delta_failures;
+  if (omaha_request_params_.delta_okay &&
+      prefs_->GetInt64(kPrefsDeltaUpdateFailures, &delta_failures) &&
+      delta_failures >= kMaxDeltaUpdateFailures) {
+    LOG(WARNING) << "Too many delta update failures, forcing full update.";
+    omaha_request_params_.delta_okay = false;
+  }
+}
+
+void UpdateAttempter::MarkDeltaUpdateFailure() {
+  CHECK(!is_full_update_);
+  int64_t delta_failures;
+  if (!prefs_->GetInt64(kPrefsDeltaUpdateFailures, &delta_failures) ||
+      delta_failures < 0) {
+    delta_failures = 0;
+  }
+  prefs_->SetInt64(kPrefsDeltaUpdateFailures, ++delta_failures);
+}
+
 }  // namespace chromeos_update_engine