From b686b4c34ea96e9d8efcb5759ab5b74bd73099a7 Mon Sep 17 00:00:00 2001 From: karlri <49443488+karlri@users.noreply.github.com> Date: Mon, 16 Sep 2019 07:07:46 +0200 Subject: [PATCH 01/11] Feature uds: Add listen_uds to ServerBuilder (#43) Allows directly passing an Unix Listener instead of a path. Useful for example when running as a daemon under systemd with the systemd crate. --- CHANGES.md | 1 + actix-server/src/builder.rs | 29 +++++++++++++++++++++++++---- 2 files changed, 26 insertions(+), 4 deletions(-) diff --git a/CHANGES.md b/CHANGES.md index ec9b12ca..51e019e7 100644 --- a/CHANGES.md +++ b/CHANGES.md @@ -6,6 +6,7 @@ * Use new `Service` trait +* Add UDS listening support to `ServerBuilder` ## [0.2.4] - 2018-11-21 diff --git a/actix-server/src/builder.rs b/actix-server/src/builder.rs index d9f809fc..a0f0c3aa 100644 --- a/actix-server/src/builder.rs +++ b/actix-server/src/builder.rs @@ -185,20 +185,41 @@ impl ServerBuilder { #[cfg(all(unix, feature = "uds"))] /// Add new unix domain service to the server. - pub fn bind_uds(mut self, name: N, addr: U, factory: F) -> io::Result + pub fn bind_uds(self, name: N, addr: U, factory: F) -> io::Result where F: ServiceFactory, N: AsRef, U: AsRef, { - use std::net::{IpAddr, Ipv4Addr, SocketAddr}; use std::os::unix::net::UnixListener; - // TODO: need to do something with existing paths - let _ = std::fs::remove_file(addr.as_ref()); + // The path must not exist when we try to bind. + // Try to remove it to avoid bind error. + if let Err(e) = std::fs::remove_file(addr.as_ref()) { + // NotFound is expected and not an issue. Anything else is. + if e.kind() != std::io::ErrorKind::NotFound { + return Err(e); + } + } let lst = UnixListener::bind(addr)?; + self.listen_uds(name, lst, factory) + } + #[cfg(all(unix, feature = "uds"))] + /// Add new unix domain service to the server. + /// Useful when running as a systemd service and + /// a socket FD can be acquired using the systemd crate. + pub fn listen_uds>( + mut self, + name: N, + lst: std::os::unix::net::UnixListener, + factory: F, + ) -> io::Result + where + F: ServiceFactory, + { + use std::net::{IpAddr, Ipv4Addr, SocketAddr}; let token = self.token.next(); let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080); self.services.push(StreamNewService::create( From 8be5f773f491d1f7db0437da1dcede9c6f49c374 Mon Sep 17 00:00:00 2001 From: Nikolay Kim Date: Tue, 17 Sep 2019 16:04:20 +0600 Subject: [PATCH 02/11] add actix-testing crate --- Cargo.toml | 3 +- actix-testing/Cargo.toml | 51 ++++++++++++ actix-testing/LICENSE-APACHE | 1 + actix-testing/LICENSE-MIT | 1 + actix-testing/src/lib.rs | 152 +++++++++++++++++++++++++++++++++++ actix-testing/src/rt.rs | 116 ++++++++++++++++++++++++++ 6 files changed, 323 insertions(+), 1 deletion(-) create mode 100644 actix-testing/Cargo.toml create mode 120000 actix-testing/LICENSE-APACHE create mode 120000 actix-testing/LICENSE-MIT create mode 100644 actix-testing/src/lib.rs create mode 100644 actix-testing/src/rt.rs diff --git a/Cargo.toml b/Cargo.toml index cc9e4596..c88be5dc 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -17,14 +17,15 @@ edition = "2018" members = [ "actix-codec", "actix-connect", + "actix-ioframe", "actix-rt", "actix-service", "actix-server", "actix-server-config", + "actix-testing", "actix-test-server", "actix-threadpool", "actix-tower", - "actix-ioframe", "actix-utils", "router", ] diff --git a/actix-testing/Cargo.toml b/actix-testing/Cargo.toml new file mode 100644 index 00000000..a6083f07 --- /dev/null +++ b/actix-testing/Cargo.toml @@ -0,0 +1,51 @@ +[package] +name = "actix-testing" +version = "0.1.0" +authors = ["Nikolay Kim "] +description = "Actix test server" +keywords = ["network", "framework", "async", "futures"] +homepage = "https://actix.rs" +repository = "https://github.com/actix/actix-net.git" +documentation = "https://docs.rs/actix-testing/" +categories = ["network-programming", "asynchronous"] +license = "MIT/Apache-2.0" +exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"] +edition = "2018" +workspace = ".." + +[package.metadata.docs.rs] +features = ["ssl", "tls", "rust-tls"] + +[lib] +name = "actix_testing" +path = "src/lib.rs" + +[features] +default = [] + +# openssl +ssl = ["openssl", "actix-server/ssl"] + +# rustls +rust-tls = ["rustls", "tokio-rustls", "webpki", "webpki-roots"] + +[dependencies] +actix-rt = "0.2.1" +actix-server = "0.6.0" +actix-server-config = "0.1.0" +actix-service = "0.4.0" + +log = "0.4" +net2 = "0.2" +futures = "0.1" +tokio-tcp = "0.1" +tokio-reactor = "0.1" + +# openssl +openssl = { version="0.10", optional = true } + +#rustls +rustls = { version = "^0.15", optional = true } +tokio-rustls = { version = "^0.9", optional = true } +webpki = { version = "0.19", optional = true } +webpki-roots = { version = "0.16", optional = true } diff --git a/actix-testing/LICENSE-APACHE b/actix-testing/LICENSE-APACHE new file mode 120000 index 00000000..965b606f --- /dev/null +++ b/actix-testing/LICENSE-APACHE @@ -0,0 +1 @@ +../LICENSE-APACHE \ No newline at end of file diff --git a/actix-testing/LICENSE-MIT b/actix-testing/LICENSE-MIT new file mode 120000 index 00000000..76219eb7 --- /dev/null +++ b/actix-testing/LICENSE-MIT @@ -0,0 +1 @@ +../LICENSE-MIT \ No newline at end of file diff --git a/actix-testing/src/lib.rs b/actix-testing/src/lib.rs new file mode 100644 index 00000000..f3607f92 --- /dev/null +++ b/actix-testing/src/lib.rs @@ -0,0 +1,152 @@ +//! Various helpers for Actix applications to use during testing. +use std::sync::mpsc; +use std::{net, thread}; + +use actix_rt::System; +use actix_server::{Server, ServerBuilder, StreamServiceFactory}; +pub use actix_server_config::{Io, ServerConfig}; + +use net2::TcpBuilder; +use tokio_reactor::Handle; +use tokio_tcp::TcpStream; + +mod rt; +pub use self::rt::*; + +/// The `TestServer` type. +/// +/// `TestServer` is very simple test server that simplify process of writing +/// integration tests for actix-net applications. +/// +/// # Examples +/// +/// ```rust +/// use actix_service::{service_fn, IntoNewService}; +/// use actix_testing::TestServer; +/// +/// fn main() { +/// let srv = TestServer::with(|| service_fn( +/// |sock| { +/// println!("New connection: {:?}", sock); +/// Ok::<_, ()>(()) +/// } +/// )); +/// +/// println!("SOCKET: {:?}", srv.connect()); +/// } +/// ``` +pub struct TestServer; + +/// Test server runstime +pub struct TestServerRuntime { + addr: net::SocketAddr, + host: String, + port: u16, + system: System, +} + +impl TestServer { + /// Start new server with server builder + pub fn new(mut factory: F) -> TestServerRuntime + where + F: FnMut(ServerBuilder) -> ServerBuilder + Send + 'static, + { + let (tx, rx) = mpsc::channel(); + + // run server in separate thread + thread::spawn(move || { + let sys = System::new("actix-test-server"); + factory(Server::build()) + .workers(1) + .disable_signals() + .start(); + + tx.send(System::current()).unwrap(); + sys.run() + }); + let system = rx.recv().unwrap(); + + TestServerRuntime { + system, + addr: "127.0.0.1:0".parse().unwrap(), + host: "127.0.0.1".to_string(), + port: 0, + } + } + + /// Start new test server with application factory + pub fn with>(factory: F) -> TestServerRuntime { + let (tx, rx) = mpsc::channel(); + + // run server in separate thread + thread::spawn(move || { + let sys = System::new("actix-test-server"); + let tcp = net::TcpListener::bind("127.0.0.1:0").unwrap(); + let local_addr = tcp.local_addr().unwrap(); + + Server::build() + .listen("test", tcp, factory)? + .workers(1) + .disable_signals() + .start(); + + tx.send((System::current(), local_addr)).unwrap(); + sys.run() + }); + + let (system, addr) = rx.recv().unwrap(); + + let host = format!("{}", addr.ip()); + let port = addr.port(); + + TestServerRuntime { + system, + addr, + host, + port, + } + } + + /// Get firat available unused local address + pub fn unused_addr() -> net::SocketAddr { + let addr: net::SocketAddr = "127.0.0.1:0".parse().unwrap(); + let socket = TcpBuilder::new_v4().unwrap(); + socket.bind(&addr).unwrap(); + socket.reuse_address(true).unwrap(); + let tcp = socket.to_tcp_listener().unwrap(); + tcp.local_addr().unwrap() + } +} + +impl TestServerRuntime { + /// Test server host + pub fn host(&self) -> &str { + &self.host + } + + /// Test server port + pub fn port(&self) -> u16 { + self.port + } + + /// Get test server address + pub fn addr(&self) -> net::SocketAddr { + self.addr + } + + /// Stop http server + fn stop(&mut self) { + self.system.stop(); + } + + /// Connect to server, return tokio TcpStream + pub fn connect(&self) -> std::io::Result { + TcpStream::from_std(net::TcpStream::connect(self.addr)?, &Handle::default()) + } +} + +impl Drop for TestServerRuntime { + fn drop(&mut self) { + self.stop() + } +} diff --git a/actix-testing/src/rt.rs b/actix-testing/src/rt.rs new file mode 100644 index 00000000..488f3d65 --- /dev/null +++ b/actix-testing/src/rt.rs @@ -0,0 +1,116 @@ +//! Various helpers for Actix applications to use during testing. +use std::cell::RefCell; + +use actix_rt::{System, SystemRunner}; +use actix_service::Service; +use futures::future::{lazy, Future, IntoFuture}; + +thread_local! { + static RT: RefCell = { + RefCell::new(Inner(Some(System::builder().build()))) + }; +} + +struct Inner(Option); + +impl Inner { + fn get_mut(&mut self) -> &mut SystemRunner { + self.0.as_mut().unwrap() + } +} + +impl Drop for Inner { + fn drop(&mut self) { + std::mem::forget(self.0.take().unwrap()) + } +} + +/// Runs the provided future, blocking the current thread until the future +/// completes. +/// +/// This function can be used to synchronously block the current thread +/// until the provided `future` has resolved either successfully or with an +/// error. The result of the future is then returned from this function +/// call. +/// +/// Note that this function is intended to be used only for testing purpose. +/// This function panics on nested call. +pub fn block_on(f: F) -> Result +where + F: IntoFuture, +{ + RT.with(move |rt| rt.borrow_mut().get_mut().block_on(f.into_future())) +} + +/// Runs the provided function, blocking the current thread until the result +/// future completes. +/// +/// This function can be used to synchronously block the current thread +/// until the provided `future` has resolved either successfully or with an +/// error. The result of the future is then returned from this function +/// call. +/// +/// Note that this function is intended to be used only for testing purpose. +/// This function panics on nested call. +pub fn block_fn(f: F) -> Result +where + F: FnOnce() -> R, + R: IntoFuture, +{ + RT.with(move |rt| rt.borrow_mut().get_mut().block_on(lazy(f))) +} + +/// Spawn future to the current test runtime. +pub fn spawn(fut: F) +where + F: Future + 'static, +{ + run_on(move || { + actix_rt::spawn(fut); + }); +} + +/// Runs the provided function, with runtime enabled. +/// +/// Note that this function is intended to be used only for testing purpose. +/// This function panics on nested call. +pub fn run_on(f: F) -> R +where + F: FnOnce() -> R, +{ + RT.with(move |rt| { + rt.borrow_mut() + .get_mut() + .block_on(lazy(|| Ok::<_, ()>(f()))) + }) + .unwrap() +} + +/// Calls service and waits for response future completion. +/// +/// ```rust,ignore +/// use actix_web::{test, App, HttpResponse, http::StatusCode}; +/// use actix_service::Service; +/// +/// #[test] +/// fn test_response() { +/// let mut app = test::init_service( +/// App::new() +/// .service(web::resource("/test").to(|| HttpResponse::Ok())) +/// ); +/// +/// // Create request object +/// let req = test::TestRequest::with_uri("/test").to_request(); +/// +/// // Call application +/// let resp = test::call_service(&mut app, req); +/// assert_eq!(resp.status(), StatusCode::OK); +/// } +/// ``` +pub fn call_service(app: &mut S, req: R) -> S::Response +where + S: Service, + S::Error: std::fmt::Debug, +{ + block_on(run_on(move || app.call(req))).unwrap() +} From 5469d8c910f6e52ea5887066f10d1ba6a65f09ee Mon Sep 17 00:00:00 2001 From: Nikolay Kim Date: Wed, 25 Sep 2019 09:26:12 +0600 Subject: [PATCH 03/11] prep actix-testing release --- README.md | 2 +- actix-testing/CHANGES.md | 58 ++++++++++++++++++++++++++++++++++++++++ actix-testing/Cargo.toml | 24 +---------------- actix-testing/README.md | 9 +++++++ 4 files changed, 69 insertions(+), 24 deletions(-) create mode 100644 actix-testing/CHANGES.md create mode 100644 actix-testing/README.md diff --git a/README.md b/README.md index 0b4cc7e6..99ecd5fc 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# Actix net [![Build Status](https://travis-ci.org/actix/actix-net.svg?branch=master)](https://travis-ci.org/actix/actix-net) [![codecov](https://codecov.io/gh/actix/actix-net/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-net) [![crates.io](https://meritbadge.herokuapp.com/actix-net)](https://crates.io/crates/actix-net) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) +# Actix net [![Build Status](https://travis-ci.org/actix/actix-net.svg?branch=master)](https://travis-ci.org/actix/actix-net) [![codecov](https://codecov.io/gh/actix/actix-net/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-net) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) Actix net - framework for composable network services diff --git a/actix-testing/CHANGES.md b/actix-testing/CHANGES.md new file mode 100644 index 00000000..798dbf50 --- /dev/null +++ b/actix-testing/CHANGES.md @@ -0,0 +1,58 @@ +# Changes + +## [0.2.5] - 2019-0917 + +### Changed + +* Update serde_urlencoded to "0.6.1" + +### Fixed + +* Do not override current `System` + + +## [0.2.4] - 2019-07-18 + +* Update actix-server to 0.6 + +## [0.2.3] - 2019-07-16 + +* Add `delete`, `options`, `patch` methods to `TestServerRunner` + +## [0.2.2] - 2019-06-16 + +* Add .put() and .sput() methods + +## [0.2.1] - 2019-06-05 + +* Add license files + +## [0.2.0] - 2019-05-12 + +* Update awc and actix-http deps + +## [0.1.1] - 2019-04-24 + +* Always make new connection for http client + + +## [0.1.0] - 2019-04-16 + +* No changes + + +## [0.1.0-alpha.3] - 2019-04-02 + +* Request functions accept path #743 + + +## [0.1.0-alpha.2] - 2019-03-29 + +* Added TestServerRuntime::load_body() method + +* Update actix-http and awc libraries + + +## [0.1.0-alpha.1] - 2019-03-28 + +* Initial impl diff --git a/actix-testing/Cargo.toml b/actix-testing/Cargo.toml index a6083f07..3c101b13 100644 --- a/actix-testing/Cargo.toml +++ b/actix-testing/Cargo.toml @@ -2,33 +2,20 @@ name = "actix-testing" version = "0.1.0" authors = ["Nikolay Kim "] -description = "Actix test server" +description = "Actix testing utils" keywords = ["network", "framework", "async", "futures"] homepage = "https://actix.rs" repository = "https://github.com/actix/actix-net.git" documentation = "https://docs.rs/actix-testing/" categories = ["network-programming", "asynchronous"] license = "MIT/Apache-2.0" -exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"] edition = "2018" workspace = ".." -[package.metadata.docs.rs] -features = ["ssl", "tls", "rust-tls"] - [lib] name = "actix_testing" path = "src/lib.rs" -[features] -default = [] - -# openssl -ssl = ["openssl", "actix-server/ssl"] - -# rustls -rust-tls = ["rustls", "tokio-rustls", "webpki", "webpki-roots"] - [dependencies] actix-rt = "0.2.1" actix-server = "0.6.0" @@ -40,12 +27,3 @@ net2 = "0.2" futures = "0.1" tokio-tcp = "0.1" tokio-reactor = "0.1" - -# openssl -openssl = { version="0.10", optional = true } - -#rustls -rustls = { version = "^0.15", optional = true } -tokio-rustls = { version = "^0.9", optional = true } -webpki = { version = "0.19", optional = true } -webpki-roots = { version = "0.16", optional = true } diff --git a/actix-testing/README.md b/actix-testing/README.md new file mode 100644 index 00000000..cb217c61 --- /dev/null +++ b/actix-testing/README.md @@ -0,0 +1,9 @@ +# Actix test utilities [[![crates.io](https://meritbadge.herokuapp.com/actix-testing)](https://crates.io/crates/actix-testint) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) + +## Documentation & community resources + +* [User Guide](https://actix.rs/docs/) +* [API Documentation](https://docs.rs/actix-testing/) +* [Chat on gitter](https://gitter.im/actix/actix) +* Cargo package: [actix-http-test](https://crates.io/crates/actix-testing) +* Minimum supported Rust version: 1.37 or later From 715a770d7afa0aff1fda963649bc6a621dcc3b7d Mon Sep 17 00:00:00 2001 From: Nikolay Kim Date: Wed, 25 Sep 2019 09:31:52 +0600 Subject: [PATCH 04/11] deprecate test server --- actix-test-server/Cargo.toml | 27 --------------------------- actix-test-server/README.md | 3 +++ actix-testing/README.md | 2 +- 3 files changed, 4 insertions(+), 28 deletions(-) create mode 100644 actix-test-server/README.md diff --git a/actix-test-server/Cargo.toml b/actix-test-server/Cargo.toml index dd461c9d..ece93434 100644 --- a/actix-test-server/Cargo.toml +++ b/actix-test-server/Cargo.toml @@ -13,25 +13,10 @@ exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"] edition = "2018" workspace = ".." -[package.metadata.docs.rs] -features = ["ssl", "tls", "rust-tls"] - [lib] name = "actix_test_server" path = "src/lib.rs" -[features] -default = [] - -# tls -tls = ["native-tls", "actix-server/tls"] - -# openssl -ssl = ["openssl", "actix-server/ssl"] - -# rustls -rust-tls = ["rustls", "tokio-rustls", "webpki", "webpki-roots"] - [dependencies] actix-rt = "0.2.1" actix-server = "0.5.0" @@ -43,17 +28,5 @@ futures = "0.1" tokio-tcp = "0.1" tokio-reactor = "0.1" -# native-tls -native-tls = { version="0.2", optional = true } - -# openssl -openssl = { version="0.10", optional = true } - -#rustls -rustls = { version = "^0.15", optional = true } -tokio-rustls = { version = "^0.9", optional = true } -webpki = { version = "0.19", optional = true } -webpki-roots = { version = "0.16", optional = true } - [dev-dependencies] actix-service = "0.4.0" diff --git a/actix-test-server/README.md b/actix-test-server/README.md new file mode 100644 index 00000000..61f2773d --- /dev/null +++ b/actix-test-server/README.md @@ -0,0 +1,3 @@ +# Actix test server (Deprecated) + +Use [actix-testing](https://docs.rs/actix-testing/) instead diff --git a/actix-testing/README.md b/actix-testing/README.md index cb217c61..bd4eec2f 100644 --- a/actix-testing/README.md +++ b/actix-testing/README.md @@ -1,4 +1,4 @@ -# Actix test utilities [[![crates.io](https://meritbadge.herokuapp.com/actix-testing)](https://crates.io/crates/actix-testint) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) +# Actix test utilities [![crates.io](https://meritbadge.herokuapp.com/actix-testing)](https://crates.io/crates/actix-testint) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) ## Documentation & community resources From 41e49e8093667c29584f7ee638937b645b49faf9 Mon Sep 17 00:00:00 2001 From: Nikolay Kim Date: Wed, 25 Sep 2019 09:32:33 +0600 Subject: [PATCH 05/11] update changes --- actix-testing/CHANGES.md | 55 +--------------------------------------- 1 file changed, 1 insertion(+), 54 deletions(-) diff --git a/actix-testing/CHANGES.md b/actix-testing/CHANGES.md index 798dbf50..3dfd22fb 100644 --- a/actix-testing/CHANGES.md +++ b/actix-testing/CHANGES.md @@ -1,58 +1,5 @@ # Changes -## [0.2.5] - 2019-0917 - -### Changed - -* Update serde_urlencoded to "0.6.1" - -### Fixed - -* Do not override current `System` - - -## [0.2.4] - 2019-07-18 - -* Update actix-server to 0.6 - -## [0.2.3] - 2019-07-16 - -* Add `delete`, `options`, `patch` methods to `TestServerRunner` - -## [0.2.2] - 2019-06-16 - -* Add .put() and .sput() methods - -## [0.2.1] - 2019-06-05 - -* Add license files - -## [0.2.0] - 2019-05-12 - -* Update awc and actix-http deps - -## [0.1.1] - 2019-04-24 - -* Always make new connection for http client - - -## [0.1.0] - 2019-04-16 - -* No changes - - -## [0.1.0-alpha.3] - 2019-04-02 - -* Request functions accept path #743 - - -## [0.1.0-alpha.2] - 2019-03-29 - -* Added TestServerRuntime::load_body() method - -* Update actix-http and awc libraries - - -## [0.1.0-alpha.1] - 2019-03-28 +## [0.1.0] - 2019-09-25 * Initial impl From c859d13e3bcc861c5ea1f39001c5fe49fde43820 Mon Sep 17 00:00:00 2001 From: Nikolay Kim Date: Wed, 25 Sep 2019 09:51:28 +0600 Subject: [PATCH 06/11] use actix-testing instead of test server --- Cargo.toml | 1 - actix-connect/Cargo.toml | 2 +- actix-connect/tests/test_connect.rs | 73 ++++++-------- actix-ioframe/Cargo.toml | 2 +- actix-ioframe/tests/test_server.rs | 19 ++-- actix-test-server/Cargo.toml | 4 +- actix-test-server/src/lib.rs | 149 +--------------------------- 7 files changed, 46 insertions(+), 204 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index c88be5dc..02bd2166 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -23,7 +23,6 @@ members = [ "actix-server", "actix-server-config", "actix-testing", - "actix-test-server", "actix-threadpool", "actix-tower", "actix-utils", diff --git a/actix-connect/Cargo.toml b/actix-connect/Cargo.toml index afa57a93..d7d0c276 100644 --- a/actix-connect/Cargo.toml +++ b/actix-connect/Cargo.toml @@ -57,5 +57,5 @@ webpki = { version = "0.19", optional = true } [dev-dependencies] bytes = "0.4" -actix-test-server = { version="0.2.2", features=["ssl"] } +actix-testing = { version="0.1.0" } actix-server-config = "0.1.0" diff --git a/actix-connect/tests/test_connect.rs b/actix-connect/tests/test_connect.rs index 738cfc42..0de0cf90 100644 --- a/actix-connect/tests/test_connect.rs +++ b/actix-connect/tests/test_connect.rs @@ -1,13 +1,12 @@ use actix_codec::{BytesCodec, Framed}; use actix_server_config::Io; use actix_service::{service_fn, NewService, Service}; -use actix_test_server::TestServer; +use actix_testing::{self as test, TestServer}; use bytes::Bytes; use futures::{future::lazy, Future, Sink}; -use http::{HttpTryFrom, Uri}; use trust_dns_resolver::config::{ResolverConfig, ResolverOpts}; -use actix_connect::{default_connector, Connect}; +use actix_connect::Connect; #[cfg(feature = "ssl")] #[test] @@ -44,7 +43,7 @@ fn test_rustls_string() { } #[test] fn test_static_str() { - let mut srv = TestServer::with(|| { + let srv = TestServer::with(|| { service_fn(|io: Io| { Framed::new(io.into_parts().0, BytesCodec) .send(Bytes::from_static(b"test")) @@ -52,33 +51,29 @@ fn test_static_str() { }) }); - let resolver = srv - .block_on(lazy( - || Ok::<_, ()>(actix_connect::start_default_resolver()), - )) - .unwrap(); - let mut conn = srv - .block_on(lazy(|| { - Ok::<_, ()>(actix_connect::new_connector(resolver.clone())) - })) - .unwrap(); + let resolver = test::block_on(lazy( + || Ok::<_, ()>(actix_connect::start_default_resolver()), + )) + .unwrap(); - let con = srv - .block_on(conn.call(Connect::with("10", srv.addr()))) - .unwrap(); + let mut conn = test::block_on(lazy(|| { + Ok::<_, ()>(actix_connect::new_connector(resolver.clone())) + })) + .unwrap(); + + let con = test::block_on(conn.call(Connect::with("10", srv.addr()))).unwrap(); assert_eq!(con.peer_addr().unwrap(), srv.addr()); let connect = Connect::new(srv.host().to_owned()); - let mut conn = srv - .block_on(lazy(|| Ok::<_, ()>(actix_connect::new_connector(resolver)))) - .unwrap(); - let con = srv.block_on(conn.call(connect)); + let mut conn = + test::block_on(lazy(|| Ok::<_, ()>(actix_connect::new_connector(resolver)))).unwrap(); + let con = test::block_on(conn.call(connect)); assert!(con.is_err()); } #[test] fn test_new_service() { - let mut srv = TestServer::with(|| { + let srv = TestServer::with(|| { service_fn(|io: Io| { Framed::new(io.into_parts().0, BytesCodec) .send(Bytes::from_static(b"test")) @@ -86,24 +81,20 @@ fn test_new_service() { }) }); - let resolver = srv - .block_on(lazy(|| { - Ok::<_, ()>(actix_connect::start_resolver( - ResolverConfig::default(), - ResolverOpts::default(), - )) - })) - .unwrap(); - let factory = srv - .block_on(lazy(|| { - Ok::<_, ()>(actix_connect::new_connector_factory(resolver)) - })) - .unwrap(); + let resolver = test::block_on(lazy(|| { + Ok::<_, ()>(actix_connect::start_resolver( + ResolverConfig::default(), + ResolverOpts::default(), + )) + })) + .unwrap(); + let factory = test::block_on(lazy(|| { + Ok::<_, ()>(actix_connect::new_connector_factory(resolver)) + })) + .unwrap(); - let mut conn = srv.block_on(factory.new_service(&())).unwrap(); - let con = srv - .block_on(conn.call(Connect::with("10", srv.addr()))) - .unwrap(); + let mut conn = test::block_on(factory.new_service(&())).unwrap(); + let con = test::block_on(conn.call(Connect::with("10", srv.addr()))).unwrap(); assert_eq!(con.peer_addr().unwrap(), srv.addr()); } @@ -120,7 +111,7 @@ fn test_uri() { let mut conn = default_connector(); let addr = Uri::try_from(format!("https://localhost:{}", srv.port())).unwrap(); - let con = srv.run_on(move || conn.call(addr.into())).unwrap(); + let con = test::run_on(move || conn.call(addr.into())).unwrap(); assert_eq!(con.peer_addr().unwrap(), srv.addr()); } @@ -137,6 +128,6 @@ fn test_rustls_uri() { let mut conn = default_connector(); let addr = Uri::try_from(format!("https://localhost:{}", srv.port())).unwrap(); - let con = srv.run_on(move || conn.call(addr.into())).unwrap(); + let con = test::run_on(move || conn.call(addr.into())).unwrap(); assert_eq!(con.peer_addr().unwrap(), srv.addr()); } diff --git a/actix-ioframe/Cargo.toml b/actix-ioframe/Cargo.toml index 0c03c096..932499f9 100644 --- a/actix-ioframe/Cargo.toml +++ b/actix-ioframe/Cargo.toml @@ -29,7 +29,7 @@ log = "0.4" [dev-dependencies] actix-rt = "0.2.2" actix-connect = "0.2.0" -actix-test-server = "0.2.2" +actix-testing = "0.1.0" actix-server-config = "0.1.1" tokio-tcp = "0.1" tokio-timer = "0.2" diff --git a/actix-ioframe/tests/test_server.rs b/actix-ioframe/tests/test_server.rs index f995f400..c197bb56 100644 --- a/actix-ioframe/tests/test_server.rs +++ b/actix-ioframe/tests/test_server.rs @@ -5,7 +5,7 @@ use std::time::Duration; use actix_codec::BytesCodec; use actix_server_config::Io; use actix_service::{new_apply_fn, Service}; -use actix_test_server::TestServer; +use actix_testing::{self as test, TestServer}; use futures::Future; use tokio_tcp::TcpStream; use tokio_timer::sleep; @@ -19,7 +19,7 @@ fn test_disconnect() -> std::io::Result<()> { let disconnect = Arc::new(AtomicBool::new(false)); let disconnect1 = disconnect.clone(); - let mut srv = TestServer::with(move || { + let srv = TestServer::with(move || { let disconnect1 = disconnect1.clone(); new_apply_fn( @@ -41,15 +41,14 @@ fn test_disconnect() -> std::io::Result<()> { }) .finish(|_t| Ok(None)); - let conn = srv - .block_on( - actix_connect::default_connector() - .call(actix_connect::Connect::with(String::new(), srv.addr())), - ) - .unwrap(); + let conn = test::block_on( + actix_connect::default_connector() + .call(actix_connect::Connect::with(String::new(), srv.addr())), + ) + .unwrap(); - srv.block_on(client.call(conn.into_parts().0)).unwrap(); - let _ = srv.block_on( + test::block_on(client.call(conn.into_parts().0)).unwrap(); + let _ = test::block_on( sleep(Duration::from_millis(100)) .map(|_| ()) .map_err(|_| ()), diff --git a/actix-test-server/Cargo.toml b/actix-test-server/Cargo.toml index ece93434..8e063c38 100644 --- a/actix-test-server/Cargo.toml +++ b/actix-test-server/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "actix-test-server" -version = "0.2.2" +version = "0.2.3" authors = ["Nikolay Kim "] description = "Actix test server" keywords = ["network", "framework", "async", "futures"] @@ -11,7 +11,6 @@ categories = ["network-programming", "asynchronous"] license = "MIT/Apache-2.0" exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"] edition = "2018" -workspace = ".." [lib] name = "actix_test_server" @@ -21,6 +20,7 @@ path = "src/lib.rs" actix-rt = "0.2.1" actix-server = "0.5.0" actix-server-config = "0.1.0" +actix-testing = "0.1.0" log = "0.4" net2 = "0.2" diff --git a/actix-test-server/src/lib.rs b/actix-test-server/src/lib.rs index 7a3e0623..4681ce9b 100644 --- a/actix-test-server/src/lib.rs +++ b/actix-test-server/src/lib.rs @@ -1,149 +1,2 @@ //! Various helpers for Actix applications to use during testing. -use std::sync::mpsc; -use std::{net, thread}; - -use actix_rt::{Runtime, System}; -use actix_server::{Server, StreamServiceFactory}; -pub use actix_server_config::{Io, ServerConfig}; - -use futures::future::{lazy, Future, IntoFuture}; -use net2::TcpBuilder; -use tokio_reactor::Handle; -use tokio_tcp::TcpStream; - -/// The `TestServer` type. -/// -/// `TestServer` is very simple test server that simplify process of writing -/// integration tests for actix-net applications. -/// -/// # Examples -/// -/// ```rust -/// use actix_service::{service_fn, IntoNewService}; -/// use actix_test_server::TestServer; -/// -/// fn main() { -/// let srv = TestServer::with(|| service_fn( -/// |sock| { -/// println!("New connection: {:?}", sock); -/// Ok::<_, ()>(()) -/// } -/// )); -/// -/// println!("SOCKET: {:?}", srv.connect()); -/// } -/// ``` -pub struct TestServer; - -/// Test server runstime -pub struct TestServerRuntime { - addr: net::SocketAddr, - host: String, - port: u16, - rt: Runtime, -} - -impl TestServer { - /// Start new test server with application factory - pub fn with(factory: F) -> TestServerRuntime { - let (tx, rx) = mpsc::channel(); - - // run server in separate thread - thread::spawn(move || { - let sys = System::new("actix-test-server"); - let tcp = net::TcpListener::bind("127.0.0.1:0").unwrap(); - let local_addr = tcp.local_addr().unwrap(); - - Server::build() - .listen("test", tcp, factory)? - .workers(1) - .disable_signals() - .start(); - - tx.send((System::current(), local_addr)).unwrap(); - sys.run() - }); - - let (system, addr) = rx.recv().unwrap(); - System::set_current(system); - - let rt = Runtime::new().unwrap(); - let host = format!("{}", addr.ip()); - let port = addr.port(); - - TestServerRuntime { - addr, - rt, - host, - port, - } - } - - /// Get firat available unused local address - pub fn unused_addr() -> net::SocketAddr { - let addr: net::SocketAddr = "127.0.0.1:0".parse().unwrap(); - let socket = TcpBuilder::new_v4().unwrap(); - socket.bind(&addr).unwrap(); - socket.reuse_address(true).unwrap(); - let tcp = socket.to_tcp_listener().unwrap(); - tcp.local_addr().unwrap() - } -} - -impl TestServerRuntime { - /// Execute future on current runtime - pub fn block_on(&mut self, fut: F) -> Result - where - F: Future, - { - self.rt.block_on(fut) - } - - /// Runs the provided function, with runtime enabled. - pub fn run_on(&mut self, f: F) -> Result - where - F: FnOnce() -> R, - R: IntoFuture, - { - self.rt.block_on(lazy(|| f().into_future())) - } - - /// Spawn future to the current runtime - pub fn spawn(&mut self, fut: F) - where - F: Future + 'static, - { - self.rt.spawn(fut); - } - - /// Test server host - pub fn host(&self) -> &str { - &self.host - } - - /// Test server port - pub fn port(&self) -> u16 { - self.port - } - - /// Get test server address - pub fn addr(&self) -> net::SocketAddr { - self.addr - } - - /// Stop http server - fn stop(&mut self) { - System::current().stop(); - } - - /// Connect to server, return tokio TcpStream - pub fn connect(&self) -> std::io::Result { - TcpStream::from_std(net::TcpStream::connect(self.addr)?, &Handle::default()) - } -} - -impl Drop for TestServerRuntime { - fn drop(&mut self) { - self.stop() - } -} +pub use actix_testing::*; From ca982b246753f05671f38ad829746150121a5df1 Mon Sep 17 00:00:00 2001 From: Nikolay Kim Date: Wed, 25 Sep 2019 10:00:54 +0600 Subject: [PATCH 07/11] update workspace deps for tests --- Cargo.toml | 13 +++++++++++++ actix-connect/tests/test_connect.rs | 19 ++++++++++--------- 2 files changed, 23 insertions(+), 9 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 02bd2166..60443fe0 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -39,3 +39,16 @@ futures = "0.1.25" openssl = "0.10" tokio-tcp = "0.1" tokio-openssl = "0.3" + +[patch.crates-io] +actix-codec = { path = "actix-codec" } +actix-connect = { path = "actix-connect" } +actix-ioframe = { path = "actix-ioframe" } +actix-rt = { path = "actix-rt" } +actix-server = { path = "actix-server" } +actix-server-config = { path = "actix-server-config" } +actix-service = { path = "actix-service" } +actix-testing = { path = "actix-testing" } +actix-threadpool = { path = "actix-threadpool" } +actix-utils = { path = "actix-utils" } +actix-router = { path = "router" } diff --git a/actix-connect/tests/test_connect.rs b/actix-connect/tests/test_connect.rs index 0de0cf90..a8fdb1b6 100644 --- a/actix-connect/tests/test_connect.rs +++ b/actix-connect/tests/test_connect.rs @@ -4,14 +4,15 @@ use actix_service::{service_fn, NewService, Service}; use actix_testing::{self as test, TestServer}; use bytes::Bytes; use futures::{future::lazy, Future, Sink}; +use http::{HttpTryFrom, Uri}; use trust_dns_resolver::config::{ResolverConfig, ResolverOpts}; -use actix_connect::Connect; +use actix_connect::{default_connector, Connect}; #[cfg(feature = "ssl")] #[test] fn test_string() { - let mut srv = TestServer::with(|| { + let srv = TestServer::with(|| { service_fn(|io: Io| { Framed::new(io.into_parts().0, BytesCodec) .send(Bytes::from_static(b"test")) @@ -21,14 +22,14 @@ fn test_string() { let mut conn = default_connector(); let addr = format!("localhost:{}", srv.port()); - let con = srv.run_on(move || conn.call(addr.into())).unwrap(); + let con = test::call_service(&mut conn, addr.into()); assert_eq!(con.peer_addr().unwrap(), srv.addr()); } #[cfg(feature = "rust-tls")] #[test] fn test_rustls_string() { - let mut srv = TestServer::with(|| { + let srv = TestServer::with(|| { service_fn(|io: Io| { Framed::new(io.into_parts().0, BytesCodec) .send(Bytes::from_static(b"test")) @@ -38,7 +39,7 @@ fn test_rustls_string() { let mut conn = default_connector(); let addr = format!("localhost:{}", srv.port()); - let con = srv.run_on(move || conn.call(addr.into())).unwrap(); + let con = test::call_service(&mut conn, addr.into()); assert_eq!(con.peer_addr().unwrap(), srv.addr()); } #[test] @@ -101,7 +102,7 @@ fn test_new_service() { #[cfg(feature = "ssl")] #[test] fn test_uri() { - let mut srv = TestServer::with(|| { + let srv = TestServer::with(|| { service_fn(|io: Io| { Framed::new(io.into_parts().0, BytesCodec) .send(Bytes::from_static(b"test")) @@ -111,14 +112,14 @@ fn test_uri() { let mut conn = default_connector(); let addr = Uri::try_from(format!("https://localhost:{}", srv.port())).unwrap(); - let con = test::run_on(move || conn.call(addr.into())).unwrap(); + let con = test::call_service(&mut conn, addr.into()); assert_eq!(con.peer_addr().unwrap(), srv.addr()); } #[cfg(feature = "rust-tls")] #[test] fn test_rustls_uri() { - let mut srv = TestServer::with(|| { + let srv = TestServer::with(|| { service_fn(|io: Io| { Framed::new(io.into_parts().0, BytesCodec) .send(Bytes::from_static(b"test")) @@ -128,6 +129,6 @@ fn test_rustls_uri() { let mut conn = default_connector(); let addr = Uri::try_from(format!("https://localhost:{}", srv.port())).unwrap(); - let con = test::run_on(move || conn.call(addr.into())).unwrap(); + let con = test::call_service(&mut conn, addr.into()); assert_eq!(con.peer_addr().unwrap(), srv.addr()); } From dbf566928c0ab80a913134ed070bae123a81aba9 Mon Sep 17 00:00:00 2001 From: Nikolay Kim Date: Wed, 25 Sep 2019 10:01:08 +0600 Subject: [PATCH 08/11] drop tower intergration --- actix-tower/CHANGES.md | 2 - actix-tower/Cargo.toml | 29 -- actix-tower/LICENSE-APACHE | 1 - actix-tower/LICENSE-MIT | 1 - actix-tower/src/lib.rs | 580 ------------------------------------- 5 files changed, 613 deletions(-) delete mode 100644 actix-tower/CHANGES.md delete mode 100644 actix-tower/Cargo.toml delete mode 120000 actix-tower/LICENSE-APACHE delete mode 120000 actix-tower/LICENSE-MIT delete mode 100644 actix-tower/src/lib.rs diff --git a/actix-tower/CHANGES.md b/actix-tower/CHANGES.md deleted file mode 100644 index 06729a2e..00000000 --- a/actix-tower/CHANGES.md +++ /dev/null @@ -1,2 +0,0 @@ -# Changes - diff --git a/actix-tower/Cargo.toml b/actix-tower/Cargo.toml deleted file mode 100644 index e309b131..00000000 --- a/actix-tower/Cargo.toml +++ /dev/null @@ -1,29 +0,0 @@ -[package] -name = "actix-tower" -version = "0.1.0" -authors = ["Nikolay Kim ", "Marcus Griep "] -description = "Actix Tower" -keywords = ["network", "framework", "async", "futures"] -homepage = "https://actix.rs" -repository = "https://github.com/actix/actix-net.git" -documentation = "https://docs.rs/actix-tower/" -categories = ["network-programming", "asynchronous"] -license = "MIT/Apache-2.0" -exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"] -edition = "2018" -workspace = ".." - -[badges] -travis-ci = { repository = "actix/actix-tower", branch = "master" } -appveyor = { repository = "actix/actix-net" } -codecov = { repository = "actix/actix-tower", branch = "master", service = "github" } - -[lib] -name = "actix_tower" -path = "src/lib.rs" - -[dependencies] -actix-service = "0.3.6" -futures = "0.1.24" -tower-service = "0.2.0" - diff --git a/actix-tower/LICENSE-APACHE b/actix-tower/LICENSE-APACHE deleted file mode 120000 index 965b606f..00000000 --- a/actix-tower/LICENSE-APACHE +++ /dev/null @@ -1 +0,0 @@ -../LICENSE-APACHE \ No newline at end of file diff --git a/actix-tower/LICENSE-MIT b/actix-tower/LICENSE-MIT deleted file mode 120000 index 76219eb7..00000000 --- a/actix-tower/LICENSE-MIT +++ /dev/null @@ -1 +0,0 @@ -../LICENSE-MIT \ No newline at end of file diff --git a/actix-tower/src/lib.rs b/actix-tower/src/lib.rs deleted file mode 100644 index 4c172a72..00000000 --- a/actix-tower/src/lib.rs +++ /dev/null @@ -1,580 +0,0 @@ -//! Utilities to provide interoperability between services based on the -//! `actix-service` and `tower-service` crates. -//! -//! ## Example -//! -//! In the following example, we take a `RandomService`—which will always -//! return 4—and wraps it with a middleware that will always add 1 to the -//! result. This pattern can be further used to wrap services from either -//! `tower-service` or `actix-service` with middleware provided by the other. -//! -//! ``` -//! use actix_tower::ActixServiceExt; -//! # use futures::{Async, Future}; -//! use actix_service::Service; -//! -//! struct RandomService; -//! impl Service for RandomService { -//! // … -//! # type Request = (); -//! # type Response = u32; -//! # type Error = (); -//! # type Future = futures::future::FutureResult; -//! # -//! # fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> { -//! # Ok(Async::Ready(())) -//! # } -//! # -//! # fn call(&mut self, _req: Self::Request) -> Self::Future { -//! # futures::finished(4) -//! # } -//! } -//! -//! struct AddOneMiddleware(S); -//! impl tower_service::Service for AddOneMiddleware -//! where -//! S: tower_service::Service, -//! S::Future: 'static, -//! { -//! /// … -//! # type Response = u32; -//! # type Error = S::Error; -//! # type Future = Box>; -//! # -//! # fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> { -//! # self.0.poll_ready() -//! # } -//! # -//! # fn call(&mut self, req: R) -> Self::Future { -//! # let fut = self.0.call(req).map(|x| x + 1); -//! # Box::new(fut) -//! # } -//! } -//! -//! let mut s = RandomService.wrap_with_tower_middleware(AddOneMiddleware); -//! assert_eq!(Ok(Async::Ready(())), s.poll_ready()); -//! assert_eq!(Ok(Async::Ready(5)), s.call(()).poll()); -//! ``` - -use actix_service::Service as ActixService; -use std::marker::PhantomData; -use tower_service::Service as TowerService; - -/// Compatibility wrapper associating a `tower_service::Service` with a particular -/// `Request` type, so that it can be used as an `actix_service::Service`. -/// -/// Generally created through convenience methods on the `TowerServiceExt` trait. -pub struct ActixCompat { - inner: S, - _phantom: PhantomData, -} - -impl ActixCompat { - /// Wraps a `tower_service::Service` in a compatibility wrapper. - pub fn new(inner: S) -> Self { - ActixCompat { - inner, - _phantom: PhantomData, - } - } -} - -/// Extension trait for wrapping a `tower_service::Service` instance for use as -/// an `actix_service::Service`. -pub trait TowerServiceExt: TowerService + Sized { - /// Wraps a `tower_service::Service` in a compatibility wrapper. - /// - /// ``` - /// use actix_service::Service; - /// use actix_tower::TowerServiceExt; - /// # use futures::{Async, Future}; - /// - /// struct RandomService; - /// impl tower_service::Service for RandomService { - /// // … - /// # type Response = u32; - /// # type Error = (); - /// # type Future = futures::future::FutureResult; - /// # - /// # fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> { - /// # Ok(Async::Ready(())) - /// # } - /// # - /// # fn call(&mut self, _req: R) -> Self::Future { - /// # futures::finished(4) - /// # } - /// } - /// - /// let mut s = RandomService.into_actix_service(); - /// assert_eq!(Ok(Async::Ready(())), s.poll_ready()); - /// assert_eq!(Ok(Async::Ready(4)), s.call(()).poll()); - /// ``` - fn into_actix_service(self) -> ActixCompat { - ActixCompat::new(self) - } - - /// Takes a function that, when provided with an `actix_service::Service` wraps it - /// and returns a new service. Useful for wrapping a `tower_service::Service` with - /// middleware built for `actix_service`. - /// - /// ``` - /// use actix_tower::TowerServiceExt; - /// # use futures::{Async, Future}; - /// use tower_service::Service; - /// - /// struct RandomService; - /// impl Service for RandomService { - /// // … - /// # type Response = u32; - /// # type Error = (); - /// # type Future = futures::future::FutureResult; - /// # - /// # fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> { - /// # Ok(Async::Ready(())) - /// # } - /// # - /// # fn call(&mut self, _req: R) -> Self::Future { - /// # futures::finished(4) - /// # } - /// } - /// - /// struct AddOneTransform(S); - /// impl actix_service::Service for AddOneTransform - /// where - /// S: actix_service::Service, - /// S::Future: 'static, - /// { - /// /// … - /// # type Request = S::Request; - /// # type Response = u32; - /// # type Error = S::Error; - /// # type Future = Box>; - /// # - /// # fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> { - /// # self.0.poll_ready() - /// # } - /// # - /// # fn call(&mut self, req: Self::Request) -> Self::Future { - /// # let fut = self.0.call(req).map(|x| x + 1); - /// # Box::new(fut) - /// # } - /// } - /// - /// let mut s = RandomService.wrap_with_actix_middleware(AddOneTransform); - /// assert_eq!(Ok(Async::Ready(())), s.poll_ready()); - /// assert_eq!(Ok(Async::Ready(5)), s.call(()).poll()); - /// ``` - fn wrap_with_actix_middleware(self, f: F) -> TowerCompat - where - F: FnOnce(ActixCompat) -> U, - U: ActixService, - { - f(self.into_actix_service()).into_tower_service() - } -} - -impl TowerServiceExt for S where S: TowerService + Sized {} - -impl ActixService for ActixCompat -where - S: TowerService, -{ - type Request = R; - type Response = S::Response; - type Error = S::Error; - type Future = S::Future; - - fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> { - TowerService::poll_ready(&mut self.inner) - } - - fn call(&mut self, req: Self::Request) -> Self::Future { - TowerService::call(&mut self.inner, req) - } -} - -/// Compatibility wrapper associating an `actix_service::Service` with a particular -/// `Request` type, so that it can be used as a `tower_service::Service`. -/// -/// Generally created through convenience methods on the `ActixServiceExt` trait. -pub struct TowerCompat { - inner: S, -} - -impl TowerCompat { - /// Wraps an `actix_service::Service` in a compatibility wrapper. - pub fn new(inner: S) -> Self { - TowerCompat { inner } - } -} - -/// Extension trait for wrapping an `actix_service::Service` instance for use as -/// a `tower_service::Service`. -pub trait ActixServiceExt: ActixService + Sized { - /// Wraps a `tower_service::Service` in a compatibility wrapper. - /// - /// ``` - /// use actix_tower::ActixServiceExt; - /// # use futures::{Async, Future}; - /// use tower_service::Service; - /// - /// struct RandomService; - /// impl actix_service::Service for RandomService { - /// // … - /// # type Request = (); - /// # type Response = u32; - /// # type Error = (); - /// # type Future = futures::future::FutureResult; - /// # - /// # fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> { - /// # Ok(Async::Ready(())) - /// # } - /// # - /// # fn call(&mut self, _req: Self::Request) -> Self::Future { - /// # futures::finished(4) - /// # } - /// } - /// - /// let mut s = RandomService.into_tower_service(); - /// assert_eq!(Ok(Async::Ready(())), s.poll_ready()); - /// assert_eq!(Ok(Async::Ready(4)), s.call(()).poll()); - /// ``` - fn into_tower_service(self) -> TowerCompat { - TowerCompat::new(self) - } - - /// Takes a function that, when provided with a `tower_service::Service` wraps it - /// and returns a new service. Useful for wrapping an `actix_service::Service` with - /// middleware built for `tower_service`. - /// - /// ``` - /// use actix_tower::ActixServiceExt; - /// # use futures::{Async, Future}; - /// use actix_service::Service; - /// - /// struct RandomService; - /// impl Service for RandomService { - /// // … - /// # type Request = (); - /// # type Response = u32; - /// # type Error = (); - /// # type Future = futures::future::FutureResult; - /// # - /// # fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> { - /// # Ok(Async::Ready(())) - /// # } - /// # - /// # fn call(&mut self, _req: Self::Request) -> Self::Future { - /// # futures::finished(4) - /// # } - /// } - /// - /// struct AddOneMiddleware(S); - /// impl tower_service::Service for AddOneMiddleware - /// where - /// S: tower_service::Service, - /// S::Future: 'static, - /// { - /// /// … - /// # type Response = u32; - /// # type Error = S::Error; - /// # type Future = Box>; - /// # - /// # fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> { - /// # self.0.poll_ready() - /// # } - /// # - /// # fn call(&mut self, req: R) -> Self::Future { - /// # let fut = self.0.call(req).map(|x| x + 1); - /// # Box::new(fut) - /// # } - /// } - /// - /// let mut s = RandomService.wrap_with_tower_middleware(AddOneMiddleware); - /// assert_eq!(Ok(Async::Ready(())), s.poll_ready()); - /// assert_eq!(Ok(Async::Ready(5)), s.call(()).poll()); - /// ``` - fn wrap_with_tower_middleware(self, f: F) -> ActixCompat - where - F: FnOnce(TowerCompat) -> U, - U: TowerService, - { - f(self.into_tower_service()).into_actix_service() - } -} - -impl ActixServiceExt for S where S: ActixService + Sized {} - -impl TowerService for TowerCompat -where - S: ActixService, -{ - type Response = S::Response; - type Error = S::Error; - type Future = S::Future; - - fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> { - ActixService::poll_ready(&mut self.inner) - } - - fn call(&mut self, req: S::Request) -> Self::Future { - ActixService::call(&mut self.inner, req) - } -} - -#[cfg(test)] -mod tests { - mod tower_service_into_actix_service { - use crate::TowerServiceExt; - use actix_service::{Service as ActixService, ServiceExt, Transform}; - use futures::{future::FutureResult, Async, Future, Poll}; - use tower_service::Service as TowerService; - - #[test] - fn random_service_returns_4() { - let mut s = RandomService.into_actix_service(); - - assert_eq!(Ok(Async::Ready(())), s.poll_ready()); - - assert_eq!(Ok(Async::Ready(4)), s.call(()).poll()); - } - - #[test] - fn random_service_can_combine() { - let mut s = RandomService.into_actix_service().map(|x| x + 1); - - assert_eq!(Ok(Async::Ready(())), s.poll_ready()); - - assert_eq!(Ok(Async::Ready(5)), s.call(()).poll()); - } - - #[test] - fn random_service_can_use_actix_middleware() { - let mut s = RandomService.wrap_with_actix_middleware(DoMathTransform); - - assert_eq!(Ok(Async::Ready(())), s.poll_ready()); - - assert_eq!(Ok(Async::Ready(68)), s.call(()).poll()); - } - - #[test] - fn random_service_and_add_service_chained() { - let s1 = RandomService.into_actix_service(); - let s2 = AddOneService.into_actix_service(); - let s3 = AddOneService.into_actix_service(); - - let mut s = s1.and_then(s2).and_then(s3); - - assert_eq!(Ok(Async::Ready(())), s.poll_ready()); - - assert_eq!(Ok(Async::Ready(6)), s.call(()).poll()); - } - - #[test] - fn random_service_and_add_service_and_ignoring_service_chained() { - let s1 = RandomService.into_actix_service(); - let s2 = AddOneService.into_actix_service(); - let s3 = AddOneService.into_actix_service(); - let s4 = RandomService.into_actix_service(); - - let mut s = s1.and_then(s2).and_then(s3).and_then(s4); - - assert_eq!(Ok(Async::Ready(())), s.poll_ready()); - - assert_eq!(Ok(Async::Ready(4)), s.call(()).poll()); - } - - #[test] - fn random_service_can_be_transformed_to_do_math() { - let transform = DoMath; - - let mut s = transform - .new_transform(RandomService.into_actix_service()) - .wait() - .unwrap(); - - assert_eq!(Ok(Async::Ready(())), s.poll_ready()); - - assert_eq!(Ok(Async::Ready(68)), s.call(()).poll()); - } - - struct RandomService; - impl TowerService for RandomService { - type Response = u32; - type Error = (); - type Future = FutureResult; - - fn poll_ready(&mut self) -> Poll<(), Self::Error> { - Ok(Async::Ready(())) - } - - fn call(&mut self, _req: R) -> Self::Future { - futures::finished(4) - } - } - - struct AddOneService; - impl TowerService for AddOneService { - type Response = u32; - type Error = (); - type Future = FutureResult; - - fn poll_ready(&mut self) -> Poll<(), Self::Error> { - Ok(Async::Ready(())) - } - - fn call(&mut self, req: u32) -> Self::Future { - futures::finished(req + 1) - } - } - - struct DoMathTransform(S); - impl ActixService for DoMathTransform - where - S: ActixService, - S::Future: 'static, - { - type Request = S::Request; - type Response = u32; - type Error = S::Error; - type Future = Box>; - - fn poll_ready(&mut self) -> Poll<(), Self::Error> { - self.0.poll_ready() - } - - fn call(&mut self, req: Self::Request) -> Self::Future { - let fut = self.0.call(req).map(|x| x * 17); - Box::new(fut) - } - } - - struct DoMath; - impl Transform for DoMath - where - S: ActixService, - S::Future: 'static, - { - type Request = S::Request; - type Response = u32; - type Error = S::Error; - type Transform = DoMathTransform; - type InitError = (); - type Future = FutureResult; - - fn new_transform(&self, service: S) -> Self::Future { - futures::finished(DoMathTransform(service)) - } - } - } - - mod actix_service_into_tower_service { - use crate::{ActixServiceExt, TowerServiceExt}; - use actix_service::{Service as ActixService, ServiceExt}; - use futures::{future::FutureResult, Async, Future, Poll}; - use tower_service::Service as TowerService; - - #[test] - fn random_service_returns_4() { - let mut s = RandomService.into_tower_service(); - - assert_eq!(Ok(Async::Ready(())), s.poll_ready()); - - assert_eq!(Ok(Async::Ready(4)), s.call(()).poll()); - } - - #[test] - fn random_service_can_use_tower_middleware() { - let mut s = - AddOneService::wrap(RandomService.into_tower_service()).into_actix_service(); - - assert_eq!(Ok(Async::Ready(())), s.poll_ready()); - - assert_eq!(Ok(Async::Ready(5)), s.call(()).poll()); - } - - #[test] - fn do_math_service_can_use_tower_middleware() { - let mut s = - AddOneService::wrap(DoMathService.into_tower_service()).into_actix_service(); - - assert_eq!(Ok(Async::Ready(())), s.poll_ready()); - - assert_eq!(Ok(Async::Ready(188)), s.call(11).poll()); - } - - #[test] - fn random_service_and_add_service_and_ignoring_service_chained() { - let s1 = RandomService.wrap_with_tower_middleware(AddOneService::wrap); - let s2 = DoMathService.wrap_with_tower_middleware(AddOneService::wrap); - - let mut s = s1.and_then(s2); - - assert_eq!(Ok(Async::Ready(())), s.poll_ready()); - - assert_eq!(Ok(Async::Ready(86)), s.call(()).poll()); - } - - struct RandomService; - impl ActixService for RandomService { - type Request = (); - type Response = u32; - type Error = (); - type Future = FutureResult; - - fn poll_ready(&mut self) -> Poll<(), Self::Error> { - Ok(Async::Ready(())) - } - - fn call(&mut self, _req: Self::Request) -> Self::Future { - futures::finished(4) - } - } - - struct AddOneService { - inner: S, - } - - impl AddOneService { - fn wrap(inner: S) -> Self { - AddOneService { inner } - } - } - - impl TowerService for AddOneService - where - S: TowerService, - S::Future: 'static, - { - type Response = u32; - type Error = S::Error; - type Future = Box>; - - fn poll_ready(&mut self) -> Poll<(), Self::Error> { - self.inner.poll_ready() - } - - fn call(&mut self, req: R) -> Self::Future { - let fut = self.inner.call(req).map(|x| x + 1); - - Box::new(fut) - } - } - - struct DoMathService; - impl ActixService for DoMathService { - type Request = u32; - type Response = u32; - type Error = (); - type Future = FutureResult; - - fn poll_ready(&mut self) -> Poll<(), Self::Error> { - Ok(Async::Ready(())) - } - - fn call(&mut self, req: Self::Request) -> Self::Future { - futures::finished(req * 17) - } - } - } -} From a02ff17cb192b4b2c3614df47578e6971bdf5d9b Mon Sep 17 00:00:00 2001 From: Nikolay Kim Date: Wed, 25 Sep 2019 10:11:17 +0600 Subject: [PATCH 09/11] remove actix-tower from workspace --- Cargo.toml | 1 - 1 file changed, 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 60443fe0..7b33514f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -24,7 +24,6 @@ members = [ "actix-server-config", "actix-testing", "actix-threadpool", - "actix-tower", "actix-utils", "router", ] From 4837a901e2c2d3ced41c14ac9a09b492c0192ef9 Mon Sep 17 00:00:00 2001 From: Nikolay Kim Date: Wed, 25 Sep 2019 10:35:15 +0600 Subject: [PATCH 10/11] prepare actix-server release --- CHANGES.md | 69 ----------------------------------------- actix-server/CHANGES.md | 7 +++++ actix-server/Cargo.toml | 2 +- 3 files changed, 8 insertions(+), 70 deletions(-) delete mode 100644 CHANGES.md diff --git a/CHANGES.md b/CHANGES.md deleted file mode 100644 index 51e019e7..00000000 --- a/CHANGES.md +++ /dev/null @@ -1,69 +0,0 @@ -# Changes - -## [0.3.0] - xxx - -* Split `Service` trait to separate crate - -* Use new `Service` trait - -* Add UDS listening support to `ServerBuilder` - -## [0.2.4] - 2018-11-21 - -### Added - -* Allow to skip name resolution stage in Connector - - -## [0.2.3] - 2018-11-17 - -### Added - -* Framed::is_write_buf_empty() checks if write buffer is flushed - -## [0.2.2] - 2018-11-14 - -### Added - -* Add low/high caps to Framed - -### Changed - -* Refactor Connector and Resolver services - - -### Fixed - -* Fix wrong service to socket binding - - -## [0.2.0] - 2018-11-08 - -### Added - -* Timeout service - -* Added ServiceConfig and ServiceRuntime for server service configuration - - -### Changed - -* Connector has been refactored - -* timer and LowResTimer renamed to time and LowResTime - -* Refactored `Server::configure()` method - - -## [0.1.1] - 2018-10-10 - -### Changed - -- Set actix min version - 0.7.5 - -- Set trust-dns min version - - -## [0.1.0] - 2018-10-08 - -* Initial impl diff --git a/actix-server/CHANGES.md b/actix-server/CHANGES.md index 9094f5ff..6ab3bcc9 100644 --- a/actix-server/CHANGES.md +++ b/actix-server/CHANGES.md @@ -1,5 +1,12 @@ # Changes +## [0.6.1] - 2019-09-25 + +### Added + +* Add UDS listening support to `ServerBuilder` + + ## [0.6.0] - 2019-07-18 ### Added diff --git a/actix-server/Cargo.toml b/actix-server/Cargo.toml index c7c40820..2bda582a 100644 --- a/actix-server/Cargo.toml +++ b/actix-server/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "actix-server" -version = "0.6.0" +version = "0.6.1" authors = ["Nikolay Kim "] description = "Actix server - General purpose tcp server" keywords = ["network", "framework", "async", "futures"] From aa9bbe2114e5ee4f772a2c885428a27253e2d159 Mon Sep 17 00:00:00 2001 From: Nikolay Kim Date: Wed, 25 Sep 2019 10:47:06 +0600 Subject: [PATCH 11/11] prepare actix-ioframe release --- actix-ioframe/CHANGES.md | 2 +- actix-ioframe/Cargo.toml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/actix-ioframe/CHANGES.md b/actix-ioframe/CHANGES.md index 0f084238..90905f5f 100644 --- a/actix-ioframe/CHANGES.md +++ b/actix-ioframe/CHANGES.md @@ -1,5 +1,5 @@ # Changes -## [0.1.0] - 2019-07-17 +## [0.1.0] - 2019-09-25 * Initial release diff --git a/actix-ioframe/Cargo.toml b/actix-ioframe/Cargo.toml index 932499f9..b5838832 100644 --- a/actix-ioframe/Cargo.toml +++ b/actix-ioframe/Cargo.toml @@ -6,7 +6,7 @@ description = "Actix framed service" keywords = ["network", "framework", "async", "futures"] homepage = "https://actix.rs" repository = "https://github.com/actix/actix-net.git" -documentation = "https://docs.rs/actix-ioframed/" +documentation = "https://docs.rs/actix-ioframe/" categories = ["network-programming", "asynchronous"] license = "MIT/Apache-2.0" exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]