diff options
Diffstat (limited to 'cli')
| -rw-r--r-- | cli/msg.fbs | 114 | ||||
| -rw-r--r-- | cli/ops/dispatch_flatbuffers.rs | 24 | ||||
| -rw-r--r-- | cli/ops/fs.rs | 532 | ||||
| -rw-r--r-- | cli/ops/mod.rs | 56 | ||||
| -rw-r--r-- | cli/ops/utils.rs | 1 |
5 files changed, 334 insertions, 393 deletions
diff --git a/cli/msg.fbs b/cli/msg.fbs index a7359c527..b5fc52483 100644 --- a/cli/msg.fbs +++ b/cli/msg.fbs @@ -1,27 +1,7 @@ union Any { - Chdir, - Chmod, - Chown, - CopyFile, - Cwd, - CwdRes, - Link, - MakeTempDir, - MakeTempDirRes, - Mkdir, Read, - ReadDir, - ReadDirRes, ReadRes, - Readlink, - ReadlinkRes, - Remove, - Rename, Seek, - Stat, - StatRes, - Symlink, - Truncate, Write, WriteRes, } @@ -122,105 +102,11 @@ table FormatErrorRes { error: string; } -table Chdir { - directory: string; -} - table KeyValue { key: string; value: string; } -table MakeTempDir { - dir: string; - prefix: string; - suffix: string; -} - -table MakeTempDirRes { - path: string; -} - -table Mkdir { - path: string; - recursive: bool; - mode: uint; // Specified by https://godoc.org/os#FileMode -} - -table Chmod { - path: string; - mode: uint; // Specified by https://godoc.org/os#FileMode -} - -table Chown { - path: string; - uid: uint; - gid: uint; // Specified by https://godoc.org/os#Chown -} - -table Remove { - path: string; - recursive: bool; -} - -table ReadDir { - path: string; -} - -table ReadDirRes { - entries: [StatRes]; -} - -table CopyFile { - from: string; - to: string; -} - -table Rename { - oldpath: string; - newpath: string; -} - -table Readlink { - name: string; -} - -table ReadlinkRes { - path: string; -} - -table Symlink { - oldname: string; - newname: string; -} - -table Link { - oldname: string; - newname: string; -} - -table Stat { - filename: string; - lstat: bool; -} - -table StatRes { - is_file: bool; - is_symlink: bool; - len: ulong; - modified:ulong; - accessed:ulong; - created:ulong; - mode: uint; - has_mode: bool; // false on windows - name: string; -} - -table Truncate { - name: string; - len: uint; -} - table Read { rid: uint32; // (ptr, len) is passed as second parameter to Deno.core.send(). diff --git a/cli/ops/dispatch_flatbuffers.rs b/cli/ops/dispatch_flatbuffers.rs index bd0158751..edec77703 100644 --- a/cli/ops/dispatch_flatbuffers.rs +++ b/cli/ops/dispatch_flatbuffers.rs @@ -6,19 +6,14 @@ use deno::*; use flatbuffers::FlatBufferBuilder; use hyper::rt::Future; -use super::files::{op_read, op_write}; -use super::fs::{ - op_chdir, op_chmod, op_chown, op_copy_file, op_cwd, op_link, - op_make_temp_dir, op_mkdir, op_read_dir, op_read_link, op_remove, op_rename, - op_stat, op_symlink, op_truncate, -}; - type CliDispatchFn = fn( state: &ThreadSafeState, base: &msg::Base<'_>, data: Option<PinnedBuf>, ) -> CliOpResult; +use super::files::{op_read, op_write}; + /// Processes raw messages from JavaScript. /// This functions invoked every time Deno.core.dispatch() is called. /// control corresponds to the first argument of Deno.core.dispatch(). @@ -125,22 +120,7 @@ pub fn serialize_response( /// Standard ops set for most isolates pub fn op_selector_std(inner_type: msg::Any) -> Option<CliDispatchFn> { match inner_type { - msg::Any::Chdir => Some(op_chdir), - msg::Any::Chmod => Some(op_chmod), - msg::Any::Chown => Some(op_chown), - msg::Any::CopyFile => Some(op_copy_file), - msg::Any::Cwd => Some(op_cwd), - msg::Any::Link => Some(op_link), - msg::Any::MakeTempDir => Some(op_make_temp_dir), - msg::Any::Mkdir => Some(op_mkdir), msg::Any::Read => Some(op_read), - msg::Any::ReadDir => Some(op_read_dir), - msg::Any::Readlink => Some(op_read_link), - msg::Any::Remove => Some(op_remove), - msg::Any::Rename => Some(op_rename), - msg::Any::Stat => Some(op_stat), - msg::Any::Symlink => Some(op_symlink), - msg::Any::Truncate => Some(op_truncate), msg::Any::Write => Some(op_write), _ => None, diff --git a/cli/ops/fs.rs b/cli/ops/fs.rs index f655e4e2d..c549bef32 100644 --- a/cli/ops/fs.rs +++ b/cli/ops/fs.rs @@ -1,14 +1,12 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -use super::dispatch_flatbuffers::serialize_response; +// Some deserializer fields are only used on Unix and Windows build fails without it +#![allow(dead_code)] use super::dispatch_json::{blocking_json, Deserialize, JsonOp, Value}; -use super::utils::*; use crate::deno_error::DenoError; use crate::deno_error::ErrorKind; use crate::fs as deno_fs; -use crate::msg; use crate::state::ThreadSafeState; use deno::*; -use flatbuffers::FlatBufferBuilder; use remove_dir_all::remove_dir_all; use std::convert::From; use std::fs; @@ -18,99 +16,130 @@ use std::time::UNIX_EPOCH; #[cfg(unix)] use std::os::unix::fs::PermissionsExt; +#[derive(Deserialize)] +struct ChdirArgs { + directory: String, +} + pub fn op_chdir( _state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let inner = base.inner_as_chdir().unwrap(); - let directory = inner.directory().unwrap(); - std::env::set_current_dir(&directory)?; - ok_buf(empty_buf()) + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: ChdirArgs = serde_json::from_value(args)?; + std::env::set_current_dir(&args.directory)?; + Ok(JsonOp::Sync(json!({}))) +} + +#[derive(Deserialize)] +#[serde(rename_all = "camelCase")] +struct MkdirArgs { + promise_id: Option<u64>, + path: String, + recursive: bool, + mode: u32, } pub fn op_mkdir( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let inner = base.inner_as_mkdir().unwrap(); - let (path, path_) = deno_fs::resolve_from_cwd(inner.path().unwrap())?; - let recursive = inner.recursive(); - let mode = inner.mode(); + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: MkdirArgs = serde_json::from_value(args)?; + let (path, path_) = deno_fs::resolve_from_cwd(args.path.as_ref())?; state.check_write(&path_)?; - blocking(base.sync(), move || { + let is_sync = args.promise_id.is_none(); + blocking_json(is_sync, move || { debug!("op_mkdir {}", path_); - deno_fs::mkdir(&path, mode, recursive)?; - Ok(empty_buf()) + deno_fs::mkdir(&path, args.mode, args.recursive)?; + Ok(json!({})) }) } +#[derive(Deserialize)] +#[serde(rename_all = "camelCase")] +struct ChmodArgs { + promise_id: Option<u64>, + path: String, + mode: u32, +} + pub fn op_chmod( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let inner = base.inner_as_chmod().unwrap(); - let _mode = inner.mode(); - let (path, path_) = deno_fs::resolve_from_cwd(inner.path().unwrap())?; + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: ChmodArgs = serde_json::from_value(args)?; + let (path, path_) = deno_fs::resolve_from_cwd(args.path.as_ref())?; state.check_write(&path_)?; - blocking(base.sync(), move || { + let is_sync = args.promise_id.is_none(); + blocking_json(is_sync, move || { debug!("op_chmod {}", &path_); // Still check file/dir exists on windows let _metadata = fs::metadata(&path)?; #[cfg(any(unix))] { let mut permissions = _metadata.permissions(); - permissions.set_mode(_mode); + permissions.set_mode(args.mode); fs::set_permissions(&path, permissions)?; } - Ok(empty_buf()) + Ok(json!({})) }) } +#[derive(Deserialize)] +#[serde(rename_all = "camelCase")] +struct ChownArgs { + promise_id: Option<u64>, + path: String, + uid: u32, + gid: u32, +} + pub fn op_chown( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let inner = base.inner_as_chown().unwrap(); - let path = String::from(inner.path().unwrap()); - let uid = inner.uid(); - let gid = inner.gid(); - - state.check_write(&path)?; - - blocking(base.sync(), move || { - debug!("op_chown {}", &path); - match deno_fs::chown(&path, uid, gid) { - Ok(_) => Ok(empty_buf()), + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: ChownArgs = serde_json::from_value(args)?; + + state.check_write(&args.path)?; + + let is_sync = args.promise_id.is_none(); + blocking_json(is_sync, move || { + debug!("op_chown {}", &args.path); + match deno_fs::chown(args.path.as_ref(), args.uid, args.gid) { + Ok(_) => Ok(json!({})), Err(e) => Err(e), } }) } +#[derive(Deserialize)] +#[serde(rename_all = "camelCase")] +struct RemoveArgs { + promise_id: Option<u64>, + path: String, + recursive: bool, +} + pub fn op_remove( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let inner = base.inner_as_remove().unwrap(); - let (path, path_) = deno_fs::resolve_from_cwd(inner.path().unwrap())?; - let recursive = inner.recursive(); + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: RemoveArgs = serde_json::from_value(args)?; + let (path, path_) = deno_fs::resolve_from_cwd(args.path.as_ref())?; + let recursive = args.recursive; state.check_write(&path_)?; - blocking(base.sync(), move || { + let is_sync = args.promise_id.is_none(); + blocking_json(is_sync, move || { debug!("op_remove {}", path.display()); let metadata = fs::metadata(&path)?; if metadata.is_file() { @@ -120,25 +149,34 @@ pub fn op_remove( } else { fs::remove_dir(&path)?; } - Ok(empty_buf()) + Ok(json!({})) }) } +#[derive(Deserialize)] +#[serde(rename_all = "camelCase")] +struct CopyFileArgs { + promise_id: Option<u64>, + from: String, + to: String, +} + pub fn op_copy_file( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let inner = base.inner_as_copy_file().unwrap(); - let (from, from_) = deno_fs::resolve_from_cwd(inner.from().unwrap())?; - let (to, to_) = deno_fs::resolve_from_cwd(inner.to().unwrap())?; + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: CopyFileArgs = serde_json::from_value(args)?; + + let (from, from_) = deno_fs::resolve_from_cwd(args.from.as_ref())?; + let (to, to_) = deno_fs::resolve_from_cwd(args.to.as_ref())?; state.check_read(&from_)?; state.check_write(&to_)?; debug!("op_copy_file {} {}", from.display(), to.display()); - blocking(base.sync(), move || { + let is_sync = args.promise_id.is_none(); + blocking_json(is_sync, move || { // On *nix, Rust deem non-existent path as invalid input // See https://github.com/rust-lang/rust/issues/54800 // Once the issue is reolved, we should remove this workaround. @@ -150,7 +188,7 @@ pub fn op_copy_file( } fs::copy(&from, &to)?; - Ok(empty_buf()) + Ok(json!({})) }) } @@ -174,22 +212,29 @@ fn get_mode(_perm: &fs::Permissions) -> u32 { 0 } +#[derive(Deserialize)] +#[serde(rename_all = "camelCase")] +struct StatArgs { + promise_id: Option<u64>, + filename: String, + lstat: bool, +} + pub fn op_stat( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let inner = base.inner_as_stat().unwrap(); - let cmd_id = base.cmd_id(); + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: StatArgs = serde_json::from_value(args)?; + let (filename, filename_) = - deno_fs::resolve_from_cwd(inner.filename().unwrap())?; - let lstat = inner.lstat(); + deno_fs::resolve_from_cwd(args.filename.as_ref())?; + let lstat = args.lstat; state.check_read(&filename_)?; - blocking(base.sync(), move || { - let builder = &mut FlatBufferBuilder::new(); + let is_sync = args.promise_id.is_none(); + blocking_json(is_sync, move || { debug!("op_stat {} {}", filename.display(), lstat); let metadata = if lstat { fs::symlink_metadata(&filename)? @@ -197,146 +242,140 @@ pub fn op_stat( fs::metadata(&filename)? }; - let inner = msg::StatRes::create( - builder, - &msg::StatResArgs { - is_file: metadata.is_file(), - is_symlink: metadata.file_type().is_symlink(), - len: metadata.len(), - modified: to_seconds!(metadata.modified()), - accessed: to_seconds!(metadata.accessed()), - created: to_seconds!(metadata.created()), - mode: get_mode(&metadata.permissions()), - has_mode: cfg!(target_family = "unix"), - ..Default::default() - }, - ); - - Ok(serialize_response( - cmd_id, - builder, - msg::BaseArgs { - inner: Some(inner.as_union_value()), - inner_type: msg::Any::StatRes, - ..Default::default() - }, - )) + Ok(json!({ + "isFile": metadata.is_file(), + "isSymlink": metadata.file_type().is_symlink(), + "len": metadata.len(), + "modified":to_seconds!(metadata.modified()), + "accessed":to_seconds!(metadata.accessed()), + "created":to_seconds!(metadata.created()), + "mode": get_mode(&metadata.permissions()), + "hasMode": cfg!(target_family = "unix"), // false on windows, + })) }) } +#[derive(Deserialize)] +#[serde(rename_all = "camelCase")] +struct ReadDirArgs { + promise_id: Option<u64>, + path: String, +} + pub fn op_read_dir( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let inner = base.inner_as_read_dir().unwrap(); - let cmd_id = base.cmd_id(); - let (path, path_) = deno_fs::resolve_from_cwd(inner.path().unwrap())?; + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: ReadDirArgs = serde_json::from_value(args)?; + let (path, path_) = deno_fs::resolve_from_cwd(args.path.as_ref())?; state.check_read(&path_)?; - blocking(base.sync(), move || { + let is_sync = args.promise_id.is_none(); + blocking_json(is_sync, move || { debug!("op_read_dir {}", path.display()); - let builder = &mut FlatBufferBuilder::new(); + let entries: Vec<_> = fs::read_dir(path)? .map(|entry| { let entry = entry.unwrap(); let metadata = entry.metadata().unwrap(); let file_type = metadata.file_type(); - let name = builder.create_string(entry.file_name().to_str().unwrap()); - - msg::StatRes::create( - builder, - &msg::StatResArgs { - is_file: file_type.is_file(), - is_symlink: file_type.is_symlink(), - len: metadata.len(), - modified: to_seconds!(metadata.modified()), - accessed: to_seconds!(metadata.accessed()), - created: to_seconds!(metadata.created()), - name: Some(name), - mode: get_mode(&metadata.permissions()), - has_mode: cfg!(target_family = "unix"), - }, - ) + + json!({ + "isFile": file_type.is_file(), + "isSymlink": file_type.is_symlink(), + "len": metadata.len(), + "modified": to_seconds!(metadata.modified()), + "accessed": to_seconds!(metadata.accessed()), + "created": to_seconds!(metadata.created()), + "mode": get_mode(&metadata.permissions()), + "name": entry.file_name().to_str().unwrap(), + "hasMode": cfg!(target_family = "unix"), // false on windows, + }) }) .collect(); - let entries = builder.create_vector(&entries); - let inner = msg::ReadDirRes::create( - builder, - &msg::ReadDirResArgs { - entries: Some(entries), - }, - ); - Ok(serialize_response( - cmd_id, - builder, - msg::BaseArgs { - inner: Some(inner.as_union_value()), - inner_type: msg::Any::ReadDirRes, - ..Default::default() - }, - )) + Ok(json!({ "entries": entries })) }) } +#[derive(Deserialize)] +#[serde(rename_all = "camelCase")] +struct RenameArgs { + promise_id: Option<u64>, + oldpath: String, + newpath: String, +} + pub fn op_rename( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let inner = base.inner_as_rename().unwrap(); - let (oldpath, oldpath_) = - deno_fs::resolve_from_cwd(inner.oldpath().unwrap())?; - let (newpath, newpath_) = - deno_fs::resolve_from_cwd(inner.newpath().unwrap())?; + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: RenameArgs = serde_json::from_value(args)?; + + let (oldpath, oldpath_) = deno_fs::resolve_from_cwd(args.oldpath.as_ref())?; + let (newpath, newpath_) = deno_fs::resolve_from_cwd(args.newpath.as_ref())?; state.check_read(&oldpath_)?; state.check_write(&oldpath_)?; state.check_write(&newpath_)?; - blocking(base.sync(), move || { + let is_sync = args.promise_id.is_none(); + blocking_json(is_sync, move || { debug!("op_rename {} {}", oldpath.display(), newpath.display()); fs::rename(&oldpath, &newpath)?; - Ok(empty_buf()) + Ok(json!({})) }) } +#[derive(Deserialize)] +#[serde(rename_all = "camelCase")] +struct LinkArgs { + promise_id: Option<u64>, + oldname: String, + newname: String, +} + pub fn op_link( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let inner = base.inner_as_link().unwrap(); - let (oldname, oldpath_) = - deno_fs::resolve_from_cwd(inner.oldname().unwrap())?; - let (newname, newname_) = - deno_fs::resolve_from_cwd(inner.newname().unwrap())?; + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: LinkArgs = serde_json::from_value(args)?; - state.check_read(&oldpath_)?; + let (oldname, oldname_) = deno_fs::resolve_from_cwd(args.oldname.as_ref())?; + let (newname, newname_) = deno_fs::resolve_from_cwd(args.newname.as_ref())?; + + state.check_read(&oldname_)?; state.check_write(&newname_)?; - blocking(base.sync(), move || { + let is_sync = args.promise_id.is_none(); + blocking_json(is_sync, move || { debug!("op_link {} {}", oldname.display(), newname.display()); std::fs::hard_link(&oldname, &newname)?; - Ok(empty_buf()) + Ok(json!({})) }) } +#[derive(Deserialize)] +#[serde(rename_all = "camelCase")] +struct SymlinkArgs { + promise_id: Option<u64>, + oldname: String, + newname: String, +} + pub fn op_symlink( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let inner = base.inner_as_symlink().unwrap(); - let (oldname, _) = deno_fs::resolve_from_cwd(inner.oldname().unwrap())?; - let (newname, newname_) = - deno_fs::resolve_from_cwd(inner.newname().unwrap())?; + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: SymlinkArgs = serde_json::from_value(args)?; + + let (oldname, _oldname_) = deno_fs::resolve_from_cwd(args.oldname.as_ref())?; + let (newname, newname_) = deno_fs::resolve_from_cwd(args.newname.as_ref())?; state.check_write(&newname_)?; // TODO Use type for Windows. @@ -345,88 +384,97 @@ pub fn op_symlink( DenoError::new(ErrorKind::Other, "Not implemented".to_string()).into(), ); } - blocking(base.sync(), move || { + let is_sync = args.promise_id.is_none(); + blocking_json(is_sync, move || { debug!("op_symlink {} {}", oldname.display(), newname.display()); #[cfg(any(unix))] std::os::unix::fs::symlink(&oldname, &newname)?; - Ok(empty_buf()) + Ok(json!({})) }) } +#[derive(Deserialize)] +#[serde(rename_all = "camelCase")] +struct ReadLinkArgs { + promise_id: Option<u64>, + name: String, +} + pub fn op_read_link( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let inner = base.inner_as_readlink().unwrap(); - let cmd_id = base.cmd_id(); - let (name, name_) = deno_fs::resolve_from_cwd(inner.name().unwrap())?; + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: ReadLinkArgs = serde_json::from_value(args)?; + + let (name, name_) = deno_fs::resolve_from_cwd(args.name.as_ref())?; state.check_read(&name_)?; - blocking(base.sync(), move || { + let is_sync = args.promise_id.is_none(); + blocking_json(is_sync, move || { debug!("op_read_link {}", name.display()); let path = fs::read_link(&name)?; - let builder = &mut FlatBufferBuilder::new(); - let path_off = builder.create_string(path.to_str().unwrap()); - let inner = msg::ReadlinkRes::create( - builder, - &msg::ReadlinkResArgs { - path: Some(path_off), - }, - ); - Ok(serialize_response( - cmd_id, - builder, - msg::BaseArgs { - inner: Some(inner.as_union_value()), - inner_type: msg::Any::ReadlinkRes, - ..Default::default() - }, - )) + let path_str = path.to_str().unwrap(); + + Ok(json!(path_str)) }) } +#[derive(Deserialize)] +#[serde(rename_all = "camelCase")] +struct TruncateArgs { + promise_id: Option<u64>, + name: String, + len: u64, +} + pub fn op_truncate( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: TruncateArgs = serde_json::from_value(args)?; - let inner = base.inner_as_truncate().unwrap(); - let (filename, filename_) = deno_fs::resolve_from_cwd(inner.name().unwrap())?; - let len = inner.len(); + let (filename, filename_) = deno_fs::resolve_from_cwd(args.name.as_ref())?; + let len = args.len; state.check_write(&filename_)?; - blocking(base.sync(), move || { + let is_sync = args.promise_id.is_none(); + blocking_json(is_sync, move || { debug!("op_truncate {} {}", filename_, len); let f = fs::OpenOptions::new().write(true).open(&filename)?; - f.set_len(u64::from(len))?; - Ok(empty_buf()) + f.set_len(len)?; + Ok(json!({})) }) } +#[derive(Deserialize)] +#[serde(rename_all = "camelCase")] +struct MakeTempDirArgs { + promise_id: Option<u64>, + dir: Option<String>, + prefix: Option<String>, + suffix: Option<String>, +} + pub fn op_make_temp_dir( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let base = Box::new(*base); - let inner = base.inner_as_make_temp_dir().unwrap(); - let cmd_id = base.cmd_id(); + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: MakeTempDirArgs = serde_json::from_value(args)?; // FIXME state.check_write("make_temp")?; - let dir = inner.dir().map(PathBuf::from); - let prefix = inner.prefix().map(String::from); - let suffix = inner.suffix().map(String::from); + let dir = args.dir.map(PathBuf::from); + let prefix = args.prefix.map(String::from); + let suffix = args.suffix.map(String::from); - blocking(base.sync(), move || { + let is_sync = args.promise_id.is_none(); + blocking_json(is_sync, 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. @@ -436,23 +484,9 @@ pub fn op_make_temp_dir( prefix.as_ref().map(|x| &**x), suffix.as_ref().map(|x| &**x), )?; - let builder = &mut FlatBufferBuilder::new(); - let path_off = builder.create_string(path.to_str().unwrap()); - let inner = msg::MakeTempDirRes::create( - builder, - &msg::MakeTempDirResArgs { - path: Some(path_off), - }, - ); - Ok(serialize_response( - cmd_id, - builder, - msg::BaseArgs { - inner: Some(inner.as_union_value()), - inner_type: msg::Any::MakeTempDirRes, - ..Default::default() - }, - )) + let path_str = path.to_str().unwrap(); + + Ok(json!(path_str)) }) } @@ -482,24 +516,10 @@ pub fn op_utime( pub fn op_cwd( _state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let cmd_id = base.cmd_id(); + _args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { let path = std::env::current_dir()?; - let builder = &mut FlatBufferBuilder::new(); - let cwd = - builder.create_string(&path.into_os_string().into_string().unwrap()); - let inner = msg::CwdRes::create(builder, &msg::CwdResArgs { cwd: Some(cwd) }); - let response_buf = serialize_response( - cmd_id, - builder, - msg::BaseArgs { - inner: Some(inner.as_union_value()), - inner_type: msg::Any::CwdRes, - ..Default::default() - }, - ); - ok_buf(response_buf) + let path_str = path.into_os_string().into_string().unwrap(); + Ok(JsonOp::Sync(json!(path_str))) } diff --git a/cli/ops/mod.rs b/cli/ops/mod.rs index 4636754c9..1a853e992 100644 --- a/cli/ops/mod.rs +++ b/cli/ops/mod.rs @@ -26,7 +26,7 @@ mod workers; // Warning! These values are duplicated in the TypeScript code (js/dispatch.ts), // update with care. -pub const OP_FLATBUFFER: OpId = 44; +pub const OP_FLATBUFFER: OpId = 100; pub const OP_READ: OpId = 1; pub const OP_WRITE: OpId = 2; pub const OP_EXIT: OpId = 3; @@ -68,6 +68,21 @@ pub const OP_WORKER_GET_MESSAGE: OpId = 38; pub const OP_RUN: OpId = 39; pub const OP_RUN_STATUS: OpId = 40; pub const OP_KILL: OpId = 41; +pub const OP_CHDIR: OpId = 42; +pub const OP_MKDIR: OpId = 43; +pub const OP_CHMOD: OpId = 44; +pub const OP_CHOWN: OpId = 45; +pub const OP_REMOVE: OpId = 46; +pub const OP_COPY_FILE: OpId = 47; +pub const OP_STAT: OpId = 48; +pub const OP_READ_DIR: OpId = 49; +pub const OP_RENAME: OpId = 50; +pub const OP_LINK: OpId = 51; +pub const OP_SYMLINK: OpId = 52; +pub const OP_READ_LINK: OpId = 53; +pub const OP_TRUNCATE: OpId = 54; +pub const OP_MAKE_TEMP_DIR: OpId = 55; +pub const OP_CWD: OpId = 56; pub fn dispatch( state: &ThreadSafeState, @@ -242,6 +257,45 @@ pub fn dispatch( OP_KILL => { dispatch_json::dispatch(process::op_kill, state, control, zero_copy) } + OP_CHDIR => { + dispatch_json::dispatch(fs::op_chdir, state, control, zero_copy) + } + OP_MKDIR => { + dispatch_json::dispatch(fs::op_mkdir, state, control, zero_copy) + } + OP_CHMOD => { + dispatch_json::dispatch(fs::op_chmod, state, control, zero_copy) + } + OP_CHOWN => { + dispatch_json::dispatch(fs::op_chown, state, control, zero_copy) + } + OP_REMOVE => { + dispatch_json::dispatch(fs::op_remove, state, control, zero_copy) + } + OP_COPY_FILE => { + dispatch_json::dispatch(fs::op_copy_file, state, control, zero_copy) + } + OP_STAT => dispatch_json::dispatch(fs::op_stat, state, control, zero_copy), + OP_READ_DIR => { + dispatch_json::dispatch(fs::op_read_dir, state, control, zero_copy) + } + OP_RENAME => { + dispatch_json::dispatch(fs::op_rename, state, control, zero_copy) + } + OP_LINK => dispatch_json::dispatch(fs::op_link, state, control, zero_copy), + OP_SYMLINK => { + dispatch_json::dispatch(fs::op_symlink, state, control, zero_copy) + } + OP_READ_LINK => { + dispatch_json::dispatch(fs::op_read_link, state, control, zero_copy) + } + OP_TRUNCATE => { + dispatch_json::dispatch(fs::op_truncate, state, control, zero_copy) + } + OP_MAKE_TEMP_DIR => { + dispatch_json::dispatch(fs::op_make_temp_dir, state, control, zero_copy) + } + OP_CWD => dispatch_json::dispatch(fs::op_cwd, state, control, zero_copy), OP_FLATBUFFER => dispatch_flatbuffers::dispatch(state, control, zero_copy), _ => panic!("bad op_id"), }; diff --git a/cli/ops/utils.rs b/cli/ops/utils.rs index 95b13b77a..daa6150a6 100644 --- a/cli/ops/utils.rs +++ b/cli/ops/utils.rs @@ -1,3 +1,4 @@ +#![allow(dead_code)] use crate::tokio_util; use deno::Buf; use deno::ErrBox; |