Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 1 | // Copyright (c) 2010 The Chromium OS Authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
| 5 | #ifndef CHROMEOS_PLATFORM_UPDATE_ENGINE_MULTI_HTTP_FETCHER_H__ |
| 6 | #define CHROMEOS_PLATFORM_UPDATE_ENGINE_MULTI_HTTP_FETCHER_H__ |
| 7 | |
Andrew de los Reyes | 4516810 | 2010-11-22 11:13:50 -0800 | [diff] [blame] | 8 | #include <deque> |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 9 | #include <tr1/memory> |
| 10 | #include <utility> |
| 11 | #include <vector> |
| 12 | |
| 13 | #include "update_engine/http_fetcher.h" |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 14 | #include "update_engine/utils.h" |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 15 | |
| 16 | // This class is a simple wrapper around an HttpFetcher. The client |
| 17 | // specifies a vector of byte ranges. MultiHttpFetcher will fetch bytes |
| 18 | // from those offsets. Pass -1 as a length to specify unlimited length. |
| 19 | // It really only would make sense for the last range specified to have |
| 20 | // unlimited length. |
| 21 | |
| 22 | namespace chromeos_update_engine { |
| 23 | |
| 24 | template<typename BaseHttpFetcher> |
| 25 | class MultiHttpFetcher : public HttpFetcher, public HttpFetcherDelegate { |
| 26 | public: |
| 27 | typedef std::vector<std::pair<off_t, off_t> > RangesVect; |
Andrew de los Reyes | 4516810 | 2010-11-22 11:13:50 -0800 | [diff] [blame] | 28 | typedef std::vector<std::tr1::shared_ptr<BaseHttpFetcher> > FetchersVect; |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 29 | |
Andrew de los Reyes | 4516810 | 2010-11-22 11:13:50 -0800 | [diff] [blame] | 30 | MultiHttpFetcher(ProxyResolver* proxy_resolver) |
| 31 | : HttpFetcher(proxy_resolver), |
| 32 | sent_transfer_complete_(false), |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 33 | pending_next_fetcher_(false), |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 34 | current_index_(0), |
| 35 | bytes_received_this_fetcher_(0) {} |
| 36 | ~MultiHttpFetcher() {} |
| 37 | |
| 38 | void set_ranges(const RangesVect& ranges) { |
| 39 | ranges_ = ranges; |
| 40 | fetchers_.resize(ranges_.size()); // Allocate the fetchers |
| 41 | for (typename std::vector<std::tr1::shared_ptr<BaseHttpFetcher> |
| 42 | >::iterator it = fetchers_.begin(), e = fetchers_.end(); |
| 43 | it != e; ++it) { |
Andrew de los Reyes | 4516810 | 2010-11-22 11:13:50 -0800 | [diff] [blame] | 44 | (*it) = std::tr1::shared_ptr<BaseHttpFetcher>( |
| 45 | new BaseHttpFetcher(proxy_resolver_)); |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 46 | (*it)->set_delegate(this); |
| 47 | } |
Andrew de los Reyes | 4516810 | 2010-11-22 11:13:50 -0800 | [diff] [blame] | 48 | LOG(INFO) << "done w/ list"; |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 49 | } |
Darin Petkov | 9b23057 | 2010-10-08 10:20:09 -0700 | [diff] [blame] | 50 | |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 51 | void SetOffset(off_t offset) {} // for now, doesn't support this |
| 52 | |
| 53 | // Begins the transfer to the specified URL. |
| 54 | void BeginTransfer(const std::string& url) { |
| 55 | url_ = url; |
| 56 | if (ranges_.empty()) { |
| 57 | if (delegate_) |
| 58 | delegate_->TransferComplete(this, true); |
| 59 | return; |
| 60 | } |
| 61 | current_index_ = 0; |
| 62 | LOG(INFO) << "starting first transfer"; |
| 63 | StartTransfer(); |
| 64 | } |
| 65 | |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 66 | void TransferTerminated(HttpFetcher* fetcher) { |
| 67 | LOG(INFO) << "Received transfer terminated."; |
| 68 | if (pending_next_fetcher_) { |
| 69 | pending_next_fetcher_ = false; |
| 70 | if (++current_index_ >= ranges_.size()) { |
| 71 | SendTransferComplete(fetcher, true); |
| 72 | } else { |
| 73 | StartTransfer(); |
| 74 | } |
| 75 | return; |
| 76 | } |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 77 | current_index_ = ranges_.size(); |
| 78 | sent_transfer_complete_ = true; // a fib |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 79 | if (delegate_) { |
| 80 | // Note that after the callback returns this object may be destroyed. |
| 81 | delegate_->TransferTerminated(this); |
| 82 | } |
| 83 | } |
| 84 | |
| 85 | void TerminateTransfer() { |
| 86 | // If the current fetcher is already being terminated, just wait for its |
| 87 | // TransferTerminated callback. |
| 88 | if (pending_next_fetcher_) { |
| 89 | pending_next_fetcher_ = false; |
| 90 | return; |
| 91 | } |
| 92 | // If there's a current active fetcher terminate it and wait for its |
| 93 | // TransferTerminated callback. |
| 94 | if (current_index_ < fetchers_.size()) { |
| 95 | fetchers_[current_index_]->TerminateTransfer(); |
| 96 | return; |
| 97 | } |
| 98 | // Transfer is terminated before it got started and before any ranges were |
| 99 | // added. |
| 100 | TransferTerminated(this); |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 101 | } |
| 102 | |
| 103 | void Pause() { |
| 104 | if (current_index_ < fetchers_.size()) |
| 105 | fetchers_[current_index_]->Pause(); |
| 106 | } |
| 107 | |
| 108 | void Unpause() { |
| 109 | if (current_index_ < fetchers_.size()) |
| 110 | fetchers_[current_index_]->Unpause(); |
| 111 | } |
| 112 | |
Darin Petkov | fc7a0ce | 2010-10-25 10:38:37 -0700 | [diff] [blame] | 113 | // These functions are overloaded in LibcurlHttp fetcher for testing purposes. |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 114 | void set_idle_seconds(int seconds) { |
| 115 | for (typename std::vector<std::tr1::shared_ptr<BaseHttpFetcher> >::iterator |
| 116 | it = fetchers_.begin(), |
| 117 | e = fetchers_.end(); it != e; ++it) { |
| 118 | (*it)->set_idle_seconds(seconds); |
| 119 | } |
| 120 | } |
| 121 | void set_retry_seconds(int seconds) { |
| 122 | for (typename std::vector<std::tr1::shared_ptr<BaseHttpFetcher> >::iterator |
| 123 | it = fetchers_.begin(), |
| 124 | e = fetchers_.end(); it != e; ++it) { |
| 125 | (*it)->set_retry_seconds(seconds); |
| 126 | } |
| 127 | } |
Darin Petkov | fc7a0ce | 2010-10-25 10:38:37 -0700 | [diff] [blame] | 128 | void SetConnectionAsExpensive(bool is_expensive) { |
| 129 | for (typename std::vector<std::tr1::shared_ptr<BaseHttpFetcher> >::iterator |
| 130 | it = fetchers_.begin(), |
| 131 | e = fetchers_.end(); it != e; ++it) { |
| 132 | (*it)->SetConnectionAsExpensive(is_expensive); |
| 133 | } |
| 134 | } |
| 135 | void SetBuildType(bool is_official) { |
| 136 | for (typename std::vector<std::tr1::shared_ptr<BaseHttpFetcher> >::iterator |
| 137 | it = fetchers_.begin(), |
| 138 | e = fetchers_.end(); it != e; ++it) { |
| 139 | (*it)->SetBuildType(is_official); |
| 140 | } |
| 141 | } |
Andrew de los Reyes | 4516810 | 2010-11-22 11:13:50 -0800 | [diff] [blame] | 142 | |
| 143 | virtual void SetProxies(const std::deque<std::string>& proxies) { |
| 144 | for (typename FetchersVect::iterator it = fetchers_.begin(), |
| 145 | e = fetchers_.end(); it != e; ++it) { |
| 146 | (*it)->SetProxies(proxies); |
| 147 | } |
| 148 | } |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 149 | |
| 150 | private: |
| 151 | void SendTransferComplete(HttpFetcher* fetcher, bool successful) { |
| 152 | if (sent_transfer_complete_) |
| 153 | return; |
| 154 | LOG(INFO) << "Sending transfer complete"; |
| 155 | sent_transfer_complete_ = true; |
| 156 | http_response_code_ = fetcher->http_response_code(); |
| 157 | if (delegate_) |
| 158 | delegate_->TransferComplete(this, successful); |
| 159 | } |
Darin Petkov | 9b23057 | 2010-10-08 10:20:09 -0700 | [diff] [blame] | 160 | |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 161 | void StartTransfer() { |
| 162 | if (current_index_ >= ranges_.size()) { |
| 163 | return; |
| 164 | } |
Darin Petkov | 9b23057 | 2010-10-08 10:20:09 -0700 | [diff] [blame] | 165 | LOG(INFO) << "Starting a transfer @" << ranges_[current_index_].first << "(" |
| 166 | << ranges_[current_index_].second << ")"; |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 167 | bytes_received_this_fetcher_ = 0; |
| 168 | fetchers_[current_index_]->SetOffset(ranges_[current_index_].first); |
Andrew de los Reyes | 34e41a1 | 2010-10-26 20:07:58 -0700 | [diff] [blame] | 169 | if (delegate_) |
| 170 | delegate_->SeekToOffset(ranges_[current_index_].first); |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 171 | fetchers_[current_index_]->BeginTransfer(url_); |
| 172 | } |
Darin Petkov | 9b23057 | 2010-10-08 10:20:09 -0700 | [diff] [blame] | 173 | |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 174 | void ReceivedBytes(HttpFetcher* fetcher, const char* bytes, int length) { |
| 175 | TEST_AND_RETURN(current_index_ < ranges_.size()); |
| 176 | TEST_AND_RETURN(fetcher == fetchers_[current_index_].get()); |
| 177 | TEST_AND_RETURN(!pending_next_fetcher_); |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 178 | off_t next_size = length; |
| 179 | if (ranges_[current_index_].second >= 0) { |
| 180 | next_size = std::min(next_size, |
| 181 | ranges_[current_index_].second - |
| 182 | bytes_received_this_fetcher_); |
| 183 | } |
| 184 | LOG_IF(WARNING, next_size <= 0) << "Asked to write length <= 0"; |
Andrew de los Reyes | 34e41a1 | 2010-10-26 20:07:58 -0700 | [diff] [blame] | 185 | if (delegate_) { |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 186 | delegate_->ReceivedBytes(this, bytes, next_size); |
Andrew de los Reyes | 34e41a1 | 2010-10-26 20:07:58 -0700 | [diff] [blame] | 187 | } |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 188 | bytes_received_this_fetcher_ += length; |
| 189 | if (ranges_[current_index_].second >= 0 && |
| 190 | bytes_received_this_fetcher_ >= ranges_[current_index_].second) { |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 191 | // Terminates the current fetcher. Waits for its TransferTerminated |
| 192 | // callback before starting the next fetcher so that we don't end up |
| 193 | // signalling the delegate that the whole multi-transfer is complete |
| 194 | // before all fetchers are really done and cleaned up. |
| 195 | pending_next_fetcher_ = true; |
| 196 | fetcher->TerminateTransfer(); |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 197 | } |
| 198 | } |
| 199 | |
| 200 | void TransferComplete(HttpFetcher* fetcher, bool successful) { |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 201 | TEST_AND_RETURN(!pending_next_fetcher_); |
| 202 | LOG(INFO) << "Received transfer complete."; |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 203 | if (current_index_ >= ranges_.size()) { |
| 204 | SendTransferComplete(fetcher, true); |
| 205 | return; |
| 206 | } |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 207 | if (ranges_[current_index_].second < 0) { |
| 208 | // We're done with the current operation |
| 209 | current_index_++; |
| 210 | if (current_index_ >= ranges_.size() || !successful) { |
| 211 | SendTransferComplete(fetcher, successful); |
| 212 | } else { |
| 213 | // Do the next transfer |
| 214 | StartTransfer(); |
| 215 | } |
| 216 | return; |
| 217 | } |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 218 | if (bytes_received_this_fetcher_ < ranges_[current_index_].second) { |
| 219 | LOG(WARNING) << "Received insufficient bytes from fetcher. " |
| 220 | << "Ending early"; |
| 221 | SendTransferComplete(fetcher, false); |
| 222 | return; |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 223 | } |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 224 | LOG(INFO) << "Got spurious TransferComplete. Ignoring."; |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 225 | } |
Darin Petkov | 9b23057 | 2010-10-08 10:20:09 -0700 | [diff] [blame] | 226 | |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 227 | // If true, do not send any more data or TransferComplete to the delegate. |
Darin Petkov | fc7a0ce | 2010-10-25 10:38:37 -0700 | [diff] [blame] | 228 | bool sent_transfer_complete_; |
Darin Petkov | 9b23057 | 2010-10-08 10:20:09 -0700 | [diff] [blame] | 229 | |
Darin Petkov | 9ce452b | 2010-11-17 14:33:28 -0800 | [diff] [blame] | 230 | // If true, the next fetcher needs to be started when TransferTerminated is |
| 231 | // received from the current fetcher. |
| 232 | bool pending_next_fetcher_; |
| 233 | |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 234 | RangesVect ranges_; |
Andrew de los Reyes | 4516810 | 2010-11-22 11:13:50 -0800 | [diff] [blame] | 235 | FetchersVect fetchers_; |
Darin Petkov | 9b23057 | 2010-10-08 10:20:09 -0700 | [diff] [blame] | 236 | |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 237 | RangesVect::size_type current_index_; // index into ranges_, fetchers_ |
| 238 | off_t bytes_received_this_fetcher_; |
| 239 | |
Andrew de los Reyes | 3fd5d30 | 2010-10-07 20:07:18 -0700 | [diff] [blame] | 240 | DISALLOW_COPY_AND_ASSIGN(MultiHttpFetcher); |
| 241 | }; |
| 242 | |
| 243 | } // namespace chromeos_update_engine |
| 244 | |
| 245 | #endif // CHROMEOS_PLATFORM_UPDATE_ENGINE_MULTI_HTTP_FETCHER_H__ |