takanawa-core 0.2.0

Core chunk planning and resumable .part file state for Takanawa range downloads
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

use std::path::PathBuf;

use thiserror::Error;

pub type Result<T> = std::result::Result<T, TakanawaError>;

#[derive(Debug, Error)]
pub enum TakanawaError {
    #[error("invalid config: {0}")]
    InvalidConfig(String),

    #[error("target file already exists: {0}")]
    TargetExists(PathBuf),

    #[error("part file is busy: {0}")]
    PartBusy(PathBuf),

    #[error("part file size mismatch: expected {expected} bytes, got {actual} bytes")]
    PartSizeMismatch { expected: u64, actual: u64 },

    #[error("part metadata is corrupt: {0}")]
    PartCorrupt(String),

    #[error("remote resource changed: {0}")]
    RemoteChanged(String),

    #[error("HTTP protocol violation: {0}")]
    HttpProtocol(String),

    #[error("retryable HTTP status: {0}")]
    RetryableHttpStatus(u16),

    #[error("network error: {0}")]
    Network(String),

    #[error("hash mismatch")]
    HashMismatch,

    #[error("download was cancelled")]
    Cancelled,

    #[error("download is already running")]
    AlreadyStarted,

    #[error("download is not running")]
    NotRunning,

    #[error("runtime is not initialized")]
    RuntimeNotInitialized,

    #[error("null pointer: {0}")]
    NullPointer(&'static str),

    #[error("ABI struct size mismatch for {name}: expected at least {expected}, got {actual}")]
    StructSizeMismatch {
        name: &'static str,
        expected: usize,
        actual: usize,
    },

    #[error("ABI mismatch: {0}")]
    AbiMismatch(String),

    #[error("invalid UTF-8: {0}")]
    Utf8(String),

    #[error("FFI error: {0}")]
    Ffi(String),

    #[error("I/O error: {0}")]
    Io(#[from] std::io::Error),
}

impl TakanawaError {
    #[must_use]
    pub fn is_retryable(&self) -> bool {
        matches!(self, Self::Network(_) | Self::RetryableHttpStatus(_))
    }
}