mirror of
https://github.com/denoland/deno.git
synced 2024-12-22 23:34:47 -05:00
2048 lines
51 KiB
Rust
2048 lines
51 KiB
Rust
// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
|
|
// Some deserializer fields are only used on Unix and Windows build fails without it
|
|
use super::io::StdFileResource;
|
|
use super::utils::into_string;
|
|
use crate::fs_util::canonicalize_path;
|
|
use crate::permissions::Permissions;
|
|
use deno_core::error::custom_error;
|
|
use deno_core::error::type_error;
|
|
use deno_core::error::AnyError;
|
|
use deno_core::op;
|
|
use deno_core::CancelFuture;
|
|
use deno_core::CancelHandle;
|
|
use deno_core::ZeroCopyBuf;
|
|
|
|
use deno_core::Extension;
|
|
use deno_core::OpState;
|
|
use deno_core::ResourceId;
|
|
use deno_crypto::rand::thread_rng;
|
|
use deno_crypto::rand::Rng;
|
|
use log::debug;
|
|
use serde::Deserialize;
|
|
use serde::Serialize;
|
|
use std::borrow::Cow;
|
|
use std::cell::RefCell;
|
|
use std::convert::From;
|
|
use std::env::current_dir;
|
|
use std::env::set_current_dir;
|
|
use std::env::temp_dir;
|
|
use std::io;
|
|
use std::io::Error;
|
|
use std::io::Seek;
|
|
use std::io::SeekFrom;
|
|
use std::io::Write;
|
|
use std::path::Path;
|
|
use std::path::PathBuf;
|
|
use std::rc::Rc;
|
|
use std::time::SystemTime;
|
|
use std::time::UNIX_EPOCH;
|
|
|
|
#[cfg(not(unix))]
|
|
use deno_core::error::generic_error;
|
|
#[cfg(not(unix))]
|
|
use deno_core::error::not_supported;
|
|
|
|
pub fn init() -> Extension {
|
|
Extension::builder()
|
|
.ops(vec![
|
|
op_open_sync::decl(),
|
|
op_open_async::decl(),
|
|
op_write_file_sync::decl(),
|
|
op_write_file_async::decl(),
|
|
op_seek_sync::decl(),
|
|
op_seek_async::decl(),
|
|
op_fdatasync_sync::decl(),
|
|
op_fdatasync_async::decl(),
|
|
op_fsync_sync::decl(),
|
|
op_fsync_async::decl(),
|
|
op_fstat_sync::decl(),
|
|
op_fstat_async::decl(),
|
|
op_flock_sync::decl(),
|
|
op_flock_async::decl(),
|
|
op_funlock_sync::decl(),
|
|
op_funlock_async::decl(),
|
|
op_umask::decl(),
|
|
op_chdir::decl(),
|
|
op_mkdir_sync::decl(),
|
|
op_mkdir_async::decl(),
|
|
op_chmod_sync::decl(),
|
|
op_chmod_async::decl(),
|
|
op_chown_sync::decl(),
|
|
op_chown_async::decl(),
|
|
op_remove_sync::decl(),
|
|
op_remove_async::decl(),
|
|
op_copy_file_sync::decl(),
|
|
op_copy_file_async::decl(),
|
|
op_stat_sync::decl(),
|
|
op_stat_async::decl(),
|
|
op_realpath_sync::decl(),
|
|
op_realpath_async::decl(),
|
|
op_read_dir_sync::decl(),
|
|
op_read_dir_async::decl(),
|
|
op_rename_sync::decl(),
|
|
op_rename_async::decl(),
|
|
op_link_sync::decl(),
|
|
op_link_async::decl(),
|
|
op_symlink_sync::decl(),
|
|
op_symlink_async::decl(),
|
|
op_read_link_sync::decl(),
|
|
op_read_link_async::decl(),
|
|
op_ftruncate_sync::decl(),
|
|
op_ftruncate_async::decl(),
|
|
op_truncate_sync::decl(),
|
|
op_truncate_async::decl(),
|
|
op_make_temp_dir_sync::decl(),
|
|
op_make_temp_dir_async::decl(),
|
|
op_make_temp_file_sync::decl(),
|
|
op_make_temp_file_async::decl(),
|
|
op_cwd::decl(),
|
|
op_futime_sync::decl(),
|
|
op_futime_async::decl(),
|
|
op_utime_sync::decl(),
|
|
op_utime_async::decl(),
|
|
op_readfile_sync::decl(),
|
|
op_readfile_text_sync::decl(),
|
|
op_readfile_async::decl(),
|
|
op_readfile_text_async::decl(),
|
|
])
|
|
.build()
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct OpenArgs {
|
|
path: String,
|
|
mode: Option<u32>,
|
|
options: OpenOptions,
|
|
}
|
|
|
|
#[derive(Deserialize, Default, Debug)]
|
|
#[serde(rename_all = "camelCase")]
|
|
#[serde(default)]
|
|
pub struct OpenOptions {
|
|
read: bool,
|
|
write: bool,
|
|
create: bool,
|
|
truncate: bool,
|
|
append: bool,
|
|
create_new: bool,
|
|
}
|
|
|
|
fn open_helper(
|
|
state: &mut OpState,
|
|
args: &OpenArgs,
|
|
) -> Result<(PathBuf, std::fs::OpenOptions), AnyError> {
|
|
let path = Path::new(&args.path).to_path_buf();
|
|
|
|
let mut open_options = std::fs::OpenOptions::new();
|
|
|
|
if let Some(mode) = args.mode {
|
|
// mode only used if creating the file on Unix
|
|
// if not specified, defaults to 0o666
|
|
#[cfg(unix)]
|
|
{
|
|
use std::os::unix::fs::OpenOptionsExt;
|
|
open_options.mode(mode & 0o777);
|
|
}
|
|
#[cfg(not(unix))]
|
|
let _ = mode; // avoid unused warning
|
|
}
|
|
|
|
let permissions = state.borrow_mut::<Permissions>();
|
|
let options = &args.options;
|
|
|
|
if options.read {
|
|
permissions.read.check(&path)?;
|
|
}
|
|
|
|
if options.write || options.append {
|
|
permissions.write.check(&path)?;
|
|
}
|
|
|
|
open_options
|
|
.read(options.read)
|
|
.create(options.create)
|
|
.write(options.write)
|
|
.truncate(options.truncate)
|
|
.append(options.append)
|
|
.create_new(options.create_new);
|
|
|
|
Ok((path, open_options))
|
|
}
|
|
|
|
#[op]
|
|
fn op_open_sync(
|
|
state: &mut OpState,
|
|
args: OpenArgs,
|
|
) -> Result<ResourceId, AnyError> {
|
|
let (path, open_options) = open_helper(state, &args)?;
|
|
let std_file = open_options.open(&path).map_err(|err| {
|
|
Error::new(err.kind(), format!("{}, open '{}'", err, path.display()))
|
|
})?;
|
|
let resource = StdFileResource::fs_file(std_file);
|
|
let rid = state.resource_table.add(resource);
|
|
Ok(rid)
|
|
}
|
|
|
|
#[op]
|
|
async fn op_open_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
args: OpenArgs,
|
|
) -> Result<ResourceId, AnyError> {
|
|
let (path, open_options) = open_helper(&mut state.borrow_mut(), &args)?;
|
|
let std_file = tokio::task::spawn_blocking(move || {
|
|
open_options.open(path.clone()).map_err(|err| {
|
|
Error::new(err.kind(), format!("{}, open '{}'", err, path.display()))
|
|
})
|
|
})
|
|
.await?;
|
|
let resource = StdFileResource::fs_file(std_file?);
|
|
let rid = state.borrow_mut().resource_table.add(resource);
|
|
Ok(rid)
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct WriteFileArgs {
|
|
path: String,
|
|
mode: Option<u32>,
|
|
append: bool,
|
|
create: bool,
|
|
data: ZeroCopyBuf,
|
|
cancel_rid: Option<ResourceId>,
|
|
}
|
|
|
|
impl WriteFileArgs {
|
|
fn into_open_args_and_data(self) -> (OpenArgs, ZeroCopyBuf) {
|
|
(
|
|
OpenArgs {
|
|
path: self.path,
|
|
mode: self.mode,
|
|
options: OpenOptions {
|
|
read: false,
|
|
write: true,
|
|
create: self.create,
|
|
truncate: !self.append,
|
|
append: self.append,
|
|
create_new: false,
|
|
},
|
|
},
|
|
self.data,
|
|
)
|
|
}
|
|
}
|
|
|
|
#[op]
|
|
fn op_write_file_sync(
|
|
state: &mut OpState,
|
|
args: WriteFileArgs,
|
|
) -> Result<(), AnyError> {
|
|
let (open_args, data) = args.into_open_args_and_data();
|
|
let (path, open_options) = open_helper(state, &open_args)?;
|
|
write_file(&path, open_options, &open_args, data)
|
|
}
|
|
|
|
#[op]
|
|
async fn op_write_file_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
args: WriteFileArgs,
|
|
) -> Result<(), AnyError> {
|
|
let cancel_handle = match args.cancel_rid {
|
|
Some(cancel_rid) => state
|
|
.borrow_mut()
|
|
.resource_table
|
|
.get::<CancelHandle>(cancel_rid)
|
|
.ok(),
|
|
None => None,
|
|
};
|
|
let (open_args, data) = args.into_open_args_and_data();
|
|
let (path, open_options) = open_helper(&mut *state.borrow_mut(), &open_args)?;
|
|
let write_future = tokio::task::spawn_blocking(move || {
|
|
write_file(&path, open_options, &open_args, data)
|
|
});
|
|
if let Some(cancel_handle) = cancel_handle {
|
|
write_future.or_cancel(cancel_handle).await???;
|
|
} else {
|
|
write_future.await??;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn write_file(
|
|
path: &Path,
|
|
open_options: std::fs::OpenOptions,
|
|
_open_args: &OpenArgs,
|
|
data: ZeroCopyBuf,
|
|
) -> Result<(), AnyError> {
|
|
let mut std_file = open_options.open(path).map_err(|err| {
|
|
Error::new(err.kind(), format!("{}, open '{}'", err, path.display()))
|
|
})?;
|
|
|
|
// need to chmod the file if it already exists and a mode is specified
|
|
#[cfg(unix)]
|
|
if let Some(mode) = &_open_args.mode {
|
|
use std::os::unix::fs::PermissionsExt;
|
|
let permissions = PermissionsExt::from_mode(mode & 0o777);
|
|
std_file
|
|
.set_permissions(permissions)
|
|
.map_err(|err: Error| {
|
|
Error::new(err.kind(), format!("{}, chmod '{}'", err, path.display()))
|
|
})?;
|
|
}
|
|
|
|
std_file.write_all(&data)?;
|
|
Ok(())
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct SeekArgs {
|
|
rid: ResourceId,
|
|
offset: i64,
|
|
whence: i32,
|
|
}
|
|
|
|
fn seek_helper(args: SeekArgs) -> Result<(u32, SeekFrom), AnyError> {
|
|
let rid = args.rid;
|
|
let offset = args.offset;
|
|
let whence = args.whence as u32;
|
|
// Translate seek mode to Rust repr.
|
|
let seek_from = match whence {
|
|
0 => SeekFrom::Start(offset as u64),
|
|
1 => SeekFrom::Current(offset),
|
|
2 => SeekFrom::End(offset),
|
|
_ => {
|
|
return Err(type_error(format!("Invalid seek mode: {}", whence)));
|
|
}
|
|
};
|
|
|
|
Ok((rid, seek_from))
|
|
}
|
|
|
|
#[op]
|
|
fn op_seek_sync(state: &mut OpState, args: SeekArgs) -> Result<u64, AnyError> {
|
|
let (rid, seek_from) = seek_helper(args)?;
|
|
let pos = StdFileResource::with_file(state, rid, |std_file| {
|
|
std_file.seek(seek_from).map_err(AnyError::from)
|
|
})?;
|
|
Ok(pos)
|
|
}
|
|
|
|
#[op]
|
|
async fn op_seek_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
args: SeekArgs,
|
|
) -> Result<u64, AnyError> {
|
|
let (rid, seek_from) = seek_helper(args)?;
|
|
|
|
let resource = state
|
|
.borrow_mut()
|
|
.resource_table
|
|
.get::<StdFileResource>(rid)?;
|
|
|
|
let std_file = resource.std_file();
|
|
|
|
tokio::task::spawn_blocking(move || {
|
|
let mut std_file = std_file.lock();
|
|
std_file.seek(seek_from)
|
|
})
|
|
.await?
|
|
.map_err(AnyError::from)
|
|
}
|
|
|
|
#[op]
|
|
fn op_fdatasync_sync(
|
|
state: &mut OpState,
|
|
rid: ResourceId,
|
|
) -> Result<(), AnyError> {
|
|
StdFileResource::with_file(state, rid, |std_file| {
|
|
std_file.sync_data().map_err(AnyError::from)
|
|
})?;
|
|
Ok(())
|
|
}
|
|
|
|
#[op]
|
|
async fn op_fdatasync_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
rid: ResourceId,
|
|
) -> Result<(), AnyError> {
|
|
let resource = state
|
|
.borrow_mut()
|
|
.resource_table
|
|
.get::<StdFileResource>(rid)?;
|
|
|
|
let std_file = resource.std_file();
|
|
|
|
tokio::task::spawn_blocking(move || {
|
|
let std_file = std_file.lock();
|
|
std_file.sync_data()
|
|
})
|
|
.await?
|
|
.map_err(AnyError::from)
|
|
}
|
|
|
|
#[op]
|
|
fn op_fsync_sync(state: &mut OpState, rid: ResourceId) -> Result<(), AnyError> {
|
|
StdFileResource::with_file(state, rid, |std_file| {
|
|
std_file.sync_all().map_err(AnyError::from)
|
|
})?;
|
|
Ok(())
|
|
}
|
|
|
|
#[op]
|
|
async fn op_fsync_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
rid: ResourceId,
|
|
) -> Result<(), AnyError> {
|
|
let resource = state
|
|
.borrow_mut()
|
|
.resource_table
|
|
.get::<StdFileResource>(rid)?;
|
|
|
|
let std_file = resource.std_file();
|
|
|
|
tokio::task::spawn_blocking(move || {
|
|
let std_file = std_file.lock();
|
|
std_file.sync_all()
|
|
})
|
|
.await?
|
|
.map_err(AnyError::from)
|
|
}
|
|
|
|
#[op]
|
|
fn op_fstat_sync(
|
|
state: &mut OpState,
|
|
rid: ResourceId,
|
|
) -> Result<FsStat, AnyError> {
|
|
let metadata = StdFileResource::with_file(state, rid, |std_file| {
|
|
std_file.metadata().map_err(AnyError::from)
|
|
})?;
|
|
Ok(get_stat(metadata))
|
|
}
|
|
|
|
#[op]
|
|
async fn op_fstat_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
rid: ResourceId,
|
|
) -> Result<FsStat, AnyError> {
|
|
let resource = state
|
|
.borrow_mut()
|
|
.resource_table
|
|
.get::<StdFileResource>(rid)?;
|
|
|
|
let std_file = resource.std_file();
|
|
|
|
let metadata = tokio::task::spawn_blocking(move || {
|
|
let std_file = std_file.lock();
|
|
std_file.metadata()
|
|
})
|
|
.await?
|
|
.map_err(AnyError::from)?;
|
|
Ok(get_stat(metadata))
|
|
}
|
|
|
|
#[op]
|
|
fn op_flock_sync(
|
|
state: &mut OpState,
|
|
rid: ResourceId,
|
|
exclusive: bool,
|
|
) -> Result<(), AnyError> {
|
|
use fs3::FileExt;
|
|
super::check_unstable(state, "Deno.flockSync");
|
|
|
|
StdFileResource::with_file(state, rid, |std_file| {
|
|
if exclusive {
|
|
std_file.lock_exclusive()?;
|
|
} else {
|
|
std_file.lock_shared()?;
|
|
}
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
#[op]
|
|
async fn op_flock_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
rid: ResourceId,
|
|
exclusive: bool,
|
|
) -> Result<(), AnyError> {
|
|
use fs3::FileExt;
|
|
super::check_unstable2(&state, "Deno.flock");
|
|
|
|
let resource = state
|
|
.borrow_mut()
|
|
.resource_table
|
|
.get::<StdFileResource>(rid)?;
|
|
|
|
let std_file = resource.std_file();
|
|
|
|
tokio::task::spawn_blocking(move || -> Result<(), AnyError> {
|
|
let std_file = std_file.lock();
|
|
if exclusive {
|
|
std_file.lock_exclusive()?;
|
|
} else {
|
|
std_file.lock_shared()?;
|
|
}
|
|
Ok(())
|
|
})
|
|
.await?
|
|
}
|
|
|
|
#[op]
|
|
fn op_funlock_sync(
|
|
state: &mut OpState,
|
|
rid: ResourceId,
|
|
) -> Result<(), AnyError> {
|
|
use fs3::FileExt;
|
|
super::check_unstable(state, "Deno.funlockSync");
|
|
|
|
StdFileResource::with_file(state, rid, |std_file| {
|
|
std_file.unlock()?;
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
#[op]
|
|
async fn op_funlock_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
rid: ResourceId,
|
|
) -> Result<(), AnyError> {
|
|
use fs3::FileExt;
|
|
super::check_unstable2(&state, "Deno.funlock");
|
|
|
|
let resource = state
|
|
.borrow_mut()
|
|
.resource_table
|
|
.get::<StdFileResource>(rid)?;
|
|
|
|
let std_file = resource.std_file();
|
|
|
|
tokio::task::spawn_blocking(move || -> Result<(), AnyError> {
|
|
let std_file = std_file.lock();
|
|
std_file.unlock()?;
|
|
Ok(())
|
|
})
|
|
.await?
|
|
}
|
|
|
|
#[op]
|
|
fn op_umask(state: &mut OpState, mask: Option<u32>) -> Result<u32, AnyError> {
|
|
super::check_unstable(state, "Deno.umask");
|
|
// TODO implement umask for Windows
|
|
// see https://github.com/nodejs/node/blob/master/src/node_process_methods.cc
|
|
// and https://docs.microsoft.com/fr-fr/cpp/c-runtime-library/reference/umask?view=vs-2019
|
|
#[cfg(not(unix))]
|
|
{
|
|
let _ = mask; // avoid unused warning.
|
|
Err(not_supported())
|
|
}
|
|
#[cfg(unix)]
|
|
{
|
|
use nix::sys::stat::mode_t;
|
|
use nix::sys::stat::umask;
|
|
use nix::sys::stat::Mode;
|
|
let r = if let Some(mask) = mask {
|
|
// If mask provided, return previous.
|
|
umask(Mode::from_bits_truncate(mask as mode_t))
|
|
} else {
|
|
// If no mask provided, we query the current. Requires two syscalls.
|
|
let prev = umask(Mode::from_bits_truncate(0o777));
|
|
let _ = umask(prev);
|
|
prev
|
|
};
|
|
Ok(r.bits() as u32)
|
|
}
|
|
}
|
|
|
|
#[op]
|
|
fn op_chdir(state: &mut OpState, directory: String) -> Result<(), AnyError> {
|
|
let d = PathBuf::from(&directory);
|
|
state.borrow_mut::<Permissions>().read.check(&d)?;
|
|
set_current_dir(&d).map_err(|err| {
|
|
Error::new(err.kind(), format!("{}, chdir '{}'", err, directory))
|
|
})?;
|
|
Ok(())
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct MkdirArgs {
|
|
path: String,
|
|
recursive: bool,
|
|
mode: Option<u32>,
|
|
}
|
|
|
|
#[op]
|
|
fn op_mkdir_sync(state: &mut OpState, args: MkdirArgs) -> Result<(), AnyError> {
|
|
let path = Path::new(&args.path).to_path_buf();
|
|
let mode = args.mode.unwrap_or(0o777) & 0o777;
|
|
state.borrow_mut::<Permissions>().write.check(&path)?;
|
|
debug!("op_mkdir {} {:o} {}", path.display(), mode, args.recursive);
|
|
let mut builder = std::fs::DirBuilder::new();
|
|
builder.recursive(args.recursive);
|
|
#[cfg(unix)]
|
|
{
|
|
use std::os::unix::fs::DirBuilderExt;
|
|
builder.mode(mode);
|
|
}
|
|
builder.create(&path).map_err(|err| {
|
|
Error::new(err.kind(), format!("{}, mkdir '{}'", err, path.display()))
|
|
})?;
|
|
Ok(())
|
|
}
|
|
|
|
#[op]
|
|
async fn op_mkdir_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
args: MkdirArgs,
|
|
) -> Result<(), AnyError> {
|
|
let path = Path::new(&args.path).to_path_buf();
|
|
let mode = args.mode.unwrap_or(0o777) & 0o777;
|
|
|
|
{
|
|
let mut state = state.borrow_mut();
|
|
state.borrow_mut::<Permissions>().write.check(&path)?;
|
|
}
|
|
|
|
tokio::task::spawn_blocking(move || {
|
|
debug!("op_mkdir {} {:o} {}", path.display(), mode, args.recursive);
|
|
let mut builder = std::fs::DirBuilder::new();
|
|
builder.recursive(args.recursive);
|
|
#[cfg(unix)]
|
|
{
|
|
use std::os::unix::fs::DirBuilderExt;
|
|
builder.mode(mode);
|
|
}
|
|
builder.create(&path).map_err(|err| {
|
|
Error::new(err.kind(), format!("{}, mkdir '{}'", err, path.display()))
|
|
})?;
|
|
Ok(())
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct ChmodArgs {
|
|
path: String,
|
|
mode: u32,
|
|
}
|
|
|
|
#[op]
|
|
fn op_chmod_sync(state: &mut OpState, args: ChmodArgs) -> Result<(), AnyError> {
|
|
let path = Path::new(&args.path);
|
|
let mode = args.mode & 0o777;
|
|
|
|
state.borrow_mut::<Permissions>().write.check(path)?;
|
|
debug!("op_chmod_sync {} {:o}", path.display(), mode);
|
|
raw_chmod(path, mode)
|
|
}
|
|
|
|
#[op]
|
|
async fn op_chmod_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
args: ChmodArgs,
|
|
) -> Result<(), AnyError> {
|
|
let path = Path::new(&args.path).to_path_buf();
|
|
let mode = args.mode & 0o777;
|
|
|
|
{
|
|
let mut state = state.borrow_mut();
|
|
state.borrow_mut::<Permissions>().write.check(&path)?;
|
|
}
|
|
|
|
tokio::task::spawn_blocking(move || {
|
|
debug!("op_chmod_async {} {:o}", path.display(), mode);
|
|
raw_chmod(&path, mode)
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
fn raw_chmod(path: &Path, _raw_mode: u32) -> Result<(), AnyError> {
|
|
let err_mapper = |err: Error| {
|
|
Error::new(err.kind(), format!("{}, chmod '{}'", err, path.display()))
|
|
};
|
|
#[cfg(unix)]
|
|
{
|
|
use std::os::unix::fs::PermissionsExt;
|
|
let permissions = PermissionsExt::from_mode(_raw_mode);
|
|
std::fs::set_permissions(&path, permissions).map_err(err_mapper)?;
|
|
Ok(())
|
|
}
|
|
// TODO Implement chmod for Windows (#4357)
|
|
#[cfg(not(unix))]
|
|
{
|
|
// Still check file/dir exists on Windows
|
|
let _metadata = std::fs::metadata(&path).map_err(err_mapper)?;
|
|
Err(not_supported())
|
|
}
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct ChownArgs {
|
|
path: String,
|
|
uid: Option<u32>,
|
|
gid: Option<u32>,
|
|
}
|
|
|
|
#[op]
|
|
fn op_chown_sync(state: &mut OpState, args: ChownArgs) -> Result<(), AnyError> {
|
|
let path = Path::new(&args.path).to_path_buf();
|
|
state.borrow_mut::<Permissions>().write.check(&path)?;
|
|
debug!(
|
|
"op_chown_sync {} {:?} {:?}",
|
|
path.display(),
|
|
args.uid,
|
|
args.gid,
|
|
);
|
|
#[cfg(unix)]
|
|
{
|
|
use crate::errors::get_nix_error_class;
|
|
use nix::unistd::{chown, Gid, Uid};
|
|
let nix_uid = args.uid.map(Uid::from_raw);
|
|
let nix_gid = args.gid.map(Gid::from_raw);
|
|
chown(&path, nix_uid, nix_gid).map_err(|err| {
|
|
custom_error(
|
|
get_nix_error_class(&err),
|
|
format!("{}, chown '{}'", err.desc(), path.display()),
|
|
)
|
|
})?;
|
|
Ok(())
|
|
}
|
|
// TODO Implement chown for Windows
|
|
#[cfg(not(unix))]
|
|
{
|
|
Err(generic_error("Not implemented"))
|
|
}
|
|
}
|
|
|
|
#[op]
|
|
async fn op_chown_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
args: ChownArgs,
|
|
) -> Result<(), AnyError> {
|
|
let path = Path::new(&args.path).to_path_buf();
|
|
|
|
{
|
|
let mut state = state.borrow_mut();
|
|
state.borrow_mut::<Permissions>().write.check(&path)?;
|
|
}
|
|
|
|
tokio::task::spawn_blocking(move || {
|
|
debug!(
|
|
"op_chown_async {} {:?} {:?}",
|
|
path.display(),
|
|
args.uid,
|
|
args.gid,
|
|
);
|
|
#[cfg(unix)]
|
|
{
|
|
use crate::errors::get_nix_error_class;
|
|
use nix::unistd::{chown, Gid, Uid};
|
|
let nix_uid = args.uid.map(Uid::from_raw);
|
|
let nix_gid = args.gid.map(Gid::from_raw);
|
|
chown(&path, nix_uid, nix_gid).map_err(|err| {
|
|
custom_error(
|
|
get_nix_error_class(&err),
|
|
format!("{}, chown '{}'", err.desc(), path.display()),
|
|
)
|
|
})?;
|
|
Ok(())
|
|
}
|
|
// TODO Implement chown for Windows
|
|
#[cfg(not(unix))]
|
|
Err(not_supported())
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct RemoveArgs {
|
|
path: String,
|
|
recursive: bool,
|
|
}
|
|
|
|
#[op]
|
|
fn op_remove_sync(
|
|
state: &mut OpState,
|
|
args: RemoveArgs,
|
|
) -> Result<(), AnyError> {
|
|
let path = PathBuf::from(&args.path);
|
|
let recursive = args.recursive;
|
|
|
|
state.borrow_mut::<Permissions>().write.check(&path)?;
|
|
|
|
#[cfg(not(unix))]
|
|
use std::os::windows::prelude::MetadataExt;
|
|
|
|
let err_mapper = |err: Error| {
|
|
Error::new(err.kind(), format!("{}, remove '{}'", err, path.display()))
|
|
};
|
|
let metadata = std::fs::symlink_metadata(&path).map_err(err_mapper)?;
|
|
|
|
debug!("op_remove_sync {} {}", path.display(), recursive);
|
|
let file_type = metadata.file_type();
|
|
if file_type.is_file() {
|
|
std::fs::remove_file(&path).map_err(err_mapper)?;
|
|
} else if recursive {
|
|
std::fs::remove_dir_all(&path).map_err(err_mapper)?;
|
|
} else if file_type.is_symlink() {
|
|
#[cfg(unix)]
|
|
std::fs::remove_file(&path).map_err(err_mapper)?;
|
|
#[cfg(not(unix))]
|
|
{
|
|
use winapi::um::winnt::FILE_ATTRIBUTE_DIRECTORY;
|
|
if metadata.file_attributes() & FILE_ATTRIBUTE_DIRECTORY != 0 {
|
|
std::fs::remove_dir(&path).map_err(err_mapper)?;
|
|
} else {
|
|
std::fs::remove_file(&path).map_err(err_mapper)?;
|
|
}
|
|
}
|
|
} else if file_type.is_dir() {
|
|
std::fs::remove_dir(&path).map_err(err_mapper)?;
|
|
} else {
|
|
// pipes, sockets, etc...
|
|
std::fs::remove_file(&path).map_err(err_mapper)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
#[op]
|
|
async fn op_remove_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
args: RemoveArgs,
|
|
) -> Result<(), AnyError> {
|
|
let path = PathBuf::from(&args.path);
|
|
let recursive = args.recursive;
|
|
|
|
{
|
|
let mut state = state.borrow_mut();
|
|
state.borrow_mut::<Permissions>().write.check(&path)?;
|
|
}
|
|
|
|
tokio::task::spawn_blocking(move || {
|
|
#[cfg(not(unix))]
|
|
use std::os::windows::prelude::MetadataExt;
|
|
let err_mapper = |err: Error| {
|
|
Error::new(err.kind(), format!("{}, remove '{}'", err, path.display()))
|
|
};
|
|
let metadata = std::fs::symlink_metadata(&path).map_err(err_mapper)?;
|
|
|
|
debug!("op_remove_async {} {}", path.display(), recursive);
|
|
let file_type = metadata.file_type();
|
|
if file_type.is_file() {
|
|
std::fs::remove_file(&path).map_err(err_mapper)?;
|
|
} else if recursive {
|
|
std::fs::remove_dir_all(&path).map_err(err_mapper)?;
|
|
} else if file_type.is_symlink() {
|
|
#[cfg(unix)]
|
|
std::fs::remove_file(&path).map_err(err_mapper)?;
|
|
#[cfg(not(unix))]
|
|
{
|
|
use winapi::um::winnt::FILE_ATTRIBUTE_DIRECTORY;
|
|
if metadata.file_attributes() & FILE_ATTRIBUTE_DIRECTORY != 0 {
|
|
std::fs::remove_dir(&path).map_err(err_mapper)?;
|
|
} else {
|
|
std::fs::remove_file(&path).map_err(err_mapper)?;
|
|
}
|
|
}
|
|
} else if file_type.is_dir() {
|
|
std::fs::remove_dir(&path).map_err(err_mapper)?;
|
|
} else {
|
|
// pipes, sockets, etc...
|
|
std::fs::remove_file(&path).map_err(err_mapper)?;
|
|
}
|
|
Ok(())
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct CopyFileArgs {
|
|
from: String,
|
|
to: String,
|
|
}
|
|
|
|
#[op]
|
|
fn op_copy_file_sync(
|
|
state: &mut OpState,
|
|
args: CopyFileArgs,
|
|
) -> Result<(), AnyError> {
|
|
let from = PathBuf::from(&args.from);
|
|
let to = PathBuf::from(&args.to);
|
|
|
|
let permissions = state.borrow_mut::<Permissions>();
|
|
permissions.read.check(&from)?;
|
|
permissions.write.check(&to)?;
|
|
|
|
debug!("op_copy_file_sync {} {}", from.display(), to.display());
|
|
// On *nix, Rust reports non-existent `from` as ErrorKind::InvalidInput
|
|
// See https://github.com/rust-lang/rust/issues/54800
|
|
// Once the issue is resolved, we should remove this workaround.
|
|
if cfg!(unix) && !from.is_file() {
|
|
return Err(custom_error(
|
|
"NotFound",
|
|
format!(
|
|
"File not found, copy '{}' -> '{}'",
|
|
from.display(),
|
|
to.display()
|
|
),
|
|
));
|
|
}
|
|
|
|
let err_mapper = |err: Error| {
|
|
Error::new(
|
|
err.kind(),
|
|
format!("{}, copy '{}' -> '{}'", err, from.display(), to.display()),
|
|
)
|
|
};
|
|
// returns size of from as u64 (we ignore)
|
|
std::fs::copy(&from, &to).map_err(err_mapper)?;
|
|
Ok(())
|
|
}
|
|
|
|
#[op]
|
|
async fn op_copy_file_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
args: CopyFileArgs,
|
|
) -> Result<(), AnyError> {
|
|
let from = PathBuf::from(&args.from);
|
|
let to = PathBuf::from(&args.to);
|
|
|
|
{
|
|
let mut state = state.borrow_mut();
|
|
let permissions = state.borrow_mut::<Permissions>();
|
|
permissions.read.check(&from)?;
|
|
permissions.write.check(&to)?;
|
|
}
|
|
|
|
debug!("op_copy_file_async {} {}", from.display(), to.display());
|
|
tokio::task::spawn_blocking(move || {
|
|
// On *nix, Rust reports non-existent `from` as ErrorKind::InvalidInput
|
|
// See https://github.com/rust-lang/rust/issues/54800
|
|
// Once the issue is resolved, we should remove this workaround.
|
|
if cfg!(unix) && !from.is_file() {
|
|
return Err(custom_error(
|
|
"NotFound",
|
|
format!(
|
|
"File not found, copy '{}' -> '{}'",
|
|
from.display(),
|
|
to.display()
|
|
),
|
|
));
|
|
}
|
|
|
|
let err_mapper = |err: Error| {
|
|
Error::new(
|
|
err.kind(),
|
|
format!("{}, copy '{}' -> '{}'", err, from.display(), to.display()),
|
|
)
|
|
};
|
|
// returns size of from as u64 (we ignore)
|
|
std::fs::copy(&from, &to).map_err(err_mapper)?;
|
|
Ok(())
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
fn to_msec(maybe_time: Result<SystemTime, io::Error>) -> Option<u64> {
|
|
match maybe_time {
|
|
Ok(time) => {
|
|
let msec = time
|
|
.duration_since(UNIX_EPOCH)
|
|
.map(|t| t.as_millis() as u64)
|
|
.unwrap_or_else(|err| err.duration().as_millis() as u64);
|
|
Some(msec)
|
|
}
|
|
Err(_) => None,
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct FsStat {
|
|
is_file: bool,
|
|
is_directory: bool,
|
|
is_symlink: bool,
|
|
size: u64,
|
|
// In milliseconds, like JavaScript. Available on both Unix or Windows.
|
|
mtime: Option<u64>,
|
|
atime: Option<u64>,
|
|
birthtime: Option<u64>,
|
|
// Following are only valid under Unix.
|
|
dev: u64,
|
|
ino: u64,
|
|
mode: u32,
|
|
nlink: u64,
|
|
uid: u32,
|
|
gid: u32,
|
|
rdev: u64,
|
|
blksize: u64,
|
|
blocks: u64,
|
|
}
|
|
|
|
#[inline(always)]
|
|
fn get_stat(metadata: std::fs::Metadata) -> FsStat {
|
|
// Unix stat member (number types only). 0 if not on unix.
|
|
macro_rules! usm {
|
|
($member:ident) => {{
|
|
#[cfg(unix)]
|
|
{
|
|
metadata.$member()
|
|
}
|
|
#[cfg(not(unix))]
|
|
{
|
|
0
|
|
}
|
|
}};
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
use std::os::unix::fs::MetadataExt;
|
|
FsStat {
|
|
is_file: metadata.is_file(),
|
|
is_directory: metadata.is_dir(),
|
|
is_symlink: metadata.file_type().is_symlink(),
|
|
size: metadata.len(),
|
|
// In milliseconds, like JavaScript. Available on both Unix or Windows.
|
|
mtime: to_msec(metadata.modified()),
|
|
atime: to_msec(metadata.accessed()),
|
|
birthtime: to_msec(metadata.created()),
|
|
// Following are only valid under Unix.
|
|
dev: usm!(dev),
|
|
ino: usm!(ino),
|
|
mode: usm!(mode),
|
|
nlink: usm!(nlink),
|
|
uid: usm!(uid),
|
|
gid: usm!(gid),
|
|
rdev: usm!(rdev),
|
|
blksize: usm!(blksize),
|
|
blocks: usm!(blocks),
|
|
}
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct StatArgs {
|
|
path: String,
|
|
lstat: bool,
|
|
}
|
|
|
|
#[op]
|
|
fn op_stat_sync(
|
|
state: &mut OpState,
|
|
args: StatArgs,
|
|
) -> Result<FsStat, AnyError> {
|
|
let path = PathBuf::from(&args.path);
|
|
let lstat = args.lstat;
|
|
state.borrow_mut::<Permissions>().read.check(&path)?;
|
|
debug!("op_stat_sync {} {}", path.display(), lstat);
|
|
let err_mapper = |err: Error| {
|
|
Error::new(err.kind(), format!("{}, stat '{}'", err, path.display()))
|
|
};
|
|
let metadata = if lstat {
|
|
std::fs::symlink_metadata(&path).map_err(err_mapper)?
|
|
} else {
|
|
std::fs::metadata(&path).map_err(err_mapper)?
|
|
};
|
|
Ok(get_stat(metadata))
|
|
}
|
|
|
|
#[op]
|
|
async fn op_stat_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
args: StatArgs,
|
|
) -> Result<FsStat, AnyError> {
|
|
let path = PathBuf::from(&args.path);
|
|
let lstat = args.lstat;
|
|
|
|
{
|
|
let mut state = state.borrow_mut();
|
|
state.borrow_mut::<Permissions>().read.check(&path)?;
|
|
}
|
|
|
|
tokio::task::spawn_blocking(move || {
|
|
debug!("op_stat_async {} {}", path.display(), lstat);
|
|
let err_mapper = |err: Error| {
|
|
Error::new(err.kind(), format!("{}, stat '{}'", err, path.display()))
|
|
};
|
|
let metadata = if lstat {
|
|
std::fs::symlink_metadata(&path).map_err(err_mapper)?
|
|
} else {
|
|
std::fs::metadata(&path).map_err(err_mapper)?
|
|
};
|
|
Ok(get_stat(metadata))
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
#[op]
|
|
fn op_realpath_sync(
|
|
state: &mut OpState,
|
|
path: String,
|
|
) -> Result<String, AnyError> {
|
|
let path = PathBuf::from(&path);
|
|
|
|
let permissions = state.borrow_mut::<Permissions>();
|
|
permissions.read.check(&path)?;
|
|
if path.is_relative() {
|
|
permissions.read.check_blind(¤t_dir()?, "CWD")?;
|
|
}
|
|
|
|
debug!("op_realpath_sync {}", path.display());
|
|
// corresponds to the realpath on Unix and
|
|
// CreateFile and GetFinalPathNameByHandle on Windows
|
|
let realpath = canonicalize_path(&path)?;
|
|
let realpath_str = into_string(realpath.into_os_string())?;
|
|
Ok(realpath_str)
|
|
}
|
|
|
|
#[op]
|
|
async fn op_realpath_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
path: String,
|
|
) -> Result<String, AnyError> {
|
|
let path = PathBuf::from(&path);
|
|
|
|
{
|
|
let mut state = state.borrow_mut();
|
|
let permissions = state.borrow_mut::<Permissions>();
|
|
permissions.read.check(&path)?;
|
|
if path.is_relative() {
|
|
permissions.read.check_blind(¤t_dir()?, "CWD")?;
|
|
}
|
|
}
|
|
|
|
tokio::task::spawn_blocking(move || {
|
|
debug!("op_realpath_async {}", path.display());
|
|
// corresponds to the realpath on Unix and
|
|
// CreateFile and GetFinalPathNameByHandle on Windows
|
|
let realpath = canonicalize_path(&path)?;
|
|
let realpath_str = into_string(realpath.into_os_string())?;
|
|
Ok(realpath_str)
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct DirEntry {
|
|
name: String,
|
|
is_file: bool,
|
|
is_directory: bool,
|
|
is_symlink: bool,
|
|
}
|
|
|
|
#[op]
|
|
fn op_read_dir_sync(
|
|
state: &mut OpState,
|
|
path: String,
|
|
) -> Result<Vec<DirEntry>, AnyError> {
|
|
let path = PathBuf::from(&path);
|
|
|
|
state.borrow_mut::<Permissions>().read.check(&path)?;
|
|
|
|
debug!("op_read_dir_sync {}", path.display());
|
|
let err_mapper = |err: Error| {
|
|
Error::new(err.kind(), format!("{}, readdir '{}'", err, path.display()))
|
|
};
|
|
let entries: Vec<_> = std::fs::read_dir(&path)
|
|
.map_err(err_mapper)?
|
|
.filter_map(|entry| {
|
|
let entry = entry.unwrap();
|
|
// Not all filenames can be encoded as UTF-8. Skip those for now.
|
|
if let Ok(name) = into_string(entry.file_name()) {
|
|
Some(DirEntry {
|
|
name,
|
|
is_file: entry
|
|
.file_type()
|
|
.map_or(false, |file_type| file_type.is_file()),
|
|
is_directory: entry
|
|
.file_type()
|
|
.map_or(false, |file_type| file_type.is_dir()),
|
|
is_symlink: entry
|
|
.file_type()
|
|
.map_or(false, |file_type| file_type.is_symlink()),
|
|
})
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.collect();
|
|
|
|
Ok(entries)
|
|
}
|
|
|
|
#[op]
|
|
async fn op_read_dir_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
path: String,
|
|
) -> Result<Vec<DirEntry>, AnyError> {
|
|
let path = PathBuf::from(&path);
|
|
{
|
|
let mut state = state.borrow_mut();
|
|
state.borrow_mut::<Permissions>().read.check(&path)?;
|
|
}
|
|
tokio::task::spawn_blocking(move || {
|
|
debug!("op_read_dir_async {}", path.display());
|
|
let err_mapper = |err: Error| {
|
|
Error::new(err.kind(), format!("{}, readdir '{}'", err, path.display()))
|
|
};
|
|
let entries: Vec<_> = std::fs::read_dir(&path)
|
|
.map_err(err_mapper)?
|
|
.filter_map(|entry| {
|
|
let entry = entry.unwrap();
|
|
// Not all filenames can be encoded as UTF-8. Skip those for now.
|
|
if let Ok(name) = into_string(entry.file_name()) {
|
|
Some(DirEntry {
|
|
name,
|
|
is_file: entry
|
|
.file_type()
|
|
.map_or(false, |file_type| file_type.is_file()),
|
|
is_directory: entry
|
|
.file_type()
|
|
.map_or(false, |file_type| file_type.is_dir()),
|
|
is_symlink: entry
|
|
.file_type()
|
|
.map_or(false, |file_type| file_type.is_symlink()),
|
|
})
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.collect();
|
|
|
|
Ok(entries)
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct RenameArgs {
|
|
oldpath: String,
|
|
newpath: String,
|
|
}
|
|
|
|
#[op]
|
|
fn op_rename_sync(
|
|
state: &mut OpState,
|
|
args: RenameArgs,
|
|
) -> Result<(), AnyError> {
|
|
let oldpath = PathBuf::from(&args.oldpath);
|
|
let newpath = PathBuf::from(&args.newpath);
|
|
|
|
let permissions = state.borrow_mut::<Permissions>();
|
|
permissions.read.check(&oldpath)?;
|
|
permissions.write.check(&oldpath)?;
|
|
permissions.write.check(&newpath)?;
|
|
debug!("op_rename_sync {} {}", oldpath.display(), newpath.display());
|
|
let err_mapper = |err: Error| {
|
|
Error::new(
|
|
err.kind(),
|
|
format!(
|
|
"{}, rename '{}' -> '{}'",
|
|
err,
|
|
oldpath.display(),
|
|
newpath.display()
|
|
),
|
|
)
|
|
};
|
|
std::fs::rename(&oldpath, &newpath).map_err(err_mapper)?;
|
|
Ok(())
|
|
}
|
|
|
|
#[op]
|
|
async fn op_rename_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
args: RenameArgs,
|
|
) -> Result<(), AnyError> {
|
|
let oldpath = PathBuf::from(&args.oldpath);
|
|
let newpath = PathBuf::from(&args.newpath);
|
|
{
|
|
let mut state = state.borrow_mut();
|
|
let permissions = state.borrow_mut::<Permissions>();
|
|
permissions.read.check(&oldpath)?;
|
|
permissions.write.check(&oldpath)?;
|
|
permissions.write.check(&newpath)?;
|
|
}
|
|
tokio::task::spawn_blocking(move || {
|
|
debug!(
|
|
"op_rename_async {} {}",
|
|
oldpath.display(),
|
|
newpath.display()
|
|
);
|
|
let err_mapper = |err: Error| {
|
|
Error::new(
|
|
err.kind(),
|
|
format!(
|
|
"{}, rename '{}' -> '{}'",
|
|
err,
|
|
oldpath.display(),
|
|
newpath.display()
|
|
),
|
|
)
|
|
};
|
|
std::fs::rename(&oldpath, &newpath).map_err(err_mapper)?;
|
|
Ok(())
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct LinkArgs {
|
|
oldpath: String,
|
|
newpath: String,
|
|
}
|
|
|
|
#[op]
|
|
fn op_link_sync(state: &mut OpState, args: LinkArgs) -> Result<(), AnyError> {
|
|
let oldpath = PathBuf::from(&args.oldpath);
|
|
let newpath = PathBuf::from(&args.newpath);
|
|
|
|
let permissions = state.borrow_mut::<Permissions>();
|
|
permissions.read.check(&oldpath)?;
|
|
permissions.write.check(&oldpath)?;
|
|
permissions.read.check(&newpath)?;
|
|
permissions.write.check(&newpath)?;
|
|
|
|
debug!("op_link_sync {} {}", oldpath.display(), newpath.display());
|
|
let err_mapper = |err: Error| {
|
|
Error::new(
|
|
err.kind(),
|
|
format!(
|
|
"{}, link '{}' -> '{}'",
|
|
err,
|
|
oldpath.display(),
|
|
newpath.display()
|
|
),
|
|
)
|
|
};
|
|
std::fs::hard_link(&oldpath, &newpath).map_err(err_mapper)?;
|
|
Ok(())
|
|
}
|
|
|
|
#[op]
|
|
async fn op_link_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
args: LinkArgs,
|
|
) -> Result<(), AnyError> {
|
|
let oldpath = PathBuf::from(&args.oldpath);
|
|
let newpath = PathBuf::from(&args.newpath);
|
|
|
|
{
|
|
let mut state = state.borrow_mut();
|
|
let permissions = state.borrow_mut::<Permissions>();
|
|
permissions.read.check(&oldpath)?;
|
|
permissions.write.check(&oldpath)?;
|
|
permissions.read.check(&newpath)?;
|
|
permissions.write.check(&newpath)?;
|
|
}
|
|
|
|
tokio::task::spawn_blocking(move || {
|
|
debug!("op_link_async {} {}", oldpath.display(), newpath.display());
|
|
let err_mapper = |err: Error| {
|
|
Error::new(
|
|
err.kind(),
|
|
format!(
|
|
"{}, link '{}' -> '{}'",
|
|
err,
|
|
oldpath.display(),
|
|
newpath.display()
|
|
),
|
|
)
|
|
};
|
|
std::fs::hard_link(&oldpath, &newpath).map_err(err_mapper)?;
|
|
Ok(())
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct SymlinkArgs {
|
|
oldpath: String,
|
|
newpath: String,
|
|
#[cfg(not(unix))]
|
|
options: Option<SymlinkOptions>,
|
|
}
|
|
|
|
#[cfg(not(unix))]
|
|
#[derive(Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct SymlinkOptions {
|
|
_type: String,
|
|
}
|
|
|
|
#[op]
|
|
fn op_symlink_sync(
|
|
state: &mut OpState,
|
|
args: SymlinkArgs,
|
|
) -> Result<(), AnyError> {
|
|
let oldpath = PathBuf::from(&args.oldpath);
|
|
let newpath = PathBuf::from(&args.newpath);
|
|
|
|
state.borrow_mut::<Permissions>().write.check_all()?;
|
|
state.borrow_mut::<Permissions>().read.check_all()?;
|
|
|
|
debug!(
|
|
"op_symlink_sync {} {}",
|
|
oldpath.display(),
|
|
newpath.display()
|
|
);
|
|
let err_mapper = |err: Error| {
|
|
Error::new(
|
|
err.kind(),
|
|
format!(
|
|
"{}, symlink '{}' -> '{}'",
|
|
err,
|
|
oldpath.display(),
|
|
newpath.display()
|
|
),
|
|
)
|
|
};
|
|
#[cfg(unix)]
|
|
{
|
|
use std::os::unix::fs::symlink;
|
|
symlink(&oldpath, &newpath).map_err(err_mapper)?;
|
|
Ok(())
|
|
}
|
|
#[cfg(not(unix))]
|
|
{
|
|
use std::os::windows::fs::{symlink_dir, symlink_file};
|
|
|
|
match args.options {
|
|
Some(options) => match options._type.as_ref() {
|
|
"file" => symlink_file(&oldpath, &newpath).map_err(err_mapper)?,
|
|
"dir" => symlink_dir(&oldpath, &newpath).map_err(err_mapper)?,
|
|
_ => return Err(type_error("unsupported type")),
|
|
},
|
|
None => {
|
|
let old_meta = std::fs::metadata(&oldpath);
|
|
match old_meta {
|
|
Ok(metadata) => {
|
|
if metadata.is_file() {
|
|
symlink_file(&oldpath, &newpath).map_err(err_mapper)?
|
|
} else if metadata.is_dir() {
|
|
symlink_dir(&oldpath, &newpath).map_err(err_mapper)?
|
|
}
|
|
}
|
|
Err(_) => return Err(type_error("you must pass a `options` argument for non-existent target path in windows".to_string())),
|
|
}
|
|
}
|
|
};
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[op]
|
|
async fn op_symlink_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
args: SymlinkArgs,
|
|
) -> Result<(), AnyError> {
|
|
let oldpath = PathBuf::from(&args.oldpath);
|
|
let newpath = PathBuf::from(&args.newpath);
|
|
|
|
{
|
|
let mut state = state.borrow_mut();
|
|
state.borrow_mut::<Permissions>().write.check_all()?;
|
|
state.borrow_mut::<Permissions>().read.check_all()?;
|
|
}
|
|
|
|
tokio::task::spawn_blocking(move || {
|
|
debug!("op_symlink_async {} {}", oldpath.display(), newpath.display());
|
|
let err_mapper = |err: Error| {
|
|
Error::new(
|
|
err.kind(),
|
|
format!(
|
|
"{}, symlink '{}' -> '{}'",
|
|
err,
|
|
oldpath.display(),
|
|
newpath.display()
|
|
),
|
|
)
|
|
};
|
|
#[cfg(unix)]
|
|
{
|
|
use std::os::unix::fs::symlink;
|
|
symlink(&oldpath, &newpath).map_err(err_mapper)?;
|
|
Ok(())
|
|
}
|
|
#[cfg(not(unix))]
|
|
{
|
|
use std::os::windows::fs::{symlink_dir, symlink_file};
|
|
|
|
match args.options {
|
|
Some(options) => match options._type.as_ref() {
|
|
"file" => symlink_file(&oldpath, &newpath).map_err(err_mapper)?,
|
|
"dir" => symlink_dir(&oldpath, &newpath).map_err(err_mapper)?,
|
|
_ => return Err(type_error("unsupported type")),
|
|
},
|
|
None => {
|
|
let old_meta = std::fs::metadata(&oldpath);
|
|
match old_meta {
|
|
Ok(metadata) => {
|
|
if metadata.is_file() {
|
|
symlink_file(&oldpath, &newpath).map_err(err_mapper)?
|
|
} else if metadata.is_dir() {
|
|
symlink_dir(&oldpath, &newpath).map_err(err_mapper)?
|
|
}
|
|
}
|
|
Err(_) => return Err(type_error("you must pass a `options` argument for non-existent target path in windows".to_string())),
|
|
}
|
|
}
|
|
};
|
|
Ok(())
|
|
}
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
#[op]
|
|
fn op_read_link_sync(
|
|
state: &mut OpState,
|
|
path: String,
|
|
) -> Result<String, AnyError> {
|
|
let path = PathBuf::from(&path);
|
|
|
|
state.borrow_mut::<Permissions>().read.check(&path)?;
|
|
|
|
debug!("op_read_link_value {}", path.display());
|
|
let err_mapper = |err: Error| {
|
|
Error::new(
|
|
err.kind(),
|
|
format!("{}, readlink '{}'", err, path.display()),
|
|
)
|
|
};
|
|
let target = std::fs::read_link(&path)
|
|
.map_err(err_mapper)?
|
|
.into_os_string();
|
|
let targetstr = into_string(target)?;
|
|
Ok(targetstr)
|
|
}
|
|
|
|
#[op]
|
|
async fn op_read_link_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
path: String,
|
|
) -> Result<String, AnyError> {
|
|
let path = PathBuf::from(&path);
|
|
{
|
|
let mut state = state.borrow_mut();
|
|
state.borrow_mut::<Permissions>().read.check(&path)?;
|
|
}
|
|
tokio::task::spawn_blocking(move || {
|
|
debug!("op_read_link_async {}", path.display());
|
|
let err_mapper = |err: Error| {
|
|
Error::new(
|
|
err.kind(),
|
|
format!("{}, readlink '{}'", err, path.display()),
|
|
)
|
|
};
|
|
let target = std::fs::read_link(&path)
|
|
.map_err(err_mapper)?
|
|
.into_os_string();
|
|
let targetstr = into_string(target)?;
|
|
Ok(targetstr)
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct FtruncateArgs {
|
|
rid: ResourceId,
|
|
len: i32,
|
|
}
|
|
|
|
#[op]
|
|
fn op_ftruncate_sync(
|
|
state: &mut OpState,
|
|
args: FtruncateArgs,
|
|
) -> Result<(), AnyError> {
|
|
let rid = args.rid;
|
|
let len = args.len as u64;
|
|
StdFileResource::with_file(state, rid, |std_file| {
|
|
std_file.set_len(len).map_err(AnyError::from)
|
|
})?;
|
|
Ok(())
|
|
}
|
|
|
|
#[op]
|
|
async fn op_ftruncate_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
args: FtruncateArgs,
|
|
) -> Result<(), AnyError> {
|
|
let rid = args.rid;
|
|
let len = args.len as u64;
|
|
|
|
let resource = state
|
|
.borrow_mut()
|
|
.resource_table
|
|
.get::<StdFileResource>(rid)?;
|
|
|
|
let std_file = resource.std_file();
|
|
|
|
tokio::task::spawn_blocking(move || {
|
|
let std_file = std_file.lock();
|
|
std_file.set_len(len)
|
|
})
|
|
.await?
|
|
.map_err(AnyError::from)
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct TruncateArgs {
|
|
path: String,
|
|
len: u64,
|
|
}
|
|
|
|
#[op]
|
|
fn op_truncate_sync(
|
|
state: &mut OpState,
|
|
args: TruncateArgs,
|
|
) -> Result<(), AnyError> {
|
|
let path = PathBuf::from(&args.path);
|
|
let len = args.len;
|
|
|
|
state.borrow_mut::<Permissions>().write.check(&path)?;
|
|
|
|
debug!("op_truncate_sync {} {}", path.display(), len);
|
|
let err_mapper = |err: Error| {
|
|
Error::new(
|
|
err.kind(),
|
|
format!("{}, truncate '{}'", err, path.display()),
|
|
)
|
|
};
|
|
let f = std::fs::OpenOptions::new()
|
|
.write(true)
|
|
.open(&path)
|
|
.map_err(err_mapper)?;
|
|
f.set_len(len).map_err(err_mapper)?;
|
|
Ok(())
|
|
}
|
|
|
|
#[op]
|
|
async fn op_truncate_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
args: TruncateArgs,
|
|
) -> Result<(), AnyError> {
|
|
let path = PathBuf::from(&args.path);
|
|
let len = args.len;
|
|
{
|
|
let mut state = state.borrow_mut();
|
|
state.borrow_mut::<Permissions>().write.check(&path)?;
|
|
}
|
|
tokio::task::spawn_blocking(move || {
|
|
debug!("op_truncate_async {} {}", path.display(), len);
|
|
let err_mapper = |err: Error| {
|
|
Error::new(
|
|
err.kind(),
|
|
format!("{}, truncate '{}'", err, path.display()),
|
|
)
|
|
};
|
|
let f = std::fs::OpenOptions::new()
|
|
.write(true)
|
|
.open(&path)
|
|
.map_err(err_mapper)?;
|
|
f.set_len(len).map_err(err_mapper)?;
|
|
Ok(())
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
fn make_temp(
|
|
dir: Option<&Path>,
|
|
prefix: Option<&str>,
|
|
suffix: Option<&str>,
|
|
is_dir: bool,
|
|
) -> std::io::Result<PathBuf> {
|
|
let prefix_ = prefix.unwrap_or("");
|
|
let suffix_ = suffix.unwrap_or("");
|
|
let mut buf: PathBuf = match dir {
|
|
Some(p) => p.to_path_buf(),
|
|
None => temp_dir(),
|
|
}
|
|
.join("_");
|
|
let mut rng = thread_rng();
|
|
loop {
|
|
let unique = rng.gen::<u32>();
|
|
buf.set_file_name(format!("{}{:08x}{}", prefix_, unique, suffix_));
|
|
let r = if is_dir {
|
|
#[allow(unused_mut)]
|
|
let mut builder = std::fs::DirBuilder::new();
|
|
#[cfg(unix)]
|
|
{
|
|
use std::os::unix::fs::DirBuilderExt;
|
|
builder.mode(0o700);
|
|
}
|
|
builder.create(buf.as_path())
|
|
} else {
|
|
let mut open_options = std::fs::OpenOptions::new();
|
|
open_options.write(true).create_new(true);
|
|
#[cfg(unix)]
|
|
{
|
|
use std::os::unix::fs::OpenOptionsExt;
|
|
open_options.mode(0o600);
|
|
}
|
|
open_options.open(buf.as_path())?;
|
|
Ok(())
|
|
};
|
|
match r {
|
|
Err(ref e) if e.kind() == std::io::ErrorKind::AlreadyExists => continue,
|
|
Ok(_) => return Ok(buf),
|
|
Err(e) => return Err(e),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct MakeTempArgs {
|
|
dir: Option<String>,
|
|
prefix: Option<String>,
|
|
suffix: Option<String>,
|
|
}
|
|
|
|
#[op]
|
|
fn op_make_temp_dir_sync(
|
|
state: &mut OpState,
|
|
args: MakeTempArgs,
|
|
) -> Result<String, AnyError> {
|
|
let dir = args.dir.map(|s| PathBuf::from(&s));
|
|
let prefix = args.prefix.map(String::from);
|
|
let suffix = args.suffix.map(String::from);
|
|
|
|
state
|
|
.borrow_mut::<Permissions>()
|
|
.write
|
|
.check(dir.clone().unwrap_or_else(temp_dir).as_path())?;
|
|
|
|
// TODO(piscisaureus): use byte vector for paths, not a string.
|
|
// See https://github.com/denoland/deno/issues/627.
|
|
// We can't assume that paths are always valid utf8 strings.
|
|
let path = make_temp(
|
|
// Converting Option<String> to Option<&str>
|
|
dir.as_deref(),
|
|
prefix.as_deref(),
|
|
suffix.as_deref(),
|
|
true,
|
|
)?;
|
|
let path_str = into_string(path.into_os_string())?;
|
|
|
|
Ok(path_str)
|
|
}
|
|
|
|
#[op]
|
|
async fn op_make_temp_dir_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
args: MakeTempArgs,
|
|
) -> Result<String, AnyError> {
|
|
let dir = args.dir.map(|s| PathBuf::from(&s));
|
|
let prefix = args.prefix.map(String::from);
|
|
let suffix = args.suffix.map(String::from);
|
|
{
|
|
let mut state = state.borrow_mut();
|
|
state
|
|
.borrow_mut::<Permissions>()
|
|
.write
|
|
.check(dir.clone().unwrap_or_else(temp_dir).as_path())?;
|
|
}
|
|
tokio::task::spawn_blocking(move || {
|
|
// TODO(piscisaureus): use byte vector for paths, not a string.
|
|
// See https://github.com/denoland/deno/issues/627.
|
|
// We can't assume that paths are always valid utf8 strings.
|
|
let path = make_temp(
|
|
// Converting Option<String> to Option<&str>
|
|
dir.as_deref(),
|
|
prefix.as_deref(),
|
|
suffix.as_deref(),
|
|
true,
|
|
)?;
|
|
let path_str = into_string(path.into_os_string())?;
|
|
|
|
Ok(path_str)
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
#[op]
|
|
fn op_make_temp_file_sync(
|
|
state: &mut OpState,
|
|
args: MakeTempArgs,
|
|
) -> Result<String, AnyError> {
|
|
let dir = args.dir.map(|s| PathBuf::from(&s));
|
|
let prefix = args.prefix.map(String::from);
|
|
let suffix = args.suffix.map(String::from);
|
|
|
|
state
|
|
.borrow_mut::<Permissions>()
|
|
.write
|
|
.check(dir.clone().unwrap_or_else(temp_dir).as_path())?;
|
|
|
|
// TODO(piscisaureus): use byte vector for paths, not a string.
|
|
// See https://github.com/denoland/deno/issues/627.
|
|
// We can't assume that paths are always valid utf8 strings.
|
|
let path = make_temp(
|
|
// Converting Option<String> to Option<&str>
|
|
dir.as_deref(),
|
|
prefix.as_deref(),
|
|
suffix.as_deref(),
|
|
false,
|
|
)?;
|
|
let path_str = into_string(path.into_os_string())?;
|
|
|
|
Ok(path_str)
|
|
}
|
|
|
|
#[op]
|
|
async fn op_make_temp_file_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
args: MakeTempArgs,
|
|
) -> Result<String, AnyError> {
|
|
let dir = args.dir.map(|s| PathBuf::from(&s));
|
|
let prefix = args.prefix.map(String::from);
|
|
let suffix = args.suffix.map(String::from);
|
|
{
|
|
let mut state = state.borrow_mut();
|
|
state
|
|
.borrow_mut::<Permissions>()
|
|
.write
|
|
.check(dir.clone().unwrap_or_else(temp_dir).as_path())?;
|
|
}
|
|
tokio::task::spawn_blocking(move || {
|
|
// TODO(piscisaureus): use byte vector for paths, not a string.
|
|
// See https://github.com/denoland/deno/issues/627.
|
|
// We can't assume that paths are always valid utf8 strings.
|
|
let path = make_temp(
|
|
// Converting Option<String> to Option<&str>
|
|
dir.as_deref(),
|
|
prefix.as_deref(),
|
|
suffix.as_deref(),
|
|
false,
|
|
)?;
|
|
let path_str = into_string(path.into_os_string())?;
|
|
|
|
Ok(path_str)
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct FutimeArgs {
|
|
rid: ResourceId,
|
|
atime: (i64, u32),
|
|
mtime: (i64, u32),
|
|
}
|
|
|
|
#[op]
|
|
fn op_futime_sync(
|
|
state: &mut OpState,
|
|
args: FutimeArgs,
|
|
) -> Result<(), AnyError> {
|
|
super::check_unstable(state, "Deno.futimeSync");
|
|
let rid = args.rid;
|
|
let atime = filetime::FileTime::from_unix_time(args.atime.0, args.atime.1);
|
|
let mtime = filetime::FileTime::from_unix_time(args.mtime.0, args.mtime.1);
|
|
|
|
StdFileResource::with_file(state, rid, |std_file| {
|
|
filetime::set_file_handle_times(std_file, Some(atime), Some(mtime))
|
|
.map_err(AnyError::from)
|
|
})?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[op]
|
|
async fn op_futime_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
args: FutimeArgs,
|
|
) -> Result<(), AnyError> {
|
|
super::check_unstable2(&state, "Deno.futime");
|
|
let rid = args.rid;
|
|
let atime = filetime::FileTime::from_unix_time(args.atime.0, args.atime.1);
|
|
let mtime = filetime::FileTime::from_unix_time(args.mtime.0, args.mtime.1);
|
|
|
|
let resource = state
|
|
.borrow_mut()
|
|
.resource_table
|
|
.get::<StdFileResource>(rid)?;
|
|
|
|
let std_file = resource.std_file();
|
|
tokio::task::spawn_blocking(move || {
|
|
let std_file = std_file.lock();
|
|
filetime::set_file_handle_times(&std_file, Some(atime), Some(mtime))?;
|
|
Ok(())
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct UtimeArgs {
|
|
path: String,
|
|
atime: (i64, u32),
|
|
mtime: (i64, u32),
|
|
}
|
|
|
|
#[op]
|
|
fn op_utime_sync(state: &mut OpState, args: UtimeArgs) -> Result<(), AnyError> {
|
|
super::check_unstable(state, "Deno.utime");
|
|
|
|
let path = PathBuf::from(&args.path);
|
|
let atime = filetime::FileTime::from_unix_time(args.atime.0, args.atime.1);
|
|
let mtime = filetime::FileTime::from_unix_time(args.mtime.0, args.mtime.1);
|
|
|
|
state.borrow_mut::<Permissions>().write.check(&path)?;
|
|
filetime::set_file_times(&path, atime, mtime).map_err(|err| {
|
|
Error::new(err.kind(), format!("{}, utime '{}'", err, path.display()))
|
|
})?;
|
|
Ok(())
|
|
}
|
|
|
|
#[op]
|
|
async fn op_utime_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
args: UtimeArgs,
|
|
) -> Result<(), AnyError> {
|
|
super::check_unstable(&state.borrow(), "Deno.utime");
|
|
|
|
let path = PathBuf::from(&args.path);
|
|
let atime = filetime::FileTime::from_unix_time(args.atime.0, args.atime.1);
|
|
let mtime = filetime::FileTime::from_unix_time(args.mtime.0, args.mtime.1);
|
|
|
|
state
|
|
.borrow_mut()
|
|
.borrow_mut::<Permissions>()
|
|
.write
|
|
.check(&path)?;
|
|
|
|
tokio::task::spawn_blocking(move || {
|
|
filetime::set_file_times(&path, atime, mtime).map_err(|err| {
|
|
Error::new(err.kind(), format!("{}, utime '{}'", err, path.display()))
|
|
})?;
|
|
Ok(())
|
|
})
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
#[op]
|
|
fn op_cwd(state: &mut OpState) -> Result<String, AnyError> {
|
|
let path = current_dir()?;
|
|
state
|
|
.borrow_mut::<Permissions>()
|
|
.read
|
|
.check_blind(&path, "CWD")?;
|
|
let path_str = into_string(path.into_os_string())?;
|
|
Ok(path_str)
|
|
}
|
|
|
|
#[op]
|
|
fn op_readfile_sync(
|
|
state: &mut OpState,
|
|
path: String,
|
|
) -> Result<ZeroCopyBuf, AnyError> {
|
|
let permissions = state.borrow_mut::<Permissions>();
|
|
let path = Path::new(&path);
|
|
permissions.read.check(path)?;
|
|
Ok(std::fs::read(path)?.into())
|
|
}
|
|
|
|
#[op]
|
|
fn op_readfile_text_sync(
|
|
state: &mut OpState,
|
|
path: String,
|
|
) -> Result<String, AnyError> {
|
|
let permissions = state.borrow_mut::<Permissions>();
|
|
let path = Path::new(&path);
|
|
permissions.read.check(path)?;
|
|
Ok(string_from_utf8_lossy(std::fs::read(path)?))
|
|
}
|
|
|
|
#[op]
|
|
async fn op_readfile_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
path: String,
|
|
cancel_rid: Option<ResourceId>,
|
|
) -> Result<ZeroCopyBuf, AnyError> {
|
|
{
|
|
let path = Path::new(&path);
|
|
let mut state = state.borrow_mut();
|
|
state.borrow_mut::<Permissions>().read.check(path)?;
|
|
}
|
|
let fut = tokio::task::spawn_blocking(move || {
|
|
let path = Path::new(&path);
|
|
Ok(std::fs::read(path).map(ZeroCopyBuf::from)?)
|
|
});
|
|
if let Some(cancel_rid) = cancel_rid {
|
|
let cancel_handle = state
|
|
.borrow_mut()
|
|
.resource_table
|
|
.get::<CancelHandle>(cancel_rid);
|
|
if let Ok(cancel_handle) = cancel_handle {
|
|
return fut.or_cancel(cancel_handle).await??;
|
|
}
|
|
}
|
|
fut.await?
|
|
}
|
|
|
|
#[op]
|
|
async fn op_readfile_text_async(
|
|
state: Rc<RefCell<OpState>>,
|
|
path: String,
|
|
cancel_rid: Option<ResourceId>,
|
|
) -> Result<String, AnyError> {
|
|
{
|
|
let path = Path::new(&path);
|
|
let mut state = state.borrow_mut();
|
|
state.borrow_mut::<Permissions>().read.check(path)?;
|
|
}
|
|
let fut = tokio::task::spawn_blocking(move || {
|
|
let path = Path::new(&path);
|
|
Ok(string_from_utf8_lossy(std::fs::read(path)?))
|
|
});
|
|
if let Some(cancel_rid) = cancel_rid {
|
|
let cancel_handle = state
|
|
.borrow_mut()
|
|
.resource_table
|
|
.get::<CancelHandle>(cancel_rid);
|
|
if let Ok(cancel_handle) = cancel_handle {
|
|
return fut.or_cancel(cancel_handle).await??;
|
|
}
|
|
}
|
|
fut.await?
|
|
}
|
|
|
|
// Like String::from_utf8_lossy but operates on owned values
|
|
fn string_from_utf8_lossy(buf: Vec<u8>) -> String {
|
|
match String::from_utf8_lossy(&buf) {
|
|
// buf contained non-utf8 chars than have been patched
|
|
Cow::Owned(s) => s,
|
|
// SAFETY: if Borrowed then the buf only contains utf8 chars,
|
|
// we do this instead of .into_owned() to avoid copying the input buf
|
|
Cow::Borrowed(_) => unsafe { String::from_utf8_unchecked(buf) },
|
|
}
|
|
}
|