update_attempter.cc revision c7cc45e4ac9ca1f4693dfc93e4ff203992d446a1 
1//
2// Copyright (C) 2012 The Android Open Source Project
3//
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at
7//
8//      http://www.apache.org/licenses/LICENSE-2.0
9//
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15//
16
17#include "update_engine/update_attempter.h"
18
19#include <stdint.h>
20
21#include <algorithm>
22#include <memory>
23#include <set>
24#include <string>
25#include <utility>
26#include <vector>
27
28#include <base/bind.h>
29#include <base/files/file_util.h>
30#include <base/logging.h>
31#include <base/rand_util.h>
32#include <base/strings/string_util.h>
33#include <base/strings/stringprintf.h>
34#include <brillo/bind_lambda.h>
35#include <brillo/make_unique_ptr.h>
36#include <brillo/message_loops/message_loop.h>
37#include <debugd/dbus-constants.h>
38#include <policy/device_policy.h>
39#include <policy/libpolicy.h>
40#include <power_manager/dbus-constants.h>
41#include <power_manager/dbus-proxies.h>
42#include <update_engine/dbus-constants.h>
43
44#include "update_engine/common/boot_control_interface.h"
45#include "update_engine/common/certificate_checker.h"
46#include "update_engine/common/clock_interface.h"
47#include "update_engine/common/constants.h"
48#include "update_engine/common/hardware_interface.h"
49#include "update_engine/common/libcurl_http_fetcher.h"
50#include "update_engine/common/multi_range_http_fetcher.h"
51#include "update_engine/common/platform_constants.h"
52#include "update_engine/common/prefs_interface.h"
53#include "update_engine/common/subprocess.h"
54#include "update_engine/common/utils.h"
55#include "update_engine/dbus_service.h"
56#include "update_engine/metrics.h"
57#include "update_engine/omaha_request_action.h"
58#include "update_engine/omaha_request_params.h"
59#include "update_engine/omaha_response_handler_action.h"
60#include "update_engine/p2p_manager.h"
61#include "update_engine/payload_consumer/download_action.h"
62#include "update_engine/payload_consumer/filesystem_verifier_action.h"
63#include "update_engine/payload_consumer/postinstall_runner_action.h"
64#include "update_engine/payload_state_interface.h"
65#include "update_engine/system_state.h"
66#include "update_engine/update_manager/policy.h"
67#include "update_engine/update_manager/update_manager.h"
68#include "update_engine/update_status_utils.h"
69
70using base::Bind;
71using base::Callback;
72using base::Time;
73using base::TimeDelta;
74using base::TimeTicks;
75using brillo::MessageLoop;
76using chromeos_update_manager::EvalStatus;
77using chromeos_update_manager::Policy;
78using chromeos_update_manager::UpdateCheckParams;
79using std::set;
80using std::shared_ptr;
81using std::string;
82using std::vector;
83
84namespace chromeos_update_engine {
85
86const int UpdateAttempter::kMaxDeltaUpdateFailures = 3;
87
88namespace {
89const int kMaxConsecutiveObeyProxyRequests = 20;
90
91// By default autest bypasses scattering. If we want to test scattering,
92// use kScheduledAUTestURLRequest. The URL used is same in both cases, but
93// different params are passed to CheckForUpdate().
94const char kAUTestURLRequest[] = "autest";
95const char kScheduledAUTestURLRequest[] = "autest-scheduled";
96}  // namespace
97
98// Turns a generic ErrorCode::kError to a generic error code specific
99// to |action| (e.g., ErrorCode::kFilesystemVerifierError). If |code| is
100// not ErrorCode::kError, or the action is not matched, returns |code|
101// unchanged.
102ErrorCode GetErrorCodeForAction(AbstractAction* action,
103                                     ErrorCode code) {
104  if (code != ErrorCode::kError)
105    return code;
106
107  const string type = action->Type();
108  if (type == OmahaRequestAction::StaticType())
109    return ErrorCode::kOmahaRequestError;
110  if (type == OmahaResponseHandlerAction::StaticType())
111    return ErrorCode::kOmahaResponseHandlerError;
112  if (type == FilesystemVerifierAction::StaticType())
113    return ErrorCode::kFilesystemVerifierError;
114  if (type == PostinstallRunnerAction::StaticType())
115    return ErrorCode::kPostinstallRunnerError;
116
117  return code;
118}
119
120UpdateAttempter::UpdateAttempter(
121    SystemState* system_state,
122    CertificateChecker* cert_checker,
123    LibCrosProxy* libcros_proxy,
124    org::chromium::debugdProxyInterface* debugd_proxy)
125    : processor_(new ActionProcessor()),
126      system_state_(system_state),
127      cert_checker_(cert_checker),
128      chrome_proxy_resolver_(libcros_proxy),
129      debugd_proxy_(debugd_proxy) {
130}
131
132UpdateAttempter::~UpdateAttempter() {
133  // CertificateChecker might not be initialized in unittests.
134  if (cert_checker_)
135    cert_checker_->SetObserver(nullptr);
136  CleanupCpuSharesManagement();
137  // Release ourselves as the ActionProcessor's delegate to prevent
138  // re-scheduling the updates due to the processing stopped.
139  processor_->set_delegate(nullptr);
140}
141
142void UpdateAttempter::Init() {
143  // Pulling from the SystemState can only be done after construction, since
144  // this is an aggregate of various objects (such as the UpdateAttempter),
145  // which requires them all to be constructed prior to it being used.
146  prefs_ = system_state_->prefs();
147  omaha_request_params_ = system_state_->request_params();
148
149  if (cert_checker_)
150    cert_checker_->SetObserver(this);
151
152  // In case of update_engine restart without a reboot we need to restore the
153  // reboot needed state.
154  if (GetBootTimeAtUpdate(nullptr))
155    status_ = UpdateStatus::UPDATED_NEED_REBOOT;
156  else
157    status_ = UpdateStatus::IDLE;
158
159  chrome_proxy_resolver_.Init();
160}
161
162void UpdateAttempter::ScheduleUpdates() {
163  if (IsUpdateRunningOrScheduled())
164    return;
165
166  chromeos_update_manager::UpdateManager* const update_manager =
167      system_state_->update_manager();
168  CHECK(update_manager);
169  Callback<void(EvalStatus, const UpdateCheckParams&)> callback = Bind(
170      &UpdateAttempter::OnUpdateScheduled, base::Unretained(this));
171  // We limit the async policy request to a reasonably short time, to avoid a
172  // starvation due to a transient bug.
173  update_manager->AsyncPolicyRequest(callback, &Policy::UpdateCheckAllowed);
174  waiting_for_scheduled_check_ = true;
175}
176
177void UpdateAttempter::CertificateChecked(ServerToCheck server_to_check,
178                                         CertificateCheckResult result) {
179  metrics::ReportCertificateCheckMetrics(system_state_,
180                                         server_to_check,
181                                         result);
182}
183
184bool UpdateAttempter::CheckAndReportDailyMetrics() {
185  int64_t stored_value;
186  Time now = system_state_->clock()->GetWallclockTime();
187  if (system_state_->prefs()->Exists(kPrefsDailyMetricsLastReportedAt) &&
188      system_state_->prefs()->GetInt64(kPrefsDailyMetricsLastReportedAt,
189                                       &stored_value)) {
190    Time last_reported_at = Time::FromInternalValue(stored_value);
191    TimeDelta time_reported_since = now - last_reported_at;
192    if (time_reported_since.InSeconds() < 0) {
193      LOG(WARNING) << "Last reported daily metrics "
194                   << utils::FormatTimeDelta(time_reported_since) << " ago "
195                   << "which is negative. Either the system clock is wrong or "
196                   << "the kPrefsDailyMetricsLastReportedAt state variable "
197                   << "is wrong.";
198      // In this case, report daily metrics to reset.
199    } else {
200      if (time_reported_since.InSeconds() < 24*60*60) {
201        LOG(INFO) << "Last reported daily metrics "
202                  << utils::FormatTimeDelta(time_reported_since) << " ago.";
203        return false;
204      }
205      LOG(INFO) << "Last reported daily metrics "
206                << utils::FormatTimeDelta(time_reported_since) << " ago, "
207                << "which is more than 24 hours ago.";
208    }
209  }
210
211  LOG(INFO) << "Reporting daily metrics.";
212  system_state_->prefs()->SetInt64(kPrefsDailyMetricsLastReportedAt,
213                                   now.ToInternalValue());
214
215  ReportOSAge();
216
217  return true;
218}
219
220void UpdateAttempter::ReportOSAge() {
221  struct stat sb;
222
223  if (system_state_ == nullptr)
224    return;
225
226  if (stat("/etc/lsb-release", &sb) != 0) {
227    PLOG(ERROR) << "Error getting file status for /etc/lsb-release "
228                << "(Note: this may happen in some unit tests)";
229    return;
230  }
231
232  Time lsb_release_timestamp = utils::TimeFromStructTimespec(&sb.st_ctim);
233  Time now = system_state_->clock()->GetWallclockTime();
234  TimeDelta age = now - lsb_release_timestamp;
235  if (age.InSeconds() < 0) {
236    LOG(ERROR) << "The OS age (" << utils::FormatTimeDelta(age)
237               << ") is negative. Maybe the clock is wrong? "
238               << "(Note: this may happen in some unit tests.)";
239    return;
240  }
241
242  metrics::ReportDailyMetrics(system_state_, age);
243}
244
245void UpdateAttempter::Update(const string& app_version,
246                             const string& omaha_url,
247                             const string& target_channel,
248                             const string& target_version_prefix,
249                             bool obey_proxies,
250                             bool interactive) {
251  // This is normally called frequently enough so it's appropriate to use as a
252  // hook for reporting daily metrics.
253  // TODO(garnold) This should be hooked to a separate (reliable and consistent)
254  // timeout event.
255  CheckAndReportDailyMetrics();
256
257  // Notify of the new update attempt, clearing prior interactive requests.
258  if (forced_update_pending_callback_.get())
259    forced_update_pending_callback_->Run(false, false);
260
261  fake_update_success_ = false;
262  if (status_ == UpdateStatus::UPDATED_NEED_REBOOT) {
263    // Although we have applied an update, we still want to ping Omaha
264    // to ensure the number of active statistics is accurate.
265    //
266    // Also convey to the UpdateEngine.Check.Result metric that we're
267    // not performing an update check because of this.
268    LOG(INFO) << "Not updating b/c we already updated and we're waiting for "
269              << "reboot, we'll ping Omaha instead";
270    metrics::ReportUpdateCheckMetrics(system_state_,
271                                      metrics::CheckResult::kRebootPending,
272                                      metrics::CheckReaction::kUnset,
273                                      metrics::DownloadErrorCode::kUnset);
274    PingOmaha();
275    return;
276  }
277  if (status_ != UpdateStatus::IDLE) {
278    // Update in progress. Do nothing
279    return;
280  }
281
282  if (!CalculateUpdateParams(app_version,
283                             omaha_url,
284                             target_channel,
285                             target_version_prefix,
286                             obey_proxies,
287                             interactive)) {
288    return;
289  }
290
291  BuildUpdateActions(interactive);
292
293  SetStatusAndNotify(UpdateStatus::CHECKING_FOR_UPDATE);
294
295  // Update the last check time here; it may be re-updated when an Omaha
296  // response is received, but this will prevent us from repeatedly scheduling
297  // checks in the case where a response is not received.
298  UpdateLastCheckedTime();
299
300  // Just in case we didn't update boot flags yet, make sure they're updated
301  // before any update processing starts.
302  start_action_processor_ = true;
303  UpdateBootFlags();
304}
305
306void UpdateAttempter::RefreshDevicePolicy() {
307  // Lazy initialize the policy provider, or reload the latest policy data.
308  if (!policy_provider_.get())
309    policy_provider_.reset(new policy::PolicyProvider());
310  policy_provider_->Reload();
311
312  const policy::DevicePolicy* device_policy = nullptr;
313  if (policy_provider_->device_policy_is_loaded())
314    device_policy = &policy_provider_->GetDevicePolicy();
315
316  if (device_policy)
317    LOG(INFO) << "Device policies/settings present";
318  else
319    LOG(INFO) << "No device policies/settings present.";
320
321  system_state_->set_device_policy(device_policy);
322  system_state_->p2p_manager()->SetDevicePolicy(device_policy);
323}
324
325void UpdateAttempter::CalculateP2PParams(bool interactive) {
326  bool use_p2p_for_downloading = false;
327  bool use_p2p_for_sharing = false;
328
329  // Never use p2p for downloading in interactive checks unless the
330  // developer has opted in for it via a marker file.
331  //
332  // (Why would a developer want to opt in? If he's working on the
333  // update_engine or p2p codebases so he can actually test his
334  // code.).
335
336  if (system_state_ != nullptr) {
337    if (!system_state_->p2p_manager()->IsP2PEnabled()) {
338      LOG(INFO) << "p2p is not enabled - disallowing p2p for both"
339                << " downloading and sharing.";
340    } else {
341      // Allow p2p for sharing, even in interactive checks.
342      use_p2p_for_sharing = true;
343      if (!interactive) {
344        LOG(INFO) << "Non-interactive check - allowing p2p for downloading";
345        use_p2p_for_downloading = true;
346      } else {
347        LOG(INFO) << "Forcibly disabling use of p2p for downloading "
348                  << "since this update attempt is interactive.";
349      }
350    }
351  }
352
353  PayloadStateInterface* const payload_state = system_state_->payload_state();
354  payload_state->SetUsingP2PForDownloading(use_p2p_for_downloading);
355  payload_state->SetUsingP2PForSharing(use_p2p_for_sharing);
356}
357
358bool UpdateAttempter::CalculateUpdateParams(const string& app_version,
359                                            const string& omaha_url,
360                                            const string& target_channel,
361                                            const string& target_version_prefix,
362                                            bool obey_proxies,
363                                            bool interactive) {
364  http_response_code_ = 0;
365  PayloadStateInterface* const payload_state = system_state_->payload_state();
366
367  // Refresh the policy before computing all the update parameters.
368  RefreshDevicePolicy();
369
370  // Set the target version prefix, if provided.
371  if (!target_version_prefix.empty())
372    omaha_request_params_->set_target_version_prefix(target_version_prefix);
373
374  CalculateScatteringParams(interactive);
375
376  CalculateP2PParams(interactive);
377  if (payload_state->GetUsingP2PForDownloading() ||
378      payload_state->GetUsingP2PForSharing()) {
379    // OK, p2p is to be used - start it and perform housekeeping.
380    if (!StartP2PAndPerformHousekeeping()) {
381      // If this fails, disable p2p for this attempt
382      LOG(INFO) << "Forcibly disabling use of p2p since starting p2p or "
383                << "performing housekeeping failed.";
384      payload_state->SetUsingP2PForDownloading(false);
385      payload_state->SetUsingP2PForSharing(false);
386    }
387  }
388
389  if (!omaha_request_params_->Init(app_version,
390                                   omaha_url,
391                                   interactive)) {
392    LOG(ERROR) << "Unable to initialize Omaha request params.";
393    return false;
394  }
395
396  // Set the target channel, if one was provided.
397  if (target_channel.empty()) {
398    LOG(INFO) << "No target channel mandated by policy.";
399  } else {
400    LOG(INFO) << "Setting target channel as mandated: " << target_channel;
401    // Pass in false for powerwash_allowed until we add it to the policy
402    // protobuf.
403    string error_message;
404    if (!omaha_request_params_->SetTargetChannel(target_channel, false,
405                                                 &error_message)) {
406      LOG(ERROR) << "Setting the channel failed: " << error_message;
407    }
408
409    // Since this is the beginning of a new attempt, update the download
410    // channel. The download channel won't be updated until the next attempt,
411    // even if target channel changes meanwhile, so that how we'll know if we
412    // should cancel the current download attempt if there's such a change in
413    // target channel.
414    omaha_request_params_->UpdateDownloadChannel();
415  }
416
417  LOG(INFO) << "target_version_prefix = "
418            << omaha_request_params_->target_version_prefix()
419            << ", scatter_factor_in_seconds = "
420            << utils::FormatSecs(scatter_factor_.InSeconds());
421
422  LOG(INFO) << "Wall Clock Based Wait Enabled = "
423            << omaha_request_params_->wall_clock_based_wait_enabled()
424            << ", Update Check Count Wait Enabled = "
425            << omaha_request_params_->update_check_count_wait_enabled()
426            << ", Waiting Period = " << utils::FormatSecs(
427               omaha_request_params_->waiting_period().InSeconds());
428
429  LOG(INFO) << "Use p2p For Downloading = "
430            << payload_state->GetUsingP2PForDownloading()
431            << ", Use p2p For Sharing = "
432            << payload_state->GetUsingP2PForSharing();
433
434  obeying_proxies_ = true;
435  if (obey_proxies || proxy_manual_checks_ == 0) {
436    LOG(INFO) << "forced to obey proxies";
437    // If forced to obey proxies, every 20th request will not use proxies
438    proxy_manual_checks_++;
439    LOG(INFO) << "proxy manual checks: " << proxy_manual_checks_;
440    if (proxy_manual_checks_ >= kMaxConsecutiveObeyProxyRequests) {
441      proxy_manual_checks_ = 0;
442      obeying_proxies_ = false;
443    }
444  } else if (base::RandInt(0, 4) == 0) {
445    obeying_proxies_ = false;
446  }
447  LOG_IF(INFO, !obeying_proxies_) << "To help ensure updates work, this update "
448      "check we are ignoring the proxy settings and using "
449      "direct connections.";
450
451  DisableDeltaUpdateIfNeeded();
452  return true;
453}
454
455void UpdateAttempter::CalculateScatteringParams(bool interactive) {
456  // Take a copy of the old scatter value before we update it, as
457  // we need to update the waiting period if this value changes.
458  TimeDelta old_scatter_factor = scatter_factor_;
459  const policy::DevicePolicy* device_policy = system_state_->device_policy();
460  if (device_policy) {
461    int64_t new_scatter_factor_in_secs = 0;
462    device_policy->GetScatterFactorInSeconds(&new_scatter_factor_in_secs);
463    if (new_scatter_factor_in_secs < 0)  // sanitize input, just in case.
464      new_scatter_factor_in_secs  = 0;
465    scatter_factor_ = TimeDelta::FromSeconds(new_scatter_factor_in_secs);
466  }
467
468  bool is_scatter_enabled = false;
469  if (scatter_factor_.InSeconds() == 0) {
470    LOG(INFO) << "Scattering disabled since scatter factor is set to 0";
471  } else if (interactive) {
472    LOG(INFO) << "Scattering disabled as this is an interactive update check";
473  } else if (!system_state_->hardware()->IsOOBEComplete(nullptr)) {
474    LOG(INFO) << "Scattering disabled since OOBE is not complete yet";
475  } else {
476    is_scatter_enabled = true;
477    LOG(INFO) << "Scattering is enabled";
478  }
479
480  if (is_scatter_enabled) {
481    // This means the scattering policy is turned on.
482    // Now check if we need to update the waiting period. The two cases
483    // in which we'd need to update the waiting period are:
484    // 1. First time in process or a scheduled check after a user-initiated one.
485    //    (omaha_request_params_->waiting_period will be zero in this case).
486    // 2. Admin has changed the scattering policy value.
487    //    (new scattering value will be different from old one in this case).
488    int64_t wait_period_in_secs = 0;
489    if (omaha_request_params_->waiting_period().InSeconds() == 0) {
490      // First case. Check if we have a suitable value to set for
491      // the waiting period.
492      if (prefs_->GetInt64(kPrefsWallClockWaitPeriod, &wait_period_in_secs) &&
493          wait_period_in_secs > 0 &&
494          wait_period_in_secs <= scatter_factor_.InSeconds()) {
495        // This means:
496        // 1. There's a persisted value for the waiting period available.
497        // 2. And that persisted value is still valid.
498        // So, in this case, we should reuse the persisted value instead of
499        // generating a new random value to improve the chances of a good
500        // distribution for scattering.
501        omaha_request_params_->set_waiting_period(
502          TimeDelta::FromSeconds(wait_period_in_secs));
503        LOG(INFO) << "Using persisted wall-clock waiting period: " <<
504            utils::FormatSecs(
505                omaha_request_params_->waiting_period().InSeconds());
506      } else {
507        // This means there's no persisted value for the waiting period
508        // available or its value is invalid given the new scatter_factor value.
509        // So, we should go ahead and regenerate a new value for the
510        // waiting period.
511        LOG(INFO) << "Persisted value not present or not valid ("
512                  << utils::FormatSecs(wait_period_in_secs)
513                  << ") for wall-clock waiting period.";
514        GenerateNewWaitingPeriod();
515      }
516    } else if (scatter_factor_ != old_scatter_factor) {
517      // This means there's already a waiting period value, but we detected
518      // a change in the scattering policy value. So, we should regenerate the
519      // waiting period to make sure it's within the bounds of the new scatter
520      // factor value.
521      GenerateNewWaitingPeriod();
522    } else {
523      // Neither the first time scattering is enabled nor the scattering value
524      // changed. Nothing to do.
525      LOG(INFO) << "Keeping current wall-clock waiting period: " <<
526          utils::FormatSecs(
527              omaha_request_params_->waiting_period().InSeconds());
528    }
529
530    // The invariant at this point is that omaha_request_params_->waiting_period
531    // is non-zero no matter which path we took above.
532    LOG_IF(ERROR, omaha_request_params_->waiting_period().InSeconds() == 0)
533        << "Waiting Period should NOT be zero at this point!!!";
534
535    // Since scattering is enabled, wall clock based wait will always be
536    // enabled.
537    omaha_request_params_->set_wall_clock_based_wait_enabled(true);
538
539    // If we don't have any issues in accessing the file system to update
540    // the update check count value, we'll turn that on as well.
541    bool decrement_succeeded = DecrementUpdateCheckCount();
542    omaha_request_params_->set_update_check_count_wait_enabled(
543      decrement_succeeded);
544  } else {
545    // This means the scattering feature is turned off or disabled for
546    // this particular update check. Make sure to disable
547    // all the knobs and artifacts so that we don't invoke any scattering
548    // related code.
549    omaha_request_params_->set_wall_clock_based_wait_enabled(false);
550    omaha_request_params_->set_update_check_count_wait_enabled(false);
551    omaha_request_params_->set_waiting_period(TimeDelta::FromSeconds(0));
552    prefs_->Delete(kPrefsWallClockWaitPeriod);
553    prefs_->Delete(kPrefsUpdateCheckCount);
554    // Don't delete the UpdateFirstSeenAt file as we don't want manual checks
555    // that result in no-updates (e.g. due to server side throttling) to
556    // cause update starvation by having the client generate a new
557    // UpdateFirstSeenAt for each scheduled check that follows a manual check.
558  }
559}
560
561void UpdateAttempter::GenerateNewWaitingPeriod() {
562  omaha_request_params_->set_waiting_period(TimeDelta::FromSeconds(
563      base::RandInt(1, scatter_factor_.InSeconds())));
564
565  LOG(INFO) << "Generated new wall-clock waiting period: " << utils::FormatSecs(
566                omaha_request_params_->waiting_period().InSeconds());
567
568  // Do a best-effort to persist this in all cases. Even if the persistence
569  // fails, we'll still be able to scatter based on our in-memory value.
570  // The persistence only helps in ensuring a good overall distribution
571  // across multiple devices if they tend to reboot too often.
572  system_state_->payload_state()->SetScatteringWaitPeriod(
573      omaha_request_params_->waiting_period());
574}
575
576void UpdateAttempter::BuildPostInstallActions(
577    InstallPlanAction* previous_action) {
578  shared_ptr<PostinstallRunnerAction> postinstall_runner_action(
579      new PostinstallRunnerAction(system_state_->boot_control()));
580  actions_.push_back(shared_ptr<AbstractAction>(postinstall_runner_action));
581  BondActions(previous_action,
582              postinstall_runner_action.get());
583}
584
585void UpdateAttempter::BuildUpdateActions(bool interactive) {
586  CHECK(!processor_->IsRunning());
587  processor_->set_delegate(this);
588
589  // Actions:
590  std::unique_ptr<LibcurlHttpFetcher> update_check_fetcher(
591      new LibcurlHttpFetcher(GetProxyResolver(), system_state_->hardware()));
592  update_check_fetcher->set_server_to_check(ServerToCheck::kUpdate);
593  // Try harder to connect to the network, esp when not interactive.
594  // See comment in libcurl_http_fetcher.cc.
595  update_check_fetcher->set_no_network_max_retries(interactive ? 1 : 3);
596  shared_ptr<OmahaRequestAction> update_check_action(
597      new OmahaRequestAction(system_state_,
598                             nullptr,
599                             std::move(update_check_fetcher),
600                             false));
601  shared_ptr<OmahaResponseHandlerAction> response_handler_action(
602      new OmahaResponseHandlerAction(system_state_));
603  shared_ptr<FilesystemVerifierAction> src_filesystem_verifier_action(
604      new FilesystemVerifierAction(system_state_->boot_control(),
605                                   VerifierMode::kComputeSourceHash));
606
607  shared_ptr<OmahaRequestAction> download_started_action(
608      new OmahaRequestAction(system_state_,
609                             new OmahaEvent(
610                                 OmahaEvent::kTypeUpdateDownloadStarted),
611                             brillo::make_unique_ptr(new LibcurlHttpFetcher(
612                                 GetProxyResolver(),
613                                 system_state_->hardware())),
614                             false));
615
616  LibcurlHttpFetcher* download_fetcher =
617      new LibcurlHttpFetcher(GetProxyResolver(), system_state_->hardware());
618  download_fetcher->set_server_to_check(ServerToCheck::kDownload);
619  shared_ptr<DownloadAction> download_action(
620      new DownloadAction(prefs_,
621                         system_state_,
622                         new MultiRangeHttpFetcher(
623                             download_fetcher)));  // passes ownership
624  shared_ptr<OmahaRequestAction> download_finished_action(
625      new OmahaRequestAction(
626          system_state_,
627          new OmahaEvent(OmahaEvent::kTypeUpdateDownloadFinished),
628          brillo::make_unique_ptr(
629              new LibcurlHttpFetcher(GetProxyResolver(),
630                                     system_state_->hardware())),
631          false));
632  shared_ptr<FilesystemVerifierAction> dst_filesystem_verifier_action(
633      new FilesystemVerifierAction(system_state_->boot_control(),
634                                   VerifierMode::kVerifyTargetHash));
635  shared_ptr<OmahaRequestAction> update_complete_action(
636      new OmahaRequestAction(
637          system_state_,
638          new OmahaEvent(OmahaEvent::kTypeUpdateComplete),
639          brillo::make_unique_ptr(
640              new LibcurlHttpFetcher(GetProxyResolver(),
641                                     system_state_->hardware())),
642          false));
643
644  download_action->set_delegate(this);
645  response_handler_action_ = response_handler_action;
646  download_action_ = download_action;
647
648  actions_.push_back(shared_ptr<AbstractAction>(update_check_action));
649  actions_.push_back(shared_ptr<AbstractAction>(response_handler_action));
650  actions_.push_back(shared_ptr<AbstractAction>(
651      src_filesystem_verifier_action));
652  actions_.push_back(shared_ptr<AbstractAction>(download_started_action));
653  actions_.push_back(shared_ptr<AbstractAction>(download_action));
654  actions_.push_back(shared_ptr<AbstractAction>(download_finished_action));
655  actions_.push_back(shared_ptr<AbstractAction>(
656      dst_filesystem_verifier_action));
657
658  // Bond them together. We have to use the leaf-types when calling
659  // BondActions().
660  BondActions(update_check_action.get(),
661              response_handler_action.get());
662  BondActions(response_handler_action.get(),
663              src_filesystem_verifier_action.get());
664  BondActions(src_filesystem_verifier_action.get(),
665              download_action.get());
666  BondActions(download_action.get(),
667              dst_filesystem_verifier_action.get());
668  BuildPostInstallActions(dst_filesystem_verifier_action.get());
669
670  actions_.push_back(shared_ptr<AbstractAction>(update_complete_action));
671
672  // Enqueue the actions
673  for (const shared_ptr<AbstractAction>& action : actions_) {
674    processor_->EnqueueAction(action.get());
675  }
676}
677
678bool UpdateAttempter::Rollback(bool powerwash) {
679  if (!CanRollback()) {
680    return false;
681  }
682
683  // Extra check for enterprise-enrolled devices since they don't support
684  // powerwash.
685  if (powerwash) {
686    // Enterprise-enrolled devices have an empty owner in their device policy.
687    string owner;
688    RefreshDevicePolicy();
689    const policy::DevicePolicy* device_policy = system_state_->device_policy();
690    if (device_policy && (!device_policy->GetOwner(&owner) || owner.empty())) {
691      LOG(ERROR) << "Enterprise device detected. "
692                 << "Cannot perform a powerwash for enterprise devices.";
693      return false;
694    }
695  }
696
697  processor_->set_delegate(this);
698
699  // Initialize the default request params.
700  if (!omaha_request_params_->Init("", "", true)) {
701    LOG(ERROR) << "Unable to initialize Omaha request params.";
702    return false;
703  }
704
705  LOG(INFO) << "Setting rollback options.";
706  InstallPlan install_plan;
707
708  install_plan.target_slot = GetRollbackSlot();
709  install_plan.source_slot = system_state_->boot_control()->GetCurrentSlot();
710
711  TEST_AND_RETURN_FALSE(
712      install_plan.LoadPartitionsFromSlots(system_state_->boot_control()));
713  install_plan.powerwash_required = powerwash;
714
715  LOG(INFO) << "Using this install plan:";
716  install_plan.Dump();
717
718  shared_ptr<InstallPlanAction> install_plan_action(
719      new InstallPlanAction(install_plan));
720  actions_.push_back(shared_ptr<AbstractAction>(install_plan_action));
721
722  BuildPostInstallActions(install_plan_action.get());
723
724  // Enqueue the actions
725  for (const shared_ptr<AbstractAction>& action : actions_) {
726    processor_->EnqueueAction(action.get());
727  }
728
729  // Update the payload state for Rollback.
730  system_state_->payload_state()->Rollback();
731
732  SetStatusAndNotify(UpdateStatus::ATTEMPTING_ROLLBACK);
733
734  // Just in case we didn't update boot flags yet, make sure they're updated
735  // before any update processing starts. This also schedules the start of the
736  // actions we just posted.
737  start_action_processor_ = true;
738  UpdateBootFlags();
739  return true;
740}
741
742bool UpdateAttempter::CanRollback() const {
743  // We can only rollback if the update_engine isn't busy and we have a valid
744  // rollback partition.
745  return (status_ == UpdateStatus::IDLE &&
746          GetRollbackSlot() != BootControlInterface::kInvalidSlot);
747}
748
749BootControlInterface::Slot UpdateAttempter::GetRollbackSlot() const {
750  LOG(INFO) << "UpdateAttempter::GetRollbackSlot";
751  const unsigned int num_slots = system_state_->boot_control()->GetNumSlots();
752  const BootControlInterface::Slot current_slot =
753      system_state_->boot_control()->GetCurrentSlot();
754
755  LOG(INFO) << "  Installed slots: " << num_slots;
756  LOG(INFO) << "  Booted from slot: "
757            << BootControlInterface::SlotName(current_slot);
758
759  if (current_slot == BootControlInterface::kInvalidSlot || num_slots < 2) {
760    LOG(INFO) << "Device is not updateable.";
761    return BootControlInterface::kInvalidSlot;
762  }
763
764  vector<BootControlInterface::Slot> bootable_slots;
765  for (BootControlInterface::Slot slot = 0; slot < num_slots; slot++) {
766    if (slot != current_slot &&
767        system_state_->boot_control()->IsSlotBootable(slot)) {
768      LOG(INFO) << "Found bootable slot "
769                << BootControlInterface::SlotName(slot);
770      return slot;
771    }
772  }
773  LOG(INFO) << "No other bootable slot found.";
774  return BootControlInterface::kInvalidSlot;
775}
776
777void UpdateAttempter::CheckForUpdate(const string& app_version,
778                                     const string& omaha_url,
779                                     bool interactive) {
780  LOG(INFO) << "Forced update check requested.";
781  forced_app_version_.clear();
782  forced_omaha_url_.clear();
783
784  // Certain conditions must be met to allow setting custom version and update
785  // server URLs. However, kScheduledAUTestURLRequest and kAUTestURLRequest are
786  // always allowed regardless of device state.
787  if (IsAnyUpdateSourceAllowed()) {
788    forced_app_version_ = app_version;
789    forced_omaha_url_ = omaha_url;
790  }
791  if (omaha_url == kScheduledAUTestURLRequest) {
792    forced_omaha_url_ = constants::kOmahaDefaultAUTestURL;
793    // Pretend that it's not user-initiated even though it is,
794    // so as to test scattering logic, etc. which get kicked off
795    // only in scheduled update checks.
796    interactive = false;
797  } else if (omaha_url == kAUTestURLRequest) {
798    forced_omaha_url_ = constants::kOmahaDefaultAUTestURL;
799  }
800
801  if (forced_update_pending_callback_.get()) {
802    // Make sure that a scheduling request is made prior to calling the forced
803    // update pending callback.
804    ScheduleUpdates();
805    forced_update_pending_callback_->Run(true, interactive);
806  }
807}
808
809bool UpdateAttempter::RebootIfNeeded() {
810  if (status_ != UpdateStatus::UPDATED_NEED_REBOOT) {
811    LOG(INFO) << "Reboot requested, but status is "
812              << UpdateStatusToString(status_) << ", so not rebooting.";
813    return false;
814  }
815
816  if (USE_POWER_MANAGEMENT && RequestPowerManagerReboot())
817    return true;
818
819  return RebootDirectly();
820}
821
822void UpdateAttempter::WriteUpdateCompletedMarker() {
823  string boot_id;
824  if (!utils::GetBootId(&boot_id))
825    return;
826  prefs_->SetString(kPrefsUpdateCompletedOnBootId, boot_id);
827
828  int64_t value = system_state_->clock()->GetBootTime().ToInternalValue();
829  prefs_->SetInt64(kPrefsUpdateCompletedBootTime, value);
830}
831
832bool UpdateAttempter::RequestPowerManagerReboot() {
833  org::chromium::PowerManagerProxyInterface* power_manager_proxy =
834      system_state_->power_manager_proxy();
835  if (!power_manager_proxy) {
836    LOG(WARNING) << "No PowerManager proxy defined, skipping reboot.";
837    return false;
838  }
839  LOG(INFO) << "Calling " << power_manager::kPowerManagerInterface << "."
840            << power_manager::kRequestRestartMethod;
841  brillo::ErrorPtr error;
842  return power_manager_proxy->RequestRestart(
843      power_manager::REQUEST_RESTART_FOR_UPDATE, &error);
844}
845
846bool UpdateAttempter::RebootDirectly() {
847  vector<string> command;
848  command.push_back("/sbin/shutdown");
849  command.push_back("-r");
850  command.push_back("now");
851  LOG(INFO) << "Running \"" << JoinString(command, ' ') << "\"";
852  int rc = 0;
853  Subprocess::SynchronousExec(command, &rc, nullptr);
854  return rc == 0;
855}
856
857void UpdateAttempter::OnUpdateScheduled(EvalStatus status,
858                                        const UpdateCheckParams& params) {
859  waiting_for_scheduled_check_ = false;
860
861  if (status == EvalStatus::kSucceeded) {
862    if (!params.updates_enabled) {
863      LOG(WARNING) << "Updates permanently disabled.";
864      // Signal disabled status, then switch right back to idle. This is
865      // necessary for ensuring that observers waiting for a signal change will
866      // actually notice one on subsequent calls. Note that we don't need to
867      // re-schedule a check in this case as updates are permanently disabled;
868      // further (forced) checks may still initiate a scheduling call.
869      SetStatusAndNotify(UpdateStatus::DISABLED);
870      SetStatusAndNotify(UpdateStatus::IDLE);
871      return;
872    }
873
874    LOG(INFO) << "Running "
875              << (params.is_interactive ? "interactive" : "periodic")
876              << " update.";
877
878    string app_version, omaha_url;
879    if (params.is_interactive) {
880      app_version = forced_app_version_;
881      omaha_url = forced_omaha_url_;
882    }
883
884    Update(app_version, omaha_url, params.target_channel,
885           params.target_version_prefix, false, params.is_interactive);
886  } else {
887    LOG(WARNING)
888        << "Update check scheduling failed (possibly timed out); retrying.";
889    ScheduleUpdates();
890  }
891
892  // This check ensures that future update checks will be or are already
893  // scheduled. The check should never fail. A check failure means that there's
894  // a bug that will most likely prevent further automatic update checks. It
895  // seems better to crash in such cases and restart the update_engine daemon
896  // into, hopefully, a known good state.
897  CHECK(IsUpdateRunningOrScheduled());
898}
899
900void UpdateAttempter::UpdateLastCheckedTime() {
901  last_checked_time_ = system_state_->clock()->GetWallclockTime().ToTimeT();
902}
903
904// Delegate methods:
905void UpdateAttempter::ProcessingDone(const ActionProcessor* processor,
906                                     ErrorCode code) {
907  LOG(INFO) << "Processing Done.";
908  actions_.clear();
909
910  // Reset cpu shares back to normal.
911  CleanupCpuSharesManagement();
912
913  if (status_ == UpdateStatus::REPORTING_ERROR_EVENT) {
914    LOG(INFO) << "Error event sent.";
915
916    // Inform scheduler of new status;
917    SetStatusAndNotify(UpdateStatus::IDLE);
918    ScheduleUpdates();
919
920    if (!fake_update_success_) {
921      return;
922    }
923    LOG(INFO) << "Booted from FW B and tried to install new firmware, "
924        "so requesting reboot from user.";
925  }
926
927  if (code == ErrorCode::kSuccess) {
928    WriteUpdateCompletedMarker();
929    prefs_->SetInt64(kPrefsDeltaUpdateFailures, 0);
930    prefs_->SetString(kPrefsPreviousVersion,
931                      omaha_request_params_->app_version());
932    DeltaPerformer::ResetUpdateProgress(prefs_, false);
933
934    system_state_->payload_state()->UpdateSucceeded();
935
936    // Since we're done with scattering fully at this point, this is the
937    // safest point delete the state files, as we're sure that the status is
938    // set to reboot (which means no more updates will be applied until reboot)
939    // This deletion is required for correctness as we want the next update
940    // check to re-create a new random number for the update check count.
941    // Similarly, we also delete the wall-clock-wait period that was persisted
942    // so that we start with a new random value for the next update check
943    // after reboot so that the same device is not favored or punished in any
944    // way.
945    prefs_->Delete(kPrefsUpdateCheckCount);
946    system_state_->payload_state()->SetScatteringWaitPeriod(TimeDelta());
947    prefs_->Delete(kPrefsUpdateFirstSeenAt);
948
949    SetStatusAndNotify(UpdateStatus::UPDATED_NEED_REBOOT);
950    ScheduleUpdates();
951    LOG(INFO) << "Update successfully applied, waiting to reboot.";
952
953    // This pointer is null during rollback operations, and the stats
954    // don't make much sense then anyway.
955    if (response_handler_action_) {
956      const InstallPlan& install_plan =
957          response_handler_action_->install_plan();
958
959      // Generate an unique payload identifier.
960      const string target_version_uid =
961          install_plan.payload_hash + ":" + install_plan.metadata_signature;
962
963      // Expect to reboot into the new version to send the proper metric during
964      // next boot.
965      system_state_->payload_state()->ExpectRebootInNewVersion(
966          target_version_uid);
967    } else {
968      // If we just finished a rollback, then we expect to have no Omaha
969      // response. Otherwise, it's an error.
970      if (system_state_->payload_state()->GetRollbackVersion().empty()) {
971        LOG(ERROR) << "Can't send metrics because expected "
972            "response_handler_action_ missing.";
973      }
974    }
975    return;
976  }
977
978  if (ScheduleErrorEventAction()) {
979    return;
980  }
981  LOG(INFO) << "No update.";
982  SetStatusAndNotify(UpdateStatus::IDLE);
983  ScheduleUpdates();
984}
985
986void UpdateAttempter::ProcessingStopped(const ActionProcessor* processor) {
987  // Reset cpu shares back to normal.
988  CleanupCpuSharesManagement();
989  download_progress_ = 0.0;
990  SetStatusAndNotify(UpdateStatus::IDLE);
991  ScheduleUpdates();
992  actions_.clear();
993  error_event_.reset(nullptr);
994}
995
996// Called whenever an action has finished processing, either successfully
997// or otherwise.
998void UpdateAttempter::ActionCompleted(ActionProcessor* processor,
999                                      AbstractAction* action,
1000                                      ErrorCode code) {
1001  // Reset download progress regardless of whether or not the download
1002  // action succeeded. Also, get the response code from HTTP request
1003  // actions (update download as well as the initial update check
1004  // actions).
1005  const string type = action->Type();
1006  if (type == DownloadAction::StaticType()) {
1007    download_progress_ = 0.0;
1008    DownloadAction* download_action = static_cast<DownloadAction*>(action);
1009    http_response_code_ = download_action->GetHTTPResponseCode();
1010  } else if (type == OmahaRequestAction::StaticType()) {
1011    OmahaRequestAction* omaha_request_action =
1012        static_cast<OmahaRequestAction*>(action);
1013    // If the request is not an event, then it's the update-check.
1014    if (!omaha_request_action->IsEvent()) {
1015      http_response_code_ = omaha_request_action->GetHTTPResponseCode();
1016
1017      // Record the number of consecutive failed update checks.
1018      if (http_response_code_ == kHttpResponseInternalServerError ||
1019          http_response_code_ == kHttpResponseServiceUnavailable) {
1020        consecutive_failed_update_checks_++;
1021      } else {
1022        consecutive_failed_update_checks_ = 0;
1023      }
1024
1025      // Store the server-dictated poll interval, if any.
1026      server_dictated_poll_interval_ =
1027          std::max(0, omaha_request_action->GetOutputObject().poll_interval);
1028    }
1029  }
1030  if (code != ErrorCode::kSuccess) {
1031    // If the current state is at or past the download phase, count the failure
1032    // in case a switch to full update becomes necessary. Ignore network
1033    // transfer timeouts and failures.
1034    if (status_ >= UpdateStatus::DOWNLOADING &&
1035        code != ErrorCode::kDownloadTransferError) {
1036      MarkDeltaUpdateFailure();
1037    }
1038    // On failure, schedule an error event to be sent to Omaha.
1039    CreatePendingErrorEvent(action, code);
1040    return;
1041  }
1042  // Find out which action completed.
1043  if (type == OmahaResponseHandlerAction::StaticType()) {
1044    // Note that the status will be updated to DOWNLOADING when some bytes get
1045    // actually downloaded from the server and the BytesReceived callback is
1046    // invoked. This avoids notifying the user that a download has started in
1047    // cases when the server and the client are unable to initiate the download.
1048    CHECK(action == response_handler_action_.get());
1049    const InstallPlan& plan = response_handler_action_->install_plan();
1050    UpdateLastCheckedTime();
1051    new_version_ = plan.version;
1052    new_payload_size_ = plan.payload_size;
1053    SetupDownload();
1054    SetupCpuSharesManagement();
1055    SetStatusAndNotify(UpdateStatus::UPDATE_AVAILABLE);
1056  } else if (type == DownloadAction::StaticType()) {
1057    SetStatusAndNotify(UpdateStatus::FINALIZING);
1058  }
1059}
1060
1061void UpdateAttempter::BytesReceived(uint64_t bytes_progressed,
1062                                    uint64_t bytes_received,
1063                                    uint64_t total) {
1064  // The PayloadState keeps track of how many bytes were actually downloaded
1065  // from a given URL for the URL skipping logic.
1066  system_state_->payload_state()->DownloadProgress(bytes_progressed);
1067
1068  double progress = static_cast<double>(bytes_received) /
1069      static_cast<double>(total);
1070  // Self throttle based on progress. Also send notifications if
1071  // progress is too slow.
1072  const double kDeltaPercent = 0.01;  // 1%
1073  if (status_ != UpdateStatus::DOWNLOADING ||
1074      bytes_received == total ||
1075      progress - download_progress_ >= kDeltaPercent ||
1076      TimeTicks::Now() - last_notify_time_ >= TimeDelta::FromSeconds(10)) {
1077    download_progress_ = progress;
1078    SetStatusAndNotify(UpdateStatus::DOWNLOADING);
1079  }
1080}
1081
1082void UpdateAttempter::DownloadComplete() {
1083  system_state_->payload_state()->DownloadComplete();
1084}
1085
1086bool UpdateAttempter::OnCheckForUpdates(brillo::ErrorPtr* error) {
1087  CheckForUpdate(
1088      "" /* app_version */, "" /* omaha_url */, true /* interactive */);
1089  return true;
1090}
1091
1092bool UpdateAttempter::OnTrackChannel(const string& channel,
1093                                     brillo::ErrorPtr* error) {
1094  LOG(INFO) << "Setting destination channel to: " << channel;
1095  string error_message;
1096  if (!system_state_->request_params()->SetTargetChannel(
1097          channel, false /* powerwash_allowed */, &error_message)) {
1098    brillo::Error::AddTo(error,
1099                         FROM_HERE,
1100                         brillo::errors::dbus::kDomain,
1101                         "set_target_error",
1102                         error_message);
1103    return false;
1104  }
1105  return true;
1106}
1107
1108bool UpdateAttempter::GetWeaveState(int64_t* last_checked_time,
1109                                    double* progress,
1110                                    UpdateStatus* update_status,
1111                                    string* current_channel,
1112                                    string* tracking_channel) {
1113  *last_checked_time = last_checked_time_;
1114  *progress = download_progress_;
1115  *update_status = status_;
1116  OmahaRequestParams* rp = system_state_->request_params();
1117  *current_channel = rp->current_channel();
1118  *tracking_channel = rp->target_channel();
1119  return true;
1120}
1121
1122bool UpdateAttempter::ResetStatus() {
1123  LOG(INFO) << "Attempting to reset state from "
1124            << UpdateStatusToString(status_) << " to UpdateStatus::IDLE";
1125
1126  switch (status_) {
1127    case UpdateStatus::IDLE:
1128      // no-op.
1129      return true;
1130
1131    case UpdateStatus::UPDATED_NEED_REBOOT:  {
1132      bool ret_value = true;
1133      status_ = UpdateStatus::IDLE;
1134
1135      // Remove the reboot marker so that if the machine is rebooted
1136      // after resetting to idle state, it doesn't go back to
1137      // UpdateStatus::UPDATED_NEED_REBOOT state.
1138      ret_value = prefs_->Delete(kPrefsUpdateCompletedOnBootId) && ret_value;
1139      ret_value = prefs_->Delete(kPrefsUpdateCompletedBootTime) && ret_value;
1140
1141      // Update the boot flags so the current slot has higher priority.
1142      BootControlInterface* boot_control = system_state_->boot_control();
1143      if (!boot_control->SetActiveBootSlot(boot_control->GetCurrentSlot()))
1144        ret_value = false;
1145
1146      // Notify the PayloadState that the successful payload was canceled.
1147      system_state_->payload_state()->ResetUpdateStatus();
1148
1149      // The previous version is used to report back to omaha after reboot that
1150      // we actually rebooted into the new version from this "prev-version". We
1151      // need to clear out this value now to prevent it being sent on the next
1152      // updatecheck request.
1153      ret_value = prefs_->SetString(kPrefsPreviousVersion, "") && ret_value;
1154
1155      LOG(INFO) << "Reset status " << (ret_value ? "successful" : "failed");
1156      return ret_value;
1157    }
1158
1159    default:
1160      LOG(ERROR) << "Reset not allowed in this state.";
1161      return false;
1162  }
1163}
1164
1165bool UpdateAttempter::GetStatus(int64_t* last_checked_time,
1166                                double* progress,
1167                                string* current_operation,
1168                                string* new_version,
1169                                int64_t* new_payload_size) {
1170  *last_checked_time = last_checked_time_;
1171  *progress = download_progress_;
1172  *current_operation = UpdateStatusToString(status_);
1173  *new_version = new_version_;
1174  *new_payload_size = new_payload_size_;
1175  return true;
1176}
1177
1178void UpdateAttempter::UpdateBootFlags() {
1179  if (update_boot_flags_running_) {
1180    LOG(INFO) << "Update boot flags running, nothing to do.";
1181    return;
1182  }
1183  if (updated_boot_flags_) {
1184    LOG(INFO) << "Already updated boot flags. Skipping.";
1185    if (start_action_processor_) {
1186      ScheduleProcessingStart();
1187    }
1188    return;
1189  }
1190  // This is purely best effort. Failures should be logged by Subprocess. Run
1191  // the script asynchronously to avoid blocking the event loop regardless of
1192  // the script runtime.
1193  update_boot_flags_running_ = true;
1194  LOG(INFO) << "Marking booted slot as good.";
1195  if (!system_state_->boot_control()->MarkBootSuccessfulAsync(Bind(
1196          &UpdateAttempter::CompleteUpdateBootFlags, base::Unretained(this)))) {
1197    LOG(ERROR) << "Failed to mark current boot as successful.";
1198    CompleteUpdateBootFlags(false);
1199  }
1200}
1201
1202void UpdateAttempter::CompleteUpdateBootFlags(bool successful) {
1203  update_boot_flags_running_ = false;
1204  updated_boot_flags_ = true;
1205  if (start_action_processor_) {
1206    ScheduleProcessingStart();
1207  }
1208}
1209
1210void UpdateAttempter::BroadcastStatus() {
1211  if (system_state_->weave_service())
1212    system_state_->weave_service()->UpdateWeaveState();
1213
1214  if (!dbus_adaptor_)
1215    return;
1216  last_notify_time_ = TimeTicks::Now();
1217  dbus_adaptor_->SendStatusUpdateSignal(
1218      last_checked_time_,
1219      download_progress_,
1220      UpdateStatusToString(status_),
1221      new_version_.c_str(),
1222      new_payload_size_);
1223}
1224
1225uint32_t UpdateAttempter::GetErrorCodeFlags()  {
1226  uint32_t flags = 0;
1227
1228  if (!system_state_->hardware()->IsNormalBootMode())
1229    flags |= static_cast<uint32_t>(ErrorCode::kDevModeFlag);
1230
1231  if (response_handler_action_.get() &&
1232      response_handler_action_->install_plan().is_resume)
1233    flags |= static_cast<uint32_t>(ErrorCode::kResumedFlag);
1234
1235  if (!system_state_->hardware()->IsOfficialBuild())
1236    flags |= static_cast<uint32_t>(ErrorCode::kTestImageFlag);
1237
1238  if (omaha_request_params_->update_url() !=
1239      constants::kOmahaDefaultProductionURL) {
1240    flags |= static_cast<uint32_t>(ErrorCode::kTestOmahaUrlFlag);
1241  }
1242
1243  return flags;
1244}
1245
1246bool UpdateAttempter::ShouldCancel(ErrorCode* cancel_reason) {
1247  // Check if the channel we're attempting to update to is the same as the
1248  // target channel currently chosen by the user.
1249  OmahaRequestParams* params = system_state_->request_params();
1250  if (params->download_channel() != params->target_channel()) {
1251    LOG(ERROR) << "Aborting download as target channel: "
1252               << params->target_channel()
1253               << " is different from the download channel: "
1254               << params->download_channel();
1255    *cancel_reason = ErrorCode::kUpdateCanceledByChannelChange;
1256    return true;
1257  }
1258
1259  return false;
1260}
1261
1262void UpdateAttempter::SetStatusAndNotify(UpdateStatus status) {
1263  status_ = status;
1264  BroadcastStatus();
1265}
1266
1267void UpdateAttempter::CreatePendingErrorEvent(AbstractAction* action,
1268                                              ErrorCode code) {
1269  if (error_event_.get()) {
1270    // This shouldn't really happen.
1271    LOG(WARNING) << "There's already an existing pending error event.";
1272    return;
1273  }
1274
1275  // For now assume that a generic Omaha response action failure means that
1276  // there's no update so don't send an event. Also, double check that the
1277  // failure has not occurred while sending an error event -- in which case
1278  // don't schedule another. This shouldn't really happen but just in case...
1279  if ((action->Type() == OmahaResponseHandlerAction::StaticType() &&
1280       code == ErrorCode::kError) ||
1281      status_ == UpdateStatus::REPORTING_ERROR_EVENT) {
1282    return;
1283  }
1284
1285  // Classify the code to generate the appropriate result so that
1286  // the Borgmon charts show up the results correctly.
1287  // Do this before calling GetErrorCodeForAction which could potentially
1288  // augment the bit representation of code and thus cause no matches for
1289  // the switch cases below.
1290  OmahaEvent::Result event_result;
1291  switch (code) {
1292    case ErrorCode::kOmahaUpdateIgnoredPerPolicy:
1293    case ErrorCode::kOmahaUpdateDeferredPerPolicy:
1294    case ErrorCode::kOmahaUpdateDeferredForBackoff:
1295      event_result = OmahaEvent::kResultUpdateDeferred;
1296      break;
1297    default:
1298      event_result = OmahaEvent::kResultError;
1299      break;
1300  }
1301
1302  code = GetErrorCodeForAction(action, code);
1303  fake_update_success_ = code == ErrorCode::kPostinstallBootedFromFirmwareB;
1304
1305  // Compute the final error code with all the bit flags to be sent to Omaha.
1306  code = static_cast<ErrorCode>(
1307      static_cast<uint32_t>(code) | GetErrorCodeFlags());
1308  error_event_.reset(new OmahaEvent(OmahaEvent::kTypeUpdateComplete,
1309                                    event_result,
1310                                    code));
1311}
1312
1313bool UpdateAttempter::ScheduleErrorEventAction() {
1314  if (error_event_.get() == nullptr)
1315    return false;
1316
1317  LOG(ERROR) << "Update failed.";
1318  system_state_->payload_state()->UpdateFailed(error_event_->error_code);
1319
1320  // Send it to Omaha.
1321  LOG(INFO) << "Reporting the error event";
1322  shared_ptr<OmahaRequestAction> error_event_action(
1323      new OmahaRequestAction(system_state_,
1324                             error_event_.release(),  // Pass ownership.
1325                             brillo::make_unique_ptr(new LibcurlHttpFetcher(
1326                                 GetProxyResolver(),
1327                                 system_state_->hardware())),
1328                             false));
1329  actions_.push_back(shared_ptr<AbstractAction>(error_event_action));
1330  processor_->EnqueueAction(error_event_action.get());
1331  SetStatusAndNotify(UpdateStatus::REPORTING_ERROR_EVENT);
1332  processor_->StartProcessing();
1333  return true;
1334}
1335
1336void UpdateAttempter::SetCpuShares(utils::CpuShares shares) {
1337  if (shares_ == shares) {
1338    return;
1339  }
1340  if (utils::SetCpuShares(shares)) {
1341    shares_ = shares;
1342    LOG(INFO) << "CPU shares = " << shares_;
1343  }
1344}
1345
1346void UpdateAttempter::SetupCpuSharesManagement() {
1347  if (manage_shares_id_ != MessageLoop::kTaskIdNull) {
1348    LOG(ERROR) << "Cpu shares timeout source hasn't been destroyed.";
1349    CleanupCpuSharesManagement();
1350  }
1351  const int kCpuSharesTimeout = 2 * 60 * 60;  // 2 hours
1352  manage_shares_id_ = MessageLoop::current()->PostDelayedTask(
1353      FROM_HERE,
1354      Bind(&UpdateAttempter::ManageCpuSharesCallback, base::Unretained(this)),
1355      TimeDelta::FromSeconds(kCpuSharesTimeout));
1356  SetCpuShares(utils::kCpuSharesLow);
1357}
1358
1359void UpdateAttempter::CleanupCpuSharesManagement() {
1360  if (manage_shares_id_ != MessageLoop::kTaskIdNull) {
1361    // The UpdateAttempter is instantiated by default by the FakeSystemState,
1362    // even when it is not used. We check the manage_shares_id_ before calling
1363    // the MessageLoop::current() since the unit test using a FakeSystemState
1364    // may have not define a MessageLoop for the current thread.
1365    MessageLoop::current()->CancelTask(manage_shares_id_);
1366    manage_shares_id_ = MessageLoop::kTaskIdNull;
1367  }
1368  SetCpuShares(utils::kCpuSharesNormal);
1369}
1370
1371void UpdateAttempter::ScheduleProcessingStart() {
1372  LOG(INFO) << "Scheduling an action processor start.";
1373  start_action_processor_ = false;
1374  MessageLoop::current()->PostTask(
1375      FROM_HERE,
1376      Bind([this] { this->processor_->StartProcessing(); }));
1377}
1378
1379void UpdateAttempter::ManageCpuSharesCallback() {
1380  SetCpuShares(utils::kCpuSharesNormal);
1381  manage_shares_id_ = MessageLoop::kTaskIdNull;
1382}
1383
1384void UpdateAttempter::DisableDeltaUpdateIfNeeded() {
1385  int64_t delta_failures;
1386  if (omaha_request_params_->delta_okay() &&
1387      prefs_->GetInt64(kPrefsDeltaUpdateFailures, &delta_failures) &&
1388      delta_failures >= kMaxDeltaUpdateFailures) {
1389    LOG(WARNING) << "Too many delta update failures, forcing full update.";
1390    omaha_request_params_->set_delta_okay(false);
1391  }
1392}
1393
1394void UpdateAttempter::MarkDeltaUpdateFailure() {
1395  // Don't try to resume a failed delta update.
1396  DeltaPerformer::ResetUpdateProgress(prefs_, false);
1397  int64_t delta_failures;
1398  if (!prefs_->GetInt64(kPrefsDeltaUpdateFailures, &delta_failures) ||
1399      delta_failures < 0) {
1400    delta_failures = 0;
1401  }
1402  prefs_->SetInt64(kPrefsDeltaUpdateFailures, ++delta_failures);
1403}
1404
1405void UpdateAttempter::SetupDownload() {
1406  MultiRangeHttpFetcher* fetcher =
1407      static_cast<MultiRangeHttpFetcher*>(download_action_->http_fetcher());
1408  fetcher->ClearRanges();
1409  if (response_handler_action_->install_plan().is_resume) {
1410    // Resuming an update so fetch the update manifest metadata first.
1411    int64_t manifest_metadata_size = 0;
1412    prefs_->GetInt64(kPrefsManifestMetadataSize, &manifest_metadata_size);
1413    fetcher->AddRange(0, manifest_metadata_size);
1414    // If there're remaining unprocessed data blobs, fetch them. Be careful not
1415    // to request data beyond the end of the payload to avoid 416 HTTP response
1416    // error codes.
1417    int64_t next_data_offset = 0;
1418    prefs_->GetInt64(kPrefsUpdateStateNextDataOffset, &next_data_offset);
1419    uint64_t resume_offset = manifest_metadata_size + next_data_offset;
1420    if (resume_offset < response_handler_action_->install_plan().payload_size) {
1421      fetcher->AddRange(resume_offset);
1422    }
1423  } else {
1424    fetcher->AddRange(0);
1425  }
1426}
1427
1428void UpdateAttempter::PingOmaha() {
1429  if (!processor_->IsRunning()) {
1430    shared_ptr<OmahaRequestAction> ping_action(new OmahaRequestAction(
1431        system_state_,
1432        nullptr,
1433        brillo::make_unique_ptr(new LibcurlHttpFetcher(
1434            GetProxyResolver(),
1435            system_state_->hardware())),
1436        true));
1437    actions_.push_back(shared_ptr<OmahaRequestAction>(ping_action));
1438    processor_->set_delegate(nullptr);
1439    processor_->EnqueueAction(ping_action.get());
1440    // Call StartProcessing() synchronously here to avoid any race conditions
1441    // caused by multiple outstanding ping Omaha requests.  If we call
1442    // StartProcessing() asynchronously, the device can be suspended before we
1443    // get a chance to callback to StartProcessing().  When the device resumes
1444    // (assuming the device sleeps longer than the next update check period),
1445    // StartProcessing() is called back and at the same time, the next update
1446    // check is fired which eventually invokes StartProcessing().  A crash
1447    // can occur because StartProcessing() checks to make sure that the
1448    // processor is idle which it isn't due to the two concurrent ping Omaha
1449    // requests.
1450    processor_->StartProcessing();
1451  } else {
1452    LOG(WARNING) << "Action processor running, Omaha ping suppressed.";
1453  }
1454
1455  // Update the last check time here; it may be re-updated when an Omaha
1456  // response is received, but this will prevent us from repeatedly scheduling
1457  // checks in the case where a response is not received.
1458  UpdateLastCheckedTime();
1459
1460  // Update the status which will schedule the next update check
1461  SetStatusAndNotify(UpdateStatus::UPDATED_NEED_REBOOT);
1462  ScheduleUpdates();
1463}
1464
1465
1466bool UpdateAttempter::DecrementUpdateCheckCount() {
1467  int64_t update_check_count_value;
1468
1469  if (!prefs_->Exists(kPrefsUpdateCheckCount)) {
1470    // This file does not exist. This means we haven't started our update
1471    // check count down yet, so nothing more to do. This file will be created
1472    // later when we first satisfy the wall-clock-based-wait period.
1473    LOG(INFO) << "No existing update check count. That's normal.";
1474    return true;
1475  }
1476
1477  if (prefs_->GetInt64(kPrefsUpdateCheckCount, &update_check_count_value)) {
1478    // Only if we're able to read a proper integer value, then go ahead
1479    // and decrement and write back the result in the same file, if needed.
1480    LOG(INFO) << "Update check count = " << update_check_count_value;
1481
1482    if (update_check_count_value == 0) {
1483      // It could be 0, if, for some reason, the file didn't get deleted
1484      // when we set our status to waiting for reboot. so we just leave it
1485      // as is so that we can prevent another update_check wait for this client.
1486      LOG(INFO) << "Not decrementing update check count as it's already 0.";
1487      return true;
1488    }
1489
1490    if (update_check_count_value > 0)
1491      update_check_count_value--;
1492    else
1493      update_check_count_value = 0;
1494
1495    // Write out the new value of update_check_count_value.
1496    if (prefs_->SetInt64(kPrefsUpdateCheckCount, update_check_count_value)) {
1497      // We successfully wrote out te new value, so enable the
1498      // update check based wait.
1499      LOG(INFO) << "New update check count = " << update_check_count_value;
1500      return true;
1501    }
1502  }
1503
1504  LOG(INFO) << "Deleting update check count state due to read/write errors.";
1505
1506  // We cannot read/write to the file, so disable the update check based wait
1507  // so that we don't get stuck in this OS version by any chance (which could
1508  // happen if there's some bug that causes to read/write incorrectly).
1509  // Also attempt to delete the file to do our best effort to cleanup.
1510  prefs_->Delete(kPrefsUpdateCheckCount);
1511  return false;
1512}
1513
1514
1515void UpdateAttempter::UpdateEngineStarted() {
1516  // If we just booted into a new update, keep the previous OS version
1517  // in case we rebooted because of a crash of the old version, so we
1518  // can do a proper crash report with correct information.
1519  // This must be done before calling
1520  // system_state_->payload_state()->UpdateEngineStarted() since it will
1521  // delete SystemUpdated marker file.
1522  if (system_state_->system_rebooted() &&
1523      prefs_->Exists(kPrefsSystemUpdatedMarker)) {
1524    if (!prefs_->GetString(kPrefsPreviousVersion, &prev_version_)) {
1525      // If we fail to get the version string, make sure it stays empty.
1526      prev_version_.clear();
1527    }
1528  }
1529
1530  system_state_->payload_state()->UpdateEngineStarted();
1531  StartP2PAtStartup();
1532}
1533
1534bool UpdateAttempter::StartP2PAtStartup() {
1535  if (system_state_ == nullptr ||
1536      !system_state_->p2p_manager()->IsP2PEnabled()) {
1537    LOG(INFO) << "Not starting p2p at startup since it's not enabled.";
1538    return false;
1539  }
1540
1541  if (system_state_->p2p_manager()->CountSharedFiles() < 1) {
1542    LOG(INFO) << "Not starting p2p at startup since our application "
1543              << "is not sharing any files.";
1544    return false;
1545  }
1546
1547  return StartP2PAndPerformHousekeeping();
1548}
1549
1550bool UpdateAttempter::StartP2PAndPerformHousekeeping() {
1551  if (system_state_ == nullptr)
1552    return false;
1553
1554  if (!system_state_->p2p_manager()->IsP2PEnabled()) {
1555    LOG(INFO) << "Not starting p2p since it's not enabled.";
1556    return false;
1557  }
1558
1559  LOG(INFO) << "Ensuring that p2p is running.";
1560  if (!system_state_->p2p_manager()->EnsureP2PRunning()) {
1561    LOG(ERROR) << "Error starting p2p.";
1562    return false;
1563  }
1564
1565  LOG(INFO) << "Performing p2p housekeeping.";
1566  if (!system_state_->p2p_manager()->PerformHousekeeping()) {
1567    LOG(ERROR) << "Error performing housekeeping for p2p.";
1568    return false;
1569  }
1570
1571  LOG(INFO) << "Done performing p2p housekeeping.";
1572  return true;
1573}
1574
1575bool UpdateAttempter::GetBootTimeAtUpdate(Time *out_boot_time) {
1576  // In case of an update_engine restart without a reboot, we stored the boot_id
1577  // when the update was completed by setting a pref, so we can check whether
1578  // the last update was on this boot or a previous one.
1579  string boot_id;
1580  TEST_AND_RETURN_FALSE(utils::GetBootId(&boot_id));
1581
1582  string update_completed_on_boot_id;
1583  if (!prefs_->Exists(kPrefsUpdateCompletedOnBootId) ||
1584      !prefs_->GetString(kPrefsUpdateCompletedOnBootId,
1585                         &update_completed_on_boot_id) ||
1586      update_completed_on_boot_id != boot_id)
1587    return false;
1588
1589  // Short-circuit avoiding the read in case out_boot_time is nullptr.
1590  if (out_boot_time) {
1591    int64_t boot_time = 0;
1592    // Since the kPrefsUpdateCompletedOnBootId was correctly set, this pref
1593    // should not fail.
1594    TEST_AND_RETURN_FALSE(
1595        prefs_->GetInt64(kPrefsUpdateCompletedBootTime, &boot_time));
1596    *out_boot_time = Time::FromInternalValue(boot_time);
1597  }
1598  return true;
1599}
1600
1601bool UpdateAttempter::IsUpdateRunningOrScheduled() {
1602  return ((status_ != UpdateStatus::IDLE &&
1603           status_ != UpdateStatus::UPDATED_NEED_REBOOT) ||
1604          waiting_for_scheduled_check_);
1605}
1606
1607bool UpdateAttempter::IsAnyUpdateSourceAllowed() {
1608  // We allow updates from any source if either of these are true:
1609  //  * The device is running an unofficial (dev/test) image.
1610  //  * The debugd dev features are accessible (i.e. in devmode with no owner).
1611  // This protects users running a base image, while still allowing a specific
1612  // window (gated by the debug dev features) where `cros flash` is usable.
1613  if (!system_state_->hardware()->IsOfficialBuild()) {
1614    LOG(INFO) << "Non-official build; allowing any update source.";
1615    return true;
1616  }
1617
1618  // Even though the debugd tools are also gated on devmode, checking here can
1619  // save us a D-Bus call so it's worth doing explicitly.
1620  if (system_state_->hardware()->IsNormalBootMode()) {
1621    LOG(INFO) << "Not in devmode; disallowing custom update sources.";
1622    return false;
1623  }
1624
1625  // Official images in devmode are allowed a custom update source iff the
1626  // debugd dev tools are enabled.
1627  if (!debugd_proxy_)
1628    return false;
1629  int32_t dev_features = debugd::DEV_FEATURES_DISABLED;
1630  brillo::ErrorPtr error;
1631  bool success = debugd_proxy_->QueryDevFeatures(&dev_features, &error);
1632
1633  // Some boards may not include debugd so it's expected that this may fail,
1634  // in which case we default to disallowing custom update sources.
1635  if (success && !(dev_features & debugd::DEV_FEATURES_DISABLED)) {
1636    LOG(INFO) << "Debugd dev tools enabled; allowing any update source.";
1637    return true;
1638  }
1639  LOG(INFO) << "Debugd dev tools disabled; disallowing custom update sources.";
1640  return false;
1641}
1642
1643}  // namespace chromeos_update_engine
1644