use std::sync::Arc;
use tracing::{debug, info, warn};
use crate::request::request_group::DownloadStatus;
use crate::util::rwlock_ext::RwLockRecover;
impl super::RequestGroupMan {
pub fn fill_from_reserver(&self) -> Vec<Arc<std::sync::RwLock<super::RequestGroup>>> {
let _lifecycle = self.lifecycle_guard();
let max = self.max_concurrent();
let current_active = self.active_count();
let slots_available = if max == 0 {
self.reserved.len()
} else {
max.saturating_sub(current_active)
};
if slots_available == 0 || self.reserved.is_empty() {
return Vec::new();
}
let mut promoted = Vec::new();
let mut pending = Vec::new();
for _ in 0..slots_available {
let group = match self.reserved.pop_front() {
Some(g) => g,
None => break,
};
let gid = group.recover().gid();
if group.recover().is_pause_requested() {
debug!(
gid = gid.value(),
"Skipping paused group, adding to pending"
);
pending.push(group);
continue;
}
if !group.recover().is_dependency_resolved() {
let dep_desc = group
.recover()
.dependency
.recover()
.as_ref()
.map(|d| d.description())
.unwrap_or_default();
debug!(gid = gid.value(), "Dependency not resolved: {}", dep_desc);
pending.push(group);
continue;
}
group.recover().drop_piece_storage();
let paused = {
let mut g = group.recover_mut();
match g.status() {
DownloadStatus::Waiting => {
g.clear_command_failure();
g.start().ok(); g.control_flags.clear_pause();
false
}
DownloadStatus::Paused => true,
other => {
warn!(
gid = gid.value(),
?other,
"Unexpected status in reserved queue, skipping"
);
false
}
}
};
if paused {
pending.push(group);
continue;
}
let gid_val = gid;
self.active.insert(gid_val, Arc::clone(&group));
info!(
gid = gid_val.value(),
"Promoted group from reserved to active"
);
promoted.push(group);
}
for group in pending.into_iter().rev() {
self.reserved.push_front(group);
}
promoted
}
pub fn active_count(&self) -> usize {
self.active
.iter()
.filter(|entry| !entry.recover().is_seed_only())
.count()
}
pub fn exceeds_max_concurrent(&self) -> bool {
let max = self.max_concurrent();
max > 0 && self.active_count() > max
}
pub fn reduce_to_limit(&self) -> usize {
let max = self.max_concurrent();
if max == 0 {
return 0;
}
let excess = self.active_count().saturating_sub(max);
if excess == 0 {
return 0;
}
let mut paused = 0;
let entries: Vec<_> = self.active.iter().collect();
for entry in entries.into_iter().rev() {
if paused >= excess {
break;
}
let mut g = entry.recover_mut();
if !matches!(g.status(), DownloadStatus::Active) || g.is_seed_only() {
continue;
}
if g.pause().is_ok() {
g.request_restart();
paused += 1;
}
}
if paused > 0 {
info!(
paused,
"Paused excess active downloads to respect max_concurrent limit"
);
}
paused
}
}