payload_state.h revision 674c318a84e4344fce0fdaee039784ed7900d188
1// Copyright (c) 2012 The Chromium OS Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#ifndef CHROMEOS_PLATFORM_UPDATE_ENGINE_PAYLOAD_STATE_H__ 6#define CHROMEOS_PLATFORM_UPDATE_ENGINE_PAYLOAD_STATE_H__ 7 8#include <base/time.h> 9 10#include "update_engine/payload_state_interface.h" 11#include "update_engine/prefs_interface.h" 12 13namespace chromeos_update_engine { 14 15class SystemState; 16 17// Encapsulates all the payload state required for download. This includes the 18// state necessary for handling multiple URLs in Omaha response, the backoff 19// state, etc. All state is persisted so that we use the most recently saved 20// value when resuming the update_engine process. All state is also cached in 21// memory so that we ensure we always make progress based on last known good 22// state even when there's any issue in reading/writing from the file system. 23class PayloadState : public PayloadStateInterface { 24 public: 25 PayloadState(); 26 virtual ~PayloadState() {} 27 28 // Initializes a payload state object using the given global system state. 29 // It performs the initial loading of all persisted state into memory and 30 // dumps the initial state for debugging purposes. Note: the other methods 31 // should be called only after calling Initialize on this object. 32 bool Initialize(SystemState* system_state); 33 34 // Implementation of PayloadStateInterface methods. 35 virtual void SetResponse(const OmahaResponse& response); 36 virtual void DownloadComplete(); 37 virtual void DownloadProgress(size_t count); 38 virtual void UpdateResumed(); 39 virtual void UpdateRestarted(); 40 virtual void UpdateSucceeded(); 41 virtual void UpdateFailed(ActionExitCode error); 42 virtual bool ShouldBackoffDownload(); 43 44 virtual inline std::string GetResponseSignature() { 45 return response_signature_; 46 } 47 48 virtual inline uint32_t GetPayloadAttemptNumber() { 49 return payload_attempt_number_; 50 } 51 52 virtual inline uint32_t GetUrlIndex() { 53 return url_index_; 54 } 55 56 virtual inline uint32_t GetUrlFailureCount() { 57 return url_failure_count_; 58 } 59 60 virtual inline uint32_t GetUrlSwitchCount() { 61 return url_switch_count_; 62 } 63 64 virtual inline base::Time GetBackoffExpiryTime() { 65 return backoff_expiry_time_; 66 } 67 68 virtual base::TimeDelta GetUpdateDuration(); 69 70 virtual base::TimeDelta GetUpdateDurationUptime(); 71 72 virtual inline uint64_t GetCurrentBytesDownloaded(DownloadSource source) { 73 return source < kNumDownloadSources ? current_bytes_downloaded_[source] : 0; 74 } 75 76 virtual inline uint64_t GetTotalBytesDownloaded(DownloadSource source) { 77 return source < kNumDownloadSources ? total_bytes_downloaded_[source] : 0; 78 } 79 80 virtual inline uint32_t GetNumReboots() { 81 return num_reboots_; 82 } 83 84 private: 85 // Increments the payload attempt number which governs the backoff behavior 86 // at the time of the next update check. 87 void IncrementPayloadAttemptNumber(); 88 89 // Advances the current URL index to the next available one. If all URLs have 90 // been exhausted during the current payload download attempt (as indicated 91 // by the payload attempt number), then it will increment the payload attempt 92 // number and wrap around again with the first URL in the list. This also 93 // updates the URL switch count, if needed. 94 void IncrementUrlIndex(); 95 96 // Increments the failure count of the current URL. If the configured max 97 // failure count is reached for this URL, it advances the current URL index 98 // to the next URL and resets the failure count for that URL. 99 void IncrementFailureCount(); 100 101 // Updates the backoff expiry time exponentially based on the current 102 // payload attempt number. 103 void UpdateBackoffExpiryTime(); 104 105 // Updates the value of current download source based on the current URL 106 // index. If the download source is not one of the known sources, it's set 107 // to kNumDownloadSources. 108 void UpdateCurrentDownloadSource(); 109 110 // Updates the various metrics corresponding with the given number of bytes 111 // that were downloaded recently. 112 void UpdateBytesDownloaded(size_t count); 113 114 // Reports the various metrics related to the number of bytes downloaded. 115 void ReportBytesDownloadedMetrics(); 116 117 // Reports the metric related to number of URL switches. 118 void ReportUpdateUrlSwitchesMetric(); 119 120 // Reports the various metrics related to rebooting during an update. 121 void ReportRebootMetrics(); 122 123 // Reports the various metrics related to update duration. 124 void ReportDurationMetrics(); 125 126 // Resets all the persisted state values which are maintained relative to the 127 // current response signature. The response signature itself is not reset. 128 void ResetPersistedState(); 129 130 // Resets the appropriate state related to download sources that need to be 131 // reset on a new update. 132 void ResetDownloadSourcesOnNewUpdate(); 133 134 // Returns the persisted value for the given key. It also validates that 135 // the value returned is non-negative. 136 int64_t GetPersistedValue(const std::string& key); 137 138 // Calculates the response "signature", which is basically a string composed 139 // of the subset of the fields in the current response that affect the 140 // behavior of the PayloadState. 141 std::string CalculateResponseSignature(); 142 143 // Initializes the current response signature from the persisted state. 144 void LoadResponseSignature(); 145 146 // Sets the response signature to the given value. Also persists the value 147 // being set so that we resume from the save value in case of a process 148 // restart. 149 void SetResponseSignature(const std::string& response_signature); 150 151 // Initializes the payload attempt number from the persisted state. 152 void LoadPayloadAttemptNumber(); 153 154 // Sets the payload attempt number to the given value. Also persists the 155 // value being set so that we resume from the same value in case of a process 156 // restart. 157 void SetPayloadAttemptNumber(uint32_t payload_attempt_number); 158 159 // Initializes the current URL index from the persisted state. 160 void LoadUrlIndex(); 161 162 // Sets the current URL index to the given value. Also persists the value 163 // being set so that we resume from the same value in case of a process 164 // restart. 165 void SetUrlIndex(uint32_t url_index); 166 167 // Initializes the current URL's failure count from the persisted stae. 168 void LoadUrlFailureCount(); 169 170 // Sets the current URL's failure count to the given value. Also persists the 171 // value being set so that we resume from the same value in case of a process 172 // restart. 173 void SetUrlFailureCount(uint32_t url_failure_count); 174 175 // Sets |url_switch_count_| to the given value and persists the value. 176 void SetUrlSwitchCount(uint32_t url_switch_count); 177 178 // Initializes |url_switch_count_| from the persisted stae. 179 void LoadUrlSwitchCount(); 180 181 // Initializes the backoff expiry time from the persisted state. 182 void LoadBackoffExpiryTime(); 183 184 // Sets the backoff expiry time to the given value. Also persists the value 185 // being set so that we resume from the same value in case of a process 186 // restart. 187 void SetBackoffExpiryTime(const base::Time& new_time); 188 189 // Initializes |update_timestamp_start_| from the persisted state. 190 void LoadUpdateTimestampStart(); 191 192 // Sets |update_timestamp_start_| to the given value and persists the value. 193 void SetUpdateTimestampStart(const base::Time& value); 194 195 // Sets |update_timestamp_end_| to the given value. This is not persisted 196 // as it happens at the end of the update process where state is deleted 197 // anyway. 198 void SetUpdateTimestampEnd(const base::Time& value); 199 200 // Initializes |update_duration_uptime_| from the persisted state. 201 void LoadUpdateDurationUptime(); 202 203 // Helper method used in SetUpdateDurationUptime() and 204 // CalculateUpdateDurationUptime(). 205 void SetUpdateDurationUptimeExtended(const base::TimeDelta& value, 206 const base::Time& timestamp, 207 bool use_logging); 208 209 // Sets |update_duration_uptime_| to the given value and persists 210 // the value and sets |update_duration_uptime_timestamp_| to the 211 // current monotonic time. 212 void SetUpdateDurationUptime(const base::TimeDelta& value); 213 214 // Adds the difference between current monotonic time and 215 // |update_duration_uptime_timestamp_| to |update_duration_uptime_| and 216 // sets |update_duration_uptime_timestamp_| to current monotonic time. 217 void CalculateUpdateDurationUptime(); 218 219 // Returns the full key for a download source given the prefix. 220 std::string GetPrefsKey(const std::string& prefix, DownloadSource source); 221 222 // Loads the number of bytes that have been currently downloaded through the 223 // previous attempts from the persisted state for the given source. It's 224 // reset to 0 everytime we begin a full update and is continued from previous 225 // attempt if we're resuming the update. 226 void LoadCurrentBytesDownloaded(DownloadSource source); 227 228 // Sets the number of bytes that have been currently downloaded for the 229 // given source. This value is also persisted. 230 void SetCurrentBytesDownloaded(DownloadSource source, 231 uint64_t current_bytes_downloaded, 232 bool log); 233 234 // Loads the total number of bytes that have been downloaded (since the last 235 // successful update) from the persisted state for the given source. It's 236 // reset to 0 everytime we successfully apply an update and counts the bytes 237 // downloaded for both successful and failed attempts since then. 238 void LoadTotalBytesDownloaded(DownloadSource source); 239 240 // Sets the total number of bytes that have been downloaded so far for the 241 // given source. This value is also persisted. 242 void SetTotalBytesDownloaded(DownloadSource source, 243 uint64_t total_bytes_downloaded, 244 bool log); 245 246 // The global state of the system. 247 SystemState* system_state_; 248 249 // Initializes |num_reboots_| from the persisted state. 250 void LoadNumReboots(); 251 252 // Sets |num_reboots| for the update attempt. Also persists the 253 // value being set so that we resume from the same value in case of a process 254 // restart. 255 void SetNumReboots(uint32_t num_reboots); 256 257 // Checks to see if the device rebooted since the last call and if so 258 // increments num_reboots. 259 void UpdateNumReboots(); 260 261 // Interface object with which we read/write persisted state. This must 262 // be set by calling the Initialize method before calling any other method. 263 PrefsInterface* prefs_; 264 265 // This is the current response object from Omaha. 266 OmahaResponse response_; 267 268 // This stores a "signature" of the current response. The signature here 269 // refers to a subset of the current response from Omaha. Each update to 270 // this value is persisted so we resume from the same value in case of a 271 // process restart. 272 std::string response_signature_; 273 274 // The number of times we've tried to download the payload in full. This is 275 // incremented each time we download the payload in full successsfully or 276 // when we exhaust all failure limits for all URLs and are about to wrap 277 // around back to the first URL. Each update to this value is persisted so 278 // we resume from the same value in case of a process restart. 279 uint32_t payload_attempt_number_; 280 281 // The index of the current URL. This type is different from the one in the 282 // accessor methods because PrefsInterface supports only int64_t but we want 283 // to provide a stronger abstraction of uint32_t. Each update to this value 284 // is persisted so we resume from the same value in case of a process 285 // restart. 286 int64_t url_index_; 287 288 // The count of failures encountered in the current attempt to download using 289 // the current URL (specified by url_index_). Each update to this value is 290 // persisted so we resume from the same value in case of a process restart. 291 int64_t url_failure_count_; 292 293 // The number of times we've switched URLs. 294 int32_t url_switch_count_; 295 296 // The current download source based on the current URL. This value is 297 // not persisted as it can be recomputed everytime we update the URL. 298 // We're storing this so as not to recompute this on every few bytes of 299 // data we read from the socket. 300 DownloadSource current_download_source_; 301 302 // The number of system reboots during an update attempt. Technically since 303 // we don't go out of our way to not update it when not attempting an update, 304 // also records the number of reboots before the next update attempt starts. 305 uint32_t num_reboots_; 306 307 // The timestamp until which we've to wait before attempting to download the 308 // payload again, so as to backoff repeated downloads. 309 base::Time backoff_expiry_time_; 310 311 // The most recently calculated value of the update duration. 312 base::TimeDelta update_duration_current_; 313 314 // The point in time (wall-clock) that the update was started. 315 base::Time update_timestamp_start_; 316 317 // The point in time (wall-clock) that the update ended. If the update 318 // is still in progress, this is set to the Epoch (e.g. 0). 319 base::Time update_timestamp_end_; 320 321 // The update duration uptime 322 base::TimeDelta update_duration_uptime_; 323 324 // The monotonic time when |update_duration_uptime_| was last set 325 base::Time update_duration_uptime_timestamp_; 326 327 // The number of bytes that have been downloaded for each source for each new 328 // update attempt. If we resume an update, we'll continue from the previous 329 // value, but if we get a new response or if the previous attempt failed, 330 // we'll reset this to 0 to start afresh. Each update to this value is 331 // persisted so we resume from the same value in case of a process restart. 332 // The extra index in the array is to no-op accidental access in case the 333 // return value from GetCurrentDownloadSource is used without validation. 334 uint64_t current_bytes_downloaded_[kNumDownloadSources + 1]; 335 336 // The number of bytes that have been downloaded for each source since the 337 // the last successful update. This is used to compute the overhead we incur. 338 // Each update to this value is persisted so we resume from the same value in 339 // case of a process restart. 340 // The extra index in the array is to no-op accidental access in case the 341 // return value from GetCurrentDownloadSource is used without validation. 342 uint64_t total_bytes_downloaded_[kNumDownloadSources + 1]; 343 344 // Returns the number of URLs in the current response. 345 // Note: This value will be 0 if this method is called before we receive 346 // the first valid Omaha response in this process. 347 uint32_t GetNumUrls() { 348 return response_.payload_urls.size(); 349 } 350 351 // A small timespan used when comparing wall-clock times for coping 352 // with the fact that clocks drift and consequently are adjusted 353 // (either forwards or backwards) via NTP. 354 static const base::TimeDelta kDurationSlack; 355 356 DISALLOW_COPY_AND_ASSIGN(PayloadState); 357}; 358 359} // namespace chromeos_update_engine 360 361#endif // CHROMEOS_PLATFORM_UPDATE_ENGINE_PAYLOAD_STATE_H__ 362