blob: 3d5ee113f2b7d99447313444b13bcd6b493bab4f [file] [log] [blame]
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07001// 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 Reyes45168102010-11-22 11:13:50 -08008#include <deque>
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -07009#include <tr1/memory>
10#include <utility>
11#include <vector>
12
13#include "update_engine/http_fetcher.h"
Darin Petkov9ce452b2010-11-17 14:33:28 -080014#include "update_engine/utils.h"
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -070015
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
22namespace chromeos_update_engine {
23
24template<typename BaseHttpFetcher>
25class MultiHttpFetcher : public HttpFetcher, public HttpFetcherDelegate {
26 public:
27 typedef std::vector<std::pair<off_t, off_t> > RangesVect;
Andrew de los Reyes45168102010-11-22 11:13:50 -080028 typedef std::vector<std::tr1::shared_ptr<BaseHttpFetcher> > FetchersVect;
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -070029
Andrew de los Reyes45168102010-11-22 11:13:50 -080030 MultiHttpFetcher(ProxyResolver* proxy_resolver)
31 : HttpFetcher(proxy_resolver),
32 sent_transfer_complete_(false),
Darin Petkov9ce452b2010-11-17 14:33:28 -080033 pending_next_fetcher_(false),
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -070034 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 Reyes45168102010-11-22 11:13:50 -080044 (*it) = std::tr1::shared_ptr<BaseHttpFetcher>(
45 new BaseHttpFetcher(proxy_resolver_));
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -070046 (*it)->set_delegate(this);
47 }
Andrew de los Reyes45168102010-11-22 11:13:50 -080048 LOG(INFO) << "done w/ list";
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -070049 }
Darin Petkov9b230572010-10-08 10:20:09 -070050
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -070051 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 Petkov9ce452b2010-11-17 14:33:28 -080066 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 Reyes3fd5d302010-10-07 20:07:18 -070077 current_index_ = ranges_.size();
78 sent_transfer_complete_ = true; // a fib
Darin Petkov9ce452b2010-11-17 14:33:28 -080079 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 Reyes3fd5d302010-10-07 20:07:18 -0700101 }
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 Petkovfc7a0ce2010-10-25 10:38:37 -0700113 // These functions are overloaded in LibcurlHttp fetcher for testing purposes.
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -0700114 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 Petkovfc7a0ce2010-10-25 10:38:37 -0700128 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 Reyes45168102010-11-22 11:13:50 -0800142
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 Reyes3fd5d302010-10-07 20:07:18 -0700149
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 Petkov9b230572010-10-08 10:20:09 -0700160
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -0700161 void StartTransfer() {
162 if (current_index_ >= ranges_.size()) {
163 return;
164 }
Darin Petkov9b230572010-10-08 10:20:09 -0700165 LOG(INFO) << "Starting a transfer @" << ranges_[current_index_].first << "("
166 << ranges_[current_index_].second << ")";
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -0700167 bytes_received_this_fetcher_ = 0;
168 fetchers_[current_index_]->SetOffset(ranges_[current_index_].first);
Andrew de los Reyes34e41a12010-10-26 20:07:58 -0700169 if (delegate_)
170 delegate_->SeekToOffset(ranges_[current_index_].first);
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -0700171 fetchers_[current_index_]->BeginTransfer(url_);
172 }
Darin Petkov9b230572010-10-08 10:20:09 -0700173
Darin Petkov9ce452b2010-11-17 14:33:28 -0800174 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 Reyes3fd5d302010-10-07 20:07:18 -0700178 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 Reyes34e41a12010-10-26 20:07:58 -0700185 if (delegate_) {
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -0700186 delegate_->ReceivedBytes(this, bytes, next_size);
Andrew de los Reyes34e41a12010-10-26 20:07:58 -0700187 }
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -0700188 bytes_received_this_fetcher_ += length;
189 if (ranges_[current_index_].second >= 0 &&
190 bytes_received_this_fetcher_ >= ranges_[current_index_].second) {
Darin Petkov9ce452b2010-11-17 14:33:28 -0800191 // 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 Reyes3fd5d302010-10-07 20:07:18 -0700197 }
198 }
199
200 void TransferComplete(HttpFetcher* fetcher, bool successful) {
Darin Petkov9ce452b2010-11-17 14:33:28 -0800201 TEST_AND_RETURN(!pending_next_fetcher_);
202 LOG(INFO) << "Received transfer complete.";
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -0700203 if (current_index_ >= ranges_.size()) {
204 SendTransferComplete(fetcher, true);
205 return;
206 }
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -0700207 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 Reyes3fd5d302010-10-07 20:07:18 -0700218 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 Reyes3fd5d302010-10-07 20:07:18 -0700223 }
Darin Petkov9ce452b2010-11-17 14:33:28 -0800224 LOG(INFO) << "Got spurious TransferComplete. Ignoring.";
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -0700225 }
Darin Petkov9b230572010-10-08 10:20:09 -0700226
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -0700227 // If true, do not send any more data or TransferComplete to the delegate.
Darin Petkovfc7a0ce2010-10-25 10:38:37 -0700228 bool sent_transfer_complete_;
Darin Petkov9b230572010-10-08 10:20:09 -0700229
Darin Petkov9ce452b2010-11-17 14:33:28 -0800230 // 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 Reyes3fd5d302010-10-07 20:07:18 -0700234 RangesVect ranges_;
Andrew de los Reyes45168102010-11-22 11:13:50 -0800235 FetchersVect fetchers_;
Darin Petkov9b230572010-10-08 10:20:09 -0700236
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -0700237 RangesVect::size_type current_index_; // index into ranges_, fetchers_
238 off_t bytes_received_this_fetcher_;
239
Andrew de los Reyes3fd5d302010-10-07 20:07:18 -0700240 DISALLOW_COPY_AND_ASSIGN(MultiHttpFetcher);
241};
242
243} // namespace chromeos_update_engine
244
245#endif // CHROMEOS_PLATFORM_UPDATE_ENGINE_MULTI_HTTP_FETCHER_H__