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