feat(peers): allow updating connection timeout

crates/librqbit/src/session.rs

@@ -1348,7 +1348,7 @@ impl Session {
                 storage_factory,
                 options: ManagedTorrentOptions {
                     force_tracker_interval: opts.force_tracker_interval,
-                    peer_connect_timeout: peer_opts.connect_timeout,
+                    peer_connect_timeout: RwLock::new(peer_opts.connect_timeout),
                     peer_read_write_timeout: peer_opts.read_write_timeout,
                     allow_overwrite: opts.overwrite,
                     output_folder,

crates/librqbit/src/torrent_state/live/mod.rs

@@ -485,7 +485,7 @@ impl TorrentStateLive {
         };
         let _token_guard = handler.cancel_token.clone().drop_guard();
         let options = PeerConnectionOptions {
-            connect_timeout: self.shared.options.peer_connect_timeout,
+            connect_timeout: self.shared.options.peer_connect_timeout(),
             read_write_timeout: self.shared.options.peer_read_write_timeout,
             ..Default::default()
         };
@@ -550,7 +550,7 @@ impl TorrentStateLive {
         let _token_guard = handler.cancel_token.clone().drop_guard();
 
         let options = PeerConnectionOptions {
-            connect_timeout: state.shared.options.peer_connect_timeout,
+            connect_timeout: state.shared.options.peer_connect_timeout(),
             read_write_timeout: state.shared.options.peer_read_write_timeout,
             ..Default::default()
         };

crates/librqbit/src/torrent_state/mod.rs

@@ -110,7 +110,7 @@ pub(crate) struct ManagedTorrentLocked {
 #[derive(Default)]
 pub(crate) struct ManagedTorrentOptions {
     pub force_tracker_interval: Option<Duration>,
-    pub peer_connect_timeout: Option<Duration>,
+    pub(crate) peer_connect_timeout: RwLock<Option<Duration>>,
     pub peer_read_write_timeout: Option<Duration>,
     pub allow_overwrite: bool,
     pub output_folder: PathBuf,
@@ -121,6 +121,16 @@ pub(crate) struct ManagedTorrentOptions {
     pub _disable_upload: bool,
 }
 
+impl ManagedTorrentOptions {
+    pub(crate) fn peer_connect_timeout(&self) -> Option<Duration> {
+        *self.peer_connect_timeout.read()
+    }
+
+    pub(crate) fn set_peer_connect_timeout(&self, timeout: Option<Duration>) {
+        *self.peer_connect_timeout.write() = timeout;
+    }
+}
+
 impl ManagedTorrentOptions {
     #[cfg(feature = "disable-upload")]
     pub fn disable_upload(&self) -> bool {
@@ -231,6 +241,16 @@ impl ManagedTorrent {
         &self.shared
     }
 
+    /// Update the timeout used by future outgoing peer connection attempts.
+    /// Existing peer connections are not interrupted.
+    pub fn set_peer_connect_timeout(&self, timeout: Option<Duration>) {
+        self.shared.options.set_peer_connect_timeout(timeout);
+    }
+
+    pub fn peer_connect_timeout(&self) -> Option<Duration> {
+        self.shared.options.peer_connect_timeout()
+    }
+
     /// The resolved on-disk folder this torrent's files are written under.
     pub fn output_folder(&self) -> &Path {
         &self.shared.options.output_folder
@@ -719,3 +739,22 @@ fn spawn_peer_adder(live: &Arc<TorrentStateLive>, mut peer_rx: PeerStream) {
         },
     );
 }
+
+#[cfg(test)]
+mod tests {
+    use std::time::Duration;
+
+    use super::ManagedTorrentOptions;
+
+    #[test]
+    fn peer_connect_timeout_can_be_updated_for_future_connections() {
+        let options = ManagedTorrentOptions::default();
+        assert_eq!(options.peer_connect_timeout(), None);
+
+        options.set_peer_connect_timeout(Some(Duration::from_secs(3)));
+        assert_eq!(options.peer_connect_timeout(), Some(Duration::from_secs(3)));
+
+        options.set_peer_connect_timeout(None);
+        assert_eq!(options.peer_connect_timeout(), None);
+    }
+}