update_engine: Create cros vs. aosp boundary clear
Its time to make the boundary between Chrome OS and Android code more
clear. This CL moves all CrOS only code to "chromeos" directory and the
same for Android (in "android" directory). This way we would easily know
which code is uses in which project and can keep the code cleaner and
more maintainable.
One big remaining problem is download_action* files. It seems like
DownloadAction class does a lot of things that chrome OS needs and it
depends on a lot of Chrome OS stuff, but Android is also using thie
Action in a way that circumvent the Chrome OS stuff. For example Android
checks for SystemState to be nullptr to not do things. This is really
fragile and needs to change. Probably Android Team has to implement
their own DownloadAction of some sort and not re use the Chrome OS one
in a very fragile way.
Removed a few android files that have not been used anywhere.
Changed some clang-format and lint issues in order to pass preupload.
BUG=b:171829801
TEST=cros_workon_make --board reef --test update_engine
Change-Id: I3fff1d4a100a065a5c1484a845241b5521614d9f
Reviewed-on: https://chromium-review.googlesource.com/c/aosp/platform/system/update_engine/+/2508965
Tested-by: Amin Hassani <ahassani@chromium.org>
Auto-Submit: Amin Hassani <ahassani@chromium.org>
Reviewed-by: Jae Hoon Kim <kimjae@chromium.org>
Reviewed-by: Tianjie Xu <xunchang@google.com>
Reviewed-by: Kelvin Zhang <zhangkelvin@google.com>
Commit-Queue: Amin Hassani <ahassani@chromium.org>
diff --git a/cros/omaha_request_params.h b/cros/omaha_request_params.h
new file mode 100644
index 0000000..26ea1c9
--- /dev/null
+++ b/cros/omaha_request_params.h
@@ -0,0 +1,420 @@
+//
+// Copyright (C) 2012 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.
+//
+
+#ifndef UPDATE_ENGINE_CROS_OMAHA_REQUEST_PARAMS_H_
+#define UPDATE_ENGINE_CROS_OMAHA_REQUEST_PARAMS_H_
+
+#include <stdint.h>
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include <base/macros.h>
+#include <base/time/time.h>
+#include <gtest/gtest_prod.h> // for FRIEND_TEST
+
+#include "update_engine/common/constants.h"
+#include "update_engine/common/platform_constants.h"
+#include "update_engine/cros/image_properties.h"
+#include "update_engine/update_manager/policy.h"
+
+// This gathers local system information and prepares info used by the
+// Omaha request action.
+
+namespace chromeos_update_engine {
+
+class SystemState;
+
+// This class encapsulates the data Omaha gets for the request, along with
+// essential state needed for the processing of the request/response. The
+// strings in this struct should not be XML escaped.
+//
+// TODO(jaysri): chromium-os:39752 tracks the need to rename this class to
+// reflect its lifetime more appropriately.
+class OmahaRequestParams {
+ public:
+ explicit OmahaRequestParams(SystemState* system_state)
+ : system_state_(system_state),
+ os_platform_(constants::kOmahaPlatformName),
+ os_version_(kOsVersion),
+ delta_okay_(true),
+ interactive_(false),
+ rollback_allowed_(false),
+ rollback_data_save_requested_(false),
+ wall_clock_based_wait_enabled_(false),
+ update_check_count_wait_enabled_(false),
+ min_update_checks_needed_(kDefaultMinUpdateChecks),
+ max_update_checks_allowed_(kDefaultMaxUpdateChecks),
+ is_install_(false) {}
+
+ virtual ~OmahaRequestParams();
+
+ enum ActiveCountingType {
+ kDayBased = 0,
+ kDateBased,
+ };
+
+ struct AppParams {
+ ActiveCountingType active_counting_type;
+ // |name| is only used for DLCs to store the DLC ID.
+ std::string name;
+ int64_t ping_active;
+ int64_t ping_date_last_active;
+ int64_t ping_date_last_rollcall;
+ bool send_ping;
+ // |updated| is only used for DLCs to decide sending DBus message to
+ // dlcservice on an install/update completion.
+ bool updated = true;
+ };
+
+ // Setters and getters for the various properties.
+ inline std::string os_platform() const { return os_platform_; }
+ inline std::string os_version() const { return os_version_; }
+ inline std::string os_sp() const { return os_sp_; }
+ inline std::string os_board() const { return image_props_.board; }
+ inline std::string os_build_fingerprint() const {
+ return image_props_.build_fingerprint;
+ }
+ inline std::string os_build_type() const { return image_props_.build_type; }
+ inline std::string board_app_id() const { return image_props_.product_id; }
+ inline std::string canary_app_id() const {
+ return image_props_.canary_product_id;
+ }
+ inline void set_app_id(const std::string& app_id) {
+ image_props_.product_id = app_id;
+ image_props_.canary_product_id = app_id;
+ }
+ inline std::string app_lang() const { return app_lang_; }
+ inline std::string hwid() const { return hwid_; }
+ inline std::string device_requisition() const { return device_requisition_; }
+
+ inline void set_app_version(const std::string& version) {
+ image_props_.version = version;
+ }
+ inline std::string app_version() const { return image_props_.version; }
+ inline std::string product_components() const {
+ return image_props_.product_components;
+ }
+ inline void set_product_components(const std::string& product_components) {
+ image_props_.product_components = product_components;
+ }
+
+ inline std::string current_channel() const {
+ return image_props_.current_channel;
+ }
+ inline std::string target_channel() const {
+ return mutable_image_props_.target_channel;
+ }
+ inline std::string download_channel() const { return download_channel_; }
+
+ // Can client accept a delta ?
+ inline void set_delta_okay(bool ok) { delta_okay_ = ok; }
+ inline bool delta_okay() const { return delta_okay_; }
+
+ // True if this is a user-initiated update check.
+ inline void set_interactive(bool interactive) { interactive_ = interactive; }
+ inline bool interactive() const { return interactive_; }
+
+ inline void set_update_url(const std::string& url) { update_url_ = url; }
+ inline std::string update_url() const { return update_url_; }
+
+ inline void set_target_version_prefix(const std::string& prefix) {
+ target_version_prefix_ = prefix;
+ }
+
+ inline std::string target_version_prefix() const {
+ return target_version_prefix_;
+ }
+
+ inline std::string lts_tag() const { return lts_tag_; }
+
+ inline void set_lts_tag(const std::string& hint) { lts_tag_ = hint; }
+
+ inline void set_rollback_allowed(bool rollback_allowed) {
+ rollback_allowed_ = rollback_allowed;
+ }
+
+ inline bool rollback_allowed() const { return rollback_allowed_; }
+
+ inline void set_rollback_data_save_requested(
+ bool rollback_data_save_requested) {
+ rollback_data_save_requested_ = rollback_data_save_requested;
+ }
+
+ inline bool rollback_data_save_requested() const {
+ return rollback_data_save_requested_;
+ }
+
+ inline void set_rollback_allowed_milestones(int rollback_allowed_milestones) {
+ rollback_allowed_milestones_ = rollback_allowed_milestones;
+ }
+
+ inline int rollback_allowed_milestones() const {
+ return rollback_allowed_milestones_;
+ }
+
+ inline void set_wall_clock_based_wait_enabled(bool enabled) {
+ wall_clock_based_wait_enabled_ = enabled;
+ }
+ inline bool wall_clock_based_wait_enabled() const {
+ return wall_clock_based_wait_enabled_;
+ }
+
+ inline void set_waiting_period(base::TimeDelta period) {
+ waiting_period_ = period;
+ }
+ base::TimeDelta waiting_period() const { return waiting_period_; }
+
+ inline void set_update_check_count_wait_enabled(bool enabled) {
+ update_check_count_wait_enabled_ = enabled;
+ }
+
+ inline bool update_check_count_wait_enabled() const {
+ return update_check_count_wait_enabled_;
+ }
+
+ inline void set_min_update_checks_needed(int64_t min) {
+ min_update_checks_needed_ = min;
+ }
+ inline int64_t min_update_checks_needed() const {
+ return min_update_checks_needed_;
+ }
+
+ inline void set_max_update_checks_allowed(int64_t max) {
+ max_update_checks_allowed_ = max;
+ }
+ inline int64_t max_update_checks_allowed() const {
+ return max_update_checks_allowed_;
+ }
+ inline void set_dlc_apps_params(
+ const std::map<std::string, AppParams>& dlc_apps_params) {
+ dlc_apps_params_ = dlc_apps_params;
+ }
+ inline const std::map<std::string, AppParams>& dlc_apps_params() const {
+ return dlc_apps_params_;
+ }
+ inline void set_is_install(bool is_install) { is_install_ = is_install; }
+ inline bool is_install() const { return is_install_; }
+
+ inline void set_autoupdate_token(const std::string& token) {
+ autoupdate_token_ = token;
+ }
+ inline const std::string& autoupdate_token() const {
+ return autoupdate_token_;
+ }
+
+ // Returns the App ID corresponding to the current value of the
+ // download channel.
+ virtual std::string GetAppId() const;
+
+ // Returns the DLC app ID.
+ virtual std::string GetDlcAppId(const std::string& dlc_id) const;
+
+ // Returns true if the App ID is a DLC App ID that is currently part of the
+ // request parameters.
+ virtual bool IsDlcAppId(const std::string& app_id) const;
+
+ // If the App ID is a DLC App ID will set to no update.
+ void SetDlcNoUpdate(const std::string& app_id);
+
+ // Suggested defaults
+ static const char kOsVersion[];
+ static const int64_t kDefaultMinUpdateChecks = 0;
+ static const int64_t kDefaultMaxUpdateChecks = 8;
+
+ // Initializes all the data in the object. Non-empty
+ // |in_app_version| or |in_update_url| prevents automatic detection
+ // of the parameter. Returns true on success, false otherwise.
+ bool Init(const std::string& in_app_version,
+ const std::string& in_update_url,
+ const chromeos_update_manager::UpdateCheckParams& params);
+
+ // Permanently changes the release channel to |channel|. Performs a
+ // powerwash, if required and allowed.
+ // Returns true on success, false otherwise. Note: This call will fail if
+ // there's a channel change pending already. This is to serialize all the
+ // channel changes done by the user in order to avoid having to solve
+ // numerous edge cases around ensuring the powerwash happens as intended in
+ // all such cases.
+ virtual bool SetTargetChannel(const std::string& channel,
+ bool is_powerwash_allowed,
+ std::string* error_message);
+
+ // Updates the download channel for this particular attempt from the current
+ // value of target channel. This method takes a "snapshot" of the current
+ // value of target channel and uses it for all subsequent Omaha requests for
+ // this attempt (i.e. initial request as well as download progress/error
+ // event requests). The snapshot will be updated only when either this method
+ // or Init is called again.
+ virtual void UpdateDownloadChannel();
+
+ // Returns whether we should powerwash for this update. Note that this is
+ // just an indication, the final decision to powerwash or not is made in the
+ // response handler.
+ bool ShouldPowerwash() const;
+
+ // Check if the provided update URL is official, meaning either the default
+ // autoupdate server or the autoupdate autotest server.
+ virtual bool IsUpdateUrlOfficial() const;
+
+ // For unit-tests.
+ void set_root(const std::string& root);
+ void set_current_channel(const std::string& channel) {
+ image_props_.current_channel = channel;
+ }
+ void set_target_channel(const std::string& channel) {
+ mutable_image_props_.target_channel = channel;
+ }
+ void set_os_sp(const std::string& os_sp) { os_sp_ = os_sp; }
+ void set_os_board(const std::string& os_board) {
+ image_props_.board = os_board;
+ }
+ void set_app_lang(const std::string& app_lang) { app_lang_ = app_lang; }
+ void set_hwid(const std::string& hwid) { hwid_ = hwid; }
+ void set_is_powerwash_allowed(bool powerwash_allowed) {
+ mutable_image_props_.is_powerwash_allowed = powerwash_allowed;
+ }
+ bool is_powerwash_allowed() {
+ return mutable_image_props_.is_powerwash_allowed;
+ }
+
+ void set_device_requisition(const std::string& requisition) {
+ device_requisition_ = requisition;
+ }
+
+ private:
+ FRIEND_TEST(OmahaRequestParamsTest, ChannelIndexTest);
+ FRIEND_TEST(OmahaRequestParamsTest, IsValidChannelTest);
+ FRIEND_TEST(OmahaRequestParamsTest, SetIsPowerwashAllowedTest);
+ FRIEND_TEST(OmahaRequestParamsTest, SetTargetChannelInvalidTest);
+ FRIEND_TEST(OmahaRequestParamsTest, SetTargetChannelTest);
+ FRIEND_TEST(OmahaRequestParamsTest, ShouldPowerwashTest);
+ FRIEND_TEST(OmahaRequestParamsTest, ToMoreStableChannelFlagTest);
+
+ // Returns true if |channel| is a valid channel, otherwise write error to
+ // |error_message| if passed and return false.
+ bool IsValidChannel(const std::string& channel,
+ std::string* error_message) const;
+ bool IsValidChannel(const std::string& channel) const {
+ return IsValidChannel(channel, nullptr);
+ }
+
+ // Returns the index of the given channel.
+ int GetChannelIndex(const std::string& channel) const;
+
+ // True if we're trying to update to a more stable channel.
+ // i.e. index(target_channel) > index(current_channel).
+ bool ToMoreStableChannel() const;
+
+ // Gets the machine type (e.g. "i686").
+ std::string GetMachineType() const;
+
+ // Global system context.
+ SystemState* system_state_;
+
+ // The system image properties.
+ ImageProperties image_props_;
+ MutableImageProperties mutable_image_props_;
+
+ // Basic properties of the OS and Application that go into the Omaha request.
+ std::string os_platform_;
+ std::string os_version_;
+ std::string os_sp_;
+ std::string app_lang_;
+
+ // There are three channel values we deal with:
+ // * The channel we got the image we are running from or "current channel"
+ // stored in |image_props_.current_channel|.
+ //
+ // * The release channel we are tracking, where we should get updates from,
+ // stored in |mutable_image_props_.target_channel|. This channel is
+ // normally the same as the current_channel, except when the user changes
+ // the channel. In that case it'll have the release channel the user
+ // switched to, regardless of whether we downloaded an update from that
+ // channel or not, or if we are in the middle of a download from a
+ // previously selected channel (as opposed to download channel
+ // which gets updated only at the start of next download).
+ //
+ // * The channel from which we're downloading the payload. This should
+ // normally be the same as target channel. But if the user made another
+ // channel change after we started the download, then they'd be different,
+ // in which case, we'd detect elsewhere that the target channel has been
+ // changed and cancel the current download attempt.
+ std::string download_channel_;
+
+ // The value defining the parameters of the LTS (Long Term Support).
+ std::string lts_tag_;
+
+ std::string hwid_; // Hardware Qualification ID of the client
+ // TODO(b:133324571) tracks removal of this field once it is no longer
+ // needed in AU requests. Remove by October 1st 2019.
+ std::string device_requisition_; // Chrome OS Requisition type.
+ bool delta_okay_; // If this client can accept a delta
+ bool interactive_; // Whether this is a user-initiated update check
+
+ // The URL to send the Omaha request to.
+ std::string update_url_;
+
+ // Prefix of the target OS version that the enterprise wants this device
+ // to be pinned to. It's empty otherwise.
+ std::string target_version_prefix_;
+
+ // Whether the client is accepting rollback images too.
+ bool rollback_allowed_;
+
+ // Whether rollbacks should preserve some system state during powerwash.
+ bool rollback_data_save_requested_;
+
+ // How many milestones the client can rollback to.
+ int rollback_allowed_milestones_;
+
+ // True if scattering or staging are enabled, in which case waiting_period_
+ // specifies the amount of absolute time that we've to wait for before sending
+ // a request to Omaha.
+ bool wall_clock_based_wait_enabled_;
+ base::TimeDelta waiting_period_;
+
+ // True if scattering or staging are enabled to denote the number of update
+ // checks we've to skip before we can send a request to Omaha. The min and max
+ // values establish the bounds for a random number to be chosen within that
+ // range to enable such a wait.
+ bool update_check_count_wait_enabled_;
+ int64_t min_update_checks_needed_;
+ int64_t max_update_checks_allowed_;
+
+ // When reading files, prepend root_ to the paths. Useful for testing.
+ std::string root_;
+
+ // A list of DLC modules to install. A mapping from DLC App ID to |AppParams|.
+ std::map<std::string, AppParams> dlc_apps_params_;
+
+ // This variable defines whether the payload is being installed in the current
+ // partition. At the moment, this is used for installing DLC modules on the
+ // current active partition instead of the inactive partition.
+ bool is_install_;
+
+ // Token used when making an update request for a specific build.
+ // For example: Token for a Quick Fix Build:
+ // https://cloud.google.com/docs/chrome-enterprise/policies/?policy=DeviceQuickFixBuildToken
+ std::string autoupdate_token_;
+
+ DISALLOW_COPY_AND_ASSIGN(OmahaRequestParams);
+};
+
+} // namespace chromeos_update_engine
+
+#endif // UPDATE_ENGINE_CROS_OMAHA_REQUEST_PARAMS_H_