Android: Implement the update attempter for Android. This patch implements the update workflow for non-Brillo targets. Only the applyPayload() method is implemented here with a minimal subset of functionally implemented in it. This new class acts as the service delegate, handling all the binder service method calls for non-Brillo targets. Bug: 25631949 TEST=FEATURES=test emerge-link update_engine TEST=`mmma system/update_engine` on aosp_arm-eng and edison-eng TEST=Deployed on a non-Brillo device and tested with update_engine_client Change-Id: I678cd141633bc2c0920a09ef27a02d53682d5330
diff --git a/update_attempter_android.cc b/update_attempter_android.cc new file mode 100644 index 0000000..131efbb --- /dev/null +++ b/update_attempter_android.cc
@@ -0,0 +1,389 @@ +// +// Copyright (C) 2016 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_attempter_android.h" + +#include <algorithm> +#include <utility> + +#include <base/bind.h> +#include <base/logging.h> +#include <brillo/bind_lambda.h> +#include <brillo/message_loops/message_loop.h> + +#include "update_engine/common/constants.h" +#include "update_engine/common/libcurl_http_fetcher.h" +#include "update_engine/common/multi_range_http_fetcher.h" +#include "update_engine/common/utils.h" +#include "update_engine/daemon_state_android.h" +#include "update_engine/payload_consumer/download_action.h" +#include "update_engine/payload_consumer/filesystem_verifier_action.h" +#include "update_engine/payload_consumer/postinstall_runner_action.h" + +using base::Bind; +using base::TimeDelta; +using base::TimeTicks; +using std::shared_ptr; +using std::string; +using std::vector; + +namespace chromeos_update_engine { + +namespace { + +const char* const kErrorDomain = "update_engine"; +// TODO(deymo): Convert the different errors to a numeric value to report them +// back on the service error. +const char* const kGenericError = "generic_error"; + +// Log and set the error on the passed ErrorPtr. +bool LogAndSetError(brillo::ErrorPtr* error, + const tracked_objects::Location& location, + const string& reason) { + brillo::Error::AddTo(error, location, kErrorDomain, kGenericError, reason); + LOG(ERROR) << "Replying with failure: " << location.ToString() << ": " + << reason; + return false; +} + +} // namespace + +UpdateAttempterAndroid::UpdateAttempterAndroid( + DaemonStateAndroid* daemon_state, + PrefsInterface* prefs, + BootControlInterface* boot_control, + HardwareInterface* hardware) + : daemon_state_(daemon_state), + prefs_(prefs), + boot_control_(boot_control), + hardware_(hardware), + processor_(new ActionProcessor()) { +} + +UpdateAttempterAndroid::~UpdateAttempterAndroid() { + // Release ourselves as the ActionProcessor's delegate to prevent + // re-scheduling the updates due to the processing stopped. + processor_->set_delegate(nullptr); +} + +void UpdateAttempterAndroid::Init() { + // In case of update_engine restart without a reboot we need to restore the + // reboot needed state. + if (UpdateCompletedOnThisBoot()) + status_ = UpdateStatus::UPDATED_NEED_REBOOT; + else + status_ = UpdateStatus::IDLE; +} + +bool UpdateAttempterAndroid::ApplyPayload( + const string& payload_url, + int64_t payload_offset, + int64_t payload_size, + const vector<string>& key_value_pair_headers, + brillo::ErrorPtr* error) { + if (status_ == UpdateStatus::UPDATED_NEED_REBOOT) { + return LogAndSetError( + error, FROM_HERE, "An update already applied, waiting for reboot"); + } + if (ongoing_update_) { + return LogAndSetError( + error, FROM_HERE, "Already processing an update, cancel it first."); + } + DCHECK(status_ == UpdateStatus::IDLE); + + // Unique identifier for the payload. + // TODO(deymo): Set this the payload unique id using a value passed in the + // |key_value_pair_headers| list to allow resuming updates. + string payload_id = ""; + + // Setup the InstallPlan based on the request. + install_plan_ = InstallPlan(); + + install_plan_.download_url = payload_url; + install_plan_.version = ""; + install_plan_.payload_size = payload_size; + // TODO(deymo): Retrieve the payload_hash from the properties. + install_plan_.payload_hash = ""; + install_plan_.metadata_size = 0; + install_plan_.metadata_signature = ""; + // The |public_key_rsa| key would override the public key stored on disk. + install_plan_.public_key_rsa = ""; + + install_plan_.hash_checks_mandatory = hardware_->IsOfficialBuild(); + install_plan_.is_resume = !payload_id.empty() && + DeltaPerformer::CanResumeUpdate(prefs_, payload_id); + if (!install_plan_.is_resume) { + if (!DeltaPerformer::ResetUpdateProgress(prefs_, false)) { + LOG(WARNING) << "Unable to reset the update progress."; + } + if (!prefs_->SetString(kPrefsUpdateCheckResponseHash, payload_id)) { + LOG(WARNING) << "Unable to save the update check response hash."; + } + } + // The |is_full_update| is not used anymore since minor_version 3. + install_plan_.is_full_update = true; + + install_plan_.source_slot = boot_control_->GetCurrentSlot(); + install_plan_.target_slot = install_plan_.source_slot == 0 ? 1 : 0; + install_plan_.powerwash_required = false; + + LOG(INFO) << "Using this install plan:"; + install_plan_.Dump(); + + BuildUpdateActions(); + SetupDownload(); + cpu_limiter_.StartLimiter(); + SetStatusAndNotify(UpdateStatus::UPDATE_AVAILABLE); + + // Just in case we didn't update boot flags yet, make sure they're updated + // before any update processing starts. This will start the update process. + UpdateBootFlags(); + return true; +} + +bool UpdateAttempterAndroid::SuspendUpdate(brillo::ErrorPtr* error) { + // TODO(deymo): Implement suspend/resume. + return LogAndSetError(error, FROM_HERE, "Suspend/resume not implemented"); +} + +bool UpdateAttempterAndroid::ResumeUpdate(brillo::ErrorPtr* error) { + // TODO(deymo): Implement suspend/resume. + return LogAndSetError(error, FROM_HERE, "Suspend/resume not implemented"); +} + +bool UpdateAttempterAndroid::CancelUpdate(brillo::ErrorPtr* error) { + if (status_ == UpdateStatus::IDLE || + status_ == UpdateStatus::UPDATED_NEED_REBOOT) { + return LogAndSetError(error, FROM_HERE, "No ongoing update to cancel."); + } + + // TODO(deymo): Implement cancel. + return LogAndSetError(error, FROM_HERE, "Cancel not implemented"); +} + +void UpdateAttempterAndroid::ProcessingDone(const ActionProcessor* processor, + ErrorCode code) { + LOG(INFO) << "Processing Done."; + + if (code == ErrorCode::kSuccess) { + // Update succeeded. + WriteUpdateCompletedMarker(); + prefs_->SetInt64(kPrefsDeltaUpdateFailures, 0); + DeltaPerformer::ResetUpdateProgress(prefs_, false); + + LOG(INFO) << "Update successfully applied, waiting to reboot."; + } + + TerminateUpdateAndNotify(code); +} + +void UpdateAttempterAndroid::ProcessingStopped( + const ActionProcessor* processor) { + TerminateUpdateAndNotify(ErrorCode::kUserCanceled); +} + +void UpdateAttempterAndroid::ActionCompleted(ActionProcessor* processor, + AbstractAction* action, + ErrorCode code) { + // Reset download progress regardless of whether or not the download + // action succeeded. + const string type = action->Type(); + if (type == DownloadAction::StaticType()) { + download_progress_ = 0.0; + } + if (code != ErrorCode::kSuccess) { + // If an action failed, the ActionProcessor will cancel the whole thing. + return; + } + if (type == DownloadAction::StaticType()) { + SetStatusAndNotify(UpdateStatus::FINALIZING); + } +} + +void UpdateAttempterAndroid::BytesReceived(uint64_t bytes_progressed, + uint64_t bytes_received, + uint64_t total) { + double progress = 0.; + if (total) + progress = static_cast<double>(bytes_received) / static_cast<double>(total); + // Self throttle based on progress. Also send notifications if + // progress is too slow. + const double kDeltaPercent = 0.01; // 1% + if (status_ != UpdateStatus::DOWNLOADING || bytes_received == total || + progress - download_progress_ >= kDeltaPercent || + TimeTicks::Now() - last_notify_time_ >= TimeDelta::FromSeconds(10)) { + download_progress_ = progress; + SetStatusAndNotify(UpdateStatus::DOWNLOADING); + } +} + +bool UpdateAttempterAndroid::ShouldCancel(ErrorCode* cancel_reason) { + // TODO(deymo): Notify the DownloadAction that it should cancel the update + // download. + return false; +} + +void UpdateAttempterAndroid::DownloadComplete() { + // Nothing needs to be done when the download completes. +} + +void UpdateAttempterAndroid::UpdateBootFlags() { + if (updated_boot_flags_) { + LOG(INFO) << "Already updated boot flags. Skipping."; + CompleteUpdateBootFlags(true); + return; + } + // This is purely best effort. + LOG(INFO) << "Marking booted slot as good."; + if (!boot_control_->MarkBootSuccessfulAsync( + Bind(&UpdateAttempterAndroid::CompleteUpdateBootFlags, + base::Unretained(this)))) { + LOG(ERROR) << "Failed to mark current boot as successful."; + CompleteUpdateBootFlags(false); + } +} + +void UpdateAttempterAndroid::CompleteUpdateBootFlags(bool successful) { + updated_boot_flags_ = true; + ScheduleProcessingStart(); +} + +void UpdateAttempterAndroid::ScheduleProcessingStart() { + LOG(INFO) << "Scheduling an action processor start."; + brillo::MessageLoop::current()->PostTask( + FROM_HERE, Bind([this] { this->processor_->StartProcessing(); })); +} + +void UpdateAttempterAndroid::TerminateUpdateAndNotify(ErrorCode error_code) { + if (status_ == UpdateStatus::IDLE) { + LOG(ERROR) << "No ongoing update, but TerminatedUpdate() called."; + return; + } + + // Reset cpu shares back to normal. + cpu_limiter_.StopLimiter(); + download_progress_ = 0.0; + actions_.clear(); + UpdateStatus new_status = + (error_code == ErrorCode::kSuccess ? UpdateStatus::UPDATED_NEED_REBOOT + : UpdateStatus::IDLE); + SetStatusAndNotify(new_status); + ongoing_update_ = false; + + for (auto observer : daemon_state_->service_observers()) + observer->SendPayloadApplicationComplete(error_code); +} + +void UpdateAttempterAndroid::SetStatusAndNotify(UpdateStatus status) { + status_ = status; + for (auto observer : daemon_state_->service_observers()) { + observer->SendStatusUpdate( + 0, download_progress_, status_, "", install_plan_.payload_size); + } + last_notify_time_ = TimeTicks::Now(); +} + +void UpdateAttempterAndroid::BuildUpdateActions() { + CHECK(!processor_->IsRunning()); + processor_->set_delegate(this); + + // Actions: + shared_ptr<InstallPlanAction> install_plan_action( + new InstallPlanAction(install_plan_)); + + LibcurlHttpFetcher* download_fetcher = + new LibcurlHttpFetcher(&proxy_resolver_, hardware_); + download_fetcher->set_server_to_check(ServerToCheck::kDownload); + shared_ptr<DownloadAction> download_action(new DownloadAction( + prefs_, + boot_control_, + hardware_, + nullptr, // system_state, not used. + new MultiRangeHttpFetcher(download_fetcher))); // passes ownership + shared_ptr<FilesystemVerifierAction> dst_filesystem_verifier_action( + new FilesystemVerifierAction(boot_control_, + VerifierMode::kVerifyTargetHash)); + + shared_ptr<PostinstallRunnerAction> postinstall_runner_action( + new PostinstallRunnerAction(boot_control_)); + + download_action->set_delegate(this); + download_action_ = download_action; + + actions_.push_back(shared_ptr<AbstractAction>(install_plan_action)); + actions_.push_back(shared_ptr<AbstractAction>(download_action)); + actions_.push_back( + shared_ptr<AbstractAction>(dst_filesystem_verifier_action)); + actions_.push_back(shared_ptr<AbstractAction>(postinstall_runner_action)); + + // Bond them together. We have to use the leaf-types when calling + // BondActions(). + BondActions(install_plan_action.get(), download_action.get()); + BondActions(download_action.get(), dst_filesystem_verifier_action.get()); + BondActions(dst_filesystem_verifier_action.get(), + postinstall_runner_action.get()); + + // Enqueue the actions. + for (const shared_ptr<AbstractAction>& action : actions_) + processor_->EnqueueAction(action.get()); +} + +void UpdateAttempterAndroid::SetupDownload() { + MultiRangeHttpFetcher* fetcher = + static_cast<MultiRangeHttpFetcher*>(download_action_->http_fetcher()); + fetcher->ClearRanges(); + if (install_plan_.is_resume) { + // Resuming an update so fetch the update manifest metadata first. + int64_t manifest_metadata_size = 0; + prefs_->GetInt64(kPrefsManifestMetadataSize, &manifest_metadata_size); + fetcher->AddRange(0, manifest_metadata_size); + // If there're remaining unprocessed data blobs, fetch them. Be careful not + // to request data beyond the end of the payload to avoid 416 HTTP response + // error codes. + int64_t next_data_offset = 0; + prefs_->GetInt64(kPrefsUpdateStateNextDataOffset, &next_data_offset); + uint64_t resume_offset = manifest_metadata_size + next_data_offset; + if (!install_plan_.payload_size || + resume_offset < install_plan_.payload_size) { + fetcher->AddRange(resume_offset); + } + } else { + fetcher->AddRange(0); + } +} + +bool UpdateAttempterAndroid::WriteUpdateCompletedMarker() { + string boot_id; + TEST_AND_RETURN_FALSE(utils::GetBootId(&boot_id)); + prefs_->SetString(kPrefsUpdateCompletedOnBootId, boot_id); + return true; +} + +bool UpdateAttempterAndroid::UpdateCompletedOnThisBoot() { + // In case of an update_engine restart without a reboot, we stored the boot_id + // when the update was completed by setting a pref, so we can check whether + // the last update was on this boot or a previous one. + string boot_id; + TEST_AND_RETURN_FALSE(utils::GetBootId(&boot_id)); + + string update_completed_on_boot_id; + return (prefs_->Exists(kPrefsUpdateCompletedOnBootId) && + prefs_->GetString(kPrefsUpdateCompletedOnBootId, + &update_completed_on_boot_id) && + update_completed_on_boot_id == boot_id); +} + +} // namespace chromeos_update_engine