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