use std::sync::Arc;
use tracing::{debug, warn};
use super::command::Command;
use super::engine_command::TaskResult;
use crate::dns::dns_cache::DnsCache;
use crate::error::Aria2Error;
use crate::ftp::FtpConnectionPool;
use crate::rate_limiter::RateLimiter;
use crate::request::request_group::{DownloadOptions, GroupId, RequestGroup};
use crate::util::rwlock_ext::RwLockRecover;
use tokio_util::sync::CancellationToken;
pub fn spawn_download_task(
group: Arc<std::sync::RwLock<RequestGroup>>,
_ftp_pool: Arc<FtpConnectionPool>,
_dns_cache: Arc<tokio::sync::Mutex<DnsCache>>,
global_limiter: Option<RateLimiter>,
generation: u64,
completion_tx: tokio::sync::mpsc::UnboundedSender<(GroupId, u64, TaskResult)>,
) -> Option<(tokio::task::JoinHandle<()>, CancellationToken)> {
let gid = group.recover().gid();
let uris = group.recover().uris().to_vec();
let options = group.recover().options_arc();
group.recover().inc_commands();
let first_uri = match uris.first() {
Some(u) => u.clone(),
None => {
warn!(gid = gid.value(), "No URIs in group, cannot spawn task");
group.recover().dec_commands();
return None;
}
};
let shutdown = CancellationToken::new();
let task_shutdown = shutdown.clone();
let dns_cache = _dns_cache;
let completion_tx = completion_tx.clone();
let handle = tokio::spawn(async move {
let result = tokio::select! {
command_result = create_command_for_group(
Arc::clone(&group),
first_uri,
options,
global_limiter,
dns_cache,
) => {
match command_result {
Ok(mut cmd) => tokio::select! {
result = cmd.execute() => result,
_ = task_shutdown.cancelled() => {
cmd.shutdown().await;
Err(Aria2Error::DownloadFailed("download shutdown requested".into()))
}
},
Err(error) => Err(error),
}
}
_ = task_shutdown.cancelled() => {
Err(Aria2Error::DownloadFailed("download shutdown requested".into()))
}
};
let task_result = match result {
Ok(()) => {
debug!(gid = gid.value(), "Download task completed successfully");
TaskResult::Success
}
Err(Aria2Error::Recoverable(recoverable)) => {
warn!(
gid = gid.value(),
"Download task failed with recoverable error"
);
TaskResult::Failed(Aria2Error::Recoverable(recoverable))
}
Err(e) => {
warn!(gid = gid.value(), error = %e, "Download task failed");
TaskResult::Failed(e)
}
};
if completion_tx.send((gid, generation, task_result)).is_err() {
debug!(
gid = gid.value(),
"Completion channel closed, engine likely shut down"
);
}
});
Some((handle, shutdown))
}
fn direct_origin(uri: &str) -> Option<(String, u16)> {
let parsed = url::Url::parse(uri).ok()?;
let scheme = parsed.scheme();
if !matches!(scheme, "http" | "https" | "ftp" | "ftps") {
return None;
}
Some((
parsed.host_str()?.to_string(),
parsed.port_or_known_default()?,
))
}
async fn create_command_for_group(
group: Arc<std::sync::RwLock<RequestGroup>>,
first_uri: String,
options: Arc<DownloadOptions>,
global_limiter: Option<RateLimiter>,
dns_cache: Arc<tokio::sync::Mutex<DnsCache>>,
) -> crate::error::Result<Box<dyn Command>> {
#[cfg(feature = "metalink")]
if let Some((metalink_data, file_index)) = group.recover().metalink_source() {
let base_uri = group.recover().metalink_base_uri();
let mut command = crate::engine::metalink_download_command::MetalinkDownloadCommand::new_with_group_source(
Arc::clone(&group),
&metalink_data,
file_index,
&options,
base_uri.as_deref(),
)?;
if let Some(limiter) = global_limiter {
command.set_global_limiter(limiter);
}
return Ok(Box::new(command));
}
create_command_for_uri(&first_uri, group, &options, global_limiter, &dns_cache).await
}
async fn create_command_for_uri(
uri: &str,
group: Arc<std::sync::RwLock<RequestGroup>>,
options: &DownloadOptions,
global_limiter: Option<RateLimiter>,
dns_cache: &Arc<tokio::sync::Mutex<DnsCache>>,
) -> crate::error::Result<Box<dyn Command>> {
let uri_lower = uri.to_lowercase();
#[cfg(feature = "sftp")]
if uri_lower.starts_with("sftp://") {
let mut cmd = crate::engine::sftp_download_command::SftpDownloadCommand::new_with_group(
Arc::clone(&group),
uri,
options,
options.dir.as_deref(),
options.out.as_deref(),
)?;
if let Some(limiter) = global_limiter {
cmd.set_global_limiter(limiter);
}
return Ok(Box::new(cmd));
}
#[cfg(feature = "bittorrent")]
if uri_lower.starts_with("bt://") {
let output_dir = options.dir.as_deref();
let torrent_bytes = group
.recover()
.bt_metadata_data()
.or_else(|| {
group
.recover()
.metadata_info()
.and_then(|info| info.metadata_path().map(std::path::PathBuf::from))
.and_then(|path| std::fs::read(path).ok())
})
.ok_or_else(|| {
Aria2Error::Fatal(crate::error::FatalError::Config(
"Resolved BitTorrent payload has no metadata source".to_string(),
))
})?;
let mut cmd = crate::engine::bt_download_command::BtDownloadCommand::new_with_group(
group,
&torrent_bytes,
options,
output_dir,
)?;
if let Some(limiter) = global_limiter {
cmd.set_global_limiter(limiter);
}
return Ok(Box::new(cmd));
}
#[cfg(feature = "bittorrent")]
if uri_lower.starts_with("magnet:") {
let output_dir = options.dir.as_deref();
let mut cmd =
crate::engine::magnet_download_command::MagnetDownloadCommand::new_with_group(
group, output_dir,
)?;
if let Some(limiter) = global_limiter.clone() {
cmd.set_global_limiter(limiter);
}
return Ok(Box::new(cmd));
}
if uri_lower.starts_with("ftp://") || uri_lower.starts_with("ftps://") {
let output_dir = options.dir.as_deref();
let output_name = options.out.as_deref();
let mut cmd = crate::engine::ftp_download_command::FtpDownloadCommand::new_with_group(
group,
output_dir,
output_name,
)?;
if let Some(limiter) = global_limiter.clone() {
cmd.set_global_limiter(limiter);
}
cmd.set_dns_cache(Arc::clone(dns_cache));
if let Some((hostname, port)) = direct_origin(uri)
&& let Ok(addresses) = dns_cache.lock().await.resolve(&hostname, port).await
{
cmd.set_resolved_addresses(addresses);
}
return Ok(Box::new(cmd));
}
let output_dir = options.dir.as_deref();
let group_output_name = group.recover().output_name();
let output_name = group_output_name.as_deref().or(options.out.as_deref());
let resolved_addresses = if let Some((hostname, port)) = direct_origin(uri) {
dns_cache.lock().await.resolve(&hostname, port).await.ok()
} else {
None
};
let mut cmd =
crate::engine::download_command::DownloadCommand::new_with_group_and_resolved_addresses(
group,
uri,
options,
output_dir,
output_name,
resolved_addresses,
)?;
if let Some(limiter) = global_limiter {
cmd.set_global_limiter(limiter);
}
Ok(Box::new(cmd))
}