rustic_core 0.11.0

rustic_core - library for fast, encrypted, deduplicated backups that powers rustic-rs
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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

use std::sync::Arc;

use log::info;

/// A progress used to indicate/update the status of something which is being processed
#[derive(Debug, Clone)]
pub struct Progress(Arc<dyn RusticProgress>);

impl Progress {
    /// Create a new `Progress` from a suitable trait implementation
    pub fn new<P: RusticProgress>(p: P) -> Self {
        Self(Arc::new(p))
    }

    /// Create a new hidden `Progress`
    #[must_use]
    pub fn hidden() -> Self {
        Self(Arc::new(HiddenProgress))
    }

    /// Check if progress is hidden
    #[must_use]
    pub fn is_hidden(&self) -> bool {
        self.0.is_hidden()
    }

    /// Set total length for this progress
    ///
    /// # Arguments
    ///
    /// * `len` - The total length of this progress
    pub fn set_length(&self, len: u64) {
        self.0.set_length(len);
    }

    /// Set title for this progress
    ///
    /// # Arguments
    ///
    /// * `title` - The title of this progress
    pub fn set_title(&self, title: &str) {
        self.0.set_title(title);
    }

    /// Advance progress by given increment
    ///
    /// # Arguments
    ///
    /// * `inc` - The increment to advance this progress
    pub fn inc(&self, inc: u64) {
        self.0.inc(inc);
    }

    /// Finish the progress
    pub fn finish(&self) {
        self.0.finish();
    }
}

/// Trait to report progress information for any rustic action which supports that.
///
/// Implement this trait when you want to display this progress to your users.
pub trait RusticProgress: Send + Sync + 'static + std::fmt::Debug {
    /// Check if progress is hidden
    fn is_hidden(&self) -> bool;

    /// Set total length for this progress
    ///
    /// # Arguments
    ///
    /// * `len` - The total length of this progress
    fn set_length(&self, len: u64);

    /// Set title for this progress
    ///
    /// # Arguments
    ///
    /// * `title` - The title of this progress
    fn set_title(&self, title: &str);

    /// Advance progress by given increment
    ///
    /// # Arguments
    ///
    /// * `inc` - The increment to advance this progress
    fn inc(&self, inc: u64);

    /// Finish the progress
    fn finish(&self);
}

/// Type of progress
#[derive(Debug, Clone, Copy)]
pub enum ProgressType {
    /// a progress spinner. Note that this progress doesn't get a length and is not advanced, only finished.
    Spinner,
    /// a progress which counts something
    Counter,
    /// a progress which counts bytes
    Bytes,
}

/// Trait to start progress information report progress information for any rustic action which supports that.
///
/// Implement this trait when you want to display this progress to your users.
pub trait ProgressBars: std::fmt::Debug + Send + Sync + 'static {
    /// Start a new progress.
    ///
    /// # Arguments
    ///
    /// * `progress_type` - The type of the progress
    /// * `prefix` - The prefix of the progress
    fn progress(&self, progress_type: ProgressType, prefix: &str) -> Progress;
}

/// A Progress showing nothing at all
#[derive(Clone, Copy, Debug)]
pub struct HiddenProgress;
impl RusticProgress for HiddenProgress {
    fn is_hidden(&self) -> bool {
        true
    }
    fn set_length(&self, _len: u64) {}
    fn set_title(&self, _title: &str) {}
    fn inc(&self, _inc: u64) {}
    fn finish(&self) {}
}

/// A dummy struct which shows no progress but only logs titles and end of a progress.
#[derive(Clone, Copy, Debug)]
pub struct NoProgress;

impl RusticProgress for NoProgress {
    fn is_hidden(&self) -> bool {
        true
    }
    fn set_length(&self, _len: u64) {}
    fn set_title(&self, title: &str) {
        info!("{title}");
    }
    fn inc(&self, _inc: u64) {}
    fn finish(&self) {
        info!("finished.");
    }
}

/// Don't show progress bars, only log rudimentary progress information.
#[derive(Clone, Copy, Debug)]
pub struct NoProgressBars;

impl ProgressBars for NoProgressBars {
    fn progress(&self, _progress_type: ProgressType, prefix: &str) -> Progress {
        info!("{prefix}");
        Progress::new(NoProgress)
    }
}