tfio 0.3.1

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

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

use super::{AsyncOpFuture, AsyncRollbackableOperation};

/// Asynchronously creates a new file. Fails if the file already exists.
pub struct AsyncCreateFile {
    path: PathBuf,
}

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

impl AsyncRollbackableOperation for AsyncCreateFile {
    fn execute(&mut self) -> AsyncOpFuture<'_> {
        Box::pin(async move {
            tokio::fs::OpenOptions::new()
                .write(true)
                .create_new(true)
                .open(&self.path)
                .await
                .map(|_| ())
        })
    }

    fn rollback(&mut self) -> AsyncOpFuture<'_> {
        Box::pin(async move {
            match tokio::fs::remove_file(&self.path).await {
                Err(e) if e.kind() == io::ErrorKind::NotFound => Ok(()),
                other => other,
            }
        })
    }
}

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

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

impl AsyncRollbackableOperation for AsyncCreateDirectory {
    fn execute(&mut self) -> AsyncOpFuture<'_> {
        Box::pin(async move {
            // Walk up to find the topmost new component (sync metadata is fine here).
            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());
            tokio::fs::create_dir_all(&self.path).await
        })
    }

    fn rollback(&mut self) -> AsyncOpFuture<'_> {
        Box::pin(async move {
            match &self.created_root {
                Some(root) => match tokio::fs::remove_dir_all(root).await {
                    Err(e) if e.kind() == io::ErrorKind::NotFound => Ok(()),
                    other => other,
                },
                None => Ok(()),
            }
        })
    }
}