android_system_update_engine

// // Copyright (C) 2012 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // #ifndef UPDATE_ENGINE_PAYLOAD_STATE_H_ #define UPDATE_ENGINE_PAYLOAD_STATE_H_ #include <algorithm> #include <string> #include <vector> #include <base/time/time.h> #include <gtest/gtest_prod.h> // for FRIEND_TEST #include "update_engine/common/prefs_interface.h" #include "update_engine/metrics_constants.h" #include "update_engine/payload_state_interface.h" namespace chromeos_update_engine { class SystemState; // Encapsulates all the payload state required for download. This includes the // state necessary for handling multiple URLs in Omaha response, the backoff // state, etc. All state is persisted so that we use the most recently saved // value when resuming the update_engine process. All state is also cached in // memory so that we ensure we always make progress based on last known good // state even when there's any issue in reading/writing from the file system. class PayloadState : public PayloadStateInterface { public: PayloadState(); ~PayloadState() override {} // Initializes a payload state object using the given global system state. // It performs the initial loading of all persisted state into memory and // dumps the initial state for debugging purposes. Note: the other methods // should be called only after calling Initialize on this object. bool Initialize(SystemState* system_state); // Implementation of PayloadStateInterface methods. void SetResponse(const OmahaResponse& response) override; void DownloadComplete() override; void DownloadProgress(size_t count) override; void UpdateResumed() override; void UpdateRestarted() override; void UpdateSucceeded() override; void UpdateFailed(ErrorCode error) override; void ResetUpdateStatus() override; bool ShouldBackoffDownload() override; void Rollback() override; void ExpectRebootInNewVersion(const std::string& target_version_uid) override; void SetUsingP2PForDownloading(bool value) override; void SetUsingP2PForSharing(bool value) override { using_p2p_for_sharing_ = value; } inline std::string GetResponseSignature() override { return response_signature_; } inline int GetFullPayloadAttemptNumber() override { return full_payload_attempt_number_; } inline int GetPayloadAttemptNumber() override { return payload_attempt_number_; } inline std::string GetCurrentUrl() override { return (payload_index_ < candidate_urls_.size() && url_index_ < candidate_urls_[payload_index_].size()) ? candidate_urls_[payload_index_][url_index_] : ""; } inline uint32_t GetUrlFailureCount() override { return url_failure_count_; } inline uint32_t GetUrlSwitchCount() override { return url_switch_count_; } inline int GetNumResponsesSeen() override { return num_responses_seen_; } inline base::Time GetBackoffExpiryTime() override { return backoff_expiry_time_; } base::TimeDelta GetUpdateDuration() override; base::TimeDelta GetUpdateDurationUptime() override; inline uint64_t GetCurrentBytesDownloaded(DownloadSource source) override { return source < kNumDownloadSources ? current_bytes_downloaded_[source] : 0; } inline uint64_t GetTotalBytesDownloaded(DownloadSource source) override { return source < kNumDownloadSources ? total_bytes_downloaded_[source] : 0; } inline uint32_t GetNumReboots() override { return num_reboots_; } void UpdateEngineStarted() override; inline bool GetRollbackHappened() override { return rollback_happened_; } void SetRollbackHappened(bool rollback_happened) override; inline std::string GetRollbackVersion() override { return rollback_version_; } int GetP2PNumAttempts() override; base::Time GetP2PFirstAttemptTimestamp() override; void P2PNewAttempt() override; bool P2PAttemptAllowed() override; bool GetUsingP2PForDownloading() const override { return using_p2p_for_downloading_; } bool GetUsingP2PForSharing() const override { return using_p2p_for_sharing_; } base::TimeDelta GetScatteringWaitPeriod() override { return scattering_wait_period_; } void SetScatteringWaitPeriod(base::TimeDelta wait_period) override; void SetStagingWaitPeriod(base::TimeDelta wait_period) override; void SetP2PUrl(const std::string& url) override { p2p_url_ = url; } std::string GetP2PUrl() const override { return p2p_url_; } bool NextPayload() override; private: enum class AttemptType { kUpdate, kRollback, }; friend class PayloadStateTest; FRIEND_TEST(PayloadStateTest, RebootAfterUpdateFailedMetric); FRIEND_TEST(PayloadStateTest, RebootAfterUpdateSucceed); FRIEND_TEST(PayloadStateTest, RebootAfterCanceledUpdate); FRIEND_TEST(PayloadStateTest, RollbackHappened); FRIEND_TEST(PayloadStateTest, RollbackVersion); FRIEND_TEST(PayloadStateTest, UpdateSuccessWithWipedPrefs); // Helper called when an attempt has begun, is called by // UpdateResumed(), UpdateRestarted() and Rollback(). void AttemptStarted(AttemptType attempt_type); // Increments the payload attempt number used for metrics. void IncrementPayloadAttemptNumber(); // Increments the payload attempt number which governs the backoff behavior // at the time of the next update check. void IncrementFullPayloadAttemptNumber(); // Advances the current URL index to the next available one. If all URLs have // been exhausted during the current payload download attempt (as indicated // by the payload attempt number), then it will increment the payload attempt // number and wrap around again with the first URL in the list. This also // updates the URL switch count, if needed. void IncrementUrlIndex(); // Increments the failure count of the current URL. If the configured max // failure count is reached for this URL, it advances the current URL index // to the next URL and resets the failure count for that URL. void IncrementFailureCount(); // Updates the backoff expiry time exponentially based on the current // payload attempt number. void UpdateBackoffExpiryTime(); // Updates the value of current download source based on the current URL // index. If the download source is not one of the known sources, it's set // to kNumDownloadSources. void UpdateCurrentDownloadSource(); // Updates the various metrics corresponding with the given number of bytes // that were downloaded recently. void UpdateBytesDownloaded(size_t count); // Calculates the PayloadType we're using. PayloadType CalculatePayloadType(); // Collects and reports the various metrics related to an update attempt. void CollectAndReportAttemptMetrics(ErrorCode code); // Persists values related to the UpdateEngine.Attempt.* metrics so // we can identify later if an update attempt ends abnormally. void PersistAttemptMetrics(); // Clears persistent state previously set using AttemptMetricsPersist(). void ClearPersistedAttemptMetrics(); // Checks if persistent state previously set using AttemptMetricsPersist() // exists and, if so, emits it with |attempt_result| set to // metrics::AttemptResult::kAbnormalTermination. void ReportAndClearPersistedAttemptMetrics(); // Collects and reports the various metrics related to a successful update. void CollectAndReportSuccessfulUpdateMetrics(); // Checks if we were expecting to be running in the new version but the // boot into