Struct EngineConfig 

pub struct EngineConfig {

    pub download_dir: PathBuf,
    pub max_concurrent_downloads: usize,
    pub max_connections_per_download: usize,
    pub min_segment_size: u64,
    pub global_download_limit: Option<u64>,
    pub global_upload_limit: Option<u64>,
    pub schedule_rules: Vec<ScheduleRule>,
    pub user_agent: String,
    pub enable_dht: bool,
    pub enable_pex: bool,
    pub enable_lpd: bool,
    pub max_peers: usize,
    pub seed_ratio: f64,
    pub database_path: Option<PathBuf>,
    pub http: HttpConfig,
    pub torrent: TorrentConfig,
}

Main configuration for the download engine

Fields

download_dir: PathBuf

Directory to save downloads

max_concurrent_downloads: usize

Maximum concurrent downloads

max_connections_per_download: usize

Maximum connections per download (for segmented HTTP)

min_segment_size: u64

Minimum segment size in bytes (won’t split smaller than this)

global_download_limit: Option<u64>

Global download speed limit (bytes/sec, None = unlimited)

global_upload_limit: Option<u64>

Global upload speed limit (bytes/sec, None = unlimited)

schedule_rules: Vec<ScheduleRule>

Bandwidth schedule rules for time-based limits Rules are evaluated in order, first match wins

user_agent: String

Default user agent

enable_dht: bool

Enable DHT for torrents

enable_pex: bool

Enable PEX (Peer Exchange) for torrents

enable_lpd: bool

Enable LPD (Local Peer Discovery) for torrents

max_peers: usize

Maximum peers per torrent

seed_ratio: f64

Stop seeding when this ratio is reached

database_path: Option<PathBuf>

Database path for session persistence

http: HttpConfig

HTTP configuration

torrent: TorrentConfig

BitTorrent configuration

Implementations

impl EngineConfig

pub fn new() -> Self

Create a new config with default values

pub fn download_dir(self, path: impl Into<PathBuf>) -> Self

Set the download directory

pub fn max_concurrent_downloads(self, max: usize) -> Self

Set maximum concurrent downloads

pub fn max_connections_per_download(self, max: usize) -> Self

Set maximum connections per download

pub fn download_limit(self, limit: Option<u64>) -> Self

Set global download speed limit

pub fn upload_limit(self, limit: Option<u64>) -> Self

Set global upload speed limit

pub fn user_agent(self, ua: impl Into<String>) -> Self

Set the user agent

pub fn schedule_rules(self, rules: Vec<ScheduleRule>) -> Self

Set bandwidth schedule rules

pub fn add_schedule_rule(self, rule: ScheduleRule) -> Self

Add a bandwidth schedule rule

pub fn database_path(self, path: impl Into<PathBuf>) -> Self

Set the database path for persistence

pub fn validate(&self) -> Result<()>

Validate the configuration

pub fn get_database_path(&self) -> PathBuf

Get the database path, using default if not set

Trait Implementations

impl Clone for EngineConfig

fn clone(&self) -> EngineConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EngineConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for EngineConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for EngineConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for EngineConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.