AU: Changes for deltas on traditional bios machines.

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 "chromeos/obsolete_logging.h"
 
 using std::max;
 using std::make_pair;
 
 // This is a concrete implementation of HttpFetcher that uses libcurl to do the
 // http work.
 
 namespace chromeos_update_engine {
 
 LibcurlHttpFetcher::~LibcurlHttpFetcher() {
   CleanUp();
 }
 
 void LibcurlHttpFetcher::ResumeTransfer(const std::string& url) {
+  LOG(INFO) << "Starting/Resuming transfer";
   CHECK(!transfer_in_progress_);
   url_ = url;
   curl_multi_handle_ = curl_multi_init();
   CHECK(curl_multi_handle_);
 
   curl_handle_ = curl_easy_init();
   CHECK(curl_handle_);
 
   if (post_data_set_) {
     CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_POST, 1), CURLE_OK);
@@ skipping 10 matching lines @@
     resume_offset_ = bytes_downloaded_;
     CHECK_EQ(curl_easy_setopt(curl_handle_,
                               CURLOPT_RESUME_FROM_LARGE,
                               bytes_downloaded_), CURLE_OK);
   }
 
   CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_WRITEDATA, this), CURLE_OK);
   CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_WRITEFUNCTION,
                             StaticLibcurlWrite), CURLE_OK);
   CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_URL, url_.c_str()), CURLE_OK);
+
+  // If the connection drops under 10 bytes/sec for 90 seconds, reconnect.
+  CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_LOW_SPEED_LIMIT, 10),
+           CURLE_OK);
+  CHECK_EQ(curl_easy_setopt(curl_handle_, CURLOPT_LOW_SPEED_TIME, 90),
+           CURLE_OK);
+
   CHECK_EQ(curl_multi_add_handle(curl_multi_handle_, curl_handle_), CURLM_OK);
   transfer_in_progress_ = true;
-  CurlPerformOnce();
 }
 
 // Begins the transfer, which must not have already been started.
 void LibcurlHttpFetcher::BeginTransfer(const std::string& url) {
   transfer_size_ = -1;
   bytes_downloaded_ = 0;
   resume_offset_ = 0;
-  ResumeTransfer(url);
+  do {
+    ResumeTransfer(url);
+  } while (CurlPerformOnce());
 }
 
 void LibcurlHttpFetcher::TerminateTransfer() {
   CleanUp();
 }
 
-// TODO(adlr): detect network failures
-void LibcurlHttpFetcher::CurlPerformOnce() {
+bool LibcurlHttpFetcher::CurlPerformOnce() {
   CHECK(transfer_in_progress_);
   int running_handles = 0;
   CURLMcode retcode = CURLM_CALL_MULTI_PERFORM;
 
   // libcurl may request that we immediately call curl_multi_perform after it
   // returns, so we do. libcurl promises that curl_multi_perform will not block.
   while (CURLM_CALL_MULTI_PERFORM == retcode) {
     retcode = curl_multi_perform(curl_multi_handle_, &running_handles);
   }
   if (0 == running_handles) {
     // we're done!
     CleanUp();
 
     if ((transfer_size_ >= 0) && (bytes_downloaded_ < transfer_size_)) {
-      ResumeTransfer(url_);
+      // Need to restart transfer
+      return true;
     } else {
       if (delegate_) {
         delegate_->TransferComplete(this, true);  // success
       }
     }
   } else {
     // set up callback
     SetupMainloopSources();
   }
+  return false;
 }
 
 size_t LibcurlHttpFetcher::LibcurlWrite(void *ptr, size_t size, size_t nmemb) {
   {
     double transfer_size_double;
     CHECK_EQ(curl_easy_getinfo(curl_handle_,
                                CURLINFO_CONTENT_LENGTH_DOWNLOAD,
                                &transfer_size_double), CURLE_OK);
     off_t new_transfer_size = static_cast<off_t>(transfer_size_double);
     if (new_transfer_size > 0) {
@@ skipping 51 matching lines @@
       if (io_channels_.find(i) != io_channels_.end()) {
         g_source_remove(io_channels_[i].second);
         g_io_channel_unref(io_channels_[i].first);
         io_channels_.erase(io_channels_.find(i));
       }
       continue;
     }
     // If we are already tracking this fd, continue.
     if (io_channels_.find(i) != io_channels_.end())
       continue;
-
     // We must track a new fd
     GIOChannel *io_channel = g_io_channel_unix_new(i);
     guint tag = g_io_add_watch(
         io_channel,
         static_cast<GIOCondition>(G_IO_IN | G_IO_OUT | G_IO_PRI |
                                   G_IO_ERR | G_IO_HUP),
         &StaticFDCallback,
         this);
     io_channels_[i] = make_pair(io_channel, tag);
+    static int io_counter = 0;
+    io_counter++;
+    if (io_counter % 50 == 0) {
+      LOG(INFO) << "io_counter = " << io_counter;
+    }
   }
 
   // Wet up a timeout callback for libcurl
   long ms = 0;
   CHECK_EQ(curl_multi_timeout(curl_multi_handle_, &ms), CURLM_OK);
   if (ms < 0) {
     // From http://curl.haxx.se/libcurl/c/curl_multi_timeout.html:
     //     if libcurl returns a -1 timeout here, it just means that libcurl
     //     currently has no stored timeout value. You must not wait too long
     //     (more than a few seconds perhaps) before you call
     //     curl_multi_perform() again.
     ms = idle_ms_;
   }
-  if (timeout_source_) {
-    g_source_destroy(timeout_source_);
-    timeout_source_ = NULL;
+  if (!timeout_source_) {
+    LOG(INFO) << "setting up timeout source:" << ms;
+    timeout_source_ = g_timeout_source_new(1000);
+    CHECK(timeout_source_);
+    g_source_set_callback(timeout_source_, StaticTimeoutCallback, this,
+                          NULL);
+    g_source_attach(timeout_source_, NULL);
+    static int counter = 0;
+    counter++;
+    if (counter % 50 == 0) {
+      LOG(INFO) << "counter = " << counter;
+    }
   }
-  timeout_source_ = g_timeout_source_new(ms);
-  CHECK(timeout_source_);
-  g_source_set_callback(timeout_source_, StaticTimeoutCallback, this,
-                        NULL);
-  g_source_attach(timeout_source_, NULL);
 }
 
 bool LibcurlHttpFetcher::FDCallback(GIOChannel *source,
                                     GIOCondition condition) {
-  // Figure out which source it was; hopefully there aren't too many b/c
-  // this is a linear scan of our channels
-  bool found_in_set = false;
-  for (IOChannels::iterator it = io_channels_.begin();
-       it != io_channels_.end(); ++it) {
-    if (it->second.first == source) {
-      // We will return false from this method, meaning that we shouldn't keep
-      // this g_io_channel around. So we remove it now from our collection of
-      // g_io_channels so that the other code in this class doens't mess with
-      // this (doomed) GIOChannel.
-      // TODO(adlr): optimize by seeing if we should reuse this GIOChannel
-      g_source_remove(it->second.second);
-      g_io_channel_unref(it->second.first);
-      io_channels_.erase(it);
-      found_in_set = true;
-      break;
-    }
+  while (CurlPerformOnce()) {
+    ResumeTransfer(url_);
   }
-  CHECK(found_in_set);
-  CurlPerformOnce();
-  return false;
+  // We handle removing of this source elsewhere, so we always return true.
+  // The docs say, "the function should return FALSE if the event source
+  // should be removed."
+  // http://www.gtk.org/api/2.6/glib/glib-IO-Channels.html#GIOFunc
+  return true;
 }
 
-bool LibcurlHttpFetcher::TimeoutCallback() {
+gboolean LibcurlHttpFetcher::TimeoutCallback() {
+  if (!transfer_in_progress_)
+    return TRUE;
   // Since we will return false from this function, which tells glib to
   // destroy the timeout callback, we must NULL it out here. This way, when
   // setting up callback sources again, we won't try to delete this (doomed)
   // timeout callback then.
   // TODO(adlr): optimize by checking if we can keep this timeout callback.
-  timeout_source_ = NULL;
-  CurlPerformOnce();
-  return false;
+  //timeout_source_ = NULL;
+  while (CurlPerformOnce()) {
+    ResumeTransfer(url_);
+  }
+  return TRUE;
 }
 
 void LibcurlHttpFetcher::CleanUp() {
   if (timeout_source_) {
     g_source_destroy(timeout_source_);
     timeout_source_ = NULL;
   }
 
   for (IOChannels::iterator it = io_channels_.begin();
        it != io_channels_.end(); ++it) {
@@ skipping 11 matching lines @@
     curl_handle_ = NULL;
   }
   if (curl_multi_handle_) {
     CHECK_EQ(curl_multi_cleanup(curl_multi_handle_), CURLM_OK);
     curl_multi_handle_ = NULL;
   }
   transfer_in_progress_ = false;
 }
 
 }  // namespace chromeos_update_engine