Merge pull request #237 from Berrysoft:dev/new-fs

feat(fs): new fs methods

Author: George-Miao

compio-driver/src/iour/op.rs

@@ -198,6 +198,62 @@ impl OpCode for Sync {
     }
 }
 
+impl OpCode for Unlink {
+    fn create_entry(self: Pin<&mut Self>) -> OpEntry {
+        opcode::UnlinkAt::new(Fd(libc::AT_FDCWD), self.path.as_ptr())
+            .flags(if self.dir { libc::AT_REMOVEDIR } else { 0 })
+            .build()
+            .into()
+    }
+}
+
+impl OpCode for CreateDir {
+    fn create_entry(self: Pin<&mut Self>) -> OpEntry {
+        opcode::MkDirAt::new(Fd(libc::AT_FDCWD), self.path.as_ptr())
+            .mode(self.mode)
+            .build()
+            .into()
+    }
+}
+
+impl OpCode for Rename {
+    fn create_entry(self: Pin<&mut Self>) -> OpEntry {
+        opcode::RenameAt::new(
+            Fd(libc::AT_FDCWD),
+            self.old_path.as_ptr(),
+            Fd(libc::AT_FDCWD),
+            self.new_path.as_ptr(),
+        )
+        .build()
+        .into()
+    }
+}
+
+impl OpCode for Symlink {
+    fn create_entry(self: Pin<&mut Self>) -> OpEntry {
+        opcode::SymlinkAt::new(
+            Fd(libc::AT_FDCWD),
+            self.source.as_ptr(),
+            self.target.as_ptr(),
+        )
+        .build()
+        .into()
+    }
+}
+
+impl OpCode for HardLink {
+    fn create_entry(self: Pin<&mut Self>) -> OpEntry {
+        opcode::LinkAt::new(
+            Fd(libc::AT_FDCWD),
+            self.source.as_ptr(),
+            Fd(libc::AT_FDCWD),
+            self.target.as_ptr(),
+        )
+        .build()
+        .into()
+    }
+}
+
 impl OpCode for ShutdownSocket {
     fn create_entry(self: Pin<&mut Self>) -> OpEntry {
         opcode::Shutdown::new(Fd(self.fd), self.how())

compio-driver/src/op.rs

@@ -15,7 +15,10 @@ pub use crate::sys::op::{
     SendVectored,
 };
 #[cfg(unix)]
-pub use crate::sys::op::{FileStat, OpenFile, PathStat, ReadVectoredAt, WriteVectoredAt};
+pub use crate::sys::op::{
+    CreateDir, FileStat, HardLink, OpenFile, PathStat, ReadVectoredAt, Rename, Symlink, Unlink,
+    WriteVectoredAt,
+};
 use crate::sys::{sockaddr_storage, socklen_t, RawFd};
 
 /// Trait to update the buffer length inside the [`BufResult`].

compio-driver/src/poll/op.rs

@@ -288,6 +288,65 @@ impl OpCode for Sync {
     }
 }
 
+impl OpCode for Unlink {
+    fn pre_submit(self: Pin<&mut Self>) -> io::Result<Decision> {
+        Ok(Decision::blocking_dummy())
+    }
+
+    fn on_event(self: Pin<&mut Self>, _: &Event) -> Poll<io::Result<usize>> {
+        if self.dir {
+            syscall!(libc::rmdir(self.path.as_ptr()))?;
+        } else {
+            syscall!(libc::unlink(self.path.as_ptr()))?;
+        }
+        Poll::Ready(Ok(0))
+    }
+}
+
+impl OpCode for CreateDir {
+    fn pre_submit(self: Pin<&mut Self>) -> io::Result<Decision> {
+        Ok(Decision::blocking_dummy())
+    }
+
+    fn on_event(self: Pin<&mut Self>, _: &Event) -> Poll<io::Result<usize>> {
+        syscall!(libc::mkdir(self.path.as_ptr(), self.mode))?;
+        Poll::Ready(Ok(0))
+    }
+}
+
+impl OpCode for Rename {
+    fn pre_submit(self: Pin<&mut Self>) -> io::Result<Decision> {
+        Ok(Decision::blocking_dummy())
+    }
+
+    fn on_event(self: Pin<&mut Self>, _: &Event) -> Poll<io::Result<usize>> {
+        syscall!(libc::rename(self.old_path.as_ptr(), self.new_path.as_ptr()))?;
+        Poll::Ready(Ok(0))
+    }
+}
+
+impl OpCode for Symlink {
+    fn pre_submit(self: Pin<&mut Self>) -> io::Result<Decision> {
+        Ok(Decision::blocking_dummy())
+    }
+
+    fn on_event(self: Pin<&mut Self>, _: &Event) -> Poll<io::Result<usize>> {
+        syscall!(libc::symlink(self.source.as_ptr(), self.target.as_ptr()))?;
+        Poll::Ready(Ok(0))
+    }
+}
+
+impl OpCode for HardLink {
+    fn pre_submit(self: Pin<&mut Self>) -> io::Result<Decision> {
+        Ok(Decision::blocking_dummy())
+    }
+
+    fn on_event(self: Pin<&mut Self>, _: &Event) -> Poll<io::Result<usize>> {
+        syscall!(libc::link(self.source.as_ptr(), self.target.as_ptr()))?;
+        Poll::Ready(Ok(0))
+    }
+}
+
 impl OpCode for ShutdownSocket {
     fn pre_submit(self: Pin<&mut Self>) -> io::Result<Decision> {
         Ok(Decision::blocking_dummy())

compio-driver/src/unix/op.rs

@@ -144,6 +144,71 @@ impl<T: IoVectoredBuf> IntoInner for WriteVectoredAt<T> {
     }
 }
 
+/// Remove file or directory.
+pub struct Unlink {
+    pub(crate) path: CString,
+    pub(crate) dir: bool,
+}
+
+impl Unlink {
+    /// Create [`Unlink`].
+    pub fn new(path: CString, dir: bool) -> Self {
+        Self { path, dir }
+    }
+}
+
+/// Create a directory.
+pub struct CreateDir {
+    pub(crate) path: CString,
+    pub(crate) mode: libc::mode_t,
+}
+
+impl CreateDir {
+    /// Create [`CreateDir`].
+    pub fn new(path: CString, mode: libc::mode_t) -> Self {
+        Self { path, mode }
+    }
+}
+
+/// Rename a file or directory.
+pub struct Rename {
+    pub(crate) old_path: CString,
+    pub(crate) new_path: CString,
+}
+
+impl Rename {
+    /// Create [`Rename`].
+    pub fn new(old_path: CString, new_path: CString) -> Self {
+        Self { old_path, new_path }
+    }
+}
+
+/// Create a symlink.
+pub struct Symlink {
+    pub(crate) source: CString,
+    pub(crate) target: CString,
+}
+
+impl Symlink {
+    /// Create [`Symlink`]. `target` is a symlink to `source`.
+    pub fn new(source: CString, target: CString) -> Self {
+        Self { source, target }
+    }
+}
+
+/// Create a hard link.
+pub struct HardLink {
+    pub(crate) source: CString,
+    pub(crate) target: CString,
+}
+
+impl HardLink {
+    /// Create [`HardLink`]. `target` is a hard link to `source`.
+    pub fn new(source: CString, target: CString) -> Self {
+        Self { source, target }
+    }
+}
+
 impl ShutdownSocket {
     pub(crate) fn how(&self) -> i32 {
         match self.how {

compio-fs/src/lib.rs

@@ -20,6 +20,9 @@ pub use metadata::*;
 mod stdio;
 pub use stdio::*;
 
+mod utils;
+pub use utils::*;
+
 #[cfg(windows)]
 pub mod named_pipe;
 

compio-fs/src/utils/mod.rs

@@ -0,0 +1,158 @@
+#[cfg(unix)]
+#[path = "unix.rs"]
+mod sys;
+
+#[cfg(windows)]
+#[path = "windows.rs"]
+mod sys;
+
+use std::{io, path::Path};
+
+use compio_buf::{buf_try, BufResult, IoBuf};
+use compio_io::{AsyncReadAtExt, AsyncWriteAtExt};
+
+use crate::{metadata, File};
+
+/// Removes a file from the filesystem.
+pub async fn remove_file(path: impl AsRef<Path>) -> io::Result<()> {
+    sys::remove_file(path).await
+}
+
+/// Removes an empty directory.
+pub async fn remove_dir(path: impl AsRef<Path>) -> io::Result<()> {
+    sys::remove_dir(path).await
+}
+
+/// Creates a new, empty directory at the provided path.
+pub async fn create_dir(path: impl AsRef<Path>) -> io::Result<()> {
+    DirBuilder::new().create(path).await
+}
+
+/// Recursively create a directory and all of its parent components if they are
+/// missing.
+pub async fn create_dir_all(path: impl AsRef<Path>) -> io::Result<()> {
+    DirBuilder::new().recursive(true).create(path).await
+}
+
+/// Rename a file or directory to a new name, replacing the original file if
+/// `to` already exists.
+pub async fn rename(from: impl AsRef<Path>, to: impl AsRef<Path>) -> io::Result<()> {
+    sys::rename(from, to).await
+}
+
+/// Creates a new symbolic link on the filesystem.
+#[cfg(unix)]
+pub async fn symlink(original: impl AsRef<Path>, link: impl AsRef<Path>) -> io::Result<()> {
+    sys::symlink(original, link).await
+}
+
+/// Creates a new symlink to a non-directory file on the filesystem.
+#[cfg(windows)]
+pub async fn symlink_file(original: impl AsRef<Path>, link: impl AsRef<Path>) -> io::Result<()> {
+    sys::symlink_file(original, link).await
+}
+
+/// Creates a new symlink to a directory on the filesystem.
+#[cfg(windows)]
+pub async fn symlink_dir(original: impl AsRef<Path>, link: impl AsRef<Path>) -> io::Result<()> {
+    sys::symlink_dir(original, link).await
+}
+
+/// Creates a new hard link on the filesystem.
+pub async fn hard_link(original: impl AsRef<Path>, link: impl AsRef<Path>) -> io::Result<()> {
+    sys::hard_link(original, link).await
+}
+
+/// Write a slice as the entire contents of a file.
+///
+/// This function will create a file if it does not exist,
+/// and will entirely replace its contents if it does.
+pub async fn write<P: AsRef<Path>, B: IoBuf>(path: P, buf: B) -> BufResult<(), B> {
+    let (mut file, buf) = buf_try!(File::create(path).await, buf);
+    file.write_all_at(buf, 0).await
+}
+
+/// Read the entire contents of a file into a bytes vector.
+pub async fn read<P: AsRef<Path>>(path: P) -> io::Result<Vec<u8>> {
+    let file = File::open(path).await?;
+    let BufResult(res, buffer) = file.read_to_end_at(Vec::new(), 0).await;
+    res?;
+    Ok(buffer)
+}
+
+/// A builder used to create directories in various manners.
+pub struct DirBuilder {
+    inner: sys::DirBuilder,
+    recursive: bool,
+}
+
+impl Default for DirBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl DirBuilder {
+    /// Creates a new set of options with default mode/security settings for all
+    /// platforms and also non-recursive.
+    pub fn new() -> Self {
+        Self {
+            inner: sys::DirBuilder::new(),
+            recursive: false,
+        }
+    }
+
+    /// 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.
+    pub fn recursive(&mut self, recursive: bool) -> &mut Self {
+        self.recursive = recursive;
+        self
+    }
+
+    /// Creates the specified directory with the options configured in this
+    /// builder.
+    pub async fn create(&self, path: impl AsRef<Path>) -> io::Result<()> {
+        let path = path.as_ref();
+        if self.recursive {
+            self.create_dir_all(path).await
+        } else {
+            self.inner.create(path).await
+        }
+    }
+
+    async fn create_dir_all(&self, path: &Path) -> io::Result<()> {
+        if path == Path::new("") {
+            return Ok(());
+        }
+
+        match self.inner.create(path).await {
+            Ok(()) => return Ok(()),
+            Err(ref e) if e.kind() == io::ErrorKind::NotFound => {}
+            Err(_) if metadata(path).await.map(|m| m.is_dir()).unwrap_or_default() => return Ok(()),
+            Err(e) => return Err(e),
+        }
+        match path.parent() {
+            Some(p) => Box::pin(self.create_dir_all(p)).await?,
+            None => {
+                return Err(io::Error::new(
+                    io::ErrorKind::Other,
+                    "failed to create whole tree",
+                ));
+            }
+        }
+        match self.inner.create(path).await {
+            Ok(()) => Ok(()),
+            Err(_) if metadata(path).await.map(|m| m.is_dir()).unwrap_or_default() => Ok(()),
+            Err(e) => Err(e),
+        }
+    }
+}
+
+#[cfg(unix)]
+impl std::os::unix::fs::DirBuilderExt for DirBuilder {
+    fn mode(&mut self, mode: u32) -> &mut Self {
+        self.inner.mode(mode);
+        self
+    }
+}