refactor(#219): runtime defaults into settings

Author: artrixdotdev

crates/libtortillas/src/engine/actor.rs

@@ -19,6 +19,7 @@ use crate::{
    hashes::InfoHash,
    peer::PeerId,
    protocol::stream::PeerStream,
+   settings::Settings,
    torrent::{PieceStorageStrategy, TorrentActor},
    tracker::udp::UdpServer,
 };
@@ -51,13 +52,8 @@ pub struct EngineActor {
 
    pub(crate) default_piece_storage_strategy: PieceStorageStrategy,
 
-   /// Mailbox size for each torrent instance
-   pub(crate) mailbox_size: usize,
-
-   /// If we autostart torrents
-   pub(crate) autostart: Option<bool>,
-   /// How many peers we need to have before we start downloading
-   pub(crate) sufficient_peers: Option<usize>,
+   /// Runtime behavior settings shared with torrent, peer, and tracker actors.
+   pub(crate) settings: Settings,
 
    pub(crate) default_base_path: Option<PathBuf>,
 }
@@ -96,21 +92,8 @@ pub struct EngineActorArgs {
    /// managed by this engine.
    pub piece_storage_strategy: PieceStorageStrategy,
 
-   /// Mailbox size for each torrent instance.
-   ///
-   /// Defaults to 64 if not provided. If set to 0, the mailbox will be
-   /// unbounded.
-   pub mailbox_size: Option<usize>,
-
-   /// Whether to automatically start torrents when they become ready.
-   ///
-   /// If not provided, defaults to `None` (use engine-level default).
-   pub autostart: Option<bool>,
-
-   /// Minimum number of peers required before starting download.
-   ///
-   /// If not provided, defaults to `None` (use engine-level default).
-   pub sufficient_peers: Option<usize>,
+   /// Runtime behavior settings.
+   pub settings: Settings,
 
    /// Default base path for torrent downloads.
    ///
@@ -144,23 +127,25 @@ impl Actor for EngineActor {
          udp_addr,
          peer_id,
          piece_storage_strategy,
-         mailbox_size,
-         autostart,
-         sufficient_peers,
+         settings,
          default_base_path,
       } = args;
 
-      let tcp_addr = tcp_addr.unwrap_or_else(|| SocketAddr::from(([0, 0, 0, 0], 0)));
-      // Should this be port 6881?
-      let utp_addr = utp_addr.unwrap_or_else(|| SocketAddr::from(([0, 0, 0, 0], 0)));
-      let udp_addr = udp_addr.unwrap_or_else(|| SocketAddr::from(([0, 0, 0, 0], 0)));
+      let tcp_addr = tcp_addr.unwrap_or(settings.engine.tcp_addr);
+      let utp_addr = utp_addr.unwrap_or(settings.engine.utp_addr);
+      let udp_addr = udp_addr.unwrap_or(settings.engine.udp_addr);
       let tcp_socket = TcpListener::bind(tcp_addr)
          .await
          .map_err(|e| EngineError::NetworkSetupFailed(format!("tcp bind {tcp_addr}: {e}")))?;
       let utp_socket = UtpSocketUdp::new_udp(utp_addr)
          .await
          .map_err(|e| EngineError::NetworkSetupFailed(format!("utp bind {utp_addr}: {e}")))?;
-      let udp_server = UdpServer::new(Some(udp_addr)).await;
+      let udp_server = UdpServer::new_with_receive_buffer_size(
+         Some(udp_addr),
+         settings.tracker.udp_receive_buffer_size,
+      )
+      .await
+      .map_err(|e| EngineError::NetworkSetupFailed(format!("udp bind {udp_addr}: {e}")))?;
 
       let peer_id = peer_id.unwrap_or_default();
 
@@ -172,9 +157,7 @@ impl Actor for EngineActor {
          peer_id,
          actor_ref,
          default_piece_storage_strategy: piece_storage_strategy,
-         mailbox_size: mailbox_size.unwrap_or(64),
-         autostart,
-         sufficient_peers,
+         settings,
          default_base_path,
       })
    }

crates/libtortillas/src/engine/messages.rs

@@ -1,6 +1,6 @@
 use futures::future::try_join_all;
 use kameo::{actor::Spawn, mailbox, messages, prelude::ActorRef, supervision::RestartPolicy};
-use tokio::time::{Duration, timeout};
+use tokio::time::timeout;
 use tracing::{error, warn};
 
 use super::{EngineActor, EngineExport};
@@ -12,8 +12,6 @@ use crate::{
    torrent::{self, TorrentActor, TorrentActorArgs, TorrentState},
 };
 
-const INCOMING_PEER_HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(10);
-
 pub(crate) mod commands {
    use anyhow::anyhow;
 
@@ -25,19 +23,15 @@ pub(crate) mod commands {
       /// handshaked nor verified at this point.
       #[message]
       pub(crate) async fn incoming_peer(&mut self, mut stream: PeerStream) {
-         let handshake = match timeout(
-            INCOMING_PEER_HANDSHAKE_TIMEOUT,
-            stream.recv_handshake_message(),
-         )
-         .await
-         {
+         let handshake_timeout = self.settings.engine.incoming_peer_handshake_timeout;
+         let handshake = match timeout(handshake_timeout, stream.recv_handshake_message()).await {
             Ok(Ok(handshake)) => handshake,
             Ok(Err(err)) => {
                warn!(error = %err, %stream, "Failed to read incoming peer handshake");
                return;
             }
             Err(_) => {
-               warn!(%stream, timeout = ?INCOMING_PEER_HANDSHAKE_TIMEOUT, "Timed out reading incoming peer handshake");
+               warn!(%stream, timeout = ?handshake_timeout, "Timed out reading incoming peer handshake");
                return;
             }
          };
@@ -116,14 +110,18 @@ pub(crate) mod commands {
                tracker_server: self.udp_server.clone(),
                primary_addr: None,
                piece_storage: self.default_piece_storage_strategy.clone(),
-               autostart: self.autostart,
-               sufficient_peers: self.sufficient_peers,
+               autostart: None,
+               sufficient_peers: None,
                base_path: self.default_base_path.clone(),
+               settings: self.settings.clone(),
             },
          )
          .restart_policy(RestartPolicy::Permanent)
-         .restart_limit(3, Duration::from_secs(60))
-         .spawn_with_mailbox(match self.mailbox_size {
+         .restart_limit(
+            self.settings.engine.torrent_restart.limit,
+            self.settings.engine.torrent_restart.period,
+         )
+         .spawn_with_mailbox(match self.settings.engine.torrent_mailbox_size {
             0 => {
                warn!(
                   ?info_hash,

crates/libtortillas/src/engine/mod.rs

@@ -51,6 +51,7 @@ use crate::{
    errors::EngineError,
    metainfo::{MetaInfo, TorrentFile},
    peer::PeerId,
+   settings::Settings,
    torrent::{PieceStorageStrategy, Torrent, TorrentExport},
 };
 
@@ -104,36 +105,69 @@ impl Engine {
       /// Strategy for storing pieces of the torrent.
       #[builder(default)]
       piece_storage_strategy: PieceStorageStrategy,
+      /// Runtime behavior settings for engine, torrent, peer, and tracker
+      /// actors.
+      settings: Option<Settings>,
       /// The mailbox size for each torrent instance.
       ///
       /// In simple terms, this is the number of messages that each torrent
       /// instance can have in queue.
       ///
       /// If `Some(0)` is provided, the mailbox will be unbounded (no limit).
-      /// If `None` is provided, a sensible default is used.
+      /// If `Some(_)` is provided, it overrides
+      /// [`Settings::engine.
+      /// torrent_mailbox_size`](crate::settings::EngineSettings::torrent_mailbox_size).
+      /// If `None` is provided, the supplied [`Settings`] value is
+      /// preserved.
       ///
       /// Higher values increase memory usage but reduce sender backpressure
       /// when the mailbox is busy, which can improve throughput. Lower values
       /// do the inverse.
       ///
-      /// Default: `64` when `None` is provided.
+      /// Default: `64` through [`Settings::default`] when no custom settings
+      /// are supplied.
       mailbox_size: Option<usize>,
       /// If we autostart torrents as soon as we have [`Self::sufficient_peers`]
       /// peers connected.
-      /// Default: `true`
+      ///
+      /// If `Some(_)` is provided, it overrides
+      /// [`Settings::torrent.
+      /// autostart`](crate::settings::TorrentSettings::autostart).
+      /// If `None` is provided, the supplied [`Settings`] value is preserved.
+      ///
+      /// Default: `true` through [`Settings::default`] when no custom settings
+      /// are supplied.
       autostart: Option<bool>,
       /// How many peers we need to have before we start downloading.
       ///
       /// Is ignored if [`Self::autostart`] is `false`.
       ///
-      /// Default: `6`
+      /// If `Some(_)` is provided, it overrides
+      /// [`Settings::torrent.
+      /// sufficient_peers`](crate::settings::TorrentSettings::sufficient_peers).
+      /// If `None` is provided, the supplied [`Settings`] value is
+      /// preserved.
+      ///
+      /// Default: `6` through [`Settings::default`] when no custom settings
+      /// are supplied.
       sufficient_peers: Option<usize>,
       /// Default base path for torrents
       ///
       /// Default: `std::env::current_dir()`
       #[builder(into)]
       output_path: Option<PathBuf>,
    ) -> Self {
+      let mut settings = settings.unwrap_or_default();
+      if let Some(mailbox_size) = mailbox_size {
+         settings.engine.torrent_mailbox_size = mailbox_size;
+      }
+      if let Some(autostart) = autostart {
+         settings.torrent.autostart = autostart;
+      }
+      if let Some(sufficient_peers) = sufficient_peers {
+         settings.torrent.sufficient_peers = sufficient_peers;
+      }
+
       let output_path = match output_path {
          Some(path) => {
             if path.is_absolute() {
@@ -153,9 +187,7 @@ impl Engine {
          udp_addr,
          peer_id: Some(custom_id),
          piece_storage_strategy,
-         mailbox_size,
-         autostart,
-         sufficient_peers,
+         settings,
          default_base_path: Some(output_path),
       };
 

crates/libtortillas/src/lib.rs

@@ -5,6 +5,7 @@ pub mod metainfo;
 pub mod peer;
 pub mod pieces;
 pub mod protocol;
+pub mod settings;
 pub mod torrent;
 pub mod tracker;
 
@@ -92,7 +93,7 @@ pub(crate) mod testing {
    }
 
    pub(crate) async fn udp_server() -> UdpServer {
-      UdpServer::new(None).await
+      UdpServer::new(None).await.unwrap()
    }
 
    pub(crate) fn init_tracing() {
@@ -119,6 +120,7 @@ pub mod prelude {
       hashes::InfoHash,
       metainfo::*,
       peer::{Peer, PeerId},
+      settings::*,
       torrent::*,
       tracker::Tracker,
    };