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: 53 ChromeOSPolicy() {} 54 ~ChromeOSPolicy() override {} 55 56 // Policy overrides. 57 EvalStatus UpdateCheckAllowed( 58 EvaluationContext* ec, State* state, std::string* error, 59 UpdateCheckParams* result) const override; 60 61 EvalStatus UpdateCanBeApplied( 62 EvaluationContext* ec, 63 State* state, 64 std::string* error, 65 chromeos_update_engine::ErrorCode* result, 66 chromeos_update_engine::InstallPlan* install_plan) const override; 67 68 EvalStatus UpdateCanStart( 69 EvaluationContext* ec, 70 State* state, 71 std::string* error, 72 UpdateDownloadParams* result, 73 UpdateState update_state) const override; 74 75 EvalStatus UpdateDownloadAllowed( 76 EvaluationContext* ec, 77 State* state, 78 std::string* error, 79 bool* result) const override; 80 81 EvalStatus P2PEnabled( 82 EvaluationContext* ec, 83 State* state, 84 std::string* error, 85 bool* result) const override; 86 87 EvalStatus P2PEnabledChanged( 88 EvaluationContext* ec, 89 State* state, 90 std::string* error, 91 bool* result, 92 bool prev_result) const override; 93 94 protected: 95 // Policy override. 96 std::string PolicyName() const override { return "ChromeOSPolicy"; } 97 98 private: 99 friend class UmChromeOSPolicyTest; 100 FRIEND_TEST(UmChromeOSPolicyTest, UpdateCheckAllowedWaitsForTheTimeout); 101 FRIEND_TEST(UmChromeOSPolicyTest, UpdateCheckAllowedWaitsForOOBE); 102 FRIEND_TEST(UmChromeOSPolicyTest, 103 UpdateCanStartNotAllowedScatteringNewWaitPeriodApplies); 104 FRIEND_TEST(UmChromeOSPolicyTest, 105 UpdateCanStartNotAllowedScatteringPrevWaitPeriodStillApplies); 106 FRIEND_TEST(UmChromeOSPolicyTest, 107 UpdateCanStartNotAllowedScatteringNewCountThresholdApplies); 108 FRIEND_TEST(UmChromeOSPolicyTest, 109 UpdateCanStartNotAllowedScatteringPrevCountThresholdStillApplies); 110 FRIEND_TEST(UmChromeOSPolicyTest, UpdateCanStartAllowedScatteringSatisfied); 111 FRIEND_TEST(UmChromeOSPolicyTest, 112 UpdateCanStartAllowedInteractivePreventsScattering); 113 FRIEND_TEST(UmChromeOSPolicyTest, 114 UpdateCanStartAllowedP2PDownloadingBlockedDueToNumAttempts); 115 FRIEND_TEST(UmChromeOSPolicyTest, 116 UpdateCanStartAllowedP2PDownloadingBlockedDueToAttemptsPeriod); 117 118 // Auxiliary constant (zero by default). 119 const base::TimeDelta kZeroInterval; 120 121 static const NextUpdateCheckPolicyConstants kNextUpdateCheckPolicyConstants; 122 123 // Maximum number of times we'll allow using P2P for the same update payload. 124 static const int kMaxP2PAttempts; 125 // Maximum period of time allowed for download a payload via P2P, in seconds. 126 static const int kMaxP2PAttemptsPeriodInSeconds; 127 128 // A private policy for determining backoff and the download URL to use. 129 // Within |update_state|, |backoff_expiry| and |is_backoff_disabled| are used 130 // for determining whether backoff is still in effect; if not, 131 // |download_errors| is scanned past |failures_last_updated|, and a new 132 // download URL from |download_urls| is found and written to |result->url_idx| 133 // (-1 means no usable URL exists); |download_errors_max| determines the 134 // maximum number of attempts per URL, according to the Omaha response. If an 135 // update failure is identified then |result->do_increment_failures| is set to 136 // true; if backoff is enabled, a new backoff period is computed (from the 137 // time of failure) based on |num_failures|. Otherwise, backoff expiry is 138 // nullified, indicating that no backoff is in effect. 139 // 140 // If backing off but the previous backoff expiry is unchanged, returns 141 // |EvalStatus::kAskMeAgainLater|. Otherwise: 142 // 143 // * If backing off with a new expiry time, then |result->backoff_expiry| is 144 // set to this time. 145 // 146 // * Else, |result->backoff_expiry| is set to null, indicating that no backoff 147 // is in effect. 148 // 149 // In any of these cases, returns |EvalStatus::kSucceeded|. If an error 150 // occurred, returns |EvalStatus::kFailed|. 151 EvalStatus UpdateBackoffAndDownloadUrl( 152 EvaluationContext* ec, State* state, std::string* error, 153 UpdateBackoffAndDownloadUrlResult* result, 154 const UpdateState& update_state) const; 155 156 // A private policy for checking whether scattering is due. Writes in |result| 157 // the decision as to whether or not to scatter; a wallclock-based scatter 158 // wait period, which ranges from zero (do not wait) and no greater than the 159 // current scatter factor provided by the device policy (if available) or the 160 // maximum wait period determined by Omaha; and an update check-based 161 // threshold between zero (no threshold) and the maximum number determined by 162 // the update engine. Within |update_state|, |scatter_wait_period| should 163 // contain the last scattering period returned by this function, or zero if no 164 // wait period is known; |scatter_check_threshold| is the last update check 165 // threshold, or zero if no such threshold is known. If not scattering, or if 166 // any of the scattering values has changed, returns |EvalStatus::kSucceeded|; 167 // otherwise, |EvalStatus::kAskMeAgainLater|. 168 EvalStatus UpdateScattering(EvaluationContext* ec, State* state, 169 std::string* error, 170 UpdateScatteringResult* result, 171 const UpdateState& update_state) const; 172 173 DISALLOW_COPY_AND_ASSIGN(ChromeOSPolicy); 174 }; 175 176 } // namespace chromeos_update_manager 177 178 #endif // UPDATE_ENGINE_UPDATE_MANAGER_CHROMEOS_POLICY_H_ 179