summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/eager_unix.rs85
-rw-r--r--src/main.rs3
-rw-r--r--src/ops.rs7
-rw-r--r--src/resources.rs94
4 files changed, 4 insertions, 185 deletions
diff --git a/src/eager_unix.rs b/src/eager_unix.rs
deleted file mode 100644
index 1699c421c..000000000
--- a/src/eager_unix.rs
+++ /dev/null
@@ -1,85 +0,0 @@
-// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
-use crate::resources::{EagerAccept, EagerRead, EagerWrite, Resource};
-use crate::tokio_util;
-use crate::tokio_write;
-
-use futures::future::{self, Either};
-use std;
-use std::io::{ErrorKind, Read, Write};
-use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd};
-use tokio;
-use tokio::net::{TcpListener, TcpStream};
-use tokio_io;
-
-pub fn tcp_read<T: AsMut<[u8]>>(
- tcp_stream: &TcpStream,
- resource: Resource,
- mut buf: T,
-) -> EagerRead<Resource, T> {
- // Unfortunately we can't just call read() on tokio::net::TcpStream
- let fd = (*tcp_stream).as_raw_fd();
- let mut std_tcp_stream = unsafe { std::net::TcpStream::from_raw_fd(fd) };
- let read_result = std_tcp_stream.read(buf.as_mut());
- // std_tcp_stream will close when it gets dropped. Thus...
- let _ = std_tcp_stream.into_raw_fd();
- match read_result {
- Ok(nread) => Either::B(future::ok((resource, buf, nread))),
- Err(err) => {
- if err.kind() == ErrorKind::WouldBlock {
- Either::A(tokio_io::io::read(resource, buf))
- } else {
- Either::B(future::err(err))
- }
- }
- }
-}
-
-pub fn tcp_write<T: AsRef<[u8]>>(
- tcp_stream: &TcpStream,
- resource: Resource,
- buf: T,
-) -> EagerWrite<Resource, T> {
- let fd = (*tcp_stream).as_raw_fd();
- let mut std_tcp_stream = unsafe { std::net::TcpStream::from_raw_fd(fd) };
- let write_result = std_tcp_stream.write(buf.as_ref());
- // std_tcp_stream will close when it gets dropped. Thus...
- let _ = std_tcp_stream.into_raw_fd();
- match write_result {
- Ok(nwrite) => Either::B(future::ok((resource, buf, nwrite))),
- Err(err) => {
- if err.kind() == ErrorKind::WouldBlock {
- Either::A(tokio_write::write(resource, buf))
- } else {
- Either::B(future::err(err))
- }
- }
- }
-}
-
-pub fn tcp_accept(
- tcp_listener: &TcpListener,
- resource: Resource,
-) -> EagerAccept {
- let fd = (*tcp_listener).as_raw_fd();
- let std_listener = unsafe { std::net::TcpListener::from_raw_fd(fd) };
- let result = std_listener.accept();
- // std_listener will close when it gets dropped. Thus...
- let _ = std_listener.into_raw_fd();
- match result {
- Ok((std_stream, addr)) => {
- let result = tokio::net::TcpStream::from_std(
- std_stream,
- &tokio::reactor::Handle::default(),
- );
- let tokio_stream = result.unwrap();
- Either::B(future::ok((tokio_stream, addr)))
- }
- Err(err) => {
- if err.kind() == ErrorKind::WouldBlock {
- Either::A(tokio_util::accept(resource))
- } else {
- Either::B(future::err(err))
- }
- }
- }
-}
diff --git a/src/main.rs b/src/main.rs
index 9afbbb8a9..0f12eebd1 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -35,9 +35,6 @@ mod tokio_write;
pub mod version;
pub mod workers;
-#[cfg(unix)]
-mod eager_unix;
-
use crate::cli::Cli;
use crate::errors::RustOrJsError;
use crate::isolate::Isolate;
diff --git a/src/ops.rs b/src/ops.rs
index 33a7d7cdd..c6b9fe84a 100644
--- a/src/ops.rs
+++ b/src/ops.rs
@@ -18,6 +18,7 @@ use crate::resources;
use crate::resources::table_entries;
use crate::resources::Resource;
use crate::tokio_util;
+use crate::tokio_write;
use crate::version;
use deno_core::deno_buf;
use deno_core::JSError;
@@ -918,7 +919,7 @@ fn op_read(
match resources::lookup(rid) {
None => odd_future(errors::bad_resource()),
Some(resource) => {
- let op = resources::eager_read(resource, data)
+ let op = tokio::io::read(resource, data)
.map_err(DenoError::from)
.and_then(move |(_resource, _buf, nread)| {
let builder = &mut FlatBufferBuilder::new();
@@ -956,7 +957,7 @@ fn op_write(
match resources::lookup(rid) {
None => odd_future(errors::bad_resource()),
Some(resource) => {
- let op = resources::eager_write(resource, data)
+ let op = tokio_write::write(resource, data)
.map_err(DenoError::from)
.and_then(move |(_resource, _buf, nwritten)| {
let builder = &mut FlatBufferBuilder::new();
@@ -1551,7 +1552,7 @@ fn op_accept(
match resources::lookup(server_rid) {
None => odd_future(errors::bad_resource()),
Some(server_resource) => {
- let op = resources::eager_accept(server_resource)
+ let op = tokio_util::accept(server_resource)
.map_err(DenoError::from)
.and_then(move |(tcp_stream, _socket_addr)| {
new_conn(cmd_id, tcp_stream)
diff --git a/src/resources.rs b/src/resources.rs
index e962bce8e..1540f4ff7 100644
--- a/src/resources.rs
+++ b/src/resources.rs
@@ -9,8 +9,6 @@
// handlers) look up resources by their integer id here.
use crate::cli::Buf;
-#[cfg(unix)]
-use crate::eager_unix as eager;
use crate::errors;
use crate::errors::bad_resource;
use crate::errors::DenoError;
@@ -18,11 +16,8 @@ use crate::errors::DenoResult;
use crate::http_body::HttpBody;
use crate::isolate_state::WorkerChannels;
use crate::repl::Repl;
-use crate::tokio_util;
-use crate::tokio_write;
use futures;
-use futures::future::{Either, FutureResult};
use futures::Future;
use futures::Poll;
use futures::Sink;
@@ -39,7 +34,6 @@ use std::sync::{Arc, Mutex};
use tokio;
use tokio::io::{AsyncRead, AsyncWrite};
use tokio::net::TcpStream;
-use tokio_io;
use tokio_process;
pub type ResourceId = u32; // Sometimes referred to RID.
@@ -440,94 +434,6 @@ pub fn lookup(rid: ResourceId) -> Option<Resource> {
table.get(&rid).map(|_| Resource { rid })
}
-pub type EagerRead<R, T> =
- Either<tokio_io::io::Read<R, T>, FutureResult<(R, T, usize), std::io::Error>>;
-
-pub type EagerWrite<R, T> =
- Either<tokio_write::Write<R, T>, FutureResult<(R, T, usize), std::io::Error>>;
-
-pub type EagerAccept = Either<
- tokio_util::Accept,
- FutureResult<(tokio::net::TcpStream, std::net::SocketAddr), std::io::Error>,
->;
-
-#[cfg(not(unix))]
-#[allow(unused_mut)]
-pub fn eager_read<T: AsMut<[u8]>>(
- resource: Resource,
- mut buf: T,
-) -> EagerRead<Resource, T> {
- Either::A(tokio_io::io::read(resource, buf))
-}
-
-#[cfg(not(unix))]
-pub fn eager_write<T: AsRef<[u8]>>(
- resource: Resource,
- buf: T,
-) -> EagerWrite<Resource, T> {
- Either::A(tokio_write::write(resource, buf))
-}
-
-#[cfg(not(unix))]
-pub fn eager_accept(resource: Resource) -> EagerAccept {
- Either::A(tokio_util::accept(resource))
-}
-
-// This is an optimization that Tokio should do.
-// Attempt to call read() on the main thread.
-#[cfg(unix)]
-pub fn eager_read<T: AsMut<[u8]>>(
- resource: Resource,
- buf: T,
-) -> EagerRead<Resource, T> {
- let mut table = RESOURCE_TABLE.lock().unwrap();
- let maybe_repr = table.get_mut(&resource.rid);
- match maybe_repr {
- None => panic!("bad rid"),
- Some(repr) => match repr {
- Repr::TcpStream(ref mut tcp_stream) => {
- eager::tcp_read(tcp_stream, resource, buf)
- }
- _ => Either::A(tokio_io::io::read(resource, buf)),
- },
- }
-}
-
-// This is an optimization that Tokio should do.
-// Attempt to call write() on the main thread.
-#[cfg(unix)]
-pub fn eager_write<T: AsRef<[u8]>>(
- resource: Resource,
- buf: T,
-) -> EagerWrite<Resource, T> {
- let mut table = RESOURCE_TABLE.lock().unwrap();
- let maybe_repr = table.get_mut(&resource.rid);
- match maybe_repr {
- None => panic!("bad rid"),
- Some(repr) => match repr {
- Repr::TcpStream(ref mut tcp_stream) => {
- eager::tcp_write(tcp_stream, resource, buf)
- }
- _ => Either::A(tokio_write::write(resource, buf)),
- },
- }
-}
-
-#[cfg(unix)]
-pub fn eager_accept(resource: Resource) -> EagerAccept {
- let mut table = RESOURCE_TABLE.lock().unwrap();
- let maybe_repr = table.get_mut(&resource.rid);
- match maybe_repr {
- None => panic!("bad rid"),
- Some(repr) => match repr {
- Repr::TcpListener(ref mut tcp_listener, _) => {
- eager::tcp_accept(tcp_listener, resource)
- }
- _ => Either::A(tokio_util::accept(resource)),
- },
- }
-}
-
// TODO(kevinkassimo): revamp this after the following lands:
// https://github.com/tokio-rs/tokio/pull/785
pub fn seek(
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-24 16:45:39 +0000