1 // 2 // Copyright (C) 2017 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 #include "update_engine/update_manager/next_update_check_policy_impl.h" 18 19 #include <algorithm> 20 21 #include "update_engine/common/utils.h" 22 23 using base::Time; 24 using base::TimeDelta; 25 using std::max; 26 using std::string; 27 28 namespace chromeos_update_manager { 29 30 NextUpdateCheckTimePolicyImpl::NextUpdateCheckTimePolicyImpl( 31 const NextUpdateCheckPolicyConstants& constants) 32 : policy_constants_(constants) {} 33 34 EvalStatus NextUpdateCheckTimePolicyImpl::UpdateCheckAllowed( 35 EvaluationContext* ec, 36 State* state, 37 string* error, 38 UpdateCheckParams* result) const { 39 // Ensure that periodic update checks are timed properly. 40 Time next_update_check; 41 42 if (NextUpdateCheckTime( 43 ec, state, error, &next_update_check, policy_constants_) != 44 EvalStatus::kSucceeded) { 45 return EvalStatus::kFailed; 46 } 47 if (!ec->IsWallclockTimeGreaterThan(next_update_check)) { 48 LOG(INFO) << "Periodic check interval not satisfied, blocking until " 49 << chromeos_update_engine::utils::ToString(next_update_check); 50 return EvalStatus::kAskMeAgainLater; 51 } 52 53 return EvalStatus::kContinue; 54 } 55 56 EvalStatus NextUpdateCheckTimePolicyImpl::NextUpdateCheckTime( 57 EvaluationContext* ec, 58 State* state, 59 string* error, 60 Time* next_update_check, 61 const NextUpdateCheckPolicyConstants& constants) { 62 UpdaterProvider* const updater_provider = state->updater_provider(); 63 64 // Don't check for updates too often. We limit the update checks to once every 65 // some interval. The interval is kTimeoutInitialInterval the first time and 66 // kTimeoutPeriodicInterval for the subsequent update checks. If the update 67 // check fails, we increase the interval between the update checks 68 // exponentially until kTimeoutMaxBackoffInterval. Finally, to avoid having 69 // many chromebooks running update checks at the exact same time, we add some 70 // fuzz to the interval. 71 const Time* updater_started_time = 72 ec->GetValue(updater_provider->var_updater_started_time()); 73 POLICY_CHECK_VALUE_AND_FAIL(updater_started_time, error); 74 75 const Time* last_checked_time = 76 ec->GetValue(updater_provider->var_last_checked_time()); 77 78 const auto* seed = ec->GetValue(state->random_provider()->var_seed()); 79 POLICY_CHECK_VALUE_AND_FAIL(seed, error); 80 81 PRNG prng(*seed); 82 83 // If this is the first attempt, compute and return an initial value. 84 if (last_checked_time == nullptr || 85 *last_checked_time < *updater_started_time) { 86 *next_update_check = *updater_started_time + 87 FuzzedInterval(&prng, 88 constants.timeout_initial_interval, 89 constants.timeout_regular_fuzz); 90 return EvalStatus::kSucceeded; 91 } 92 93 // Check whether the server is enforcing a poll interval; if not, this value 94 // will be zero. 95 const unsigned int* server_dictated_poll_interval = 96 ec->GetValue(updater_provider->var_server_dictated_poll_interval()); 97 POLICY_CHECK_VALUE_AND_FAIL(server_dictated_poll_interval, error); 98 99 int interval = *server_dictated_poll_interval; 100 int fuzz = 0; 101 102 // If no poll interval was dictated by server compute a back-off period, 103 // starting from a predetermined base periodic interval and increasing 104 // exponentially by the number of consecutive failed attempts. 105 if (interval == 0) { 106 const unsigned int* consecutive_failed_update_checks = 107 ec->GetValue(updater_provider->var_consecutive_failed_update_checks()); 108 POLICY_CHECK_VALUE_AND_FAIL(consecutive_failed_update_checks, error); 109 110 interval = constants.timeout_periodic_interval; 111 unsigned int num_failures = *consecutive_failed_update_checks; 112 while (interval < constants.timeout_max_backoff_interval && num_failures) { 113 interval *= 2; 114 num_failures--; 115 } 116 } 117 118 // We cannot back off longer than the predetermined maximum interval. 119 if (interval > constants.timeout_max_backoff_interval) 120 interval = constants.timeout_max_backoff_interval; 121 122 // We cannot back off shorter than the predetermined periodic interval. Also, 123 // in this case set the fuzz to a predetermined regular value. 124 if (interval <= constants.timeout_periodic_interval) { 125 interval = constants.timeout_periodic_interval; 126 fuzz = constants.timeout_regular_fuzz; 127 } 128 129 // If not otherwise determined, defer to a fuzz of +/-(interval / 2). 130 if (fuzz == 0) 131 fuzz = interval; 132 133 *next_update_check = 134 *last_checked_time + FuzzedInterval(&prng, interval, fuzz); 135 return EvalStatus::kSucceeded; 136 } 137 138 TimeDelta NextUpdateCheckTimePolicyImpl::FuzzedInterval(PRNG* prng, 139 int interval, 140 int fuzz) { 141 DCHECK_GE(interval, 0); 142 DCHECK_GE(fuzz, 0); 143 int half_fuzz = fuzz / 2; 144 // This guarantees the output interval is non negative. 145 int interval_min = max(interval - half_fuzz, 0); 146 int interval_max = interval + half_fuzz; 147 return TimeDelta::FromSeconds(prng->RandMinMax(interval_min, interval_max)); 148 } 149 150 } // namespace chromeos_update_manager 151
