AU: Manual proxy support

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 <string>
 #include <tr1/memory>
 #include <vector>
 
+#include <base/rand_util.h>
 #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/multi_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/update_check_scheduler.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 using std::make_pair;
 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";
 
+namespace {
+const int kMaxConsecutiveObeyProxyRequests = 20;
+}  // namespace {}
+
 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";
     case UPDATE_STATUS_DOWNLOADING:
       return "UPDATE_STATUS_DOWNLOADING";
@@ skipping 26 matching lines @@
     return kActionCodeOmahaResponseHandlerError;
   if (type == FilesystemCopierAction::StaticType())
     return kActionCodeFilesystemCopierError;
   if (type == PostinstallRunnerAction::StaticType())
     return kActionCodePostinstallRunnerError;
 
   return code;
 }
 
 UpdateAttempter::UpdateAttempter(PrefsInterface* prefs,
-                                 MetricsLibraryInterface* metrics_lib)
+                                 MetricsLibraryInterface* metrics_lib,
+                                 DbusGlibInterface* dbus_iface)
     : processor_(new ActionProcessor()),
       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),
-      is_full_update_(false) {
+      is_full_update_(false),
+      proxy_manual_checks_(0),
+      obeying_proxies_(true),
+      chrome_proxy_resolver_(dbus_iface) {
   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) {
+                             const std::string& omaha_url,
+                             bool force_obey_proxies) {
   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;
   }
+  
+  obeying_proxies_ = true;
+  static const char message[] = "To help ensure updates work, this update "

[petkov, 2010/11/19 05:37:15]

Can you do one LOG_IF(INFO, obeying_proxies_) after the whole if-statement and
avoid this message variable?

[adlr, 2010/11/20 02:52:29]

Done.

+      "check we are ignoring the proxy settings and using "
+      "direct connections.";
+  if (force_obey_proxies) {

[petkov, 2010/11/19 05:37:15]

does it make sense to always obey proxies on the first update check, regardless
if it's manual or automatic? you could just add || proxy_manual_checks_ == 0
here if it makes sense... not sure though.

[adlr, 2010/11/20 02:52:29]

seems fine. added

+    LOG(INFO) << "forced to obey proxies";
+    // If forced to obey proxies, every 20th request will not use proxies
+    proxy_manual_checks_++;
+    LOG(INFO) << "proxy manual checks: " << proxy_manual_checks_;
+    if (proxy_manual_checks_ >= kMaxConsecutiveObeyProxyRequests) {
+      proxy_manual_checks_ = 0;
+      force_obey_proxies = false;

[petkov, 2010/11/19 05:37:15]

no need?

[adlr, 2010/11/20 02:52:29]

good call. removed

+      obeying_proxies_ = true;

[petkov, 2010/11/19 05:37:15]

do you mean obeying_proxies_ = false?

[adlr, 2010/11/20 02:52:29]

Done.

+      LOG(INFO) << message;
+    }
+  } else {
+    if (base::RandInt(0, 4) == 0) {
+      LOG(INFO) << message;
+      obeying_proxies_ = false;
+    } else {
+      LOG(INFO) << "using proxies";
+    }
+  }
+
   DisableDeltaUpdateIfNeeded();
   CHECK(!processor_->IsRunning());
   processor_->set_delegate(this);
 
   // Actions:
   shared_ptr<OmahaRequestAction> update_check_action(
       new OmahaRequestAction(prefs_,
                              omaha_request_params_,
                              NULL,
-                             new LibcurlHttpFetcher));
+                             new LibcurlHttpFetcher(GetProxyResolver())));
   shared_ptr<OmahaResponseHandlerAction> response_handler_action(
       new OmahaResponseHandlerAction(prefs_));
   shared_ptr<FilesystemCopierAction> filesystem_copier_action(
       new FilesystemCopierAction(false));
   shared_ptr<FilesystemCopierAction> kernel_filesystem_copier_action(
       new FilesystemCopierAction(true));
   shared_ptr<OmahaRequestAction> download_started_action(
       new OmahaRequestAction(prefs_,
                              omaha_request_params_,
                              new OmahaEvent(
                                  OmahaEvent::kTypeUpdateDownloadStarted),
-                             new LibcurlHttpFetcher));
+                             new LibcurlHttpFetcher(GetProxyResolver())));

[petkov, 2010/11/19 05:37:15]

You should probably always obey proxies for event actions.

[adlr, 2010/11/20 02:52:29]

The idea was we would be consistent for a given update cycle. GetProxyResolver()
will always return the same thing for a given cycle. I think that's better
behavior, but i'm open to suggestion if you think that should be changed...

[petkov, 2010/11/22 17:49:00]

Yes, makes sense. I missed the fact that the whole update cycle will use the
same resolver. Looks good as is.

   shared_ptr<DownloadAction> download_action(
-      new DownloadAction(prefs_, new MultiHttpFetcher<LibcurlHttpFetcher>));
+      new DownloadAction(prefs_, new MultiHttpFetcher<LibcurlHttpFetcher>(
+          GetProxyResolver())));
   shared_ptr<OmahaRequestAction> download_finished_action(
       new OmahaRequestAction(prefs_,
                              omaha_request_params_,
                              new OmahaEvent(
                                  OmahaEvent::kTypeUpdateDownloadFinished),
-                             new LibcurlHttpFetcher));
+                             new LibcurlHttpFetcher(GetProxyResolver())));
   shared_ptr<PostinstallRunnerAction> postinstall_runner_action(
       new PostinstallRunnerAction);
   shared_ptr<OmahaRequestAction> update_complete_action(
       new OmahaRequestAction(prefs_,
                              omaha_request_params_,
                              new OmahaEvent(OmahaEvent::kTypeUpdateComplete),
-                             new LibcurlHttpFetcher));
+                             new LibcurlHttpFetcher(GetProxyResolver())));
 
   download_action->set_delegate(this);
   response_handler_action_ = response_handler_action;
   download_action_ = download_action;
 
   actions_.push_back(shared_ptr<AbstractAction>(update_check_action));
   actions_.push_back(shared_ptr<AbstractAction>(response_handler_action));
   actions_.push_back(shared_ptr<AbstractAction>(filesystem_copier_action));
   actions_.push_back(shared_ptr<AbstractAction>(
       kernel_filesystem_copier_action));
@@ skipping 26 matching lines @@
   processor_->StartProcessing();
 }
 
 void UpdateAttempter::CheckForUpdate(const std::string& app_version,
                                      const std::string& omaha_url) {
   if (status_ != UPDATE_STATUS_IDLE) {
     LOG(INFO) << "Check for update requested, but status is "
               << UpdateStatusToString(status_) << ", so not checking.";
     return;
   }
-  Update(app_version, omaha_url);
+  Update(app_version, omaha_url, true);
 }
 
 bool UpdateAttempter::RebootIfNeeded() {
   if (status_ != UPDATE_STATUS_UPDATED_NEED_REBOOT) {
     LOG(INFO) << "Reboot requested, but status is "
               << UpdateStatusToString(status_) << ", so not rebooting.";
     return false;
   }
   TEST_AND_RETURN_FALSE(utils::Reboot());
   return true;
@@ skipping 202 matching lines @@
 
 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));
+                             new LibcurlHttpFetcher(GetProxyResolver())));
   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;
@@ skipping 78 matching lines @@
     if (resume_offset < response_handler_action_->install_plan().size) {
       ranges.push_back(make_pair(resume_offset, -1));
     }
   } else {
     ranges.push_back(make_pair(0, -1));
   }
   fetcher->set_ranges(ranges);
 }
 
 }  // namespace chromeos_update_engine