do some programming
This commit is contained in:
Pat Hickey
353
crates/wasi-common/tokio/src/dir.rs
Normal file
353
crates/wasi-common/tokio/src/dir.rs
Normal file
@@ -0,0 +1,353 @@
|
|||||||
|
use crate::{
|
||||||
|
asyncify,
|
||||||
|
file::{filetype_from, File},
|
||||||
|
};
|
||||||
|
use cap_fs_ext::{DirEntryExt, DirExt, MetadataExt, SystemTimeSpec};
|
||||||
|
use std::any::Any;
|
||||||
|
use std::path::{Path, PathBuf};
|
||||||
|
use wasi_common::{
|
||||||
|
dir::{ReaddirCursor, ReaddirEntity, WasiDir},
|
||||||
|
file::{FdFlags, FileType, Filestat, OFlags, WasiFile},
|
||||||
|
Error, ErrorExt,
|
||||||
|
};
|
||||||
|
|
||||||
|
pub struct Dir(cap_std::fs::Dir);
|
||||||
|
|
||||||
|
impl Dir {
|
||||||
|
pub fn from_cap_std(dir: cap_std::fs::Dir) -> Self {
|
||||||
|
Dir(dir)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[wiggle::async_trait]
|
||||||
|
impl WasiDir for Dir {
|
||||||
|
fn as_any(&self) -> &dyn Any {
|
||||||
|
self
|
||||||
|
}
|
||||||
|
async fn open_file(
|
||||||
|
&self,
|
||||||
|
symlink_follow: bool,
|
||||||
|
path: &str,
|
||||||
|
oflags: OFlags,
|
||||||
|
read: bool,
|
||||||
|
write: bool,
|
||||||
|
fdflags: FdFlags,
|
||||||
|
) -> Result<Box<dyn WasiFile>, Error> {
|
||||||
|
use cap_fs_ext::{FollowSymlinks, OpenOptionsFollowExt};
|
||||||
|
use wasi_common::file::FdFlags;
|
||||||
|
|
||||||
|
let mut opts = cap_std::fs::OpenOptions::new();
|
||||||
|
|
||||||
|
if oflags.contains(OFlags::CREATE | OFlags::EXCLUSIVE) {
|
||||||
|
opts.create_new(true);
|
||||||
|
opts.write(true);
|
||||||
|
} else if oflags.contains(OFlags::CREATE) {
|
||||||
|
opts.create(true);
|
||||||
|
opts.write(true);
|
||||||
|
}
|
||||||
|
if oflags.contains(OFlags::TRUNCATE) {
|
||||||
|
opts.truncate(true);
|
||||||
|
}
|
||||||
|
if read {
|
||||||
|
opts.read(true);
|
||||||
|
}
|
||||||
|
if write {
|
||||||
|
opts.write(true);
|
||||||
|
} else {
|
||||||
|
// If not opened write, open read. This way the OS lets us open the file.
|
||||||
|
// If FileCaps::READ is not set, read calls will be rejected at the
|
||||||
|
// get_cap check.
|
||||||
|
opts.read(true);
|
||||||
|
}
|
||||||
|
if fdflags.contains(FdFlags::APPEND) {
|
||||||
|
opts.append(true);
|
||||||
|
}
|
||||||
|
|
||||||
|
if symlink_follow {
|
||||||
|
opts.follow(FollowSymlinks::Yes);
|
||||||
|
} else {
|
||||||
|
opts.follow(FollowSymlinks::No);
|
||||||
|
}
|
||||||
|
// the DSYNC, SYNC, and RSYNC flags are ignored! We do not
|
||||||
|
// have support for them in cap-std yet.
|
||||||
|
// ideally OpenOptions would just support this though:
|
||||||
|
// https://github.com/bytecodealliance/cap-std/issues/146
|
||||||
|
if fdflags.intersects(FdFlags::DSYNC | FdFlags::SYNC | FdFlags::RSYNC) {
|
||||||
|
return Err(Error::not_supported().context("SYNC family of FdFlags"));
|
||||||
|
}
|
||||||
|
|
||||||
|
let f = asyncify(move || self.0.open_with(Path::new(path), &opts)).await?;
|
||||||
|
let mut f = File::from_cap_std(f);
|
||||||
|
// NONBLOCK does not have an OpenOption either, but we can patch that on with set_fd_flags:
|
||||||
|
if fdflags.contains(FdFlags::NONBLOCK) {
|
||||||
|
f.set_fdflags(FdFlags::NONBLOCK).await?;
|
||||||
|
}
|
||||||
|
Ok(Box::new(f))
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn open_dir(&self, symlink_follow: bool, path: &str) -> Result<Box<dyn WasiDir>, Error> {
|
||||||
|
let path = unsafe { std::mem::transmute::<_, &'static str>(path) };
|
||||||
|
let d = if symlink_follow {
|
||||||
|
asyncify(move || self.0.open_dir(Path::new(path))).await?
|
||||||
|
} else {
|
||||||
|
asyncify(move || self.0.open_dir_nofollow(Path::new(path))).await?
|
||||||
|
};
|
||||||
|
Ok(Box::new(Dir::from_cap_std(d)))
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn create_dir(&self, path: &str) -> Result<(), Error> {
|
||||||
|
asyncify(|| self.0.create_dir(Path::new(path))).await?;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
async fn readdir(
|
||||||
|
&self,
|
||||||
|
cursor: ReaddirCursor,
|
||||||
|
) -> Result<Box<dyn Iterator<Item = Result<ReaddirEntity, Error>>>, Error> {
|
||||||
|
// cap_std's read_dir does not include . and .., we should prepend these.
|
||||||
|
// Why does the Ok contain a tuple? We can't construct a cap_std::fs::DirEntry, and we don't
|
||||||
|
// have enough info to make a ReaddirEntity yet.
|
||||||
|
let dir_meta = asyncify(|| self.0.dir_metadata()).await?;
|
||||||
|
let rd = vec![
|
||||||
|
{
|
||||||
|
let name = ".".to_owned();
|
||||||
|
Ok((FileType::Directory, dir_meta.ino(), name))
|
||||||
|
},
|
||||||
|
{
|
||||||
|
let name = "..".to_owned();
|
||||||
|
Ok((FileType::Directory, dir_meta.ino(), name))
|
||||||
|
},
|
||||||
|
]
|
||||||
|
.into_iter()
|
||||||
|
.chain(
|
||||||
|
// Now process the `DirEntry`s:
|
||||||
|
self.0.entries()?.map(|entry| {
|
||||||
|
let entry = entry?;
|
||||||
|
// XXX full_metadata blocks, but we arent in an async iterator:
|
||||||
|
let meta = entry.full_metadata()?;
|
||||||
|
let inode = meta.ino();
|
||||||
|
let filetype = filetype_from(&meta.file_type());
|
||||||
|
let name = entry
|
||||||
|
.file_name()
|
||||||
|
.into_string()
|
||||||
|
.map_err(|_| Error::illegal_byte_sequence().context("filename"))?;
|
||||||
|
Ok((filetype, inode, name))
|
||||||
|
}),
|
||||||
|
)
|
||||||
|
// Enumeration of the iterator makes it possible to define the ReaddirCursor
|
||||||
|
.enumerate()
|
||||||
|
.map(|(ix, r)| match r {
|
||||||
|
Ok((filetype, inode, name)) => Ok(ReaddirEntity {
|
||||||
|
next: ReaddirCursor::from(ix as u64 + 1),
|
||||||
|
filetype,
|
||||||
|
inode,
|
||||||
|
name,
|
||||||
|
}),
|
||||||
|
Err(e) => Err(e),
|
||||||
|
})
|
||||||
|
.skip(u64::from(cursor) as usize);
|
||||||
|
|
||||||
|
Ok(Box::new(rd))
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn symlink(&self, src_path: &str, dest_path: &str) -> Result<(), Error> {
|
||||||
|
asyncify(|| self.0.symlink(src_path, dest_path)).await?;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
async fn remove_dir(&self, path: &str) -> Result<(), Error> {
|
||||||
|
asyncify(|| self.0.remove_dir(Path::new(path))).await?;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn unlink_file(&self, path: &str) -> Result<(), Error> {
|
||||||
|
asyncify(|| self.0.remove_file_or_symlink(Path::new(path))).await?;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
async fn read_link(&self, path: &str) -> Result<PathBuf, Error> {
|
||||||
|
let link = asyncify(|| self.0.read_link(Path::new(path))).await?;
|
||||||
|
Ok(link)
|
||||||
|
}
|
||||||
|
async fn get_filestat(&self) -> Result<Filestat, Error> {
|
||||||
|
let meta = asyncify(|| self.0.dir_metadata()).await?;
|
||||||
|
Ok(Filestat {
|
||||||
|
device_id: meta.dev(),
|
||||||
|
inode: meta.ino(),
|
||||||
|
filetype: filetype_from(&meta.file_type()),
|
||||||
|
nlink: meta.nlink(),
|
||||||
|
size: meta.len(),
|
||||||
|
atim: meta.accessed().map(|t| Some(t.into_std())).unwrap_or(None),
|
||||||
|
mtim: meta.modified().map(|t| Some(t.into_std())).unwrap_or(None),
|
||||||
|
ctim: meta.created().map(|t| Some(t.into_std())).unwrap_or(None),
|
||||||
|
})
|
||||||
|
}
|
||||||
|
async fn get_path_filestat(
|
||||||
|
&self,
|
||||||
|
path: &str,
|
||||||
|
follow_symlinks: bool,
|
||||||
|
) -> Result<Filestat, Error> {
|
||||||
|
let meta = if follow_symlinks {
|
||||||
|
asyncify(|| self.0.metadata(Path::new(path))).await?
|
||||||
|
} else {
|
||||||
|
asyncify(|| self.0.symlink_metadata(Path::new(path))).await?
|
||||||
|
};
|
||||||
|
Ok(Filestat {
|
||||||
|
device_id: meta.dev(),
|
||||||
|
inode: meta.ino(),
|
||||||
|
filetype: filetype_from(&meta.file_type()),
|
||||||
|
nlink: meta.nlink(),
|
||||||
|
size: meta.len(),
|
||||||
|
atim: meta.accessed().map(|t| Some(t.into_std())).unwrap_or(None),
|
||||||
|
mtim: meta.modified().map(|t| Some(t.into_std())).unwrap_or(None),
|
||||||
|
ctim: meta.created().map(|t| Some(t.into_std())).unwrap_or(None),
|
||||||
|
})
|
||||||
|
}
|
||||||
|
async fn rename(
|
||||||
|
&self,
|
||||||
|
src_path: &str,
|
||||||
|
dest_dir: &dyn WasiDir,
|
||||||
|
dest_path: &str,
|
||||||
|
) -> Result<(), Error> {
|
||||||
|
let dest_dir = dest_dir
|
||||||
|
.as_any()
|
||||||
|
.downcast_ref::<Self>()
|
||||||
|
.ok_or(Error::badf().context("failed downcast to cap-std Dir"))?;
|
||||||
|
asyncify(|| {
|
||||||
|
self.0
|
||||||
|
.rename(Path::new(src_path), &dest_dir.0, Path::new(dest_path))
|
||||||
|
})
|
||||||
|
.await?;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
async fn hard_link(
|
||||||
|
&self,
|
||||||
|
src_path: &str,
|
||||||
|
target_dir: &dyn WasiDir,
|
||||||
|
target_path: &str,
|
||||||
|
) -> Result<(), Error> {
|
||||||
|
let target_dir = target_dir
|
||||||
|
.as_any()
|
||||||
|
.downcast_ref::<Self>()
|
||||||
|
.ok_or(Error::badf().context("failed downcast to cap-std Dir"))?;
|
||||||
|
let src_path = Path::new(src_path);
|
||||||
|
let target_path = Path::new(target_path);
|
||||||
|
asyncify(|| self.0.hard_link(src_path, &target_dir.0, target_path)).await?;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
async fn set_times(
|
||||||
|
&self,
|
||||||
|
path: &str,
|
||||||
|
atime: Option<wasi_common::SystemTimeSpec>,
|
||||||
|
mtime: Option<wasi_common::SystemTimeSpec>,
|
||||||
|
follow_symlinks: bool,
|
||||||
|
) -> Result<(), Error> {
|
||||||
|
asyncify(|| {
|
||||||
|
if follow_symlinks {
|
||||||
|
self.0.set_times(
|
||||||
|
Path::new(path),
|
||||||
|
convert_systimespec(atime),
|
||||||
|
convert_systimespec(mtime),
|
||||||
|
)
|
||||||
|
} else {
|
||||||
|
self.0.set_symlink_times(
|
||||||
|
Path::new(path),
|
||||||
|
convert_systimespec(atime),
|
||||||
|
convert_systimespec(mtime),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
})
|
||||||
|
.await?;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn convert_systimespec(t: Option<wasi_common::SystemTimeSpec>) -> Option<SystemTimeSpec> {
|
||||||
|
match t {
|
||||||
|
Some(wasi_common::SystemTimeSpec::Absolute(t)) => Some(SystemTimeSpec::Absolute(t)),
|
||||||
|
Some(wasi_common::SystemTimeSpec::SymbolicNow) => Some(SystemTimeSpec::SymbolicNow),
|
||||||
|
None => None,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod test {
|
||||||
|
use super::Dir;
|
||||||
|
#[tokio::test]
|
||||||
|
async fn scratch_dir() {
|
||||||
|
let tempdir = tempfile::Builder::new()
|
||||||
|
.prefix("cap-std-sync")
|
||||||
|
.tempdir()
|
||||||
|
.expect("create temporary dir");
|
||||||
|
let preopen_dir = unsafe { cap_std::fs::Dir::open_ambient_dir(tempdir.path()) }
|
||||||
|
.expect("open ambient temporary dir");
|
||||||
|
let preopen_dir = Dir::from_cap_std(preopen_dir);
|
||||||
|
wasi_common::WasiDir::open_dir(&preopen_dir, false, ".")
|
||||||
|
.await
|
||||||
|
.expect("open the same directory via WasiDir abstraction");
|
||||||
|
}
|
||||||
|
|
||||||
|
// Readdir does not work on windows, so we won't test it there.
|
||||||
|
#[cfg(not(windows))]
|
||||||
|
#[tokio::test]
|
||||||
|
async fn readdir() {
|
||||||
|
use std::collections::HashMap;
|
||||||
|
use wasi_common::dir::{ReaddirCursor, ReaddirEntity, WasiDir};
|
||||||
|
use wasi_common::file::{FdFlags, FileType, OFlags};
|
||||||
|
|
||||||
|
async fn readdir_into_map(dir: &dyn WasiDir) -> HashMap<String, ReaddirEntity> {
|
||||||
|
let mut out = HashMap::new();
|
||||||
|
for readdir_result in dir
|
||||||
|
.readdir(ReaddirCursor::from(0))
|
||||||
|
.await
|
||||||
|
.expect("readdir succeeds")
|
||||||
|
{
|
||||||
|
let entity = readdir_result.expect("readdir entry is valid");
|
||||||
|
out.insert(entity.name.clone(), entity);
|
||||||
|
}
|
||||||
|
out
|
||||||
|
}
|
||||||
|
|
||||||
|
let tempdir = tempfile::Builder::new()
|
||||||
|
.prefix("cap-std-sync")
|
||||||
|
.tempdir()
|
||||||
|
.expect("create temporary dir");
|
||||||
|
let preopen_dir = unsafe { cap_std::fs::Dir::open_ambient_dir(tempdir.path()) }
|
||||||
|
.expect("open ambient temporary dir");
|
||||||
|
let preopen_dir = Dir::from_cap_std(preopen_dir);
|
||||||
|
|
||||||
|
let entities = readdir_into_map(&preopen_dir).await;
|
||||||
|
assert_eq!(
|
||||||
|
entities.len(),
|
||||||
|
2,
|
||||||
|
"should just be . and .. in empty dir: {:?}",
|
||||||
|
entities
|
||||||
|
);
|
||||||
|
assert!(entities.get(".").is_some());
|
||||||
|
assert!(entities.get("..").is_some());
|
||||||
|
|
||||||
|
preopen_dir
|
||||||
|
.open_file(
|
||||||
|
false,
|
||||||
|
"file1",
|
||||||
|
OFlags::CREATE,
|
||||||
|
true,
|
||||||
|
false,
|
||||||
|
FdFlags::empty(),
|
||||||
|
)
|
||||||
|
.await
|
||||||
|
.expect("create file1");
|
||||||
|
|
||||||
|
let entities = readdir_into_map(&preopen_dir).await;
|
||||||
|
assert_eq!(entities.len(), 3, "should be ., .., file1 {:?}", entities);
|
||||||
|
assert_eq!(
|
||||||
|
entities.get(".").expect(". entry").filetype,
|
||||||
|
FileType::Directory
|
||||||
|
);
|
||||||
|
assert_eq!(
|
||||||
|
entities.get("..").expect(".. entry").filetype,
|
||||||
|
FileType::Directory
|
||||||
|
);
|
||||||
|
assert_eq!(
|
||||||
|
entities.get("file1").expect("file1 entry").filetype,
|
||||||
|
FileType::RegularFile
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
278
crates/wasi-common/tokio/src/file.rs
Normal file
278
crates/wasi-common/tokio/src/file.rs
Normal file
@@ -0,0 +1,278 @@
|
|||||||
|
use crate::asyncify;
|
||||||
|
use cap_fs_ext::MetadataExt;
|
||||||
|
use fs_set_times::{SetTimes, SystemTimeSpec};
|
||||||
|
use std::any::Any;
|
||||||
|
use std::convert::TryInto;
|
||||||
|
use std::io;
|
||||||
|
use system_interface::fs::{FileIoExt, GetSetFdFlags};
|
||||||
|
use system_interface::io::ReadReady;
|
||||||
|
use wasi_common::{
|
||||||
|
file::{Advice, FdFlags, FileType, Filestat, WasiFile},
|
||||||
|
Error, ErrorExt,
|
||||||
|
};
|
||||||
|
|
||||||
|
mod internal {
|
||||||
|
#[cfg(not(windows))]
|
||||||
|
use unsafe_io::os::posish::{AsRawFd, RawFd};
|
||||||
|
#[cfg(windows)]
|
||||||
|
use unsafe_io::os::windows::{AsRawHandleOrSocket, RawHandleOrSocket};
|
||||||
|
use unsafe_io::OwnsRaw;
|
||||||
|
use wasi_common::Error;
|
||||||
|
|
||||||
|
// This internal type wraps tokio's File so that we can impl the
|
||||||
|
// `AsUnsafeFile` trait. We impl this on an internal type, rather than on
|
||||||
|
// super::File, because we don't want consumers of this library to be able
|
||||||
|
// to use our `AsUnsafeFile`.
|
||||||
|
pub(super) struct Internal(pub(super) tokio::fs::File);
|
||||||
|
|
||||||
|
#[cfg(not(windows))]
|
||||||
|
impl AsRawFd for Internal {
|
||||||
|
fn as_raw_fd(&self) -> RawFd {
|
||||||
|
self.0.as_raw_fd()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(windows)]
|
||||||
|
impl AsRawHandleOrSocket for Internal {
|
||||||
|
fn as_raw_handle_or_socket(&self) -> RawHandleOrSocket {
|
||||||
|
self.0.as_raw_handle_or_socket()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Safety: `Internal` owns its handle.
|
||||||
|
unsafe impl OwnsRaw for Internal {}
|
||||||
|
|
||||||
|
// Tokio provides implementations of these methods, which are not
|
||||||
|
// available via AsUnsafeFile.
|
||||||
|
impl Internal {
|
||||||
|
pub async fn set_len(&self, size: u64) -> Result<(), Error> {
|
||||||
|
Ok(self.0.set_len(size).await?)
|
||||||
|
}
|
||||||
|
pub async fn sync_data(&self) -> Result<(), Error> {
|
||||||
|
Ok(self.0.sync_data().await?)
|
||||||
|
}
|
||||||
|
pub async fn sync_all(&self) -> Result<(), Error> {
|
||||||
|
Ok(self.0.sync_all().await?)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub struct File(internal::Internal);
|
||||||
|
|
||||||
|
impl File {
|
||||||
|
pub fn from_cap_std(file: cap_std::fs::File) -> Self {
|
||||||
|
File(internal::Internal(tokio::fs::File::from_std(
|
||||||
|
file.into_std(),
|
||||||
|
)))
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn metadata(&self) -> Result<cap_std::fs::Metadata, Error> {
|
||||||
|
use unsafe_io::AsUnsafeFile;
|
||||||
|
asyncify(|| Ok(cap_std::fs::Metadata::from_file(&self.0.as_file_view())?)).await
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[wiggle::async_trait]
|
||||||
|
impl WasiFile for File {
|
||||||
|
fn as_any(&self) -> &dyn Any {
|
||||||
|
self
|
||||||
|
}
|
||||||
|
async fn datasync(&self) -> Result<(), Error> {
|
||||||
|
self.0.sync_data().await
|
||||||
|
}
|
||||||
|
async fn sync(&self) -> Result<(), Error> {
|
||||||
|
self.0.sync_all().await
|
||||||
|
}
|
||||||
|
async fn get_filetype(&self) -> Result<FileType, Error> {
|
||||||
|
let meta = self.metadata().await?;
|
||||||
|
Ok(filetype_from(&meta.file_type()))
|
||||||
|
}
|
||||||
|
async fn get_fdflags(&self) -> Result<FdFlags, Error> {
|
||||||
|
let fdflags = asyncify(|| self.0.get_fd_flags()).await?;
|
||||||
|
Ok(from_sysif_fdflags(fdflags))
|
||||||
|
}
|
||||||
|
async fn set_fdflags(&mut self, fdflags: FdFlags) -> Result<(), Error> {
|
||||||
|
if fdflags.intersects(
|
||||||
|
wasi_common::file::FdFlags::DSYNC
|
||||||
|
| wasi_common::file::FdFlags::SYNC
|
||||||
|
| wasi_common::file::FdFlags::RSYNC,
|
||||||
|
) {
|
||||||
|
return Err(Error::invalid_argument().context("cannot set DSYNC, SYNC, or RSYNC flag"));
|
||||||
|
}
|
||||||
|
asyncify(move || self.0.set_fd_flags(to_sysif_fdflags(fdflags))).await?;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
async fn get_filestat(&self) -> Result<Filestat, Error> {
|
||||||
|
let meta = self.metadata().await?;
|
||||||
|
Ok(Filestat {
|
||||||
|
device_id: meta.dev(),
|
||||||
|
inode: meta.ino(),
|
||||||
|
filetype: filetype_from(&meta.file_type()),
|
||||||
|
nlink: meta.nlink(),
|
||||||
|
size: meta.len(),
|
||||||
|
atim: meta.accessed().map(|t| Some(t.into_std())).unwrap_or(None),
|
||||||
|
mtim: meta.modified().map(|t| Some(t.into_std())).unwrap_or(None),
|
||||||
|
ctim: meta.created().map(|t| Some(t.into_std())).unwrap_or(None),
|
||||||
|
})
|
||||||
|
}
|
||||||
|
async fn set_filestat_size(&self, size: u64) -> Result<(), Error> {
|
||||||
|
// Tokio asyncified this already:
|
||||||
|
self.0.set_len(size).await?;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
async fn advise(&self, offset: u64, len: u64, advice: Advice) -> Result<(), Error> {
|
||||||
|
asyncify(move || self.0.advise(offset, len, convert_advice(advice))).await?;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
async fn allocate(&self, offset: u64, len: u64) -> Result<(), Error> {
|
||||||
|
asyncify(move || self.0.allocate(offset, len)).await?;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
async fn set_times(
|
||||||
|
&self,
|
||||||
|
atime: Option<wasi_common::SystemTimeSpec>,
|
||||||
|
mtime: Option<wasi_common::SystemTimeSpec>,
|
||||||
|
) -> Result<(), Error> {
|
||||||
|
asyncify(|| {
|
||||||
|
self.0
|
||||||
|
.set_times(convert_systimespec(atime), convert_systimespec(mtime))
|
||||||
|
})
|
||||||
|
.await?;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
async fn read_vectored<'a>(&self, bufs: &mut [io::IoSliceMut<'a>]) -> Result<u64, Error> {
|
||||||
|
// XXX use tokio's AsyncReadExt trait instead!
|
||||||
|
let n = self.0.read_vectored(bufs)?;
|
||||||
|
Ok(n.try_into()?)
|
||||||
|
}
|
||||||
|
async fn read_vectored_at<'a>(
|
||||||
|
&self,
|
||||||
|
bufs: &mut [io::IoSliceMut<'a>],
|
||||||
|
offset: u64,
|
||||||
|
) -> Result<u64, Error> {
|
||||||
|
let n = asyncify(move || self.0.read_vectored_at(bufs, offset)).await?;
|
||||||
|
Ok(n.try_into()?)
|
||||||
|
}
|
||||||
|
async fn write_vectored<'a>(&self, bufs: &[io::IoSlice<'a>]) -> Result<u64, Error> {
|
||||||
|
// XXX use tokio's AsyncWriteExt trait instead!
|
||||||
|
let n = self.0.write_vectored(bufs)?;
|
||||||
|
Ok(n.try_into()?)
|
||||||
|
}
|
||||||
|
async fn write_vectored_at<'a>(
|
||||||
|
&self,
|
||||||
|
bufs: &[io::IoSlice<'a>],
|
||||||
|
offset: u64,
|
||||||
|
) -> Result<u64, Error> {
|
||||||
|
let n = asyncify(move || self.0.write_vectored_at(bufs, offset)).await?;
|
||||||
|
Ok(n.try_into()?)
|
||||||
|
}
|
||||||
|
async fn seek(&self, pos: std::io::SeekFrom) -> Result<u64, Error> {
|
||||||
|
asyncify(move || self.0.seek(pos)).await
|
||||||
|
}
|
||||||
|
async fn peek(&self, buf: &mut [u8]) -> Result<u64, Error> {
|
||||||
|
let n = asyncify(move || self.0.peek(buf)).await?;
|
||||||
|
Ok(n.try_into()?)
|
||||||
|
}
|
||||||
|
async fn num_ready_bytes(&self) -> Result<u64, Error> {
|
||||||
|
use unsafe_io::AsUnsafeFile;
|
||||||
|
asyncify(|| self.0.as_file_view().num_ready_bytes()).await
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub fn filetype_from(ft: &cap_std::fs::FileType) -> FileType {
|
||||||
|
use cap_fs_ext::FileTypeExt;
|
||||||
|
if ft.is_dir() {
|
||||||
|
FileType::Directory
|
||||||
|
} else if ft.is_symlink() {
|
||||||
|
FileType::SymbolicLink
|
||||||
|
} else if ft.is_socket() {
|
||||||
|
if ft.is_block_device() {
|
||||||
|
FileType::SocketDgram
|
||||||
|
} else {
|
||||||
|
FileType::SocketStream
|
||||||
|
}
|
||||||
|
} else if ft.is_block_device() {
|
||||||
|
FileType::BlockDevice
|
||||||
|
} else if ft.is_char_device() {
|
||||||
|
FileType::CharacterDevice
|
||||||
|
} else if ft.is_file() {
|
||||||
|
FileType::RegularFile
|
||||||
|
} else {
|
||||||
|
FileType::Unknown
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(windows)]
|
||||||
|
use std::os::windows::io::{AsRawHandle, RawHandle};
|
||||||
|
#[cfg(windows)]
|
||||||
|
impl AsRawHandle for File {
|
||||||
|
fn as_raw_handle(&self) -> RawHandle {
|
||||||
|
self.0.as_raw_handle()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(unix)]
|
||||||
|
use std::os::unix::io::{AsRawFd, RawFd};
|
||||||
|
#[cfg(unix)]
|
||||||
|
impl AsRawFd for File {
|
||||||
|
fn as_raw_fd(&self) -> RawFd {
|
||||||
|
self.0.as_raw_fd()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub fn convert_systimespec(t: Option<wasi_common::SystemTimeSpec>) -> Option<SystemTimeSpec> {
|
||||||
|
match t {
|
||||||
|
Some(wasi_common::SystemTimeSpec::Absolute(t)) => {
|
||||||
|
Some(SystemTimeSpec::Absolute(t.into_std()))
|
||||||
|
}
|
||||||
|
Some(wasi_common::SystemTimeSpec::SymbolicNow) => Some(SystemTimeSpec::SymbolicNow),
|
||||||
|
None => None,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn to_sysif_fdflags(f: wasi_common::file::FdFlags) -> system_interface::fs::FdFlags {
|
||||||
|
let mut out = system_interface::fs::FdFlags::empty();
|
||||||
|
if f.contains(wasi_common::file::FdFlags::APPEND) {
|
||||||
|
out |= system_interface::fs::FdFlags::APPEND;
|
||||||
|
}
|
||||||
|
if f.contains(wasi_common::file::FdFlags::DSYNC) {
|
||||||
|
out |= system_interface::fs::FdFlags::DSYNC;
|
||||||
|
}
|
||||||
|
if f.contains(wasi_common::file::FdFlags::NONBLOCK) {
|
||||||
|
out |= system_interface::fs::FdFlags::NONBLOCK;
|
||||||
|
}
|
||||||
|
if f.contains(wasi_common::file::FdFlags::RSYNC) {
|
||||||
|
out |= system_interface::fs::FdFlags::RSYNC;
|
||||||
|
}
|
||||||
|
if f.contains(wasi_common::file::FdFlags::SYNC) {
|
||||||
|
out |= system_interface::fs::FdFlags::SYNC;
|
||||||
|
}
|
||||||
|
out
|
||||||
|
}
|
||||||
|
pub fn from_sysif_fdflags(f: system_interface::fs::FdFlags) -> wasi_common::file::FdFlags {
|
||||||
|
let mut out = wasi_common::file::FdFlags::empty();
|
||||||
|
if f.contains(system_interface::fs::FdFlags::APPEND) {
|
||||||
|
out |= wasi_common::file::FdFlags::APPEND;
|
||||||
|
}
|
||||||
|
if f.contains(system_interface::fs::FdFlags::DSYNC) {
|
||||||
|
out |= wasi_common::file::FdFlags::DSYNC;
|
||||||
|
}
|
||||||
|
if f.contains(system_interface::fs::FdFlags::NONBLOCK) {
|
||||||
|
out |= wasi_common::file::FdFlags::NONBLOCK;
|
||||||
|
}
|
||||||
|
if f.contains(system_interface::fs::FdFlags::RSYNC) {
|
||||||
|
out |= wasi_common::file::FdFlags::RSYNC;
|
||||||
|
}
|
||||||
|
if f.contains(system_interface::fs::FdFlags::SYNC) {
|
||||||
|
out |= wasi_common::file::FdFlags::SYNC;
|
||||||
|
}
|
||||||
|
out
|
||||||
|
}
|
||||||
|
pub fn convert_advice(advice: Advice) -> system_interface::fs::Advice {
|
||||||
|
match advice {
|
||||||
|
Advice::Normal => system_interface::fs::Advice::Normal,
|
||||||
|
Advice::Sequential => system_interface::fs::Advice::Sequential,
|
||||||
|
Advice::Random => system_interface::fs::Advice::Random,
|
||||||
|
Advice::WillNeed => system_interface::fs::Advice::WillNeed,
|
||||||
|
Advice::DontNeed => system_interface::fs::Advice::DontNeed,
|
||||||
|
Advice::NoReuse => system_interface::fs::Advice::NoReuse,
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -109,3 +109,20 @@ impl WasiCtxBuilder {
|
|||||||
self.0.build()
|
self.0.build()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pub(crate) async fn asyncify<'a, F, T>(f: F) -> Result<T, Error>
|
||||||
|
where
|
||||||
|
F: FnOnce() -> Result<T, std::io::Error> + Send + 'a,
|
||||||
|
T: Send + 'static,
|
||||||
|
{
|
||||||
|
// spawn_blocking requires a 'static function, but since we await on the
|
||||||
|
// JoinHandle the lifetime of the spawn will be no longer than this function's body
|
||||||
|
let f: Box<dyn FnOnce() -> Result<T, std::io::Error> + Send + 'a> = Box::new(f);
|
||||||
|
let f = unsafe {
|
||||||
|
std::mem::transmute::<_, Box<dyn FnOnce() -> Result<T, std::io::Error> + Send + 'static>>(f)
|
||||||
|
};
|
||||||
|
match tokio::task::spawn_blocking(|| f()).await {
|
||||||
|
Ok(res) => Ok(res?),
|
||||||
|
Err(_) => panic!("spawn_blocking died"),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|||||||
Reference in New Issue
Block a user