1 /* <!-- copyright */
2 /*
3 * aria2 - The high speed download utility
4 *
5 * Copyright (C) 2006 Tatsuhiro Tsujikawa
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 *
21 * In addition, as a special exception, the copyright holders give
22 * permission to link the code of portions of this program with the
23 * OpenSSL library under certain conditions as described in each
24 * individual source file, and distribute linked combinations
25 * including the two.
26 * You must obey the GNU General Public License in all respects
27 * for all of the code used other than OpenSSL. If you modify
28 * file(s) with this exception, you may extend this exception to your
29 * version of the file(s), but you are not obligated to do so. If you
30 * do not wish to do so, delete this exception statement from your
31 * version. If you delete this exception statement from all source
32 * files in the program, then also delete it here.
33 */
34 /* copyright --> */
35 #include "DefaultPeerStorage.h"
36
37 #include <algorithm>
38
39 #include "LogFactory.h"
40 #include "Logger.h"
41 #include "message.h"
42 #include "Peer.h"
43 #include "BtRuntime.h"
44 #include "BtSeederStateChoke.h"
45 #include "BtLeecherStateChoke.h"
46 #include "PieceStorage.h"
47 #include "wallclock.h"
48 #include "a2functional.h"
49 #include "fmt.h"
50 #include "SimpleRandomizer.h"
51
52 namespace aria2 {
53
54 namespace {
55
56 const size_t MAX_PEER_LIST_SIZE = 512;
57
58 } // namespace
59
DefaultPeerStorage()60 DefaultPeerStorage::DefaultPeerStorage()
61 : maxPeerListSize_(MAX_PEER_LIST_SIZE),
62 seederStateChoke_(make_unique<BtSeederStateChoke>()),
63 leecherStateChoke_(make_unique<BtLeecherStateChoke>()),
64 lastTransferStatMapUpdated_(Timer::zero())
65 {
66 }
67
~DefaultPeerStorage()68 DefaultPeerStorage::~DefaultPeerStorage()
69 {
70 assert(uniqPeers_.size() == unusedPeers_.size() + usedPeers_.size());
71 }
72
countAllPeer() const73 size_t DefaultPeerStorage::countAllPeer() const
74 {
75 return unusedPeers_.size() + usedPeers_.size();
76 }
77
isPeerAlreadyAdded(const std::shared_ptr<Peer> & peer)78 bool DefaultPeerStorage::isPeerAlreadyAdded(const std::shared_ptr<Peer>& peer)
79 {
80 return uniqPeers_.count(
81 std::make_pair(peer->getIPAddress(), peer->getOrigPort()));
82 }
83
addUniqPeer(const std::shared_ptr<Peer> & peer)84 void DefaultPeerStorage::addUniqPeer(const std::shared_ptr<Peer>& peer)
85 {
86 uniqPeers_.insert(std::make_pair(peer->getIPAddress(), peer->getOrigPort()));
87 }
88
addPeer(const std::shared_ptr<Peer> & peer)89 bool DefaultPeerStorage::addPeer(const std::shared_ptr<Peer>& peer)
90 {
91 if (unusedPeers_.size() >= maxPeerListSize_) {
92 A2_LOG_DEBUG(fmt("Adding %s:%u is rejected, since unused peer list is full "
93 "(%lu peers > %lu)",
94 peer->getIPAddress().c_str(), peer->getPort(),
95 static_cast<unsigned long>(unusedPeers_.size()),
96 static_cast<unsigned long>(maxPeerListSize_)));
97 return false;
98 }
99 if (isPeerAlreadyAdded(peer)) {
100 A2_LOG_DEBUG(fmt("Adding %s:%u is rejected because it has been already"
101 " added.",
102 peer->getIPAddress().c_str(), peer->getPort()));
103 return false;
104 }
105 if (isBadPeer(peer->getIPAddress())) {
106 A2_LOG_DEBUG(fmt("Adding %s:%u is rejected because it is marked bad.",
107 peer->getIPAddress().c_str(), peer->getPort()));
108 return false;
109 }
110 const size_t peerListSize = unusedPeers_.size();
111 if (peerListSize >= maxPeerListSize_) {
112 deleteUnusedPeer(peerListSize - maxPeerListSize_ + 1);
113 }
114 unusedPeers_.push_back(peer);
115 addUniqPeer(peer);
116 A2_LOG_DEBUG(fmt("Now unused peer list contains %lu peers",
117 static_cast<unsigned long>(unusedPeers_.size())));
118 return true;
119 }
120
addPeer(const std::vector<std::shared_ptr<Peer>> & peers)121 void DefaultPeerStorage::addPeer(
122 const std::vector<std::shared_ptr<Peer>>& peers)
123 {
124 if (unusedPeers_.size() < maxPeerListSize_) {
125 for (auto& peer : peers) {
126 if (isPeerAlreadyAdded(peer)) {
127 A2_LOG_DEBUG(fmt("Adding %s:%u is rejected because it has been already"
128 " added.",
129 peer->getIPAddress().c_str(), peer->getPort()));
130 continue;
131 }
132 else if (isBadPeer(peer->getIPAddress())) {
133 A2_LOG_DEBUG(fmt("Adding %s:%u is rejected because it is marked bad.",
134 peer->getIPAddress().c_str(), peer->getPort()));
135 continue;
136 }
137 else {
138 A2_LOG_DEBUG(fmt(MSG_ADDING_PEER, peer->getIPAddress().c_str(),
139 peer->getPort()));
140 }
141 unusedPeers_.push_back(peer);
142 addUniqPeer(peer);
143 }
144 }
145 else {
146 for (auto& peer : peers) {
147 A2_LOG_DEBUG(
148 fmt("Adding %s:%u is rejected, since unused peer list is full "
149 "(%lu peers > %lu)",
150 peer->getIPAddress().c_str(), peer->getPort(),
151 static_cast<unsigned long>(unusedPeers_.size()),
152 static_cast<unsigned long>(maxPeerListSize_)));
153 }
154 }
155 const size_t peerListSize = unusedPeers_.size();
156 if (peerListSize > maxPeerListSize_) {
157 deleteUnusedPeer(peerListSize - maxPeerListSize_);
158 }
159 A2_LOG_DEBUG(fmt("Now unused peer list contains %lu peers",
160 static_cast<unsigned long>(unusedPeers_.size())));
161 }
162
163 std::shared_ptr<Peer>
addAndCheckoutPeer(const std::shared_ptr<Peer> & peer,cuid_t cuid)164 DefaultPeerStorage::addAndCheckoutPeer(const std::shared_ptr<Peer>& peer,
165 cuid_t cuid)
166 {
167 if (isPeerAlreadyAdded(peer)) {
168 auto it = std::find_if(std::begin(unusedPeers_), std::end(unusedPeers_),
169 [&peer](const std::shared_ptr<Peer>& p) {
170 return p->getIPAddress() == peer->getIPAddress() &&
171 p->getOrigPort() == peer->getOrigPort();
172 });
173 if (it == std::end(unusedPeers_)) {
174 // peer is in usedPeers_.
175 return nullptr;
176 }
177
178 unusedPeers_.erase(it);
179 }
180 else {
181 addUniqPeer(peer);
182 }
183
184 unusedPeers_.push_front(peer);
185
186 return checkoutPeer(cuid);
187 }
188
addDroppedPeer(const std::shared_ptr<Peer> & peer)189 void DefaultPeerStorage::addDroppedPeer(const std::shared_ptr<Peer>& peer)
190 {
191 // Make sure that no duplicated peer exists in droppedPeers_. If
192 // exists, erase older one.
193 for (auto i = std::begin(droppedPeers_), eoi = std::end(droppedPeers_);
194 i != eoi; ++i) {
195 if ((*i)->getIPAddress() == peer->getIPAddress() &&
196 (*i)->getPort() == peer->getPort()) {
197 droppedPeers_.erase(i);
198 break;
199 }
200 }
201 droppedPeers_.push_front(peer);
202 if (droppedPeers_.size() > 50) {
203 droppedPeers_.pop_back();
204 }
205 }
206
getUnusedPeers()207 const std::deque<std::shared_ptr<Peer>>& DefaultPeerStorage::getUnusedPeers()
208 {
209 return unusedPeers_;
210 }
211
getUsedPeers()212 const PeerSet& DefaultPeerStorage::getUsedPeers() { return usedPeers_; }
213
getDroppedPeers()214 const std::deque<std::shared_ptr<Peer>>& DefaultPeerStorage::getDroppedPeers()
215 {
216 return droppedPeers_;
217 }
218
isPeerAvailable()219 bool DefaultPeerStorage::isPeerAvailable() { return !unusedPeers_.empty(); }
220
isBadPeer(const std::string & ipaddr)221 bool DefaultPeerStorage::isBadPeer(const std::string& ipaddr)
222 {
223 auto i = badPeers_.find(ipaddr);
224 if (i == std::end(badPeers_)) {
225 return false;
226 }
227
228 if ((*i).second <= global::wallclock()) {
229 badPeers_.erase(i);
230 return false;
231 }
232
233 return true;
234 }
235
addBadPeer(const std::string & ipaddr)236 void DefaultPeerStorage::addBadPeer(const std::string& ipaddr)
237 {
238 if (lastBadPeerCleaned_.difference(global::wallclock()) >= 1_h) {
239 for (auto i = std::begin(badPeers_); i != std::end(badPeers_);) {
240 if ((*i).second <= global::wallclock()) {
241 A2_LOG_DEBUG(fmt("Purge %s from bad peer", (*i).first.c_str()));
242 badPeers_.erase(i++);
243 // badPeers_.end() will not be invalidated.
244 }
245 else {
246 ++i;
247 }
248 }
249 lastBadPeerCleaned_ = global::wallclock();
250 }
251 A2_LOG_DEBUG(fmt("Added %s as bad peer", ipaddr.c_str()));
252 // We use variable timeout to avoid many bad peers wake up at once.
253 auto t = global::wallclock();
254 t.advance(std::chrono::seconds(
255 std::max(SimpleRandomizer::getInstance()->getRandomNumber(601), 120L)));
256
257 badPeers_[ipaddr] = std::move(t);
258 }
259
deleteUnusedPeer(size_t delSize)260 void DefaultPeerStorage::deleteUnusedPeer(size_t delSize)
261 {
262 for (; delSize > 0 && !unusedPeers_.empty(); --delSize) {
263 auto& peer = unusedPeers_.back();
264 onErasingPeer(peer);
265 A2_LOG_DEBUG(fmt("Remove peer %s:%u", peer->getIPAddress().c_str(),
266 peer->getOrigPort()));
267 unusedPeers_.pop_back();
268 }
269 }
270
checkoutPeer(cuid_t cuid)271 std::shared_ptr<Peer> DefaultPeerStorage::checkoutPeer(cuid_t cuid)
272 {
273 if (!isPeerAvailable()) {
274 return nullptr;
275 }
276 auto peer = unusedPeers_.front();
277 unusedPeers_.pop_front();
278 if (peer->usedBy() != 0) {
279 A2_LOG_WARN(fmt("CUID#%" PRId64 " is already set for peer %s:%u",
280 peer->usedBy(), peer->getIPAddress().c_str(),
281 peer->getOrigPort()));
282 }
283 peer->usedBy(cuid);
284 usedPeers_.insert(peer);
285 A2_LOG_DEBUG(fmt("Checkout peer %s:%u to CUID#%" PRId64,
286 peer->getIPAddress().c_str(), peer->getOrigPort(),
287 peer->usedBy()));
288 return peer;
289 }
290
onErasingPeer(const std::shared_ptr<Peer> & peer)291 void DefaultPeerStorage::onErasingPeer(const std::shared_ptr<Peer>& peer)
292 {
293 uniqPeers_.erase(std::make_pair(peer->getIPAddress(), peer->getOrigPort()));
294 }
295
onReturningPeer(const std::shared_ptr<Peer> & peer)296 void DefaultPeerStorage::onReturningPeer(const std::shared_ptr<Peer>& peer)
297 {
298 if (peer->isActive()) {
299 if (peer->isDisconnectedGracefully() && !peer->isIncomingPeer()) {
300 peer->startDrop();
301 addDroppedPeer(peer);
302 }
303 // Execute choking algorithm if unchoked and interested peer is
304 // disconnected.
305 if (!peer->amChoking() && peer->peerInterested()) {
306 executeChoke();
307 }
308 }
309 peer->usedBy(0);
310 }
311
returnPeer(const std::shared_ptr<Peer> & peer)312 void DefaultPeerStorage::returnPeer(const std::shared_ptr<Peer>& peer)
313 {
314 A2_LOG_DEBUG(fmt("Peer %s:%u returned from CUID#%" PRId64,
315 peer->getIPAddress().c_str(), peer->getOrigPort(),
316 peer->usedBy()));
317 if (usedPeers_.erase(peer)) {
318 onReturningPeer(peer);
319 onErasingPeer(peer);
320 }
321 else {
322 A2_LOG_WARN(fmt("Cannot find peer %s:%u in usedPeers_",
323 peer->getIPAddress().c_str(), peer->getOrigPort()));
324 }
325 }
326
chokeRoundIntervalElapsed()327 bool DefaultPeerStorage::chokeRoundIntervalElapsed()
328 {
329 constexpr auto CHOKE_ROUND_INTERVAL = 10_s;
330
331 if (pieceStorage_->downloadFinished()) {
332 return seederStateChoke_->getLastRound().difference(global::wallclock()) >=
333 CHOKE_ROUND_INTERVAL;
334 }
335
336 return leecherStateChoke_->getLastRound().difference(global::wallclock()) >=
337 CHOKE_ROUND_INTERVAL;
338 }
339
executeChoke()340 void DefaultPeerStorage::executeChoke()
341 {
342 if (pieceStorage_->downloadFinished()) {
343 return seederStateChoke_->executeChoke(usedPeers_);
344 }
345 else {
346 return leecherStateChoke_->executeChoke(usedPeers_);
347 }
348 }
349
setPieceStorage(const std::shared_ptr<PieceStorage> & ps)350 void DefaultPeerStorage::setPieceStorage(
351 const std::shared_ptr<PieceStorage>& ps)
352 {
353 pieceStorage_ = ps;
354 }
355
setBtRuntime(const std::shared_ptr<BtRuntime> & btRuntime)356 void DefaultPeerStorage::setBtRuntime(
357 const std::shared_ptr<BtRuntime>& btRuntime)
358 {
359 btRuntime_ = btRuntime;
360 }
361
362 } // namespace aria2
363