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