1 files changed, 91 insertions, 72 deletions

diff --git a/core/examples/http_bench_json_ops.rs b/core/examples/http_bench_json_ops.rs
index f0fc5f94c..6e3063a0f 100644
--- a/core/examples/http_bench_json_ops.rs
+++ b/core/examples/http_bench_json_ops.rs
@@ -1,25 +1,29 @@
 #[macro_use]
 extern crate log;
 
-use deno_core::serde_json;
+use deno_core::js_check;
+use deno_core::BasicState;
+use deno_core::BufVec;
 use deno_core::CoreIsolate;
-use deno_core::CoreIsolateState;
 use deno_core::ErrBox;
+use deno_core::OpRegistry;
 use deno_core::Script;
 use deno_core::StartupData;
 use deno_core::ZeroCopyBuf;
 use futures::future::poll_fn;
 use futures::future::Future;
+use serde_json::Value;
+use std::convert::TryInto;
 use std::env;
-use std::io::Error;
-use std::io::ErrorKind;
 use std::net::SocketAddr;
 use std::pin::Pin;
+use std::rc::Rc;
 use std::task::Poll;
 use tokio::io::AsyncRead;
 use tokio::io::AsyncWrite;
 use tokio::net::TcpListener;
 use tokio::net::TcpStream;
+use tokio::runtime;
 
 struct Logger;
 
@@ -37,66 +41,79 @@ impl log::Log for Logger {
   fn flush(&self) {}
 }
 
-pub fn isolate_new() -> CoreIsolate {
+fn create_isolate() -> CoreIsolate {
+  let state = BasicState::new();
+  state.register_op_json_sync("listen", op_listen);
+  state.register_op_json_sync("close", op_close);
+  state.register_op_json_async("accept", op_accept);
+  state.register_op_json_async("read", op_read);
+  state.register_op_json_async("write", op_write);
+
   let startup_data = StartupData::Script(Script {
     source: include_str!("http_bench_json_ops.js"),
     filename: "http_bench_json_ops.js",
   });
 
-  let mut isolate = CoreIsolate::new(startup_data, false);
-
-  isolate.register_op_json_sync("listen", op_listen);
-  isolate.register_op_json_async("accept", op_accept);
-  isolate.register_op_json_async("read", op_read);
-  isolate.register_op_json_async("write", op_write);
-  isolate.register_op_json_sync("close", op_close);
+  CoreIsolate::new(state, startup_data, false)
+}
 
-  isolate
+fn op_listen(
+  state: &BasicState,
+  _args: Value,
+  _bufs: &mut [ZeroCopyBuf],
+) -> Result<Value, ErrBox> {
+  debug!("listen");
+  let addr = "127.0.0.1:4544".parse::<SocketAddr>().unwrap();
+  let std_listener = std::net::TcpListener::bind(&addr)?;
+  let listener = TcpListener::from_std(std_listener)?;
+  let rid = state
+    .resource_table
+    .borrow_mut()
+    .add("tcpListener", Box::new(listener));
+  Ok(serde_json::json!({ "rid": rid }))
 }
 
 fn op_close(
-  state: &mut CoreIsolateState,
-  args: serde_json::Value,
+  state: &BasicState,
+  args: Value,
   _buf: &mut [ZeroCopyBuf],
-) -> Result<serde_json::Value, ErrBox> {
-  let rid = args.get("rid").unwrap().as_u64().unwrap() as u32;
+) -> Result<Value, ErrBox> {
+  let rid: u32 = args
+    .get("rid")
+    .unwrap()
+    .as_u64()
+    .unwrap()
+    .try_into()
+    .unwrap();
   debug!("close rid={}", rid);
 
-  let resource_table = &mut state.resource_table.borrow_mut();
-  resource_table
+  state
+    .resource_table
+    .borrow_mut()
     .close(rid)
     .map(|_| serde_json::json!(()))
-    .ok_or_else(bad_resource)
-}
-
-fn op_listen(
-  state: &mut CoreIsolateState,
-  _args: serde_json::Value,
-  _buf: &mut [ZeroCopyBuf],
-) -> Result<serde_json::Value, ErrBox> {
-  debug!("listen");
-  let addr = "127.0.0.1:4544".parse::<SocketAddr>().unwrap();
-  let std_listener = std::net::TcpListener::bind(&addr)?;
-  let listener = TcpListener::from_std(std_listener)?;
-  let resource_table = &mut state.resource_table.borrow_mut();
-  let rid = resource_table.add("tcpListener", Box::new(listener));
-  Ok(serde_json::json!({ "rid": rid }))
+    .ok_or_else(ErrBox::bad_resource_id)
 }
 
 fn op_accept(
-  state: &mut CoreIsolateState,
-  args: serde_json::Value,
-  _buf: &mut [ZeroCopyBuf],
-) -> impl Future<Output = Result<serde_json::Value, ErrBox>> {
-  let rid = args.get("rid").unwrap().as_u64().unwrap() as u32;
+  state: Rc<BasicState>,
+  args: Value,
+  _bufs: BufVec,
+) -> impl Future<Output = Result<Value, ErrBox>> {
+  let rid: u32 = args
+    .get("rid")
+    .unwrap()
+    .as_u64()
+    .unwrap()
+    .try_into()
+    .unwrap();
   debug!("accept rid={}", rid);
 
-  let resource_table = state.resource_table.clone();
   poll_fn(move |cx| {
-    let resource_table = &mut resource_table.borrow_mut();
+    let resource_table = &mut state.resource_table.borrow_mut();
     let listener = resource_table
       .get_mut::<TcpListener>(rid)
-      .ok_or_else(bad_resource)?;
+      .ok_or_else(ErrBox::bad_resource_id)?;
     listener.poll_accept(cx)?.map(|(stream, _addr)| {
       let rid = resource_table.add("tcpStream", Box::new(stream));
       Ok(serde_json::json!({ "rid": rid }))
@@ -105,57 +122,59 @@ fn op_accept(
 }
 
 fn op_read(
-  state: &mut CoreIsolateState,
-  args: serde_json::Value,
-  bufs: &mut [ZeroCopyBuf],
-) -> impl Future<Output = Result<serde_json::Value, ErrBox>> {
+  state: Rc<BasicState>,
+  args: Value,
+  mut bufs: BufVec,
+) -> impl Future<Output = Result<Value, ErrBox>> {
   assert_eq!(bufs.len(), 1, "Invalid number of arguments");
 
-  let rid = args.get("rid").unwrap().as_u64().unwrap() as u32;
+  let rid: u32 = args
+    .get("rid")
+    .unwrap()
+    .as_u64()
+    .unwrap()
+    .try_into()
+    .unwrap();
   debug!("read rid={}", rid);
 
-  let mut buf = bufs[0].clone();
-  let resource_table = state.resource_table.clone();
-
-  poll_fn(move |cx| -> Poll<Result<serde_json::Value, ErrBox>> {
-    let resource_table = &mut resource_table.borrow_mut();
+  poll_fn(move |cx| -> Poll<Result<Value, ErrBox>> {
+    let resource_table = &mut state.resource_table.borrow_mut();
     let stream = resource_table
       .get_mut::<TcpStream>(rid)
-      .ok_or_else(bad_resource)?;
+      .ok_or_else(ErrBox::bad_resource_id)?;
     Pin::new(stream)
-      .poll_read(cx, &mut buf)?
+      .poll_read(cx, &mut bufs[0])?
       .map(|nread| Ok(serde_json::json!({ "nread": nread })))
   })
 }
 
 fn op_write(
-  state: &mut CoreIsolateState,
-  args: serde_json::Value,
-  bufs: &mut [ZeroCopyBuf],
-) -> impl Future<Output = Result<serde_json::Value, ErrBox>> {
+  state: Rc<BasicState>,
+  args: Value,
+  bufs: BufVec,
+) -> impl Future<Output = Result<Value, ErrBox>> {
   assert_eq!(bufs.len(), 1, "Invalid number of arguments");
 
-  let rid = args.get("rid").unwrap().as_u64().unwrap() as u32;
+  let rid: u32 = args
+    .get("rid")
+    .unwrap()
+    .as_u64()
+    .unwrap()
+    .try_into()
+    .unwrap();
   debug!("write rid={}", rid);
 
-  let buf = bufs[0].clone();
-  let resource_table = state.resource_table.clone();
-
   poll_fn(move |cx| {
-    let resource_table = &mut resource_table.borrow_mut();
+    let resource_table = &mut state.resource_table.borrow_mut();
     let stream = resource_table
       .get_mut::<TcpStream>(rid)
-      .ok_or_else(bad_resource)?;
+      .ok_or_else(ErrBox::bad_resource_id)?;
     Pin::new(stream)
-      .poll_write(cx, &buf)?
+      .poll_write(cx, &bufs[0])?
       .map(|nwritten| Ok(serde_json::json!({ "nwritten": nwritten })))
   })
 }
 
-fn bad_resource() -> ErrBox {
-  Error::new(ErrorKind::NotFound, "bad resource id").into()
-}
-
 fn main() {
   log::set_logger(&Logger).unwrap();
   log::set_max_level(
@@ -168,11 +187,11 @@ fn main() {
   // NOTE: `--help` arg will display V8 help and exit
   deno_core::v8_set_flags(env::args().collect());
 
-  let isolate = isolate_new();
-  let mut runtime = tokio::runtime::Builder::new()
+  let isolate = create_isolate();
+  let mut runtime = runtime::Builder::new()
     .basic_scheduler()
     .enable_all()
     .build()
     .unwrap();
-  deno_core::js_check(runtime.block_on(isolate));
+  js_check(runtime.block_on(isolate));
 }