Home | History | Annotate | Download | only in update_engine 
      1 //
      2 // Copyright (C) 2016 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_ANDROID_H_
     18 #define UPDATE_ENGINE_UPDATE_ATTEMPTER_ANDROID_H_
     19 
     20 #include <stdint.h>
     21 
     22 #include <memory>
     23 #include <string>
     24 #include <vector>
     25 
     26 #include <base/time/time.h>
     27 
     28 #include "update_engine/client_library/include/update_engine/update_status.h"
     29 #include "update_engine/common/action_processor.h"
     30 #include "update_engine/common/boot_control_interface.h"
     31 #include "update_engine/common/hardware_interface.h"
     32 #include "update_engine/common/prefs_interface.h"
     33 #include "update_engine/daemon_state_interface.h"
     34 #include "update_engine/network_selector_interface.h"
     35 #include "update_engine/payload_consumer/download_action.h"
     36 #include "update_engine/payload_consumer/postinstall_runner_action.h"
     37 #include "update_engine/service_delegate_android_interface.h"
     38 #include "update_engine/service_observer_interface.h"
     39 
     40 namespace chromeos_update_engine {
     41 
     42 class UpdateAttempterAndroid
     43     : public ServiceDelegateAndroidInterface,
     44       public ActionProcessorDelegate,
     45       public DownloadActionDelegate,
     46       public PostinstallRunnerAction::DelegateInterface {
     47  public:
     48   using UpdateStatus = update_engine::UpdateStatus;
     49 
     50   UpdateAttempterAndroid(DaemonStateInterface* daemon_state,
     51                          PrefsInterface* prefs,
     52                          BootControlInterface* boot_control_,
     53                          HardwareInterface* hardware_);
     54   ~UpdateAttempterAndroid() override;
     55 
     56   // Further initialization to be done post construction.
     57   void Init();
     58 
     59   // ServiceDelegateAndroidInterface overrides.
     60   bool ApplyPayload(const std::string& payload_url,
     61                     int64_t payload_offset,
     62                     int64_t payload_size,
     63                     const std::vector<std::string>& key_value_pair_headers,
     64                     brillo::ErrorPtr* error) override;
     65   bool SuspendUpdate(brillo::ErrorPtr* error) override;
     66   bool ResumeUpdate(brillo::ErrorPtr* error) override;
     67   bool CancelUpdate(brillo::ErrorPtr* error) override;
     68   bool ResetStatus(brillo::ErrorPtr* error) override;
     69 
     70   // ActionProcessorDelegate methods:
     71   void ProcessingDone(const ActionProcessor* processor,
     72                       ErrorCode code) override;
     73   void ProcessingStopped(const ActionProcessor* processor) override;
     74   void ActionCompleted(ActionProcessor* processor,
     75                        AbstractAction* action,
     76                        ErrorCode code) override;
     77 
     78   // DownloadActionDelegate overrides.
     79   void BytesReceived(uint64_t bytes_progressed,
     80                      uint64_t bytes_received,
     81                      uint64_t total) override;
     82   bool ShouldCancel(ErrorCode* cancel_reason) override;
     83   void DownloadComplete() override;
     84 
     85   // PostinstallRunnerAction::DelegateInterface
     86   void ProgressUpdate(double progress) override;
     87 
     88  private:
     89   // Asynchronously marks the current slot as successful if needed. If already
     90   // marked as good, CompleteUpdateBootFlags() is called starting the action
     91   // processor.
     92   void UpdateBootFlags();
     93 
     94   // Called when the boot flags have been updated.
     95   void CompleteUpdateBootFlags(bool success);
     96 
     97   // Schedules an event loop callback to start the action processor. This is
     98   // scheduled asynchronously to unblock the event loop.
     99   void ScheduleProcessingStart();
    100 
    101   // Notifies an update request completed with the given error |code| to all
    102   // observers.
    103   void TerminateUpdateAndNotify(ErrorCode error_code);
    104 
    105   // Sets the status to the given |status| and notifies a status update to
    106   // all observers.
    107   void SetStatusAndNotify(UpdateStatus status);
    108 
    109   // Helper method to construct the sequence of actions to be performed for
    110   // applying an update from the given |url|.
    111   void BuildUpdateActions(const std::string& url);
    112 
    113   // Writes to the processing completed marker. Does nothing if
    114   // |update_completed_marker_| is empty.
    115   bool WriteUpdateCompletedMarker();
    116 
    117   // Returns whether an update was completed in the current boot.
    118   bool UpdateCompletedOnThisBoot();
    119 
    120   DaemonStateInterface* daemon_state_;
    121 
    122   // DaemonStateAndroid pointers.
    123   PrefsInterface* prefs_;
    124   BootControlInterface* boot_control_;
    125   HardwareInterface* hardware_;
    126 
    127   // Last status notification timestamp used for throttling. Use monotonic
    128   // TimeTicks to ensure that notifications are sent even if the system clock is
    129   // set back in the middle of an update.
    130   base::TimeTicks last_notify_time_;
    131 
    132   // The list of actions and action processor that runs them asynchronously.
    133   // Only used when |ongoing_update_| is true.
    134   std::vector<std::shared_ptr<AbstractAction>> actions_;
    135   std::unique_ptr<ActionProcessor> processor_;
    136 
    137   // Pointer to the DownloadAction in the actions_ vector.
    138   std::shared_ptr<DownloadAction> download_action_;
    139 
    140   // Whether there is an ongoing update. This implies that an update was started
    141   // but not finished yet. This value will be true even if the update was
    142   // suspended.
    143   bool ongoing_update_{false};
    144 
    145   // The InstallPlan used during the ongoing update.
    146   InstallPlan install_plan_;
    147 
    148   // For status:
    149   UpdateStatus status_{UpdateStatus::IDLE};
    150   double download_progress_{0.0};
    151 
    152   // The offset in the payload file where the CrAU part starts.
    153   int64_t base_offset_{0};
    154 
    155   // Only direct proxy supported.
    156   DirectProxyResolver proxy_resolver_;
    157 
    158   // Helper class to select the network to use during the update.
    159   std::unique_ptr<NetworkSelectorInterface> network_selector_;
    160 
    161   // Whether we have marked the current slot as good. This step is required
    162   // before applying an update to the other slot.
    163   bool updated_boot_flags_ = false;
    164 
    165   DISALLOW_COPY_AND_ASSIGN(UpdateAttempterAndroid);
    166 };
    167 
    168 }  // namespace chromeos_update_engine
    169 
    170 #endif  // UPDATE_ENGINE_UPDATE_ATTEMPTER_ANDROID_H_
    171