diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml deleted file mode 100644 index 7c76e171..00000000 --- a/.github/workflows/bench.yml +++ /dev/null @@ -1,29 +0,0 @@ -name: Benchmark (Linux) - -on: - pull_request: - types: [opened, synchronize, reopened] - push: - branches: - - master - - '1.0' - -jobs: - check_benchmark: - runs-on: ubuntu-latest - - steps: - - uses: actions/checkout@v2 - - - name: Install Rust - uses: actions-rs/toolchain@v1 - with: - toolchain: nightly - profile: minimal - override: true - - - name: Check benchmark - uses: actions-rs/cargo@v1 - with: - command: bench - args: --package=actix-service diff --git a/.github/workflows/linux.yml b/.github/workflows/linux.yml index 23efaa8a..8ea7823d 100644 --- a/.github/workflows/linux.yml +++ b/.github/workflows/linux.yml @@ -14,7 +14,7 @@ jobs: fail-fast: false matrix: version: - - 1.42.0 + - 1.46.0 - stable - nightly diff --git a/Cargo.toml b/Cargo.toml index f032478a..78e54d35 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,31 +1,25 @@ [workspace] members = [ "actix-codec", - "actix-connect", - "actix-rt", "actix-macros", - "actix-service", + "actix-router", + "actix-rt", "actix-server", - "actix-testing", - "actix-threadpool", + "actix-service", "actix-tls", "actix-tracing", "actix-utils", - "router", - "string", + "bytestring", ] [patch.crates-io] actix-codec = { path = "actix-codec" } -actix-connect = { path = "actix-connect" } -actix-rt = { path = "actix-rt" } actix-macros = { path = "actix-macros" } +actix-router = { path = "actix-router" } +actix-rt = { path = "actix-rt" } actix-server = { path = "actix-server" } actix-service = { path = "actix-service" } -actix-testing = { path = "actix-testing" } -actix-threadpool = { path = "actix-threadpool" } actix-tls = { path = "actix-tls" } actix-tracing = { path = "actix-tracing" } actix-utils = { path = "actix-utils" } -actix-router = { path = "router" } -bytestring = { path = "string" } +bytestring = { path = "bytestring" } diff --git a/README.md b/README.md index 827f937f..95500e43 100644 --- a/README.md +++ b/README.md @@ -1,9 +1,12 @@ -# 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 -Actix net - framework for composable network services +> A collection of lower-level libraries for composable network services. + +![Apache 2.0 or MIT licensed](https://img.shields.io/crates/l/actix-server) +[![codecov](https://codecov.io/gh/actix/actix-net/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-net) +[![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x) ## Build statuses - | Platform | Build Status | | ---------------- | ------------ | | Linux | [![build status](https://github.com/actix/actix-net/workflows/CI%20%28Linux%29/badge.svg?branch=master&event=push)](https://github.com/actix/actix-net/actions?query=workflow%3A"CI+(Linux)") | @@ -11,59 +14,13 @@ Actix net - framework for composable network services | Windows | [![build status](https://github.com/actix/actix-net/workflows/CI%20%28Windows%29/badge.svg?branch=master&event=push)](https://github.com/actix/actix-net/actions?query=workflow%3A"CI+(Windows)") | | Windows (MinGW) | [![build status](https://github.com/actix/actix-net/workflows/CI%20%28Windows-mingw%29/badge.svg?branch=master&event=push)](https://github.com/actix/actix-net/actions?query=workflow%3A"CI+(Windows-mingw)") | -## Documentation & community resources - -* [Chat on Gitter](https://gitter.im/actix/actix) -* Minimum supported Rust version: 1.42 or later - ## Example +See `actix-server/examples` and `actix-tls/examples` for some basic examples. -```rust -fn main() -> io::Result<()> { - // load ssl keys - let mut builder = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap(); - builder.set_private_key_file("./examples/key.pem", SslFiletype::PEM).unwrap(); - builder.set_certificate_chain_file("./examples/cert.pem").unwrap(); - let acceptor = builder.build(); - - let num = Arc::new(AtomicUsize::new(0)); - - // bind socket address and start workers. By default server uses number of - // available logical cpu as threads count. actix net start separate - // instances of service pipeline in each worker. - Server::build() - .bind( - // configure service pipeline - "basic", "0.0.0.0:8443", - move || { - let num = num.clone(); - let acceptor = acceptor.clone(); - - // construct transformation pipeline - pipeline( - // service for converting incoming TcpStream to a SslStream - fn_service(move |stream: actix_rt::net::TcpStream| async move { - SslAcceptorExt::accept_async(&acceptor, stream.into_parts().0).await - .map_err(|e| println!("Openssl error: {}", e)) - })) - // .and_then() combinator chains result of previos service call to argument - /// for next service calll. in this case, on success we chain - /// ssl stream to the `logger` service. - .and_then(fn_service(logger)) - // Next service counts number of connections - .and_then(move |_| { - let num = num.fetch_add(1, Ordering::Relaxed); - println!("got ssl connection {:?}", num); - future::ok(()) - }) - }, - )? - .run() -} -``` +### MSRV +This repo's Minimum Supported Rust Version (MSRV) is 1.46.0. ## License - This project is licensed under either of * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0)) @@ -73,6 +30,5 @@ at your option. ## Code of Conduct -Contribution to the actix-net crate is organized under the terms of the -Contributor Covenant, the maintainer of actix-net, @fafhrd91, promises to -intervene to uphold that code of conduct. +Contribution to the actix-net repo is organized under the terms of the Contributor Covenant. +The Actix team promises to intervene to uphold that code of conduct. diff --git a/actix-codec/CHANGES.md b/actix-codec/CHANGES.md index cd4424d0..f6102cbf 100644 --- a/actix-codec/CHANGES.md +++ b/actix-codec/CHANGES.md @@ -1,14 +1,25 @@ # Changes -## Unreleased - 2020-xx-xx -* Upgrade `pin-project` to `1.0`. +## Unreleased - 2021-xx-xx + + +## 0.4.0-beta.1 - 2020-12-28 +* Replace `pin-project` with `pin-project-lite`. [#237] +* Upgrade `tokio` dependency to `1`. [#237] +* Upgrade `tokio-util` dependency to `0.6`. [#237] +* Upgrade `bytes` dependency to `1`. [#237] + +[#237]: https://github.com/actix/actix-net/pull/237 + ## 0.3.0 - 2020-08-23 * No changes from beta 2. + ## 0.3.0-beta.2 - 2020-08-19 * Remove unused type parameter from `Framed::replace_codec`. + ## 0.3.0-beta.1 - 2020-08-19 * Use `.advance()` instead of `.split_to()`. * Upgrade `tokio-util` to `0.3`. @@ -18,32 +29,31 @@ * Add method on `Framed` to get a pinned reference to the underlying I/O. * Add method on `Framed` check emptiness of read buffer. -## [0.2.0] - 2019-12-10 +## 0.2.0 - 2019-12-10 * Use specific futures dependencies -## [0.2.0-alpha.4] +## 0.2.0-alpha.4 * Fix buffer remaining capacity calculation -## [0.2.0-alpha.3] +## 0.2.0-alpha.3 * Use tokio 0.2 - * Fix low/high watermark for write/read buffers -## [0.2.0-alpha.2] +## 0.2.0-alpha.2 * Migrated to `std::future` -## [0.1.2] - 2019-03-27 +## 0.1.2 - 2019-03-27 * Added `Framed::map_io()` method. -## [0.1.1] - 2019-03-06 +## 0.1.1 - 2019-03-06 * Added `FramedParts::with_read_buffer()` method. -## [0.1.0] - 2018-12-09 +## 0.1.0 - 2018-12-09 * Move codec to separate crate diff --git a/actix-codec/Cargo.toml b/actix-codec/Cargo.toml index 1214945a..95a24764 100644 --- a/actix-codec/Cargo.toml +++ b/actix-codec/Cargo.toml @@ -1,12 +1,12 @@ [package] name = "actix-codec" -version = "0.3.0" +version = "0.4.0-beta.1" authors = ["Nikolay Kim "] -description = "Codec utilities for working with framed protocols." +description = "Codec utilities for working with framed protocols" keywords = ["network", "framework", "async", "futures"] homepage = "https://actix.rs" repository = "https://github.com/actix/actix-net.git" -documentation = "https://docs.rs/actix-codec/" +documentation = "https://docs.rs/actix-codec" categories = ["network-programming", "asynchronous"] license = "MIT OR Apache-2.0" edition = "2018" @@ -17,10 +17,10 @@ path = "src/lib.rs" [dependencies] bitflags = "1.2.1" -bytes = "0.5.2" -futures-core = { version = "0.3.4", default-features = false } -futures-sink = { version = "0.3.4", default-features = false } +bytes = "1" +futures-core = { version = "0.3.7", default-features = false } +futures-sink = { version = "0.3.7", default-features = false } log = "0.4" -pin-project = "1.0.0" -tokio = { version = "0.2.5", default-features = false } -tokio-util = { version = "0.3.1", default-features = false, features = ["codec"] } +pin-project-lite = "0.2" +tokio = "1" +tokio-util = { version = "0.6", features = ["codec", "io"] } diff --git a/actix-codec/src/bcodec.rs b/actix-codec/src/bcodec.rs index 045b20a2..b06279ea 100644 --- a/actix-codec/src/bcodec.rs +++ b/actix-codec/src/bcodec.rs @@ -14,7 +14,7 @@ impl Encoder for BytesCodec { #[inline] fn encode(&mut self, item: Bytes, dst: &mut BytesMut) -> Result<(), Self::Error> { - dst.extend_from_slice(item.bytes()); + dst.extend_from_slice(item.chunk()); Ok(()) } } diff --git a/actix-codec/src/framed.rs b/actix-codec/src/framed.rs index 844f20d8..cf2297dc 100644 --- a/actix-codec/src/framed.rs +++ b/actix-codec/src/framed.rs @@ -5,7 +5,6 @@ use std::{fmt, io}; use bytes::{Buf, BytesMut}; use futures_core::{ready, Stream}; use futures_sink::Sink; -use pin_project::pin_project; use crate::{AsyncRead, AsyncWrite, Decoder, Encoder}; @@ -21,22 +20,23 @@ bitflags::bitflags! { } } -/// A unified `Stream` and `Sink` interface to an underlying I/O object, using -/// the `Encoder` and `Decoder` traits to encode and decode frames. -/// -/// Raw I/O objects work with byte sequences, but higher-level code usually -/// wants to batch these into meaningful chunks, called "frames". This -/// method layers framing on top of an I/O object, by using the `Encoder`/`Decoder` -/// traits to handle encoding and decoding of message frames. Note that -/// the incoming and outgoing frame types may be distinct. -#[pin_project] -pub struct Framed { - #[pin] - io: T, - codec: U, - flags: Flags, - read_buf: BytesMut, - write_buf: BytesMut, +pin_project_lite::pin_project! { + /// A unified `Stream` and `Sink` interface to an underlying I/O object, using + /// the `Encoder` and `Decoder` traits to encode and decode frames. + /// + /// Raw I/O objects work with byte sequences, but higher-level code usually + /// wants to batch these into meaningful chunks, called "frames". This + /// method layers framing on top of an I/O object, by using the `Encoder`/`Decoder` + /// traits to handle encoding and decoding of message frames. Note that + /// the incoming and outgoing frame types may be distinct. + pub struct Framed { + #[pin] + io: T, + codec: U, + flags: Flags, + read_buf: BytesMut, + write_buf: BytesMut, + } } impl Framed @@ -220,7 +220,8 @@ impl Framed { if remaining < LW { this.read_buf.reserve(HW - remaining) } - let cnt = match this.io.poll_read_buf(cx, &mut this.read_buf) { + + let cnt = match tokio_util::io::poll_read_buf(this.io, cx, this.read_buf) { Poll::Pending => return Poll::Pending, Poll::Ready(Err(e)) => return Poll::Ready(Some(Err(e.into()))), Poll::Ready(Ok(cnt)) => cnt, diff --git a/actix-codec/src/lib.rs b/actix-codec/src/lib.rs index 8c346052..dec30ba6 100644 --- a/actix-codec/src/lib.rs +++ b/actix-codec/src/lib.rs @@ -1,4 +1,4 @@ -//! Utilities for encoding and decoding frames. +//! Codec utilities for working with framed protocols. //! //! Contains adapters to go from streams of bytes, [`AsyncRead`] and //! [`AsyncWrite`], to framed streams implementing [`Sink`] and [`Stream`]. @@ -18,5 +18,6 @@ mod framed; pub use self::bcodec::BytesCodec; pub use self::framed::{Framed, FramedParts}; -pub use tokio::io::{AsyncRead, AsyncWrite}; +pub use tokio::io::{AsyncRead, AsyncWrite, ReadBuf}; pub use tokio_util::codec::{Decoder, Encoder}; +pub use tokio_util::io::poll_read_buf; diff --git a/actix-connect/CHANGES.md b/actix-connect/CHANGES.md deleted file mode 100644 index 6f18b5b4..00000000 --- a/actix-connect/CHANGES.md +++ /dev/null @@ -1,154 +0,0 @@ -# Changes - -## Unreleased - 2020-xx-xx - - -## 2.0.0 - 2020-09-02 -- No significant changes from `2.0.0-alpha.4`. - -## 2.0.0-alpha.4 - 2020-08-17 - -### Changed - -* Update `rustls` dependency to 0.18 -* Update `tokio-rustls` dependency to 0.14 - - -## [2.0.0-alpha.3] - 2020-05-08 - -### Fixed - -* Corrected spelling of `ConnectError::Unresolverd` to `ConnectError::Unresolved` - -## [2.0.0-alpha.2] - 2020-03-08 - -### Changed - -* Update `trust-dns-proto` dependency to 0.19. [#116] -* Update `trust-dns-resolver` dependency to 0.19. [#116] -* `Address` trait is now required to have static lifetime. [#116] -* `start_resolver` and `start_default_resolver` are now `async` and may return a `ConnectError`. [#116] - -[#116]: https://github.com/actix/actix-net/pull/116 - -## [2.0.0-alpha.1] - 2020-03-03 - -### Changed - -* Update `rustls` dependency to 0.17 -* Update `tokio-rustls` dependency to 0.13 - -## [1.0.2] - 2020-01-15 - -* Fix actix-service 1.0.3 compatibility - -## [1.0.1] - 2019-12-15 - -* Fix trust-dns-resolver compilation - -## [1.0.0] - 2019-12-11 - -* Release - -## [1.0.0-alpha.3] - 2019-12-07 - -### Changed - -* Migrate to tokio 0.2 - - -## [1.0.0-alpha.2] - 2019-12-02 - -### Changed - -* Migrated to `std::future` - - -## [0.3.0] - 2019-10-03 - -### Changed - -* Update `rustls` to 0.16 -* Minimum required Rust version upped to 1.37.0 - -## [0.2.5] - 2019-09-05 - -* Add `TcpConnectService` - -## [0.2.4] - 2019-09-02 - -* Use arbiter's storage for default async resolver - -## [0.2.3] - 2019-08-05 - -* Add `ConnectService` and `OpensslConnectService` - -## [0.2.2] - 2019-07-24 - -* Add `rustls` support - -## [0.2.1] - 2019-07-17 - -### Added - -* Expose Connect addrs #30 - -### Changed - -* Update `derive_more` to 0.15 - - -## [0.2.0] - 2019-05-12 - -### Changed - -* Upgrade to actix-service 0.4 - - -## [0.1.5] - 2019-04-19 - -### Added - -* `Connect::set_addr()` - -### Changed - -* Use trust-dns-resolver 0.11.0 - - -## [0.1.4] - 2019-04-12 - -### Changed - -* Do not start default resolver immediately for default connector. - - -## [0.1.3] - 2019-04-11 - -### Changed - -* Start trust-dns default resolver on first use - -## [0.1.2] - 2019-04-04 - -### Added - -* Log error if dns system config could not be loaded. - -### Changed - -* Rename connect Connector to TcpConnector #10 - - -## [0.1.1] - 2019-03-15 - -### Fixed - -* Fix error handling for single address - - -## [0.1.0] - 2019-03-14 - -* Refactor resolver and connector services - -* Rename crate diff --git a/actix-connect/Cargo.toml b/actix-connect/Cargo.toml deleted file mode 100644 index 233195c5..00000000 --- a/actix-connect/Cargo.toml +++ /dev/null @@ -1,58 +0,0 @@ -[package] -name = "actix-connect" -version = "2.0.0" -authors = ["Nikolay Kim "] -description = "TCP connector service for Actix ecosystem." -keywords = ["network", "framework", "async", "futures"] -homepage = "https://actix.rs" -repository = "https://github.com/actix/actix-net.git" -documentation = "https://docs.rs/actix-connect/" -categories = ["network-programming", "asynchronous"] -license = "MIT OR Apache-2.0" -edition = "2018" - -[package.metadata.docs.rs] -features = ["openssl", "rustls", "uri"] - -[lib] -name = "actix_connect" -path = "src/lib.rs" - -[features] -default = ["uri"] - -# openssl -openssl = ["open-ssl", "tokio-openssl"] - -# rustls -rustls = ["rust-tls", "tokio-rustls", "webpki"] - -# support http::Uri as connect address -uri = ["http"] - -[dependencies] -actix-service = "1.0.6" -actix-codec = "0.3.0" -actix-utils = "2.0.0" -actix-rt = "1.1.1" - -derive_more = "0.99.2" -either = "1.5.3" -futures-util = { version = "0.3.4", default-features = false } -http = { version = "0.2.0", optional = true } -log = "0.4" -trust-dns-proto = { version = "0.19", default-features = false, features = ["tokio-runtime"] } -trust-dns-resolver = { version = "0.19", default-features = false, features = ["tokio-runtime", "system-config"] } - -# openssl -open-ssl = { package = "openssl", version = "0.10", optional = true } -tokio-openssl = { version = "0.4.0", optional = true } - -# rustls -rust-tls = { package = "rustls", version = "0.18.0", optional = true } -tokio-rustls = { version = "0.14.0", optional = true } -webpki = { version = "0.21", optional = true } - -[dev-dependencies] -bytes = "0.5.3" -actix-testing = "1.0.0" diff --git a/actix-connect/src/connect.rs b/actix-connect/src/connect.rs deleted file mode 100644 index 37fa9c6e..00000000 --- a/actix-connect/src/connect.rs +++ /dev/null @@ -1,282 +0,0 @@ -use std::collections::{vec_deque, VecDeque}; -use std::fmt; -use std::iter::{FromIterator, FusedIterator}; -use std::net::SocketAddr; - -use either::Either; - -/// Connect request -pub trait Address: Unpin + 'static { - /// Host name of the request - fn host(&self) -> &str; - - /// Port of the request - fn port(&self) -> Option; -} - -impl Address for String { - fn host(&self) -> &str { - &self - } - - fn port(&self) -> Option { - None - } -} - -impl Address for &'static str { - fn host(&self) -> &str { - self - } - - fn port(&self) -> Option { - None - } -} - -/// Connect request -#[derive(Eq, PartialEq, Debug, Hash)] -pub struct Connect { - pub(crate) req: T, - pub(crate) port: u16, - pub(crate) addr: Option>>, -} - -impl Connect { - /// Create `Connect` instance by splitting the string by ':' and convert the second part to u16 - pub fn new(req: T) -> Connect { - let (_, port) = parse(req.host()); - Connect { - req, - port: port.unwrap_or(0), - addr: None, - } - } - - /// Create new `Connect` instance from host and address. Connector skips name resolution stage - /// for such connect messages. - pub fn with(req: T, addr: SocketAddr) -> Connect { - Connect { - req, - port: 0, - addr: Some(Either::Left(addr)), - } - } - - /// Use port if address does not provide one. - /// - /// By default it set to 0 - pub fn set_port(mut self, port: u16) -> Self { - self.port = port; - self - } - - /// Use address. - pub fn set_addr(mut self, addr: Option) -> Self { - if let Some(addr) = addr { - self.addr = Some(Either::Left(addr)); - } - self - } - - /// Use addresses. - pub fn set_addrs(mut self, addrs: I) -> Self - where - I: IntoIterator, - { - let mut addrs = VecDeque::from_iter(addrs); - self.addr = if addrs.len() < 2 { - addrs.pop_front().map(Either::Left) - } else { - Some(Either::Right(addrs)) - }; - self - } - - /// Host name - pub fn host(&self) -> &str { - self.req.host() - } - - /// Port of the request - pub fn port(&self) -> u16 { - self.req.port().unwrap_or(self.port) - } - - /// Pre-resolved addresses of the request. - pub fn addrs(&self) -> ConnectAddrsIter<'_> { - let inner = match self.addr { - None => Either::Left(None), - Some(Either::Left(addr)) => Either::Left(Some(addr)), - Some(Either::Right(ref addrs)) => Either::Right(addrs.iter()), - }; - - ConnectAddrsIter { inner } - } - - /// Takes pre-resolved addresses of the request. - pub fn take_addrs(&mut self) -> ConnectTakeAddrsIter { - let inner = match self.addr.take() { - None => Either::Left(None), - Some(Either::Left(addr)) => Either::Left(Some(addr)), - Some(Either::Right(addrs)) => Either::Right(addrs.into_iter()), - }; - - ConnectTakeAddrsIter { inner } - } -} - -impl From for Connect { - fn from(addr: T) -> Self { - Connect::new(addr) - } -} - -impl fmt::Display for Connect { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "{}:{}", self.host(), self.port()) - } -} - -/// Iterator over addresses in a [`Connect`] request. -#[derive(Clone)] -pub struct ConnectAddrsIter<'a> { - inner: Either, vec_deque::Iter<'a, SocketAddr>>, -} - -impl Iterator for ConnectAddrsIter<'_> { - type Item = SocketAddr; - - fn next(&mut self) -> Option { - match self.inner { - Either::Left(ref mut opt) => opt.take(), - Either::Right(ref mut iter) => iter.next().copied(), - } - } - - fn size_hint(&self) -> (usize, Option) { - match self.inner { - Either::Left(Some(_)) => (1, Some(1)), - Either::Left(None) => (0, Some(0)), - Either::Right(ref iter) => iter.size_hint(), - } - } -} - -impl fmt::Debug for ConnectAddrsIter<'_> { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.debug_list().entries(self.clone()).finish() - } -} - -impl ExactSizeIterator for ConnectAddrsIter<'_> {} - -impl FusedIterator for ConnectAddrsIter<'_> {} - -/// Owned iterator over addresses in a [`Connect`] request. -#[derive(Debug)] -pub struct ConnectTakeAddrsIter { - inner: Either, vec_deque::IntoIter>, -} - -impl Iterator for ConnectTakeAddrsIter { - type Item = SocketAddr; - - fn next(&mut self) -> Option { - match self.inner { - Either::Left(ref mut opt) => opt.take(), - Either::Right(ref mut iter) => iter.next(), - } - } - - fn size_hint(&self) -> (usize, Option) { - match self.inner { - Either::Left(Some(_)) => (1, Some(1)), - Either::Left(None) => (0, Some(0)), - Either::Right(ref iter) => iter.size_hint(), - } - } -} - -impl ExactSizeIterator for ConnectTakeAddrsIter {} - -impl FusedIterator for ConnectTakeAddrsIter {} - -fn parse(host: &str) -> (&str, Option) { - let mut parts_iter = host.splitn(2, ':'); - if let Some(host) = parts_iter.next() { - let port_str = parts_iter.next().unwrap_or(""); - if let Ok(port) = port_str.parse::() { - (host, Some(port)) - } else { - (host, None) - } - } else { - (host, None) - } -} - -pub struct Connection { - io: U, - req: T, -} - -impl Connection { - pub fn new(io: U, req: T) -> Self { - Self { io, req } - } -} - -impl Connection { - /// Reconstruct from a parts. - pub fn from_parts(io: U, req: T) -> Self { - Self { io, req } - } - - /// Deconstruct into a parts. - pub fn into_parts(self) -> (U, T) { - (self.io, self.req) - } - - /// Replace inclosed object, return new Stream and old object - pub fn replace(self, io: Y) -> (U, Connection) { - (self.io, Connection { io, req: self.req }) - } - - /// Returns a shared reference to the underlying stream. - pub fn get_ref(&self) -> &U { - &self.io - } - - /// Returns a mutable reference to the underlying stream. - pub fn get_mut(&mut self) -> &mut U { - &mut self.io - } -} - -impl Connection { - /// Get request - pub fn host(&self) -> &str { - &self.req.host() - } -} - -impl std::ops::Deref for Connection { - type Target = U; - - fn deref(&self) -> &U { - &self.io - } -} - -impl std::ops::DerefMut for Connection { - fn deref_mut(&mut self) -> &mut U { - &mut self.io - } -} - -impl fmt::Debug for Connection { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "Stream {{{:?}}}", self.io) - } -} diff --git a/actix-connect/src/connector.rs b/actix-connect/src/connector.rs deleted file mode 100644 index 9dc9a2ad..00000000 --- a/actix-connect/src/connector.rs +++ /dev/null @@ -1,172 +0,0 @@ -use std::collections::VecDeque; -use std::future::Future; -use std::io; -use std::marker::PhantomData; -use std::net::SocketAddr; -use std::pin::Pin; -use std::task::{Context, Poll}; - -use actix_rt::net::TcpStream; -use actix_service::{Service, ServiceFactory}; -use futures_util::future::{err, ok, BoxFuture, Either, FutureExt, Ready}; - -use super::connect::{Address, Connect, Connection}; -use super::error::ConnectError; - -/// TCP connector service factory -#[derive(Debug)] -pub struct TcpConnectorFactory(PhantomData); - -impl TcpConnectorFactory { - pub fn new() -> Self { - TcpConnectorFactory(PhantomData) - } - - /// Create TCP connector service - pub fn service(&self) -> TcpConnector { - TcpConnector(PhantomData) - } -} - -impl Default for TcpConnectorFactory { - fn default() -> Self { - TcpConnectorFactory(PhantomData) - } -} - -impl Clone for TcpConnectorFactory { - fn clone(&self) -> Self { - TcpConnectorFactory(PhantomData) - } -} - -impl ServiceFactory for TcpConnectorFactory { - type Request = Connect; - type Response = Connection; - type Error = ConnectError; - type Config = (); - type Service = TcpConnector; - type InitError = (); - type Future = Ready>; - - fn new_service(&self, _: ()) -> Self::Future { - ok(self.service()) - } -} - -/// TCP connector service -#[derive(Default, Debug)] -pub struct TcpConnector(PhantomData); - -impl TcpConnector { - pub fn new() -> Self { - TcpConnector(PhantomData) - } -} - -impl Clone for TcpConnector { - fn clone(&self) -> Self { - TcpConnector(PhantomData) - } -} - -impl Service for TcpConnector { - type Request = Connect; - type Response = Connection; - type Error = ConnectError; - #[allow(clippy::type_complexity)] - type Future = Either, Ready>>; - - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { - Poll::Ready(Ok(())) - } - - fn call(&mut self, req: Connect) -> Self::Future { - let port = req.port(); - let Connect { req, addr, .. } = req; - - if let Some(addr) = addr { - Either::Left(TcpConnectorResponse::new(req, port, addr)) - } else { - error!("TCP connector: got unresolved address"); - Either::Right(err(ConnectError::Unresolved)) - } - } -} - -#[doc(hidden)] -/// TCP stream connector response future -pub struct TcpConnectorResponse { - req: Option, - port: u16, - addrs: Option>, - stream: Option>>, -} - -impl TcpConnectorResponse { - pub fn new( - req: T, - port: u16, - addr: either::Either>, - ) -> TcpConnectorResponse { - trace!( - "TCP connector - connecting to {:?} port:{}", - req.host(), - port - ); - - match addr { - either::Either::Left(addr) => TcpConnectorResponse { - req: Some(req), - port, - addrs: None, - stream: Some(TcpStream::connect(addr).boxed()), - }, - either::Either::Right(addrs) => TcpConnectorResponse { - req: Some(req), - port, - addrs: Some(addrs), - stream: None, - }, - } - } -} - -impl Future for TcpConnectorResponse { - type Output = Result, ConnectError>; - - fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - let this = self.get_mut(); - - // connect - loop { - if let Some(new) = this.stream.as_mut() { - match new.as_mut().poll(cx) { - Poll::Ready(Ok(sock)) => { - let req = this.req.take().unwrap(); - trace!( - "TCP connector - successfully connected to connecting to {:?} - {:?}", - req.host(), sock.peer_addr() - ); - return Poll::Ready(Ok(Connection::new(sock, req))); - } - Poll::Pending => return Poll::Pending, - Poll::Ready(Err(err)) => { - trace!( - "TCP connector - failed to connect to connecting to {:?} port: {}", - this.req.as_ref().unwrap().host(), - this.port, - ); - if this.addrs.is_none() || this.addrs.as_ref().unwrap().is_empty() { - return Poll::Ready(Err(err.into())); - } - } - } - } - - // try to connect - let addr = this.addrs.as_mut().unwrap().pop_front().unwrap(); - this.stream = Some(TcpStream::connect(addr).boxed()); - } - } -} diff --git a/actix-connect/src/lib.rs b/actix-connect/src/lib.rs deleted file mode 100644 index 36d0b98a..00000000 --- a/actix-connect/src/lib.rs +++ /dev/null @@ -1,113 +0,0 @@ -//! TCP connector service for Actix ecosystem. -//! -//! ## Package feature -//! -//! * `openssl` - enables TLS support via `openssl` crate -//! * `rustls` - enables TLS support via `rustls` crate - -#![deny(rust_2018_idioms, nonstandard_style)] -#![recursion_limit = "128"] -#![doc(html_logo_url = "https://actix.rs/img/logo.png")] -#![doc(html_favicon_url = "https://actix.rs/favicon.ico")] - -#[macro_use] -extern crate log; - -mod connect; -mod connector; -mod error; -mod resolve; -mod service; -pub mod ssl; - -#[cfg(feature = "uri")] -mod uri; - -use actix_rt::{net::TcpStream, Arbiter}; -use actix_service::{pipeline, pipeline_factory, Service, ServiceFactory}; -use trust_dns_resolver::config::{ResolverConfig, ResolverOpts}; -use trust_dns_resolver::system_conf::read_system_conf; -use trust_dns_resolver::TokioAsyncResolver as AsyncResolver; - -pub mod resolver { - pub use trust_dns_resolver::config::{ResolverConfig, ResolverOpts}; - pub use trust_dns_resolver::system_conf::read_system_conf; - pub use trust_dns_resolver::{error::ResolveError, AsyncResolver}; -} - -pub use self::connect::{Address, Connect, Connection}; -pub use self::connector::{TcpConnector, TcpConnectorFactory}; -pub use self::error::ConnectError; -pub use self::resolve::{Resolver, ResolverFactory}; -pub use self::service::{ConnectService, ConnectServiceFactory, TcpConnectService}; - -pub async fn start_resolver( - cfg: ResolverConfig, - opts: ResolverOpts, -) -> Result { - Ok(AsyncResolver::tokio(cfg, opts).await?) -} - -struct DefaultResolver(AsyncResolver); - -pub(crate) async fn get_default_resolver() -> Result { - if Arbiter::contains_item::() { - Ok(Arbiter::get_item(|item: &DefaultResolver| item.0.clone())) - } else { - let (cfg, opts) = match read_system_conf() { - Ok((cfg, opts)) => (cfg, opts), - Err(e) => { - log::error!("TRust-DNS can not load system config: {}", e); - (ResolverConfig::default(), ResolverOpts::default()) - } - }; - - let resolver = AsyncResolver::tokio(cfg, opts).await?; - - Arbiter::set_item(DefaultResolver(resolver.clone())); - Ok(resolver) - } -} - -pub async fn start_default_resolver() -> Result { - get_default_resolver().await -} - -/// Create TCP connector service. -pub fn new_connector( - resolver: AsyncResolver, -) -> impl Service, Response = Connection, Error = ConnectError> - + Clone { - pipeline(Resolver::new(resolver)).and_then(TcpConnector::new()) -} - -/// Create TCP connector service factory. -pub fn new_connector_factory( - resolver: AsyncResolver, -) -> impl ServiceFactory< - Config = (), - Request = Connect, - Response = Connection, - Error = ConnectError, - InitError = (), -> + Clone { - pipeline_factory(ResolverFactory::new(resolver)).and_then(TcpConnectorFactory::new()) -} - -/// Create connector service with default parameters. -pub fn default_connector( -) -> impl Service, Response = Connection, Error = ConnectError> - + Clone { - pipeline(Resolver::default()).and_then(TcpConnector::new()) -} - -/// Create connector service factory with default parameters. -pub fn default_connector_factory() -> impl ServiceFactory< - Config = (), - Request = Connect, - Response = Connection, - Error = ConnectError, - InitError = (), -> + Clone { - pipeline_factory(ResolverFactory::default()).and_then(TcpConnectorFactory::new()) -} diff --git a/actix-connect/src/resolve.rs b/actix-connect/src/resolve.rs deleted file mode 100644 index bfb1482f..00000000 --- a/actix-connect/src/resolve.rs +++ /dev/null @@ -1,208 +0,0 @@ -use std::future::Future; -use std::marker::PhantomData; -use std::net::SocketAddr; -use std::pin::Pin; -use std::task::{Context, Poll}; - -use actix_service::{Service, ServiceFactory}; -use futures_util::future::{ok, Either, Ready}; -use trust_dns_resolver::TokioAsyncResolver as AsyncResolver; -use trust_dns_resolver::{error::ResolveError, lookup_ip::LookupIp}; - -use crate::connect::{Address, Connect}; -use crate::error::ConnectError; -use crate::get_default_resolver; - -/// DNS Resolver Service factory -pub struct ResolverFactory { - resolver: Option, - _t: PhantomData, -} - -impl ResolverFactory { - /// Create new resolver instance with custom configuration and options. - pub fn new(resolver: AsyncResolver) -> Self { - ResolverFactory { - resolver: Some(resolver), - _t: PhantomData, - } - } - - pub fn service(&self) -> Resolver { - Resolver { - resolver: self.resolver.clone(), - _t: PhantomData, - } - } -} - -impl Default for ResolverFactory { - fn default() -> Self { - ResolverFactory { - resolver: None, - _t: PhantomData, - } - } -} - -impl Clone for ResolverFactory { - fn clone(&self) -> Self { - ResolverFactory { - resolver: self.resolver.clone(), - _t: PhantomData, - } - } -} - -impl ServiceFactory for ResolverFactory { - type Request = Connect; - type Response = Connect; - type Error = ConnectError; - type Config = (); - type Service = Resolver; - type InitError = (); - type Future = Ready>; - - fn new_service(&self, _: ()) -> Self::Future { - ok(self.service()) - } -} - -/// DNS Resolver Service -pub struct Resolver { - resolver: Option, - _t: PhantomData, -} - -impl Resolver { - /// Create new resolver instance with custom configuration and options. - pub fn new(resolver: AsyncResolver) -> Self { - Resolver { - resolver: Some(resolver), - _t: PhantomData, - } - } -} - -impl Default for Resolver { - fn default() -> Self { - Resolver { - resolver: None, - _t: PhantomData, - } - } -} - -impl Clone for Resolver { - fn clone(&self) -> Self { - Resolver { - resolver: self.resolver.clone(), - _t: PhantomData, - } - } -} - -impl Service for Resolver { - type Request = Connect; - type Response = Connect; - type Error = ConnectError; - #[allow(clippy::type_complexity)] - type Future = Either< - Pin>>>, - Ready, Self::Error>>, - >; - - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { - Poll::Ready(Ok(())) - } - - fn call(&mut self, mut req: Connect) -> Self::Future { - if req.addr.is_some() { - Either::Right(ok(req)) - } else if let Ok(ip) = req.host().parse() { - req.addr = Some(either::Either::Left(SocketAddr::new(ip, req.port()))); - Either::Right(ok(req)) - } else { - let resolver = self.resolver.as_ref().map(AsyncResolver::clone); - Either::Left(Box::pin(async move { - trace!("DNS resolver: resolving host {:?}", req.host()); - let resolver = if let Some(resolver) = resolver { - resolver - } else { - get_default_resolver() - .await - .expect("Failed to get default resolver") - }; - ResolverFuture::new(req, &resolver).await - })) - } - } -} - -type LookupIpFuture = Pin>>>; - -#[doc(hidden)] -/// Resolver future -pub struct ResolverFuture { - req: Option>, - lookup: LookupIpFuture, -} - -impl ResolverFuture { - pub fn new(req: Connect, resolver: &AsyncResolver) -> Self { - let host = if let Some(host) = req.host().splitn(2, ':').next() { - host - } else { - req.host() - }; - - // Clone data to be moved to the lookup future - let host_clone = host.to_owned(); - let resolver_clone = resolver.clone(); - - ResolverFuture { - lookup: Box::pin(async move { - let resolver = resolver_clone; - resolver.lookup_ip(host_clone).await - }), - req: Some(req), - } - } -} - -impl Future for ResolverFuture { - type Output = Result, ConnectError>; - - fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - let this = self.get_mut(); - - match Pin::new(&mut this.lookup).poll(cx) { - Poll::Pending => Poll::Pending, - Poll::Ready(Ok(ips)) => { - let req = this.req.take().unwrap(); - let port = req.port(); - let req = req.set_addrs(ips.iter().map(|ip| SocketAddr::new(ip, port))); - - trace!( - "DNS resolver: host {:?} resolved to {:?}", - req.host(), - req.addrs() - ); - - if req.addr.is_none() { - Poll::Ready(Err(ConnectError::NoRecords)) - } else { - Poll::Ready(Ok(req)) - } - } - Poll::Ready(Err(e)) => { - trace!( - "DNS resolver: failed to resolve host {:?} err: {}", - this.req.as_ref().unwrap().host(), - e - ); - Poll::Ready(Err(e.into())) - } - } - } -} diff --git a/actix-connect/src/service.rs b/actix-connect/src/service.rs deleted file mode 100644 index 1047e3df..00000000 --- a/actix-connect/src/service.rs +++ /dev/null @@ -1,232 +0,0 @@ -use std::future::Future; -use std::pin::Pin; -use std::task::{Context, Poll}; - -use actix_rt::net::TcpStream; -use actix_service::{Service, ServiceFactory}; -use either::Either; -use futures_util::future::{ok, Ready}; -use trust_dns_resolver::TokioAsyncResolver as AsyncResolver; - -use crate::connect::{Address, Connect, Connection}; -use crate::connector::{TcpConnector, TcpConnectorFactory}; -use crate::error::ConnectError; -use crate::resolve::{Resolver, ResolverFactory}; - -pub struct ConnectServiceFactory { - tcp: TcpConnectorFactory, - resolver: ResolverFactory, -} - -impl ConnectServiceFactory { - /// Construct new ConnectService factory - pub fn new() -> Self { - ConnectServiceFactory { - tcp: TcpConnectorFactory::default(), - resolver: ResolverFactory::default(), - } - } - - /// Construct new connect service with custom dns resolver - pub fn with_resolver(resolver: AsyncResolver) -> Self { - ConnectServiceFactory { - tcp: TcpConnectorFactory::default(), - resolver: ResolverFactory::new(resolver), - } - } - - /// Construct new service - pub fn service(&self) -> ConnectService { - ConnectService { - tcp: self.tcp.service(), - resolver: self.resolver.service(), - } - } - - /// Construct new tcp stream service - pub fn tcp_service(&self) -> TcpConnectService { - TcpConnectService { - tcp: self.tcp.service(), - resolver: self.resolver.service(), - } - } -} - -impl Default for ConnectServiceFactory { - fn default() -> Self { - ConnectServiceFactory { - tcp: TcpConnectorFactory::default(), - resolver: ResolverFactory::default(), - } - } -} - -impl Clone for ConnectServiceFactory { - fn clone(&self) -> Self { - ConnectServiceFactory { - tcp: self.tcp.clone(), - resolver: self.resolver.clone(), - } - } -} - -impl ServiceFactory for ConnectServiceFactory { - type Request = Connect; - type Response = Connection; - type Error = ConnectError; - type Config = (); - type Service = ConnectService; - type InitError = (); - type Future = Ready>; - - fn new_service(&self, _: ()) -> Self::Future { - ok(self.service()) - } -} - -#[derive(Clone)] -pub struct ConnectService { - tcp: TcpConnector, - resolver: Resolver, -} - -impl Service for ConnectService { - type Request = Connect; - type Response = Connection; - type Error = ConnectError; - type Future = ConnectServiceResponse; - - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { - Poll::Ready(Ok(())) - } - - fn call(&mut self, req: Connect) -> Self::Future { - ConnectServiceResponse { - state: ConnectState::Resolve(self.resolver.call(req)), - tcp: self.tcp.clone(), - } - } -} - -enum ConnectState { - Resolve( as Service>::Future), - Connect( as Service>::Future), -} - -impl ConnectState { - #[allow(clippy::type_complexity)] - fn poll( - &mut self, - cx: &mut Context<'_>, - ) -> Either, ConnectError>>, Connect> { - match self { - ConnectState::Resolve(ref mut fut) => match Pin::new(fut).poll(cx) { - Poll::Pending => Either::Left(Poll::Pending), - Poll::Ready(Ok(res)) => Either::Right(res), - Poll::Ready(Err(err)) => Either::Left(Poll::Ready(Err(err))), - }, - ConnectState::Connect(ref mut fut) => Either::Left(Pin::new(fut).poll(cx)), - } - } -} - -pub struct ConnectServiceResponse { - state: ConnectState, - tcp: TcpConnector, -} - -impl Future for ConnectServiceResponse { - type Output = Result, ConnectError>; - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - let res = match self.state.poll(cx) { - Either::Right(res) => { - self.state = ConnectState::Connect(self.tcp.call(res)); - self.state.poll(cx) - } - Either::Left(res) => return res, - }; - - match res { - Either::Left(res) => res, - Either::Right(_) => panic!(), - } - } -} - -#[derive(Clone)] -pub struct TcpConnectService { - tcp: TcpConnector, - resolver: Resolver, -} - -impl Service for TcpConnectService { - type Request = Connect; - type Response = TcpStream; - type Error = ConnectError; - type Future = TcpConnectServiceResponse; - - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { - Poll::Ready(Ok(())) - } - - fn call(&mut self, req: Connect) -> Self::Future { - TcpConnectServiceResponse { - state: TcpConnectState::Resolve(self.resolver.call(req)), - tcp: self.tcp.clone(), - } - } -} - -enum TcpConnectState { - Resolve( as Service>::Future), - Connect( as Service>::Future), -} - -impl TcpConnectState { - fn poll( - &mut self, - cx: &mut Context<'_>, - ) -> Either>, Connect> { - match self { - TcpConnectState::Resolve(ref mut fut) => match Pin::new(fut).poll(cx) { - Poll::Pending => (), - Poll::Ready(Ok(res)) => return Either::Right(res), - Poll::Ready(Err(err)) => return Either::Left(Poll::Ready(Err(err))), - }, - TcpConnectState::Connect(ref mut fut) => { - if let Poll::Ready(res) = Pin::new(fut).poll(cx) { - return match res { - Ok(conn) => Either::Left(Poll::Ready(Ok(conn.into_parts().0))), - Err(err) => Either::Left(Poll::Ready(Err(err))), - }; - } - } - } - Either::Left(Poll::Pending) - } -} - -pub struct TcpConnectServiceResponse { - state: TcpConnectState, - tcp: TcpConnector, -} - -impl Future for TcpConnectServiceResponse { - type Output = Result; - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - let res = match self.state.poll(cx) { - Either::Right(res) => { - self.state = TcpConnectState::Connect(self.tcp.call(res)); - self.state.poll(cx) - } - Either::Left(res) => return res, - }; - - match res { - Either::Left(res) => res, - Either::Right(_) => panic!(), - } - } -} diff --git a/actix-connect/src/ssl/openssl.rs b/actix-connect/src/ssl/openssl.rs deleted file mode 100644 index e1c6b6fb..00000000 --- a/actix-connect/src/ssl/openssl.rs +++ /dev/null @@ -1,268 +0,0 @@ -use std::future::Future; -use std::marker::PhantomData; -use std::pin::Pin; -use std::task::{Context, Poll}; -use std::{fmt, io}; - -pub use open_ssl::ssl::{Error as SslError, SslConnector, SslMethod}; -pub use tokio_openssl::{HandshakeError, SslStream}; - -use actix_codec::{AsyncRead, AsyncWrite}; -use actix_rt::net::TcpStream; -use actix_service::{Service, ServiceFactory}; -use futures_util::future::{err, ok, Either, FutureExt, LocalBoxFuture, Ready}; -use trust_dns_resolver::TokioAsyncResolver as AsyncResolver; - -use crate::{ - Address, Connect, ConnectError, ConnectService, ConnectServiceFactory, Connection, -}; - -/// OpenSSL connector factory -pub struct OpensslConnector { - connector: SslConnector, - _t: PhantomData<(T, U)>, -} - -impl OpensslConnector { - pub fn new(connector: SslConnector) -> Self { - OpensslConnector { - connector, - _t: PhantomData, - } - } -} - -impl OpensslConnector -where - T: Address + 'static, - U: AsyncRead + AsyncWrite + Unpin + fmt::Debug + 'static, -{ - pub fn service(connector: SslConnector) -> OpensslConnectorService { - OpensslConnectorService { - connector, - _t: PhantomData, - } - } -} - -impl Clone for OpensslConnector { - fn clone(&self) -> Self { - Self { - connector: self.connector.clone(), - _t: PhantomData, - } - } -} - -impl ServiceFactory for OpensslConnector -where - T: Address + 'static, - U: AsyncRead + AsyncWrite + Unpin + fmt::Debug + 'static, -{ - type Request = Connection; - type Response = Connection>; - type Error = io::Error; - type Config = (); - type Service = OpensslConnectorService; - type InitError = (); - type Future = Ready>; - - fn new_service(&self, _: ()) -> Self::Future { - ok(OpensslConnectorService { - connector: self.connector.clone(), - _t: PhantomData, - }) - } -} - -pub struct OpensslConnectorService { - connector: SslConnector, - _t: PhantomData<(T, U)>, -} - -impl Clone for OpensslConnectorService { - fn clone(&self) -> Self { - Self { - connector: self.connector.clone(), - _t: PhantomData, - } - } -} - -impl Service for OpensslConnectorService -where - T: Address + 'static, - U: AsyncRead + AsyncWrite + Unpin + fmt::Debug + 'static, -{ - type Request = Connection; - type Response = Connection>; - type Error = io::Error; - #[allow(clippy::type_complexity)] - type Future = Either, Ready>>; - - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { - Poll::Ready(Ok(())) - } - - fn call(&mut self, stream: Connection) -> Self::Future { - trace!("SSL Handshake start for: {:?}", stream.host()); - let (io, stream) = stream.replace(()); - let host = stream.host().to_string(); - - match self.connector.configure() { - Err(e) => Either::Right(err(io::Error::new(io::ErrorKind::Other, e))), - Ok(config) => Either::Left(ConnectAsyncExt { - fut: async move { tokio_openssl::connect(config, &host, io).await } - .boxed_local(), - stream: Some(stream), - _t: PhantomData, - }), - } - } -} - -pub struct ConnectAsyncExt { - fut: LocalBoxFuture<'static, Result, HandshakeError>>, - stream: Option>, - _t: PhantomData, -} - -impl Future for ConnectAsyncExt -where - U: AsyncRead + AsyncWrite + Unpin + fmt::Debug + 'static, -{ - type Output = Result>, io::Error>; - - fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - let this = self.get_mut(); - - match Pin::new(&mut this.fut).poll(cx) { - Poll::Ready(Ok(stream)) => { - let s = this.stream.take().unwrap(); - trace!("SSL Handshake success: {:?}", s.host()); - Poll::Ready(Ok(s.replace(stream).1)) - } - Poll::Ready(Err(e)) => { - trace!("SSL Handshake error: {:?}", e); - Poll::Ready(Err(io::Error::new(io::ErrorKind::Other, format!("{}", e)))) - } - Poll::Pending => Poll::Pending, - } - } -} - -pub struct OpensslConnectServiceFactory { - tcp: ConnectServiceFactory, - openssl: OpensslConnector, -} - -impl OpensslConnectServiceFactory { - /// Construct new OpensslConnectService factory - pub fn new(connector: SslConnector) -> Self { - OpensslConnectServiceFactory { - tcp: ConnectServiceFactory::default(), - openssl: OpensslConnector::new(connector), - } - } - - /// Construct new connect service with custom DNS resolver - pub fn with_resolver(connector: SslConnector, resolver: AsyncResolver) -> Self { - OpensslConnectServiceFactory { - tcp: ConnectServiceFactory::with_resolver(resolver), - openssl: OpensslConnector::new(connector), - } - } - - /// Construct OpenSSL connect service - pub fn service(&self) -> OpensslConnectService { - OpensslConnectService { - tcp: self.tcp.service(), - openssl: OpensslConnectorService { - connector: self.openssl.connector.clone(), - _t: PhantomData, - }, - } - } -} - -impl Clone for OpensslConnectServiceFactory { - fn clone(&self) -> Self { - OpensslConnectServiceFactory { - tcp: self.tcp.clone(), - openssl: self.openssl.clone(), - } - } -} - -impl ServiceFactory for OpensslConnectServiceFactory { - type Request = Connect; - type Response = SslStream; - type Error = ConnectError; - type Config = (); - type Service = OpensslConnectService; - type InitError = (); - type Future = Ready>; - - fn new_service(&self, _: ()) -> Self::Future { - ok(self.service()) - } -} - -#[derive(Clone)] -pub struct OpensslConnectService { - tcp: ConnectService, - openssl: OpensslConnectorService, -} - -impl Service for OpensslConnectService { - type Request = Connect; - type Response = SslStream; - type Error = ConnectError; - type Future = OpensslConnectServiceResponse; - - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { - Poll::Ready(Ok(())) - } - - fn call(&mut self, req: Connect) -> Self::Future { - OpensslConnectServiceResponse { - fut1: Some(self.tcp.call(req)), - fut2: None, - openssl: self.openssl.clone(), - } - } -} - -pub struct OpensslConnectServiceResponse { - fut1: Option< as Service>::Future>, - fut2: Option< as Service>::Future>, - openssl: OpensslConnectorService, -} - -impl Future for OpensslConnectServiceResponse { - type Output = Result, ConnectError>; - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - if let Some(ref mut fut) = self.fut1 { - match futures_util::ready!(Pin::new(fut).poll(cx)) { - Ok(res) => { - let _ = self.fut1.take(); - self.fut2 = Some(self.openssl.call(res)); - } - Err(e) => return Poll::Ready(Err(e)), - } - } - - if let Some(ref mut fut) = self.fut2 { - match futures_util::ready!(Pin::new(fut).poll(cx)) { - Ok(connect) => Poll::Ready(Ok(connect.into_parts().0)), - Err(e) => Poll::Ready(Err(ConnectError::Io(io::Error::new( - io::ErrorKind::Other, - e, - )))), - } - } else { - Poll::Pending - } - } -} diff --git a/actix-connect/src/uri.rs b/actix-connect/src/uri.rs deleted file mode 100644 index 5f5f15de..00000000 --- a/actix-connect/src/uri.rs +++ /dev/null @@ -1,37 +0,0 @@ -use http::Uri; - -use crate::Address; - -impl Address for Uri { - fn host(&self) -> &str { - self.host().unwrap_or("") - } - - fn port(&self) -> Option { - if let Some(port) = self.port_u16() { - Some(port) - } else { - port(self.scheme_str()) - } - } -} - -// TODO: load data from file -fn port(scheme: Option<&str>) -> Option { - if let Some(scheme) = scheme { - match scheme { - "http" => Some(80), - "https" => Some(443), - "ws" => Some(80), - "wss" => Some(443), - "amqp" => Some(5672), - "amqps" => Some(5671), - "sb" => Some(5671), - "mqtt" => Some(1883), - "mqtts" => Some(8883), - _ => None, - } - } else { - None - } -} diff --git a/actix-macros/CHANGES.md b/actix-macros/CHANGES.md index 9f5977c4..e5245775 100644 --- a/actix-macros/CHANGES.md +++ b/actix-macros/CHANGES.md @@ -1,13 +1,27 @@ -# CHANGES +# Changes -## 0.1.3 - 2020-12-3 +## Unreleased - 2021-xx-xx + + +## 0.2.0 - 2021-02-02 +* Update to latest `actix_rt::System::new` signature. [#261] + +[#261]: https://github.com/actix/actix-net/pull/261 + + +## 0.2.0-beta.1 - 2021-01-09 +* Remove `actix-reexport` feature. [#218] + +[#218]: https://github.com/actix/actix-net/pull/218 + + +## 0.1.3 - 2020-12-03 +* Add `actix-reexport` feature. [#218] + +[#218]: https://github.com/actix/actix-net/pull/218 -* Add `actix-reexport` feature ## 0.1.2 - 2020-05-18 - -### Changed - * Forward actix_rt::test arguments to test function [#127] [#127]: https://github.com/actix/actix-net/pull/127 diff --git a/actix-macros/Cargo.toml b/actix-macros/Cargo.toml index 1181ace5..0555f990 100644 --- a/actix-macros/Cargo.toml +++ b/actix-macros/Cargo.toml @@ -1,10 +1,10 @@ [package] name = "actix-macros" -version = "0.1.3" +version = "0.2.0" authors = ["Nikolay Kim "] -description = "Actix runtime macros" -repository = "https://github.com/actix/actix-net" -documentation = "https://docs.rs/actix-macros/" +description = "Macros for Actix system and runtime" +repository = "https://github.com/actix/actix-net.git" +documentation = "https://docs.rs/actix-macros" categories = ["network-programming", "asynchronous"] license = "MIT OR Apache-2.0" edition = "2018" @@ -16,11 +16,8 @@ proc-macro = true quote = "1.0.3" syn = { version = "^1", features = ["full"] } -[features] -actix-reexport = [] - [dev-dependencies] -actix-rt = "1.0" +actix-rt = "2.0.0" futures-util = { version = "0.3", default-features = false } trybuild = "1" diff --git a/actix-macros/src/lib.rs b/actix-macros/src/lib.rs index fc655a64..0d634a59 100644 --- a/actix-macros/src/lib.rs +++ b/actix-macros/src/lib.rs @@ -1,4 +1,12 @@ -//! Macros for use with Tokio +//! Macros for Actix system and runtime. +//! +//! The [`actix-rt`](https://docs.rs/actix-rt) crate must be available for macro output to compile. +//! +//! # Entry-point +//! See docs for the [`#[main]`](macro@main) macro. +//! +//! # Tests +//! See docs for the [`#[test]`](macro@test) macro. #![deny(rust_2018_idioms, nonstandard_style)] #![doc(html_logo_url = "https://actix.rs/img/logo.png")] @@ -7,11 +15,10 @@ use proc_macro::TokenStream; use quote::quote; -/// Marks async function to be executed by actix system. +/// Marks async entry-point function to be executed by Actix system. /// -/// ## Usage -/// -/// ```rust +/// # Examples +/// ``` /// #[actix_rt::main] /// async fn main() { /// println!("Hello world"); @@ -26,42 +33,32 @@ pub fn main(_: TokenStream, item: TokenStream) -> TokenStream { let vis = &input.vis; let sig = &mut input.sig; let body = &input.block; - let name = &sig.ident; if sig.asyncness.is_none() { - return syn::Error::new_spanned(sig.fn_token, "only async fn is supported") - .to_compile_error() - .into(); + return syn::Error::new_spanned( + sig.fn_token, + "the async keyword is missing from the function declaration", + ) + .to_compile_error() + .into(); } sig.asyncness = None; - if cfg!(feature = "actix-reexport") { - (quote! { - #(#attrs)* - #vis #sig { - actix::System::new(stringify!(#name)) - .block_on(async move { #body }) - } - }) - .into() - } else { - (quote! { - #(#attrs)* - #vis #sig { - actix_rt::System::new(stringify!(#name)) - .block_on(async move { #body }) - } - }) - .into() - } + (quote! { + #(#attrs)* + #vis #sig { + actix_rt::System::new() + .block_on(async move { #body }) + } + }) + .into() } -/// Marks async test function to be executed by actix runtime. +/// Marks async test function to be executed in an Actix system. /// -/// ## Usage -/// -/// ```no_run +/// # Examples +/// ``` /// #[actix_rt::test] /// async fn my_test() { /// assert!(true); @@ -85,7 +82,7 @@ pub fn test(_: TokenStream, item: TokenStream) -> TokenStream { if sig.asyncness.is_none() { return syn::Error::new_spanned( input.sig.fn_token, - format!("only async fn is supported, {}", input.sig.ident), + "the async keyword is missing from the function declaration", ) .to_compile_error() .into(); @@ -93,24 +90,19 @@ pub fn test(_: TokenStream, item: TokenStream) -> TokenStream { sig.asyncness = None; - let result = if has_test_attr { - quote! { - #(#attrs)* - #vis #sig { - actix_rt::System::new("test") - .block_on(async { #body }) - } - } + let missing_test_attr = if has_test_attr { + quote!() } else { - quote! { - #[test] - #(#attrs)* - #vis #sig { - actix_rt::System::new("test") - .block_on(async { #body }) - } - } + quote!(#[test]) }; - result.into() + (quote! { + #missing_test_attr + #(#attrs)* + #vis #sig { + actix_rt::System::new() + .block_on(async { #body }) + } + }) + .into() } diff --git a/actix-macros/tests/trybuild.rs b/actix-macros/tests/trybuild.rs index d944e3a2..a726d3bd 100644 --- a/actix-macros/tests/trybuild.rs +++ b/actix-macros/tests/trybuild.rs @@ -3,7 +3,9 @@ fn compile_macros() { let t = trybuild::TestCases::new(); t.pass("tests/trybuild/main-01-basic.rs"); t.compile_fail("tests/trybuild/main-02-only-async.rs"); + t.pass("tests/trybuild/main-03-fn-params.rs"); t.pass("tests/trybuild/test-01-basic.rs"); t.pass("tests/trybuild/test-02-keep-attrs.rs"); + t.compile_fail("tests/trybuild/test-03-only-async.rs"); } diff --git a/actix-macros/tests/trybuild/main-02-only-async.stderr b/actix-macros/tests/trybuild/main-02-only-async.stderr index e5e44492..fc060071 100644 --- a/actix-macros/tests/trybuild/main-02-only-async.stderr +++ b/actix-macros/tests/trybuild/main-02-only-async.stderr @@ -1,4 +1,4 @@ -error: only async fn is supported +error: the async keyword is missing from the function declaration --> $DIR/main-02-only-async.rs:2:1 | 2 | fn main() { diff --git a/actix-macros/tests/trybuild/main-03-fn-params.rs b/actix-macros/tests/trybuild/main-03-fn-params.rs new file mode 100644 index 00000000..3f83b4b6 --- /dev/null +++ b/actix-macros/tests/trybuild/main-03-fn-params.rs @@ -0,0 +1,6 @@ +#[actix_rt::main] +async fn main2(_param: bool) { + futures_util::future::ready(()).await +} + +fn main() {} diff --git a/actix-macros/tests/trybuild/test-03-only-async.rs b/actix-macros/tests/trybuild/test-03-only-async.rs new file mode 100644 index 00000000..436ff460 --- /dev/null +++ b/actix-macros/tests/trybuild/test-03-only-async.rs @@ -0,0 +1,6 @@ +#[actix_rt::test] +fn my_test() { + futures_util::future::ready(()).await +} + +fn main() {} diff --git a/actix-macros/tests/trybuild/test-03-only-async.stderr b/actix-macros/tests/trybuild/test-03-only-async.stderr new file mode 100644 index 00000000..4d8190a5 --- /dev/null +++ b/actix-macros/tests/trybuild/test-03-only-async.stderr @@ -0,0 +1,5 @@ +error: the async keyword is missing from the function declaration + --> $DIR/test-03-only-async.rs:2:1 + | +2 | fn my_test() { + | ^^ diff --git a/router/CHANGES.md b/actix-router/CHANGES.md similarity index 74% rename from router/CHANGES.md rename to actix-router/CHANGES.md index bb148c87..4c19aedc 100644 --- a/router/CHANGES.md +++ b/actix-router/CHANGES.md @@ -1,6 +1,18 @@ # Changes -## Unreleased - 2020-xx-xx +## Unreleased - 2021-xx-xx + + +## 0.2.7 - 2021-02-06 +* Add `Router::recognize_checked` [#247] + +[#247]: https://github.com/actix/actix-net/pull/247 + + +## 0.2.6 - 2021-01-09 +* Use `bytestring` version range compatible with Bytes v1.0. [#246] + +[#246]: https://github.com/actix/actix-net/pull/246 ## 0.2.5 - 2020-09-20 diff --git a/router/Cargo.toml b/actix-router/Cargo.toml similarity index 69% rename from router/Cargo.toml rename to actix-router/Cargo.toml index fe553e27..f55c2c38 100644 --- a/router/Cargo.toml +++ b/actix-router/Cargo.toml @@ -1,12 +1,12 @@ [package] name = "actix-router" -version = "0.2.5" +version = "0.2.7" authors = ["Nikolay Kim "] description = "Resource path matching library" -keywords = ["actix"] +keywords = ["actix", "router", "routing"] homepage = "https://actix.rs" repository = "https://github.com/actix/actix-net.git" -documentation = "https://docs.rs/actix-router/" +documentation = "https://docs.rs/actix-router" license = "MIT OR Apache-2.0" edition = "2018" @@ -20,10 +20,10 @@ default = ["http"] [dependencies] regex = "1.3.1" serde = "1.0.104" -bytestring = "0.1.2" +bytestring = ">=0.1.5, <2" log = "0.4.8" -http = { version = "0.2.0", optional = true } +http = { version = "0.2.2", optional = true } [dev-dependencies] -http = "0.2.0" +http = "0.2.2" serde_derive = "1.0" diff --git a/actix-connect/LICENSE-APACHE b/actix-router/LICENSE-APACHE similarity index 100% rename from actix-connect/LICENSE-APACHE rename to actix-router/LICENSE-APACHE diff --git a/actix-connect/LICENSE-MIT b/actix-router/LICENSE-MIT similarity index 100% rename from actix-connect/LICENSE-MIT rename to actix-router/LICENSE-MIT diff --git a/router/src/de.rs b/actix-router/src/de.rs similarity index 100% rename from router/src/de.rs rename to actix-router/src/de.rs diff --git a/router/src/lib.rs b/actix-router/src/lib.rs similarity index 100% rename from router/src/lib.rs rename to actix-router/src/lib.rs diff --git a/router/src/path.rs b/actix-router/src/path.rs similarity index 100% rename from router/src/path.rs rename to actix-router/src/path.rs index 0998c614..76fd97da 100644 --- a/router/src/path.rs +++ b/actix-router/src/path.rs @@ -50,20 +50,20 @@ impl Path { } } - #[inline] /// Get reference to inner path instance + #[inline] pub fn get_ref(&self) -> &T { &self.path } - #[inline] /// Get mutable reference to inner path instance + #[inline] pub fn get_mut(&mut self) -> &mut T { &mut self.path } - #[inline] /// Path + #[inline] pub fn path(&self) -> &str { let skip = self.skip as usize; let path = self.path.path(); @@ -74,23 +74,23 @@ impl Path { } } - #[inline] /// Set new path + #[inline] pub fn set(&mut self, path: T) { self.skip = 0; self.path = path; self.segments.clear(); } - #[inline] /// Reset state + #[inline] pub fn reset(&mut self) { self.skip = 0; self.segments.clear(); } - #[inline] /// Skip first `n` chars in path + #[inline] pub fn skip(&mut self, n: u16) { self.skip += n; } @@ -109,14 +109,14 @@ impl Path { self.segments.push((name, PathItem::Static(value))); } - #[inline] /// Check if there are any matched patterns + #[inline] pub fn is_empty(&self) -> bool { self.segments.is_empty() } - #[inline] /// Check number of extracted parameters + #[inline] pub fn len(&self) -> usize { self.segments.len() } diff --git a/router/src/resource.rs b/actix-router/src/resource.rs similarity index 99% rename from router/src/resource.rs rename to actix-router/src/resource.rs index 2ab4ceb5..8dbef26c 100644 --- a/router/src/resource.rs +++ b/actix-router/src/resource.rs @@ -28,6 +28,7 @@ enum PatternElement { } #[derive(Clone, Debug)] +#[allow(clippy::large_enum_variant)] enum PatternType { Static(String), Prefix(String), @@ -154,8 +155,8 @@ impl ResourceDef { &self.pattern } - #[inline] /// Check if path matches this pattern. + #[inline] pub fn is_match(&self, path: &str) -> bool { match self.tp { PatternType::Static(ref s) => s == path, diff --git a/router/src/router.rs b/actix-router/src/router.rs similarity index 94% rename from router/src/router.rs rename to actix-router/src/router.rs index bcbe61f9..aeb1aa36 100644 --- a/router/src/router.rs +++ b/actix-router/src/router.rs @@ -45,6 +45,24 @@ impl Router { None } + pub fn recognize_checked( + &self, + resource: &mut R, + check: F, + ) -> Option<(&T, ResourceId)> + where + F: Fn(&R, &Option) -> bool, + R: Resource

, + P: ResourcePath, + { + for item in self.0.iter() { + if item.0.match_path_checked(resource, &check, &item.2) { + return Some((&item.1, ResourceId(item.0.id()))); + } + } + None + } + pub fn recognize_mut_checked( &mut self, resource: &mut R, diff --git a/router/src/url.rs b/actix-router/src/url.rs similarity index 100% rename from router/src/url.rs rename to actix-router/src/url.rs diff --git a/actix-rt/CHANGES.md b/actix-rt/CHANGES.md index 9b5fb636..6754ca33 100644 --- a/actix-rt/CHANGES.md +++ b/actix-rt/CHANGES.md @@ -1,11 +1,79 @@ # Changes -## Unreleased - 2020-xx-xx +## Unreleased - 2021-xx-xx + +## 2.0.2 - 2021-02-06 +* Add `Arbiter::handle` to get a handle of an owned Arbiter. [#274] +* Add `System::try_current` for situations where actix may or may not be running a System. [#275] + +[#274]: https://github.com/actix/actix-net/pull/274 +[#275]: https://github.com/actix/actix-net/pull/275 + + +## 2.0.1 - 2021-02-06 +* Expose `JoinError` from Tokio. [#271] + +[#271]: https://github.com/actix/actix-net/pull/271 + + +## 2.0.0 - 2021-02-02 +* Remove all Arbiter-local storage methods. [#262] +* Re-export `tokio::pin`. [#262] + +[#262]: https://github.com/actix/actix-net/pull/262 + + +## 2.0.0-beta.3 - 2021-01-31 +* Remove `run_in_tokio`, `attach_to_tokio` and `AsyncSystemRunner`. [#253] +* Return `JoinHandle` from `actix_rt::spawn`. [#253] +* Remove old `Arbiter::spawn`. Implementation is now inlined into `actix_rt::spawn`. [#253] +* Rename `Arbiter::{send => spawn}` and `Arbiter::{exec_fn => spawn_fn}`. [#253] +* Remove `Arbiter::exec`. [#253] +* Remove deprecated `Arbiter::local_join` and `Arbiter::is_running`. [#253] +* `Arbiter::spawn` now accepts !Unpin futures. [#256] +* `System::new` no longer takes arguments. [#257] +* Remove `System::with_current`. [#257] +* Remove `Builder`. [#257] +* Add `System::with_init` as replacement for `Builder::run`. [#257] +* Rename `System::{is_set => is_registered}`. [#257] +* Add `ArbiterHandle` for sending messages to non-current-thread arbiters. [#257]. +* `System::arbiter` now returns an `&ArbiterHandle`. [#257] +* `Arbiter::current` now returns an `ArbiterHandle` instead. [#257] +* `Arbiter::join` now takes self by value. [#257] + +[#253]: https://github.com/actix/actix-net/pull/253 +[#254]: https://github.com/actix/actix-net/pull/254 +[#256]: https://github.com/actix/actix-net/pull/256 +[#257]: https://github.com/actix/actix-net/pull/257 + + +## 2.0.0-beta.2 - 2021-01-09 +* Add `task` mod with re-export of `tokio::task::{spawn_blocking, yield_now, JoinHandle}` [#245] +* Add default "macros" feature to allow faster compile times when using `default-features=false`. + +[#245]: https://github.com/actix/actix-net/pull/245 + + +## 2.0.0-beta.1 - 2020-12-28 ### Added - * Add `System::attach_to_tokio` method. [#173] +### Changed +* Update `tokio` dependency to `1.0`. [#236] +* Rename `time` module `delay_for` to `sleep`, `delay_until` to `sleep_until`, `Delay` to `Sleep` + to stay aligned with Tokio's naming. [#236] +* Remove `'static` lifetime requirement for `Runtime::block_on` and `SystemRunner::block_on`. + * These methods now accept `&self` when calling. [#236] +* Remove `'static` lifetime requirement for `System::run` and `Builder::run`. [#236] +* `Arbiter::spawn` now panics when `System` is not in scope. [#207] + +### Fixed +* Fix work load issue by removing `PENDING` thread local. [#207] + +[#207]: https://github.com/actix/actix-net/pull/207 +[#236]: https://github.com/actix/actix-net/pull/236 + ## [1.1.1] - 2020-04-30 ### Fixed diff --git a/actix-rt/Cargo.toml b/actix-rt/Cargo.toml index 68bca814..7990e67d 100644 --- a/actix-rt/Cargo.toml +++ b/actix-rt/Cargo.toml @@ -1,12 +1,15 @@ [package] name = "actix-rt" -version = "1.1.1" -authors = ["Nikolay Kim "] -description = "Actix runtime" -keywords = ["network", "framework", "async", "futures"] +version = "2.0.2" +authors = [ + "Nikolay Kim ", + "Rob Ede ", +] +description = "Tokio-based single-threaded async runtime for the Actix ecosystem" +keywords = ["async", "futures", "io", "runtime"] homepage = "https://actix.rs" repository = "https://github.com/actix/actix-net.git" -documentation = "https://docs.rs/actix-rt/" +documentation = "https://docs.rs/actix-rt" categories = ["network-programming", "asynchronous"] license = "MIT OR Apache-2.0" edition = "2018" @@ -15,13 +18,16 @@ edition = "2018" name = "actix_rt" path = "src/lib.rs" +[features] +default = ["macros"] +macros = ["actix-macros"] + [dependencies] -actix-macros = "0.1.0" -copyless = "0.1.4" -futures-channel = "0.3.4" -futures-util = { version = "0.3.4", default-features = false, features = ["alloc"] } -smallvec = "1" -tokio = { version = "0.2.6", default-features = false, features = ["rt-core", "rt-util", "io-driver", "tcp", "uds", "udp", "time", "signal", "stream"] } +actix-macros = { version = "0.2.0", optional = true } + +futures-core = { version = "0.3", default-features = false } +tokio = { version = "1.2", features = ["rt", "net", "parking_lot", "signal", "sync", "time"] } [dev-dependencies] -tokio = { version = "0.2.6", features = ["full"] } +tokio = { version = "1.2", features = ["full"] } +hyper = { version = "0.14", default-features = false, features = ["server", "tcp", "http1"] } diff --git a/actix-rt/README.md b/actix-rt/README.md new file mode 100644 index 00000000..c29d563d --- /dev/null +++ b/actix-rt/README.md @@ -0,0 +1,5 @@ +# actix-rt + +> Tokio-based single-threaded async runtime for the Actix ecosystem. + +See crate documentation for more: https://docs.rs/actix-rt. diff --git a/actix-rt/examples/hyper.rs b/actix-rt/examples/hyper.rs new file mode 100644 index 00000000..8bad1b33 --- /dev/null +++ b/actix-rt/examples/hyper.rs @@ -0,0 +1,28 @@ +use hyper::service::{make_service_fn, service_fn}; +use hyper::{Body, Request, Response, Server}; +use std::convert::Infallible; +use std::net::SocketAddr; + +async fn handle(_req: Request) -> Result, Infallible> { + Ok(Response::new(Body::from("Hello World"))) +} + +fn main() { + actix_rt::System::with_tokio_rt(|| { + tokio::runtime::Builder::new_multi_thread() + .enable_all() + .build() + .unwrap() + }) + .block_on(async { + let make_service = + make_service_fn(|_conn| async { Ok::<_, Infallible>(service_fn(handle)) }); + + let server = + Server::bind(&SocketAddr::from(([127, 0, 0, 1], 3000))).serve(make_service); + + if let Err(e) = server.await { + eprintln!("server error: {}", e); + } + }) +} diff --git a/actix-rt/src/arbiter.rs b/actix-rt/src/arbiter.rs index 295d2624..9ff1419d 100644 --- a/actix-rt/src/arbiter.rs +++ b/actix-rt/src/arbiter.rs @@ -1,40 +1,30 @@ -use std::any::{Any, TypeId}; -use std::cell::{Cell, RefCell}; -use std::collections::HashMap; -use std::pin::Pin; -use std::sync::atomic::{AtomicUsize, Ordering}; -use std::task::{Context, Poll}; -use std::{fmt, thread}; - -use futures_channel::mpsc::{unbounded, UnboundedReceiver, UnboundedSender}; -use futures_channel::oneshot::{channel, Canceled, Sender}; -use futures_util::{ - future::{self, Future, FutureExt}, - stream::Stream, +use std::{ + cell::RefCell, + fmt, + future::Future, + pin::Pin, + sync::atomic::{AtomicUsize, Ordering}, + task::{Context, Poll}, + thread, }; -use crate::runtime::Runtime; -use crate::system::System; +use futures_core::ready; +use tokio::{sync::mpsc, task::LocalSet}; -use copyless::BoxHelper; - -use smallvec::SmallVec; -pub use tokio::task::JoinHandle; - -thread_local!( - static ADDR: RefCell> = RefCell::new(None); - static RUNNING: Cell = Cell::new(false); - static Q: RefCell>>>> = RefCell::new(Vec::new()); - static PENDING: RefCell; 8]>> = RefCell::new(SmallVec::new()); - static STORAGE: RefCell>> = RefCell::new(HashMap::new()); -); +use crate::{ + runtime::{default_tokio_runtime, Runtime}, + system::{System, SystemCommand}, +}; pub(crate) static COUNT: AtomicUsize = AtomicUsize::new(0); +thread_local!( + static HANDLE: RefCell> = RefCell::new(None); +); + pub(crate) enum ArbiterCommand { Stop, - Execute(Box + Unpin + Send>), - ExecuteFn(Box), + Execute(Pin + Send>>), } impl fmt::Debug for ArbiterCommand { @@ -42,427 +32,229 @@ impl fmt::Debug for ArbiterCommand { match self { ArbiterCommand::Stop => write!(f, "ArbiterCommand::Stop"), ArbiterCommand::Execute(_) => write!(f, "ArbiterCommand::Execute"), - ArbiterCommand::ExecuteFn(_) => write!(f, "ArbiterCommand::ExecuteFn"), } } } -#[derive(Debug)] -/// Arbiters provide an asynchronous execution environment for actors, functions -/// and futures. When an Arbiter is created, it spawns a new OS thread, and -/// hosts an event loop. Some Arbiter functions execute on the current thread. -pub struct Arbiter { - sender: UnboundedSender, - thread_handle: Option>, +/// A handle for sending spawn and stop messages to an [Arbiter]. +#[derive(Debug, Clone)] +pub struct ArbiterHandle { + tx: mpsc::UnboundedSender, } -impl Clone for Arbiter { - fn clone(&self) -> Self { - Self::with_sender(self.sender.clone()) - } -} - -impl Default for Arbiter { - fn default() -> Self { - Self::new() - } -} - -impl Arbiter { - pub(crate) fn new_system() -> Self { - let (tx, rx) = unbounded(); - - let arb = Arbiter::with_sender(tx); - ADDR.with(|cell| *cell.borrow_mut() = Some(arb.clone())); - RUNNING.with(|cell| cell.set(false)); - STORAGE.with(|cell| cell.borrow_mut().clear()); - Arbiter::spawn(ArbiterController { stop: None, rx }); - - arb +impl ArbiterHandle { + pub(crate) fn new(tx: mpsc::UnboundedSender) -> Self { + Self { tx } } - /// Returns the current thread's arbiter's address. If no Arbiter is present, then this - /// function will panic! - pub fn current() -> Arbiter { - ADDR.with(|cell| match *cell.borrow() { - Some(ref addr) => addr.clone(), - None => panic!("Arbiter is not running"), - }) - } - - /// Check if current arbiter is running. - pub fn is_running() -> bool { - RUNNING.with(|cell| cell.get()) - } - - /// Stop arbiter from continuing it's event loop. - pub fn stop(&self) { - let _ = self.sender.unbounded_send(ArbiterCommand::Stop); - } - - /// Spawn new thread and run event loop in spawned thread. - /// Returns address of newly created arbiter. - pub fn new() -> Arbiter { - let id = COUNT.fetch_add(1, Ordering::Relaxed); - let name = format!("actix-rt:worker:{}", id); - let sys = System::current(); - let (arb_tx, arb_rx) = unbounded(); - let arb_tx2 = arb_tx.clone(); - - let handle = thread::Builder::new() - .name(name.clone()) - .spawn(move || { - let mut rt = Runtime::new().expect("Can not create Runtime"); - let arb = Arbiter::with_sender(arb_tx); - - let (stop, stop_rx) = channel(); - RUNNING.with(|cell| cell.set(true)); - STORAGE.with(|cell| cell.borrow_mut().clear()); - - System::set_current(sys); - - // start arbiter controller - rt.spawn(ArbiterController { - stop: Some(stop), - rx: arb_rx, - }); - ADDR.with(|cell| *cell.borrow_mut() = Some(arb.clone())); - - // register arbiter - let _ = System::current() - .sys() - .unbounded_send(SystemCommand::RegisterArbiter(id, arb)); - - // run loop - let _ = rt.block_on(stop_rx).unwrap_or(1); - - // unregister arbiter - let _ = System::current() - .sys() - .unbounded_send(SystemCommand::UnregisterArbiter(id)); - }) - .unwrap_or_else(|err| { - panic!("Cannot spawn an arbiter's thread {:?}: {:?}", &name, err) - }); - - Arbiter { - sender: arb_tx2, - thread_handle: Some(handle), - } - } - - pub(crate) fn run_system(rt: Option<&Runtime>) { - RUNNING.with(|cell| cell.set(true)); - Q.with(|cell| { - let mut v = cell.borrow_mut(); - for fut in v.drain(..) { - if let Some(rt) = rt { - rt.spawn(fut); - } else { - tokio::task::spawn_local(fut); - } - } - }); - } - - pub(crate) fn stop_system() { - RUNNING.with(|cell| cell.set(false)); - } - - /// Spawn a future on the current thread. This does not create a new Arbiter - /// or Arbiter address, it is simply a helper for spawning futures on the current - /// thread. - pub fn spawn(future: F) + /// Send a future to the [Arbiter]'s thread and spawn it. + /// + /// If you require a result, include a response channel in the future. + /// + /// Returns true if future was sent successfully and false if the [Arbiter] has died. + pub fn spawn(&self, future: Fut) -> bool where - F: Future + 'static, + Fut: Future + Send + 'static, { - RUNNING.with(move |cell| { - if cell.get() { - // Spawn the future on running executor - let len = PENDING.with(move |cell| { - let mut p = cell.borrow_mut(); - p.push(tokio::task::spawn_local(future)); - p.len() - }); - if len > 7 { - // Before reaching the inline size - tokio::task::spawn_local(CleanupPending); - } - } else { - // Box the future and push it to the queue, this results in double boxing - // because the executor boxes the future again, but works for now - Q.with(move |cell| { - cell.borrow_mut().push(Pin::from(Box::alloc().init(future))) - }); - } - }); + self.tx + .send(ArbiterCommand::Execute(Box::pin(future))) + .is_ok() } - /// Executes a future on the current thread. This does not create a new Arbiter - /// or Arbiter address, it is simply a helper for executing futures on the current - /// thread. - pub fn spawn_fn(f: F) - where - F: FnOnce() -> R + 'static, - R: Future + 'static, - { - Arbiter::spawn(future::lazy(|_| f()).flatten()) - } - - /// Send a future to the Arbiter's thread, and spawn it. - pub fn send(&self, future: F) - where - F: Future + Send + Unpin + 'static, - { - let _ = self - .sender - .unbounded_send(ArbiterCommand::Execute(Box::new(future))); - } - - /// Send a function to the Arbiter's thread, and execute it. Any result from the function - /// is discarded. - pub fn exec_fn(&self, f: F) + /// Send a function to the [Arbiter]'s thread and execute it. + /// + /// Any result from the function is discarded. If you require a result, include a response + /// channel in the function. + /// + /// Returns true if function was sent successfully and false if the [Arbiter] has died. + pub fn spawn_fn(&self, f: F) -> bool where F: FnOnce() + Send + 'static, { - let _ = self - .sender - .unbounded_send(ArbiterCommand::ExecuteFn(Box::new(move || { - f(); - }))); + self.spawn(async { f() }) } - /// Send a function to the Arbiter's thread. This function will be executed asynchronously. - /// A future is created, and when resolved will contain the result of the function sent - /// to the Arbiters thread. - pub fn exec(&self, f: F) -> impl Future> - where - F: FnOnce() -> R + Send + 'static, - R: Send + 'static, - { - let (tx, rx) = channel(); - let _ = self - .sender - .unbounded_send(ArbiterCommand::ExecuteFn(Box::new(move || { - if !tx.is_canceled() { - let _ = tx.send(f()); - } - }))); - rx - } - - /// Set item to arbiter storage - pub fn set_item(item: T) { - STORAGE.with(move |cell| cell.borrow_mut().insert(TypeId::of::(), Box::new(item))); - } - - /// Check if arbiter storage contains item - pub fn contains_item() -> bool { - STORAGE.with(move |cell| cell.borrow().get(&TypeId::of::()).is_some()) - } - - /// Get a reference to a type previously inserted on this arbiter's storage. + /// Instruct [Arbiter] to stop processing it's event loop. /// - /// Panics is item is not inserted - pub fn get_item(mut f: F) -> R - where - F: FnMut(&T) -> R, - { - STORAGE.with(move |cell| { - let st = cell.borrow(); - let item = st - .get(&TypeId::of::()) - .and_then(|boxed| (&**boxed as &(dyn Any + 'static)).downcast_ref()) - .unwrap(); - f(item) - }) + /// Returns true if stop message was sent successfully and false if the [Arbiter] has + /// been dropped. + pub fn stop(&self) -> bool { + self.tx.send(ArbiterCommand::Stop).is_ok() } +} - /// Get a mutable reference to a type previously inserted on this arbiter's storage. +/// An Arbiter represents a thread that provides an asynchronous execution environment for futures +/// and functions. +/// +/// When an arbiter is created, it spawns a new [OS thread](thread), and hosts an event loop. +#[derive(Debug)] +pub struct Arbiter { + tx: mpsc::UnboundedSender, + thread_handle: thread::JoinHandle<()>, +} + +impl Arbiter { + /// Spawn a new Arbiter thread and start its event loop. /// - /// Panics is item is not inserted - pub fn get_mut_item(mut f: F) -> R + /// # Panics + /// Panics if a [System] is not registered on the current thread. + #[allow(clippy::new_without_default)] + pub fn new() -> Arbiter { + Self::with_tokio_rt(|| { + default_tokio_runtime().expect("Cannot create new Arbiter's Runtime.") + }) + } + + /// Spawn a new Arbiter using the [Tokio Runtime](tokio-runtime) returned from a closure. + /// + /// [tokio-runtime]: tokio::runtime::Runtime + #[doc(hidden)] + pub fn with_tokio_rt(runtime_factory: F) -> Arbiter where - F: FnMut(&mut T) -> R, + F: Fn() -> tokio::runtime::Runtime + Send + 'static, { - STORAGE.with(move |cell| { - let mut st = cell.borrow_mut(); - let item = st - .get_mut(&TypeId::of::()) - .and_then(|boxed| (&mut **boxed as &mut (dyn Any + 'static)).downcast_mut()) - .unwrap(); - f(item) - }) - } + let sys = System::current(); + let system_id = sys.id(); + let arb_id = COUNT.fetch_add(1, Ordering::Relaxed); - fn with_sender(sender: UnboundedSender) -> Self { - Self { - sender, - thread_handle: None, - } - } + let name = format!("actix-rt|system:{}|arbiter:{}", system_id, arb_id); + let (tx, rx) = mpsc::unbounded_channel(); - /// Wait for the event loop to stop by joining the underlying thread (if have Some). - pub fn join(&mut self) -> thread::Result<()> { - if let Some(thread_handle) = self.thread_handle.take() { - thread_handle.join() - } else { - Ok(()) - } - } + let (ready_tx, ready_rx) = std::sync::mpsc::channel::<()>(); - /// Returns a future that will be completed once all currently spawned futures - /// have completed. - pub fn local_join() -> impl Future { - PENDING.with(move |cell| { - let current = cell.replace(SmallVec::new()); - future::join_all(current).map(|_| ()) - }) - } -} + let thread_handle = thread::Builder::new() + .name(name.clone()) + .spawn({ + let tx = tx.clone(); + move || { + let rt = Runtime::from(runtime_factory()); + let hnd = ArbiterHandle::new(tx); -/// Future used for cleaning-up already finished `JoinHandle`s -/// from the `PENDING` list so the vector doesn't grow indefinitely -struct CleanupPending; + System::set_current(sys); -impl Future for CleanupPending { - type Output = (); + HANDLE.with(|cell| *cell.borrow_mut() = Some(hnd.clone())); - fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - PENDING.with(move |cell| { - let mut pending = cell.borrow_mut(); - let mut i = 0; - while i != pending.len() { - if Pin::new(&mut pending[i]).poll(cx).is_ready() { - pending.remove(i); - } else { - i += 1; + // register arbiter + let _ = System::current() + .tx() + .send(SystemCommand::RegisterArbiter(arb_id, hnd)); + + ready_tx.send(()).unwrap(); + + // run arbiter event processing loop + rt.block_on(ArbiterRunner { rx }); + + // deregister arbiter + let _ = System::current() + .tx() + .send(SystemCommand::DeregisterArbiter(arb_id)); } - } - }); + }) + .unwrap_or_else(|err| { + panic!("Cannot spawn Arbiter's thread: {:?}. {:?}", &name, err) + }); - Poll::Ready(()) + ready_rx.recv().unwrap(); + + Arbiter { tx, thread_handle } + } + + /// Sets up an Arbiter runner in a new System using the provided runtime local task set. + pub(crate) fn in_new_system(local: &LocalSet) -> ArbiterHandle { + let (tx, rx) = mpsc::unbounded_channel(); + + let hnd = ArbiterHandle::new(tx); + + HANDLE.with(|cell| *cell.borrow_mut() = Some(hnd.clone())); + + local.spawn_local(ArbiterRunner { rx }); + + hnd + } + + /// Return a handle to the this Arbiter's message sender. + pub fn handle(&self) -> ArbiterHandle { + ArbiterHandle::new(self.tx.clone()) + } + + /// Return a handle to the current thread's Arbiter's message sender. + /// + /// # Panics + /// Panics if no Arbiter is running on the current thread. + pub fn current() -> ArbiterHandle { + HANDLE.with(|cell| match *cell.borrow() { + Some(ref hnd) => hnd.clone(), + None => panic!("Arbiter is not running."), + }) + } + + /// Stop Arbiter from continuing it's event loop. + /// + /// Returns true if stop message was sent successfully and false if the Arbiter has been dropped. + pub fn stop(&self) -> bool { + self.tx.send(ArbiterCommand::Stop).is_ok() + } + + /// Send a future to the Arbiter's thread and spawn it. + /// + /// If you require a result, include a response channel in the future. + /// + /// Returns true if future was sent successfully and false if the Arbiter has died. + pub fn spawn(&self, future: Fut) -> bool + where + Fut: Future + Send + 'static, + { + self.tx + .send(ArbiterCommand::Execute(Box::pin(future))) + .is_ok() + } + + /// Send a function to the Arbiter's thread and execute it. + /// + /// Any result from the function is discarded. If you require a result, include a response + /// channel in the function. + /// + /// Returns true if function was sent successfully and false if the Arbiter has died. + pub fn spawn_fn(&self, f: F) -> bool + where + F: FnOnce() + Send + 'static, + { + self.spawn(async { f() }) + } + + /// Wait for Arbiter's event loop to complete. + /// + /// Joins the underlying OS thread handle. See [`JoinHandle::join`](thread::JoinHandle::join). + pub fn join(self) -> thread::Result<()> { + self.thread_handle.join() } } -struct ArbiterController { - stop: Option>, - rx: UnboundedReceiver, +/// A persistent future that processes [Arbiter] commands. +struct ArbiterRunner { + rx: mpsc::UnboundedReceiver, } -impl Drop for ArbiterController { - fn drop(&mut self) { - if thread::panicking() { - if System::current().stop_on_panic() { - eprintln!("Panic in Arbiter thread, shutting down system."); - System::current().stop_with_code(1) - } else { - eprintln!("Panic in Arbiter thread."); - } - } - } -} - -impl Future for ArbiterController { +impl Future for ArbiterRunner { type Output = (); fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + // process all items currently buffered in channel loop { - match Pin::new(&mut self.rx).poll_next(cx) { - Poll::Ready(None) => return Poll::Ready(()), - Poll::Ready(Some(item)) => match item { + match ready!(Pin::new(&mut self.rx).poll_recv(cx)) { + // channel closed; no more messages can be received + None => return Poll::Ready(()), + + // process arbiter command + Some(item) => match item { ArbiterCommand::Stop => { - if let Some(stop) = self.stop.take() { - let _ = stop.send(0); - }; return Poll::Ready(()); } - ArbiterCommand::Execute(fut) => { - let len = PENDING.with(move |cell| { - let mut p = cell.borrow_mut(); - p.push(tokio::task::spawn_local(fut)); - p.len() - }); - if len > 7 { - // Before reaching the inline size - tokio::task::spawn_local(CleanupPending); - } - } - ArbiterCommand::ExecuteFn(f) => { - f.call_box(); + ArbiterCommand::Execute(task_fut) => { + tokio::task::spawn_local(task_fut); } }, - Poll::Pending => return Poll::Pending, } } } } - -#[derive(Debug)] -pub(crate) enum SystemCommand { - Exit(i32), - RegisterArbiter(usize, Arbiter), - UnregisterArbiter(usize), -} - -#[derive(Debug)] -pub(crate) struct SystemArbiter { - stop: Option>, - commands: UnboundedReceiver, - arbiters: HashMap, -} - -impl SystemArbiter { - pub(crate) fn new(stop: Sender, commands: UnboundedReceiver) -> Self { - SystemArbiter { - commands, - stop: Some(stop), - arbiters: HashMap::new(), - } - } -} - -impl Future for SystemArbiter { - type Output = (); - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - loop { - match Pin::new(&mut self.commands).poll_next(cx) { - Poll::Ready(None) => return Poll::Ready(()), - Poll::Ready(Some(cmd)) => match cmd { - SystemCommand::Exit(code) => { - // stop arbiters - for arb in self.arbiters.values() { - arb.stop(); - } - // stop event loop - if let Some(stop) = self.stop.take() { - let _ = stop.send(code); - } - } - SystemCommand::RegisterArbiter(name, hnd) => { - self.arbiters.insert(name, hnd); - } - SystemCommand::UnregisterArbiter(name) => { - self.arbiters.remove(&name); - } - }, - Poll::Pending => return Poll::Pending, - } - } - } -} - -pub trait FnExec: Send + 'static { - fn call_box(self: Box); -} - -impl FnExec for F -where - F: FnOnce() + Send + 'static, -{ - #[allow(clippy::boxed_local)] - fn call_box(self: Box) { - (*self)() - } -} diff --git a/actix-rt/src/builder.rs b/actix-rt/src/builder.rs deleted file mode 100644 index f4d9b1bf..00000000 --- a/actix-rt/src/builder.rs +++ /dev/null @@ -1,191 +0,0 @@ -use std::borrow::Cow; -use std::io; - -use futures_channel::mpsc::unbounded; -use futures_channel::oneshot::{channel, Receiver}; -use futures_util::future::{lazy, Future, FutureExt}; -use tokio::task::LocalSet; - -use crate::arbiter::{Arbiter, SystemArbiter}; -use crate::runtime::Runtime; -use crate::system::System; - -/// Builder struct for a actix runtime. -/// -/// Either use `Builder::build` to create a system and start actors. -/// Alternatively, use `Builder::run` to start the tokio runtime and -/// run a function in its context. -pub struct Builder { - /// Name of the System. Defaults to "actix" if unset. - name: Cow<'static, str>, - - /// Whether the Arbiter will stop the whole System on uncaught panic. Defaults to false. - stop_on_panic: bool, -} - -impl Builder { - pub(crate) fn new() -> Self { - Builder { - name: Cow::Borrowed("actix"), - stop_on_panic: false, - } - } - - /// Sets the name of the System. - pub fn name>(mut self, name: T) -> Self { - self.name = Cow::Owned(name.into()); - self - } - - /// Sets the option 'stop_on_panic' which controls whether the System is stopped when an - /// uncaught panic is thrown from a worker thread. - /// - /// Defaults to false. - pub fn stop_on_panic(mut self, stop_on_panic: bool) -> Self { - self.stop_on_panic = stop_on_panic; - self - } - - /// Create new System. - /// - /// This method panics if it can not create tokio runtime - pub fn build(self) -> SystemRunner { - self.create_runtime(|| {}) - } - - /// Create new System that can run asynchronously. - /// - /// This method panics if it cannot start the system arbiter - pub(crate) fn build_async(self, local: &LocalSet) -> AsyncSystemRunner { - self.create_async_runtime(local) - } - - /// This function will start tokio runtime and will finish once the - /// `System::stop()` message get called. - /// Function `f` get called within tokio runtime context. - pub fn run(self, f: F) -> io::Result<()> - where - F: FnOnce() + 'static, - { - self.create_runtime(f).run() - } - - fn create_async_runtime(self, local: &LocalSet) -> AsyncSystemRunner { - let (stop_tx, stop) = channel(); - let (sys_sender, sys_receiver) = unbounded(); - - let system = System::construct(sys_sender, Arbiter::new_system(), self.stop_on_panic); - - // system arbiter - let arb = SystemArbiter::new(stop_tx, sys_receiver); - - // start the system arbiter - let _ = local.spawn_local(arb); - - AsyncSystemRunner { stop, system } - } - - fn create_runtime(self, f: F) -> SystemRunner - where - F: FnOnce() + 'static, - { - let (stop_tx, stop) = channel(); - let (sys_sender, sys_receiver) = unbounded(); - - let system = System::construct(sys_sender, Arbiter::new_system(), self.stop_on_panic); - - // system arbiter - let arb = SystemArbiter::new(stop_tx, sys_receiver); - - let mut rt = Runtime::new().unwrap(); - rt.spawn(arb); - - // init system arbiter and run configuration method - rt.block_on(lazy(move |_| f())); - - SystemRunner { rt, stop, system } - } -} - -#[derive(Debug)] -pub(crate) struct AsyncSystemRunner { - stop: Receiver, - system: System, -} - -impl AsyncSystemRunner { - /// This function will start event loop and returns a future that - /// resolves once the `System::stop()` function is called. - pub(crate) fn run_nonblocking(self) -> impl Future> + Send { - let AsyncSystemRunner { stop, .. } = self; - - // run loop - lazy(|_| { - Arbiter::run_system(None); - async { - let res = match stop.await { - Ok(code) => { - if code != 0 { - Err(io::Error::new( - io::ErrorKind::Other, - format!("Non-zero exit code: {}", code), - )) - } else { - Ok(()) - } - } - Err(e) => Err(io::Error::new(io::ErrorKind::Other, e)), - }; - Arbiter::stop_system(); - res - } - }) - .flatten() - } -} - -/// Helper object that runs System's event loop -#[must_use = "SystemRunner must be run"] -#[derive(Debug)] -pub struct SystemRunner { - rt: Runtime, - stop: Receiver, - system: System, -} - -impl SystemRunner { - /// This function will start event loop and will finish once the - /// `System::stop()` function is called. - pub fn run(self) -> io::Result<()> { - let SystemRunner { mut rt, stop, .. } = self; - - // run loop - Arbiter::run_system(Some(&rt)); - let result = match rt.block_on(stop) { - Ok(code) => { - if code != 0 { - Err(io::Error::new( - io::ErrorKind::Other, - format!("Non-zero exit code: {}", code), - )) - } else { - Ok(()) - } - } - Err(e) => Err(io::Error::new(io::ErrorKind::Other, e)), - }; - Arbiter::stop_system(); - result - } - - /// Execute a future and wait for result. - pub fn block_on(&mut self, fut: F) -> O - where - F: Future + 'static, - { - Arbiter::run_system(Some(&self.rt)); - let res = self.rt.block_on(fut); - Arbiter::stop_system(); - res - } -} diff --git a/actix-rt/src/lib.rs b/actix-rt/src/lib.rs index dccd9202..a7e9f309 100644 --- a/actix-rt/src/lib.rs +++ b/actix-rt/src/lib.rs @@ -1,65 +1,107 @@ -//! A runtime implementation that runs everything on the current thread. +//! Tokio-based single-threaded async runtime for the Actix ecosystem. +//! +//! In most parts of the the Actix ecosystem, it has been chosen to use !Send futures. For this +//! reason, a single-threaded runtime is appropriate since it is guaranteed that futures will not +//! be moved between threads. This can result in small performance improvements over cases where +//! atomics would otherwise be needed. +//! +//! To achieve similar performance to multi-threaded, work-stealing runtimes, applications +//! using `actix-rt` will create multiple, mostly disconnected, single-threaded runtimes. +//! This approach has good performance characteristics for workloads where the majority of tasks +//! have similar runtime expense. +//! +//! The disadvantage is that idle threads will not steal work from very busy, stuck or otherwise +//! backlogged threads. Tasks that are disproportionately expensive should be offloaded to the +//! blocking task thread-pool using [`task::spawn_blocking`]. +//! +//! # Examples +//! ``` +//! use std::sync::mpsc; +//! use actix_rt::{Arbiter, System}; +//! +//! let _ = System::new(); +//! +//! let (tx, rx) = mpsc::channel::(); +//! +//! let arbiter = Arbiter::new(); +//! arbiter.spawn_fn(move || tx.send(42).unwrap()); +//! +//! let num = rx.recv().unwrap(); +//! assert_eq!(num, 42); +//! +//! arbiter.stop(); +//! arbiter.join().unwrap(); +//! ``` + #![deny(rust_2018_idioms, nonstandard_style)] #![allow(clippy::type_complexity)] +#![warn(missing_docs)] #![doc(html_logo_url = "https://actix.rs/img/logo.png")] #![doc(html_favicon_url = "https://actix.rs/favicon.ico")] -#[cfg(not(test))] // Work around for rust-lang/rust#62127 +use std::future::Future; + +use tokio::task::JoinHandle; + +// Cannot define a main macro when compiled into test harness. +// Workaround for https://github.com/rust-lang/rust/issues/62127. +#[cfg(all(feature = "macros", not(test)))] pub use actix_macros::{main, test}; mod arbiter; -mod builder; mod runtime; mod system; -pub use self::arbiter::Arbiter; -pub use self::builder::{Builder, SystemRunner}; +pub use self::arbiter::{Arbiter, ArbiterHandle}; pub use self::runtime::Runtime; -pub use self::system::System; +pub use self::system::{System, SystemRunner}; -/// Spawns a future on the current arbiter. -/// -/// # Panics -/// -/// This function panics if actix system is not running. -pub fn spawn(f: F) -where - F: futures_util::future::Future + 'static, -{ - if !System::is_set() { - panic!("System is not running"); - } +pub use tokio::pin; - Arbiter::spawn(f); -} - -/// Asynchronous signal handling pub mod signal { + //! Asynchronous signal handling (Tokio re-exports). + #[cfg(unix)] pub mod unix { + //! Unix specific signals (Tokio re-exports). pub use tokio::signal::unix::*; } pub use tokio::signal::ctrl_c; } -/// TCP/UDP/Unix bindings pub mod net { + //! TCP/UDP/Unix bindings (Tokio re-exports). + pub use tokio::net::UdpSocket; pub use tokio::net::{TcpListener, TcpStream}; #[cfg(unix)] - mod unix { - pub use tokio::net::{UnixDatagram, UnixListener, UnixStream}; - } - - #[cfg(unix)] - pub use self::unix::*; + pub use tokio::net::{UnixDatagram, UnixListener, UnixStream}; } -/// Utilities for tracking time. pub mod time { + //! Utilities for tracking time (Tokio re-exports). + pub use tokio::time::Instant; - pub use tokio::time::{delay_for, delay_until, Delay}; pub use tokio::time::{interval, interval_at, Interval}; + pub use tokio::time::{sleep, sleep_until, Sleep}; pub use tokio::time::{timeout, Timeout}; } + +pub mod task { + //! Task management (Tokio re-exports). + + pub use tokio::task::{spawn_blocking, yield_now, JoinError, JoinHandle}; +} + +/// Spawns a future on the current thread. +/// +/// # Panics +/// Panics if Actix system is not running. +#[inline] +pub fn spawn(f: Fut) -> JoinHandle<()> +where + Fut: Future + 'static, +{ + tokio::task::spawn_local(f) +} diff --git a/actix-rt/src/runtime.rs b/actix-rt/src/runtime.rs index d3231192..1adbf6c0 100644 --- a/actix-rt/src/runtime.rs +++ b/actix-rt/src/runtime.rs @@ -1,28 +1,29 @@ -use std::future::Future; -use std::io; -use tokio::{runtime, task::LocalSet}; +use std::{future::Future, io}; -/// Single-threaded runtime provides a way to start reactor -/// and runtime on the current thread. +use tokio::task::{JoinHandle, LocalSet}; + +/// A Tokio-based runtime proxy. /// -/// See [module level][mod] documentation for more details. -/// -/// [mod]: crate +/// All spawned futures will be executed on the current thread. Therefore, there is no `Send` bound +/// on submitted futures. #[derive(Debug)] pub struct Runtime { local: LocalSet, - rt: runtime::Runtime, + rt: tokio::runtime::Runtime, +} + +pub(crate) fn default_tokio_runtime() -> io::Result { + tokio::runtime::Builder::new_current_thread() + .enable_io() + .enable_time() + .build() } impl Runtime { - #[allow(clippy::new_ret_no_self)] /// Returns a new runtime initialized with default configuration values. - pub fn new() -> io::Result { - let rt = runtime::Builder::new() - .enable_io() - .enable_time() - .basic_scheduler() - .build()?; + #[allow(clippy::new_ret_no_self)] + pub fn new() -> io::Result { + let rt = default_tokio_runtime()?; Ok(Runtime { rt, @@ -30,62 +31,66 @@ impl Runtime { }) } - /// Spawn a future onto the single-threaded runtime. + /// Reference to local task set. + pub(crate) fn local_set(&self) -> &LocalSet { + &self.local + } + + /// Offload a future onto the single-threaded runtime. /// - /// See [module level][mod] documentation for more details. + /// The returned join handle can be used to await the future's result. /// - /// [mod]: crate + /// See [crate root][crate] documentation for more details. /// /// # Examples - /// - /// ```rust,ignore - /// # use futures::{future, Future, Stream}; - /// use actix_rt::Runtime; - /// - /// # fn dox() { - /// // Create the runtime - /// let mut rt = Runtime::new().unwrap(); + /// ``` + /// let rt = actix_rt::Runtime::new().unwrap(); /// /// // Spawn a future onto the runtime - /// rt.spawn(future::lazy(|_| { + /// let handle = rt.spawn(async { /// println!("running on the runtime"); - /// })); - /// # } - /// # pub fn main() {} + /// 42 + /// }); + /// + /// assert_eq!(rt.block_on(handle).unwrap(), 42); /// ``` /// /// # Panics - /// - /// This function panics if the spawn fails. Failure occurs if the executor - /// is currently at capacity and is unable to spawn a new future. - pub fn spawn(&self, future: F) -> &Self - where - F: Future + 'static, - { - self.local.spawn_local(future); - self - } - - /// 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 will **also** execute any spawned futures on the - /// current thread, but will **not** block until these other spawned futures - /// have completed. Once the function returns, any uncompleted futures - /// remain pending in the `Runtime` instance. These futures will not run - /// until `block_on` or `run` is called again. - /// - /// The caller is responsible for ensuring that other spawned futures - /// complete execution by calling `block_on` or `run`. - pub fn block_on(&mut self, f: F) -> F::Output + /// This function panics if the spawn fails. Failure occurs if the executor is currently at + /// capacity and is unable to spawn a new future. + pub fn spawn(&self, future: F) -> JoinHandle where F: Future + 'static, { - self.local.block_on(&mut self.rt, f) + self.local.spawn_local(future) + } + + /// 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 will also execute any spawned futures on the current thread, but + /// will not block until these other spawned futures have completed. Once the function returns, + /// any uncompleted futures remain pending in the `Runtime` instance. These futures will not run + /// until `block_on` or `run` is called again. + /// + /// The caller is responsible for ensuring that other spawned futures complete execution by + /// calling `block_on` or `run`. + pub fn block_on(&self, f: F) -> F::Output + where + F: Future, + { + self.local.block_on(&self.rt, f) + } +} + +impl From for Runtime { + fn from(rt: tokio::runtime::Runtime) -> Self { + Self { + local: LocalSet::new(), + rt, + } } } diff --git a/actix-rt/src/system.rs b/actix-rt/src/system.rs index 2e1ae174..3bc8a6e3 100644 --- a/actix-rt/src/system.rs +++ b/actix-rt/src/system.rs @@ -1,195 +1,98 @@ -use std::cell::RefCell; -use std::future::Future; -use std::io; -use std::sync::atomic::{AtomicUsize, Ordering}; +use std::{ + cell::RefCell, + collections::HashMap, + future::Future, + io, + pin::Pin, + sync::atomic::{AtomicUsize, Ordering}, + task::{Context, Poll}, +}; -use futures_channel::mpsc::UnboundedSender; -use tokio::task::LocalSet; +use futures_core::ready; +use tokio::sync::{mpsc, oneshot}; -use crate::arbiter::{Arbiter, SystemCommand}; -use crate::builder::{Builder, SystemRunner}; +use crate::{arbiter::ArbiterHandle, runtime::default_tokio_runtime, Arbiter, Runtime}; static SYSTEM_COUNT: AtomicUsize = AtomicUsize::new(0); -/// System is a runtime manager. -#[derive(Clone, Debug)] -pub struct System { - id: usize, - sys: UnboundedSender, - arbiter: Arbiter, - stop_on_panic: bool, -} - thread_local!( static CURRENT: RefCell> = RefCell::new(None); ); +/// A manager for a per-thread distributed async runtime. +#[derive(Clone, Debug)] +pub struct System { + id: usize, + sys_tx: mpsc::UnboundedSender, + + /// Handle to the first [Arbiter] that is created with the System. + arbiter_handle: ArbiterHandle, +} + impl System { - /// Constructs new system and sets it as current + /// Create a new system. + /// + /// # Panics + /// Panics if underlying Tokio runtime can not be created. + #[allow(clippy::new_ret_no_self)] + pub fn new() -> SystemRunner { + Self::with_tokio_rt(|| { + default_tokio_runtime() + .expect("Default Actix (Tokio) runtime could not be created.") + }) + } + + /// Create a new System using the [Tokio Runtime](tokio-runtime) returned from a closure. + /// + /// [tokio-runtime]: tokio::runtime::Runtime + #[doc(hidden)] + pub fn with_tokio_rt(runtime_factory: F) -> SystemRunner + where + F: Fn() -> tokio::runtime::Runtime, + { + let (stop_tx, stop_rx) = oneshot::channel(); + let (sys_tx, sys_rx) = mpsc::unbounded_channel(); + + let rt = Runtime::from(runtime_factory()); + let sys_arbiter = Arbiter::in_new_system(rt.local_set()); + let system = System::construct(sys_tx, sys_arbiter.clone()); + + system + .tx() + .send(SystemCommand::RegisterArbiter(usize::MAX, sys_arbiter)) + .unwrap(); + + // init background system arbiter + let sys_ctrl = SystemController::new(sys_rx, stop_tx); + rt.spawn(sys_ctrl); + + SystemRunner { + rt, + stop_rx, + system, + } + } + + /// Constructs new system and registers it on the current thread. pub(crate) fn construct( - sys: UnboundedSender, - arbiter: Arbiter, - stop_on_panic: bool, + sys_tx: mpsc::UnboundedSender, + arbiter_handle: ArbiterHandle, ) -> Self { let sys = System { - sys, - arbiter, - stop_on_panic, + sys_tx, + arbiter_handle, id: SYSTEM_COUNT.fetch_add(1, Ordering::SeqCst), }; + System::set_current(sys.clone()); + sys } - /// Build a new system with a customized tokio runtime. - /// - /// This allows to customize the runtime. See struct level docs on - /// `Builder` for more information. - pub fn builder() -> Builder { - Builder::new() - } - - #[allow(clippy::new_ret_no_self)] - /// Create new system. - /// - /// This method panics if it can not create tokio runtime - pub fn new>(name: T) -> SystemRunner { - Self::builder().name(name).build() - } - - /// Create new system using provided tokio `LocalSet`. - /// - /// This method panics if it can not spawn system arbiter - /// - /// Note: This method uses provided `LocalSet` to create a `System` future only. - /// All the [`Arbiter`]s will be started in separate threads using their own tokio `Runtime`s. - /// It means that using this method currently it is impossible to make `actix-rt` work in the - /// alternative `tokio` `Runtime`s (e.g. provided by [`tokio_compat`]). - /// - /// [`tokio_compat`]: https://crates.io/crates/tokio-compat - /// - /// # Examples - /// - /// ``` - /// use tokio::{runtime::Runtime, task::LocalSet}; - /// use actix_rt::System; - /// use futures_util::future::try_join_all; - /// - /// async fn run_application() { - /// let first_task = tokio::spawn(async { - /// // ... - /// # println!("One task"); - /// # Ok::<(),()>(()) - /// }); - /// - /// let second_task = tokio::spawn(async { - /// // ... - /// # println!("Another task"); - /// # Ok::<(),()>(()) - /// }); - /// - /// try_join_all(vec![first_task, second_task]) - /// .await - /// .expect("Some of the futures finished unexpectedly"); - /// } - /// - /// - /// let mut runtime = tokio::runtime::Builder::new() - /// .core_threads(2) - /// .enable_all() - /// .threaded_scheduler() - /// .build() - /// .unwrap(); - /// - /// - /// let actix_system_task = LocalSet::new(); - /// let sys = System::run_in_tokio("actix-main-system", &actix_system_task); - /// actix_system_task.spawn_local(sys); - /// - /// let rest_operations = run_application(); - /// runtime.block_on(actix_system_task.run_until(rest_operations)); - /// ``` - pub fn run_in_tokio>( - name: T, - local: &LocalSet, - ) -> impl Future> { - Self::builder() - .name(name) - .build_async(local) - .run_nonblocking() - } - - /// Consume the provided tokio Runtime and start the `System` in it. - /// This method will create a `LocalSet` object and occupy the current thread - /// for the created `System` exclusively. All the other asynchronous tasks that - /// should be executed as well must be aggregated into one future, provided as the last - /// argument to this method. - /// - /// Note: This method uses provided `Runtime` to create a `System` future only. - /// All the [`Arbiter`]s will be started in separate threads using their own tokio `Runtime`s. - /// It means that using this method currently it is impossible to make `actix-rt` work in the - /// alternative `tokio` `Runtime`s (e.g. provided by `tokio_compat`). - /// - /// [`tokio_compat`]: https://crates.io/crates/tokio-compat - /// - /// # Arguments - /// - /// - `name`: Name of the System - /// - `runtime`: A tokio Runtime to run the system in. - /// - `rest_operations`: A future to be executed in the runtime along with the System. - /// - /// # Examples - /// - /// ``` - /// use tokio::runtime::Runtime; - /// use actix_rt::System; - /// use futures_util::future::try_join_all; - /// - /// async fn run_application() { - /// let first_task = tokio::spawn(async { - /// // ... - /// # println!("One task"); - /// # Ok::<(),()>(()) - /// }); - /// - /// let second_task = tokio::spawn(async { - /// // ... - /// # println!("Another task"); - /// # Ok::<(),()>(()) - /// }); - /// - /// try_join_all(vec![first_task, second_task]) - /// .await - /// .expect("Some of the futures finished unexpectedly"); - /// } - /// - /// - /// let runtime = tokio::runtime::Builder::new() - /// .core_threads(2) - /// .enable_all() - /// .threaded_scheduler() - /// .build() - /// .unwrap(); - /// - /// let rest_operations = run_application(); - /// System::attach_to_tokio("actix-main-system", runtime, rest_operations); - /// ``` - pub fn attach_to_tokio( - name: impl Into, - mut runtime: tokio::runtime::Runtime, - rest_operations: Fut, - ) -> R - where - Fut: std::future::Future, - { - let actix_system_task = LocalSet::new(); - let sys = System::run_in_tokio(name.into(), &actix_system_task); - actix_system_task.spawn_local(sys); - - runtime.block_on(actix_system_task.run_until(rest_operations)) - } - /// Get current running system. + /// + /// # Panics + /// Panics if no system is registered on the current thread. pub fn current() -> System { CURRENT.with(|cell| match *cell.borrow() { Some(ref sys) => sys.clone(), @@ -197,67 +100,156 @@ impl System { }) } - /// Check if current system is set, i.e., as already been started. - pub fn is_set() -> bool { - CURRENT.with(|cell| cell.borrow().is_some()) + /// Try to get current running system. + /// + /// Returns `None` if no System has been started. + /// + /// Contrary to `current`, this never panics. + pub fn try_current() -> Option { + CURRENT.with(|cell| cell.borrow().clone()) } - /// Set current running system. + /// Get handle to a the System's initial [Arbiter]. + pub fn arbiter(&self) -> &ArbiterHandle { + &self.arbiter_handle + } + + /// Check if there is a System registered on the current thread. + pub fn is_registered() -> bool { + CURRENT.with(|sys| sys.borrow().is_some()) + } + + /// Register given system on current thread. #[doc(hidden)] pub fn set_current(sys: System) { - CURRENT.with(|s| { - *s.borrow_mut() = Some(sys); + CURRENT.with(|cell| { + *cell.borrow_mut() = Some(sys); }) } - /// Execute function with system reference. - pub fn with_current(f: F) -> R - where - F: FnOnce(&System) -> R, - { - CURRENT.with(|cell| match *cell.borrow() { - Some(ref sys) => f(sys), - None => panic!("System is not running"), - }) - } - - /// System id + /// Numeric system identifier. + /// + /// Useful when using multiple Systems. pub fn id(&self) -> usize { self.id } - /// Stop the system + /// Stop the system (with code 0). pub fn stop(&self) { self.stop_with_code(0) } - /// Stop the system with a particular exit code. + /// Stop the system with a given exit code. pub fn stop_with_code(&self, code: i32) { - let _ = self.sys.unbounded_send(SystemCommand::Exit(code)); + let _ = self.sys_tx.send(SystemCommand::Exit(code)); } - pub(crate) fn sys(&self) -> &UnboundedSender { - &self.sys - } - - /// Return status of 'stop_on_panic' option which controls whether the System is stopped when an - /// uncaught panic is thrown from a worker thread. - pub fn stop_on_panic(&self) -> bool { - self.stop_on_panic - } - - /// System arbiter - pub fn arbiter(&self) -> &Arbiter { - &self.arbiter - } - - /// This function will start tokio runtime and will finish once the - /// `System::stop()` message get called. - /// Function `f` get called within tokio runtime context. - pub fn run(f: F) -> io::Result<()> - where - F: FnOnce() + 'static, - { - Self::builder().run(f) + pub(crate) fn tx(&self) -> &mpsc::UnboundedSender { + &self.sys_tx + } +} + +/// Runner that keeps a [System]'s event loop alive until stop message is received. +#[must_use = "A SystemRunner does nothing unless `run` is called."] +#[derive(Debug)] +pub struct SystemRunner { + rt: Runtime, + stop_rx: oneshot::Receiver, + system: System, +} + +impl SystemRunner { + /// Starts event loop and will return once [System] is [stopped](System::stop). + pub fn run(self) -> io::Result<()> { + let SystemRunner { rt, stop_rx, .. } = self; + + // run loop + match rt.block_on(stop_rx) { + Ok(code) => { + if code != 0 { + Err(io::Error::new( + io::ErrorKind::Other, + format!("Non-zero exit code: {}", code), + )) + } else { + Ok(()) + } + } + + Err(e) => Err(io::Error::new(io::ErrorKind::Other, e)), + } + } + + /// Runs the provided future, blocking the current thread until the future completes. + #[inline] + pub fn block_on(&self, fut: F) -> F::Output { + self.rt.block_on(fut) + } +} + +#[derive(Debug)] +pub(crate) enum SystemCommand { + Exit(i32), + RegisterArbiter(usize, ArbiterHandle), + DeregisterArbiter(usize), +} + +/// There is one `SystemController` per [System]. It runs in the background, keeping track of +/// [Arbiter]s and is able to distribute a system-wide stop command. +#[derive(Debug)] +pub(crate) struct SystemController { + stop_tx: Option>, + cmd_rx: mpsc::UnboundedReceiver, + arbiters: HashMap, +} + +impl SystemController { + pub(crate) fn new( + cmd_rx: mpsc::UnboundedReceiver, + stop_tx: oneshot::Sender, + ) -> Self { + SystemController { + cmd_rx, + stop_tx: Some(stop_tx), + arbiters: HashMap::with_capacity(4), + } + } +} + +impl Future for SystemController { + type Output = (); + + fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + // process all items currently buffered in channel + loop { + match ready!(Pin::new(&mut self.cmd_rx).poll_recv(cx)) { + // channel closed; no more messages can be received + None => return Poll::Ready(()), + + // process system command + Some(cmd) => match cmd { + SystemCommand::Exit(code) => { + // stop all arbiters + for arb in self.arbiters.values() { + arb.stop(); + } + + // stop event loop + // will only fire once + if let Some(stop_tx) = self.stop_tx.take() { + let _ = stop_tx.send(code); + } + } + + SystemCommand::RegisterArbiter(id, arb) => { + self.arbiters.insert(id, arb); + } + + SystemCommand::DeregisterArbiter(id) => { + self.arbiters.remove(&id); + } + }, + } + } } } diff --git a/actix-rt/tests/integration_tests.rs b/actix-rt/tests/integration_tests.rs deleted file mode 100644 index 8e775bab..00000000 --- a/actix-rt/tests/integration_tests.rs +++ /dev/null @@ -1,114 +0,0 @@ -use std::time::{Duration, Instant}; - -#[test] -fn start_and_stop() { - actix_rt::System::new("start_and_stop").block_on(async move { - assert!( - actix_rt::Arbiter::is_running(), - "System doesn't seem to have started" - ); - }); - assert!( - !actix_rt::Arbiter::is_running(), - "System doesn't seem to have stopped" - ); -} - -#[test] -fn await_for_timer() { - let time = Duration::from_secs(2); - let instant = Instant::now(); - actix_rt::System::new("test_wait_timer").block_on(async move { - tokio::time::delay_for(time).await; - }); - assert!( - instant.elapsed() >= time, - "Block on should poll awaited future to completion" - ); -} - -#[test] -fn join_another_arbiter() { - let time = Duration::from_secs(2); - let instant = Instant::now(); - actix_rt::System::new("test_join_another_arbiter").block_on(async move { - let mut arbiter = actix_rt::Arbiter::new(); - arbiter.send(Box::pin(async move { - tokio::time::delay_for(time).await; - actix_rt::Arbiter::current().stop(); - })); - arbiter.join().unwrap(); - }); - assert!( - instant.elapsed() >= time, - "Join on another arbiter should complete only when it calls stop" - ); - - let instant = Instant::now(); - actix_rt::System::new("test_join_another_arbiter").block_on(async move { - let mut arbiter = actix_rt::Arbiter::new(); - arbiter.exec_fn(move || { - actix_rt::spawn(async move { - tokio::time::delay_for(time).await; - actix_rt::Arbiter::current().stop(); - }); - }); - arbiter.join().unwrap(); - }); - assert!( - instant.elapsed() >= time, - "Join on a arbiter that has used actix_rt::spawn should wait for said future" - ); - - let instant = Instant::now(); - actix_rt::System::new("test_join_another_arbiter").block_on(async move { - let mut arbiter = actix_rt::Arbiter::new(); - arbiter.send(Box::pin(async move { - tokio::time::delay_for(time).await; - actix_rt::Arbiter::current().stop(); - })); - arbiter.stop(); - arbiter.join().unwrap(); - }); - assert!( - instant.elapsed() < time, - "Premature stop of arbiter should conclude regardless of it's current state" - ); -} - -#[test] -fn join_current_arbiter() { - let time = Duration::from_secs(2); - - let instant = Instant::now(); - actix_rt::System::new("test_join_current_arbiter").block_on(async move { - actix_rt::spawn(async move { - tokio::time::delay_for(time).await; - actix_rt::Arbiter::current().stop(); - }); - actix_rt::Arbiter::local_join().await; - }); - assert!( - instant.elapsed() >= time, - "Join on current arbiter should wait for all spawned futures" - ); - - let large_timer = Duration::from_secs(20); - let instant = Instant::now(); - actix_rt::System::new("test_join_current_arbiter").block_on(async move { - actix_rt::spawn(async move { - tokio::time::delay_for(time).await; - actix_rt::Arbiter::current().stop(); - }); - let f = actix_rt::Arbiter::local_join(); - actix_rt::spawn(async move { - tokio::time::delay_for(large_timer).await; - actix_rt::Arbiter::current().stop(); - }); - f.await; - }); - assert!( - instant.elapsed() < large_timer, - "local_join should await only for the already spawned futures" - ); -} diff --git a/actix-rt/tests/tests.rs b/actix-rt/tests/tests.rs new file mode 100644 index 00000000..86fba96d --- /dev/null +++ b/actix-rt/tests/tests.rs @@ -0,0 +1,300 @@ +use std::{ + sync::{ + atomic::{AtomicBool, Ordering}, + mpsc::channel, + Arc, + }, + thread, + time::{Duration, Instant}, +}; + +use actix_rt::{Arbiter, System}; +use tokio::sync::oneshot; + +#[test] +fn await_for_timer() { + let time = Duration::from_secs(1); + let instant = Instant::now(); + System::new().block_on(async move { + tokio::time::sleep(time).await; + }); + assert!( + instant.elapsed() >= time, + "Block on should poll awaited future to completion" + ); +} + +#[test] +fn join_another_arbiter() { + let time = Duration::from_secs(1); + let instant = Instant::now(); + System::new().block_on(async move { + let arbiter = Arbiter::new(); + arbiter.spawn(Box::pin(async move { + tokio::time::sleep(time).await; + Arbiter::current().stop(); + })); + arbiter.join().unwrap(); + }); + assert!( + instant.elapsed() >= time, + "Join on another arbiter should complete only when it calls stop" + ); + + let instant = Instant::now(); + System::new().block_on(async move { + let arbiter = Arbiter::new(); + arbiter.spawn_fn(move || { + actix_rt::spawn(async move { + tokio::time::sleep(time).await; + Arbiter::current().stop(); + }); + }); + arbiter.join().unwrap(); + }); + assert!( + instant.elapsed() >= time, + "Join on an arbiter that has used actix_rt::spawn should wait for said future" + ); + + let instant = Instant::now(); + System::new().block_on(async move { + let arbiter = Arbiter::new(); + arbiter.spawn(Box::pin(async move { + tokio::time::sleep(time).await; + Arbiter::current().stop(); + })); + arbiter.stop(); + arbiter.join().unwrap(); + }); + assert!( + instant.elapsed() < time, + "Premature stop of arbiter should conclude regardless of it's current state" + ); +} + +#[test] +fn non_static_block_on() { + let string = String::from("test_str"); + let string = string.as_str(); + + let sys = System::new(); + + sys.block_on(async { + actix_rt::time::sleep(Duration::from_millis(1)).await; + assert_eq!("test_str", string); + }); + + let rt = actix_rt::Runtime::new().unwrap(); + + rt.block_on(async { + actix_rt::time::sleep(Duration::from_millis(1)).await; + assert_eq!("test_str", string); + }); +} + +#[test] +fn wait_for_spawns() { + let rt = actix_rt::Runtime::new().unwrap(); + + let handle = rt.spawn(async { + println!("running on the runtime"); + // assertion panic is caught at task boundary + assert_eq!(1, 2); + }); + + assert!(rt.block_on(handle).is_err()); +} + +#[test] +fn arbiter_spawn_fn_runs() { + let _ = System::new(); + + let (tx, rx) = channel::(); + + let arbiter = Arbiter::new(); + arbiter.spawn_fn(move || tx.send(42).unwrap()); + + let num = rx.recv().unwrap(); + assert_eq!(num, 42); + + arbiter.stop(); + arbiter.join().unwrap(); +} + +#[test] +fn arbiter_handle_spawn_fn_runs() { + let sys = System::new(); + + let (tx, rx) = channel::(); + + let arbiter = Arbiter::new(); + let handle = arbiter.handle(); + drop(arbiter); + + handle.spawn_fn(move || { + tx.send(42).unwrap(); + System::current().stop() + }); + + let num = rx.recv_timeout(Duration::from_secs(2)).unwrap(); + assert_eq!(num, 42); + + handle.stop(); + sys.run().unwrap(); +} + +#[test] +fn arbiter_drop_no_panic_fn() { + let _ = System::new(); + + let arbiter = Arbiter::new(); + arbiter.spawn_fn(|| panic!("test")); + + arbiter.stop(); + arbiter.join().unwrap(); +} + +#[test] +fn arbiter_drop_no_panic_fut() { + let _ = System::new(); + + let arbiter = Arbiter::new(); + arbiter.spawn(async { panic!("test") }); + + arbiter.stop(); + arbiter.join().unwrap(); +} + +#[test] +#[should_panic] +fn no_system_current_panic() { + System::current(); +} + +#[test] +#[should_panic] +fn no_system_arbiter_new_panic() { + Arbiter::new(); +} + +#[test] +fn system_arbiter_spawn() { + let runner = System::new(); + + let (tx, rx) = oneshot::channel(); + let sys = System::current(); + + thread::spawn(|| { + // this thread will have no arbiter in it's thread local so call will panic + Arbiter::current(); + }) + .join() + .unwrap_err(); + + let thread = thread::spawn(|| { + // this thread will have no arbiter in it's thread local so use the system handle instead + System::set_current(sys); + let sys = System::current(); + + let arb = sys.arbiter(); + arb.spawn(async move { + tx.send(42u32).unwrap(); + System::current().stop(); + }); + }); + + assert_eq!(runner.block_on(rx).unwrap(), 42); + thread.join().unwrap(); +} + +#[test] +fn system_stop_stops_arbiters() { + let sys = System::new(); + let arb = Arbiter::new(); + + // arbiter should be alive to receive spawn msg + assert!(Arbiter::current().spawn_fn(|| {})); + assert!(arb.spawn_fn(|| {})); + + System::current().stop(); + sys.run().unwrap(); + + // account for slightly slow thread de-spawns (only observed on windows) + thread::sleep(Duration::from_millis(100)); + + // arbiter should be dead and return false + assert!(!Arbiter::current().spawn_fn(|| {})); + assert!(!arb.spawn_fn(|| {})); + + arb.join().unwrap(); +} + +#[test] +fn new_system_with_tokio() { + let (tx, rx) = channel(); + + let res = System::with_tokio_rt(move || { + tokio::runtime::Builder::new_multi_thread() + .enable_io() + .enable_time() + .thread_keep_alive(Duration::from_millis(1000)) + .worker_threads(2) + .max_blocking_threads(2) + .on_thread_start(|| {}) + .on_thread_stop(|| {}) + .build() + .unwrap() + }) + .block_on(async { + actix_rt::time::sleep(Duration::from_millis(1)).await; + + tokio::task::spawn(async move { + tx.send(42).unwrap(); + }) + .await + .unwrap(); + + 123usize + }); + + assert_eq!(res, 123); + assert_eq!(rx.recv().unwrap(), 42); +} + +#[test] +fn new_arbiter_with_tokio() { + let _ = System::new(); + + let arb = Arbiter::with_tokio_rt(|| { + tokio::runtime::Builder::new_current_thread() + .enable_all() + .build() + .unwrap() + }); + + let counter = Arc::new(AtomicBool::new(true)); + + let counter1 = counter.clone(); + let did_spawn = arb.spawn(async move { + actix_rt::time::sleep(Duration::from_millis(1)).await; + counter1.store(false, Ordering::SeqCst); + Arbiter::current().stop(); + }); + + assert!(did_spawn); + + arb.join().unwrap(); + + assert_eq!(false, counter.load(Ordering::SeqCst)); +} + +#[test] +fn try_current_no_system() { + assert!(System::try_current().is_none()) +} + +#[test] +fn try_current_with_system() { + System::new().block_on(async { assert!(System::try_current().is_some()) }); +} diff --git a/actix-server/CHANGES.md b/actix-server/CHANGES.md index 32d182c7..f465843c 100644 --- a/actix-server/CHANGES.md +++ b/actix-server/CHANGES.md @@ -1,13 +1,49 @@ # Changes -## Unreleased - 2020-xx-xx +## Unreleased - 2021-xx-xx + + +## 2.0.0-beta.3 - 2021-02-06 +* Hidden `ServerBuilder::start` method has been removed. Use `ServerBuilder::run`. [#246] +* Add retry for EINTR signal (`io::Interrupted`) in `Accept`'s poll loop. [#264] +* Add `ServerBuilder::worker_max_blocking_threads` to customize blocking thread pool size. [#265] +* Update `actix-rt` to `2.0.0`. [#273] + +[#246]: https://github.com/actix/actix-net/pull/246 +[#264]: https://github.com/actix/actix-net/pull/264 +[#265]: https://github.com/actix/actix-net/pull/265 +[#273]: https://github.com/actix/actix-net/pull/273 + + +## 2.0.0-beta.2 - 2021-01-03 +* Merge `actix-testing` to `actix-server` as `test_server` mod. [#242] + +[#242]: https://github.com/actix/actix-net/pull/242 + + +## 2.0.0-beta.1 - 2020-12-28 * Added explicit info log message on accept queue pause. [#215] * Prevent double registration of sockets when back-pressure is resolved. [#223] +<<<<<<< HEAD * Added ServerBuilder::on_stop to run an async closure before Server shutdown [#230] [#215]: https://github.com/actix/actix-net/pull/215 [#223]: https://github.com/actix/actix-net/pull/223 [#230]: https://github.com/actix/actix-net/pull/230 +======= +* Update `mio` dependency to `0.7.3`. [#239] +* Remove `socket2` dependency. [#239] +* `ServerBuilder::backlog` now accepts `u32` instead of `i32`. [#239] +* Remove `AcceptNotify` type and pass `WakerQueue` to `Worker` to wake up `Accept`'s `Poll`. [#239] +* Convert `mio::net::TcpStream` to `actix_rt::net::TcpStream`(`UnixStream` for uds) using + `FromRawFd` and `IntoRawFd`(`FromRawSocket` and `IntoRawSocket` on windows). [#239] +* Remove `AsyncRead` and `AsyncWrite` trait bound for `socket::FromStream` trait. [#239] + +[#215]: https://github.com/actix/actix-net/pull/215 +[#223]: https://github.com/actix/actix-net/pull/223 +[#239]: https://github.com/actix/actix-net/pull/239 + +>>>>>>> master ## 1.0.4 - 2020-09-12 * Update actix-codec to 0.3.0. diff --git a/actix-server/Cargo.toml b/actix-server/Cargo.toml old mode 100644 new mode 100755 index 1a67f61c..9d13e456 --- a/actix-server/Cargo.toml +++ b/actix-server/Cargo.toml @@ -1,12 +1,15 @@ [package] name = "actix-server" -version = "1.0.4" -authors = ["Nikolay Kim "] +version = "2.0.0-beta.3" +authors = [ + "Nikolay Kim ", + "fakeshadow <24548779@qq.com>", +] description = "General purpose TCP server built for the Actix ecosystem" keywords = ["network", "framework", "async", "futures"] homepage = "https://actix.rs" repository = "https://github.com/actix/actix-net.git" -documentation = "https://docs.rs/actix-server/" +documentation = "https://docs.rs/actix-server" categories = ["network-programming", "asynchronous"] license = "MIT OR Apache-2.0" exclude = [".gitignore", ".cargo/config"] @@ -20,25 +23,21 @@ path = "src/lib.rs" default = [] [dependencies] -actix-service = "1.0.6" -actix-rt = "1.1.1" -actix-codec = "0.3.0" -actix-utils = "2.0.0" +actix-codec = "0.4.0-beta.1" +actix-rt = { version = "2.0.0", default-features = false } +actix-service = "2.0.0-beta.4" +actix-utils = "3.0.0-beta.2" +futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] } log = "0.4" +mio = { version = "0.7.6", features = ["os-poll", "net"] } num_cpus = "1.13" -mio = "0.6.19" -socket2 = "0.3" -futures-channel = { version = "0.3.4", default-features = false } -futures-util = { version = "0.3.4", default-features = false, features = ["sink"] } slab = "0.4" - -# unix domain sockets -# FIXME: Remove it and use mio own uds feature once mio 0.7 is released -mio-uds = { version = "0.6.7" } +tokio = { version = "1", features = ["sync"] } [dev-dependencies] -bytes = "0.5" -env_logger = "0.7" -actix-testing = "1.0.0" -tokio = { version = "0.2", features = ["io-util"] } +actix-rt = "2.0.0" +bytes = "1" +env_logger = "0.8" +futures-util = { version = "0.3.7", default-features = false, features = ["sink"] } +tokio = { version = "1", features = ["io-util"] } diff --git a/actix-server/src/accept.rs b/actix-server/src/accept.rs index bef175d8..c8c1da47 100644 --- a/actix-server/src/accept.rs +++ b/actix-server/src/accept.rs @@ -1,120 +1,88 @@ -use std::sync::mpsc as sync_mpsc; use std::time::Duration; use std::{io, thread}; -use actix_rt::time::{delay_until, Instant}; -use actix_rt::System; +use actix_rt::{ + time::{sleep_until, Instant}, + System, +}; use log::{error, info}; +use mio::{Interest, Poll, Token as MioToken}; use slab::Slab; use crate::server::Server; -use crate::socket::{SocketAddr, SocketListener, StdListener}; -use crate::worker::{Conn, WorkerClient}; +use crate::socket::{MioListener, SocketAddr}; +use crate::waker_queue::{WakerInterest, WakerQueue, WAKER_TOKEN}; +use crate::worker::{Conn, WorkerHandle}; use crate::Token; -pub(crate) enum Command { - Pause, - Resume, - Stop, - Worker(WorkerClient), -} - struct ServerSocketInfo { + // addr for socket. mainly used for logging. addr: SocketAddr, + // be ware this is the crate token for identify socket and should not be confused with + // mio::Token token: Token, - sock: SocketListener, + lst: MioListener, + // timeout is used to mark the deadline when this socket's listener should be registered again + // after an error. timeout: Option, } -#[derive(Clone)] -pub(crate) struct AcceptNotify(mio::SetReadiness); - -impl AcceptNotify { - pub(crate) fn new(ready: mio::SetReadiness) -> Self { - AcceptNotify(ready) - } - - pub(crate) fn notify(&self) { - let _ = self.0.set_readiness(mio::Ready::readable()); - } -} - -impl Default for AcceptNotify { - fn default() -> Self { - AcceptNotify::new(mio::Registration::new2().1) - } -} - +/// Accept loop would live with `ServerBuilder`. +/// +/// It's tasked with construct `Poll` instance and `WakerQueue` which would be distributed to +/// `Accept` and `Worker`. +/// +/// It would also listen to `ServerCommand` and push interests to `WakerQueue`. pub(crate) struct AcceptLoop { - cmd_reg: Option, - cmd_ready: mio::SetReadiness, - notify_reg: Option, - notify_ready: mio::SetReadiness, - tx: sync_mpsc::Sender, - rx: Option>, srv: Option, + poll: Option, + waker: WakerQueue, } impl AcceptLoop { - pub fn new(srv: Server) -> AcceptLoop { - let (tx, rx) = sync_mpsc::channel(); - let (cmd_reg, cmd_ready) = mio::Registration::new2(); - let (notify_reg, notify_ready) = mio::Registration::new2(); + pub fn new(srv: Server) -> Self { + let poll = Poll::new().unwrap_or_else(|e| panic!("Can not create `mio::Poll`: {}", e)); + let waker = WakerQueue::new(poll.registry()) + .unwrap_or_else(|e| panic!("Can not create `mio::Waker`: {}", e)); - AcceptLoop { - tx, - cmd_ready, - cmd_reg: Some(cmd_reg), - notify_ready, - notify_reg: Some(notify_reg), - rx: Some(rx), + Self { srv: Some(srv), + poll: Some(poll), + waker, } } - pub fn send(&self, msg: Command) { - let _ = self.tx.send(msg); - let _ = self.cmd_ready.set_readiness(mio::Ready::readable()); + pub(crate) fn waker_owned(&self) -> WakerQueue { + self.waker.clone() } - pub fn get_notify(&self) -> AcceptNotify { - AcceptNotify::new(self.notify_ready.clone()) + pub fn wake(&self, i: WakerInterest) { + self.waker.wake(i); } pub(crate) fn start( &mut self, - socks: Vec<(Token, StdListener)>, - workers: Vec, + socks: Vec<(Token, MioListener)>, + handles: Vec, ) { let srv = self.srv.take().expect("Can not re-use AcceptInfo"); + let poll = self.poll.take().unwrap(); + let waker = self.waker.clone(); - Accept::start( - self.rx.take().expect("Can not re-use AcceptInfo"), - self.cmd_reg.take().expect("Can not re-use AcceptInfo"), - self.notify_reg.take().expect("Can not re-use AcceptInfo"), - socks, - srv, - workers, - ); + Accept::start(poll, waker, socks, srv, handles); } } +/// poll instance of the server. struct Accept { - poll: mio::Poll, - rx: sync_mpsc::Receiver, - sockets: Slab, - workers: Vec, + poll: Poll, + waker: WakerQueue, + handles: Vec, srv: Server, - timer: (mio::Registration, mio::SetReadiness), next: usize, backpressure: bool, } -const DELTA: usize = 100; -const CMD: mio::Token = mio::Token(0); -const TIMER: mio::Token = mio::Token(1); -const NOTIFY: mio::Token = mio::Token(2); - /// This function defines errors that are per-connection. Which basically /// means that if we get this error from `accept()` system call it means /// next connection might be ready to be accepted. @@ -129,326 +97,297 @@ fn connection_error(e: &io::Error) -> bool { } impl Accept { - #![allow(clippy::too_many_arguments)] pub(crate) fn start( - rx: sync_mpsc::Receiver, - cmd_reg: mio::Registration, - notify_reg: mio::Registration, - socks: Vec<(Token, StdListener)>, + poll: Poll, + waker: WakerQueue, + socks: Vec<(Token, MioListener)>, srv: Server, - workers: Vec, + handles: Vec, ) { + // Accept runs in its own thread and would want to spawn additional futures to current + // actix system. let sys = System::current(); - - // start accept thread - let _ = thread::Builder::new() + thread::Builder::new() .name("actix-server accept loop".to_owned()) .spawn(move || { System::set_current(sys); - let mut accept = Accept::new(rx, socks, workers, srv); - - // Start listening for incoming commands - if let Err(err) = accept.poll.register( - &cmd_reg, - CMD, - mio::Ready::readable(), - mio::PollOpt::edge(), - ) { - panic!("Can not register Registration: {}", err); - } - - // Start listening for notify updates - if let Err(err) = accept.poll.register( - ¬ify_reg, - NOTIFY, - mio::Ready::readable(), - mio::PollOpt::edge(), - ) { - panic!("Can not register Registration: {}", err); - } - - accept.poll(); - }); + let (mut accept, sockets) = + Accept::new_with_sockets(poll, waker, socks, handles, srv); + accept.poll_with(sockets); + }) + .unwrap(); } - fn new( - rx: sync_mpsc::Receiver, - socks: Vec<(Token, StdListener)>, - workers: Vec, + fn new_with_sockets( + poll: Poll, + waker: WakerQueue, + socks: Vec<(Token, MioListener)>, + handles: Vec, srv: Server, - ) -> Accept { - // Create a poll instance - let poll = match mio::Poll::new() { - Ok(poll) => poll, - Err(err) => panic!("Can not create mio::Poll: {}", err), - }; - - // Start accept + ) -> (Accept, Slab) { let mut sockets = Slab::new(); - for (hnd_token, lst) in socks.into_iter() { + for (hnd_token, mut lst) in socks.into_iter() { let addr = lst.local_addr(); - let server = lst.into_listener(); let entry = sockets.vacant_entry(); let token = entry.key(); // Start listening for incoming connections - if let Err(err) = poll.register( - &server, - mio::Token(token + DELTA), - mio::Ready::readable(), - mio::PollOpt::edge(), - ) { - panic!("Can not register io: {}", err); - } + poll.registry() + .register(&mut lst, MioToken(token), Interest::READABLE) + .unwrap_or_else(|e| panic!("Can not register io: {}", e)); entry.insert(ServerSocketInfo { addr, token: hnd_token, - sock: server, + lst, timeout: None, }); } - // Timer - let (tm, tmr) = mio::Registration::new2(); - if let Err(err) = - poll.register(&tm, TIMER, mio::Ready::readable(), mio::PollOpt::edge()) - { - panic!("Can not register Registration: {}", err); - } - - Accept { + let accept = Accept { poll, - rx, - sockets, - workers, + waker, + handles, srv, next: 0, - timer: (tm, tmr), backpressure: false, - } + }; + + (accept, sockets) } - fn poll(&mut self) { - // Create storage for events + fn poll_with(&mut self, mut sockets: Slab) { let mut events = mio::Events::with_capacity(128); loop { - if let Err(err) = self.poll.poll(&mut events, None) { - panic!("Poll error: {}", err); + if let Err(e) = self.poll.poll(&mut events, None) { + match e.kind() { + std::io::ErrorKind::Interrupted => { + continue; + } + _ => { + panic!("Poll error: {}", e); + } + } } for event in events.iter() { let token = event.token(); match token { - CMD => { - if !self.process_cmd() { - return; + // This is a loop because interests for command from previous version was + // a loop that would try to drain the command channel. It's yet unknown + // if it's necessary/good practice to actively drain the waker queue. + WAKER_TOKEN => 'waker: loop { + // take guard with every iteration so no new interest can be added + // until the current task is done. + let mut guard = self.waker.guard(); + match guard.pop_front() { + // worker notify it becomes available. we may want to recover + // from backpressure. + Some(WakerInterest::WorkerAvailable) => { + drop(guard); + self.maybe_backpressure(&mut sockets, false); + } + // a new worker thread is made and it's handle would be added + // to Accept + Some(WakerInterest::Worker(handle)) => { + drop(guard); + // maybe we want to recover from a backpressure. + self.maybe_backpressure(&mut sockets, false); + self.handles.push(handle); + } + // got timer interest and it's time to try register socket(s) + // again. + Some(WakerInterest::Timer) => { + drop(guard); + self.process_timer(&mut sockets) + } + Some(WakerInterest::Pause) => { + drop(guard); + sockets.iter_mut().for_each(|(_, info)| { + match self.deregister(info) { + Ok(_) => info!( + "Paused accepting connections on {}", + info.addr + ), + Err(e) => { + error!("Can not deregister server socket {}", e) + } + } + }); + } + Some(WakerInterest::Resume) => { + drop(guard); + sockets.iter_mut().for_each(|(token, info)| { + self.register_logged(token, info); + }); + } + Some(WakerInterest::Stop) => { + return self.deregister_all(&mut sockets); + } + // waker queue is drained. + None => { + // Reset the WakerQueue before break so it does not grow + // infinitely. + WakerQueue::reset(&mut guard); + break 'waker; + } } - } - TIMER => self.process_timer(), - NOTIFY => self.backpressure(false), + }, _ => { let token = usize::from(token); - if token < DELTA { - continue; - } - self.accept(token - DELTA); + self.accept(&mut sockets, token); } } } } } - fn process_timer(&mut self) { + fn process_timer(&self, sockets: &mut Slab) { let now = Instant::now(); - for (token, info) in self.sockets.iter_mut() { + sockets.iter_mut().for_each(|(token, info)| { + // only the ServerSocketInfo have an associate timeout value was de registered. if let Some(inst) = info.timeout.take() { if now > inst { - if let Err(err) = self.poll.register( - &info.sock, - mio::Token(token + DELTA), - mio::Ready::readable(), - mio::PollOpt::edge(), - ) { - error!("Can not register server socket {}", err); - } else { - info!("Resume accepting connections on {}", info.addr); - } + self.register_logged(token, info); } else { info.timeout = Some(inst); } } - } - } - - fn process_cmd(&mut self) -> bool { - loop { - match self.rx.try_recv() { - Ok(cmd) => match cmd { - Command::Pause => { - for (_, info) in self.sockets.iter_mut() { - if let Err(err) = self.poll.deregister(&info.sock) { - error!("Can not deregister server socket {}", err); - } else { - info!("Paused accepting connections on {}", info.addr); - } - } - } - Command::Resume => { - for (token, info) in self.sockets.iter() { - if let Err(err) = self.register(token, info) { - error!("Can not resume socket accept process: {}", err); - } else { - info!( - "Accepting connections on {} has been resumed", - info.addr - ); - } - } - } - Command::Stop => { - for (_, info) in self.sockets.iter() { - let _ = self.poll.deregister(&info.sock); - } - return false; - } - Command::Worker(worker) => { - self.backpressure(false); - self.workers.push(worker); - } - }, - Err(err) => match err { - sync_mpsc::TryRecvError::Empty => break, - sync_mpsc::TryRecvError::Disconnected => { - for (_, info) in self.sockets.iter() { - let _ = self.poll.deregister(&info.sock); - } - return false; - } - }, - } - } - true + }); } #[cfg(not(target_os = "windows"))] - fn register(&self, token: usize, info: &ServerSocketInfo) -> io::Result<()> { - self.poll.register( - &info.sock, - mio::Token(token + DELTA), - mio::Ready::readable(), - mio::PollOpt::edge(), - ) + fn register(&self, token: usize, info: &mut ServerSocketInfo) -> io::Result<()> { + self.poll + .registry() + .register(&mut info.lst, MioToken(token), Interest::READABLE) } #[cfg(target_os = "windows")] - fn register(&self, token: usize, info: &ServerSocketInfo) -> io::Result<()> { + fn register(&self, token: usize, info: &mut ServerSocketInfo) -> io::Result<()> { // On windows, calling register without deregister cause an error. // See https://github.com/actix/actix-web/issues/905 // Calling reregister seems to fix the issue. self.poll - .register( - &info.sock, - mio::Token(token + DELTA), - mio::Ready::readable(), - mio::PollOpt::edge(), - ) + .registry() + .register(&mut info.lst, mio::Token(token), Interest::READABLE) .or_else(|_| { - self.poll.reregister( - &info.sock, - mio::Token(token + DELTA), - mio::Ready::readable(), - mio::PollOpt::edge(), + self.poll.registry().reregister( + &mut info.lst, + mio::Token(token), + Interest::READABLE, ) }) } - fn backpressure(&mut self, on: bool) { + fn register_logged(&self, token: usize, info: &mut ServerSocketInfo) { + match self.register(token, info) { + Ok(_) => info!("Resume accepting connections on {}", info.addr), + Err(e) => error!("Can not register server socket {}", e), + } + } + + fn deregister(&self, info: &mut ServerSocketInfo) -> io::Result<()> { + self.poll.registry().deregister(&mut info.lst) + } + + fn deregister_all(&self, sockets: &mut Slab) { + sockets.iter_mut().for_each(|(_, info)| { + info!("Accepting connections on {} has been paused", info.addr); + let _ = self.deregister(info); + }); + } + + fn maybe_backpressure(&mut self, sockets: &mut Slab, on: bool) { if self.backpressure { if !on { self.backpressure = false; - for (token, info) in self.sockets.iter() { + for (token, info) in sockets.iter_mut() { if info.timeout.is_some() { // socket will attempt to re-register itself when its timeout completes continue; } - - if let Err(err) = self.register(token, info) { - error!("Can not resume socket accept process: {}", err); - } else { - info!("Accepting connections on {} has been resumed", info.addr); - } + self.register_logged(token, info); } } } else if on { self.backpressure = true; - for (_, info) in self.sockets.iter() { - let _ = self.poll.deregister(&info.sock); - info!("Accepting connections on {} has been paused", info.addr); - } + self.deregister_all(sockets); } } - fn accept_one(&mut self, mut msg: Conn) { + fn accept_one(&mut self, sockets: &mut Slab, mut msg: Conn) { if self.backpressure { - while !self.workers.is_empty() { - match self.workers[self.next].send(msg) { - Ok(_) => (), + while !self.handles.is_empty() { + match self.handles[self.next].send(msg) { + Ok(_) => { + self.set_next(); + break; + } Err(tmp) => { - self.srv.worker_faulted(self.workers[self.next].idx); + // worker lost contact and could be gone. a message is sent to + // `ServerBuilder` future to notify it a new worker should be made. + // after that remove the fault worker. + self.srv.worker_faulted(self.handles[self.next].idx); msg = tmp; - self.workers.swap_remove(self.next); - if self.workers.is_empty() { + self.handles.swap_remove(self.next); + if self.handles.is_empty() { error!("No workers"); return; - } else if self.workers.len() <= self.next { + } else if self.handles.len() <= self.next { self.next = 0; } continue; } } - self.next = (self.next + 1) % self.workers.len(); - break; } } else { let mut idx = 0; - while idx < self.workers.len() { + while idx < self.handles.len() { idx += 1; - if self.workers[self.next].available() { - match self.workers[self.next].send(msg) { + if self.handles[self.next].available() { + match self.handles[self.next].send(msg) { Ok(_) => { - self.next = (self.next + 1) % self.workers.len(); + self.set_next(); return; } + // worker lost contact and could be gone. a message is sent to + // `ServerBuilder` future to notify it a new worker should be made. + // after that remove the fault worker and enter backpressure if necessary. Err(tmp) => { - self.srv.worker_faulted(self.workers[self.next].idx); + self.srv.worker_faulted(self.handles[self.next].idx); msg = tmp; - self.workers.swap_remove(self.next); - if self.workers.is_empty() { + self.handles.swap_remove(self.next); + if self.handles.is_empty() { error!("No workers"); - self.backpressure(true); + self.maybe_backpressure(sockets, true); return; - } else if self.workers.len() <= self.next { + } else if self.handles.len() <= self.next { self.next = 0; } continue; } } } - self.next = (self.next + 1) % self.workers.len(); + self.set_next(); } // enable backpressure - self.backpressure(true); - self.accept_one(msg); + self.maybe_backpressure(sockets, true); + self.accept_one(sockets, msg); } } - fn accept(&mut self, token: usize) { + // set next worker handle that would accept work. + fn set_next(&mut self) { + self.next = (self.next + 1) % self.handles.len(); + } + + fn accept(&mut self, sockets: &mut Slab, token: usize) { loop { - let msg = if let Some(info) = self.sockets.get_mut(token) { - match info.sock.accept() { + let msg = if let Some(info) = sockets.get_mut(token) { + match info.lst.accept() { Ok(Some((io, addr))) => Conn { io, token: info.token, @@ -458,19 +397,24 @@ impl Accept { Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => return, Err(ref e) if connection_error(e) => continue, Err(e) => { + // deregister listener temporary error!("Error accepting connection: {}", e); - if let Err(err) = self.poll.deregister(&info.sock) { + if let Err(err) = self.deregister(info) { error!("Can not deregister server socket {}", err); } - // sleep after error + // sleep after error. write the timeout to socket info as later the poll + // would need it mark which socket and when it's listener should be + // registered. info.timeout = Some(Instant::now() + Duration::from_millis(500)); - let r = self.timer.1.clone(); - System::current().arbiter().send(Box::pin(async move { - delay_until(Instant::now() + Duration::from_millis(510)).await; - let _ = r.set_readiness(mio::Ready::readable()); - })); + // after the sleep a Timer interest is sent to Accept Poll + let waker = self.waker.clone(); + System::current().arbiter().spawn(async move { + sleep_until(Instant::now() + Duration::from_millis(510)).await; + waker.wake(WakerInterest::Timer); + }); + return; } } @@ -478,7 +422,7 @@ impl Accept { return; }; - self.accept_one(msg); + self.accept_one(sockets, msg); } } } diff --git a/actix-server/src/builder.rs b/actix-server/src/builder.rs index 9572024c..7f64eed7 100644 --- a/actix-server/src/builder.rs +++ b/actix-server/src/builder.rs @@ -2,43 +2,43 @@ use std::future::Future; use std::pin::Pin; use std::task::{Context, Poll}; use std::time::Duration; -use std::{io, mem, net}; +use std::{io, mem}; use actix_rt::net::TcpStream; -use actix_rt::time::{delay_until, Instant}; -use actix_rt::{spawn, System}; -use futures_channel::mpsc::{unbounded, UnboundedReceiver}; -use futures_channel::oneshot; -use futures_util::stream::FuturesUnordered; -use futures_util::{ready, stream::Stream, StreamExt}; +use actix_rt::time::{sleep_until, Instant}; +use actix_rt::{self as rt, System}; use log::{error, info}; -use socket2::{Domain, Protocol, Socket, Type}; +use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver}; +use tokio::sync::oneshot; -use crate::accept::{AcceptLoop, AcceptNotify, Command}; +use crate::accept::AcceptLoop; use crate::config::{ConfiguredService, ServiceConfig}; use crate::server::{Server, ServerCommand}; use crate::service::{InternalServiceFactory, ServiceFactory, StreamNewService}; use crate::signals::{Signal, Signals}; -use crate::socket::StdListener; -use crate::worker::{self, Worker, WorkerAvailability, WorkerClient}; -use crate::Token; +use crate::socket::{MioListener, StdSocketAddr, StdTcpListener, ToSocketAddrs}; +use crate::socket::{MioTcpListener, MioTcpSocket}; +use crate::waker_queue::{WakerInterest, WakerQueue}; +use crate::worker::{self, ServerWorker, ServerWorkerConfig, WorkerAvailability, WorkerHandle}; +use crate::{join_all, Token}; +use futures_core::future::LocalBoxFuture; /// Server builder pub struct ServerBuilder { threads: usize, token: Token, - backlog: i32, - workers: Vec<(usize, WorkerClient)>, + backlog: u32, + handles: Vec<(usize, WorkerHandle)>, services: Vec>, - sockets: Vec<(Token, String, StdListener)>, + sockets: Vec<(Token, String, MioListener)>, accept: AcceptLoop, exit: bool, - shutdown_timeout: Duration, no_signals: bool, cmd: UnboundedReceiver, server: Server, - on_stop: Pin>>, + on_stop: Box LocalBoxFuture<'static, ()>>, notify: Vec>, + worker_config: ServerWorkerConfig, } impl Default for ServerBuilder { @@ -50,24 +50,24 @@ impl Default for ServerBuilder { impl ServerBuilder { /// Create new Server builder instance pub fn new() -> ServerBuilder { - let (tx, rx) = unbounded(); + let (tx, rx) = unbounded_channel(); let server = Server::new(tx); ServerBuilder { threads: num_cpus::get(), - token: Token(0), - workers: Vec::new(), + token: Token::default(), + handles: Vec::new(), services: Vec::new(), sockets: Vec::new(), accept: AcceptLoop::new(server.clone()), backlog: 2048, exit: false, - shutdown_timeout: Duration::from_secs(30), no_signals: false, cmd: rx, notify: Vec::new(), server, - on_stop: Box::pin(async {}), + on_stop: Box::new(|| Box::pin(async {})), + worker_config: ServerWorkerConfig::default(), } } @@ -81,6 +81,24 @@ impl ServerBuilder { self } + /// Set max number of threads for each worker's blocking task thread pool. + /// + /// One thread pool is set up **per worker**; not shared across workers. + /// + /// # Examples: + /// ``` + /// # use actix_server::ServerBuilder; + /// let builder = ServerBuilder::new() + /// .workers(4) // server has 4 worker thread. + /// .worker_max_blocking_threads(4); // every worker has 4 max blocking threads. + /// ``` + /// + /// See [tokio::runtime::Builder::max_blocking_threads] for behavior reference. + pub fn worker_max_blocking_threads(mut self, num: usize) -> Self { + self.worker_config.max_blocking_threads(num); + self + } + /// Set the maximum number of pending connections. /// /// This refers to the number of clients that can be waiting to be served. @@ -91,7 +109,7 @@ impl ServerBuilder { /// Generally set in the 64-2048 range. Default value is 2048. /// /// This method should be called before `bind()` method call. - pub fn backlog(mut self, num: i32) -> Self { + pub fn backlog(mut self, num: u32) -> Self { self.backlog = num; self } @@ -127,7 +145,8 @@ impl ServerBuilder { /// /// By default shutdown timeout sets to 30 seconds. pub fn shutdown_timeout(mut self, sec: u64) -> Self { - self.shutdown_timeout = Duration::from_secs(sec); + self.worker_config + .shutdown_timeout(Duration::from_secs(sec)); self } @@ -149,7 +168,7 @@ impl ServerBuilder { for (name, lst) in cfg.services { let token = self.token.next(); srv.stream(token, name.clone(), lst.local_addr()?); - self.sockets.push((token, name, StdListener::Tcp(lst))); + self.sockets.push((token, name, MioListener::Tcp(lst))); } self.services.push(Box::new(srv)); } @@ -162,7 +181,7 @@ impl ServerBuilder { pub fn bind>(mut self, name: N, addr: U, factory: F) -> io::Result where F: ServiceFactory, - U: net::ToSocketAddrs, + U: ToSocketAddrs, { let sockets = bind_addr(addr, self.backlog)?; @@ -175,21 +194,19 @@ impl ServerBuilder { lst.local_addr()?, )); self.sockets - .push((token, name.as_ref().to_string(), StdListener::Tcp(lst))); + .push((token, name.as_ref().to_string(), MioListener::Tcp(lst))); } Ok(self) } - #[cfg(all(unix))] /// Add new unix domain service to the server. + #[cfg(unix)] pub fn bind_uds(self, name: N, addr: U, factory: F) -> io::Result where F: ServiceFactory, N: AsRef, U: AsRef, { - use std::os::unix::net::UnixListener; - // 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()) { @@ -199,26 +216,27 @@ impl ServerBuilder { } } - let lst = UnixListener::bind(addr)?; + let lst = crate::socket::StdUnixListener::bind(addr)?; self.listen_uds(name, lst, factory) } - #[cfg(all(unix))] /// 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. + #[cfg(unix)] pub fn listen_uds>( mut self, name: N, - lst: std::os::unix::net::UnixListener, + lst: crate::socket::StdUnixListener, factory: F, ) -> io::Result where F: ServiceFactory, { - use std::net::{IpAddr, Ipv4Addr, SocketAddr}; + use std::net::{IpAddr, Ipv4Addr}; + lst.set_nonblocking(true)?; let token = self.token.next(); - let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080); + let addr = StdSocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080); self.services.push(StreamNewService::create( name.as_ref().to_string(), token, @@ -226,7 +244,7 @@ impl ServerBuilder { addr, )); self.sockets - .push((token, name.as_ref().to_string(), StdListener::Uds(lst))); + .push((token, name.as_ref().to_string(), MioListener::from(lst))); Ok(self) } @@ -234,27 +252,26 @@ impl ServerBuilder { pub fn listen>( mut self, name: N, - lst: net::TcpListener, + lst: StdTcpListener, factory: F, ) -> io::Result where F: ServiceFactory, { + lst.set_nonblocking(true)?; + let addr = lst.local_addr()?; + let token = self.token.next(); self.services.push(StreamNewService::create( name.as_ref().to_string(), token, factory, - lst.local_addr()?, + addr, )); - self.sockets - .push((token, name.as_ref().to_string(), StdListener::Tcp(lst))); - Ok(self) - } - #[doc(hidden)] - pub fn start(self) -> Server { - self.run() + self.sockets + .push((token, name.as_ref().to_string(), MioListener::from(lst))); + Ok(self) } /// Starts processing incoming connections and return server controller. @@ -265,12 +282,12 @@ impl ServerBuilder { info!("Starting {} workers", self.threads); // start workers - let workers = (0..self.threads) + let handles = (0..self.threads) .map(|idx| { - let worker = self.start_worker(idx, self.accept.get_notify()); - self.workers.push((idx, worker.clone())); + let handle = self.start_worker(idx, self.accept.waker_owned()); + self.handles.push((idx, handle.clone())); - worker + handle }) .collect(); @@ -283,7 +300,7 @@ impl ServerBuilder { .into_iter() .map(|t| (t.0, t.2)) .collect(), - workers, + handles, ); // handle signals @@ -293,43 +310,46 @@ impl ServerBuilder { // start http server actor let server = self.server.clone(); - spawn(self); + rt::spawn(self); server } } /// Async closure that would run before Server is shutdown. /// - /// The exact timing is after `ServerCommand::Stop` is received. + /// The exact timing is after server received stopping command. + /// /// Before worker threads stopped if the shutdown is graceful. /// - /// Or before `actix::System` is stopped when not graceful. - /// (If `ServerBuilder::system_exit` is set to true) - pub fn on_stop(mut self, future: F) -> Self + /// Or before [actix_rt::System] is stopped when not graceful. + /// (If [ServerBuilder::system_exit] is set to true) + pub fn on_stop(mut self, func: F) -> Self where - F: FnOnce() -> Fut + 'static, + F: Fn() -> Fut + Clone + 'static, Fut: Future, { - self.on_stop = Box::pin(async move { future().await }); + self.on_stop = Box::new(move || { + let func = func.clone(); + Box::pin(async move { func().await }) + }); self } - fn start_worker(&self, idx: usize, notify: AcceptNotify) -> WorkerClient { - let avail = WorkerAvailability::new(notify); - let services: Vec> = - self.services.iter().map(|v| v.clone_factory()).collect(); + fn start_worker(&self, idx: usize, waker: WakerQueue) -> WorkerHandle { + let avail = WorkerAvailability::new(waker); + let services = self.services.iter().map(|v| v.clone_factory()).collect(); - Worker::start(idx, services, avail, self.shutdown_timeout) + ServerWorker::start(idx, services, avail, self.worker_config) } fn handle_cmd(&mut self, item: ServerCommand) { match item { ServerCommand::Pause(tx) => { - self.accept.send(Command::Pause); + self.accept.wake(WakerInterest::Pause); let _ = tx.send(()); } ServerCommand::Resume(tx) => { - self.accept.send(Command::Resume); + self.accept.wake(WakerInterest::Resume); let _ = tx.send(()); } ServerCommand::Signal(sig) => { @@ -373,25 +393,28 @@ impl ServerBuilder { let exit = self.exit; // stop accept thread - self.accept.send(Command::Stop); + self.accept.wake(WakerInterest::Stop); let notify = std::mem::take(&mut self.notify); // take the on_stop future. - let mut on_stop = Box::pin(async {}) as _; + let mut on_stop = + Box::new(|| Box::pin(async {}) as LocalBoxFuture<'static, ()>) as _; std::mem::swap(&mut self.on_stop, &mut on_stop); // stop workers - if !self.workers.is_empty() && graceful { - let stop_workers = self - .workers + if !self.handles.is_empty() && graceful { + let iter = self + .handles .iter() .map(move |worker| worker.1.stop(graceful)) - .collect::>() - .collect::>(); + .collect(); - spawn(async move { - on_stop.await; - stop_workers.await; + let fut = join_all(iter); + + rt::spawn(async move { + on_stop().await; + + let _ = fut.await; if let Some(tx) = completion { let _ = tx.send(()); } @@ -399,18 +422,18 @@ impl ServerBuilder { let _ = tx.send(()); } if exit { - spawn(async { - delay_until(Instant::now() + Duration::from_millis(300)).await; + rt::spawn(async { + sleep_until(Instant::now() + Duration::from_millis(300)).await; System::current().stop(); }); } }); // we need to stop system if server was spawned } else { - spawn(async move { - on_stop.await; + rt::spawn(async move { + on_stop().await; if exit { - delay_until(Instant::now() + Duration::from_millis(300)).await; + sleep_until(Instant::now() + Duration::from_millis(300)).await; System::current().stop(); } }); @@ -425,9 +448,9 @@ impl ServerBuilder { } ServerCommand::WorkerFaulted(idx) => { let mut found = false; - for i in 0..self.workers.len() { - if self.workers[i].0 == idx { - self.workers.swap_remove(i); + for i in 0..self.handles.len() { + if self.handles[i].0 == idx { + self.handles.swap_remove(i); found = true; break; } @@ -436,10 +459,10 @@ impl ServerBuilder { if found { error!("Worker has died {:?}, restarting", idx); - let mut new_idx = self.workers.len(); + let mut new_idx = self.handles.len(); 'found: loop { - for i in 0..self.workers.len() { - if self.workers[i].0 == new_idx { + for i in 0..self.handles.len() { + if self.handles[i].0 == new_idx { new_idx += 1; continue 'found; } @@ -447,9 +470,9 @@ impl ServerBuilder { break; } - let worker = self.start_worker(new_idx, self.accept.get_notify()); - self.workers.push((new_idx, worker.clone())); - self.accept.send(Command::Worker(worker)); + let handle = self.start_worker(new_idx, self.accept.waker_owned()); + self.handles.push((new_idx, handle.clone())); + self.accept.wake(WakerInterest::Worker(handle)); } } } @@ -461,20 +484,18 @@ impl Future for ServerBuilder { fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { loop { - match ready!(Pin::new(&mut self.cmd).poll_next(cx)) { - Some(it) => self.as_mut().get_mut().handle_cmd(it), - None => { - return Poll::Pending; - } + match Pin::new(&mut self.cmd).poll_recv(cx) { + Poll::Ready(Some(it)) => self.as_mut().get_mut().handle_cmd(it), + _ => return Poll::Pending, } } } } -pub(super) fn bind_addr( +pub(super) fn bind_addr( addr: S, - backlog: i32, -) -> io::Result> { + backlog: u32, +) -> io::Result> { let mut err = None; let mut succ = false; let mut sockets = Vec::new(); @@ -502,14 +523,13 @@ pub(super) fn bind_addr( } } -fn create_tcp_listener(addr: net::SocketAddr, backlog: i32) -> io::Result { - let domain = match addr { - net::SocketAddr::V4(_) => Domain::ipv4(), - net::SocketAddr::V6(_) => Domain::ipv6(), +fn create_tcp_listener(addr: StdSocketAddr, backlog: u32) -> io::Result { + let socket = match addr { + StdSocketAddr::V4(_) => MioTcpSocket::new_v4()?, + StdSocketAddr::V6(_) => MioTcpSocket::new_v6()?, }; - let socket = Socket::new(domain, Type::stream(), Some(Protocol::tcp()))?; - socket.set_reuse_address(true)?; - socket.bind(&addr.into())?; - socket.listen(backlog)?; - Ok(socket.into_tcp_listener()) + + socket.set_reuseaddr(true)?; + socket.bind(addr)?; + socket.listen(backlog) } diff --git a/actix-server/src/config.rs b/actix-server/src/config.rs index 28996b9b..20270a2f 100644 --- a/actix-server/src/config.rs +++ b/actix-server/src/config.rs @@ -1,26 +1,30 @@ use std::collections::HashMap; -use std::{fmt, io, net}; +use std::future::Future; +use std::{fmt, io}; use actix_rt::net::TcpStream; -use actix_service as actix; +use actix_service::{ + fn_service, IntoServiceFactory as IntoBaseServiceFactory, + ServiceFactory as BaseServiceFactory, +}; use actix_utils::counter::CounterGuard; -use futures_util::future::{ok, Future, FutureExt, LocalBoxFuture}; +use futures_core::future::LocalBoxFuture; use log::error; -use super::builder::bind_addr; -use super::service::{BoxedServerService, InternalServiceFactory, StreamService}; -use super::Token; -use crate::socket::StdStream; +use crate::builder::bind_addr; +use crate::service::{BoxedServerService, InternalServiceFactory, StreamService}; +use crate::socket::{MioStream, MioTcpListener, StdSocketAddr, StdTcpListener, ToSocketAddrs}; +use crate::{ready, Token}; pub struct ServiceConfig { - pub(crate) services: Vec<(String, net::TcpListener)>, + pub(crate) services: Vec<(String, MioTcpListener)>, pub(crate) apply: Option>, pub(crate) threads: usize, - pub(crate) backlog: i32, + pub(crate) backlog: u32, } impl ServiceConfig { - pub(super) fn new(threads: usize, backlog: i32) -> ServiceConfig { + pub(super) fn new(threads: usize, backlog: u32) -> ServiceConfig { ServiceConfig { threads, backlog, @@ -40,24 +44,20 @@ impl ServiceConfig { /// Add new service to server pub fn bind>(&mut self, name: N, addr: U) -> io::Result<&mut Self> where - U: net::ToSocketAddrs, + U: ToSocketAddrs, { let sockets = bind_addr(addr, self.backlog)?; for lst in sockets { - self.listen(name.as_ref(), lst); + self._listen(name.as_ref(), lst); } Ok(self) } /// Add new service to server - pub fn listen>(&mut self, name: N, lst: net::TcpListener) -> &mut Self { - if self.apply.is_none() { - self.apply = Some(Box::new(not_configured)); - } - self.services.push((name.as_ref().to_string(), lst)); - self + pub fn listen>(&mut self, name: N, lst: StdTcpListener) -> &mut Self { + self._listen(name, MioTcpListener::from_std(lst)) } /// Register service configuration function. This function get called @@ -69,11 +69,19 @@ impl ServiceConfig { self.apply = Some(Box::new(f)); Ok(()) } + + fn _listen>(&mut self, name: N, lst: MioTcpListener) -> &mut Self { + if self.apply.is_none() { + self.apply = Some(Box::new(not_configured)); + } + self.services.push((name.as_ref().to_string(), lst)); + self + } } pub(super) struct ConfiguredService { rt: Box, - names: HashMap, + names: HashMap, topics: HashMap, services: Vec, } @@ -88,7 +96,7 @@ impl ConfiguredService { } } - pub(super) fn stream(&mut self, token: Token, name: String, addr: net::SocketAddr) { + pub(super) fn stream(&mut self, token: Token, name: String, addr: StdSocketAddr) { self.names.insert(token, (name.clone(), addr)); self.topics.insert(name, token); self.services.push(token); @@ -118,7 +126,7 @@ impl InternalServiceFactory for ConfiguredService { let tokens = self.services.clone(); // construct services - async move { + Box::pin(async move { let mut services = rt.services; // TODO: Proper error handling here for f in rt.onstart.into_iter() { @@ -141,18 +149,15 @@ impl InternalServiceFactory for ConfiguredService { let name = names.remove(&token).unwrap().0; res.push(( token, - Box::new(StreamService::new(actix::fn_service( - move |_: TcpStream| { - error!("Service {:?} is not configured", name); - ok::<_, ()>(()) - }, - ))), + Box::new(StreamService::new(fn_service(move |_: TcpStream| { + error!("Service {:?} is not configured", name); + ready::>(Ok(())) + }))), )); }; } Ok(res) - } - .boxed_local() + }) } } @@ -208,8 +213,8 @@ impl ServiceRuntime { /// *ServiceConfig::bind()* or *ServiceConfig::listen()* methods. pub fn service(&mut self, name: &str, service: F) where - F: actix::IntoServiceFactory, - T: actix::ServiceFactory + 'static, + F: IntoBaseServiceFactory, + T: BaseServiceFactory + 'static, T::Future: 'static, T::Service: 'static, T::InitError: fmt::Debug, @@ -232,13 +237,13 @@ impl ServiceRuntime { where F: Future + 'static, { - self.onstart.push(fut.boxed_local()) + self.onstart.push(Box::pin(fut)) } } type BoxedNewService = Box< - dyn actix::ServiceFactory< - Request = (Option, StdStream), + dyn BaseServiceFactory< + (Option, MioStream), Response = (), Error = (), InitError = (), @@ -252,15 +257,14 @@ struct ServiceFactory { inner: T, } -impl actix::ServiceFactory for ServiceFactory +impl BaseServiceFactory<(Option, MioStream)> for ServiceFactory where - T: actix::ServiceFactory, + T: BaseServiceFactory, T::Future: 'static, T::Service: 'static, T::Error: 'static, T::InitError: fmt::Debug + 'static, { - type Request = (Option, StdStream); type Response = (); type Error = (); type Config = (); @@ -270,7 +274,7 @@ where fn new_service(&self, _: ()) -> Self::Future { let fut = self.inner.new_service(()); - async move { + Box::pin(async move { match fut.await { Ok(s) => Ok(Box::new(StreamService::new(s)) as BoxedServerService), Err(e) => { @@ -278,7 +282,6 @@ where Err(()) } } - } - .boxed_local() + }) } } diff --git a/actix-server/src/lib.rs b/actix-server/src/lib.rs index d7a7c242..24129b5a 100644 --- a/actix-server/src/lib.rs +++ b/actix-server/src/lib.rs @@ -11,21 +11,38 @@ mod server; mod service; mod signals; mod socket; +mod test_server; +mod waker_queue; mod worker; pub use self::builder::ServerBuilder; pub use self::config::{ServiceConfig, ServiceRuntime}; pub use self::server::Server; pub use self::service::ServiceFactory; +pub use self::test_server::TestServer; #[doc(hidden)] pub use self::socket::FromStream; +use std::future::Future; +use std::pin::Pin; +use std::task::{Context, Poll}; + /// Socket ID token #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub(crate) struct Token(usize); +impl Default for Token { + fn default() -> Self { + Self::new() + } +} + impl Token { + fn new() -> Self { + Self(0) + } + pub(crate) fn next(&mut self) -> Token { let token = Token(self.0); self.0 += 1; @@ -37,3 +54,90 @@ impl Token { pub fn new() -> ServerBuilder { ServerBuilder::default() } + +// temporary Ready type for std::future::{ready, Ready}; Can be removed when MSRV surpass 1.48 +#[doc(hidden)] +pub struct Ready(Option); + +pub(crate) fn ready(t: T) -> Ready { + Ready(Some(t)) +} + +impl Unpin for Ready {} + +impl Future for Ready { + type Output = T; + + fn poll(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll { + Poll::Ready(self.get_mut().0.take().unwrap()) + } +} + +// a poor man's join future. joined future is only used when starting/stopping the server. +// pin_project and pinned futures are overkill for this task. +pub(crate) struct JoinAll { + fut: Vec>, +} + +pub(crate) fn join_all(fut: Vec + 'static>) -> JoinAll { + let fut = fut + .into_iter() + .map(|f| JoinFuture::Future(Box::pin(f))) + .collect(); + + JoinAll { fut } +} + +enum JoinFuture { + Future(Pin>>), + Result(Option), +} + +impl Unpin for JoinAll {} + +impl Future for JoinAll { + type Output = Vec; + + fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + let mut ready = true; + + let this = self.get_mut(); + for fut in this.fut.iter_mut() { + if let JoinFuture::Future(f) = fut { + match f.as_mut().poll(cx) { + Poll::Ready(t) => { + *fut = JoinFuture::Result(Some(t)); + } + Poll::Pending => ready = false, + } + } + } + + if ready { + let mut res = Vec::new(); + for fut in this.fut.iter_mut() { + if let JoinFuture::Result(f) = fut { + res.push(f.take().unwrap()); + } + } + + Poll::Ready(res) + } else { + Poll::Pending + } + } +} + +#[cfg(test)] +mod test { + use super::*; + + #[actix_rt::test] + async fn test_join_all() { + let futs = vec![ready(Ok(1)), ready(Err(3)), ready(Ok(9))]; + let mut res = join_all(futs).await.into_iter(); + assert_eq!(Ok(1), res.next().unwrap()); + assert_eq!(Err(3), res.next().unwrap()); + assert_eq!(Ok(9), res.next().unwrap()); + } +} diff --git a/actix-server/src/server.rs b/actix-server/src/server.rs index b29a9e02..6b0d0aea 100644 --- a/actix-server/src/server.rs +++ b/actix-server/src/server.rs @@ -3,9 +3,8 @@ use std::io; use std::pin::Pin; use std::task::{Context, Poll}; -use futures_channel::mpsc::UnboundedSender; -use futures_channel::oneshot; -use futures_util::FutureExt; +use tokio::sync::mpsc::UnboundedSender; +use tokio::sync::oneshot; use crate::builder::ServerBuilder; use crate::signals::Signal; @@ -42,11 +41,11 @@ impl Server { } pub(crate) fn signal(&self, sig: Signal) { - let _ = self.0.unbounded_send(ServerCommand::Signal(sig)); + let _ = self.0.send(ServerCommand::Signal(sig)); } pub(crate) fn worker_faulted(&self, idx: usize) { - let _ = self.0.unbounded_send(ServerCommand::WorkerFaulted(idx)); + let _ = self.0.send(ServerCommand::WorkerFaulted(idx)); } /// Pause accepting incoming connections @@ -55,15 +54,19 @@ impl Server { /// All opened connection remains active. pub fn pause(&self) -> impl Future { let (tx, rx) = oneshot::channel(); - let _ = self.0.unbounded_send(ServerCommand::Pause(tx)); - rx.map(|_| ()) + let _ = self.0.send(ServerCommand::Pause(tx)); + async { + let _ = rx.await; + } } /// Resume accepting incoming connections pub fn resume(&self) -> impl Future { let (tx, rx) = oneshot::channel(); - let _ = self.0.unbounded_send(ServerCommand::Resume(tx)); - rx.map(|_| ()) + let _ = self.0.send(ServerCommand::Resume(tx)); + async { + let _ = rx.await; + } } /// Stop incoming connection processing, stop all workers and exit. @@ -71,11 +74,13 @@ impl Server { /// If server starts with `spawn()` method, then spawned thread get terminated. pub fn stop(&self, graceful: bool) -> impl Future { let (tx, rx) = oneshot::channel(); - let _ = self.0.unbounded_send(ServerCommand::Stop { + let _ = self.0.send(ServerCommand::Stop { graceful, completion: Some(tx), }); - rx.map(|_| ()) + async { + let _ = rx.await; + } } } @@ -93,7 +98,7 @@ impl Future for Server { if this.1.is_none() { let (tx, rx) = oneshot::channel(); - if this.0.unbounded_send(ServerCommand::Notify(tx)).is_err() { + if this.0.send(ServerCommand::Notify(tx)).is_err() { return Poll::Ready(Ok(())); } this.1 = Some(rx); @@ -101,8 +106,7 @@ impl Future for Server { match Pin::new(this.1.as_mut().unwrap()).poll(cx) { Poll::Pending => Poll::Pending, - Poll::Ready(Ok(_)) => Poll::Ready(Ok(())), - Poll::Ready(Err(_)) => Poll::Ready(Ok(())), + Poll::Ready(_) => Poll::Ready(Ok(())), } } } diff --git a/actix-server/src/service.rs b/actix-server/src/service.rs index 4fc49586..63d2c1f5 100644 --- a/actix-server/src/service.rs +++ b/actix-server/src/service.rs @@ -2,18 +2,16 @@ use std::marker::PhantomData; use std::net::SocketAddr; use std::task::{Context, Poll}; -use actix_rt::spawn; -use actix_service::{self as actix, Service, ServiceFactory as ActixServiceFactory}; +use actix_service::{Service, ServiceFactory as BaseServiceFactory}; use actix_utils::counter::CounterGuard; -use futures_util::future::{err, ok, LocalBoxFuture, Ready}; -use futures_util::{FutureExt, TryFutureExt}; +use futures_core::future::LocalBoxFuture; use log::error; -use super::Token; -use crate::socket::{FromStream, StdStream}; +use crate::socket::{FromStream, MioStream}; +use crate::{ready, Ready, Token}; pub trait ServiceFactory: Send + Clone + 'static { - type Factory: actix::ServiceFactory; + type Factory: BaseServiceFactory; fn create(&self) -> Self::Factory; } @@ -28,54 +26,57 @@ pub(crate) trait InternalServiceFactory: Send { pub(crate) type BoxedServerService = Box< dyn Service< - Request = (Option, StdStream), + (Option, MioStream), Response = (), Error = (), Future = Ready>, >, >; -pub(crate) struct StreamService { - service: T, +pub(crate) struct StreamService { + service: S, + _phantom: PhantomData, } -impl StreamService { - pub(crate) fn new(service: T) -> Self { - StreamService { service } +impl StreamService { + pub(crate) fn new(service: S) -> Self { + StreamService { + service, + _phantom: PhantomData, + } } } -impl Service for StreamService +impl Service<(Option, MioStream)> for StreamService where - T: Service, - T::Future: 'static, - T::Error: 'static, + S: Service, + S::Future: 'static, + S::Error: 'static, I: FromStream, { - type Request = (Option, StdStream); type Response = (); type Error = (); type Future = Ready>; - fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll> { + fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll> { self.service.poll_ready(ctx).map_err(|_| ()) } - fn call(&mut self, (guard, req): (Option, StdStream)) -> Self::Future { - match FromStream::from_stdstream(req) { + fn call(&self, (guard, req): (Option, MioStream)) -> Self::Future { + ready(match FromStream::from_mio(req) { Ok(stream) => { let f = self.service.call(stream); - spawn(async move { + actix_rt::spawn(async move { let _ = f.await; drop(guard); }); - ok(()) + Ok(()) } Err(e) => { error!("Can not convert to an async tcp stream: {}", e); - err(()) + Err(()) } - } + }) } } @@ -129,22 +130,23 @@ where fn create(&self) -> LocalBoxFuture<'static, Result, ()>> { let token = self.token; - self.inner - .create() - .new_service(()) - .map_err(|_| ()) - .map_ok(move |inner| { - let service: BoxedServerService = Box::new(StreamService::new(inner)); - vec![(token, service)] - }) - .boxed_local() + let fut = self.inner.create().new_service(()); + Box::pin(async move { + match fut.await { + Ok(inner) => { + let service = Box::new(StreamService::new(inner)) as _; + Ok(vec![(token, service)]) + } + Err(_) => Err(()), + } + }) } } impl ServiceFactory for F where F: Fn() -> T + Send + Clone + 'static, - T: actix::ServiceFactory, + T: BaseServiceFactory, I: FromStream, { type Factory = T; diff --git a/actix-server/src/signals.rs b/actix-server/src/signals.rs index 4fc51fc1..0e3cef13 100644 --- a/actix-server/src/signals.rs +++ b/actix-server/src/signals.rs @@ -2,8 +2,6 @@ use std::future::Future; use std::pin::Pin; use std::task::{Context, Poll}; -use futures_util::future::lazy; - use crate::server::Server; /// Different types of process signals @@ -23,48 +21,49 @@ pub(crate) enum Signal { pub(crate) struct Signals { srv: Server, #[cfg(not(unix))] - stream: Pin>>>, + signals: futures_core::future::LocalBoxFuture<'static, std::io::Result<()>>, #[cfg(unix)] - streams: Vec<(Signal, actix_rt::signal::unix::Signal)>, + signals: Vec<(Signal, actix_rt::signal::unix::Signal)>, } impl Signals { pub(crate) fn start(srv: Server) { - actix_rt::spawn(lazy(|_| { - #[cfg(not(unix))] - { - actix_rt::spawn(Signals { - srv, - stream: Box::pin(actix_rt::signal::ctrl_c()), - }); - } - #[cfg(unix)] - { - use actix_rt::signal::unix; + #[cfg(not(unix))] + { + actix_rt::spawn(Signals { + srv, + signals: Box::pin(actix_rt::signal::ctrl_c()), + }); + } + #[cfg(unix)] + { + use actix_rt::signal::unix; - let mut streams = Vec::new(); + let sig_map = [ + (unix::SignalKind::interrupt(), Signal::Int), + (unix::SignalKind::hangup(), Signal::Hup), + (unix::SignalKind::terminate(), Signal::Term), + (unix::SignalKind::quit(), Signal::Quit), + ]; - let sig_map = [ - (unix::SignalKind::interrupt(), Signal::Int), - (unix::SignalKind::hangup(), Signal::Hup), - (unix::SignalKind::terminate(), Signal::Term), - (unix::SignalKind::quit(), Signal::Quit), - ]; + let signals = sig_map + .iter() + .filter_map(|(kind, sig)| { + unix::signal(*kind) + .map(|tokio_sig| (*sig, tokio_sig)) + .map_err(|e| { + log::error!( + "Can not initialize stream handler for {:?} err: {}", + sig, + e + ) + }) + .ok() + }) + .collect::>(); - for (kind, sig) in sig_map.iter() { - match unix::signal(*kind) { - Ok(stream) => streams.push((*sig, stream)), - Err(e) => log::error!( - "Can not initialize stream handler for {:?} err: {}", - sig, - e - ), - } - } - - actix_rt::spawn(Signals { srv, streams }) - } - })); + actix_rt::spawn(Signals { srv, signals }); + } } } @@ -73,25 +72,20 @@ impl Future for Signals { fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { #[cfg(not(unix))] - match Pin::new(&mut self.stream).poll(cx) { + match self.signals.as_mut().poll(cx) { Poll::Ready(_) => { self.srv.signal(Signal::Int); Poll::Ready(()) } - Poll::Pending => return Poll::Pending, + Poll::Pending => Poll::Pending, } #[cfg(unix)] { - for idx in 0..self.streams.len() { - loop { - match self.streams[idx].1.poll_recv(cx) { - Poll::Ready(None) => return Poll::Ready(()), - Poll::Pending => break, - Poll::Ready(Some(_)) => { - let sig = self.streams[idx].0; - self.srv.signal(sig); - } - } + for (sig, fut) in self.signals.iter_mut() { + if Pin::new(fut).poll_recv(cx).is_ready() { + let sig = *sig; + self.srv.signal(sig); + return Poll::Ready(()); } } Poll::Pending diff --git a/actix-server/src/socket.rs b/actix-server/src/socket.rs index 3025660a..416e253b 100644 --- a/actix-server/src/socket.rs +++ b/actix-server/src/socket.rs @@ -1,135 +1,91 @@ -use std::{fmt, io, net}; +pub(crate) use std::net::{ + SocketAddr as StdSocketAddr, TcpListener as StdTcpListener, ToSocketAddrs, +}; + +pub(crate) use mio::net::{TcpListener as MioTcpListener, TcpSocket as MioTcpSocket}; +#[cfg(unix)] +pub(crate) use { + mio::net::UnixListener as MioUnixListener, + std::os::unix::net::UnixListener as StdUnixListener, +}; + +use std::{fmt, io}; -use actix_codec::{AsyncRead, AsyncWrite}; use actix_rt::net::TcpStream; +use mio::event::Source; +use mio::net::TcpStream as MioTcpStream; +use mio::{Interest, Registry, Token}; -pub(crate) enum StdListener { - Tcp(net::TcpListener), - #[cfg(all(unix))] - Uds(std::os::unix::net::UnixListener), +#[cfg(windows)] +use std::os::windows::io::{FromRawSocket, IntoRawSocket}; +#[cfg(unix)] +use { + actix_rt::net::UnixStream, + mio::net::{SocketAddr as MioSocketAddr, UnixStream as MioUnixStream}, + std::os::unix::io::{FromRawFd, IntoRawFd}, +}; + +pub(crate) enum MioListener { + Tcp(MioTcpListener), + #[cfg(unix)] + Uds(MioUnixListener), } -pub(crate) enum SocketAddr { - Tcp(net::SocketAddr), - #[cfg(all(unix))] - Uds(std::os::unix::net::SocketAddr), -} - -impl fmt::Display for SocketAddr { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - match *self { - SocketAddr::Tcp(ref addr) => write!(f, "{}", addr), - #[cfg(all(unix))] - SocketAddr::Uds(ref addr) => write!(f, "{:?}", addr), - } - } -} - -impl fmt::Debug for SocketAddr { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - match *self { - SocketAddr::Tcp(ref addr) => write!(f, "{:?}", addr), - #[cfg(all(unix))] - SocketAddr::Uds(ref addr) => write!(f, "{:?}", addr), - } - } -} - -impl fmt::Display for StdListener { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - match *self { - StdListener::Tcp(ref lst) => write!(f, "{}", lst.local_addr().ok().unwrap()), - #[cfg(all(unix))] - StdListener::Uds(ref lst) => write!(f, "{:?}", lst.local_addr().ok().unwrap()), - } - } -} - -impl StdListener { +impl MioListener { pub(crate) fn local_addr(&self) -> SocketAddr { - match self { - StdListener::Tcp(lst) => SocketAddr::Tcp(lst.local_addr().unwrap()), - #[cfg(all(unix))] - StdListener::Uds(lst) => SocketAddr::Uds(lst.local_addr().unwrap()), - } - } - - pub(crate) fn into_listener(self) -> SocketListener { - match self { - StdListener::Tcp(lst) => SocketListener::Tcp( - mio::net::TcpListener::from_std(lst) - .expect("Can not create mio::net::TcpListener"), - ), - #[cfg(all(unix))] - StdListener::Uds(lst) => SocketListener::Uds( - mio_uds::UnixListener::from_listener(lst) - .expect("Can not create mio_uds::UnixListener"), - ), - } - } -} - -#[derive(Debug)] -pub enum StdStream { - Tcp(std::net::TcpStream), - #[cfg(all(unix))] - Uds(std::os::unix::net::UnixStream), -} - -pub(crate) enum SocketListener { - Tcp(mio::net::TcpListener), - #[cfg(all(unix))] - Uds(mio_uds::UnixListener), -} - -impl SocketListener { - pub(crate) fn accept(&self) -> io::Result> { match *self { - SocketListener::Tcp(ref lst) => lst - .accept_std() - .map(|(stream, addr)| Some((StdStream::Tcp(stream), SocketAddr::Tcp(addr)))), - #[cfg(all(unix))] - SocketListener::Uds(ref lst) => lst.accept_std().map(|res| { - res.map(|(stream, addr)| (StdStream::Uds(stream), SocketAddr::Uds(addr))) - }), + MioListener::Tcp(ref lst) => SocketAddr::Tcp(lst.local_addr().unwrap()), + #[cfg(unix)] + MioListener::Uds(ref lst) => SocketAddr::Uds(lst.local_addr().unwrap()), + } + } + + pub(crate) fn accept(&self) -> io::Result> { + match *self { + MioListener::Tcp(ref lst) => lst + .accept() + .map(|(stream, addr)| Some((MioStream::Tcp(stream), SocketAddr::Tcp(addr)))), + #[cfg(unix)] + MioListener::Uds(ref lst) => lst + .accept() + .map(|(stream, addr)| Some((MioStream::Uds(stream), SocketAddr::Uds(addr)))), } } } -impl mio::Evented for SocketListener { +impl Source for MioListener { fn register( - &self, - poll: &mio::Poll, - token: mio::Token, - interest: mio::Ready, - opts: mio::PollOpt, + &mut self, + registry: &Registry, + token: Token, + interests: Interest, ) -> io::Result<()> { match *self { - SocketListener::Tcp(ref lst) => lst.register(poll, token, interest, opts), - #[cfg(all(unix))] - SocketListener::Uds(ref lst) => lst.register(poll, token, interest, opts), + MioListener::Tcp(ref mut lst) => lst.register(registry, token, interests), + #[cfg(unix)] + MioListener::Uds(ref mut lst) => lst.register(registry, token, interests), } } fn reregister( - &self, - poll: &mio::Poll, - token: mio::Token, - interest: mio::Ready, - opts: mio::PollOpt, + &mut self, + registry: &Registry, + token: Token, + interests: Interest, ) -> io::Result<()> { match *self { - SocketListener::Tcp(ref lst) => lst.reregister(poll, token, interest, opts), - #[cfg(all(unix))] - SocketListener::Uds(ref lst) => lst.reregister(poll, token, interest, opts), + MioListener::Tcp(ref mut lst) => lst.reregister(registry, token, interests), + #[cfg(unix)] + MioListener::Uds(ref mut lst) => lst.reregister(registry, token, interests), } } - fn deregister(&self, poll: &mio::Poll) -> io::Result<()> { + + fn deregister(&mut self, registry: &Registry) -> io::Result<()> { match *self { - SocketListener::Tcp(ref lst) => lst.deregister(poll), - #[cfg(all(unix))] - SocketListener::Uds(ref lst) => { - let res = lst.deregister(poll); + MioListener::Tcp(ref mut lst) => lst.deregister(registry), + #[cfg(unix)] + MioListener::Uds(ref mut lst) => { + let res = lst.deregister(registry); // cleanup file path if let Ok(addr) = lst.local_addr() { @@ -143,28 +99,156 @@ impl mio::Evented for SocketListener { } } -pub trait FromStream: AsyncRead + AsyncWrite + Sized { - fn from_stdstream(sock: StdStream) -> io::Result; +impl From for MioListener { + fn from(lst: StdTcpListener) -> Self { + MioListener::Tcp(MioTcpListener::from_std(lst)) + } } -impl FromStream for TcpStream { - fn from_stdstream(sock: StdStream) -> io::Result { - match sock { - StdStream::Tcp(stream) => TcpStream::from_std(stream), +#[cfg(unix)] +impl From for MioListener { + fn from(lst: StdUnixListener) -> Self { + MioListener::Uds(MioUnixListener::from_std(lst)) + } +} + +impl fmt::Debug for MioListener { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match *self { + MioListener::Tcp(ref lst) => write!(f, "{:?}", lst), #[cfg(all(unix))] - StdStream::Uds(_) => { + MioListener::Uds(ref lst) => write!(f, "{:?}", lst), + } + } +} + +impl fmt::Display for MioListener { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match *self { + MioListener::Tcp(ref lst) => write!(f, "{}", lst.local_addr().ok().unwrap()), + #[cfg(unix)] + MioListener::Uds(ref lst) => write!(f, "{:?}", lst.local_addr().ok().unwrap()), + } + } +} + +pub(crate) enum SocketAddr { + Tcp(StdSocketAddr), + #[cfg(unix)] + Uds(MioSocketAddr), +} + +impl fmt::Display for SocketAddr { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match *self { + SocketAddr::Tcp(ref addr) => write!(f, "{}", addr), + #[cfg(unix)] + SocketAddr::Uds(ref addr) => write!(f, "{:?}", addr), + } + } +} + +impl fmt::Debug for SocketAddr { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match *self { + SocketAddr::Tcp(ref addr) => write!(f, "{:?}", addr), + #[cfg(unix)] + SocketAddr::Uds(ref addr) => write!(f, "{:?}", addr), + } + } +} + +#[derive(Debug)] +pub enum MioStream { + Tcp(MioTcpStream), + #[cfg(unix)] + Uds(MioUnixStream), +} + +/// helper trait for converting mio stream to tokio stream. +pub trait FromStream: Sized { + fn from_mio(sock: MioStream) -> io::Result; +} + +// FIXME: This is a workaround and we need an efficient way to convert between mio and tokio stream +#[cfg(unix)] +impl FromStream for TcpStream { + fn from_mio(sock: MioStream) -> io::Result { + match sock { + MioStream::Tcp(mio) => { + let raw = IntoRawFd::into_raw_fd(mio); + // SAFETY: This is a in place conversion from mio stream to tokio stream. + TcpStream::from_std(unsafe { FromRawFd::from_raw_fd(raw) }) + } + MioStream::Uds(_) => { panic!("Should not happen, bug in server impl"); } } } } -#[cfg(all(unix))] -impl FromStream for actix_rt::net::UnixStream { - fn from_stdstream(sock: StdStream) -> io::Result { +// FIXME: This is a workaround and we need an efficient way to convert between mio and tokio stream +#[cfg(windows)] +impl FromStream for TcpStream { + fn from_mio(sock: MioStream) -> io::Result { match sock { - StdStream::Tcp(_) => panic!("Should not happen, bug in server impl"), - StdStream::Uds(stream) => actix_rt::net::UnixStream::from_std(stream), + MioStream::Tcp(mio) => { + let raw = IntoRawSocket::into_raw_socket(mio); + // SAFETY: This is a in place conversion from mio stream to tokio stream. + TcpStream::from_std(unsafe { FromRawSocket::from_raw_socket(raw) }) + } + } + } +} + +// FIXME: This is a workaround and we need an efficient way to convert between mio and tokio stream +#[cfg(unix)] +impl FromStream for UnixStream { + fn from_mio(sock: MioStream) -> io::Result { + match sock { + MioStream::Tcp(_) => panic!("Should not happen, bug in server impl"), + MioStream::Uds(mio) => { + let raw = IntoRawFd::into_raw_fd(mio); + // SAFETY: This is a in place conversion from mio stream to tokio stream. + UnixStream::from_std(unsafe { FromRawFd::from_raw_fd(raw) }) + } + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn socket_addr() { + let addr = SocketAddr::Tcp("127.0.0.1:8080".parse().unwrap()); + assert!(format!("{:?}", addr).contains("127.0.0.1:8080")); + assert_eq!(format!("{}", addr), "127.0.0.1:8080"); + + let addr: StdSocketAddr = "127.0.0.1:0".parse().unwrap(); + let socket = MioTcpSocket::new_v4().unwrap(); + socket.set_reuseaddr(true).unwrap(); + socket.bind(addr).unwrap(); + let tcp = socket.listen(128).unwrap(); + let lst = MioListener::Tcp(tcp); + assert!(format!("{:?}", lst).contains("TcpListener")); + assert!(format!("{}", lst).contains("127.0.0.1")); + } + + #[test] + #[cfg(unix)] + fn uds() { + let _ = std::fs::remove_file("/tmp/sock.xxxxx"); + if let Ok(socket) = MioUnixListener::bind("/tmp/sock.xxxxx") { + let addr = socket.local_addr().expect("Couldn't get local address"); + let a = SocketAddr::Uds(addr); + assert!(format!("{:?}", a).contains("/tmp/sock.xxxxx")); + assert!(format!("{}", a).contains("/tmp/sock.xxxxx")); + + let lst = MioListener::Uds(socket); + assert!(format!("{:?}", lst).contains("/tmp/sock.xxxxx")); + assert!(format!("{}", lst).contains("/tmp/sock.xxxxx")); } } } diff --git a/actix-testing/src/lib.rs b/actix-server/src/test_server.rs similarity index 69% rename from actix-testing/src/lib.rs rename to actix-server/src/test_server.rs index efcdd394..864f391c 100644 --- a/actix-testing/src/lib.rs +++ b/actix-server/src/test_server.rs @@ -1,19 +1,9 @@ -//! Various helpers for Actix applications to use during testing. - -#![deny(rust_2018_idioms, nonstandard_style)] -#![allow(clippy::type_complexity, clippy::needless_doctest_main)] -#![doc(html_logo_url = "https://actix.rs/img/logo.png")] -#![doc(html_favicon_url = "https://actix.rs/favicon.ico")] - use std::sync::mpsc; use std::{net, thread}; use actix_rt::{net::TcpStream, System}; -use actix_server::{Server, ServerBuilder, ServiceFactory}; -use socket2::{Domain, Protocol, Socket, Type}; -#[cfg(not(test))] // Work around for rust-lang/rust#62127 -pub use actix_macros::test; +use crate::{Server, ServerBuilder, ServiceFactory}; /// The `TestServer` type. /// @@ -22,9 +12,9 @@ pub use actix_macros::test; /// /// # Examples /// -/// ```rust +/// ``` /// use actix_service::fn_service; -/// use actix_testing::TestServer; +/// use actix_server::TestServer; /// /// #[actix_rt::main] /// async fn main() { @@ -58,11 +48,8 @@ impl TestServer { // run server in separate thread thread::spawn(move || { - let sys = System::new("actix-test-server"); - factory(Server::build()) - .workers(1) - .disable_signals() - .start(); + let sys = System::new(); + factory(Server::build()).workers(1).disable_signals().run(); tx.send(System::current()).unwrap(); sys.run() @@ -83,17 +70,19 @@ impl TestServer { // run server in separate thread thread::spawn(move || { - let sys = System::new("actix-test-server"); + let sys = System::new(); 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.block_on(async { + Server::build() + .listen("test", tcp, factory) + .unwrap() + .workers(1) + .disable_signals() + .run(); + tx.send((System::current(), local_addr)).unwrap(); + }); sys.run() }); @@ -113,11 +102,10 @@ impl TestServer { /// Get first available unused local address pub fn unused_addr() -> net::SocketAddr { let addr: net::SocketAddr = "127.0.0.1:0".parse().unwrap(); - let socket = - Socket::new(Domain::ipv4(), Type::stream(), Some(Protocol::tcp())).unwrap(); - socket.bind(&addr.into()).unwrap(); - socket.set_reuse_address(true).unwrap(); - let tcp = socket.into_tcp_listener(); + let socket = mio::net::TcpSocket::new_v4().unwrap(); + socket.bind(addr).unwrap(); + socket.set_reuseaddr(true).unwrap(); + let tcp = socket.listen(1024).unwrap(); tcp.local_addr().unwrap() } } diff --git a/actix-server/src/waker_queue.rs b/actix-server/src/waker_queue.rs new file mode 100644 index 00000000..f92363b5 --- /dev/null +++ b/actix-server/src/waker_queue.rs @@ -0,0 +1,89 @@ +use std::{ + collections::VecDeque, + ops::Deref, + sync::{Arc, Mutex, MutexGuard}, +}; + +use mio::{Registry, Token as MioToken, Waker}; + +use crate::worker::WorkerHandle; + +/// waker token for `mio::Poll` instance +pub(crate) const WAKER_TOKEN: MioToken = MioToken(usize::MAX); + +/// `mio::Waker` with a queue for waking up the `Accept`'s `Poll` and contains the `WakerInterest` +/// the `Poll` would want to look into. +pub(crate) struct WakerQueue(Arc<(Waker, Mutex>)>); + +impl Clone for WakerQueue { + fn clone(&self) -> Self { + Self(self.0.clone()) + } +} + +impl Deref for WakerQueue { + type Target = (Waker, Mutex>); + + fn deref(&self) -> &Self::Target { + self.0.deref() + } +} + +impl WakerQueue { + /// construct a waker queue with given `Poll`'s `Registry` and capacity. + /// + /// A fixed `WAKER_TOKEN` is used to identify the wake interest and the `Poll` needs to match + /// event's token for it to properly handle `WakerInterest`. + pub(crate) fn new(registry: &Registry) -> std::io::Result { + let waker = Waker::new(registry, WAKER_TOKEN)?; + let queue = Mutex::new(VecDeque::with_capacity(16)); + + Ok(Self(Arc::new((waker, queue)))) + } + + /// push a new interest to the queue and wake up the accept poll afterwards. + pub(crate) fn wake(&self, interest: WakerInterest) { + let (waker, queue) = self.deref(); + + queue + .lock() + .expect("Failed to lock WakerQueue") + .push_back(interest); + + waker + .wake() + .unwrap_or_else(|e| panic!("can not wake up Accept Poll: {}", e)); + } + + /// get a MutexGuard of the waker queue. + pub(crate) fn guard(&self) -> MutexGuard<'_, VecDeque> { + self.deref().1.lock().expect("Failed to lock WakerQueue") + } + + /// reset the waker queue so it does not grow infinitely. + pub(crate) fn reset(queue: &mut VecDeque) { + std::mem::swap(&mut VecDeque::::with_capacity(16), queue); + } +} + +/// types of interests we would look into when `Accept`'s `Poll` is waked up by waker. +/// +/// *. These interests should not be confused with `mio::Interest` and mostly not I/O related +pub(crate) enum WakerInterest { + /// `WorkerAvailable` is an interest from `Worker` notifying `Accept` there is a worker + /// available and can accept new tasks. + WorkerAvailable, + /// `Pause`, `Resume`, `Stop` Interest are from `ServerBuilder` future. It listens to + /// `ServerCommand` and notify `Accept` to do exactly these tasks. + Pause, + Resume, + Stop, + /// `Timer` is an interest sent as a delayed future. When an error happens on accepting + /// connection `Accept` would deregister socket listener temporary and wake up the poll and + /// register them again after the delayed future resolve. + Timer, + /// `Worker` is an interest happen after a worker runs into faulted state(This is determined + /// by if work can be sent to it successfully).`Accept` would be waked up and add the new + /// `WorkerHandle`. + Worker(WorkerHandle), +} diff --git a/actix-server/src/worker.rs b/actix-server/src/worker.rs index bfd11979..defc7306 100644 --- a/actix-server/src/worker.rs +++ b/actix-server/src/worker.rs @@ -1,22 +1,22 @@ +use std::future::Future; use std::pin::Pin; use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; use std::sync::Arc; use std::task::{Context, Poll}; -use std::time; +use std::time::Duration; -use actix_rt::time::{delay_until, Delay, Instant}; +use actix_rt::time::{sleep_until, Instant, Sleep}; use actix_rt::{spawn, Arbiter}; use actix_utils::counter::Counter; -use futures_channel::mpsc::{unbounded, UnboundedReceiver, UnboundedSender}; -use futures_channel::oneshot; -use futures_util::future::{join_all, LocalBoxFuture, MapOk}; -use futures_util::{future::Future, stream::Stream, FutureExt, TryFutureExt}; +use futures_core::future::LocalBoxFuture; use log::{error, info, trace}; +use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender}; +use tokio::sync::oneshot; -use crate::accept::AcceptNotify; use crate::service::{BoxedServerService, InternalServiceFactory}; -use crate::socket::{SocketAddr, StdStream}; -use crate::Token; +use crate::socket::{MioStream, SocketAddr}; +use crate::waker_queue::{WakerInterest, WakerQueue}; +use crate::{join_all, Token}; pub(crate) struct WorkerCommand(Conn); @@ -29,7 +29,7 @@ pub(crate) struct StopCommand { #[derive(Debug)] pub(crate) struct Conn { - pub io: StdStream, + pub io: MioStream, pub token: Token, pub peer: Option, } @@ -46,31 +46,33 @@ pub fn max_concurrent_connections(num: usize) { MAX_CONNS.store(num, Ordering::Relaxed); } -pub(crate) fn num_connections() -> usize { - MAX_CONNS_COUNTER.with(|conns| conns.total()) -} - thread_local! { static MAX_CONNS_COUNTER: Counter = Counter::new(MAX_CONNS.load(Ordering::Relaxed)); } +pub(crate) fn num_connections() -> usize { + MAX_CONNS_COUNTER.with(|conns| conns.total()) +} + +// a handle to worker that can send message to worker and share the availability of worker to other +// thread. #[derive(Clone)] -pub(crate) struct WorkerClient { +pub(crate) struct WorkerHandle { pub idx: usize, tx1: UnboundedSender, tx2: UnboundedSender, avail: WorkerAvailability, } -impl WorkerClient { +impl WorkerHandle { pub fn new( idx: usize, tx1: UnboundedSender, tx2: UnboundedSender, avail: WorkerAvailability, ) -> Self { - WorkerClient { + WorkerHandle { idx, tx1, tx2, @@ -79,9 +81,7 @@ impl WorkerClient { } pub fn send(&self, msg: Conn) -> Result<(), Conn> { - self.tx1 - .unbounded_send(WorkerCommand(msg)) - .map_err(|msg| msg.into_inner().0) + self.tx1.send(WorkerCommand(msg)).map_err(|msg| msg.0 .0) } pub fn available(&self) -> bool { @@ -90,21 +90,21 @@ impl WorkerClient { pub fn stop(&self, graceful: bool) -> oneshot::Receiver { let (result, rx) = oneshot::channel(); - let _ = self.tx2.unbounded_send(StopCommand { graceful, result }); + let _ = self.tx2.send(StopCommand { graceful, result }); rx } } #[derive(Clone)] pub(crate) struct WorkerAvailability { - notify: AcceptNotify, + waker: WakerQueue, available: Arc, } impl WorkerAvailability { - pub fn new(notify: AcceptNotify) -> Self { + pub fn new(waker: WakerQueue) -> Self { WorkerAvailability { - notify, + waker, available: Arc::new(AtomicBool::new(false)), } } @@ -115,17 +115,17 @@ impl WorkerAvailability { pub fn set(&self, val: bool) { let old = self.available.swap(val, Ordering::Release); + // notify the accept on switched to available. if !old && val { - self.notify.notify() + self.waker.wake(WakerInterest::WorkerAvailable); } } } -/// Service worker +/// Service worker. /// -/// Worker accepts Socket objects via unbounded channel and starts stream -/// processing. -pub(crate) struct Worker { +/// Worker accepts Socket objects via unbounded channel and starts stream processing. +pub(crate) struct ServerWorker { rx: UnboundedReceiver, rx2: UnboundedReceiver, services: Vec, @@ -133,7 +133,7 @@ pub(crate) struct Worker { conns: Counter, factories: Vec>, state: WorkerState, - shutdown_timeout: time::Duration, + config: ServerWorkerConfig, } struct WorkerService { @@ -159,68 +159,108 @@ enum WorkerServiceStatus { Stopped, } -impl Worker { +/// Config for worker behavior passed down from server builder. +#[derive(Copy, Clone)] +pub(crate) struct ServerWorkerConfig { + shutdown_timeout: Duration, + max_blocking_threads: usize, +} + +impl Default for ServerWorkerConfig { + fn default() -> Self { + // 512 is the default max blocking thread count of tokio runtime. + let max_blocking_threads = std::cmp::max(512 / num_cpus::get(), 1); + Self { + shutdown_timeout: Duration::from_secs(30), + max_blocking_threads, + } + } +} + +impl ServerWorkerConfig { + pub(crate) fn max_blocking_threads(&mut self, num: usize) { + self.max_blocking_threads = num; + } + + pub(crate) fn shutdown_timeout(&mut self, dur: Duration) { + self.shutdown_timeout = dur; + } +} + +impl ServerWorker { pub(crate) fn start( idx: usize, factories: Vec>, availability: WorkerAvailability, - shutdown_timeout: time::Duration, - ) -> WorkerClient { - let (tx1, rx) = unbounded(); - let (tx2, rx2) = unbounded(); + config: ServerWorkerConfig, + ) -> WorkerHandle { + let (tx1, rx) = unbounded_channel(); + let (tx2, rx2) = unbounded_channel(); let avail = availability.clone(); - Arbiter::new().send( - async move { - availability.set(false); - let mut wrk = MAX_CONNS_COUNTER.with(move |conns| Worker { - rx, - rx2, - availability, - factories, - shutdown_timeout, - services: Vec::new(), - conns: conns.clone(), - state: WorkerState::Unavailable(Vec::new()), - }); + // every worker runs in it's own arbiter. + // use a custom tokio runtime builder to change the settings of runtime. + Arbiter::with_tokio_rt(move || { + tokio::runtime::Builder::new_current_thread() + .enable_all() + .max_blocking_threads(config.max_blocking_threads) + .build() + .unwrap() + }) + .spawn(async move { + availability.set(false); + let mut wrk = MAX_CONNS_COUNTER.with(move |conns| ServerWorker { + rx, + rx2, + availability, + factories, + config, + services: Vec::new(), + conns: conns.clone(), + state: WorkerState::Unavailable, + }); - let mut fut: Vec, _>> = Vec::new(); - for (idx, factory) in wrk.factories.iter().enumerate() { - fut.push(factory.create().map_ok(move |r| { - r.into_iter() - .map(|(t, s): (Token, _)| (idx, t, s)) - .collect::>() - })); - } + let fut = wrk + .factories + .iter() + .enumerate() + .map(|(idx, factory)| { + let fut = factory.create(); + async move { + fut.await.map(|r| { + r.into_iter().map(|(t, s)| (idx, t, s)).collect::>() + }) + } + }) + .collect::>(); - spawn(async move { - let res = join_all(fut).await; - let res: Result, _> = res.into_iter().collect(); - match res { - Ok(services) => { - for item in services { - for (factory, token, service) in item { - assert_eq!(token.0, wrk.services.len()); - wrk.services.push(WorkerService { - factory, - service, - status: WorkerServiceStatus::Unavailable, - }); - } + // a second spawn to make sure worker future runs as non boxed future. + // As Arbiter::spawn would box the future before send it to arbiter. + spawn(async move { + let res: Result, _> = join_all(fut).await.into_iter().collect(); + match res { + Ok(services) => { + for item in services { + for (factory, token, service) in item { + assert_eq!(token.0, wrk.services.len()); + wrk.services.push(WorkerService { + factory, + service, + status: WorkerServiceStatus::Unavailable, + }); } } - Err(e) => { - error!("Can not start worker: {:?}", e); - Arbiter::current().stop(); - } } - wrk.await - }); - } - .boxed(), - ); + Err(e) => { + error!("Can not start worker: {:?}", e); + Arbiter::current().stop(); + } + } + wrk.await + }); + }); - WorkerClient::new(idx, tx1, tx2, avail) + WorkerHandle::new(idx, tx1, tx2, avail) } fn shutdown(&mut self, force: bool) { @@ -242,7 +282,7 @@ impl Worker { fn check_readiness(&mut self, cx: &mut Context<'_>) -> Result { let mut ready = self.conns.available(cx); let mut failed = None; - for (idx, srv) in &mut self.services.iter_mut().enumerate() { + for (idx, srv) in self.services.iter_mut().enumerate() { if srv.status == WorkerServiceStatus::Available || srv.status == WorkerServiceStatus::Unavailable { @@ -288,29 +328,26 @@ impl Worker { enum WorkerState { Available, - Unavailable(Vec), + Unavailable, Restarting( usize, Token, - #[allow(clippy::type_complexity)] - Pin, ()>>>>, + LocalBoxFuture<'static, Result, ()>>, ), Shutdown( - Pin>, - Pin>, + Pin>, + Pin>, Option>, ), } -impl Future for Worker { +impl Future for ServerWorker { type Output = (); - // FIXME: remove this attribute - #[allow(clippy::never_loop)] fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { // `StopWorker` message handler if let Poll::Ready(Some(StopCommand { graceful, result })) = - Pin::new(&mut self.rx2).poll_next(cx) + Pin::new(&mut self.rx2).poll_recv(cx) { self.availability.set(false); let num = num_connections(); @@ -324,8 +361,8 @@ impl Future for Worker { if num != 0 { info!("Graceful worker shutdown, {} connections", num); self.state = WorkerState::Shutdown( - Box::pin(delay_until(Instant::now() + time::Duration::from_secs(1))), - Box::pin(delay_until(Instant::now() + self.shutdown_timeout)), + Box::pin(sleep_until(Instant::now() + Duration::from_secs(1))), + Box::pin(sleep_until(Instant::now() + self.config.shutdown_timeout)), Some(result), ); } else { @@ -341,53 +378,35 @@ impl Future for Worker { } match self.state { - WorkerState::Unavailable(ref mut conns) => { - let conn = conns.pop(); - match self.check_readiness(cx) { - Ok(true) => { - // process requests from wait queue - if let Some(conn) = conn { - let guard = self.conns.get(); - let _ = self.services[conn.token.0] - .service - .call((Some(guard), conn.io)); - } else { - self.state = WorkerState::Available; - self.availability.set(true); - } - self.poll(cx) - } - Ok(false) => { - // push connection back to queue - if let Some(conn) = conn { - if let WorkerState::Unavailable(ref mut conns) = self.state { - conns.push(conn); - } - } - Poll::Pending - } - Err((token, idx)) => { - trace!( - "Service {:?} failed, restarting", - self.factories[idx].name(token) - ); - self.services[token.0].status = WorkerServiceStatus::Restarting; - self.state = - WorkerState::Restarting(idx, token, self.factories[idx].create()); - self.poll(cx) - } + WorkerState::Unavailable => match self.check_readiness(cx) { + Ok(true) => { + self.state = WorkerState::Available; + self.availability.set(true); + self.poll(cx) } - } + Ok(false) => Poll::Pending, + Err((token, idx)) => { + trace!( + "Service {:?} failed, restarting", + self.factories[idx].name(token) + ); + self.services[token.0].status = WorkerServiceStatus::Restarting; + self.state = + WorkerState::Restarting(idx, token, self.factories[idx].create()); + self.poll(cx) + } + }, WorkerState::Restarting(idx, token, ref mut fut) => { - match Pin::new(fut).poll(cx) { + match fut.as_mut().poll(cx) { Poll::Ready(Ok(item)) => { - for (token, service) in item { + // only interest in the first item? + if let Some((token, service)) = item.into_iter().next() { trace!( "Service {:?} has been restarted", self.factories[idx].name(token) ); self.services[token.0].created(service); - self.state = WorkerState::Unavailable(Vec::new()); + self.state = WorkerState::Unavailable; return self.poll(cx); } } @@ -397,9 +416,7 @@ impl Future for Worker { self.factories[idx].name(token) ); } - Poll::Pending => { - return Poll::Pending; - } + Poll::Pending => return Poll::Pending, } self.poll(cx) } @@ -412,71 +429,56 @@ impl Future for Worker { } // check graceful timeout - match t2.as_mut().poll(cx) { - Poll::Pending => (), - Poll::Ready(_) => { - let _ = tx.take().unwrap().send(false); - self.shutdown(true); - Arbiter::current().stop(); - return Poll::Ready(()); - } + if Pin::new(t2).poll(cx).is_ready() { + let _ = tx.take().unwrap().send(false); + self.shutdown(true); + Arbiter::current().stop(); + return Poll::Ready(()); } // sleep for 1 second and then check again - match t1.as_mut().poll(cx) { - Poll::Pending => (), - Poll::Ready(_) => { - *t1 = Box::pin(delay_until( - Instant::now() + time::Duration::from_secs(1), - )); - let _ = t1.as_mut().poll(cx); - } + if t1.as_mut().poll(cx).is_ready() { + *t1 = Box::pin(sleep_until(Instant::now() + Duration::from_secs(1))); + let _ = t1.as_mut().poll(cx); } + Poll::Pending } - WorkerState::Available => { - loop { - match Pin::new(&mut self.rx).poll_next(cx) { - // handle incoming io stream - Poll::Ready(Some(WorkerCommand(msg))) => { - match self.check_readiness(cx) { - Ok(true) => { - let guard = self.conns.get(); - let _ = self.services[msg.token.0] - .service - .call((Some(guard), msg.io)); - continue; - } - Ok(false) => { - trace!("Worker is unavailable"); - self.availability.set(false); - self.state = WorkerState::Unavailable(vec![msg]); - } - Err((token, idx)) => { - trace!( - "Service {:?} failed, restarting", - self.factories[idx].name(token) - ); - self.availability.set(false); - self.services[token.0].status = - WorkerServiceStatus::Restarting; - self.state = WorkerState::Restarting( - idx, - token, - self.factories[idx].create(), - ); - } - } - return self.poll(cx); - } - Poll::Pending => { - self.state = WorkerState::Available; - return Poll::Pending; - } - Poll::Ready(None) => return Poll::Ready(()), + // actively poll stream and handle worker command + WorkerState::Available => loop { + match self.check_readiness(cx) { + Ok(true) => (), + Ok(false) => { + trace!("Worker is unavailable"); + self.availability.set(false); + self.state = WorkerState::Unavailable; + return self.poll(cx); + } + Err((token, idx)) => { + trace!( + "Service {:?} failed, restarting", + self.factories[idx].name(token) + ); + self.availability.set(false); + self.services[token.0].status = WorkerServiceStatus::Restarting; + self.state = + WorkerState::Restarting(idx, token, self.factories[idx].create()); + return self.poll(cx); } } - } + + match Pin::new(&mut self.rx).poll_recv(cx) { + // handle incoming io stream + Poll::Ready(Some(WorkerCommand(msg))) => { + let guard = self.conns.get(); + let _ = self.services[msg.token.0] + .service + .call((Some(guard), msg.io)); + } + Poll::Pending => return Poll::Pending, + Poll::Ready(None) => return Poll::Ready(()), + }; + }, } } } diff --git a/actix-server/tests/test_server.rs b/actix-server/tests/test_server.rs index 4f987781..01a8ccbe 100644 --- a/actix-server/tests/test_server.rs +++ b/actix-server/tests/test_server.rs @@ -5,14 +5,13 @@ use std::{net, thread, time}; use actix_server::Server; use actix_service::fn_service; use futures_util::future::{lazy, ok}; -use socket2::{Domain, Protocol, Socket, Type}; fn unused_addr() -> net::SocketAddr { let addr: net::SocketAddr = "127.0.0.1:0".parse().unwrap(); - let socket = Socket::new(Domain::ipv4(), Type::stream(), Some(Protocol::tcp())).unwrap(); - socket.bind(&addr.into()).unwrap(); - socket.set_reuse_address(true).unwrap(); - let tcp = socket.into_tcp_listener(); + let socket = mio::net::TcpSocket::new_v4().unwrap(); + socket.bind(addr).unwrap(); + socket.set_reuseaddr(true).unwrap(); + let tcp = socket.listen(32).unwrap(); tcp.local_addr().unwrap() } @@ -22,13 +21,15 @@ fn test_bind() { let (tx, rx) = mpsc::channel(); let h = thread::spawn(move || { - let sys = actix_rt::System::new("test"); - let srv = Server::build() - .workers(1) - .disable_signals() - .bind("test", addr, move || fn_service(|_| ok::<_, ()>(()))) - .unwrap() - .start(); + let sys = actix_rt::System::new(); + let srv = sys.block_on(lazy(|_| { + Server::build() + .workers(1) + .disable_signals() + .bind("test", addr, move || fn_service(|_| ok::<_, ()>(()))) + .unwrap() + .run() + })); let _ = tx.send((srv, actix_rt::System::current())); let _ = sys.run(); }); @@ -46,15 +47,17 @@ fn test_listen() { let (tx, rx) = mpsc::channel(); let h = thread::spawn(move || { - let sys = actix_rt::System::new("test"); + let sys = actix_rt::System::new(); let lst = net::TcpListener::bind(addr).unwrap(); - Server::build() - .disable_signals() - .workers(1) - .listen("test", lst, move || fn_service(|_| ok::<_, ()>(()))) - .unwrap() - .start(); - let _ = tx.send(actix_rt::System::current()); + sys.block_on(async { + Server::build() + .disable_signals() + .workers(1) + .listen("test", lst, move || fn_service(|_| ok::<_, ()>(()))) + .unwrap() + .run(); + let _ = tx.send(actix_rt::System::current()); + }); let _ = sys.run(); }); let sys = rx.recv().unwrap(); @@ -78,23 +81,26 @@ fn test_start() { let (tx, rx) = mpsc::channel(); let h = thread::spawn(move || { - let sys = actix_rt::System::new("test"); - let srv: Server = Server::build() - .backlog(100) - .disable_signals() - .bind("test", addr, move || { - fn_service(|io: TcpStream| async move { - let mut f = Framed::new(io, BytesCodec); - f.send(Bytes::from_static(b"test")).await.unwrap(); - Ok::<_, ()>(()) + let sys = actix_rt::System::new(); + let srv = sys.block_on(lazy(|_| { + Server::build() + .backlog(100) + .disable_signals() + .bind("test", addr, move || { + fn_service(|io: TcpStream| async move { + let mut f = Framed::new(io, BytesCodec); + f.send(Bytes::from_static(b"test")).await.unwrap(); + Ok::<_, ()>(()) + }) }) - }) - .unwrap() - .start(); + .unwrap() + .run() + })); let _ = tx.send((srv, actix_rt::System::current())); let _ = sys.run(); }); + let (srv, sys) = rx.recv().unwrap(); let mut buf = [1u8; 4]; @@ -144,29 +150,31 @@ fn test_configure() { let h = thread::spawn(move || { let num = num2.clone(); - let sys = actix_rt::System::new("test"); - let srv = Server::build() - .disable_signals() - .configure(move |cfg| { - let num = num.clone(); - let lst = net::TcpListener::bind(addr3).unwrap(); - cfg.bind("addr1", addr1) - .unwrap() - .bind("addr2", addr2) - .unwrap() - .listen("addr3", lst) - .apply(move |rt| { - let num = num.clone(); - rt.service("addr1", fn_service(|_| ok::<_, ()>(()))); - rt.service("addr3", fn_service(|_| ok::<_, ()>(()))); - rt.on_start(lazy(move |_| { - let _ = num.fetch_add(1, Ordering::Relaxed); - })) - }) - }) - .unwrap() - .workers(1) - .start(); + let sys = actix_rt::System::new(); + let srv = sys.block_on(lazy(|_| { + Server::build() + .disable_signals() + .configure(move |cfg| { + let num = num.clone(); + let lst = net::TcpListener::bind(addr3).unwrap(); + cfg.bind("addr1", addr1) + .unwrap() + .bind("addr2", addr2) + .unwrap() + .listen("addr3", lst) + .apply(move |rt| { + let num = num.clone(); + rt.service("addr1", fn_service(|_| ok::<_, ()>(()))); + rt.service("addr3", fn_service(|_| ok::<_, ()>(()))); + rt.on_start(lazy(move |_| { + let _ = num.fetch_add(1, Ordering::Relaxed); + })) + }) + }) + .unwrap() + .workers(1) + .run() + })); let _ = tx.send((srv, actix_rt::System::current())); let _ = sys.run(); }); @@ -194,41 +202,40 @@ fn test_on_stop_graceful() { let addr = unused_addr(); let (tx, rx) = mpsc::channel(); - let h = thread::spawn({ + thread::spawn({ let bool = bool.clone(); move || { - let sys = actix_rt::System::new("test"); - let srv: Server = Server::build() - .backlog(100) - .disable_signals() - .on_stop(|| async move { - bool.store(true, Ordering::SeqCst); - }) - .bind("test", addr, move || { - fn_service(|io: TcpStream| async move { - let mut f = Framed::new(io, BytesCodec); - f.send(Bytes::from_static(b"test")).await.unwrap(); - Ok::<_, ()>(()) + actix_rt::System::new().block_on(async { + let srv = Server::build() + .backlog(100) + .disable_signals() + .on_stop(move || { + let bool = bool.clone(); + async move { + bool.store(true, Ordering::SeqCst); + } }) - }) - .unwrap() - .start(); + .bind("test", addr, move || { + fn_service(|io: TcpStream| async move { + let mut f = Framed::new(io, BytesCodec); + f.send(Bytes::from_static(b"test")).await.unwrap(); + Ok::<_, ()>(()) + }) + }) + .unwrap() + .run(); - let _ = tx.send((srv, actix_rt::System::current())); - let _ = sys.run(); + tx.send(srv.clone()).unwrap(); + + srv.await + }) } }); - let (srv, sys) = rx.recv().unwrap(); - + let srv = rx.recv().unwrap(); let _ = srv.stop(true); - - thread::sleep(time::Duration::from_millis(100)); - + thread::sleep(time::Duration::from_millis(300)); assert!(bool.load(Ordering::SeqCst)); - - sys.stop(); - let _ = h.join(); } #[test] @@ -244,39 +251,38 @@ fn test_on_stop_force() { let addr = unused_addr(); let (tx, rx) = mpsc::channel(); - let h = thread::spawn({ + thread::spawn({ let bool = bool.clone(); move || { - let sys = actix_rt::System::new("test"); - let srv: Server = Server::build() - .backlog(100) - .disable_signals() - .on_stop(|| async move { - bool.store(true, Ordering::SeqCst); - }) - .bind("test", addr, move || { - fn_service(|io: TcpStream| async move { - let mut f = Framed::new(io, BytesCodec); - f.send(Bytes::from_static(b"test")).await.unwrap(); - Ok::<_, ()>(()) + actix_rt::System::new().block_on(async { + let srv = Server::build() + .backlog(100) + .disable_signals() + .on_stop(move || { + let bool = bool.clone(); + async move { + bool.store(true, Ordering::SeqCst); + } }) - }) - .unwrap() - .start(); + .bind("test", addr, move || { + fn_service(|io: TcpStream| async move { + let mut f = Framed::new(io, BytesCodec); + f.send(Bytes::from_static(b"test")).await.unwrap(); + Ok::<_, ()>(()) + }) + }) + .unwrap() + .run(); - let _ = tx.send((srv, actix_rt::System::current())); - let _ = sys.run(); + tx.send(srv.clone()).unwrap(); + + srv.await + }) } }); - let (srv, sys) = rx.recv().unwrap(); - + let srv = rx.recv().unwrap(); let _ = srv.stop(false); - - thread::sleep(time::Duration::from_millis(100)); - + thread::sleep(time::Duration::from_millis(300)); assert!(bool.load(Ordering::SeqCst)); - - sys.stop(); - let _ = h.join(); } diff --git a/actix-service/CHANGES.md b/actix-service/CHANGES.md index 82481f46..f5da9d2e 100644 --- a/actix-service/CHANGES.md +++ b/actix-service/CHANGES.md @@ -1,13 +1,50 @@ # Changes -## Unreleased - 2020-xx-xx -* Upgrade `pin-project` to `1.0`. +## Unreleased - 2021-xx-xx + + +## 2.0.0-beta.4 - 2021-02-04 +* `Service::poll_ready` and `Service::call` receive `&self`. [#247] +* `apply_fn` and `apply_fn_factory` now receive `Fn(Req, &Service)` function type. [#247] +* `apply_cfg` and `apply_cfg_factory` now receive `Fn(Req, &Service)` function type. [#247] +* `fn_service` and friends now receive `Fn(Req)` function type. [#247] + +[#247]: https://github.com/actix/actix-net/pull/247 + + +## 2.0.0-beta.3 - 2021-01-09 +* The `forward_ready!` macro converts errors. [#246] + +[#246]: https://github.com/actix/actix-net/pull/246 + + +## 2.0.0-beta.2 - 2021-01-03 +* Remove redundant type parameter from `map_config`. + + +## 2.0.0-beta.1 - 2020-12-28 +* `Service`, other traits, and many type signatures now take the the request type as a type + parameter instead of an associated type. [#232] +* Add `always_ready!` and `forward_ready!` macros. [#233] +* Crate is now `no_std`. [#233] +* Migrate pin projections to `pin-project-lite`. [#233] +* Remove `AndThenApplyFn` and Pipeline `and_then_apply_fn`. Use the + `.and_then(apply_fn(...))` construction. [#233] +* Move non-vital methods to `ServiceExt` and `ServiceFactoryExt` extension traits. [#235] + +[#232]: https://github.com/actix/actix-net/pull/232 +[#233]: https://github.com/actix/actix-net/pull/233 +[#235]: https://github.com/actix/actix-net/pull/235 + ## 1.0.6 - 2020-08-09 ### Fixed -* Removed unsound custom Cell implementation that allowed obtaining several mutable references to the same data, which is undefined behavior in Rust and could lead to violations of memory safety. External code could obtain several mutable references to the same data through service combinators. Attempts to acquire several mutable references to the same data will instead result in a panic. +* Removed unsound custom Cell implementation that allowed obtaining several mutable references to + the same data, which is undefined behavior in Rust and could lead to violations of memory safety. External code could obtain several mutable references to the same data through + service combinators. Attempts to acquire several mutable references to the same data will instead + result in a panic. ## [1.0.5] - 2020-01-16 diff --git a/actix-service/Cargo.toml b/actix-service/Cargo.toml index 1505873b..eecf4669 100644 --- a/actix-service/Cargo.toml +++ b/actix-service/Cargo.toml @@ -1,7 +1,11 @@ [package] name = "actix-service" -version = "1.0.6" -authors = ["Nikolay Kim "] +version = "2.0.0-beta.4" +authors = [ + "Nikolay Kim ", + "Rob Ede ", + "fakeshadow <24548779@qq.com>", +] description = "Service trait and combinators for representing asynchronous request/response operations." keywords = ["network", "framework", "async", "futures", "service"] homepage = "https://actix.rs" @@ -17,17 +21,9 @@ name = "actix_service" path = "src/lib.rs" [dependencies] -futures-util = "0.3.1" -pin-project = "1.0.0" +futures-core = { version = "0.3.7", default-features = false } +pin-project-lite = "0.2" [dev-dependencies] -actix-rt = "1.0.0" -criterion = "0.3" - -[[bench]] -name = "unsafecell_vs_refcell" -harness = false - -[[bench]] -name = "and_then" -harness = false +actix-rt = "2.0.0" +futures-util = { version = "0.3.7", default-features = false } diff --git a/actix-service/README.md b/actix-service/README.md index 73108a36..28c38295 100644 --- a/actix-service/README.md +++ b/actix-service/README.md @@ -2,6 +2,12 @@ > Service trait and combinators for representing asynchronous request/response operations. -See documentation for detailed explanations these components: [https://docs.rs/actix-service][docs]. +[![crates.io](https://img.shields.io/crates/v/actix-service?label=latest)](https://crates.io/crates/actix-service) +[![Documentation](https://docs.rs/actix-service/badge.svg?version=2.0.0-beta.4)](https://docs.rs/actix-service/2.0.0-beta.4) +[![Version](https://img.shields.io/badge/rustc-1.46+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html) +![License](https://img.shields.io/crates/l/actix-service.svg) +[![Dependency Status](https://deps.rs/crate/actix-service/2.0.0-beta.4/status.svg)](https://deps.rs/crate/actix-service/2.0.0-beta.4) +[![Download](https://img.shields.io/crates/d/actix-service.svg)](https://crates.io/crates/actix-service) +[![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x) -[docs]: https://docs.rs/actix-service +See documentation for detailed explanations of these components: https://docs.rs/actix-service. diff --git a/actix-service/benches/and_then.rs b/actix-service/benches/and_then.rs deleted file mode 100644 index f4174dd7..00000000 --- a/actix-service/benches/and_then.rs +++ /dev/null @@ -1,332 +0,0 @@ -use actix_service::boxed::BoxFuture; -use actix_service::IntoService; -use actix_service::Service; -/// Benchmark various implementations of and_then -use criterion::{criterion_main, Criterion}; -use futures_util::future::join_all; -use futures_util::future::TryFutureExt; -use std::cell::{RefCell, UnsafeCell}; -use std::future::Future; -use std::pin::Pin; -use std::rc::Rc; -use std::task::{Context, Poll}; - -/* - * Test services A,B for AndThen service implementations - */ - -async fn svc1(_: ()) -> Result { - Ok(1) -} - -async fn svc2(req: usize) -> Result { - Ok(req + 1) -} - -/* - * AndThenUC - original AndThen service based on UnsafeCell - * Cut down version of actix_service::AndThenService based on actix-service::Cell - */ - -struct AndThenUC(Rc>); - -impl AndThenUC { - fn new(a: A, b: B) -> Self - where - A: Service, - B: Service, - { - Self(Rc::new(UnsafeCell::new((a, b)))) - } -} - -impl Clone for AndThenUC { - fn clone(&self) -> Self { - Self(self.0.clone()) - } -} - -impl Service for AndThenUC -where - A: Service, - B: Service, -{ - type Request = A::Request; - type Response = B::Response; - type Error = A::Error; - type Future = AndThenServiceResponse; - - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { - Poll::Ready(Ok(())) - } - - fn call(&mut self, req: A::Request) -> Self::Future { - let fut = unsafe { &mut *(*self.0).get() }.0.call(req); - AndThenServiceResponse { - state: State::A(fut, Some(self.0.clone())), - } - } -} - -#[pin_project::pin_project] -pub(crate) struct AndThenServiceResponse -where - A: Service, - B: Service, -{ - #[pin] - state: State, -} - -#[pin_project::pin_project(project = StateProj)] -enum State -where - A: Service, - B: Service, -{ - A(#[pin] A::Future, Option>>), - B(#[pin] B::Future), - Empty, -} - -impl Future for AndThenServiceResponse -where - A: Service, - B: Service, -{ - type Output = Result; - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - let mut this = self.as_mut().project(); - - match this.state.as_mut().project() { - StateProj::A(fut, b) => match fut.poll(cx)? { - Poll::Ready(res) => { - let b = b.take().unwrap(); - this.state.set(State::Empty); // drop fut A - let fut = unsafe { &mut (*b.get()).1 }.call(res); - this.state.set(State::B(fut)); - self.poll(cx) - } - Poll::Pending => Poll::Pending, - }, - StateProj::B(fut) => fut.poll(cx).map(|r| { - this.state.set(State::Empty); - r - }), - StateProj::Empty => { - panic!("future must not be polled after it returned `Poll::Ready`") - } - } - } -} - -/* - * AndThenRC - AndThen service based on RefCell - */ - -struct AndThenRC(Rc>); - -impl AndThenRC { - fn new(a: A, b: B) -> Self - where - A: Service, - B: Service, - { - Self(Rc::new(RefCell::new((a, b)))) - } -} - -impl Clone for AndThenRC { - fn clone(&self) -> Self { - Self(self.0.clone()) - } -} - -impl Service for AndThenRC -where - A: Service, - B: Service, -{ - type Request = A::Request; - type Response = B::Response; - type Error = A::Error; - type Future = AndThenServiceResponseRC; - - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { - Poll::Ready(Ok(())) - } - - fn call(&mut self, req: A::Request) -> Self::Future { - let fut = self.0.borrow_mut().0.call(req); - AndThenServiceResponseRC { - state: StateRC::A(fut, Some(self.0.clone())), - } - } -} - -#[pin_project::pin_project] -pub(crate) struct AndThenServiceResponseRC -where - A: Service, - B: Service, -{ - #[pin] - state: StateRC, -} - -#[pin_project::pin_project(project = StateRCProj)] -enum StateRC -where - A: Service, - B: Service, -{ - A(#[pin] A::Future, Option>>), - B(#[pin] B::Future), - Empty, -} - -impl Future for AndThenServiceResponseRC -where - A: Service, - B: Service, -{ - type Output = Result; - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - let mut this = self.as_mut().project(); - - match this.state.as_mut().project() { - StateRCProj::A(fut, b) => match fut.poll(cx)? { - Poll::Ready(res) => { - let b = b.take().unwrap(); - this.state.set(StateRC::Empty); // drop fut A - let fut = b.borrow_mut().1.call(res); - this.state.set(StateRC::B(fut)); - self.poll(cx) - } - Poll::Pending => Poll::Pending, - }, - StateRCProj::B(fut) => fut.poll(cx).map(|r| { - this.state.set(StateRC::Empty); - r - }), - StateRCProj::Empty => { - panic!("future must not be polled after it returned `Poll::Ready`") - } - } - } -} - -/* - * AndThenRCFuture - AndThen service based on RefCell - * and standard futures::future::and_then combinator in a Box - */ - -struct AndThenRCFuture(Rc>); - -impl AndThenRCFuture { - fn new(a: A, b: B) -> Self - where - A: Service, - B: Service, - { - Self(Rc::new(RefCell::new((a, b)))) - } -} - -impl Clone for AndThenRCFuture { - fn clone(&self) -> Self { - Self(self.0.clone()) - } -} - -impl Service for AndThenRCFuture -where - A: Service + 'static, - A::Future: 'static, - B: Service + 'static, - B::Future: 'static, -{ - type Request = A::Request; - type Response = B::Response; - type Error = A::Error; - type Future = BoxFuture; - - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { - Poll::Ready(Ok(())) - } - - fn call(&mut self, req: A::Request) -> Self::Future { - let fut = self.0.borrow_mut().0.call(req); - let core = self.0.clone(); - let fut2 = move |res| (*core).borrow_mut().1.call(res); - Box::pin(fut.and_then(fut2)) - } -} - -/// Criterion Benchmark for async Service -/// Should be used from within criterion group: -/// ```rust,ignore -/// let mut criterion: ::criterion::Criterion<_> = -/// ::criterion::Criterion::default().configure_from_args(); -/// bench_async_service(&mut criterion, ok_service(), "async_service_direct"); -/// ``` -/// -/// Usable for benching Service wrappers: -/// Using minimum service code implementation we first measure -/// time to run minimum service, then measure time with wrapper. -/// -/// Sample output -/// async_service_direct time: [1.0908 us 1.1656 us 1.2613 us] -pub fn bench_async_service(c: &mut Criterion, srv: S, name: &str) -where - S: Service + Clone + 'static, -{ - let mut rt = actix_rt::System::new("test"); - - // start benchmark loops - c.bench_function(name, move |b| { - b.iter_custom(|iters| { - let mut srvs: Vec<_> = (1..iters).map(|_| srv.clone()).collect(); - // exclude request generation, it appears it takes significant time vs call (3us vs 1us) - let start = std::time::Instant::now(); - // benchmark body - rt.block_on(async move { join_all(srvs.iter_mut().map(|srv| srv.call(()))).await }); - // check that at least first request succeeded - start.elapsed() - }) - }); -} - -pub fn service_benches() { - let mut criterion: ::criterion::Criterion<_> = - ::criterion::Criterion::default().configure_from_args(); - bench_async_service( - &mut criterion, - AndThenUC::new(svc1.into_service(), svc2.into_service()), - "AndThen with UnsafeCell", - ); - bench_async_service( - &mut criterion, - AndThenRC::new(svc1.into_service(), svc2.into_service()), - "AndThen with RefCell", - ); - bench_async_service( - &mut criterion, - AndThenUC::new(svc1.into_service(), svc2.into_service()), - "AndThen with UnsafeCell", - ); - bench_async_service( - &mut criterion, - AndThenRC::new(svc1.into_service(), svc2.into_service()), - "AndThen with RefCell", - ); - bench_async_service( - &mut criterion, - AndThenRCFuture::new(svc1.into_service(), svc2.into_service()), - "AndThen with RefCell via future::and_then", - ); -} - -criterion_main!(service_benches); diff --git a/actix-service/benches/unsafecell_vs_refcell.rs b/actix-service/benches/unsafecell_vs_refcell.rs deleted file mode 100644 index a599795f..00000000 --- a/actix-service/benches/unsafecell_vs_refcell.rs +++ /dev/null @@ -1,112 +0,0 @@ -use actix_service::Service; -use criterion::{criterion_main, Criterion}; -use futures_util::future::join_all; -use futures_util::future::{ok, Ready}; -use std::cell::{RefCell, UnsafeCell}; -use std::rc::Rc; -use std::task::{Context, Poll}; - -struct SrvUC(Rc>); - -impl Default for SrvUC { - fn default() -> Self { - Self(Rc::new(UnsafeCell::new(0))) - } -} - -impl Clone for SrvUC { - fn clone(&self) -> Self { - Self(self.0.clone()) - } -} - -impl Service for SrvUC { - type Request = (); - type Response = usize; - type Error = (); - type Future = Ready>; - - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { - Poll::Ready(Ok(())) - } - - fn call(&mut self, _: ()) -> Self::Future { - unsafe { *(*self.0).get() = *(*self.0).get() + 1 }; - ok(unsafe { *self.0.get() }) - } -} - -struct SrvRC(Rc>); - -impl Default for SrvRC { - fn default() -> Self { - Self(Rc::new(RefCell::new(0))) - } -} - -impl Clone for SrvRC { - fn clone(&self) -> Self { - Self(self.0.clone()) - } -} - -impl Service for SrvRC { - type Request = (); - type Response = usize; - type Error = (); - type Future = Ready>; - - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { - Poll::Ready(Ok(())) - } - - fn call(&mut self, _: ()) -> Self::Future { - let prev = *self.0.borrow(); - *(*self.0).borrow_mut() = prev + 1; - ok(*self.0.borrow()) - } -} - -/// Criterion Benchmark for async Service -/// Should be used from within criterion group: -/// ```rust,ignore -/// let mut criterion: ::criterion::Criterion<_> = -/// ::criterion::Criterion::default().configure_from_args(); -/// bench_async_service(&mut criterion, ok_service(), "async_service_direct"); -/// ``` -/// -/// Usable for benching Service wrappers: -/// Using minimum service code implementation we first measure -/// time to run minimum service, then measure time with wrapper. -/// -/// Sample output -/// async_service_direct time: [1.0908 us 1.1656 us 1.2613 us] -pub fn bench_async_service(c: &mut Criterion, srv: S, name: &str) -where - S: Service + Clone + 'static, -{ - let mut rt = actix_rt::System::new("test"); - - // start benchmark loops - c.bench_function(name, move |b| { - b.iter_custom(|iters| { - let mut srvs: Vec<_> = (1..iters).map(|_| srv.clone()).collect(); - // exclude request generation, it appears it takes significant time vs call (3us vs 1us) - let start = std::time::Instant::now(); - // benchmark body - rt.block_on(async move { join_all(srvs.iter_mut().map(|srv| srv.call(()))).await }); - // check that at least first request succeeded - start.elapsed() - }) - }); -} - -pub fn service_benches() { - let mut criterion: ::criterion::Criterion<_> = - ::criterion::Criterion::default().configure_from_args(); - bench_async_service(&mut criterion, SrvUC::default(), "Service with UnsafeCell"); - bench_async_service(&mut criterion, SrvRC::default(), "Service with RefCell"); - bench_async_service(&mut criterion, SrvUC::default(), "Service with UnsafeCell"); - bench_async_service(&mut criterion, SrvRC::default(), "Service with RefCell"); -} -criterion_main!(service_benches); diff --git a/actix-service/src/and_then.rs b/actix-service/src/and_then.rs index caaf8615..e3b293ea 100644 --- a/actix-service/src/and_then.rs +++ b/actix-service/src/and_then.rs @@ -1,8 +1,13 @@ -use std::cell::RefCell; -use std::future::Future; -use std::pin::Pin; -use std::rc::Rc; -use std::task::{Context, Poll}; +use alloc::rc::Rc; +use core::{ + future::Future, + marker::PhantomData, + pin::Pin, + task::{Context, Poll}, +}; + +use futures_core::ready; +use pin_project_lite::pin_project; use super::{Service, ServiceFactory}; @@ -10,77 +15,88 @@ use super::{Service, ServiceFactory}; /// of another service which completes successfully. /// /// This is created by the `Pipeline::and_then` method. -pub(crate) struct AndThenService(Rc>); +pub(crate) struct AndThenService(Rc<(A, B)>, PhantomData); -impl AndThenService { +impl AndThenService { /// Create new `AndThen` combinator pub(crate) fn new(a: A, b: B) -> Self where - A: Service, - B: Service, + A: Service, + B: Service, { - Self(Rc::new(RefCell::new((a, b)))) + Self(Rc::new((a, b)), PhantomData) } } -impl Clone for AndThenService { +impl Clone for AndThenService { fn clone(&self) -> Self { - AndThenService(self.0.clone()) + AndThenService(self.0.clone(), PhantomData) } } -impl Service for AndThenService +impl Service for AndThenService where - A: Service, - B: Service, + A: Service, + B: Service, { - type Request = A::Request; type Response = B::Response; type Error = A::Error; - type Future = AndThenServiceResponse; + type Future = AndThenServiceResponse; - fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll> { - let mut srv = self.0.borrow_mut(); - let not_ready = !srv.0.poll_ready(cx)?.is_ready(); - if !srv.1.poll_ready(cx)?.is_ready() || not_ready { + fn poll_ready(&self, cx: &mut Context<'_>) -> Poll> { + let (a, b) = &*self.0; + let not_ready = !a.poll_ready(cx)?.is_ready(); + if !b.poll_ready(cx)?.is_ready() || not_ready { Poll::Pending } else { Poll::Ready(Ok(())) } } - fn call(&mut self, req: A::Request) -> Self::Future { + fn call(&self, req: Req) -> Self::Future { AndThenServiceResponse { - state: State::A(self.0.borrow_mut().0.call(req), Some(self.0.clone())), + state: State::A { + fut: self.0 .0.call(req), + b: Some(self.0.clone()), + }, } } } -#[pin_project::pin_project] -pub(crate) struct AndThenServiceResponse -where - A: Service, - B: Service, -{ - #[pin] - state: State, +pin_project! { + pub(crate) struct AndThenServiceResponse + where + A: Service, + B: Service, + { + #[pin] + state: State, + } } -#[pin_project::pin_project(project = StateProj)] -enum State -where - A: Service, - B: Service, -{ - A(#[pin] A::Future, Option>>), - B(#[pin] B::Future), - Empty, +pin_project! { + #[project = StateProj] + enum State + where + A: Service, + B: Service, + { + A { + #[pin] + fut: A::Future, + b: Option>, + }, + B { + #[pin] + fut: B::Future, + }, + } } -impl Future for AndThenServiceResponse +impl Future for AndThenServiceResponse where - A: Service, - B: Service, + A: Service, + B: Service, { type Output = Result; @@ -88,49 +104,41 @@ where let mut this = self.as_mut().project(); match this.state.as_mut().project() { - StateProj::A(fut, b) => match fut.poll(cx)? { - Poll::Ready(res) => { - let b = b.take().unwrap(); - this.state.set(State::Empty); // drop fut A - let fut = b.borrow_mut().1.call(res); - this.state.set(State::B(fut)); - self.poll(cx) - } - Poll::Pending => Poll::Pending, - }, - StateProj::B(fut) => fut.poll(cx).map(|r| { - this.state.set(State::Empty); - r - }), - StateProj::Empty => { - panic!("future must not be polled after it returned `Poll::Ready`") + StateProj::A { fut, b } => { + let res = ready!(fut.poll(cx))?; + let b = b.take().unwrap(); + let fut = b.1.call(res); + this.state.set(State::B { fut }); + self.poll(cx) } + StateProj::B { fut } => fut.poll(cx), } } } /// `.and_then()` service factory combinator -pub(crate) struct AndThenServiceFactory +pub(crate) struct AndThenServiceFactory where - A: ServiceFactory, + A: ServiceFactory, A::Config: Clone, B: ServiceFactory< + A::Response, Config = A::Config, - Request = A::Response, Error = A::Error, InitError = A::InitError, >, { inner: Rc<(A, B)>, + _phantom: PhantomData, } -impl AndThenServiceFactory +impl AndThenServiceFactory where - A: ServiceFactory, + A: ServiceFactory, A::Config: Clone, B: ServiceFactory< + A::Response, Config = A::Config, - Request = A::Response, Error = A::Error, InitError = A::InitError, >, @@ -139,29 +147,29 @@ where pub(crate) fn new(a: A, b: B) -> Self { Self { inner: Rc::new((a, b)), + _phantom: PhantomData, } } } -impl ServiceFactory for AndThenServiceFactory +impl ServiceFactory for AndThenServiceFactory where - A: ServiceFactory, + A: ServiceFactory, A::Config: Clone, B: ServiceFactory< + A::Response, Config = A::Config, - Request = A::Response, Error = A::Error, InitError = A::InitError, >, { - type Request = A::Request; type Response = B::Response; type Error = A::Error; type Config = A::Config; - type Service = AndThenService; + type Service = AndThenService; type InitError = A::InitError; - type Future = AndThenServiceFactoryResponse; + type Future = AndThenServiceFactoryResponse; fn new_service(&self, cfg: A::Config) -> Self::Future { let inner = &*self.inner; @@ -172,13 +180,13 @@ where } } -impl Clone for AndThenServiceFactory +impl Clone for AndThenServiceFactory where - A: ServiceFactory, + A: ServiceFactory, A::Config: Clone, B: ServiceFactory< + A::Response, Config = A::Config, - Request = A::Response, Error = A::Error, InitError = A::InitError, >, @@ -186,29 +194,31 @@ where fn clone(&self) -> Self { Self { inner: self.inner.clone(), + _phantom: PhantomData, } } } -#[pin_project::pin_project] -pub(crate) struct AndThenServiceFactoryResponse -where - A: ServiceFactory, - B: ServiceFactory, -{ - #[pin] - fut_a: A::Future, - #[pin] - fut_b: B::Future, +pin_project! { + pub(crate) struct AndThenServiceFactoryResponse + where + A: ServiceFactory, + B: ServiceFactory, + { + #[pin] + fut_a: A::Future, + #[pin] + fut_b: B::Future, - a: Option, - b: Option, + a: Option, + b: Option, + } } -impl AndThenServiceFactoryResponse +impl AndThenServiceFactoryResponse where - A: ServiceFactory, - B: ServiceFactory, + A: ServiceFactory, + B: ServiceFactory, { fn new(fut_a: A::Future, fut_b: B::Future) -> Self { AndThenServiceFactoryResponse { @@ -220,12 +230,12 @@ where } } -impl Future for AndThenServiceFactoryResponse +impl Future for AndThenServiceFactoryResponse where - A: ServiceFactory, - B: ServiceFactory, + A: ServiceFactory, + B: ServiceFactory, { - type Output = Result, A::InitError>; + type Output = Result, A::InitError>; fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { let this = self.project(); @@ -253,28 +263,31 @@ where #[cfg(test)] mod tests { - use std::cell::Cell; - use std::rc::Rc; - use std::task::{Context, Poll}; + use alloc::rc::Rc; + use core::{ + cell::Cell, + task::{Context, Poll}, + }; - use futures_util::future::{lazy, ok, ready, Ready}; + use futures_util::future::lazy; - use crate::{fn_factory, pipeline, pipeline_factory, Service, ServiceFactory}; + use crate::{ + fn_factory, ok, pipeline, pipeline_factory, ready, Ready, Service, ServiceFactory, + }; struct Srv1(Rc>); - impl Service for Srv1 { - type Request = &'static str; + impl Service<&'static str> for Srv1 { type Response = &'static str; type Error = (); type Future = Ready>; - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { + fn poll_ready(&self, _: &mut Context<'_>) -> Poll> { self.0.set(self.0.get() + 1); Poll::Ready(Ok(())) } - fn call(&mut self, req: &'static str) -> Self::Future { + fn call(&self, req: &'static str) -> Self::Future { ok(req) } } @@ -282,18 +295,17 @@ mod tests { #[derive(Clone)] struct Srv2(Rc>); - impl Service for Srv2 { - type Request = &'static str; + impl Service<&'static str> for Srv2 { type Response = (&'static str, &'static str); type Error = (); type Future = Ready>; - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { + fn poll_ready(&self, _: &mut Context<'_>) -> Poll> { self.0.set(self.0.get() + 1); Poll::Ready(Ok(())) } - fn call(&mut self, req: &'static str) -> Self::Future { + fn call(&self, req: &'static str) -> Self::Future { ok((req, "srv2")) } } @@ -301,7 +313,7 @@ mod tests { #[actix_rt::test] async fn test_poll_ready() { let cnt = Rc::new(Cell::new(0)); - let mut srv = pipeline(Srv1(cnt.clone())).and_then(Srv2(cnt.clone())); + let srv = pipeline(Srv1(cnt.clone())).and_then(Srv2(cnt.clone())); let res = lazy(|cx| srv.poll_ready(cx)).await; assert_eq!(res, Poll::Ready(Ok(()))); assert_eq!(cnt.get(), 2); @@ -310,7 +322,7 @@ mod tests { #[actix_rt::test] async fn test_call() { let cnt = Rc::new(Cell::new(0)); - let mut srv = pipeline(Srv1(cnt.clone())).and_then(Srv2(cnt)); + let srv = pipeline(Srv1(cnt.clone())).and_then(Srv2(cnt)); let res = srv.call("srv1").await; assert!(res.is_ok()); assert_eq!(res.unwrap(), ("srv1", "srv2")); @@ -324,7 +336,7 @@ mod tests { pipeline_factory(fn_factory(move || ready(Ok::<_, ()>(Srv1(cnt2.clone()))))) .and_then(move || ready(Ok(Srv2(cnt.clone())))); - let mut srv = new_srv.new_service(()).await.unwrap(); + let srv = new_srv.new_service(()).await.unwrap(); let res = srv.call("srv1").await; assert!(res.is_ok()); assert_eq!(res.unwrap(), ("srv1", "srv2")); diff --git a/actix-service/src/and_then_apply_fn.rs b/actix-service/src/and_then_apply_fn.rs deleted file mode 100644 index b62cf505..00000000 --- a/actix-service/src/and_then_apply_fn.rs +++ /dev/null @@ -1,326 +0,0 @@ -use std::cell::RefCell; -use std::future::Future; -use std::marker::PhantomData; -use std::pin::Pin; -use std::rc::Rc; -use std::task::{Context, Poll}; - -use crate::{Service, ServiceFactory}; - -/// `Apply` service combinator -pub(crate) struct AndThenApplyFn -where - A: Service, - B: Service, - F: FnMut(A::Response, &mut B) -> Fut, - Fut: Future>, - Err: From + From, -{ - srv: Rc>, - r: PhantomData<(Fut, Res, Err)>, -} - -impl AndThenApplyFn -where - A: Service, - B: Service, - F: FnMut(A::Response, &mut B) -> Fut, - Fut: Future>, - Err: From + From, -{ - /// Create new `Apply` combinator - pub(crate) fn new(a: A, b: B, f: F) -> Self { - Self { - srv: Rc::new(RefCell::new((a, b, f))), - r: PhantomData, - } - } -} - -impl Clone for AndThenApplyFn -where - A: Service, - B: Service, - F: FnMut(A::Response, &mut B) -> Fut, - Fut: Future>, - Err: From + From, -{ - fn clone(&self) -> Self { - AndThenApplyFn { - srv: self.srv.clone(), - r: PhantomData, - } - } -} - -impl Service for AndThenApplyFn -where - A: Service, - B: Service, - F: FnMut(A::Response, &mut B) -> Fut, - Fut: Future>, - Err: From + From, -{ - type Request = A::Request; - type Response = Res; - type Error = Err; - type Future = AndThenApplyFnFuture; - - fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll> { - let mut inner = self.srv.borrow_mut(); - let not_ready = inner.0.poll_ready(cx)?.is_pending(); - if inner.1.poll_ready(cx)?.is_pending() || not_ready { - Poll::Pending - } else { - Poll::Ready(Ok(())) - } - } - - fn call(&mut self, req: A::Request) -> Self::Future { - let fut = self.srv.borrow_mut().0.call(req); - AndThenApplyFnFuture { - state: State::A(fut, Some(self.srv.clone())), - } - } -} - -#[pin_project::pin_project] -pub(crate) struct AndThenApplyFnFuture -where - A: Service, - B: Service, - F: FnMut(A::Response, &mut B) -> Fut, - Fut: Future>, - Err: From, - Err: From, -{ - #[pin] - state: State, -} - -#[pin_project::pin_project(project = StateProj)] -enum State -where - A: Service, - B: Service, - F: FnMut(A::Response, &mut B) -> Fut, - Fut: Future>, - Err: From, - Err: From, -{ - A(#[pin] A::Future, Option>>), - B(#[pin] Fut), - Empty, -} - -impl Future for AndThenApplyFnFuture -where - A: Service, - B: Service, - F: FnMut(A::Response, &mut B) -> Fut, - Fut: Future>, - Err: From + From, -{ - type Output = Result; - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - let mut this = self.as_mut().project(); - - match this.state.as_mut().project() { - StateProj::A(fut, b) => match fut.poll(cx)? { - Poll::Ready(res) => { - let b = b.take().unwrap(); - this.state.set(State::Empty); - let (_, b, f) = &mut *b.borrow_mut(); - let fut = f(res, b); - this.state.set(State::B(fut)); - self.poll(cx) - } - Poll::Pending => Poll::Pending, - }, - StateProj::B(fut) => fut.poll(cx).map(|r| { - this.state.set(State::Empty); - r - }), - StateProj::Empty => { - panic!("future must not be polled after it returned `Poll::Ready`") - } - } - } -} - -/// `AndThenApplyFn` service factory -pub(crate) struct AndThenApplyFnFactory { - srv: Rc<(A, B, F)>, - r: PhantomData<(Fut, Res, Err)>, -} - -impl AndThenApplyFnFactory -where - A: ServiceFactory, - B: ServiceFactory, - F: FnMut(A::Response, &mut B::Service) -> Fut + Clone, - Fut: Future>, - Err: From + From, -{ - /// Create new `ApplyNewService` new service instance - pub(crate) fn new(a: A, b: B, f: F) -> Self { - Self { - srv: Rc::new((a, b, f)), - r: PhantomData, - } - } -} - -impl Clone for AndThenApplyFnFactory { - fn clone(&self) -> Self { - Self { - srv: self.srv.clone(), - r: PhantomData, - } - } -} - -impl ServiceFactory for AndThenApplyFnFactory -where - A: ServiceFactory, - A::Config: Clone, - B: ServiceFactory, - F: FnMut(A::Response, &mut B::Service) -> Fut + Clone, - Fut: Future>, - Err: From + From, -{ - type Request = A::Request; - type Response = Res; - type Error = Err; - type Service = AndThenApplyFn; - type Config = A::Config; - type InitError = A::InitError; - type Future = AndThenApplyFnFactoryResponse; - - fn new_service(&self, cfg: A::Config) -> Self::Future { - let srv = &*self.srv; - AndThenApplyFnFactoryResponse { - a: None, - b: None, - f: srv.2.clone(), - fut_a: srv.0.new_service(cfg.clone()), - fut_b: srv.1.new_service(cfg), - } - } -} - -#[pin_project::pin_project] -pub(crate) struct AndThenApplyFnFactoryResponse -where - A: ServiceFactory, - B: ServiceFactory, - F: FnMut(A::Response, &mut B::Service) -> Fut + Clone, - Fut: Future>, - Err: From, - Err: From, -{ - #[pin] - fut_b: B::Future, - #[pin] - fut_a: A::Future, - f: F, - a: Option, - b: Option, -} - -impl Future for AndThenApplyFnFactoryResponse -where - A: ServiceFactory, - B: ServiceFactory, - F: FnMut(A::Response, &mut B::Service) -> Fut + Clone, - Fut: Future>, - Err: From + From, -{ - type Output = - Result, A::InitError>; - - fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - let this = self.project(); - - if this.a.is_none() { - if let Poll::Ready(service) = this.fut_a.poll(cx)? { - *this.a = Some(service); - } - } - - if this.b.is_none() { - if let Poll::Ready(service) = this.fut_b.poll(cx)? { - *this.b = Some(service); - } - } - - if this.a.is_some() && this.b.is_some() { - Poll::Ready(Ok(AndThenApplyFn { - srv: Rc::new(RefCell::new(( - this.a.take().unwrap(), - this.b.take().unwrap(), - this.f.clone(), - ))), - r: PhantomData, - })) - } else { - Poll::Pending - } - } -} - -#[cfg(test)] -mod tests { - use super::*; - - use futures_util::future::{lazy, ok, Ready, TryFutureExt}; - - use crate::{fn_service, pipeline, pipeline_factory, Service, ServiceFactory}; - - #[derive(Clone)] - struct Srv; - impl Service for Srv { - type Request = (); - type Response = (); - type Error = (); - type Future = Ready>; - - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { - Poll::Ready(Ok(())) - } - - #[allow(clippy::unit_arg)] - fn call(&mut self, req: Self::Request) -> Self::Future { - ok(req) - } - } - - #[actix_rt::test] - async fn test_service() { - let mut srv = pipeline(ok).and_then_apply_fn(Srv, |req: &'static str, s| { - s.call(()).map_ok(move |res| (req, res)) - }); - let res = lazy(|cx| srv.poll_ready(cx)).await; - assert_eq!(res, Poll::Ready(Ok(()))); - - let res = srv.call("srv").await; - assert!(res.is_ok()); - assert_eq!(res.unwrap(), ("srv", ())); - } - - #[actix_rt::test] - async fn test_service_factory() { - let new_srv = pipeline_factory(|| ok::<_, ()>(fn_service(ok))).and_then_apply_fn( - || ok(Srv), - |req: &'static str, s| s.call(()).map_ok(move |res| (req, res)), - ); - let mut srv = new_srv.new_service(()).await.unwrap(); - let res = lazy(|cx| srv.poll_ready(cx)).await; - assert_eq!(res, Poll::Ready(Ok(()))); - - let res = srv.call("srv").await; - assert!(res.is_ok()); - assert_eq!(res.unwrap(), ("srv", ())); - } -} diff --git a/actix-service/src/apply.rs b/actix-service/src/apply.rs index d1f8ff3a..9a7e27d2 100644 --- a/actix-service/src/apply.rs +++ b/actix-service/src/apply.rs @@ -1,236 +1,239 @@ -use std::future::Future; -use std::marker::PhantomData; -use std::pin::Pin; -use std::task::{Context, Poll}; +use core::{ + future::Future, + marker::PhantomData, + pin::Pin, + task::{Context, Poll}, +}; + +use futures_core::ready; +use pin_project_lite::pin_project; use super::{IntoService, IntoServiceFactory, Service, ServiceFactory}; /// Apply transform function to a service. -pub fn apply_fn(service: U, f: F) -> Apply +/// +/// The In and Out type params refer to the request and response types for the wrapped service. +pub fn apply_fn( + service: I, + wrap_fn: F, +) -> Apply where - T: Service, - F: FnMut(In, &mut T) -> R, - R: Future>, - U: IntoService, + I: IntoService, + S: Service, + F: Fn(Req, &S) -> Fut, + Fut: Future>, { - Apply::new(service.into_service(), f) + Apply::new(service.into_service(), wrap_fn) } /// Service factory that produces `apply_fn` service. -pub fn apply_fn_factory( - service: U, +/// +/// The In and Out type params refer to the request and response types for the wrapped service. +pub fn apply_fn_factory( + service: I, f: F, -) -> ApplyServiceFactory +) -> ApplyFactory where - T: ServiceFactory, - F: FnMut(In, &mut T::Service) -> R + Clone, - R: Future>, - U: IntoServiceFactory, + I: IntoServiceFactory, + SF: ServiceFactory, + F: Fn(Req, &SF::Service) -> Fut + Clone, + Fut: Future>, { - ApplyServiceFactory::new(service.into_factory(), f) + ApplyFactory::new(service.into_factory(), f) } -/// `Apply` service combinator -pub struct Apply +/// `Apply` service combinator. +/// +/// The In and Out type params refer to the request and response types for the wrapped service. +pub struct Apply where - T: Service, + S: Service, { - service: T, - f: F, - r: PhantomData<(In, Out, R)>, + service: S, + wrap_fn: F, + _phantom: PhantomData<(Req, In, Res, Err)>, } -impl Apply +impl Apply where - T: Service, - F: FnMut(In, &mut T) -> R, - R: Future>, + S: Service, + F: Fn(Req, &S) -> Fut, + Fut: Future>, { /// Create new `Apply` combinator - fn new(service: T, f: F) -> Self { + fn new(service: S, wrap_fn: F) -> Self { Self { service, - f, - r: PhantomData, + wrap_fn, + _phantom: PhantomData, } } } -impl Clone for Apply +impl Clone for Apply where - T: Service + Clone, - F: FnMut(In, &mut T) -> R + Clone, - R: Future>, + S: Service + Clone, + F: Fn(Req, &S) -> Fut + Clone, + Fut: Future>, { fn clone(&self) -> Self { Apply { service: self.service.clone(), - f: self.f.clone(), - r: PhantomData, + wrap_fn: self.wrap_fn.clone(), + _phantom: PhantomData, } } } -impl Service for Apply +impl Service for Apply where - T: Service, - F: FnMut(In, &mut T) -> R, - R: Future>, + S: Service, + F: Fn(Req, &S) -> Fut, + Fut: Future>, { - type Request = In; - type Response = Out; + type Response = Res; type Error = Err; - type Future = R; + type Future = Fut; - fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll> { - Poll::Ready(futures_util::ready!(self.service.poll_ready(cx))) - } + crate::forward_ready!(service); - fn call(&mut self, req: In) -> Self::Future { - (self.f)(req, &mut self.service) + fn call(&self, req: Req) -> Self::Future { + (self.wrap_fn)(req, &self.service) } } -/// `apply()` service factory -pub struct ApplyServiceFactory -where - T: ServiceFactory, - F: FnMut(In, &mut T::Service) -> R + Clone, - R: Future>, -{ - service: T, - f: F, - r: PhantomData<(R, In, Out)>, +/// `ApplyFactory` service factory combinator. +pub struct ApplyFactory { + factory: SF, + wrap_fn: F, + _phantom: PhantomData<(Req, In, Res, Err)>, } -impl ApplyServiceFactory +impl ApplyFactory where - T: ServiceFactory, - F: FnMut(In, &mut T::Service) -> R + Clone, - R: Future>, + SF: ServiceFactory, + F: Fn(Req, &SF::Service) -> Fut + Clone, + Fut: Future>, { - /// Create new `ApplyNewService` new service instance - fn new(service: T, f: F) -> Self { + /// Create new `ApplyFactory` new service instance + fn new(factory: SF, wrap_fn: F) -> Self { Self { - f, - service, - r: PhantomData, + factory, + wrap_fn, + _phantom: PhantomData, } } } -impl Clone for ApplyServiceFactory +impl Clone for ApplyFactory where - T: ServiceFactory + Clone, - F: FnMut(In, &mut T::Service) -> R + Clone, - R: Future>, + SF: ServiceFactory + Clone, + F: Fn(Req, &SF::Service) -> Fut + Clone, + Fut: Future>, { fn clone(&self) -> Self { Self { - service: self.service.clone(), - f: self.f.clone(), - r: PhantomData, + factory: self.factory.clone(), + wrap_fn: self.wrap_fn.clone(), + _phantom: PhantomData, } } } -impl ServiceFactory for ApplyServiceFactory +impl ServiceFactory + for ApplyFactory where - T: ServiceFactory, - F: FnMut(In, &mut T::Service) -> R + Clone, - R: Future>, + SF: ServiceFactory, + F: Fn(Req, &SF::Service) -> Fut + Clone, + Fut: Future>, { - type Request = In; - type Response = Out; + type Response = Res; type Error = Err; - type Config = T::Config; - type Service = Apply; - type InitError = T::InitError; - type Future = ApplyServiceFactoryResponse; + type Config = SF::Config; + type Service = Apply; + type InitError = SF::InitError; + type Future = ApplyServiceFactoryResponse; - fn new_service(&self, cfg: T::Config) -> Self::Future { - ApplyServiceFactoryResponse::new(self.service.new_service(cfg), self.f.clone()) + fn new_service(&self, cfg: SF::Config) -> Self::Future { + let svc = self.factory.new_service(cfg); + ApplyServiceFactoryResponse::new(svc, self.wrap_fn.clone()) } } -#[pin_project::pin_project] -pub struct ApplyServiceFactoryResponse -where - T: ServiceFactory, - F: FnMut(In, &mut T::Service) -> R, - R: Future>, -{ - #[pin] - fut: T::Future, - f: Option, - r: PhantomData<(In, Out)>, +pin_project! { + pub struct ApplyServiceFactoryResponse + where + SF: ServiceFactory, + F: Fn(Req, &SF::Service) -> Fut, + Fut: Future>, + { + #[pin] + fut: SF::Future, + wrap_fn: Option, + _phantom: PhantomData<(Req, Res)>, + } } -impl ApplyServiceFactoryResponse +impl ApplyServiceFactoryResponse where - T: ServiceFactory, - F: FnMut(In, &mut T::Service) -> R, - R: Future>, + SF: ServiceFactory, + F: Fn(Req, &SF::Service) -> Fut, + Fut: Future>, { - fn new(fut: T::Future, f: F) -> Self { + fn new(fut: SF::Future, wrap_fn: F) -> Self { Self { - f: Some(f), fut, - r: PhantomData, + wrap_fn: Some(wrap_fn), + _phantom: PhantomData, } } } -impl Future for ApplyServiceFactoryResponse +impl Future + for ApplyServiceFactoryResponse where - T: ServiceFactory, - F: FnMut(In, &mut T::Service) -> R, - R: Future>, + SF: ServiceFactory, + F: Fn(Req, &SF::Service) -> Fut, + Fut: Future>, { - type Output = Result, T::InitError>; + type Output = Result, SF::InitError>; fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { let this = self.project(); - if let Poll::Ready(svc) = this.fut.poll(cx)? { - Poll::Ready(Ok(Apply::new(svc, this.f.take().unwrap()))) - } else { - Poll::Pending - } + let svc = ready!(this.fut.poll(cx))?; + Poll::Ready(Ok(Apply::new(svc, this.wrap_fn.take().unwrap()))) } } #[cfg(test)] mod tests { - use std::task::{Context, Poll}; + use core::task::Poll; - use futures_util::future::{lazy, ok, Ready}; + use futures_util::future::lazy; use super::*; - use crate::{pipeline, pipeline_factory, Service, ServiceFactory}; + use crate::{ok, pipeline, pipeline_factory, Ready, Service, ServiceFactory}; #[derive(Clone)] struct Srv; - impl Service for Srv { - type Request = (); + impl Service<()> for Srv { type Response = (); type Error = (); type Future = Ready>; - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { - Poll::Ready(Ok(())) - } + crate::always_ready!(); - fn call(&mut self, _: ()) -> Self::Future { + fn call(&self, _: ()) -> Self::Future { ok(()) } } #[actix_rt::test] async fn test_call() { - let mut srv = pipeline(apply_fn(Srv, |req: &'static str, srv| { + let srv = pipeline(apply_fn(Srv, |req: &'static str, srv| { let fut = srv.call(()); async move { fut.await.unwrap(); @@ -258,7 +261,7 @@ mod tests { }, )); - let mut srv = new_srv.new_service(()).await.unwrap(); + let srv = new_srv.new_service(()).await.unwrap(); assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(()))); diff --git a/actix-service/src/apply_cfg.rs b/actix-service/src/apply_cfg.rs index 0d984309..25fc5fc2 100644 --- a/actix-service/src/apply_cfg.rs +++ b/actix-service/src/apply_cfg.rs @@ -1,227 +1,233 @@ -use std::cell::RefCell; -use std::future::Future; -use std::marker::PhantomData; -use std::pin::Pin; -use std::rc::Rc; -use std::task::{Context, Poll}; +use alloc::rc::Rc; +use core::{ + future::Future, + marker::PhantomData, + pin::Pin, + task::{Context, Poll}, +}; + +use futures_core::ready; +use pin_project_lite::pin_project; use crate::{Service, ServiceFactory}; -/// Convert `Fn(Config, &mut Service1) -> Future` fn to a service factory -pub fn apply_cfg( - srv: T, +/// Convert `Fn(Config, &Service1) -> Future` fn to a service factory. +pub fn apply_cfg( + srv: S1, f: F, ) -> impl ServiceFactory< - Config = C, - Request = S::Request, - Response = S::Response, - Error = S::Error, - Service = S, - InitError = E, - Future = R, + Req, + Config = Cfg, + Response = S2::Response, + Error = S2::Error, + Service = S2, + InitError = Err, + Future = Fut, > + Clone where - F: FnMut(C, &mut T) -> R, - T: Service, - R: Future>, - S: Service, + S1: Service, + F: Fn(Cfg, &S1) -> Fut, + Fut: Future>, + S2: Service, { ApplyConfigService { - srv: Rc::new(RefCell::new((srv, f))), - _t: PhantomData, + srv: Rc::new((srv, f)), + _phantom: PhantomData, } } -/// Convert `Fn(Config, &mut Service1) -> Future` fn to a service factory +/// Convert `Fn(Config, &ServiceFactory1) -> Future` fn to a service factory. /// /// Service1 get constructed from `T` factory. -pub fn apply_cfg_factory( - factory: T, +pub fn apply_cfg_factory( + factory: SF, f: F, ) -> impl ServiceFactory< - Config = C, - Request = S::Request, + Req, + Config = Cfg, Response = S::Response, Error = S::Error, Service = S, - InitError = T::InitError, + InitError = SF::InitError, > + Clone where - F: FnMut(C, &mut T::Service) -> R, - T: ServiceFactory, - T::InitError: From, - R: Future>, - S: Service, + SF: ServiceFactory, + F: Fn(Cfg, &SF::Service) -> Fut, + SF::InitError: From, + Fut: Future>, + S: Service, { ApplyConfigServiceFactory { - srv: Rc::new(RefCell::new((factory, f))), - _t: PhantomData, + srv: Rc::new((factory, f)), + _phantom: PhantomData, } } -/// Convert `Fn(Config, &mut Server) -> Future` fn to NewService\ -struct ApplyConfigService +/// Convert `Fn(Config, &Server) -> Future` fn to NewService\ +struct ApplyConfigService where - F: FnMut(C, &mut T) -> R, - T: Service, - R: Future>, - S: Service, + S1: Service, + F: Fn(Cfg, &S1) -> Fut, + Fut: Future>, + S2: Service, { - srv: Rc>, - _t: PhantomData<(C, R, S)>, + srv: Rc<(S1, F)>, + _phantom: PhantomData<(Cfg, Req, Fut, S2)>, } -impl Clone for ApplyConfigService +impl Clone for ApplyConfigService where - F: FnMut(C, &mut T) -> R, - T: Service, - R: Future>, - S: Service, + S1: Service, + F: Fn(Cfg, &S1) -> Fut, + Fut: Future>, + S2: Service, { fn clone(&self) -> Self { ApplyConfigService { srv: self.srv.clone(), - _t: PhantomData, + _phantom: PhantomData, } } } -impl ServiceFactory for ApplyConfigService +impl ServiceFactory + for ApplyConfigService where - F: FnMut(C, &mut T) -> R, - T: Service, - R: Future>, - S: Service, + S1: Service, + F: Fn(Cfg, &S1) -> Fut, + Fut: Future>, + S2: Service, { - type Config = C; - type Request = S::Request; - type Response = S::Response; - type Error = S::Error; - type Service = S; + type Response = S2::Response; + type Error = S2::Error; + type Config = Cfg; + type Service = S2; - type InitError = E; - type Future = R; + type InitError = Err; + type Future = Fut; - fn new_service(&self, cfg: C) -> Self::Future { - let (t, f) = &mut *self.srv.borrow_mut(); + fn new_service(&self, cfg: Cfg) -> Self::Future { + let (t, f) = &*self.srv; f(cfg, t) } } /// Convert `Fn(&Config) -> Future` fn to NewService -struct ApplyConfigServiceFactory +struct ApplyConfigServiceFactory where - F: FnMut(C, &mut T::Service) -> R, - T: ServiceFactory, - R: Future>, - S: Service, + SF: ServiceFactory, + F: Fn(Cfg, &SF::Service) -> Fut, + Fut: Future>, + S: Service, { - srv: Rc>, - _t: PhantomData<(C, R, S)>, + srv: Rc<(SF, F)>, + _phantom: PhantomData<(Cfg, Req, Fut, S)>, } -impl Clone for ApplyConfigServiceFactory +impl Clone for ApplyConfigServiceFactory where - F: FnMut(C, &mut T::Service) -> R, - T: ServiceFactory, - R: Future>, - S: Service, + SF: ServiceFactory, + F: Fn(Cfg, &SF::Service) -> Fut, + Fut: Future>, + S: Service, { fn clone(&self) -> Self { Self { srv: self.srv.clone(), - _t: PhantomData, + _phantom: PhantomData, } } } -impl ServiceFactory for ApplyConfigServiceFactory +impl ServiceFactory + for ApplyConfigServiceFactory where - F: FnMut(C, &mut T::Service) -> R, - T: ServiceFactory, - T::InitError: From, - R: Future>, - S: Service, + SF: ServiceFactory, + SF::InitError: From, + F: Fn(Cfg, &SF::Service) -> Fut, + Fut: Future>, + S: Service, { - type Config = C; - type Request = S::Request; type Response = S::Response; type Error = S::Error; + type Config = Cfg; type Service = S; - type InitError = T::InitError; - type Future = ApplyConfigServiceFactoryResponse; + type InitError = SF::InitError; + type Future = ApplyConfigServiceFactoryResponse; - fn new_service(&self, cfg: C) -> Self::Future { + fn new_service(&self, cfg: Cfg) -> Self::Future { ApplyConfigServiceFactoryResponse { cfg: Some(cfg), store: self.srv.clone(), - state: State::A(self.srv.borrow().0.new_service(())), + state: State::A { + fut: self.srv.0.new_service(()), + }, } } } -#[pin_project::pin_project] -struct ApplyConfigServiceFactoryResponse -where - F: FnMut(C, &mut T::Service) -> R, - T: ServiceFactory, - T::InitError: From, - R: Future>, - S: Service, -{ - cfg: Option, - store: Rc>, - #[pin] - state: State, +pin_project! { + struct ApplyConfigServiceFactoryResponse + where + SF: ServiceFactory, + SF::InitError: From, + F: Fn(Cfg, &SF::Service) -> Fut, + Fut: Future>, + S: Service, + { + cfg: Option, + store: Rc<(SF, F)>, + #[pin] + state: State, + } } -#[pin_project::pin_project(project = StateProj)] -enum State -where - T: ServiceFactory, - T::InitError: From, - R: Future>, - S: Service, -{ - A(#[pin] T::Future), - B(T::Service), - C(#[pin] R), +pin_project! { + #[project = StateProj] + enum State + where + SF: ServiceFactory, + SF::InitError: From, + Fut: Future>, + S: Service, + { + A { #[pin] fut: SF::Future }, + B { svc: SF::Service }, + C { #[pin] fut: Fut }, + } } -impl Future for ApplyConfigServiceFactoryResponse +impl Future + for ApplyConfigServiceFactoryResponse where - F: FnMut(C, &mut T::Service) -> R, - T: ServiceFactory, - T::InitError: From, - R: Future>, - S: Service, + SF: ServiceFactory, + SF::InitError: From, + F: Fn(Cfg, &SF::Service) -> Fut, + Fut: Future>, + S: Service, { - type Output = Result; + type Output = Result; fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { let mut this = self.as_mut().project(); match this.state.as_mut().project() { - StateProj::A(fut) => match fut.poll(cx)? { - Poll::Pending => Poll::Pending, - Poll::Ready(srv) => { - this.state.set(State::B(srv)); - self.poll(cx) + StateProj::A { fut } => { + let svc = ready!(fut.poll(cx))?; + this.state.set(State::B { svc }); + self.poll(cx) + } + StateProj::B { svc } => { + ready!(svc.poll_ready(cx))?; + { + let (_, f) = &**this.store; + let fut = f(this.cfg.take().unwrap(), svc); + this.state.set(State::C { fut }); } - }, - StateProj::B(srv) => match srv.poll_ready(cx)? { - Poll::Ready(_) => { - { - let (_, f) = &mut *this.store.borrow_mut(); - let fut = f(this.cfg.take().unwrap(), srv); - this.state.set(State::C(fut)); - } - self.poll(cx) - } - Poll::Pending => Poll::Pending, - }, - StateProj::C(fut) => fut.poll(cx), + self.poll(cx) + } + StateProj::C { fut } => fut.poll(cx), } } } diff --git a/actix-service/src/boxed.rs b/actix-service/src/boxed.rs index e630f81c..6ad2eaf4 100644 --- a/actix-service/src/boxed.rs +++ b/actix-service/src/boxed.rs @@ -1,145 +1,141 @@ -use std::future::Future; -use std::pin::Pin; -use std::task::{Context, Poll}; - -use futures_util::future::FutureExt; +use alloc::boxed::Box; +use core::{ + future::Future, + marker::PhantomData, + pin::Pin, + task::{Context, Poll}, +}; use crate::{Service, ServiceFactory}; -pub type BoxFuture = Pin>>>; +pub type BoxFuture = Pin>>; pub type BoxService = - Box>>; + Box>>>; -pub struct BoxServiceFactory(Inner); +pub struct BoxServiceFactory(Inner); /// Create boxed service factory -pub fn factory( - factory: T, -) -> BoxServiceFactory +pub fn factory( + factory: SF, +) -> BoxServiceFactory where - T: ServiceFactory + 'static, - T::Request: 'static, - T::Response: 'static, - T::Service: 'static, - T::Future: 'static, - T::Error: 'static, - T::InitError: 'static, + SF: ServiceFactory + 'static, + Req: 'static, + SF::Response: 'static, + SF::Service: 'static, + SF::Future: 'static, + SF::Error: 'static, + SF::InitError: 'static, { BoxServiceFactory(Box::new(FactoryWrapper { factory, - _t: std::marker::PhantomData, + _t: PhantomData, })) } /// Create boxed service -pub fn service(service: T) -> BoxService +pub fn service(service: S) -> BoxService where - T: Service + 'static, - T::Future: 'static, + S: Service + 'static, + Req: 'static, + S::Future: 'static, { - Box::new(ServiceWrapper(service)) + Box::new(ServiceWrapper(service, PhantomData)) } type Inner = Box< dyn ServiceFactory< + Req, Config = C, - Request = Req, Response = Res, Error = Err, InitError = InitErr, Service = BoxService, - Future = BoxFuture, InitErr>, + Future = BoxFuture, InitErr>>, >, >; -impl ServiceFactory for BoxServiceFactory +impl ServiceFactory + for BoxServiceFactory where Req: 'static, Res: 'static, Err: 'static, InitErr: 'static, { - type Request = Req; type Response = Res; type Error = Err; type InitError = InitErr; type Config = C; type Service = BoxService; - type Future = BoxFuture; + type Future = BoxFuture>; fn new_service(&self, cfg: C) -> Self::Future { self.0.new_service(cfg) } } -struct FactoryWrapper { - factory: T, - _t: std::marker::PhantomData, +struct FactoryWrapper { + factory: SF, + _t: PhantomData<(Req, Cfg)>, } -impl ServiceFactory for FactoryWrapper +impl ServiceFactory for FactoryWrapper where Req: 'static, Res: 'static, Err: 'static, InitErr: 'static, - T: ServiceFactory< - Config = C, - Request = Req, - Response = Res, - Error = Err, - InitError = InitErr, - >, - T::Future: 'static, - T::Service: 'static, - ::Future: 'static, + SF: ServiceFactory, + SF::Future: 'static, + SF::Service: 'static, + >::Future: 'static, { - type Request = Req; type Response = Res; type Error = Err; type InitError = InitErr; - type Config = C; + type Config = Cfg; type Service = BoxService; - type Future = BoxFuture; + type Future = BoxFuture>; - fn new_service(&self, cfg: C) -> Self::Future { - Box::pin( - self.factory - .new_service(cfg) - .map(|res| res.map(ServiceWrapper::boxed)), - ) + fn new_service(&self, cfg: Cfg) -> Self::Future { + let fut = self.factory.new_service(cfg); + Box::pin(async { + let res = fut.await; + res.map(ServiceWrapper::boxed) + }) } } -struct ServiceWrapper(T); +struct ServiceWrapper, Req>(S, PhantomData); -impl ServiceWrapper +impl ServiceWrapper where - T: Service + 'static, - T::Future: 'static, + S: Service + 'static, + Req: 'static, + S::Future: 'static, { - fn boxed(service: T) -> BoxService { - Box::new(ServiceWrapper(service)) + fn boxed(service: S) -> BoxService { + Box::new(ServiceWrapper(service, PhantomData)) } } -impl Service for ServiceWrapper +impl Service for ServiceWrapper where - T: Service, - T::Future: 'static, + S: Service, + S::Future: 'static, { - type Request = Req; type Response = Res; type Error = Err; - type Future = BoxFuture; + type Future = BoxFuture>; - fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll> { + fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll> { self.0.poll_ready(ctx) } - fn call(&mut self, req: Self::Request) -> Self::Future { + fn call(&self, req: Req) -> Self::Future { Box::pin(self.0.call(req)) } } diff --git a/actix-service/src/ext.rs b/actix-service/src/ext.rs new file mode 100644 index 00000000..e778d11e --- /dev/null +++ b/actix-service/src/ext.rs @@ -0,0 +1,70 @@ +use crate::{dev, Service, ServiceFactory}; + +pub trait ServiceExt: Service { + /// Map this service's output to a different type, returning a new service + /// of the resulting type. + /// + /// This function is similar to the `Option::map` or `Iterator::map` where + /// it will change the type of the underlying service. + /// + /// Note that this function consumes the receiving service and returns a + /// wrapped version of it, similar to the existing `map` methods in the + /// standard library. + fn map(self, f: F) -> dev::Map + where + Self: Sized, + F: FnMut(Self::Response) -> R, + { + dev::Map::new(self, f) + } + + /// Map this service's error to a different error, returning a new service. + /// + /// This function is similar to the `Result::map_err` where it will change + /// the error type of the underlying service. For example, this can be useful to + /// ensure that services have the same error type. + /// + /// Note that this function consumes the receiving service and returns a + /// wrapped version of it. + fn map_err(self, f: F) -> dev::MapErr + where + Self: Sized, + F: Fn(Self::Error) -> E, + { + dev::MapErr::new(self, f) + } +} + +impl ServiceExt for S where S: Service {} + +pub trait ServiceFactoryExt: ServiceFactory { + /// Map this service's output to a different type, returning a new service + /// of the resulting type. + fn map(self, f: F) -> crate::map::MapServiceFactory + where + Self: Sized, + F: FnMut(Self::Response) -> R + Clone, + { + crate::map::MapServiceFactory::new(self, f) + } + + /// Map this service's error to a different error, returning a new service. + fn map_err(self, f: F) -> crate::map_err::MapErrServiceFactory + where + Self: Sized, + F: Fn(Self::Error) -> E + Clone, + { + crate::map_err::MapErrServiceFactory::new(self, f) + } + + /// Map this factory's init error to a different error, returning a new service. + fn map_init_err(self, f: F) -> crate::map_init_err::MapInitErr + where + Self: Sized, + F: Fn(Self::InitError) -> E + Clone, + { + crate::map_init_err::MapInitErr::new(self, f) + } +} + +impl ServiceFactoryExt for S where S: ServiceFactory {} diff --git a/actix-service/src/fn_service.rs b/actix-service/src/fn_service.rs index 08690a5d..230f437b 100644 --- a/actix-service/src/fn_service.rs +++ b/actix-service/src/fn_service.rs @@ -1,17 +1,13 @@ -use std::future::Future; -use std::marker::PhantomData; -use std::task::{Context, Poll}; +use core::{future::Future, marker::PhantomData, task::Poll}; -use futures_util::future::{ok, Ready}; - -use crate::{IntoService, IntoServiceFactory, Service, ServiceFactory}; +use crate::{ok, IntoService, IntoServiceFactory, Ready, Service, ServiceFactory}; /// Create `ServiceFactory` for function that can act as a `Service` pub fn fn_service( f: F, ) -> FnServiceFactory where - F: FnMut(Req) -> Fut + Clone, + F: Fn(Req) -> Fut + Clone, Fut: Future>, { FnServiceFactory::new(f) @@ -21,7 +17,7 @@ where /// /// # Example /// -/// ```rust +/// ``` /// use std::io; /// use actix_service::{fn_factory, fn_service, Service, ServiceFactory}; /// use futures_util::future::ok; @@ -43,7 +39,7 @@ where /// }); /// /// // construct new service -/// let mut srv = factory.new_service(()).await?; +/// let srv = factory.new_service(()).await?; /// /// // now we can use `div` service /// let result = srv.call((10, 20)).await?; @@ -53,9 +49,11 @@ where /// Ok(()) /// } /// ``` -pub fn fn_factory(f: F) -> FnServiceNoConfig +pub fn fn_factory( + f: F, +) -> FnServiceNoConfig where - Srv: Service, + Srv: Service, F: Fn() -> Fut, Fut: Future>, { @@ -69,7 +67,7 @@ where /// /// # Example /// -/// ```rust +/// ``` /// use std::io; /// use actix_service::{fn_factory_with_config, fn_service, Service, ServiceFactory}; /// use futures_util::future::ok; @@ -83,7 +81,7 @@ where /// }); /// /// // construct new service with config argument -/// let mut srv = factory.new_service(10).await?; +/// let srv = factory.new_service(10).await?; /// /// let result = srv.call(10).await?; /// assert_eq!(result, 100); @@ -92,13 +90,13 @@ where /// Ok(()) /// } /// ``` -pub fn fn_factory_with_config( +pub fn fn_factory_with_config( f: F, -) -> FnServiceConfig +) -> FnServiceConfig where F: Fn(Cfg) -> Fut, Fut: Future>, - Srv: Service, + Srv: Service, { FnServiceConfig::new(f) } @@ -132,28 +130,25 @@ where } } -impl Service for FnService +impl Service for FnService where - F: FnMut(Req) -> Fut, + F: Fn(Req) -> Fut, Fut: Future>, { - type Request = Req; type Response = Res; type Error = Err; type Future = Fut; - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { - Poll::Ready(Ok(())) - } + crate::always_ready!(); - fn call(&mut self, req: Req) -> Self::Future { + fn call(&self, req: Req) -> Self::Future { (self.f)(req) } } -impl IntoService> for F +impl IntoService, Req> for F where - F: FnMut(Req) -> Fut, + F: Fn(Req) -> Fut, Fut: Future>, { fn into_service(self) -> FnService { @@ -163,7 +158,7 @@ where pub struct FnServiceFactory where - F: FnMut(Req) -> Fut, + F: Fn(Req) -> Fut, Fut: Future>, { f: F, @@ -172,7 +167,7 @@ where impl FnServiceFactory where - F: FnMut(Req) -> Fut + Clone, + F: Fn(Req) -> Fut + Clone, Fut: Future>, { fn new(f: F) -> Self { @@ -182,7 +177,7 @@ where impl Clone for FnServiceFactory where - F: FnMut(Req) -> Fut + Clone, + F: Fn(Req) -> Fut + Clone, Fut: Future>, { fn clone(&self) -> Self { @@ -190,31 +185,28 @@ where } } -impl Service for FnServiceFactory +impl Service for FnServiceFactory where - F: FnMut(Req) -> Fut + Clone, + F: Fn(Req) -> Fut + Clone, Fut: Future>, { - type Request = Req; type Response = Res; type Error = Err; type Future = Fut; - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { - Poll::Ready(Ok(())) - } + crate::always_ready!(); - fn call(&mut self, req: Self::Request) -> Self::Future { + fn call(&self, req: Req) -> Self::Future { (self.f)(req) } } -impl ServiceFactory for FnServiceFactory +impl ServiceFactory + for FnServiceFactory where - F: FnMut(Req) -> Fut + Clone, + F: Fn(Req) -> Fut + Clone, Fut: Future>, { - type Request = Req; type Response = Res; type Error = Err; @@ -229,7 +221,7 @@ where } impl - IntoServiceFactory> for F + IntoServiceFactory, Req> for F where F: Fn(Req) -> Fut + Clone, Fut: Future>, @@ -240,32 +232,32 @@ where } /// Convert `Fn(&Config) -> Future` fn to NewService -pub struct FnServiceConfig +pub struct FnServiceConfig where F: Fn(Cfg) -> Fut, Fut: Future>, - Srv: Service, + Srv: Service, { f: F, - _t: PhantomData<(Fut, Cfg, Srv, Err)>, + _t: PhantomData<(Fut, Cfg, Req, Srv, Err)>, } -impl FnServiceConfig +impl FnServiceConfig where F: Fn(Cfg) -> Fut, Fut: Future>, - Srv: Service, + Srv: Service, { fn new(f: F) -> Self { FnServiceConfig { f, _t: PhantomData } } } -impl Clone for FnServiceConfig +impl Clone for FnServiceConfig where F: Fn(Cfg) -> Fut + Clone, Fut: Future>, - Srv: Service, + Srv: Service, { fn clone(&self) -> Self { FnServiceConfig { @@ -275,13 +267,13 @@ where } } -impl ServiceFactory for FnServiceConfig +impl ServiceFactory + for FnServiceConfig where F: Fn(Cfg) -> Fut, Fut: Future>, - Srv: Service, + Srv: Service, { - type Request = Srv::Request; type Response = Srv::Response; type Error = Srv::Error; @@ -296,82 +288,83 @@ where } /// Converter for `Fn() -> Future` fn -pub struct FnServiceNoConfig +pub struct FnServiceNoConfig where - F: Fn() -> R, - S: Service, - R: Future>, + F: Fn() -> Fut, + Srv: Service, + Fut: Future>, { f: F, - _t: PhantomData, + _t: PhantomData<(Cfg, Req)>, } -impl FnServiceNoConfig +impl FnServiceNoConfig where - F: Fn() -> R, - R: Future>, - S: Service, + F: Fn() -> Fut, + Fut: Future>, + Srv: Service, { fn new(f: F) -> Self { Self { f, _t: PhantomData } } } -impl ServiceFactory for FnServiceNoConfig +impl ServiceFactory + for FnServiceNoConfig where - F: Fn() -> R, - R: Future>, - S: Service, + F: Fn() -> Fut, + Fut: Future>, + Srv: Service, { - type Request = S::Request; - type Response = S::Response; - type Error = S::Error; - type Service = S; - type Config = C; - type InitError = E; - type Future = R; + type Response = Srv::Response; + type Error = Srv::Error; + type Config = Cfg; + type Service = Srv; + type InitError = Err; + type Future = Fut; - fn new_service(&self, _: C) -> Self::Future { + fn new_service(&self, _: Cfg) -> Self::Future { (self.f)() } } -impl Clone for FnServiceNoConfig +impl Clone for FnServiceNoConfig where - F: Fn() -> R + Clone, - R: Future>, - S: Service, + F: Fn() -> Fut + Clone, + Fut: Future>, + Srv: Service, { fn clone(&self) -> Self { Self::new(self.f.clone()) } } -impl IntoServiceFactory> for F +impl + IntoServiceFactory, Req> for F where - F: Fn() -> R, - R: Future>, - S: Service, + F: Fn() -> Fut, + Fut: Future>, + Srv: Service, { - fn into_factory(self) -> FnServiceNoConfig { + fn into_factory(self) -> FnServiceNoConfig { FnServiceNoConfig::new(self) } } #[cfg(test)] mod tests { - use std::task::Poll; + use core::task::Poll; - use futures_util::future::{lazy, ok}; + use futures_util::future::lazy; use super::*; - use crate::{Service, ServiceFactory}; + use crate::{ok, Service, ServiceFactory}; #[actix_rt::test] async fn test_fn_service() { let new_srv = fn_service(|()| ok::<_, ()>("srv")); - let mut srv = new_srv.new_service(()).await.unwrap(); + let srv = new_srv.new_service(()).await.unwrap(); let res = srv.call(()).await; assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(()))); assert!(res.is_ok()); @@ -380,7 +373,7 @@ mod tests { #[actix_rt::test] async fn test_fn_service_service() { - let mut srv = fn_service(|()| ok::<_, ()>("srv")); + let srv = fn_service(|()| ok::<_, ()>("srv")); let res = srv.call(()).await; assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(()))); @@ -394,7 +387,7 @@ mod tests { ok::<_, ()>(fn_service(move |()| ok::<_, ()>(("srv", cfg)))) }); - let mut srv = new_srv.new_service(1).await.unwrap(); + let srv = new_srv.new_service(1).await.unwrap(); let res = srv.call(()).await; assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(()))); assert!(res.is_ok()); diff --git a/actix-service/src/lib.rs b/actix-service/src/lib.rs index 96c878e3..7c3a271c 100644 --- a/actix-service/src/lib.rs +++ b/actix-service/src/lib.rs @@ -1,45 +1,54 @@ //! See [`Service`] docs for information on this crate's foundational trait. +#![no_std] #![deny(rust_2018_idioms, nonstandard_style)] #![allow(clippy::type_complexity)] #![doc(html_logo_url = "https://actix.rs/img/logo.png")] #![doc(html_favicon_url = "https://actix.rs/favicon.ico")] -use std::cell::RefCell; -use std::future::Future; -use std::rc::Rc; -use std::sync::Arc; -use std::task::{self, Context, Poll}; +extern crate alloc; + +use alloc::{boxed::Box, rc::Rc, sync::Arc}; +use core::{ + cell::RefCell, + future::Future, + task::{self, Context, Poll}, +}; mod and_then; -mod and_then_apply_fn; mod apply; mod apply_cfg; pub mod boxed; +mod ext; mod fn_service; mod map; mod map_config; mod map_err; mod map_init_err; mod pipeline; +mod ready; mod then; mod transform; mod transform_err; pub use self::apply::{apply_fn, apply_fn_factory}; pub use self::apply_cfg::{apply_cfg, apply_cfg_factory}; +pub use self::ext::{ServiceExt, ServiceFactoryExt}; pub use self::fn_service::{fn_factory, fn_factory_with_config, fn_service}; pub use self::map_config::{map_config, unit_config}; pub use self::pipeline::{pipeline, pipeline_factory, Pipeline, PipelineFactory}; pub use self::transform::{apply, Transform}; +#[allow(unused_imports)] +use self::ready::{err, ok, ready, Ready}; + /// An asynchronous operation from `Request` to a `Response`. /// /// The `Service` trait models a request/response interaction, receiving requests and returning /// replies. You can think about a service as a function with one argument that returns some result /// asynchronously. Conceptually, the operation looks like this: /// -/// ```rust,ignore +/// ```ignore /// async fn(Request) -> Result /// ``` /// @@ -51,7 +60,7 @@ pub use self::transform::{apply, Transform}; /// simple API surfaces. This leads to simpler design of each service, improves test-ability and /// makes composition easier. /// -/// ```rust,ignore +/// ```ignore /// struct MyService; /// /// impl Service for MyService { @@ -60,26 +69,23 @@ pub use self::transform::{apply, Transform}; /// type Error = MyError; /// type Future = Pin>>>; /// -/// fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll> { ... } +/// fn poll_ready(&self, cx: &mut Context<'_>) -> Poll> { ... } /// -/// fn call(&mut self, req: Self::Request) -> Self::Future { ... } +/// fn call(&self, req: Self::Request) -> Self::Future { ... } /// } /// ``` /// /// Sometimes it is not necessary to implement the Service trait. For example, the above service /// could be rewritten as a simple function and passed to [fn_service](fn_service()). /// -/// ```rust,ignore +/// ```ignore /// async fn my_service(req: u8) -> Result; /// ``` -pub trait Service { - /// Requests handled by the service. - type Request; - +pub trait Service { /// Responses given by the service. type Response; - /// Errors produced by the service. + /// Errors produced by the service when polling readiness or executing call. type Error; /// The future response value. @@ -98,7 +104,7 @@ pub trait Service { /// # Notes /// 1. `.poll_ready()` might be called on different task from actual service call. /// 1. In case of chained services, `.poll_ready()` get called for all services at once. - fn poll_ready(&mut self, ctx: &mut task::Context<'_>) -> Poll>; + fn poll_ready(&self, ctx: &mut task::Context<'_>) -> Poll>; /// Process the request and return the response asynchronously. /// @@ -109,40 +115,7 @@ pub trait Service { /// /// Calling `call` without calling `poll_ready` is permitted. The /// implementation must be resilient to this fact. - fn call(&mut self, req: Self::Request) -> Self::Future; - - /// Map this service's output to a different type, returning a new service - /// of the resulting type. - /// - /// This function is similar to the `Option::map` or `Iterator::map` where - /// it will change the type of the underlying service. - /// - /// Note that this function consumes the receiving service and returns a - /// wrapped version of it, similar to the existing `map` methods in the - /// standard library. - fn map(self, f: F) -> crate::dev::Map - where - Self: Sized, - F: FnMut(Self::Response) -> R, - { - crate::dev::Map::new(self, f) - } - - /// Map this service's error to a different error, returning a new service. - /// - /// This function is similar to the `Result::map_err` where it will change - /// the error type of the underlying service. For example, this can be useful to - /// ensure that services have the same error type. - /// - /// Note that this function consumes the receiving service and returns a - /// wrapped version of it. - fn map_err(self, f: F) -> crate::dev::MapErr - where - Self: Sized, - F: Fn(Self::Error) -> E, - { - crate::dev::MapErr::new(self, f) - } + fn call(&self, req: Req) -> Self::Future; } /// Factory for creating `Service`s. @@ -154,10 +127,7 @@ pub trait Service { /// requests on that new TCP stream. /// /// `Config` is a service factory configuration type. -pub trait ServiceFactory { - /// Requests handled by the created services. - type Request; - +pub trait ServiceFactory { /// Responses given by the created services. type Response; @@ -168,11 +138,7 @@ pub trait ServiceFactory { type Config; /// The kind of `Service` created by this factory. - type Service: Service< - Request = Self::Request, - Response = Self::Response, - Error = Self::Error, - >; + type Service: Service; /// Errors potentially raised while building a service. type InitError; @@ -182,113 +148,80 @@ pub trait ServiceFactory { /// Create and return a new service asynchronously. fn new_service(&self, cfg: Self::Config) -> Self::Future; - - /// Map this service's output to a different type, returning a new service - /// of the resulting type. - fn map(self, f: F) -> crate::map::MapServiceFactory - where - Self: Sized, - F: FnMut(Self::Response) -> R + Clone, - { - crate::map::MapServiceFactory::new(self, f) - } - - /// Map this service's error to a different error, returning a new service. - fn map_err(self, f: F) -> crate::map_err::MapErrServiceFactory - where - Self: Sized, - F: Fn(Self::Error) -> E + Clone, - { - crate::map_err::MapErrServiceFactory::new(self, f) - } - - /// Map this factory's init error to a different error, returning a new service. - fn map_init_err(self, f: F) -> crate::map_init_err::MapInitErr - where - Self: Sized, - F: Fn(Self::InitError) -> E + Clone, - { - crate::map_init_err::MapInitErr::new(self, f) - } } -impl<'a, S> Service for &'a mut S +impl<'a, S, Req> Service for &'a mut S where - S: Service + 'a, + S: Service + 'a, { - type Request = S::Request; type Response = S::Response; type Error = S::Error; type Future = S::Future; - fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll> { + fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll> { (**self).poll_ready(ctx) } - fn call(&mut self, request: Self::Request) -> S::Future { + fn call(&self, request: Req) -> S::Future { (**self).call(request) } } -impl Service for Box +impl Service for Box where - S: Service + ?Sized, + S: Service + ?Sized, { - type Request = S::Request; type Response = S::Response; type Error = S::Error; type Future = S::Future; - fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll> { + fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll> { (**self).poll_ready(ctx) } - fn call(&mut self, request: Self::Request) -> S::Future { + fn call(&self, request: Req) -> S::Future { (**self).call(request) } } -impl Service for RefCell +impl Service for RefCell where - S: Service, + S: Service, { - type Request = S::Request; type Response = S::Response; type Error = S::Error; type Future = S::Future; - fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll> { - self.borrow_mut().poll_ready(ctx) + fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll> { + self.borrow().poll_ready(ctx) } - fn call(&mut self, request: Self::Request) -> S::Future { - self.borrow_mut().call(request) + fn call(&self, request: Req) -> S::Future { + self.borrow().call(request) } } -impl Service for Rc> +impl Service for Rc> where - S: Service, + S: Service, { - type Request = S::Request; type Response = S::Response; type Error = S::Error; type Future = S::Future; - fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll> { - self.borrow_mut().poll_ready(ctx) + fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll> { + self.borrow().poll_ready(ctx) } - fn call(&mut self, request: Self::Request) -> S::Future { - (&mut (**self).borrow_mut()).call(request) + fn call(&self, request: Req) -> S::Future { + self.borrow().call(request) } } -impl ServiceFactory for Rc +impl ServiceFactory for Rc where - S: ServiceFactory, + S: ServiceFactory, { - type Request = S::Request; type Response = S::Response; type Error = S::Error; type Config = S::Config; @@ -301,11 +234,10 @@ where } } -impl ServiceFactory for Arc +impl ServiceFactory for Arc where - S: ServiceFactory, + S: ServiceFactory, { - type Request = S::Request; type Response = S::Response; type Error = S::Error; type Config = S::Config; @@ -319,52 +251,52 @@ where } /// Trait for types that can be converted to a `Service` -pub trait IntoService +pub trait IntoService where - T: Service, + S: Service, { /// Convert to a `Service` - fn into_service(self) -> T; + fn into_service(self) -> S; } /// Trait for types that can be converted to a `ServiceFactory` -pub trait IntoServiceFactory +pub trait IntoServiceFactory where - T: ServiceFactory, + SF: ServiceFactory, { /// Convert `Self` to a `ServiceFactory` - fn into_factory(self) -> T; + fn into_factory(self) -> SF; } -impl IntoService for T +impl IntoService for S where - T: Service, + S: Service, { - fn into_service(self) -> T { + fn into_service(self) -> S { self } } -impl IntoServiceFactory for T +impl IntoServiceFactory for SF where - T: ServiceFactory, + SF: ServiceFactory, { - fn into_factory(self) -> T { + fn into_factory(self) -> SF { self } } -/// Convert object of type `T` to a service `S` -pub fn into_service(tp: T) -> S +/// Convert object of type `U` to a service `S` +pub fn into_service(tp: I) -> S where - S: Service, - T: IntoService, + I: IntoService, + S: Service, { tp.into_service() } pub mod dev { - pub use crate::apply::{Apply, ApplyServiceFactory}; + pub use crate::apply::{Apply, ApplyFactory}; pub use crate::fn_service::{ FnService, FnServiceConfig, FnServiceFactory, FnServiceNoConfig, }; @@ -375,3 +307,31 @@ pub mod dev { pub use crate::transform::ApplyTransform; pub use crate::transform_err::TransformMapInitErr; } + +#[macro_export] +macro_rules! always_ready { + () => { + #[inline] + fn poll_ready( + &self, + _: &mut ::core::task::Context<'_>, + ) -> ::core::task::Poll> { + Poll::Ready(Ok(())) + } + }; +} + +#[macro_export] +macro_rules! forward_ready { + ($field:ident) => { + #[inline] + fn poll_ready( + &self, + cx: &mut ::core::task::Context<'_>, + ) -> ::core::task::Poll> { + self.$field + .poll_ready(cx) + .map_err(::core::convert::Into::into) + } + }; +} diff --git a/actix-service/src/map.rs b/actix-service/src/map.rs index ec3520a1..12fd4395 100644 --- a/actix-service/src/map.rs +++ b/actix-service/src/map.rs @@ -1,25 +1,29 @@ -use std::future::Future; -use std::marker::PhantomData; -use std::pin::Pin; -use std::task::{Context, Poll}; +use core::{ + future::Future, + marker::PhantomData, + pin::Pin, + task::{Context, Poll}, +}; + +use pin_project_lite::pin_project; use super::{Service, ServiceFactory}; /// Service for the `map` combinator, changing the type of a service's response. /// /// This is created by the `ServiceExt::map` method. -pub struct Map { +pub struct Map { service: A, f: F, - _t: PhantomData, + _t: PhantomData<(Req, Res)>, } -impl Map { +impl Map { /// Create new `Map` combinator pub(crate) fn new(service: A, f: F) -> Self where - A: Service, - F: FnMut(A::Response) -> Response, + A: Service, + F: FnMut(A::Response) -> Res, { Self { service, @@ -29,7 +33,7 @@ impl Map { } } -impl Clone for Map +impl Clone for Map where A: Clone, F: Clone, @@ -43,52 +47,50 @@ where } } -impl Service for Map +impl Service for Map where - A: Service, - F: FnMut(A::Response) -> Response + Clone, + A: Service, + F: FnMut(A::Response) -> Res + Clone, { - type Request = A::Request; - type Response = Response; + type Response = Res; type Error = A::Error; - type Future = MapFuture; + type Future = MapFuture; - fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll> { - self.service.poll_ready(ctx) - } + crate::forward_ready!(service); - fn call(&mut self, req: A::Request) -> Self::Future { + fn call(&self, req: Req) -> Self::Future { MapFuture::new(self.service.call(req), self.f.clone()) } } -#[pin_project::pin_project] -pub struct MapFuture -where - A: Service, - F: FnMut(A::Response) -> Response, -{ - f: F, - #[pin] - fut: A::Future, +pin_project! { + pub struct MapFuture + where + A: Service, + F: FnMut(A::Response) -> Res, + { + f: F, + #[pin] + fut: A::Future, + } } -impl MapFuture +impl MapFuture where - A: Service, - F: FnMut(A::Response) -> Response, + A: Service, + F: FnMut(A::Response) -> Res, { fn new(fut: A::Future, f: F) -> Self { MapFuture { f, fut } } } -impl Future for MapFuture +impl Future for MapFuture where - A: Service, - F: FnMut(A::Response) -> Response, + A: Service, + F: FnMut(A::Response) -> Res, { - type Output = Result; + type Output = Result; fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { let this = self.project(); @@ -102,17 +104,17 @@ where } /// `MapNewService` new service combinator -pub struct MapServiceFactory { +pub struct MapServiceFactory { a: A, f: F, - r: PhantomData, + r: PhantomData<(Res, Req)>, } -impl MapServiceFactory { +impl MapServiceFactory { /// Create new `Map` new service instance pub(crate) fn new(a: A, f: F) -> Self where - A: ServiceFactory, + A: ServiceFactory, F: FnMut(A::Response) -> Res, { Self { @@ -123,7 +125,7 @@ impl MapServiceFactory { } } -impl Clone for MapServiceFactory +impl Clone for MapServiceFactory where A: Clone, F: Clone, @@ -137,39 +139,39 @@ where } } -impl ServiceFactory for MapServiceFactory +impl ServiceFactory for MapServiceFactory where - A: ServiceFactory, + A: ServiceFactory, F: FnMut(A::Response) -> Res + Clone, { - type Request = A::Request; type Response = Res; type Error = A::Error; type Config = A::Config; - type Service = Map; + type Service = Map; type InitError = A::InitError; - type Future = MapServiceFuture; + type Future = MapServiceFuture; fn new_service(&self, cfg: A::Config) -> Self::Future { MapServiceFuture::new(self.a.new_service(cfg), self.f.clone()) } } -#[pin_project::pin_project] -pub struct MapServiceFuture -where - A: ServiceFactory, - F: FnMut(A::Response) -> Res, -{ - #[pin] - fut: A::Future, - f: Option, +pin_project! { + pub struct MapServiceFuture + where + A: ServiceFactory, + F: FnMut(A::Response) -> Res, + { + #[pin] + fut: A::Future, + f: Option, + } } -impl MapServiceFuture +impl MapServiceFuture where - A: ServiceFactory, + A: ServiceFactory, F: FnMut(A::Response) -> Res, { fn new(fut: A::Future, f: F) -> Self { @@ -177,12 +179,12 @@ where } } -impl Future for MapServiceFuture +impl Future for MapServiceFuture where - A: ServiceFactory, + A: ServiceFactory, F: FnMut(A::Response) -> Res, { - type Output = Result, A::InitError>; + type Output = Result, A::InitError>; fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { let this = self.project(); @@ -197,38 +199,37 @@ where #[cfg(test)] mod tests { - use futures_util::future::{lazy, ok, Ready}; + use futures_util::future::lazy; use super::*; - use crate::{IntoServiceFactory, Service, ServiceFactory}; + use crate::{ + ok, IntoServiceFactory, Ready, Service, ServiceExt, ServiceFactory, ServiceFactoryExt, + }; struct Srv; - impl Service for Srv { - type Request = (); + impl Service<()> for Srv { type Response = (); type Error = (); type Future = Ready>; - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { - Poll::Ready(Ok(())) - } + crate::always_ready!(); - fn call(&mut self, _: ()) -> Self::Future { + fn call(&self, _: ()) -> Self::Future { ok(()) } } #[actix_rt::test] async fn test_poll_ready() { - let mut srv = Srv.map(|_| "ok"); + let srv = Srv.map(|_| "ok"); let res = lazy(|cx| srv.poll_ready(cx)).await; assert_eq!(res, Poll::Ready(Ok(()))); } #[actix_rt::test] async fn test_call() { - let mut srv = Srv.map(|_| "ok"); + let srv = Srv.map(|_| "ok"); let res = srv.call(()).await; assert!(res.is_ok()); assert_eq!(res.unwrap(), "ok"); @@ -237,7 +238,7 @@ mod tests { #[actix_rt::test] async fn test_new_service() { let new_srv = (|| ok::<_, ()>(Srv)).into_factory().map(|_| "ok"); - let mut srv = new_srv.new_service(&()).await.unwrap(); + let srv = new_srv.new_service(&()).await.unwrap(); let res = srv.call(()).await; assert!(res.is_ok()); assert_eq!(res.unwrap(), ("ok")); diff --git a/actix-service/src/map_config.rs b/actix-service/src/map_config.rs index 7a1a1b89..1297f7a0 100644 --- a/actix-service/src/map_config.rs +++ b/actix-service/src/map_config.rs @@ -1,4 +1,4 @@ -use std::marker::PhantomData; +use core::marker::PhantomData; use super::{IntoServiceFactory, ServiceFactory}; @@ -6,121 +6,123 @@ use super::{IntoServiceFactory, ServiceFactory}; /// /// Note that this function consumes the receiving service factory and returns /// a wrapped version of it. -pub fn map_config(factory: U, f: F) -> MapConfig +pub fn map_config(factory: I, f: F) -> MapConfig where - T: ServiceFactory, - U: IntoServiceFactory, - F: Fn(C) -> T::Config, + I: IntoServiceFactory, + SF: ServiceFactory, + F: Fn(Cfg) -> SF::Config, { MapConfig::new(factory.into_factory(), f) } -/// Replace config with unit -pub fn unit_config(factory: U) -> UnitConfig +/// Replace config with unit. +pub fn unit_config(factory: I) -> UnitConfig where - T: ServiceFactory, - U: IntoServiceFactory, + I: IntoServiceFactory, + SF: ServiceFactory, { UnitConfig::new(factory.into_factory()) } /// `map_config()` adapter service factory -pub struct MapConfig { - a: A, - f: F, - e: PhantomData, +pub struct MapConfig { + factory: SF, + cfg_mapper: F, + e: PhantomData<(Cfg, Req)>, } -impl MapConfig { +impl MapConfig { /// Create new `MapConfig` combinator - pub(crate) fn new(a: A, f: F) -> Self + pub(crate) fn new(factory: SF, cfg_mapper: F) -> Self where - A: ServiceFactory, - F: Fn(C) -> A::Config, + SF: ServiceFactory, + F: Fn(Cfg) -> SF::Config, { Self { - a, - f, + factory, + cfg_mapper, e: PhantomData, } } } -impl Clone for MapConfig +impl Clone for MapConfig where - A: Clone, + SF: Clone, F: Clone, { fn clone(&self) -> Self { Self { - a: self.a.clone(), - f: self.f.clone(), + factory: self.factory.clone(), + cfg_mapper: self.cfg_mapper.clone(), e: PhantomData, } } } -impl ServiceFactory for MapConfig +impl ServiceFactory for MapConfig where - A: ServiceFactory, - F: Fn(C) -> A::Config, + SF: ServiceFactory, + F: Fn(Cfg) -> SF::Config, { - type Request = A::Request; - type Response = A::Response; - type Error = A::Error; + type Response = SF::Response; + type Error = SF::Error; - type Config = C; - type Service = A::Service; - type InitError = A::InitError; - type Future = A::Future; + type Config = Cfg; + type Service = SF::Service; + type InitError = SF::InitError; + type Future = SF::Future; - fn new_service(&self, cfg: C) -> Self::Future { - self.a.new_service((self.f)(cfg)) + fn new_service(&self, cfg: Self::Config) -> Self::Future { + let mapped_cfg = (self.cfg_mapper)(cfg); + self.factory.new_service(mapped_cfg) } } /// `unit_config()` config combinator -pub struct UnitConfig { - a: A, - e: PhantomData, +pub struct UnitConfig { + factory: SF, + _phantom: PhantomData<(Cfg, Req)>, } -impl UnitConfig +impl UnitConfig where - A: ServiceFactory, + SF: ServiceFactory, { /// Create new `UnitConfig` combinator - pub(crate) fn new(a: A) -> Self { - Self { a, e: PhantomData } - } -} - -impl Clone for UnitConfig -where - A: Clone, -{ - fn clone(&self) -> Self { + pub(crate) fn new(factory: SF) -> Self { Self { - a: self.a.clone(), - e: PhantomData, + factory, + _phantom: PhantomData, } } } -impl ServiceFactory for UnitConfig +impl Clone for UnitConfig where - A: ServiceFactory, + SF: Clone, { - type Request = A::Request; - type Response = A::Response; - type Error = A::Error; - - type Config = C; - type Service = A::Service; - type InitError = A::InitError; - type Future = A::Future; - - fn new_service(&self, _: C) -> Self::Future { - self.a.new_service(()) + fn clone(&self) -> Self { + Self { + factory: self.factory.clone(), + _phantom: PhantomData, + } + } +} + +impl ServiceFactory for UnitConfig +where + SF: ServiceFactory, +{ + type Response = SF::Response; + type Error = SF::Error; + + type Config = Cfg; + type Service = SF::Service; + type InitError = SF::InitError; + type Future = SF::Future; + + fn new_service(&self, _: Cfg) -> Self::Future { + self.factory.new_service(()) } } diff --git a/actix-service/src/map_err.rs b/actix-service/src/map_err.rs index ee7145c3..ff25c4f7 100644 --- a/actix-service/src/map_err.rs +++ b/actix-service/src/map_err.rs @@ -1,7 +1,11 @@ -use std::future::Future; -use std::marker::PhantomData; -use std::pin::Pin; -use std::task::{Context, Poll}; +use core::{ + future::Future, + marker::PhantomData, + pin::Pin, + task::{Context, Poll}, +}; + +use pin_project_lite::pin_project; use super::{Service, ServiceFactory}; @@ -9,18 +13,18 @@ use super::{Service, ServiceFactory}; /// error. /// /// This is created by the `ServiceExt::map_err` method. -pub struct MapErr { - service: A, +pub struct MapErr { + service: S, f: F, - _t: PhantomData, + _t: PhantomData<(E, Req)>, } -impl MapErr { +impl MapErr { /// Create new `MapErr` combinator - pub(crate) fn new(service: A, f: F) -> Self + pub(crate) fn new(service: S, f: F) -> Self where - A: Service, - F: Fn(A::Error) -> E, + S: Service, + F: Fn(S::Error) -> E, { Self { service, @@ -30,9 +34,9 @@ impl MapErr { } } -impl Clone for MapErr +impl Clone for MapErr where - A: Clone, + S: Clone, F: Clone, { fn clone(&self) -> Self { @@ -44,39 +48,39 @@ where } } -impl Service for MapErr +impl Service for MapErr where - A: Service, + A: Service, F: Fn(A::Error) -> E + Clone, { - type Request = A::Request; type Response = A::Response; type Error = E; - type Future = MapErrFuture; + type Future = MapErrFuture; - fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll> { + fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll> { self.service.poll_ready(ctx).map_err(&self.f) } - fn call(&mut self, req: A::Request) -> Self::Future { + fn call(&self, req: Req) -> Self::Future { MapErrFuture::new(self.service.call(req), self.f.clone()) } } -#[pin_project::pin_project] -pub struct MapErrFuture -where - A: Service, - F: Fn(A::Error) -> E, -{ - f: F, - #[pin] - fut: A::Future, +pin_project! { + pub struct MapErrFuture + where + A: Service, + F: Fn(A::Error) -> E, + { + f: F, + #[pin] + fut: A::Future, + } } -impl MapErrFuture +impl MapErrFuture where - A: Service, + A: Service, F: Fn(A::Error) -> E, { fn new(fut: A::Future, f: F) -> Self { @@ -84,9 +88,9 @@ where } } -impl Future for MapErrFuture +impl Future for MapErrFuture where - A: Service, + A: Service, F: Fn(A::Error) -> E, { type Output = Result; @@ -101,19 +105,19 @@ where /// service's error. /// /// This is created by the `NewServiceExt::map_err` method. -pub struct MapErrServiceFactory +pub struct MapErrServiceFactory where - A: ServiceFactory, + A: ServiceFactory, F: Fn(A::Error) -> E + Clone, { a: A, f: F, - e: PhantomData, + e: PhantomData<(E, Req)>, } -impl MapErrServiceFactory +impl MapErrServiceFactory where - A: ServiceFactory, + A: ServiceFactory, F: Fn(A::Error) -> E + Clone, { /// Create new `MapErr` new service instance @@ -126,9 +130,9 @@ where } } -impl Clone for MapErrServiceFactory +impl Clone for MapErrServiceFactory where - A: ServiceFactory + Clone, + A: ServiceFactory + Clone, F: Fn(A::Error) -> E + Clone, { fn clone(&self) -> Self { @@ -140,39 +144,39 @@ where } } -impl ServiceFactory for MapErrServiceFactory +impl ServiceFactory for MapErrServiceFactory where - A: ServiceFactory, + A: ServiceFactory, F: Fn(A::Error) -> E + Clone, { - type Request = A::Request; type Response = A::Response; type Error = E; type Config = A::Config; - type Service = MapErr; + type Service = MapErr; type InitError = A::InitError; - type Future = MapErrServiceFuture; + type Future = MapErrServiceFuture; fn new_service(&self, cfg: A::Config) -> Self::Future { MapErrServiceFuture::new(self.a.new_service(cfg), self.f.clone()) } } -#[pin_project::pin_project] -pub struct MapErrServiceFuture -where - A: ServiceFactory, - F: Fn(A::Error) -> E, -{ - #[pin] - fut: A::Future, - f: F, +pin_project! { + pub struct MapErrServiceFuture + where + A: ServiceFactory, + F: Fn(A::Error) -> E, + { + #[pin] + fut: A::Future, + f: F, + } } -impl MapErrServiceFuture +impl MapErrServiceFuture where - A: ServiceFactory, + A: ServiceFactory, F: Fn(A::Error) -> E, { fn new(fut: A::Future, f: F) -> Self { @@ -180,12 +184,12 @@ where } } -impl Future for MapErrServiceFuture +impl Future for MapErrServiceFuture where - A: ServiceFactory, + A: ServiceFactory, F: Fn(A::Error) -> E + Clone, { - type Output = Result, A::InitError>; + type Output = Result, A::InitError>; fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { let this = self.project(); @@ -199,38 +203,40 @@ where #[cfg(test)] mod tests { - use futures_util::future::{err, lazy, ok, Ready}; + use futures_util::future::lazy; use super::*; - use crate::{IntoServiceFactory, Service, ServiceFactory}; + use crate::{ + err, ok, IntoServiceFactory, Ready, Service, ServiceExt, ServiceFactory, + ServiceFactoryExt, + }; struct Srv; - impl Service for Srv { - type Request = (); + impl Service<()> for Srv { type Response = (); type Error = (); type Future = Ready>; - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { + fn poll_ready(&self, _: &mut Context<'_>) -> Poll> { Poll::Ready(Err(())) } - fn call(&mut self, _: ()) -> Self::Future { + fn call(&self, _: ()) -> Self::Future { err(()) } } #[actix_rt::test] async fn test_poll_ready() { - let mut srv = Srv.map_err(|_| "error"); + let srv = Srv.map_err(|_| "error"); let res = lazy(|cx| srv.poll_ready(cx)).await; assert_eq!(res, Poll::Ready(Err("error"))); } #[actix_rt::test] async fn test_call() { - let mut srv = Srv.map_err(|_| "error"); + let srv = Srv.map_err(|_| "error"); let res = srv.call(()).await; assert!(res.is_err()); assert_eq!(res.err().unwrap(), "error"); @@ -239,7 +245,7 @@ mod tests { #[actix_rt::test] async fn test_new_service() { let new_srv = (|| ok::<_, ()>(Srv)).into_factory().map_err(|_| "error"); - let mut srv = new_srv.new_service(&()).await.unwrap(); + let srv = new_srv.new_service(&()).await.unwrap(); let res = srv.call(()).await; assert!(res.is_err()); assert_eq!(res.err().unwrap(), "error"); diff --git a/actix-service/src/map_init_err.rs b/actix-service/src/map_init_err.rs index b1eec072..9fc383aa 100644 --- a/actix-service/src/map_init_err.rs +++ b/actix-service/src/map_init_err.rs @@ -1,21 +1,25 @@ -use std::future::Future; -use std::marker::PhantomData; -use std::pin::Pin; -use std::task::{Context, Poll}; +use core::{ + future::Future, + marker::PhantomData, + pin::Pin, + task::{Context, Poll}, +}; + +use pin_project_lite::pin_project; use super::ServiceFactory; /// `MapInitErr` service combinator -pub struct MapInitErr { +pub struct MapInitErr { a: A, f: F, - e: PhantomData, + e: PhantomData<(Req, Err)>, } -impl MapInitErr +impl MapInitErr where - A: ServiceFactory, - F: Fn(A::InitError) -> E, + A: ServiceFactory, + F: Fn(A::InitError) -> Err, { /// Create new `MapInitErr` combinator pub(crate) fn new(a: A, f: F) -> Self { @@ -27,7 +31,7 @@ where } } -impl Clone for MapInitErr +impl Clone for MapInitErr where A: Clone, F: Clone, @@ -41,39 +45,39 @@ where } } -impl ServiceFactory for MapInitErr +impl ServiceFactory for MapInitErr where - A: ServiceFactory, + A: ServiceFactory, F: Fn(A::InitError) -> E + Clone, { - type Request = A::Request; type Response = A::Response; type Error = A::Error; type Config = A::Config; type Service = A::Service; type InitError = E; - type Future = MapInitErrFuture; + type Future = MapInitErrFuture; fn new_service(&self, cfg: A::Config) -> Self::Future { MapInitErrFuture::new(self.a.new_service(cfg), self.f.clone()) } } -#[pin_project::pin_project] -pub struct MapInitErrFuture -where - A: ServiceFactory, - F: Fn(A::InitError) -> E, -{ - f: F, - #[pin] - fut: A::Future, +pin_project! { + pub struct MapInitErrFuture + where + A: ServiceFactory, + F: Fn(A::InitError) -> E, + { + f: F, + #[pin] + fut: A::Future, + } } -impl MapInitErrFuture +impl MapInitErrFuture where - A: ServiceFactory, + A: ServiceFactory, F: Fn(A::InitError) -> E, { fn new(fut: A::Future, f: F) -> Self { @@ -81,9 +85,9 @@ where } } -impl Future for MapInitErrFuture +impl Future for MapInitErrFuture where - A: ServiceFactory, + A: ServiceFactory, F: Fn(A::InitError) -> E, { type Output = Result; diff --git a/actix-service/src/pipeline.rs b/actix-service/src/pipeline.rs index 75cd6af9..0ec43f0d 100644 --- a/actix-service/src/pipeline.rs +++ b/actix-service/src/pipeline.rs @@ -1,8 +1,9 @@ -use std::future::Future; -use std::task::{Context, Poll}; +use core::{ + marker::PhantomData, + task::{Context, Poll}, +}; use crate::and_then::{AndThenService, AndThenServiceFactory}; -use crate::and_then_apply_fn::{AndThenApplyFn, AndThenApplyFnFactory}; use crate::map::{Map, MapServiceFactory}; use crate::map_err::{MapErr, MapErrServiceFactory}; use crate::map_init_err::MapInitErr; @@ -10,33 +11,39 @@ use crate::then::{ThenService, ThenServiceFactory}; use crate::{IntoService, IntoServiceFactory, Service, ServiceFactory}; /// Construct new pipeline with one service in pipeline chain. -pub fn pipeline(service: F) -> Pipeline +pub fn pipeline(service: I) -> Pipeline where - F: IntoService, - T: Service, + I: IntoService, + S: Service, { Pipeline { service: service.into_service(), + _phantom: PhantomData, } } /// Construct new pipeline factory with one service factory. -pub fn pipeline_factory(factory: F) -> PipelineFactory +pub fn pipeline_factory(factory: I) -> PipelineFactory where - T: ServiceFactory, - F: IntoServiceFactory, + I: IntoServiceFactory, + SF: ServiceFactory, { PipelineFactory { factory: factory.into_factory(), + _phantom: PhantomData, } } /// Pipeline service - pipeline allows to compose multiple service into one service. -pub struct Pipeline { - service: T, +pub struct Pipeline { + service: S, + _phantom: PhantomData, } -impl Pipeline { +impl Pipeline +where + S: Service, +{ /// Call another service after call to this one has resolved successfully. /// /// This function can be used to chain two services together and ensure that @@ -46,41 +53,18 @@ impl Pipeline { /// /// Note that this function consumes the receiving service and returns a /// wrapped version of it. - pub fn and_then( + pub fn and_then( self, - service: F, - ) -> Pipeline< - impl Service + Clone, - > + service: I, + ) -> Pipeline + Clone, Req> where Self: Sized, - F: IntoService, - U: Service, + I: IntoService, + S1: Service, { Pipeline { service: AndThenService::new(self.service, service.into_service()), - } - } - - /// Apply function to specified service and use it as a next service in - /// chain. - /// - /// Short version of `pipeline_factory(...).and_then(apply_fn_factory(...))` - pub fn and_then_apply_fn( - self, - service: I, - f: F, - ) -> Pipeline + Clone> - where - Self: Sized, - I: IntoService, - U: Service, - F: FnMut(T::Response, &mut U) -> Fut, - Fut: Future>, - Err: From + From, - { - Pipeline { - service: AndThenApplyFn::new(self.service, service.into_service(), f), + _phantom: PhantomData, } } @@ -89,19 +73,18 @@ impl Pipeline { /// /// Note that this function consumes the receiving pipeline and returns a /// wrapped version of it. - pub fn then( + pub fn then( self, service: F, - ) -> Pipeline< - impl Service + Clone, - > + ) -> Pipeline + Clone, Req> where Self: Sized, - F: IntoService, - U: Service, Error = T::Error>, + F: IntoService>, + S1: Service, Error = S::Error>, { Pipeline { service: ThenService::new(self.service, service.into_service()), + _phantom: PhantomData, } } @@ -114,13 +97,14 @@ impl Pipeline { /// Note that this function consumes the receiving service and returns a /// wrapped version of it, similar to the existing `map` methods in the /// standard library. - pub fn map(self, f: F) -> Pipeline> + pub fn map(self, f: F) -> Pipeline, Req> where Self: Sized, - F: FnMut(T::Response) -> R, + F: FnMut(S::Response) -> R, { Pipeline { service: Map::new(self.service, f), + _phantom: PhantomData, } } @@ -132,114 +116,85 @@ impl Pipeline { /// /// Note that this function consumes the receiving service and returns a /// wrapped version of it. - pub fn map_err(self, f: F) -> Pipeline> + pub fn map_err(self, f: F) -> Pipeline, Req> where Self: Sized, - F: Fn(T::Error) -> E, + F: Fn(S::Error) -> E, { Pipeline { service: MapErr::new(self.service, f), + _phantom: PhantomData, } } } -impl Clone for Pipeline +impl Clone for Pipeline where T: Clone, { fn clone(&self) -> Self { Pipeline { service: self.service.clone(), + _phantom: PhantomData, } } } -impl Service for Pipeline { - type Request = T::Request; - type Response = T::Response; - type Error = T::Error; - type Future = T::Future; +impl, Req> Service for Pipeline { + type Response = S::Response; + type Error = S::Error; + type Future = S::Future; #[inline] - fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll> { + fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll> { self.service.poll_ready(ctx) } #[inline] - fn call(&mut self, req: T::Request) -> Self::Future { + fn call(&self, req: Req) -> Self::Future { self.service.call(req) } } /// Pipeline factory -pub struct PipelineFactory { - factory: T, +pub struct PipelineFactory { + factory: SF, + _phantom: PhantomData, } -impl PipelineFactory { +impl PipelineFactory +where + SF: ServiceFactory, +{ /// Call another service after call to this one has resolved successfully. - pub fn and_then( + pub fn and_then( self, - factory: F, + factory: I, ) -> PipelineFactory< impl ServiceFactory< - Request = T::Request, - Response = U::Response, - Error = T::Error, - Config = T::Config, - InitError = T::InitError, - Service = impl Service< - Request = T::Request, - Response = U::Response, - Error = T::Error, - > + Clone, + Req, + Response = SF1::Response, + Error = SF::Error, + Config = SF::Config, + InitError = SF::InitError, + Service = impl Service + Clone, > + Clone, + Req, > where Self: Sized, - T::Config: Clone, - F: IntoServiceFactory, - U: ServiceFactory< - Config = T::Config, - Request = T::Response, - Error = T::Error, - InitError = T::InitError, + SF::Config: Clone, + I: IntoServiceFactory, + SF1: ServiceFactory< + SF::Response, + Config = SF::Config, + Error = SF::Error, + InitError = SF::InitError, >, { PipelineFactory { factory: AndThenServiceFactory::new(self.factory, factory.into_factory()), - } - } - - /// Apply function to specified service and use it as a next service in - /// chain. - /// - /// Short version of `pipeline_factory(...).and_then(apply_fn_factory(...))` - pub fn and_then_apply_fn( - self, - factory: I, - f: F, - ) -> PipelineFactory< - impl ServiceFactory< - Request = T::Request, - Response = Res, - Error = Err, - Config = T::Config, - InitError = T::InitError, - Service = impl Service + Clone, - > + Clone, - > - where - Self: Sized, - T::Config: Clone, - I: IntoServiceFactory, - U: ServiceFactory, - F: FnMut(T::Response, &mut U::Service) -> Fut + Clone, - Fut: Future>, - Err: From + From, - { - PipelineFactory { - factory: AndThenApplyFnFactory::new(self.factory, factory.into_factory(), f), + _phantom: PhantomData, } } @@ -249,96 +204,103 @@ impl PipelineFactory { /// /// Note that this function consumes the receiving pipeline and returns a /// wrapped version of it. - pub fn then( + pub fn then( self, - factory: F, + factory: I, ) -> PipelineFactory< impl ServiceFactory< - Request = T::Request, - Response = U::Response, - Error = T::Error, - Config = T::Config, - InitError = T::InitError, - Service = impl Service< - Request = T::Request, - Response = U::Response, - Error = T::Error, - > + Clone, + Req, + Response = SF1::Response, + Error = SF::Error, + Config = SF::Config, + InitError = SF::InitError, + Service = impl Service + Clone, > + Clone, + Req, > where Self: Sized, - T::Config: Clone, - F: IntoServiceFactory, - U: ServiceFactory< - Config = T::Config, - Request = Result, - Error = T::Error, - InitError = T::InitError, + SF::Config: Clone, + I: IntoServiceFactory>, + SF1: ServiceFactory< + Result, + Config = SF::Config, + Error = SF::Error, + InitError = SF::InitError, >, { PipelineFactory { factory: ThenServiceFactory::new(self.factory, factory.into_factory()), + _phantom: PhantomData, } } /// Map this service's output to a different type, returning a new service /// of the resulting type. - pub fn map(self, f: F) -> PipelineFactory> + pub fn map(self, f: F) -> PipelineFactory, Req> where Self: Sized, - F: FnMut(T::Response) -> R + Clone, + F: FnMut(SF::Response) -> R + Clone, { PipelineFactory { factory: MapServiceFactory::new(self.factory, f), + _phantom: PhantomData, } } /// Map this service's error to a different error, returning a new service. - pub fn map_err(self, f: F) -> PipelineFactory> + pub fn map_err( + self, + f: F, + ) -> PipelineFactory, Req> where Self: Sized, - F: Fn(T::Error) -> E + Clone, + F: Fn(SF::Error) -> E + Clone, { PipelineFactory { factory: MapErrServiceFactory::new(self.factory, f), + _phantom: PhantomData, } } /// Map this factory's init error to a different error, returning a new service. - pub fn map_init_err(self, f: F) -> PipelineFactory> + pub fn map_init_err(self, f: F) -> PipelineFactory, Req> where Self: Sized, - F: Fn(T::InitError) -> E + Clone, + F: Fn(SF::InitError) -> E + Clone, { PipelineFactory { factory: MapInitErr::new(self.factory, f), + _phantom: PhantomData, } } } -impl Clone for PipelineFactory +impl Clone for PipelineFactory where T: Clone, { fn clone(&self) -> Self { PipelineFactory { factory: self.factory.clone(), + _phantom: PhantomData, } } } -impl ServiceFactory for PipelineFactory { - type Config = T::Config; - type Request = T::Request; - type Response = T::Response; - type Error = T::Error; - type Service = T::Service; - type InitError = T::InitError; - type Future = T::Future; +impl ServiceFactory for PipelineFactory +where + SF: ServiceFactory, +{ + type Config = SF::Config; + type Response = SF::Response; + type Error = SF::Error; + type Service = SF::Service; + type InitError = SF::InitError; + type Future = SF::Future; #[inline] - fn new_service(&self, cfg: T::Config) -> Self::Future { + fn new_service(&self, cfg: SF::Config) -> Self::Future { self.factory.new_service(cfg) } } diff --git a/actix-service/src/ready.rs b/actix-service/src/ready.rs new file mode 100644 index 00000000..8b0c2ea7 --- /dev/null +++ b/actix-service/src/ready.rs @@ -0,0 +1,54 @@ +//! When MSRV is 1.48, replace with `core::future::Ready` and `core::future::ready()`. + +use core::{ + future::Future, + pin::Pin, + task::{Context, Poll}, +}; + +/// Future for the [`ready`](ready()) function. +#[derive(Debug, Clone)] +#[must_use = "futures do nothing unless you `.await` or poll them"] +pub struct Ready { + val: Option, +} + +impl Ready { + /// Unwraps the value from this immediately ready future. + #[inline] + pub fn into_inner(mut self) -> T { + self.val.take().unwrap() + } +} + +impl Unpin for Ready {} + +impl Future for Ready { + type Output = T; + + #[inline] + fn poll(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll { + let val = self.val.take().expect("Ready can not be polled twice."); + Poll::Ready(val) + } +} + +/// Creates a future that is immediately ready with a value. +#[allow(dead_code)] +pub(crate) fn ready(val: T) -> Ready { + Ready { val: Some(val) } +} + +/// Create a future that is immediately ready with a success value. +#[allow(dead_code)] +pub(crate) fn ok(val: T) -> Ready> { + Ready { val: Some(Ok(val)) } +} + +/// Create a future that is immediately ready with an error value. +#[allow(dead_code)] +pub(crate) fn err(err: E) -> Ready> { + Ready { + val: Some(Err(err)), + } +} diff --git a/actix-service/src/then.rs b/actix-service/src/then.rs index 3da46cbb..c9428824 100644 --- a/actix-service/src/then.rs +++ b/actix-service/src/then.rs @@ -1,8 +1,13 @@ -use std::cell::RefCell; -use std::future::Future; -use std::pin::Pin; -use std::rc::Rc; -use std::task::{Context, Poll}; +use alloc::rc::Rc; +use core::{ + future::Future, + marker::PhantomData, + pin::Pin, + task::{Context, Poll}, +}; + +use futures_core::ready; +use pin_project_lite::pin_project; use super::{Service, ServiceFactory}; @@ -10,77 +15,81 @@ use super::{Service, ServiceFactory}; /// another service. /// /// This is created by the `Pipeline::then` method. -pub(crate) struct ThenService(Rc>); +pub(crate) struct ThenService(Rc<(A, B)>, PhantomData); -impl ThenService { +impl ThenService { /// Create new `.then()` combinator - pub(crate) fn new(a: A, b: B) -> ThenService + pub(crate) fn new(a: A, b: B) -> ThenService where - A: Service, - B: Service, Error = A::Error>, + A: Service, + B: Service, Error = A::Error>, { - Self(Rc::new(RefCell::new((a, b)))) + Self(Rc::new((a, b)), PhantomData) } } -impl Clone for ThenService { +impl Clone for ThenService { fn clone(&self) -> Self { - ThenService(self.0.clone()) + ThenService(self.0.clone(), PhantomData) } } -impl Service for ThenService +impl Service for ThenService where - A: Service, - B: Service, Error = A::Error>, + A: Service, + B: Service, Error = A::Error>, { - type Request = A::Request; type Response = B::Response; type Error = B::Error; - type Future = ThenServiceResponse; + type Future = ThenServiceResponse; - fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll> { - let mut srv = self.0.borrow_mut(); - let not_ready = !srv.0.poll_ready(cx)?.is_ready(); - if !srv.1.poll_ready(cx)?.is_ready() || not_ready { + fn poll_ready(&self, cx: &mut Context<'_>) -> Poll> { + let (a, b) = &*self.0; + let not_ready = !a.poll_ready(cx)?.is_ready(); + if !b.poll_ready(cx)?.is_ready() || not_ready { Poll::Pending } else { Poll::Ready(Ok(())) } } - fn call(&mut self, req: A::Request) -> Self::Future { + fn call(&self, req: Req) -> Self::Future { ThenServiceResponse { - state: State::A(self.0.borrow_mut().0.call(req), Some(self.0.clone())), + state: State::A { + fut: self.0 .0.call(req), + b: Some(self.0.clone()), + }, } } } -#[pin_project::pin_project] -pub(crate) struct ThenServiceResponse -where - A: Service, - B: Service>, -{ - #[pin] - state: State, +pin_project! { + pub(crate) struct ThenServiceResponse + where + A: Service, + B: Service>, + { + #[pin] + state: State, + } } -#[pin_project::pin_project(project = StateProj)] -enum State -where - A: Service, - B: Service>, -{ - A(#[pin] A::Future, Option>>), - B(#[pin] B::Future), - Empty, +pin_project! { + #[project = StateProj] + enum State + where + A: Service, + B: Service>, + { + A { #[pin] fut: A::Future, b: Option> }, + B { #[pin] fut: B::Future }, + } } -impl Future for ThenServiceResponse +impl Future for ThenServiceResponse where - A: Service, - B: Service>, + A: Service, + B: Service>, { type Output = Result; @@ -88,66 +97,56 @@ where let mut this = self.as_mut().project(); match this.state.as_mut().project() { - StateProj::A(fut, b) => match fut.poll(cx) { - Poll::Ready(res) => { - let b = b.take().unwrap(); - this.state.set(State::Empty); // drop fut A - let fut = b.borrow_mut().1.call(res); - this.state.set(State::B(fut)); - self.poll(cx) - } - Poll::Pending => Poll::Pending, - }, - StateProj::B(fut) => fut.poll(cx).map(|r| { - this.state.set(State::Empty); - r - }), - StateProj::Empty => { - panic!("future must not be polled after it returned `Poll::Ready`") + StateProj::A { fut, b } => { + let res = ready!(fut.poll(cx)); + let b = b.take().unwrap(); + let fut = b.1.call(res); + this.state.set(State::B { fut }); + self.poll(cx) } + StateProj::B { fut } => fut.poll(cx), } } } /// `.then()` service factory combinator -pub(crate) struct ThenServiceFactory(Rc<(A, B)>); +pub(crate) struct ThenServiceFactory(Rc<(A, B)>, PhantomData); -impl ThenServiceFactory +impl ThenServiceFactory where - A: ServiceFactory, + A: ServiceFactory, A::Config: Clone, B: ServiceFactory< + Result, Config = A::Config, - Request = Result, Error = A::Error, InitError = A::InitError, >, { /// Create new `AndThen` combinator pub(crate) fn new(a: A, b: B) -> Self { - Self(Rc::new((a, b))) + Self(Rc::new((a, b)), PhantomData) } } -impl ServiceFactory for ThenServiceFactory +impl ServiceFactory for ThenServiceFactory where - A: ServiceFactory, + A: ServiceFactory, A::Config: Clone, B: ServiceFactory< + Result, Config = A::Config, - Request = Result, Error = A::Error, InitError = A::InitError, >, { - type Request = A::Request; type Response = B::Response; type Error = A::Error; type Config = A::Config; - type Service = ThenService; + type Service = ThenService; type InitError = A::InitError; - type Future = ThenServiceFactoryResponse; + type Future = ThenServiceFactoryResponse; fn new_service(&self, cfg: A::Config) -> Self::Future { let srv = &*self.0; @@ -155,37 +154,38 @@ where } } -impl Clone for ThenServiceFactory { +impl Clone for ThenServiceFactory { fn clone(&self) -> Self { - Self(self.0.clone()) + Self(self.0.clone(), PhantomData) } } -#[pin_project::pin_project] -pub(crate) struct ThenServiceFactoryResponse -where - A: ServiceFactory, - B: ServiceFactory< - Config = A::Config, - Request = Result, - Error = A::Error, - InitError = A::InitError, - >, -{ - #[pin] - fut_b: B::Future, - #[pin] - fut_a: A::Future, - a: Option, - b: Option, +pin_project! { + pub(crate) struct ThenServiceFactoryResponse + where + A: ServiceFactory, + B: ServiceFactory< + Result, + Config = A::Config, + Error = A::Error, + InitError = A::InitError, + >, + { + #[pin] + fut_b: B::Future, + #[pin] + fut_a: A::Future, + a: Option, + b: Option, + } } -impl ThenServiceFactoryResponse +impl ThenServiceFactoryResponse where - A: ServiceFactory, + A: ServiceFactory, B: ServiceFactory< + Result, Config = A::Config, - Request = Result, Error = A::Error, InitError = A::InitError, >, @@ -200,17 +200,17 @@ where } } -impl Future for ThenServiceFactoryResponse +impl Future for ThenServiceFactoryResponse where - A: ServiceFactory, + A: ServiceFactory, B: ServiceFactory< + Result, Config = A::Config, - Request = Result, Error = A::Error, InitError = A::InitError, >, { - type Output = Result, A::InitError>; + type Output = Result, A::InitError>; fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { let this = self.project(); @@ -238,29 +238,30 @@ where #[cfg(test)] mod tests { - use std::cell::Cell; - use std::rc::Rc; - use std::task::{Context, Poll}; + use alloc::rc::Rc; + use core::{ + cell::Cell, + task::{Context, Poll}, + }; - use futures_util::future::{err, lazy, ok, ready, Ready}; + use futures_util::future::lazy; - use crate::{pipeline, pipeline_factory, Service, ServiceFactory}; + use crate::{err, ok, pipeline, pipeline_factory, ready, Ready, Service, ServiceFactory}; #[derive(Clone)] struct Srv1(Rc>); - impl Service for Srv1 { - type Request = Result<&'static str, &'static str>; + impl Service> for Srv1 { type Response = &'static str; type Error = (); type Future = Ready>; - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { + fn poll_ready(&self, _: &mut Context<'_>) -> Poll> { self.0.set(self.0.get() + 1); Poll::Ready(Ok(())) } - fn call(&mut self, req: Result<&'static str, &'static str>) -> Self::Future { + fn call(&self, req: Result<&'static str, &'static str>) -> Self::Future { match req { Ok(msg) => ok(msg), Err(_) => err(()), @@ -270,18 +271,17 @@ mod tests { struct Srv2(Rc>); - impl Service for Srv2 { - type Request = Result<&'static str, ()>; + impl Service> for Srv2 { type Response = (&'static str, &'static str); type Error = (); type Future = Ready>; - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { + fn poll_ready(&self, _: &mut Context<'_>) -> Poll> { self.0.set(self.0.get() + 1); Poll::Ready(Err(())) } - fn call(&mut self, req: Result<&'static str, ()>) -> Self::Future { + fn call(&self, req: Result<&'static str, ()>) -> Self::Future { match req { Ok(msg) => ok((msg, "ok")), Err(()) => ok(("srv2", "err")), @@ -292,7 +292,7 @@ mod tests { #[actix_rt::test] async fn test_poll_ready() { let cnt = Rc::new(Cell::new(0)); - let mut srv = pipeline(Srv1(cnt.clone())).then(Srv2(cnt.clone())); + let srv = pipeline(Srv1(cnt.clone())).then(Srv2(cnt.clone())); let res = lazy(|cx| srv.poll_ready(cx)).await; assert_eq!(res, Poll::Ready(Err(()))); assert_eq!(cnt.get(), 2); @@ -301,7 +301,7 @@ mod tests { #[actix_rt::test] async fn test_call() { let cnt = Rc::new(Cell::new(0)); - let mut srv = pipeline(Srv1(cnt.clone())).then(Srv2(cnt)); + let srv = pipeline(Srv1(cnt.clone())).then(Srv2(cnt)); let res = srv.call(Ok("srv1")).await; assert!(res.is_ok()); @@ -318,7 +318,7 @@ mod tests { let cnt2 = cnt.clone(); let blank = move || ready(Ok::<_, ()>(Srv1(cnt2.clone()))); let factory = pipeline_factory(blank).then(move || ready(Ok(Srv2(cnt.clone())))); - let mut srv = factory.new_service(&()).await.unwrap(); + let srv = factory.new_service(&()).await.unwrap(); let res = srv.call(Ok("srv1")).await; assert!(res.is_ok()); assert_eq!(res.unwrap(), ("srv1", "ok")); diff --git a/actix-service/src/transform.rs b/actix-service/src/transform.rs index 0ebfc5b7..7f477e54 100644 --- a/actix-service/src/transform.rs +++ b/actix-service/src/transform.rs @@ -1,18 +1,23 @@ -use std::future::Future; -use std::pin::Pin; -use std::rc::Rc; -use std::sync::Arc; -use std::task::{Context, Poll}; +use alloc::{rc::Rc, sync::Arc}; +use core::{ + future::Future, + marker::PhantomData, + pin::Pin, + task::{Context, Poll}, +}; + +use futures_core::ready; +use pin_project_lite::pin_project; use crate::transform_err::TransformMapInitErr; use crate::{IntoServiceFactory, Service, ServiceFactory}; /// Apply transform to a service. -pub fn apply(t: T, factory: U) -> ApplyTransform +pub fn apply(t: T, factory: I) -> ApplyTransform where - S: ServiceFactory, - T: Transform, - U: IntoServiceFactory, + I: IntoServiceFactory, + S: ServiceFactory, + T: Transform, { ApplyTransform::new(t, factory.into_factory()) } @@ -26,7 +31,7 @@ where /// /// For example, timeout transform: /// -/// ```rust,ignore +/// ```ignore /// pub struct Timeout { /// service: S, /// timeout: Duration, @@ -41,11 +46,9 @@ where /// type Error = TimeoutError; /// type Future = TimeoutServiceResponse; /// -/// fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll> { -/// ready!(self.service.poll_ready(cx)).map_err(TimeoutError::Service) -/// } +/// actix_service::forward_ready!(service); /// -/// fn call(&mut self, req: S::Request) -> Self::Future { +/// fn call(&self, req: S::Request) -> Self::Future { /// TimeoutServiceResponse { /// fut: self.service.call(req), /// sleep: Delay::new(clock::now() + self.timeout), @@ -65,7 +68,7 @@ where /// /// Factory for `Timeout` middleware from the above example could look like this: /// -/// ```rust,,ignore +/// ```ignore /// pub struct TimeoutTransform { /// timeout: Duration, /// } @@ -89,10 +92,7 @@ where /// } /// } /// ``` -pub trait Transform { - /// Requests handled by the service. - type Request; - +pub trait Transform { /// Responses given by the service. type Response; @@ -100,11 +100,7 @@ pub trait Transform { type Error; /// The `TransformService` value created by this factory - type Transform: Service< - Request = Self::Request, - Response = Self::Response, - Error = Self::Error, - >; + type Transform: Service; /// Errors produced while building a transform service. type InitError; @@ -117,7 +113,7 @@ pub trait Transform { /// Map this transform's factory error to a different error, /// returning a new transform service factory. - fn map_init_err(self, f: F) -> TransformMapInitErr + fn map_init_err(self, f: F) -> TransformMapInitErr where Self: Sized, F: Fn(Self::InitError) -> E + Clone, @@ -126,15 +122,14 @@ pub trait Transform { } } -impl Transform for Rc +impl Transform for Rc where - T: Transform, + T: Transform, { - type Request = T::Request; type Response = T::Response; type Error = T::Error; - type InitError = T::InitError; type Transform = T::Transform; + type InitError = T::InitError; type Future = T::Future; fn new_transform(&self, service: S) -> T::Future { @@ -142,15 +137,14 @@ where } } -impl Transform for Arc +impl Transform for Arc where - T: Transform, + T: Transform, { - type Request = T::Request; type Response = T::Response; type Error = T::Error; - type InitError = T::InitError; type Transform = T::Transform; + type InitError = T::InitError; type Future = T::Future; fn new_transform(&self, service: S) -> T::Future { @@ -159,72 +153,76 @@ where } /// `Apply` transform to new service -pub struct ApplyTransform(Rc<(T, S)>); +pub struct ApplyTransform(Rc<(T, S)>, PhantomData); -impl ApplyTransform +impl ApplyTransform where - S: ServiceFactory, - T: Transform, + S: ServiceFactory, + T: Transform, { /// Create new `ApplyTransform` new service instance fn new(t: T, service: S) -> Self { - Self(Rc::new((t, service))) + Self(Rc::new((t, service)), PhantomData) } } -impl Clone for ApplyTransform { +impl Clone for ApplyTransform { fn clone(&self) -> Self { - ApplyTransform(self.0.clone()) + ApplyTransform(self.0.clone(), PhantomData) } } -impl ServiceFactory for ApplyTransform +impl ServiceFactory for ApplyTransform where - S: ServiceFactory, - T: Transform, + S: ServiceFactory, + T: Transform, { - type Request = T::Request; type Response = T::Response; type Error = T::Error; type Config = S::Config; type Service = T::Transform; type InitError = T::InitError; - type Future = ApplyTransformFuture; + type Future = ApplyTransformFuture; fn new_service(&self, cfg: S::Config) -> Self::Future { ApplyTransformFuture { store: self.0.clone(), - state: ApplyTransformFutureState::A(self.0.as_ref().1.new_service(cfg)), + state: ApplyTransformFutureState::A { + fut: self.0.as_ref().1.new_service(cfg), + }, } } } -#[pin_project::pin_project] -pub struct ApplyTransformFuture -where - S: ServiceFactory, - T: Transform, -{ - store: Rc<(T, S)>, - #[pin] - state: ApplyTransformFutureState, +pin_project! { + pub struct ApplyTransformFuture + where + S: ServiceFactory, + T: Transform, + { + store: Rc<(T, S)>, + #[pin] + state: ApplyTransformFutureState, + } } -#[pin_project::pin_project(project = ApplyTransformFutureStateProj)] -pub enum ApplyTransformFutureState -where - S: ServiceFactory, - T: Transform, -{ - A(#[pin] S::Future), - B(#[pin] T::Future), +pin_project! { + #[project = ApplyTransformFutureStateProj] + pub enum ApplyTransformFutureState + where + S: ServiceFactory, + T: Transform, + { + A { #[pin] fut: S::Future }, + B { #[pin] fut: T::Future }, + } } -impl Future for ApplyTransformFuture +impl Future for ApplyTransformFuture where - S: ServiceFactory, - T: Transform, + S: ServiceFactory, + T: Transform, { type Output = Result; @@ -232,15 +230,13 @@ where let mut this = self.as_mut().project(); match this.state.as_mut().project() { - ApplyTransformFutureStateProj::A(fut) => match fut.poll(cx)? { - Poll::Ready(srv) => { - let fut = this.store.0.new_transform(srv); - this.state.set(ApplyTransformFutureState::B(fut)); - self.poll(cx) - } - Poll::Pending => Poll::Pending, - }, - ApplyTransformFutureStateProj::B(fut) => fut.poll(cx), + ApplyTransformFutureStateProj::A { fut } => { + let srv = ready!(fut.poll(cx))?; + let fut = this.store.0.new_transform(srv); + this.state.set(ApplyTransformFutureState::B { fut }); + self.poll(cx) + } + ApplyTransformFutureStateProj::B { fut } => fut.poll(cx), } } } diff --git a/actix-service/src/transform_err.rs b/actix-service/src/transform_err.rs index 9d306f0c..cbf5fe3b 100644 --- a/actix-service/src/transform_err.rs +++ b/actix-service/src/transform_err.rs @@ -1,7 +1,11 @@ -use std::future::Future; -use std::marker::PhantomData; -use std::pin::Pin; -use std::task::{Context, Poll}; +use core::{ + future::Future, + marker::PhantomData, + pin::Pin, + task::{Context, Poll}, +}; + +use pin_project_lite::pin_project; use super::Transform; @@ -9,75 +13,75 @@ use super::Transform; /// transform's init error. /// /// This is created by the `Transform::map_init_err` method. -pub struct TransformMapInitErr { - t: T, - f: F, - e: PhantomData<(S, E)>, +pub struct TransformMapInitErr { + transform: T, + mapper: F, + _phantom: PhantomData<(S, Req, E)>, } -impl TransformMapInitErr { +impl TransformMapInitErr { pub(crate) fn new(t: T, f: F) -> Self where - T: Transform, + T: Transform, F: Fn(T::InitError) -> E, { Self { - t, - f, - e: PhantomData, + transform: t, + mapper: f, + _phantom: PhantomData, } } } -impl Clone for TransformMapInitErr +impl Clone for TransformMapInitErr where T: Clone, F: Clone, { fn clone(&self) -> Self { Self { - t: self.t.clone(), - f: self.f.clone(), - e: PhantomData, + transform: self.transform.clone(), + mapper: self.mapper.clone(), + _phantom: PhantomData, } } } -impl Transform for TransformMapInitErr +impl Transform for TransformMapInitErr where - T: Transform, + T: Transform, F: Fn(T::InitError) -> E + Clone, { - type Request = T::Request; type Response = T::Response; type Error = T::Error; type Transform = T::Transform; type InitError = E; - type Future = TransformMapInitErrFuture; + type Future = TransformMapInitErrFuture; fn new_transform(&self, service: S) -> Self::Future { TransformMapInitErrFuture { - fut: self.t.new_transform(service), - f: self.f.clone(), + fut: self.transform.new_transform(service), + f: self.mapper.clone(), } } } -#[pin_project::pin_project] -pub struct TransformMapInitErrFuture -where - T: Transform, +pin_project! { + pub struct TransformMapInitErrFuture + where + T: Transform, F: Fn(T::InitError) -> E, -{ - #[pin] - fut: T::Future, - f: F, + { + #[pin] + fut: T::Future, + f: F, + } } -impl Future for TransformMapInitErrFuture +impl Future for TransformMapInitErrFuture where - T: Transform, + T: Transform, F: Fn(T::InitError) -> E + Clone, { type Output = Result; diff --git a/actix-testing/CHANGES.md b/actix-testing/CHANGES.md deleted file mode 100644 index 86a79ed7..00000000 --- a/actix-testing/CHANGES.md +++ /dev/null @@ -1,33 +0,0 @@ -# Changes - -## [1.0.1] - 2020-05-19 - -* Replace deprecated `net2` crate with `socket2` - -* Remove unused `futures` dependency - -## [1.0.0] - 2019-12-11 - -* Update actix-server to 1.0.0 - -## [1.0.0-alpha.3] - 2019-12-07 - -* Migrate to tokio 0.2 - -## [1.0.0-alpha.2] - 2019-12-02 - -* Re-export `test` attribute macros - - -## [0.3.0-alpha.1] - 2019-11-22 - -* Migrate to std::future - -## [0.2.0] - 2019-10-14 - -* Upgrade actix-server and actix-server-config deps - - -## [0.1.0] - 2019-09-25 - -* Initial impl diff --git a/actix-testing/Cargo.toml b/actix-testing/Cargo.toml deleted file mode 100644 index 430a12b6..00000000 --- a/actix-testing/Cargo.toml +++ /dev/null @@ -1,27 +0,0 @@ -[package] -name = "actix-testing" -version = "1.0.1" -authors = ["Nikolay Kim "] -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 OR Apache-2.0" -edition = "2018" -workspace = ".." -readme = "README.md" - -[lib] -name = "actix_testing" -path = "src/lib.rs" - -[dependencies] -actix-rt = "1.0.0" -actix-macros = "0.1.0" -actix-server = "1.0.0" -actix-service = "1.0.0" - -log = "0.4" -socket2 = "0.3" diff --git a/actix-testing/README.md b/actix-testing/README.md deleted file mode 100644 index bd4eec2f..00000000 --- a/actix-testing/README.md +++ /dev/null @@ -1,9 +0,0 @@ -# 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 diff --git a/actix-threadpool/CHANGES.md b/actix-threadpool/CHANGES.md deleted file mode 100644 index 9b481fbf..00000000 --- a/actix-threadpool/CHANGES.md +++ /dev/null @@ -1,49 +0,0 @@ -# Changes - -## [0.3.3] - 2020-07-14 - -### Changed - -* Update parking_lot to 0.11 - -## [0.3.2] - 2020-05-20 - -## Added - -* Implement `std::error::Error` for `BlockingError` [#120] - -[#120]: https://github.com/actix/actix-net/pull/120 - -## [0.3.1] - 2019-12-12 - -### Changed - -* Update parking_lot to 0.10 - -## [0.3.0] - 2019-12-02 - -### Changed - -* Expect `Result` type as a function return type - -## [0.2.0] - 2019-11-21 - -### Changed - -* Migrate to `std::future` - -## [0.1.2] - 2019-08-05 - -### Changed - -* Update `derive_more` to 0.15 - -* Update `parking_lot` to 0.9 - -## [0.1.1] - 2019-06-05 - -* Update parking_lot - -## [0.1.0] - 2019-03-28 - -* Move threadpool to separate crate diff --git a/actix-threadpool/Cargo.toml b/actix-threadpool/Cargo.toml deleted file mode 100644 index 5998bae7..00000000 --- a/actix-threadpool/Cargo.toml +++ /dev/null @@ -1,27 +0,0 @@ -[package] -name = "actix-threadpool" -version = "0.3.3" -authors = ["Nikolay Kim "] -description = "Actix thread pool for sync code" -keywords = ["actix", "network", "framework", "async", "futures"] -homepage = "https://actix.rs" -repository = "https://github.com/actix/actix-net.git" -documentation = "https://docs.rs/actix-threadpool/" -categories = ["network-programming", "asynchronous"] -license = "MIT OR Apache-2.0" -exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"] -edition = "2018" -workspace = ".." - -[lib] -name = "actix_threadpool" -path = "src/lib.rs" - -[dependencies] -derive_more = "0.99.2" -futures-channel = "0.3.1" -parking_lot = "0.11" -lazy_static = "1.3" -log = "0.4" -num_cpus = "1.10" -threadpool = "1.7" diff --git a/actix-threadpool/LICENSE-APACHE b/actix-threadpool/LICENSE-APACHE deleted file mode 120000 index 965b606f..00000000 --- a/actix-threadpool/LICENSE-APACHE +++ /dev/null @@ -1 +0,0 @@ -../LICENSE-APACHE \ No newline at end of file diff --git a/actix-threadpool/LICENSE-MIT b/actix-threadpool/LICENSE-MIT deleted file mode 120000 index 76219eb7..00000000 --- a/actix-threadpool/LICENSE-MIT +++ /dev/null @@ -1 +0,0 @@ -../LICENSE-MIT \ No newline at end of file diff --git a/actix-threadpool/src/lib.rs b/actix-threadpool/src/lib.rs deleted file mode 100644 index 2fda28ef..00000000 --- a/actix-threadpool/src/lib.rs +++ /dev/null @@ -1,96 +0,0 @@ -//! Thread pool for blocking operations - -#![deny(rust_2018_idioms, nonstandard_style)] -#![doc(html_logo_url = "https://actix.rs/img/logo.png")] -#![doc(html_favicon_url = "https://actix.rs/favicon.ico")] - -use std::fmt; -use std::future::Future; -use std::pin::Pin; -use std::task::{Context, Poll}; - -use derive_more::Display; -use futures_channel::oneshot; -use parking_lot::Mutex; -use threadpool::ThreadPool; - -/// Env variable for default cpu pool size. -const ENV_CPU_POOL_VAR: &str = "ACTIX_THREADPOOL"; - -lazy_static::lazy_static! { - pub(crate) static ref DEFAULT_POOL: Mutex = { - let num = std::env::var(ENV_CPU_POOL_VAR) - .map_err(|_| ()) - .and_then(|val| { - val.parse().map_err(|_| log::warn!( - "Can not parse {} value, using default", - ENV_CPU_POOL_VAR, - )) - }) - .unwrap_or_else(|_| num_cpus::get() * 5); - Mutex::new( - threadpool::Builder::new() - .thread_name("actix-web".to_owned()) - .num_threads(num) - .build(), - ) - }; -} - -thread_local! { - static POOL: ThreadPool = { - DEFAULT_POOL.lock().clone() - }; -} - -/// Blocking operation execution error -#[derive(Debug, Display)] -pub enum BlockingError { - #[display(fmt = "{:?}", _0)] - Error(E), - #[display(fmt = "Thread pool is gone")] - Canceled, -} - -impl std::error::Error for BlockingError {} - -/// Execute blocking function on a thread pool, returns future that resolves -/// to result of the function execution. -pub fn run(f: F) -> CpuFuture -where - F: FnOnce() -> Result + Send + 'static, - I: Send + 'static, - E: Send + fmt::Debug + 'static, -{ - let (tx, rx) = oneshot::channel(); - POOL.with(|pool| { - pool.execute(move || { - if !tx.is_canceled() { - let _ = tx.send(f()); - } - }) - }); - - CpuFuture { rx } -} - -/// Blocking operation completion future. It resolves with results -/// of blocking function execution. -pub struct CpuFuture { - rx: oneshot::Receiver>, -} - -impl Future for CpuFuture { - type Output = Result>; - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - let rx = Pin::new(&mut self.rx); - let res = match rx.poll(cx) { - Poll::Pending => return Poll::Pending, - Poll::Ready(res) => res - .map_err(|_| BlockingError::Canceled) - .and_then(|res| res.map_err(BlockingError::Error)), - }; - Poll::Ready(res) - } -} diff --git a/actix-tls/CHANGES.md b/actix-tls/CHANGES.md index 592b96b0..a87f0fc5 100644 --- a/actix-tls/CHANGES.md +++ b/actix-tls/CHANGES.md @@ -1,6 +1,36 @@ # Changes -## Unreleased - 2020-xx-xx +## Unreleased - 2021-xx-xx + + +## 3.0.0-beta.3 - 2021-02-06 +* Remove `trust-dns-proto` and `trust-dns-resolver`. [#248] +* Use `std::net::ToSocketAddrs` as simple and basic default resolver. [#248] +* Add `Resolve` trait for custom DNS resolvers. [#248] +* Add `Resolver::new_custom` function to construct custom resolvers. [#248] +* Export `webpki_roots::TLS_SERVER_ROOTS` in `actix_tls::connect` mod and remove + the export from `actix_tls::accept` [#248] +* Remove `ConnectTakeAddrsIter`. `Connect::take_addrs` now returns `ConnectAddrsIter<'static>` + as owned iterator. [#248] +* Rename `Address::{host => hostname}` to more accurately describe which URL segment is returned. +* Update `actix-rt` to `2.0.0`. [#273] + +[#248]: https://github.com/actix/actix-net/pull/248 +[#273]: https://github.com/actix/actix-net/pull/273 + + +## 3.0.0-beta.2 - 2021-xx-xx +* Depend on stable trust-dns packages. [#204] + +[#204]: https://github.com/actix/actix-net/pull/204 + + +## 3.0.0-beta.1 - 2020-12-29 +* Move acceptors under `accept` module. [#238] +* Merge `actix-connect` crate under `connect` module. [#238] +* Add feature flags to enable acceptors and/or connectors individually. [#238] + +[#238]: https://github.com/actix/actix-net/pull/238 ## 2.0.0 - 2020-09-03 diff --git a/actix-tls/Cargo.toml b/actix-tls/Cargo.toml old mode 100644 new mode 100755 index 801f6144..db79d6ab --- a/actix-tls/Cargo.toml +++ b/actix-tls/Cargo.toml @@ -1,64 +1,76 @@ [package] name = "actix-tls" -version = "2.0.0" +version = "3.0.0-beta.3" authors = ["Nikolay Kim "] -description = "TLS acceptor services for Actix ecosystem." -keywords = ["network", "framework", "async", "tls", "ssl"] +description = "TLS acceptor and connector services for Actix ecosystem" +keywords = ["network", "tls", "ssl", "async", "transport"] homepage = "https://actix.rs" repository = "https://github.com/actix/actix-net.git" -documentation = "https://docs.rs/actix-tls/" +documentation = "https://docs.rs/actix-tls" categories = ["network-programming", "asynchronous"] license = "MIT OR Apache-2.0" edition = "2018" [package.metadata.docs.rs] -features = ["openssl", "rustls", "nativetls"] +features = ["openssl", "rustls", "native-tls", "accept", "connect", "uri"] [lib] name = "actix_tls" path = "src/lib.rs" -[[example]] -name = "basic" -required-features = ["rustls"] - [features] -default = [] +default = ["accept", "connect", "uri"] -# openssl -openssl = ["open-ssl", "tokio-openssl"] +# enable acceptor services +accept = [] -# rustls -rustls = ["rust-tls", "webpki", "webpki-roots", "tokio-rustls"] +# enable connector services +connect = [] -# nativetls -nativetls = ["native-tls", "tokio-tls"] +# use openssl impls +openssl = ["tls-openssl", "tokio-openssl"] + +# use rustls impls +rustls = ["tokio-rustls", "webpki-roots"] + +# use native-tls impls +native-tls = ["tokio-native-tls"] + +# support http::Uri as connect address +uri = ["http"] [dependencies] -actix-service = "1.0.0" -actix-codec = "0.3.0" -actix-utils = "2.0.0" +actix-codec = "0.4.0-beta.1" +actix-rt = { version = "2.0.0", default-features = false } +actix-service = "2.0.0-beta.4" +actix-utils = "3.0.0-beta.2" -futures-util = { version = "0.3.4", default-features = false } +derive_more = "0.99.5" +futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] } +http = { version = "0.2.3", optional = true } +log = "0.4" +tokio-util = { version = "0.6.3", default-features = false } # openssl -open-ssl = { package = "openssl", version = "0.10", optional = true } -tokio-openssl = { version = "0.4.0", optional = true } +tls-openssl = { package = "openssl", version = "0.10", optional = true } +tokio-openssl = { version = "0.6", optional = true } # rustls -rust-tls = { package = "rustls", version = "0.18.0", optional = true } -webpki = { version = "0.21", optional = true } -webpki-roots = { version = "0.20", optional = true } -tokio-rustls = { version = "0.14.0", optional = true } +tokio-rustls = { version = "0.22", optional = true } +webpki-roots = { version = "0.21", optional = true } # native-tls -native-tls = { version = "0.2", optional = true } -tokio-tls = { version = "0.3", optional = true } +tokio-native-tls = { version = "0.3", optional = true } [dev-dependencies] -bytes = "0.5" +actix-rt = "2.0.0" +actix-server = "2.0.0-beta.3" +bytes = "1" +env_logger = "0.8" +futures-util = { version = "0.3.7", default-features = false, features = ["sink"] } log = "0.4" -env_logger = "0.7" -actix-testing = "1.0.0" -actix-server = "1" -actix-rt = "1" +trust-dns-resolver = "0.20.0" + +[[example]] +name = "basic" +required-features = ["accept", "rustls"] diff --git a/actix-tls/examples/basic.rs b/actix-tls/examples/basic.rs index cd706958..d1762b08 100644 --- a/actix-tls/examples/basic.rs +++ b/actix-tls/examples/basic.rs @@ -15,6 +15,10 @@ //! http --verify=false https://127.0.0.1:8443 //! ``` +// this use only exists because of how we have organised the crate +// it is not necessary for your actual code +use tokio_rustls::rustls; + use std::{ env, fs::File, @@ -27,10 +31,10 @@ use std::{ use actix_server::Server; use actix_service::pipeline_factory; -use actix_tls::rustls::Acceptor as RustlsAcceptor; +use actix_tls::accept::rustls::Acceptor as RustlsAcceptor; use futures_util::future::ok; use log::info; -use rust_tls::{ +use rustls::{ internal::pemfile::certs, internal::pemfile::rsa_private_keys, NoClientAuth, ServerConfig, }; diff --git a/actix-tls/src/accept/mod.rs b/actix-tls/src/accept/mod.rs new file mode 100644 index 00000000..8b1fe47c --- /dev/null +++ b/actix-tls/src/accept/mod.rs @@ -0,0 +1,42 @@ +//! TLS acceptor services for Actix ecosystem. +//! +//! ## Crate Features +//! * `openssl` - TLS acceptor using the `openssl` crate. +//! * `rustls` - TLS acceptor using the `rustls` crate. +//! * `native-tls` - TLS acceptor using the `native-tls` crate. + +use std::sync::atomic::{AtomicUsize, Ordering}; + +use actix_utils::counter::Counter; + +#[cfg(feature = "openssl")] +pub mod openssl; + +#[cfg(feature = "rustls")] +pub mod rustls; + +#[cfg(feature = "native-tls")] +pub mod nativetls; + +pub(crate) static MAX_CONN: AtomicUsize = AtomicUsize::new(256); + +thread_local! { + static MAX_CONN_COUNTER: Counter = Counter::new(MAX_CONN.load(Ordering::Relaxed)); +} + +/// Sets the maximum per-worker concurrent TLS connection limit. +/// +/// All listeners will stop accepting connections when this limit is reached. +/// It can be used to regulate the global TLS CPU usage. +/// +/// By default, the connection limit is 256. +pub fn max_concurrent_tls_connect(num: usize) { + MAX_CONN.store(num, Ordering::Relaxed); +} + +/// TLS error combined with service error. +#[derive(Debug)] +pub enum TlsError { + Tls(E1), + Service(E2), +} diff --git a/actix-tls/src/accept/nativetls.rs b/actix-tls/src/accept/nativetls.rs new file mode 100644 index 00000000..236ce973 --- /dev/null +++ b/actix-tls/src/accept/nativetls.rs @@ -0,0 +1,99 @@ +use std::task::{Context, Poll}; + +use actix_codec::{AsyncRead, AsyncWrite}; +use actix_service::{Service, ServiceFactory}; +use actix_utils::counter::Counter; +use futures_core::future::LocalBoxFuture; + +pub use tokio_native_tls::native_tls::Error; +pub use tokio_native_tls::{TlsAcceptor, TlsStream}; + +use super::MAX_CONN_COUNTER; + +/// Accept TLS connections via `native-tls` package. +/// +/// `native-tls` feature enables this `Acceptor` type. +pub struct Acceptor { + acceptor: TlsAcceptor, +} + +impl Acceptor { + /// Create `native-tls` based `Acceptor` service factory. + #[inline] + pub fn new(acceptor: TlsAcceptor) -> Self { + Acceptor { acceptor } + } +} + +impl Clone for Acceptor { + #[inline] + fn clone(&self) -> Self { + Self { + acceptor: self.acceptor.clone(), + } + } +} + +impl ServiceFactory for Acceptor +where + T: AsyncRead + AsyncWrite + Unpin + 'static, +{ + type Response = TlsStream; + type Error = Error; + type Config = (); + + type Service = NativeTlsAcceptorService; + type InitError = (); + type Future = LocalBoxFuture<'static, Result>; + + fn new_service(&self, _: ()) -> Self::Future { + let res = MAX_CONN_COUNTER.with(|conns| { + Ok(NativeTlsAcceptorService { + acceptor: self.acceptor.clone(), + conns: conns.clone(), + }) + }); + Box::pin(async { res }) + } +} + +pub struct NativeTlsAcceptorService { + acceptor: TlsAcceptor, + conns: Counter, +} + +impl Clone for NativeTlsAcceptorService { + fn clone(&self) -> Self { + Self { + acceptor: self.acceptor.clone(), + conns: self.conns.clone(), + } + } +} + +impl Service for NativeTlsAcceptorService +where + T: AsyncRead + AsyncWrite + Unpin + 'static, +{ + type Response = TlsStream; + type Error = Error; + type Future = LocalBoxFuture<'static, Result, Error>>; + + fn poll_ready(&self, cx: &mut Context<'_>) -> Poll> { + if self.conns.available(cx) { + Poll::Ready(Ok(())) + } else { + Poll::Pending + } + } + + fn call(&self, io: T) -> Self::Future { + let guard = self.conns.get(); + let this = self.clone(); + Box::pin(async move { + let io = this.acceptor.accept(io).await; + drop(guard); + io + }) + } +} diff --git a/actix-tls/src/accept/openssl.rs b/actix-tls/src/accept/openssl.rs new file mode 100644 index 00000000..8ca88578 --- /dev/null +++ b/actix-tls/src/accept/openssl.rs @@ -0,0 +1,111 @@ +use std::{ + future::Future, + pin::Pin, + task::{Context, Poll}, +}; + +use actix_codec::{AsyncRead, AsyncWrite}; +use actix_service::{Service, ServiceFactory}; +use actix_utils::counter::{Counter, CounterGuard}; +use futures_core::{future::LocalBoxFuture, ready}; + +pub use openssl::ssl::{ + AlpnError, Error as SslError, HandshakeError, Ssl, SslAcceptor, SslAcceptorBuilder, +}; +pub use tokio_openssl::SslStream; + +use super::MAX_CONN_COUNTER; + +/// Accept TLS connections via `openssl` package. +/// +/// `openssl` feature enables this `Acceptor` type. +pub struct Acceptor { + acceptor: SslAcceptor, +} + +impl Acceptor { + /// Create OpenSSL based `Acceptor` service factory. + #[inline] + pub fn new(acceptor: SslAcceptor) -> Self { + Acceptor { acceptor } + } +} + +impl Clone for Acceptor { + #[inline] + fn clone(&self) -> Self { + Self { + acceptor: self.acceptor.clone(), + } + } +} + +impl ServiceFactory for Acceptor +where + T: AsyncRead + AsyncWrite + Unpin + 'static, +{ + type Response = SslStream; + type Error = SslError; + type Config = (); + type Service = AcceptorService; + type InitError = (); + type Future = LocalBoxFuture<'static, Result>; + + fn new_service(&self, _: ()) -> Self::Future { + let res = MAX_CONN_COUNTER.with(|conns| { + Ok(AcceptorService { + acceptor: self.acceptor.clone(), + conns: conns.clone(), + }) + }); + Box::pin(async { res }) + } +} + +pub struct AcceptorService { + acceptor: SslAcceptor, + conns: Counter, +} + +impl Service for AcceptorService +where + T: AsyncRead + AsyncWrite + Unpin + 'static, +{ + type Response = SslStream; + type Error = SslError; + type Future = AcceptorServiceResponse; + + fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll> { + if self.conns.available(ctx) { + Poll::Ready(Ok(())) + } else { + Poll::Pending + } + } + + fn call(&self, io: T) -> Self::Future { + let ssl_ctx = self.acceptor.context(); + let ssl = Ssl::new(ssl_ctx).expect("Provided SSL acceptor was invalid."); + AcceptorServiceResponse { + _guard: self.conns.get(), + stream: Some(SslStream::new(ssl, io).unwrap()), + } + } +} + +pub struct AcceptorServiceResponse +where + T: AsyncRead + AsyncWrite, +{ + stream: Option>, + _guard: CounterGuard, +} + +impl Future for AcceptorServiceResponse { + type Output = Result, SslError>; + + fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + ready!(Pin::new(self.stream.as_mut().unwrap()).poll_accept(cx))?; + Poll::Ready(Ok(self.stream.take().expect("SSL connect has resolved."))) + } +} diff --git a/actix-tls/src/rustls.rs b/actix-tls/src/accept/rustls.rs similarity index 55% rename from actix-tls/src/rustls.rs rename to actix-tls/src/accept/rustls.rs index 3c3c60bf..ff5cf3e5 100644 --- a/actix-tls/src/rustls.rs +++ b/actix-tls/src/accept/rustls.rs @@ -1,86 +1,86 @@ -use std::future::Future; -use std::io; -use std::marker::PhantomData; -use std::pin::Pin; -use std::sync::Arc; -use std::task::{Context, Poll}; +use std::{ + future::Future, + io, + pin::Pin, + sync::Arc, + task::{Context, Poll}, +}; use actix_codec::{AsyncRead, AsyncWrite}; use actix_service::{Service, ServiceFactory}; use actix_utils::counter::{Counter, CounterGuard}; -use futures_util::future::{ok, Ready}; +use futures_core::future::LocalBoxFuture; use tokio_rustls::{Accept, TlsAcceptor}; -pub use rust_tls::{ServerConfig, Session}; +pub use tokio_rustls::rustls::{ServerConfig, Session}; pub use tokio_rustls::server::TlsStream; -pub use webpki_roots::TLS_SERVER_ROOTS; -use crate::MAX_CONN_COUNTER; +use super::MAX_CONN_COUNTER; /// Accept TLS connections via `rustls` package. /// /// `rustls` feature enables this `Acceptor` type. -pub struct Acceptor { +pub struct Acceptor { config: Arc, - io: PhantomData, } -impl Acceptor { +impl Acceptor { /// Create Rustls based `Acceptor` service factory. #[inline] pub fn new(config: ServerConfig) -> Self { Acceptor { config: Arc::new(config), - io: PhantomData, } } } -impl Clone for Acceptor { +impl Clone for Acceptor { #[inline] fn clone(&self) -> Self { Self { config: self.config.clone(), - io: PhantomData, } } } -impl ServiceFactory for Acceptor { - type Request = T; +impl ServiceFactory for Acceptor +where + T: AsyncRead + AsyncWrite + Unpin, +{ type Response = TlsStream; type Error = io::Error; - type Service = AcceptorService; - type Config = (); + + type Service = AcceptorService; type InitError = (); - type Future = Ready>; + type Future = LocalBoxFuture<'static, Result>; fn new_service(&self, _: ()) -> Self::Future { - MAX_CONN_COUNTER.with(|conns| { - ok(AcceptorService { + let res = MAX_CONN_COUNTER.with(|conns| { + Ok(AcceptorService { acceptor: self.config.clone().into(), conns: conns.clone(), - io: PhantomData, }) - }) + }); + Box::pin(async { res }) } } /// Rustls based `Acceptor` service -pub struct AcceptorService { +pub struct AcceptorService { acceptor: TlsAcceptor, - io: PhantomData, conns: Counter, } -impl Service for AcceptorService { - type Request = T; +impl Service for AcceptorService +where + T: AsyncRead + AsyncWrite + Unpin, +{ type Response = TlsStream; type Error = io::Error; type Future = AcceptorServiceFut; - fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll> { + fn poll_ready(&self, cx: &mut Context<'_>) -> Poll> { if self.conns.available(cx) { Poll::Ready(Ok(())) } else { @@ -88,7 +88,7 @@ impl Service for AcceptorService { } } - fn call(&mut self, req: Self::Request) -> Self::Future { + fn call(&self, req: T) -> Self::Future { AcceptorServiceFut { _guard: self.conns.get(), fut: self.acceptor.accept(req), @@ -104,16 +104,14 @@ where _guard: CounterGuard, } -impl Future for AcceptorServiceFut { +impl Future for AcceptorServiceFut +where + T: AsyncRead + AsyncWrite + Unpin, +{ type Output = Result, io::Error>; fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { let this = self.get_mut(); - - let res = futures_util::ready!(Pin::new(&mut this.fut).poll(cx)); - match res { - Ok(io) => Poll::Ready(Ok(io)), - Err(e) => Poll::Ready(Err(e)), - } + Pin::new(&mut this.fut).poll(cx) } } diff --git a/actix-tls/src/connect/connect.rs b/actix-tls/src/connect/connect.rs new file mode 100755 index 00000000..9e5d417f --- /dev/null +++ b/actix-tls/src/connect/connect.rs @@ -0,0 +1,332 @@ +use std::{ + collections::{vec_deque, VecDeque}, + fmt, + iter::{self, FromIterator as _}, + mem, + net::SocketAddr, +}; + +/// Parse a host into parts (hostname and port). +pub trait Address: Unpin + 'static { + /// Get hostname part. + fn hostname(&self) -> &str; + + /// Get optional port part. + fn port(&self) -> Option { + None + } +} + +impl Address for String { + fn hostname(&self) -> &str { + &self + } +} + +impl Address for &'static str { + fn hostname(&self) -> &str { + self + } +} + +#[derive(Debug, Eq, PartialEq, Hash)] +pub(crate) enum ConnectAddrs { + None, + One(SocketAddr), + Multi(VecDeque), +} + +impl ConnectAddrs { + pub(crate) fn is_none(&self) -> bool { + matches!(self, Self::None) + } + + pub(crate) fn is_some(&self) -> bool { + !self.is_none() + } +} + +impl Default for ConnectAddrs { + fn default() -> Self { + Self::None + } +} + +impl From> for ConnectAddrs { + fn from(addr: Option) -> Self { + match addr { + Some(addr) => ConnectAddrs::One(addr), + None => ConnectAddrs::None, + } + } +} + +/// Connection info. +#[derive(Debug, PartialEq, Eq, Hash)] +pub struct Connect { + pub(crate) req: T, + pub(crate) port: u16, + pub(crate) addr: ConnectAddrs, +} + +impl Connect { + /// Create `Connect` instance by splitting the string by ':' and convert the second part to u16 + pub fn new(req: T) -> Connect { + let (_, port) = parse_host(req.hostname()); + + Connect { + req, + port: port.unwrap_or(0), + addr: ConnectAddrs::None, + } + } + + /// Create new `Connect` instance from host and address. Connector skips name resolution stage + /// for such connect messages. + pub fn with_addr(req: T, addr: SocketAddr) -> Connect { + Connect { + req, + port: 0, + addr: ConnectAddrs::One(addr), + } + } + + /// Use port if address does not provide one. + /// + /// Default value is 0. + pub fn set_port(mut self, port: u16) -> Self { + self.port = port; + self + } + + /// Set address. + pub fn set_addr(mut self, addr: Option) -> Self { + self.addr = ConnectAddrs::from(addr); + self + } + + /// Set list of addresses. + pub fn set_addrs(mut self, addrs: I) -> Self + where + I: IntoIterator, + { + let mut addrs = VecDeque::from_iter(addrs); + self.addr = if addrs.len() < 2 { + ConnectAddrs::from(addrs.pop_front()) + } else { + ConnectAddrs::Multi(addrs) + }; + self + } + + /// Get hostname. + pub fn hostname(&self) -> &str { + self.req.hostname() + } + + /// Get request port. + pub fn port(&self) -> u16 { + self.req.port().unwrap_or(self.port) + } + + /// Get resolved request addresses. + pub fn addrs(&self) -> ConnectAddrsIter<'_> { + match self.addr { + ConnectAddrs::None => ConnectAddrsIter::None, + ConnectAddrs::One(addr) => ConnectAddrsIter::One(addr), + ConnectAddrs::Multi(ref addrs) => ConnectAddrsIter::Multi(addrs.iter()), + } + } + + /// Take resolved request addresses. + pub fn take_addrs(&mut self) -> ConnectAddrsIter<'static> { + match mem::take(&mut self.addr) { + ConnectAddrs::None => ConnectAddrsIter::None, + ConnectAddrs::One(addr) => ConnectAddrsIter::One(addr), + ConnectAddrs::Multi(addrs) => ConnectAddrsIter::MultiOwned(addrs.into_iter()), + } + } +} + +impl From for Connect { + fn from(addr: T) -> Self { + Connect::new(addr) + } +} + +impl fmt::Display for Connect { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}:{}", self.hostname(), self.port()) + } +} + +/// Iterator over addresses in a [`Connect`] request. +#[derive(Clone)] +pub enum ConnectAddrsIter<'a> { + None, + One(SocketAddr), + Multi(vec_deque::Iter<'a, SocketAddr>), + MultiOwned(vec_deque::IntoIter), +} + +impl Iterator for ConnectAddrsIter<'_> { + type Item = SocketAddr; + + fn next(&mut self) -> Option { + match *self { + Self::None => None, + Self::One(addr) => { + *self = Self::None; + Some(addr) + } + Self::Multi(ref mut iter) => iter.next().copied(), + Self::MultiOwned(ref mut iter) => iter.next(), + } + } + + fn size_hint(&self) -> (usize, Option) { + match *self { + Self::None => (0, Some(0)), + Self::One(_) => (1, Some(1)), + Self::Multi(ref iter) => iter.size_hint(), + Self::MultiOwned(ref iter) => iter.size_hint(), + } + } +} + +impl fmt::Debug for ConnectAddrsIter<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_list().entries(self.clone()).finish() + } +} + +impl iter::ExactSizeIterator for ConnectAddrsIter<'_> {} + +impl iter::FusedIterator for ConnectAddrsIter<'_> {} + +pub struct Connection { + io: U, + req: T, +} + +impl Connection { + pub fn new(io: U, req: T) -> Self { + Self { io, req } + } +} + +impl Connection { + /// Reconstruct from a parts. + pub fn from_parts(io: U, req: T) -> Self { + Self { io, req } + } + + /// Deconstruct into a parts. + pub fn into_parts(self) -> (U, T) { + (self.io, self.req) + } + + /// Replace inclosed object, return new Stream and old object + pub fn replace_io(self, io: Y) -> (U, Connection) { + (self.io, Connection { io, req: self.req }) + } + + /// Returns a shared reference to the underlying stream. + pub fn io_ref(&self) -> &U { + &self.io + } + + /// Returns a mutable reference to the underlying stream. + pub fn io_mut(&mut self) -> &mut U { + &mut self.io + } +} + +impl Connection { + /// Get hostname. + pub fn host(&self) -> &str { + self.req.hostname() + } +} + +impl std::ops::Deref for Connection { + type Target = U; + + fn deref(&self) -> &U { + &self.io + } +} + +impl std::ops::DerefMut for Connection { + fn deref_mut(&mut self) -> &mut U { + &mut self.io + } +} + +impl fmt::Debug for Connection { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "Stream {{{:?}}}", self.io) + } +} + +fn parse_host(host: &str) -> (&str, Option) { + let mut parts_iter = host.splitn(2, ':'); + + match parts_iter.next() { + Some(hostname) => { + let port_str = parts_iter.next().unwrap_or(""); + let port = port_str.parse::().ok(); + (hostname, port) + } + + None => (host, None), + } +} + +#[cfg(test)] +mod tests { + use std::net::{IpAddr, Ipv4Addr}; + + use super::*; + + #[test] + fn test_host_parser() { + assert_eq!(parse_host("example.com"), ("example.com", None)); + assert_eq!(parse_host("example.com:8080"), ("example.com", Some(8080))); + assert_eq!(parse_host("example:8080"), ("example", Some(8080))); + assert_eq!(parse_host("example.com:false"), ("example.com", None)); + assert_eq!(parse_host("example.com:false:false"), ("example.com", None)); + } + + #[test] + fn test_addr_iter_multi() { + let localhost = SocketAddr::from((IpAddr::from(Ipv4Addr::LOCALHOST), 8080)); + let unspecified = SocketAddr::from((IpAddr::from(Ipv4Addr::UNSPECIFIED), 8080)); + + let mut addrs = VecDeque::new(); + addrs.push_back(localhost); + addrs.push_back(unspecified); + + let mut iter = ConnectAddrsIter::Multi(addrs.iter()); + assert_eq!(iter.next(), Some(localhost)); + assert_eq!(iter.next(), Some(unspecified)); + assert_eq!(iter.next(), None); + + let mut iter = ConnectAddrsIter::MultiOwned(addrs.into_iter()); + assert_eq!(iter.next(), Some(localhost)); + assert_eq!(iter.next(), Some(unspecified)); + assert_eq!(iter.next(), None); + } + + #[test] + fn test_addr_iter_single() { + let localhost = SocketAddr::from((IpAddr::from(Ipv4Addr::LOCALHOST), 8080)); + + let mut iter = ConnectAddrsIter::One(localhost); + assert_eq!(iter.next(), Some(localhost)); + assert_eq!(iter.next(), None); + + let mut iter = ConnectAddrsIter::None; + assert_eq!(iter.next(), None); + } +} diff --git a/actix-tls/src/connect/connector.rs b/actix-tls/src/connect/connector.rs new file mode 100755 index 00000000..9acb1dd5 --- /dev/null +++ b/actix-tls/src/connect/connector.rs @@ -0,0 +1,158 @@ +use std::{ + collections::VecDeque, + future::Future, + io, + net::SocketAddr, + pin::Pin, + task::{Context, Poll}, +}; + +use actix_rt::net::TcpStream; +use actix_service::{Service, ServiceFactory}; +use futures_core::{future::LocalBoxFuture, ready}; +use log::{error, trace}; +use tokio_util::sync::ReusableBoxFuture; + +use super::connect::{Address, Connect, ConnectAddrs, Connection}; +use super::error::ConnectError; + +/// TCP connector service factory +#[derive(Debug, Copy, Clone)] +pub struct TcpConnectorFactory; + +impl TcpConnectorFactory { + /// Create TCP connector service + pub fn service(&self) -> TcpConnector { + TcpConnector + } +} + +impl ServiceFactory> for TcpConnectorFactory { + type Response = Connection; + type Error = ConnectError; + type Config = (); + type Service = TcpConnector; + type InitError = (); + type Future = LocalBoxFuture<'static, Result>; + + fn new_service(&self, _: ()) -> Self::Future { + let service = self.service(); + Box::pin(async move { Ok(service) }) + } +} + +/// TCP connector service +#[derive(Debug, Copy, Clone)] +pub struct TcpConnector; + +impl Service> for TcpConnector { + type Response = Connection; + type Error = ConnectError; + type Future = TcpConnectorResponse; + + actix_service::always_ready!(); + + fn call(&self, req: Connect) -> Self::Future { + let port = req.port(); + let Connect { req, addr, .. } = req; + + TcpConnectorResponse::new(req, port, addr) + } +} + +/// TCP stream connector response future +pub enum TcpConnectorResponse { + Response { + req: Option, + port: u16, + addrs: Option>, + stream: Option>>, + }, + Error(Option), +} + +impl TcpConnectorResponse { + pub(crate) fn new(req: T, port: u16, addr: ConnectAddrs) -> TcpConnectorResponse { + if addr.is_none() { + error!("TCP connector: unresolved connection address"); + return TcpConnectorResponse::Error(Some(ConnectError::Unresolved)); + } + + trace!( + "TCP connector: connecting to {} on port {}", + req.hostname(), + port + ); + + match addr { + ConnectAddrs::None => unreachable!("none variant already checked"), + + ConnectAddrs::One(addr) => TcpConnectorResponse::Response { + req: Some(req), + port, + addrs: None, + stream: Some(ReusableBoxFuture::new(TcpStream::connect(addr))), + }, + + // when resolver returns multiple socket addr for request they would be popped from + // front end of queue and returns with the first successful tcp connection. + ConnectAddrs::Multi(addrs) => TcpConnectorResponse::Response { + req: Some(req), + port, + addrs: Some(addrs), + stream: None, + }, + } + } +} + +impl Future for TcpConnectorResponse { + type Output = Result, ConnectError>; + + fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + match self.get_mut() { + TcpConnectorResponse::Error(err) => Poll::Ready(Err(err.take().unwrap())), + + TcpConnectorResponse::Response { + req, + port, + addrs, + stream, + } => loop { + if let Some(new) = stream.as_mut() { + match ready!(new.poll(cx)) { + Ok(sock) => { + let req = req.take().unwrap(); + trace!( + "TCP connector: successfully connected to {:?} - {:?}", + req.hostname(), + sock.peer_addr() + ); + return Poll::Ready(Ok(Connection::new(sock, req))); + } + + Err(err) => { + trace!( + "TCP connector: failed to connect to {:?} port: {}", + req.as_ref().unwrap().hostname(), + port, + ); + + if addrs.is_none() || addrs.as_ref().unwrap().is_empty() { + return Poll::Ready(Err(ConnectError::Io(err))); + } + } + } + } + + // try to connect + let addr = addrs.as_mut().unwrap().pop_front().unwrap(); + + match stream { + Some(rbf) => rbf.set(TcpStream::connect(addr)), + None => *stream = Some(ReusableBoxFuture::new(TcpStream::connect(addr))), + } + }, + } + } +} diff --git a/actix-connect/src/error.rs b/actix-tls/src/connect/error.rs similarity index 77% rename from actix-connect/src/error.rs rename to actix-tls/src/connect/error.rs index 84b363dc..5d8cb9db 100644 --- a/actix-connect/src/error.rs +++ b/actix-tls/src/connect/error.rs @@ -1,13 +1,12 @@ use std::io; -use derive_more::{Display, From}; -use trust_dns_resolver::error::ResolveError; +use derive_more::Display; -#[derive(Debug, From, Display)] +#[derive(Debug, Display)] pub enum ConnectError { /// Failed to resolve the hostname #[display(fmt = "Failed resolving hostname: {}", _0)] - Resolver(ResolveError), + Resolver(Box), /// No dns records #[display(fmt = "No dns records found for the input")] diff --git a/actix-tls/src/connect/mod.rs b/actix-tls/src/connect/mod.rs new file mode 100644 index 00000000..4010e3cb --- /dev/null +++ b/actix-tls/src/connect/mod.rs @@ -0,0 +1,74 @@ +//! TCP connector services for Actix ecosystem. +//! +//! # Stages of the TCP connector service: +//! - Resolve [`Address`] with given [`Resolver`] and collect list of socket addresses. +//! - Establish TCP connection and return [`TcpStream`]. +//! +//! # Stages of TLS connector services: +//! - Establish [`TcpStream`] with connector service. +//! - Wrap the stream and perform connect handshake with remote peer. +//! - Return certain stream type that impls `AsyncRead` and `AsyncWrite`. +//! +//! # Package feature +//! * `openssl` - enables TLS support via `openssl` crate +//! * `rustls` - enables TLS support via `rustls` crate +//! +//! [`TcpStream`]: actix_rt::net::TcpStream + +#[allow(clippy::module_inception)] +mod connect; +mod connector; +mod error; +mod resolve; +mod service; +pub mod ssl; +#[cfg(feature = "uri")] +mod uri; + +use actix_rt::net::TcpStream; +use actix_service::{pipeline, pipeline_factory, Service, ServiceFactory}; + +pub use self::connect::{Address, Connect, Connection}; +pub use self::connector::{TcpConnector, TcpConnectorFactory}; +pub use self::error::ConnectError; +pub use self::resolve::{Resolve, Resolver, ResolverFactory}; +pub use self::service::{ConnectService, ConnectServiceFactory, TcpConnectService}; + +/// Create TCP connector service. +pub fn new_connector( + resolver: Resolver, +) -> impl Service, Response = Connection, Error = ConnectError> + Clone +{ + pipeline(resolver).and_then(TcpConnector) +} + +/// Create TCP connector service factory. +pub fn new_connector_factory( + resolver: Resolver, +) -> impl ServiceFactory< + Connect, + Config = (), + Response = Connection, + Error = ConnectError, + InitError = (), +> + Clone { + pipeline_factory(ResolverFactory::new(resolver)).and_then(TcpConnectorFactory) +} + +/// Create connector service with default parameters. +pub fn default_connector( +) -> impl Service, Response = Connection, Error = ConnectError> + Clone +{ + new_connector(Resolver::Default) +} + +/// Create connector service factory with default parameters. +pub fn default_connector_factory() -> impl ServiceFactory< + Connect, + Config = (), + Response = Connection, + Error = ConnectError, + InitError = (), +> + Clone { + new_connector_factory(Resolver::Default) +} diff --git a/actix-tls/src/connect/resolve.rs b/actix-tls/src/connect/resolve.rs new file mode 100755 index 00000000..32e442bf --- /dev/null +++ b/actix-tls/src/connect/resolve.rs @@ -0,0 +1,243 @@ +use std::{ + future::Future, + io, + net::SocketAddr, + pin::Pin, + rc::Rc, + task::{Context, Poll}, + vec::IntoIter, +}; + +use actix_rt::task::{spawn_blocking, JoinHandle}; +use actix_service::{Service, ServiceFactory}; +use futures_core::{future::LocalBoxFuture, ready}; +use log::trace; + +use super::connect::{Address, Connect}; +use super::error::ConnectError; + +/// DNS Resolver Service Factory +#[derive(Clone)] +pub struct ResolverFactory { + resolver: Resolver, +} + +impl ResolverFactory { + pub fn new(resolver: Resolver) -> Self { + Self { resolver } + } + + pub fn service(&self) -> Resolver { + self.resolver.clone() + } +} + +impl ServiceFactory> for ResolverFactory { + type Response = Connect; + type Error = ConnectError; + type Config = (); + type Service = Resolver; + type InitError = (); + type Future = LocalBoxFuture<'static, Result>; + + fn new_service(&self, _: ()) -> Self::Future { + let service = self.resolver.clone(); + Box::pin(async { Ok(service) }) + } +} + +/// DNS Resolver Service +#[derive(Clone)] +pub enum Resolver { + Default, + Custom(Rc), +} + +/// An interface for custom async DNS resolvers. +/// +/// # Usage +/// ```rust +/// use std::net::SocketAddr; +/// +/// use actix_tls::connect::{Resolve, Resolver}; +/// use futures_util::future::LocalBoxFuture; +/// +/// // use trust-dns async tokio resolver +/// use trust_dns_resolver::TokioAsyncResolver; +/// +/// struct MyResolver { +/// trust_dns: TokioAsyncResolver, +/// }; +/// +/// // impl Resolve trait and convert given host address str and port to SocketAddr. +/// impl Resolve for MyResolver { +/// fn lookup<'a>( +/// &'a self, +/// host: &'a str, +/// port: u16, +/// ) -> LocalBoxFuture<'a, Result, Box>> { +/// Box::pin(async move { +/// let res = self +/// .trust_dns +/// .lookup_ip(host) +/// .await? +/// .iter() +/// .map(|ip| SocketAddr::new(ip, port)) +/// .collect(); +/// Ok(res) +/// }) +/// } +/// } +/// +/// let resolver = MyResolver { +/// trust_dns: TokioAsyncResolver::tokio_from_system_conf().unwrap(), +/// }; +/// +/// // construct custom resolver +/// let resolver = Resolver::new_custom(resolver); +/// +/// // pass custom resolver to connector builder. +/// // connector would then be usable as a service or awc's connector. +/// let connector = actix_tls::connect::new_connector::<&str>(resolver.clone()); +/// +/// // resolver can be passed to connector factory where returned service factory +/// // can be used to construct new connector services. +/// let factory = actix_tls::connect::new_connector_factory::<&str>(resolver); +/// ``` +pub trait Resolve { + fn lookup<'a>( + &'a self, + host: &'a str, + port: u16, + ) -> LocalBoxFuture<'a, Result, Box>>; +} + +impl Resolver { + /// Constructor for custom Resolve trait object and use it as resolver. + pub fn new_custom(resolver: impl Resolve + 'static) -> Self { + Self::Custom(Rc::new(resolver)) + } + + // look up with default resolver variant. + fn look_up(req: &Connect) -> JoinHandle>> { + let host = req.hostname(); + // TODO: Connect should always return host with port if possible. + let host = if req + .hostname() + .splitn(2, ':') + .last() + .and_then(|p| p.parse::().ok()) + .map(|p| p == req.port()) + .unwrap_or(false) + { + host.to_string() + } else { + format!("{}:{}", host, req.port()) + }; + + // run blocking DNS lookup in thread pool + spawn_blocking(move || std::net::ToSocketAddrs::to_socket_addrs(&host)) + } +} + +impl Service> for Resolver { + type Response = Connect; + type Error = ConnectError; + type Future = ResolverFuture; + + actix_service::always_ready!(); + + fn call(&self, req: Connect) -> Self::Future { + if req.addr.is_some() { + ResolverFuture::Connected(Some(req)) + } else if let Ok(ip) = req.hostname().parse() { + let addr = SocketAddr::new(ip, req.port()); + let req = req.set_addr(Some(addr)); + ResolverFuture::Connected(Some(req)) + } else { + trace!("DNS resolver: resolving host {:?}", req.hostname()); + + match self { + Self::Default => { + let fut = Self::look_up(&req); + ResolverFuture::LookUp(fut, Some(req)) + } + + Self::Custom(resolver) => { + let resolver = Rc::clone(&resolver); + ResolverFuture::LookupCustom(Box::pin(async move { + let addrs = resolver + .lookup(req.hostname(), req.port()) + .await + .map_err(ConnectError::Resolver)?; + + let req = req.set_addrs(addrs); + + if req.addr.is_none() { + Err(ConnectError::NoRecords) + } else { + Ok(req) + } + })) + } + } + } + } +} + +pub enum ResolverFuture { + Connected(Option>), + LookUp( + JoinHandle>>, + Option>, + ), + LookupCustom(LocalBoxFuture<'static, Result, ConnectError>>), +} + +impl Future for ResolverFuture { + type Output = Result, ConnectError>; + + fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + match self.get_mut() { + Self::Connected(conn) => Poll::Ready(Ok(conn + .take() + .expect("ResolverFuture polled after finished"))), + + Self::LookUp(fut, req) => { + let res = match ready!(Pin::new(fut).poll(cx)) { + Ok(Ok(res)) => Ok(res), + Ok(Err(e)) => Err(ConnectError::Resolver(Box::new(e))), + Err(e) => Err(ConnectError::Io(e.into())), + }; + + let req = req.take().unwrap(); + + let addrs = res.map_err(|err| { + trace!( + "DNS resolver: failed to resolve host {:?} err: {:?}", + req.hostname(), + err + ); + + err + })?; + + let req = req.set_addrs(addrs); + + trace!( + "DNS resolver: host {:?} resolved to {:?}", + req.hostname(), + req.addrs() + ); + + if req.addr.is_none() { + Poll::Ready(Err(ConnectError::NoRecords)) + } else { + Poll::Ready(Ok(req)) + } + } + + Self::LookupCustom(fut) => fut.as_mut().poll(cx), + } + } +} diff --git a/actix-tls/src/connect/service.rs b/actix-tls/src/connect/service.rs new file mode 100755 index 00000000..98765ca1 --- /dev/null +++ b/actix-tls/src/connect/service.rs @@ -0,0 +1,178 @@ +use std::{ + future::Future, + pin::Pin, + task::{Context, Poll}, +}; + +use actix_rt::net::TcpStream; +use actix_service::{Service, ServiceFactory}; +use futures_core::{future::LocalBoxFuture, ready}; + +use super::connect::{Address, Connect, Connection}; +use super::connector::{TcpConnector, TcpConnectorFactory}; +use super::error::ConnectError; +use super::resolve::{Resolver, ResolverFactory}; + +pub struct ConnectServiceFactory { + tcp: TcpConnectorFactory, + resolver: ResolverFactory, +} + +impl ConnectServiceFactory { + /// Construct new ConnectService factory + pub fn new(resolver: Resolver) -> Self { + ConnectServiceFactory { + tcp: TcpConnectorFactory, + resolver: ResolverFactory::new(resolver), + } + } + + /// Construct new service + pub fn service(&self) -> ConnectService { + ConnectService { + tcp: self.tcp.service(), + resolver: self.resolver.service(), + } + } + + /// Construct new tcp stream service + pub fn tcp_service(&self) -> TcpConnectService { + TcpConnectService { + tcp: self.tcp.service(), + resolver: self.resolver.service(), + } + } +} + +impl Clone for ConnectServiceFactory { + fn clone(&self) -> Self { + ConnectServiceFactory { + tcp: self.tcp, + resolver: self.resolver.clone(), + } + } +} + +impl ServiceFactory> for ConnectServiceFactory { + type Response = Connection; + type Error = ConnectError; + type Config = (); + type Service = ConnectService; + type InitError = (); + type Future = LocalBoxFuture<'static, Result>; + + fn new_service(&self, _: ()) -> Self::Future { + let service = self.service(); + Box::pin(async move { Ok(service) }) + } +} + +#[derive(Clone)] +pub struct ConnectService { + tcp: TcpConnector, + resolver: Resolver, +} + +impl Service> for ConnectService { + type Response = Connection; + type Error = ConnectError; + type Future = ConnectServiceResponse; + + actix_service::always_ready!(); + + fn call(&self, req: Connect) -> Self::Future { + ConnectServiceResponse { + fut: ConnectFuture::Resolve(self.resolver.call(req)), + tcp: self.tcp, + } + } +} + +// helper enum to generic over futures of resolve and connect phase. +pub(crate) enum ConnectFuture { + Resolve(>>::Future), + Connect(>>::Future), +} + +// helper enum to contain the future output of ConnectFuture +pub(crate) enum ConnectOutput { + Resolved(Connect), + Connected(Connection), +} + +impl ConnectFuture { + fn poll_connect( + &mut self, + cx: &mut Context<'_>, + ) -> Poll, ConnectError>> { + match self { + ConnectFuture::Resolve(ref mut fut) => { + Pin::new(fut).poll(cx).map_ok(ConnectOutput::Resolved) + } + ConnectFuture::Connect(ref mut fut) => { + Pin::new(fut).poll(cx).map_ok(ConnectOutput::Connected) + } + } + } +} + +pub struct ConnectServiceResponse { + fut: ConnectFuture, + tcp: TcpConnector, +} + +impl Future for ConnectServiceResponse { + type Output = Result, ConnectError>; + + fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + loop { + match ready!(self.fut.poll_connect(cx))? { + ConnectOutput::Resolved(res) => { + self.fut = ConnectFuture::Connect(self.tcp.call(res)); + } + ConnectOutput::Connected(res) => return Poll::Ready(Ok(res)), + } + } + } +} + +#[derive(Clone)] +pub struct TcpConnectService { + tcp: TcpConnector, + resolver: Resolver, +} + +impl Service> for TcpConnectService { + type Response = TcpStream; + type Error = ConnectError; + type Future = TcpConnectServiceResponse; + + actix_service::always_ready!(); + + fn call(&self, req: Connect) -> Self::Future { + TcpConnectServiceResponse { + fut: ConnectFuture::Resolve(self.resolver.call(req)), + tcp: self.tcp, + } + } +} + +pub struct TcpConnectServiceResponse { + fut: ConnectFuture, + tcp: TcpConnector, +} + +impl Future for TcpConnectServiceResponse { + type Output = Result; + + fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + loop { + match ready!(self.fut.poll_connect(cx))? { + ConnectOutput::Resolved(res) => { + self.fut = ConnectFuture::Connect(self.tcp.call(res)); + } + ConnectOutput::Connected(conn) => return Poll::Ready(Ok(conn.into_parts().0)), + } + } + } +} diff --git a/actix-connect/src/ssl/mod.rs b/actix-tls/src/connect/ssl/mod.rs similarity index 100% rename from actix-connect/src/ssl/mod.rs rename to actix-tls/src/connect/ssl/mod.rs diff --git a/actix-tls/src/connect/ssl/openssl.rs b/actix-tls/src/connect/ssl/openssl.rs new file mode 100755 index 00000000..b1c53f56 --- /dev/null +++ b/actix-tls/src/connect/ssl/openssl.rs @@ -0,0 +1,246 @@ +use std::{ + fmt, + future::Future, + io, + pin::Pin, + task::{Context, Poll}, +}; + +use actix_codec::{AsyncRead, AsyncWrite}; +use actix_rt::net::TcpStream; +use actix_service::{Service, ServiceFactory}; +use futures_core::{future::LocalBoxFuture, ready}; +use log::trace; + +pub use openssl::ssl::{Error as SslError, HandshakeError, SslConnector, SslMethod}; +pub use tokio_openssl::SslStream; + +use crate::connect::resolve::Resolve; +use crate::connect::{ + Address, Connect, ConnectError, ConnectService, ConnectServiceFactory, Connection, Resolver, +}; + +/// OpenSSL connector factory +pub struct OpensslConnector { + connector: SslConnector, +} + +impl OpensslConnector { + pub fn new(connector: SslConnector) -> Self { + OpensslConnector { connector } + } + + pub fn service(connector: SslConnector) -> OpensslConnectorService { + OpensslConnectorService { connector } + } +} + +impl Clone for OpensslConnector { + fn clone(&self) -> Self { + Self { + connector: self.connector.clone(), + } + } +} + +impl ServiceFactory> for OpensslConnector +where + T: Address + 'static, + U: AsyncRead + AsyncWrite + Unpin + fmt::Debug + 'static, +{ + type Response = Connection>; + type Error = io::Error; + type Config = (); + type Service = OpensslConnectorService; + type InitError = (); + type Future = LocalBoxFuture<'static, Result>; + + fn new_service(&self, _: ()) -> Self::Future { + let connector = self.connector.clone(); + Box::pin(async { Ok(OpensslConnectorService { connector }) }) + } +} + +pub struct OpensslConnectorService { + connector: SslConnector, +} + +impl Clone for OpensslConnectorService { + fn clone(&self) -> Self { + Self { + connector: self.connector.clone(), + } + } +} + +impl Service> for OpensslConnectorService +where + T: Address + 'static, + U: AsyncRead + AsyncWrite + Unpin + fmt::Debug + 'static, +{ + type Response = Connection>; + type Error = io::Error; + type Future = ConnectAsyncExt; + + actix_service::always_ready!(); + + fn call(&self, stream: Connection) -> Self::Future { + trace!("SSL Handshake start for: {:?}", stream.host()); + let (io, stream) = stream.replace_io(()); + let host = stream.host(); + + let config = self + .connector + .configure() + .expect("SSL connect configuration was invalid."); + + let ssl = config + .into_ssl(host) + .expect("SSL connect configuration was invalid."); + + ConnectAsyncExt { + io: Some(SslStream::new(ssl, io).unwrap()), + stream: Some(stream), + } + } +} + +pub struct ConnectAsyncExt { + io: Option>, + stream: Option>, +} + +impl Future for ConnectAsyncExt +where + U: AsyncRead + AsyncWrite + Unpin + fmt::Debug + 'static, +{ + type Output = Result>, io::Error>; + + fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + let this = self.get_mut(); + + match ready!(Pin::new(this.io.as_mut().unwrap()).poll_connect(cx)) { + Ok(_) => { + let stream = this.stream.take().unwrap(); + trace!("SSL Handshake success: {:?}", stream.host()); + Poll::Ready(Ok(stream.replace_io(this.io.take().unwrap()).1)) + } + Err(e) => { + trace!("SSL Handshake error: {:?}", e); + Poll::Ready(Err(io::Error::new(io::ErrorKind::Other, format!("{}", e)))) + } + } + } +} + +pub struct OpensslConnectServiceFactory { + tcp: ConnectServiceFactory, + openssl: OpensslConnector, +} + +impl OpensslConnectServiceFactory { + /// Construct new OpensslConnectService factory + pub fn new(connector: SslConnector) -> Self { + OpensslConnectServiceFactory { + tcp: ConnectServiceFactory::new(Resolver::Default), + openssl: OpensslConnector::new(connector), + } + } + + /// Construct new connect service with custom DNS resolver + pub fn with_resolver(connector: SslConnector, resolver: impl Resolve + 'static) -> Self { + OpensslConnectServiceFactory { + tcp: ConnectServiceFactory::new(Resolver::new_custom(resolver)), + openssl: OpensslConnector::new(connector), + } + } + + /// Construct OpenSSL connect service + pub fn service(&self) -> OpensslConnectService { + OpensslConnectService { + tcp: self.tcp.service(), + openssl: OpensslConnectorService { + connector: self.openssl.connector.clone(), + }, + } + } +} + +impl Clone for OpensslConnectServiceFactory { + fn clone(&self) -> Self { + OpensslConnectServiceFactory { + tcp: self.tcp.clone(), + openssl: self.openssl.clone(), + } + } +} + +impl ServiceFactory> for OpensslConnectServiceFactory { + type Response = SslStream; + type Error = ConnectError; + type Config = (); + type Service = OpensslConnectService; + type InitError = (); + type Future = LocalBoxFuture<'static, Result>; + + fn new_service(&self, _: ()) -> Self::Future { + let service = self.service(); + Box::pin(async { Ok(service) }) + } +} + +#[derive(Clone)] +pub struct OpensslConnectService { + tcp: ConnectService, + openssl: OpensslConnectorService, +} + +impl Service> for OpensslConnectService { + type Response = SslStream; + type Error = ConnectError; + type Future = OpensslConnectServiceResponse; + + actix_service::always_ready!(); + + fn call(&self, req: Connect) -> Self::Future { + OpensslConnectServiceResponse { + fut1: Some(self.tcp.call(req)), + fut2: None, + openssl: self.openssl.clone(), + } + } +} + +pub struct OpensslConnectServiceResponse { + fut1: Option<>>::Future>, + fut2: Option<>>::Future>, + openssl: OpensslConnectorService, +} + +impl Future for OpensslConnectServiceResponse { + type Output = Result, ConnectError>; + + fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + if let Some(ref mut fut) = self.fut1 { + match ready!(Pin::new(fut).poll(cx)) { + Ok(res) => { + let _ = self.fut1.take(); + self.fut2 = Some(self.openssl.call(res)); + } + Err(e) => return Poll::Ready(Err(e)), + } + } + + if let Some(ref mut fut) = self.fut2 { + match ready!(Pin::new(fut).poll(cx)) { + Ok(connect) => Poll::Ready(Ok(connect.into_parts().0)), + Err(e) => Poll::Ready(Err(ConnectError::Io(io::Error::new( + io::ErrorKind::Other, + e, + )))), + } + } else { + Poll::Pending + } + } +} diff --git a/actix-connect/src/ssl/rustls.rs b/actix-tls/src/connect/ssl/rustls.rs old mode 100644 new mode 100755 similarity index 50% rename from actix-connect/src/ssl/rustls.rs rename to actix-tls/src/connect/ssl/rustls.rs index 3e646082..46b4b11d --- a/actix-connect/src/ssl/rustls.rs +++ b/actix-tls/src/connect/ssl/rustls.rs @@ -1,108 +1,92 @@ -use std::fmt; -use std::future::Future; -use std::marker::PhantomData; -use std::pin::Pin; -use std::sync::Arc; -use std::task::{Context, Poll}; +use std::{ + fmt, + future::Future, + pin::Pin, + sync::Arc, + task::{Context, Poll}, +}; -pub use rust_tls::Session; +pub use tokio_rustls::rustls::Session; pub use tokio_rustls::{client::TlsStream, rustls::ClientConfig}; +pub use webpki_roots::TLS_SERVER_ROOTS; use actix_codec::{AsyncRead, AsyncWrite}; use actix_service::{Service, ServiceFactory}; -use futures_util::future::{ok, Ready}; +use futures_core::{future::LocalBoxFuture, ready}; +use log::trace; +use tokio_rustls::webpki::DNSNameRef; use tokio_rustls::{Connect, TlsConnector}; -use webpki::DNSNameRef; -use crate::{Address, Connection}; +use crate::connect::{Address, Connection}; /// Rustls connector factory -pub struct RustlsConnector { +pub struct RustlsConnector { connector: Arc, - _t: PhantomData<(T, U)>, } -impl RustlsConnector { +impl RustlsConnector { pub fn new(connector: Arc) -> Self { - RustlsConnector { - connector, - _t: PhantomData, + RustlsConnector { connector } + } +} + +impl RustlsConnector { + pub fn service(connector: Arc) -> RustlsConnectorService { + RustlsConnectorService { connector } + } +} + +impl Clone for RustlsConnector { + fn clone(&self) -> Self { + Self { + connector: self.connector.clone(), } } } -impl RustlsConnector +impl ServiceFactory> for RustlsConnector +where + U: AsyncRead + AsyncWrite + Unpin + fmt::Debug, +{ + type Response = Connection>; + type Error = std::io::Error; + type Config = (); + type Service = RustlsConnectorService; + type InitError = (); + type Future = LocalBoxFuture<'static, Result>; + + fn new_service(&self, _: ()) -> Self::Future { + let connector = self.connector.clone(); + Box::pin(async { Ok(RustlsConnectorService { connector }) }) + } +} + +pub struct RustlsConnectorService { + connector: Arc, +} + +impl Clone for RustlsConnectorService { + fn clone(&self) -> Self { + Self { + connector: self.connector.clone(), + } + } +} + +impl Service> for RustlsConnectorService where T: Address, U: AsyncRead + AsyncWrite + Unpin + fmt::Debug, { - pub fn service(connector: Arc) -> RustlsConnectorService { - RustlsConnectorService { - connector, - _t: PhantomData, - } - } -} - -impl Clone for RustlsConnector { - fn clone(&self) -> Self { - Self { - connector: self.connector.clone(), - _t: PhantomData, - } - } -} - -impl ServiceFactory for RustlsConnector -where - U: AsyncRead + AsyncWrite + Unpin + fmt::Debug, -{ - type Request = Connection; - type Response = Connection>; - type Error = std::io::Error; - type Config = (); - type Service = RustlsConnectorService; - type InitError = (); - type Future = Ready>; - - fn new_service(&self, _: ()) -> Self::Future { - ok(RustlsConnectorService { - connector: self.connector.clone(), - _t: PhantomData, - }) - } -} - -pub struct RustlsConnectorService { - connector: Arc, - _t: PhantomData<(T, U)>, -} - -impl Clone for RustlsConnectorService { - fn clone(&self) -> Self { - Self { - connector: self.connector.clone(), - _t: PhantomData, - } - } -} - -impl Service for RustlsConnectorService -where - U: AsyncRead + AsyncWrite + Unpin + fmt::Debug, -{ - type Request = Connection; type Response = Connection>; type Error = std::io::Error; type Future = ConnectAsyncExt; - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { - Poll::Ready(Ok(())) - } + actix_service::always_ready!(); - fn call(&mut self, stream: Connection) -> Self::Future { + fn call(&self, stream: Connection) -> Self::Future { trace!("SSL Handshake start for: {:?}", stream.host()); - let (io, stream) = stream.replace(()); + let (io, stream) = stream.replace_io(()); let host = DNSNameRef::try_from_ascii_str(stream.host()) .expect("rustls currently only handles hostname-based connections. See https://github.com/briansmith/webpki/issues/54"); ConnectAsyncExt { @@ -117,20 +101,18 @@ pub struct ConnectAsyncExt { stream: Option>, } -impl Future for ConnectAsyncExt +impl Future for ConnectAsyncExt where + T: Address, U: AsyncRead + AsyncWrite + Unpin + fmt::Debug, { type Output = Result>, std::io::Error>; fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { let this = self.get_mut(); - Poll::Ready( - futures_util::ready!(Pin::new(&mut this.fut).poll(cx)).map(|stream| { - let s = this.stream.take().unwrap(); - trace!("SSL Handshake success: {:?}", s.host()); - s.replace(stream).1 - }), - ) + let stream = ready!(Pin::new(&mut this.fut).poll(cx))?; + let s = this.stream.take().unwrap(); + trace!("SSL Handshake success: {:?}", s.host()); + Poll::Ready(Ok(s.replace_io(stream).1)) } } diff --git a/actix-tls/src/connect/uri.rs b/actix-tls/src/connect/uri.rs new file mode 100644 index 00000000..2d54b618 --- /dev/null +++ b/actix-tls/src/connect/uri.rs @@ -0,0 +1,43 @@ +use http::Uri; + +use super::Address; + +impl Address for Uri { + fn hostname(&self) -> &str { + self.host().unwrap_or("") + } + + fn port(&self) -> Option { + match self.port_u16() { + Some(port) => Some(port), + None => scheme_to_port(self.scheme_str()), + } + } +} + +// Get port from well-known URL schemes. +fn scheme_to_port(scheme: Option<&str>) -> Option { + match scheme { + // HTTP + Some("http") => Some(80), + Some("https") => Some(443), + + // WebSockets + Some("ws") => Some(80), + Some("wss") => Some(443), + + // Advanced Message Queuing Protocol (AMQP) + Some("amqp") => Some(5672), + Some("amqps") => Some(5671), + + // Message Queuing Telemetry Transport (MQTT) + Some("mqtt") => Some(1883), + Some("mqtts") => Some(8883), + + // File Transfer Protocol (FTP) + Some("ftp") => Some(1883), + Some("ftps") => Some(990), + + _ => None, + } +} diff --git a/actix-tls/src/lib.rs b/actix-tls/src/lib.rs index 8cc18046..83e18d58 100644 --- a/actix-tls/src/lib.rs +++ b/actix-tls/src/lib.rs @@ -1,46 +1,13 @@ -//! TLS acceptor services for Actix ecosystem. -//! -//! ## Crate Features -//! * `openssl` - TLS acceptor using the `openssl` crate. -//! * `rustls` - TLS acceptor using the `rustls` crate. -//! * `nativetls` - TLS acceptor using the `native-tls` crate. +//! TLS acceptor and connector services for Actix ecosystem #![deny(rust_2018_idioms, nonstandard_style)] #![doc(html_logo_url = "https://actix.rs/img/logo.png")] #![doc(html_favicon_url = "https://actix.rs/favicon.ico")] -use std::sync::atomic::{AtomicUsize, Ordering}; - -use actix_utils::counter::Counter; - #[cfg(feature = "openssl")] -pub mod openssl; +extern crate tls_openssl as openssl; -#[cfg(feature = "rustls")] -pub mod rustls; - -#[cfg(feature = "nativetls")] -pub mod nativetls; - -pub(crate) static MAX_CONN: AtomicUsize = AtomicUsize::new(256); - -thread_local! { - static MAX_CONN_COUNTER: Counter = Counter::new(MAX_CONN.load(Ordering::Relaxed)); -} - -/// Sets the maximum per-worker concurrent TLS connection limit. -/// -/// All listeners will stop accepting connections when this limit is reached. -/// It can be used to regulate the global TLS CPU usage. -/// -/// By default, the connection limit is 256. -pub fn max_concurrent_tls_connect(num: usize) { - MAX_CONN.store(num, Ordering::Relaxed); -} - -/// TLS error combined with service error. -#[derive(Debug)] -pub enum TlsError { - Tls(E1), - Service(E2), -} +#[cfg(feature = "accept")] +pub mod accept; +#[cfg(feature = "connect")] +pub mod connect; diff --git a/actix-tls/src/nativetls.rs b/actix-tls/src/nativetls.rs deleted file mode 100644 index fa66bff6..00000000 --- a/actix-tls/src/nativetls.rs +++ /dev/null @@ -1,114 +0,0 @@ -use std::marker::PhantomData; -use std::task::{Context, Poll}; - -use actix_codec::{AsyncRead, AsyncWrite}; -use actix_service::{Service, ServiceFactory}; -use actix_utils::counter::Counter; -use futures_util::future::{self, FutureExt, LocalBoxFuture, TryFutureExt}; - -pub use native_tls::Error; -pub use tokio_tls::{TlsAcceptor, TlsStream}; - -use crate::MAX_CONN_COUNTER; - -/// Accept TLS connections via `native-tls` package. -/// -/// `nativetls` feature enables this `Acceptor` type. -pub struct Acceptor { - acceptor: TlsAcceptor, - io: PhantomData, -} - -impl Acceptor -where - T: AsyncRead + AsyncWrite + Unpin, -{ - /// Create `native-tls` based `Acceptor` service factory. - #[inline] - pub fn new(acceptor: TlsAcceptor) -> Self { - Acceptor { - acceptor, - io: PhantomData, - } - } -} - -impl Clone for Acceptor { - #[inline] - fn clone(&self) -> Self { - Self { - acceptor: self.acceptor.clone(), - io: PhantomData, - } - } -} - -impl ServiceFactory for Acceptor -where - T: AsyncRead + AsyncWrite + Unpin + 'static, -{ - type Request = T; - type Response = TlsStream; - type Error = Error; - type Service = NativeTlsAcceptorService; - - type Config = (); - type InitError = (); - type Future = future::Ready>; - - fn new_service(&self, _: ()) -> Self::Future { - MAX_CONN_COUNTER.with(|conns| { - future::ok(NativeTlsAcceptorService { - acceptor: self.acceptor.clone(), - conns: conns.clone(), - io: PhantomData, - }) - }) - } -} - -pub struct NativeTlsAcceptorService { - acceptor: TlsAcceptor, - io: PhantomData, - conns: Counter, -} - -impl Clone for NativeTlsAcceptorService { - fn clone(&self) -> Self { - Self { - acceptor: self.acceptor.clone(), - io: PhantomData, - conns: self.conns.clone(), - } - } -} - -impl Service for NativeTlsAcceptorService -where - T: AsyncRead + AsyncWrite + Unpin + 'static, -{ - type Request = T; - type Response = TlsStream; - type Error = Error; - type Future = LocalBoxFuture<'static, Result, Error>>; - - fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll> { - if self.conns.available(cx) { - Poll::Ready(Ok(())) - } else { - Poll::Pending - } - } - - fn call(&mut self, req: Self::Request) -> Self::Future { - let guard = self.conns.get(); - let this = self.clone(); - async move { this.acceptor.accept(req).await } - .map_ok(move |io| { - // Required to preserve `CounterGuard` until `Self::Future` is completely resolved. - let _ = guard; - io - }) - .boxed_local() - } -} diff --git a/actix-tls/src/openssl.rs b/actix-tls/src/openssl.rs deleted file mode 100644 index 46dc10de..00000000 --- a/actix-tls/src/openssl.rs +++ /dev/null @@ -1,113 +0,0 @@ -use std::future::Future; -use std::marker::PhantomData; -use std::pin::Pin; -use std::task::{Context, Poll}; - -use actix_codec::{AsyncRead, AsyncWrite}; -use actix_service::{Service, ServiceFactory}; -use actix_utils::counter::{Counter, CounterGuard}; -use futures_util::future::{ok, FutureExt, LocalBoxFuture, Ready}; - -pub use open_ssl::ssl::{AlpnError, SslAcceptor, SslAcceptorBuilder}; -pub use tokio_openssl::{HandshakeError, SslStream}; - -use crate::MAX_CONN_COUNTER; - -/// Accept TLS connections via `openssl` package. -/// -/// `openssl` feature enables this `Acceptor` type. -pub struct Acceptor { - acceptor: SslAcceptor, - io: PhantomData, -} - -impl Acceptor { - /// Create OpenSSL based `Acceptor` service factory. - #[inline] - pub fn new(acceptor: SslAcceptor) -> Self { - Acceptor { - acceptor, - io: PhantomData, - } - } -} - -impl Clone for Acceptor { - #[inline] - fn clone(&self) -> Self { - Self { - acceptor: self.acceptor.clone(), - io: PhantomData, - } - } -} - -impl ServiceFactory for Acceptor { - type Request = T; - type Response = SslStream; - type Error = HandshakeError; - type Config = (); - type Service = AcceptorService; - type InitError = (); - type Future = Ready>; - - fn new_service(&self, _: ()) -> Self::Future { - MAX_CONN_COUNTER.with(|conns| { - ok(AcceptorService { - acceptor: self.acceptor.clone(), - conns: conns.clone(), - io: PhantomData, - }) - }) - } -} - -pub struct AcceptorService { - acceptor: SslAcceptor, - conns: Counter, - io: PhantomData, -} - -impl Service for AcceptorService { - type Request = T; - type Response = SslStream; - type Error = HandshakeError; - type Future = AcceptorServiceResponse; - - fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll> { - if self.conns.available(ctx) { - Poll::Ready(Ok(())) - } else { - Poll::Pending - } - } - - fn call(&mut self, req: Self::Request) -> Self::Future { - let acc = self.acceptor.clone(); - AcceptorServiceResponse { - _guard: self.conns.get(), - fut: async move { - let acc = acc; - tokio_openssl::accept(&acc, req).await - } - .boxed_local(), - } - } -} - -pub struct AcceptorServiceResponse -where - T: AsyncRead + AsyncWrite, -{ - fut: LocalBoxFuture<'static, Result, HandshakeError>>, - _guard: CounterGuard, -} - -impl Future for AcceptorServiceResponse { - type Output = Result, HandshakeError>; - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - let io = futures_util::ready!(Pin::new(&mut self.fut).poll(cx))?; - Poll::Ready(Ok(io)) - } -} diff --git a/actix-connect/tests/test_connect.rs b/actix-tls/tests/test_connect.rs old mode 100644 new mode 100755 similarity index 76% rename from actix-connect/tests/test_connect.rs rename to actix-tls/tests/test_connect.rs index 21d78d2c..7ee7afda --- a/actix-connect/tests/test_connect.rs +++ b/actix-tls/tests/test_connect.rs @@ -2,15 +2,14 @@ use std::io; use actix_codec::{BytesCodec, Framed}; use actix_rt::net::TcpStream; +use actix_server::TestServer; use actix_service::{fn_service, Service, ServiceFactory}; -use actix_testing::TestServer; use bytes::Bytes; use futures_util::sink::SinkExt; -use actix_connect::resolver::{ResolverConfig, ResolverOpts}; -use actix_connect::Connect; +use actix_tls::connect::{self as actix_connect, Connect}; -#[cfg(feature = "openssl")] +#[cfg(all(feature = "connect", feature = "openssl"))] #[actix_rt::test] async fn test_string() { let srv = TestServer::with(|| { @@ -21,7 +20,7 @@ async fn test_string() { }) }); - let mut conn = actix_connect::default_connector(); + let conn = actix_connect::default_connector(); let addr = format!("localhost:{}", srv.port()); let con = conn.call(addr.into()).await.unwrap(); assert_eq!(con.peer_addr().unwrap(), srv.addr()); @@ -38,7 +37,7 @@ async fn test_rustls_string() { }) }); - let mut conn = actix_connect::default_connector(); + let conn = actix_connect::default_connector(); let addr = format!("localhost:{}", srv.port()); let con = conn.call(addr.into()).await.unwrap(); assert_eq!(con.peer_addr().unwrap(), srv.addr()); @@ -54,14 +53,17 @@ async fn test_static_str() { }) }); - let resolver = actix_connect::start_default_resolver().await.unwrap(); - let mut conn = actix_connect::new_connector(resolver.clone()); + let conn = actix_connect::default_connector(); - let con = conn.call(Connect::with("10", srv.addr())).await.unwrap(); + let con = conn + .call(Connect::with_addr("10", srv.addr())) + .await + .unwrap(); assert_eq!(con.peer_addr().unwrap(), srv.addr()); let connect = Connect::new(srv.host().to_owned()); - let mut conn = actix_connect::new_connector(resolver); + + let conn = actix_connect::default_connector(); let con = conn.call(connect).await; assert!(con.is_err()); } @@ -76,15 +78,13 @@ async fn test_new_service() { }) }); - let resolver = - actix_connect::start_resolver(ResolverConfig::default(), ResolverOpts::default()) - .await - .unwrap(); + let factory = actix_connect::default_connector_factory(); - let factory = actix_connect::new_connector_factory(resolver); - - let mut conn = factory.new_service(()).await.unwrap(); - let con = conn.call(Connect::with("10", srv.addr())).await.unwrap(); + let conn = factory.new_service(()).await.unwrap(); + let con = conn + .call(Connect::with_addr("10", srv.addr())) + .await + .unwrap(); assert_eq!(con.peer_addr().unwrap(), srv.addr()); } @@ -101,7 +101,7 @@ async fn test_openssl_uri() { }) }); - let mut conn = actix_connect::default_connector(); + let conn = actix_connect::default_connector(); let addr = http::Uri::try_from(format!("https://localhost:{}", srv.port())).unwrap(); let con = conn.call(addr.into()).await.unwrap(); assert_eq!(con.peer_addr().unwrap(), srv.addr()); @@ -120,7 +120,7 @@ async fn test_rustls_uri() { }) }); - let mut conn = actix_connect::default_connector(); + let conn = actix_connect::default_connector(); let addr = http::Uri::try_from(format!("https://localhost:{}", srv.port())).unwrap(); let con = conn.call(addr.into()).await.unwrap(); assert_eq!(con.peer_addr().unwrap(), srv.addr()); diff --git a/actix-tls/tests/test_resolvers.rs b/actix-tls/tests/test_resolvers.rs new file mode 100644 index 00000000..0f49c486 --- /dev/null +++ b/actix-tls/tests/test_resolvers.rs @@ -0,0 +1,78 @@ +use std::{ + io, + net::{Ipv4Addr, SocketAddr}, +}; + +use actix_rt::net::TcpStream; +use actix_server::TestServer; +use actix_service::{fn_service, Service, ServiceFactory}; +use futures_core::future::LocalBoxFuture; + +use actix_tls::connect::{new_connector_factory, Connect, Resolve, Resolver}; + +#[actix_rt::test] +async fn custom_resolver() { + /// Always resolves to localhost with the given port. + struct LocalOnlyResolver; + + impl Resolve for LocalOnlyResolver { + fn lookup<'a>( + &'a self, + _host: &'a str, + port: u16, + ) -> LocalBoxFuture<'a, Result, Box>> { + Box::pin(async move { + let local = format!("127.0.0.1:{}", port).parse().unwrap(); + Ok(vec![local]) + }) + } + } + + let addr = LocalOnlyResolver.lookup("example.com", 8080).await.unwrap()[0]; + assert_eq!(addr, SocketAddr::new(Ipv4Addr::LOCALHOST.into(), 8080)) +} + +#[actix_rt::test] +async fn custom_resolver_connect() { + use trust_dns_resolver::TokioAsyncResolver; + + let srv = + TestServer::with(|| fn_service(|_io: TcpStream| async { Ok::<_, io::Error>(()) })); + + struct MyResolver { + trust_dns: TokioAsyncResolver, + } + + impl Resolve for MyResolver { + fn lookup<'a>( + &'a self, + host: &'a str, + port: u16, + ) -> LocalBoxFuture<'a, Result, Box>> { + Box::pin(async move { + let res = self + .trust_dns + .lookup_ip(host) + .await? + .iter() + .map(|ip| SocketAddr::new(ip, port)) + .collect(); + Ok(res) + }) + } + } + + let resolver = MyResolver { + trust_dns: TokioAsyncResolver::tokio_from_system_conf().unwrap(), + }; + + let resolver = Resolver::new_custom(resolver); + let factory = new_connector_factory(resolver); + + let conn = factory.new_service(()).await.unwrap(); + let con = conn + .call(Connect::with_addr("example.com", srv.addr())) + .await + .unwrap(); + assert_eq!(con.peer_addr().unwrap(), srv.addr()); +} diff --git a/actix-tracing/Cargo.toml b/actix-tracing/Cargo.toml index d0b7bf29..60ad1454 100644 --- a/actix-tracing/Cargo.toml +++ b/actix-tracing/Cargo.toml @@ -6,7 +6,7 @@ description = "Support for tokio tracing with Actix services" keywords = ["network", "framework", "tracing"] homepage = "https://actix.rs" repository = "https://github.com/actix/actix-net.git" -documentation = "https://docs.rs/actix-tracing/" +documentation = "https://docs.rs/actix-tracing" categories = ["network-programming", "asynchronous"] license = "MIT OR Apache-2.0" edition = "2018" @@ -16,11 +16,12 @@ name = "actix_tracing" path = "src/lib.rs" [dependencies] -actix-service = "1.0.4" +actix-service = "2.0.0-beta.4" + futures-util = { version = "0.3.4", default-features = false } tracing = "0.1" tracing-futures = "0.2" [dev_dependencies] -actix-rt = "1.0" -slab = "0.4" \ No newline at end of file +actix-rt = "2.0.0" +slab = "0.4" diff --git a/actix-tracing/src/lib.rs b/actix-tracing/src/lib.rs index b61ffac8..b34f40d6 100644 --- a/actix-tracing/src/lib.rs +++ b/actix-tracing/src/lib.rs @@ -4,8 +4,7 @@ #![doc(html_logo_url = "https://actix.rs/img/logo.png")] #![doc(html_favicon_url = "https://actix.rs/favicon.ico")] -use std::marker::PhantomData; -use std::task::{Context, Poll}; +use core::marker::PhantomData; use actix_service::{ apply, dev::ApplyTransform, IntoServiceFactory, Service, ServiceFactory, Transform, @@ -27,21 +26,18 @@ impl TracingService { } } -impl Service for TracingService +impl Service for TracingService where - S: Service, - F: Fn(&S::Request) -> Option, + S: Service, + F: Fn(&Req) -> Option, { - type Request = S::Request; type Response = S::Response; type Error = S::Error; type Future = Either>; - fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll> { - self.inner.poll_ready(ctx) - } + actix_service::forward_ready!(inner); - fn call(&mut self, req: Self::Request) -> Self::Future { + fn call(&self, req: Req) -> Self::Future { let span = (self.make_span)(&req); let _enter = span.as_ref().map(|s| s.enter()); @@ -74,18 +70,12 @@ impl TracingTransform { } } -impl Transform for TracingTransform +impl Transform for TracingTransform where - S: Service, - U: ServiceFactory< - Request = S::Request, - Response = S::Response, - Error = S::Error, - Service = S, - >, - F: Fn(&S::Request) -> Option + Clone, + S: Service, + U: ServiceFactory, + F: Fn(&Req) -> Option + Clone, { - type Request = S::Request; type Response = S::Response; type Error = S::Error; type Transform = TracingService; @@ -104,20 +94,20 @@ where /// is passed in a reference to the request being handled by the service. /// /// For example: -/// ```rust,ignore +/// ```ignore /// let traced_service = trace( /// web_service, /// |req: &Request| Some(span!(Level::INFO, "request", req.id)) /// ); /// ``` -pub fn trace( - service_factory: U, +pub fn trace( + service_factory: I, make_span: F, -) -> ApplyTransform, S> +) -> ApplyTransform, S, Req> where - S: ServiceFactory, - F: Fn(&S::Request) -> Option + Clone, - U: IntoServiceFactory, + I: IntoServiceFactory, + S: ServiceFactory, + F: Fn(&Req) -> Option + Clone, { apply( TracingTransform::new(make_span), @@ -239,7 +229,7 @@ mod test { let span_svc = span!(Level::TRACE, "span_svc"); let trace_service_factory = trace(service_factory, |_: &&str| Some(span_svc.clone())); - let mut service = trace_service_factory.new_service(()).await.unwrap(); + let service = trace_service_factory.new_service(()).await.unwrap(); service.call("boo").await.unwrap(); let id = span_svc.id().unwrap().into_u64(); diff --git a/actix-utils/CHANGES.md b/actix-utils/CHANGES.md index 22b7c7bf..a7871612 100644 --- a/actix-utils/CHANGES.md +++ b/actix-utils/CHANGES.md @@ -1,223 +1,162 @@ # Changes -## Unreleased - 2020-xx-xx -* Upgrade `pin-project` to `1.0`. +## Unreleased - 2021-xx-xx + + +## 3.0.0-beta.2 - 2021-02-06 +* Update `actix-rt` to `2.0.0`. [#273] + +[#273]: https://github.com/actix/actix-net/pull/273 + + +## 3.0.0-beta.1 - 2020-12-28 +* Update `bytes` dependency to `1`. [#237] +* Use `pin-project-lite` to replace `pin-project`. [#229] +* Remove `condition`,`either`,`inflight`,`keepalive`,`oneshot`,`order`,`stream` and `time` mods. [#229] + +[#229]: https://github.com/actix/actix-net/pull/229 +[#237]: https://github.com/actix/actix-net/pull/237 + ## 2.0.0 - 2020-08-23 * No changes from beta 1. + ## 2.0.0-beta.1 - 2020-08-19 * Upgrade `tokio-util` to `0.3`. * Remove unsound custom Cell and use `std::cell::RefCell` instead, as well as `actix-service`. * Rename method to correctly spelled `LocalWaker::is_registered`. -## [1.0.6] - 2020-01-08 -* Add `Clone` impl for `condition::Waiter` +## 1.0.6 - 2020-01-08 +* Add `Clone` impl for `condition::Waiter`. -## [1.0.5] - 2020-01-08 +## 1.0.5 - 2020-01-08 * Add `Condition` type. - * Add `Pool` of one-shot's. -## [1.0.4] - 2019-12-20 +## 1.0.4 - 2019-12-20 * Add methods to check `LocalWaker` registration state. -## [1.0.3] - 2019-12-11 +## 1.0.3 - 2019-12-11 * Revert InOrder service changes -## [1.0.2] - 2019-12-11 -* Allow to create `framed::Dispatcher` with custom `mpsc::Receiver` +## 1.0.2 - 2019-12-11 +* Allow to create `framed::Dispatcher` with custom `mpsc::Receiver`. +* Add `oneshot::Sender::is_canceled()` method. -* Add `oneshot::Sender::is_canceled()` method -## [1.0.1] - 2019-12-11 +## 1.0.1 - 2019-12-11 +* Optimize InOrder service. -* Optimize InOrder service -## [1.0.0] - 2019-12-11 +## 1.0.0 - 2019-12-11 +* Simplify oneshot and mpsc implementations. -* Simplify oneshot and mpsc implementations -## [1.0.0-alpha.3] - 2019-12-07 +## 1.0.0-alpha.3 - 2019-12-07 +* Migrate to tokio 0.2. +* Fix oneshot. -* Migrate to tokio 0.2 -* Fix oneshot +## 1.0.0-alpha.2 - 2019-12-02 +* Migrate to `std::future`. -## [1.0.0-alpha.2] - 2019-12-02 - -* Migrate to `std::future` - -## [0.4.7] - 2019-10-14 +## 0.4.7 - 2019-10-14 * Re-register task on every framed transport poll. -## [0.4.6] - 2019-10-08 - +## 0.4.6 - 2019-10-08 * Refactor `Counter` type. register current task in available method. -## [0.4.5] - 2019-07-19 - -### Removed - -* Deprecated `CloneableService` as it is not safe +## 0.4.5 - 2019-07-19 +* Deprecated `CloneableService` as it is not safe. -## [0.4.4] - 2019-07-17 - -### Changed - -* Undeprecate `FramedTransport` as it is actually useful +## 0.4.4 - 2019-07-17 +* Undeprecate `FramedTransport` as it is actually useful. -## [0.4.3] - 2019-07-17 - -### Deprecated - -* Deprecate `CloneableService` as it is not safe and in general not very useful - -* Deprecate `FramedTransport` in favor of `actix-ioframe` +## 0.4.3 - 2019-07-17 +* Deprecate `CloneableService` as it is not safe and in general not very useful. +* Deprecate `FramedTransport` in favor of `actix-ioframe`. -## [0.4.2] - 2019-06-26 - -### Fixed - -* Do not block on sink drop for FramedTransport +## 0.4.2 - 2019-06-26 +* Do not block on sink drop for FramedTransport. -## [0.4.1] - 2019-05-15 - -### Changed - -* Change `Either` constructor +## 0.4.1 - 2019-05-15 +* Change `Either` constructor. -## [0.4.0] - 2019-05-11 +## 0.4.0 - 2019-05-11 +* Change `Either` to handle two nexted services. +* Upgrade actix-service 0.4. +* Removed framed related services. +* Removed stream related services. -### Changed - -* Change `Either` to handle two nexted services - -* Upgrade actix-service 0.4 - -### Deleted - -* Framed related services - -* Stream related services - -## [0.3.5] - 2019-04-04 - -### Added +## 0.3.5 - 2019-04-04 * Allow to send messages to `FramedTransport` via mpsc channel. - -### Changed - -* Remove 'static constraint from Clonable service +* Remove `'static` constraint from Clonable service. -## [0.3.4] - 2019-03-12 - -### Changed - +## 0.3.4 - 2019-03-12 * `TimeoutService`, `InOrderService`, `InFlightService` accepts generic IntoService services. - -### Fixed - -* Fix `InFlightService::poll_ready()` nested service readiness check - -* Fix `InOrderService::poll_ready()` nested service readiness check +* Fix `InFlightService::poll_ready()` nested service readiness check. +* Fix `InOrderService::poll_ready()` nested service readiness check. -## [0.3.3] - 2019-03-09 - -### Changed - -* Revert IntoFuture change - -* Add generic config param for IntoFramed and TakeOne new services +## 0.3.3 - 2019-03-09 +* Revert IntoFuture change. +* Add generic config param for IntoFramed and TakeOne new services. -## [0.3.2] - 2019-03-04 +## 0.3.2 - 2019-03-04 +* Use IntoFuture for new services. -### Changed - -* Use IntoFuture for new services +## 0.3.1 - 2019-03-04 +* Use new type of transform trait. -## [0.3.1] - 2019-03-04 - -### Changed - -* Use new type of transform trait - - -## [0.3.0] - 2019-03-02 - -### Changed - +## 0.3.0 - 2019-03-02 * Use new `NewService` trait - * BoxedNewService` and `BoxedService` types moved to actix-service crate. -## [0.2.4] - 2019-02-21 - -### Changed - +## 0.2.4 - 2019-02-21 * Custom `BoxedNewService` implementation. -## [0.2.3] - 2019-02-21 - -### Added - -* Add `BoxedNewService` and `BoxedService` +## 0.2.3 - 2019-02-21 +* Add `BoxedNewService` and `BoxedService`. -## [0.2.2] - 2019-02-11 - -### Added - -* Add `Display` impl for `TimeoutError` - -* Add `Display` impl for `InOrderError` +## 0.2.2 - 2019-02-11 +* Add `Display` impl for `TimeoutError`. +* Add `Display` impl for `InOrderError`. -## [0.2.1] - 2019-02-06 - -### Added - +## 0.2.1 - 2019-02-06 * Add `InOrder` service. the service yields responses as they become available, in the order that their originating requests were submitted to the service. - -### Changed - -* Convert `Timeout` and `InFlight` services to a transforms +* Convert `Timeout` and `InFlight` services to a transforms. -## [0.2.0] - 2019-02-01 - -* Fix framed transport error handling - -* Added Clone impl for Either service - -* Added Clone impl for Timeout service factory - -* Added Service and NewService for Stream dispatcher - -* Switch to actix-service 0.2 +## 0.2.0 - 2019-02-01 +* Fix framed transport error handling. +* Added Clone impl for Either service. +* Added Clone impl for Timeout service factory. +* Added Service and NewService for Stream dispatcher. +* Switch to actix-service 0.2. -## [0.1.0] - 2018-12-09 - -* Move utils services to separate crate +## 0.1.0 - 2018-12-09 +* Move utils services to separate crate. diff --git a/actix-utils/Cargo.toml b/actix-utils/Cargo.toml index 7f47f359..da46256e 100644 --- a/actix-utils/Cargo.toml +++ b/actix-utils/Cargo.toml @@ -1,12 +1,12 @@ [package] name = "actix-utils" -version = "2.0.0" +version = "3.0.0-beta.2" authors = ["Nikolay Kim "] -description = "Various network related services and utilities for the Actix ecosystem." +description = "Various network related services and utilities for the Actix ecosystem" keywords = ["network", "framework", "async", "futures"] homepage = "https://actix.rs" repository = "https://github.com/actix/actix-net.git" -documentation = "https://docs.rs/actix-utils/" +documentation = "https://docs.rs/actix-utils" categories = ["network-programming", "asynchronous"] license = "MIT OR Apache-2.0" edition = "2018" @@ -16,15 +16,15 @@ name = "actix_utils" path = "src/lib.rs" [dependencies] -actix-codec = "0.3.0" -actix-rt = "1.1.1" -actix-service = "1.0.6" -bitflags = "1.2.1" -bytes = "0.5.3" -either = "1.5.3" -futures-channel = { version = "0.3.4", default-features = false } -futures-sink = { version = "0.3.4", default-features = false } -futures-util = { version = "0.3.4", default-features = false } +actix-codec = "0.4.0-beta.1" +actix-rt = { version = "2.0.0", default-features = false } +actix-service = "2.0.0-beta.4" + +futures-core = { version = "0.3.7", default-features = false } +futures-sink = { version = "0.3.7", default-features = false } log = "0.4" -pin-project = "1.0.0" -slab = "0.4" +pin-project-lite = "0.2.0" + +[dev-dependencies] +actix-rt = "2.0.0" +futures-util = { version = "0.3.7", default-features = false } diff --git a/actix-utils/src/condition.rs b/actix-utils/src/condition.rs deleted file mode 100644 index 9c7c977c..00000000 --- a/actix-utils/src/condition.rs +++ /dev/null @@ -1,129 +0,0 @@ -use std::cell::RefCell; -use std::future::Future; -use std::pin::Pin; -use std::rc::Rc; -use std::task::{Context, Poll}; - -use slab::Slab; - -use crate::task::LocalWaker; - -/// Condition allows to notify multiple receivers at the same time -pub struct Condition(Rc>); - -struct Inner { - data: Slab>, -} - -impl Default for Condition { - fn default() -> Self { - Self::new() - } -} - -impl Condition { - pub fn new() -> Condition { - Condition(Rc::new(RefCell::new(Inner { data: Slab::new() }))) - } - - /// Get condition waiter - pub fn wait(&mut self) -> Waiter { - let token = self.0.borrow_mut().data.insert(None); - Waiter { - token, - inner: self.0.clone(), - } - } - - /// Notify all waiters - pub fn notify(&self) { - let inner = self.0.borrow(); - for item in inner.data.iter() { - if let Some(waker) = item.1 { - waker.wake(); - } - } - } -} - -impl Drop for Condition { - fn drop(&mut self) { - self.notify() - } -} - -#[must_use = "Waiter do nothing unless polled"] -pub struct Waiter { - token: usize, - inner: Rc>, -} - -impl Clone for Waiter { - fn clone(&self) -> Self { - let token = self.inner.borrow_mut().data.insert(None); - Waiter { - token, - inner: self.inner.clone(), - } - } -} - -impl Future for Waiter { - type Output = (); - - fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - let this = self.get_mut(); - - let mut inner = this.inner.borrow_mut(); - let inner = unsafe { inner.data.get_unchecked_mut(this.token) }; - if inner.is_none() { - let waker = LocalWaker::default(); - waker.register(cx.waker()); - *inner = Some(waker); - Poll::Pending - } else if inner.as_mut().unwrap().register(cx.waker()) { - Poll::Pending - } else { - Poll::Ready(()) - } - } -} - -impl Drop for Waiter { - fn drop(&mut self) { - self.inner.borrow_mut().data.remove(self.token); - } -} - -#[cfg(test)] -mod tests { - use super::*; - use futures_util::future::lazy; - - #[actix_rt::test] - async fn test_condition() { - let mut cond = Condition::new(); - let mut waiter = cond.wait(); - assert_eq!( - lazy(|cx| Pin::new(&mut waiter).poll(cx)).await, - Poll::Pending - ); - cond.notify(); - waiter.await; - - let mut waiter = cond.wait(); - assert_eq!( - lazy(|cx| Pin::new(&mut waiter).poll(cx)).await, - Poll::Pending - ); - let mut waiter2 = waiter.clone(); - assert_eq!( - lazy(|cx| Pin::new(&mut waiter2).poll(cx)).await, - Poll::Pending - ); - - drop(cond); - waiter.await; - waiter2.await; - } -} diff --git a/actix-utils/src/counter.rs b/actix-utils/src/counter.rs index 4fe9dd0a..0b5984d2 100644 --- a/actix-utils/src/counter.rs +++ b/actix-utils/src/counter.rs @@ -1,6 +1,7 @@ -use std::cell::Cell; +use core::cell::Cell; +use core::task; + use std::rc::Rc; -use std::task; use crate::task::LocalWaker; diff --git a/actix-utils/src/dispatcher.rs b/actix-utils/src/dispatcher.rs index 1ee72564..1e55aa2c 100644 --- a/actix-utils/src/dispatcher.rs +++ b/actix-utils/src/dispatcher.rs @@ -1,15 +1,17 @@ -//! Framed dispatcher service and related utilities +//! Framed dispatcher service and related utilities. #![allow(type_alias_bounds)] -use std::pin::Pin; -use std::task::{Context, Poll}; -use std::{fmt, mem}; +use core::future::Future; +use core::pin::Pin; +use core::task::{Context, Poll}; +use core::{fmt, mem}; use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed}; use actix_service::{IntoService, Service}; -use futures_util::{future::Future, stream::Stream, FutureExt}; +use futures_core::stream::Stream; use log::debug; +use pin_project_lite::pin_project; use crate::mpsc; @@ -61,28 +63,35 @@ pub enum Message { Close, } -/// Dispatcher is a future that reads frames from Framed object -/// and passes them to the service. -#[pin_project::pin_project] -pub struct Dispatcher -where - S: Service::Item, Response = I>, - S::Error: 'static, - S::Future: 'static, - T: AsyncRead + AsyncWrite, - U: Encoder + Decoder, - I: 'static, - >::Error: std::fmt::Debug, -{ - service: S, - state: State, - #[pin] - framed: Framed, - rx: mpsc::Receiver, S::Error>>, - tx: mpsc::Sender, S::Error>>, +pin_project! { + /// Dispatcher is a future that reads frames from Framed object + /// and passes them to the service. + pub struct Dispatcher + where + S: Service<::Item, Response = I>, + S::Error: 'static, + S::Future: 'static, + T: AsyncRead, + T: AsyncWrite, + U: Encoder, + U: Decoder, + I: 'static, + >::Error: fmt::Debug, + { + service: S, + state: State, + #[pin] + framed: Framed, + rx: mpsc::Receiver, S::Error>>, + tx: mpsc::Sender, S::Error>>, + } } -enum State + Decoder, I> { +enum State +where + S: Service<::Item>, + U: Encoder + Decoder, +{ Processing, Error(DispatcherError), FramedError(DispatcherError), @@ -90,7 +99,11 @@ enum State + Decoder, I> { Stopping, } -impl + Decoder, I> State { +impl State +where + S: Service<::Item>, + U: Encoder + Decoder, +{ fn take_error(&mut self) -> DispatcherError { match mem::replace(self, State::Processing) { State::Error(err) => err, @@ -108,16 +121,19 @@ impl + Decoder, I> State { impl Dispatcher where - S: Service::Item, Response = I>, + S: Service<::Item, Response = I>, S::Error: 'static, S::Future: 'static, T: AsyncRead + AsyncWrite, U: Decoder + Encoder, I: 'static, - ::Error: std::fmt::Debug, - >::Error: std::fmt::Debug, + ::Error: fmt::Debug, + >::Error: fmt::Debug, { - pub fn new>(framed: Framed, service: F) -> Self { + pub fn new(framed: Framed, service: F) -> Self + where + F: IntoService::Item>, + { let (tx, rx) = mpsc::channel(); Dispatcher { framed, @@ -129,11 +145,14 @@ where } /// Construct new `Dispatcher` instance with customer `mpsc::Receiver` - pub fn with_rx>( + pub fn with_rx( framed: Framed, service: F, rx: mpsc::Receiver, S::Error>>, - ) -> Self { + ) -> Self + where + F: IntoService::Item>, + { let tx = rx.sender(); Dispatcher { framed, @@ -172,13 +191,13 @@ where fn poll_read(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> bool where - S: Service::Item, Response = I>, + S: Service<::Item, Response = I>, S::Error: 'static, S::Future: 'static, T: AsyncRead + AsyncWrite, U: Decoder + Encoder, I: 'static, - >::Error: std::fmt::Debug, + >::Error: fmt::Debug, { loop { let this = self.as_mut().project(); @@ -198,9 +217,11 @@ where }; let tx = this.tx.clone(); - actix_rt::spawn(this.service.call(item).map(move |item| { + let fut = this.service.call(item); + actix_rt::spawn(async move { + let item = fut.await; let _ = tx.send(item.map(Message::Item)); - })); + }); } Poll::Pending => return false, Poll::Ready(Err(err)) => { @@ -214,13 +235,13 @@ where /// write to framed object fn poll_write(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> bool where - S: Service::Item, Response = I>, + S: Service<::Item, Response = I>, S::Error: 'static, S::Future: 'static, T: AsyncRead + AsyncWrite, U: Decoder + Encoder, I: 'static, - >::Error: std::fmt::Debug, + >::Error: fmt::Debug, { loop { let mut this = self.as_mut().project(); @@ -265,14 +286,14 @@ where impl Future for Dispatcher where - S: Service::Item, Response = I>, + S: Service<::Item, Response = I>, S::Error: 'static, S::Future: 'static, T: AsyncRead + AsyncWrite, U: Decoder + Encoder, I: 'static, - >::Error: std::fmt::Debug, - ::Error: std::fmt::Debug, + >::Error: fmt::Debug, + ::Error: fmt::Debug, { type Output = Result<(), DispatcherError>; diff --git a/actix-utils/src/either.rs b/actix-utils/src/either.rs deleted file mode 100644 index fdf15ffe..00000000 --- a/actix-utils/src/either.rs +++ /dev/null @@ -1,153 +0,0 @@ -//! Contains `Either` service and related types and functions. -use std::pin::Pin; -use std::task::{Context, Poll}; - -use actix_service::{Service, ServiceFactory}; -use futures_util::{future, future::Future, ready}; - -/// Combine two different service types into a single type. -/// -/// Both services must be of the same request, response, and error types. -/// `EitherService` is useful for handling conditional branching in service -/// middleware to different inner service types. -pub struct EitherService { - left: A, - right: B, -} - -impl Clone for EitherService { - fn clone(&self) -> Self { - EitherService { - left: self.left.clone(), - right: self.right.clone(), - } - } -} - -impl Service for EitherService -where - A: Service, - B: Service, -{ - type Request = either::Either; - type Response = A::Response; - type Error = A::Error; - type Future = future::Either; - - fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll> { - let left = self.left.poll_ready(cx)?; - let right = self.right.poll_ready(cx)?; - - if left.is_ready() && right.is_ready() { - Poll::Ready(Ok(())) - } else { - Poll::Pending - } - } - - fn call(&mut self, req: either::Either) -> Self::Future { - match req { - either::Either::Left(req) => future::Either::Left(self.left.call(req)), - either::Either::Right(req) => future::Either::Right(self.right.call(req)), - } - } -} - -/// Combine two different new service types into a single service. -pub struct Either { - left: A, - right: B, -} - -impl Either { - pub fn new(left: A, right: B) -> Either - where - A: ServiceFactory, - A::Config: Clone, - B: ServiceFactory< - Config = A::Config, - Response = A::Response, - Error = A::Error, - InitError = A::InitError, - >, - { - Either { left, right } - } -} - -impl ServiceFactory for Either -where - A: ServiceFactory, - A::Config: Clone, - B: ServiceFactory< - Config = A::Config, - Response = A::Response, - Error = A::Error, - InitError = A::InitError, - >, -{ - type Request = either::Either; - type Response = A::Response; - type Error = A::Error; - type InitError = A::InitError; - type Config = A::Config; - type Service = EitherService; - type Future = EitherNewService; - - fn new_service(&self, cfg: A::Config) -> Self::Future { - EitherNewService { - left: None, - right: None, - left_fut: self.left.new_service(cfg.clone()), - right_fut: self.right.new_service(cfg), - } - } -} - -impl Clone for Either { - fn clone(&self) -> Self { - Self { - left: self.left.clone(), - right: self.right.clone(), - } - } -} - -#[doc(hidden)] -#[pin_project::pin_project] -pub struct EitherNewService { - left: Option, - right: Option, - #[pin] - left_fut: A::Future, - #[pin] - right_fut: B::Future, -} - -impl Future for EitherNewService -where - A: ServiceFactory, - B: ServiceFactory, -{ - type Output = Result, A::InitError>; - - fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - let this = self.project(); - - if this.left.is_none() { - *this.left = Some(ready!(this.left_fut.poll(cx))?); - } - if this.right.is_none() { - *this.right = Some(ready!(this.right_fut.poll(cx))?); - } - - if this.left.is_some() && this.right.is_some() { - Poll::Ready(Ok(EitherService { - left: this.left.take().unwrap(), - right: this.right.take().unwrap(), - })) - } else { - Poll::Pending - } - } -} diff --git a/actix-utils/src/inflight.rs b/actix-utils/src/inflight.rs deleted file mode 100644 index 8975a2d2..00000000 --- a/actix-utils/src/inflight.rs +++ /dev/null @@ -1,169 +0,0 @@ -use std::convert::Infallible; -use std::future::Future; -use std::pin::Pin; -use std::task::{Context, Poll}; - -use actix_service::{IntoService, Service, Transform}; -use futures_util::future::{ok, Ready}; - -use super::counter::{Counter, CounterGuard}; - -/// InFlight - new service for service that can limit number of in-flight -/// async requests. -/// -/// Default number of in-flight requests is 15 -pub struct InFlight { - max_inflight: usize, -} - -impl InFlight { - pub fn new(max: usize) -> Self { - Self { max_inflight: max } - } -} - -impl Default for InFlight { - fn default() -> Self { - Self::new(15) - } -} - -impl Transform for InFlight -where - S: Service, -{ - type Request = S::Request; - type Response = S::Response; - type Error = S::Error; - type InitError = Infallible; - type Transform = InFlightService; - type Future = Ready>; - - fn new_transform(&self, service: S) -> Self::Future { - ok(InFlightService::new(self.max_inflight, service)) - } -} - -pub struct InFlightService { - count: Counter, - service: S, -} - -impl InFlightService -where - S: Service, -{ - pub fn new(max: usize, service: U) -> Self - where - U: IntoService, - { - Self { - count: Counter::new(max), - service: service.into_service(), - } - } -} - -impl Service for InFlightService -where - T: Service, -{ - type Request = T::Request; - type Response = T::Response; - type Error = T::Error; - type Future = InFlightServiceResponse; - - fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll> { - if self.service.poll_ready(cx)?.is_pending() { - Poll::Pending - } else if !self.count.available(cx) { - log::trace!("InFlight limit exceeded"); - Poll::Pending - } else { - Poll::Ready(Ok(())) - } - } - - fn call(&mut self, req: T::Request) -> Self::Future { - InFlightServiceResponse { - fut: self.service.call(req), - _guard: self.count.get(), - } - } -} - -#[doc(hidden)] -#[pin_project::pin_project] -pub struct InFlightServiceResponse { - #[pin] - fut: T::Future, - _guard: CounterGuard, -} - -impl Future for InFlightServiceResponse { - type Output = Result; - - fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - self.project().fut.poll(cx) - } -} - -#[cfg(test)] -mod tests { - - use std::task::{Context, Poll}; - use std::time::Duration; - - use super::*; - use actix_service::{apply, fn_factory, Service, ServiceFactory}; - use futures_util::future::{lazy, ok, FutureExt, LocalBoxFuture}; - - struct SleepService(Duration); - - impl Service for SleepService { - type Request = (); - type Response = (); - type Error = (); - type Future = LocalBoxFuture<'static, Result<(), ()>>; - - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { - Poll::Ready(Ok(())) - } - - fn call(&mut self, _: ()) -> Self::Future { - actix_rt::time::delay_for(self.0) - .then(|_| ok::<_, ()>(())) - .boxed_local() - } - } - - #[actix_rt::test] - async fn test_transform() { - let wait_time = Duration::from_millis(50); - - let mut srv = InFlightService::new(1, SleepService(wait_time)); - assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(()))); - - let res = srv.call(()); - assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Pending); - - let _ = res.await; - assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(()))); - } - - #[actix_rt::test] - async fn test_new_transform() { - let wait_time = Duration::from_millis(50); - - let srv = apply(InFlight::new(1), fn_factory(|| ok(SleepService(wait_time)))); - - let mut srv = srv.new_service(&()).await.unwrap(); - assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(()))); - - let res = srv.call(()); - assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Pending); - - let _ = res.await; - assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(()))); - } -} diff --git a/actix-utils/src/keepalive.rs b/actix-utils/src/keepalive.rs deleted file mode 100644 index 4413dcd5..00000000 --- a/actix-utils/src/keepalive.rs +++ /dev/null @@ -1,125 +0,0 @@ -use std::convert::Infallible; -use std::future::Future; -use std::marker::PhantomData; -use std::pin::Pin; -use std::task::{Context, Poll}; -use std::time::Duration; - -use actix_rt::time::{delay_until, Delay, Instant}; -use actix_service::{Service, ServiceFactory}; -use futures_util::future::{ok, Ready}; - -use super::time::{LowResTime, LowResTimeService}; - -pub struct KeepAlive { - f: F, - ka: Duration, - time: LowResTime, - _t: PhantomData<(R, E)>, -} - -impl KeepAlive -where - F: Fn() -> E + Clone, -{ - pub fn new(ka: Duration, time: LowResTime, f: F) -> Self { - KeepAlive { - f, - ka, - time, - _t: PhantomData, - } - } -} - -impl Clone for KeepAlive -where - F: Clone, -{ - fn clone(&self) -> Self { - KeepAlive { - f: self.f.clone(), - ka: self.ka, - time: self.time.clone(), - _t: PhantomData, - } - } -} - -impl ServiceFactory for KeepAlive -where - F: Fn() -> E + Clone, -{ - type Request = R; - type Response = R; - type Error = E; - type InitError = Infallible; - type Config = (); - type Service = KeepAliveService; - type Future = Ready>; - - fn new_service(&self, _: ()) -> Self::Future { - ok(KeepAliveService::new( - self.ka, - self.time.timer(), - self.f.clone(), - )) - } -} - -pub struct KeepAliveService { - f: F, - ka: Duration, - time: LowResTimeService, - delay: Delay, - expire: Instant, - _t: PhantomData<(R, E)>, -} - -impl KeepAliveService -where - F: Fn() -> E, -{ - pub fn new(ka: Duration, time: LowResTimeService, f: F) -> Self { - let expire = Instant::from_std(time.now() + ka); - KeepAliveService { - f, - ka, - time, - expire, - delay: delay_until(expire), - _t: PhantomData, - } - } -} - -impl Service for KeepAliveService -where - F: Fn() -> E, -{ - type Request = R; - type Response = R; - type Error = E; - type Future = Ready>; - - fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll> { - match Pin::new(&mut self.delay).poll(cx) { - Poll::Ready(_) => { - let now = Instant::from_std(self.time.now()); - if self.expire <= now { - Poll::Ready(Err((self.f)())) - } else { - self.delay.reset(self.expire); - let _ = Pin::new(&mut self.delay).poll(cx); - Poll::Ready(Ok(())) - } - } - Poll::Pending => Poll::Ready(Ok(())), - } - } - - fn call(&mut self, req: R) -> Self::Future { - self.expire = Instant::from_std(self.time.now() + self.ka); - ok(req) - } -} diff --git a/actix-utils/src/lib.rs b/actix-utils/src/lib.rs index 19df225b..5c10bac6 100644 --- a/actix-utils/src/lib.rs +++ b/actix-utils/src/lib.rs @@ -1,20 +1,12 @@ -//! Actix utils - various helper services +//! Various network related services and utilities for the Actix ecosystem. #![deny(rust_2018_idioms, nonstandard_style)] #![allow(clippy::type_complexity)] #![doc(html_logo_url = "https://actix.rs/img/logo.png")] #![doc(html_favicon_url = "https://actix.rs/favicon.ico")] -pub mod condition; pub mod counter; pub mod dispatcher; -pub mod either; -pub mod inflight; -pub mod keepalive; pub mod mpsc; -pub mod oneshot; -pub mod order; -pub mod stream; pub mod task; -pub mod time; pub mod timeout; diff --git a/actix-utils/src/mpsc.rs b/actix-utils/src/mpsc.rs index 5905e123..2f2b3f04 100644 --- a/actix-utils/src/mpsc.rs +++ b/actix-utils/src/mpsc.rs @@ -1,15 +1,17 @@ //! A multi-producer, single-consumer, futures-aware, FIFO queue. -use std::any::Any; -use std::cell::RefCell; + +use core::any::Any; +use core::cell::RefCell; +use core::fmt; +use core::pin::Pin; +use core::task::{Context, Poll}; + use std::collections::VecDeque; use std::error::Error; -use std::fmt; -use std::pin::Pin; use std::rc::Rc; -use std::task::{Context, Poll}; +use futures_core::stream::Stream; use futures_sink::Sink; -use futures_util::stream::Stream; use crate::task::LocalWaker; diff --git a/actix-utils/src/oneshot.rs b/actix-utils/src/oneshot.rs deleted file mode 100644 index e75fad60..00000000 --- a/actix-utils/src/oneshot.rs +++ /dev/null @@ -1,316 +0,0 @@ -//! A one-shot, futures-aware channel. -use std::cell::RefCell; -use std::future::Future; -use std::pin::Pin; -use std::rc::Rc; -use std::task::{Context, Poll}; - -pub use futures_channel::oneshot::Canceled; -use slab::Slab; - -use crate::task::LocalWaker; - -/// Creates a new futures-aware, one-shot channel. -pub fn channel() -> (Sender, Receiver) { - let inner = Rc::new(RefCell::new(Inner { - value: None, - rx_task: LocalWaker::new(), - })); - let tx = Sender { - inner: inner.clone(), - }; - let rx = Receiver { inner }; - (tx, rx) -} - -/// Creates a new futures-aware, pool of one-shot's. -pub fn pool() -> Pool { - Pool(Rc::new(RefCell::new(Slab::new()))) -} - -/// Represents the completion half of a oneshot through which the result of a -/// computation is signaled. -#[derive(Debug)] -pub struct Sender { - inner: Rc>>, -} - -/// A future representing the completion of a computation happening elsewhere in -/// memory. -#[derive(Debug)] -#[must_use = "futures do nothing unless polled"] -pub struct Receiver { - inner: Rc>>, -} - -// The channels do not ever project Pin to the inner T -impl Unpin for Receiver {} -impl Unpin for Sender {} - -#[derive(Debug)] -struct Inner { - value: Option, - rx_task: LocalWaker, -} - -impl Sender { - /// Completes this oneshot with a successful result. - /// - /// This function will consume `self` and indicate to the other end, the - /// `Receiver`, that the error provided is the result of the computation this - /// represents. - /// - /// If the value is successfully enqueued for the remote end to receive, - /// then `Ok(())` is returned. If the receiving end was dropped before - /// this function was called, however, then `Err` is returned with the value - /// provided. - pub fn send(self, val: T) -> Result<(), T> { - if Rc::strong_count(&self.inner) == 2 { - let mut inner = self.inner.borrow_mut(); - inner.value = Some(val); - inner.rx_task.wake(); - Ok(()) - } else { - Err(val) - } - } - - /// Tests to see whether this `Sender`'s corresponding `Receiver` - /// has gone away. - pub fn is_canceled(&self) -> bool { - Rc::strong_count(&self.inner) == 1 - } -} - -impl Drop for Sender { - fn drop(&mut self) { - self.inner.borrow().rx_task.wake(); - } -} - -impl Future for Receiver { - type Output = Result; - - fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - let this = self.get_mut(); - - // If we've got a value, then skip the logic below as we're done. - if let Some(val) = this.inner.borrow_mut().value.take() { - return Poll::Ready(Ok(val)); - } - - // Check if sender is dropped and return error if it is. - if Rc::strong_count(&this.inner) == 1 { - Poll::Ready(Err(Canceled)) - } else { - this.inner.borrow().rx_task.register(cx.waker()); - Poll::Pending - } - } -} - -/// Futures-aware, pool of one-shot's. -pub struct Pool(Rc>>>); - -bitflags::bitflags! { - pub struct Flags: u8 { - const SENDER = 0b0000_0001; - const RECEIVER = 0b0000_0010; - } -} - -#[derive(Debug)] -struct PoolInner { - flags: Flags, - value: Option, - waker: LocalWaker, -} - -impl Pool { - pub fn channel(&mut self) -> (PSender, PReceiver) { - let token = self.0.borrow_mut().insert(PoolInner { - flags: Flags::all(), - value: None, - waker: LocalWaker::default(), - }); - - ( - PSender { - token, - inner: self.0.clone(), - }, - PReceiver { - token, - inner: self.0.clone(), - }, - ) - } -} - -impl Clone for Pool { - fn clone(&self) -> Self { - Pool(self.0.clone()) - } -} - -/// Represents the completion half of a oneshot through which the result of a -/// computation is signaled. -#[derive(Debug)] -pub struct PSender { - token: usize, - inner: Rc>>>, -} - -/// A future representing the completion of a computation happening elsewhere in -/// memory. -#[derive(Debug)] -#[must_use = "futures do nothing unless polled"] -pub struct PReceiver { - token: usize, - inner: Rc>>>, -} - -// The one-shots do not ever project Pin to the inner T -impl Unpin for PReceiver {} -impl Unpin for PSender {} - -impl PSender { - /// Completes this oneshot with a successful result. - /// - /// This function will consume `self` and indicate to the other end, the - /// `Receiver`, that the error provided is the result of the computation this - /// represents. - /// - /// If the value is successfully enqueued for the remote end to receive, - /// then `Ok(())` is returned. If the receiving end was dropped before - /// this function was called, however, then `Err` is returned with the value - /// provided. - pub fn send(self, val: T) -> Result<(), T> { - let mut inner = self.inner.borrow_mut(); - let inner = unsafe { inner.get_unchecked_mut(self.token) }; - - if inner.flags.contains(Flags::RECEIVER) { - inner.value = Some(val); - inner.waker.wake(); - Ok(()) - } else { - Err(val) - } - } - - /// Tests to see whether this `Sender`'s corresponding `Receiver` - /// has gone away. - pub fn is_canceled(&self) -> bool { - !unsafe { self.inner.borrow().get_unchecked(self.token) } - .flags - .contains(Flags::RECEIVER) - } -} - -impl Drop for PSender { - fn drop(&mut self) { - let mut inner = self.inner.borrow_mut(); - let inner_token = unsafe { inner.get_unchecked_mut(self.token) }; - if inner_token.flags.contains(Flags::RECEIVER) { - inner_token.waker.wake(); - inner_token.flags.remove(Flags::SENDER); - } else { - inner.remove(self.token); - } - } -} - -impl Drop for PReceiver { - fn drop(&mut self) { - let mut inner = self.inner.borrow_mut(); - let inner_token = unsafe { inner.get_unchecked_mut(self.token) }; - if inner_token.flags.contains(Flags::SENDER) { - inner_token.flags.remove(Flags::RECEIVER); - } else { - inner.remove(self.token); - } - } -} - -impl Future for PReceiver { - type Output = Result; - - fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - let this = self.get_mut(); - let mut inner = this.inner.borrow_mut(); - let inner = unsafe { inner.get_unchecked_mut(this.token) }; - - // If we've got a value, then skip the logic below as we're done. - if let Some(val) = inner.value.take() { - return Poll::Ready(Ok(val)); - } - - // Check if sender is dropped and return error if it is. - if !inner.flags.contains(Flags::SENDER) { - Poll::Ready(Err(Canceled)) - } else { - inner.waker.register(cx.waker()); - Poll::Pending - } - } -} - -#[cfg(test)] -mod tests { - use super::*; - use futures_util::future::lazy; - - #[actix_rt::test] - async fn test_oneshot() { - let (tx, rx) = channel(); - tx.send("test").unwrap(); - assert_eq!(rx.await.unwrap(), "test"); - - let (tx, rx) = channel(); - assert!(!tx.is_canceled()); - drop(rx); - assert!(tx.is_canceled()); - assert!(tx.send("test").is_err()); - - let (tx, rx) = channel::<&'static str>(); - drop(tx); - assert!(rx.await.is_err()); - - let (tx, mut rx) = channel::<&'static str>(); - assert_eq!(lazy(|cx| Pin::new(&mut rx).poll(cx)).await, Poll::Pending); - tx.send("test").unwrap(); - assert_eq!(rx.await.unwrap(), "test"); - - let (tx, mut rx) = channel::<&'static str>(); - assert_eq!(lazy(|cx| Pin::new(&mut rx).poll(cx)).await, Poll::Pending); - drop(tx); - assert!(rx.await.is_err()); - } - - #[actix_rt::test] - async fn test_pool() { - let (tx, rx) = pool().channel(); - tx.send("test").unwrap(); - assert_eq!(rx.await.unwrap(), "test"); - - let (tx, rx) = pool().channel(); - assert!(!tx.is_canceled()); - drop(rx); - assert!(tx.is_canceled()); - assert!(tx.send("test").is_err()); - - let (tx, rx) = pool::<&'static str>().channel(); - drop(tx); - assert!(rx.await.is_err()); - - let (tx, mut rx) = pool::<&'static str>().channel(); - assert_eq!(lazy(|cx| Pin::new(&mut rx).poll(cx)).await, Poll::Pending); - tx.send("test").unwrap(); - assert_eq!(rx.await.unwrap(), "test"); - - let (tx, mut rx) = pool::<&'static str>().channel(); - assert_eq!(lazy(|cx| Pin::new(&mut rx).poll(cx)).await, Poll::Pending); - drop(tx); - assert!(rx.await.is_err()); - } -} diff --git a/actix-utils/src/order.rs b/actix-utils/src/order.rs deleted file mode 100644 index 2d11b491..00000000 --- a/actix-utils/src/order.rs +++ /dev/null @@ -1,283 +0,0 @@ -use std::collections::VecDeque; -use std::convert::Infallible; -use std::fmt; -use std::future::Future; -use std::marker::PhantomData; -use std::pin::Pin; -use std::rc::Rc; -use std::task::{Context, Poll}; - -use actix_service::{IntoService, Service, Transform}; -use futures_util::future::{ok, Ready}; - -use crate::oneshot; -use crate::task::LocalWaker; - -struct Record { - rx: oneshot::Receiver>, - tx: oneshot::Sender>, -} - -/// Timeout error -pub enum InOrderError { - /// Service error - Service(E), - /// Service call dropped - Disconnected, -} - -impl From for InOrderError { - fn from(err: E) -> Self { - InOrderError::Service(err) - } -} - -impl fmt::Debug for InOrderError { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - match self { - InOrderError::Service(e) => write!(f, "InOrderError::Service({:?})", e), - InOrderError::Disconnected => write!(f, "InOrderError::Disconnected"), - } - } -} - -impl fmt::Display for InOrderError { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - match self { - InOrderError::Service(e) => e.fmt(f), - InOrderError::Disconnected => write!(f, "InOrder service disconnected"), - } - } -} - -/// InOrder - The service will yield responses as they become available, -/// in the order that their originating requests were submitted to the service. -pub struct InOrder { - _t: PhantomData, -} - -impl InOrder -where - S: Service, - S::Response: 'static, - S::Future: 'static, - S::Error: 'static, -{ - pub fn new() -> Self { - Self { _t: PhantomData } - } - - pub fn service(service: S) -> InOrderService { - InOrderService::new(service) - } -} - -impl Default for InOrder -where - S: Service, - S::Response: 'static, - S::Future: 'static, - S::Error: 'static, -{ - fn default() -> Self { - Self::new() - } -} - -impl Transform for InOrder -where - S: Service, - S::Response: 'static, - S::Future: 'static, - S::Error: 'static, -{ - type Request = S::Request; - type Response = S::Response; - type Error = InOrderError; - type InitError = Infallible; - type Transform = InOrderService; - type Future = Ready>; - - fn new_transform(&self, service: S) -> Self::Future { - ok(InOrderService::new(service)) - } -} - -pub struct InOrderService { - service: S, - waker: Rc, - acks: VecDeque>, -} - -impl InOrderService -where - S: Service, - S::Response: 'static, - S::Future: 'static, - S::Error: 'static, -{ - pub fn new(service: U) -> Self - where - U: IntoService, - { - Self { - service: service.into_service(), - acks: VecDeque::new(), - waker: Rc::new(LocalWaker::new()), - } - } -} - -impl Service for InOrderService -where - S: Service, - S::Response: 'static, - S::Future: 'static, - S::Error: 'static, -{ - type Request = S::Request; - type Response = S::Response; - type Error = InOrderError; - type Future = InOrderServiceResponse; - - fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll> { - // poll_ready could be called from different task - self.waker.register(cx.waker()); - - // check acks - while !self.acks.is_empty() { - let rec = self.acks.front_mut().unwrap(); - match Pin::new(&mut rec.rx).poll(cx) { - Poll::Ready(Ok(res)) => { - let rec = self.acks.pop_front().unwrap(); - let _ = rec.tx.send(res); - } - Poll::Pending => break, - Poll::Ready(Err(oneshot::Canceled)) => { - return Poll::Ready(Err(InOrderError::Disconnected)) - } - } - } - - // check nested service - if self - .service - .poll_ready(cx) - .map_err(InOrderError::Service)? - .is_pending() - { - Poll::Pending - } else { - Poll::Ready(Ok(())) - } - } - - fn call(&mut self, request: S::Request) -> Self::Future { - let (tx1, rx1) = oneshot::channel(); - let (tx2, rx2) = oneshot::channel(); - self.acks.push_back(Record { rx: rx1, tx: tx2 }); - - let waker = self.waker.clone(); - let fut = self.service.call(request); - actix_rt::spawn(async move { - let res = fut.await; - waker.wake(); - let _ = tx1.send(res); - }); - - InOrderServiceResponse { rx: rx2 } - } -} - -#[doc(hidden)] -pub struct InOrderServiceResponse { - rx: oneshot::Receiver>, -} - -impl Future for InOrderServiceResponse { - type Output = Result>; - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - match Pin::new(&mut self.rx).poll(cx) { - Poll::Pending => Poll::Pending, - Poll::Ready(Ok(Ok(res))) => Poll::Ready(Ok(res)), - Poll::Ready(Ok(Err(e))) => Poll::Ready(Err(e.into())), - Poll::Ready(Err(_)) => Poll::Ready(Err(InOrderError::Disconnected)), - } - } -} - -#[cfg(test)] -mod tests { - - use std::task::{Context, Poll}; - use std::time::Duration; - - use super::*; - use actix_service::Service; - use futures_channel::oneshot; - use futures_util::future::{lazy, poll_fn, FutureExt, LocalBoxFuture}; - - struct Srv; - - impl Service for Srv { - type Request = oneshot::Receiver; - type Response = usize; - type Error = (); - type Future = LocalBoxFuture<'static, Result>; - - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { - Poll::Ready(Ok(())) - } - - fn call(&mut self, req: oneshot::Receiver) -> Self::Future { - req.map(|res| res.map_err(|_| ())).boxed_local() - } - } - - #[actix_rt::test] - async fn test_in_order() { - let (tx1, rx1) = oneshot::channel(); - let (tx2, rx2) = oneshot::channel(); - let (tx3, rx3) = oneshot::channel(); - let (tx_stop, rx_stop) = oneshot::channel(); - - let h = std::thread::spawn(move || { - let rx1 = rx1; - let rx2 = rx2; - let rx3 = rx3; - let tx_stop = tx_stop; - actix_rt::System::new("test").block_on(async { - let mut srv = InOrderService::new(Srv); - - let _ = lazy(|cx| srv.poll_ready(cx)).await; - let res1 = srv.call(rx1); - let res2 = srv.call(rx2); - let res3 = srv.call(rx3); - - actix_rt::spawn(async move { - poll_fn(|cx| { - let _ = srv.poll_ready(cx); - Poll::<()>::Pending - }) - .await; - }); - - assert_eq!(res1.await.unwrap(), 1); - assert_eq!(res2.await.unwrap(), 2); - assert_eq!(res3.await.unwrap(), 3); - - let _ = tx_stop.send(()); - actix_rt::System::current().stop(); - }); - }); - - let _ = tx3.send(3); - std::thread::sleep(Duration::from_millis(50)); - let _ = tx2.send(2); - let _ = tx1.send(1); - - let _ = rx_stop.await; - let _ = h.join(); - } -} diff --git a/actix-utils/src/stream.rs b/actix-utils/src/stream.rs deleted file mode 100644 index 72e9e019..00000000 --- a/actix-utils/src/stream.rs +++ /dev/null @@ -1,76 +0,0 @@ -use std::future::Future; -use std::pin::Pin; -use std::task::{Context, Poll}; - -use actix_service::{IntoService, Service}; -use futures_util::{stream::Stream, FutureExt}; - -use crate::mpsc; - -#[pin_project::pin_project] -pub struct Dispatcher -where - S: Stream, - T: Service + 'static, -{ - #[pin] - stream: S, - service: T, - err_rx: mpsc::Receiver, - err_tx: mpsc::Sender, -} - -impl Dispatcher -where - S: Stream, - T: Service + 'static, -{ - pub fn new(stream: S, service: F) -> Self - where - F: IntoService, - { - let (err_tx, err_rx) = mpsc::channel(); - Dispatcher { - err_rx, - err_tx, - stream, - service: service.into_service(), - } - } -} - -impl Future for Dispatcher -where - S: Stream, - T: Service + 'static, -{ - type Output = Result<(), T::Error>; - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - let mut this = self.as_mut().project(); - - if let Poll::Ready(Some(e)) = Pin::new(&mut this.err_rx).poll_next(cx) { - return Poll::Ready(Err(e)); - } - - loop { - return match this.service.poll_ready(cx)? { - Poll::Ready(_) => match this.stream.poll_next(cx) { - Poll::Ready(Some(item)) => { - let stop = this.err_tx.clone(); - actix_rt::spawn(this.service.call(item).map(move |res| { - if let Err(e) = res { - let _ = stop.send(e); - } - })); - this = self.as_mut().project(); - continue; - } - Poll::Pending => Poll::Pending, - Poll::Ready(None) => Poll::Ready(Ok(())), - }, - Poll::Pending => Poll::Pending, - }; - } - } -} diff --git a/actix-utils/src/task.rs b/actix-utils/src/task.rs index cb32eb8d..2a3469cf 100644 --- a/actix-utils/src/task.rs +++ b/actix-utils/src/task.rs @@ -1,7 +1,7 @@ -use std::cell::UnsafeCell; -use std::marker::PhantomData; -use std::task::Waker; -use std::{fmt, rc}; +use core::cell::UnsafeCell; +use core::fmt; +use core::marker::PhantomData; +use core::task::Waker; /// A synchronization primitive for task wakeup. /// @@ -23,7 +23,8 @@ use std::{fmt, rc}; #[derive(Default)] pub struct LocalWaker { pub(crate) waker: UnsafeCell>, - _t: PhantomData>, + // mark LocalWaker as a !Send type. + _t: PhantomData<*const ()>, } impl LocalWaker { @@ -39,16 +40,16 @@ impl LocalWaker { since = "2.1.0", note = "In favor of `wake`. State of the register doesn't matter at `wake` up" )] - #[inline] /// Check if waker has been registered. + #[inline] pub fn is_registered(&self) -> bool { unsafe { (*self.waker.get()).is_some() } } - #[inline] /// Registers the waker to be notified on calls to `wake`. /// /// Returns `true` if waker was registered before. + #[inline] pub fn register(&self, waker: &Waker) -> bool { unsafe { let w = self.waker.get(); @@ -57,20 +58,20 @@ impl LocalWaker { } } - #[inline] /// Calls `wake` on the last `Waker` passed to `register`. /// /// If `register` has not been called yet, then this does nothing. + #[inline] pub fn wake(&self) { if let Some(waker) = self.take() { waker.wake(); } } - #[inline] /// Returns the last `Waker` passed to `register`, so that the user can wake it. /// /// If a waker has not been registered, this returns `None`. + #[inline] pub fn take(&self) -> Option { unsafe { (*self.waker.get()).take() } } diff --git a/actix-utils/src/time.rs b/actix-utils/src/time.rs deleted file mode 100644 index 2ce65bc3..00000000 --- a/actix-utils/src/time.rs +++ /dev/null @@ -1,225 +0,0 @@ -use std::cell::RefCell; -use std::convert::Infallible; -use std::rc::Rc; -use std::task::{Context, Poll}; -use std::time::{self, Duration, Instant}; - -use actix_rt::time::delay_for; -use actix_service::{Service, ServiceFactory}; -use futures_util::future::{ok, ready, FutureExt, Ready}; - -#[derive(Clone, Debug)] -pub struct LowResTime(Rc>); - -#[derive(Debug)] -struct Inner { - resolution: Duration, - current: Option, -} - -impl Inner { - fn new(resolution: Duration) -> Self { - Inner { - resolution, - current: None, - } - } -} - -impl LowResTime { - pub fn with(resolution: Duration) -> LowResTime { - LowResTime(Rc::new(RefCell::new(Inner::new(resolution)))) - } - - pub fn timer(&self) -> LowResTimeService { - LowResTimeService(self.0.clone()) - } -} - -impl Default for LowResTime { - fn default() -> Self { - LowResTime(Rc::new(RefCell::new(Inner::new(Duration::from_secs(1))))) - } -} - -impl ServiceFactory for LowResTime { - type Request = (); - type Response = Instant; - type Error = Infallible; - type InitError = Infallible; - type Config = (); - type Service = LowResTimeService; - type Future = Ready>; - - fn new_service(&self, _: ()) -> Self::Future { - ok(self.timer()) - } -} - -#[derive(Clone, Debug)] -pub struct LowResTimeService(Rc>); - -impl LowResTimeService { - pub fn with(resolution: Duration) -> LowResTimeService { - LowResTimeService(Rc::new(RefCell::new(Inner::new(resolution)))) - } - - /// Get current time. This function has to be called from - /// future's poll method, otherwise it panics. - pub fn now(&self) -> Instant { - let cur = self.0.borrow().current; - if let Some(cur) = cur { - cur - } else { - let now = Instant::now(); - let inner = self.0.clone(); - let interval = { - let mut b = inner.borrow_mut(); - b.current = Some(now); - b.resolution - }; - - actix_rt::spawn(delay_for(interval).then(move |_| { - inner.borrow_mut().current.take(); - ready(()) - })); - now - } - } -} - -impl Service for LowResTimeService { - type Request = (); - type Response = Instant; - type Error = Infallible; - type Future = Ready>; - - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { - Poll::Ready(Ok(())) - } - - fn call(&mut self, _: ()) -> Self::Future { - ok(self.now()) - } -} - -#[derive(Clone, Debug)] -pub struct SystemTime(Rc>); - -#[derive(Debug)] -struct SystemTimeInner { - resolution: Duration, - current: Option, -} - -impl SystemTimeInner { - fn new(resolution: Duration) -> Self { - SystemTimeInner { - resolution, - current: None, - } - } -} - -#[derive(Clone, Debug)] -pub struct SystemTimeService(Rc>); - -impl SystemTimeService { - pub fn with(resolution: Duration) -> SystemTimeService { - SystemTimeService(Rc::new(RefCell::new(SystemTimeInner::new(resolution)))) - } - - /// Get current time. This function has to be called from - /// future's poll method, otherwise it panics. - pub fn now(&self) -> time::SystemTime { - let cur = self.0.borrow().current; - if let Some(cur) = cur { - cur - } else { - let now = time::SystemTime::now(); - let inner = self.0.clone(); - let interval = { - let mut b = inner.borrow_mut(); - b.current = Some(now); - b.resolution - }; - - actix_rt::spawn(delay_for(interval).then(move |_| { - inner.borrow_mut().current.take(); - ready(()) - })); - now - } - } -} - -#[cfg(test)] -mod tests { - use super::*; - use std::time::{Duration, SystemTime}; - - /// State Under Test: Two calls of `SystemTimeService::now()` return the same value if they are done within resolution interval of `SystemTimeService`. - /// - /// Expected Behavior: Two back-to-back calls of `SystemTimeService::now()` return the same value. - #[actix_rt::test] - async fn system_time_service_time_does_not_immediately_change() { - let resolution = Duration::from_millis(50); - - let time_service = SystemTimeService::with(resolution); - assert_eq!(time_service.now(), time_service.now()); - } - - /// State Under Test: Two calls of `LowResTimeService::now()` return the same value if they are done within resolution interval of `SystemTimeService`. - /// - /// Expected Behavior: Two back-to-back calls of `LowResTimeService::now()` return the same value. - #[actix_rt::test] - async fn low_res_time_service_time_does_not_immediately_change() { - let resolution = Duration::from_millis(50); - let time_service = LowResTimeService::with(resolution); - assert_eq!(time_service.now(), time_service.now()); - } - - /// State Under Test: `SystemTimeService::now()` updates returned value every resolution period. - /// - /// Expected Behavior: Two calls of `LowResTimeService::now()` made in subsequent resolution interval return different values - /// and second value is greater than the first one at least by a resolution interval. - #[actix_rt::test] - async fn system_time_service_time_updates_after_resolution_interval() { - let resolution = Duration::from_millis(100); - let wait_time = Duration::from_millis(300); - - let time_service = SystemTimeService::with(resolution); - - let first_time = time_service - .now() - .duration_since(SystemTime::UNIX_EPOCH) - .unwrap(); - - delay_for(wait_time).await; - - let second_time = time_service - .now() - .duration_since(SystemTime::UNIX_EPOCH) - .unwrap(); - - assert!(second_time - first_time >= wait_time); - } - - /// State Under Test: `LowResTimeService::now()` updates returned value every resolution period. - /// - /// Expected Behavior: Two calls of `LowResTimeService::now()` made in subsequent resolution interval return different values - /// and second value is greater than the first one at least by a resolution interval. - #[actix_rt::test] - async fn low_res_time_service_time_updates_after_resolution_interval() { - let resolution = Duration::from_millis(100); - let wait_time = Duration::from_millis(300); - let time_service = LowResTimeService::with(resolution); - - let first_time = time_service.now(); - - delay_for(wait_time).await; - - let second_time = time_service.now(); - assert!(second_time - first_time >= wait_time); - } -} diff --git a/actix-utils/src/timeout.rs b/actix-utils/src/timeout.rs index f1d30f19..9304e5f6 100644 --- a/actix-utils/src/timeout.rs +++ b/actix-utils/src/timeout.rs @@ -1,16 +1,16 @@ //! Service that applies a timeout to requests. //! -//! If the response does not complete within the specified timeout, the response -//! will be aborted. -use std::future::Future; -use std::marker::PhantomData; -use std::pin::Pin; -use std::task::{Context, Poll}; -use std::{fmt, time}; +//! If the response does not complete within the specified timeout, the response will be aborted. -use actix_rt::time::{delay_for, Delay}; +use core::future::Future; +use core::marker::PhantomData; +use core::pin::Pin; +use core::task::{Context, Poll}; +use core::{fmt, time}; + +use actix_rt::time::{sleep, Sleep}; use actix_service::{IntoService, Service, Transform}; -use futures_util::future::{ok, Ready}; +use pin_project_lite::pin_project; /// Applies a timeout to requests. #[derive(Debug)] @@ -78,126 +78,147 @@ impl Clone for Timeout { } } -impl Transform for Timeout +impl Transform for Timeout where - S: Service, + S: Service, { - type Request = S::Request; type Response = S::Response; type Error = TimeoutError; + type Transform = TimeoutService; type InitError = E; - type Transform = TimeoutService; - type Future = Ready>; + type Future = TimeoutFuture; fn new_transform(&self, service: S) -> Self::Future { - ok(TimeoutService { + let service = TimeoutService { service, timeout: self.timeout, - }) + _phantom: PhantomData, + }; + + TimeoutFuture { + service: Some(service), + _err: PhantomData, + } + } +} + +pub struct TimeoutFuture { + service: Option, + _err: PhantomData, +} + +impl Unpin for TimeoutFuture {} + +impl Future for TimeoutFuture { + type Output = Result; + + fn poll(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll { + Poll::Ready(Ok(self.get_mut().service.take().unwrap())) } } /// Applies a timeout to requests. #[derive(Debug, Clone)] -pub struct TimeoutService { +pub struct TimeoutService { service: S, timeout: time::Duration, + _phantom: PhantomData, } -impl TimeoutService +impl TimeoutService where - S: Service, + S: Service, { pub fn new(timeout: time::Duration, service: U) -> Self where - U: IntoService, + U: IntoService, { TimeoutService { timeout, service: service.into_service(), + _phantom: PhantomData, } } } -impl Service for TimeoutService +impl Service for TimeoutService where - S: Service, + S: Service, { - type Request = S::Request; type Response = S::Response; type Error = TimeoutError; - type Future = TimeoutServiceResponse; + type Future = TimeoutServiceResponse; - fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll> { - self.service.poll_ready(cx).map_err(TimeoutError::Service) - } + actix_service::forward_ready!(service); - fn call(&mut self, request: S::Request) -> Self::Future { + fn call(&self, request: Req) -> Self::Future { TimeoutServiceResponse { fut: self.service.call(request), - sleep: delay_for(self.timeout), + sleep: sleep(self.timeout), } } } -/// `TimeoutService` response future -#[pin_project::pin_project] -#[derive(Debug)] -pub struct TimeoutServiceResponse { - #[pin] - fut: T::Future, - sleep: Delay, +pin_project! { + /// `TimeoutService` response future + #[derive(Debug)] + pub struct TimeoutServiceResponse + where + S: Service + { + #[pin] + fut: S::Future, + #[pin] + sleep: Sleep, + } } -impl Future for TimeoutServiceResponse +impl Future for TimeoutServiceResponse where - T: Service, + S: Service, { - type Output = Result>; + type Output = Result>; fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - let mut this = self.project(); + let this = self.project(); // First, try polling the future - match this.fut.poll(cx) { - Poll::Ready(Ok(v)) => return Poll::Ready(Ok(v)), - Poll::Ready(Err(e)) => return Poll::Ready(Err(TimeoutError::Service(e))), - Poll::Pending => {} + if let Poll::Ready(res) = this.fut.poll(cx) { + return match res { + Ok(v) => Poll::Ready(Ok(v)), + Err(e) => Poll::Ready(Err(TimeoutError::Service(e))), + }; } // Now check the sleep - match Pin::new(&mut this.sleep).poll(cx) { - Poll::Pending => Poll::Pending, - Poll::Ready(_) => Poll::Ready(Err(TimeoutError::Timeout)), - } + this.sleep.poll(cx).map(|_| Err(TimeoutError::Timeout)) } } #[cfg(test)] mod tests { - use std::task::{Context, Poll}; - use std::time::Duration; + use core::task::Poll; + use core::time::Duration; use super::*; use actix_service::{apply, fn_factory, Service, ServiceFactory}; - use futures_util::future::{ok, FutureExt, LocalBoxFuture}; + use futures_core::future::LocalBoxFuture; struct SleepService(Duration); - impl Service for SleepService { - type Request = (); + impl Service<()> for SleepService { type Response = (); type Error = (); type Future = LocalBoxFuture<'static, Result<(), ()>>; - fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> { - Poll::Ready(Ok(())) - } + actix_service::always_ready!(); - fn call(&mut self, _: ()) -> Self::Future { - actix_rt::time::delay_for(self.0) - .then(|_| ok::<_, ()>(())) - .boxed_local() + fn call(&self, _: ()) -> Self::Future { + let sleep = actix_rt::time::sleep(self.0); + Box::pin(async move { + sleep.await; + Ok(()) + }) } } @@ -206,7 +227,7 @@ mod tests { let resolution = Duration::from_millis(100); let wait_time = Duration::from_millis(50); - let mut timeout = TimeoutService::new(resolution, SleepService(wait_time)); + let timeout = TimeoutService::new(resolution, SleepService(wait_time)); assert_eq!(timeout.call(()).await, Ok(())); } @@ -215,7 +236,7 @@ mod tests { let resolution = Duration::from_millis(100); let wait_time = Duration::from_millis(500); - let mut timeout = TimeoutService::new(resolution, SleepService(wait_time)); + let timeout = TimeoutService::new(resolution, SleepService(wait_time)); assert_eq!(timeout.call(()).await, Err(TimeoutError::Timeout)); } @@ -226,9 +247,9 @@ mod tests { let timeout = apply( Timeout::new(resolution), - fn_factory(|| ok::<_, ()>(SleepService(wait_time))), + fn_factory(|| async { Ok::<_, ()>(SleepService(wait_time)) }), ); - let mut srv = timeout.new_service(&()).await.unwrap(); + let srv = timeout.new_service(&()).await.unwrap(); assert_eq!(srv.call(()).await, Err(TimeoutError::Timeout)); } diff --git a/bytestring/CHANGES.md b/bytestring/CHANGES.md new file mode 100644 index 00000000..217eb8d0 --- /dev/null +++ b/bytestring/CHANGES.md @@ -0,0 +1,36 @@ +# Changes + +## Unreleased - 2021-xx-xx + + +## 1.0.0 - 2020-12-31 +* Update `bytes` dependency to `1`. +* Add array and slice of `u8` impls of `TryFrom` up to 32 in length. +* Rename `get_ref` to `as_bytes` and rename `into_inner` to `into_bytes`. +* `ByteString::new` is now a `const fn`. +* Crate is now `#[no_std]` compatible. + + +## 0.1.5 - 2020-03-30 +* Serde support + + +## 0.1.4 - 2020-01-14 +* Fix `AsRef` impl + + +## 0.1.3 - 2020-01-13 +* Add `PartialEq>`, `AsRef<[u8]>` impls + + +## 0.1.2 - 2019-12-22 +* Fix `new()` method +* Make `ByteString::from_static()` and `ByteString::from_bytes_unchecked()` methods const. + + +## 0.1.1 - 2019-12-07 +* Fix hash impl + + +## 0.1.0 - 2019-12-07 +* Initial release diff --git a/bytestring/Cargo.toml b/bytestring/Cargo.toml new file mode 100644 index 00000000..3dbf07b7 --- /dev/null +++ b/bytestring/Cargo.toml @@ -0,0 +1,27 @@ +[package] +name = "bytestring" +version = "1.0.0" +authors = [ + "Nikolay Kim ", + "Rob Ede ", +] +description = "An immutable UTF-8 encoded string using Bytes as storage" +keywords = ["string", "bytes", "utf8", "web", "actix"] +categories = ["no-std", "web-programming"] +homepage = "https://actix.rs" +repository = "https://github.com/actix/actix-net.git" +documentation = "https://docs.rs/bytestring" +license = "MIT OR Apache-2.0" +edition = "2018" + +[lib] +name = "bytestring" +path = "src/lib.rs" + +[dependencies] +bytes = "1" +serde = { version = "1.0", optional = true } + +[dev-dependencies] +serde_json = "1.0" +ahash = { version = "0.7", default-features = false } diff --git a/actix-testing/LICENSE-APACHE b/bytestring/LICENSE-APACHE similarity index 100% rename from actix-testing/LICENSE-APACHE rename to bytestring/LICENSE-APACHE diff --git a/actix-testing/LICENSE-MIT b/bytestring/LICENSE-MIT similarity index 100% rename from actix-testing/LICENSE-MIT rename to bytestring/LICENSE-MIT diff --git a/string/src/lib.rs b/bytestring/src/lib.rs similarity index 66% rename from string/src/lib.rs rename to bytestring/src/lib.rs index 18cbc890..63ba92ed 100644 --- a/string/src/lib.rs +++ b/bytestring/src/lib.rs @@ -1,37 +1,38 @@ //! A UTF-8 encoded read-only string using Bytes as storage. +#![no_std] #![deny(rust_2018_idioms, nonstandard_style)] #![doc(html_logo_url = "https://actix.rs/img/logo.png")] #![doc(html_favicon_url = "https://actix.rs/favicon.ico")] -use std::convert::TryFrom; -use std::{borrow, fmt, hash, ops, str}; +extern crate alloc; + +use alloc::{string::String, vec::Vec}; +use core::{borrow, convert::TryFrom, fmt, hash, ops, str}; use bytes::Bytes; -/// A UTF-8 encoded string with [`Bytes`] as a storage. -/// -/// [`Bytes`]: bytes::Bytes -#[derive(Clone, Eq, Ord, PartialOrd, Default)] +/// An immutable UTF-8 encoded string with [`Bytes`] as a storage. +#[derive(Clone, Default, Eq, PartialOrd, Ord)] pub struct ByteString(Bytes); impl ByteString { - /// Creates a new `ByteString`. - pub fn new() -> Self { + /// Creates a new empty `ByteString`. + pub const fn new() -> Self { ByteString(Bytes::new()) } - /// Get a reference to the underlying bytes object. - pub fn get_ref(&self) -> &Bytes { + /// Get a reference to the underlying `Bytes` object. + pub fn as_bytes(&self) -> &Bytes { &self.0 } - /// Unwraps this `ByteString`, returning the underlying bytes object. - pub fn into_inner(self) -> Bytes { + /// Unwraps this `ByteString` into the underlying `Bytes` object. + pub fn into_bytes(self) -> Bytes { self.0 } - /// Creates a new `ByteString` from a static str. + /// Creates a new `ByteString` from a `&'static str`. pub const fn from_static(src: &'static str) -> ByteString { Self(Bytes::from_static(src.as_bytes())) } @@ -39,11 +40,10 @@ impl ByteString { /// Creates a new `ByteString` from a Bytes. /// /// # Safety - /// This function is unsafe because it does not check the bytes passed to it - /// are valid UTF-8. If this constraint is violated, - /// it may cause memory unsafety issues with future users of the `ByteString`, - /// as we assume that `ByteString`s are valid UTF-8. - /// However, the most likely issue is that the data gets corrupted. + /// This function is unsafe because it does not check the bytes passed to it are valid UTF-8. + /// If this constraint is violated, it may cause memory unsafety issues with future users of + /// the `ByteString`, as we assume that `ByteString`s are valid UTF-8. However, the most likely + /// issue is that the data gets corrupted. pub const unsafe fn from_bytes_unchecked(src: Bytes) -> ByteString { Self(src) } @@ -84,8 +84,10 @@ impl ops::Deref for ByteString { #[inline] fn deref(&self) -> &str { - let b = self.0.as_ref(); - unsafe { str::from_utf8_unchecked(b) } + let bytes = self.0.as_ref(); + // SAFETY: + // UTF-8 validity is guaranteed at during construction. + unsafe { str::from_utf8_unchecked(bytes) } } } @@ -96,21 +98,24 @@ impl borrow::Borrow for ByteString { } impl From for ByteString { + #[inline] fn from(value: String) -> Self { Self(Bytes::from(value)) } } -impl<'a> From<&'a str> for ByteString { - fn from(value: &'a str) -> Self { +impl From<&str> for ByteString { + #[inline] + fn from(value: &str) -> Self { Self(Bytes::copy_from_slice(value.as_ref())) } } -impl<'a> TryFrom<&'a [u8]> for ByteString { +impl TryFrom<&[u8]> for ByteString { type Error = str::Utf8Error; - fn try_from(value: &'a [u8]) -> Result { + #[inline] + fn try_from(value: &[u8]) -> Result { let _ = str::from_utf8(value)?; Ok(ByteString(Bytes::copy_from_slice(value))) } @@ -119,15 +124,17 @@ impl<'a> TryFrom<&'a [u8]> for ByteString { impl TryFrom> for ByteString { type Error = str::Utf8Error; + #[inline] fn try_from(value: Vec) -> Result { - let _ = str::from_utf8(value.as_ref())?; - Ok(ByteString(Bytes::from(value))) + let buf = String::from_utf8(value).map_err(|err| err.utf8_error())?; + Ok(ByteString(Bytes::from(buf))) } } impl TryFrom for ByteString { type Error = str::Utf8Error; + #[inline] fn try_from(value: Bytes) -> Result { let _ = str::from_utf8(value.as_ref())?; Ok(ByteString(value)) @@ -137,8 +144,9 @@ impl TryFrom for ByteString { impl TryFrom for ByteString { type Error = str::Utf8Error; + #[inline] fn try_from(value: bytes::BytesMut) -> Result { - let _ = str::from_utf8(value.as_ref())?; + let _ = str::from_utf8(&value)?; Ok(ByteString(value.freeze())) } } @@ -146,10 +154,20 @@ impl TryFrom for ByteString { macro_rules! array_impls { ($($len:expr)+) => { $( - impl<'a> TryFrom<&'a [u8; $len]> for ByteString { + impl TryFrom<[u8; $len]> for ByteString { type Error = str::Utf8Error; - fn try_from(value: &'a [u8; $len]) -> Result { + #[inline] + fn try_from(value: [u8; $len]) -> Result { + ByteString::try_from(&value[..]) + } + } + + impl TryFrom<&[u8; $len]> for ByteString { + type Error = str::Utf8Error; + + #[inline] + fn try_from(value: &[u8; $len]) -> Result { ByteString::try_from(&value[..]) } } @@ -157,7 +175,7 @@ macro_rules! array_impls { } } -array_impls!(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16); +array_impls!(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32); impl fmt::Debug for ByteString { fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { @@ -173,6 +191,8 @@ impl fmt::Display for ByteString { #[cfg(feature = "serde")] mod serde { + use alloc::string::String; + use serde::de::{Deserialize, Deserializer}; use serde::ser::{Serialize, Serializer}; @@ -201,16 +221,19 @@ mod serde { #[cfg(test)] mod test { + use alloc::borrow::ToOwned; + use core::hash::{Hash, Hasher}; + + use ahash::AHasher; + use super::*; - use std::collections::hash_map::DefaultHasher; - use std::hash::{Hash, Hasher}; #[test] fn test_partial_eq() { let s: ByteString = ByteString::from_static("test"); assert_eq!(s, "test"); assert_eq!(s, *"test"); - assert_eq!(s, "test".to_string()); + assert_eq!(s, "test".to_owned()); } #[test] @@ -220,10 +243,10 @@ mod test { #[test] fn test_hash() { - let mut hasher1 = DefaultHasher::default(); + let mut hasher1 = AHasher::default(); "str".hash(&mut hasher1); - let mut hasher2 = DefaultHasher::default(); + let mut hasher2 = AHasher::default(); let s = ByteString::from_static("str"); s.hash(&mut hasher2); assert_eq!(hasher1.finish(), hasher2.finish()); @@ -231,7 +254,7 @@ mod test { #[test] fn test_from_string() { - let s: ByteString = "hello".to_string().into(); + let s: ByteString = "hello".to_owned().into(); assert_eq!(&s, "hello"); let t: &str = s.as_ref(); assert_eq!(t, "hello"); @@ -249,17 +272,25 @@ mod test { } #[test] - fn test_try_from_rbytes() { + fn test_try_from_slice() { let _ = ByteString::try_from(b"nice bytes").unwrap(); } + #[test] + fn test_try_from_array() { + assert_eq!( + ByteString::try_from([b'h', b'i']).unwrap(), + ByteString::from_static("hi") + ); + } + #[test] fn test_try_from_bytes() { let _ = ByteString::try_from(Bytes::from_static(b"nice bytes")).unwrap(); } #[test] - fn test_try_from_bytesmut() { + fn test_try_from_bytes_mut() { let _ = ByteString::try_from(bytes::BytesMut::from(&b"nice bytes"[..])).unwrap(); } diff --git a/router/LICENSE-APACHE b/router/LICENSE-APACHE deleted file mode 120000 index 965b606f..00000000 --- a/router/LICENSE-APACHE +++ /dev/null @@ -1 +0,0 @@ -../LICENSE-APACHE \ No newline at end of file diff --git a/router/LICENSE-MIT b/router/LICENSE-MIT deleted file mode 120000 index 76219eb7..00000000 --- a/router/LICENSE-MIT +++ /dev/null @@ -1 +0,0 @@ -../LICENSE-MIT \ No newline at end of file diff --git a/string/CHANGES.md b/string/CHANGES.md deleted file mode 100644 index 030c3cd5..00000000 --- a/string/CHANGES.md +++ /dev/null @@ -1,27 +0,0 @@ -# Changes - -## [0.1.5] - 2020-03-30 - -* Serde support - -## [0.1.4] - 2020-01-14 - -* Fix `AsRef` impl - -## [0.1.3] - 2020-01-13 - -* Add `PartialEq>`, `AsRef<[u8]>` impls - -## [0.1.2] - 2019-12-22 - -* Fix `new()` method - -* Make `ByteString::from_static()` and `ByteString::from_bytes_unchecked()` methods const. - -## [0.1.1] - 2019-12-07 - -* Fix hash impl - -## [0.1.0] - 2019-12-07 - -* Initial release diff --git a/string/Cargo.toml b/string/Cargo.toml deleted file mode 100644 index 3653fe58..00000000 --- a/string/Cargo.toml +++ /dev/null @@ -1,22 +0,0 @@ -[package] -name = "bytestring" -version = "0.1.5" -authors = ["Nikolay Kim "] -description = "A UTF-8 encoded string with Bytes as a storage" -keywords = ["actix"] -homepage = "https://actix.rs" -repository = "https://github.com/actix/actix-net.git" -documentation = "https://docs.rs/bytestring/" -license = "MIT OR Apache-2.0" -edition = "2018" - -[lib] -name = "bytestring" -path = "src/lib.rs" - -[dependencies] -bytes = "0.5.3" -serde = { version = "1.0", optional = true } - -[dev-dependencies] -serde_json = "1.0" \ No newline at end of file diff --git a/string/LICENSE-APACHE b/string/LICENSE-APACHE deleted file mode 120000 index 965b606f..00000000 --- a/string/LICENSE-APACHE +++ /dev/null @@ -1 +0,0 @@ -../LICENSE-APACHE \ No newline at end of file diff --git a/string/LICENSE-MIT b/string/LICENSE-MIT deleted file mode 120000 index 76219eb7..00000000 --- a/string/LICENSE-MIT +++ /dev/null @@ -1 +0,0 @@ -../LICENSE-MIT \ No newline at end of file