dj 1.0.0

CLI-first backup solution with content-addressable storage
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

#[derive(Debug, thiserror::Error)]
pub enum Error {
    #[error("IO error: {0}")]
    Io(#[from] std::io::Error),

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

    #[error("Encryption error: {message}")]
    Encryption { message: String },

    #[error("Decryption error: {message}")]
    Decryption { message: String },

    #[error("Repository error: {message}")]
    Repository { message: String },

    #[error("Backend error: {message}")]
    Backend { message: String },

    #[error("Index error: {message}")]
    Index { message: String },

    #[error("Snapshot not found: {id}")]
    SnapshotNotFound { id: String },

    #[error("Object not found: {hash}")]
    ObjectNotFound { hash: String },

    #[error("Invalid hash: {hash}")]
    InvalidHash { hash: String },

    #[error("Corrupted data: {message}")]
    CorruptedData { message: String },

    #[error("Authentication failed: {message}")]
    Authentication { message: String },

    #[error("Permission denied: {message}")]
    PermissionDenied { message: String },

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

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

    #[error("Lock error: {message}")]
    Lock { message: String },

    #[error("Validation error: {message}")]
    Validation { message: String },

    #[error("Operation cancelled")]
    Cancelled,

    #[error("Operation timeout")]
    Timeout,

    #[error("Generic error: {0}")]
    Generic(#[from] anyhow::Error),
}

impl Error {
    pub fn encryption<S: Into<String>>(message: S) -> Self {
        Self::Encryption {
            message: message.into(),
        }
    }

    pub fn decryption<S: Into<String>>(message: S) -> Self {
        Self::Decryption {
            message: message.into(),
        }
    }

    pub fn repository<S: Into<String>>(message: S) -> Self {
        Self::Repository {
            message: message.into(),
        }
    }

    pub fn backend<S: Into<String>>(message: S) -> Self {
        Self::Backend {
            message: message.into(),
        }
    }

    pub fn index<S: Into<String>>(message: S) -> Self {
        Self::Index {
            message: message.into(),
        }
    }

    pub fn corrupted_data<S: Into<String>>(message: S) -> Self {
        Self::CorruptedData {
            message: message.into(),
        }
    }

    pub fn authentication<S: Into<String>>(message: S) -> Self {
        Self::Authentication {
            message: message.into(),
        }
    }

    pub fn network<S: Into<String>>(message: S) -> Self {
        Self::Network {
            message: message.into(),
        }
    }

    pub fn configuration<S: Into<String>>(message: S) -> Self {
        Self::Configuration {
            message: message.into(),
        }
    }

    pub fn lock<S: Into<String>>(message: S) -> Self {
        Self::Lock {
            message: message.into(),
        }
    }

    pub fn validation<S: Into<String>>(message: S) -> Self {
        Self::Validation {
            message: message.into(),
        }
    }
}

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