prepare next set of betas (#273)

Co-authored-by: lishuo <lishuo.03@bytedance.com>

Cargo.toml

@@ -6,7 +6,6 @@ members = [
   "actix-rt",
   "actix-server",
   "actix-service",
-  "actix-threadpool",
   "actix-tls",
   "actix-tracing",
   "actix-utils",
@@ -20,7 +19,6 @@ actix-router = { path = "actix-router" }
 actix-rt = { path = "actix-rt" }
 actix-server = { path = "actix-server" }
 actix-service = { path = "actix-service" }
-actix-threadpool = { path = "actix-threadpool" }
 actix-tls = { path = "actix-tls" }
 actix-tracing = { path = "actix-tracing" }
 actix-utils = { path = "actix-utils" }

actix-codec/Cargo.toml

@@ -6,7 +6,7 @@ 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"

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

actix-macros/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
 name = "actix-macros"
-version = "0.1.3"
+version = "0.2.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix runtime macros"
+description = "Macros for Actix system and runtime"
-repository = "https://github.com/actix/actix-net"
+repository = "https://github.com/actix/actix-net.git"
-documentation = "https://docs.rs/actix-macros/"
+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"

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,10 +15,9 @@
 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
 ///
+/// # Examples
 /// ```
 /// #[actix_rt::main]
 /// async fn main() {
@@ -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")
+        return syn::Error::new_spanned(
-            .to_compile_error()
+            sig.fn_token,
-            .into();
+            "the async keyword is missing from the function declaration",
+        )
+        .to_compile_error()
+        .into();
     }
 
     sig.asyncness = None;
 
-    if cfg!(feature = "actix-reexport") {
+    (quote! {
-        (quote! {
+        #(#attrs)*
-            #(#attrs)*
+        #vis #sig {
-            #vis #sig {
+            actix_rt::System::new()
-                actix::System::new(stringify!(#name))
+                .block_on(async move { #body })
-                    .block_on(async move { #body })
+        }
-            }
+    })
-        })
+    .into()
-        .into()
-    } else {
-        (quote! {
-            #(#attrs)*
-            #vis #sig {
-                actix_rt::System::new(stringify!(#name))
-                    .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
+/// # Examples
-///
+/// ```
-/// ```no_run
 /// #[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 {
+    let missing_test_attr = if has_test_attr {
-        quote! {
+        quote!()
-            #(#attrs)*
-            #vis #sig {
-                actix_rt::System::new("test")
-                    .block_on(async { #body })
-            }
-        }
     } else {
-        quote! {
+        quote!(#[test])
-            #[test]
-            #(#attrs)*
-            #vis #sig {
-                actix_rt::System::new("test")
-                    .block_on(async { #body })
-            }
-        }
     };
 
-    result.into()
+    (quote! {
+        #missing_test_attr
+        #(#attrs)*
+        #vis #sig {
+            actix_rt::System::new()
+                .block_on(async { #body })
+        }
+    })
+    .into()
 }

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");
 }

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() {

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() {}

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() {}

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() {
+  | ^^

actix-router/CHANGES.md

@@ -1,6 +1,9 @@
 # Changes
 
 ## Unreleased - 2021-xx-xx
+* Add `Router::recognize_checked` [#247]
+
+[#247]: https://github.com/actix/actix-net/pull/247
 
 
 ## 0.2.6 - 2021-01-09

actix-router/Cargo.toml

@@ -6,7 +6,7 @@ description = "Resource path matching library"
 keywords = ["actix"]
 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"
 

actix-router/src/path.rs

@@ -50,20 +50,20 @@ impl<T: ResourcePath> Path<T> {
         }
     }
 
-    #[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<T: ResourcePath> Path<T> {
         }
     }
 
-    #[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<T: ResourcePath> Path<T> {
         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()
     }

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,

actix-router/src/router.rs

@@ -45,6 +45,24 @@ impl<T, U> Router<T, U> {
         None
     }
 
+    pub fn recognize_checked<R, P, F>(
+        &self,
+        resource: &mut R,
+        check: F,
+    ) -> Option<(&T, ResourceId)>
+    where
+        F: Fn(&R, &Option<U>) -> bool,
+        R: Resource<P>,
+        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<R, P, F>(
         &mut self,
         resource: &mut R,

actix-rt/CHANGES.md

@@ -1,10 +1,52 @@
 # Changes
 
 ## Unreleased - 2021-xx-xx
+
+
+## 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]

actix-rt/Cargo.toml

@@ -1,12 +1,15 @@
 [package]
 name = "actix-rt"
-version = "2.0.0-beta.1"
+version = "2.0.1"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+authors = [
-description = "Tokio-based single-thread async runtime for the Actix ecosystem"
+    "Nikolay Kim <fafhrd91@gmail.com>",
-keywords = ["network", "framework", "async", "futures"]
+    "Rob Ede <robjtede@icloud.com>",
+]
+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,7 +18,16 @@ edition = "2018"
 name = "actix_rt"
 path = "src/lib.rs"
 
-[dependencies]
+[features]
-actix-macros = "0.1.0"
+default = ["macros"]
+macros = ["actix-macros"]
 
-tokio = { version = "1", features = ["rt", "net", "parking_lot", "signal", "sync", "time"] }
+[dependencies]
+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 = "1.2", features = ["full"] }
+hyper = { version = "0.14", default-features = false, features = ["server", "tcp", "http1"] }

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.

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<Body>) -> Result<Response<Body>, 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);
+        }
+    })
+}

actix-rt/src/arbiter.rs

@@ -1,39 +1,30 @@
-use std::any::{Any, TypeId};
+use std::{
-use std::cell::RefCell;
+    cell::RefCell,
-use std::collections::HashMap;
+    fmt,
-use std::future::Future;
+    future::Future,
-use std::pin::Pin;
+    pin::Pin,
-use std::sync::atomic::{AtomicUsize, Ordering};
+    sync::atomic::{AtomicUsize, Ordering},
-use std::task::{Context, Poll};
+    task::{Context, Poll},
-use std::{fmt, thread};
+    thread,
+};
 
-use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender};
+use futures_core::ready;
-use tokio::sync::oneshot::{channel, error::RecvError as Canceled, Sender};
+use tokio::{sync::mpsc, task::LocalSet};
-// use futures_util::stream::FuturesUnordered;
-// use tokio::task::JoinHandle;
-// use tokio::stream::StreamExt;
-use tokio::task::LocalSet;
 
-use crate::runtime::Runtime;
+use crate::{
-use crate::system::System;
+    runtime::{default_tokio_runtime, Runtime},
-
+    system::{System, SystemCommand},
-thread_local!(
+};
-    static ADDR: RefCell<Option<Arbiter>> = RefCell::new(None);
-    // TODO: Commented out code are for Arbiter::local_join function.
-    // It can be safely removed if this function is not used in actix-*.
-    //
-    // /// stores join handle for spawned async tasks.
-    // static HANDLE: RefCell<FuturesUnordered<JoinHandle<()>>> =
-    //     RefCell::new(FuturesUnordered::new());
-    static STORAGE: RefCell<HashMap<TypeId, Box<dyn Any>>> = RefCell::new(HashMap::new());
-);
 
 pub(crate) static COUNT: AtomicUsize = AtomicUsize::new(0);
 
+thread_local!(
+    static HANDLE: RefCell<Option<ArbiterHandle>> = RefCell::new(None);
+);
+
 pub(crate) enum ArbiterCommand {
     Stop,
-    Execute(Box<dyn Future<Output = ()> + Unpin + Send>),
+    Execute(Pin<Box<dyn Future<Output = ()> + Send>>),
-    ExecuteFn(Box<dyn FnExec>),
 }
 
 impl fmt::Debug for ArbiterCommand {
@@ -41,391 +32,224 @@ 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"),
         }
     }
 }
 
+/// A handle for sending spawn and stop messages to an [Arbiter].
+#[derive(Debug, Clone)]
+pub struct ArbiterHandle {
+    tx: mpsc::UnboundedSender<ArbiterCommand>,
+}
+
+impl ArbiterHandle {
+    pub(crate) fn new(tx: mpsc::UnboundedSender<ArbiterCommand>) -> Self {
+        Self { tx }
+    }
+
+    /// 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<Fut>(&self, future: Fut) -> bool
+    where
+        Fut: Future<Output = ()> + 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<F>(&self, f: F) -> bool
+    where
+        F: FnOnce() + Send + 'static,
+    {
+        self.spawn(async { f() })
+    }
+
+    /// Instruct [Arbiter] to stop processing 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()
+    }
+}
+
+/// 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)]
-/// 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<ArbiterCommand>,
+    tx: mpsc::UnboundedSender<ArbiterCommand>,
-    thread_handle: Option<thread::JoinHandle<()>>,
+    thread_handle: thread::JoinHandle<()>,
-}
-
-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(local: &LocalSet) -> Self {
+    /// Spawn a new Arbiter thread and start its event loop.
-        let (tx, rx) = unbounded_channel();
+    ///
-
+    /// # Panics
-        let arb = Arbiter::with_sender(tx);
+    /// Panics if a [System] is not registered on the current thread.
-        ADDR.with(|cell| *cell.borrow_mut() = Some(arb.clone()));
+    #[allow(clippy::new_without_default)]
-        STORAGE.with(|cell| cell.borrow_mut().clear());
+    pub fn new() -> Arbiter {
-
+        Self::with_tokio_rt(|| {
-        local.spawn_local(ArbiterController { rx });
+            default_tokio_runtime().expect("Cannot create new Arbiter's Runtime.")
-
-        arb
-    }
-
-    /// 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.
+    /// Spawn a new Arbiter using the [Tokio Runtime](tokio-runtime) returned from a closure.
-    #[deprecated(note = "Thread local variables for running state of Arbiter is removed")]
+    ///
-    pub fn is_running() -> bool {
+    /// [tokio-runtime]: tokio::runtime::Runtime
-        false
+    #[doc(hidden)]
-    }
+    pub fn with_tokio_rt<F>(runtime_factory: F) -> Arbiter
-
+    where
-    /// Stop arbiter from continuing it's event loop.
+        F: Fn() -> tokio::runtime::Runtime + Send + 'static,
-    pub fn stop(&self) {
+    {
-        let _ = self.sender.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 (tx, rx) = unbounded_channel();
+        let system_id = sys.id();
+        let arb_id = COUNT.fetch_add(1, Ordering::Relaxed);
 
-        let handle = thread::Builder::new()
+        let name = format!("actix-rt|system:{}|arbiter:{}", system_id, arb_id);
+        let (tx, rx) = mpsc::unbounded_channel();
+
+        let (ready_tx, ready_rx) = std::sync::mpsc::channel::<()>();
+
+        let thread_handle = thread::Builder::new()
             .name(name.clone())
             .spawn({
                 let tx = tx.clone();
                 move || {
-                    let rt = Runtime::new().expect("Can not create Runtime");
+                    let rt = Runtime::from(runtime_factory());
-                    let arb = Arbiter::with_sender(tx);
+                    let hnd = ArbiterHandle::new(tx);
-
-                    STORAGE.with(|cell| cell.borrow_mut().clear());
 
                     System::set_current(sys);
 
-                    ADDR.with(|cell| *cell.borrow_mut() = Some(arb.clone()));
+                    HANDLE.with(|cell| *cell.borrow_mut() = Some(hnd.clone()));
 
                     // register arbiter
                     let _ = System::current()
-                        .sys()
+                        .tx()
-                        .send(SystemCommand::RegisterArbiter(id, arb));
+                        .send(SystemCommand::RegisterArbiter(arb_id, hnd));
 
-                    // start arbiter controller
+                    ready_tx.send(()).unwrap();
-                    // run loop
-                    rt.block_on(ArbiterController { rx });
 
-                    // unregister arbiter
+                    // run arbiter event processing loop
+                    rt.block_on(ArbiterRunner { rx });
+
+                    // deregister arbiter
                     let _ = System::current()
-                        .sys()
+                        .tx()
-                        .send(SystemCommand::UnregisterArbiter(id));
+                        .send(SystemCommand::DeregisterArbiter(arb_id));
                 }
             })
             .unwrap_or_else(|err| {
-                panic!("Cannot spawn an arbiter's thread {:?}: {:?}", &name, err)
+                panic!("Cannot spawn Arbiter's thread: {:?}. {:?}", &name, err)
             });
 
-        Arbiter {
+        ready_rx.recv().unwrap();
-            sender: tx,
+
-            thread_handle: Some(handle),
+        Arbiter { tx, thread_handle }
-        }
     }
 
-    /// Spawn a future on the current thread. This does not create a new Arbiter
+    /// Sets up an Arbiter runner in a new System using the provided runtime local task set.
-    /// or Arbiter address, it is simply a helper for spawning futures on the current
+    pub(crate) fn in_new_system(local: &LocalSet) -> ArbiterHandle {
-    /// thread.
+        let (tx, rx) = mpsc::unbounded_channel();
-    pub fn spawn<F>(future: F)
+
-    where
+        let hnd = ArbiterHandle::new(tx);
-        F: Future<Output = ()> + 'static,
+
-    {
+        HANDLE.with(|cell| *cell.borrow_mut() = Some(hnd.clone()));
-        // HANDLE.with(|handle| {
+
-        //     let handle = handle.borrow();
+        local.spawn_local(ArbiterRunner { rx });
-        //     handle.push(tokio::task::spawn_local(future));
+
-        // });
+        hnd
-        // let _ = tokio::task::spawn_local(CleanupPending);
-        let _ = tokio::task::spawn_local(future);
     }
 
-    /// Executes a future on the current thread. This does not create a new Arbiter
+    /// Return a handle to the current thread's Arbiter's message sender.
-    /// or Arbiter address, it is simply a helper for executing futures on the current
+    ///
-    /// thread.
+    /// # Panics
-    pub fn spawn_fn<F, R>(f: F)
+    /// Panics if no Arbiter is running on the current thread.
-    where
+    pub fn current() -> ArbiterHandle {
-        F: FnOnce() -> R + 'static,
+        HANDLE.with(|cell| match *cell.borrow() {
-        R: Future<Output = ()> + 'static,
+            Some(ref addr) => addr.clone(),
-    {
+            None => panic!("Arbiter is not running."),
-        Arbiter::spawn(async {
-            f();
         })
     }
 
-    /// Send a future to the Arbiter's thread, and spawn it.
+    /// Stop Arbiter from continuing it's event loop.
-    pub fn send<F>(&self, future: F)
+    ///
-    where
+    /// Returns true if stop message was sent successfully and false if the Arbiter has been dropped.
-        F: Future<Output = ()> + Send + Unpin + 'static,
+    pub fn stop(&self) -> bool {
-    {
+        self.tx.send(ArbiterCommand::Stop).is_ok()
-        let _ = self.sender.send(ArbiterCommand::Execute(Box::new(future)));
     }
 
-    /// Send a function to the Arbiter's thread, and execute it. Any result from the function
+    /// Send a future to the Arbiter's thread and spawn it.
-    /// is discarded.
+    ///
-    pub fn exec_fn<F>(&self, f: F)
+    /// 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<Fut>(&self, future: Fut) -> bool
+    where
+        Fut: Future<Output = ()> + 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<F>(&self, f: F) -> bool
     where
         F: FnOnce() + Send + 'static,
     {
-        let _ = self
+        self.spawn(async { f() })
-            .sender
-            .send(ArbiterCommand::ExecuteFn(Box::new(move || {
-                f();
-            })));
     }
 
-    /// Send a function to the Arbiter's thread. This function will be executed asynchronously.
+    /// Wait for Arbiter's event loop to complete.
-    /// A future is created, and when resolved will contain the result of the function sent
-    /// to the Arbiters thread.
-    pub fn exec<F, R>(&self, f: F) -> impl Future<Output = Result<R, Canceled>>
-    where
-        F: FnOnce() -> R + Send + 'static,
-        R: Send + 'static,
-    {
-        let (tx, rx) = channel();
-        let _ = self
-            .sender
-            .send(ArbiterCommand::ExecuteFn(Box::new(move || {
-                if !tx.is_closed() {
-                    let _ = tx.send(f());
-                }
-            })));
-        rx
-    }
-
-    /// Set item to arbiter storage
-    pub fn set_item<T: 'static>(item: T) {
-        STORAGE.with(move |cell| cell.borrow_mut().insert(TypeId::of::<T>(), Box::new(item)));
-    }
-
-    /// Check if arbiter storage contains item
-    pub fn contains_item<T: 'static>() -> bool {
-        STORAGE.with(move |cell| cell.borrow().get(&TypeId::of::<T>()).is_some())
-    }
-
-    /// Get a reference to a type previously inserted on this arbiter's storage.
     ///
-    /// Panics is item is not inserted
+    /// Joins the underlying OS thread handle. See [`JoinHandle::join`](thread::JoinHandle::join).
-    pub fn get_item<T: 'static, F, R>(mut f: F) -> R
+    pub fn join(self) -> thread::Result<()> {
-    where
+        self.thread_handle.join()
-        F: FnMut(&T) -> R,
-    {
-        STORAGE.with(move |cell| {
-            let st = cell.borrow();
-            let item = st
-                .get(&TypeId::of::<T>())
-                .and_then(|boxed| (&**boxed as &(dyn Any + 'static)).downcast_ref())
-                .unwrap();
-            f(item)
-        })
-    }
-
-    /// Get a mutable reference to a type previously inserted on this arbiter's storage.
-    ///
-    /// Panics is item is not inserted
-    pub fn get_mut_item<T: 'static, F, R>(mut f: F) -> R
-    where
-        F: FnMut(&mut T) -> R,
-    {
-        STORAGE.with(move |cell| {
-            let mut st = cell.borrow_mut();
-            let item = st
-                .get_mut(&TypeId::of::<T>())
-                .and_then(|boxed| (&mut **boxed as &mut (dyn Any + 'static)).downcast_mut())
-                .unwrap();
-            f(item)
-        })
-    }
-
-    fn with_sender(sender: UnboundedSender<ArbiterCommand>) -> Self {
-        Self {
-            sender,
-            thread_handle: None,
-        }
-    }
-
-    /// 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(())
-        }
-    }
-
-    /// Returns a future that will be completed once all currently spawned futures
-    /// have completed.
-    #[deprecated(since = "1.2.0", note = "Arbiter::local_join function is removed.")]
-    pub async fn local_join() {
-        // let handle = HANDLE.with(|fut| std::mem::take(&mut *fut.borrow_mut()));
-        // async move {
-        //     handle.collect::<Vec<_>>().await;
-        // }
-        unimplemented!("Arbiter::local_join function is removed.")
     }
 }
 
-// /// Future used for cleaning-up already finished `JoinHandle`s
+/// A persistent future that processes [Arbiter] commands.
-// /// from the `PENDING` list so the vector doesn't grow indefinitely
+struct ArbiterRunner {
-// struct CleanupPending;
+    rx: mpsc::UnboundedReceiver<ArbiterCommand>,
-//
-// impl Future for CleanupPending {
-//     type Output = ();
-//
-//     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-//         HANDLE.with(move |handle| {
-//             recycle_join_handle(&mut *handle.borrow_mut(), cx);
-//         });
-//
-//         Poll::Ready(())
-//     }
-// }
-
-struct ArbiterController {
-    rx: UnboundedReceiver<ArbiterCommand>,
 }
 
-impl Drop for ArbiterController {
+impl Future for ArbiterRunner {
-    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 {
     type Output = ();
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        // process all items currently buffered in channel
         loop {
-            match Pin::new(&mut self.rx).poll_recv(cx) {
+            match ready!(Pin::new(&mut self.rx).poll_recv(cx)) {
-                Poll::Ready(None) => return Poll::Ready(()),
+                // channel closed; no more messages can be received
-                Poll::Ready(Some(item)) => match item {
+                None => return Poll::Ready(()),
-                    ArbiterCommand::Stop => return Poll::Ready(()),
+
-                    ArbiterCommand::Execute(fut) => {
+                // process arbiter command
-                        // HANDLE.with(|handle| {
+                Some(item) => match item {
-                        //     let mut handle = handle.borrow_mut();
+                    ArbiterCommand::Stop => {
-                        //     handle.push(tokio::task::spawn_local(fut));
+                        return Poll::Ready(());
-                        //     recycle_join_handle(&mut *handle, cx);
-                        // });
-                        tokio::task::spawn_local(fut);
                     }
-                    ArbiterCommand::ExecuteFn(f) => {
+                    ArbiterCommand::Execute(task_fut) => {
-                        f.call_box();
+                        tokio::task::spawn_local(task_fut);
                     }
                 },
-                Poll::Pending => return Poll::Pending,
             }
         }
     }
 }
-
-// fn recycle_join_handle(handle: &mut FuturesUnordered<JoinHandle<()>>, cx: &mut Context<'_>) {
-//     let _ = Pin::new(&mut *handle).poll_next(cx);
-//
-//     // Try to recycle more join handles and free up memory.
-//     //
-//     // this is a guess. The yield limit for FuturesUnordered is 32.
-//     // So poll an extra 3 times would make the total poll below 128.
-//     if handle.len() > 64 {
-//         (0..3).for_each(|_| {
-//             let _ = Pin::new(&mut *handle).poll_next(cx);
-//         })
-//     }
-// }
-
-#[derive(Debug)]
-pub(crate) enum SystemCommand {
-    Exit(i32),
-    RegisterArbiter(usize, Arbiter),
-    UnregisterArbiter(usize),
-}
-
-#[derive(Debug)]
-pub(crate) struct SystemArbiter {
-    stop: Option<Sender<i32>>,
-    commands: UnboundedReceiver<SystemCommand>,
-    arbiters: HashMap<usize, Arbiter>,
-}
-
-impl SystemArbiter {
-    pub(crate) fn new(stop: Sender<i32>, commands: UnboundedReceiver<SystemCommand>) -> 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<Self::Output> {
-        loop {
-            match Pin::new(&mut self.commands).poll_recv(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<Self>);
-}
-
-impl<F> FnExec for F
-where
-    F: FnOnce() + Send + 'static,
-{
-    #[allow(clippy::boxed_local)]
-    fn call_box(self: Box<Self>) {
-        (*self)()
-    }
-}

actix-rt/src/builder.rs

@@ -1,183 +0,0 @@
-use std::borrow::Cow;
-use std::future::Future;
-use std::io;
-
-use tokio::sync::mpsc::unbounded_channel;
-use tokio::sync::oneshot::{channel, Receiver};
-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<T: Into<String>>(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<F>(self, f: F) -> io::Result<()>
-    where
-        F: FnOnce(),
-    {
-        self.create_runtime(f).run()
-    }
-
-    fn create_async_runtime(self, local: &LocalSet) -> AsyncSystemRunner {
-        let (stop_tx, stop) = channel();
-        let (sys_sender, sys_receiver) = unbounded_channel();
-
-        let system =
-            System::construct(sys_sender, Arbiter::new_system(local), 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<F>(self, f: F) -> SystemRunner
-    where
-        F: FnOnce(),
-    {
-        let (stop_tx, stop) = channel();
-        let (sys_sender, sys_receiver) = unbounded_channel();
-
-        let rt = Runtime::new().unwrap();
-
-        let system = System::construct(
-            sys_sender,
-            Arbiter::new_system(rt.local()),
-            self.stop_on_panic,
-        );
-
-        // system arbiter
-        let arb = SystemArbiter::new(stop_tx, sys_receiver);
-
-        rt.spawn(arb);
-
-        // init system arbiter and run configuration method
-        rt.block_on(async { f() });
-
-        SystemRunner { rt, stop, system }
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct AsyncSystemRunner {
-    stop: Receiver<i32>,
-    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<Output = Result<(), io::Error>> + Send {
-        let AsyncSystemRunner { stop, .. } = self;
-
-        // run loop
-        async {
-            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)),
-            }
-        }
-    }
-}
-
-/// Helper object that runs System's event loop
-#[must_use = "SystemRunner must be run"]
-#[derive(Debug)]
-pub struct SystemRunner {
-    rt: Runtime,
-    stop: Receiver<i32>,
-    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 { rt, stop, .. } = self;
-
-        // run loop
-        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)),
-        }
-    }
-
-    /// Execute a future and wait for result.
-    #[inline]
-    pub fn block_on<F: Future>(&self, fut: F) -> F::Output {
-        self.rt.block_on(fut)
-    }
-}

actix-rt/src/lib.rs

@@ -1,70 +1,107 @@
-//! Tokio-based single-thread async runtime for the Actix ecosystem.
+//! 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::<u32>();
+//!
+//! 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")]
 
 use std::future::Future;
 
-#[cfg(not(test))] // Work around for rust-lang/rust#62127
+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::arbiter::{Arbiter, ArbiterHandle};
-pub use self::builder::{Builder, SystemRunner};
 pub use self::runtime::Runtime;
-pub use self::system::System;
+pub use self::system::{System, SystemRunner};
 
-/// Spawns a future on the current arbiter.
+pub use tokio::pin;
-///
-/// # Panics
-///
-/// This function panics if actix system is not running.
-#[inline]
-pub fn spawn<F>(f: F)
-where
-    F: Future<Output = ()> + 'static,
-{
-    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};
-        pub use tokio::net::{UnixDatagram, UnixListener, UnixStream};
-    }
-
-    #[cfg(unix)]
-    pub use self::unix::*;
 }
 
-/// Utilities for tracking time.
 pub mod time {
+    //! Utilities for tracking time (Tokio re-exports).
+
     pub use tokio::time::Instant;
     pub use tokio::time::{interval, interval_at, Interval};
     pub use tokio::time::{sleep, sleep_until, Sleep};
     pub use tokio::time::{timeout, Timeout};
 }
 
-/// task management.
 pub mod task {
-    pub use tokio::task::{spawn_blocking, yield_now, JoinHandle};
+    //! 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<Fut>(f: Fut) -> JoinHandle<()>
+where
+    Fut: Future<Output = ()> + 'static,
+{
+    tokio::task::spawn_local(f)
 }

actix-rt/src/runtime.rs

@@ -1,27 +1,29 @@
-use std::future::Future;
+use std::{future::Future, io};
-use std::io;
-use tokio::{runtime, task::LocalSet};
 
-/// Single-threaded runtime provides a way to start reactor
+use tokio::task::{JoinHandle, LocalSet};
-/// and runtime on the current thread.
+
+/// A Tokio-based runtime proxy.
 ///
-/// See [module level][mod] documentation for more details.
+/// All spawned futures will be executed on the current thread. Therefore, there is no `Send` bound
-///
+/// on submitted futures.
-/// [mod]: crate
 #[derive(Debug)]
 pub struct Runtime {
     local: LocalSet,
-    rt: runtime::Runtime,
+    rt: tokio::runtime::Runtime,
+}
+
+pub(crate) fn default_tokio_runtime() -> io::Result<tokio::runtime::Runtime> {
+    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<Runtime> {
+    #[allow(clippy::new_ret_no_self)]
-        let rt = runtime::Builder::new_current_thread()
+    pub fn new() -> io::Result<Self> {
-            .enable_io()
+        let rt = default_tokio_runtime()?;
-            .enable_time()
-            .build()?;
 
         Ok(Runtime {
             rt,
@@ -29,62 +31,53 @@ impl Runtime {
         })
     }
 
-    pub(super) fn local(&self) -> &LocalSet {
+    /// Reference to local task set.
+    pub(crate) fn local_set(&self) -> &LocalSet {
         &self.local
     }
 
-    /// Spawn a future onto the single-threaded runtime.
+    /// 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
-    ///
+    /// ```
-    /// ```ignore
+    /// let rt = actix_rt::Runtime::new().unwrap();
-    /// # use futures::{future, Future, Stream};
-    /// use actix_rt::Runtime;
-    ///
-    /// # fn dox() {
-    /// // Create the runtime
-    /// let rt = Runtime::new().unwrap();
     ///
     /// // Spawn a future onto the runtime
-    /// rt.spawn(future::lazy(|_| {
+    /// let handle = rt.spawn(async {
     ///     println!("running on the runtime");
-    /// }));
+    ///     42
-    /// # }
+    /// });
-    /// # pub fn main() {}
+    ///
+    /// assert_eq!(rt.block_on(handle).unwrap(), 42);
     /// ```
     ///
     /// # Panics
-    ///
+    /// This function panics if the spawn fails. Failure occurs if the executor is currently at
-    /// This function panics if the spawn fails. Failure occurs if the executor
+    /// capacity and is unable to spawn a new future.
-    /// is currently at capacity and is unable to spawn a new future.
+    pub fn spawn<F>(&self, future: F) -> JoinHandle<F::Output>
-    pub fn spawn<F>(&self, future: F) -> &Self
     where
-        F: Future<Output = ()> + 'static,
+        F: Future + 'static,
     {
-        self.local.spawn_local(future);
+        self.local.spawn_local(future)
-        self
     }
 
-    /// Runs the provided future, blocking the current thread until the future
+    /// Runs the provided future, blocking the current thread until the future completes.
-    /// completes.
     ///
-    /// This function can be used to synchronously block the current thread
+    /// This function can be used to synchronously block the current thread until the provided
-    /// until the provided `future` has resolved either successfully or with an
+    /// `future` has resolved either successfully or with an error. The result of the future is
-    /// error. The result of the future is then returned from this function
+    /// then returned from this function call.
-    /// call.
     ///
-    /// Note that this function will **also** execute any spawned futures on the
+    /// Note that this function will also execute any spawned futures on the current thread, but
-    /// current thread, but will **not** block until these other spawned futures
+    /// will not block until these other spawned futures have completed. Once the function returns,
-    /// have completed. Once the function returns, any uncompleted futures
+    /// any uncompleted futures remain pending in the `Runtime` instance. These futures will not run
-    /// 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
+    /// The caller is responsible for ensuring that other spawned futures complete execution by
-    /// complete execution by calling `block_on` or `run`.
+    /// calling `block_on` or `run`.
     pub fn block_on<F>(&self, f: F) -> F::Output
     where
         F: Future,
@@ -92,3 +85,12 @@ impl Runtime {
         self.local.block_on(&self.rt, f)
     }
 }
+
+impl From<tokio::runtime::Runtime> for Runtime {
+    fn from(rt: tokio::runtime::Runtime) -> Self {
+        Self {
+            local: LocalSet::new(),
+            rt,
+        }
+    }
+}

actix-rt/src/system.rs

@@ -1,193 +1,98 @@
-use std::cell::RefCell;
+use std::{
-use std::future::Future;
+    cell::RefCell,
-use std::io;
+    collections::HashMap,
-use std::sync::atomic::{AtomicUsize, Ordering};
+    future::Future,
+    io,
+    pin::Pin,
+    sync::atomic::{AtomicUsize, Ordering},
+    task::{Context, Poll},
+};
 
-use tokio::sync::mpsc::UnboundedSender;
+use futures_core::ready;
-use tokio::task::LocalSet;
+use tokio::sync::{mpsc, oneshot};
 
-use crate::arbiter::{Arbiter, SystemCommand};
+use crate::{arbiter::ArbiterHandle, runtime::default_tokio_runtime, Arbiter, Runtime};
-use crate::builder::{Builder, SystemRunner};
 
 static SYSTEM_COUNT: AtomicUsize = AtomicUsize::new(0);
 
-/// System is a runtime manager.
-#[derive(Clone, Debug)]
-pub struct System {
-    id: usize,
-    sys: UnboundedSender<SystemCommand>,
-    arbiter: Arbiter,
-    stop_on_panic: bool,
-}
-
 thread_local!(
     static CURRENT: RefCell<Option<System>> = RefCell::new(None);
 );
 
+/// A manager for a per-thread distributed async runtime.
+#[derive(Clone, Debug)]
+pub struct System {
+    id: usize,
+    sys_tx: mpsc::UnboundedSender<SystemCommand>,
+
+    /// 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<F>(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<SystemCommand>,
+        sys_tx: mpsc::UnboundedSender<SystemCommand>,
-        arbiter: Arbiter,
+        arbiter_handle: ArbiterHandle,
-        stop_on_panic: bool,
     ) -> Self {
         let sys = System {
-            sys,
+            sys_tx,
-            arbiter,
+            arbiter_handle,
-            stop_on_panic,
             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<T: Into<String>>(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
-    ///
-    /// ```ignore
-    /// 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 runtime = tokio::runtime::Builder::new_multi_thread()
-    ///     .worker_threads(2)
-    ///     .enable_all()
-    ///     .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<T: Into<String>>(
-        name: T,
-        local: &LocalSet,
-    ) -> impl Future<Output = io::Result<()>> {
-        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
-    ///
-    /// ```ignore
-    /// 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_multi_thread()
-    ///     .worker_threads(2)
-    ///     .enable_all()
-    ///     .build()
-    ///     .unwrap();
-    ///
-    /// let rest_operations = run_application();
-    /// System::attach_to_tokio("actix-main-system", runtime, rest_operations);
-    /// ```
-    pub fn attach_to_tokio<Fut, R>(
-        name: impl Into<String>,
-        runtime: tokio::runtime::Runtime,
-        rest_operations: Fut,
-    ) -> R
-    where
-        Fut: std::future::Future<Output = R>,
-    {
-        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(),
@@ -195,67 +100,147 @@ impl System {
         })
     }
 
-    /// Check if current system is set, i.e., as already been started.
+    /// Get handle to a the System's initial [Arbiter].
-    pub fn is_set() -> bool {
+    pub fn arbiter(&self) -> &ArbiterHandle {
-        CURRENT.with(|cell| cell.borrow().is_some())
+        &self.arbiter_handle
     }
 
-    /// Set current running system.
+    /// 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| {
+        CURRENT.with(|cell| {
-            *s.borrow_mut() = Some(sys);
+            *cell.borrow_mut() = Some(sys);
         })
     }
 
-    /// Execute function with system reference.
+    /// Numeric system identifier.
-    pub fn with_current<F, R>(f: F) -> R
+    ///
-    where
+    /// Useful when using multiple Systems.
-        F: FnOnce(&System) -> R,
-    {
-        CURRENT.with(|cell| match *cell.borrow() {
-            Some(ref sys) => f(sys),
-            None => panic!("System is not running"),
-        })
-    }
-
-    /// System id
     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.send(SystemCommand::Exit(code));
+        let _ = self.sys_tx.send(SystemCommand::Exit(code));
     }
 
-    pub(crate) fn sys(&self) -> &UnboundedSender<SystemCommand> {
+    pub(crate) fn tx(&self) -> &mpsc::UnboundedSender<SystemCommand> {
-        &self.sys
+        &self.sys_tx
-    }
+    }
-
+}
-    /// Return status of 'stop_on_panic' option which controls whether the System is stopped when an
+
-    /// uncaught panic is thrown from a worker thread.
+/// Runner that keeps a [System]'s event loop alive until stop message is received.
-    pub fn stop_on_panic(&self) -> bool {
+#[must_use = "A SystemRunner does nothing unless `run` is called."]
-        self.stop_on_panic
+#[derive(Debug)]
-    }
+pub struct SystemRunner {
-
+    rt: Runtime,
-    /// System arbiter
+    stop_rx: oneshot::Receiver<i32>,
-    pub fn arbiter(&self) -> &Arbiter {
+    system: System,
-        &self.arbiter
+}
-    }
+
-
+impl SystemRunner {
-    /// This function will start tokio runtime and will finish once the
+    /// Starts event loop and will return once [System] is [stopped](System::stop).
-    /// `System::stop()` message get called.
+    pub fn run(self) -> io::Result<()> {
-    /// Function `f` get called within tokio runtime context.
+        let SystemRunner { rt, stop_rx, .. } = self;
-    pub fn run<F>(f: F) -> io::Result<()>
+
-    where
+        // run loop
-        F: FnOnce(),
+        match rt.block_on(stop_rx) {
-    {
+            Ok(code) => {
-        Self::builder().run(f)
+                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<F: Future>(&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<oneshot::Sender<i32>>,
+    cmd_rx: mpsc::UnboundedReceiver<SystemCommand>,
+    arbiters: HashMap<usize, ArbiterHandle>,
+}
+
+impl SystemController {
+    pub(crate) fn new(
+        cmd_rx: mpsc::UnboundedReceiver<SystemCommand>,
+        stop_tx: oneshot::Sender<i32>,
+    ) -> 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<Self::Output> {
+        // 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);
+                    }
+                },
+            }
+        }
     }
 }

actix-rt/tests/integration_tests.rs

@@ -1,126 +0,0 @@
-use std::time::{Duration, Instant};
-
-#[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::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(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::sleep(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::sleep(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::sleep(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"
-//     );
-// }
-
-#[test]
-fn non_static_block_on() {
-    let string = String::from("test_str");
-    let str = string.as_str();
-
-    let sys = actix_rt::System::new("borrow some");
-
-    sys.block_on(async {
-        actix_rt::time::sleep(Duration::from_millis(1)).await;
-        assert_eq!("test_str", str);
-    });
-
-    let rt = actix_rt::Runtime::new().unwrap();
-
-    rt.block_on(async {
-        actix_rt::time::sleep(Duration::from_millis(1)).await;
-        assert_eq!("test_str", str);
-    });
-
-    actix_rt::System::run(|| {
-        assert_eq!("test_str", str);
-        actix_rt::System::current().stop();
-    })
-    .unwrap();
-}

actix-rt/tests/tests.rs

@@ -0,0 +1,268 @@
+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::<u32>();
+
+    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_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));
+}

actix-server/CHANGES.md

@@ -1,9 +1,18 @@
 # Changes
 
 ## 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

actix-server/Cargo.toml

@@ -9,7 +9,7 @@ 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"]
@@ -24,11 +24,11 @@ default = []
 
 [dependencies]
 actix-codec = "0.4.0-beta.1"
-actix-rt = "2.0.0-beta.1"
+actix-rt = { version = "2.0.0", default-features = false }
-actix-service = "2.0.0-beta.2"
+actix-service = "2.0.0-beta.4"
-actix-utils = "3.0.0-beta.1"
+actix-utils = "3.0.0-beta.2"
 
-futures-core = { version = "0.3.7", default-features = false }
+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"
@@ -36,6 +36,7 @@ slab = "0.4"
 tokio = { version = "1", features = ["sync"] }
 
 [dev-dependencies]
+actix-rt = "2.0.0"
 bytes = "1"
 env_logger = "0.8"
 futures-util = { version = "0.3.7", default-features = false, features = ["sink"] }

actix-server/src/accept.rs

@@ -1,8 +1,10 @@
 use std::time::Duration;
 use std::{io, thread};
 
-use actix_rt::time::{sleep_until, Instant};
+use actix_rt::{
-use actix_rt::System;
+    time::{sleep_until, Instant},
+    System,
+};
 use log::{error, info};
 use mio::{Interest, Poll, Token as MioToken};
 use slab::Slab;
@@ -159,9 +161,16 @@ impl Accept {
         let mut events = mio::Events::with_capacity(128);
 
         loop {
-            self.poll
+            if let Err(e) = self.poll.poll(&mut events, None) {
-                .poll(&mut events, None)
+                match e.kind() {
-                .unwrap_or_else(|e| panic!("Poll error: {}", e));
+                    std::io::ErrorKind::Interrupted => {
+                        continue;
+                    }
+                    _ => {
+                        panic!("Poll error: {}", e);
+                    }
+                }
+            }
 
             for event in events.iter() {
                 let token = event.token();
@@ -401,10 +410,11 @@ impl Accept {
 
                         // after the sleep a Timer interest is sent to Accept Poll
                         let waker = self.waker.clone();
-                        System::current().arbiter().send(Box::pin(async move {
+                        System::current().arbiter().spawn(async move {
                             sleep_until(Instant::now() + Duration::from_millis(510)).await;
                             waker.wake(WakerInterest::Timer);
-                        }));
+                        });
+
                         return;
                     }
                 }

actix-server/src/builder.rs

@@ -6,7 +6,7 @@ use std::{io, mem};
 
 use actix_rt::net::TcpStream;
 use actix_rt::time::{sleep_until, Instant};
-use actix_rt::{spawn, System};
+use actix_rt::{self as rt, System};
 use log::{error, info};
 use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver};
 use tokio::sync::oneshot;
@@ -19,7 +19,7 @@ use crate::signals::{Signal, Signals};
 use crate::socket::{MioListener, StdSocketAddr, StdTcpListener, ToSocketAddrs};
 use crate::socket::{MioTcpListener, MioTcpSocket};
 use crate::waker_queue::{WakerInterest, WakerQueue};
-use crate::worker::{self, Worker, WorkerAvailability, WorkerHandle};
+use crate::worker::{self, ServerWorker, ServerWorkerConfig, WorkerAvailability, WorkerHandle};
 use crate::{join_all, Token};
 
 /// Server builder
@@ -32,11 +32,11 @@ pub struct ServerBuilder {
     sockets: Vec<(Token, String, MioListener)>,
     accept: AcceptLoop,
     exit: bool,
-    shutdown_timeout: Duration,
     no_signals: bool,
     cmd: UnboundedReceiver<ServerCommand>,
     server: Server,
     notify: Vec<oneshot::Sender<()>>,
+    worker_config: ServerWorkerConfig,
 }
 
 impl Default for ServerBuilder {
@@ -60,11 +60,11 @@ impl ServerBuilder {
             accept: AcceptLoop::new(server.clone()),
             backlog: 2048,
             exit: false,
-            shutdown_timeout: Duration::from_secs(30),
             no_signals: false,
             cmd: rx,
             notify: Vec::new(),
             server,
+            worker_config: ServerWorkerConfig::default(),
         }
     }
 
@@ -78,6 +78,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.
@@ -124,7 +142,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
     }
 
@@ -177,8 +196,8 @@ impl ServerBuilder {
         Ok(self)
     }
 
-    #[cfg(unix)]
     /// Add new unix domain service to the server.
+    #[cfg(unix)]
     pub fn bind_uds<F, U, N>(self, name: N, addr: U, factory: F) -> io::Result<Self>
     where
         F: ServiceFactory<actix_rt::net::UnixStream>,
@@ -198,10 +217,10 @@ impl ServerBuilder {
         self.listen_uds(name, lst, factory)
     }
 
-    #[cfg(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<F, N: AsRef<str>>(
         mut self,
         name: N,
@@ -288,7 +307,7 @@ impl ServerBuilder {
 
             // start http server actor
             let server = self.server.clone();
-            spawn(self);
+            rt::spawn(self);
             server
         }
     }
@@ -297,7 +316,7 @@ impl ServerBuilder {
         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) {
@@ -364,7 +383,7 @@ impl ServerBuilder {
 
                     let fut = join_all(iter);
 
-                    spawn(async move {
+                    rt::spawn(async move {
                         let _ = fut.await;
                         if let Some(tx) = completion {
                             let _ = tx.send(());
@@ -373,16 +392,16 @@ impl ServerBuilder {
                             let _ = tx.send(());
                         }
                         if exit {
-                            spawn(async {
+                            rt::spawn(async {
                                 sleep_until(Instant::now() + Duration::from_millis(300)).await;
                                 System::current().stop();
                             });
                         }
-                    })
+                    });
                 } else {
                     // we need to stop system if server was spawned
                     if self.exit {
-                        spawn(async {
+                        rt::spawn(async {
                             sleep_until(Instant::now() + Duration::from_millis(300)).await;
                             System::current().stop();
                         });

actix-server/src/service.rs

@@ -58,11 +58,11 @@ where
     type Error = ();
     type Future = Ready<Result<(), ()>>;
 
-    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         self.service.poll_ready(ctx).map_err(|_| ())
     }
 
-    fn call(&mut self, (guard, req): (Option<CounterGuard>, MioStream)) -> Self::Future {
+    fn call(&self, (guard, req): (Option<CounterGuard>, MioStream)) -> Self::Future {
         ready(match FromStream::from_mio(req) {
             Ok(stream) => {
                 let f = self.service.call(stream);

actix-server/src/signals.rs

@@ -2,8 +2,6 @@ use std::future::Future;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
-use futures_core::future::LocalBoxFuture;
-
 use crate::server::Server;
 
 /// Different types of process signals
@@ -23,9 +21,9 @@ pub(crate) enum Signal {
 pub(crate) struct Signals {
     srv: Server,
     #[cfg(not(unix))]
-    signals: LocalBoxFuture<'static, std::io::Result<()>>,
+    signals: futures_core::future::LocalBoxFuture<'static, std::io::Result<()>>,
     #[cfg(unix)]
-    signals: Vec<(Signal, LocalBoxFuture<'static, ()>)>,
+    signals: Vec<(Signal, actix_rt::signal::unix::Signal)>,
 }
 
 impl Signals {
@@ -48,23 +46,21 @@ impl Signals {
                 (unix::SignalKind::quit(), Signal::Quit),
             ];
 
-            let mut signals = Vec::new();
+            let signals = sig_map
-
+                .iter()
-            for (kind, sig) in sig_map.iter() {
+                .filter_map(|(kind, sig)| {
-                match unix::signal(*kind) {
+                    unix::signal(*kind)
-                    Ok(mut stream) => {
+                        .map(|tokio_sig| (*sig, tokio_sig))
-                        let fut = Box::pin(async move {
+                        .map_err(|e| {
-                            let _ = stream.recv().await;
+                            log::error!(
-                        }) as _;
+                                "Can not initialize stream handler for {:?} err: {}",
-                        signals.push((*sig, fut));
+                                sig,
-                    }
+                                e
-                    Err(e) => log::error!(
+                            )
-                        "Can not initialize stream handler for {:?} err: {}",
+                        })
-                        sig,
+                        .ok()
-                        e
+                })
-                    ),
+                .collect::<Vec<_>>();
-                }
-            }
 
             actix_rt::spawn(Signals { srv, signals });
         }
@@ -86,7 +82,7 @@ impl Future for Signals {
         #[cfg(unix)]
         {
             for (sig, fut) in self.signals.iter_mut() {
-                if fut.as_mut().poll(cx).is_ready() {
+                if Pin::new(fut).poll_recv(cx).is_ready() {
                     let sig = *sig;
                     self.srv.signal(sig);
                     return Poll::Ready(());

actix-server/src/test_server.rs

@@ -48,7 +48,7 @@ impl TestServer {
 
         // run server in separate thread
         thread::spawn(move || {
-            let sys = System::new("actix-test-server");
+            let sys = System::new();
             factory(Server::build()).workers(1).disable_signals().run();
 
             tx.send(System::current()).unwrap();
@@ -70,7 +70,7 @@ 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();
 

actix-server/src/worker.rs

@@ -122,11 +122,10 @@ impl WorkerAvailability {
     }
 }
 
-/// Service worker
+/// Service worker.
 ///
-/// Worker accepts Socket objects via unbounded channel and starts stream
+/// Worker accepts Socket objects via unbounded channel and starts stream processing.
-/// processing.
+pub(crate) struct ServerWorker {
-pub(crate) struct Worker {
     rx: UnboundedReceiver<WorkerCommand>,
     rx2: UnboundedReceiver<StopCommand>,
     services: Vec<WorkerService>,
@@ -134,7 +133,7 @@ pub(crate) struct Worker {
     conns: Counter,
     factories: Vec<Box<dyn InternalServiceFactory>>,
     state: WorkerState,
-    shutdown_timeout: Duration,
+    config: ServerWorkerConfig,
 }
 
 struct WorkerService {
@@ -160,26 +159,62 @@ 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<Box<dyn InternalServiceFactory>>,
         availability: WorkerAvailability,
-        shutdown_timeout: Duration,
+        config: ServerWorkerConfig,
     ) -> WorkerHandle {
         let (tx1, rx) = unbounded_channel();
         let (tx2, rx2) = unbounded_channel();
         let avail = availability.clone();
 
         // every worker runs in it's own arbiter.
-        Arbiter::new().send(Box::pin(async move {
+        // 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| Worker {
+            let mut wrk = MAX_CONNS_COUNTER.with(move |conns| ServerWorker {
                 rx,
                 rx2,
                 availability,
                 factories,
-                shutdown_timeout,
+                config,
                 services: Vec::new(),
                 conns: conns.clone(),
                 state: WorkerState::Unavailable,
@@ -199,6 +234,8 @@ impl Worker {
                 })
                 .collect::<Vec<_>>();
 
+            // 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<Vec<_>, _> = join_all(fut).await.into_iter().collect();
                 match res {
@@ -221,7 +258,7 @@ impl Worker {
                 }
                 wrk.await
             });
-        }));
+        });
 
         WorkerHandle::new(idx, tx1, tx2, avail)
     }
@@ -304,7 +341,7 @@ enum WorkerState {
     ),
 }
 
-impl Future for Worker {
+impl Future for ServerWorker {
     type Output = ();
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
@@ -325,7 +362,7 @@ impl Future for Worker {
                     info!("Graceful worker shutdown, {} connections", num);
                     self.state = WorkerState::Shutdown(
                         Box::pin(sleep_until(Instant::now() + Duration::from_secs(1))),
-                        Box::pin(sleep_until(Instant::now() + self.shutdown_timeout)),
+                        Box::pin(sleep_until(Instant::now() + self.config.shutdown_timeout)),
                         Some(result),
                     );
                 } else {

actix-server/tests/test_server.rs

@@ -21,7 +21,7 @@ fn test_bind() {
     let (tx, rx) = mpsc::channel();
 
     let h = thread::spawn(move || {
-        let sys = actix_rt::System::new("test");
+        let sys = actix_rt::System::new();
         let srv = sys.block_on(lazy(|_| {
             Server::build()
                 .workers(1)
@@ -47,7 +47,7 @@ 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();
         sys.block_on(async {
             Server::build()
@@ -81,7 +81,7 @@ fn test_start() {
     let (tx, rx) = mpsc::channel();
 
     let h = thread::spawn(move || {
-        let sys = actix_rt::System::new("test");
+        let sys = actix_rt::System::new();
         let srv = sys.block_on(lazy(|_| {
             Server::build()
                 .backlog(100)
@@ -150,7 +150,7 @@ fn test_configure() {
 
     let h = thread::spawn(move || {
         let num = num2.clone();
-        let sys = actix_rt::System::new("test");
+        let sys = actix_rt::System::new();
         let srv = sys.block_on(lazy(|_| {
             Server::build()
                 .disable_signals()

actix-service/CHANGES.md

@@ -3,6 +3,15 @@
 ## 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]
 

actix-service/Cargo.toml

@@ -1,9 +1,10 @@
 [package]
 name = "actix-service"
-version = "2.0.0-beta.3"
+version = "2.0.0-beta.4"
 authors = [
     "Nikolay Kim <fafhrd91@gmail.com>",
     "Rob Ede <robjtede@icloud.com>",
+    "fakeshadow <24548779@qq.com>",
 ]
 description = "Service trait and combinators for representing asynchronous request/response operations."
 keywords = ["network", "framework", "async", "futures", "service"]
@@ -24,5 +25,5 @@ futures-core = { version = "0.3.7", default-features = false }
 pin-project-lite = "0.2"
 
 [dev-dependencies]
-actix-rt = "1.0.0"
+actix-rt = "2.0.0"
 futures-util = { version = "0.3.7", default-features = false }

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.

actix-service/src/and_then.rs

@@ -1,12 +1,12 @@
 use alloc::rc::Rc;
 use core::{
-    cell::RefCell,
     future::Future,
     marker::PhantomData,
     pin::Pin,
     task::{Context, Poll},
 };
 
+use futures_core::ready;
 use pin_project_lite::pin_project;
 
 use super::{Service, ServiceFactory};
@@ -15,7 +15,7 @@ use super::{Service, ServiceFactory};
 /// of another service which completes successfully.
 ///
 /// This is created by the `Pipeline::and_then` method.
-pub(crate) struct AndThenService<A, B, Req>(Rc<RefCell<(A, B)>>, PhantomData<Req>);
+pub(crate) struct AndThenService<A, B, Req>(Rc<(A, B)>, PhantomData<Req>);
 
 impl<A, B, Req> AndThenService<A, B, Req> {
     /// Create new `AndThen` combinator
@@ -24,7 +24,7 @@ impl<A, B, Req> AndThenService<A, B, Req> {
         A: Service<Req>,
         B: Service<A::Response, Error = A::Error>,
     {
-        Self(Rc::new(RefCell::new((a, b))), PhantomData)
+        Self(Rc::new((a, b)), PhantomData)
     }
 }
 
@@ -43,20 +43,20 @@ where
     type Error = A::Error;
     type Future = AndThenServiceResponse<A, B, Req>;
 
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        let mut srv = self.0.borrow_mut();
+        let (a, b) = &*self.0;
-        let not_ready = !srv.0.poll_ready(cx)?.is_ready();
+        let not_ready = !a.poll_ready(cx)?.is_ready();
-        if !srv.1.poll_ready(cx)?.is_ready() || not_ready {
+        if !b.poll_ready(cx)?.is_ready() || not_ready {
             Poll::Pending
         } else {
             Poll::Ready(Ok(()))
         }
     }
 
-    fn call(&mut self, req: Req) -> Self::Future {
+    fn call(&self, req: Req) -> Self::Future {
         AndThenServiceResponse {
             state: State::A {
-                fut: self.0.borrow_mut().0.call(req),
+                fut: self.0 .0.call(req),
                 b: Some(self.0.clone()),
             },
         }
@@ -84,13 +84,12 @@ pin_project! {
         A {
             #[pin]
             fut: A::Future,
-            b: Option<Rc<RefCell<(A, B)>>>,
+            b: Option<Rc<(A, B)>>,
         },
         B {
             #[pin]
             fut: B::Future,
         },
-        Empty,
     }
 }
 
@@ -105,23 +104,14 @@ where
         let mut this = self.as_mut().project();
 
         match this.state.as_mut().project() {
-            StateProj::A { fut, b } => match fut.poll(cx)? {
+            StateProj::A { fut, b } => {
-                Poll::Ready(res) => {
+                let res = ready!(fut.poll(cx))?;
-                    let b = b.take().unwrap();
+                let b = b.take().unwrap();
-                    this.state.set(State::Empty); // drop fut A
+                let fut = b.1.call(res);
-                    let fut = b.borrow_mut().1.call(res);
+                this.state.set(State::B { fut });
-                    this.state.set(State::B { fut });
+                self.poll(cx)
-                    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::B { fut } => fut.poll(cx),
         }
     }
 }
@@ -292,12 +282,12 @@ mod tests {
         type Error = ();
         type Future = Ready<Result<Self::Response, ()>>;
 
-        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
             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)
         }
     }
@@ -310,12 +300,12 @@ mod tests {
         type Error = ();
         type Future = Ready<Result<Self::Response, ()>>;
 
-        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
             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"))
         }
     }
@@ -323,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);
@@ -332,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"));
@@ -346,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"));

actix-service/src/apply.rs

@@ -20,7 +20,7 @@ pub fn apply_fn<I, S, F, Fut, Req, In, Res, Err>(
 where
     I: IntoService<S, In>,
     S: Service<In, Error = Err>,
-    F: FnMut(Req, &mut S) -> Fut,
+    F: Fn(Req, &S) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
 {
     Apply::new(service.into_service(), wrap_fn)
@@ -36,7 +36,7 @@ pub fn apply_fn_factory<I, SF, F, Fut, Req, In, Res, Err>(
 where
     I: IntoServiceFactory<SF, In>,
     SF: ServiceFactory<In, Error = Err>,
-    F: FnMut(Req, &mut SF::Service) -> Fut + Clone,
+    F: Fn(Req, &SF::Service) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
 {
     ApplyFactory::new(service.into_factory(), f)
@@ -57,7 +57,7 @@ where
 impl<S, F, Fut, Req, In, Res, Err> Apply<S, F, Req, In, Res, Err>
 where
     S: Service<In, Error = Err>,
-    F: FnMut(Req, &mut S) -> Fut,
+    F: Fn(Req, &S) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
 {
     /// Create new `Apply` combinator
@@ -73,7 +73,7 @@ where
 impl<S, F, Fut, Req, In, Res, Err> Clone for Apply<S, F, Req, In, Res, Err>
 where
     S: Service<In, Error = Err> + Clone,
-    F: FnMut(Req, &mut S) -> Fut + Clone,
+    F: Fn(Req, &S) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
 {
     fn clone(&self) -> Self {
@@ -88,7 +88,7 @@ where
 impl<S, F, Fut, Req, In, Res, Err> Service<Req> for Apply<S, F, Req, In, Res, Err>
 where
     S: Service<In, Error = Err>,
-    F: FnMut(Req, &mut S) -> Fut,
+    F: Fn(Req, &S) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
 {
     type Response = Res;
@@ -97,8 +97,8 @@ where
 
     crate::forward_ready!(service);
 
-    fn call(&mut self, req: Req) -> Self::Future {
+    fn call(&self, req: Req) -> Self::Future {
-        (self.wrap_fn)(req, &mut self.service)
+        (self.wrap_fn)(req, &self.service)
     }
 }
 
@@ -112,7 +112,7 @@ pub struct ApplyFactory<SF, F, Req, In, Res, Err> {
 impl<SF, F, Fut, Req, In, Res, Err> ApplyFactory<SF, F, Req, In, Res, Err>
 where
     SF: ServiceFactory<In, Error = Err>,
-    F: FnMut(Req, &mut SF::Service) -> Fut + Clone,
+    F: Fn(Req, &SF::Service) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
 {
     /// Create new `ApplyFactory` new service instance
@@ -128,7 +128,7 @@ where
 impl<SF, F, Fut, Req, In, Res, Err> Clone for ApplyFactory<SF, F, Req, In, Res, Err>
 where
     SF: ServiceFactory<In, Error = Err> + Clone,
-    F: FnMut(Req, &mut SF::Service) -> Fut + Clone,
+    F: Fn(Req, &SF::Service) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
 {
     fn clone(&self) -> Self {
@@ -144,7 +144,7 @@ impl<SF, F, Fut, Req, In, Res, Err> ServiceFactory<Req>
     for ApplyFactory<SF, F, Req, In, Res, Err>
 where
     SF: ServiceFactory<In, Error = Err>,
-    F: FnMut(Req, &mut SF::Service) -> Fut + Clone,
+    F: Fn(Req, &SF::Service) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
 {
     type Response = Res;
@@ -165,7 +165,7 @@ pin_project! {
     pub struct ApplyServiceFactoryResponse<SF, F, Fut, Req, In, Res, Err>
     where
         SF: ServiceFactory<In, Error = Err>,
-        F: FnMut(Req, &mut SF::Service) -> Fut,
+        F: Fn(Req, &SF::Service) -> Fut,
         Fut: Future<Output = Result<Res, Err>>,
     {
         #[pin]
@@ -178,7 +178,7 @@ pin_project! {
 impl<SF, F, Fut, Req, In, Res, Err> ApplyServiceFactoryResponse<SF, F, Fut, Req, In, Res, Err>
 where
     SF: ServiceFactory<In, Error = Err>,
-    F: FnMut(Req, &mut SF::Service) -> Fut,
+    F: Fn(Req, &SF::Service) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
 {
     fn new(fut: SF::Future, wrap_fn: F) -> Self {
@@ -194,7 +194,7 @@ impl<SF, F, Fut, Req, In, Res, Err> Future
     for ApplyServiceFactoryResponse<SF, F, Fut, Req, In, Res, Err>
 where
     SF: ServiceFactory<In, Error = Err>,
-    F: FnMut(Req, &mut SF::Service) -> Fut,
+    F: Fn(Req, &SF::Service) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
 {
     type Output = Result<Apply<SF::Service, F, Req, In, Res, Err>, SF::InitError>;
@@ -226,14 +226,14 @@ mod tests {
 
         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();
@@ -261,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(())));
 

actix-service/src/apply_cfg.rs

@@ -1,17 +1,17 @@
 use alloc::rc::Rc;
 use core::{
-    cell::RefCell,
     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<Service2>` fn to a service factory.
+/// Convert `Fn(Config, &Service1) -> Future<Service2>` fn to a service factory.
 pub fn apply_cfg<S1, Req, F, Cfg, Fut, S2, Err>(
     srv: S1,
     f: F,
@@ -26,17 +26,17 @@ pub fn apply_cfg<S1, Req, F, Cfg, Fut, S2, Err>(
 > + Clone
 where
     S1: Service<Req>,
-    F: FnMut(Cfg, &mut S1) -> Fut,
+    F: Fn(Cfg, &S1) -> Fut,
     Fut: Future<Output = Result<S2, Err>>,
     S2: Service<Req>,
 {
     ApplyConfigService {
-        srv: Rc::new(RefCell::new((srv, f))),
+        srv: Rc::new((srv, f)),
         _phantom: PhantomData,
     }
 }
 
-/// Convert `Fn(Config, &mut ServiceFactory1) -> Future<ServiceFactory2>` fn to a service factory.
+/// Convert `Fn(Config, &ServiceFactory1) -> Future<ServiceFactory2>` fn to a service factory.
 ///
 /// Service1 get constructed from `T` factory.
 pub fn apply_cfg_factory<SF, Req, F, Cfg, Fut, S>(
@@ -52,33 +52,33 @@ pub fn apply_cfg_factory<SF, Req, F, Cfg, Fut, S>(
 > + Clone
 where
     SF: ServiceFactory<Req, Config = ()>,
-    F: FnMut(Cfg, &mut SF::Service) -> Fut,
+    F: Fn(Cfg, &SF::Service) -> Fut,
     SF::InitError: From<SF::Error>,
     Fut: Future<Output = Result<S, SF::InitError>>,
     S: Service<Req>,
 {
     ApplyConfigServiceFactory {
-        srv: Rc::new(RefCell::new((factory, f))),
+        srv: Rc::new((factory, f)),
         _phantom: PhantomData,
     }
 }
 
-/// Convert `Fn(Config, &mut Server) -> Future<Service>` fn to NewService\
+/// Convert `Fn(Config, &Server) -> Future<Service>` fn to NewService\
 struct ApplyConfigService<S1, Req, F, Cfg, Fut, S2, Err>
 where
     S1: Service<Req>,
-    F: FnMut(Cfg, &mut S1) -> Fut,
+    F: Fn(Cfg, &S1) -> Fut,
     Fut: Future<Output = Result<S2, Err>>,
     S2: Service<Req>,
 {
-    srv: Rc<RefCell<(S1, F)>>,
+    srv: Rc<(S1, F)>,
     _phantom: PhantomData<(Cfg, Req, Fut, S2)>,
 }
 
 impl<S1, Req, F, Cfg, Fut, S2, Err> Clone for ApplyConfigService<S1, Req, F, Cfg, Fut, S2, Err>
 where
     S1: Service<Req>,
-    F: FnMut(Cfg, &mut S1) -> Fut,
+    F: Fn(Cfg, &S1) -> Fut,
     Fut: Future<Output = Result<S2, Err>>,
     S2: Service<Req>,
 {
@@ -94,20 +94,20 @@ impl<S1, Req, F, Cfg, Fut, S2, Err> ServiceFactory<Req>
     for ApplyConfigService<S1, Req, F, Cfg, Fut, S2, Err>
 where
     S1: Service<Req>,
-    F: FnMut(Cfg, &mut S1) -> Fut,
+    F: Fn(Cfg, &S1) -> Fut,
     Fut: Future<Output = Result<S2, Err>>,
     S2: Service<Req>,
 {
-    type Config = Cfg;
     type Response = S2::Response;
     type Error = S2::Error;
+    type Config = Cfg;
     type Service = S2;
 
     type InitError = Err;
     type Future = Fut;
 
     fn new_service(&self, cfg: Cfg) -> Self::Future {
-        let (t, f) = &mut *self.srv.borrow_mut();
+        let (t, f) = &*self.srv;
         f(cfg, t)
     }
 }
@@ -116,18 +116,18 @@ where
 struct ApplyConfigServiceFactory<SF, Req, F, Cfg, Fut, S>
 where
     SF: ServiceFactory<Req, Config = ()>,
-    F: FnMut(Cfg, &mut SF::Service) -> Fut,
+    F: Fn(Cfg, &SF::Service) -> Fut,
     Fut: Future<Output = Result<S, SF::InitError>>,
     S: Service<Req>,
 {
-    srv: Rc<RefCell<(SF, F)>>,
+    srv: Rc<(SF, F)>,
     _phantom: PhantomData<(Cfg, Req, Fut, S)>,
 }
 
 impl<SF, Req, F, Cfg, Fut, S> Clone for ApplyConfigServiceFactory<SF, Req, F, Cfg, Fut, S>
 where
     SF: ServiceFactory<Req, Config = ()>,
-    F: FnMut(Cfg, &mut SF::Service) -> Fut,
+    F: Fn(Cfg, &SF::Service) -> Fut,
     Fut: Future<Output = Result<S, SF::InitError>>,
     S: Service<Req>,
 {
@@ -144,13 +144,13 @@ impl<SF, Req, F, Cfg, Fut, S> ServiceFactory<Req>
 where
     SF: ServiceFactory<Req, Config = ()>,
     SF::InitError: From<SF::Error>,
-    F: FnMut(Cfg, &mut SF::Service) -> Fut,
+    F: Fn(Cfg, &SF::Service) -> Fut,
     Fut: Future<Output = Result<S, SF::InitError>>,
     S: Service<Req>,
 {
-    type Config = Cfg;
     type Response = S::Response;
     type Error = S::Error;
+    type Config = Cfg;
     type Service = S;
 
     type InitError = SF::InitError;
@@ -161,7 +161,7 @@ where
             cfg: Some(cfg),
             store: self.srv.clone(),
             state: State::A {
-                fut: self.srv.borrow().0.new_service(()),
+                fut: self.srv.0.new_service(()),
             },
         }
     }
@@ -172,12 +172,12 @@ pin_project! {
     where
         SF: ServiceFactory<Req, Config = ()>,
         SF::InitError: From<SF::Error>,
-        F: FnMut(Cfg, &mut SF::Service) -> Fut,
+        F: Fn(Cfg, &SF::Service) -> Fut,
         Fut: Future<Output = Result<S, SF::InitError>>,
         S: Service<Req>,
     {
         cfg: Option<Cfg>,
-        store: Rc<RefCell<(SF, F)>>,
+        store: Rc<(SF, F)>,
         #[pin]
         state: State<SF, Fut, S, Req>,
     }
@@ -203,7 +203,7 @@ impl<SF, Req, F, Cfg, Fut, S> Future
 where
     SF: ServiceFactory<Req, Config = ()>,
     SF::InitError: From<SF::Error>,
-    F: FnMut(Cfg, &mut SF::Service) -> Fut,
+    F: Fn(Cfg, &SF::Service) -> Fut,
     Fut: Future<Output = Result<S, SF::InitError>>,
     S: Service<Req>,
 {
@@ -213,24 +213,20 @@ where
         let mut this = self.as_mut().project();
 
         match this.state.as_mut().project() {
-            StateProj::A { fut } => match fut.poll(cx)? {
+            StateProj::A { fut } => {
-                Poll::Pending => Poll::Pending,
+                let svc = ready!(fut.poll(cx))?;
-                Poll::Ready(svc) => {
+                this.state.set(State::B { svc });
-                    this.state.set(State::B { svc });
+                self.poll(cx)
-                    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 });
                 }
-            },
+                self.poll(cx)
-            StateProj::B { svc } => match svc.poll_ready(cx)? {
+            }
-                Poll::Ready(_) => {
-                    {
-                        let (_, f) = &mut *this.store.borrow_mut();
-                        let fut = f(this.cfg.take().unwrap(), svc);
-                        this.state.set(State::C { fut });
-                    }
-                    self.poll(cx)
-                }
-                Poll::Pending => Poll::Pending,
-            },
             StateProj::C { fut } => fut.poll(cx),
         }
     }

actix-service/src/boxed.rs

@@ -131,11 +131,11 @@ where
     type Error = Err;
     type Future = BoxFuture<Result<Res, Err>>;
 
-    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         self.0.poll_ready(ctx)
     }
 
-    fn call(&mut self, req: Req) -> Self::Future {
+    fn call(&self, req: Req) -> Self::Future {
         Box::pin(self.0.call(req))
     }
 }

actix-service/src/fn_service.rs

@@ -7,7 +7,7 @@ pub fn fn_service<F, Fut, Req, Res, Err, Cfg>(
     f: F,
 ) -> FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
 where
-    F: FnMut(Req) -> Fut + Clone,
+    F: Fn(Req) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
 {
     FnServiceFactory::new(f)
@@ -39,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?;
@@ -81,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);
@@ -132,7 +132,7 @@ where
 
 impl<F, Fut, Req, Res, Err> Service<Req> for FnService<F, Fut, Req, Res, Err>
 where
-    F: FnMut(Req) -> Fut,
+    F: Fn(Req) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
 {
     type Response = Res;
@@ -141,14 +141,14 @@ where
 
     crate::always_ready!();
 
-    fn call(&mut self, req: Req) -> Self::Future {
+    fn call(&self, req: Req) -> Self::Future {
         (self.f)(req)
     }
 }
 
 impl<F, Fut, Req, Res, Err> IntoService<FnService<F, Fut, Req, Res, Err>, Req> for F
 where
-    F: FnMut(Req) -> Fut,
+    F: Fn(Req) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
 {
     fn into_service(self) -> FnService<F, Fut, Req, Res, Err> {
@@ -158,7 +158,7 @@ where
 
 pub struct FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
 where
-    F: FnMut(Req) -> Fut,
+    F: Fn(Req) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
 {
     f: F,
@@ -167,7 +167,7 @@ where
 
 impl<F, Fut, Req, Res, Err, Cfg> FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
 where
-    F: FnMut(Req) -> Fut + Clone,
+    F: Fn(Req) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
 {
     fn new(f: F) -> Self {
@@ -177,7 +177,7 @@ where
 
 impl<F, Fut, Req, Res, Err, Cfg> Clone for FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
 where
-    F: FnMut(Req) -> Fut + Clone,
+    F: Fn(Req) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
 {
     fn clone(&self) -> Self {
@@ -187,7 +187,7 @@ where
 
 impl<F, Fut, Req, Res, Err> Service<Req> for FnServiceFactory<F, Fut, Req, Res, Err, ()>
 where
-    F: FnMut(Req) -> Fut + Clone,
+    F: Fn(Req) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
 {
     type Response = Res;
@@ -196,7 +196,7 @@ where
 
     crate::always_ready!();
 
-    fn call(&mut self, req: Req) -> Self::Future {
+    fn call(&self, req: Req) -> Self::Future {
         (self.f)(req)
     }
 }
@@ -204,7 +204,7 @@ where
 impl<F, Fut, Req, Res, Err, Cfg> ServiceFactory<Req>
     for FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
 where
-    F: FnMut(Req) -> Fut + Clone,
+    F: Fn(Req) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
 {
     type Response = Res;
@@ -318,8 +318,8 @@ where
 {
     type Response = Srv::Response;
     type Error = Srv::Error;
-    type Service = Srv;
     type Config = Cfg;
+    type Service = Srv;
     type InitError = Err;
     type Future = Fut;
 
@@ -364,7 +364,7 @@ mod tests {
     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());
@@ -373,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(())));
@@ -387,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());

actix-service/src/lib.rs

@@ -69,9 +69,9 @@ use self::ready::{err, ok, ready, Ready};
 ///      type Error = MyError;
 ///      type Future = Pin<Box<Future<Output=Result<Self::Response, Self::Error>>>>;
 ///
-///      fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { ... }
+///      fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { ... }
 ///
-///      fn call(&mut self, req: Self::Request) -> Self::Future { ... }
+///      fn call(&self, req: Self::Request) -> Self::Future { ... }
 /// }
 /// ```
 ///
@@ -104,7 +104,7 @@ pub trait Service<Req> {
     /// # 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<Result<(), Self::Error>>;
+    fn poll_ready(&self, ctx: &mut task::Context<'_>) -> Poll<Result<(), Self::Error>>;
 
     /// Process the request and return the response asynchronously.
     ///
@@ -115,7 +115,7 @@ pub trait Service<Req> {
     ///
     /// Calling `call` without calling `poll_ready` is permitted. The
     /// implementation must be resilient to this fact.
-    fn call(&mut self, req: Req) -> Self::Future;
+    fn call(&self, req: Req) -> Self::Future;
 }
 
 /// Factory for creating `Service`s.
@@ -158,11 +158,11 @@ where
     type Error = S::Error;
     type Future = S::Future;
 
-    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         (**self).poll_ready(ctx)
     }
 
-    fn call(&mut self, request: Req) -> S::Future {
+    fn call(&self, request: Req) -> S::Future {
         (**self).call(request)
     }
 }
@@ -175,11 +175,11 @@ where
     type Error = S::Error;
     type Future = S::Future;
 
-    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), S::Error>> {
+    fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), S::Error>> {
         (**self).poll_ready(ctx)
     }
 
-    fn call(&mut self, request: Req) -> S::Future {
+    fn call(&self, request: Req) -> S::Future {
         (**self).call(request)
     }
 }
@@ -192,12 +192,12 @@ where
     type Error = S::Error;
     type Future = S::Future;
 
-    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.borrow_mut().poll_ready(ctx)
+        self.borrow().poll_ready(ctx)
     }
 
-    fn call(&mut self, request: Req) -> S::Future {
+    fn call(&self, request: Req) -> S::Future {
-        self.borrow_mut().call(request)
+        self.borrow().call(request)
     }
 }
 
@@ -209,12 +209,12 @@ where
     type Error = S::Error;
     type Future = S::Future;
 
-    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.borrow_mut().poll_ready(ctx)
+        self.borrow().poll_ready(ctx)
     }
 
-    fn call(&mut self, request: Req) -> S::Future {
+    fn call(&self, request: Req) -> S::Future {
-        (&mut (**self).borrow_mut()).call(request)
+        self.borrow().call(request)
     }
 }
 
@@ -311,8 +311,9 @@ pub mod dev {
 #[macro_export]
 macro_rules! always_ready {
     () => {
+        #[inline]
         fn poll_ready(
-            &mut self,
+            &self,
             _: &mut ::core::task::Context<'_>,
         ) -> ::core::task::Poll<Result<(), Self::Error>> {
             Poll::Ready(Ok(()))
@@ -323,8 +324,9 @@ macro_rules! always_ready {
 #[macro_export]
 macro_rules! forward_ready {
     ($field:ident) => {
+        #[inline]
         fn poll_ready(
-            &mut self,
+            &self,
             cx: &mut ::core::task::Context<'_>,
         ) -> ::core::task::Poll<Result<(), Self::Error>> {
             self.$field

actix-service/src/map.rs

@@ -58,7 +58,7 @@ where
 
     crate::forward_ready!(service);
 
-    fn call(&mut self, req: Req) -> Self::Future {
+    fn call(&self, req: Req) -> Self::Future {
         MapFuture::new(self.service.call(req), self.f.clone())
     }
 }
@@ -215,21 +215,21 @@ mod tests {
 
         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");
@@ -238,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"));

actix-service/src/map_err.rs

@@ -57,11 +57,11 @@ where
     type Error = E;
     type Future = MapErrFuture<A, Req, F, E>;
 
-    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         self.service.poll_ready(ctx).map_err(&self.f)
     }
 
-    fn call(&mut self, req: Req) -> Self::Future {
+    fn call(&self, req: Req) -> Self::Future {
         MapErrFuture::new(self.service.call(req), self.f.clone())
     }
 }
@@ -218,25 +218,25 @@ mod tests {
         type Error = ();
         type Future = Ready<Result<(), ()>>;
 
-        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
             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");
@@ -245,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");

actix-service/src/pipeline.rs

@@ -146,12 +146,12 @@ impl<S: Service<Req>, Req> Service<Req> for Pipeline<S, Req> {
     type Future = S::Future;
 
     #[inline]
-    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), S::Error>> {
+    fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), S::Error>> {
         self.service.poll_ready(ctx)
     }
 
     #[inline]
-    fn call(&mut self, req: Req) -> Self::Future {
+    fn call(&self, req: Req) -> Self::Future {
         self.service.call(req)
     }
 }

actix-service/src/then.rs

@@ -1,12 +1,12 @@
 use alloc::rc::Rc;
 use core::{
-    cell::RefCell,
     future::Future,
     marker::PhantomData,
     pin::Pin,
     task::{Context, Poll},
 };
 
+use futures_core::ready;
 use pin_project_lite::pin_project;
 
 use super::{Service, ServiceFactory};
@@ -15,7 +15,7 @@ use super::{Service, ServiceFactory};
 /// another service.
 ///
 /// This is created by the `Pipeline::then` method.
-pub(crate) struct ThenService<A, B, Req>(Rc<RefCell<(A, B)>>, PhantomData<Req>);
+pub(crate) struct ThenService<A, B, Req>(Rc<(A, B)>, PhantomData<Req>);
 
 impl<A, B, Req> ThenService<A, B, Req> {
     /// Create new `.then()` combinator
@@ -24,7 +24,7 @@ impl<A, B, Req> ThenService<A, B, Req> {
         A: Service<Req>,
         B: Service<Result<A::Response, A::Error>, Error = A::Error>,
     {
-        Self(Rc::new(RefCell::new((a, b))), PhantomData)
+        Self(Rc::new((a, b)), PhantomData)
     }
 }
 
@@ -43,20 +43,20 @@ where
     type Error = B::Error;
     type Future = ThenServiceResponse<A, B, Req>;
 
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        let mut srv = self.0.borrow_mut();
+        let (a, b) = &*self.0;
-        let not_ready = !srv.0.poll_ready(cx)?.is_ready();
+        let not_ready = !a.poll_ready(cx)?.is_ready();
-        if !srv.1.poll_ready(cx)?.is_ready() || not_ready {
+        if !b.poll_ready(cx)?.is_ready() || not_ready {
             Poll::Pending
         } else {
             Poll::Ready(Ok(()))
         }
     }
 
-    fn call(&mut self, req: Req) -> Self::Future {
+    fn call(&self, req: Req) -> Self::Future {
         ThenServiceResponse {
             state: State::A {
-                fut: self.0.borrow_mut().0.call(req),
+                fut: self.0 .0.call(req),
                 b: Some(self.0.clone()),
             },
         }
@@ -81,9 +81,8 @@ pin_project! {
         A: Service<Req>,
         B: Service<Result<A::Response, A::Error>>,
     {
-        A { #[pin] fut: A::Future, b: Option<Rc<RefCell<(A, B)>>> },
+        A { #[pin] fut: A::Future, b: Option<Rc<(A, B)>> },
         B { #[pin] fut: B::Future },
-        Empty,
     }
 }
 
@@ -98,23 +97,14 @@ where
         let mut this = self.as_mut().project();
 
         match this.state.as_mut().project() {
-            StateProj::A { fut, b } => match fut.poll(cx) {
+            StateProj::A { fut, b } => {
-                Poll::Ready(res) => {
+                let res = ready!(fut.poll(cx));
-                    let b = b.take().unwrap();
+                let b = b.take().unwrap();
-                    this.state.set(State::Empty); // drop fut A
+                let fut = b.1.call(res);
-                    let fut = b.borrow_mut().1.call(res);
+                this.state.set(State::B { fut });
-                    this.state.set(State::B { fut });
+                self.poll(cx)
-                    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::B { fut } => fut.poll(cx),
         }
     }
 }
@@ -266,12 +256,12 @@ mod tests {
         type Error = ();
         type Future = Ready<Result<Self::Response, Self::Error>>;
 
-        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
             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(()),
@@ -286,12 +276,12 @@ mod tests {
         type Error = ();
         type Future = Ready<Result<Self::Response, ()>>;
 
-        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
             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")),
@@ -302,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);
@@ -311,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());
@@ -328,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"));

actix-service/src/transform.rs

@@ -6,6 +6,7 @@ use core::{
     task::{Context, Poll},
 };
 
+use futures_core::ready;
 use pin_project_lite::pin_project;
 
 use crate::transform_err::TransformMapInitErr;
@@ -47,7 +48,7 @@ where
 ///
 ///     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),
@@ -127,8 +128,8 @@ where
 {
     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,8 +143,8 @@ where
 {
     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 {
@@ -229,14 +230,12 @@ where
         let mut this = self.as_mut().project();
 
         match this.state.as_mut().project() {
-            ApplyTransformFutureStateProj::A { fut } => match fut.poll(cx)? {
+            ApplyTransformFutureStateProj::A { fut } => {
-                Poll::Ready(srv) => {
+                let srv = ready!(fut.poll(cx))?;
-                    let fut = this.store.0.new_transform(srv);
+                let fut = this.store.0.new_transform(srv);
-                    this.state.set(ApplyTransformFutureState::B { fut });
+                this.state.set(ApplyTransformFutureState::B { fut });
-                    self.poll(cx)
+                self.poll(cx)
-                }
+            }
-                Poll::Pending => Poll::Pending,
-            },
             ApplyTransformFutureStateProj::B { fut } => fut.poll(cx),
         }
     }

actix-threadpool/CHANGES.md

@@ -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

actix-threadpool/Cargo.toml

@@ -1,27 +0,0 @@
-[package]
-name = "actix-threadpool"
-version = "0.3.3"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-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.7"
-parking_lot = "0.11"
-lazy_static = "1.3"
-log = "0.4"
-num_cpus = "1.10"
-threadpool = "1.7"

actix-threadpool/LICENSE-APACHE

@@ -1 +0,0 @@
-../LICENSE-APACHE

actix-threadpool/LICENSE-MIT

@@ -1 +0,0 @@
-../LICENSE-MIT

actix-threadpool/src/lib.rs

@@ -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<ThreadPool> = {
-        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<E: fmt::Debug> {
-    #[display(fmt = "{:?}", _0)]
-    Error(E),
-    #[display(fmt = "Thread pool is gone")]
-    Canceled,
-}
-
-impl<E: fmt::Debug> std::error::Error for BlockingError<E> {}
-
-/// Execute blocking function on a thread pool, returns future that resolves
-/// to result of the function execution.
-pub fn run<F, I, E>(f: F) -> CpuFuture<I, E>
-where
-    F: FnOnce() -> Result<I, E> + 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<I, E> {
-    rx: oneshot::Receiver<Result<I, E>>,
-}
-
-impl<I, E: fmt::Debug> Future for CpuFuture<I, E> {
-    type Output = Result<I, BlockingError<E>>;
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        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)
-    }
-}

actix-tls/CHANGES.md

@@ -3,6 +3,22 @@
 ## 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]
 

actix-tls/Cargo.toml

@@ -1,12 +1,12 @@
 [package]
 name = "actix-tls"
-version = "3.0.0-beta.2"
+version = "3.0.0-beta.3"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 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"
@@ -18,10 +18,6 @@ features = ["openssl", "rustls", "native-tls", "accept", "connect", "uri"]
 name = "actix_tls"
 path = "src/lib.rs"
 
-[[example]]
-name = "basic"
-required-features = ["accept", "rustls"]
-
 [features]
 default = ["accept", "connect", "uri"]
 
@@ -29,55 +25,52 @@ default = ["accept", "connect", "uri"]
 accept = []
 
 # enable connector services
-connect = ["trust-dns-proto/tokio-runtime", "trust-dns-resolver/tokio-runtime", "trust-dns-resolver/system-config"]
+connect = []
 
 # use openssl impls
 openssl = ["tls-openssl", "tokio-openssl"]
 
 # use rustls impls
-rustls = ["tls-rustls", "webpki", "webpki-roots", "tokio-rustls"]
+rustls = ["tokio-rustls", "webpki-roots"]
 
 # use native-tls impls
-native-tls = ["tls-native-tls", "tokio-native-tls"]
+native-tls = ["tokio-native-tls"]
 
 # support http::Uri as connect address
 uri = ["http"]
 
 [dependencies]
 actix-codec = "0.4.0-beta.1"
-actix-rt = "2.0.0-beta.1"
+actix-rt = { version = "2.0.0", default-features = false }
-actix-service = "2.0.0-beta.2"
+actix-service = "2.0.0-beta.4"
-actix-utils = "3.0.0-beta.1"
+actix-utils = "3.0.0-beta.2"
 
 derive_more = "0.99.5"
-either = "1.6"
+futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] }
-futures-util = { version = "0.3.7", default-features = false }
+http = { version = "0.2.3", optional = true }
-http = { version = "0.2.2", optional = true }
 log = "0.4"
-
+tokio-util = { version = "0.6.3", default-features = false }
-# resolver
-trust-dns-proto = { version = "0.20.0", default-features = false, optional = true }
-trust-dns-resolver = { version = "0.20.0", default-features = false, optional = true }
 
 # openssl
 tls-openssl = { package = "openssl", version = "0.10", optional = true }
 tokio-openssl = { version = "0.6", optional = true }
 
-# TODO: Reduce dependencies where tokio wrappers re-export base crate.
-
 # rustls
-tls-rustls = { package = "rustls", version = "0.19", optional = true }
 tokio-rustls = { version = "0.22", optional = true }
-webpki = { version = "0.21", optional = true }
 webpki-roots = { version = "0.21", optional = true }
 
 # native-tls
-tls-native-tls = { package = "native-tls", version = "0.2", optional = true }
 tokio-native-tls = { version = "0.3", optional = true }
 
 [dev-dependencies]
+actix-rt = "2.0.0"
 actix-server = "2.0.0-beta.2"
 bytes = "1"
 env_logger = "0.8"
 futures-util = { version = "0.3.7", default-features = false, features = ["sink"] }
 log = "0.4"
+trust-dns-resolver = "0.20.0"
+
+[[example]]
+name = "basic"
+required-features = ["accept", "rustls"]

actix-tls/examples/basic.rs

@@ -15,9 +15,9 @@
 //! http --verify=false https://127.0.0.1:8443
 //! ```
 
-// this rename only exists because of how we have organised the crate's feature flags
+// this use only exists because of how we have organised the crate
 // it is not necessary for your actual code
-extern crate tls_rustls as rustls;
+use tokio_rustls::rustls;
 
 use std::{
     env,

actix-tls/src/accept/nativetls.rs

@@ -3,9 +3,9 @@ use std::task::{Context, Poll};
 use actix_codec::{AsyncRead, AsyncWrite};
 use actix_service::{Service, ServiceFactory};
 use actix_utils::counter::Counter;
-use futures_util::future::{ready, LocalBoxFuture, Ready};
+use futures_core::future::LocalBoxFuture;
 
-pub use native_tls::Error;
+pub use tokio_native_tls::native_tls::Error;
 pub use tokio_native_tls::{TlsAcceptor, TlsStream};
 
 use super::MAX_CONN_COUNTER;
@@ -44,15 +44,16 @@ where
 
     type Service = NativeTlsAcceptorService;
     type InitError = ();
-    type Future = Ready<Result<Self::Service, Self::InitError>>;
+    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
 
     fn new_service(&self, _: ()) -> Self::Future {
-        MAX_CONN_COUNTER.with(|conns| {
+        let res = MAX_CONN_COUNTER.with(|conns| {
-            ready(Ok(NativeTlsAcceptorService {
+            Ok(NativeTlsAcceptorService {
                 acceptor: self.acceptor.clone(),
                 conns: conns.clone(),
-            }))
+            })
-        })
+        });
+        Box::pin(async { res })
     }
 }
 
@@ -78,7 +79,7 @@ where
     type Error = Error;
     type Future = LocalBoxFuture<'static, Result<TlsStream<T>, Error>>;
 
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         if self.conns.available(cx) {
             Poll::Ready(Ok(()))
         } else {
@@ -86,7 +87,7 @@ where
         }
     }
 
-    fn call(&mut self, io: T) -> Self::Future {
+    fn call(&self, io: T) -> Self::Future {
         let guard = self.conns.get();
         let this = self.clone();
         Box::pin(async move {

actix-tls/src/accept/openssl.rs

@@ -1,14 +1,13 @@
-use std::future::Future;
+use std::{
-use std::pin::Pin;
+    future::Future,
-use std::task::{Context, Poll};
+    pin::Pin,
+    task::{Context, Poll},
+};
 
 use actix_codec::{AsyncRead, AsyncWrite};
 use actix_service::{Service, ServiceFactory};
 use actix_utils::counter::{Counter, CounterGuard};
-use futures_util::{
+use futures_core::{future::LocalBoxFuture, ready};
-    future::{ready, Ready},
-    ready,
-};
 
 pub use openssl::ssl::{
     AlpnError, Error as SslError, HandshakeError, Ssl, SslAcceptor, SslAcceptorBuilder,
@@ -50,15 +49,16 @@ where
     type Config = ();
     type Service = AcceptorService;
     type InitError = ();
-    type Future = Ready<Result<Self::Service, Self::InitError>>;
+    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
 
     fn new_service(&self, _: ()) -> Self::Future {
-        MAX_CONN_COUNTER.with(|conns| {
+        let res = MAX_CONN_COUNTER.with(|conns| {
-            ready(Ok(AcceptorService {
+            Ok(AcceptorService {
                 acceptor: self.acceptor.clone(),
                 conns: conns.clone(),
-            }))
+            })
-        })
+        });
+        Box::pin(async { res })
     }
 }
 
@@ -75,7 +75,7 @@ where
     type Error = SslError;
     type Future = AcceptorServiceResponse<T>;
 
-    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(&self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         if self.conns.available(ctx) {
             Poll::Ready(Ok(()))
         } else {
@@ -83,7 +83,7 @@ where
         }
     }
 
-    fn call(&mut self, io: T) -> Self::Future {
+    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 {

actix-tls/src/accept/rustls.rs

@@ -1,18 +1,19 @@
-use std::future::Future;
+use std::{
-use std::io;
+    future::Future,
-use std::pin::Pin;
+    io,
-use std::sync::Arc;
+    pin::Pin,
-use std::task::{Context, Poll};
+    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::{ready, Ready};
+use futures_core::future::LocalBoxFuture;
 use tokio_rustls::{Accept, TlsAcceptor};
 
-pub use rustls::{ServerConfig, Session};
+pub use tokio_rustls::rustls::{ServerConfig, Session};
 pub use tokio_rustls::server::TlsStream;
-pub use webpki_roots::TLS_SERVER_ROOTS;
 
 use super::MAX_CONN_COUNTER;
 
@@ -52,15 +53,16 @@ where
 
     type Service = AcceptorService;
     type InitError = ();
-    type Future = Ready<Result<Self::Service, Self::InitError>>;
+    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
 
     fn new_service(&self, _: ()) -> Self::Future {
-        MAX_CONN_COUNTER.with(|conns| {
+        let res = MAX_CONN_COUNTER.with(|conns| {
-            ready(Ok(AcceptorService {
+            Ok(AcceptorService {
                 acceptor: self.config.clone().into(),
                 conns: conns.clone(),
-            }))
+            })
-        })
+        });
+        Box::pin(async { res })
     }
 }
 
@@ -78,7 +80,7 @@ where
     type Error = io::Error;
     type Future = AcceptorServiceFut<T>;
 
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         if self.conns.available(cx) {
             Poll::Ready(Ok(()))
         } else {
@@ -86,7 +88,7 @@ where
         }
     }
 
-    fn call(&mut self, req: T) -> Self::Future {
+    fn call(&self, req: T) -> Self::Future {
         AcceptorServiceFut {
             _guard: self.conns.get(),
             fut: self.acceptor.accept(req),

actix-tls/src/connect/connect.rs

@@ -1,128 +1,150 @@
-use std::collections::{vec_deque, VecDeque};
+use std::{
-use std::fmt;
+    collections::{vec_deque, VecDeque},
-use std::iter::{FromIterator, FusedIterator};
+    fmt,
-use std::net::SocketAddr;
+    iter::{self, FromIterator as _},
+    mem,
+    net::SocketAddr,
+};
 
-use either::Either;
+/// Parse a host into parts (hostname and port).
-
-/// Connect request
 pub trait Address: Unpin + 'static {
-    /// Host name of the request
+    /// Get hostname part.
-    fn host(&self) -> &str;
+    fn hostname(&self) -> &str;
 
-    /// Port of the request
+    /// Get optional port part.
-    fn port(&self) -> Option<u16>;
+    fn port(&self) -> Option<u16> {
+        None
+    }
 }
 
 impl Address for String {
-    fn host(&self) -> &str {
+    fn hostname(&self) -> &str {
         &self
     }
-
-    fn port(&self) -> Option<u16> {
-        None
-    }
 }
 
 impl Address for &'static str {
-    fn host(&self) -> &str {
+    fn hostname(&self) -> &str {
         self
     }
-
-    fn port(&self) -> Option<u16> {
-        None
-    }
 }
 
-/// Connect request
+#[derive(Debug, Eq, PartialEq, Hash)]
-#[derive(Eq, PartialEq, Debug, Hash)]
+pub(crate) enum ConnectAddrs {
+    None,
+    One(SocketAddr),
+    Multi(VecDeque<SocketAddr>),
+}
+
+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<Option<SocketAddr>> for ConnectAddrs {
+    fn from(addr: Option<SocketAddr>) -> Self {
+        match addr {
+            Some(addr) => ConnectAddrs::One(addr),
+            None => ConnectAddrs::None,
+        }
+    }
+}
+
+/// Connection info.
+#[derive(Debug, PartialEq, Eq, Hash)]
 pub struct Connect<T> {
     pub(crate) req: T,
     pub(crate) port: u16,
-    pub(crate) addr: Option<Either<SocketAddr, VecDeque<SocketAddr>>>,
+    pub(crate) addr: ConnectAddrs,
 }
 
 impl<T: Address> Connect<T> {
     /// Create `Connect` instance by splitting the string by ':' and convert the second part to u16
     pub fn new(req: T) -> Connect<T> {
-        let (_, port) = parse(req.host());
+        let (_, port) = parse_host(req.hostname());
+
         Connect {
             req,
             port: port.unwrap_or(0),
-            addr: None,
+            addr: ConnectAddrs::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<T> {
+    pub fn with_addr(req: T, addr: SocketAddr) -> Connect<T> {
         Connect {
             req,
             port: 0,
-            addr: Some(Either::Left(addr)),
+            addr: ConnectAddrs::One(addr),
         }
     }
 
     /// Use port if address does not provide one.
     ///
-    /// By default it set to 0
+    /// Default value is 0.
     pub fn set_port(mut self, port: u16) -> Self {
         self.port = port;
         self
     }
 
-    /// Use address.
+    /// Set address.
     pub fn set_addr(mut self, addr: Option<SocketAddr>) -> Self {
-        if let Some(addr) = addr {
+        self.addr = ConnectAddrs::from(addr);
-            self.addr = Some(Either::Left(addr));
-        }
         self
     }
 
-    /// Use addresses.
+    /// Set list of addresses.
     pub fn set_addrs<I>(mut self, addrs: I) -> Self
     where
         I: IntoIterator<Item = SocketAddr>,
     {
         let mut addrs = VecDeque::from_iter(addrs);
         self.addr = if addrs.len() < 2 {
-            addrs.pop_front().map(Either::Left)
+            ConnectAddrs::from(addrs.pop_front())
         } else {
-            Some(Either::Right(addrs))
+            ConnectAddrs::Multi(addrs)
         };
         self
     }
 
-    /// Host name
+    /// Get hostname.
-    pub fn host(&self) -> &str {
+    pub fn hostname(&self) -> &str {
-        self.req.host()
+        self.req.hostname()
     }
 
-    /// Port of the request
+    /// Get request port.
     pub fn port(&self) -> u16 {
         self.req.port().unwrap_or(self.port)
     }
 
-    /// Pre-resolved addresses of the request.
+    /// Get resolved request addresses.
     pub fn addrs(&self) -> ConnectAddrsIter<'_> {
-        let inner = match self.addr {
+        match self.addr {
-            None => Either::Left(None),
+            ConnectAddrs::None => ConnectAddrsIter::None,
-            Some(Either::Left(addr)) => Either::Left(Some(addr)),
+            ConnectAddrs::One(addr) => ConnectAddrsIter::One(addr),
-            Some(Either::Right(ref addrs)) => Either::Right(addrs.iter()),
+            ConnectAddrs::Multi(ref addrs) => ConnectAddrsIter::Multi(addrs.iter()),
-        };
+        }
-
-        ConnectAddrsIter { inner }
     }
 
-    /// Takes pre-resolved addresses of the request.
+    /// Take resolved request addresses.
-    pub fn take_addrs(&mut self) -> ConnectTakeAddrsIter {
+    pub fn take_addrs(&mut self) -> ConnectAddrsIter<'static> {
-        let inner = match self.addr.take() {
+        match mem::take(&mut self.addr) {
-            None => Either::Left(None),
+            ConnectAddrs::None => ConnectAddrsIter::None,
-            Some(Either::Left(addr)) => Either::Left(Some(addr)),
+            ConnectAddrs::One(addr) => ConnectAddrsIter::One(addr),
-            Some(Either::Right(addrs)) => Either::Right(addrs.into_iter()),
+            ConnectAddrs::Multi(addrs) => ConnectAddrsIter::MultiOwned(addrs.into_iter()),
-        };
+        }
-
-        ConnectTakeAddrsIter { inner }
     }
 }
 
@@ -134,31 +156,40 @@ impl<T: Address> From<T> for Connect<T> {
 
 impl<T: Address> fmt::Display for Connect<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}:{}", self.host(), self.port())
+        write!(f, "{}:{}", self.hostname(), self.port())
     }
 }
 
 /// Iterator over addresses in a [`Connect`] request.
 #[derive(Clone)]
-pub struct ConnectAddrsIter<'a> {
+pub enum ConnectAddrsIter<'a> {
-    inner: Either<Option<SocketAddr>, vec_deque::Iter<'a, SocketAddr>>,
+    None,
+    One(SocketAddr),
+    Multi(vec_deque::Iter<'a, SocketAddr>),
+    MultiOwned(vec_deque::IntoIter<SocketAddr>),
 }
 
 impl Iterator for ConnectAddrsIter<'_> {
     type Item = SocketAddr;
 
     fn next(&mut self) -> Option<Self::Item> {
-        match self.inner {
+        match *self {
-            Either::Left(ref mut opt) => opt.take(),
+            Self::None => None,
-            Either::Right(ref mut iter) => iter.next().copied(),
+            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<usize>) {
-        match self.inner {
+        match *self {
-            Either::Left(Some(_)) => (1, Some(1)),
+            Self::None => (0, Some(0)),
-            Either::Left(None) => (0, Some(0)),
+            Self::One(_) => (1, Some(1)),
-            Either::Right(ref iter) => iter.size_hint(),
+            Self::Multi(ref iter) => iter.size_hint(),
+            Self::MultiOwned(ref iter) => iter.size_hint(),
         }
     }
 }
@@ -169,52 +200,9 @@ impl fmt::Debug for ConnectAddrsIter<'_> {
     }
 }
 
-impl ExactSizeIterator for ConnectAddrsIter<'_> {}
+impl iter::ExactSizeIterator for ConnectAddrsIter<'_> {}
 
-impl FusedIterator for ConnectAddrsIter<'_> {}
+impl iter::FusedIterator for ConnectAddrsIter<'_> {}
-
-/// Owned iterator over addresses in a [`Connect`] request.
-#[derive(Debug)]
-pub struct ConnectTakeAddrsIter {
-    inner: Either<Option<SocketAddr>, vec_deque::IntoIter<SocketAddr>>,
-}
-
-impl Iterator for ConnectTakeAddrsIter {
-    type Item = SocketAddr;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        match self.inner {
-            Either::Left(ref mut opt) => opt.take(),
-            Either::Right(ref mut iter) => iter.next(),
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        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<u16>) {
-    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::<u16>() {
-            (host, Some(port))
-        } else {
-            (host, None)
-        }
-    } else {
-        (host, None)
-    }
-}
 
 pub struct Connection<T, U> {
     io: U,
@@ -239,25 +227,25 @@ impl<T, U> Connection<T, U> {
     }
 
     /// Replace inclosed object, return new Stream and old object
-    pub fn replace<Y>(self, io: Y) -> (U, Connection<T, Y>) {
+    pub fn replace_io<Y>(self, io: Y) -> (U, Connection<T, Y>) {
         (self.io, Connection { io, req: self.req })
     }
 
     /// Returns a shared reference to the underlying stream.
-    pub fn get_ref(&self) -> &U {
+    pub fn io_ref(&self) -> &U {
         &self.io
     }
 
     /// Returns a mutable reference to the underlying stream.
-    pub fn get_mut(&mut self) -> &mut U {
+    pub fn io_mut(&mut self) -> &mut U {
         &mut self.io
     }
 }
 
 impl<T: Address, U> Connection<T, U> {
-    /// Get request
+    /// Get hostname.
     pub fn host(&self) -> &str {
-        &self.req.host()
+        self.req.hostname()
     }
 }
 
@@ -280,3 +268,65 @@ impl<T, U: fmt::Debug> fmt::Debug for Connection<T, U> {
         write!(f, "Stream {{{:?}}}", self.io)
     }
 }
+
+fn parse_host(host: &str) -> (&str, Option<u16>) {
+    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::<u16>().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);
+    }
+}

actix-tls/src/connect/connector.rs

@@ -1,129 +1,102 @@
-use std::collections::VecDeque;
+use std::{
-use std::future::Future;
+    collections::VecDeque,
-use std::io;
+    future::Future,
-use std::marker::PhantomData;
+    io,
-use std::net::SocketAddr;
+    net::SocketAddr,
-use std::pin::Pin;
+    pin::Pin,
-use std::task::{Context, Poll};
+    task::{Context, Poll},
+};
 
 use actix_rt::net::TcpStream;
 use actix_service::{Service, ServiceFactory};
-use futures_util::future::{ready, Ready};
+use futures_core::{future::LocalBoxFuture, ready};
 use log::{error, trace};
+use tokio_util::sync::ReusableBoxFuture;
 
-use super::connect::{Address, Connect, Connection};
+use super::connect::{Address, Connect, ConnectAddrs, Connection};
 use super::error::ConnectError;
 
 /// TCP connector service factory
-#[derive(Debug)]
+#[derive(Debug, Copy, Clone)]
-pub struct TcpConnectorFactory<T>(PhantomData<T>);
+pub struct TcpConnectorFactory;
-
-impl<T> TcpConnectorFactory<T> {
-    pub fn new() -> Self {
-        TcpConnectorFactory(PhantomData)
-    }
 
+impl TcpConnectorFactory {
     /// Create TCP connector service
-    pub fn service(&self) -> TcpConnector<T> {
+    pub fn service(&self) -> TcpConnector {
-        TcpConnector(PhantomData)
+        TcpConnector
     }
 }
 
-impl<T> Default for TcpConnectorFactory<T> {
+impl<T: Address> ServiceFactory<Connect<T>> for TcpConnectorFactory {
-    fn default() -> Self {
-        TcpConnectorFactory(PhantomData)
-    }
-}
-
-impl<T> Clone for TcpConnectorFactory<T> {
-    fn clone(&self) -> Self {
-        TcpConnectorFactory(PhantomData)
-    }
-}
-
-impl<T: Address> ServiceFactory<Connect<T>> for TcpConnectorFactory<T> {
     type Response = Connection<T, TcpStream>;
     type Error = ConnectError;
     type Config = ();
-    type Service = TcpConnector<T>;
+    type Service = TcpConnector;
     type InitError = ();
-    type Future = Ready<Result<Self::Service, Self::InitError>>;
+    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
 
     fn new_service(&self, _: ()) -> Self::Future {
-        ready(Ok(self.service()))
+        let service = self.service();
+        Box::pin(async move { Ok(service) })
     }
 }
 
 /// TCP connector service
-#[derive(Default, Debug)]
+#[derive(Debug, Copy, Clone)]
-pub struct TcpConnector<T>(PhantomData<T>);
+pub struct TcpConnector;
 
-impl<T> TcpConnector<T> {
+impl<T: Address> Service<Connect<T>> for TcpConnector {
-    pub fn new() -> Self {
-        TcpConnector(PhantomData)
-    }
-}
-
-impl<T> Clone for TcpConnector<T> {
-    fn clone(&self) -> Self {
-        TcpConnector(PhantomData)
-    }
-}
-
-impl<T: Address> Service<Connect<T>> for TcpConnector<T> {
     type Response = Connection<T, TcpStream>;
     type Error = ConnectError;
     type Future = TcpConnectorResponse<T>;
 
     actix_service::always_ready!();
 
-    fn call(&mut self, req: Connect<T>) -> Self::Future {
+    fn call(&self, req: Connect<T>) -> Self::Future {
         let port = req.port();
         let Connect { req, addr, .. } = req;
 
-        if let Some(addr) = addr {
+        TcpConnectorResponse::new(req, port, addr)
-            TcpConnectorResponse::new(req, port, addr)
-        } else {
-            error!("TCP connector: got unresolved address");
-            TcpConnectorResponse::Error(Some(ConnectError::Unresolved))
-        }
     }
 }
 
-type LocalBoxFuture<'a, T> = Pin<Box<dyn Future<Output = T> + 'a>>;
-
-#[doc(hidden)]
 /// TCP stream connector response future
 pub enum TcpConnectorResponse<T> {
     Response {
         req: Option<T>,
         port: u16,
         addrs: Option<VecDeque<SocketAddr>>,
-        stream: Option<LocalBoxFuture<'static, Result<TcpStream, io::Error>>>,
+        stream: Option<ReusableBoxFuture<Result<TcpStream, io::Error>>>,
     },
     Error(Option<ConnectError>),
 }
 
 impl<T: Address> TcpConnectorResponse<T> {
-    pub fn new(
+    pub(crate) fn new(req: T, port: u16, addr: ConnectAddrs) -> TcpConnectorResponse<T> {
-        req: T,
+        if addr.is_none() {
-        port: u16,
+            error!("TCP connector: unresolved connection address");
-        addr: either::Either<SocketAddr, VecDeque<SocketAddr>>,
+            return TcpConnectorResponse::Error(Some(ConnectError::Unresolved));
-    ) -> TcpConnectorResponse<T> {
+        }
+
         trace!(
-            "TCP connector - connecting to {:?} port:{}",
+            "TCP connector: connecting to {} on port {}",
-            req.host(),
+            req.hostname(),
             port
         );
 
         match addr {
-            either::Either::Left(addr) => TcpConnectorResponse::Response {
+            ConnectAddrs::None => unreachable!("none variant already checked"),
+
+            ConnectAddrs::One(addr) => TcpConnectorResponse::Response {
                 req: Some(req),
                 port,
                 addrs: None,
-                stream: Some(Box::pin(TcpStream::connect(addr))),
+                stream: Some(ReusableBoxFuture::new(TcpStream::connect(addr))),
             },
-            either::Either::Right(addrs) => TcpConnectorResponse::Response {
+
+            // 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),
@@ -137,10 +110,9 @@ impl<T: Address> Future for TcpConnectorResponse<T> {
     type Output = Result<Connection<T, TcpStream>, ConnectError>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.get_mut();
+        match self.get_mut() {
-        match this {
+            TcpConnectorResponse::Error(err) => Poll::Ready(Err(err.take().unwrap())),
-            TcpConnectorResponse::Error(e) => Poll::Ready(Err(e.take().unwrap())),
+
-            // connect
             TcpConnectorResponse::Response {
                 req,
                 port,
@@ -148,24 +120,26 @@ impl<T: Address> Future for TcpConnectorResponse<T> {
                 stream,
             } => loop {
                 if let Some(new) = stream.as_mut() {
-                    match new.as_mut().poll(cx) {
+                    match ready!(new.poll(cx)) {
-                        Poll::Ready(Ok(sock)) => {
+                        Ok(sock) => {
                             let req = req.take().unwrap();
                             trace!(
-                                "TCP connector - successfully connected to connecting to {:?} - {:?}",
+                                "TCP connector: successfully connected to {:?} - {:?}",
-                                req.host(), sock.peer_addr()
+                                req.hostname(),
+                                sock.peer_addr()
                             );
                             return Poll::Ready(Ok(Connection::new(sock, req)));
                         }
-                        Poll::Pending => return Poll::Pending,
+
-                        Poll::Ready(Err(err)) => {
+                        Err(err) => {
                             trace!(
-                                "TCP connector - failed to connect to connecting to {:?} port: {}",
+                                "TCP connector: failed to connect to {:?} port: {}",
-                                req.as_ref().unwrap().host(),
+                                req.as_ref().unwrap().hostname(),
                                 port,
                             );
+
                             if addrs.is_none() || addrs.as_ref().unwrap().is_empty() {
-                                return Poll::Ready(Err(err.into()));
+                                return Poll::Ready(Err(ConnectError::Io(err)));
                             }
                         }
                     }
@@ -173,7 +147,11 @@ impl<T: Address> Future for TcpConnectorResponse<T> {
 
                 // try to connect
                 let addr = addrs.as_mut().unwrap().pop_front().unwrap();
-                *stream = Some(Box::pin(TcpStream::connect(addr)));
+
+                match stream {
+                    Some(rbf) => rbf.set(TcpStream::connect(addr)),
+                    None => *stream = Some(ReusableBoxFuture::new(TcpStream::connect(addr))),
+                }
             },
         }
     }

actix-tls/src/connect/error.rs

@@ -1,13 +1,12 @@
 use std::io;
 
-use derive_more::{Display, From};
+use derive_more::Display;
-use trust_dns_resolver::error::ResolveError;
 
-#[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<dyn std::error::Error>),
 
     /// No dns records
     #[display(fmt = "No dns records found for the input")]

actix-tls/src/connect/mod.rs

@@ -1,10 +1,21 @@
-//! TCP connector service for Actix ecosystem.
+//! TCP connector services for Actix ecosystem.
 //!
-//! ## Package feature
+//! # 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;
@@ -14,67 +25,26 @@ pub mod ssl;
 #[cfg(feature = "uri")]
 mod uri;
 
-use actix_rt::{net::TcpStream, Arbiter};
+use actix_rt::net::TcpStream;
 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::resolve::{Resolve, Resolver, ResolverFactory};
 pub use self::service::{ConnectService, ConnectServiceFactory, TcpConnectService};
 
-pub async fn start_resolver(
-    cfg: ResolverConfig,
-    opts: ResolverOpts,
-) -> Result<AsyncResolver, ConnectError> {
-    Ok(AsyncResolver::tokio(cfg, opts)?)
-}
-
-struct DefaultResolver(AsyncResolver);
-
-pub(crate) async fn get_default_resolver() -> Result<AsyncResolver, ConnectError> {
-    if Arbiter::contains_item::<DefaultResolver>() {
-        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)?;
-
-        Arbiter::set_item(DefaultResolver(resolver.clone()));
-        Ok(resolver)
-    }
-}
-
-pub async fn start_default_resolver() -> Result<AsyncResolver, ConnectError> {
-    get_default_resolver().await
-}
-
 /// Create TCP connector service.
 pub fn new_connector<T: Address + 'static>(
-    resolver: AsyncResolver,
+    resolver: Resolver,
 ) -> impl Service<Connect<T>, Response = Connection<T, TcpStream>, Error = ConnectError> + Clone
 {
-    pipeline(Resolver::new(resolver)).and_then(TcpConnector::new())
+    pipeline(resolver).and_then(TcpConnector)
 }
 
 /// Create TCP connector service factory.
 pub fn new_connector_factory<T: Address + 'static>(
-    resolver: AsyncResolver,
+    resolver: Resolver,
 ) -> impl ServiceFactory<
     Connect<T>,
     Config = (),
@@ -82,14 +52,14 @@ pub fn new_connector_factory<T: Address + 'static>(
     Error = ConnectError,
     InitError = (),
 > + Clone {
-    pipeline_factory(ResolverFactory::new(resolver)).and_then(TcpConnectorFactory::new())
+    pipeline_factory(ResolverFactory::new(resolver)).and_then(TcpConnectorFactory)
 }
 
 /// Create connector service with default parameters.
 pub fn default_connector<T: Address + 'static>(
 ) -> impl Service<Connect<T>, Response = Connection<T, TcpStream>, Error = ConnectError> + Clone
 {
-    pipeline(Resolver::default()).and_then(TcpConnector::new())
+    new_connector(Resolver::Default)
 }
 
 /// Create connector service factory with default parameters.
@@ -100,5 +70,5 @@ pub fn default_connector_factory<T: Address + 'static>() -> impl ServiceFactory<
     Error = ConnectError,
     InitError = (),
 > + Clone {
-    pipeline_factory(ResolverFactory::default()).and_then(TcpConnectorFactory::new())
+    new_connector_factory(Resolver::Default)
 }

actix-tls/src/connect/resolve.rs

@@ -1,188 +1,232 @@
-use std::future::Future;
+use std::{
-use std::marker::PhantomData;
+    future::Future,
-use std::net::SocketAddr;
+    io,
-use std::pin::Pin;
+    net::SocketAddr,
-use std::task::{Context, Poll};
+    pin::Pin,
+    rc::Rc,
+    task::{Context, Poll},
+    vec::IntoIter,
+};
 
+use actix_rt::task::{spawn_blocking, JoinHandle};
 use actix_service::{Service, ServiceFactory};
-use futures_util::future::{ok, Either, Ready};
+use futures_core::{future::LocalBoxFuture, ready};
 use log::trace;
-use trust_dns_resolver::TokioAsyncResolver as AsyncResolver;
-use trust_dns_resolver::{error::ResolveError, lookup_ip::LookupIp};
 
 use super::connect::{Address, Connect};
 use super::error::ConnectError;
-use super::get_default_resolver;
 
-/// DNS Resolver Service factory
+/// DNS Resolver Service Factory
-pub struct ResolverFactory<T> {
+#[derive(Clone)]
-    resolver: Option<AsyncResolver>,
+pub struct ResolverFactory {
-    _t: PhantomData<T>,
+    resolver: Resolver,
 }
 
-impl<T> ResolverFactory<T> {
+impl ResolverFactory {
-    /// Create new resolver instance with custom configuration and options.
+    pub fn new(resolver: Resolver) -> Self {
-    pub fn new(resolver: AsyncResolver) -> Self {
+        Self { resolver }
-        ResolverFactory {
-            resolver: Some(resolver),
-            _t: PhantomData,
-        }
     }
 
-    pub fn service(&self) -> Resolver<T> {
+    pub fn service(&self) -> Resolver {
-        Resolver {
+        self.resolver.clone()
-            resolver: self.resolver.clone(),
-            _t: PhantomData,
-        }
     }
 }
 
-impl<T> Default for ResolverFactory<T> {
+impl<T: Address> ServiceFactory<Connect<T>> for ResolverFactory {
-    fn default() -> Self {
-        ResolverFactory {
-            resolver: None,
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T> Clone for ResolverFactory<T> {
-    fn clone(&self) -> Self {
-        ResolverFactory {
-            resolver: self.resolver.clone(),
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T: Address> ServiceFactory<Connect<T>> for ResolverFactory<T> {
     type Response = Connect<T>;
     type Error = ConnectError;
     type Config = ();
-    type Service = Resolver<T>;
+    type Service = Resolver;
     type InitError = ();
-    type Future = Ready<Result<Self::Service, Self::InitError>>;
+    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
 
     fn new_service(&self, _: ()) -> Self::Future {
-        ok(self.service())
+        let service = self.resolver.clone();
+        Box::pin(async { Ok(service) })
     }
 }
 
 /// DNS Resolver Service
-pub struct Resolver<T> {
+#[derive(Clone)]
-    resolver: Option<AsyncResolver>,
+pub enum Resolver {
-    _t: PhantomData<T>,
+    Default,
+    Custom(Rc<dyn Resolve>),
 }
 
-impl<T> Resolver<T> {
+/// An interface for custom async DNS resolvers.
-    /// Create new resolver instance with custom configuration and options.
+///
-    pub fn new(resolver: AsyncResolver) -> Self {
+/// # Usage
-        Resolver {
+/// ```rust
-            resolver: Some(resolver),
+/// use std::net::SocketAddr;
-            _t: PhantomData,
+///
-        }
+/// 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<Vec<SocketAddr>, Box<dyn std::error::Error>>> {
+///         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<Vec<SocketAddr>, Box<dyn std::error::Error>>>;
+}
+
+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<T: Address>(req: &Connect<T>) -> JoinHandle<io::Result<IntoIter<SocketAddr>>> {
+        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::<u16>().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<T> Default for Resolver<T> {
+impl<T: Address> Service<Connect<T>> for Resolver {
-    fn default() -> Self {
-        Resolver {
-            resolver: None,
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T> Clone for Resolver<T> {
-    fn clone(&self) -> Self {
-        Resolver {
-            resolver: self.resolver.clone(),
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T: Address> Service<Connect<T>> for Resolver<T> {
     type Response = Connect<T>;
     type Error = ConnectError;
-    #[allow(clippy::type_complexity)]
+    type Future = ResolverFuture<T>;
-    type Future = Either<
-        Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>,
-        Ready<Result<Connect<T>, Self::Error>>,
-    >;
 
     actix_service::always_ready!();
 
-    fn call(&mut self, mut req: Connect<T>) -> Self::Future {
+    fn call(&self, req: Connect<T>) -> Self::Future {
         if req.addr.is_some() {
-            Either::Right(ok(req))
+            ResolverFuture::Connected(Some(req))
-        } else if let Ok(ip) = req.host().parse() {
+        } else if let Ok(ip) = req.hostname().parse() {
-            req.addr = Some(either::Either::Left(SocketAddr::new(ip, req.port())));
+            let addr = SocketAddr::new(ip, req.port());
-            Either::Right(ok(req))
+            let req = req.set_addr(Some(addr));
+            ResolverFuture::Connected(Some(req))
         } else {
-            let resolver = self.resolver.as_ref().map(AsyncResolver::clone);
+            trace!("DNS resolver: resolving host {:?}", req.hostname());
-            Either::Left(Box::pin(async move {
+
-                trace!("DNS resolver: resolving host {:?}", req.host());
+            match self {
-                let resolver = if let Some(resolver) = resolver {
+                Self::Default => {
-                    resolver
+                    let fut = Self::look_up(&req);
-                } else {
+                    ResolverFuture::LookUp(fut, Some(req))
-                    get_default_resolver()
+                }
-                        .await
+
-                        .expect("Failed to get default resolver")
+                Self::Custom(resolver) => {
-                };
+                    let resolver = Rc::clone(&resolver);
-                ResolverFuture::new(req, &resolver).await
+                    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)
+                        }
+                    }))
+                }
+            }
         }
     }
 }
 
-type LookupIpFuture = Pin<Box<dyn Future<Output = Result<LookupIp, ResolveError>>>>;
+pub enum ResolverFuture<T: Address> {
-
+    Connected(Option<Connect<T>>),
-#[doc(hidden)]
+    LookUp(
-/// Resolver future
+        JoinHandle<io::Result<IntoIter<SocketAddr>>>,
-pub struct ResolverFuture<T: Address> {
+        Option<Connect<T>>,
-    req: Option<Connect<T>>,
+    ),
-    lookup: LookupIpFuture,
+    LookupCustom(LocalBoxFuture<'static, Result<Connect<T>, ConnectError>>),
-}
-
-impl<T: Address> ResolverFuture<T> {
-    pub fn new(req: Connect<T>, 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<T: Address> Future for ResolverFuture<T> {
     type Output = Result<Connect<T>, ConnectError>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.get_mut();
+        match self.get_mut() {
+            Self::Connected(conn) => Poll::Ready(Ok(conn
+                .take()
+                .expect("ResolverFuture polled after finished"))),
 
-        match Pin::new(&mut this.lookup).poll(cx) {
+            Self::LookUp(fut, req) => {
-            Poll::Pending => Poll::Pending,
+                let res = match ready!(Pin::new(fut).poll(cx)) {
-            Poll::Ready(Ok(ips)) => {
+                    Ok(Ok(res)) => Ok(res),
-                let req = this.req.take().unwrap();
+                    Ok(Err(e)) => Err(ConnectError::Resolver(Box::new(e))),
-                let port = req.port();
+                    Err(e) => Err(ConnectError::Io(e.into())),
-                let req = req.set_addrs(ips.iter().map(|ip| SocketAddr::new(ip, port)));
+                };
+
+                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.host(),
+                    req.hostname(),
                     req.addrs()
                 );
 
@@ -192,14 +236,8 @@ impl<T: Address> Future for ResolverFuture<T> {
                     Poll::Ready(Ok(req))
                 }
             }
-            Poll::Ready(Err(e)) => {
+
-                trace!(
+            Self::LookupCustom(fut) => fut.as_mut().poll(cx),
-                    "DNS resolver: failed to resolve host {:?} err: {}",
-                    this.req.as_ref().unwrap().host(),
-                    e
-                );
-                Poll::Ready(Err(e.into()))
-            }
         }
     }
 }

actix-tls/src/connect/service.rs

@@ -1,42 +1,34 @@
-use std::future::Future;
+use std::{
-use std::pin::Pin;
+    future::Future,
-use std::task::{Context, Poll};
+    pin::Pin,
+    task::{Context, Poll},
+};
 
 use actix_rt::net::TcpStream;
 use actix_service::{Service, ServiceFactory};
-use either::Either;
+use futures_core::{future::LocalBoxFuture, ready};
-use futures_util::future::{ok, Ready};
-use trust_dns_resolver::TokioAsyncResolver as AsyncResolver;
 
 use super::connect::{Address, Connect, Connection};
 use super::connector::{TcpConnector, TcpConnectorFactory};
 use super::error::ConnectError;
 use super::resolve::{Resolver, ResolverFactory};
 
-pub struct ConnectServiceFactory<T> {
+pub struct ConnectServiceFactory {
-    tcp: TcpConnectorFactory<T>,
+    tcp: TcpConnectorFactory,
-    resolver: ResolverFactory<T>,
+    resolver: ResolverFactory,
 }
 
-impl<T> ConnectServiceFactory<T> {
+impl ConnectServiceFactory {
     /// Construct new ConnectService factory
-    pub fn new() -> Self {
+    pub fn new(resolver: Resolver) -> Self {
         ConnectServiceFactory {
-            tcp: TcpConnectorFactory::default(),
+            tcp: TcpConnectorFactory,
-            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<T> {
+    pub fn service(&self) -> ConnectService {
         ConnectService {
             tcp: self.tcp.service(),
             resolver: self.resolver.service(),
@@ -44,7 +36,7 @@ impl<T> ConnectServiceFactory<T> {
     }
 
     /// Construct new tcp stream service
-    pub fn tcp_service(&self) -> TcpConnectService<T> {
+    pub fn tcp_service(&self) -> TcpConnectService {
         TcpConnectService {
             tcp: self.tcp.service(),
             resolver: self.resolver.service(),
@@ -52,174 +44,135 @@ impl<T> ConnectServiceFactory<T> {
     }
 }
 
-impl<T> Default for ConnectServiceFactory<T> {
+impl Clone for ConnectServiceFactory {
-    fn default() -> Self {
-        ConnectServiceFactory {
-            tcp: TcpConnectorFactory::default(),
-            resolver: ResolverFactory::default(),
-        }
-    }
-}
-
-impl<T> Clone for ConnectServiceFactory<T> {
     fn clone(&self) -> Self {
         ConnectServiceFactory {
-            tcp: self.tcp.clone(),
+            tcp: self.tcp,
             resolver: self.resolver.clone(),
         }
     }
 }
 
-impl<T: Address> ServiceFactory<Connect<T>> for ConnectServiceFactory<T> {
+impl<T: Address> ServiceFactory<Connect<T>> for ConnectServiceFactory {
     type Response = Connection<T, TcpStream>;
     type Error = ConnectError;
     type Config = ();
-    type Service = ConnectService<T>;
+    type Service = ConnectService;
     type InitError = ();
-    type Future = Ready<Result<Self::Service, Self::InitError>>;
+    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
 
     fn new_service(&self, _: ()) -> Self::Future {
-        ok(self.service())
+        let service = self.service();
+        Box::pin(async move { Ok(service) })
     }
 }
 
 #[derive(Clone)]
-pub struct ConnectService<T> {
+pub struct ConnectService {
-    tcp: TcpConnector<T>,
+    tcp: TcpConnector,
-    resolver: Resolver<T>,
+    resolver: Resolver,
 }
 
-impl<T: Address> Service<Connect<T>> for ConnectService<T> {
+impl<T: Address> Service<Connect<T>> for ConnectService {
     type Response = Connection<T, TcpStream>;
     type Error = ConnectError;
     type Future = ConnectServiceResponse<T>;
 
     actix_service::always_ready!();
 
-    fn call(&mut self, req: Connect<T>) -> Self::Future {
+    fn call(&self, req: Connect<T>) -> Self::Future {
         ConnectServiceResponse {
-            state: ConnectState::Resolve(self.resolver.call(req)),
+            fut: ConnectFuture::Resolve(self.resolver.call(req)),
-            tcp: self.tcp.clone(),
+            tcp: self.tcp,
         }
     }
 }
 
-enum ConnectState<T: Address> {
+// helper enum to generic over futures of resolve and connect phase.
-    Resolve(<Resolver<T> as Service<Connect<T>>>::Future),
+pub(crate) enum ConnectFuture<T: Address> {
-    Connect(<TcpConnector<T> as Service<Connect<T>>>::Future),
+    Resolve(<Resolver as Service<Connect<T>>>::Future),
+    Connect(<TcpConnector as Service<Connect<T>>>::Future),
 }
 
-impl<T: Address> ConnectState<T> {
+// helper enum to contain the future output of ConnectFuture
-    #[allow(clippy::type_complexity)]
+pub(crate) enum ConnectOutput<T: Address> {
-    fn poll(
+    Resolved(Connect<T>),
+    Connected(Connection<T, TcpStream>),
+}
+
+impl<T: Address> ConnectFuture<T> {
+    fn poll_connect(
         &mut self,
         cx: &mut Context<'_>,
-    ) -> Either<Poll<Result<Connection<T, TcpStream>, ConnectError>>, Connect<T>> {
+    ) -> Poll<Result<ConnectOutput<T>, ConnectError>> {
         match self {
-            ConnectState::Resolve(ref mut fut) => match Pin::new(fut).poll(cx) {
+            ConnectFuture::Resolve(ref mut fut) => {
-                Poll::Pending => Either::Left(Poll::Pending),
+                Pin::new(fut).poll(cx).map_ok(ConnectOutput::Resolved)
-                Poll::Ready(Ok(res)) => Either::Right(res),
+            }
-                Poll::Ready(Err(err)) => Either::Left(Poll::Ready(Err(err))),
+            ConnectFuture::Connect(ref mut fut) => {
-            },
+                Pin::new(fut).poll(cx).map_ok(ConnectOutput::Connected)
-            ConnectState::Connect(ref mut fut) => Either::Left(Pin::new(fut).poll(cx)),
+            }
         }
     }
 }
 
 pub struct ConnectServiceResponse<T: Address> {
-    state: ConnectState<T>,
+    fut: ConnectFuture<T>,
-    tcp: TcpConnector<T>,
+    tcp: TcpConnector,
 }
 
 impl<T: Address> Future for ConnectServiceResponse<T> {
     type Output = Result<Connection<T, TcpStream>, ConnectError>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let res = match self.state.poll(cx) {
+        loop {
-            Either::Right(res) => {
+            match ready!(self.fut.poll_connect(cx))? {
-                self.state = ConnectState::Connect(self.tcp.call(res));
+                ConnectOutput::Resolved(res) => {
-                self.state.poll(cx)
+                    self.fut = ConnectFuture::Connect(self.tcp.call(res));
+                }
+                ConnectOutput::Connected(res) => return Poll::Ready(Ok(res)),
             }
-            Either::Left(res) => return res,
-        };
-
-        match res {
-            Either::Left(res) => res,
-            Either::Right(_) => panic!(),
         }
     }
 }
 
 #[derive(Clone)]
-pub struct TcpConnectService<T> {
+pub struct TcpConnectService {
-    tcp: TcpConnector<T>,
+    tcp: TcpConnector,
-    resolver: Resolver<T>,
+    resolver: Resolver,
 }
 
-impl<T: Address + 'static> Service<Connect<T>> for TcpConnectService<T> {
+impl<T: Address> Service<Connect<T>> for TcpConnectService {
     type Response = TcpStream;
     type Error = ConnectError;
     type Future = TcpConnectServiceResponse<T>;
 
     actix_service::always_ready!();
 
-    fn call(&mut self, req: Connect<T>) -> Self::Future {
+    fn call(&self, req: Connect<T>) -> Self::Future {
         TcpConnectServiceResponse {
-            state: TcpConnectState::Resolve(self.resolver.call(req)),
+            fut: ConnectFuture::Resolve(self.resolver.call(req)),
-            tcp: self.tcp.clone(),
+            tcp: self.tcp,
         }
     }
 }
 
-enum TcpConnectState<T: Address> {
-    Resolve(<Resolver<T> as Service<Connect<T>>>::Future),
-    Connect(<TcpConnector<T> as Service<Connect<T>>>::Future),
-}
-
-impl<T: Address> TcpConnectState<T> {
-    fn poll(
-        &mut self,
-        cx: &mut Context<'_>,
-    ) -> Either<Poll<Result<TcpStream, ConnectError>>, Connect<T>> {
-        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<T: Address> {
-    state: TcpConnectState<T>,
+    fut: ConnectFuture<T>,
-    tcp: TcpConnector<T>,
+    tcp: TcpConnector,
 }
 
 impl<T: Address> Future for TcpConnectServiceResponse<T> {
     type Output = Result<TcpStream, ConnectError>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let res = match self.state.poll(cx) {
+        loop {
-            Either::Right(res) => {
+            match ready!(self.fut.poll_connect(cx))? {
-                self.state = TcpConnectState::Connect(self.tcp.call(res));
+                ConnectOutput::Resolved(res) => {
-                self.state.poll(cx)
+                    self.fut = ConnectFuture::Connect(self.tcp.call(res));
+                }
+                ConnectOutput::Connected(conn) => return Poll::Ready(Ok(conn.into_parts().0)),
             }
-            Either::Left(res) => return res,
-        };
-
-        match res {
-            Either::Left(res) => res,
-            Either::Right(_) => panic!(),
         }
     }
 }

actix-tls/src/connect/ssl/openssl.rs

@@ -1,23 +1,23 @@
-use std::future::Future;
+use std::{
-use std::marker::PhantomData;
+    fmt,
-use std::pin::Pin;
+    future::Future,
-use std::task::{Context, Poll};
+    io,
-use std::{fmt, io};
+    pin::Pin,
+    task::{Context, Poll},
+};
 
 use actix_codec::{AsyncRead, AsyncWrite};
 use actix_rt::net::TcpStream;
 use actix_service::{Service, ServiceFactory};
-use futures_util::{
+use futures_core::{future::LocalBoxFuture, ready};
-    future::{ready, Either, Ready},
-    ready,
-};
 use log::trace;
+
 pub use openssl::ssl::{Error as SslError, HandshakeError, SslConnector, SslMethod};
 pub use tokio_openssl::SslStream;
-use trust_dns_resolver::TokioAsyncResolver as AsyncResolver;
 
+use crate::connect::resolve::Resolve;
 use crate::connect::{
-    Address, Connect, ConnectError, ConnectService, ConnectServiceFactory, Connection,
+    Address, Connect, ConnectError, ConnectService, ConnectServiceFactory, Connection, Resolver,
 };
 
 /// OpenSSL connector factory
@@ -29,9 +29,7 @@ impl OpensslConnector {
     pub fn new(connector: SslConnector) -> Self {
         OpensslConnector { connector }
     }
-}
 
-impl OpensslConnector {
     pub fn service(connector: SslConnector) -> OpensslConnectorService {
         OpensslConnectorService { connector }
     }
@@ -55,12 +53,11 @@ where
     type Config = ();
     type Service = OpensslConnectorService;
     type InitError = ();
-    type Future = Ready<Result<Self::Service, Self::InitError>>;
+    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
 
     fn new_service(&self, _: ()) -> Self::Future {
-        ready(Ok(OpensslConnectorService {
+        let connector = self.connector.clone();
-            connector: self.connector.clone(),
+        Box::pin(async { Ok(OpensslConnectorService { connector }) })
-        }))
     }
 }
 
@@ -83,29 +80,27 @@ where
 {
     type Response = Connection<T, SslStream<U>>;
     type Error = io::Error;
-    #[allow(clippy::type_complexity)]
+    type Future = ConnectAsyncExt<T, U>;
-    type Future = Either<ConnectAsyncExt<T, U>, Ready<Result<Self::Response, Self::Error>>>;
 
     actix_service::always_ready!();
 
-    fn call(&mut self, stream: Connection<T, U>) -> Self::Future {
+    fn call(&self, stream: Connection<T, U>) -> Self::Future {
         trace!("SSL Handshake start for: {:?}", stream.host());
-        let (io, stream) = stream.replace(());
+        let (io, stream) = stream.replace_io(());
-        let host = stream.host().to_string();
+        let host = stream.host();
 
-        match self.connector.configure() {
+        let config = self
-            Err(e) => Either::Right(ready(Err(io::Error::new(io::ErrorKind::Other, e)))),
+            .connector
-            Ok(config) => {
+            .configure()
-                let ssl = config
+            .expect("SSL connect configuration was invalid.");
-                    .into_ssl(&host)
-                    .expect("SSL connect configuration was invalid.");
 
-                Either::Left(ConnectAsyncExt {
+        let ssl = config
-                    io: Some(SslStream::new(ssl, io).unwrap()),
+            .into_ssl(host)
-                    stream: Some(stream),
+            .expect("SSL connect configuration was invalid.");
-                    _t: PhantomData,
+
-                })
+        ConnectAsyncExt {
-            }
+            io: Some(SslStream::new(ssl, io).unwrap()),
+            stream: Some(stream),
         }
     }
 }
@@ -113,7 +108,6 @@ where
 pub struct ConnectAsyncExt<T, U> {
     io: Option<SslStream<U>>,
     stream: Option<Connection<T, ()>>,
-    _t: PhantomData<U>,
 }
 
 impl<T: Address, U> Future for ConnectAsyncExt<T, U>
@@ -129,7 +123,7 @@ where
             Ok(_) => {
                 let stream = this.stream.take().unwrap();
                 trace!("SSL Handshake success: {:?}", stream.host());
-                Poll::Ready(Ok(stream.replace(this.io.take().unwrap()).1))
+                Poll::Ready(Ok(stream.replace_io(this.io.take().unwrap()).1))
             }
             Err(e) => {
                 trace!("SSL Handshake error: {:?}", e);
@@ -139,30 +133,30 @@ where
     }
 }
 
-pub struct OpensslConnectServiceFactory<T> {
+pub struct OpensslConnectServiceFactory {
-    tcp: ConnectServiceFactory<T>,
+    tcp: ConnectServiceFactory,
     openssl: OpensslConnector,
 }
 
-impl<T> OpensslConnectServiceFactory<T> {
+impl OpensslConnectServiceFactory {
     /// Construct new OpensslConnectService factory
     pub fn new(connector: SslConnector) -> Self {
         OpensslConnectServiceFactory {
-            tcp: ConnectServiceFactory::default(),
+            tcp: ConnectServiceFactory::new(Resolver::Default),
             openssl: OpensslConnector::new(connector),
         }
     }
 
     /// Construct new connect service with custom DNS resolver
-    pub fn with_resolver(connector: SslConnector, resolver: AsyncResolver) -> Self {
+    pub fn with_resolver(connector: SslConnector, resolver: impl Resolve + 'static) -> Self {
         OpensslConnectServiceFactory {
-            tcp: ConnectServiceFactory::with_resolver(resolver),
+            tcp: ConnectServiceFactory::new(Resolver::new_custom(resolver)),
             openssl: OpensslConnector::new(connector),
         }
     }
 
     /// Construct OpenSSL connect service
-    pub fn service(&self) -> OpensslConnectService<T> {
+    pub fn service(&self) -> OpensslConnectService {
         OpensslConnectService {
             tcp: self.tcp.service(),
             openssl: OpensslConnectorService {
@@ -172,7 +166,7 @@ impl<T> OpensslConnectServiceFactory<T> {
     }
 }
 
-impl<T> Clone for OpensslConnectServiceFactory<T> {
+impl Clone for OpensslConnectServiceFactory {
     fn clone(&self) -> Self {
         OpensslConnectServiceFactory {
             tcp: self.tcp.clone(),
@@ -181,33 +175,34 @@ impl<T> Clone for OpensslConnectServiceFactory<T> {
     }
 }
 
-impl<T: Address + 'static> ServiceFactory<Connect<T>> for OpensslConnectServiceFactory<T> {
+impl<T: Address + 'static> ServiceFactory<Connect<T>> for OpensslConnectServiceFactory {
     type Response = SslStream<TcpStream>;
     type Error = ConnectError;
     type Config = ();
-    type Service = OpensslConnectService<T>;
+    type Service = OpensslConnectService;
     type InitError = ();
-    type Future = Ready<Result<Self::Service, Self::InitError>>;
+    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
 
     fn new_service(&self, _: ()) -> Self::Future {
-        ready(Ok(self.service()))
+        let service = self.service();
+        Box::pin(async { Ok(service) })
     }
 }
 
 #[derive(Clone)]
-pub struct OpensslConnectService<T> {
+pub struct OpensslConnectService {
-    tcp: ConnectService<T>,
+    tcp: ConnectService,
     openssl: OpensslConnectorService,
 }
 
-impl<T: Address + 'static> Service<Connect<T>> for OpensslConnectService<T> {
+impl<T: Address + 'static> Service<Connect<T>> for OpensslConnectService {
     type Response = SslStream<TcpStream>;
     type Error = ConnectError;
     type Future = OpensslConnectServiceResponse<T>;
 
     actix_service::always_ready!();
 
-    fn call(&mut self, req: Connect<T>) -> Self::Future {
+    fn call(&self, req: Connect<T>) -> Self::Future {
         OpensslConnectServiceResponse {
             fut1: Some(self.tcp.call(req)),
             fut2: None,
@@ -217,7 +212,7 @@ impl<T: Address + 'static> Service<Connect<T>> for OpensslConnectService<T> {
 }
 
 pub struct OpensslConnectServiceResponse<T: Address + 'static> {
-    fut1: Option<<ConnectService<T> as Service<Connect<T>>>::Future>,
+    fut1: Option<<ConnectService as Service<Connect<T>>>::Future>,
     fut2: Option<<OpensslConnectorService as Service<Connection<T, TcpStream>>>::Future>,
     openssl: OpensslConnectorService,
 }

actix-tls/src/connect/ssl/rustls.rs

@@ -1,21 +1,21 @@
-use std::fmt;
+use std::{
-use std::future::Future;
+    fmt,
-use std::pin::Pin;
+    future::Future,
-use std::sync::Arc;
+    pin::Pin,
-use std::task::{Context, Poll};
+    sync::Arc,
+    task::{Context, Poll},
+};
 
-pub use rustls::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::{
+use futures_core::{future::LocalBoxFuture, ready};
-    future::{ready, Ready},
-    ready,
-};
 use log::trace;
+use tokio_rustls::webpki::DNSNameRef;
 use tokio_rustls::{Connect, TlsConnector};
-use webpki::DNSNameRef;
 
 use crate::connect::{Address, Connection};
 
@@ -53,12 +53,11 @@ where
     type Config = ();
     type Service = RustlsConnectorService;
     type InitError = ();
-    type Future = Ready<Result<Self::Service, Self::InitError>>;
+    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
 
     fn new_service(&self, _: ()) -> Self::Future {
-        ready(Ok(RustlsConnectorService {
+        let connector = self.connector.clone();
-            connector: self.connector.clone(),
+        Box::pin(async { Ok(RustlsConnectorService { connector }) })
-        }))
     }
 }
 
@@ -85,9 +84,9 @@ where
 
     actix_service::always_ready!();
 
-    fn call(&mut self, stream: Connection<T, U>) -> Self::Future {
+    fn call(&self, stream: Connection<T, U>) -> 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 {
@@ -114,6 +113,6 @@ where
         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(stream).1))
+        Poll::Ready(Ok(s.replace_io(stream).1))
     }
 }

actix-tls/src/connect/uri.rs

@@ -3,35 +3,41 @@ use http::Uri;
 use super::Address;
 
 impl Address for Uri {
-    fn host(&self) -> &str {
+    fn hostname(&self) -> &str {
         self.host().unwrap_or("")
     }
 
     fn port(&self) -> Option<u16> {
-        if let Some(port) = self.port_u16() {
+        match self.port_u16() {
-            Some(port)
+            Some(port) => Some(port),
-        } else {
+            None => scheme_to_port(self.scheme_str()),
-            port(self.scheme_str())
         }
     }
 }
 
-// TODO: load data from file
+// Get port from well-known URL schemes.
-fn port(scheme: Option<&str>) -> Option<u16> {
+fn scheme_to_port(scheme: Option<&str>) -> Option<u16> {
-    if let Some(scheme) = scheme {
+    match scheme {
-        match scheme {
+        // HTTP
-            "http" => Some(80),
+        Some("http") => Some(80),
-            "https" => Some(443),
+        Some("https") => Some(443),
-            "ws" => Some(80),
+
-            "wss" => Some(443),
+        // WebSockets
-            "amqp" => Some(5672),
+        Some("ws") => Some(80),
-            "amqps" => Some(5671),
+        Some("wss") => Some(443),
-            "sb" => Some(5671),
+
-            "mqtt" => Some(1883),
+        // Advanced Message Queuing Protocol (AMQP)
-            "mqtts" => Some(8883),
+        Some("amqp") => Some(5672),
-            _ => None,
+        Some("amqps") => Some(5671),
-        }
+
-    } else {
+        // Message Queuing Telemetry Transport (MQTT)
-        None
+        Some("mqtt") => Some(1883),
+        Some("mqtts") => Some(8883),
+
+        // File Transfer Protocol (FTP)
+        Some("ftp") => Some(1883),
+        Some("ftps") => Some(990),
+
+        _ => None,
     }
 }

actix-tls/src/lib.rs

@@ -4,12 +4,8 @@
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
 
-#[cfg(feature = "native-tls")]
-extern crate tls_native_tls as native_tls;
 #[cfg(feature = "openssl")]
 extern crate tls_openssl as openssl;
-#[cfg(feature = "rustls")]
-extern crate tls_rustls as rustls;
 
 #[cfg(feature = "accept")]
 pub mod accept;

actix-tls/tests/test_connect.rs

@@ -7,11 +7,7 @@ use actix_service::{fn_service, Service, ServiceFactory};
 use bytes::Bytes;
 use futures_util::sink::SinkExt;
 
-use actix_tls::connect::{
+use actix_tls::connect::{self as actix_connect, Connect};
-    self as actix_connect,
-    resolver::{ResolverConfig, ResolverOpts},
-    Connect,
-};
 
 #[cfg(all(feature = "connect", feature = "openssl"))]
 #[actix_rt::test]
@@ -24,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());
@@ -41,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());
@@ -57,14 +53,17 @@ async fn test_static_str() {
         })
     });
 
-    let resolver = actix_connect::start_default_resolver().await.unwrap();
+    let conn = actix_connect::default_connector();
-    let mut conn = actix_connect::new_connector(resolver.clone());
 
-    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());
 }
@@ -79,15 +78,13 @@ async fn test_new_service() {
         })
     });
 
-    let resolver =
+    let factory = actix_connect::default_connector_factory();
-        actix_connect::start_resolver(ResolverConfig::default(), ResolverOpts::default())
-            .await
-            .unwrap();
 
-    let factory = actix_connect::new_connector_factory(resolver);
+    let conn = factory.new_service(()).await.unwrap();
-
+    let con = conn
-    let mut conn = factory.new_service(()).await.unwrap();
+        .call(Connect::with_addr("10", srv.addr()))
-    let con = conn.call(Connect::with("10", srv.addr())).await.unwrap();
+        .await
+        .unwrap();
     assert_eq!(con.peer_addr().unwrap(), srv.addr());
 }
 
@@ -104,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());
@@ -123,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());

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<Vec<SocketAddr>, Box<dyn std::error::Error>>> {
+            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<Vec<SocketAddr>, Box<dyn std::error::Error>>> {
+            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());
+}

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,12 +16,12 @@ name = "actix_tracing"
 path = "src/lib.rs"
 
 [dependencies]
-actix-service = "2.0.0-beta.2"
+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"
+actix-rt = "2.0.0"
 slab = "0.4"

actix-tracing/src/lib.rs

@@ -37,7 +37,7 @@ where
 
     actix_service::forward_ready!(inner);
 
-    fn call(&mut self, req: Req) -> Self::Future {
+    fn call(&self, req: Req) -> Self::Future {
         let span = (self.make_span)(&req);
         let _enter = span.as_ref().map(|s| s.enter());
 
@@ -229,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();

actix-utils/CHANGES.md

@@ -3,6 +3,12 @@
 ## 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]

actix-utils/Cargo.toml

@@ -1,12 +1,12 @@
 [package]
 name = "actix-utils"
-version = "3.0.0-beta.1"
+version = "3.0.0-beta.2"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 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"
@@ -17,8 +17,8 @@ path = "src/lib.rs"
 
 [dependencies]
 actix-codec = "0.4.0-beta.1"
-actix-rt = "2.0.0-beta.1"
+actix-rt = { version = "2.0.0", default-features = false }
-actix-service = "2.0.0-beta.2"
+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 }
@@ -26,4 +26,5 @@ log = "0.4"
 pin-project-lite = "0.2.0"
 
 [dev-dependencies]
+actix-rt = "2.0.0"
 futures-util = { version = "0.3.7", default-features = false }

actix-utils/src/task.rs

@@ -40,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();
@@ -58,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<Waker> {
         unsafe { (*self.waker.get()).take() }
     }

actix-utils/src/timeout.rs

@@ -151,7 +151,7 @@ where
 
     actix_service::forward_ready!(service);
 
-    fn call(&mut self, request: Req) -> Self::Future {
+    fn call(&self, request: Req) -> Self::Future {
         TimeoutServiceResponse {
             fut: self.service.call(request),
             sleep: sleep(self.timeout),
@@ -213,7 +213,7 @@ mod tests {
 
         actix_service::always_ready!();
 
-        fn call(&mut self, _: ()) -> Self::Future {
+        fn call(&self, _: ()) -> Self::Future {
             let sleep = actix_rt::time::sleep(self.0);
             Box::pin(async move {
                 sleep.await;
@@ -227,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(()));
     }
 
@@ -236,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));
     }
 
@@ -249,7 +249,7 @@ mod tests {
             Timeout::new(resolution),
             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));
     }

bytestring/Cargo.toml

@@ -10,7 +10,7 @@ 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/"
+documentation = "https://docs.rs/bytestring"
 license = "MIT OR Apache-2.0"
 edition = "2018"
 
@@ -24,4 +24,4 @@ serde = { version = "1.0", optional = true }
 
 [dev-dependencies]
 serde_json = "1.0"
-ahash = { version = "0.6", default-features = false }
+ahash = { version = "0.7", default-features = false }