brume 0.1.0

A library for bidirectional file synchronization
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

use std::fmt::Display;

use concrete::ConcreteUpdateApplicationError;
use filesystem::VfsReloadError;
use thiserror::Error;
use update::{ReconciliationError, VfsUpdateApplicationError};
use vfs::InvalidPathError;

pub mod concrete;
pub mod filesystem;
pub mod sorted_vec;
pub mod synchro;
pub mod update;
pub mod vfs;

#[cfg(test)]
mod test_utils;

#[derive(Error, Debug)]
pub enum Error {
    #[error("failed to reload vfs from concrete FS {fs_name}")]
    VfsReloadError {
        fs_name: String,
        source: VfsReloadError,
    },
    #[error("failed to apply update to VFS node on {fs_name}")]
    VfsUpdateApplicationFailed {
        fs_name: String,
        source: VfsUpdateApplicationError,
    },
    #[error("failed to apply update to Concrete FS {fs_name}")]
    ConcreteUpdateFailed {
        fs_name: String,
        source: ConcreteUpdateApplicationError,
    },
    #[error("failed to reconcile updates from both filesystems")]
    ReconciliationFailed(#[from] ReconciliationError),
    #[error("Provided path is incorrect")]
    InvalidPath(#[from] InvalidPathError),
}

impl Error {
    pub fn vfs_reload<E: Into<VfsReloadError>>(fs_name: &str, source: E) -> Self {
        Self::VfsReloadError {
            fs_name: fs_name.to_string(),
            source: source.into(),
        }
    }

    pub fn vfs_update_application<E: Into<VfsUpdateApplicationError>>(
        fs_name: &str,
        source: E,
    ) -> Self {
        Self::VfsUpdateApplicationFailed {
            fs_name: fs_name.to_string(),
            source: source.into(),
        }
    }

    pub fn concrete_application<E: Into<ConcreteUpdateApplicationError>>(
        fs_name: &str,
        source: E,
    ) -> Self {
        Self::ConcreteUpdateFailed {
            fs_name: fs_name.to_string(),
            source: source.into(),
        }
    }

    /// Returns true if the error is caused by the concrete backend (eg: network down, no space
    /// left,...)
    pub fn is_concrete(&self) -> bool {
        match self {
            Error::VfsReloadError { source, .. } => match source {
                VfsReloadError::FsBackendError(_) => true,
                VfsReloadError::DiffError(_) => false,
            },
            Error::ReconciliationFailed(ReconciliationError::FsBackendError { .. }) => true,
            _ => false,
        }
    }
}

#[derive(Error, Debug)]
pub struct NameMismatchError {
    pub found: String,
    pub expected: String,
}

impl Display for NameMismatchError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "name mismatch, expected {}, got {}",
            self.expected, self.found
        )
    }
}