atomic-ops 0.1.1

Performs atomic operations in the filesystem
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

use std::{
    path::{Path, PathBuf},
    sync::Arc,
};

use serde::{Deserialize, Serialize};
use serde_flow::encoder::{bincode, FlowEncoder};

use crate::{
    error::{OpsError, OpsResult},
    operation::LoaderFn,
    process::{constants::DELETE_FILE_ID, Process},
};

#[derive(Serialize, Deserialize, Default)]
pub struct Op {
    from: PathBuf,

    #[serde(skip)]
    bytes: Vec<u8>,
}

impl Op {
    #[must_use]
    pub fn new(from: &Path) -> Self {
        let mut object = Self {
            from: from.to_path_buf(),
            bytes: Vec::new(),
        };
        object.bytes = bincode::Encoder::serialize(&object).unwrap();
        object
    }

    pub fn from_bytes(bytes: &[u8]) -> OpsResult<Self> {
        let mut decoded: Op =
            bincode::Encoder::deserialize(bytes).map_err(|_| OpsError::SerializeFailed)?;
        decoded.bytes = bytes.to_vec();
        Ok(decoded)
    }
}

pub fn load(bytes: &[u8]) -> OpsResult<Box<dyn Process>> {
    let value = Op::from_bytes(bytes)?;
    Ok(Box::new(value))
}

pub fn loader() -> (u8, LoaderFn) {
    (DELETE_FILE_ID, Arc::new(load))
}

impl Process for Op {
    #[inline]
    fn prepare(&self) -> OpsResult<()> {
        Ok(())
    }

    #[inline]
    fn run(&self) -> OpsResult<()> {
        Ok(())
    }

    #[inline]
    fn clean(&self) -> OpsResult<()> {
        std::fs::remove_file(self.from.as_path())?;
        Ok(())
    }

    #[inline]
    fn revert_prepare(&self) -> OpsResult<()> {
        Ok(())
    }

    #[inline]
    fn revert_run(&self) -> OpsResult<()> {
        Ok(())
    }

    fn id() -> u8 {
        DELETE_FILE_ID
    }

    fn as_bytes(&self) -> &[u8] {
        &self.bytes
    }
}

#[cfg(test)]
pub mod tests {

    #[test]
    fn remove_file() {}
}