add high_priority flag to tracker announcements, to put them at the front of the queue. This can be done manually in force_reannounce() or will happen automatically as part of connection-boost

Author: arvidn

bindings/python/src/torrent_handle.cpp

@@ -596,6 +596,7 @@ void bind_torrent_handle()
         ;
 
     s.attr("ignore_min_interval") = torrent_handle::ignore_min_interval;
+    s.attr("high_priority") = torrent_handle::high_priority;
     s.attr("overwrite_existing") = torrent_handle::overwrite_existing;
     s.attr("piece_granularity") = torrent_handle::piece_granularity;
     s.attr("graceful_pause") = torrent_handle::graceful_pause;

include/libtorrent/torrent.hpp

@@ -828,7 +828,7 @@ namespace libtorrent {
 		// forcefully sets next_announce to the current time
 		void force_tracker_request(time_point, int tracker_idx, reannounce_flags_t flags);
 		void scrape_tracker(int idx, bool user_triggered);
-		void announce_with_tracker(event_t = event_t::none);
+		void announce_with_tracker(event_t = event_t::none, bool high_priority = false);
 
 #ifndef TORRENT_DISABLE_DHT
 		void dht_announce();

include/libtorrent/torrent_handle.hpp

@@ -1166,6 +1166,11 @@ namespace aux {
 		// and the tracker is announced immediately.
 		static constexpr reannounce_flags_t ignore_min_interval = 0_bit;
 
+		// by default, force-reannounce will queue the announce normally.
+		// If this flag is set, the announce will be put at the front of the
+		// tracker queue for immediate processing.
+		static constexpr reannounce_flags_t high_priority = 1_bit;
+
 		// ``force_reannounce()`` will force this torrent to do another tracker
 		// request, to receive new peers. The ``seconds`` argument specifies how
 		// many seconds from now to issue the tracker announces.
@@ -1179,7 +1184,7 @@ namespace aux {
 		// If set to -1 (which is the default), all trackers are re-announce.
 		//
 		// The ``flags`` argument can be used to affect the re-announce. See
-		// ignore_min_interval.
+		// ignore_min_interval and high_priority.
 		//
 		// ``force_dht_announce`` will announce the torrent to the DHT
 		// immediately.

include/libtorrent/tracker_manager.hpp

@@ -108,6 +108,11 @@ enum class event_t : std::uint8_t
 		// see parse_tracker_response()
 		static constexpr tracker_request_flags_t i2p = 1_bit;
 
+		// If set, this announce should be prioritized in the tracker queue.
+		// This does not bypass concurrency caps; it only moves the request to
+		// the front of the pending queue if we are at capacity.
+		static constexpr tracker_request_flags_t high_priority = 2_bit;
+
 		std::string url;
 		std::string trackerid;
 #if TORRENT_ABI_VERSION == 1

src/torrent.cpp

@@ -2976,7 +2976,7 @@ namespace {
 		};
 	}
 
-	void torrent::announce_with_tracker(event_t e)
+	void torrent::announce_with_tracker(event_t e, bool const high_priority)
 	{
 		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(e == event_t::stopped || state() != torrent_status::checking_files);
@@ -3278,6 +3278,7 @@ namespace {
 							, print_endpoint(aep.local_endpoint).c_str());
 					}
 
+					if (high_priority) req.kind |= tracker_request::high_priority;
 					// if we're not logging session logs, don't bother creating an
 					// observer object just for logging
 					if (m_abort && m_ses.should_log())
@@ -3842,7 +3843,15 @@ namespace {
 			debug_log("*** found no tracker endpoints to announce");
 		}
 #endif
-		update_tracker_timer(aux::time_now32());
+
+		if (flags & torrent_handle::high_priority)
+		{
+			announce_with_tracker(event_t::none, true);
+		}
+		else
+		{
+			update_tracker_timer(aux::time_now32());
+		}
 	}
 
 #if TORRENT_ABI_VERSION == 1
@@ -10129,7 +10138,8 @@ namespace {
 
 		update_want_tick();
 
-		announce_with_tracker();
+		bool const high_priority = m_connect_boost_counter > 0;
+		announce_with_tracker(event_t::none, high_priority);
 
 		lsd_announce();
 	}
@@ -12350,7 +12360,8 @@ namespace {
 		if ((!m_abort && !is_paused() && state() != torrent_status::checking_files)
 			|| r.event == event_t::stopped)
 		{
-			announce_with_tracker(r.event);
+			// if the tracker that failed was high-priority, make the next attempt high priority as well
+			announce_with_tracker(r.event, (r.kind & torrent_handle::high_priority) != 0);
 		}
 		else
 		{

src/torrent_handle.cpp

@@ -81,6 +81,7 @@ namespace libtorrent {
 	constexpr pause_flags_t torrent_handle::clear_disk_cache;
 	constexpr deadline_flags_t torrent_handle::alert_when_available;
 	constexpr reannounce_flags_t torrent_handle::ignore_min_interval;
+	constexpr reannounce_flags_t torrent_handle::high_priority;
 	constexpr file_progress_flags_t torrent_handle::piece_granularity;
 
 	constexpr status_flags_t torrent_handle::query_distributed_copies;

src/tracker_manager.cpp

@@ -51,6 +51,7 @@ namespace libtorrent {
 
 constexpr tracker_request_flags_t tracker_request::scrape_request;
 constexpr tracker_request_flags_t tracker_request::i2p;
+constexpr tracker_request_flags_t tracker_request::high_priority;
 
 	timeout_handler::timeout_handler(io_context& ios)
 		: m_start_time(clock_type::now())
@@ -275,11 +276,12 @@ constexpr tracker_request_flags_t tracker_request::i2p;
 		TORRENT_ASSERT(req.num_want >= 0);
 		TORRENT_ASSERT(!m_abort || req.event == event_t::stopped);
 		if (m_abort && req.event != event_t::stopped) return;
+		bool const high_priority = bool(req.kind & tracker_request::high_priority);
 
 #ifndef TORRENT_DISABLE_LOGGING
 		std::shared_ptr<request_callback> cb = c.lock();
-		if (cb) cb->debug_log("*** QUEUE_TRACKER_REQUEST [ listen_port: %d ]"
-			, req.listen_port);
+		if (cb) cb->debug_log("*** QUEUE_TRACKER_REQUEST [ listen_port: %d priority: %d ]"
+			, req.listen_port, high_priority);
 #endif
 
 		std::string const protocol = req.url.substr(0, req.url.find(':'));
@@ -298,7 +300,14 @@ constexpr tracker_request_flags_t tracker_request::i2p;
 			}
 			else
 			{
-				m_queued.push_back(std::move(con));
+				if (high_priority)
+				{
+					m_queued.push_front(std::move(con));
+				}
+				else
+				{
+					m_queued.push_back(std::move(con));
+				}
 				m_stats_counters.set_value(counters::num_queued_tracker_announces, std::int64_t(m_queued.size()));
 			}
 			return;