update_manager/staging_utils.cc

//
// Copyright (C) 2018 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/staging_utils.h"

#include <utility>
#include <vector>

#include <base/logging.h>
#include <base/rand_util.h>
#include <base/time/time.h>
#include <policy/device_policy.h>

#include "update_engine/common/constants.h"
#include "update_engine/common/hardware_interface.h"
#include "update_engine/common/prefs_interface.h"
#include "update_engine/system_state.h"

using base::TimeDelta;
using chromeos_update_engine::kPrefsWallClockStagingWaitPeriod;
using chromeos_update_engine::PrefsInterface;
using chromeos_update_engine::SystemState;
using policy::DevicePolicy;

namespace chromeos_update_manager {

int GetStagingSchedule(const DevicePolicy* device_policy,
                       StagingSchedule* staging_schedule_out) {
  StagingSchedule staging_schedule;
  if (!device_policy->GetDeviceUpdateStagingSchedule(&staging_schedule) ||
      staging_schedule.empty()) {
    return 0;
  }

  // Last percentage of the schedule should be 100.
  if (staging_schedule.back().percentage != 100) {
    LOG(ERROR) << "Last percentage of the schedule is not 100, it's: "
               << staging_schedule.back().percentage;
    return 0;
  }

  int previous_days = 0;
  int previous_percentage = -1;
  // Ensure that the schedule has a monotonically increasing set of percentages
  // and that days are also monotonically increasing.
  for (const auto& staging_pair : staging_schedule) {
    int days = staging_pair.days;
    if (previous_days >= days) {
      LOG(ERROR) << "Days in staging schedule are not monotonically "
                 << "increasing. Previous value: " << previous_days
                 << " Current value: " << days;
      return 0;
    }
    previous_days = days;
    int percentage = staging_pair.percentage;
    if (previous_percentage >= percentage) {
      LOG(ERROR) << "Percentages in staging schedule are not monotonically "
                 << "increasing. Previous value: " << previous_percentage
                 << " Current value: " << percentage;
      return 0;
    }
    previous_percentage = percentage;
  }
  // Modify staging schedule only if the schedule in the device policy is valid.
  if (staging_schedule_out)
    *staging_schedule_out = std::move(staging_schedule);

  return previous_days;
}

int CalculateWaitTimeInDaysFromSchedule(
    const StagingSchedule& staging_schedule) {
  int prev_days = 0;
  int percentage_position = base::RandInt(1, 100);
  for (const auto& staging_pair : staging_schedule) {
    int days = staging_pair.days;
    if (percentage_position <= staging_pair.percentage) {
      // Scatter between the start of the range and the end.
      return prev_days + base::RandInt(1, days - prev_days);
    }
    prev_days = days;
  }
  // Something went wrong.
  NOTREACHED();
  return 0;
}

StagingCase CalculateStagingCase(const DevicePolicy* device_policy,
                                 PrefsInterface* prefs,
                                 TimeDelta* staging_wait_time,
                                 StagingSchedule* staging_schedule) {
  // Check that the schedule in the device policy is correct.
  StagingSchedule new_staging_schedule;
  int max_days = GetStagingSchedule(device_policy, &new_staging_schedule);
  if (max_days == 0)
    return StagingCase::kOff;

  // Calculate the new wait time.
  TimeDelta new_staging_wait_time = TimeDelta::FromDays(
      CalculateWaitTimeInDaysFromSchedule(new_staging_schedule));
  DCHECK_GT(new_staging_wait_time.InSeconds(), 0);
  if (staging_wait_time->InSeconds() > 0) {
    // If there hasn't been any changes to the schedule and there is a value
    // set, don't change the waiting time.
    if (new_staging_schedule == *staging_schedule) {
      return StagingCase::kNoAction;
    }
    // Otherwise, update the schedule and wait time.
    *staging_wait_time = new_staging_wait_time;
    *staging_schedule = std::move(new_staging_schedule);
    return StagingCase::kNoSavedValue;
  }
  // Getting this means the schedule changed, update the old schedule.
  *staging_schedule = std::move(new_staging_schedule);

  int64_t wait_period_in_days;
  // There exists a persisted value that is valid. That is, it's smaller than
  // the maximum amount of days of staging set by the user.
  if (prefs->GetInt64(kPrefsWallClockStagingWaitPeriod, &wait_period_in_days) &&
      wait_period_in_days > 0 && wait_period_in_days <= max_days) {
    *staging_wait_time = TimeDelta::FromDays(wait_period_in_days);
    return StagingCase::kSetStagingFromPref;
  }

  *staging_wait_time = new_staging_wait_time;
  return StagingCase::kNoSavedValue;
}

}  // namespace chromeos_update_manager