mirror of https://github.com/aria2/aria2
552 lines
14 KiB
C++
552 lines
14 KiB
C++
/* <!-- copyright */
|
|
/*
|
|
* aria2 - The high speed download utility
|
|
*
|
|
* Copyright (C) 2006 Tatsuhiro Tsujikawa
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*
|
|
* In addition, as a special exception, the copyright holders give
|
|
* permission to link the code of portions of this program with the
|
|
* OpenSSL library under certain conditions as described in each
|
|
* individual source file, and distribute linked combinations
|
|
* including the two.
|
|
* You must obey the GNU General Public License in all respects
|
|
* for all of the code used other than OpenSSL. If you modify
|
|
* file(s) with this exception, you may extend this exception to your
|
|
* version of the file(s), but you are not obligated to do so. If you
|
|
* do not wish to do so, delete this exception statement from your
|
|
* version. If you delete this exception statement from all source
|
|
* files in the program, then also delete it here.
|
|
*/
|
|
/* copyright --> */
|
|
#ifndef _D_REQUEST_GROUP_H_
|
|
#define _D_REQUEST_GROUP_H_
|
|
|
|
#include "common.h"
|
|
|
|
#include <string>
|
|
#include <algorithm>
|
|
#include <vector>
|
|
|
|
#include "SharedHandle.h"
|
|
#include "TransferStat.h"
|
|
#include "TimeA2.h"
|
|
#include "Request.h"
|
|
#include "DownloadResultCode.h"
|
|
#include "MetadataInfo.h"
|
|
|
|
namespace aria2 {
|
|
|
|
class DownloadEngine;
|
|
class SegmentMan;
|
|
class Command;
|
|
class DownloadCommand;
|
|
class DownloadContext;
|
|
class PieceStorage;
|
|
class BtProgressInfoFile;
|
|
class Dependency;
|
|
class PreDownloadHandler;
|
|
class PostDownloadHandler;
|
|
class DiskWriterFactory;
|
|
class Option;
|
|
class Logger;
|
|
class RequestGroup;
|
|
class CheckIntegrityEntry;
|
|
struct DownloadResult;
|
|
class URISelector;
|
|
class URIResult;
|
|
class RequestGroupMan;
|
|
#ifdef ENABLE_BITTORRENT
|
|
class BtRuntime;
|
|
class PeerStorage;
|
|
#endif // ENABLE_BITTORRENT
|
|
|
|
typedef int64_t gid_t;
|
|
|
|
class RequestGroup {
|
|
public:
|
|
enum HaltReason {
|
|
NONE,
|
|
SHUTDOWN_SIGNAL,
|
|
USER_REQUEST
|
|
};
|
|
private:
|
|
static gid_t gidCounter_;
|
|
|
|
gid_t gid_;
|
|
|
|
SharedHandle<Option> option_;
|
|
|
|
size_t numConcurrentCommand_;
|
|
|
|
/**
|
|
* This is the number of connections used in streaming protocol(http/ftp)
|
|
*/
|
|
unsigned int numStreamConnection_;
|
|
|
|
unsigned int numStreamCommand_;
|
|
|
|
unsigned int numCommand_;
|
|
|
|
SharedHandle<SegmentMan> segmentMan_;
|
|
|
|
SharedHandle<DownloadContext> downloadContext_;
|
|
|
|
SharedHandle<PieceStorage> pieceStorage_;
|
|
|
|
bool saveControlFile_;
|
|
|
|
SharedHandle<BtProgressInfoFile> progressInfoFile_;
|
|
|
|
SharedHandle<DiskWriterFactory> diskWriterFactory_;
|
|
|
|
SharedHandle<Dependency> dependency_;
|
|
|
|
bool fileAllocationEnabled_;
|
|
|
|
bool preLocalFileCheckEnabled_;
|
|
|
|
bool haltRequested_;
|
|
|
|
bool forceHaltRequested_;
|
|
|
|
HaltReason haltReason_;
|
|
|
|
bool pauseRequested_;
|
|
|
|
std::vector<SharedHandle<PreDownloadHandler> > preDownloadHandlers_;
|
|
|
|
std::vector<SharedHandle<PostDownloadHandler> > postDownloadHandlers_;
|
|
|
|
std::vector<std::string> acceptTypes_;
|
|
|
|
SharedHandle<URISelector> uriSelector_;
|
|
|
|
Time lastModifiedTime_;
|
|
|
|
unsigned int fileNotFoundCount_;
|
|
|
|
// Timeout used for HTTP/FTP downloads.
|
|
time_t timeout_;
|
|
|
|
#ifdef ENABLE_BITTORRENT
|
|
WeakHandle<BtRuntime> btRuntime_;
|
|
|
|
WeakHandle<PeerStorage> peerStorage_;
|
|
#endif // ENABLE_BITTORRENT
|
|
|
|
// This flag just indicates that the downloaded file is not saved disk but
|
|
// just sits in memory.
|
|
bool inMemoryDownload_;
|
|
|
|
unsigned int maxDownloadSpeedLimit_;
|
|
|
|
unsigned int maxUploadSpeedLimit_;
|
|
|
|
SharedHandle<URIResult> lastUriResult_;
|
|
|
|
// If this download generates another downloads when completed(for
|
|
// example, downloads generated by PostDownloadHandler), this field
|
|
// has the GID of generated RequestGroups. empty list means there is
|
|
// no such RequestGroup.
|
|
std::vector<gid_t> followedByGIDs_;
|
|
|
|
// If this download is a part of another download(for example,
|
|
// downloading torrent file described in Metalink file), this field
|
|
// has the GID of parent RequestGroup. 0 means this is a parent
|
|
// RequestGroup.
|
|
gid_t belongsToGID_;
|
|
|
|
SharedHandle<MetadataInfo> metadataInfo_;
|
|
|
|
RequestGroupMan* requestGroupMan_;
|
|
|
|
int resumeFailureCount_;
|
|
|
|
Logger* logger_;
|
|
|
|
void validateFilename(const std::string& expectedFilename,
|
|
const std::string& actualFilename) const;
|
|
|
|
void initializePreDownloadHandler();
|
|
|
|
void initializePostDownloadHandler();
|
|
|
|
bool tryAutoFileRenaming();
|
|
|
|
// Returns the result code of this RequestGroup. If the download
|
|
// finished, then returns downloadresultcode::FINISHED. If the
|
|
// download didn't finish and error result is available in
|
|
// _uriResults, then last result code is returned. Otherwise
|
|
// returns downloadresultcode::UNKNOWN_ERROR.
|
|
downloadresultcode::RESULT downloadResult() const;
|
|
|
|
void removeDefunctControlFile
|
|
(const SharedHandle<BtProgressInfoFile>& progressInfoFile);
|
|
public:
|
|
// The copy of option is stored in RequestGroup object.
|
|
RequestGroup(const SharedHandle<Option>& option);
|
|
|
|
~RequestGroup();
|
|
|
|
const SharedHandle<SegmentMan>& getSegmentMan() const
|
|
{
|
|
return segmentMan_;
|
|
}
|
|
|
|
// Returns first bootstrap commands to initiate a download.
|
|
// If this is HTTP/FTP download and file size is unknown, only 1 command
|
|
// (usually, HttpInitiateConnection or FtpInitiateConnection) will be created.
|
|
void createInitialCommand(std::vector<Command*>& commands,
|
|
DownloadEngine* e);
|
|
|
|
void createNextCommandWithAdj(std::vector<Command*>& commands,
|
|
DownloadEngine* e, int numAdj);
|
|
|
|
void createNextCommand(std::vector<Command*>& commands,
|
|
DownloadEngine* e, unsigned int numCommand);
|
|
|
|
void createNextCommand(std::vector<Command*>& commands, DownloadEngine* e);
|
|
|
|
bool downloadFinished() const;
|
|
|
|
bool allDownloadFinished() const;
|
|
|
|
void closeFile();
|
|
|
|
std::string getFirstFilePath() const;
|
|
|
|
uint64_t getTotalLength() const;
|
|
|
|
uint64_t getCompletedLength() const;
|
|
|
|
/**
|
|
* Compares expected filename with specified actualFilename.
|
|
* The expected filename refers to FileEntry::getBasename() of the first
|
|
* element of DownloadContext::getFileEntries()
|
|
*/
|
|
void validateFilename(const std::string& actualFilename) const;
|
|
|
|
void validateTotalLength(uint64_t expectedTotalLength,
|
|
uint64_t actualTotalLength) const;
|
|
|
|
void validateTotalLength(uint64_t actualTotalLength) const;
|
|
|
|
void setNumConcurrentCommand(unsigned int num)
|
|
{
|
|
numConcurrentCommand_ = num;
|
|
}
|
|
|
|
unsigned int getNumConcurrentCommand() const
|
|
{
|
|
return numConcurrentCommand_;
|
|
}
|
|
|
|
gid_t getGID() const
|
|
{
|
|
return gid_;
|
|
}
|
|
|
|
TransferStat calculateStat() const;
|
|
|
|
const SharedHandle<DownloadContext>& getDownloadContext() const
|
|
{
|
|
return downloadContext_;
|
|
}
|
|
|
|
// This function also calls
|
|
// downloadContext->setOwnerRequestGroup(this).
|
|
void setDownloadContext(const SharedHandle<DownloadContext>& downloadContext);
|
|
|
|
const SharedHandle<PieceStorage>& getPieceStorage() const
|
|
{
|
|
return pieceStorage_;
|
|
}
|
|
|
|
void setPieceStorage(const SharedHandle<PieceStorage>& pieceStorage);
|
|
|
|
void setProgressInfoFile(const SharedHandle<BtProgressInfoFile>& progressInfoFile);
|
|
|
|
void increaseStreamCommand();
|
|
|
|
void decreaseStreamCommand();
|
|
|
|
void increaseStreamConnection();
|
|
|
|
void decreaseStreamConnection();
|
|
|
|
unsigned int getNumConnection() const;
|
|
|
|
void increaseNumCommand();
|
|
|
|
void decreaseNumCommand();
|
|
|
|
unsigned int getNumCommand() const
|
|
{
|
|
return numCommand_;
|
|
}
|
|
|
|
// TODO is it better to move the following 2 methods to SingleFileDownloadContext?
|
|
void setDiskWriterFactory(const SharedHandle<DiskWriterFactory>& diskWriterFactory);
|
|
|
|
const SharedHandle<DiskWriterFactory>& getDiskWriterFactory() const
|
|
{
|
|
return diskWriterFactory_;
|
|
}
|
|
|
|
void setFileAllocationEnabled(bool f)
|
|
{
|
|
fileAllocationEnabled_ = f;
|
|
}
|
|
|
|
bool isFileAllocationEnabled() const
|
|
{
|
|
return fileAllocationEnabled_;
|
|
}
|
|
|
|
bool needsFileAllocation() const;
|
|
|
|
/**
|
|
* Setting preLocalFileCheckEnabled_ to false, then skip the check to see
|
|
* if a file is already exists and control file exists etc.
|
|
* Always open file with DiskAdaptor::initAndOpenFile()
|
|
*/
|
|
void setPreLocalFileCheckEnabled(bool f)
|
|
{
|
|
preLocalFileCheckEnabled_ = f;
|
|
}
|
|
|
|
bool isPreLocalFileCheckEnabled() const
|
|
{
|
|
return preLocalFileCheckEnabled_;
|
|
}
|
|
|
|
void setHaltRequested(bool f, HaltReason = SHUTDOWN_SIGNAL);
|
|
|
|
void setForceHaltRequested(bool f, HaltReason = SHUTDOWN_SIGNAL);
|
|
|
|
bool isHaltRequested() const
|
|
{
|
|
return haltRequested_;
|
|
}
|
|
|
|
bool isForceHaltRequested() const
|
|
{
|
|
return forceHaltRequested_;
|
|
}
|
|
|
|
void setPauseRequested(bool f);
|
|
|
|
bool isPauseRequested() const
|
|
{
|
|
return pauseRequested_;
|
|
}
|
|
|
|
void dependsOn(const SharedHandle<Dependency>& dep);
|
|
|
|
bool isDependencyResolved();
|
|
|
|
void releaseRuntimeResource(DownloadEngine* e);
|
|
|
|
void postDownloadProcessing(std::vector<SharedHandle<RequestGroup> >& groups);
|
|
|
|
void addPostDownloadHandler(const SharedHandle<PostDownloadHandler>& handler);
|
|
|
|
void clearPostDownloadHandler();
|
|
|
|
void preDownloadProcessing();
|
|
|
|
void addPreDownloadHandler(const SharedHandle<PreDownloadHandler>& handler);
|
|
|
|
void clearPreDownloadHandler();
|
|
|
|
void processCheckIntegrityEntry(std::vector<Command*>& commands,
|
|
const SharedHandle<CheckIntegrityEntry>& entry,
|
|
DownloadEngine* e);
|
|
|
|
// Initializes pieceStorage_ and segmentMan_. We guarantee that
|
|
// either both of pieceStorage_ and segmentMan_ are initialized or
|
|
// they are not.
|
|
void initPieceStorage();
|
|
|
|
void dropPieceStorage();
|
|
|
|
bool downloadFinishedByFileLength();
|
|
|
|
void loadAndOpenFile(const SharedHandle<BtProgressInfoFile>& progressInfoFile);
|
|
|
|
void shouldCancelDownloadForSafety();
|
|
|
|
void adjustFilename(const SharedHandle<BtProgressInfoFile>& infoFile);
|
|
|
|
SharedHandle<DownloadResult> createDownloadResult() const;
|
|
|
|
const SharedHandle<Option>& getOption() const
|
|
{
|
|
return option_;
|
|
}
|
|
|
|
void reportDownloadFinished();
|
|
|
|
const std::vector<std::string>& getAcceptTypes() const
|
|
{
|
|
return acceptTypes_;
|
|
}
|
|
|
|
void addAcceptType(const std::string& type);
|
|
|
|
template<typename InputIterator>
|
|
void addAcceptType(InputIterator first, InputIterator last)
|
|
{
|
|
for(; first != last; ++first) {
|
|
if(std::find(acceptTypes_.begin(), acceptTypes_.end(), *first) ==
|
|
acceptTypes_.end()) {
|
|
acceptTypes_.push_back(*first);
|
|
}
|
|
}
|
|
}
|
|
|
|
void removeAcceptType(const std::string& type);
|
|
|
|
void setURISelector(const SharedHandle<URISelector>& uriSelector);
|
|
|
|
const SharedHandle<URISelector>& getURISelector() const
|
|
{
|
|
return uriSelector_;
|
|
}
|
|
|
|
void applyLastModifiedTimeToLocalFiles();
|
|
|
|
void updateLastModifiedTime(const Time& time);
|
|
|
|
void increaseAndValidateFileNotFoundCount();
|
|
|
|
// Just set inMemoryDownload flag true.
|
|
void markInMemoryDownload();
|
|
|
|
// Returns inMemoryDownload flag.
|
|
bool inMemoryDownload() const
|
|
{
|
|
return inMemoryDownload_;
|
|
}
|
|
|
|
void setTimeout(time_t timeout);
|
|
|
|
time_t getTimeout() const
|
|
{
|
|
return timeout_;
|
|
}
|
|
|
|
// Returns true if current download speed exceeds
|
|
// maxDownloadSpeedLimit_. Always returns false if
|
|
// maxDownloadSpeedLimit_ == 0. Otherwise returns false.
|
|
bool doesDownloadSpeedExceed();
|
|
|
|
// Returns true if current upload speed exceeds
|
|
// maxUploadSpeedLimit_. Always returns false if
|
|
// maxUploadSpeedLimit_ == 0. Otherwise returns false.
|
|
bool doesUploadSpeedExceed();
|
|
|
|
unsigned int getMaxDownloadSpeedLimit() const
|
|
{
|
|
return maxDownloadSpeedLimit_;
|
|
}
|
|
|
|
void setMaxDownloadSpeedLimit(unsigned int speed)
|
|
{
|
|
maxDownloadSpeedLimit_ = speed;
|
|
}
|
|
|
|
unsigned int getMaxUploadSpeedLimit() const
|
|
{
|
|
return maxUploadSpeedLimit_;
|
|
}
|
|
|
|
void setMaxUploadSpeedLimit(unsigned int speed)
|
|
{
|
|
maxUploadSpeedLimit_ = speed;
|
|
}
|
|
|
|
void setLastUriResult(std::string uri, downloadresultcode::RESULT result);
|
|
|
|
void saveControlFile() const;
|
|
|
|
void removeControlFile() const;
|
|
|
|
void enableSaveControlFile() { saveControlFile_ = true; }
|
|
|
|
void disableSaveControlFile() { saveControlFile_ = false; }
|
|
|
|
template<typename InputIterator>
|
|
void followedBy(InputIterator groupFirst, InputIterator groupLast)
|
|
{
|
|
followedByGIDs_.clear();
|
|
for(; groupFirst != groupLast; ++groupFirst) {
|
|
followedByGIDs_.push_back((*groupFirst)->getGID());
|
|
}
|
|
}
|
|
|
|
const std::vector<gid_t>& followedBy() const
|
|
{
|
|
return followedByGIDs_;
|
|
}
|
|
|
|
void belongsTo(gid_t gid)
|
|
{
|
|
belongsToGID_ = gid;
|
|
}
|
|
|
|
gid_t belongsTo() const
|
|
{
|
|
return belongsToGID_;
|
|
}
|
|
|
|
void setRequestGroupMan(RequestGroupMan* requestGroupMan)
|
|
{
|
|
requestGroupMan_ = requestGroupMan;
|
|
}
|
|
|
|
int getResumeFailureCount() const
|
|
{
|
|
return resumeFailureCount_;
|
|
}
|
|
|
|
void increaseResumeFailureCount()
|
|
{
|
|
++resumeFailureCount_;
|
|
}
|
|
|
|
bool p2pInvolved() const;
|
|
|
|
void setMetadataInfo(const SharedHandle<MetadataInfo>& info)
|
|
{
|
|
metadataInfo_ = info;
|
|
}
|
|
|
|
const SharedHandle<MetadataInfo>& getMetadataInfo() const
|
|
{
|
|
return metadataInfo_;
|
|
}
|
|
|
|
static void resetGIDCounter() { gidCounter_ = 0; }
|
|
|
|
static gid_t newGID();
|
|
};
|
|
|
|
} // namespace aria2
|
|
|
|
#endif // _D_REQUEST_GROUP_H_
|