d4708/qBittorrent
1
0
Fork 0
mirror of https://github.com/d47081/qBittorrent.git synced 2025-01-23 04:54:18 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #6724 from glassez/libt11

Browse Source 
Don't use features, deprecated in libtorrent-1.1
This commit is contained in:
Vladimir Golovnev 2017-05-16 18:54:00 +03:00 committed by GitHub
commit 44f8a48d73
24 changed files with 578 additions and 437 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/base/base.pri
View File

@ -89,8 +89,6 @@ SOURCES += \
$$PWD/net/private/geoipdatabase.cpp \
$$PWD/bittorrent/infohash.cpp \
$$PWD/bittorrent/session.cpp \
$$PWD/bittorrent/sessionstatus.cpp \
$$PWD/bittorrent/cachestatus.cpp \
$$PWD/bittorrent/magneturi.cpp \
$$PWD/bittorrent/torrentinfo.cpp \
$$PWD/bittorrent/torrenthandle.cpp \

69
src/base/bittorrent/cachestatus.cpp
View File

@ -1,69 +0,0 @@
/*
* Bittorrent Client using Qt and libtorrent.
* Copyright (C) 2015 Vladimir Golovnev <glassez@yandex.ru>
*
* 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 this program with the OpenSSL project's "OpenSSL" library (or with
* modified versions of it that use the same license as the "OpenSSL" library),
* and distribute the linked executables. 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), 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.
*/
#include <libtorrent/version.hpp>
#include "cachestatus.h"
using namespace BitTorrent;
CacheStatus::CacheStatus(const libtorrent::cache_status &nativeStatus)
: m_nativeStatus(nativeStatus)
{
}
int CacheStatus::totalUsedBuffers() const
{
return m_nativeStatus.total_used_buffers;
}
qreal CacheStatus::readRatio() const
{
if (m_nativeStatus.blocks_read > 0)
return (static_cast<qreal>(m_nativeStatus.blocks_read_hit) / m_nativeStatus.blocks_read);
else
return -1;
}
int CacheStatus::jobQueueLength() const
{
#if LIBTORRENT_VERSION_NUM < 10100
return m_nativeStatus.job_queue_length;
#else
return m_nativeStatus.queued_jobs;
#endif
}
int CacheStatus::averageJobTime() const
{
return m_nativeStatus.average_job_time;
}
qlonglong CacheStatus::queuedBytes() const
{
return m_nativeStatus.queued_bytes;
}

21
src/base/bittorrent/cachestatus.h
View File

@ -1,6 +1,6 @@
/*
* Bittorrent Client using Qt and libtorrent.
* Copyright (C) 2015 Vladimir Golovnev <glassez@yandex.ru>
* Copyright (C) 2015, 2017 Vladimir Golovnev <glassez@yandex.ru>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
@ -30,23 +30,16 @@
#define BITTORRENT_CACHESTATUS_H
#include <QtGlobal>
#include <libtorrent/disk_io_thread.hpp>
namespace BitTorrent
{
class CacheStatus
struct CacheStatus
{
public:
CacheStatus(const libtorrent::cache_status &nativeStatus);
int totalUsedBuffers() const;
qreal readRatio() const;
int jobQueueLength() const;
int averageJobTime() const;
qlonglong queuedBytes() const;
private:
libtorrent::cache_status m_nativeStatus;
quint64 totalUsedBuffers = 0;
quint64 jobQueueLength = 0;
quint64 averageJobTime = 0;
quint64 queuedBytes = 0;
qreal readRatio = 0.0;
};
}

6
src/base/bittorrent/peerinfo.cpp
View File

@ -121,12 +121,6 @@ bool PeerInfo::isConnecting() const
return (m_nativeInfo.flags & libt::peer_info::connecting);
}
bool PeerInfo::isQueued() const
{
return (m_nativeInfo.flags & libt::peer_info::queued);
}
bool PeerInfo::isOnParole() const
{
return (m_nativeInfo.flags & libt::peer_info::on_parole);

1
src/base/bittorrent/peerinfo.h
View File

@ -68,7 +68,6 @@ namespace BitTorrent
bool isHandshake() const;
bool isConnecting() const;
bool isQueued() const;
bool isOnParole() const;
bool isSeed() const;

10
src/base/bittorrent/private/statistics.cpp
View File

@ -45,13 +45,13 @@ quint64 Statistics::getAlltimeUL() const
void Statistics::gather()
{
SessionStatus ss = m_session->status();
if (ss.totalDownload() > m_sessionDL) {
m_sessionDL = ss.totalDownload();
const SessionStatus &ss = m_session->status();
if (ss.totalDownload > m_sessionDL) {
m_sessionDL = ss.totalDownload;
m_dirty = true;
}
if (ss.totalUpload() > m_sessionUL) {
m_sessionUL = ss.totalUpload();
if (ss.totalUpload > m_sessionUL) {
m_sessionUL = ss.totalUpload;
m_dirty = true;
}

4
src/base/bittorrent/private/statistics.h
View File

@ -30,8 +30,8 @@ private:
// Will overflow at 15.9 EiB
quint64 m_alltimeUL;
quint64 m_alltimeDL;
qint64 m_sessionUL;
qint64 m_sessionDL;
quint64 m_sessionUL;
quint64 m_sessionDL;
mutable qint64 m_lastWrite;
mutable bool m_dirty;

286
src/base/bittorrent/session.cpp
View File

@ -51,6 +51,7 @@
#include <libtorrent/bdecode.hpp>
#endif
#include <libtorrent/bencode.hpp>
#include <libtorrent/disk_io_thread.hpp>
#include <libtorrent/error_code.hpp>
#include <libtorrent/extensions/ut_metadata.hpp>
#include <libtorrent/extensions/ut_pex.hpp>
@ -62,6 +63,10 @@
#endif
#include <libtorrent/magnet_uri.hpp>
#include <libtorrent/session.hpp>
#if LIBTORRENT_VERSION_NUM >= 10100
#include <libtorrent/session_stats.hpp>
#endif
#include <libtorrent/session_status.hpp>
#include <libtorrent/torrent_info.hpp>
#include "base/logger.h"
@ -78,13 +83,11 @@
#include "base/utils/fs.h"
#include "base/utils/random.h"
#include "base/utils/string.h"
#include "cachestatus.h"
#include "magneturi.h"
#include "private/filterparserthread.h"
#include "private/statistics.h"
#include "private/bandwidthscheduler.h"
#include "private/resumedatasavingmanager.h"
#include "sessionstatus.h"
#include "torrenthandle.h"
#include "tracker.h"
#include "trackerentry.h"
@ -357,6 +360,8 @@ Session::Session(QObject *parent)
{
QMetaObject::invokeMethod(this, "readAlerts", Qt::QueuedConnection);
});
configurePeerClasses();
#endif
// Enabling plugins
@ -429,6 +434,11 @@ Session::Session(QObject *parent)
// initialize PortForwarder instance
Net::PortForwarder::initInstance(m_nativeSession);
#if LIBTORRENT_VERSION_NUM >= 10100
initMetrics();
m_statsUpdateTimer.start();
#endif
qDebug("* BitTorrent Session constructed");
}
@ -870,6 +880,7 @@ void Session::configure()
libt::settings_pack settingsPack = m_nativeSession->get_settings();
configure(settingsPack);
m_nativeSession->apply_settings(settingsPack);
configurePeerClasses();
#endif
if (m_IPFilteringChanged) {
@ -909,6 +920,75 @@ void Session::adjustLimits(libt::settings_pack &settingsPack)
, maxActive > -1 ? maxActive + m_extraLimit : maxActive);
}
void Session::initMetrics()
{
m_metricIndices.net.hasIncomingConnections = libt::find_metric_idx("net.has_incoming_connections");
Q_ASSERT(m_metricIndices.net.hasIncomingConnections >= 0);
m_metricIndices.net.sentPayloadBytes = libt::find_metric_idx("net.sent_payload_bytes");
Q_ASSERT(m_metricIndices.net.sentPayloadBytes >= 0);
m_metricIndices.net.recvPayloadBytes = libt::find_metric_idx("net.recv_payload_bytes");
Q_ASSERT(m_metricIndices.net.recvPayloadBytes >= 0);
m_metricIndices.net.sentBytes = libt::find_metric_idx("net.sent_bytes");
Q_ASSERT(m_metricIndices.net.sentBytes >= 0);
m_metricIndices.net.recvBytes = libt::find_metric_idx("net.recv_bytes");
Q_ASSERT(m_metricIndices.net.recvBytes >= 0);
m_metricIndices.net.sentIPOverheadBytes = libt::find_metric_idx("net.sent_ip_overhead_bytes");
Q_ASSERT(m_metricIndices.net.sentIPOverheadBytes >= 0);
m_metricIndices.net.recvIPOverheadBytes = libt::find_metric_idx("net.recv_ip_overhead_bytes");
Q_ASSERT(m_metricIndices.net.recvIPOverheadBytes >= 0);
m_metricIndices.net.sentTrackerBytes = libt::find_metric_idx("net.sent_tracker_bytes");
Q_ASSERT(m_metricIndices.net.sentTrackerBytes >= 0);
m_metricIndices.net.recvTrackerBytes = libt::find_metric_idx("net.recv_tracker_bytes");
Q_ASSERT(m_metricIndices.net.recvTrackerBytes >= 0);
m_metricIndices.net.recvRedundantBytes = libt::find_metric_idx("net.recv_redundant_bytes");
Q_ASSERT(m_metricIndices.net.recvRedundantBytes >= 0);
m_metricIndices.net.recvFailedBytes = libt::find_metric_idx("net.recv_failed_bytes");
Q_ASSERT(m_metricIndices.net.recvFailedBytes >= 0);
m_metricIndices.peer.numPeersConnected = libt::find_metric_idx("peer.num_peers_connected");
Q_ASSERT(m_metricIndices.peer.numPeersConnected >= 0);
m_metricIndices.peer.numPeersDownDisk = libt::find_metric_idx("peer.num_peers_down_disk");
Q_ASSERT(m_metricIndices.peer.numPeersDownDisk >= 0);
m_metricIndices.peer.numPeersUpDisk = libt::find_metric_idx("peer.num_peers_up_disk");
Q_ASSERT(m_metricIndices.peer.numPeersUpDisk >= 0);
m_metricIndices.dht.dhtBytesIn = libt::find_metric_idx("dht.dht_bytes_in");
Q_ASSERT(m_metricIndices.dht.dhtBytesIn >= 0);
m_metricIndices.dht.dhtBytesOut = libt::find_metric_idx("dht.dht_bytes_out");
Q_ASSERT(m_metricIndices.dht.dhtBytesOut >= 0);
m_metricIndices.dht.dhtNodes = libt::find_metric_idx("dht.dht_nodes");
Q_ASSERT(m_metricIndices.dht.dhtNodes >= 0);
m_metricIndices.disk.diskBlocksInUse = libt::find_metric_idx("disk.disk_blocks_in_use");
Q_ASSERT(m_metricIndices.disk.diskBlocksInUse >= 0);
m_metricIndices.disk.numBlocksRead = libt::find_metric_idx("disk.num_blocks_read");
Q_ASSERT(m_metricIndices.disk.numBlocksRead >= 0);
m_metricIndices.disk.numBlocksCacheHits = libt::find_metric_idx("disk.num_blocks_cache_hits");
Q_ASSERT(m_metricIndices.disk.numBlocksCacheHits >= 0);
m_metricIndices.disk.queuedDiskJobs = libt::find_metric_idx("disk.queued_disk_jobs");
Q_ASSERT(m_metricIndices.disk.queuedDiskJobs >= 0);
m_metricIndices.disk.diskJobTime = libt::find_metric_idx("disk.disk_job_time");
Q_ASSERT(m_metricIndices.disk.diskJobTime >= 0);
}
void Session::configure(libtorrent::settings_pack &settingsPack)
{
Logger* const logger = Logger::instance();
@ -1048,16 +1128,12 @@ void Session::configure(libtorrent::settings_pack &settingsPack)
settingsPack.set_int(libt::settings_pack::outgoing_port, outgoingPortsMin());
settingsPack.set_int(libt::settings_pack::num_outgoing_ports, outgoingPortsMax() - outgoingPortsMin() + 1);
// Ignore limits on LAN
settingsPack.set_bool(libt::settings_pack::ignore_limits_on_local_network, ignoreLimitsOnLAN());
// Include overhead in transfer limits
settingsPack.set_bool(libt::settings_pack::rate_limit_ip_overhead, includeOverheadInLimits());
// IP address to announce to trackers
settingsPack.set_str(libt::settings_pack::announce_ip, announceIP().toStdString());
// Super seeding
settingsPack.set_bool(libt::settings_pack::strict_super_seeding, isSuperSeedingEnabled());
// * Max Half-open connections
settingsPack.set_int(libt::settings_pack::half_open_limit, maxHalfOpenConnections());
// * Max connections limit
settingsPack.set_int(libt::settings_pack::connections_limit, maxConnections());
// * Global max upload slots
@ -1065,8 +1141,6 @@ void Session::configure(libtorrent::settings_pack &settingsPack)
// uTP
settingsPack.set_bool(libt::settings_pack::enable_incoming_utp, isUTPEnabled());
settingsPack.set_bool(libt::settings_pack::enable_outgoing_utp, isUTPEnabled());
// uTP rate limiting
settingsPack.set_bool(libt::settings_pack::rate_limit_utp, isUTPRateLimited());
settingsPack.set_int(libt::settings_pack::mixed_mode_algorithm, isUTPRateLimited()
? libt::settings_pack::prefer_tcp
: libt::settings_pack::peer_proportional);
@ -1079,6 +1153,70 @@ void Session::configure(libtorrent::settings_pack &settingsPack)
settingsPack.set_bool(libt::settings_pack::enable_lsd, isLSDEnabled());
}
void Session::configurePeerClasses()
{
libt::ip_filter f;
f.add_rule(libt::address_v4::from_string("0.0.0.0")
, libt::address_v4::from_string("255.255.255.255")
, 1 << libt::session::global_peer_class_id);
#if TORRENT_USE_IPV6
f.add_rule(libt::address_v6::from_string("::0")
, libt::address_v6::from_string("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")
, 1 << libt::session::global_peer_class_id);
#endif
if (ignoreLimitsOnLAN()) {
// local networks
f.add_rule(libt::address_v4::from_string("10.0.0.0")
, libt::address_v4::from_string("10.255.255.255")
, 1 << libt::session::local_peer_class_id);
f.add_rule(libt::address_v4::from_string("172.16.0.0")
, libt::address_v4::from_string("172.31.255.255")
, 1 << libt::session::local_peer_class_id);
f.add_rule(libt::address_v4::from_string("192.168.0.0")
, libt::address_v4::from_string("192.168.255.255")
, 1 << libt::session::local_peer_class_id);
// link local
f.add_rule(libt::address_v4::from_string("169.254.0.0")
, libt::address_v4::from_string("169.254.255.255")
, 1 << libt::session::local_peer_class_id);
// loopback
f.add_rule(libt::address_v4::from_string("127.0.0.0")
, libt::address_v4::from_string("127.255.255.255")
, 1 << libt::session::local_peer_class_id);
#if TORRENT_USE_IPV6
// link local
f.add_rule(libt::address_v6::from_string("fe80::")
, libt::address_v6::from_string("febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff")
, 1 << libt::session::local_peer_class_id);
// unique local addresses
f.add_rule(libt::address_v6::from_string("fc00::")
, libt::address_v6::from_string("fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")
, 1 << libt::session::local_peer_class_id);
// loopback
f.add_rule(libt::address_v6::from_string("::1")
, libt::address_v6::from_string("::1")
, 1 << libt::session::local_peer_class_id);
#endif
}
m_nativeSession->set_peer_class_filter(f);
libt::peer_class_type_filter peerClassTypeFilter;
peerClassTypeFilter.add(libt::peer_class_type_filter::tcp_socket, libt::session::tcp_peer_class_id);
peerClassTypeFilter.add(libt::peer_class_type_filter::ssl_tcp_socket, libt::session::tcp_peer_class_id);
peerClassTypeFilter.add(libt::peer_class_type_filter::i2p_socket, libt::session::tcp_peer_class_id);
if (isUTPRateLimited()) {
peerClassTypeFilter.add(libt::peer_class_type_filter::utp_socket
, libt::session::local_peer_class_id);
peerClassTypeFilter.add(libt::peer_class_type_filter::utp_socket
, libt::session::global_peer_class_id);
peerClassTypeFilter.add(libt::peer_class_type_filter::ssl_utp_socket
, libt::session::local_peer_class_id);
peerClassTypeFilter.add(libt::peer_class_type_filter::ssl_utp_socket
, libt::session::global_peer_class_id);
}
m_nativeSession->set_peer_class_type_filter(peerClassTypeFilter);
}
#else
void Session::adjustLimits(libt::session_settings &sessionSettings)
@ -1609,7 +1747,6 @@ bool Session::addTorrent_impl(AddTorrentData addData, const MagnetUri &magnetUri
libt::add_torrent_params p;
InfoHash hash;
std::vector<char> buf(fastresumeData.constData(), fastresumeData.constData() + fastresumeData.size());
std::vector<boost::uint8_t> filePriorities;
QString savePath;
@ -1663,7 +1800,7 @@ bool Session::addTorrent_impl(AddTorrentData addData, const MagnetUri &magnetUri
if (addData.resumed && !fromMagnetUri) {
// Set torrent fast resume data
p.resume_data = buf;
p.resume_data = {fastresumeData.constData(), fastresumeData.constData() + fastresumeData.size()};
p.flags |= libt::add_torrent_params::flag_use_resume_save_path;
}
else {
@ -3061,14 +3198,14 @@ void Session::recursiveTorrentDownload(const InfoHash &hash)
}
}
SessionStatus Session::status() const
const SessionStatus &Session::status() const
{
return m_nativeSession->status();
return m_status;
}
CacheStatus Session::cacheStatus() const
const CacheStatus &Session::cacheStatus() const
{
return m_nativeSession->get_cache_status();
return m_cacheStatus;
}
// Will resume torrents in backup directory
@ -3169,6 +3306,9 @@ quint64 Session::getAlltimeUL() const
void Session::refresh()
{
m_nativeSession->post_torrent_updates();
#if LIBTORRENT_VERSION_NUM >= 10100
m_nativeSession->post_session_stats();
#endif
}
void Session::handleIPFilterParsed(int ruleCount)
@ -3277,6 +3417,11 @@ void Session::handleAlert(libt::alert *a)
case libt::state_update_alert::alert_type:
handleStateUpdateAlert(static_cast<libt::state_update_alert*>(a));
break;
#if LIBTORRENT_VERSION_NUM >= 10100
case libt::session_stats_alert::alert_type:
handleSessionStatsAlert(static_cast<libt::session_stats_alert*>(a));
break;
#endif
case libt::file_error_alert::alert_type:
handleFileErrorAlert(static_cast<libt::file_error_alert*>(a));
break;
@ -3502,7 +3647,13 @@ void Session::handlePeerBanAlert(libt::peer_ban_alert *p)
void Session::handleUrlSeedAlert(libt::url_seed_alert *p)
{
Logger::instance()->addMessage(tr("URL seed lookup failed for URL: '%1', message: %2").arg(QString::fromStdString(p->url)).arg(QString::fromStdString(p->message())), Log::CRITICAL);
Logger::instance()->addMessage(tr("URL seed lookup failed for URL: '%1', message: %2")
#if LIBTORRENT_VERSION_NUM >= 10100
.arg(QString::fromStdString(p->server_url()))
#else
.arg(QString::fromStdString(p->url))
#endif
.arg(QString::fromStdString(p->message())), Log::CRITICAL);
}
void Session::handleListenSucceededAlert(libt::listen_succeeded_alert *p)
@ -3554,8 +3705,113 @@ void Session::handleExternalIPAlert(libt::external_ip_alert *p)
Logger::instance()->addMessage(tr("External IP: %1", "e.g. External IP: 192.168.0.1").arg(p->external_address.to_string(ec).c_str()), Log::INFO);
}
#if LIBTORRENT_VERSION_NUM >= 10100
void Session::handleSessionStatsAlert(libt::session_stats_alert *p)
{
qreal interval = m_statsUpdateTimer.restart() / 1000.;
m_status.hasIncomingConnections = static_cast<bool>(p->values[m_metricIndices.net.hasIncomingConnections]);
const auto ipOverheadDownload = p->values[m_metricIndices.net.recvIPOverheadBytes];
const auto ipOverheadUpload = p->values[m_metricIndices.net.sentIPOverheadBytes];
const auto totalDownload = p->values[m_metricIndices.net.recvBytes] + ipOverheadDownload;
const auto totalUpload = p->values[m_metricIndices.net.sentBytes] + ipOverheadUpload;
const auto totalPayloadDownload = p->values[m_metricIndices.net.recvPayloadBytes];
const auto totalPayloadUpload = p->values[m_metricIndices.net.sentPayloadBytes];
const auto trackerDownload = p->values[m_metricIndices.net.recvTrackerBytes];
const auto trackerUpload = p->values[m_metricIndices.net.sentTrackerBytes];
const auto dhtDownload = p->values[m_metricIndices.dht.dhtBytesIn];
const auto dhtUpload = p->values[m_metricIndices.dht.dhtBytesOut];
auto calcRate = [interval](quint64 previous, quint64 current)
{
Q_ASSERT(current >= previous);
return static_cast<quint64>((current - previous) / interval);
};
m_status.payloadDownloadRate = calcRate(m_status.totalPayloadDownload, totalPayloadDownload);
m_status.payloadUploadRate = calcRate(m_status.totalPayloadUpload, totalPayloadUpload);
m_status.downloadRate = calcRate(m_status.totalDownload, totalDownload);
m_status.uploadRate = calcRate(m_status.totalUpload, totalUpload);
m_status.ipOverheadDownloadRate = calcRate(m_status.ipOverheadDownload, ipOverheadDownload);
m_status.ipOverheadUploadRate = calcRate(m_status.ipOverheadUpload, ipOverheadUpload);
m_status.dhtDownloadRate = calcRate(m_status.dhtDownload, dhtDownload);
m_status.dhtUploadRate = calcRate(m_status.dhtUpload, dhtUpload);
m_status.trackerDownloadRate = calcRate(m_status.trackerDownload, trackerDownload);
m_status.trackerUploadRate = calcRate(m_status.trackerUpload, trackerUpload);
m_status.totalDownload = totalDownload;
m_status.totalUpload = totalUpload;
m_status.totalPayloadDownload = totalPayloadDownload;
m_status.totalPayloadUpload = totalPayloadUpload;
m_status.ipOverheadDownload = ipOverheadDownload;
m_status.ipOverheadUpload = ipOverheadUpload;
m_status.trackerDownload = trackerDownload;
m_status.trackerUpload = trackerUpload;
m_status.dhtDownload = dhtDownload;
m_status.dhtUpload = dhtUpload;
m_status.totalWasted = p->values[m_metricIndices.net.recvRedundantBytes]
+ p->values[m_metricIndices.net.recvFailedBytes];
m_status.dhtNodes = p->values[m_metricIndices.dht.dhtNodes];
m_status.diskReadQueue = p->values[m_metricIndices.peer.numPeersUpDisk];
m_status.diskWriteQueue = p->values[m_metricIndices.peer.numPeersDownDisk];
m_status.peersCount = p->values[m_metricIndices.peer.numPeersConnected];
const auto numBlocksRead = p->values[m_metricIndices.disk.numBlocksRead];
m_cacheStatus.totalUsedBuffers = p->values[m_metricIndices.disk.diskBlocksInUse];
m_cacheStatus.readRatio = numBlocksRead > 0
? static_cast<qreal>(p->values[m_metricIndices.disk.numBlocksCacheHits]) / numBlocksRead
: -1;
m_cacheStatus.jobQueueLength = p->values[m_metricIndices.disk.queuedDiskJobs];
m_cacheStatus.averageJobTime = p->values[m_metricIndices.disk.diskJobTime];
emit statsUpdated();
}
#else
void Session::updateStats()
{
libt::session_status ss = m_nativeSession->status();
m_status.hasIncomingConnections = ss.has_incoming_connections;
m_status.payloadDownloadRate = ss.payload_download_rate;
m_status.payloadUploadRate = ss.payload_upload_rate;
m_status.downloadRate = ss.download_rate;
m_status.uploadRate = ss.upload_rate;
m_status.ipOverheadDownloadRate = ss.ip_overhead_download_rate;
m_status.ipOverheadUploadRate = ss.ip_overhead_upload_rate;
m_status.dhtDownloadRate = ss.dht_download_rate;
m_status.dhtUploadRate = ss.dht_upload_rate;
m_status.trackerDownloadRate = ss.tracker_download_rate;
m_status.trackerUploadRate = ss.tracker_upload_rate;
m_status.totalDownload = ss.total_download;
m_status.totalUpload = ss.total_upload;
m_status.totalPayloadDownload = ss.total_payload_download;
m_status.totalPayloadUpload = ss.total_payload_upload;
m_status.totalWasted = ss.total_redundant_bytes + ss.total_failed_bytes;
m_status.diskReadQueue = ss.disk_read_queue;
m_status.diskWriteQueue = ss.disk_write_queue;
m_status.dhtNodes = ss.dht_nodes;
m_status.peersCount = ss.num_peers;
libt::cache_status cs = m_nativeSession->get_cache_status();
m_cacheStatus.totalUsedBuffers = cs.total_used_buffers;
m_cacheStatus.readRatio = cs.blocks_read > 0
? static_cast<qreal>(cs.blocks_read_hit) / cs.blocks_read
: -1;
m_cacheStatus.jobQueueLength = cs.job_queue_length;
m_cacheStatus.averageJobTime = cs.average_job_time;
m_cacheStatus.queuedBytes = cs.queued_bytes; // it seems that it is constantly equal to zero
emit statsUpdated();
}
#endif
void Session::handleStateUpdateAlert(libt::state_update_alert *p)
{
#if LIBTORRENT_VERSION_NUM < 10100
updateStats();
#endif
foreach (const libt::torrent_status &status, p->status) {
TorrentHandle *const torrent = m_torrents.value(status.info_hash);
if (torrent)

73
src/base/bittorrent/session.h
View File

@ -33,6 +33,9 @@
#include <vector>
#include <libtorrent/version.hpp>
#if LIBTORRENT_VERSION_NUM >= 10100
#include <QElapsedTimer>
#endif
#include <QFile>
#include <QHash>
#include <QMap>
@ -49,6 +52,8 @@
#include "base/tristatebool.h"
#include "base/types.h"
#include "addtorrentparams.h"
#include "cachestatus.h"
#include "sessionstatus.h"
#include "torrentinfo.h"
namespace libtorrent
@ -56,15 +61,12 @@ namespace libtorrent
class session;
struct torrent_handle;
class entry;
struct add_torrent_params;
struct ip_filter;
struct pe_settings;
#if LIBTORRENT_VERSION_NUM < 10100
struct session_settings;
#else
struct settings_pack;
#endif
struct session_status;
class alert;
struct torrent_alert;
@ -98,6 +100,9 @@ namespace libtorrent
struct listen_succeeded_alert;
struct listen_failed_alert;
struct external_ip_alert;
#if LIBTORRENT_VERSION_NUM >= 10100
struct session_stats_alert;
#endif
}
class QThread;
@ -127,8 +132,6 @@ enum TorrentExportFolder
namespace BitTorrent
{
class InfoHash;
class CacheStatus;
class SessionStatus;
class TorrentHandle;
class Tracker;
class MagnetUri;
@ -147,6 +150,49 @@ namespace BitTorrent
uint nbErrored = 0;
};
#if LIBTORRENT_VERSION_NUM >= 10100
struct SessionMetricIndices
{
struct
{
int hasIncomingConnections = 0;
int sentPayloadBytes = 0;
int recvPayloadBytes = 0;
int sentBytes = 0;
int recvBytes = 0;
int sentIPOverheadBytes = 0;
int recvIPOverheadBytes = 0;
int sentTrackerBytes = 0;
int recvTrackerBytes = 0;
int recvRedundantBytes = 0;
int recvFailedBytes = 0;
} net;
struct
{
int numPeersConnected = 0;
int numPeersUpDisk = 0;
int numPeersDownDisk = 0;
} peer;
struct
{
int dhtBytesIn = 0;
int dhtBytesOut = 0;
int dhtNodes = 0;
} dht;
struct
{
int diskBlocksInUse = 0;
int numBlocksRead = 0;
int numBlocksCacheHits = 0;
int queuedDiskJobs = 0;
int diskJobTime = 0;
} disk;
};
#endif
class Session : public QObject
{
Q_OBJECT
@ -324,8 +370,8 @@ namespace BitTorrent
TorrentStatusReport torrentStatusReport() const;
bool hasActiveTorrents() const;
bool hasUnfinishedTorrents() const;
SessionStatus status() const;
CacheStatus cacheStatus() const;
const SessionStatus &status() const;
const CacheStatus &cacheStatus() const;
quint64 getAlltimeDL() const;
quint64 getAlltimeUL() const;
bool isListening() const;
@ -371,6 +417,7 @@ namespace BitTorrent
void handleTorrentTrackerAuthenticationRequired(TorrentHandle *const torrent, const QString &trackerUrl);
signals:
void statsUpdated();
void torrentsUpdated();
void addTorrentFailed(const QString &error);
void torrentAdded(BitTorrent::TorrentHandle *const torrent);
@ -436,7 +483,9 @@ namespace BitTorrent
void adjustLimits(libtorrent::session_settings &sessionSettings);
#else
void configure(libtorrent::settings_pack &settingsPack);
void configurePeerClasses();
void adjustLimits(libtorrent::settings_pack &settingsPack);
void initMetrics();
#endif
void adjustLimits();
void processBannedIPs(libtorrent::ip_filter &filter);
@ -475,6 +524,9 @@ namespace BitTorrent
void handleListenSucceededAlert(libtorrent::listen_succeeded_alert *p);
void handleListenFailedAlert(libtorrent::listen_failed_alert *p);
void handleExternalIPAlert(libtorrent::external_ip_alert *p);
#if LIBTORRENT_VERSION_NUM >= 10100
void handleSessionStatsAlert(libtorrent::session_stats_alert *p);
#endif
void createTorrentHandle(const libtorrent::torrent_handle &nativeHandle);
@ -482,6 +534,7 @@ namespace BitTorrent
#if LIBTORRENT_VERSION_NUM < 10100
void dispatchAlerts(libtorrent::alert *alertPtr);
void updateStats();
#endif
void getPendingAlerts(std::vector<libtorrent::alert *> &out, ulong time = 0);
@ -598,8 +651,14 @@ namespace BitTorrent
QMutex m_alertsMutex;
QWaitCondition m_alertsWaitCondition;
std::vector<libtorrent::alert *> m_alerts;
#else
SessionMetricIndices m_metricIndices;
QElapsedTimer m_statsUpdateTimer;
#endif
SessionStatus m_status;
CacheStatus m_cacheStatus;
QNetworkConfigurationManager m_networkManager;
static Session *m_instance;

136
src/base/bittorrent/sessionstatus.cpp
View File

@ -1,136 +0,0 @@
/*
* Bittorrent Client using Qt and libtorrent.
* Copyright (C) 2015 Vladimir Golovnev <glassez@yandex.ru>
*
* 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 this program with the OpenSSL project's "OpenSSL" library (or with
* modified versions of it that use the same license as the "OpenSSL" library),
* and distribute the linked executables. 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), 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.
*/
#include "sessionstatus.h"
using namespace BitTorrent;
SessionStatus::SessionStatus(const libtorrent::session_status &nativeStatus)
: m_nativeStatus(nativeStatus)
{
}
bool SessionStatus::hasIncomingConnections() const
{
return m_nativeStatus.has_incoming_connections;
}
int SessionStatus::payloadDownloadRate() const
{
return m_nativeStatus.payload_download_rate;
}
int SessionStatus::payloadUploadRate() const
{
return m_nativeStatus.payload_upload_rate;
}
int SessionStatus::downloadRate() const
{
return m_nativeStatus.download_rate;
}
int SessionStatus::uploadRate() const
{
return m_nativeStatus.upload_rate;
}
int SessionStatus::ipOverheadDownloadRate() const
{
return m_nativeStatus.ip_overhead_download_rate;
}
int SessionStatus::ipOverheadUploadRate() const
{
return m_nativeStatus.ip_overhead_upload_rate;
}
int SessionStatus::dhtDownloadRate() const
{
return m_nativeStatus.dht_download_rate;
}
int SessionStatus::dhtUploadRate() const
{
return m_nativeStatus.dht_upload_rate;
}
int SessionStatus::trackerDownloadRate() const
{
return m_nativeStatus.tracker_download_rate;
}
int SessionStatus::trackerUploadRate() const
{
return m_nativeStatus.tracker_upload_rate;
}
qlonglong SessionStatus::totalDownload() const
{
return m_nativeStatus.total_download;
}
qlonglong SessionStatus::totalUpload() const
{
return m_nativeStatus.total_upload;
}
qlonglong SessionStatus::totalPayloadDownload() const
{
return m_nativeStatus.total_payload_download;
}
qlonglong SessionStatus::totalPayloadUpload() const
{
return m_nativeStatus.total_payload_upload;
}
qlonglong SessionStatus::totalWasted() const
{
return (m_nativeStatus.total_redundant_bytes + m_nativeStatus.total_failed_bytes);
}
int SessionStatus::diskReadQueue() const
{
return m_nativeStatus.disk_read_queue;
}
int SessionStatus::diskWriteQueue() const
{
return m_nativeStatus.disk_write_queue;
}
int SessionStatus::dhtNodes() const
{
return m_nativeStatus.dht_nodes;
}
int SessionStatus::peersCount() const
{
return m_nativeStatus.num_peers;
}

61
src/base/bittorrent/sessionstatus.h
View File

@ -1,6 +1,6 @@
/*
* Bittorrent Client using Qt and libtorrent.
* Copyright (C) 2015 Vladimir Golovnev <glassez@yandex.ru>
* Copyright (C) 2015, 2017 Vladimir Golovnev <glassez@yandex.ru>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
@ -29,50 +29,49 @@
#ifndef BITTORRENT_SESSIONSTATUS_H
#define BITTORRENT_SESSIONSTATUS_H
#include <libtorrent/session_status.hpp>
#include <QtGlobal>
namespace BitTorrent
{
class SessionStatus
struct SessionStatus
{
public:
SessionStatus(const libtorrent::session_status &nativeStatus);
bool hasIncomingConnections = false;
bool hasIncomingConnections() const;
// Return current download rate for the BT
// Current download rate for the BT
// session. Payload means that it only take into
// account "useful" part of the rate
int payloadDownloadRate() const;
quint64 payloadDownloadRate = 0;
// Return current upload rate for the BT
// Current upload rate for the BT
// session. Payload means that it only take into
// account "useful" part of the rate
int payloadUploadRate() const;
quint64 payloadUploadRate = 0;
// Additional download/upload rates
int uploadRate() const;
int downloadRate() const;
int ipOverheadUploadRate() const;
int ipOverheadDownloadRate() const;
int dhtUploadRate() const;
int dhtDownloadRate() const;
int trackerUploadRate() const;
int trackerDownloadRate() const;
quint64 uploadRate = 0;
quint64 downloadRate = 0;
quint64 ipOverheadUploadRate = 0;
quint64 ipOverheadDownloadRate = 0;
quint64 dhtUploadRate = 0;
quint64 dhtDownloadRate = 0;
quint64 trackerUploadRate = 0;
quint64 trackerDownloadRate = 0;
qlonglong totalDownload() const;
qlonglong totalUpload() const;
qlonglong totalPayloadDownload() const;
qlonglong totalPayloadUpload() const;
qlonglong totalWasted() const;
int diskReadQueue() const;
int diskWriteQueue() const;
int dhtNodes() const;
int peersCount() const;
private:
libtorrent::session_status m_nativeStatus;
quint64 totalDownload = 0;
quint64 totalUpload = 0;
quint64 totalPayloadDownload = 0;
quint64 totalPayloadUpload = 0;
quint64 ipOverheadUpload = 0;
quint64 ipOverheadDownload = 0;
quint64 dhtUpload = 0;
quint64 dhtDownload = 0;
quint64 trackerUpload = 0;
quint64 trackerDownload = 0;
quint64 totalWasted = 0;
quint64 diskReadQueue = 0;
quint64 diskWriteQueue = 0;
quint64 dhtNodes = 0;
quint64 peersCount = 0;
};
}

45
src/base/bittorrent/torrenthandle.cpp
View File

@ -148,8 +148,10 @@ QString TorrentState::toString() const
return QLatin1String("checkingDL");
case ForcedDownloading:
return QLatin1String("forcedDL");
#if LIBTORRENT_VERSION_NUM < 10100
case QueuedForChecking:
return QLatin1String("queuedForChecking");
#endif
case CheckingResumeData:
return QLatin1String("checkingResumeData");
default:
@ -659,9 +661,12 @@ bool TorrentHandle::isQueued() const
bool TorrentHandle::isChecking() const
{
return ((m_nativeStatus.state == libt::torrent_status::queued_for_checking)
|| (m_nativeStatus.state == libt::torrent_status::checking_files)
|| (m_nativeStatus.state == libt::torrent_status::checking_resume_data));
return ((m_nativeStatus.state == libt::torrent_status::checking_files)
|| (m_nativeStatus.state == libt::torrent_status::checking_resume_data)
#if LIBTORRENT_VERSION_NUM < 10100
|| (m_nativeStatus.state == libt::torrent_status::queued_for_checking)
#endif
);
}
bool TorrentHandle::isDownloading() const
@ -800,9 +805,11 @@ void TorrentHandle::updateState()
case libt::torrent_status::allocating:
m_state = TorrentState::Allocating;
break;
#if LIBTORRENT_VERSION_NUM < 10100
case libt::torrent_status::queued_for_checking:
m_state = TorrentState::QueuedForChecking;
break;
#endif
case libt::torrent_status::checking_resume_data:
m_state = TorrentState::CheckingResumeData;
break;
@ -838,7 +845,11 @@ bool TorrentHandle::hasMissingFiles() const
bool TorrentHandle::hasError() const
{
#if LIBTORRENT_VERSION_NUM < 10100
return (m_nativeStatus.paused && !m_nativeStatus.error.empty());
#else
return (m_nativeStatus.paused && m_nativeStatus.errc);
#endif
}
bool TorrentHandle::hasFilteredPieces() const
@ -860,7 +871,11 @@ int TorrentHandle::queuePosition() const
QString TorrentHandle::error() const
{
#if LIBTORRENT_VERSION_NUM < 10100
return QString::fromStdString(m_nativeStatus.error);
#else
return QString::fromStdString(m_nativeStatus.errc.message());
#endif
}
qlonglong TorrentHandle::totalDownload() const
@ -1317,11 +1332,13 @@ void TorrentHandle::moveStorage(const QString &newPath)
}
}
#if LIBTORRENT_VERSION_NUM < 10100
void TorrentHandle::setTrackerLogin(const QString &username, const QString &password)
{
m_nativeHandle.set_tracker_login(std::string(username.toLocal8Bit().constData())
, std::string(password.toLocal8Bit().constData()));
}
#endif
void TorrentHandle::renameFile(int index, const QString &name)
{
@ -1368,7 +1385,11 @@ void TorrentHandle::handleStorageMovedAlert(libtorrent::storage_moved_alert *p)
return;
}
#if LIBTORRENT_VERSION_NUM < 10100
const QString newPath = QString::fromStdString(p->path);
#else
const QString newPath(p->storage_path());
#endif
if (newPath != m_newPath) {
qWarning() << Q_FUNC_INFO << ": New path doesn't match a path in a queue.";
return;
@ -1418,7 +1439,11 @@ void TorrentHandle::handleStorageMovedFailedAlert(libtorrent::storage_moved_fail
void TorrentHandle::handleTrackerReplyAlert(libtorrent::tracker_reply_alert *p)
{
#if LIBTORRENT_VERSION_NUM < 10100
QString trackerUrl = QString::fromStdString(p->url);
#else
QString trackerUrl(p->tracker_url());
#endif
qDebug("Received a tracker reply from %s (Num_peers = %d)", qPrintable(trackerUrl), p->num_peers);
// Connection was successful now. Remove possible old errors
m_trackerInfos[trackerUrl].lastMessage.clear(); // Reset error/warning message
@ -1429,8 +1454,13 @@ void TorrentHandle::handleTrackerReplyAlert(libtorrent::tracker_reply_alert *p)
void TorrentHandle::handleTrackerWarningAlert(libtorrent::tracker_warning_alert *p)
{
#if LIBTORRENT_VERSION_NUM < 10100
QString trackerUrl = QString::fromStdString(p->url);
QString message = QString::fromStdString(p->msg);
#else
QString trackerUrl(p->tracker_url());
QString message = QString::fromStdString(p->message());
#endif
qDebug("Received a tracker warning for %s: %s", qPrintable(trackerUrl), qPrintable(message));
// Connection was successful now but there is a warning message
m_trackerInfos[trackerUrl].lastMessage = message; // Store warning message
@ -1440,8 +1470,13 @@ void TorrentHandle::handleTrackerWarningAlert(libtorrent::tracker_warning_alert
void TorrentHandle::handleTrackerErrorAlert(libtorrent::tracker_error_alert *p)
{
#if LIBTORRENT_VERSION_NUM < 10100
QString trackerUrl = QString::fromStdString(p->url);
QString message = QString::fromStdString(p->msg);
#else
QString trackerUrl(p->tracker_url());
QString message = QString::fromStdString(p->message());
#endif
qDebug("Received a tracker error for %s: %s", qPrintable(trackerUrl), qPrintable(message));
m_trackerInfos[trackerUrl].lastMessage = message;
@ -1578,7 +1613,11 @@ void TorrentHandle::handleFastResumeRejectedAlert(libtorrent::fastresume_rejecte
void TorrentHandle::handleFileRenamedAlert(libtorrent::file_renamed_alert *p)
{
#if LIBTORRENT_VERSION_NUM < 10100
QString newName = Utils::Fs::fromNativePath(QString::fromStdString(p->name));
#else
QString newName = Utils::Fs::fromNativePath(p->new_name());
#endif
// TODO: Check this!
if (filesCount() > 1) {

4
src/base/bittorrent/torrenthandle.h
View File

@ -140,7 +140,9 @@ namespace BitTorrent
CheckingUploading,
CheckingDownloading,
#if LIBTORRENT_VERSION_NUM < 10100
QueuedForChecking,
#endif
CheckingResumeData,
PausedDownloading,
@ -331,7 +333,9 @@ namespace BitTorrent
void forceReannounce(int index = -1);
void forceDHTAnnounce();
void forceRecheck();
#if LIBTORRENT_VERSION_NUM < 10100
void setTrackerLogin(const QString &username, const QString &password);
#endif
void renameFile(int index, const QString &name);
bool saveTorrentFile(const QString &path);
void prioritizeFiles(const QVector<int> &priorities);

2
src/base/bittorrent/torrentinfo.cpp
View File

@ -186,7 +186,7 @@ qlonglong TorrentInfo::fileSize(int index) const
qlonglong TorrentInfo::fileOffset(int index) const
{
if (!isValid()) return -1;
return m_nativeInfo->file_at(index).offset;
return m_nativeInfo->files().file_offset(index);
}
QList<TrackerEntry> TorrentInfo::trackers() const

20
src/gui/mainwindow.cpp
View File

@ -91,7 +91,9 @@
#include "rss/rsswidget.h"
#include "about_imp.h"
#include "optionsdlg.h"
#if LIBTORRENT_VERSION_NUM < 10100
#include "trackerlogin.h"
#endif
#include "lineedit.h"
#include "executionlog.h"
#include "hidabletabwidget.h"
@ -1317,15 +1319,19 @@ void MainWindow::addUnauthenticatedTracker(const QPair<BitTorrent::TorrentHandle
// Called when a tracker requires authentication
void MainWindow::trackerAuthenticationRequired(BitTorrent::TorrentHandle *const torrent)
{
#if LIBTORRENT_VERSION_NUM < 10100
if (m_unauthenticatedTrackers.indexOf(qMakePair(torrent, torrent->currentTracker())) < 0)
// Tracker login
new trackerLogin(this, torrent);
#else
Q_UNUSED(torrent);
#endif
}
// Check connection status and display right icon
void MainWindow::updateGUI()
{
BitTorrent::SessionStatus status = BitTorrent::Session::instance()->status();
const BitTorrent::SessionStatus &status = BitTorrent::Session::instance()->status();
// update global informations
if (m_systrayIcon) {
@ -1334,24 +1340,24 @@ void MainWindow::updateGUI()
html += "qBittorrent";
html += "</div>";
html += "<div style='vertical-align: baseline; height: 18px;'>";
html += "<img src=':/icons/skin/download.png' height='14'/>&nbsp;" + tr("DL speed: %1", "e.g: Download speed: 10 KiB/s").arg(Utils::Misc::friendlyUnit(status.payloadDownloadRate(), true));
html += "<img src=':/icons/skin/download.png' height='14'/>&nbsp;" + tr("DL speed: %1", "e.g: Download speed: 10 KiB/s").arg(Utils::Misc::friendlyUnit(status.payloadDownloadRate, true));
html += "</div>";
html += "<div style='vertical-align: baseline; height: 18px;'>";
html += "<img src=':/icons/skin/seeding.png' height='14'/>&nbsp;" + tr("UP speed: %1", "e.g: Upload speed: 10 KiB/s").arg(Utils::Misc::friendlyUnit(status.payloadUploadRate(), true));
html += "<img src=':/icons/skin/seeding.png' height='14'/>&nbsp;" + tr("UP speed: %1", "e.g: Upload speed: 10 KiB/s").arg(Utils::Misc::friendlyUnit(status.payloadUploadRate, true));
html += "</div>";
#else
// OSes such as Windows do not support html here
QString html = tr("DL speed: %1", "e.g: Download speed: 10 KiB/s").arg(Utils::Misc::friendlyUnit(status.payloadDownloadRate(), true));
QString html = tr("DL speed: %1", "e.g: Download speed: 10 KiB/s").arg(Utils::Misc::friendlyUnit(status.payloadDownloadRate, true));
html += "\n";
html += tr("UP speed: %1", "e.g: Upload speed: 10 KiB/s").arg(Utils::Misc::friendlyUnit(status.payloadUploadRate(), true));
html += tr("UP speed: %1", "e.g: Upload speed: 10 KiB/s").arg(Utils::Misc::friendlyUnit(status.payloadUploadRate, true));
#endif
m_systrayIcon->setToolTip(html); // tray icon
}
if (m_displaySpeedInTitle) {
setWindowTitle(tr("[D: %1, U: %2] qBittorrent %3", "D = Download; U = Upload; %3 is qBittorrent version")
.arg(Utils::Misc::friendlyUnit(status.payloadDownloadRate(), true))
.arg(Utils::Misc::friendlyUnit(status.payloadUploadRate(), true))
.arg(Utils::Misc::friendlyUnit(status.payloadDownloadRate, true))
.arg(Utils::Misc::friendlyUnit(status.payloadUploadRate, true))
.arg(QBT_VERSION));
}
}

25
src/gui/properties/speedwidget.cpp
View File

@ -45,7 +45,8 @@
ComboBoxMenuButton::ComboBoxMenuButton(QWidget *parent, QMenu *menu)
: QComboBox(parent)
, m_menu(menu)
{}
{
}
void ComboBoxMenuButton::showPopup()
{
@ -134,20 +135,20 @@ void SpeedWidget::update()
{
while (m_isUpdating) {
BitTorrent::SessionStatus btStatus = BitTorrent::Session::instance()->status();
const BitTorrent::SessionStatus &btStatus = BitTorrent::Session::instance()->status();
SpeedPlotView::PointData point;
point.x = QDateTime::currentDateTime().toTime_t();
point.y[SpeedPlotView::UP] = btStatus.uploadRate();
point.y[SpeedPlotView::DOWN] = btStatus.downloadRate();
point.y[SpeedPlotView::PAYLOAD_UP] = btStatus.payloadUploadRate();
point.y[SpeedPlotView::PAYLOAD_DOWN] = btStatus.payloadDownloadRate();
point.y[SpeedPlotView::OVERHEAD_UP] = btStatus.ipOverheadUploadRate();
point.y[SpeedPlotView::OVERHEAD_DOWN] = btStatus.ipOverheadDownloadRate();
point.y[SpeedPlotView::DHT_UP] = btStatus.dhtUploadRate();
point.y[SpeedPlotView::DHT_DOWN] = btStatus.dhtDownloadRate();
point.y[SpeedPlotView::TRACKER_UP] = btStatus.trackerUploadRate();
point.y[SpeedPlotView::TRACKER_DOWN] = btStatus.trackerDownloadRate();
point.y[SpeedPlotView::UP] = btStatus.uploadRate;
point.y[SpeedPlotView::DOWN] = btStatus.downloadRate;
point.y[SpeedPlotView::PAYLOAD_UP] = btStatus.payloadUploadRate;
point.y[SpeedPlotView::PAYLOAD_DOWN] = btStatus.payloadDownloadRate;
point.y[SpeedPlotView::OVERHEAD_UP] = btStatus.ipOverheadUploadRate;
point.y[SpeedPlotView::OVERHEAD_DOWN] = btStatus.ipOverheadDownloadRate;
point.y[SpeedPlotView::DHT_UP] = btStatus.dhtUploadRate;
point.y[SpeedPlotView::DHT_DOWN] = btStatus.dhtDownloadRate;
point.y[SpeedPlotView::TRACKER_UP] = btStatus.trackerUploadRate;
point.y[SpeedPlotView::TRACKER_DOWN] = btStatus.trackerDownloadRate;
m_plot->pushPoint(point);

122
src/gui/statsdialog.cpp
View File

@ -1,6 +1,6 @@
/*
* Bittorrent Client using Qt4 and libtorrent.
* Copyright (C) 2013 Nick Tiskov
* Bittorrent Client using Qt and libtorrent.
* Copyright (C) 2013 Nick Tiskov <daymansmail@gmail.com>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
@ -24,84 +24,82 @@
* modify file(s), 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.
*
* Contact : daymansmail@gmail.com
*/
#include "statsdialog.h"
#include "ui_statsdialog.h"
#include "base/utils/misc.h"
#include "base/utils/string.h"
#include "base/bittorrent/cachestatus.h"
#include "base/bittorrent/session.h"
#include "base/bittorrent/sessionstatus.h"
#include "base/bittorrent/cachestatus.h"
#include "base/bittorrent/torrenthandle.h"
#include "base/utils/misc.h"
#include "base/utils/string.h"
#include "ui_statsdialog.h"
StatsDialog::StatsDialog(QWidget *parent)
: QDialog(parent)
, ui(new Ui::StatsDialog)
, m_ui(new Ui::StatsDialog)
{
ui->setupUi(this);
setAttribute(Qt::WA_DeleteOnClose);
connect(ui->buttonBox, SIGNAL(accepted()), SLOT(close()));
updateUI();
t = new QTimer(this);
t->setInterval(1500);
connect(t, SIGNAL(timeout()), SLOT(updateUI()));
t->start();
m_ui->setupUi(this);
setAttribute(Qt::WA_DeleteOnClose);
connect(m_ui->buttonBox, &QDialogButtonBox::accepted, this, &StatsDialog::close);
show();
update();
connect(BitTorrent::Session::instance(), &BitTorrent::Session::statsUpdated
, this, &StatsDialog::update);
show();
}
StatsDialog::~StatsDialog() {
t->stop();
delete t;
delete ui;
StatsDialog::~StatsDialog()
{
delete m_ui;
}
void StatsDialog::updateUI() {
BitTorrent::SessionStatus ss = BitTorrent::Session::instance()->status();
BitTorrent::CacheStatus cs = BitTorrent::Session::instance()->cacheStatus();
void StatsDialog::update()
{
const BitTorrent::SessionStatus &ss = BitTorrent::Session::instance()->status();
const BitTorrent::CacheStatus &cs = BitTorrent::Session::instance()->cacheStatus();
// Alltime DL/UL
quint64 atd = BitTorrent::Session::instance()->getAlltimeDL();
quint64 atu = BitTorrent::Session::instance()->getAlltimeUL();
ui->labelAlltimeDL->setText(Utils::Misc::friendlyUnit(atd));
ui->labelAlltimeUL->setText(Utils::Misc::friendlyUnit(atu));
// Total waste (this session)
ui->labelWaste->setText(Utils::Misc::friendlyUnit(ss.totalWasted()));
// Global ratio
ui->labelGlobalRatio->setText(
( atd > 0 && atu > 0 ) ?
Utils::String::fromDouble((qreal)atu / (qreal)atd, 2) :
"-"
);
// Cache hits
qreal readRatio = cs.readRatio();
ui->labelCacheHits->setText((readRatio >= 0) ? Utils::String::fromDouble(100 * readRatio, 2) : "-");
// Buffers size
ui->labelTotalBuf->setText(Utils::Misc::friendlyUnit(cs.totalUsedBuffers() * 16 * 1024));
// Disk overload (100%) equivalent
// From lt manual: disk_write_queue and disk_read_queue are the number of peers currently waiting on a disk write or disk read
// to complete before it receives or sends any more data on the socket. It's a metric of how disk bound you are.
// Alltime DL/UL
quint64 atd = BitTorrent::Session::instance()->getAlltimeDL();
quint64 atu = BitTorrent::Session::instance()->getAlltimeUL();
m_ui->labelAlltimeDL->setText(Utils::Misc::friendlyUnit(atd));
m_ui->labelAlltimeUL->setText(Utils::Misc::friendlyUnit(atu));
// Total waste (this session)
m_ui->labelWaste->setText(Utils::Misc::friendlyUnit(ss.totalWasted));
// Global ratio
m_ui->labelGlobalRatio->setText(
((atd > 0) && (atu > 0))
? Utils::String::fromDouble((qreal)atu / (qreal)atd, 2)
: "-");
// Cache hits
qreal readRatio = cs.readRatio;
m_ui->labelCacheHits->setText((readRatio >= 0) ? Utils::String::fromDouble(100 * readRatio, 2) : "-");
// Buffers size
m_ui->labelTotalBuf->setText(Utils::Misc::friendlyUnit(cs.totalUsedBuffers * 16 * 1024));
// Disk overload (100%) equivalent
// From lt manual: disk_write_queue and disk_read_queue are the number of peers currently waiting on a disk write or disk read
// to complete before it receives or sends any more data on the socket. It's a metric of how disk bound you are.
// num_peers is not reliable (adds up peers, which didn't even overcome tcp handshake)
quint32 peers = 0;
foreach (BitTorrent::TorrentHandle *const torrent, BitTorrent::Session::instance()->torrents())
peers += torrent->peersCount();
// num_peers is not reliable (adds up peers, which didn't even overcome tcp handshake)
quint32 peers = 0;
foreach (BitTorrent::TorrentHandle *const torrent, BitTorrent::Session::instance()->torrents())
peers += torrent->peersCount();
ui->labelWriteStarve->setText(QString("%1%").arg(((ss.diskWriteQueue() > 0) && (peers > 0))
? Utils::String::fromDouble((100. * ss.diskWriteQueue()) / peers, 2)
: "0"));
ui->labelReadStarve->setText(QString("%1%").arg(((ss.diskReadQueue() > 0) && (peers > 0))
? Utils::String::fromDouble((100. * ss.diskReadQueue()) / peers, 2)
: "0"));
// Disk queues
ui->labelQueuedJobs->setText(QString::number(cs.jobQueueLength()));
ui->labelJobsTime->setText(tr("%1 ms", "18 milliseconds").arg(cs.averageJobTime()));
ui->labelQueuedBytes->setText(Utils::Misc::friendlyUnit(cs.queuedBytes()));
m_ui->labelWriteStarve->setText(QString("%1%")
.arg(((ss.diskWriteQueue > 0) && (peers > 0))
? Utils::String::fromDouble((100. * ss.diskWriteQueue) / peers, 2)
: "0"));
m_ui->labelReadStarve->setText(QString("%1%")
.arg(((ss.diskReadQueue > 0) && (peers > 0))
? Utils::String::fromDouble((100. * ss.diskReadQueue) / peers, 2)
: "0"));
// Disk queues
m_ui->labelQueuedJobs->setText(QString::number(cs.jobQueueLength));
m_ui->labelJobsTime->setText(tr("%1 ms", "18 milliseconds").arg(cs.averageJobTime));
m_ui->labelQueuedBytes->setText(Utils::Misc::friendlyUnit(cs.queuedBytes));
// Total connected peers
ui->labelPeers->setText(QString::number(ss.peersCount()));
// Total connected peers
m_ui->labelPeers->setText(QString::number(ss.peersCount));
}

24
src/gui/statsdialog.h
View File

@ -1,6 +1,6 @@
/*
* Bittorrent Client using Qt4 and libtorrent.
* Copyright (C) 2013 Nick Tiskov
* Bittorrent Client using Qt and libtorrent.
* Copyright (C) 2013 Nick Tiskov <daymansmail@gmail.com>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
@ -24,33 +24,31 @@
* modify file(s), 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.
*
* Contact : daymansmail@gmail.com
*/
#ifndef STATSDIALOG_H
#define STATSDIALOG_H
#include <QDialog>
#include <QTimer>
namespace Ui {
class StatsDialog;
namespace Ui
{
class StatsDialog;
}
class StatsDialog : public QDialog {
Q_OBJECT
class StatsDialog: public QDialog
{
Q_OBJECT
public:
explicit StatsDialog(QWidget *parent);
~StatsDialog();
~StatsDialog() override;
private slots:
void updateUI();
void update();
private:
Ui::StatsDialog *ui;
QTimer* t;
Ui::StatsDialog *m_ui;
};
#endif // STATSDIALOG_H

39
src/gui/statusbar.cpp
View File

@ -34,7 +34,6 @@
#include <QStatusBar>
#include <QFrame>
#include <QLabel>
#include <QTimer>
#include <QPushButton>
#include <QHBoxLayout>
#include <QFontMetrics>
@ -135,10 +134,9 @@ StatusBar::StatusBar(QStatusBar *bar)
bar->adjustSize();
// Is DHT enabled
m_DHTLbl->setVisible(session->isDHTEnabled());
m_refreshTimer = new QTimer(bar);
refreshStatusBar();
connect(m_refreshTimer, SIGNAL(timeout()), this, SLOT(refreshStatusBar()));
m_refreshTimer->start(1500);
connect(BitTorrent::Session::instance(), &BitTorrent::Session::statsUpdated
, this, &StatusBar::refreshStatusBar);
}
StatusBar::~StatusBar()
@ -167,19 +165,16 @@ void StatusBar::showRestartRequired()
Logger::instance()->addMessage(tr("qBittorrent was just updated and needs to be restarted for the changes to be effective."), Log::CRITICAL);
}
void StatusBar::stopTimer()
void StatusBar::updateConnectionStatus()
{
m_refreshTimer->stop();
}
const BitTorrent::SessionStatus &sessionStatus = BitTorrent::Session::instance()->status();
void StatusBar::updateConnectionStatus(const BitTorrent::SessionStatus &sessionStatus)
{
if (!BitTorrent::Session::instance()->isListening()) {
m_connecStatusLblIcon->setIcon(QIcon(QLatin1String(":/icons/skin/disconnected.png")));
m_connecStatusLblIcon->setToolTip(QLatin1String("<b>") + tr("Connection Status:") + QLatin1String("</b><br>") + tr("Offline. This usually means that qBittorrent failed to listen on the selected port for incoming connections."));
}
else {
if (sessionStatus.hasIncomingConnections()) {
if (sessionStatus.hasIncomingConnections) {
// Connection OK
m_connecStatusLblIcon->setIcon(QIcon(QLatin1String(":/icons/skin/connected.png")));
m_connecStatusLblIcon->setToolTip(QLatin1String("<b>") + tr("Connection Status:") + QLatin1String("</b><br>") + tr("Online"));
@ -191,39 +186,41 @@ void StatusBar::updateConnectionStatus(const BitTorrent::SessionStatus &sessionS
}
}
void StatusBar::updateDHTNodesNumber(const BitTorrent::SessionStatus &sessionStatus)
void StatusBar::updateDHTNodesNumber()
{
if (BitTorrent::Session::instance()->isDHTEnabled()) {
m_DHTLbl->setVisible(true);
m_DHTLbl->setText(tr("DHT: %1 nodes").arg(QString::number(sessionStatus.dhtNodes())));
m_DHTLbl->setText(tr("DHT: %1 nodes")
.arg(BitTorrent::Session::instance()->status().dhtNodes));
}
else {
m_DHTLbl->setVisible(false);
}
}
void StatusBar::updateSpeedLabels(const BitTorrent::SessionStatus &sessionStatus)
void StatusBar::updateSpeedLabels()
{
QString speedLbl = Utils::Misc::friendlyUnit(sessionStatus.payloadDownloadRate(), true);
const BitTorrent::SessionStatus &sessionStatus = BitTorrent::Session::instance()->status();
QString speedLbl = Utils::Misc::friendlyUnit(sessionStatus.payloadDownloadRate, true);
int speedLimit = BitTorrent::Session::instance()->downloadSpeedLimit();
if (speedLimit)
speedLbl += " [" + Utils::Misc::friendlyUnit(speedLimit, true) + "]";
speedLbl += " (" + Utils::Misc::friendlyUnit(sessionStatus.totalPayloadDownload()) + ")";
speedLbl += " (" + Utils::Misc::friendlyUnit(sessionStatus.totalPayloadDownload) + ")";
m_dlSpeedLbl->setText(speedLbl);
speedLimit = BitTorrent::Session::instance()->uploadSpeedLimit();
speedLbl = Utils::Misc::friendlyUnit(sessionStatus.payloadUploadRate(), true);
speedLbl = Utils::Misc::friendlyUnit(sessionStatus.payloadUploadRate, true);
if (speedLimit)
speedLbl += " [" + Utils::Misc::friendlyUnit(speedLimit, true) + "]";
speedLbl += " (" + Utils::Misc::friendlyUnit(sessionStatus.totalPayloadUpload()) + ")";
speedLbl += " (" + Utils::Misc::friendlyUnit(sessionStatus.totalPayloadUpload) + ")";
m_upSpeedLbl->setText(speedLbl);
}
void StatusBar::refreshStatusBar()
{
const BitTorrent::SessionStatus sessionStatus = BitTorrent::Session::instance()->status();
updateConnectionStatus(sessionStatus);
updateDHTNodesNumber(sessionStatus);
updateSpeedLabels(sessionStatus);
updateConnectionStatus();
updateDHTNodesNumber();
updateSpeedLabels();
}
void StatusBar::updateAltSpeedsBtn(bool alternative)

19
src/gui/statusbar.h
View File

@ -1,6 +1,6 @@
/*
* Bittorrent Client using Qt4 and libtorrent.
* Copyright (C) 2006 Christophe Dumez
* Bittorrent Client using Qt and libtorrent.
* Copyright (C) 2006 Christophe Dumez <chris@qbittorrent.org>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
@ -24,8 +24,6 @@
* modify file(s), 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.
*
* Contact : chris@qbittorrent.org
*/
#ifndef STATUSBAR_H
@ -36,13 +34,12 @@
class QStatusBar;
class QFrame;
class QLabel;
class QTimer;
class QPushButton;
class QHBoxLayout;
namespace BitTorrent
{
class SessionStatus;
struct SessionStatus;
}
class StatusBar: public QObject
@ -57,7 +54,6 @@ public:
public slots:
void showRestartRequired();
void stopTimer();
void refreshStatusBar();
void updateAltSpeedsBtn(bool alternative);
void toggleAlternativeSpeeds();
@ -65,6 +61,10 @@ public slots:
void capUploadSpeed();
private:
void updateConnectionStatus();
void updateDHTNodesNumber();
void updateSpeedLabels();
QStatusBar *m_bar;
QPushButton *m_dlSpeedLbl;
QPushButton *m_upSpeedLbl;
@ -75,13 +75,8 @@ private:
QFrame *m_statusSep4;
QPushButton *m_connecStatusLblIcon;
QPushButton *m_altSpeedsBtn;
QTimer *m_refreshTimer;
QWidget *m_container;
QHBoxLayout *m_layout;
void updateConnectionStatus(const BitTorrent::SessionStatus &sessionStatus);
void updateDHTNodesNumber(const BitTorrent::SessionStatus &sessionStatus);
void updateSpeedLabels(const BitTorrent::SessionStatus &sessionStatus);
};
#endif // STATUSBAR_H

4
src/gui/torrentmodel.cpp
View File

@ -338,7 +338,9 @@ QIcon getIconByState(BitTorrent::TorrentState state)
return getQueuedIcon();
case BitTorrent::TorrentState::CheckingDownloading:
case BitTorrent::TorrentState::CheckingUploading:
#if LIBTORRENT_VERSION_NUM < 10100
case BitTorrent::TorrentState::QueuedForChecking:
#endif
case BitTorrent::TorrentState::CheckingResumeData:
return getCheckingIcon();
case BitTorrent::TorrentState::Unknown:
@ -391,7 +393,9 @@ QColor getColorByState(BitTorrent::TorrentState state)
case BitTorrent::TorrentState::QueuedUploading:
case BitTorrent::TorrentState::CheckingDownloading:
case BitTorrent::TorrentState::CheckingUploading:
#if LIBTORRENT_VERSION_NUM < 10100
case BitTorrent::TorrentState::QueuedForChecking:
#endif
case BitTorrent::TorrentState::CheckingResumeData:
if (!dark)
return QColor(0, 128, 128); // Teal

6
src/gui/trackerlogin.cpp
View File

@ -28,9 +28,11 @@
* Contact : chris@qbittorrent.org
*/
#include "base/bittorrent/torrenthandle.h"
#include "trackerlogin.h"
#include <libtorrent/version.hpp>
#include "base/bittorrent/torrenthandle.h"
trackerLogin::trackerLogin(QWidget *parent, BitTorrent::TorrentHandle *const torrent)
: QDialog(parent)
, m_torrent(torrent)
@ -47,7 +49,9 @@ trackerLogin::~trackerLogin() {}
void trackerLogin::on_loginButton_clicked() {
// login
#if LIBTORRENT_VERSION_NUM < 10100
m_torrent->setTrackerLogin(lineUsername->text(), linePasswd->text());
#endif
close();
}

2
src/gui/transferlistdelegate.cpp
View File

@ -258,9 +258,11 @@ QString TransferListDelegate::getStatusString(const int state) const
case BitTorrent::TorrentState::CheckingUploading:
str = tr("Checking", "Torrent local data is being checked");
break;
#if LIBTORRENT_VERSION_NUM < 10100
case BitTorrent::TorrentState::QueuedForChecking:
str = tr("Queued for checking", "i.e. torrent is queued for hash checking");
break;
#endif
case BitTorrent::TorrentState::CheckingResumeData:
str = tr("Checking resume data", "used when loading the torrents from disk after qbt is launched. It checks the correctness of the .fastresume file. Normally it is completed in a fraction of a second, unless loading many many torrents.");
break;

34
src/webui/btjson.cpp
View File

@ -676,12 +676,12 @@ QByteArray btjson::getTransferInfo()
QVariantMap getTranserInfoMap()
{
QVariantMap map;
BitTorrent::SessionStatus sessionStatus = BitTorrent::Session::instance()->status();
BitTorrent::CacheStatus cacheStatus = BitTorrent::Session::instance()->cacheStatus();
map[KEY_TRANSFER_DLSPEED] = sessionStatus.payloadDownloadRate();
map[KEY_TRANSFER_DLDATA] = sessionStatus.totalPayloadDownload();
map[KEY_TRANSFER_UPSPEED] = sessionStatus.payloadUploadRate();
map[KEY_TRANSFER_UPDATA] = sessionStatus.totalPayloadUpload();
const BitTorrent::SessionStatus &sessionStatus = BitTorrent::Session::instance()->status();
const BitTorrent::CacheStatus &cacheStatus = BitTorrent::Session::instance()->cacheStatus();
map[KEY_TRANSFER_DLSPEED] = sessionStatus.payloadDownloadRate;
map[KEY_TRANSFER_DLDATA] = sessionStatus.totalPayloadDownload;
map[KEY_TRANSFER_UPSPEED] = sessionStatus.payloadUploadRate;
map[KEY_TRANSFER_UPDATA] = sessionStatus.totalPayloadUpload;
map[KEY_TRANSFER_DLRATELIMIT] = BitTorrent::Session::instance()->downloadSpeedLimit();
map[KEY_TRANSFER_UPRATELIMIT] = BitTorrent::Session::instance()->uploadSpeedLimit();
@ -689,30 +689,30 @@ QVariantMap getTranserInfoMap()
quint64 atu = BitTorrent::Session::instance()->getAlltimeUL();
map[KEY_TRANSFER_ALLTIME_DL] = atd;
map[KEY_TRANSFER_ALLTIME_UL] = atu;
map[KEY_TRANSFER_TOTAL_WASTE_SESSION] = sessionStatus.totalWasted();
map[KEY_TRANSFER_TOTAL_WASTE_SESSION] = sessionStatus.totalWasted;
map[KEY_TRANSFER_GLOBAL_RATIO] = ( atd > 0 && atu > 0 ) ? Utils::String::fromDouble((qreal)atu / (qreal)atd, 2) : "-";
map[KEY_TRANSFER_TOTAL_PEER_CONNECTIONS] = sessionStatus.peersCount();
map[KEY_TRANSFER_TOTAL_PEER_CONNECTIONS] = sessionStatus.peersCount;
qreal readRatio = cacheStatus.readRatio();
qreal readRatio = cacheStatus.readRatio;
map[KEY_TRANSFER_READ_CACHE_HITS] = (readRatio >= 0) ? Utils::String::fromDouble(100 * readRatio, 2) : "-";
map[KEY_TRANSFER_TOTAL_BUFFERS_SIZE] = cacheStatus.totalUsedBuffers() * 16 * 1024;
map[KEY_TRANSFER_TOTAL_BUFFERS_SIZE] = cacheStatus.totalUsedBuffers * 16 * 1024;
// num_peers is not reliable (adds up peers, which didn't even overcome tcp handshake)
quint32 peers = 0;
foreach (BitTorrent::TorrentHandle *const torrent, BitTorrent::Session::instance()->torrents())
peers += torrent->peersCount();
map[KEY_TRANSFER_WRITE_CACHE_OVERLOAD] = ((sessionStatus.diskWriteQueue() > 0) && (peers > 0)) ? Utils::String::fromDouble((100. * sessionStatus.diskWriteQueue()) / peers, 2) : "0";
map[KEY_TRANSFER_READ_CACHE_OVERLOAD] = ((sessionStatus.diskReadQueue() > 0) && (peers > 0)) ? Utils::String::fromDouble((100. * sessionStatus.diskReadQueue()) / peers, 2) : "0";
map[KEY_TRANSFER_WRITE_CACHE_OVERLOAD] = ((sessionStatus.diskWriteQueue > 0) && (peers > 0)) ? Utils::String::fromDouble((100. * sessionStatus.diskWriteQueue) / peers, 2) : "0";
map[KEY_TRANSFER_READ_CACHE_OVERLOAD] = ((sessionStatus.diskReadQueue > 0) && (peers > 0)) ? Utils::String::fromDouble((100. * sessionStatus.diskReadQueue) / peers, 2) : "0";
map[KEY_TRANSFER_QUEUED_IO_JOBS] = cacheStatus.jobQueueLength();
map[KEY_TRANSFER_AVERAGE_TIME_QUEUE] = cacheStatus.averageJobTime();
map[KEY_TRANSFER_TOTAL_QUEUED_SIZE] = cacheStatus.queuedBytes();
map[KEY_TRANSFER_QUEUED_IO_JOBS] = cacheStatus.jobQueueLength;
map[KEY_TRANSFER_AVERAGE_TIME_QUEUE] = cacheStatus.averageJobTime;
map[KEY_TRANSFER_TOTAL_QUEUED_SIZE] = cacheStatus.queuedBytes;
map[KEY_TRANSFER_DHT_NODES] = sessionStatus.dhtNodes();
map[KEY_TRANSFER_DHT_NODES] = sessionStatus.dhtNodes;
if (!BitTorrent::Session::instance()->isListening())
map[KEY_TRANSFER_CONNECTION_STATUS] = "disconnected";
else
map[KEY_TRANSFER_CONNECTION_STATUS] = sessionStatus.hasIncomingConnections() ? "connected" : "firewalled";
map[KEY_TRANSFER_CONNECTION_STATUS] = sessionStatus.hasIncomingConnections ? "connected" : "firewalled";
return map;
}