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