fsys 1.1.0

Filesystem IO for Rust storage engines: journal substrate, io_uring, NVMe passthrough, atomic writes, cross-platform durability.
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

//! Async directory CRUD wrappers. See [`crate::async_io`] for the
//! design rationale.

use crate::handle::Handle;
use crate::meta::DirEntry;
use crate::{Error, Result};
use std::path::{Path, PathBuf};
use std::sync::Arc;

impl Handle {
    /// Async variant of [`Handle::mkdir`].
    pub async fn mkdir_async(self: Arc<Self>, path: impl AsRef<Path>) -> Result<()> {
        super::require_runtime()?;
        let path: PathBuf = path.as_ref().to_path_buf();
        tokio::task::spawn_blocking(move || self.mkdir(&path))
            .await
            .map_err(join_error_to_io)?
    }

    /// Async variant of [`Handle::mkdir_all`].
    pub async fn mkdir_all_async(self: Arc<Self>, path: impl AsRef<Path>) -> Result<()> {
        super::require_runtime()?;
        let path: PathBuf = path.as_ref().to_path_buf();
        tokio::task::spawn_blocking(move || self.mkdir_all(&path))
            .await
            .map_err(join_error_to_io)?
    }

    /// Async variant of [`Handle::rmdir`].
    pub async fn rmdir_async(self: Arc<Self>, path: impl AsRef<Path>) -> Result<()> {
        super::require_runtime()?;
        let path: PathBuf = path.as_ref().to_path_buf();
        tokio::task::spawn_blocking(move || self.rmdir(&path))
            .await
            .map_err(join_error_to_io)?
    }

    /// Async variant of [`Handle::rmdir_all`].
    pub async fn rmdir_all_async(self: Arc<Self>, path: impl AsRef<Path>) -> Result<()> {
        super::require_runtime()?;
        let path: PathBuf = path.as_ref().to_path_buf();
        tokio::task::spawn_blocking(move || self.rmdir_all(&path))
            .await
            .map_err(join_error_to_io)?
    }

    /// Async variant of [`Handle::list`].
    pub async fn list_async(self: Arc<Self>, path: impl AsRef<Path>) -> Result<Vec<DirEntry>> {
        super::require_runtime()?;
        let path: PathBuf = path.as_ref().to_path_buf();
        tokio::task::spawn_blocking(move || self.list(&path))
            .await
            .map_err(join_error_to_io)?
    }

    /// Async variant of [`Handle::scan`].
    pub async fn scan_async(self: Arc<Self>, path: impl AsRef<Path>) -> Result<Vec<DirEntry>> {
        super::require_runtime()?;
        let path: PathBuf = path.as_ref().to_path_buf();
        tokio::task::spawn_blocking(move || self.scan(&path))
            .await
            .map_err(join_error_to_io)?
    }

    /// Async variant of [`Handle::scan_all`].
    pub async fn scan_all_async(self: Arc<Self>, path: impl AsRef<Path>) -> Result<Vec<DirEntry>> {
        super::require_runtime()?;
        let path: PathBuf = path.as_ref().to_path_buf();
        tokio::task::spawn_blocking(move || self.scan_all(&path))
            .await
            .map_err(join_error_to_io)?
    }

    /// Async variant of [`Handle::find`].
    pub async fn find_async(
        self: Arc<Self>,
        path: impl AsRef<Path>,
        pattern: impl Into<String>,
    ) -> Result<Vec<PathBuf>> {
        super::require_runtime()?;
        let path: PathBuf = path.as_ref().to_path_buf();
        let pattern: String = pattern.into();
        tokio::task::spawn_blocking(move || self.find(&path, &pattern))
            .await
            .map_err(join_error_to_io)?
    }

    /// Async variant of [`Handle::count`].
    pub async fn count_async(self: Arc<Self>, path: impl AsRef<Path>) -> Result<usize> {
        super::require_runtime()?;
        let path: PathBuf = path.as_ref().to_path_buf();
        tokio::task::spawn_blocking(move || self.count(&path))
            .await
            .map_err(join_error_to_io)?
    }

    /// Async variant of [`Handle::count_all`].
    pub async fn count_all_async(self: Arc<Self>, path: impl AsRef<Path>) -> Result<usize> {
        super::require_runtime()?;
        let path: PathBuf = path.as_ref().to_path_buf();
        tokio::task::spawn_blocking(move || self.count_all(&path))
            .await
            .map_err(join_error_to_io)?
    }

    /// Async variant of [`Handle::is_dir`].
    pub async fn is_dir_async(self: Arc<Self>, path: impl AsRef<Path>) -> Result<bool> {
        super::require_runtime()?;
        let path: PathBuf = path.as_ref().to_path_buf();
        tokio::task::spawn_blocking(move || self.is_dir(&path))
            .await
            .map_err(join_error_to_io)?
    }

    /// Async variant of [`Handle::is_file`].
    pub async fn is_file_async(self: Arc<Self>, path: impl AsRef<Path>) -> Result<bool> {
        super::require_runtime()?;
        let path: PathBuf = path.as_ref().to_path_buf();
        tokio::task::spawn_blocking(move || self.is_file(&path))
            .await
            .map_err(join_error_to_io)?
    }
}

fn join_error_to_io(e: tokio::task::JoinError) -> Error {
    Error::Io(std::io::Error::other(format!(
        "spawn_blocking task failed: {e}"
    )))
}