Nice automatic updates up to a point, then renice if necessary.

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 96 matching lines @@
   if (type == FilesystemCopierAction::StaticType())
     return kActionCodeFilesystemCopierError;
   if (type == PostinstallRunnerAction::StaticType())
     return kActionCodePostinstallRunnerError;
   if (type == SetBootableFlagAction::StaticType())
     return kActionCodeSetBootableFlagError;
 
   return code;
 }
 
+UpdateAttempter::UpdateAttempter(PrefsInterface* prefs,
+                                 MetricsLibraryInterface* metrics_lib)
+    : dbus_service_(NULL),
+      prefs_(prefs),
+      metrics_lib_(metrics_lib),
+      priority_(utils::kProcessPriorityNormal),
+      manage_priority_source_(NULL),
+      status_(UPDATE_STATUS_IDLE),
+      download_progress_(0.0),
+      last_checked_time_(0),
+      new_version_("0.0.0.0"),
+      new_size_(0) {
+  last_notify_time_.tv_sec = 0;
+  last_notify_time_.tv_nsec = 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;
@@ skipping 108 matching lines @@
   return true;
 }
 
 // Delegate methods:
 void UpdateAttempter::ProcessingDone(const ActionProcessor* processor,
                                      ActionExitCode code) {
   CHECK(response_handler_action_);
   LOG(INFO) << "Processing Done.";
   actions_.clear();
 
+  // Reset process priority back to normal.
+  CleanupPriorityManagement();
+
   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
     return;
   }
 
   LOG(INFO) << "Update failed.";
   if (ScheduleErrorEventAction())
     return;
   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,
@@ skipping 12 matching lines @@
   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";
     new_size_ = plan.size;
+    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.
   NOTIMPLEMENTED();
@@ skipping 83 matching lines @@
                              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::SetPriority(utils::ProcessPriority priority) {
+  if (priority_ == priority) {
+    return;
+  }
+  if (utils::SetProcessPriority(priority)) {
+    priority_ = priority;
+    LOG(INFO) << "Process priority = " << priority_;
+  }
+}
+
+void UpdateAttempter::SetupPriorityManagement() {
+  if (manage_priority_source_) {
+    LOG(ERROR) << "Process priority timeout source hasn't been destroyed.";
+    CleanupPriorityManagement();
+  }
+  const int kPriorityTimeout = 10 * 60;  // 10 minutes
+  manage_priority_source_ = g_timeout_source_new_seconds(kPriorityTimeout);
+  g_source_set_callback(manage_priority_source_,
+                        StaticManagePriorityCallback,
+                        this,
+                        NULL);
+  g_source_attach(manage_priority_source_, NULL);
+  SetPriority(utils::kProcessPriorityLow);
+}
+
+void UpdateAttempter::CleanupPriorityManagement() {
+  if (manage_priority_source_) {
+    g_source_destroy(manage_priority_source_);
+    manage_priority_source_ = NULL;
+  }
+  SetPriority(utils::kProcessPriorityNormal);
+}
+
+gboolean UpdateAttempter::StaticManagePriorityCallback(gpointer data) {
+  return reinterpret_cast<UpdateAttempter*>(data)->ManagePriorityCallback();
+}
+
+bool UpdateAttempter::ManagePriorityCallback() {
+  // If the current process priority is below normal, set it to normal
+  // and let GLib invoke this callback again.
+  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;
+}
+
 }  // namespace chromeos_update_engine