mirror/transmission
1
0
Fork 0
mirror of https://github.com/transmission/transmission synced 2025-03-15 16:29:34 +00:00
Code Issues Releases Wiki Activity

refactor: make tr_session.is_closing_private_ (#3637)

Browse source
This commit is contained in:
Charles Kerr 2022-08-13 20:04:36 -05:00 • committed by GitHub
parent f6bf652043
commit 5c8695025a
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
12 changed files with 96 additions and 58 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
libtransmission/announcer-http.cc
View file

@ -82,7 +82,7 @@ static tr_urlbuf announce_url_new(tr_session const* session, tr_announce_request
fmt::arg("numwant", req->numwant),
fmt::arg("key", req->key));
if (session->encryptionMode == TR_ENCRYPTION_REQUIRED)
if (session->encryptionMode() == TR_ENCRYPTION_REQUIRED)
{
fmt::format_to(out, "&requirecrypto=1");
}

4
libtransmission/announcer.cc
View file

@ -475,7 +475,7 @@ private:
[[nodiscard]] static time_t getNextScrapeTime(tr_session const* session, tr_tier const* tier, int interval)
{
// Maybe don't scrape paused torrents
if (!tier->isRunning && !session->scrapePausedTorrents)
if (!tier->isRunning && !session->shouldScrapePausedTorrents())
{
return 0;
}
@ -1595,7 +1595,7 @@ void tr_announcer::upkeep()
{
auto const lock = session->unique_lock();
bool const is_closing = session->isClosed;
bool const is_closing = session->isClosed();
time_t const now = tr_time();
/* maybe send out some "stopped" messages for closed torrents */

2
libtransmission/inout.cc
View file

@ -130,7 +130,7 @@ int readOrWriteBytes(
{
// open (and maybe create) the file
auto const prealloc = (!do_write || !tor->fileIsWanted(file_index)) ? TR_PREALLOCATE_NONE :
tor->session->preallocationMode;
tor->session->preallocationMode();
fd = session->openFiles().get(tor->id(), file_index, do_write, filename, prealloc, file_size);
if (fd && do_write)
{

4
libtransmission/peer-mgr.cc
View file

@ -1258,7 +1258,7 @@ void tr_peerMgrAddIncoming(tr_peerMgr* manager, tr_address const* addr, tr_port
{
auto mediator = std::make_shared<tr_handshake_mediator_impl>(*session);
tr_peerIo* const io = tr_peerIoNewIncoming(session, &session->top_bandwidth_, addr, port, tr_time(), socket);
tr_handshake* const handshake = tr_handshakeNew(mediator, io, session->encryptionMode, on_handshake_done, manager);
tr_handshake* const handshake = tr_handshakeNew(mediator, io, session->encryptionMode(), on_handshake_done, manager);
tr_peerIoUnref(io); /* balanced by the implicit ref in tr_peerIoNewIncoming() */
@ -2844,7 +2844,7 @@ void initiateConnection(tr_peerMgr* mgr, tr_swarm* s, peer_atom& atom)
else
{
auto mediator = std::make_shared<tr_handshake_mediator_impl>(*mgr->session);
tr_handshake* handshake = tr_handshakeNew(mediator, io, mgr->session->encryptionMode, on_handshake_done, mgr);
tr_handshake* handshake = tr_handshakeNew(mediator, io, mgr->session->encryptionMode(), on_handshake_done, mgr);
TR_ASSERT(io->torrentHash());

2
libtransmission/peer-msgs.cc
View file

@ -1156,7 +1156,7 @@ static void sendLtepHandshake(tr_peerMsgsImpl* msgs)
auto val = tr_variant{};
tr_variantInitDict(&val, 8);
tr_variantDictAddBool(&val, TR_KEY_e, msgs->session->encryptionMode != TR_CLEAR_PREFERRED);
tr_variantDictAddBool(&val, TR_KEY_e, msgs->session->encryptionMode() != TR_CLEAR_PREFERRED);
if (ipv6 != nullptr)
{

4
libtransmission/rpcimpl.cc
View file

@ -2270,11 +2270,11 @@ static void addSessionField(tr_session const* s, tr_variant* d, tr_quark key)
break;
case TR_KEY_start_added_torrents:
tr_variantDictAddBool(d, key, !tr_sessionGetPaused(s));
tr_variantDictAddBool(d, key, !s->shouldPauseAddedTorrents());
break;
case TR_KEY_trash_original_torrent_files:
tr_variantDictAddBool(d, key, tr_sessionGetDeleteSource(s));
tr_variantDictAddBool(d, key, s->shouldDeleteSource());
break;
case TR_KEY_speed_limit_up:

50
libtransmission/session.cc
View file

@ -82,10 +82,10 @@ static void bandwidthGroupRead(tr_session* session, std::string_view config_dir)
static int bandwidthGroupWrite(tr_session const* session, std::string_view config_dir);
static auto constexpr BandwidthGroupsFilename = "bandwidth-groups.json"sv;
static tr_port getRandomPort(tr_session const* s)
tr_port tr_session::randomPort() const
{
auto const lower = std::min(s->randomPortLow.host(), s->randomPortHigh.host());
auto const upper = std::max(s->randomPortLow.host(), s->randomPortHigh.host());
auto const lower = std::min(random_port_low_.host(), random_port_high_.host());
auto const upper = std::max(random_port_low_.host(), random_port_high_.host());
auto const range = upper - lower;
return tr_port::fromHost(lower + tr_rand_int_weak(range + 1));
}
@ -192,7 +192,7 @@ tr_encryption_mode tr_sessionGetEncryption(tr_session const* session)
{
TR_ASSERT(session != nullptr);
return session->encryptionMode;
return session->encryptionMode();
}
void tr_sessionSetEncryption(tr_session* session, tr_encryption_mode mode)
@ -200,7 +200,7 @@ void tr_sessionSetEncryption(tr_session* session, tr_encryption_mode mode)
TR_ASSERT(session != nullptr);
TR_ASSERT(mode == TR_ENCRYPTION_PREFERRED || mode == TR_ENCRYPTION_REQUIRED || mode == TR_CLEAR_PREFERRED);
session->encryptionMode = mode;
session->encryption_mode_ = mode;
}
/***
@ -411,7 +411,7 @@ void tr_sessionGetSettings(tr_session const* s, tr_variant* setme_dictionary)
tr_variantDictAddBool(d, TR_KEY_download_queue_enabled, s->queueEnabled(TR_DOWN));
tr_variantDictAddInt(d, TR_KEY_speed_limit_down, tr_sessionGetSpeedLimit_KBps(s, TR_DOWN));
tr_variantDictAddBool(d, TR_KEY_speed_limit_down_enabled, tr_sessionIsSpeedLimited(s, TR_DOWN));
tr_variantDictAddInt(d, TR_KEY_encryption, s->encryptionMode);
tr_variantDictAddInt(d, TR_KEY_encryption, s->encryptionMode());
tr_variantDictAddInt(d, TR_KEY_idle_seeding_limit, tr_sessionGetIdleLimit(s));
tr_variantDictAddBool(d, TR_KEY_idle_seeding_limit_enabled, tr_sessionIsIdleLimited(s));
tr_variantDictAddStr(d, TR_KEY_incomplete_dir, tr_sessionGetIncompleteDir(s));
@ -421,13 +421,13 @@ void tr_sessionGetSettings(tr_session const* s, tr_variant* setme_dictionary)
tr_variantDictAddInt(d, TR_KEY_peer_limit_per_torrent, s->peerLimitPerTorrent());
tr_variantDictAddInt(d, TR_KEY_peer_port, s->peerPort().host());
tr_variantDictAddBool(d, TR_KEY_peer_port_random_on_start, s->isPortRandom);
tr_variantDictAddInt(d, TR_KEY_peer_port_random_low, s->randomPortLow.host());
tr_variantDictAddInt(d, TR_KEY_peer_port_random_high, s->randomPortHigh.host());
tr_variantDictAddInt(d, TR_KEY_peer_port_random_low, s->random_port_low_.host());
tr_variantDictAddInt(d, TR_KEY_peer_port_random_high, s->random_port_high_.host());
tr_variantDictAddStr(d, TR_KEY_peer_socket_tos, tr_netTosToName(s->peer_socket_tos_));
tr_variantDictAddStr(d, TR_KEY_peer_congestion_algorithm, s->peerCongestionAlgorithm());
tr_variantDictAddBool(d, TR_KEY_pex_enabled, s->isPexEnabled);
tr_variantDictAddBool(d, TR_KEY_port_forwarding_enabled, tr_sessionIsPortForwardingEnabled(s));
tr_variantDictAddInt(d, TR_KEY_preallocation, s->preallocationMode);
tr_variantDictAddInt(d, TR_KEY_preallocation, s->preallocationMode());
tr_variantDictAddBool(d, TR_KEY_prefetch_enabled, s->isPrefetchEnabled);
tr_variantDictAddInt(d, TR_KEY_peer_id_ttl_hours, s->peer_id_ttl_hours);
tr_variantDictAddBool(d, TR_KEY_queue_stalled_enabled, s->queueStalledEnabled());
@ -445,7 +445,7 @@ void tr_sessionGetSettings(tr_session const* s, tr_variant* setme_dictionary)
tr_variantDictAddStr(d, TR_KEY_rpc_username, tr_sessionGetRPCUsername(s));
tr_variantDictAddStr(d, TR_KEY_rpc_whitelist, tr_sessionGetRPCWhitelist(s));
tr_variantDictAddBool(d, TR_KEY_rpc_whitelist_enabled, tr_sessionGetRPCWhitelistEnabled(s));
tr_variantDictAddBool(d, TR_KEY_scrape_paused_torrents_enabled, s->scrapePausedTorrents);
tr_variantDictAddBool(d, TR_KEY_scrape_paused_torrents_enabled, s->shouldScrapePausedTorrents());
tr_variantDictAddInt(d, TR_KEY_seed_queue_size, s->queueSize(TR_UP));
tr_variantDictAddBool(d, TR_KEY_seed_queue_enabled, s->queueEnabled(TR_UP));
tr_variantDictAddBool(d, TR_KEY_alt_speed_enabled, tr_sessionUsesAltSpeed(s));
@ -461,7 +461,7 @@ void tr_sessionGetSettings(tr_session const* s, tr_variant* setme_dictionary)
tr_variantDictAddInt(d, TR_KEY_upload_slots_per_torrent, s->upload_slots_per_torrent);
tr_variantDictAddStr(d, TR_KEY_bind_address_ipv4, s->bind_ipv4.readable());
tr_variantDictAddStr(d, TR_KEY_bind_address_ipv6, s->bind_ipv6.readable());
tr_variantDictAddBool(d, TR_KEY_start_added_torrents, !tr_sessionGetPaused(s));
tr_variantDictAddBool(d, TR_KEY_start_added_torrents, !s->shouldPauseAddedTorrents());
tr_variantDictAddBool(d, TR_KEY_trash_original_torrent_files, tr_sessionGetDeleteSource(s));
tr_variantDictAddInt(d, TR_KEY_anti_brute_force_threshold, tr_sessionGetAntiBruteForceThreshold(s));
tr_variantDictAddBool(d, TR_KEY_anti_brute_force_enabled, tr_sessionGetAntiBruteForceEnabled(s));
@ -876,7 +876,7 @@ void tr_session::setImpl(init_data& data)
if (tr_variantDictFindInt(settings, TR_KEY_preallocation, &i))
{
this->preallocationMode = tr_preallocation_mode(i);
this->preallocation_mode_ = tr_preallocation_mode(i);
}
if (tr_variantDictFindStrView(settings, TR_KEY_download_dir, &sv))
@ -933,12 +933,12 @@ void tr_session::setImpl(init_data& data)
/* incoming peer port */
if (tr_variantDictFindInt(settings, TR_KEY_peer_port_random_low, &i))
{
this->randomPortLow.setHost(i);
this->random_port_low_.setHost(i);
}
if (tr_variantDictFindInt(settings, TR_KEY_peer_port_random_high, &i))
{
this->randomPortHigh.setHost(i);
this->random_port_high_.setHost(i);
}
if (tr_variantDictFindBool(settings, TR_KEY_peer_port_random_on_start, &boolVal))
@ -954,7 +954,7 @@ void tr_session::setImpl(init_data& data)
peer_port.setHost(static_cast<uint16_t>(port));
}
::setPeerPort(this, boolVal ? getRandomPort(this) : peer_port);
::setPeerPort(this, boolVal ? randomPort() : peer_port);
}
if (tr_variantDictFindBool(settings, TR_KEY_port_forwarding_enabled, &boolVal))
@ -1072,7 +1072,7 @@ void tr_session::setImpl(init_data& data)
if (tr_variantDictFindBool(settings, TR_KEY_scrape_paused_torrents_enabled, &boolVal))
{
this->scrapePausedTorrents = boolVal;
this->should_scrape_paused_torrents_ = boolVal;
}
/**
@ -1240,7 +1240,7 @@ uint16_t tr_sessionGetPeerPort(tr_session const* session)
uint16_t tr_sessionSetPeerPortRandom(tr_session* session)
{
tr_port const p = getRandomPort(session);
auto const p = session->randomPort();
tr_sessionSetPeerPort(session, p.host());
return p.host();
}
@ -1729,32 +1729,32 @@ uint16_t tr_sessionGetPeerLimitPerTorrent(tr_session const* session)
****
***/
void tr_sessionSetPaused(tr_session* session, bool isPaused)
void tr_sessionSetPaused(tr_session* session, bool is_paused)
{
TR_ASSERT(tr_isSession(session));
session->pauseAddedTorrent = isPaused;
session->should_pause_added_torrents_ = is_paused;
}
bool tr_sessionGetPaused(tr_session const* session)
{
TR_ASSERT(tr_isSession(session));
return session->pauseAddedTorrent;
return session->shouldPauseAddedTorrents();
}
void tr_sessionSetDeleteSource(tr_session* session, bool deleteSource)
void tr_sessionSetDeleteSource(tr_session* session, bool delete_source)
{
TR_ASSERT(tr_isSession(session));
session->deleteSourceTorrent = deleteSource;
session->should_delete_source_torrents_ = delete_source;
}
bool tr_sessionGetDeleteSource(tr_session const* session)
{
TR_ASSERT(tr_isSession(session));
return session->deleteSourceTorrent;
return session->shouldDeleteSource();
}
/***
@ -1878,7 +1878,7 @@ void tr_session::closeImplFinish()
tr_utpClose(this);
closeBlocklists(this);
openFiles().closeAll();
isClosed = true;
is_closed_ = true;
}
static bool deadlineReached(time_t const deadline)
@ -1900,7 +1900,7 @@ void tr_sessionClose(tr_session* session)
/* close the session */
tr_runInEventThread(session, [session]() { session->closeImplStart(); });
while (!session->isClosed && !deadlineReached(deadline))
while (!session->isClosed() && !deadlineReached(deadline))
{
tr_logAddTrace("waiting for the libtransmission thread to finish");
tr_wait_msec(10);

72
libtransmission/session.h
View file

@ -155,11 +155,6 @@ public:
return std::unique_lock(session_mutex_);
}
[[nodiscard]] constexpr auto isClosing() const noexcept
{
return is_closing_;
}
// paths
[[nodiscard]] constexpr auto const& configDir() const noexcept
@ -471,14 +466,9 @@ public:
bool isUTPEnabled = false;
bool isLPDEnabled = false;
bool isPrefetchEnabled = false;
bool is_closing_ = false;
bool isClosed = false;
bool isRatioLimited = false;
bool isIdleLimited = false;
bool isIncompleteFileNamingEnabled = false;
bool pauseAddedTorrent = false;
bool deleteSourceTorrent = false;
bool scrapePausedTorrents = false;
uint8_t peer_id_ttl_hours = 0;
@ -491,10 +481,6 @@ public:
int magicNumber = 0;
tr_encryption_mode encryptionMode;
tr_preallocation_mode preallocationMode;
struct evdns_base* evdns_base = nullptr;
struct tr_event_handle* events = nullptr;
@ -532,9 +518,6 @@ public:
public_peer_port = port;
}
tr_port randomPortLow;
tr_port randomPortHigh;
std::vector<std::unique_ptr<BlocklistFile>> blocklists;
struct tr_peerMgr* peerMgr = nullptr;
struct tr_shared* shared = nullptr;
@ -562,6 +545,9 @@ public:
tr_session* const session_;
};
tr_port random_port_low_;
tr_port random_port_high_;
std::unique_ptr<tr_web> web;
tr_session_id session_id;
@ -623,11 +609,52 @@ public:
return peer_limit_per_torrent_;
}
[[nodiscard]] auto constexpr isClosing() const noexcept
{
return is_closing_;
}
[[nodiscard]] auto constexpr isClosed() const noexcept
{
return is_closed_;
}
[[nodiscard]] auto constexpr encryptionMode() const noexcept
{
return encryption_mode_;
}
[[nodiscard]] auto constexpr preallocationMode() const noexcept
{
return preallocation_mode_;
}
[[nodiscard]] auto constexpr shouldScrapePausedTorrents() const noexcept
{
return should_scrape_paused_torrents_;
}
[[nodiscard]] auto constexpr shouldPauseAddedTorrents() const noexcept
{
return should_pause_added_torrents_;
}
[[nodiscard]] auto constexpr shouldDeleteSource() const noexcept
{
return should_pause_added_torrents_;
}
private:
[[nodiscard]] tr_port randomPort() const;
friend tr_session* tr_sessionInit(char const* config_dir, bool message_queueing_enabled, tr_variant* client_settings);
friend uint16_t tr_sessionSetPeerPortRandom(tr_session* session);
friend void tr_sessionClose(tr_session* session);
friend void tr_sessionGetSettings(tr_session const* s, tr_variant* setme_dictionary);
friend void tr_sessionSet(tr_session* session, tr_variant* settings);
friend void tr_sessionSetDeleteSource(tr_session* session, bool delete_source);
friend void tr_sessionSetEncryption(tr_session* session, tr_encryption_mode mode);
friend void tr_sessionSetPaused(tr_session* session, bool is_paused);
friend void tr_sessionSetPeerLimit(tr_session* session, uint16_t max_global_peers);
friend void tr_sessionSetPeerLimitPerTorrent(tr_session* session, uint16_t max_peers);
friend void tr_sessionSetQueueEnabled(tr_session* session, tr_direction dir, bool do_limit_simultaneous_seed_torrents);
@ -642,6 +669,17 @@ private:
void closeImplWaitForIdleUdp();
void closeImplFinish();
bool should_pause_added_torrents_ = false;
bool should_delete_source_torrents_ = false;
bool should_scrape_paused_torrents_ = false;
tr_encryption_mode encryption_mode_ = TR_ENCRYPTION_PREFERRED;
tr_preallocation_mode preallocation_mode_ = TR_PREALLOCATE_SPARSE;
bool is_closing_ = false;
bool is_closed_ = false;
uint16_t peer_count_ = 0;
uint16_t peer_limit_ = 200;
uint16_t peer_limit_per_torrent_ = 50;

4
libtransmission/torrent-ctor.cc
View file

@ -351,8 +351,8 @@ tr_ctor* tr_ctorNew(tr_session const* session)
{
auto* const ctor = new tr_ctor{ session };
tr_ctorSetDeleteSource(ctor, tr_sessionGetDeleteSource(session));
tr_ctorSetPaused(ctor, TR_FALLBACK, tr_sessionGetPaused(session));
tr_ctorSetDeleteSource(ctor, session->shouldDeleteSource());
tr_ctorSetPaused(ctor, TR_FALLBACK, session->shouldPauseAddedTorrents());
tr_ctorSetPeerLimit(ctor, TR_FALLBACK, session->peerLimitPerTorrent());
tr_ctorSetDownloadDir(ctor, TR_FALLBACK, tr_sessionGetDownloadDir(session));

4
libtransmission/torrent-magnet.cc
View file

@ -238,7 +238,7 @@ bool tr_torrentUseMetainfoFromFile(
}
tor->isStopping = true;
tor->magnetVerify = true;
if (tr_sessionGetPaused(tor->session))
if (tor->session->shouldPauseAddedTorrents())
{
tor->startAfterVerify = false;
}
@ -301,7 +301,7 @@ static void onHaveAllMetainfo(tr_torrent* tor, tr_incomplete_metadata* m)
tor->incompleteMetadata = nullptr;
tor->isStopping = true;
tor->magnetVerify = true;
if (tr_sessionGetPaused(tor->session))
if (tor->session->shouldPauseAddedTorrents())
{
tor->startAfterVerify = false;
}

2
libtransmission/tr-utp.cc
View file

@ -231,7 +231,7 @@ void tr_utpInit(tr_session* session)
bool tr_utpPacket(unsigned char const* buf, size_t buflen, struct sockaddr const* from, socklen_t fromlen, tr_session* ss)
{
if (!ss->isClosed && !ss->utp_timer)
if (!ss->isClosed() && !ss->utp_timer)
{
ss->utp_timer = ss->timerMaker().create(timer_callback, ss);
reset_timer(ss);

4
libtransmission/transmission.h
View file

@ -602,10 +602,10 @@ uint16_t tr_sessionGetPeerLimit(tr_session const*);
void tr_sessionSetPeerLimitPerTorrent(tr_session*, uint16_t max_peers);
uint16_t tr_sessionGetPeerLimitPerTorrent(tr_session const*);
void tr_sessionSetPaused(tr_session*, bool isPaused);
void tr_sessionSetPaused(tr_session*, bool is_paused);
bool tr_sessionGetPaused(tr_session const*);
void tr_sessionSetDeleteSource(tr_session*, bool deleteSource);
void tr_sessionSetDeleteSource(tr_session*, bool delete_source);
bool tr_sessionGetDeleteSource(tr_session const*);
tr_priority_t tr_torrentGetPriority(tr_torrent const*);