mod demotion;
mod promotion;
mod reserved;
mod stopped;
use dashmap::DashMap;
use dashmap::mapref::entry::Entry;
use std::collections::{HashMap, HashSet};
use std::sync::Arc;
use std::sync::atomic::{AtomicU32, AtomicU64, Ordering};
use tracing::{debug, info, warn};
use reserved::{PositionMode, ReservedQueue};
use stopped::StoppedResults;
pub use reserved::PositionMode as ChangePositionMode;
use super::global_net_stat::GlobalNetStat;
use super::request_group::{DownloadOptions, DownloadStatus, GroupId, HaltReason, RequestGroup};
#[cfg(all(feature = "metalink", feature = "bittorrent"))]
use crate::engine::metalink_request_graph;
use crate::error::Result;
use crate::util::rwlock_ext::RwLockRecover;
pub struct RequestGroupMan {
groups: DashMap<GroupId, Arc<std::sync::RwLock<RequestGroup>>>,
active: DashMap<GroupId, Arc<std::sync::RwLock<RequestGroup>>>,
pub(super) reserved: ReservedQueue,
lifecycle_lock: std::sync::Mutex<()>,
pub(super) stopped: StoppedResults,
max_concurrent: AtomicU32,
next_gid: AtomicU64,
#[cfg(all(feature = "metalink", feature = "bittorrent"))]
graph_insert_lock: std::sync::Mutex<()>,
global_download_limit: std::sync::RwLock<Option<u64>>,
global_upload_limit: std::sync::RwLock<Option<u64>>,
global_net_stat: Arc<GlobalNetStat>,
}
impl RequestGroupMan {
pub fn new() -> Self {
info!("Initializing request group manager");
RequestGroupMan {
groups: DashMap::new(),
active: DashMap::new(),
reserved: ReservedQueue::new(),
lifecycle_lock: std::sync::Mutex::new(()),
stopped: StoppedResults::new(),
max_concurrent: AtomicU32::new(5), next_gid: AtomicU64::new(1),
#[cfg(all(feature = "metalink", feature = "bittorrent"))]
graph_insert_lock: std::sync::Mutex::new(()),
global_download_limit: std::sync::RwLock::new(None),
global_upload_limit: std::sync::RwLock::new(None),
global_net_stat: Arc::new(GlobalNetStat::default()),
}
}
fn lifecycle_guard(&self) -> std::sync::MutexGuard<'_, ()> {
self.lifecycle_lock
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
}
pub fn add_group(&self, uris: Vec<String>, options: DownloadOptions) -> Result<GroupId> {
let _lifecycle = self.lifecycle_guard();
let gid = self.generate_gid();
let memory_download = options.uses_memory_download();
let group = RequestGroup::new(gid, uris, options);
if memory_download {
group.mark_in_memory_download();
}
let group = Arc::new(std::sync::RwLock::new(group));
if !self.register_group(Arc::clone(&group)) {
return Err(crate::error::Aria2Error::DownloadFailed(format!(
"GID {} already exists",
gid.to_hex_string()
)));
}
self.reserved.push_back(group);
info!("Adding download task #{} (reserved)", gid.value());
debug!(
"Current reserved: {}, active: {}",
self.reserved.len(),
self.active.len()
);
Ok(gid)
}
pub fn add_group_arc(&self, group: Arc<std::sync::RwLock<RequestGroup>>) {
let _lifecycle = self.lifecycle_guard();
let gid = group.recover().gid();
if matches!(
group.recover().status(),
DownloadStatus::Complete | DownloadStatus::Error(_) | DownloadStatus::Removed
) {
warn!(gid = gid.value(), "Ignoring stale terminal request group");
return;
}
if !self.register_group(Arc::clone(&group)) {
warn!(gid = gid.value(), "Ignoring duplicate request group");
return;
}
self.next_gid
.fetch_max(gid.value().saturating_add(1), Ordering::SeqCst);
self.reserved.push_back(group);
info!(
"Adding download task #{} (reserved, pre-constructed)",
gid.value()
);
}
pub fn add_restored_group(&self, group: Arc<std::sync::RwLock<RequestGroup>>) -> Result<()> {
let _lifecycle = self.lifecycle_guard();
let gid = group.recover().gid();
if !self.register_group(Arc::clone(&group)) {
return Err(crate::error::Aria2Error::DownloadFailed(format!(
"GID {} already exists",
gid.to_hex_string()
)));
}
self.next_gid
.fetch_max(gid.value().saturating_add(1), Ordering::SeqCst);
self.reserved.push_back(group);
info!("Restored download task #{} (reserved)", gid.to_hex_string());
Ok(())
}
pub fn insert_reserved_at_front(&self, groups: Vec<Arc<std::sync::RwLock<RequestGroup>>>) {
let _lifecycle = self.lifecycle_guard();
let mut registered = Vec::with_capacity(groups.len());
for group in groups {
let gid = group.recover().gid();
if self.register_group(Arc::clone(&group)) {
registered.push(group);
} else {
warn!(gid = gid.value(), "Ignoring duplicate child request group");
}
}
let count = registered.len();
self.reserved.insert_front_batch(registered);
debug!("Inserted {} groups at front of reserved queue", count);
}
#[cfg(all(feature = "metalink", feature = "bittorrent"))]
pub fn add_metalink_graph(
&self,
graph: metalink_request_graph::MetalinkRequestGraph,
) -> Result<(GroupId, GroupId)> {
let _lifecycle = self.lifecycle_guard();
let _insert_guard = self.graph_insert_lock.lock().map_err(|_| {
crate::error::Aria2Error::DownloadFailed("graph insertion lock poisoned".to_string())
})?;
let metadata_gid = graph.metadata.recover().gid();
let payload_gid = graph.payload.recover().gid();
if metadata_gid == payload_gid {
return Err(crate::error::Aria2Error::DownloadFailed(
"Metalink graph metadata and payload must have distinct GIDs".to_string(),
));
}
if !self.register_group(Arc::clone(&graph.metadata)) {
return Err(crate::error::Aria2Error::DownloadFailed(
"Metalink graph contains a duplicate GID".to_string(),
));
}
if !self.register_group(Arc::clone(&graph.payload)) {
self.unregister_group(metadata_gid);
return Err(crate::error::Aria2Error::DownloadFailed(
"Metalink graph contains a duplicate GID".to_string(),
));
}
self.next_gid.fetch_max(
metadata_gid
.value()
.max(payload_gid.value())
.saturating_add(1),
Ordering::SeqCst,
);
self.reserved
.push_back_batch([graph.metadata, graph.payload]);
info!(
metadata_gid = metadata_gid.value(),
payload_gid = payload_gid.value(),
"Added Metalink request graph"
);
Ok((metadata_gid, payload_gid))
}
pub fn add_group_with_gid(
&self,
gid: GroupId,
uris: Vec<String>,
options: DownloadOptions,
) -> Result<()> {
let _lifecycle = self.lifecycle_guard();
let memory_download = options.uses_memory_download();
let group = RequestGroup::new(gid, uris, options);
if memory_download {
group.mark_in_memory_download();
}
let group = Arc::new(std::sync::RwLock::new(group));
if !self.register_group(Arc::clone(&group)) {
return Err(crate::error::Aria2Error::DownloadFailed(format!(
"GID {} already exists",
gid.to_hex_string()
)));
}
self.next_gid
.fetch_max(gid.value().saturating_add(1), Ordering::SeqCst);
self.reserved.push_back(group);
info!(
"Adding download task (RPC) #{} (reserved)",
gid.to_hex_string()
);
Ok(())
}
pub fn find_group(&self, gid: GroupId) -> Option<Arc<std::sync::RwLock<RequestGroup>>> {
self.groups.get(&gid).map(|entry| entry.value().clone())
}
pub fn group_by_hex(&self, hex: &str) -> Option<Arc<std::sync::RwLock<RequestGroup>>> {
let gid = GroupId::from_hex_string(hex)?;
self.find_group(gid)
}
pub fn group_by_id(&self, gid: GroupId) -> Option<Arc<std::sync::RwLock<RequestGroup>>> {
self.find_group(gid)
}
pub fn change_position(
&self,
gid: GroupId,
pos: i32,
mode: ChangePositionMode,
) -> Result<usize> {
let _lifecycle = self.lifecycle_guard();
if self.reserved.is_empty() {
return Err(crate::error::Aria2Error::InvalidArgument(
"reserved queue is empty".to_string(),
));
}
if pos < 0 && matches!(mode, PositionMode::SetFromStart | PositionMode::SetFromEnd) {
return Err(crate::error::Aria2Error::InvalidArgument(
"position must not be negative for absolute modes".to_string(),
));
}
self.reserved
.change_position(gid, pos, mode)
.ok_or_else(|| {
crate::error::Aria2Error::InvalidArgument(
"group is not in the reserved queue".to_string(),
)
})
}
pub fn remove_group_by_id(&self, gid: GroupId) -> Option<Arc<std::sync::RwLock<RequestGroup>>> {
let _lifecycle = self.lifecycle_guard();
let removed = self
.active
.remove(&gid)
.map(|(_, v)| v)
.or_else(|| self.reserved.remove_by_gid(gid));
if removed.is_some() {
self.unregister_group(gid);
}
removed
}
pub fn remove_group(&self, gid: GroupId) -> Result<()> {
let _lifecycle = self.lifecycle_guard();
if let Some(group_lock) = self.active.get(&gid).map(|entry| entry.value().clone()) {
let group = group_lock.recover();
group.request_halt(HaltReason::UserRequest);
info!("Requested removal of active download task #{}", gid.value());
return Ok(());
}
self.remove_reserved_group(gid)
}
fn remove_reserved_group(&self, gid: GroupId) -> Result<()> {
if self.reserved.find_by_gid(gid).is_none() {
return Err(crate::error::Aria2Error::InvalidArgument(format!(
"GID {} not found",
gid.value()
)));
}
if let Some(group_lock) = self.reserved.remove_by_gid(gid) {
let mut group = group_lock.recover_mut();
group.remove()?;
self.unregister_group(gid);
info!("Removing reserved download task #{}", gid.value());
self.stopped.add(group.create_download_result());
}
Ok(())
}
pub fn force_remove_group(&self, gid: GroupId) -> Result<()> {
let _lifecycle = self.lifecycle_guard();
if let Some(group_lock) = self.active.get(&gid).map(|entry| entry.value().clone()) {
group_lock
.recover()
.request_force_halt(HaltReason::UserRequest);
info!(
"Requested force removal of active download task #{}",
gid.value()
);
return Ok(());
}
self.remove_reserved_group(gid)
}
pub fn timeout_group(&self, gid: GroupId) -> bool {
if let Some(group_lock) = self.active.get(&gid).map(|entry| entry.value().clone()) {
let group = group_lock.recover();
group.request_halt(HaltReason::Timeout);
group.set_last_error(
crate::request::request_group::DownloadResultCode::TimeOut,
"Download timed out",
);
return true;
}
false
}
pub fn fail_spawned_group(&self, gid: GroupId, message: &str) -> bool {
let _lifecycle = self.lifecycle_guard();
if let Some((_, group)) = self.active.remove(&gid) {
self.unregister_group(gid);
group.recover_mut().mark_error(message.to_string());
let result = group.recover().create_download_result();
self.stopped.add(result);
debug!(
gid = gid.value(),
"Removed failed-spawn group from active and recorded error"
);
true
} else {
warn!(gid = gid.value(), "Failed-spawn group not found in active");
false
}
}
#[cfg(feature = "bittorrent")]
pub(super) fn fail_reserved_group(&self, gid: GroupId, message: &str) -> bool {
let _lifecycle = self.lifecycle_guard();
let Some(group) = self.reserved.remove_by_gid(gid) else {
warn!(gid = gid.value(), "Failed reserved group not found");
return false;
};
self.unregister_group(gid);
group.recover().mark_error_with_code(
crate::request::request_group::DownloadResultCode::BittorrentParseError,
message.to_string(),
);
self.stopped.add(group.recover().create_download_result());
info!(
gid = gid.value(),
"Recorded failed reserved dependency group"
);
true
}
pub fn pause_group(&self, gid: GroupId) -> Result<()> {
let _lifecycle = self.lifecycle_guard();
let group_lock = self.find_group(gid).ok_or_else(|| {
crate::error::Aria2Error::InvalidArgument(format!("GID {} not found", gid.value()))
})?;
let mut group = group_lock.recover_mut();
if !matches!(
group.status(),
DownloadStatus::Active | DownloadStatus::Waiting
) {
return Err(crate::error::Aria2Error::InvalidArgument(format!(
"GID#{} cannot be paused now",
gid.to_hex_string()
)));
}
group.pause()?;
info!("Pausing download task #{}", gid.value());
Ok(())
}
pub fn unpause_group(&self, gid: GroupId) -> Result<()> {
let _lifecycle = self.lifecycle_guard();
let group_lock = self.find_group(gid).ok_or_else(|| {
crate::error::Aria2Error::InvalidArgument(format!("GID {} not found", gid.value()))
})?;
let mut group = group_lock.recover_mut();
if !group.status().is_paused() {
return Err(crate::error::Aria2Error::InvalidArgument(format!(
"GID#{} cannot be unpaused now",
gid.to_hex_string()
)));
}
group.resume()?;
info!("Resuming download task #{}", gid.value());
Ok(())
}
pub fn force_pause_group(&self, gid: GroupId) -> Result<()> {
let _lifecycle = self.lifecycle_guard();
let group_lock = self.find_group(gid).ok_or_else(|| {
crate::error::Aria2Error::InvalidArgument(format!("GID {} not found", gid.value()))
})?;
let mut group = group_lock.recover_mut();
if !matches!(
group.status(),
DownloadStatus::Active | DownloadStatus::Waiting
) {
return Err(crate::error::Aria2Error::InvalidArgument(format!(
"GID#{} cannot be paused now",
gid.to_hex_string()
)));
}
group.force_pause()?;
Ok(())
}
pub fn pause_all(&self) {
let _lifecycle = self.lifecycle_guard();
for entry in self.groups.iter() {
let mut group = entry.recover_mut();
let _ = group.pause();
}
}
pub fn force_pause_all(&self) {
let _lifecycle = self.lifecycle_guard();
for entry in self.groups.iter() {
let mut group = entry.recover_mut();
let _ = group.force_pause();
}
}
pub fn unpause_all(&self) {
let _lifecycle = self.lifecycle_guard();
for entry in self.groups.iter() {
let mut group = entry.recover_mut();
let _ = group.resume();
}
}
pub fn halt_all(&self, reason: HaltReason) {
for entry in self.groups.iter() {
let group = entry.recover();
group.request_halt(reason);
}
}
pub fn force_halt_all(&self, reason: HaltReason) {
for entry in self.groups.iter() {
let group = entry.recover();
group.request_force_halt(reason);
}
}
pub fn force_remove_reserved(&self) -> usize {
let _lifecycle = self.lifecycle_guard();
let groups = self.reserved.drain();
let removed = groups.len();
for group_lock in groups {
let gid = group_lock.recover().gid();
let mut group = group_lock.recover_mut();
let _ = group.remove();
self.unregister_group(gid);
self.stopped.add(group.create_download_result());
}
if removed > 0 {
info!(removed, "Removed reserved downloads during force shutdown");
}
removed
}
pub fn update_group_options(
&self,
gid_hex: &str,
changes: HashMap<String, serde_json::Value>,
) -> std::result::Result<(), String> {
let group = self
.group_by_hex(gid_hex)
.ok_or_else(|| format!("GID {} not found", gid_hex))?;
group.recover_mut().apply_runtime_options(changes)
}
pub fn change_group_options(
&self,
gid_hex: &str,
changes: HashMap<String, serde_json::Value>,
) -> std::result::Result<(), String> {
let group = self
.group_by_hex(gid_hex)
.ok_or_else(|| format!("GID {} not found", gid_hex))?;
let gid = group.recover().gid();
let classified = group.recover().classify_runtime_options(changes)?;
let should_restart =
!classified.pending.is_empty() && group.recover().status().is_running();
{
let mut group = group.recover_mut();
group.apply_runtime_options(classified.immediate)?;
if !classified.pending.is_empty() {
group.set_pending_options(classified.pending);
}
}
if should_restart {
self.pause_group(gid).map_err(|error| error.to_string())?;
self.find_group(gid)
.ok_or_else(|| format!("GID {} disappeared during option update", gid.value()))?
.recover()
.request_restart();
}
Ok(())
}
pub fn get_group(&self, gid: GroupId) -> Option<Arc<std::sync::RwLock<RequestGroup>>> {
self.find_group(gid)
}
fn groups_snapshot(&self) -> Vec<(GroupId, Arc<std::sync::RwLock<RequestGroup>>)> {
let mut snapshot = Vec::with_capacity(self.groups.len());
let mut seen = HashSet::with_capacity(self.groups.len());
for entry in self.active.iter() {
let gid = *entry.key();
if seen.insert(gid) {
snapshot.push((gid, entry.value().clone()));
}
}
for group in self.reserved.iter_snapshot() {
let gid = group.recover().gid();
if seen.insert(gid) {
snapshot.push((gid, group));
}
}
for entry in self.groups.iter() {
let gid = *entry.key();
if seen.insert(gid) {
snapshot.push((gid, entry.value().clone()));
}
}
snapshot
}
pub fn is_group_active(&self, gid_hex: &str) -> std::result::Result<bool, String> {
let group = self
.group_by_hex(gid_hex)
.ok_or_else(|| format!("GID {} not found", gid_hex))?;
let g = group.recover();
Ok(g.status().is_active())
}
pub fn all_groups(&self) -> Vec<(GroupId, Arc<std::sync::RwLock<RequestGroup>>)> {
self.groups_snapshot()
}
pub fn list_groups(&self) -> Vec<Arc<std::sync::RwLock<RequestGroup>>> {
self.groups_snapshot()
.into_iter()
.map(|(_, group)| group)
.collect()
}
pub fn request_control_file_saves(&self) {
for group in self.list_groups() {
let group = group.recover();
if matches!(
group.status(),
DownloadStatus::Waiting | DownloadStatus::Active | DownloadStatus::Paused
) {
group.save_control_file();
}
}
}
pub fn get_active_groups(&self) -> Vec<Arc<std::sync::RwLock<RequestGroup>>> {
self.groups_snapshot()
.into_iter()
.filter(|entry| {
let g = entry.1.recover();
matches!(g.status(), DownloadStatus::Active)
})
.map(|(_, group)| group)
.collect()
}
pub fn get_waiting_groups(&self) -> Vec<Arc<std::sync::RwLock<RequestGroup>>> {
self.groups_snapshot()
.into_iter()
.filter(|g| {
matches!(
g.1.recover().status(),
DownloadStatus::Waiting | DownloadStatus::Paused
)
})
.map(|(_, group)| group)
.collect()
}
pub fn count(&self) -> usize {
self.groups.len()
}
pub fn stopped_count(&self) -> usize {
self.stopped.len()
}
pub fn max_concurrent(&self) -> usize {
self.max_concurrent.load(Ordering::Relaxed) as usize
}
pub fn set_max_concurrent(&self, max: u32) {
self.max_concurrent.store(max, Ordering::Relaxed);
info!(
"Max concurrent downloads set to {}",
if max == 0 {
"unlimited".to_string()
} else {
max.to_string()
}
);
}
pub fn set_global_speed_limit(&self, download_limit: Option<u64>, upload_limit: Option<u64>) {
*self.global_download_limit.recover_mut() = download_limit;
*self.global_upload_limit.recover_mut() = upload_limit;
debug!(
"Setting global speed limit - download: {:?}, upload: {:?}",
download_limit, upload_limit
);
}
pub fn global_download_limit(&self) -> Option<u64> {
*self.global_download_limit.recover()
}
pub fn global_upload_limit(&self) -> Option<u64> {
*self.global_upload_limit.recover()
}
pub fn clear_completed(&self) -> Result<usize> {
let _lifecycle = self.lifecycle_guard();
let to_remove: Vec<GroupId> = self
.active
.iter()
.filter_map(|entry| {
let group = entry.recover();
if matches!(
group.status(),
DownloadStatus::Complete | DownloadStatus::Error(_)
) {
Some(*entry.key())
} else {
None
}
})
.collect();
let mut count = to_remove.len();
for gid in &to_remove {
if self.active.remove(gid).is_some() {
self.unregister_group(*gid);
}
}
count += self.stopped.purge_all();
info!("Cleared {} completed tasks", count);
Ok(count)
}
pub fn get_stopped_results(
&self,
offset: i32,
count: usize,
) -> Vec<crate::request::request_group::DownloadResult> {
self.stopped.get_range(offset, count)
}
pub fn find_stopped_result(
&self,
hex: &str,
) -> Option<crate::request::request_group::DownloadResult> {
self.stopped.find_by_hex(hex)
}
pub fn remove_stopped_result(
&self,
hex: &str,
) -> Option<crate::request::request_group::DownloadResult> {
self.stopped.remove_by_hex(hex)
}
pub fn purge_stopped_results(&self) -> usize {
self.stopped.purge_all()
}
pub fn stopped_results_len(&self) -> usize {
self.stopped.len()
}
pub fn prune_stopped_results(&self, max: usize) -> usize {
let count = self.stopped.len();
if count > max {
let excess = count - max;
self.stopped.remove_oldest(excess)
} else {
0
}
}
pub fn next_available_gid(&self) -> GroupId {
self.generate_gid()
}
fn generate_gid(&self) -> GroupId {
let gid = self.next_gid.fetch_add(1, Ordering::SeqCst);
GroupId(gid)
}
fn register_group(&self, group: Arc<std::sync::RwLock<RequestGroup>>) -> bool {
let gid = group.recover().gid();
match self.groups.entry(gid) {
Entry::Vacant(entry) => {
group
.recover_mut()
.set_global_net_stat(Arc::clone(&self.global_net_stat));
entry.insert(group);
true
}
Entry::Occupied(_) => false,
}
}
fn unregister_group(&self, gid: GroupId) {
self.groups.remove(&gid);
}
pub fn download_finished(&self) -> bool {
self.groups.is_empty()
}
}
impl Default for RequestGroupMan {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::Arc;
use std::thread;
#[test]
fn test_concurrent_add_groups() {
let man = Arc::new(RequestGroupMan::new());
let num_tasks = 100;
let mut handles = vec![];
for i in 0..num_tasks {
let man_clone = man.clone();
let handle = thread::spawn(move || {
let uri = format!("http://example.com/file{}.bin", i);
let options = DownloadOptions::default();
man_clone.add_group(vec![uri], options)
});
handles.push(handle);
}
let results: Vec<_> = handles.into_iter().map(|h| h.join()).collect();
for result in results {
assert!(result.is_ok());
let gid = result.unwrap().unwrap();
assert!(gid.value() > 0);
}
assert_eq!(man.count(), num_tasks);
}
#[test]
fn stale_terminal_add_command_does_not_reinsert_group() {
let man = RequestGroupMan::new();
let gid = man
.add_group(
vec!["http://example.com/file.bin".to_string()],
DownloadOptions::default(),
)
.unwrap();
let group = man.find_group(gid).unwrap();
man.remove_group(gid).unwrap();
assert!(man.find_group(gid).is_none());
man.add_group_arc(group);
assert!(man.find_group(gid).is_none());
assert_eq!(man.reserved.len(), 0);
assert_eq!(man.stopped_count(), 1);
}
#[test]
fn control_file_save_requests_skip_terminal_groups() {
let man = RequestGroupMan::new();
let gids: Vec<_> = (0..6)
.map(|index| {
man.add_group(
vec![format!("http://example.com/file{index}.bin")],
DownloadOptions::default(),
)
.unwrap()
})
.collect();
man.fill_from_reserver();
man.find_group(gids[1])
.unwrap()
.recover_mut()
.pause()
.unwrap();
man.find_group(gids[2]).unwrap().recover().mark_complete();
man.find_group(gids[3])
.unwrap()
.recover()
.mark_error("failed".to_string());
man.find_group(gids[4]).unwrap().recover().mark_removed();
man.request_control_file_saves();
assert!(
man.find_group(gids[0])
.unwrap()
.recover()
.is_save_control_file_requested()
);
assert!(
man.find_group(gids[1])
.unwrap()
.recover()
.is_save_control_file_requested()
);
assert!(
man.find_group(gids[5])
.unwrap()
.recover()
.is_save_control_file_requested()
);
for gid in &gids[2..5] {
assert!(
!man.find_group(*gid)
.unwrap()
.recover()
.is_save_control_file_requested()
);
}
}
#[test]
fn registered_group_receives_session_transfer_counters() {
let man = RequestGroupMan::new();
let gid = man
.add_group(
vec!["http://example.com/file.bin".to_string()],
DownloadOptions::default(),
)
.unwrap();
let group = man.find_group(gid).expect("registered group");
let stats = group
.recover()
.global_net_stat()
.expect("manager counters must be injected");
stats.update_download(7);
assert_eq!(stats.session_download_length_for_test(), 7);
}
#[cfg(all(feature = "metalink", feature = "bittorrent"))]
#[test]
fn test_add_metalink_graph_is_metadata_first_and_dependency_gated() {
let man = RequestGroupMan::new();
let graph = crate::engine::metalink_request_graph::MetalinkRequestGraph::new(
"https://example.test/file.torrent",
"file.bin",
&DownloadOptions::default(),
GroupId::new(42),
GroupId::new(43),
)
.unwrap();
let (metadata_gid, payload_gid) = man.add_metalink_graph(graph).unwrap();
assert_eq!(metadata_gid, GroupId::new(42));
assert_eq!(payload_gid, GroupId::new(43));
assert_eq!(
man.reserved.iter_snapshot()[0].recover().gid(),
metadata_gid
);
assert_eq!(man.reserved.iter_snapshot()[1].recover().gid(), payload_gid);
assert!(
!man.find_group(payload_gid)
.unwrap()
.recover()
.is_dependency_resolved()
);
}
#[cfg(all(feature = "metalink", feature = "bittorrent"))]
#[test]
fn test_add_metalink_graph_rejects_duplicate_without_insertion() {
let man = RequestGroupMan::new();
man.add_group_with_gid(
GroupId::new(42),
vec!["https://example.test/existing".to_string()],
DownloadOptions::default(),
)
.unwrap();
let graph = crate::engine::metalink_request_graph::MetalinkRequestGraph::new(
"https://example.test/file.torrent",
"file.bin",
&DownloadOptions::default(),
GroupId::new(42),
GroupId::new(43),
)
.unwrap();
assert!(man.add_metalink_graph(graph).is_err());
assert!(man.find_group(GroupId::new(43)).is_none());
}
#[test]
fn test_add_group_with_gid_preserves_gid_and_advances_allocator() {
let man = RequestGroupMan::new();
let explicit_gid = GroupId::new(42);
man.add_group_with_gid(
explicit_gid,
vec!["http://example.com/file.bin".to_string()],
DownloadOptions::default(),
)
.unwrap();
assert!(man.find_group(explicit_gid).is_some());
let generated_gid = man
.add_group(
vec!["http://example.com/next.bin".to_string()],
DownloadOptions::default(),
)
.unwrap();
assert!(generated_gid.value() > explicit_gid.value());
}
#[test]
fn test_add_restored_group_preserves_gid_and_advances_allocator() {
let man = RequestGroupMan::new();
let gid = GroupId::new(0x2a);
let group = Arc::new(std::sync::RwLock::new(RequestGroup::new(
gid,
vec!["http://example.com/restored.bin".to_string()],
DownloadOptions::default(),
)));
man.add_restored_group(group).unwrap();
assert!(man.find_group(gid).is_some());
assert!(man.generate_gid().value() > gid.value());
}
#[test]
fn test_add_restored_group_rejects_duplicate_gid() {
let man = RequestGroupMan::new();
let gid = GroupId::new(0x2a);
let group = || {
Arc::new(std::sync::RwLock::new(RequestGroup::new(
gid,
vec!["http://example.com/restored.bin".to_string()],
DownloadOptions::default(),
)))
};
man.add_restored_group(group()).unwrap();
assert!(man.add_restored_group(group()).is_err());
}
#[test]
fn test_dependency_blocks_promotion_until_metadata_completes() {
let man = RequestGroupMan::new();
let metadata_gid = GroupId::new(10);
let payload_gid = GroupId::new(11);
let metadata = Arc::new(std::sync::RwLock::new(RequestGroup::new(
metadata_gid,
vec!["https://example.test/file.torrent".to_string()],
DownloadOptions::default(),
)));
let payload = Arc::new(std::sync::RwLock::new(RequestGroup::new(
payload_gid,
vec!["bt://payload".to_string()],
DownloadOptions::default(),
)));
payload.recover().set_dependency(Box::new(
crate::request::request_group::CompletionDependency::new(metadata_gid),
));
payload.recover().set_belongs_to_gid(metadata_gid);
man.add_restored_group(Arc::clone(&metadata)).unwrap();
man.add_restored_group(Arc::clone(&payload)).unwrap();
let promoted = man.fill_from_reserver();
assert_eq!(promoted.len(), 1);
assert_eq!(promoted[0].recover().gid(), metadata_gid);
assert!(man.find_group(payload_gid).is_some());
assert!(!payload.recover().is_dependency_resolved());
man.resolve_dependencies_for(metadata_gid);
let promoted = man.fill_from_reserver();
assert_eq!(promoted.len(), 1);
assert_eq!(promoted[0].recover().gid(), payload_gid);
}
#[cfg(all(feature = "metalink", feature = "bittorrent"))]
#[test]
fn test_failed_metadata_with_direct_fallback_releases_payload() {
let man = RequestGroupMan::new();
let graph = crate::engine::metalink_request_graph::MetalinkRequestGraph::new_with_fallback(
"https://example.test/file.torrent",
"file.bin",
&DownloadOptions::default(),
GroupId::new(30),
GroupId::new(31),
vec!["https://mirror.test/file.bin".to_string()],
)
.unwrap();
man.add_metalink_graph(graph).unwrap();
man.resolve_dependencies_for_status(
GroupId::new(30),
DownloadStatus::Error("metadata unavailable".to_string()),
);
let payload = man.find_group(GroupId::new(31)).expect("payload retained");
assert!(payload.recover().is_dependency_resolved());
assert_eq!(
payload.recover().uris(),
&["https://mirror.test/file.bin".to_string()]
);
}
#[cfg(feature = "metalink")]
#[test]
fn completed_stopped_result_includes_followed_by_child_gids() {
let man = RequestGroupMan::new();
let parent_gid = man
.add_group(
vec!["https://example.test/index.meta4".to_string()],
DownloadOptions::default(),
)
.unwrap();
let parent = man.find_group(parent_gid).expect("parent group");
parent
.recover()
.set_content_type("application/metalink4+xml");
parent.recover().set_in_memory_data(
br#"<?xml version="1.0"?><metalink xmlns="urn:ietf:params:xml:ns:metalink"><file name="payload.bin"><url>https://example.test/payload.bin</url></file></metalink>"#.to_vec(),
);
man.fill_from_reserver();
parent.recover().mark_complete();
let demoted = man.remove_stopped_groups(None);
assert_eq!(demoted, vec![parent_gid]);
let result = man
.find_stopped_result(&parent_gid.to_hex_string())
.expect("completed result must be stored");
assert_eq!(result.followed_by.len(), 1);
let child_gid = result.followed_by[0];
assert!(child_gid != parent_gid);
assert!(man.find_group(child_gid).is_some());
assert_eq!(man.reserved.len(), 1);
}
#[cfg(all(feature = "metalink", feature = "bittorrent"))]
#[test]
fn test_failed_torrent_only_metadata_is_stopped_as_error() {
let man = RequestGroupMan::new();
let graph = crate::engine::metalink_request_graph::MetalinkRequestGraph::new(
"https://example.test/file.torrent",
"file.bin",
&DownloadOptions::default(),
GroupId::new(40),
GroupId::new(41),
)
.unwrap();
man.add_metalink_graph(graph).unwrap();
man.resolve_dependencies_for_status(
GroupId::new(40),
DownloadStatus::Error("metadata unavailable".to_string()),
);
assert!(man.find_group(GroupId::new(41)).is_none());
assert_eq!(
man.find_stopped_result(&GroupId::new(41).to_hex_string())
.map(|result| result.code),
Some(crate::request::request_group::DownloadResultCode::BittorrentParseError)
);
}
#[test]
fn test_add_group_with_gid_accepts_zero_gid() {
let man = RequestGroupMan::new();
let zero_gid = GroupId::new(0);
man.add_group_with_gid(
zero_gid,
vec!["http://example.com/zero.bin".to_string()],
DownloadOptions::default(),
)
.unwrap();
assert!(man.find_group(zero_gid).is_some());
let generated_gid = man
.add_group(
vec!["http://example.com/next.bin".to_string()],
DownloadOptions::default(),
)
.unwrap();
assert_eq!(generated_gid, GroupId::new(1));
}
#[test]
fn test_add_group_with_gid_rejects_duplicate_gid() {
let man = RequestGroupMan::new();
let gid = GroupId::new(42);
let options = DownloadOptions::default();
man.add_group_with_gid(
gid,
vec!["http://example.com/file.bin".to_string()],
options.clone(),
)
.unwrap();
let result = man.add_group_with_gid(
gid,
vec!["http://example.com/other.bin".to_string()],
options,
);
assert!(result.is_err());
assert_eq!(man.count(), 1);
}
#[test]
fn test_add_group_goes_to_reserved() {
let man = RequestGroupMan::new();
let _gid = man
.add_group(
vec!["http://example.com/file.bin".to_string()],
DownloadOptions::default(),
)
.unwrap();
assert_eq!(man.active.len(), 0, "No groups should be active yet");
assert_eq!(man.reserved.len(), 1, "Group should be in reserved queue");
assert_eq!(man.count(), 1);
}
#[test]
fn test_seed_only_groups_do_not_consume_active_limit() {
let man = RequestGroupMan::new();
let gid = man
.add_group(
vec!["magnet:?xt=urn:btih:test".to_string()],
DownloadOptions {
bt_detach_seed_only: true,
..DownloadOptions::default()
},
)
.unwrap();
man.fill_from_reserver();
let group = man.find_group(gid).unwrap();
group.recover().enable_seed_only();
assert_eq!(man.active_count(), 0);
}
#[test]
fn test_max_concurrent() {
let man = RequestGroupMan::new();
assert_eq!(man.max_concurrent(), 5); man.set_max_concurrent(10);
assert_eq!(man.max_concurrent(), 10);
man.set_max_concurrent(0); assert_eq!(man.max_concurrent(), 0);
}
#[test]
fn test_find_group_searches_both() {
let man = RequestGroupMan::new();
let gid1 = man
.add_group(vec!["http://a.com".to_string()], DownloadOptions::default())
.unwrap();
let gid2 = GroupId(999);
let group2 = Arc::new(std::sync::RwLock::new(RequestGroup::new(
gid2,
vec!["http://b.com".to_string()],
DownloadOptions::default(),
)));
group2.recover_mut().start().unwrap();
assert!(man.register_group(Arc::clone(&group2)));
man.active.insert(gid2, group2);
assert!(man.find_group(gid1).is_some());
assert!(man.find_group(gid2).is_some());
assert!(man.find_group(GroupId(12345)).is_none());
}
#[test]
fn test_find_group_stays_visible_during_queue_transfer() {
let man = RequestGroupMan::new();
let gid = man
.add_group(
vec!["http://example.com/file.bin".to_string()],
DownloadOptions::default(),
)
.unwrap();
let promoted = man.fill_from_reserver();
assert_eq!(promoted.len(), 1);
let canonical = man.find_group(gid).expect("group must be indexed");
let moved = man.active.remove(&gid).expect("group must be active").1;
let during_active_removal = man
.find_group(gid)
.expect("lookup must survive active removal");
assert!(Arc::ptr_eq(&canonical, &during_active_removal));
man.reserved.push_front(Arc::clone(&moved));
let during_reserved_insert = man
.find_group(gid)
.expect("lookup must survive reserved insertion");
assert!(Arc::ptr_eq(&canonical, &during_reserved_insert));
let moved_back = man.reserved.pop_front().expect("group must be reserved");
let during_reserved_removal = man
.find_group(gid)
.expect("lookup must survive reserved removal");
assert!(Arc::ptr_eq(&canonical, &during_reserved_removal));
man.active.insert(gid, moved_back);
assert_eq!(man.count(), 1);
}
#[test]
fn test_group_snapshots_preserve_active_first_and_reserved_fifo() {
let man = RequestGroupMan::new();
man.set_max_concurrent(1);
let first = man
.add_group(
vec!["http://example.com/first.bin".to_string()],
DownloadOptions::default(),
)
.unwrap();
let second = man
.add_group(
vec!["http://example.com/second.bin".to_string()],
DownloadOptions::default(),
)
.unwrap();
let third = man
.add_group(
vec!["http://example.com/third.bin".to_string()],
DownloadOptions::default(),
)
.unwrap();
assert_eq!(man.fill_from_reserver().len(), 1);
let gids: Vec<_> = man.all_groups().into_iter().map(|(gid, _)| gid).collect();
assert_eq!(gids, vec![first, second, third]);
let waiting: Vec<_> = man
.get_waiting_groups()
.into_iter()
.map(|group| group.recover().gid())
.collect();
assert_eq!(waiting, vec![second, third]);
let active = man.active.remove(&first).expect("group must be active").1;
let during_transfer: Vec<_> = man.all_groups().into_iter().map(|(gid, _)| gid).collect();
assert_eq!(during_transfer, vec![second, third, first]);
man.reserved.push_front(active);
let after_requeue: Vec<_> = man.all_groups().into_iter().map(|(gid, _)| gid).collect();
assert_eq!(after_requeue, vec![first, second, third]);
}
#[test]
fn test_download_finished() {
let man = RequestGroupMan::new();
assert!(man.download_finished());
man.add_group(
vec!["http://example.com".to_string()],
DownloadOptions::default(),
)
.unwrap();
assert!(!man.download_finished());
}
#[test]
fn test_paused_group_requeues_to_reserved_and_can_resume() {
let man = RequestGroupMan::new();
let gid = man
.add_group(
vec!["http://example.com/file.bin".to_string()],
DownloadOptions::default(),
)
.unwrap();
let promoted = man.fill_from_reserver();
assert_eq!(promoted.len(), 1);
assert_eq!(man.active.len(), 1);
assert_eq!(man.reserved.len(), 0);
man.pause_group(gid).unwrap();
let group = man.find_group(gid).unwrap();
assert!(group.recover().status().is_paused());
let requeued = man.requeue_non_terminal_groups(None);
assert_eq!(requeued, 1, "paused group should be re-queued");
assert_eq!(man.active.len(), 0);
assert_eq!(man.reserved.len(), 1);
assert!(
man.find_group(gid).is_some(),
"paused group must still exist"
);
man.unpause_group(gid).unwrap();
let promoted = man.fill_from_reserver();
assert_eq!(promoted.len(), 1, "unpaused group must be re-promoted");
assert_eq!(man.active_count(), 1);
let status = man.find_group(gid).unwrap().recover().status();
assert_eq!(status, DownloadStatus::Active);
}
#[test]
fn paused_group_with_inflight_command_keeps_its_concurrency_slot() {
let man = RequestGroupMan::new();
man.set_max_concurrent(1);
let first = man
.add_group(
vec!["http://example.com/first.bin".to_string()],
DownloadOptions::default(),
)
.unwrap();
let second = man
.add_group(
vec!["http://example.com/second.bin".to_string()],
DownloadOptions::default(),
)
.unwrap();
assert_eq!(man.fill_from_reserver().len(), 1);
let first_group = man.find_group(first).unwrap();
first_group.recover().inc_commands();
man.pause_group(first).unwrap();
assert_eq!(man.active_count(), 1);
assert!(
man.fill_from_reserver().is_empty(),
"a paused command still draining must retain its active slot"
);
assert!(man.find_group(second).is_some());
assert_eq!(man.reserved.len(), 1);
}
#[test]
fn test_paused_reserved_group_is_not_promoted_until_unpaused() {
let man = RequestGroupMan::new();
let gid = man
.add_group(
vec!["http://example.com/file.bin".to_string()],
DownloadOptions::default(),
)
.unwrap();
let group = man.find_group(gid).unwrap();
{
let mut group = group.recover_mut();
group.pause().unwrap();
group.control_flags.clear_pause();
}
let promoted = man.fill_from_reserver();
assert!(promoted.is_empty(), "paused group must remain reserved");
assert_eq!(man.reserved.len(), 1);
assert_eq!(man.active.len(), 0);
assert!(man.find_group(gid).unwrap().recover().status().is_paused());
man.unpause_group(gid).unwrap();
let promoted = man.fill_from_reserver();
assert_eq!(promoted.len(), 1, "unpaused group should be promoted");
assert_eq!(man.active_count(), 1);
}
#[test]
fn test_restart_requested_group_auto_resumes_on_requeue() {
let man = RequestGroupMan::new();
let gid = man
.add_group(
vec!["http://example.com/file.bin".to_string()],
DownloadOptions::default(),
)
.unwrap();
man.fill_from_reserver();
{
let group = man.find_group(gid).unwrap();
let mut g = group.recover_mut();
g.pause().unwrap();
g.request_restart();
}
let requeued = man.requeue_non_terminal_groups(None);
assert_eq!(requeued, 1);
{
let group = man.find_group(gid).unwrap();
let g = group.recover();
assert_eq!(g.status(), DownloadStatus::Waiting);
assert!(!g.is_restart_requested(), "restart flag must be consumed");
assert!(
!g.is_pause_requested(),
"restart consumption must clear the pause request"
);
}
let promoted = man.fill_from_reserver();
assert_eq!(promoted.len(), 1);
assert_eq!(man.active_count(), 1);
}
#[test]
fn test_active_remove_requests_halt_without_removing_group() {
let man = RequestGroupMan::new();
let gid = man
.add_group(
vec!["http://example.com/file.bin".to_string()],
DownloadOptions::default(),
)
.unwrap();
man.fill_from_reserver();
man.remove_group(gid).unwrap();
let group = man.find_group(gid).expect("active group must be retained");
let guard = group.recover();
assert!(guard.is_halt_requested());
assert_eq!(guard.get_halt_reason(), HaltReason::UserRequest);
assert_eq!(man.stopped_count(), 0);
}
#[test]
fn test_force_remove_requests_force_halt_without_removing_group() {
let man = RequestGroupMan::new();
let gid = man
.add_group(
vec!["http://example.com/file.bin".to_string()],
DownloadOptions::default(),
)
.unwrap();
man.fill_from_reserver();
man.force_remove_group(gid).unwrap();
let group = man.find_group(gid).expect("active group must be retained");
let guard = group.recover();
assert!(guard.is_force_halt_requested());
assert_eq!(guard.get_halt_reason(), HaltReason::UserRequest);
}
#[test]
fn test_force_remove_waits_for_lifecycle_transition_lock() {
let man = Arc::new(RequestGroupMan::new());
let gid = man
.add_group(
vec!["http://example.com/file.bin".to_string()],
DownloadOptions::default(),
)
.unwrap();
man.fill_from_reserver();
let lifecycle = man.lifecycle_lock.lock().unwrap();
let (started_tx, started_rx) = std::sync::mpsc::channel();
let (completed_tx, completed_rx) = std::sync::mpsc::channel();
let worker = Arc::clone(&man);
let handle = thread::spawn(move || {
started_tx.send(()).unwrap();
completed_tx.send(worker.force_remove_group(gid)).unwrap();
});
started_rx
.recv_timeout(std::time::Duration::from_secs(1))
.unwrap();
assert!(
completed_rx
.recv_timeout(std::time::Duration::from_millis(100))
.is_err(),
"force removal must wait for the lifecycle transition lock"
);
drop(lifecycle);
assert!(
completed_rx
.recv_timeout(std::time::Duration::from_secs(1))
.unwrap()
.is_ok()
);
handle.join().unwrap();
let group = man
.find_group(gid)
.expect("active group must remain indexed");
assert!(group.recover().is_force_halt_requested());
}
#[test]
fn test_remove_group_writes_stopped_removed_result() {
use crate::request::request_group::DownloadResultCode;
let man = RequestGroupMan::new();
let gid = man
.add_group(
vec!["http://example.com/file.bin".to_string()],
DownloadOptions::default(),
)
.unwrap();
man.remove_group(gid).unwrap();
assert!(man.find_group(gid).is_none(), "group must be removed");
assert_eq!(man.stopped_count(), 1, "REMOVED result must be stored");
let result = man
.find_stopped_result(&gid.to_hex_string())
.expect("stopped result must be findable by GID");
assert_eq!(result.status, DownloadStatus::Removed);
assert_eq!(result.code, DownloadResultCode::Removed);
}
#[test]
fn test_fail_spawned_group_removes_from_active_and_records_error() {
let man = RequestGroupMan::new();
let gid = man
.add_group(
vec!["http://example.com/file.bin".to_string()],
DownloadOptions::default(),
)
.unwrap();
man.fill_from_reserver();
assert_eq!(man.active.len(), 1);
let ok = man.fail_spawned_group(gid, "Failed to spawn download task");
assert!(ok, "failed-spawn group should be handled");
assert!(
man.find_group(gid).is_none(),
"group must leave the manager"
);
assert_eq!(man.active.len(), 0, "group must not stay in active");
let result = man
.find_stopped_result(&gid.to_hex_string())
.expect("failed-spawn group must have a stopped result");
assert!(
matches!(result.status, DownloadStatus::Error(_)),
"failed-spawn group must be recorded as an error, got {:?}",
result.status
);
}
}