AU: Retry up to 3 times 30 seconds apart on HTTP response code 0.

libcurl_http_fetcher.cc

 // Copyright (c) 2009 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/libcurl_http_fetcher.h"
 
 #include <algorithm>
 #include <string>
 
 #include <base/logging.h>
 
 #include "update_engine/chrome_proxy_resolver.h"
 #include "update_engine/dbus_interface.h"
 #include "update_engine/flimflam_proxy.h"
 #include "update_engine/utils.h"
 
 using std::max;
 using std::make_pair;
 using std::string;
 
 // This is a concrete implementation of HttpFetcher that uses libcurl to do the
 // http work.
 
 namespace chromeos_update_engine {
 
 namespace {
 const int kMaxRetriesCount = 20;
+const int kNoNetworkRetrySeconds = 30;
 const char kCACertificatesPath[] = "/usr/share/chromeos-ca-certificates";
 }  // namespace {}
 
 LibcurlHttpFetcher::~LibcurlHttpFetcher() {
   LOG_IF(ERROR, transfer_in_progress_)
       << "Destroying the fetcher while a transfer is in progress.";
   CleanUp();
 }
 
 // On error, returns false.
@@ skipping 107 matching lines @@
 
   CHECK_EQ(curl_multi_add_handle(curl_multi_handle_, curl_handle_), CURLM_OK);
   transfer_in_progress_ = true;
 }
 
 // Begins the transfer, which must not have already been started.
 void LibcurlHttpFetcher::BeginTransfer(const std::string& url) {
   transfer_size_ = -1;
   resume_offset_ = 0;
   retry_count_ = 0;
+  no_network_retry_count_ = 0;
   http_response_code_ = 0;
   ResolveProxiesForUrl(url);
   ResumeTransfer(url);
   CurlPerformOnce();
 }
 
 void LibcurlHttpFetcher::ForceTransferTermination() {
   CleanUp();
   if (delegate_) {
     // Note that after the callback returns this object may be destroyed.
@@ skipping 20 matching lines @@
     retcode = curl_multi_perform(curl_multi_handle_, &running_handles);
     if (terminate_requested_) {
       ForceTransferTermination();
       return;
     }
   }
   if (0 == running_handles) {
     GetHttpResponseCode();
     if (http_response_code_) {
       LOG(INFO) << "HTTP response code: " << http_response_code_;
+      no_network_retry_count_ = 0;
     } else {
       LOG(ERROR) << "Unable to get http response code.";
     }
 
     // we're done!
     CleanUp();
 
+    // TODO(petkov): This temporary code tries to deal with the case where the
+    // update engine performs an update check while the network is not ready
+    // (e.g., right after resume). Longer term, we should check if the network
+    // is online/offline and return an appropriate error code.
+    if (!sent_byte_ &&
+        http_response_code_ == 0 &&
+        no_network_retry_count_ < no_network_max_retries_) {
+      no_network_retry_count_++;
+      g_timeout_add_seconds(kNoNetworkRetrySeconds,
+                            &LibcurlHttpFetcher::StaticRetryTimeoutCallback,
+                            this);
+      LOG(INFO) << "No HTTP response, retry " << no_network_retry_count_;
+      return;
+    }
+
     if (!sent_byte_ &&
         (http_response_code_ < 200 || http_response_code_ >= 300)) {
       // The transfer completed w/ error and we didn't get any bytes.
       // If we have another proxy to try, try that.
 
       PopProxy();  // Delete the proxy we just gave up on.
 
       if (HasProxy()) {
         // We have another proxy. Retry immediately.
         g_idle_add(&LibcurlHttpFetcher::StaticRetryTimeoutCallback, this);
@@ skipping 209 matching lines @@
 void LibcurlHttpFetcher::GetHttpResponseCode() {
   long http_response_code = 0;
   if (curl_easy_getinfo(curl_handle_,
                         CURLINFO_RESPONSE_CODE,
                         &http_response_code) == CURLE_OK) {
     http_response_code_ = static_cast<int>(http_response_code);
   }
 }
 
 }  // namespace chromeos_update_engine