Implement exponential backoff for throttling repeated AU downloads.
Today we retry the same payload over and over again every hour. Ideally,
we shouldn't require ever to re-download the same payload again. But
from experience we find that post-install or firmware updates may succeed
on a second attempt. So until we have code that can do such selective
retries of those steps, we currently re-download and re-apply the whole
payload. So instead of retrying over and over again, we backoff the
successive payload download attempts at 1 day, 2 days, 4 days, etc. with
an upper limit of 16 days.
Another subtle reason for which we depend on the payload retry mechanism
today is if we've failed downloading the payload via all the URLs that are
specified in the rule, we don't want to keep re-attempting the download.
This case is different from the case discussed above, because in this case
we haven't even downloaded a payload once completely. In this case also,
there's a need for throttling the amount of bytes we end up downloading
repeatedly for a particular operation that may fail. This is done by
treating the exhaustion of all URLs as equivalent to having downloaded
a full payload and subjecting it to the same backoff behavior.
We waive backoffs for dev/test images so as not to cause any delay in
our testing or development.
BUG=chromium-os:36806
TEST=Added new unit tests. Tested all scenarios on my ZGB.
Change-Id: I6bd0d3f296a3c0da0a8026fb71b24785d825e39c
Reviewed-on: https://gerrit.chromium.org/gerrit/40220
Commit-Queue: Jay Srinivasan <jaysri@chromium.org>
Reviewed-by: Jay Srinivasan <jaysri@chromium.org>
Tested-by: Jay Srinivasan <jaysri@chromium.org>
diff --git a/omaha_response.h b/omaha_response.h
new file mode 100644
index 0000000..ea4fab1
--- /dev/null
+++ b/omaha_response.h
@@ -0,0 +1,71 @@
+// Copyright (c) 2012 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.
+
+#ifndef CHROMEOS_PLATFORM_UPDATE_ENGINE_OMAHA_RESPONSE_H
+#define CHROMEOS_PLATFORM_UPDATE_ENGINE_OMAHA_RESPONSE_H
+
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <string>
+#include <vector>
+
+namespace chromeos_update_engine {
+
+// This struct encapsulates the data Omaha's response for the request.
+// The strings in this struct are not XML escaped.
+struct OmahaResponse {
+ OmahaResponse()
+ : update_exists(false),
+ poll_interval(0),
+ size(0),
+ metadata_size(0),
+ max_days_to_scatter(0),
+ max_failure_count_per_url(0),
+ needs_admin(false),
+ prompt(false),
+ is_delta_payload(false),
+ disable_payload_backoff(false) {}
+
+ // True iff there is an update to be downloaded.
+ bool update_exists;
+
+ // If non-zero, server-dictated poll interval in seconds.
+ int poll_interval;
+
+ // These are only valid if update_exists is true:
+ std::string display_version;
+
+ // The ordered list of URLs in the Omaha response. Each item is a complete
+ // URL (i.e. in terms of Omaha XML, each value is a urlBase + packageName)
+ std::vector<std::string> payload_urls;
+
+ std::string more_info_url;
+ std::string hash;
+ std::string metadata_signature;
+ std::string deadline;
+ off_t size;
+ off_t metadata_size;
+ int max_days_to_scatter;
+ // The number of URL-related failures to tolerate before moving on to the
+ // next URL in the current pass. This is a configurable value from the
+ // Omaha Response attribute, if ever we need to fine tune the behavior.
+ uint32_t max_failure_count_per_url;
+ bool needs_admin;
+ bool prompt;
+
+ // True if the payload described in this response is a delta payload.
+ // False if it's a full payload.
+ bool is_delta_payload;
+
+ // True if the Omaha rule instructs us to disable the backoff logic
+ // on the client altogether. False otherwise.
+ bool disable_payload_backoff;
+};
+COMPILE_ASSERT(sizeof(off_t) == 8, off_t_not_64bit);
+
+} // namespace chromeos_update_engine
+
+#endif // CHROMEOS_PLATFORM_UPDATE_ENGINE_OMAHA_RESPONSE_H