AU: Implement server-dictated poll interval.

update_check_scheduler.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_check_scheduler.h"
 
 #include "update_engine/utils.h"
 
 namespace chromeos_update_engine {
 
 const int UpdateCheckScheduler::kTimeoutOnce = 7 * 60;  // at 7 minutes
 const int UpdateCheckScheduler::kTimeoutPeriodic = 45 * 60;  // every 45 minutes
 const int UpdateCheckScheduler::kTimeoutRegularFuzz = 10 * 60;  // +/- 5 minutes
 const int UpdateCheckScheduler::kTimeoutMaxBackoff = 4 * 60 * 60;  // 4 hours
 
 UpdateCheckScheduler::UpdateCheckScheduler(UpdateAttempter* update_attempter)
     : update_attempter_(update_attempter),
       enabled_(false),
       scheduled_(false),
-      last_interval_(0) {}
+      last_interval_(0),
+      poll_interval_(0) {}
 
 UpdateCheckScheduler::~UpdateCheckScheduler() {}
 
 void UpdateCheckScheduler::Run() {
   enabled_ = false;
   update_attempter_->set_update_check_scheduler(NULL);
 
   if (!IsOfficialBuild()) {
     LOG(WARNING) << "Non-official build: periodic update checks disabled.";
     return;
@@ skipping 52 matching lines @@
   // seems better to crash in such cases and restart the update_engine daemon
   // into, hopefully, a known good state.
   CHECK(me->update_attempter_->status() != UPDATE_STATUS_IDLE ||
         !me->CanSchedule());
   return FALSE;  // Don't run again.
 }
 
 void UpdateCheckScheduler::ComputeNextIntervalAndFuzz(int* next_interval,
                                                       int* next_fuzz) {
   int interval = 0;
-  int fuzz = 0;
-  // Implements exponential back off on 500 (Internal Server Error) and 503
-  // (Service Unavailable) HTTP response codes.
-  if (update_attempter_->http_response_code() == 500 ||
-      update_attempter_->http_response_code() == 503) {
+  if (poll_interval_ > 0) {
+    // Server-dictated poll interval.
+    interval = poll_interval_;
+    LOG(WARNING) << "Using server-dictated poll interval: " << interval;
+  } else if (update_attempter_->http_response_code() == 500 ||
+             update_attempter_->http_response_code() == 503) {
+    // Implements exponential back off on 500 (Internal Server Error) and 503
+    // (Service Unavailable) HTTP response codes.
     interval = 2 * last_interval_;
-    if (interval > kTimeoutMaxBackoff) {
-      interval = kTimeoutMaxBackoff;
-    }
-    // Exponential back off is fuzzed by +/- |interval|/2.
-    fuzz = interval;
+    LOG(WARNING) << "Exponential back off due to 500/503 HTTP response code.";
   }
+  if (interval > kTimeoutMaxBackoff) {
+    interval = kTimeoutMaxBackoff;
+  }
+  // Back off and server-dictated poll intervals are fuzzed by +/- |interval|/2.
+  int fuzz = interval;
+
   // Ensures that under normal conditions the regular update check interval and
   // fuzz are used. Also covers the case where back off is required based on the
   // initial update check.
   if (interval < kTimeoutPeriodic) {
     interval = kTimeoutPeriodic;
     fuzz = kTimeoutRegularFuzz;
   }
   *next_interval = interval;
   *next_fuzz = fuzz;
 }
 
 void UpdateCheckScheduler::ScheduleNextCheck() {
   int interval, fuzz;
   ComputeNextIntervalAndFuzz(&interval, &fuzz);
   ScheduleCheck(interval, fuzz);
 }
 
 void UpdateCheckScheduler::SetUpdateStatus(UpdateStatus status) {
   if (status == UPDATE_STATUS_IDLE) {
     ScheduleNextCheck();
   }
 }
 
 }  // namespace chromeos_update_engine