compio-fs 0.12.0-rc.1

Filesystem IO for compio
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

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

use compio_driver::{
    ToSharedFd,
    op::{HardLink, Rename, Symlink, Unlink},
};

use crate::{
    DirBuilder, File, Metadata, OpenOptions, metadata_at, path_string, symlink_metadata_at,
};

#[derive(Debug, Clone)]
pub struct Dir {
    inner: File,
}

impl Dir {
    pub async fn open(path: impl AsRef<Path>) -> io::Result<Self> {
        let file = OpenOptions::new()
            .read(true)
            .custom_flags(libc::O_DIRECTORY)
            .open(path)
            .await?;
        Ok(Dir { inner: file })
    }

    pub async fn open_file_with(
        &self,
        path: impl AsRef<Path>,
        options: &OpenOptions,
    ) -> io::Result<File> {
        options.open_at(&self.inner, path).await
    }

    pub async fn open_dir(&self, path: impl AsRef<Path>) -> io::Result<Self> {
        let file = self
            .open_file_with(
                path,
                OpenOptions::new()
                    .read(true)
                    .custom_flags(libc::O_DIRECTORY),
            )
            .await?;
        Ok(Dir { inner: file })
    }

    pub async fn create_dir_with(
        &self,
        path: impl AsRef<Path>,
        builder: &DirBuilder,
    ) -> io::Result<()> {
        builder.create_at(&self.inner, path.as_ref()).await
    }

    pub async fn dir_metadata(&self) -> io::Result<Metadata> {
        self.inner.metadata().await
    }

    pub async fn metadata(&self, path: impl AsRef<Path>) -> io::Result<Metadata> {
        metadata_at(&self.inner, path).await
    }

    pub async fn symlink_metadata(&self, path: impl AsRef<Path>) -> io::Result<Metadata> {
        symlink_metadata_at(&self.inner, path).await
    }

    pub async fn hard_link(
        &self,
        source: impl AsRef<Path>,
        target_dir: &Self,
        target: impl AsRef<Path>,
    ) -> io::Result<()> {
        let source = path_string(source)?;
        let target = path_string(target)?;
        let op = HardLink::new(
            self.inner.to_shared_fd(),
            source,
            target_dir.inner.to_shared_fd(),
            target,
        );
        compio_runtime::submit(op).await.0?;
        Ok(())
    }

    pub async fn symlink(
        &self,
        original: impl AsRef<Path>,
        link: impl AsRef<Path>,
    ) -> io::Result<()> {
        let original = path_string(original)?;
        let link = path_string(link)?;
        let op = Symlink::new(original, self.inner.to_shared_fd(), link);
        compio_runtime::submit(op).await.0?;
        Ok(())
    }

    pub async fn rename(
        &self,
        from: impl AsRef<Path>,
        to_dir: &Self,
        to: impl AsRef<Path>,
    ) -> io::Result<()> {
        let from = path_string(from)?;
        let to = path_string(to)?;
        let op = Rename::new(
            self.inner.to_shared_fd(),
            from,
            to_dir.inner.to_shared_fd(),
            to,
        );
        compio_runtime::submit(op).await.0?;
        Ok(())
    }

    pub async fn remove_file(&self, path: impl AsRef<Path>) -> io::Result<()> {
        let path = path_string(path)?;
        let op = Unlink::new(self.inner.to_shared_fd(), path, false);
        compio_runtime::submit(op).await.0?;
        Ok(())
    }

    pub async fn remove_dir(&self, path: impl AsRef<Path>) -> io::Result<()> {
        let path = path_string(path)?;
        let op = Unlink::new(self.inner.to_shared_fd(), path, true);
        compio_runtime::submit(op).await.0?;
        Ok(())
    }
}

compio_driver::impl_raw_fd!(Dir, std::fs::File, inner);