| // Copyright 2024 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "components/update_client/pipeline.h" |
| |
| #include <cstdint> |
| #include <optional> |
| #include <queue> |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| #include "base/check.h" |
| #include "base/files/file_path.h" |
| #include "base/functional/bind.h" |
| #include "base/functional/callback.h" |
| #include "base/memory/ref_counted.h" |
| #include "base/sequence_checker.h" |
| #include "base/task/sequenced_task_runner.h" |
| #include "base/types/expected.h" |
| #include "base/values.h" |
| #include "components/update_client/action_runner.h" |
| #include "components/update_client/cancellation.h" |
| #include "components/update_client/component.h" |
| #include "components/update_client/configurator.h" |
| #include "components/update_client/crx_cache.h" |
| #include "components/update_client/op_download.h" |
| #include "components/update_client/op_install.h" |
| #include "components/update_client/op_puffin.h" |
| #include "components/update_client/protocol_parser.h" |
| #include "components/update_client/unzipper.h" |
| #include "components/update_client/update_client_errors.h" |
| #include "components/update_client/update_engine.h" |
| |
| namespace update_client { |
| |
| namespace { |
| |
| // A `Pipeline` represents an ordered sequence of operations that the update |
| // server has instructed the client to perform. Operations are functions with |
| // two inputs: |
| // 1. A `FilePath`. |
| // 2. A completion callback, which takes a `FilePath` or error. Operations |
| // that don't generate a file (e.g. a "run" action) propagate their input |
| // path. |
| // Operations return a cancellation callback when run. Operations that can't |
| // be cancelled return `base::DoNothing` as their cancellation callback. |
| // The first operation in each pipeline must tolerate an empty FilePath as |
| // input. |
| using Operation = base::OnceCallback<base::OnceClosure( |
| const base::FilePath&, |
| base::OnceCallback<void( |
| base::expected<base::FilePath, CategorizedError>)>)>; |
| using RepeatingOperation = base::RepeatingCallback<base::OnceClosure( |
| const base::FilePath&, |
| base::OnceCallback<void( |
| base::expected<base::FilePath, CategorizedError>)>)>; |
| |
| // `Pipeline` manages the flow of operations, passing the output path of |
| // each operation to the next one, short-circuiting on errors. |
| // |
| // Additionally, if a pipeline fails, it may fall back to a backup pipeline. |
| // |
| // `Pipeline` is refcounted. The callback passed to the currently-running |
| // operation holds the single ref to the pipeline, keeping it alive until |
| // `OpComplete` returns (after which, if there is another operation, another |
| // completion callback will keep it alive). |
| class Pipeline : public base::RefCountedThreadSafe<Pipeline> { |
| public: |
| Pipeline( |
| std::queue<Operation> operations, |
| const base::FilePath& first_path, |
| base::RepeatingCallback<void(const CategorizedError&)> outcome_recorder, |
| scoped_refptr<Pipeline> fallback); |
| Pipeline(const Pipeline&) = delete; |
| Pipeline& operator=(const Pipeline&) = delete; |
| |
| // Each `Pipeline` can only be used once. Returns a cancellation callback. |
| base::OnceClosure Start( |
| base::OnceCallback<void(const CategorizedError&)> callback); |
| |
| private: |
| friend class base::RefCountedThreadSafe<Pipeline>; |
| virtual ~Pipeline() = default; |
| |
| void StartNext(const base::FilePath& path); |
| void OpComplete(base::expected<base::FilePath, CategorizedError>); |
| |
| SEQUENCE_CHECKER(sequence_checker_); |
| std::queue<Operation> operations_; |
| base::FilePath first_path_; |
| base::RepeatingCallback<void(const CategorizedError&)> outcome_recorder_; |
| scoped_refptr<Pipeline> fallback_; |
| scoped_refptr<Cancellation> cancel_ = base::MakeRefCounted<Cancellation>(); |
| base::OnceCallback<void(const CategorizedError&)> callback_; |
| }; |
| |
| Pipeline::Pipeline( |
| std::queue<Operation> operations, |
| const base::FilePath& first_path, |
| base::RepeatingCallback<void(const CategorizedError&)> outcome_recorder, |
| scoped_refptr<Pipeline> fallback) |
| : operations_(std::move(operations)), |
| first_path_(first_path), |
| outcome_recorder_(outcome_recorder), |
| fallback_(fallback) {} |
| |
| base::OnceClosure Pipeline::Start( |
| base::OnceCallback<void(const CategorizedError&)> callback) { |
| CHECK(!callback_); |
| callback_ = std::move(callback); |
| StartNext(first_path_); |
| return base::BindOnce(&Cancellation::Cancel, cancel_); |
| } |
| |
| void Pipeline::StartNext(const base::FilePath& path) { |
| Operation next = std::move(operations_.front()); |
| operations_.pop(); |
| cancel_->OnCancel( |
| std::move(next).Run(path, base::BindOnce(&Pipeline::OpComplete, this))); |
| } |
| |
| void Pipeline::OpComplete( |
| base::expected<base::FilePath, CategorizedError> result) { |
| cancel_->Clear(); |
| if (!result.has_value()) { |
| outcome_recorder_.Run(result.error()); |
| if (fallback_ && !cancel_->IsCancelled()) { |
| // Pipeline failed, fall back to next pipeline. |
| cancel_->OnCancel(fallback_->Start(std::move(callback_))); |
| return; |
| } |
| // Pipeline failed and fallbacks exhausted or cancelled. |
| std::move(callback_).Run(result.error()); |
| return; |
| } |
| if (operations_.empty()) { |
| // Pipeline successfully completed. |
| std::move(callback_).Run({}); |
| return; |
| } |
| if (cancel_->IsCancelled()) { |
| // Pipeline still running, but cancelled. |
| std::move(callback_).Run( |
| {.category_ = ErrorCategory::kService, |
| .code_ = static_cast<int>(ServiceError::CANCELLED)}); |
| return; |
| } |
| // Pipeline still running: start next operation. |
| StartNext(result.value()); |
| } |
| |
| void AssemblePipeline( |
| std::optional<Operation> download_diff, |
| std::optional<Operation> patch_diff, |
| Operation download_full, |
| RepeatingOperation install, |
| std::optional<RepeatingOperation> run, |
| base::RepeatingCallback<void(const CategorizedError&)> |
| diff_outcome_recorder, |
| base::OnceCallback<void( |
| base::expected<base::OnceCallback<base::OnceClosure( |
| base::OnceCallback<void(const CategorizedError&)>)>, |
| CategorizedError>)> callback, |
| base::expected<base::FilePath, UnpackerError> cached_installer, |
| base::expected<base::FilePath, UnpackerError> prev_installer) { |
| if (cached_installer.has_value()) { |
| // Skip downloading and patching; run the cached installer. No fallbacks. |
| std::move(callback).Run(base::BindOnce( |
| &Pipeline::Start, |
| base::MakeRefCounted<Pipeline>( |
| [&] { |
| std::queue<Operation> ops; |
| ops.push(base::BindOnce(install)); |
| if (run) { |
| ops.push(base::BindOnce(*run)); |
| } |
| return ops; |
| }(), |
| cached_installer.value(), base::DoNothing(), nullptr))); |
| return; |
| } |
| |
| scoped_refptr<Pipeline> full = nullptr; |
| { |
| // Construct the full update pipeline. |
| // TODO(crbug.com/353249967): It's possible for the diff pipeline to have |
| // created and cached the full download output. Adjust the download step to |
| // check the cache. |
| std::queue<Operation> ops; |
| ops.push(std::move(download_full)); |
| ops.push(base::BindOnce(install)); |
| if (run) { |
| ops.push(base::BindOnce(*run)); |
| } |
| full = base::MakeRefCounted<Pipeline>(std::move(ops), base::FilePath(), |
| base::DoNothing(), full); |
| } |
| |
| if (download_diff && prev_installer.has_value()) { |
| // Do a differential update that falls back to a full update. |
| CHECK(patch_diff); |
| std::queue<Operation> ops; |
| ops.push(std::move(*download_diff)); |
| ops.push(std::move(*patch_diff)); |
| ops.push(base::BindOnce(install)); |
| if (run) { |
| ops.push(base::BindOnce(*run)); |
| } |
| std::move(callback).Run(base::BindOnce( |
| &Pipeline::Start, |
| base::MakeRefCounted<Pipeline>(std::move(ops), base::FilePath(), |
| diff_outcome_recorder, full))); |
| return; |
| } |
| |
| // Else, full update only. |
| std::move(callback).Run(base::BindOnce(&Pipeline::Start, full)); |
| } |
| |
| } // namespace |
| |
| void MakePipeline( |
| scoped_refptr<Configurator> config, |
| base::RepeatingCallback<int64_t(const base::FilePath&)> get_available_space, |
| bool is_foreground, |
| const std::string& session_id, |
| scoped_refptr<CrxCache> crx_cache, |
| crx_file::VerifierFormat crx_format, |
| const std::string& id, |
| const std::vector<uint8_t>& pk_hash, |
| const std::string& install_data_index, |
| const std::string& prev_fp, |
| scoped_refptr<CrxInstaller> installer, |
| base::RepeatingCallback<void(ComponentState)> state_tracker, |
| base::RepeatingCallback<void(base::Value::Dict)> event_adder, |
| CrxDownloader::ProgressCallback download_progress_callback, |
| CrxInstaller::ProgressCallback install_progress_callback, |
| base::RepeatingCallback<void(const CrxInstaller::Result&)> |
| install_complete_callback, |
| scoped_refptr<ActionHandler> action_handler, |
| base::RepeatingCallback<void(const CategorizedError&)> |
| diff_outcome_recorder, |
| const ProtocolParser::Result& result, |
| base::OnceCallback<void( |
| base::expected<base::OnceCallback<base::OnceClosure( |
| base::OnceCallback<void(const CategorizedError&)>)>, |
| CategorizedError>)> callback) { |
| // Run action. |
| std::optional<RepeatingOperation> run; |
| if (!result.action_run.empty()) { |
| run = base::BindRepeating( |
| [](base::RepeatingCallback<void(ComponentState)> state_tracker, |
| const base::FilePath& file, |
| base::OnceCallback<void( |
| base::expected<base::FilePath, CategorizedError>)> |
| callback) { |
| // Discard the input file path, and adapt callback. |
| state_tracker.Run(ComponentState::kRun); |
| return base::BindOnce( |
| [](const base::FilePath& file, bool success, |
| int error, int extra) { |
| // Discard any error result: RunAction failures |
| // don't end the pipeline. |
| return file; |
| }, |
| file) |
| .Then(std::move(callback)); |
| }, |
| state_tracker) |
| .Then(base::BindRepeating(&RunAction, action_handler, installer, |
| result.action_run, session_id, |
| event_adder)); |
| } |
| |
| if (result.status == "noupdate") { |
| if (run) { |
| // The pipeline has a run action only. |
| base::SequencedTaskRunner::GetCurrentDefault()->PostTask( |
| FROM_HERE, |
| base::BindOnce(std::move(callback), |
| base::BindOnce(&Pipeline::Start, |
| base::MakeRefCounted<Pipeline>( |
| [&] { |
| std::queue<Operation> ops; |
| ops.push(*run); |
| return ops; |
| }(), |
| base::FilePath(), |
| diff_outcome_recorder, nullptr)))); |
| return; |
| } |
| // Else, with a noupdate, there's nothing to do. |
| base::SequencedTaskRunner::GetCurrentDefault()->PostTask( |
| FROM_HERE, base::BindOnce(std::move(callback), |
| base::unexpected(CategorizedError()))); |
| return; |
| } |
| |
| if (result.status != "ok" || result.manifest.packages.empty()) { |
| base::SequencedTaskRunner::GetCurrentDefault()->PostTask( |
| FROM_HERE, |
| base::BindOnce(std::move(callback), |
| base::unexpected(CategorizedError( |
| {.category_ = ErrorCategory::kUpdateCheck})))); |
| return; |
| } |
| |
| // Download the update. |
| Operation download_full = |
| base::BindOnce( |
| [](base::RepeatingCallback<void(ComponentState)> state_tracker, |
| const base::FilePath&, |
| base::OnceCallback<void( |
| base::expected<base::FilePath, CategorizedError>)> callback) { |
| // Discard the input file path, set state to downloading, pass |
| // `callback` on to the download. |
| state_tracker.Run(ComponentState::kDownloading); |
| return callback; |
| }, |
| state_tracker) |
| .Then(base::BindOnce( |
| &DownloadOperation, config, get_available_space, is_foreground, |
| [&] { |
| std::vector<GURL> urls; |
| for (const auto& base_url : result.crx_urls) { |
| const GURL url = |
| base_url.Resolve(result.manifest.packages[0].name); |
| if (url.is_valid()) { |
| urls.push_back(url); |
| } |
| } |
| return urls; |
| }(), |
| result.manifest.packages[0].size, |
| result.manifest.packages[0].hash_sha256, event_adder, |
| download_progress_callback)); |
| |
| // Download and patch the diff update. |
| std::optional<Operation> download_diff; |
| std::optional<Operation> patch_diff; |
| if (!result.manifest.packages[0].hashdiff_sha256.empty()) { |
| download_diff = |
| base::BindOnce( |
| [](base::RepeatingCallback<void(ComponentState)> state_tracker, |
| const base::FilePath&, |
| base::OnceCallback<void( |
| base::expected<base::FilePath, CategorizedError>)> |
| callback) { |
| // Discard the input file path, pass `callback` on to the |
| // download. |
| state_tracker.Run(ComponentState::kDownloading); |
| return callback; |
| }, |
| state_tracker) |
| .Then(base::BindOnce( |
| &DownloadOperation, config, get_available_space, is_foreground, |
| [&] { |
| std::vector<GURL> urls; |
| for (const auto& base_url : result.crx_diffurls) { |
| const GURL url = |
| base_url.Resolve(result.manifest.packages[0].namediff); |
| if (url.is_valid()) { |
| urls.push_back(url); |
| } |
| } |
| return urls; |
| }(), |
| result.manifest.packages[0].sizediff, |
| result.manifest.packages[0].hashdiff_sha256, event_adder, |
| download_progress_callback)); |
| patch_diff = base::BindOnce(&PuffOperation, crx_cache, |
| config->GetPatcherFactory()->Create(), |
| event_adder, id, prev_fp); |
| } |
| |
| // Install the update. |
| RepeatingOperation install = base::BindRepeating( |
| [](scoped_refptr<Configurator> config, scoped_refptr<CrxCache> crx_cache, |
| crx_file::VerifierFormat crx_format, const std::string& id, |
| const std::vector<uint8_t>& pk_hash, |
| scoped_refptr<CrxInstaller> installer, const std::string& run, |
| const std::string& arguments, const std::string& install_data, |
| const std::string& fingerprint, |
| base::RepeatingCallback<void(ComponentState)> state_tracker, |
| base::RepeatingCallback<void(base::Value::Dict)> event_adder, |
| CrxInstaller::ProgressCallback install_progress_callback, |
| base::RepeatingCallback<void(const CrxInstaller::Result&)> |
| install_complete_callback, |
| const base::FilePath& file, |
| base::OnceCallback<void( |
| base::expected<base::FilePath, CategorizedError>)> callback) { |
| state_tracker.Run(ComponentState::kUpdating); |
| return InstallOperation( |
| crx_cache, config->GetUnzipperFactory()->Create(), crx_format, id, |
| pk_hash, installer, |
| run.empty() ? nullptr |
| : std::make_unique<CrxInstaller::InstallParams>( |
| run, arguments, install_data), |
| fingerprint, event_adder, install_progress_callback, |
| base::BindOnce( |
| [](const base::FilePath& file, |
| base::RepeatingCallback<void(const CrxInstaller::Result&)> |
| install_complete_callback, |
| const CrxInstaller::Result& result) |
| -> base::expected<base::FilePath, CategorizedError> { |
| install_complete_callback.Run(result); |
| if (result.result.category_ != ErrorCategory::kNone) { |
| return base::unexpected(result.result); |
| } |
| return file; |
| }, |
| file, install_complete_callback) |
| .Then(std::move(callback)), |
| file); |
| }, |
| config, crx_cache, crx_format, id, pk_hash, installer, |
| result.manifest.run, result.manifest.arguments, |
| [&]() -> std::string { |
| if (install_data_index.empty() || result.data.empty()) { |
| return ""; |
| } |
| const auto it = std::ranges::find( |
| result.data, install_data_index, |
| &ProtocolParser::Result::Data::install_data_index); |
| return it != std::end(result.data) ? it->text : ""; |
| }(), |
| result.manifest.packages[0].fingerprint, state_tracker, event_adder, |
| install_progress_callback, install_complete_callback); |
| |
| crx_cache->Get( |
| id, result.manifest.packages[0].fingerprint, |
| base::BindOnce( |
| [](scoped_refptr<CrxCache> crx_cache, const std::string& id, |
| const std::string& prev_fp, |
| base::OnceCallback<void( |
| base::expected<base::FilePath, UnpackerError>, |
| base::expected<base::FilePath, UnpackerError>)> callback, |
| base::expected<base::FilePath, UnpackerError> installer) { |
| crx_cache->Get(id, prev_fp, |
| base::BindOnce(std::move(callback), installer)); |
| }, |
| crx_cache, id, prev_fp, |
| base::BindOnce(&AssemblePipeline, std::move(download_diff), |
| std::move(patch_diff), std::move(download_full), |
| install, run, diff_outcome_recorder, |
| std::move(callback)))); |
| return; |
| } |
| |
| } // namespace update_client |
