From 928f63c36835f0ae741f17a7bcc3de8ab36a0913 Mon Sep 17 00:00:00 2001 From: Jonathan Reem Date: Mon, 10 Nov 2014 17:12:35 -0800 Subject: [PATCH] Removes intertwining, since it is slow and showing up in profiles Intertwining was a nice feature, but it slows down hyper significantly, so it is being removed. There is some fallout from this, mainly that Incoming has had its type parameter changed to `` and Handler receiving one bounded with `A: NetworkAcceptor`. [breaking-change] Fixes #112 --- Cargo.toml | 3 --- benches/client.rs | 6 ++--- benches/server.rs | 2 +- src/lib.rs | 1 - src/server/mod.rs | 63 +++++++++++++++++++---------------------------- 5 files changed, 29 insertions(+), 46 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 3e02adda..e5536efd 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -16,9 +16,6 @@ git = "https://github.com/hyperium/mime.rs" [dependencies.unsafe-any] git = "https://github.com/reem/rust-unsafe-any" -[dependencies.intertwine] -git = "https://github.com/reem/rust-intertwine" - [dependencies.move-acceptor] git = "https://github.com/reem/rust-move-acceptor" diff --git a/benches/client.rs b/benches/client.rs index 5678ee2c..266cf043 100644 --- a/benches/client.rs +++ b/benches/client.rs @@ -35,7 +35,7 @@ fn handle(mut incoming: Incoming) { #[bench] fn bench_curl(b: &mut test::Bencher) { let mut listening = listen(); - let s = format!("http://{}/", listening.sockets[0]); + let s = format!("http://{}/", listening.socket); let url = s.as_slice(); b.iter(|| { curl::http::handle() @@ -67,7 +67,7 @@ impl hyper::header::HeaderFormat for Foo { #[bench] fn bench_hyper(b: &mut test::Bencher) { let mut listening = listen(); - let s = format!("http://{}/", listening.sockets[0]); + let s = format!("http://{}/", listening.socket); let url = s.as_slice(); b.iter(|| { let mut req = hyper::client::Request::get(hyper::Url::parse(url).unwrap()).unwrap(); @@ -83,7 +83,7 @@ fn bench_hyper(b: &mut test::Bencher) { #[bench] fn bench_http(b: &mut test::Bencher) { let mut listening = listen(); - let s = format!("http://{}/", listening.sockets[0]); + let s = format!("http://{}/", listening.socket); let url = s.as_slice(); b.iter(|| { let mut req: http::client::RequestWriter = http::client::RequestWriter::new( diff --git a/benches/server.rs b/benches/server.rs index 4bcd3f6b..8fc701f3 100644 --- a/benches/server.rs +++ b/benches/server.rs @@ -31,7 +31,7 @@ fn bench_hyper(b: &mut Bencher) { let server = hyper::Server::http(Ipv4Addr(127, 0, 0, 1), 0); let mut listener = server.listen(hyper_handle).unwrap(); - let url = hyper::Url::parse(format!("http://{}", listener.sockets[0]).as_slice()).unwrap(); + let url = hyper::Url::parse(format!("http://{}", listener.socket).as_slice()).unwrap(); b.iter(|| request(url.clone())); listener.close().unwrap(); } diff --git a/src/lib.rs b/src/lib.rs index f2e1fbed..758d9789 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -134,7 +134,6 @@ extern crate openssl; #[cfg(test)] extern crate test; extern crate "unsafe-any" as uany; extern crate "move-acceptor" as macceptor; -extern crate intertwine; extern crate typeable; extern crate cookie; diff --git a/src/server/mod.rs b/src/server/mod.rs index 0e89187a..03373927 100644 --- a/src/server/mod.rs +++ b/src/server/mod.rs @@ -1,10 +1,9 @@ //! HTTP Server -use std::io::{Listener, IoResult, EndOfFile}; +use std::io::{Listener, EndOfFile}; use std::io::net::ip::{IpAddr, Port, SocketAddr}; use std::task::TaskBuilder; -use intertwine::{Intertwine, Intertwined}; -use macceptor::MoveAcceptor; +use macceptor::{MoveAcceptor, MoveConnections}; pub use self::request::Request; pub use self::response::Response; @@ -22,7 +21,8 @@ pub mod response; /// Once listening, it will create a `Request`/`Response` pair for each /// incoming connection, and hand them to the provided handler. pub struct Server { - pairs: Vec<(IpAddr, Port)> + ip: IpAddr, + port: Port } macro_rules! try_option( @@ -37,12 +37,10 @@ macro_rules! try_option( impl Server { /// Creates a new server that will handle `HttpStream`s. pub fn http(ip: IpAddr, port: Port) -> Server { - Server { pairs: vec![(ip, port)] } - } - - /// Creates a server that can listen to many (ip, port) pairs. - pub fn many(pairs: Vec<(IpAddr, Port)>) -> Server { - Server { pairs: pairs } + Server { + ip: ip, + port: port + } } } @@ -56,30 +54,21 @@ impl, S: NetworkStream, A: NetworkAcceptor> Server, L: NetworkListener, { - let mut acceptors = Vec::new(); - let mut sockets = Vec::new(); - for (ip, port) in self.pairs.into_iter() { - debug!("binding to {}:{}", ip, port); - let mut listener: L = try_io!(NetworkListener::::bind((ip, port))); + debug!("binding to {}:{}", self.ip, self.port); + let mut listener: L = try_io!(NetworkListener::::bind((self.ip, self.port))); - sockets.push(try_io!(listener.socket_name())); + let socket = try_io!(listener.socket_name()); - let acceptor = try_io!(listener.listen()); - acceptors.push(acceptor.clone()); - } - - let connections = acceptors.clone() - .into_iter() - .map(|acceptor| acceptor.move_incoming()) - .intertwine(); + let acceptor = try_io!(listener.listen()); + let captured = acceptor.clone(); TaskBuilder::new().named("hyper acceptor").spawn(proc() { - handler.handle(Incoming { from: connections }); + handler.handle(Incoming { from: captured.move_incoming() }); }); Ok(Listening { - acceptors: acceptors, - sockets: sockets, + acceptor: acceptor, + socket: socket, }) } @@ -90,11 +79,11 @@ impl, S: NetworkStream, A: NetworkAcceptor> Server { - from: Intertwined> +pub struct Incoming { + from: MoveConnections } -impl Iterator> for Incoming { +impl> Iterator> for Incoming { fn next(&mut self) -> Option> { for conn in self.from { match conn { @@ -130,9 +119,9 @@ impl Connection { /// A listening server, which can later be closed. pub struct Listening { - acceptors: Vec, + acceptor: A, /// The socket addresses that the server is bound to. - pub sockets: Vec, + pub socket: SocketAddr, } impl, S: NetworkStream> Listening { @@ -142,9 +131,7 @@ impl, S: NetworkStream> Listening { /// and does not close the rest of the acceptors. pub fn close(&mut self) -> HttpResult<()> { debug!("closing server"); - for acceptor in self.acceptors.iter_mut() { - try_io!(acceptor.close()); - } + try_io!(self.acceptor.close()); Ok(()) } } @@ -154,11 +141,11 @@ pub trait Handler, S: NetworkStream>: Send { /// Receives a `Request`/`Response` pair, and should perform some action on them. /// /// This could reading from the request, and writing to the response. - fn handle(self, Incoming); + fn handle(self, Incoming); } -impl, S: NetworkStream> Handler for fn(Incoming) { - fn handle(self, incoming: Incoming) { +impl, S: NetworkStream> Handler for fn(Incoming) { + fn handle(self, incoming: Incoming) { (self)(incoming) } }