smirrors 0.1.0

Automatic mirror list updater for Linux distributions
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

use thiserror::Error;

/// Main error type for SMirrors operations
#[derive(Error, Debug)]
pub enum SMirrorsError {
    #[error("Failed to detect distribution")]
    DistroDetectionFailed,

    #[error("Unsupported distribution: {0}")]
    UnsupportedDistro(String),

    #[error("Mirror test failed for {url}: {reason}")]
    MirrorTestFailed { url: String, reason: String },

    #[error("Permission denied: {0}. Try running with sudo")]
    PermissionDenied(String),

    #[error("Configuration error: {0}")]
    ConfigError(String),

    #[error("Invalid configuration value for {key}: {value}")]
    InvalidConfigValue { key: String, value: String },

    #[error("Configuration file not found at {0}")]
    ConfigNotFound(String),

    #[error("IO error: {0}")]
    IoError(#[from] std::io::Error),

    #[error("Network error: {0}")]
    NetworkError(#[from] reqwest::Error),

    #[error("Database error: {0}")]
    DatabaseError(#[from] rusqlite::Error),

    #[error("Parse error: {0}")]
    ParseError(String),

    #[error("Regex error: {0}")]
    RegexError(#[from] regex::Error),

    #[error("URL parse error: {0}")]
    UrlError(#[from] url::ParseError),

    #[error("TOML deserialization error: {0}")]
    TomlDeError(#[from] toml::de::Error),

    #[error("TOML serialization error: {0}")]
    TomlSerError(#[from] toml::ser::Error),

    #[error("JSON error: {0}")]
    JsonError(#[from] serde_json::Error),

    #[error("Systemd error: {0}")]
    SystemdError(String),

    #[error("Backup not found: {0}")]
    BackupNotFound(String),

    #[error("Backup restore failed: {0}")]
    BackupRestoreFailed(String),

    #[error("Mirror list empty after filtering")]
    NoMirrorsAvailable,

    #[error("Test timeout after {0} seconds")]
    TestTimeout(u64),

    #[error("Update failed: {0}")]
    UpdateFailed(String),

    #[error("Validation failed: {0}")]
    ValidationFailed(String),

    #[error("Lock file exists at {0}. Another instance may be running")]
    LockFileExists(String),

    #[error("Async task join error: {0}")]
    JoinError(#[from] tokio::task::JoinError),
}

impl SMirrorsError {
    /// Create a permission denied error with context
    pub fn permission_denied(operation: &str) -> Self {
        Self::PermissionDenied(operation.to_string())
    }

    /// Create a config error with context
    pub fn config_error(message: impl Into<String>) -> Self {
        Self::ConfigError(message.into())
    }

    /// Create a parse error with context
    pub fn parse_error(message: impl Into<String>) -> Self {
        Self::ParseError(message.into())
    }

    /// Create a systemd error with context
    pub fn systemd_error(message: impl Into<String>) -> Self {
        Self::SystemdError(message.into())
    }

    /// Create an update failed error with context
    pub fn update_failed(message: impl Into<String>) -> Self {
        Self::UpdateFailed(message.into())
    }

    /// Create a validation failed error with context
    pub fn validation_failed(message: impl Into<String>) -> Self {
        Self::ValidationFailed(message.into())
    }

    /// Check if error is a network-related error
    pub fn is_network_error(&self) -> bool {
        matches!(self, Self::NetworkError(_) | Self::MirrorTestFailed { .. })
    }

    /// Check if error is a permission error
    pub fn is_permission_error(&self) -> bool {
        matches!(self, Self::PermissionDenied(_))
    }

    /// Check if error is recoverable
    pub fn is_recoverable(&self) -> bool {
        matches!(
            self,
            Self::NetworkError(_)
                | Self::MirrorTestFailed { .. }
                | Self::TestTimeout(_)
        )
    }
}