| // |
| // Copyright (C) 2017 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. |
| // |
| |
| #include "update_engine/update_manager/next_update_check_policy_impl.h" |
| |
| #include <algorithm> |
| |
| #include "update_engine/common/utils.h" |
| |
| using base::Time; |
| using base::TimeDelta; |
| using std::max; |
| using std::string; |
| |
| namespace chromeos_update_manager { |
| |
| NextUpdateCheckTimePolicyImpl::NextUpdateCheckTimePolicyImpl( |
| const NextUpdateCheckPolicyConstants& constants) |
| : policy_constants_(constants) {} |
| |
| EvalStatus NextUpdateCheckTimePolicyImpl::UpdateCheckAllowed( |
| EvaluationContext* ec, |
| State* state, |
| string* error, |
| UpdateCheckParams* result) const { |
| // Ensure that periodic update checks are timed properly. |
| Time next_update_check; |
| |
| if (NextUpdateCheckTime( |
| ec, state, error, &next_update_check, policy_constants_) != |
| EvalStatus::kSucceeded) { |
| return EvalStatus::kFailed; |
| } |
| if (!ec->IsWallclockTimeGreaterThan(next_update_check)) { |
| LOG(INFO) << "Periodic check interval not satisfied, blocking until " |
| << chromeos_update_engine::utils::ToString(next_update_check); |
| return EvalStatus::kAskMeAgainLater; |
| } |
| |
| return EvalStatus::kContinue; |
| } |
| |
| EvalStatus NextUpdateCheckTimePolicyImpl::NextUpdateCheckTime( |
| EvaluationContext* ec, |
| State* state, |
| string* error, |
| Time* next_update_check, |
| const NextUpdateCheckPolicyConstants& constants) { |
| UpdaterProvider* const updater_provider = state->updater_provider(); |
| |
| // Don't check for updates too often. We limit the update checks to once every |
| // some interval. The interval is kTimeoutInitialInterval the first time and |
| // kTimeoutPeriodicInterval for the subsequent update checks. If the update |
| // check fails, we increase the interval between the update checks |
| // exponentially until kTimeoutMaxBackoffInterval. Finally, to avoid having |
| // many chromebooks running update checks at the exact same time, we add some |
| // fuzz to the interval. |
| const Time* updater_started_time = |
| ec->GetValue(updater_provider->var_updater_started_time()); |
| POLICY_CHECK_VALUE_AND_FAIL(updater_started_time, error); |
| |
| const Time* last_checked_time = |
| ec->GetValue(updater_provider->var_last_checked_time()); |
| |
| const auto* seed = ec->GetValue(state->random_provider()->var_seed()); |
| POLICY_CHECK_VALUE_AND_FAIL(seed, error); |
| |
| PRNG prng(*seed); |
| |
| // If this is the first attempt, compute and return an initial value. |
| if (last_checked_time == nullptr || |
| *last_checked_time < *updater_started_time) { |
| *next_update_check = *updater_started_time + |
| FuzzedInterval(&prng, |
| constants.timeout_initial_interval, |
| constants.timeout_regular_fuzz); |
| return EvalStatus::kSucceeded; |
| } |
| |
| // Check whether the server is enforcing a poll interval; if not, this value |
| // will be zero. |
| const unsigned int* server_dictated_poll_interval = |
| ec->GetValue(updater_provider->var_server_dictated_poll_interval()); |
| POLICY_CHECK_VALUE_AND_FAIL(server_dictated_poll_interval, error); |
| |
| int interval = *server_dictated_poll_interval; |
| int fuzz = 0; |
| |
| // If no poll interval was dictated by server compute a back-off period, |
| // starting from a predetermined base periodic interval and increasing |
| // exponentially by the number of consecutive failed attempts. |
| if (interval == 0) { |
| const unsigned int* consecutive_failed_update_checks = |
| ec->GetValue(updater_provider->var_consecutive_failed_update_checks()); |
| POLICY_CHECK_VALUE_AND_FAIL(consecutive_failed_update_checks, error); |
| |
| interval = constants.timeout_periodic_interval; |
| unsigned int num_failures = *consecutive_failed_update_checks; |
| while (interval < constants.timeout_max_backoff_interval && num_failures) { |
| interval *= 2; |
| num_failures--; |
| } |
| } |
| |
| // We cannot back off longer than the predetermined maximum interval. |
| if (interval > constants.timeout_max_backoff_interval) |
| interval = constants.timeout_max_backoff_interval; |
| |
| // We cannot back off shorter than the predetermined periodic interval. Also, |
| // in this case set the fuzz to a predetermined regular value. |
| if (interval <= constants.timeout_periodic_interval) { |
| interval = constants.timeout_periodic_interval; |
| fuzz = constants.timeout_regular_fuzz; |
| } |
| |
| // If not otherwise determined, defer to a fuzz of +/-(interval / 2). |
| if (fuzz == 0) |
| fuzz = interval; |
| |
| *next_update_check = |
| *last_checked_time + FuzzedInterval(&prng, interval, fuzz); |
| return EvalStatus::kSucceeded; |
| } |
| |
| TimeDelta NextUpdateCheckTimePolicyImpl::FuzzedInterval(PRNG* prng, |
| int interval, |
| int fuzz) { |
| DCHECK_GE(interval, 0); |
| DCHECK_GE(fuzz, 0); |
| int half_fuzz = fuzz / 2; |
| // This guarantees the output interval is non negative. |
| int interval_min = max(interval - half_fuzz, 0); |
| int interval_max = interval + half_fuzz; |
| return TimeDelta::FromSeconds(prng->RandMinMax(interval_min, interval_max)); |
| } |
| |
| } // namespace chromeos_update_manager |