refactor(runtime/ops): move runtime ops to serde ops

runtime/ops/fs_events.rs

@@ -3,7 +3,6 @@
 use crate::permissions::Permissions;
 use deno_core::error::bad_resource_id;
 use deno_core::error::AnyError;
-use deno_core::serde_json;
 use deno_core::serde_json::json;
 use deno_core::serde_json::Value;
 use deno_core::AsyncRefCell;
@@ -83,17 +82,17 @@ impl From<NotifyEvent> for FsEvent {
  }
 }
 
+#[derive(Deserialize)]
+pub struct OpenArgs {
+ recursive: bool,
+ paths: Vec<String>,
+}
+
 fn op_fs_events_open(
  state: &mut OpState,
- args: Value,
+ args: OpenArgs,
  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, AnyError> {
- #[derive(Deserialize)]
- struct OpenArgs {
- recursive: bool,
- paths: Vec<String>,
- }
- let args: OpenArgs = serde_json::from_value(args)?;
  let (sender, receiver) = mpsc::channel::<Result<FsEvent, AnyError>>(16);
  let sender = std::sync::Mutex::new(sender);
  let mut watcher: RecommendedWatcher =
@@ -125,21 +124,20 @@ fn op_fs_events_open(
  Ok(json!(rid))
 }
 
+#[derive(Deserialize)]
+pub struct PollArgs {
+ rid: u32,
+}
+
 async fn op_fs_events_poll(
  state: Rc<RefCell<OpState>>,
- args: Value,
+ args: PollArgs,
  _zero_copy: BufVec,
 ) -> Result<Value, AnyError> {
- #[derive(Deserialize)]
- struct PollArgs {
- rid: u32,
- }
- let PollArgs { rid } = serde_json::from_value(args)?;
-
  let resource = state
  .borrow()
  .resource_table
- .get::<FsEventsResource>(rid)
+ .get::<FsEventsResource>(args.rid)
  .ok_or_else(bad_resource_id)?;
  let mut receiver = RcRef::map(&resource, |r| &r.receiver).borrow_mut().await;
  let cancel = RcRef::map(resource, |r| &r.cancel);

runtime/ops/io.rs

@@ -3,7 +3,6 @@
 use deno_core::error::resource_unavailable;
 use deno_core::error::AnyError;
 use deno_core::error::{bad_resource_id, not_supported};
-use deno_core::serde_json;
 use deno_core::serde_json::json;
 use deno_core::serde_json::Value;
 use deno_core::AsyncMutFuture;
@@ -615,14 +614,13 @@ struct ShutdownArgs {
 
 async fn op_shutdown(
  state: Rc<RefCell<OpState>>,
- args: Value,
+ args: ShutdownArgs,
  _zero_copy: BufVec,
 ) -> Result<Value, AnyError> {
- let rid = serde_json::from_value::<ShutdownArgs>(args)?.rid;
  let resource = state
  .borrow()
  .resource_table
- .get_any(rid)
+ .get_any(args.rid)
  .ok_or_else(bad_resource_id)?;
  if let Some(s) = resource.downcast_rc::<ChildStdinResource>() {
  s.shutdown().await?;

runtime/ops/net.rs

@@ -520,42 +520,42 @@ enum DnsReturnRecord {
  TXT(Vec<String>),
 }
 
-async fn op_dns_resolve(
- state: Rc<RefCell<OpState>>,
- args: Value,
- _zero_copy: BufVec,
-) -> Result<Value, AnyError> {
- fn default_port() -> u16 {
- 53
- }
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ResolveAddrArgs {
+ query: String,
+ record_type: RecordType,
+ options: Option<ResolveDnsOption>,
+}
 
- #[derive(Deserialize)]
- #[serde(rename_all = "camelCase")]
- struct ResolveAddrArgs {
- query: String,
- record_type: RecordType,
- options: Option<ResolveDnsOption>,
- }
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ResolveDnsOption {
+ name_server: Option<NameServer>,
+}
 
- #[derive(Deserialize)]
- #[serde(rename_all = "camelCase")]
- struct ResolveDnsOption {
- name_server: Option<NameServer>,
- }
+fn default_port() -> u16 {
+ 53
+}
 
- #[derive(Deserialize)]
- #[serde(rename_all = "camelCase")]
-  struct NameServer {
-  ip_addr: String,
-  #[serde(default = "default_port")]
-  port: u16,
- }
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NameServer {
+ ip_addr: String,
+ #[serde(default = "default_port")]
+ port: u16,
+}
 
+async fn op_dns_resolve(
+ state: Rc<RefCell<OpState>>,
+ args: ResolveAddrArgs,
+ _zero_copy: BufVec,
+) -> Result<Value, AnyError> {
  let ResolveAddrArgs {
  query,
  record_type,
  options,
- } = serde_json::from_value(args)?;
+ } = args;
 
  let (config, opts) = if let Some(name_server) =
  options.as_ref().and_then(|o| o.name_server.as_ref())

runtime/ops/os.rs

@@ -2,7 +2,6 @@
 
 use crate::permissions::Permissions;
 use deno_core::error::{type_error, AnyError};
-use deno_core::serde_json;
 use deno_core::serde_json::json;
 use deno_core::serde_json::Value;
 use deno_core::url::Url;
@@ -44,17 +43,16 @@ fn op_exec_path(
 }
 
 #[derive(Deserialize)]
-struct SetEnv {
+pub struct SetEnv {
  key: String,
  value: String,
 }
 
 fn op_set_env(
  state: &mut OpState,
- args: Value,
+ args: SetEnv,
  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, AnyError> {
- let args: SetEnv = serde_json::from_value(args)?;
  state.borrow::<Permissions>().env.check()?;
  let invalid_key =
  args.key.is_empty() || args.key.contains(&['=', '\0'] as &[char]);
@@ -77,16 +75,15 @@ fn op_env(
 }
 
 #[derive(Deserialize)]
-struct GetEnv {
+pub struct GetEnv {
  key: String,
 }
 
 fn op_get_env(
  state: &mut OpState,
- args: Value,
+ args: GetEnv,
  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, AnyError> {
- let args: GetEnv = serde_json::from_value(args)?;
  state.borrow::<Permissions>().env.check()?;
  if args.key.is_empty() || args.key.contains(&['=', '\0'] as &[char]) {
  return Err(type_error("Key contains invalid characters."));
@@ -99,16 +96,15 @@ fn op_get_env(
 }
 
 #[derive(Deserialize)]
-struct DeleteEnv {
+pub struct DeleteEnv {
  key: String,
 }
 
 fn op_delete_env(
  state: &mut OpState,
- args: Value,
+ args: DeleteEnv,
  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, AnyError> {
- let args: DeleteEnv = serde_json::from_value(args)?;
  state.borrow::<Permissions>().env.check()?;
  if args.key.is_empty() || args.key.contains(&['=', '\0'] as &[char]) {
  return Err(type_error("Key contains invalid characters."));
@@ -118,16 +114,15 @@ fn op_delete_env(
 }
 
 #[derive(Deserialize)]
-struct Exit {
+pub struct Exit {
  code: i32,
 }
 
 fn op_exit(
  _state: &mut OpState,
- args: Value,
+ args: Exit,
  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, AnyError> {
- let args: Exit = serde_json::from_value(args)?;
  std::process::exit(args.code)
 }
 

runtime/ops/permissions.rs

@@ -4,7 +4,6 @@ use crate::permissions::Permissions;
 use deno_core::error::custom_error;
 use deno_core::error::uri_error;
 use deno_core::error::AnyError;
-use deno_core::serde_json;
 use deno_core::serde_json::json;
 use deno_core::serde_json::Value;
 use deno_core::url;
@@ -20,18 +19,17 @@ pub fn init(rt: &mut deno_core::JsRuntime) {
 }
 
 #[derive(Deserialize)]
-struct PermissionArgs {
+pub struct PermissionArgs {
  name: String,
  path: Option<String>,
  host: Option<String>,
 }
 
 pub fn op_query_permission(
  state: &mut OpState,
- args: Value,
+ args: PermissionArgs,
  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, AnyError> {
- let args: PermissionArgs = serde_json::from_value(args)?;
  let permissions = state.borrow::<Permissions>();
  let path = args.path.as_deref();
  let perm = match args.name.as_ref() {
@@ -60,10 +58,9 @@ pub fn op_query_permission(
 
 pub fn op_revoke_permission(
  state: &mut OpState,
- args: Value,
+ args: PermissionArgs,
  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, AnyError> {
- let args: PermissionArgs = serde_json::from_value(args)?;
  let permissions = state.borrow_mut::<Permissions>();
  let path = args.path.as_deref();
  let perm = match args.name.as_ref() {
@@ -92,10 +89,9 @@ pub fn op_revoke_permission(
 
 pub fn op_request_permission(
  state: &mut OpState,
- args: Value,
+ args: PermissionArgs,
  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, AnyError> {
- let args: PermissionArgs = serde_json::from_value(args)?;
  let permissions = state.borrow_mut::<Permissions>();
  let path = args.path.as_deref();
  let perm = match args.name.as_ref() {

runtime/ops/plugin.rs

@@ -5,7 +5,6 @@ use crate::permissions::Permissions;
 use deno_core::error::AnyError;
 use deno_core::futures::prelude::*;
 use deno_core::plugin_api;
-use deno_core::serde_json;
 use deno_core::serde_json::json;
 use deno_core::serde_json::Value;
 use deno_core::BufVec;
@@ -32,16 +31,15 @@ pub fn init(rt: &mut JsRuntime) {
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct OpenPluginArgs {
+pub struct OpenPluginArgs {
  filename: String,
 }
 
 pub fn op_open_plugin(
  state: &mut OpState,
- args: Value,
+ args: OpenPluginArgs,
  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, AnyError> {
- let args: OpenPluginArgs = serde_json::from_value(args)?;
  let filename = PathBuf::from(&args.filename);
 
  super::check_unstable(state, "Deno.openPlugin");

runtime/ops/process.rs

@@ -8,7 +8,6 @@ use crate::permissions::Permissions;
 use deno_core::error::bad_resource_id;
 use deno_core::error::type_error;
 use deno_core::error::AnyError;
-use deno_core::serde_json;
 use deno_core::serde_json::json;
 use deno_core::serde_json::Value;
 use deno_core::AsyncMutFuture;
@@ -54,7 +53,7 @@ fn subprocess_stdio_map(s: &str) -> Result<std::process::Stdio, AnyError> {
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct RunArgs {
+pub struct RunArgs {
  cmd: Vec<String>,
  cwd: Option<String>,
  env: Vec<(String, String)>,
@@ -84,10 +83,9 @@ impl ChildResource {
 
 fn op_run(
  state: &mut OpState,
- args: Value,
+ run_args: RunArgs,
  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, AnyError> {
- let run_args: RunArgs = serde_json::from_value(args)?;
  state.borrow::<Permissions>().run.check()?;
 
  let args = run_args.cmd;
@@ -179,16 +177,15 @@ fn op_run(
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct RunStatusArgs {
+pub struct RunStatusArgs {
  rid: i32,
 }
 
 async fn op_run_status(
  state: Rc<RefCell<OpState>>,
- args: Value,
+ args: RunStatusArgs,
  _zero_copy: BufVec,
 ) -> Result<Value, AnyError> {
- let args: RunStatusArgs = serde_json::from_value(args)?;
  let rid = args.rid as u32;
 
  {
@@ -281,13 +278,12 @@ struct KillArgs {
 
 fn op_kill(
  state: &mut OpState,
- args: Value,
+ args: KillArgs,
  _zero_copy: &mut [ZeroCopyBuf],
 ) -> Result<Value, AnyError> {
  super::check_unstable(state, "Deno.kill");
  state.borrow::<Permissions>().run.check()?;
 
- let args: KillArgs = serde_json::from_value(args)?;
  kill(args.pid, args.signo)?;
  Ok(json!({}))
 }