modde-sources 0.2.1

Download source implementations for modde
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

//! Core download-source contract: the [`DownloadSource`] trait, the
//! [`AnySource`] enum-dispatch wrapper, and the supporting value types
//! ([`DownloadHandle`], [`VerifiedFile`], [`ProgressCallback`]).

use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::sync::Arc;

use modde_core::manifest::wabbajack::DownloadDirective;

use crate::error::SourceResult;

/// Progress callback: (`bytes_downloaded`, `total_bytes`).
/// `total_bytes` may be 0 if unknown.
pub type ProgressCallback = Arc<dyn Fn(u64, u64) + Send + Sync>;

/// A resolved download ready for fetching.
#[derive(Debug, Clone)]
pub struct DownloadHandle {
    pub url: String,
    pub candidate_urls: Vec<String>,
    pub headers: HashMap<String, String>,
    pub expected_hash: u64,
    pub size_hint: Option<u64>,
}

/// A downloaded and hash-verified file.
#[derive(Debug, Clone)]
pub struct VerifiedFile {
    pub path: PathBuf,
    pub hash: u64,
}

/// Trait for download source implementations.
///
/// Each source (Nexus, GitHub, Google Drive, Mega, Direct URL) implements this
/// trait. `AnySource` provides zero-cost enum dispatch, while this trait enables
/// `impl DownloadSource` generics for monomorphization in hot paths.
pub trait DownloadSource: Send + Sync {
    /// Check if this source can handle the given directive.
    fn can_handle(&self, directive: &DownloadDirective) -> bool;

    /// Resolve a directive into a download handle with a concrete URL.
    fn resolve(
        &self,
        directive: &DownloadDirective,
    ) -> impl std::future::Future<Output = SourceResult<DownloadHandle>> + Send;

    /// Download the file to `dest` with progress reporting and verify its hash.
    fn download_with_progress(
        &self,
        handle: DownloadHandle,
        dest: &Path,
        progress: ProgressCallback,
    ) -> impl std::future::Future<Output = SourceResult<VerifiedFile>> + Send;

    /// Download the file to `dest` and verify its hash (no-op progress).
    fn download(
        &self,
        handle: DownloadHandle,
        dest: &Path,
    ) -> impl std::future::Future<Output = SourceResult<VerifiedFile>> + Send {
        let noop: ProgressCallback = Arc::new(|_, _| {});
        self.download_with_progress(handle, dest, noop)
    }
}

/// Enum dispatch for all download source implementations.
///
/// Wraps concrete source types for heterogeneous collections (e.g. `Vec<AnySource>`).
/// Each variant implements `DownloadSource`; the enum delegates via match.
pub enum AnySource {
    Nexus(crate::nexus::NexusSource),
    GitHub(crate::github::GitHubSource),
    GoogleDrive(crate::gdrive::GoogleDriveSource),
    Mega(crate::mega::MegaSource),
    MediaFire(crate::mediafire::MediaFireSource),
    Manual(crate::manual::ManualSource),
    Direct(crate::direct::DirectSource),
    WabbajackCdn(crate::wabbajack::cdn::WabbajackCdnSource),
}

/// Dispatch a non-async method call to the inner source variant.
macro_rules! dispatch {
    ($self:expr, $method:ident ( $($arg:expr),* )) => {
        match $self {
            AnySource::Nexus(s) => s.$method($($arg),*),
            AnySource::GitHub(s) => s.$method($($arg),*),
            AnySource::GoogleDrive(s) => s.$method($($arg),*),
            AnySource::Mega(s) => s.$method($($arg),*),
            AnySource::MediaFire(s) => s.$method($($arg),*),
            AnySource::Manual(s) => s.$method($($arg),*),
            AnySource::Direct(s) => s.$method($($arg),*),
            AnySource::WabbajackCdn(s) => s.$method($($arg),*),
        }
    };
}

/// Dispatch an async method call to the inner source variant.
macro_rules! dispatch_async {
    ($self:expr, $method:ident ( $($arg:expr),* )) => {
        match $self {
            AnySource::Nexus(s) => s.$method($($arg),*).await,
            AnySource::GitHub(s) => s.$method($($arg),*).await,
            AnySource::GoogleDrive(s) => s.$method($($arg),*).await,
            AnySource::Mega(s) => s.$method($($arg),*).await,
            AnySource::MediaFire(s) => s.$method($($arg),*).await,
            AnySource::Manual(s) => s.$method($($arg),*).await,
            AnySource::Direct(s) => s.$method($($arg),*).await,
            AnySource::WabbajackCdn(s) => s.$method($($arg),*).await,
        }
    };
}

impl DownloadSource for AnySource {
    fn can_handle(&self, directive: &DownloadDirective) -> bool {
        dispatch!(self, can_handle(directive))
    }

    async fn resolve(&self, directive: &DownloadDirective) -> SourceResult<DownloadHandle> {
        dispatch_async!(self, resolve(directive))
    }

    async fn download_with_progress(
        &self,
        handle: DownloadHandle,
        dest: &Path,
        progress: ProgressCallback,
    ) -> SourceResult<VerifiedFile> {
        dispatch_async!(self, download_with_progress(handle, dest, progress))
    }
}