1 // 2 // Copyright (C) 2014 The Android Open Source Project 3 // 4 // Licensed under the Apache License, Version 2.0 (the "License"); 5 // you may not use this file except in compliance with the License. 6 // You may obtain a copy of the License at 7 // 8 // http://www.apache.org/licenses/LICENSE-2.0 9 // 10 // Unless required by applicable law or agreed to in writing, software 11 // distributed under the License is distributed on an "AS IS" BASIS, 12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 // See the License for the specific language governing permissions and 14 // limitations under the License. 15 // 16 17 #ifndef UPDATE_ENGINE_UPDATE_MANAGER_CHROMEOS_POLICY_H_ 18 #define UPDATE_ENGINE_UPDATE_MANAGER_CHROMEOS_POLICY_H_ 19 20 #include <string> 21 22 #include <base/time/time.h> 23 24 #include "update_engine/update_manager/next_update_check_policy_impl.h" 25 #include "update_engine/update_manager/policy_utils.h" 26 27 namespace chromeos_update_manager { 28 29 // Output information from UpdateBackoffAndDownloadUrl. 30 struct UpdateBackoffAndDownloadUrlResult { 31 // Whether the failed attempt count (maintained by the caller) needs to be 32 // incremented. 33 bool do_increment_failures; 34 // The current backoff expiry. Null if backoff is not in effect. 35 base::Time backoff_expiry; 36 // The new URL index to use and number of download errors associated with it. 37 // Significant iff |do_increment_failures| is false and |backoff_expiry| is 38 // null. Negative value means no usable URL was found. 39 int url_idx; 40 int url_num_errors; 41 }; 42 43 // Parameters for update scattering, as returned by UpdateScattering. 44 struct UpdateScatteringResult { 45 bool is_scattering; 46 base::TimeDelta wait_period; 47 int check_threshold; 48 }; 49 50 // ChromeOSPolicy implements the policy-related logic used in ChromeOS. 51 class ChromeOSPolicy : public Policy { 52 public: ChromeOSPolicy()53 ChromeOSPolicy() {} ~ChromeOSPolicy()54 ~ChromeOSPolicy() override {} 55 56 // Policy overrides. 57 EvalStatus UpdateCheckAllowed(EvaluationContext* ec, 58 State* state, 59 std::string* error, 60 UpdateCheckParams* result) const override; 61 62 EvalStatus UpdateCanBeApplied( 63 EvaluationContext* ec, 64 State* state, 65 std::string* error, 66 chromeos_update_engine::ErrorCode* result, 67 chromeos_update_engine::InstallPlan* install_plan) const override; 68 69 EvalStatus UpdateCanStart(EvaluationContext* ec, 70 State* state, 71 std::string* error, 72 UpdateDownloadParams* result, 73 UpdateState update_state) const override; 74 75 EvalStatus UpdateDownloadAllowed(EvaluationContext* ec, 76 State* state, 77 std::string* error, 78 bool* result) const override; 79 80 EvalStatus P2PEnabled(EvaluationContext* ec, 81 State* state, 82 std::string* error, 83 bool* result) const override; 84 85 EvalStatus P2PEnabledChanged(EvaluationContext* ec, 86 State* state, 87 std::string* error, 88 bool* result, 89 bool prev_result) const override; 90 91 protected: 92 // Policy override. PolicyName()93 std::string PolicyName() const override { return "ChromeOSPolicy"; } 94 95 private: 96 friend class UmChromeOSPolicyTest; 97 FRIEND_TEST(UmChromeOSPolicyTest, UpdateCheckAllowedWaitsForTheTimeout); 98 FRIEND_TEST(UmChromeOSPolicyTest, UpdateCheckAllowedWaitsForOOBE); 99 FRIEND_TEST(UmChromeOSPolicyTest, 100 UpdateCanStartNotAllowedScatteringNewWaitPeriodApplies); 101 FRIEND_TEST(UmChromeOSPolicyTest, 102 UpdateCanStartNotAllowedScatteringPrevWaitPeriodStillApplies); 103 FRIEND_TEST(UmChromeOSPolicyTest, 104 UpdateCanStartNotAllowedScatteringNewCountThresholdApplies); 105 FRIEND_TEST(UmChromeOSPolicyTest, 106 UpdateCanStartNotAllowedScatteringPrevCountThresholdStillApplies); 107 FRIEND_TEST(UmChromeOSPolicyTest, UpdateCanStartAllowedScatteringSatisfied); 108 FRIEND_TEST(UmChromeOSPolicyTest, 109 UpdateCanStartAllowedInteractivePreventsScattering); 110 FRIEND_TEST(UmChromeOSPolicyTest, 111 UpdateCanStartAllowedP2PDownloadingBlockedDueToNumAttempts); 112 FRIEND_TEST(UmChromeOSPolicyTest, 113 UpdateCanStartAllowedP2PDownloadingBlockedDueToAttemptsPeriod); 114 FRIEND_TEST(UmChromeOSPolicyTest, 115 UpdateCheckAllowedNextUpdateCheckOutsideDisallowedInterval); 116 117 // Auxiliary constant (zero by default). 118 const base::TimeDelta kZeroInterval; 119 120 static const NextUpdateCheckPolicyConstants kNextUpdateCheckPolicyConstants; 121 122 // Maximum number of times we'll allow using P2P for the same update payload. 123 static const int kMaxP2PAttempts; 124 // Maximum period of time allowed for download a payload via P2P, in seconds. 125 static const int kMaxP2PAttemptsPeriodInSeconds; 126 127 // A private policy for determining backoff and the download URL to use. 128 // Within |update_state|, |backoff_expiry| and |is_backoff_disabled| are used 129 // for determining whether backoff is still in effect; if not, 130 // |download_errors| is scanned past |failures_last_updated|, and a new 131 // download URL from |download_urls| is found and written to |result->url_idx| 132 // (-1 means no usable URL exists); |download_errors_max| determines the 133 // maximum number of attempts per URL, according to the Omaha response. If an 134 // update failure is identified then |result->do_increment_failures| is set to 135 // true; if backoff is enabled, a new backoff period is computed (from the 136 // time of failure) based on |num_failures|. Otherwise, backoff expiry is 137 // nullified, indicating that no backoff is in effect. 138 // 139 // If backing off but the previous backoff expiry is unchanged, returns 140 // |EvalStatus::kAskMeAgainLater|. Otherwise: 141 // 142 // * If backing off with a new expiry time, then |result->backoff_expiry| is 143 // set to this time. 144 // 145 // * Else, |result->backoff_expiry| is set to null, indicating that no backoff 146 // is in effect. 147 // 148 // In any of these cases, returns |EvalStatus::kSucceeded|. If an error 149 // occurred, returns |EvalStatus::kFailed|. 150 EvalStatus UpdateBackoffAndDownloadUrl( 151 EvaluationContext* ec, 152 State* state, 153 std::string* error, 154 UpdateBackoffAndDownloadUrlResult* result, 155 const UpdateState& update_state) const; 156 157 // A private policy for checking whether scattering is due. Writes in |result| 158 // the decision as to whether or not to scatter; a wallclock-based scatter 159 // wait period, which ranges from zero (do not wait) and no greater than the 160 // current scatter factor provided by the device policy (if available) or the 161 // maximum wait period determined by Omaha; and an update check-based 162 // threshold between zero (no threshold) and the maximum number determined by 163 // the update engine. Within |update_state|, |scatter_wait_period| should 164 // contain the last scattering period returned by this function, or zero if no 165 // wait period is known; |scatter_check_threshold| is the last update check 166 // threshold, or zero if no such threshold is known. If not scattering, or if 167 // any of the scattering values has changed, returns |EvalStatus::kSucceeded|; 168 // otherwise, |EvalStatus::kAskMeAgainLater|. 169 EvalStatus UpdateScattering(EvaluationContext* ec, 170 State* state, 171 std::string* error, 172 UpdateScatteringResult* result, 173 const UpdateState& update_state) const; 174 175 DISALLOW_COPY_AND_ASSIGN(ChromeOSPolicy); 176 }; 177 178 } // namespace chromeos_update_manager 179 180 #endif // UPDATE_ENGINE_UPDATE_MANAGER_CHROMEOS_POLICY_H_ 181