github
/
aria2
mirror of https://github.com/aria2/aria2
1
0
Fork 0
Code Issues Releases Wiki Activity

2010-06-09 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net> 

Made protected member variable private. Added accessor funcs.
	* src/ActivePeerConnectionCommand.cc
	* src/ActivePeerConnectionCommand.h
	* src/CheckIntegrityDispatcherCommand.cc
	* src/DHTEntryPointNameResolveCommand.h
	* src/DHTInteractionCommand.h
	* src/FileAllocationDispatcherCommand.cc
	* src/LpdReceiveMessageCommand.h
	* src/PeerChokeCommand.cc
	* src/PeerChokeCommand.h
	* src/PeerListenCommand.cc
	* src/PeerListenCommand.h
	* src/SeedCheckCommand.cc
	* src/SeedCheckCommand.h
	* src/SequentialDispatcherCommand.h
	* src/SleepCommand.cc
	* src/SleepCommand.h
	* src/TrackerWatcherCommand.cc
	* src/TrackerWatcherCommand.h
pull/1/head
Tatsuhiro Tsujikawa 2010-06-09 14:47:13 +00:00
parent d4dfb6c4a8
commit f114c89096
19 changed files with 102 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
ChangeLog
View File

@ -1,3 +1,25 @@
2010-06-09 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net>
Made protected member variable private. Added accessor funcs.
* src/ActivePeerConnectionCommand.cc
* src/ActivePeerConnectionCommand.h
* src/CheckIntegrityDispatcherCommand.cc
* src/DHTEntryPointNameResolveCommand.h
* src/DHTInteractionCommand.h
* src/FileAllocationDispatcherCommand.cc
* src/LpdReceiveMessageCommand.h
* src/PeerChokeCommand.cc
* src/PeerChokeCommand.h
* src/PeerListenCommand.cc
* src/PeerListenCommand.h
* src/SeedCheckCommand.cc
* src/SeedCheckCommand.h
* src/SequentialDispatcherCommand.h
* src/SleepCommand.cc
* src/SleepCommand.h
* src/TrackerWatcherCommand.cc
* src/TrackerWatcherCommand.h
2010-06-09 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net>
Made protected member variable private. Added accessor funcs.

16
src/ActivePeerConnectionCommand.cc
View File

@ -66,8 +66,8 @@ ActivePeerConnectionCommand::ActivePeerConnectionCommand
:
Command(cuid),
_requestGroup(requestGroup),
interval(interval),
e(e),
_interval(interval),
_e(e),
_numNewConnection(5)
{
_requestGroup->increaseNumCommand();
@ -82,8 +82,8 @@ bool ActivePeerConnectionCommand::execute() {
if(_btRuntime->isHalt()) {
return true;
}
if(checkPoint.difference(global::wallclock) >= interval) {
checkPoint = global::wallclock;
if(_checkPoint.difference(global::wallclock) >= _interval) {
_checkPoint = global::wallclock;
TransferStat tstat = _requestGroup->calculateStat();
const unsigned int maxDownloadLimit =
_requestGroup->getMaxDownloadSpeedLimit();
@ -129,7 +129,7 @@ bool ActivePeerConnectionCommand::execute() {
}
}
}
e->addCommand(this);
_e->addCommand(this);
return false;
}
@ -138,13 +138,13 @@ void ActivePeerConnectionCommand::connectToPeer(const SharedHandle<Peer>& peer)
if(peer.isNull()) {
return;
}
peer->usedBy(e->newCUID());
peer->usedBy(_e->newCUID());
PeerInitiateConnectionCommand* command =
new PeerInitiateConnectionCommand(peer->usedBy(), _requestGroup, peer, e,
new PeerInitiateConnectionCommand(peer->usedBy(), _requestGroup, peer, _e,
_btRuntime);
command->setPeerStorage(_peerStorage);
command->setPieceStorage(_pieceStorage);
e->addCommand(command);
_e->addCommand(command);
if(getLogger()->info()) {
getLogger()->info(MSG_CONNECTING_TO_PEER,
util::itos(getCuid()).c_str(), peer->ipaddr.c_str());

6
src/ActivePeerConnectionCommand.h
View File

@ -57,9 +57,9 @@ private:
SharedHandle<PeerStorage> _peerStorage;
SharedHandle<BtAnnounce> _btAnnounce;
time_t interval; // UNIT: sec
DownloadEngine* e;
Timer checkPoint;
time_t _interval; // UNIT: sec
DownloadEngine* _e;
Timer _checkPoint;
unsigned int _numNewConnection; // the number of the connection to establish.
public:
ActivePeerConnectionCommand(cuid_t cuid,

4
src/CheckIntegrityDispatcherCommand.cc
View File

@ -56,14 +56,14 @@ CheckIntegrityDispatcherCommand::CheckIntegrityDispatcherCommand
Command* CheckIntegrityDispatcherCommand::createCommand
(const SharedHandle<CheckIntegrityEntry>& entry)
{
cuid_t newCUID = _e->newCUID();
cuid_t newCUID = getDownloadEngine()->newCUID();
if(getLogger()->info()) {
getLogger()->info("CUID#%s - Dispatching CheckIntegrityCommand CUID#%s.",
util::itos(getCuid()).c_str(),
util::itos(newCUID).c_str());
}
return new CheckIntegrityCommand
(newCUID, entry->getRequestGroup(), _e, entry);
(newCUID, entry->getRequestGroup(), getDownloadEngine(), entry);
}
} // namespace aria2

4
src/DHTEntryPointNameResolveCommand.h
View File

@ -55,9 +55,9 @@ class AsyncNameResolver;
#endif // ENABLE_ASYNC_DNS
class DHTEntryPointNameResolveCommand:public Command {
protected:
DownloadEngine* _e;
private:
DownloadEngine* _e;
#ifdef ENABLE_ASYNC_DNS
SharedHandle<AsyncNameResolver> _resolver;
#endif // ENABLE_ASYNC_DNS

4
src/DHTInteractionCommand.h
View File

@ -47,14 +47,12 @@ class DownloadEngine;
class SocketCore;
class DHTInteractionCommand:public Command {
protected:
DownloadEngine* _e;
private:
DownloadEngine* _e;
SharedHandle<DHTMessageDispatcher> _dispatcher;
SharedHandle<DHTMessageReceiver> _receiver;
SharedHandle<DHTTaskQueue> _taskQueue;
SharedHandle<SocketCore> _readCheckSocket;
public:
DHTInteractionCommand(cuid_t cuid, DownloadEngine* e);

5
src/FileAllocationDispatcherCommand.cc
View File

@ -53,13 +53,14 @@ FileAllocationDispatcherCommand::FileAllocationDispatcherCommand
Command* FileAllocationDispatcherCommand::createCommand
(const SharedHandle<FileAllocationEntry>& entry)
{
cuid_t newCUID = _e->newCUID();
cuid_t newCUID = getDownloadEngine()->newCUID();
if(getLogger()->info()) {
getLogger()->info(MSG_FILE_ALLOCATION_DISPATCH,
util::itos(newCUID).c_str());
}
FileAllocationCommand* command =
new FileAllocationCommand(newCUID, entry->getRequestGroup(), _e, entry);
new FileAllocationCommand(newCUID, entry->getRequestGroup(),
getDownloadEngine(), entry);
return command;
}

3
src/LpdReceiveMessageCommand.h
View File

@ -55,9 +55,8 @@ private:
LpdReceiveMessageCommand
(cuid_t cuid, const SharedHandle<LpdMessageReceiver>& receiver,
DownloadEngine* e);
protected:
DownloadEngine* _e;
DownloadEngine* _e;
public:
virtual ~LpdReceiveMessageCommand();

4
src/PeerChokeCommand.cc
View File

@ -47,7 +47,7 @@ namespace aria2 {
PeerChokeCommand::PeerChokeCommand(cuid_t cuid,
DownloadEngine* e):
Command(cuid),
e(e) {}
_e(e) {}
PeerChokeCommand::~PeerChokeCommand() {}
@ -58,7 +58,7 @@ bool PeerChokeCommand::execute() {
if(_peerStorage->chokeRoundIntervalElapsed()) {
_peerStorage->executeChoke();
}
e->addCommand(this);
_e->addCommand(this);
return false;
}

2
src/PeerChokeCommand.h
View File

@ -46,7 +46,7 @@ class PeerStorage;
class PeerChokeCommand : public Command {
private:
DownloadEngine* e;
DownloadEngine* _e;
SharedHandle<PeerStorage> _peerStorage;

30
src/PeerListenCommand.cc
View File

@ -60,7 +60,7 @@ PeerListenCommand* PeerListenCommand::__instance = 0;
PeerListenCommand::PeerListenCommand(cuid_t cuid, DownloadEngine* e):
Command(cuid),
e(e),
_e(e),
_lowestSpeedLimit(20*1024)
{
++__numInstance;
@ -73,7 +73,7 @@ PeerListenCommand::~PeerListenCommand()
bool PeerListenCommand::bindPort(uint16_t& port, IntSequence& seq)
{
socket.reset(new SocketCore());
_socket.reset(new SocketCore());
std::vector<int32_t> randPorts = seq.flush();
std::random_shuffle(randPorts.begin(), randPorts.end(),
@ -86,15 +86,15 @@ bool PeerListenCommand::bindPort(uint16_t& port, IntSequence& seq)
}
port = (*portItr);
try {
socket->bind(port);
socket->beginListen();
socket->setNonBlockingMode();
_socket->bind(port);
_socket->beginListen();
_socket->setNonBlockingMode();
getLogger()->notice("BitTorrent: listening to port %d", port);
return true;
} catch(RecoverableException& ex) {
getLogger()->error(MSG_BIND_FAILURE, ex,
util::itos(getCuid()).c_str(), port);
socket->closeConnection();
_socket->closeConnection();
}
}
return false;
@ -102,33 +102,33 @@ bool PeerListenCommand::bindPort(uint16_t& port, IntSequence& seq)
uint16_t PeerListenCommand::getPort() const
{
if(socket.isNull()) {
if(_socket.isNull()) {
return 0;
} else {
std::pair<std::string, uint16_t> addr;
socket->getAddrInfo(addr);
_socket->getAddrInfo(addr);
return addr.second;
}
}
bool PeerListenCommand::execute() {
if(e->isHaltRequested() || e->getRequestGroupMan()->downloadFinished()) {
if(_e->isHaltRequested() || _e->getRequestGroupMan()->downloadFinished()) {
return true;
}
for(int i = 0; i < 3 && socket->isReadable(0); ++i) {
for(int i = 0; i < 3 && _socket->isReadable(0); ++i) {
SocketHandle peerSocket;
try {
peerSocket.reset(socket->acceptConnection());
peerSocket.reset(_socket->acceptConnection());
std::pair<std::string, uint16_t> peerInfo;
peerSocket->getPeerInfo(peerInfo);
peerSocket->setNonBlockingMode();
SharedHandle<Peer> peer(new Peer(peerInfo.first, peerInfo.second, true));
cuid_t cuid = e->newCUID();
cuid_t cuid = _e->newCUID();
Command* command =
new ReceiverMSEHandshakeCommand(cuid, peer, e, peerSocket);
e->addCommand(command);
new ReceiverMSEHandshakeCommand(cuid, peer, _e, peerSocket);
_e->addCommand(command);
if(getLogger()->debug()) {
getLogger()->debug("Accepted the connection from %s:%u.",
peer->ipaddr.c_str(),
@ -140,7 +140,7 @@ bool PeerListenCommand::execute() {
getLogger()->debug(MSG_ACCEPT_FAILURE, ex, util::itos(getCuid()).c_str());
}
}
e->addCommand(this);
_e->addCommand(this);
return false;
}

4
src/PeerListenCommand.h
View File

@ -46,8 +46,8 @@ class SocketCore;
class PeerListenCommand : public Command {
private:
DownloadEngine* e;
SharedHandle<SocketCore> socket;
DownloadEngine* _e;
SharedHandle<SocketCore> _socket;
unsigned int _lowestSpeedLimit;
static unsigned int __numInstance;

22
src/SeedCheckCommand.cc
View File

@ -55,9 +55,9 @@ SeedCheckCommand::SeedCheckCommand
const SharedHandle<SeedCriteria>& seedCriteria)
:Command(cuid),
_requestGroup(requestGroup),
e(e),
seedCriteria(seedCriteria),
checkStarted(false)
_e(e),
_seedCriteria(seedCriteria),
_checkStarted(false)
{
setStatusRealtime();
_requestGroup->increaseNumCommand();
@ -72,29 +72,29 @@ bool SeedCheckCommand::execute() {
if(_btRuntime->isHalt()) {
return true;
}
if(!seedCriteria.get()) {
if(!_seedCriteria.get()) {
return false;
}
if(!checkStarted) {
if(!_checkStarted) {
if(_pieceStorage->downloadFinished()) {
checkStarted = true;
seedCriteria->reset();
_checkStarted = true;
_seedCriteria->reset();
}
}
if(checkStarted) {
if(seedCriteria->evaluate()) {
if(_checkStarted) {
if(_seedCriteria->evaluate()) {
getLogger()->notice(MSG_SEEDING_END);
_btRuntime->setHalt(true);
}
}
e->addCommand(this);
_e->addCommand(this);
return false;
}
void SeedCheckCommand::setSeedCriteria
(const SharedHandle<SeedCriteria>& seedCriteria)
{
this->seedCriteria = seedCriteria;
_seedCriteria = seedCriteria;
}
void SeedCheckCommand::setBtRuntime(const SharedHandle<BtRuntime>& btRuntime)

6
src/SeedCheckCommand.h
View File

@ -50,11 +50,11 @@ class SeedCheckCommand : public Command
{
private:
RequestGroup* _requestGroup;
DownloadEngine* e;
DownloadEngine* _e;
SharedHandle<PieceStorage> _pieceStorage;
SharedHandle<BtRuntime> _btRuntime;
SharedHandle<SeedCriteria> seedCriteria;
bool checkStarted;
SharedHandle<SeedCriteria> _seedCriteria;
bool _checkStarted;
public:
SeedCheckCommand(cuid_t cuid,
RequestGroup* requestGroup,

7
src/SequentialDispatcherCommand.h
View File

@ -47,10 +47,15 @@ class DownloadEngine;
template<typename T>
class SequentialDispatcherCommand : public Command {
protected:
private:
SharedHandle<SequentialPicker<T> > _picker;
DownloadEngine* _e;
protected:
DownloadEngine* getDownloadEngine() const
{
return _e;
}
public:
SequentialDispatcherCommand(cuid_t cuid,
const SharedHandle<SequentialPicker<T> >& picker,

14
src/SleepCommand.cc
View File

@ -47,22 +47,22 @@ namespace aria2 {
SleepCommand::SleepCommand(cuid_t cuid, DownloadEngine* e,
RequestGroup* requestGroup,
Command* nextCommand, time_t wait):
Command(cuid), engine(e), _requestGroup(requestGroup),
nextCommand(nextCommand), wait(wait), checkPoint(global::wallclock) {}
Command(cuid), _engine(e), _requestGroup(requestGroup),
_nextCommand(nextCommand), _wait(wait), _checkPoint(global::wallclock) {}
SleepCommand::~SleepCommand() {
delete nextCommand;
delete _nextCommand;
}
bool SleepCommand::execute() {
if(_requestGroup->downloadFinished() || _requestGroup->isHaltRequested()) {
return true;
} else if(checkPoint.difference(global::wallclock) >= wait) {
engine->addCommand(nextCommand);
nextCommand = 0;
} else if(_checkPoint.difference(global::wallclock) >= _wait) {
_engine->addCommand(_nextCommand);
_nextCommand = 0;
return true;
} else {
engine->addCommand(this);
_engine->addCommand(this);
return false;
}
}

8
src/SleepCommand.h
View File

@ -45,11 +45,11 @@ class RequestGroup;
class SleepCommand:public Command {
private:
DownloadEngine* engine;
DownloadEngine* _engine;
RequestGroup* _requestGroup;
Command* nextCommand;
time_t wait;
Timer checkPoint;
Command* _nextCommand;
time_t _wait;
Timer _checkPoint;
public:
SleepCommand(cuid_t cuid, DownloadEngine* e, RequestGroup* requestGroup,
Command* nextCommand, time_t wait);

16
src/TrackerWatcherCommand.cc
View File

@ -72,7 +72,7 @@ TrackerWatcherCommand::TrackerWatcherCommand
(cuid_t cuid, RequestGroup* requestGroup, DownloadEngine* e):
Command(cuid),
_requestGroup(requestGroup),
e(e)
_e(e)
{
_requestGroup->increaseNumCommand();
}
@ -91,7 +91,7 @@ bool TrackerWatcherCommand::execute() {
return true;
} else {
_trackerRequestGroup->setForceHaltRequested(true);
e->addCommand(this);
_e->addCommand(this);
return false;
}
}
@ -106,13 +106,13 @@ bool TrackerWatcherCommand::execute() {
if(!_trackerRequestGroup.isNull()) {
std::vector<Command*> commands;
try {
_trackerRequestGroup->createInitialCommand(commands, e);
_trackerRequestGroup->createInitialCommand(commands, _e);
} catch(RecoverableException& ex) {
getLogger()->error(EX_EXCEPTION_CAUGHT, ex);
std::for_each(commands.begin(), commands.end(), Deleter());
commands.clear();
}
e->addCommand(commands);
_e->addCommand(commands);
if(getLogger()->debug()) {
getLogger()->debug("added tracker request command");
}
@ -140,7 +140,7 @@ bool TrackerWatcherCommand::execute() {
_btAnnounce->resetAnnounce();
}
}
e->addCommand(this);
_e->addCommand(this);
return false;
}
@ -173,13 +173,13 @@ void TrackerWatcherCommand::processTrackerResponse
if(peer.isNull()) {
break;
}
peer->usedBy(e->newCUID());
peer->usedBy(_e->newCUID());
PeerInitiateConnectionCommand* command =
new PeerInitiateConnectionCommand
(peer->usedBy(), _requestGroup, peer, e, _btRuntime);
(peer->usedBy(), _requestGroup, peer, _e, _btRuntime);
command->setPeerStorage(_peerStorage);
command->setPieceStorage(_pieceStorage);
e->addCommand(command);
_e->addCommand(command);
if(getLogger()->debug()) {
getLogger()->debug("CUID#%s - Adding new command CUID#%s",
util::itos(getCuid()).c_str(),

2
src/TrackerWatcherCommand.h
View File

@ -53,7 +53,7 @@ class TrackerWatcherCommand : public Command
private:
RequestGroup* _requestGroup;
DownloadEngine* e;
DownloadEngine* _e;
SharedHandle<PeerStorage> _peerStorage;