AU: A basic framework for sending error events when update attempt fails.

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
@@ skipping 65 matching lines @@
     case UPDATE_STATUS_UPDATE_AVAILABLE:
       return "UPDATE_STATUS_UPDATE_AVAILABLE";
     case UPDATE_STATUS_DOWNLOADING:
       return "UPDATE_STATUS_DOWNLOADING";
     case UPDATE_STATUS_VERIFYING:
       return "UPDATE_STATUS_VERIFYING";
     case UPDATE_STATUS_FINALIZING:
       return "UPDATE_STATUS_FINALIZING";
     case UPDATE_STATUS_UPDATED_NEED_REBOOT:
       return "UPDATE_STATUS_UPDATED_NEED_REBOOT";
+    case UPDATE_STATUS_REPORTING_ERROR_EVENT:
+      return "UPDATE_STATUS_REPORTING_ERROR_EVENT";
     default:
       return "unknown status";
   }
 }
 
 void UpdateAttempter::Update() {
   if (status_ == UPDATE_STATUS_UPDATED_NEED_REBOOT) {
     LOG(INFO) << "Not updating b/c we already updated and we're waiting for "
               << "reboot";
     return;
@@ skipping 96 matching lines @@
   }
   Update();
 }
 
 // Delegate methods:
 void UpdateAttempter::ProcessingDone(const ActionProcessor* processor,
                                      ActionExitCode code) {
   CHECK(response_handler_action_);
   LOG(INFO) << "Processing Done.";
   actions_.clear();
+
+  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);
 
     // 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
-  } else {
-    LOG(INFO) << "Update failed.";
-    SetStatusAndNotify(UPDATE_STATUS_IDLE);
+    return;
   }
+
+  LOG(INFO) << "Update failed.";
+  if (ScheduleErrorEventAction())
+    return;
+  SetStatusAndNotify(UPDATE_STATUS_IDLE);
 }
 
 void UpdateAttempter::ProcessingStopped(const ActionProcessor* processor) {
   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.
   const string type = action->Type();
   if (type == DownloadAction::StaticType())
     download_progress_ = 0.0;
-  if (code != kActionCodeSuccess)
+  if (code != kActionCodeSuccess) {
+    // On failure, schedule an error event to be sent to Omaha. For
+    // now assume that Omaha response action failure means that
+    // there's no update so don't send an event. Also, double check
+    // that the failure has not occurred while sending an error event
+    // -- in which case don't schedule another. This shouldn't really
+    // happen but just in case...
+    if (type != OmahaResponseHandlerAction::StaticType() &&
+        status_ != UPDATE_STATUS_REPORTING_ERROR_EVENT) {
+      CreatePendingErrorEvent(code);
+    }
     return;
+  }
   // Find out which action completed.
   if (type == OmahaResponseHandlerAction::StaticType()) {
     SetStatusAndNotify(UPDATE_STATUS_DOWNLOADING);
     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";
@@ skipping 54 matching lines @@
   GetCPUClockTime(&last_notify_time_);
   update_engine_service_emit_status_update(
       dbus_service_,
       last_checked_time_,
       download_progress_,
       UpdateStatusToString(status_),
       new_version_.c_str(),
       new_size_);
 }
 
+void UpdateAttempter::CreatePendingErrorEvent(ActionExitCode code) {
+  if (error_event_.get()) {
+    // This shouldn't really happen.
+    LOG(WARNING) << "There's already an existing pending error event.";
+    return;
+  }
+  error_event_.reset(new OmahaEvent(OmahaEvent::kTypeUpdateComplete,
+                                    OmahaEvent::kResultError,
+                                    code));
+}
+
+bool UpdateAttempter::ScheduleErrorEventAction() {
+  if (error_event_.get() == NULL)
+    return false;
+
+  shared_ptr<OmahaRequestAction> error_event_action(
+      new OmahaRequestAction(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;
+}
+
 }  // namespace chromeos_update_engine