usenet-dl 0.4.0

Highly configurable Usenet download manager library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

//! Download finalization — evaluate results and set final download status.

use crate::types::{Event, Status};

use super::context::DownloadTaskContext;
use super::orchestration::DownloadResults;

/// Evaluate download results and finalize the download status.
///
/// Marks the download as complete or failed based on the success/failure ratio,
/// removes from active tracking, and triggers post-processing on success.
pub(super) async fn finalize_download(
    ctx: DownloadTaskContext,
    results: DownloadResults,
    _total_size_bytes: u64,
) {
    let id = ctx.id;
    let DownloadResults {
        success_count,
        failed_count,
        first_error,
        total_articles,
        individually_failed,
    } = results;

    // Combine batch-level failures with individual article failures
    let total_failed = failed_count as u64 + individually_failed;
    let total = success_count as u64 + total_failed;
    let max_failure_ratio = ctx.config.download.max_failure_ratio;

    // Handle partial or total failures
    if total_failed > 0 {
        tracing::warn!(
            download_id = id.0,
            batch_failed = failed_count,
            individually_failed = individually_failed,
            total_failed = total_failed,
            succeeded = success_count,
            total = total,
            total_articles = total_articles,
            "Download completed with some failures"
        );

        if success_count == 0
            || (total > 0 && (total_failed as f64 / total as f64) > max_failure_ratio)
        {
            let error_msg = if let Some(ref first) = first_error {
                format!(
                    "{} of {} articles failed ({:.0}%). First error: {}",
                    total_failed,
                    total,
                    if total > 0 {
                        total_failed as f64 / total as f64 * 100.0
                    } else {
                        100.0
                    },
                    first,
                )
            } else {
                format!(
                    "{} of {} articles failed ({:.0}%)",
                    total_failed,
                    total,
                    if total > 0 {
                        total_failed as f64 / total as f64 * 100.0
                    } else {
                        100.0
                    },
                )
            };
            tracing::error!(
                download_id = id.0,
                total_failed = total_failed,
                succeeded = success_count,
                "Download failed - too many article failures"
            );
            ctx.mark_failed_with_stats(
                &error_msg,
                Some(success_count as u64),
                Some(total_failed),
                Some(total_articles as u64),
            )
            .await;
            ctx.remove_from_active().await;
            return;
        }
    }

    match ctx.db.has_any_pending_articles(id).await {
        Ok(true) => {
            if let Err(e) = ctx.db.update_status(id, Status::Paused.to_i32()).await {
                tracing::error!(
                    download_id = id.0,
                    error = %e,
                    "Failed to keep partially paused download paused"
                );
            }
            ctx.remove_from_active().await;
            return;
        }
        Ok(false) => {}
        Err(e) => {
            tracing::error!(
                download_id = id.0,
                error = %e,
                "Failed to check for remaining paused work"
            );
            ctx.remove_from_active().await;
            return;
        }
    }

    // Mark download as complete
    if let Err(e) = ctx.db.update_status(id, Status::Complete.to_i32()).await {
        tracing::error!(download_id = id.0, error = %e, "Failed to mark download complete");
        ctx.remove_from_active().await;
        return;
    }
    if let Err(e) = ctx.db.set_completed(id).await {
        tracing::error!(download_id = id.0, error = %e, "Failed to set completion time");
    }

    ctx.event_tx
        .send(Event::DownloadComplete {
            id,
            articles_failed: if total_failed > 0 {
                Some(total_failed)
            } else {
                None
            },
            articles_total: Some(total_articles as u64),
        })
        .ok();
    ctx.remove_from_active().await;
    ctx.spawn_post_processing();
}