update_attempter.cc revision 1f84723f499b3b309efac11324ed4e6c937341b6 
1// Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "update_engine/update_attempter.h"
6
7#include <string>
8#include <tr1/memory>
9#include <vector>
10#include <algorithm>
11
12#include <base/file_util.h>
13#include <base/logging.h>
14#include <base/rand_util.h>
15#include <base/strings/stringprintf.h>
16#include <chromeos/dbus/service_constants.h>
17
18#include <glib.h>
19#include <metrics/metrics_library.h>
20#include <policy/libpolicy.h>
21#include <policy/device_policy.h>
22
23#include "update_engine/certificate_checker.h"
24#include "update_engine/clock_interface.h"
25#include "update_engine/constants.h"
26#include "update_engine/dbus_service.h"
27#include "update_engine/download_action.h"
28#include "update_engine/filesystem_copier_action.h"
29#include "update_engine/gpio_handler.h"
30#include "update_engine/hardware_interface.h"
31#include "update_engine/libcurl_http_fetcher.h"
32#include "update_engine/metrics.h"
33#include "update_engine/multi_range_http_fetcher.h"
34#include "update_engine/omaha_request_action.h"
35#include "update_engine/omaha_request_params.h"
36#include "update_engine/omaha_response_handler_action.h"
37#include "update_engine/p2p_manager.h"
38#include "update_engine/payload_state_interface.h"
39#include "update_engine/postinstall_runner_action.h"
40#include "update_engine/prefs_interface.h"
41#include "update_engine/subprocess.h"
42#include "update_engine/system_state.h"
43#include "update_engine/update_check_scheduler.h"
44#include "update_engine/utils.h"
45
46using base::Time;
47using base::TimeDelta;
48using base::TimeTicks;
49using base::StringPrintf;
50using google::protobuf::NewPermanentCallback;
51using std::make_pair;
52using std::tr1::shared_ptr;
53using std::set;
54using std::string;
55using std::vector;
56
57namespace chromeos_update_engine {
58
59const int UpdateAttempter::kMaxDeltaUpdateFailures = 3;
60
61// Private test server URL w/ custom port number.
62// TODO(garnold) This is a temporary hack to allow us to test the closed loop
63// automated update testing. To be replaced with an hard-coded local IP address.
64const char* const UpdateAttempter::kTestUpdateUrl(
65    "http://garnold.mtv.corp.google.com:8080/update");
66
67namespace {
68const int kMaxConsecutiveObeyProxyRequests = 20;
69
70const char* kUpdateCompletedMarker =
71    "/var/run/update_engine_autoupdate_completed";
72}  // namespace {}
73
74const char* UpdateStatusToString(UpdateStatus status) {
75  switch (status) {
76    case UPDATE_STATUS_IDLE:
77      return update_engine::kUpdateStatusIdle;
78    case UPDATE_STATUS_CHECKING_FOR_UPDATE:
79      return update_engine::kUpdateStatusCheckingForUpdate;
80    case UPDATE_STATUS_UPDATE_AVAILABLE:
81      return update_engine::kUpdateStatusUpdateAvailable;
82    case UPDATE_STATUS_DOWNLOADING:
83      return update_engine::kUpdateStatusDownloading;
84    case UPDATE_STATUS_VERIFYING:
85      return update_engine::kUpdateStatusVerifying;
86    case UPDATE_STATUS_FINALIZING:
87      return update_engine::kUpdateStatusFinalizing;
88    case UPDATE_STATUS_UPDATED_NEED_REBOOT:
89      return update_engine::kUpdateStatusUpdatedNeedReboot;
90    case UPDATE_STATUS_REPORTING_ERROR_EVENT:
91      return update_engine::kUpdateStatusReportingErrorEvent;
92    case UPDATE_STATUS_ATTEMPTING_ROLLBACK:
93      return update_engine::kUpdateStatusAttemptingRollback;
94    default:
95      return "unknown status";
96  }
97}
98
99// Turns a generic kErrorCodeError to a generic error code specific
100// to |action| (e.g., kErrorCodeFilesystemCopierError). If |code| is
101// not kErrorCodeError, or the action is not matched, returns |code|
102// unchanged.
103ErrorCode GetErrorCodeForAction(AbstractAction* action,
104                                     ErrorCode code) {
105  if (code != kErrorCodeError)
106    return code;
107
108  const string type = action->Type();
109  if (type == OmahaRequestAction::StaticType())
110    return kErrorCodeOmahaRequestError;
111  if (type == OmahaResponseHandlerAction::StaticType())
112    return kErrorCodeOmahaResponseHandlerError;
113  if (type == FilesystemCopierAction::StaticType())
114    return kErrorCodeFilesystemCopierError;
115  if (type == PostinstallRunnerAction::StaticType())
116    return kErrorCodePostinstallRunnerError;
117
118  return code;
119}
120
121UpdateAttempter::UpdateAttempter(SystemState* system_state,
122                                 DBusWrapperInterface* dbus_iface)
123    : UpdateAttempter(system_state, dbus_iface, kUpdateCompletedMarker) {}
124
125UpdateAttempter::UpdateAttempter(SystemState* system_state,
126                                 DBusWrapperInterface* dbus_iface,
127                                 const std::string& update_completed_marker)
128    : processor_(new ActionProcessor()),
129      system_state_(system_state),
130      chrome_proxy_resolver_(dbus_iface),
131      update_completed_marker_(update_completed_marker) {
132  if (!update_completed_marker_.empty() &&
133      utils::FileExists(update_completed_marker_.c_str()))
134    status_ = UPDATE_STATUS_UPDATED_NEED_REBOOT;
135  else
136    status_ = UPDATE_STATUS_IDLE;
137}
138
139void UpdateAttempter::Init() {
140  // Pulling from the SystemState can only be done after construction, since
141  // this is an aggregate of various objects (such as the UpdateAttempter),
142  // which requires them all to be constructed prior to it being used.
143  prefs_ = system_state_->prefs();
144  omaha_request_params_ = system_state_->request_params();
145}
146
147UpdateAttempter::~UpdateAttempter() {
148  CleanupCpuSharesManagement();
149}
150
151bool UpdateAttempter::CheckAndReportDailyMetrics() {
152  int64_t stored_value;
153  base::Time now = system_state_->clock()->GetWallclockTime();
154  if (system_state_->prefs()->Exists(kPrefsDailyMetricsLastReportedAt) &&
155      system_state_->prefs()->GetInt64(kPrefsDailyMetricsLastReportedAt,
156                                       &stored_value)) {
157    base::Time last_reported_at = base::Time::FromInternalValue(stored_value);
158    base::TimeDelta time_reported_since = now - last_reported_at;
159    if (time_reported_since.InSeconds() < 0) {
160      LOG(WARNING) << "Last reported daily metrics "
161                   << utils::FormatTimeDelta(time_reported_since) << " ago "
162                   << "which is negative. Either the system clock is wrong or "
163                   << "the kPrefsDailyMetricsLastReportedAt state variable "
164                   << "is wrong.";
165      // In this case, report daily metrics to reset.
166    } else {
167      if (time_reported_since.InSeconds() < 24*60*60) {
168        LOG(INFO) << "Last reported daily metrics "
169                  << utils::FormatTimeDelta(time_reported_since) << " ago.";
170        return false;
171      }
172      LOG(INFO) << "Last reported daily metrics "
173                << utils::FormatTimeDelta(time_reported_since) << " ago, "
174                << "which is more than 24 hours ago.";
175    }
176  }
177
178  LOG(INFO) << "Reporting daily metrics.";
179  system_state_->prefs()->SetInt64(kPrefsDailyMetricsLastReportedAt,
180                                   now.ToInternalValue());
181
182  ReportOSAge();
183
184  return true;
185}
186
187void UpdateAttempter::ReportOSAge() {
188  struct stat sb;
189
190  if (system_state_ == NULL)
191    return;
192
193  if (stat("/etc/lsb-release", &sb) != 0) {
194    PLOG(ERROR) << "Error getting file status for /etc/lsb-release";
195    return;
196  }
197
198  base::Time lsb_release_timestamp = utils::TimeFromStructTimespec(&sb.st_ctim);
199  base::Time now = system_state_->clock()->GetWallclockTime();
200  base::TimeDelta age = now - lsb_release_timestamp;
201  if (age.InSeconds() < 0) {
202    LOG(ERROR) << "The OS age (" << utils::FormatTimeDelta(age)
203               << ") is negative. Maybe the clock is wrong?";
204    return;
205  }
206
207  std::string metric = "Installer.OSAgeDays";
208  LOG(INFO) << "Uploading " << utils::FormatTimeDelta(age)
209            << " for metric " <<  metric;
210  system_state_->metrics_lib()->SendToUMA(
211       metric,
212       static_cast<int>(age.InDays()),
213       0,             // min: 0 days
214       6*30,          // max: 6 months (approx)
215       kNumDefaultUmaBuckets);
216
217  metrics::ReportDailyMetrics(system_state_, age);
218}
219
220void UpdateAttempter::Update(const string& app_version,
221                             const string& omaha_url,
222                             bool obey_proxies,
223                             bool interactive,
224                             bool is_test_mode) {
225  // This is called at least every 4 hours (see the constant
226  // UpdateCheckScheduler::kTimeoutMaxBackoffInterval) so it's
227  // appropriate to use as a hook for reporting daily metrics.
228  CheckAndReportDailyMetrics();
229
230  chrome_proxy_resolver_.Init();
231  fake_update_success_ = false;
232  if (status_ == UPDATE_STATUS_UPDATED_NEED_REBOOT) {
233    // Although we have applied an update, we still want to ping Omaha
234    // to ensure the number of active statistics is accurate.
235    //
236    // Also convey to the UpdateEngine.Check.Result metric that we're
237    // not performing an update check because of this.
238    LOG(INFO) << "Not updating b/c we already updated and we're waiting for "
239              << "reboot, we'll ping Omaha instead";
240    metrics::ReportUpdateCheckMetrics(system_state_,
241                                      metrics::CheckResult::kRebootPending,
242                                      metrics::CheckReaction::kUnset,
243                                      metrics::DownloadErrorCode::kUnset);
244    PingOmaha();
245    return;
246  }
247  if (status_ != UPDATE_STATUS_IDLE) {
248    // Update in progress. Do nothing
249    return;
250  }
251
252  if (!CalculateUpdateParams(app_version,
253                             omaha_url,
254                             obey_proxies,
255                             interactive,
256                             is_test_mode)) {
257    return;
258  }
259
260  BuildUpdateActions(interactive);
261
262  SetStatusAndNotify(UPDATE_STATUS_CHECKING_FOR_UPDATE,
263                     kUpdateNoticeUnspecified);
264
265  // Just in case we didn't update boot flags yet, make sure they're updated
266  // before any update processing starts.
267  start_action_processor_ = true;
268  UpdateBootFlags();
269}
270
271void UpdateAttempter::RefreshDevicePolicy() {
272  // Lazy initialize the policy provider, or reload the latest policy data.
273  if (!policy_provider_.get())
274    policy_provider_.reset(new policy::PolicyProvider());
275  policy_provider_->Reload();
276
277  const policy::DevicePolicy* device_policy = NULL;
278  if (policy_provider_->device_policy_is_loaded())
279    device_policy = &policy_provider_->GetDevicePolicy();
280
281  if (device_policy)
282    LOG(INFO) << "Device policies/settings present";
283  else
284    LOG(INFO) << "No device policies/settings present.";
285
286  system_state_->set_device_policy(device_policy);
287  system_state_->p2p_manager()->SetDevicePolicy(device_policy);
288}
289
290void UpdateAttempter::CalculateP2PParams(bool interactive) {
291  bool use_p2p_for_downloading = false;
292  bool use_p2p_for_sharing = false;
293
294  // Never use p2p for downloading in interactive checks unless the
295  // developer has opted in for it via a marker file.
296  //
297  // (Why would a developer want to opt in? If he's working on the
298  // update_engine or p2p codebases so he can actually test his
299  // code.).
300
301  if (system_state_ != NULL) {
302    if (!system_state_->p2p_manager()->IsP2PEnabled()) {
303      LOG(INFO) << "p2p is not enabled - disallowing p2p for both"
304                << " downloading and sharing.";
305    } else {
306      // Allow p2p for sharing, even in interactive checks.
307      use_p2p_for_sharing = true;
308      if (!interactive) {
309        LOG(INFO) << "Non-interactive check - allowing p2p for downloading";
310        use_p2p_for_downloading = true;
311      } else {
312        LOG(INFO) << "Forcibly disabling use of p2p for downloading "
313                  << "since this update attempt is interactive.";
314      }
315    }
316  }
317
318  omaha_request_params_->set_use_p2p_for_downloading(use_p2p_for_downloading);
319  omaha_request_params_->set_use_p2p_for_sharing(use_p2p_for_sharing);
320}
321
322bool UpdateAttempter::CalculateUpdateParams(const string& app_version,
323                                            const string& omaha_url,
324                                            bool obey_proxies,
325                                            bool interactive,
326                                            bool is_test_mode) {
327  http_response_code_ = 0;
328
329  // Set the test mode flag for the current update attempt.
330  is_test_mode_ = is_test_mode;
331  RefreshDevicePolicy();
332  const policy::DevicePolicy* device_policy = system_state_->device_policy();
333  if (device_policy) {
334    bool update_disabled = false;
335    if (device_policy->GetUpdateDisabled(&update_disabled))
336      omaha_request_params_->set_update_disabled(update_disabled);
337
338    string target_version_prefix;
339    if (device_policy->GetTargetVersionPrefix(&target_version_prefix))
340      omaha_request_params_->set_target_version_prefix(target_version_prefix);
341
342    set<string> allowed_types;
343    string allowed_types_str;
344    if (device_policy->GetAllowedConnectionTypesForUpdate(&allowed_types)) {
345      set<string>::const_iterator iter;
346      for (iter = allowed_types.begin(); iter != allowed_types.end(); ++iter)
347        allowed_types_str += *iter + " ";
348    }
349
350    LOG(INFO) << "Networks over which updates are allowed per policy : "
351              << (allowed_types_str.empty() ? "all" : allowed_types_str);
352  }
353
354  CalculateScatteringParams(interactive);
355
356  CalculateP2PParams(interactive);
357  if (omaha_request_params_->use_p2p_for_downloading() ||
358      omaha_request_params_->use_p2p_for_sharing()) {
359    // OK, p2p is to be used - start it and perform housekeeping.
360    if (!StartP2PAndPerformHousekeeping()) {
361      // If this fails, disable p2p for this attempt
362      LOG(INFO) << "Forcibly disabling use of p2p since starting p2p or "
363                << "performing housekeeping failed.";
364      omaha_request_params_->set_use_p2p_for_downloading(false);
365      omaha_request_params_->set_use_p2p_for_sharing(false);
366    }
367  }
368
369  // Determine whether an alternative test address should be used.
370  string omaha_url_to_use = omaha_url;
371  if ((is_using_test_url_ = (omaha_url_to_use.empty() && is_test_mode_))) {
372    omaha_url_to_use = kTestUpdateUrl;
373    LOG(INFO) << "using alternative server address: " << omaha_url_to_use;
374  }
375
376  if (!omaha_request_params_->Init(app_version,
377                                   omaha_url_to_use,
378                                   interactive)) {
379    LOG(ERROR) << "Unable to initialize Omaha request params.";
380    return false;
381  }
382
383  // Set the target channel iff ReleaseChannelDelegated policy is set to
384  // false and a non-empty ReleaseChannel policy is present. If delegated
385  // is true, we'll ignore ReleaseChannel policy value.
386  if (device_policy) {
387    bool delegated = false;
388    if (!device_policy->GetReleaseChannelDelegated(&delegated) || delegated) {
389      LOG(INFO) << "Channel settings are delegated to user by policy. "
390                   "Ignoring ReleaseChannel policy value";
391    }
392    else {
393      LOG(INFO) << "Channel settings are not delegated to the user by policy";
394      string target_channel;
395      if (device_policy->GetReleaseChannel(&target_channel) &&
396          !target_channel.empty()) {
397        // Pass in false for powerwash_allowed until we add it to the policy
398        // protobuf.
399        LOG(INFO) << "Setting target channel from ReleaseChannel policy value";
400        omaha_request_params_->SetTargetChannel(target_channel, false);
401
402        // Since this is the beginning of a new attempt, update the download
403        // channel. The download channel won't be updated until the next
404        // attempt, even if target channel changes meanwhile, so that how we'll
405        // know if we should cancel the current download attempt if there's
406        // such a change in target channel.
407        omaha_request_params_->UpdateDownloadChannel();
408      } else {
409        LOG(INFO) << "No ReleaseChannel specified in policy";
410      }
411    }
412  }
413
414  LOG(INFO) << "update_disabled = "
415            << utils::ToString(omaha_request_params_->update_disabled())
416            << ", target_version_prefix = "
417            << omaha_request_params_->target_version_prefix()
418            << ", scatter_factor_in_seconds = "
419            << utils::FormatSecs(scatter_factor_.InSeconds());
420
421  LOG(INFO) << "Wall Clock Based Wait Enabled = "
422            << omaha_request_params_->wall_clock_based_wait_enabled()
423            << ", Update Check Count Wait Enabled = "
424            << omaha_request_params_->update_check_count_wait_enabled()
425            << ", Waiting Period = " << utils::FormatSecs(
426               omaha_request_params_->waiting_period().InSeconds());
427
428  LOG(INFO) << "Use p2p For Downloading = "
429            << omaha_request_params_->use_p2p_for_downloading()
430            << ", Use p2p For Sharing = "
431            << omaha_request_params_->use_p2p_for_sharing();
432
433  obeying_proxies_ = true;
434  if (obey_proxies || proxy_manual_checks_ == 0) {
435    LOG(INFO) << "forced to obey proxies";
436    // If forced to obey proxies, every 20th request will not use proxies
437    proxy_manual_checks_++;
438    LOG(INFO) << "proxy manual checks: " << proxy_manual_checks_;
439    if (proxy_manual_checks_ >= kMaxConsecutiveObeyProxyRequests) {
440      proxy_manual_checks_ = 0;
441      obeying_proxies_ = false;
442    }
443  } else if (base::RandInt(0, 4) == 0) {
444    obeying_proxies_ = false;
445  }
446  LOG_IF(INFO, !obeying_proxies_) << "To help ensure updates work, this update "
447      "check we are ignoring the proxy settings and using "
448      "direct connections.";
449
450  DisableDeltaUpdateIfNeeded();
451  return true;
452}
453
454void UpdateAttempter::CalculateScatteringParams(bool interactive) {
455  // Take a copy of the old scatter value before we update it, as
456  // we need to update the waiting period if this value changes.
457  TimeDelta old_scatter_factor = scatter_factor_;
458  const policy::DevicePolicy* device_policy = system_state_->device_policy();
459  if (device_policy) {
460    int64 new_scatter_factor_in_secs = 0;
461    device_policy->GetScatterFactorInSeconds(&new_scatter_factor_in_secs);
462    if (new_scatter_factor_in_secs < 0) // sanitize input, just in case.
463      new_scatter_factor_in_secs  = 0;
464    scatter_factor_ = TimeDelta::FromSeconds(new_scatter_factor_in_secs);
465  }
466
467  bool is_scatter_enabled = false;
468  if (scatter_factor_.InSeconds() == 0) {
469    LOG(INFO) << "Scattering disabled since scatter factor is set to 0";
470  } else if (interactive) {
471    LOG(INFO) << "Scattering disabled as this is an interactive update check";
472  } else if (!system_state_->hardware()->IsOOBEComplete(nullptr)) {
473    LOG(INFO) << "Scattering disabled since OOBE is not complete yet";
474  } else {
475    is_scatter_enabled = true;
476    LOG(INFO) << "Scattering is enabled";
477  }
478
479  if (is_scatter_enabled) {
480    // This means the scattering policy is turned on.
481    // Now check if we need to update the waiting period. The two cases
482    // in which we'd need to update the waiting period are:
483    // 1. First time in process or a scheduled check after a user-initiated one.
484    //    (omaha_request_params_->waiting_period will be zero in this case).
485    // 2. Admin has changed the scattering policy value.
486    //    (new scattering value will be different from old one in this case).
487    int64 wait_period_in_secs = 0;
488    if (omaha_request_params_->waiting_period().InSeconds() == 0) {
489      // First case. Check if we have a suitable value to set for
490      // the waiting period.
491      if (prefs_->GetInt64(kPrefsWallClockWaitPeriod, &wait_period_in_secs) &&
492          wait_period_in_secs > 0 &&
493          wait_period_in_secs <= scatter_factor_.InSeconds()) {
494        // This means:
495        // 1. There's a persisted value for the waiting period available.
496        // 2. And that persisted value is still valid.
497        // So, in this case, we should reuse the persisted value instead of
498        // generating a new random value to improve the chances of a good
499        // distribution for scattering.
500        omaha_request_params_->set_waiting_period(
501          TimeDelta::FromSeconds(wait_period_in_secs));
502        LOG(INFO) << "Using persisted wall-clock waiting period: " <<
503            utils::FormatSecs(
504                omaha_request_params_->waiting_period().InSeconds());
505      }
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  prefs_->SetInt64(kPrefsWallClockWaitPeriod,
573                   omaha_request_params_->waiting_period().InSeconds());
574}
575
576void UpdateAttempter::BuildPostInstallActions(
577    InstallPlanAction* previous_action) {
578  shared_ptr<PostinstallRunnerAction> postinstall_runner_action(
579        new PostinstallRunnerAction());
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  LibcurlHttpFetcher* update_check_fetcher =
591      new LibcurlHttpFetcher(GetProxyResolver(), system_state_, is_test_mode_);
592  // Try harder to connect to the network, esp when not interactive.
593  // See comment in libcurl_http_fetcher.cc.
594  update_check_fetcher->set_no_network_max_retries(interactive ? 1 : 3);
595  update_check_fetcher->set_check_certificate(CertificateChecker::kUpdate);
596  shared_ptr<OmahaRequestAction> update_check_action(
597      new OmahaRequestAction(system_state_,
598                             NULL,
599                             update_check_fetcher,  // passes ownership
600                             false));
601  shared_ptr<OmahaResponseHandlerAction> response_handler_action(
602      new OmahaResponseHandlerAction(system_state_));
603  // We start with the kernel so it's marked as invalid more quickly.
604  shared_ptr<FilesystemCopierAction> kernel_filesystem_copier_action(
605      new FilesystemCopierAction(system_state_, true, false));
606  shared_ptr<FilesystemCopierAction> filesystem_copier_action(
607      new FilesystemCopierAction(system_state_, false, false));
608
609  shared_ptr<OmahaRequestAction> download_started_action(
610      new OmahaRequestAction(system_state_,
611                             new OmahaEvent(
612                                 OmahaEvent::kTypeUpdateDownloadStarted),
613                             new LibcurlHttpFetcher(GetProxyResolver(),
614                                                    system_state_,
615                                                    is_test_mode_),
616                             false));
617  LibcurlHttpFetcher* download_fetcher =
618      new LibcurlHttpFetcher(GetProxyResolver(), system_state_, is_test_mode_);
619  download_fetcher->set_check_certificate(CertificateChecker::kDownload);
620  shared_ptr<DownloadAction> download_action(
621      new DownloadAction(prefs_,
622                         system_state_,
623                         new MultiRangeHttpFetcher(
624                             download_fetcher)));  // passes ownership
625  shared_ptr<OmahaRequestAction> download_finished_action(
626      new OmahaRequestAction(system_state_,
627                             new OmahaEvent(
628                                 OmahaEvent::kTypeUpdateDownloadFinished),
629                             new LibcurlHttpFetcher(GetProxyResolver(),
630                                                    system_state_,
631                                                    is_test_mode_),
632                             false));
633  shared_ptr<FilesystemCopierAction> filesystem_verifier_action(
634      new FilesystemCopierAction(system_state_, false, true));
635  shared_ptr<FilesystemCopierAction> kernel_filesystem_verifier_action(
636      new FilesystemCopierAction(system_state_, true, true));
637  shared_ptr<OmahaRequestAction> update_complete_action(
638      new OmahaRequestAction(system_state_,
639                             new OmahaEvent(OmahaEvent::kTypeUpdateComplete),
640                             new LibcurlHttpFetcher(GetProxyResolver(),
641                                                    system_state_,
642                                                    is_test_mode_),
643                             false));
644
645  download_action->set_delegate(this);
646  response_handler_action_ = response_handler_action;
647  download_action_ = download_action;
648
649  actions_.push_back(shared_ptr<AbstractAction>(update_check_action));
650  actions_.push_back(shared_ptr<AbstractAction>(response_handler_action));
651  actions_.push_back(shared_ptr<AbstractAction>(filesystem_copier_action));
652  actions_.push_back(shared_ptr<AbstractAction>(
653      kernel_filesystem_copier_action));
654  actions_.push_back(shared_ptr<AbstractAction>(download_started_action));
655  actions_.push_back(shared_ptr<AbstractAction>(download_action));
656  actions_.push_back(shared_ptr<AbstractAction>(download_finished_action));
657  actions_.push_back(shared_ptr<AbstractAction>(filesystem_verifier_action));
658    actions_.push_back(shared_ptr<AbstractAction>(
659        kernel_filesystem_verifier_action));
660
661  // Bond them together. We have to use the leaf-types when calling
662  // BondActions().
663  BondActions(update_check_action.get(),
664              response_handler_action.get());
665  BondActions(response_handler_action.get(),
666              filesystem_copier_action.get());
667  BondActions(filesystem_copier_action.get(),
668              kernel_filesystem_copier_action.get());
669  BondActions(kernel_filesystem_copier_action.get(),
670              download_action.get());
671  BondActions(download_action.get(),
672              filesystem_verifier_action.get());
673  BondActions(filesystem_verifier_action.get(),
674              kernel_filesystem_verifier_action.get());
675
676  BuildPostInstallActions(kernel_filesystem_verifier_action.get());
677
678  actions_.push_back(shared_ptr<AbstractAction>(update_complete_action));
679
680  // Enqueue the actions
681  for (vector<shared_ptr<AbstractAction> >::iterator it = actions_.begin();
682       it != actions_.end(); ++it) {
683    processor_->EnqueueAction(it->get());
684  }
685}
686
687bool UpdateAttempter::Rollback(bool powerwash) {
688  if (!CanRollback()) {
689    return false;
690  }
691
692  // Extra check for enterprise-enrolled devices since they don't support
693  // powerwash.
694  if (powerwash) {
695    // Enterprise-enrolled devices have an empty owner in their device policy.
696    string owner;
697    RefreshDevicePolicy();
698    const policy::DevicePolicy* device_policy = system_state_->device_policy();
699    if (device_policy && (!device_policy->GetOwner(&owner) || owner.empty())) {
700      LOG(ERROR) << "Enterprise device detected. "
701                 << "Cannot perform a powerwash for enterprise devices.";
702      return false;
703    }
704  }
705
706  processor_->set_delegate(this);
707
708  // Initialize the default request params.
709  if (!omaha_request_params_->Init("", "", true)) {
710    LOG(ERROR) << "Unable to initialize Omaha request params.";
711    return false;
712  }
713
714  LOG(INFO) << "Setting rollback options.";
715  InstallPlan install_plan;
716
717  TEST_AND_RETURN_FALSE(utils::GetInstallDev(
718      system_state_->hardware()->BootDevice(),
719      &install_plan.install_path));
720
721  install_plan.kernel_install_path =
722      utils::KernelDeviceOfBootDevice(install_plan.install_path);
723  install_plan.powerwash_required = powerwash;
724
725  LOG(INFO) << "Using this install plan:";
726  install_plan.Dump();
727
728  shared_ptr<InstallPlanAction> install_plan_action(
729      new InstallPlanAction(install_plan));
730  actions_.push_back(shared_ptr<AbstractAction>(install_plan_action));
731
732  BuildPostInstallActions(install_plan_action.get());
733
734  // Enqueue the actions
735  for (vector<shared_ptr<AbstractAction> >::iterator it = actions_.begin();
736       it != actions_.end(); ++it) {
737    processor_->EnqueueAction(it->get());
738  }
739
740  // Update the payload state for Rollback.
741  system_state_->payload_state()->Rollback();
742
743  SetStatusAndNotify(UPDATE_STATUS_ATTEMPTING_ROLLBACK,
744                     kUpdateNoticeUnspecified);
745
746  // Just in case we didn't update boot flags yet, make sure they're updated
747  // before any update processing starts. This also schedules the start of the
748  // actions we just posted.
749  start_action_processor_ = true;
750  UpdateBootFlags();
751  return true;
752}
753
754bool UpdateAttempter::CanRollback() const {
755  // We can only rollback if the update_engine isn't busy and we have a valid
756  // rollback partition.
757  return (status_ == UPDATE_STATUS_IDLE && !GetRollbackPartition().empty());
758}
759
760std::string UpdateAttempter::GetRollbackPartition() const {
761  std::vector<std::string> kernel_devices =
762      system_state_->hardware()->GetKernelDevices();
763
764  std::string boot_kernel_device =
765      system_state_->hardware()->BootKernelDevice();
766
767  LOG(INFO) << "UpdateAttempter::GetRollbackPartition";
768  for (auto&& name : kernel_devices)
769    LOG(INFO) << "  Available kernel device = " << name;
770  LOG(INFO) << "  Boot kernel device =      " << boot_kernel_device;
771
772  auto current = std::find(kernel_devices.begin(), kernel_devices.end(),
773                           boot_kernel_device);
774
775  if(current == kernel_devices.end()) {
776    LOG(ERROR) << "Unable to find the boot kernel device in the list of "
777               << "available devices";
778    return std::string();
779  }
780
781  for (std::string const& device_name : kernel_devices) {
782    if (device_name != *current) {
783      bool bootable = false;
784      if (system_state_->hardware()->IsKernelBootable(device_name, &bootable) &&
785          bootable) {
786        return device_name;
787      }
788    }
789  }
790
791  return std::string();
792}
793
794std::vector<std::pair<std::string, bool>>
795    UpdateAttempter::GetKernelDevices() const {
796  std::vector<std::string> kernel_devices =
797    system_state_->hardware()->GetKernelDevices();
798
799  std::string boot_kernel_device =
800    system_state_->hardware()->BootKernelDevice();
801
802  std::vector<std::pair<std::string, bool>> info_list;
803  info_list.reserve(kernel_devices.size());
804
805  for (std::string device_name : kernel_devices) {
806    bool bootable = false;
807    system_state_->hardware()->IsKernelBootable(device_name, &bootable);
808    // Add '*' to the name of the partition we booted from.
809    if (device_name == boot_kernel_device)
810      device_name += '*';
811    info_list.emplace_back(device_name, bootable);
812  }
813
814  return info_list;
815}
816
817void UpdateAttempter::CheckForUpdate(const string& app_version,
818                                     const string& omaha_url,
819                                     bool interactive) {
820  LOG(INFO) << "New update check requested";
821
822  if (status_ != UPDATE_STATUS_IDLE) {
823    LOG(INFO) << "Skipping update check because current status is "
824              << UpdateStatusToString(status_);
825    return;
826  }
827
828  // Read GPIO signals and determine whether this is an automated test scenario.
829  // For safety, we only allow a test update to be performed once; subsequent
830  // update requests will be carried out normally.
831  bool is_test_mode = (!is_test_update_attempted_ &&
832                       system_state_->gpio_handler()->IsTestModeSignaled());
833  if (is_test_mode) {
834    LOG(WARNING) << "this is a test mode update attempt!";
835    is_test_update_attempted_ = true;
836  }
837
838  // Pass through the interactive flag, in case we want to simulate a scheduled
839  // test.
840  Update(app_version, omaha_url, true, interactive, is_test_mode);
841}
842
843bool UpdateAttempter::RebootIfNeeded() {
844  if (status_ != UPDATE_STATUS_UPDATED_NEED_REBOOT) {
845    LOG(INFO) << "Reboot requested, but status is "
846              << UpdateStatusToString(status_) << ", so not rebooting.";
847    return false;
848  }
849  TEST_AND_RETURN_FALSE(utils::Reboot());
850  return true;
851}
852
853void UpdateAttempter::WriteUpdateCompletedMarker() {
854  if (update_completed_marker_.empty())
855    return;
856
857  int64_t value = system_state_->clock()->GetBootTime().ToInternalValue();
858  string contents = base::StringPrintf("%" PRIi64, value);
859
860  utils::WriteFile(update_completed_marker_.c_str(),
861                   contents.c_str(),
862                   contents.length());
863}
864
865// Delegate methods:
866void UpdateAttempter::ProcessingDone(const ActionProcessor* processor,
867                                     ErrorCode code) {
868  LOG(INFO) << "Processing Done.";
869  actions_.clear();
870
871  // Reset cpu shares back to normal.
872  CleanupCpuSharesManagement();
873
874  if (status_ == UPDATE_STATUS_REPORTING_ERROR_EVENT) {
875    LOG(INFO) << "Error event sent.";
876
877    // Inform scheduler of new status; also specifically inform about a failed
878    // update attempt with a test address.
879    SetStatusAndNotify(UPDATE_STATUS_IDLE,
880                       (is_using_test_url_ ? kUpdateNoticeTestAddrFailed :
881                        kUpdateNoticeUnspecified));
882
883    if (!fake_update_success_) {
884      return;
885    }
886    LOG(INFO) << "Booted from FW B and tried to install new firmware, "
887        "so requesting reboot from user.";
888  }
889
890  if (code == kErrorCodeSuccess) {
891    WriteUpdateCompletedMarker();
892    prefs_->SetInt64(kPrefsDeltaUpdateFailures, 0);
893    prefs_->SetString(kPrefsPreviousVersion,
894                      omaha_request_params_->app_version());
895    DeltaPerformer::ResetUpdateProgress(prefs_, false);
896
897    system_state_->payload_state()->UpdateSucceeded();
898
899    // Since we're done with scattering fully at this point, this is the
900    // safest point delete the state files, as we're sure that the status is
901    // set to reboot (which means no more updates will be applied until reboot)
902    // This deletion is required for correctness as we want the next update
903    // check to re-create a new random number for the update check count.
904    // Similarly, we also delete the wall-clock-wait period that was persisted
905    // so that we start with a new random value for the next update check
906    // after reboot so that the same device is not favored or punished in any
907    // way.
908    prefs_->Delete(kPrefsUpdateCheckCount);
909    prefs_->Delete(kPrefsWallClockWaitPeriod);
910    prefs_->Delete(kPrefsUpdateFirstSeenAt);
911
912    SetStatusAndNotify(UPDATE_STATUS_UPDATED_NEED_REBOOT,
913                       kUpdateNoticeUnspecified);
914    LOG(INFO) << "Update successfully applied, waiting to reboot.";
915
916    // This pointer is NULL during rollback operations, and the stats
917    // don't make much sense then anway.
918    if (response_handler_action_) {
919      const InstallPlan& install_plan =
920          response_handler_action_->install_plan();
921
922      // Generate an unique payload identifier.
923      const string target_version_uid =
924          install_plan.payload_hash + ":" + install_plan.metadata_signature;
925
926      // Expect to reboot into the new version to send the proper metric during
927      // next boot.
928      system_state_->payload_state()->ExpectRebootInNewVersion(
929          target_version_uid);
930
931      // Also report the success code so that the percentiles can be
932      // interpreted properly for the remaining error codes in UMA.
933      utils::SendErrorCodeToUma(system_state_, code);
934    } else {
935      // If we just finished a rollback, then we expect to have no Omaha
936      // response. Otherwise, it's an error.
937      if (system_state_->payload_state()->GetRollbackVersion().empty()) {
938        LOG(ERROR) << "Can't send metrics because expected "
939            "response_handler_action_ missing.";
940      }
941    }
942    return;
943  }
944
945  if (ScheduleErrorEventAction()) {
946    return;
947  }
948  LOG(INFO) << "No update.";
949  SetStatusAndNotify(UPDATE_STATUS_IDLE, kUpdateNoticeUnspecified);
950}
951
952void UpdateAttempter::ProcessingStopped(const ActionProcessor* processor) {
953  // Reset cpu shares back to normal.
954  CleanupCpuSharesManagement();
955  download_progress_ = 0.0;
956  SetStatusAndNotify(UPDATE_STATUS_IDLE, kUpdateNoticeUnspecified);
957  actions_.clear();
958  error_event_.reset(NULL);
959}
960
961// Called whenever an action has finished processing, either successfully
962// or otherwise.
963void UpdateAttempter::ActionCompleted(ActionProcessor* processor,
964                                      AbstractAction* action,
965                                      ErrorCode code) {
966  // Reset download progress regardless of whether or not the download
967  // action succeeded. Also, get the response code from HTTP request
968  // actions (update download as well as the initial update check
969  // actions).
970  const string type = action->Type();
971  if (type == DownloadAction::StaticType()) {
972    download_progress_ = 0.0;
973    DownloadAction* download_action = dynamic_cast<DownloadAction*>(action);
974    http_response_code_ = download_action->GetHTTPResponseCode();
975  } else if (type == OmahaRequestAction::StaticType()) {
976    OmahaRequestAction* omaha_request_action =
977        dynamic_cast<OmahaRequestAction*>(action);
978    // If the request is not an event, then it's the update-check.
979    if (!omaha_request_action->IsEvent()) {
980      http_response_code_ = omaha_request_action->GetHTTPResponseCode();
981      // Forward the server-dictated poll interval to the update check
982      // scheduler, if any.
983      if (update_check_scheduler_) {
984        update_check_scheduler_->set_poll_interval(
985            omaha_request_action->GetOutputObject().poll_interval);
986      }
987    }
988  }
989  if (code != kErrorCodeSuccess) {
990    // If the current state is at or past the download phase, count the failure
991    // in case a switch to full update becomes necessary. Ignore network
992    // transfer timeouts and failures.
993    if (status_ >= UPDATE_STATUS_DOWNLOADING &&
994        code != kErrorCodeDownloadTransferError) {
995      MarkDeltaUpdateFailure();
996    }
997    // On failure, schedule an error event to be sent to Omaha.
998    CreatePendingErrorEvent(action, code);
999    return;
1000  }
1001  // Find out which action completed.
1002  if (type == OmahaResponseHandlerAction::StaticType()) {
1003    // Note that the status will be updated to DOWNLOADING when some bytes get
1004    // actually downloaded from the server and the BytesReceived callback is
1005    // invoked. This avoids notifying the user that a download has started in
1006    // cases when the server and the client are unable to initiate the download.
1007    CHECK(action == response_handler_action_.get());
1008    const InstallPlan& plan = response_handler_action_->install_plan();
1009    last_checked_time_ = time(NULL);
1010    new_version_ = plan.version;
1011    new_payload_size_ = plan.payload_size;
1012    SetupDownload();
1013    SetupCpuSharesManagement();
1014    SetStatusAndNotify(UPDATE_STATUS_UPDATE_AVAILABLE,
1015                       kUpdateNoticeUnspecified);
1016  } else if (type == DownloadAction::StaticType()) {
1017    SetStatusAndNotify(UPDATE_STATUS_FINALIZING, kUpdateNoticeUnspecified);
1018  }
1019}
1020
1021// Stop updating. An attempt will be made to record status to the disk
1022// so that updates can be resumed later.
1023void UpdateAttempter::Terminate() {
1024  // TODO(adlr): implement this method.
1025  NOTIMPLEMENTED();
1026}
1027
1028// Try to resume from a previously Terminate()d update.
1029void UpdateAttempter::ResumeUpdating() {
1030  // TODO(adlr): implement this method.
1031  NOTIMPLEMENTED();
1032}
1033
1034void UpdateAttempter::SetDownloadStatus(bool active) {
1035  download_active_ = active;
1036  LOG(INFO) << "Download status: " << (active ? "active" : "inactive");
1037}
1038
1039void UpdateAttempter::BytesReceived(uint64_t bytes_received, uint64_t total) {
1040  if (!download_active_) {
1041    LOG(ERROR) << "BytesReceived called while not downloading.";
1042    return;
1043  }
1044  double progress = static_cast<double>(bytes_received) /
1045      static_cast<double>(total);
1046  // Self throttle based on progress. Also send notifications if
1047  // progress is too slow.
1048  const double kDeltaPercent = 0.01;  // 1%
1049  if (status_ != UPDATE_STATUS_DOWNLOADING ||
1050      bytes_received == total ||
1051      progress - download_progress_ >= kDeltaPercent ||
1052      TimeTicks::Now() - last_notify_time_ >= TimeDelta::FromSeconds(10)) {
1053    download_progress_ = progress;
1054    SetStatusAndNotify(UPDATE_STATUS_DOWNLOADING, kUpdateNoticeUnspecified);
1055  }
1056}
1057
1058bool UpdateAttempter::ResetStatus() {
1059  LOG(INFO) << "Attempting to reset state from "
1060            << UpdateStatusToString(status_) << " to UPDATE_STATUS_IDLE";
1061
1062  switch (status_) {
1063    case UPDATE_STATUS_IDLE:
1064      // no-op.
1065      return true;
1066
1067    case UPDATE_STATUS_UPDATED_NEED_REBOOT:  {
1068      bool ret_value = true;
1069      status_ = UPDATE_STATUS_IDLE;
1070      LOG(INFO) << "Reset Successful";
1071
1072      // Remove the reboot marker so that if the machine is rebooted
1073      // after resetting to idle state, it doesn't go back to
1074      // UPDATE_STATUS_UPDATED_NEED_REBOOT state.
1075      if (!update_completed_marker_.empty()) {
1076        if (!base::DeleteFile(base::FilePath(update_completed_marker_), false))
1077          ret_value = false;
1078      }
1079
1080      // Notify the PayloadState that the successful payload was canceled.
1081      system_state_->payload_state()->ResetUpdateStatus();
1082
1083      return ret_value;
1084    }
1085
1086    default:
1087      LOG(ERROR) << "Reset not allowed in this state.";
1088      return false;
1089  }
1090}
1091
1092bool UpdateAttempter::GetStatus(int64_t* last_checked_time,
1093                                double* progress,
1094                                string* current_operation,
1095                                string* new_version,
1096                                int64_t* new_payload_size) {
1097  *last_checked_time = last_checked_time_;
1098  *progress = download_progress_;
1099  *current_operation = UpdateStatusToString(status_);
1100  *new_version = new_version_;
1101  *new_payload_size = new_payload_size_;
1102  return true;
1103}
1104
1105void UpdateAttempter::UpdateBootFlags() {
1106  if (update_boot_flags_running_) {
1107    LOG(INFO) << "Update boot flags running, nothing to do.";
1108    return;
1109  }
1110  if (updated_boot_flags_) {
1111    LOG(INFO) << "Already updated boot flags. Skipping.";
1112    if (start_action_processor_) {
1113      ScheduleProcessingStart();
1114    }
1115    return;
1116  }
1117  // This is purely best effort. Failures should be logged by Subprocess. Run
1118  // the script asynchronously to avoid blocking the event loop regardless of
1119  // the script runtime.
1120  update_boot_flags_running_ = true;
1121  LOG(INFO) << "Updating boot flags...";
1122  vector<string> cmd(1, "/usr/sbin/chromeos-setgoodkernel");
1123  if (!Subprocess::Get().Exec(cmd, StaticCompleteUpdateBootFlags, this)) {
1124    CompleteUpdateBootFlags(1);
1125  }
1126}
1127
1128void UpdateAttempter::CompleteUpdateBootFlags(int return_code) {
1129  update_boot_flags_running_ = false;
1130  updated_boot_flags_ = true;
1131  if (start_action_processor_) {
1132    ScheduleProcessingStart();
1133  }
1134}
1135
1136void UpdateAttempter::StaticCompleteUpdateBootFlags(
1137    int return_code,
1138    const string& output,
1139    void* p) {
1140  reinterpret_cast<UpdateAttempter*>(p)->CompleteUpdateBootFlags(return_code);
1141}
1142
1143void UpdateAttempter::BroadcastStatus() {
1144  if (!dbus_service_) {
1145    return;
1146  }
1147  last_notify_time_ = TimeTicks::Now();
1148  update_engine_service_emit_status_update(
1149      dbus_service_,
1150      last_checked_time_,
1151      download_progress_,
1152      UpdateStatusToString(status_),
1153      new_version_.c_str(),
1154      new_payload_size_);
1155}
1156
1157uint32_t UpdateAttempter::GetErrorCodeFlags()  {
1158  uint32_t flags = 0;
1159
1160  if (!system_state_->hardware()->IsNormalBootMode())
1161    flags |= kErrorCodeDevModeFlag;
1162
1163  if (response_handler_action_.get() &&
1164      response_handler_action_->install_plan().is_resume)
1165    flags |= kErrorCodeResumedFlag;
1166
1167  if (!system_state_->hardware()->IsOfficialBuild())
1168    flags |= kErrorCodeTestImageFlag;
1169
1170  if (omaha_request_params_->update_url() != kProductionOmahaUrl)
1171    flags |= kErrorCodeTestOmahaUrlFlag;
1172
1173  return flags;
1174}
1175
1176bool UpdateAttempter::ShouldCancel(ErrorCode* cancel_reason) {
1177  // Check if the channel we're attempting to update to is the same as the
1178  // target channel currently chosen by the user.
1179  OmahaRequestParams* params = system_state_->request_params();
1180  if (params->download_channel() != params->target_channel()) {
1181    LOG(ERROR) << "Aborting download as target channel: "
1182               << params->target_channel()
1183               << " is different from the download channel: "
1184               << params->download_channel();
1185    *cancel_reason = kErrorCodeUpdateCanceledByChannelChange;
1186    return true;
1187  }
1188
1189  return false;
1190}
1191
1192void UpdateAttempter::SetStatusAndNotify(UpdateStatus status,
1193                                         UpdateNotice notice) {
1194  status_ = status;
1195  if (update_check_scheduler_) {
1196    update_check_scheduler_->SetUpdateStatus(status_, notice);
1197  }
1198  BroadcastStatus();
1199}
1200
1201void UpdateAttempter::CreatePendingErrorEvent(AbstractAction* action,
1202                                              ErrorCode code) {
1203  if (error_event_.get()) {
1204    // This shouldn't really happen.
1205    LOG(WARNING) << "There's already an existing pending error event.";
1206    return;
1207  }
1208
1209  // For now assume that a generic Omaha response action failure means that
1210  // there's no update so don't send an event. Also, double check that the
1211  // failure has not occurred while sending an error event -- in which case
1212  // don't schedule another. This shouldn't really happen but just in case...
1213  if ((action->Type() == OmahaResponseHandlerAction::StaticType() &&
1214       code == kErrorCodeError) ||
1215      status_ == UPDATE_STATUS_REPORTING_ERROR_EVENT) {
1216    return;
1217  }
1218
1219  // Classify the code to generate the appropriate result so that
1220  // the Borgmon charts show up the results correctly.
1221  // Do this before calling GetErrorCodeForAction which could potentially
1222  // augment the bit representation of code and thus cause no matches for
1223  // the switch cases below.
1224  OmahaEvent::Result event_result;
1225  switch (code) {
1226    case kErrorCodeOmahaUpdateIgnoredPerPolicy:
1227    case kErrorCodeOmahaUpdateDeferredPerPolicy:
1228    case kErrorCodeOmahaUpdateDeferredForBackoff:
1229      event_result = OmahaEvent::kResultUpdateDeferred;
1230      break;
1231    default:
1232      event_result = OmahaEvent::kResultError;
1233      break;
1234  }
1235
1236  code = GetErrorCodeForAction(action, code);
1237  fake_update_success_ = code == kErrorCodePostinstallBootedFromFirmwareB;
1238
1239  // Compute the final error code with all the bit flags to be sent to Omaha.
1240  code = static_cast<ErrorCode>(code | GetErrorCodeFlags());
1241  error_event_.reset(new OmahaEvent(OmahaEvent::kTypeUpdateComplete,
1242                                    event_result,
1243                                    code));
1244}
1245
1246bool UpdateAttempter::ScheduleErrorEventAction() {
1247  if (error_event_.get() == NULL)
1248    return false;
1249
1250  LOG(ERROR) << "Update failed.";
1251  system_state_->payload_state()->UpdateFailed(error_event_->error_code);
1252
1253  // Send it to Uma.
1254  LOG(INFO) << "Reporting the error event";
1255  utils::SendErrorCodeToUma(system_state_, error_event_->error_code);
1256
1257  // Send it to Omaha.
1258  shared_ptr<OmahaRequestAction> error_event_action(
1259      new OmahaRequestAction(system_state_,
1260                             error_event_.release(),  // Pass ownership.
1261                             new LibcurlHttpFetcher(GetProxyResolver(),
1262                                                    system_state_,
1263                                                    is_test_mode_),
1264                             false));
1265  actions_.push_back(shared_ptr<AbstractAction>(error_event_action));
1266  processor_->EnqueueAction(error_event_action.get());
1267  SetStatusAndNotify(UPDATE_STATUS_REPORTING_ERROR_EVENT,
1268                     kUpdateNoticeUnspecified);
1269  processor_->StartProcessing();
1270  return true;
1271}
1272
1273void UpdateAttempter::SetCpuShares(utils::CpuShares shares) {
1274  if (shares_ == shares) {
1275    return;
1276  }
1277  if (utils::SetCpuShares(shares)) {
1278    shares_ = shares;
1279    LOG(INFO) << "CPU shares = " << shares_;
1280  }
1281}
1282
1283void UpdateAttempter::SetupCpuSharesManagement() {
1284  if (manage_shares_source_) {
1285    LOG(ERROR) << "Cpu shares timeout source hasn't been destroyed.";
1286    CleanupCpuSharesManagement();
1287  }
1288  const int kCpuSharesTimeout = 2 * 60 * 60;  // 2 hours
1289  manage_shares_source_ = g_timeout_source_new_seconds(kCpuSharesTimeout);
1290  g_source_set_callback(manage_shares_source_,
1291                        StaticManageCpuSharesCallback,
1292                        this,
1293                        NULL);
1294  g_source_attach(manage_shares_source_, NULL);
1295  SetCpuShares(utils::kCpuSharesLow);
1296}
1297
1298void UpdateAttempter::CleanupCpuSharesManagement() {
1299  if (manage_shares_source_) {
1300    g_source_destroy(manage_shares_source_);
1301    manage_shares_source_ = NULL;
1302  }
1303  SetCpuShares(utils::kCpuSharesNormal);
1304}
1305
1306gboolean UpdateAttempter::StaticManageCpuSharesCallback(gpointer data) {
1307  return reinterpret_cast<UpdateAttempter*>(data)->ManageCpuSharesCallback();
1308}
1309
1310gboolean UpdateAttempter::StaticStartProcessing(gpointer data) {
1311  reinterpret_cast<UpdateAttempter*>(data)->processor_->StartProcessing();
1312  return FALSE;  // Don't call this callback again.
1313}
1314
1315void UpdateAttempter::ScheduleProcessingStart() {
1316  LOG(INFO) << "Scheduling an action processor start.";
1317  start_action_processor_ = false;
1318  g_idle_add(&StaticStartProcessing, this);
1319}
1320
1321bool UpdateAttempter::ManageCpuSharesCallback() {
1322  SetCpuShares(utils::kCpuSharesNormal);
1323  manage_shares_source_ = NULL;
1324  return false;  // Destroy the timeout source.
1325}
1326
1327void UpdateAttempter::DisableDeltaUpdateIfNeeded() {
1328  int64_t delta_failures;
1329  if (omaha_request_params_->delta_okay() &&
1330      prefs_->GetInt64(kPrefsDeltaUpdateFailures, &delta_failures) &&
1331      delta_failures >= kMaxDeltaUpdateFailures) {
1332    LOG(WARNING) << "Too many delta update failures, forcing full update.";
1333    omaha_request_params_->set_delta_okay(false);
1334  }
1335}
1336
1337void UpdateAttempter::MarkDeltaUpdateFailure() {
1338  // Don't try to resume a failed delta update.
1339  DeltaPerformer::ResetUpdateProgress(prefs_, false);
1340  int64_t delta_failures;
1341  if (!prefs_->GetInt64(kPrefsDeltaUpdateFailures, &delta_failures) ||
1342      delta_failures < 0) {
1343    delta_failures = 0;
1344  }
1345  prefs_->SetInt64(kPrefsDeltaUpdateFailures, ++delta_failures);
1346}
1347
1348void UpdateAttempter::SetupDownload() {
1349  MultiRangeHttpFetcher* fetcher =
1350      dynamic_cast<MultiRangeHttpFetcher*>(download_action_->http_fetcher());
1351  fetcher->ClearRanges();
1352  if (response_handler_action_->install_plan().is_resume) {
1353    // Resuming an update so fetch the update manifest metadata first.
1354    int64_t manifest_metadata_size = 0;
1355    prefs_->GetInt64(kPrefsManifestMetadataSize, &manifest_metadata_size);
1356    fetcher->AddRange(0, manifest_metadata_size);
1357    // If there're remaining unprocessed data blobs, fetch them. Be careful not
1358    // to request data beyond the end of the payload to avoid 416 HTTP response
1359    // error codes.
1360    int64_t next_data_offset = 0;
1361    prefs_->GetInt64(kPrefsUpdateStateNextDataOffset, &next_data_offset);
1362    uint64_t resume_offset = manifest_metadata_size + next_data_offset;
1363    if (resume_offset < response_handler_action_->install_plan().payload_size) {
1364      fetcher->AddRange(resume_offset);
1365    }
1366  } else {
1367    fetcher->AddRange(0);
1368  }
1369}
1370
1371void UpdateAttempter::PingOmaha() {
1372  if (!processor_->IsRunning()) {
1373    shared_ptr<OmahaRequestAction> ping_action(
1374        new OmahaRequestAction(system_state_,
1375                               NULL,
1376                               new LibcurlHttpFetcher(GetProxyResolver(),
1377                                                      system_state_,
1378                                                      is_test_mode_),
1379                               true));
1380    actions_.push_back(shared_ptr<OmahaRequestAction>(ping_action));
1381    processor_->set_delegate(NULL);
1382    processor_->EnqueueAction(ping_action.get());
1383    // Call StartProcessing() synchronously here to avoid any race conditions
1384    // caused by multiple outstanding ping Omaha requests.  If we call
1385    // StartProcessing() asynchronously, the device can be suspended before we
1386    // get a chance to callback to StartProcessing().  When the device resumes
1387    // (assuming the device sleeps longer than the next update check period),
1388    // StartProcessing() is called back and at the same time, the next update
1389    // check is fired which eventually invokes StartProcessing().  A crash
1390    // can occur because StartProcessing() checks to make sure that the
1391    // processor is idle which it isn't due to the two concurrent ping Omaha
1392    // requests.
1393    processor_->StartProcessing();
1394  } else {
1395    LOG(WARNING) << "Action processor running, Omaha ping suppressed.";
1396  }
1397
1398  // Update the status which will schedule the next update check
1399  SetStatusAndNotify(UPDATE_STATUS_UPDATED_NEED_REBOOT,
1400                     kUpdateNoticeUnspecified);
1401}
1402
1403
1404bool UpdateAttempter::DecrementUpdateCheckCount() {
1405  int64 update_check_count_value;
1406
1407  if (!prefs_->Exists(kPrefsUpdateCheckCount)) {
1408    // This file does not exist. This means we haven't started our update
1409    // check count down yet, so nothing more to do. This file will be created
1410    // later when we first satisfy the wall-clock-based-wait period.
1411    LOG(INFO) << "No existing update check count. That's normal.";
1412    return true;
1413  }
1414
1415  if (prefs_->GetInt64(kPrefsUpdateCheckCount, &update_check_count_value)) {
1416    // Only if we're able to read a proper integer value, then go ahead
1417    // and decrement and write back the result in the same file, if needed.
1418    LOG(INFO) << "Update check count = " << update_check_count_value;
1419
1420    if (update_check_count_value == 0) {
1421      // It could be 0, if, for some reason, the file didn't get deleted
1422      // when we set our status to waiting for reboot. so we just leave it
1423      // as is so that we can prevent another update_check wait for this client.
1424      LOG(INFO) << "Not decrementing update check count as it's already 0.";
1425      return true;
1426    }
1427
1428    if (update_check_count_value > 0)
1429      update_check_count_value--;
1430    else
1431      update_check_count_value = 0;
1432
1433    // Write out the new value of update_check_count_value.
1434    if (prefs_->SetInt64(kPrefsUpdateCheckCount, update_check_count_value)) {
1435      // We successfully wrote out te new value, so enable the
1436      // update check based wait.
1437      LOG(INFO) << "New update check count = " << update_check_count_value;
1438      return true;
1439    }
1440  }
1441
1442  LOG(INFO) << "Deleting update check count state due to read/write errors.";
1443
1444  // We cannot read/write to the file, so disable the update check based wait
1445  // so that we don't get stuck in this OS version by any chance (which could
1446  // happen if there's some bug that causes to read/write incorrectly).
1447  // Also attempt to delete the file to do our best effort to cleanup.
1448  prefs_->Delete(kPrefsUpdateCheckCount);
1449  return false;
1450}
1451
1452
1453void UpdateAttempter::UpdateEngineStarted() {
1454  // If we just booted into a new update, keep the previous OS version
1455  // in case we rebooted because of a crash of the old version, so we
1456  // can do a proper crash report with correcy information.
1457  // This must be done before calling
1458  // system_state_->payload_state()->UpdateEngineStarted() since it will
1459  // delete SystemUpdated marker file.
1460  if (system_state_->system_rebooted() &&
1461      prefs_->Exists(kPrefsSystemUpdatedMarker)) {
1462    if (!prefs_->GetString(kPrefsPreviousVersion, &prev_version_)) {
1463      // If we fail to get the version string, make sure it stays empty.
1464      prev_version_.clear();
1465    }
1466  }
1467
1468  system_state_->payload_state()->UpdateEngineStarted();
1469  StartP2PAtStartup();
1470}
1471
1472bool UpdateAttempter::StartP2PAtStartup() {
1473  if (system_state_ == NULL ||
1474      !system_state_->p2p_manager()->IsP2PEnabled()) {
1475    LOG(INFO) << "Not starting p2p at startup since it's not enabled.";
1476    return false;
1477  }
1478
1479  if (system_state_->p2p_manager()->CountSharedFiles() < 1) {
1480    LOG(INFO) << "Not starting p2p at startup since our application "
1481              << "is not sharing any files.";
1482    return false;
1483  }
1484
1485  return StartP2PAndPerformHousekeeping();
1486}
1487
1488bool UpdateAttempter::StartP2PAndPerformHousekeeping() {
1489  if (system_state_ == NULL)
1490    return false;
1491
1492  if (!system_state_->p2p_manager()->IsP2PEnabled()) {
1493    LOG(INFO) << "Not starting p2p since it's not enabled.";
1494    return false;
1495  }
1496
1497  LOG(INFO) << "Ensuring that p2p is running.";
1498  if (!system_state_->p2p_manager()->EnsureP2PRunning()) {
1499    LOG(ERROR) << "Error starting p2p.";
1500    return false;
1501  }
1502
1503  LOG(INFO) << "Performing p2p housekeeping.";
1504  if (!system_state_->p2p_manager()->PerformHousekeeping()) {
1505    LOG(ERROR) << "Error performing housekeeping for p2p.";
1506    return false;
1507  }
1508
1509  LOG(INFO) << "Done performing p2p housekeeping.";
1510  return true;
1511}
1512
1513bool UpdateAttempter::GetBootTimeAtUpdate(base::Time *out_boot_time) {
1514  if (update_completed_marker_.empty())
1515    return false;
1516
1517  string contents;
1518  if (!utils::ReadFile(update_completed_marker_, &contents))
1519    return false;
1520
1521  char *endp;
1522  int64_t stored_value = strtoll(contents.c_str(), &endp, 10);
1523  if (*endp != '\0') {
1524    LOG(ERROR) << "Error parsing file " << update_completed_marker_ << " "
1525               << "with content '" << contents << "'";
1526    return false;
1527  }
1528
1529  *out_boot_time = Time::FromInternalValue(stored_value);
1530  return true;
1531}
1532
1533}  // namespace chromeos_update_engine
1534