1 // 2 // Copyright (C) 2011 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_COMMON_DOWNLOAD_ACTION_H_ 18 #define UPDATE_ENGINE_COMMON_DOWNLOAD_ACTION_H_ 19 20 #include <fcntl.h> 21 #include <sys/stat.h> 22 #include <sys/types.h> 23 24 #include <memory> 25 #include <string> 26 #include <utility> 27 28 #include "update_engine/common/action.h" 29 #include "update_engine/common/boot_control_interface.h" 30 #include "update_engine/common/http_fetcher.h" 31 #include "update_engine/common/multi_range_http_fetcher.h" 32 #include "update_engine/payload_consumer/delta_performer.h" 33 #include "update_engine/payload_consumer/install_plan.h" 34 35 // The Download Action downloads a specified url to disk. The url should point 36 // to an update in a delta payload format. The payload will be piped into a 37 // DeltaPerformer that will apply the delta to the disk. 38 39 namespace chromeos_update_engine { 40 41 class DownloadActionDelegate { 42 public: 43 virtual ~DownloadActionDelegate() = default; 44 45 // Called periodically after bytes are received. This method will be invoked 46 // only if the DownloadAction is running. |bytes_progressed| is the number of 47 // bytes downloaded since the last call of this method, |bytes_received| 48 // the number of bytes downloaded thus far and |total| is the number of bytes 49 // expected. 50 virtual void BytesReceived(uint64_t bytes_progressed, 51 uint64_t bytes_received, 52 uint64_t total) = 0; 53 54 // Returns whether the download should be canceled, in which case the 55 // |cancel_reason| error should be set to the reason why the download was 56 // canceled. 57 virtual bool ShouldCancel(ErrorCode* cancel_reason) = 0; 58 59 // Called once the complete payload has been downloaded. Note that any errors 60 // while applying or downloading the partial payload will result in this 61 // method not being called. 62 virtual void DownloadComplete() = 0; 63 }; 64 65 class PrefsInterface; 66 67 class DownloadAction : public InstallPlanAction, public HttpFetcherDelegate { 68 public: 69 // Debugging/logging StaticType()70 static std::string StaticType() { return "DownloadAction"; } 71 72 // Takes ownership of the passed in HttpFetcher. Useful for testing. 73 // A good calling pattern is: 74 // DownloadAction(prefs, boot_contol, hardware, 75 // new WhateverHttpFetcher, false); 76 DownloadAction(PrefsInterface* prefs, 77 BootControlInterface* boot_control, 78 HardwareInterface* hardware, 79 HttpFetcher* http_fetcher, 80 bool interactive); 81 ~DownloadAction() override; 82 83 // InstallPlanAction overrides. 84 void PerformAction() override; 85 void SuspendAction() override; 86 void ResumeAction() override; 87 void TerminateProcessing() override; Type()88 std::string Type() const override { return StaticType(); } 89 90 // Testing SetTestFileWriter(std::unique_ptr<DeltaPerformer> writer)91 void SetTestFileWriter(std::unique_ptr<DeltaPerformer> writer) { 92 delta_performer_ = std::move(writer); 93 } 94 GetHTTPResponseCode()95 int GetHTTPResponseCode() { return http_fetcher_->http_response_code(); } 96 97 // HttpFetcherDelegate methods (see http_fetcher.h) 98 bool ReceivedBytes(HttpFetcher* fetcher, 99 const void* bytes, 100 size_t length) override; 101 void SeekToOffset(off_t offset) override; 102 void TransferComplete(HttpFetcher* fetcher, bool successful) override; 103 void TransferTerminated(HttpFetcher* fetcher) override; 104 delegate()105 DownloadActionDelegate* delegate() const { return delegate_; } set_delegate(DownloadActionDelegate * delegate)106 void set_delegate(DownloadActionDelegate* delegate) { delegate_ = delegate; } 107 set_base_offset(int64_t base_offset)108 void set_base_offset(int64_t base_offset) { base_offset_ = base_offset; } 109 http_fetcher()110 HttpFetcher* http_fetcher() { return http_fetcher_.get(); } 111 112 private: 113 // Attempt to load cached manifest data from prefs 114 // return true on success, false otherwise. 115 bool LoadCachedManifest(int64_t manifest_size); 116 117 // Start downloading the current payload using delta_performer. 118 void StartDownloading(); 119 120 // Pointer to the current payload in install_plan_.payloads. 121 InstallPlan::Payload* payload_{nullptr}; 122 123 // Required pointers. 124 PrefsInterface* prefs_; 125 BootControlInterface* boot_control_; 126 HardwareInterface* hardware_; 127 128 // Pointer to the MultiRangeHttpFetcher that does the http work. 129 std::unique_ptr<MultiRangeHttpFetcher> http_fetcher_; 130 131 // If |true|, the update is user initiated (vs. periodic update checks). Hence 132 // the |delta_performer_| can decide not to use O_DSYNC flag for faster 133 // update. 134 bool interactive_; 135 136 std::unique_ptr<DeltaPerformer> delta_performer_; 137 138 // Used by TransferTerminated to figure if this action terminated itself or 139 // was terminated by the action processor. 140 ErrorCode code_; 141 142 // For reporting status to outsiders 143 DownloadActionDelegate* delegate_; 144 uint64_t bytes_received_{0}; // per file/range 145 uint64_t bytes_received_previous_payloads_{0}; 146 uint64_t bytes_total_{0}; 147 bool download_active_{false}; 148 149 // Loaded from prefs before downloading any payload. 150 size_t resume_payload_index_{0}; 151 152 // Offset of the payload in the download URL, used by UpdateAttempterAndroid. 153 int64_t base_offset_{0}; 154 155 DISALLOW_COPY_AND_ASSIGN(DownloadAction); 156 }; 157 158 // We want to be sure that we're compiled with large file support on linux, 159 // just in case we find ourselves downloading large images. 160 static_assert(8 == sizeof(off_t), "off_t not 64 bit"); 161 162 } // namespace chromeos_update_engine 163 164 #endif // UPDATE_ENGINE_COMMON_DOWNLOAD_ACTION_H_ 165