1 // 2 // Copyright (C) 2010 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_MULTI_RANGE_HTTP_FETCHER_H_ 18 #define UPDATE_ENGINE_COMMON_MULTI_RANGE_HTTP_FETCHER_H_ 19 20 #include <deque> 21 #include <memory> 22 #include <string> 23 #include <utility> 24 #include <vector> 25 26 #include "update_engine/common/http_fetcher.h" 27 28 // This class is a simple wrapper around an HttpFetcher. The client 29 // specifies a vector of byte ranges. MultiRangeHttpFetcher will fetch bytes 30 // from those offsets, using the same bash fetcher for all ranges. Thus, the 31 // fetcher must support beginning a transfer after one has stopped. Pass -1 32 // as a length to specify unlimited length. It really only would make sense 33 // for the last range specified to have unlimited length, tho it is legal for 34 // other entries to have unlimited length. 35 36 // There are three states a MultiRangeHttpFetcher object will be in: 37 // - Stopped (start state) 38 // - Downloading 39 // - Pending transfer ended 40 // Various functions below that might change state indicate possible 41 // state changes. 42 43 namespace chromeos_update_engine { 44 45 class MultiRangeHttpFetcher : public HttpFetcher, public HttpFetcherDelegate { 46 public: 47 // Takes ownership of the passed in fetcher. MultiRangeHttpFetcher(HttpFetcher * base_fetcher)48 explicit MultiRangeHttpFetcher(HttpFetcher* base_fetcher) 49 : HttpFetcher(base_fetcher->proxy_resolver()), 50 base_fetcher_(base_fetcher), 51 base_fetcher_active_(false), 52 pending_transfer_ended_(false), 53 terminating_(false), 54 current_index_(0), 55 bytes_received_this_range_(0) {} ~MultiRangeHttpFetcher()56 ~MultiRangeHttpFetcher() override {} 57 ClearRanges()58 void ClearRanges() { ranges_.clear(); } 59 AddRange(off_t offset,size_t size)60 void AddRange(off_t offset, size_t size) { 61 CHECK_GT(size, static_cast<size_t>(0)); 62 ranges_.push_back(Range(offset, size)); 63 } 64 AddRange(off_t offset)65 void AddRange(off_t offset) { 66 ranges_.push_back(Range(offset)); 67 } 68 69 // HttpFetcher overrides. SetOffset(off_t offset)70 void SetOffset(off_t offset) override {} // for now, doesn't support this 71 SetLength(size_t length)72 void SetLength(size_t length) override {} // unsupported UnsetLength()73 void UnsetLength() override {} 74 75 // Begins the transfer to the specified URL. 76 // State change: Stopped -> Downloading 77 // (corner case: Stopped -> Stopped for an empty request) 78 void BeginTransfer(const std::string& url) override; 79 80 // State change: Downloading -> Pending transfer ended 81 void TerminateTransfer() override; 82 SetHeader(const std::string & header_name,const std::string & header_value)83 void SetHeader(const std::string& header_name, 84 const std::string& header_value) override { 85 base_fetcher_->SetHeader(header_name, header_value); 86 } 87 Pause()88 void Pause() override { base_fetcher_->Pause(); } 89 Unpause()90 void Unpause() override { base_fetcher_->Unpause(); } 91 92 // These functions are overloaded in LibcurlHttp fetcher for testing purposes. set_idle_seconds(int seconds)93 void set_idle_seconds(int seconds) override { 94 base_fetcher_->set_idle_seconds(seconds); 95 } set_retry_seconds(int seconds)96 void set_retry_seconds(int seconds) override { 97 base_fetcher_->set_retry_seconds(seconds); 98 } 99 // TODO(deymo): Determine if this method should be virtual in HttpFetcher so 100 // this call is sent to the base_fetcher_. SetProxies(const std::deque<std::string> & proxies)101 virtual void SetProxies(const std::deque<std::string>& proxies) { 102 base_fetcher_->SetProxies(proxies); 103 } 104 GetBytesDownloaded()105 inline size_t GetBytesDownloaded() override { 106 return base_fetcher_->GetBytesDownloaded(); 107 } 108 set_low_speed_limit(int low_speed_bps,int low_speed_sec)109 void set_low_speed_limit(int low_speed_bps, int low_speed_sec) override { 110 base_fetcher_->set_low_speed_limit(low_speed_bps, low_speed_sec); 111 } 112 set_connect_timeout(int connect_timeout_seconds)113 void set_connect_timeout(int connect_timeout_seconds) override { 114 base_fetcher_->set_connect_timeout(connect_timeout_seconds); 115 } 116 set_max_retry_count(int max_retry_count)117 void set_max_retry_count(int max_retry_count) override { 118 base_fetcher_->set_max_retry_count(max_retry_count); 119 } 120 121 private: 122 // A range object defining the offset and length of a download chunk. Zero 123 // length indicates an unspecified end offset (note that it is impossible to 124 // request a zero-length range in HTTP). 125 class Range { 126 public: Range(off_t offset,size_t length)127 Range(off_t offset, size_t length) : offset_(offset), length_(length) {} Range(off_t offset)128 explicit Range(off_t offset) : offset_(offset), length_(0) {} 129 offset()130 inline off_t offset() const { return offset_; } length()131 inline size_t length() const { return length_; } 132 HasLength()133 inline bool HasLength() const { return (length_ > 0); } 134 135 std::string ToString() const; 136 137 private: 138 off_t offset_; 139 size_t length_; 140 }; 141 142 typedef std::vector<Range> RangesVect; 143 144 // State change: Stopped or Downloading -> Downloading 145 void StartTransfer(); 146 147 // HttpFetcherDelegate overrides. 148 // State change: Downloading -> Downloading or Pending transfer ended 149 void ReceivedBytes(HttpFetcher* fetcher, 150 const void* bytes, 151 size_t length) override; 152 153 // State change: Pending transfer ended -> Stopped 154 void TransferEnded(HttpFetcher* fetcher, bool successful); 155 // These two call TransferEnded(): 156 void TransferComplete(HttpFetcher* fetcher, bool successful) override; 157 void TransferTerminated(HttpFetcher* fetcher) override; 158 159 void Reset(); 160 161 std::unique_ptr<HttpFetcher> base_fetcher_; 162 163 // If true, do not send any more data or TransferComplete to the delegate. 164 bool base_fetcher_active_; 165 166 // If true, the next fetcher needs to be started when TransferTerminated is 167 // received from the current fetcher. 168 bool pending_transfer_ended_; 169 170 // True if we are waiting for base fetcher to terminate b/c we are 171 // ourselves terminating. 172 bool terminating_; 173 174 RangesVect ranges_; 175 176 RangesVect::size_type current_index_; // index into ranges_ 177 size_t bytes_received_this_range_; 178 179 DISALLOW_COPY_AND_ASSIGN(MultiRangeHttpFetcher); 180 }; 181 182 } // namespace chromeos_update_engine 183 184 #endif // UPDATE_ENGINE_COMMON_MULTI_RANGE_HTTP_FETCHER_H_ 185