tfio 0.3.0

A library that provides a Transaction-like interface traditionally used in databases, applied to FileIO operations.
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

use std::fs;
use std::{
    io,
    path::{Path, PathBuf},
};

use crate::RollbackableOperation;

/// Creates a new file. Fails if the file already exists.
pub struct CreateFile {
    path: PathBuf,
}

impl CreateFile {
    /// Constructs a new `CreateFile` operation.
    pub fn new<S: AsRef<Path>>(path: S) -> Self {
        Self {
            path: path.as_ref().into(),
        }
    }
}

impl RollbackableOperation for CreateFile {
    fn execute(&mut self) -> io::Result<()> {
        fs::OpenOptions::new()
            .write(true)
            .create_new(true)
            .open(&self.path)
            .map(|_| ())
    }

    fn rollback(&mut self) -> io::Result<()> {
        match fs::remove_file(&self.path) {
            Err(e) if e.kind() == io::ErrorKind::NotFound => Ok(()),
            other => other,
        }
    }
}

/// Creates a new directory (and any missing parent directories).
pub struct CreateDirectory {
    path: PathBuf,
    created_root: Option<PathBuf>,
}

impl CreateDirectory {
    /// Constructs a new `CreateDirectory` operation.
    pub fn new<S: AsRef<Path>>(path: S) -> Self {
        Self {
            path: path.as_ref().into(),
            created_root: None,
        }
    }
}

impl RollbackableOperation for CreateDirectory {
    fn execute(&mut self) -> io::Result<()> {
        // Find the topmost path component that doesn't already exist so rollback
        // removes only what this operation created, not pre-existing parent dirs.
        let mut to_create: Option<&Path> = None;
        let mut cursor: &Path = &self.path;
        loop {
            if cursor.exists() {
                break;
            }
            to_create = Some(cursor);
            cursor = match cursor.parent() {
                Some(p) => p,
                None => break,
            };
        }
        self.created_root = to_create.map(|p| p.to_path_buf());
        fs::create_dir_all(&self.path)
    }

    fn rollback(&mut self) -> io::Result<()> {
        match &self.created_root {
            Some(root) => match fs::remove_dir_all(root) {
                Err(e) if e.kind() == io::ErrorKind::NotFound => Ok(()),
                other => other,
            },
            None => Ok(()),
        }
    }
}

#[cfg(test)]
mod tests {
    use tempfile::tempdir;

    use super::*;

    #[test]
    fn create_file_works() {
        let dir = tempdir().unwrap();
        let file_path = dir.path().join("create_file.txt");

        let mut op = CreateFile::new(&file_path);
        assert!(!file_path.exists());
        op.execute().unwrap();
        assert!(file_path.exists());
        op.rollback().unwrap();
        assert!(!file_path.exists());
    }

    #[test]
    fn create_file_fails_if_exists() {
        let dir = tempdir().unwrap();
        let file_path = dir.path().join("existing.txt");
        std::fs::write(&file_path, b"data").unwrap();

        let mut op = CreateFile::new(&file_path);
        assert!(op.execute().is_err());
    }

    #[test]
    fn create_dir_works() {
        let dir = tempdir().unwrap();
        let new_dir = dir.path().join("create_dir");

        let mut op = CreateDirectory::new(&new_dir);
        assert!(!new_dir.exists());
        op.execute().unwrap();
        assert!(new_dir.exists());
        op.rollback().unwrap();
        assert!(!new_dir.exists());
    }

    #[test]
    fn create_dir_nested_rollback_only_removes_created() {
        let dir = tempdir().unwrap();
        let parent = dir.path().join("existing_parent");
        let nested = parent.join("new_leaf");

        std::fs::create_dir_all(&parent).unwrap();

        let mut op = CreateDirectory::new(&nested);
        op.execute().unwrap();
        assert!(nested.exists());
        assert!(parent.exists());

        op.rollback().unwrap();
        assert!(!nested.exists());
        assert!(parent.exists());
    }
}