• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //
2 // Copyright (C) 2012 The Android Open Source Project
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 //      http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16 
17 #ifndef UPDATE_ENGINE_UPDATE_ATTEMPTER_H_
18 #define UPDATE_ENGINE_UPDATE_ATTEMPTER_H_
19 
20 #include <time.h>
21 
22 #include <memory>
23 #include <set>
24 #include <string>
25 #include <utility>
26 #include <vector>
27 
28 #include <base/bind.h>
29 #include <base/time/time.h>
30 #include <gtest/gtest_prod.h>  // for FRIEND_TEST
31 
32 #if USE_LIBCROS
33 #include "update_engine/chrome_browser_proxy_resolver.h"
34 #endif  // USE_LIBCROS
35 #include "update_engine/certificate_checker.h"
36 #include "update_engine/client_library/include/update_engine/update_status.h"
37 #include "update_engine/common/action_processor.h"
38 #include "update_engine/common/cpu_limiter.h"
39 #include "update_engine/omaha_request_params.h"
40 #include "update_engine/omaha_response_handler_action.h"
41 #include "update_engine/payload_consumer/download_action.h"
42 #include "update_engine/payload_consumer/postinstall_runner_action.h"
43 #include "update_engine/proxy_resolver.h"
44 #include "update_engine/service_observer_interface.h"
45 #include "update_engine/system_state.h"
46 #include "update_engine/update_manager/policy.h"
47 #include "update_engine/update_manager/update_manager.h"
48 
49 class MetricsLibraryInterface;
50 
51 namespace org {
52 namespace chromium {
53 class NetworkProxyServiceInterfaceProxyInterface;
54 }  // namespace chromium
55 }  // namespace org
56 
57 namespace policy {
58 class PolicyProvider;
59 }
60 
61 namespace chromeos_update_engine {
62 
63 class UpdateEngineAdaptor;
64 
65 class UpdateAttempter : public ActionProcessorDelegate,
66                         public DownloadActionDelegate,
67                         public CertificateChecker::Observer,
68                         public PostinstallRunnerAction::DelegateInterface {
69  public:
70   using UpdateStatus = update_engine::UpdateStatus;
71   static const int kMaxDeltaUpdateFailures;
72 
73   UpdateAttempter(SystemState* system_state,
74                   CertificateChecker* cert_checker,
75                   org::chromium::NetworkProxyServiceInterfaceProxyInterface*
76                       network_proxy_service_proxy);
77   ~UpdateAttempter() override;
78 
79   // Further initialization to be done post construction.
80   void Init();
81 
82   // Initiates scheduling of update checks.
83   virtual void ScheduleUpdates();
84 
85   // Checks for update and, if a newer version is available, attempts to update
86   // the system. Non-empty |in_app_version| or |in_update_url| prevents
87   // automatic detection of the parameter.  |target_channel| denotes a
88   // policy-mandated channel we are updating to, if not empty. If |obey_proxies|
89   // is true, the update will likely respect Chrome's proxy setting. For
90   // security reasons, we may still not honor them. |interactive| should be true
91   // if this was called from the user (ie dbus).
92   virtual void Update(const std::string& app_version,
93                       const std::string& omaha_url,
94                       const std::string& target_channel,
95                       const std::string& target_version_prefix,
96                       bool obey_proxies,
97                       bool interactive);
98 
99   // ActionProcessorDelegate methods:
100   void ProcessingDone(const ActionProcessor* processor,
101                       ErrorCode code) override;
102   void ProcessingStopped(const ActionProcessor* processor) override;
103   void ActionCompleted(ActionProcessor* processor,
104                        AbstractAction* action,
105                        ErrorCode code) override;
106 
107   // PostinstallRunnerAction::DelegateInterface
108   void ProgressUpdate(double progress) override;
109 
110   // Resets the current state to UPDATE_STATUS_IDLE.
111   // Used by update_engine_client for restarting a new update without
112   // having to reboot once the previous update has reached
113   // UPDATE_STATUS_UPDATED_NEED_REBOOT state. This is used only
114   // for testing purposes.
115   virtual bool ResetStatus();
116 
117   // Returns the current status in the out params. Returns true on success.
118   virtual bool GetStatus(int64_t* last_checked_time,
119                          double* progress,
120                          std::string* current_operation,
121                          std::string* new_version,
122                          int64_t* new_size);
123 
124   // Runs chromeos-setgoodkernel, whose responsibility it is to mark the
125   // currently booted partition has high priority/permanent/etc. The execution
126   // is asynchronous. On completion, the action processor may be started
127   // depending on the |start_action_processor_| field. Note that every update
128   // attempt goes through this method.
129   void UpdateBootFlags();
130 
131   // Called when the boot flags have been updated.
132   void CompleteUpdateBootFlags(bool success);
133 
status()134   UpdateStatus status() const { return status_; }
135 
http_response_code()136   int http_response_code() const { return http_response_code_; }
set_http_response_code(int code)137   void set_http_response_code(int code) { http_response_code_ = code; }
138 
139   // This is the internal entry point for going through an
140   // update. If the current status is idle invokes Update.
141   // This is called by the DBus implementation.
142   virtual void CheckForUpdate(const std::string& app_version,
143                               const std::string& omaha_url,
144                               bool is_interactive);
145 
146   // This is the internal entry point for going through a rollback. This will
147   // attempt to run the postinstall on the non-active partition and set it as
148   // the partition to boot from. If |powerwash| is True, perform a powerwash
149   // as part of rollback. Returns True on success.
150   bool Rollback(bool powerwash);
151 
152   // This is the internal entry point for checking if we can rollback.
153   bool CanRollback() const;
154 
155   // This is the internal entry point for getting a rollback partition name,
156   // if one exists. It returns the bootable rollback kernel device partition
157   // name or empty string if none is available.
158   BootControlInterface::Slot GetRollbackSlot() const;
159 
160   // Initiates a reboot if the current state is
161   // UPDATED_NEED_REBOOT. Returns true on sucess, false otherwise.
162   bool RebootIfNeeded();
163 
164   // DownloadActionDelegate methods:
165   void BytesReceived(uint64_t bytes_progressed,
166                      uint64_t bytes_received,
167                      uint64_t total) override;
168 
169   // Returns that the update should be canceled when the download channel was
170   // changed.
171   bool ShouldCancel(ErrorCode* cancel_reason) override;
172 
173   void DownloadComplete() override;
174 
175   // Broadcasts the current status to all observers.
176   void BroadcastStatus();
177 
178   // Returns the special flags to be added to ErrorCode values based on the
179   // parameters used in the current update attempt.
180   uint32_t GetErrorCodeFlags();
181 
182   // Called at update_engine startup to do various house-keeping.
183   void UpdateEngineStarted();
184 
185   // Reloads the device policy from libbrillo. Note: This method doesn't
186   // cause a real-time policy fetch from the policy server. It just reloads the
187   // latest value that libbrillo has cached. libbrillo fetches the policies
188   // from the server asynchronously at its own frequency.
189   virtual void RefreshDevicePolicy();
190 
191   // Stores in |out_boot_time| the boottime (CLOCK_BOOTTIME) recorded at the
192   // time of the last successful update in the current boot. Returns false if
193   // there wasn't a successful update in the current boot.
194   virtual bool GetBootTimeAtUpdate(base::Time *out_boot_time);
195 
196   // Returns a version OS version that was being used before the last reboot,
197   // and if that reboot happended to be into an update (current version).
198   // This will return an empty string otherwise.
GetPrevVersion()199   std::string const& GetPrevVersion() const { return prev_version_; }
200 
201   // Returns the number of consecutive failed update checks.
consecutive_failed_update_checks()202   virtual unsigned int consecutive_failed_update_checks() const {
203     return consecutive_failed_update_checks_;
204   }
205 
206   // Returns the poll interval dictated by Omaha, if provided; zero otherwise.
server_dictated_poll_interval()207   virtual unsigned int server_dictated_poll_interval() const {
208     return server_dictated_poll_interval_;
209   }
210 
211   // Sets a callback to be used when either a forced update request is received
212   // (first argument set to true) or cleared by an update attempt (first
213   // argument set to false). The callback further encodes whether the forced
214   // check is an interactive one (second argument set to true). Takes ownership
215   // of the callback object. A null value disables callback on these events.
216   // Note that only one callback can be set, so effectively at most one client
217   // can be notified.
set_forced_update_pending_callback(base::Callback<void (bool,bool)> * callback)218   virtual void set_forced_update_pending_callback(
219       base::Callback<void(bool, bool)>*  // NOLINT(readability/function)
220       callback) {
221     forced_update_pending_callback_.reset(callback);
222   }
223 
224   // Returns true if we should allow updates from any source. In official builds
225   // we want to restrict updates to known safe sources, but under certain
226   // conditions it's useful to allow updating from anywhere (e.g. to allow
227   // 'cros flash' to function properly).
228   virtual bool IsAnyUpdateSourceAllowed();
229 
230   // Add and remove a service observer.
AddObserver(ServiceObserverInterface * observer)231   void AddObserver(ServiceObserverInterface* observer) {
232     service_observers_.insert(observer);
233   }
RemoveObserver(ServiceObserverInterface * observer)234   void RemoveObserver(ServiceObserverInterface* observer) {
235     service_observers_.erase(observer);
236   }
237 
service_observers()238   const std::set<ServiceObserverInterface*>& service_observers() {
239     return service_observers_;
240   }
241 
242   // Remove all the observers.
ClearObservers()243   void ClearObservers() { service_observers_.clear(); }
244 
245  private:
246   // Update server URL for automated lab test.
247   static const char* const kTestUpdateUrl;
248 
249   // Friend declarations for testing purposes.
250   friend class UpdateAttempterUnderTest;
251   friend class UpdateAttempterTest;
252   FRIEND_TEST(UpdateAttempterTest, ActionCompletedDownloadTest);
253   FRIEND_TEST(UpdateAttempterTest, ActionCompletedErrorTest);
254   FRIEND_TEST(UpdateAttempterTest, ActionCompletedOmahaRequestTest);
255   FRIEND_TEST(UpdateAttempterTest, CreatePendingErrorEventTest);
256   FRIEND_TEST(UpdateAttempterTest, CreatePendingErrorEventResumedTest);
257   FRIEND_TEST(UpdateAttempterTest, DisableDeltaUpdateIfNeededTest);
258   FRIEND_TEST(UpdateAttempterTest, MarkDeltaUpdateFailureTest);
259   FRIEND_TEST(UpdateAttempterTest, PingOmahaTest);
260   FRIEND_TEST(UpdateAttempterTest, ScheduleErrorEventActionNoEventTest);
261   FRIEND_TEST(UpdateAttempterTest, ScheduleErrorEventActionTest);
262   FRIEND_TEST(UpdateAttempterTest, UpdateTest);
263   FRIEND_TEST(UpdateAttempterTest, ReportDailyMetrics);
264   FRIEND_TEST(UpdateAttempterTest, BootTimeInUpdateMarkerFile);
265   FRIEND_TEST(UpdateAttempterTest, TargetVersionPrefixSetAndReset);
266 
267   // CertificateChecker::Observer method.
268   // Report metrics about the certificate being checked.
269   void CertificateChecked(ServerToCheck server_to_check,
270                           CertificateCheckResult result) override;
271 
272   // Checks if it's more than 24 hours since daily metrics were last
273   // reported and, if so, reports daily metrics. Returns |true| if
274   // metrics were reported, |false| otherwise.
275   bool CheckAndReportDailyMetrics();
276 
277   // Calculates and reports the age of the currently running OS. This
278   // is defined as the age of the /etc/lsb-release file.
279   void ReportOSAge();
280 
281   // Sets the status to the given status and notifies a status update over dbus.
282   void SetStatusAndNotify(UpdateStatus status);
283 
284   // Creates an error event object in |error_event_| to be included in an
285   // OmahaRequestAction once the current action processor is done.
286   void CreatePendingErrorEvent(AbstractAction* action, ErrorCode code);
287 
288   // If there's a pending error event allocated in |error_event_|, schedules an
289   // OmahaRequestAction with that event in the current processor, clears the
290   // pending event, updates the status and returns true. Returns false
291   // otherwise.
292   bool ScheduleErrorEventAction();
293 
294   // Schedules an event loop callback to start the action processor. This is
295   // scheduled asynchronously to unblock the event loop.
296   void ScheduleProcessingStart();
297 
298   // Checks if a full update is needed and forces it by updating the Omaha
299   // request params.
300   void DisableDeltaUpdateIfNeeded();
301 
302   // If this was a delta update attempt that failed, count it so that a full
303   // update can be tried when needed.
304   void MarkDeltaUpdateFailure();
305 
GetProxyResolver()306   ProxyResolver* GetProxyResolver() {
307 #if USE_LIBCROS
308     return obeying_proxies_ ?
309         reinterpret_cast<ProxyResolver*>(&chrome_proxy_resolver_) :
310         reinterpret_cast<ProxyResolver*>(&direct_proxy_resolver_);
311 #else
312     return &direct_proxy_resolver_;
313 #endif  // USE_LIBCROS
314   }
315 
316   // Sends a ping to Omaha.
317   // This is used after an update has been applied and we're waiting for the
318   // user to reboot.  This ping helps keep the number of actives count
319   // accurate in case a user takes a long time to reboot the device after an
320   // update has been applied.
321   void PingOmaha();
322 
323   // Helper method of Update() to calculate the update-related parameters
324   // from various sources and set the appropriate state. Please refer to
325   // Update() method for the meaning of the parametes.
326   bool CalculateUpdateParams(const std::string& app_version,
327                              const std::string& omaha_url,
328                              const std::string& target_channel,
329                              const std::string& target_version_prefix,
330                              bool obey_proxies,
331                              bool interactive);
332 
333   // Calculates all the scattering related parameters (such as waiting period,
334   // which type of scattering is enabled, etc.) and also updates/deletes
335   // the corresponding prefs file used in scattering. Should be called
336   // only after the device policy has been loaded and set in the system_state_.
337   void CalculateScatteringParams(bool is_interactive);
338 
339   // Sets a random value for the waiting period to wait for before downloading
340   // an update, if one available. This value will be upperbounded by the
341   // scatter factor value specified from policy.
342   void GenerateNewWaitingPeriod();
343 
344   // Helper method of Update() and Rollback() to construct the sequence of
345   // actions to be performed for the postinstall.
346   // |previous_action| is the previous action to get
347   // bonded with the install_plan that gets passed to postinstall.
348   void BuildPostInstallActions(InstallPlanAction* previous_action);
349 
350   // Helper method of Update() to construct the sequence of actions to
351   // be performed for an update check. Please refer to
352   // Update() method for the meaning of the parameters.
353   void BuildUpdateActions(bool interactive);
354 
355   // Decrements the count in the kUpdateCheckCountFilePath.
356   // Returns True if successfully decremented, false otherwise.
357   bool DecrementUpdateCheckCount();
358 
359   // Starts p2p and performs housekeeping. Returns true only if p2p is
360   // running and housekeeping was done.
361   bool StartP2PAndPerformHousekeeping();
362 
363   // Calculates whether peer-to-peer should be used. Sets the
364   // |use_p2p_to_download_| and |use_p2p_to_share_| parameters
365   // on the |omaha_request_params_| object.
366   void CalculateP2PParams(bool interactive);
367 
368   // Starts P2P if it's enabled and there are files to actually share.
369   // Called only at program startup. Returns true only if p2p was
370   // started and housekeeping was performed.
371   bool StartP2PAtStartup();
372 
373   // Writes to the processing completed marker. Does nothing if
374   // |update_completed_marker_| is empty.
375   void WriteUpdateCompletedMarker();
376 
377   // Reboots the system directly by calling /sbin/shutdown. Returns true on
378   // success.
379   bool RebootDirectly();
380 
381   // Callback for the async UpdateCheckAllowed policy request. If |status| is
382   // |EvalStatus::kSucceeded|, either runs or suppresses periodic update checks,
383   // based on the content of |params|. Otherwise, retries the policy request.
384   void OnUpdateScheduled(
385       chromeos_update_manager::EvalStatus status,
386       const chromeos_update_manager::UpdateCheckParams& params);
387 
388   // Updates the time an update was last attempted to the current time.
389   void UpdateLastCheckedTime();
390 
391   // Returns whether an update is currently running or scheduled.
392   bool IsUpdateRunningOrScheduled();
393 
394   // Last status notification timestamp used for throttling. Use monotonic
395   // TimeTicks to ensure that notifications are sent even if the system clock is
396   // set back in the middle of an update.
397   base::TimeTicks last_notify_time_;
398 
399   std::vector<std::shared_ptr<AbstractAction>> actions_;
400   std::unique_ptr<ActionProcessor> processor_;
401 
402   // External state of the system outside the update_engine process
403   // carved out separately to mock out easily in unit tests.
404   SystemState* system_state_;
405 
406   // Pointer to the certificate checker instance to use.
407   CertificateChecker* cert_checker_;
408 
409   // The list of services observing changes in the updater.
410   std::set<ServiceObserverInterface*> service_observers_;
411 
412   // Pointer to the OmahaResponseHandlerAction in the actions_ vector.
413   std::shared_ptr<OmahaResponseHandlerAction> response_handler_action_;
414 
415   // Pointer to the DownloadAction in the actions_ vector.
416   std::shared_ptr<DownloadAction> download_action_;
417 
418   // Pointer to the preferences store interface. This is just a cached
419   // copy of system_state->prefs() because it's used in many methods and
420   // is convenient this way.
421   PrefsInterface* prefs_ = nullptr;
422 
423   // Pending error event, if any.
424   std::unique_ptr<OmahaEvent> error_event_;
425 
426   // If we should request a reboot even tho we failed the update
427   bool fake_update_success_ = false;
428 
429   // HTTP server response code from the last HTTP request action.
430   int http_response_code_ = 0;
431 
432   // CPU limiter during the update.
433   CPULimiter cpu_limiter_;
434 
435   // For status:
436   UpdateStatus status_{UpdateStatus::IDLE};
437   double download_progress_ = 0.0;
438   int64_t last_checked_time_ = 0;
439   std::string prev_version_;
440   std::string new_version_ = "0.0.0.0";
441   int64_t new_payload_size_ = 0;
442 
443   // Common parameters for all Omaha requests.
444   OmahaRequestParams* omaha_request_params_ = nullptr;
445 
446   // Number of consecutive manual update checks we've had where we obeyed
447   // Chrome's proxy settings.
448   int proxy_manual_checks_ = 0;
449 
450   // If true, this update cycle we are obeying proxies
451   bool obeying_proxies_ = true;
452 
453   // Our two proxy resolvers
454   DirectProxyResolver direct_proxy_resolver_;
455 #if USE_LIBCROS
456   ChromeBrowserProxyResolver chrome_proxy_resolver_;
457 #endif  // USE_LIBCROS
458 
459   // Originally, both of these flags are false. Once UpdateBootFlags is called,
460   // |update_boot_flags_running_| is set to true. As soon as UpdateBootFlags
461   // completes its asynchronous run, |update_boot_flags_running_| is reset to
462   // false and |updated_boot_flags_| is set to true. From that point on there
463   // will be no more changes to these flags.
464   //
465   // True if UpdateBootFlags has completed.
466   bool updated_boot_flags_ = false;
467   // True if UpdateBootFlags is running.
468   bool update_boot_flags_running_ = false;
469 
470   // True if the action processor needs to be started by the boot flag updater.
471   bool start_action_processor_ = false;
472 
473   // Used for fetching information about the device policy.
474   std::unique_ptr<policy::PolicyProvider> policy_provider_;
475 
476   // The current scatter factor as found in the policy setting.
477   base::TimeDelta scatter_factor_;
478 
479   // The number of consecutive failed update checks. Needed for calculating the
480   // next update check interval.
481   unsigned int consecutive_failed_update_checks_ = 0;
482 
483   // The poll interval (in seconds) that was dictated by Omaha, if any; zero
484   // otherwise. This is needed for calculating the update check interval.
485   unsigned int server_dictated_poll_interval_ = 0;
486 
487   // Tracks whether we have scheduled update checks.
488   bool waiting_for_scheduled_check_ = false;
489 
490   // A callback to use when a forced update request is either received (true) or
491   // cleared by an update attempt (false). The second argument indicates whether
492   // this is an interactive update, and its value is significant iff the first
493   // argument is true.
494   std::unique_ptr<base::Callback<void(bool, bool)>>
495       forced_update_pending_callback_;
496 
497   // The |app_version| and |omaha_url| parameters received during the latest
498   // forced update request. They are retrieved for use once the update is
499   // actually scheduled.
500   std::string forced_app_version_;
501   std::string forced_omaha_url_;
502 
503   DISALLOW_COPY_AND_ASSIGN(UpdateAttempter);
504 };
505 
506 }  // namespace chromeos_update_engine
507 
508 #endif  // UPDATE_ENGINE_UPDATE_ATTEMPTER_H_
509