aria2-core 0.3.9

aria2-rust core download engine: multi-protocol segmented downloads, rate limiting, configuration, session persistence, and BitTorrent seeding
Documentation
use std::path::PathBuf;
use std::sync::Arc;
use std::time::Duration;

use tokio::sync::{RwLock as TokioRwLock, oneshot};

use super::queue::{FileAllocationEntry, FileAllocationMan};
use super::{enqueue_multi, enqueue_path, shared};
use crate::filesystem::file_allocation::AllocationStrategy;

fn make_entry(gid: u64) -> FileAllocationEntry {
    let (sender, _receiver) = oneshot::channel();
    FileAllocationEntry::single(
        gid,
        PathBuf::from(format!("/tmp/test_{gid}")),
        1024 * 1024,
        AllocationStrategy::Trunc,
        false,
        sender,
    )
}

#[test]
fn queue_picks_and_drops_entries_in_order() {
    let mut manager = FileAllocationMan::new();
    assert!(!manager.has_next());
    assert!(!manager.is_picked());

    manager.push_entry(make_entry(1));
    manager.push_entry(make_entry(2));
    assert_eq!(manager.count_in_queue(), 2);

    assert_eq!(manager.take_next_owned().expect("first entry").gid, 1);
    assert!(manager.is_picked_gid(1));
    assert_eq!(manager.count_in_queue(), 1);
    assert_eq!(manager.active_count(), 1);

    manager.drop_picked();
    assert!(!manager.is_picked());
    assert_eq!(manager.take_next_owned().expect("second entry").gid, 2);
}

#[test]
fn queue_reports_gid_membership_and_total_entries() {
    let mut manager = FileAllocationMan::new();
    manager.push_entry(make_entry(1));
    manager.push_entry(make_entry(2));

    assert!(manager.is_queued_gid(1));
    assert!(!manager.is_picked_gid(1));
    assert_eq!(manager.total_entries(), 2);

    manager.take_next_owned();
    assert!(!manager.is_queued_gid(1));
    assert!(manager.is_picked_gid(1));
    assert_eq!(manager.total_entries(), 2);
}

#[test]
fn cancel_all_notifies_queued_waiters() {
    let manager = Arc::new(TokioRwLock::new(FileAllocationMan::new()));
    let (sender_a, receiver_a) = oneshot::channel();
    let (sender_b, receiver_b) = oneshot::channel();

    {
        let mut guard = manager.blocking_write();
        guard.push_entry(FileAllocationEntry::single(
            1,
            PathBuf::from("/tmp/a"),
            100,
            AllocationStrategy::Trunc,
            false,
            sender_a,
        ));
        guard.push_entry(FileAllocationEntry::single(
            2,
            PathBuf::from("/tmp/b"),
            100,
            AllocationStrategy::Trunc,
            false,
            sender_b,
        ));
    }

    manager.blocking_write().cancel_all();
    assert_eq!(manager.blocking_read().count_in_queue(), 0);
    assert!(receiver_a.blocking_recv().unwrap().is_err());
    assert!(receiver_b.blocking_recv().unwrap().is_err());
}

#[test]
fn cancel_gid_only_notifies_matching_waiters() {
    let manager = Arc::new(TokioRwLock::new(FileAllocationMan::new()));
    let (target_sender, target_receiver) = oneshot::channel();
    let (other_sender, mut other_receiver) = oneshot::channel();
    let (target_again_sender, target_again_receiver) = oneshot::channel();

    {
        let mut guard = manager.blocking_write();
        guard.push_entry(FileAllocationEntry::single(
            11,
            PathBuf::from("/tmp/target-a"),
            100,
            AllocationStrategy::Trunc,
            false,
            target_sender,
        ));
        guard.push_entry(FileAllocationEntry::single(
            12,
            PathBuf::from("/tmp/other"),
            100,
            AllocationStrategy::Trunc,
            false,
            other_sender,
        ));
        guard.push_entry(FileAllocationEntry::single(
            11,
            PathBuf::from("/tmp/target-b"),
            100,
            AllocationStrategy::Trunc,
            false,
            target_again_sender,
        ));
    }

    assert_eq!(manager.blocking_write().cancel_gid(11), 2);
    assert_eq!(manager.blocking_read().count_in_queue(), 1);
    assert!(target_receiver.blocking_recv().unwrap().is_err());
    assert!(target_again_receiver.blocking_recv().unwrap().is_err());
    assert!(other_receiver.try_recv().is_err());

    manager.blocking_write().cancel_all();
    assert!(other_receiver.blocking_recv().unwrap().is_err());
}

#[test]
fn default_manager_starts_empty() {
    let manager = FileAllocationMan::default();
    assert!(!manager.has_next());
    assert!(!manager.is_picked());
    assert_eq!(manager.total_entries(), 0);
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn enqueue_path_allocates_file() {
    let dir = tempfile::tempdir().unwrap();
    let path = dir.path().join("allocated.bin");
    let manager = super::dispatch::test_manager();

    enqueue_path(&manager, &path, 4096, AllocationStrategy::Trunc, false, 7)
        .await
        .unwrap();
    assert_eq!(tokio::fs::metadata(path).await.unwrap().len(), 4096);
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn enqueue_multi_allocates_nested_files() {
    let dir = tempfile::tempdir().unwrap();
    let files = vec![
        (dir.path().join("a.bin"), 8192u64),
        (dir.path().join("sub/b.bin"), 4096u64),
        (dir.path().join("empty.bin"), 0u64),
    ];
    let manager = super::dispatch::test_manager();

    enqueue_multi(&manager, files.clone(), AllocationStrategy::Trunc, false, 9)
        .await
        .unwrap();

    assert_eq!(tokio::fs::metadata(&files[0].0).await.unwrap().len(), 8192);
    assert_eq!(tokio::fs::metadata(&files[1].0).await.unwrap().len(), 4096);
    assert!(!files[2].0.exists());
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn preallocation_preserves_existing_prefix_and_skips_complete_file() {
    let dir = tempfile::tempdir().unwrap();
    let partial = dir.path().join("partial.bin");
    let complete = dir.path().join("complete.bin");
    let prefix = vec![0xA5u8; 4096];
    std::fs::write(&partial, &prefix).unwrap();
    std::fs::write(&complete, vec![0xABu8; 16_384]).unwrap();
    let manager = super::dispatch::test_manager();

    enqueue_multi(
        &manager,
        vec![(partial.clone(), 8192), (complete.clone(), 8192)],
        AllocationStrategy::Prealloc,
        false,
        10,
    )
    .await
    .unwrap();

    assert_eq!(tokio::fs::metadata(&partial).await.unwrap().len(), 8192);
    assert_eq!(tokio::fs::metadata(&complete).await.unwrap().len(), 16_384);
    assert_eq!(
        &tokio::fs::read(partial).await.unwrap()[..prefix.len()],
        prefix
    );
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn worker_keeps_fifo_order() {
    let dir = tempfile::tempdir().unwrap();
    let manager = super::dispatch::test_manager();

    let (sender_a, receiver_a) = oneshot::channel();
    manager
        .write()
        .await
        .push_entry(FileAllocationEntry::single(
            1,
            dir.path().join("big.bin"),
            2 * 1024 * 1024,
            AllocationStrategy::Prealloc,
            false,
            sender_a,
        ));
    tokio::time::sleep(Duration::from_millis(50)).await;

    let (sender_b, receiver_b) = oneshot::channel();
    manager
        .write()
        .await
        .push_entry(FileAllocationEntry::single(
            2,
            dir.path().join("small.bin"),
            4096,
            AllocationStrategy::Trunc,
            false,
            sender_b,
        ));

    tokio::time::timeout(Duration::from_secs(15), receiver_a)
        .await
        .expect("first allocation must finish")
        .unwrap()
        .unwrap();
    tokio::time::timeout(Duration::from_secs(15), receiver_b)
        .await
        .expect("second allocation must finish")
        .unwrap()
        .unwrap();
    assert_eq!(
        tokio::fs::metadata(dir.path().join("small.bin"))
            .await
            .unwrap()
            .len(),
        4096
    );
}

#[test]
fn shared_manager_is_process_wide() {
    let first = shared();
    let second = shared();
    assert!(Arc::ptr_eq(&first, &second));
}