monoio 0.2.4

A thread per core runtime based on iouring.
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
147
148
149
150
151
152

mod unix;

use std::{io, os::unix::fs::DirBuilderExt, path::Path};

#[cfg(unix)]
use unix as sys;

/// A builder used to create directories in various manners.
///
/// This builder also supports platform-specific options.
pub struct DirBuilder {
    recursive: bool,
    inner: sys::BuilderInner,
}

impl DirBuilder {
    /// Creates a new set of options with default mode/security settings for all
    /// platforms and also non-recursive.
    ///
    /// This an async version of [`std::fs::DirBuilder::new`]
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use monoio::fs::DirBuilder;
    ///
    /// let builder = DirBuilder::new();
    /// ```
    pub fn new() -> Self {
        Self {
            recursive: false,
            inner: sys::BuilderInner::new(),
        }
    }

    /// Indicates that directories should be created recursively, creating all
    /// parent directories. Parents that do not exist are created with the same
    /// security and permissions settings.
    ///
    /// This option defaults to `false`.
    ///
    /// This an async version of [`std::fs::DirBuilder::recursive`]
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use monoio::fs::DirBuilder;
    ///
    /// let mut builder = DirBuilder::new();
    /// builder.recursive(true);
    /// ```
    pub fn recursive(&mut self, recursive: bool) -> &mut Self {
        self.recursive = recursive;
        self
    }

    /// Creates the specified directory with the options configured in this
    /// builder.
    ///
    /// It is considered an error if the directory already exists unless
    /// recursive mode is enabled.
    ///
    /// This is async version of [`std::fs::DirBuilder::create`] and use io-uring
    /// in support platform.
    ///
    /// # Errors
    ///
    /// An error will be returned under the following circumstances:
    ///
    /// * Path already points to an existing file.
    /// * Path already points to an existing directory and the mode is non-recursive.
    /// * The calling process doesn't have permissions to create the directory or its missing
    ///   parents.
    /// * Other I/O error occurred.
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use monoio::fs::DirBuilder;
    ///
    /// #[monoio::main]
    /// async fn main() -> std::io::Result<()> {
    ///     DirBuilder::new()
    ///         .recursive(true)
    ///         .create("/some/dir")
    ///         .await?;
    ///
    ///     Ok(())
    /// }
    /// ```
    pub async fn create<P: AsRef<Path>>(&self, path: P) -> io::Result<()> {
        if self.recursive {
            self.create_dir_all(path.as_ref()).await
        } else {
            self.inner.mkdir(path.as_ref()).await
        }
    }

    async fn create_dir_all(&self, path: &Path) -> io::Result<()> {
        if path == Path::new("") {
            return Ok(());
        }

        let mut inexist_path = path;
        let mut need_create = vec![];

        while match self.inner.mkdir(inexist_path).await {
            Ok(()) => false,
            Err(ref e) if e.kind() == io::ErrorKind::NotFound => true,
            Err(_) if is_dir(inexist_path).await => false,
            Err(e) => return Err(e),
        } {
            match inexist_path.parent() {
                Some(p) => {
                    need_create.push(inexist_path);
                    inexist_path = p;
                }
                None => {
                    return Err(io::Error::new(
                        io::ErrorKind::Other,
                        "failed to create whole tree",
                    ))
                }
            }
        }

        for p in need_create.into_iter().rev() {
            self.inner.mkdir(p).await?;
        }

        Ok(())
    }
}

impl Default for DirBuilder {
    fn default() -> Self {
        Self::new()
    }
}

impl DirBuilderExt for DirBuilder {
    fn mode(&mut self, mode: u32) -> &mut Self {
        self.inner.set_mode(mode);
        self
    }
}

// currently, will use the std version of metadata, will change to use the io-uring version
// when the statx is merge
async fn is_dir(path: &Path) -> bool {
    std::fs::metadata(path).is_ok_and(|metadata| metadata.is_dir())
}