aria2-core 0.3.3

aria2-rust core download engine: multi-protocol segmented downloads, rate limiting, configuration, session persistence, and BitTorrent seeding
Documentation
//! Stopped (completed/failed/removed) download result storage.
//!
//! Mirrors C++ `RequestGroupMan::downloadResults_`. Stores `DownloadResult`
//! entries for RPC `aria2.tellStopped` / `aria2.getDownloadResult` queries.

use crate::request::request_group::download_result::DownloadResult;
use crate::util::rwlock_ext::RwLockRecover;

/// Storage for completed/failed/removed download results.
pub struct StoppedResults {
    results: std::sync::RwLock<Vec<DownloadResult>>,
}

impl StoppedResults {
    /// Create empty result storage.
    pub fn new() -> Self {
        Self {
            results: std::sync::RwLock::new(Vec::new()),
        }
    }

    /// Add a download result if its GID is not already stored.
    ///
    /// The original `IndexedList` is keyed by GID and rejects duplicate
    /// insertion. Keep the first terminal snapshot and its position in the
    /// stopped-results FIFO when a lifecycle path races or is replayed.
    pub fn add(&self, result: DownloadResult) -> bool {
        let mut results = self.results.recover_mut();
        if results.iter().any(|existing| existing.gid == result.gid) {
            return false;
        }
        results.push(result);
        true
    }

    /// Number of stored results.
    pub fn len(&self) -> usize {
        self.results.recover().len()
    }

    /// Whether there are no stored results.
    #[allow(dead_code)]
    pub fn is_empty(&self) -> bool {
        self.results.recover().is_empty()
    }

    /// Find a result by GID hex string.
    pub fn find_by_hex(&self, hex: &str) -> Option<DownloadResult> {
        self.results
            .recover()
            .iter()
            .find(|r| r.gid_hex() == hex)
            .cloned()
    }

    /// Remove a result by GID hex string.
    pub fn remove_by_hex(&self, hex: &str) -> Option<DownloadResult> {
        let mut results = self.results.recover_mut();
        let pos = results.iter().position(|r| r.gid_hex() == hex)?;
        Some(results.remove(pos))
    }

    /// Purge all stored results.
    /// Mirrors C++ `RequestGroupMan::purgeDownloadResult()`.
    pub fn purge_all(&self) -> usize {
        let mut results = self.results.recover_mut();
        let count = results.len();
        results.clear();
        count
    }

    /// Remove the oldest (first) N results.
    /// Mirrors C++ `RequestGroupMan::purgeDownloadResult()` with limit.
    /// Used by housekeeping to enforce `MAX_DOWNLOAD_RESULT`.
    pub fn remove_oldest(&self, count: usize) -> usize {
        let mut results = self.results.recover_mut();
        let to_remove = count.min(results.len());
        results.drain(..to_remove);
        to_remove
    }

    /// Get results in the given range (offset, count).
    /// Returns a snapshot for RPC `tellStopped` pagination.
    /// Supports negative offset for reverse pagination (C++ `getPaginationRange`).
    pub fn get_range(&self, offset: i32, count: usize) -> Vec<DownloadResult> {
        let results = self.results.recover();
        let len = results.len() as i32;

        let start = if offset >= 0 {
            offset as usize
        } else {
            // Negative offset: count from the end
            (len + offset).max(0) as usize
        };

        if start >= len as usize {
            return Vec::new();
        }

        results.iter().skip(start).take(count).cloned().collect()
    }

    /// Iterate over all results (read-only snapshot).
    #[allow(dead_code)]
    pub fn iter_snapshot(&self) -> Vec<DownloadResult> {
        self.results.recover().clone()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::request::request_group::DownloadResultCode;

    fn make_result(gid_val: u64) -> DownloadResult {
        DownloadResult::new(
            crate::request::request_group::GroupId(gid_val),
            crate::request::request_group::DownloadStatus::Complete,
            DownloadResultCode::Finished,
        )
    }

    #[test]
    fn test_add_and_find() {
        let s = StoppedResults::new();
        assert!(s.add(make_result(1)));
        assert!(s.add(make_result(2)));
        assert_eq!(s.len(), 2);
    }

    #[test]
    fn test_duplicate_gid_is_rejected_without_reordering() {
        let s = StoppedResults::new();
        assert!(s.add(make_result(1)));
        assert!(s.add(make_result(2)));
        assert!(!s.add(DownloadResult::new(
            crate::request::request_group::GroupId(1),
            crate::request::request_group::DownloadStatus::Error("later".to_string()),
            crate::request::request_group::DownloadResultCode::UnknownError,
        )));

        let results = s.iter_snapshot();
        assert_eq!(results.len(), 2);
        assert_eq!(results[0].gid, crate::request::request_group::GroupId(1));
        assert_eq!(
            results[0].status,
            crate::request::request_group::DownloadStatus::Complete
        );
        assert_eq!(results[1].gid, crate::request::request_group::GroupId(2));
    }

    #[test]
    fn test_purge() {
        let s = StoppedResults::new();
        assert!(s.add(make_result(1)));
        assert!(s.add(make_result(2)));
        assert_eq!(s.purge_all(), 2);
        assert!(s.is_empty());
    }
}