Get dynamic segment by name instead of iterator

Improve Arbiter documentation

.travis.yml

@@ -10,9 +10,9 @@ matrix:
   include:
     - rust: stable
     - rust: beta
-    - rust: nightly
+    - rust: nightly-2019-03-02
   allow_failures:
-    - rust: nightly
+    - rust: nightly-2019-03-02
 
 env:
   global:
@@ -24,34 +24,26 @@ before_install:
   - sudo apt-get update -qq
   - sudo apt-get install -y openssl libssl-dev libelf-dev libdw-dev cmake gcc binutils-dev libiberty-dev
 
+before_cache: |
+  if [[ "$TRAVIS_RUST_VERSION" == "nightly-2019-03-02" ]]; then
+    RUSTFLAGS="--cfg procmacro2_semver_exempt" cargo install cargo-tarpaulin
+  fi
+
 # Add clippy
 before_script:
   - export PATH=$PATH:~/.cargo/bin
 
 script:
   - |
-    if [[ "$TRAVIS_RUST_VERSION" != "nightly" ]]; then
+    if [[ "$TRAVIS_RUST_VERSION" != "nightly-2019-03-02" ]]; then
     cargo clean
-    cargo test --features="ssl,tls,rust-tls" -- --nocapture
-    cd actix-codec && cargo test && cd ..
-    cd actix-service && cargo test && cd ..
-    cd actix-server && cargo test --all-features -- --nocapture && cd ..
-    cd actix-rt && cargo test && cd ..
-    cd actix-connector && cargo test && cd ..
-    cd actix-utils && cargo test && cd ..
-    cd router && cargo test && cd ..
+    cargo test --all --all-features -- --nocapture
     fi
+
+after_success:
   - |
-    if [[ "$TRAVIS_RUST_VERSION" == "nightly" ]]; then
-    RUSTFLAGS="--cfg procmacro2_semver_exempt" cargo install -f cargo-tarpaulin
-    cargo tarpaulin --features="ssl,tls,rust-tls" --out Xml
-    bash <(curl -s https://codecov.io/bash)
+    if [[ "$TRAVIS_RUST_VERSION" == "nightly-2019-03-02" ]]; then
+    taskset -c 0 cargo tarpaulin --all --all-features --out Xml
     echo "Uploaded code coverage"
-    cd actix-service && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash) && cd ..
-    cd actix-rt && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash) && cd ..
-    cd actix-connector && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash) && cd ..
-    cd actix-codec && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash) && cd ..
-    cd actix-server && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash) && cd ..
-    cd actix-utils && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash) && cd ..
-    cd router && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash) && cd ..
+    bash <(curl -s https://codecov.io/bash)
     fi

Cargo.toml

@@ -16,12 +16,13 @@ edition = "2018"
 [workspace]
 members = [
   "actix-codec",
-  "actix-connector",
+  "actix-connect",
   "actix-rt",
   "actix-service",
   "actix-server",
   "actix-server-config",
   "actix-test-server",
+  "actix-threadpool",
   "actix-utils",
   "router",
 ]

actix-codec/CHANGES.md

@@ -1,6 +1,11 @@
 # Changes
 
-## [0.1.0] - 2019-03-06
+## [0.1.2] - 2019-03-27
+
+* Added `Framed::map_io()` method.
+
+
+## [0.1.1] - 2019-03-06
 
 * Added `FramedParts::with_read_buffer()` method.
 

actix-codec/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-codec"
-version = "0.1.1"
+version = "0.1.2"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Utilities for encoding and decoding frames"
 keywords = ["network", "framework", "async", "futures"]
@@ -11,15 +11,15 @@ categories = ["network-programming", "asynchronous"]
 license = "MIT/Apache-2.0"
 exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
 edition = "2018"
-workspace = "../"
+workspace = ".."
 
 [lib]
 name = "actix_codec"
 path = "src/lib.rs"
 
 [dependencies]
-bytes = "0.4"
+bytes = "0.4.12"
 futures = "0.1.24"
-tokio-io = "0.1"
-tokio-codec = "0.1"
+tokio-io = "0.1.12"
+tokio-codec = "0.1.1"
 log = "0.4"

actix-codec/src/framed.rs

@@ -167,6 +167,22 @@ impl<T, U> Framed<T, U> {
         }
     }
 
+    /// Consume the `Frame`, returning `Frame` with different io.
+    pub fn map_io<F, T2>(self, f: F) -> Framed<T2, U>
+    where
+        F: Fn(T) -> T2,
+    {
+        let (inner, read_buf) = self.inner.into_parts();
+        let (inner, write_buf, lw, hw) = inner.into_parts();
+
+        Framed {
+            inner: framed_read2_with_buffer(
+                framed_write2_with_buffer(Fuse(f(inner.0), inner.1), write_buf, lw, hw),
+                read_buf,
+            ),
+        }
+    }
+
     /// Consume the `Frame`, returning `Frame` with different codec.
     pub fn map_codec<F, U2>(self, f: F) -> Framed<T, U2>
     where

actix-connect/CHANGES.md

@@ -0,0 +1,21 @@
+# Changes
+
+## [0.1.2] - 2019-04-xx
+
+### Changed
+
+* Rename connect Connector to TcpConnector #10
+
+
+## [0.1.1] - 2019-03-15
+
+### Fixed
+
+* Fix error handling for single address
+
+
+## [0.1.0] - 2019-03-14
+
+* Refactor resolver and connector services
+
+* Rename crate

actix-connect/Cargo.toml

@@ -1,12 +1,12 @@
 [package]
-name = "actix-connector"
-version = "0.3.0"
+name = "actix-connect"
+version = "0.1.2"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix Connector - tcp connector service"
 keywords = ["network", "framework", "async", "futures"]
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-net.git"
-documentation = "https://docs.rs/actix-net/"
+documentation = "https://docs.rs/actix-connect/"
 categories = ["network-programming", "asynchronous"]
 license = "MIT/Apache-2.0"
 exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
@@ -14,26 +14,42 @@ edition = "2018"
 workspace = ".."
 
 [package.metadata.docs.rs]
-features = ["ssl"]
+features = ["ssl", "uri"]
 
 [lib]
-name = "actix_connector"
+name = "actix_connect"
 path = "src/lib.rs"
 
 [features]
-default = []
+default = ["uri"]
 
 # openssl
 ssl = ["openssl", "tokio-openssl"]
 
+# support http::Uri as connect address
+uri = ["http"]
+
 [dependencies]
-actix-service = "0.3.3"
+actix-service = "0.3.4"
 actix-codec = "0.1.1"
-futures = "0.1"
-tokio-tcp = "0.1"
-tokio-current-thread = "0.1"
+actix-utils = "0.3.4"
+derive_more = "0.14.0"
+either = "1.5.1"
+futures = "0.1.25"
+http = { version = "0.1.16", optional = true }
+log = "0.4"
+tokio-tcp = "0.1.3"
+tokio-current-thread = "0.1.5"
 trust-dns-resolver = { version="0.11.0-alpha.2", default-features = false }
 
 # openssl
 openssl = { version="0.10", optional = true }
 tokio-openssl = { version="0.3", optional = true }
+
+[dev-dependencies]
+bytes = "0.4"
+actix-connect = { path=".", features=["ssl"] }
+actix-test-server = { version="0.2.0", features=["ssl"] }
+actix-server-config = "0.1.0"
+actix-utils = "0.3.4"
+tokio-tcp = "0.1"

actix-connect/src/connect.rs

@@ -0,0 +1,172 @@
+use std::collections::VecDeque;
+use std::fmt;
+use std::net::SocketAddr;
+
+use either::Either;
+
+/// Connect request
+pub trait Address {
+    /// Host name of the request
+    fn host(&self) -> &str;
+
+    /// Port of the request
+    fn port(&self) -> Option<u16>;
+}
+
+impl Address for String {
+    fn host(&self) -> &str {
+        &self
+    }
+
+    fn port(&self) -> Option<u16> {
+        None
+    }
+}
+
+impl Address for &'static str {
+    fn host(&self) -> &str {
+        self
+    }
+
+    fn port(&self) -> Option<u16> {
+        None
+    }
+}
+
+/// Connect request
+#[derive(Eq, PartialEq, Debug, Hash)]
+pub struct Connect<T> {
+    pub(crate) req: T,
+    pub(crate) port: u16,
+    pub(crate) addr: Option<Either<SocketAddr, VecDeque<SocketAddr>>>,
+}
+
+impl<T: Address> Connect<T> {
+    /// Create `Connect` instance by spliting the string by ':' and convert the second part to u16
+    pub fn new(req: T) -> Connect<T> {
+        let (_, port) = parse(req.host());
+        Connect {
+            req,
+            port: port.unwrap_or(0),
+            addr: None,
+        }
+    }
+
+    /// Create new `Connect` instance from host and address. Connector skips name resolution stage for such connect messages.
+    pub fn with(req: T, addr: SocketAddr) -> Connect<T> {
+        Connect {
+            req,
+            port: 0,
+            addr: Some(Either::Left(addr)),
+        }
+    }
+
+    /// Use port if address does not provide one.
+    ///
+    /// By default it set to 0
+    pub fn set_port(mut self, port: u16) -> Self {
+        self.port = port;
+        self
+    }
+
+    /// Host name
+    pub fn host(&self) -> &str {
+        self.req.host()
+    }
+
+    /// Port of the request
+    pub fn port(&self) -> u16 {
+        self.req.port().unwrap_or(self.port)
+    }
+}
+
+impl<T: Address> From<T> for Connect<T> {
+    fn from(addr: T) -> Self {
+        Connect::new(addr)
+    }
+}
+
+impl<T: Address> fmt::Display for Connect<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}:{}", self.host(), self.port())
+    }
+}
+
+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,
+    req: T,
+}
+
+impl<T, U> Connection<T, U> {
+    pub fn new(io: U, req: T) -> Self {
+        Self { io, req }
+    }
+}
+
+impl<T, U> Connection<T, U> {
+    /// Reconstruct from a parts.
+    pub fn from_parts(io: U, req: T) -> Self {
+        Self { io, req }
+    }
+
+    /// Deconstruct into a parts.
+    pub fn into_parts(self) -> (U, T) {
+        (self.io, self.req)
+    }
+
+    /// Replace inclosed object, return new Stream and old object
+    pub fn replace<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 {
+        &self.io
+    }
+
+    /// Returns a mutable reference to the underlying stream.
+    pub fn get_mut(&mut self) -> &mut U {
+        &mut self.io
+    }
+}
+
+impl<T: Address, U> Connection<T, U> {
+    /// Get request
+    pub fn host(&self) -> &str {
+        &self.req.host()
+    }
+}
+
+impl<T, U> std::ops::Deref for Connection<T, U> {
+    type Target = U;
+
+    fn deref(&self) -> &U {
+        &self.io
+    }
+}
+
+impl<T, U> std::ops::DerefMut for Connection<T, U> {
+    fn deref_mut(&mut self) -> &mut U {
+        &mut self.io
+    }
+}
+
+impl<T, U: fmt::Debug> fmt::Debug for Connection<T, U> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "Stream {{{:?}}}", self.io)
+    }
+}

actix-connect/src/connector.rs

@@ -0,0 +1,156 @@
+use std::collections::VecDeque;
+use std::marker::PhantomData;
+use std::net::SocketAddr;
+
+use actix_service::{NewService, Service};
+use futures::future::{err, ok, Either, FutureResult};
+use futures::{Async, Future, Poll};
+use tokio_tcp::{ConnectFuture, TcpStream};
+
+use super::connect::{Address, Connect, Connection};
+use super::error::ConnectError;
+
+/// Tcp connector service factory
+#[derive(Debug)]
+pub struct TcpConnectorFactory<T>(PhantomData<T>);
+
+impl<T> TcpConnectorFactory<T> {
+    pub fn new() -> Self {
+        TcpConnectorFactory(PhantomData)
+    }
+}
+
+impl<T> Clone for TcpConnectorFactory<T> {
+    fn clone(&self) -> Self {
+        TcpConnectorFactory(PhantomData)
+    }
+}
+
+impl<T: Address> NewService for TcpConnectorFactory<T> {
+    type Request = Connect<T>;
+    type Response = Connection<T, TcpStream>;
+    type Error = ConnectError;
+    type Service = TcpConnector<T>;
+    type InitError = ();
+    type Future = FutureResult<Self::Service, Self::InitError>;
+
+    fn new_service(&self, _: &()) -> Self::Future {
+        ok(TcpConnector(PhantomData))
+    }
+}
+
+/// Tcp connector service
+#[derive(Debug)]
+pub struct TcpConnector<T>(PhantomData<T>);
+
+impl<T> TcpConnector<T> {
+    pub fn new() -> Self {
+        TcpConnector(PhantomData)
+    }
+}
+
+impl<T> Clone for TcpConnector<T> {
+    fn clone(&self) -> Self {
+        TcpConnector(PhantomData)
+    }
+}
+
+impl<T: Address> Service for TcpConnector<T> {
+    type Request = Connect<T>;
+    type Response = Connection<T, TcpStream>;
+    type Error = ConnectError;
+    type Future = Either<TcpConnectorResponse<T>, FutureResult<Self::Response, Self::Error>>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
+    }
+
+    fn call(&mut self, req: Connect<T>) -> Self::Future {
+        let port = req.port();
+        let Connect { req, addr, .. } = req;
+
+        if let Some(addr) = addr {
+            Either::A(TcpConnectorResponse::new(req, port, addr))
+        } else {
+            error!("TCP connector: got unresolved address");
+            Either::B(err(ConnectError::Unresolverd))
+        }
+    }
+}
+
+#[doc(hidden)]
+/// Tcp stream connector response future
+pub struct TcpConnectorResponse<T> {
+    req: Option<T>,
+    port: u16,
+    addrs: Option<VecDeque<SocketAddr>>,
+    stream: Option<ConnectFuture>,
+}
+
+impl<T: Address> TcpConnectorResponse<T> {
+    pub fn new(
+        req: T,
+        port: u16,
+        addr: either::Either<SocketAddr, VecDeque<SocketAddr>>,
+    ) -> TcpConnectorResponse<T> {
+        trace!(
+            "TCP connector - connecting to {:?} port:{}",
+            req.host(),
+            port
+        );
+
+        match addr {
+            either::Either::Left(addr) => TcpConnectorResponse {
+                req: Some(req),
+                port,
+                addrs: None,
+                stream: Some(TcpStream::connect(&addr)),
+            },
+            either::Either::Right(addrs) => TcpConnectorResponse {
+                req: Some(req),
+                port,
+                addrs: Some(addrs),
+                stream: None,
+            },
+        }
+    }
+}
+
+impl<T: Address> Future for TcpConnectorResponse<T> {
+    type Item = Connection<T, TcpStream>;
+    type Error = ConnectError;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        // connect
+        loop {
+            if let Some(new) = self.stream.as_mut() {
+                match new.poll() {
+                    Ok(Async::Ready(sock)) => {
+                        let req = self.req.take().unwrap();
+                        trace!(
+                            "TCP connector - successfully connected to connecting to {:?} - {:?}",
+                            req.host(), sock.peer_addr()
+                        );
+                        return Ok(Async::Ready(Connection::new(sock, req)));
+                    }
+                    Ok(Async::NotReady) => return Ok(Async::NotReady),
+                    Err(err) => {
+                        trace!(
+                            "TCP connector - failed to connect to connecting to {:?} port: {}",
+                            self.req.as_ref().unwrap().host(),
+                            self.port,
+                        );
+                        if self.addrs.is_none() || self.addrs.as_ref().unwrap().is_empty() {
+                            return Err(err.into());
+                        }
+                    }
+                }
+            }
+
+            // try to connect
+            self.stream = Some(TcpStream::connect(
+                &self.addrs.as_mut().unwrap().pop_front().unwrap(),
+            ));
+        }
+    }
+}

actix-connect/src/error.rs

@@ -0,0 +1,26 @@
+use std::io;
+
+use derive_more::{Display, From};
+use trust_dns_resolver::error::ResolveError;
+
+#[derive(Debug, From, Display)]
+pub enum ConnectError {
+    /// Failed to resolve the hostname
+    #[display(fmt = "Failed resolving hostname: {}", _0)]
+    Resolver(ResolveError),
+
+    /// No dns records
+    #[display(fmt = "No dns records found for the input")]
+    NoRecords,
+
+    /// Invalid input
+    InvalidInput,
+
+    /// Unresolved host name
+    #[display(fmt = "Connector received `Connect` method with unresolved host")]
+    Unresolverd,
+
+    /// Connection io error
+    #[display(fmt = "{}", _0)]
+    Io(io::Error),
+}

actix-connect/src/lib.rs

@@ -0,0 +1,96 @@
+//! Actix connect - tcp connector service
+//!
+//! ## Package feature
+//!
+//! * `ssl` - enables ssl support via `openssl` crate
+//! * `rust-tls` - enables ssl support via `rustls` crate
+
+#[macro_use]
+extern crate log;
+
+mod connect;
+mod connector;
+mod error;
+mod resolver;
+pub mod ssl;
+
+#[cfg(feature = "uri")]
+mod uri;
+
+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::resolver::{Resolver, ResolverFactory};
+
+use actix_service::{NewService, Service, ServiceExt};
+use tokio_tcp::TcpStream;
+use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
+use trust_dns_resolver::system_conf::read_system_conf;
+
+#[doc(hidden)]
+#[deprecated(since = "0.1.2", note = "please use `actix_connect::TcpConnector`")]
+pub type Connector<T> = TcpConnector<T>;
+
+#[doc(hidden)]
+#[deprecated(
+    since = "0.1.2",
+    note = "please use `actix_connect::TcpConnectorFactory`"
+)]
+pub type ConnectorFactory<T> = TcpConnectorFactory<T>;
+
+pub fn start_resolver(cfg: ResolverConfig, opts: ResolverOpts) -> AsyncResolver {
+    let (resolver, bg) = AsyncResolver::new(cfg, opts);
+    tokio_current_thread::spawn(bg);
+    resolver
+}
+
+pub fn start_default_resolver() -> AsyncResolver {
+    let (cfg, opts) = if let Ok((cfg, opts)) = read_system_conf() {
+        (cfg, opts)
+    } else {
+        (ResolverConfig::default(), ResolverOpts::default())
+    };
+
+    let (resolver, bg) = AsyncResolver::new(cfg, opts);
+    tokio_current_thread::spawn(bg);
+    resolver
+}
+
+/// Create tcp connector service
+pub fn new_connector<T: Address>(
+    resolver: AsyncResolver,
+) -> impl Service<Request = Connect<T>, Response = Connection<T, TcpStream>, Error = ConnectError>
+         + Clone {
+    Resolver::new(resolver).and_then(TcpConnector::new())
+}
+
+/// Create tcp connector service
+pub fn new_connector_factory<T: Address>(
+    resolver: AsyncResolver,
+) -> impl NewService<
+    Request = Connect<T>,
+    Response = Connection<T, TcpStream>,
+    Error = ConnectError,
+    InitError = (),
+> + Clone {
+    ResolverFactory::new(resolver).and_then(TcpConnectorFactory::new())
+}
+
+/// Create connector service with default parameters
+pub fn default_connector<T: Address>(
+) -> impl Service<Request = Connect<T>, Response = Connection<T, TcpStream>, Error = ConnectError>
+         + Clone {
+    Resolver::new(start_default_resolver()).and_then(TcpConnector::new())
+}
+
+/// Create connector service factory with default parameters
+pub fn default_connector_factory<T: Address>() -> impl NewService<
+    Request = Connect<T>,
+    Response = Connection<T, TcpStream>,
+    Error = ConnectError,
+    InitError = (),
+> + Clone {
+    ResolverFactory::new(start_default_resolver()).and_then(TcpConnectorFactory::new())
+}

actix-connect/src/resolver.rs

@@ -0,0 +1,168 @@
+use std::collections::VecDeque;
+use std::marker::PhantomData;
+use std::net::SocketAddr;
+
+use actix_service::{NewService, Service};
+use futures::future::{ok, Either, FutureResult};
+use futures::{Async, Future, Poll};
+use trust_dns_resolver::lookup_ip::LookupIpFuture;
+use trust_dns_resolver::{AsyncResolver, Background};
+
+use crate::connect::{Address, Connect};
+use crate::error::ConnectError;
+
+/// DNS Resolver Service factory
+pub struct ResolverFactory<T> {
+    resolver: AsyncResolver,
+    _t: PhantomData<T>,
+}
+
+impl<T> ResolverFactory<T> {
+    /// Create new resolver instance with custom configuration and options.
+    pub fn new(resolver: AsyncResolver) -> Self {
+        ResolverFactory {
+            resolver,
+            _t: PhantomData,
+        }
+    }
+
+    pub fn resolver(&self) -> &AsyncResolver {
+        &self.resolver
+    }
+}
+
+impl<T> Clone for ResolverFactory<T> {
+    fn clone(&self) -> Self {
+        ResolverFactory {
+            resolver: self.resolver.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T: Address> NewService for ResolverFactory<T> {
+    type Request = Connect<T>;
+    type Response = Connect<T>;
+    type Error = ConnectError;
+    type Service = Resolver<T>;
+    type InitError = ();
+    type Future = FutureResult<Self::Service, Self::InitError>;
+
+    fn new_service(&self, _: &()) -> Self::Future {
+        ok(Resolver {
+            resolver: self.resolver.clone(),
+            _t: PhantomData,
+        })
+    }
+}
+
+/// DNS Resolver Service
+pub struct Resolver<T> {
+    resolver: AsyncResolver,
+    _t: PhantomData<T>,
+}
+
+impl<T> Resolver<T> {
+    /// Create new resolver instance with custom configuration and options.
+    pub fn new(resolver: AsyncResolver) -> Self {
+        Resolver {
+            resolver,
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T> Clone for Resolver<T> {
+    fn clone(&self) -> Self {
+        Resolver {
+            resolver: self.resolver.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T: Address> Service for Resolver<T> {
+    type Request = Connect<T>;
+    type Response = Connect<T>;
+    type Error = ConnectError;
+    type Future = Either<ResolverFuture<T>, FutureResult<Connect<T>, Self::Error>>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
+    }
+
+    fn call(&mut self, mut req: Connect<T>) -> Self::Future {
+        if req.addr.is_some() {
+            Either::B(ok(req))
+        } else {
+            if let Ok(ip) = req.host().parse() {
+                req.addr = Some(either::Either::Left(SocketAddr::new(ip, req.port())));
+                Either::B(ok(req))
+            } else {
+                trace!("DNS resolver: resolving host {:?}", req.host());
+                Either::A(ResolverFuture::new(req, &self.resolver))
+            }
+        }
+    }
+}
+
+#[doc(hidden)]
+/// Resolver future
+pub struct ResolverFuture<T: Address> {
+    req: Option<Connect<T>>,
+    lookup: Background<LookupIpFuture>,
+}
+
+impl<T: Address> ResolverFuture<T> {
+    pub fn new(req: Connect<T>, resolver: &AsyncResolver) -> Self {
+        let lookup = if let Some(host) = req.host().splitn(2, ':').next() {
+            resolver.lookup_ip(host)
+        } else {
+            resolver.lookup_ip(req.host())
+        };
+
+        ResolverFuture {
+            lookup,
+            req: Some(req),
+        }
+    }
+}
+
+impl<T: Address> Future for ResolverFuture<T> {
+    type Item = Connect<T>;
+    type Error = ConnectError;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        match self.lookup.poll().map_err(|e| {
+            trace!(
+                "DNS resolver: failed to resolve host {:?} err: {}",
+                self.req.as_ref().unwrap().host(),
+                e
+            );
+            e
+        })? {
+            Async::NotReady => Ok(Async::NotReady),
+            Async::Ready(ips) => {
+                let mut req = self.req.take().unwrap();
+                let mut addrs: VecDeque<_> = ips
+                    .iter()
+                    .map(|ip| SocketAddr::new(ip, req.port()))
+                    .collect();
+                trace!(
+                    "DNS resolver: host {:?} resolved to {:?}",
+                    req.host(),
+                    addrs
+                );
+                if addrs.is_empty() {
+                    Err(ConnectError::NoRecords)
+                } else if addrs.len() == 1 {
+                    req.addr = Some(either::Either::Left(addrs.pop_front().unwrap()));
+                    Ok(Async::Ready(req))
+                } else {
+                    req.addr = Some(either::Either::Right(addrs));
+                    Ok(Async::Ready(req))
+                }
+            }
+        }
+    }
+}

actix-connect/src/ssl/openssl.rs

@@ -0,0 +1,127 @@
+use std::fmt;
+use std::marker::PhantomData;
+
+use actix_codec::{AsyncRead, AsyncWrite};
+use actix_service::{NewService, Service};
+use futures::{future::ok, future::FutureResult, Async, Future, Poll};
+use openssl::ssl::{HandshakeError, SslConnector};
+use tokio_openssl::{ConnectAsync, SslConnectorExt, SslStream};
+
+use crate::{Address, Connection};
+
+/// Openssl connector factory
+pub struct OpensslConnector<T, U> {
+    connector: SslConnector,
+    _t: PhantomData<(T, U)>,
+}
+
+impl<T, U> OpensslConnector<T, U> {
+    pub fn new(connector: SslConnector) -> Self {
+        OpensslConnector {
+            connector,
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T, U> OpensslConnector<T, U>
+where
+    T: Address,
+    U: AsyncRead + AsyncWrite + fmt::Debug,
+{
+    pub fn service(
+        connector: SslConnector,
+    ) -> impl Service<
+        Request = Connection<T, U>,
+        Response = Connection<T, SslStream<U>>,
+        Error = HandshakeError<U>,
+    > {
+        OpensslConnectorService {
+            connector: connector,
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T, U> Clone for OpensslConnector<T, U> {
+    fn clone(&self) -> Self {
+        Self {
+            connector: self.connector.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T: Address, U> NewService<()> for OpensslConnector<T, U>
+where
+    U: AsyncRead + AsyncWrite + fmt::Debug,
+{
+    type Request = Connection<T, U>;
+    type Response = Connection<T, SslStream<U>>;
+    type Error = HandshakeError<U>;
+    type Service = OpensslConnectorService<T, U>;
+    type InitError = ();
+    type Future = FutureResult<Self::Service, Self::InitError>;
+
+    fn new_service(&self, _: &()) -> Self::Future {
+        ok(OpensslConnectorService {
+            connector: self.connector.clone(),
+            _t: PhantomData,
+        })
+    }
+}
+
+pub struct OpensslConnectorService<T, U> {
+    connector: SslConnector,
+    _t: PhantomData<(T, U)>,
+}
+
+impl<T: Address, U> Service for OpensslConnectorService<T, U>
+where
+    U: AsyncRead + AsyncWrite + fmt::Debug,
+{
+    type Request = Connection<T, U>;
+    type Response = Connection<T, SslStream<U>>;
+    type Error = HandshakeError<U>;
+    type Future = ConnectAsyncExt<T, U>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
+    }
+
+    fn call(&mut self, stream: Connection<T, U>) -> Self::Future {
+        trace!("SSL Handshake start for: {:?}", stream.host());
+        let (io, stream) = stream.replace(());
+        ConnectAsyncExt {
+            fut: SslConnectorExt::connect_async(&self.connector, stream.host(), io),
+            stream: Some(stream),
+        }
+    }
+}
+
+pub struct ConnectAsyncExt<T, U> {
+    fut: ConnectAsync<U>,
+    stream: Option<Connection<T, ()>>,
+}
+
+impl<T: Address, U> Future for ConnectAsyncExt<T, U>
+where
+    U: AsyncRead + AsyncWrite + fmt::Debug,
+{
+    type Item = Connection<T, SslStream<U>>;
+    type Error = HandshakeError<U>;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        match self.fut.poll().map_err(|e| {
+            trace!("SSL Handshake error: {:?}", e);
+            e
+        })? {
+            Async::Ready(stream) => {
+                let s = self.stream.take().unwrap();
+                trace!("SSL Handshake success: {:?}", s.host());
+                Ok(Async::Ready(s.replace(stream).1))
+            }
+            Async::NotReady => Ok(Async::NotReady),
+        }
+    }
+}

actix-connect/src/uri.rs

@@ -0,0 +1,37 @@
+use http::Uri;
+
+use crate::Address;
+
+impl Address for Uri {
+    fn host(&self) -> &str {
+        self.host().unwrap_or("")
+    }
+
+    fn port(&self) -> Option<u16> {
+        if let Some(port) = self.port_u16() {
+            Some(port)
+        } else {
+            port(self.scheme_str())
+        }
+    }
+}
+
+// TODO: load data from file
+fn port(scheme: Option<&str>) -> Option<u16> {
+    if let Some(scheme) = scheme {
+        match scheme {
+            "http" => Some(80),
+            "https" => Some(443),
+            "ws" => Some(80),
+            "wss" => Some(443),
+            "amqp" => Some(5672),
+            "amqps" => Some(5671),
+            "sb" => Some(5671),
+            "mqtt" => Some(1883),
+            "mqtts" => Some(8883),
+            _ => None,
+        }
+    } else {
+        None
+    }
+}

actix-connect/tests/test_connect.rs

@@ -0,0 +1,111 @@
+use actix_codec::{BytesCodec, Framed};
+use actix_server_config::Io;
+use actix_service::{fn_service, NewService, Service};
+use actix_test_server::TestServer;
+use bytes::Bytes;
+use futures::{future::lazy, Future, Sink};
+use http::{HttpTryFrom, Uri};
+use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
+
+use actix_connect::{default_connector, Connect};
+
+#[test]
+fn test_string() {
+    let mut srv = TestServer::with(|| {
+        fn_service(|io: Io<tokio_tcp::TcpStream>| {
+            Framed::new(io.into_parts().0, BytesCodec)
+                .send(Bytes::from_static(b"test"))
+                .then(|_| Ok::<_, ()>(()))
+        })
+    });
+
+    let mut conn = srv
+        .block_on(lazy(|| Ok::<_, ()>(default_connector())))
+        .unwrap();
+    let addr = format!("localhost:{}", srv.port());
+    let con = srv.block_on(conn.call(addr.into())).unwrap();
+    assert_eq!(con.peer_addr().unwrap(), srv.addr());
+}
+
+#[test]
+fn test_static_str() {
+    let mut srv = TestServer::with(|| {
+        fn_service(|io: Io<tokio_tcp::TcpStream>| {
+            Framed::new(io.into_parts().0, BytesCodec)
+                .send(Bytes::from_static(b"test"))
+                .then(|_| Ok::<_, ()>(()))
+        })
+    });
+
+    let resolver = srv
+        .block_on(lazy(
+            || Ok::<_, ()>(actix_connect::start_default_resolver()),
+        ))
+        .unwrap();
+    let mut conn = srv
+        .block_on(lazy(|| {
+            Ok::<_, ()>(actix_connect::new_connector(resolver.clone()))
+        }))
+        .unwrap();
+
+    let con = srv
+        .block_on(conn.call(Connect::with("10", srv.addr())))
+        .unwrap();
+    assert_eq!(con.peer_addr().unwrap(), srv.addr());
+
+    let connect = Connect::new(srv.host().to_owned());
+    let mut conn = srv
+        .block_on(lazy(|| Ok::<_, ()>(actix_connect::new_connector(resolver))))
+        .unwrap();
+    let con = srv.block_on(conn.call(connect));
+    assert!(con.is_err());
+}
+
+#[test]
+fn test_new_service() {
+    let mut srv = TestServer::with(|| {
+        fn_service(|io: Io<tokio_tcp::TcpStream>| {
+            Framed::new(io.into_parts().0, BytesCodec)
+                .send(Bytes::from_static(b"test"))
+                .then(|_| Ok::<_, ()>(()))
+        })
+    });
+
+    let resolver = srv
+        .block_on(lazy(|| {
+            Ok::<_, ()>(actix_connect::start_resolver(
+                ResolverConfig::default(),
+                ResolverOpts::default(),
+            ))
+        }))
+        .unwrap();
+    let factory = srv
+        .block_on(lazy(|| {
+            Ok::<_, ()>(actix_connect::new_connector_factory(resolver))
+        }))
+        .unwrap();
+
+    let mut conn = srv.block_on(factory.new_service(&())).unwrap();
+    let con = srv
+        .block_on(conn.call(Connect::with("10", srv.addr())))
+        .unwrap();
+    assert_eq!(con.peer_addr().unwrap(), srv.addr());
+}
+
+#[test]
+fn test_uri() {
+    let mut srv = TestServer::with(|| {
+        fn_service(|io: Io<tokio_tcp::TcpStream>| {
+            Framed::new(io.into_parts().0, BytesCodec)
+                .send(Bytes::from_static(b"test"))
+                .then(|_| Ok::<_, ()>(()))
+        })
+    });
+
+    let mut conn = srv
+        .block_on(lazy(|| Ok::<_, ()>(default_connector())))
+        .unwrap();
+    let addr = Uri::try_from(format!("https://localhost:{}", srv.port())).unwrap();
+    let con = srv.block_on(conn.call(addr.into())).unwrap();
+    assert_eq!(con.peer_addr().unwrap(), srv.addr());
+}

actix-connector/CHANGES.md

@@ -1,28 +0,0 @@
-# Changes
-
-## [0.3.0] - 2019-03-02
-
-### Changed
-
-* Migrate to actix-service 0.3
-
-
-## [0.2.0] - 2019-02-01
-
-### Changed
-
-* Migrate to actix-service 0.2
-
-* Upgrade trust-dns-resolver
-
-* Use tokio-current-thread instead of direct actix-rt dipendency
-
-
-## [0.1.1] - 2019-01-13
-
-* Upgrade trust-dns-proto
-
-
-## [0.1.0] - 2018-12-09
-
-* Move server to separate crate

actix-connector/src/connector.rs

@@ -1,386 +0,0 @@
-use std::collections::VecDeque;
-use std::marker::PhantomData;
-use std::net::{IpAddr, SocketAddr};
-use std::time::Duration;
-use std::{fmt, io};
-
-use actix_service::{fn_factory, NewService, Service};
-use futures::future::{ok, Either};
-use futures::{try_ready, Async, Future, Poll};
-use tokio_tcp::{ConnectFuture, TcpStream};
-use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
-use trust_dns_resolver::system_conf::read_system_conf;
-
-use super::resolver::{RequestHost, ResolveError, Resolver, ResolverFuture};
-
-/// Port of the request
-pub trait RequestPort {
-    fn port(&self) -> u16;
-}
-
-// #[derive(Fail, Debug)]
-#[derive(Debug)]
-pub enum ConnectorError {
-    /// Failed to resolve the hostname
-    // #[fail(display = "Failed resolving hostname: {}", _0)]
-    Resolver(ResolveError),
-
-    /// No dns records
-    // #[fail(display = "No dns records found for the input")]
-    NoRecords,
-
-    /// Connecting took too long
-    // #[fail(display = "Timeout out while establishing connection")]
-    Timeout,
-
-    /// Invalid input
-    InvalidInput,
-
-    /// Connection io error
-    // #[fail(display = "{}", _0)]
-    IoError(io::Error),
-}
-
-impl From<ResolveError> for ConnectorError {
-    fn from(err: ResolveError) -> Self {
-        ConnectorError::Resolver(err)
-    }
-}
-
-impl From<io::Error> for ConnectorError {
-    fn from(err: io::Error) -> Self {
-        ConnectorError::IoError(err)
-    }
-}
-
-/// Connect request
-#[derive(Eq, PartialEq, Debug, Hash)]
-pub struct Connect {
-    pub kind: ConnectKind,
-    pub timeout: Duration,
-}
-
-#[derive(Eq, PartialEq, Debug, Hash)]
-pub enum ConnectKind {
-    Host { host: String, port: u16 },
-    Addr { host: String, addr: SocketAddr },
-}
-
-impl Connect {
-    /// Create new `Connect` instance.
-    pub fn new<T: AsRef<str>>(host: T, port: u16) -> Connect {
-        Connect {
-            kind: ConnectKind::Host {
-                host: host.as_ref().to_owned(),
-                port,
-            },
-            timeout: Duration::from_secs(1),
-        }
-    }
-
-    /// Create `Connect` instance by spliting the string by ':' and convert the second part to u16
-    pub fn with<T: AsRef<str>>(host: T) -> Result<Connect, ConnectorError> {
-        let mut parts_iter = host.as_ref().splitn(2, ':');
-        let host = parts_iter.next().ok_or(ConnectorError::InvalidInput)?;
-        let port_str = parts_iter.next().unwrap_or("");
-        let port = port_str
-            .parse::<u16>()
-            .map_err(|_| ConnectorError::InvalidInput)?;
-        Ok(Connect {
-            kind: ConnectKind::Host {
-                host: host.to_owned(),
-                port,
-            },
-            timeout: Duration::from_secs(1),
-        })
-    }
-
-    /// Create new `Connect` instance from host and address. Connector skips name resolution stage for such connect messages.
-    pub fn with_address<T: Into<String>>(host: T, addr: SocketAddr) -> Connect {
-        Connect {
-            kind: ConnectKind::Addr {
-                addr,
-                host: host.into(),
-            },
-            timeout: Duration::from_secs(1),
-        }
-    }
-
-    /// Set connect timeout
-    ///
-    /// By default timeout is set to a 1 second.
-    pub fn timeout(mut self, timeout: Duration) -> Connect {
-        self.timeout = timeout;
-        self
-    }
-}
-
-impl RequestHost for Connect {
-    fn host(&self) -> &str {
-        match self.kind {
-            ConnectKind::Host { ref host, .. } => host,
-            ConnectKind::Addr { ref host, .. } => host,
-        }
-    }
-}
-
-impl RequestPort for Connect {
-    fn port(&self) -> u16 {
-        match self.kind {
-            ConnectKind::Host { port, .. } => port,
-            ConnectKind::Addr { addr, .. } => addr.port(),
-        }
-    }
-}
-
-impl fmt::Display for Connect {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}:{}", self.host(), self.port())
-    }
-}
-
-/// Tcp connector
-pub struct Connector {
-    resolver: Resolver<Connect>,
-}
-
-impl Default for Connector {
-    fn default() -> Self {
-        let (cfg, opts) = if let Ok((cfg, opts)) = read_system_conf() {
-            (cfg, opts)
-        } else {
-            (ResolverConfig::default(), ResolverOpts::default())
-        };
-
-        Connector::new(cfg, opts)
-    }
-}
-
-impl Connector {
-    /// Create new connector with resolver configuration
-    pub fn new(cfg: ResolverConfig, opts: ResolverOpts) -> Self {
-        Connector {
-            resolver: Resolver::new(cfg, opts),
-        }
-    }
-
-    /// Create new connector with custom resolver
-    pub fn with_resolver(
-        resolver: Resolver<Connect>,
-    ) -> impl Service<Request = Connect, Response = (Connect, TcpStream), Error = ConnectorError>
-                 + Clone {
-        Connector { resolver }
-    }
-
-    /// Create new default connector service
-    pub fn new_service_with_config<E>(
-        cfg: ResolverConfig,
-        opts: ResolverOpts,
-    ) -> impl NewService<
-        (),
-        Request = Connect,
-        Response = (Connect, TcpStream),
-        Error = ConnectorError,
-        InitError = E,
-    > + Clone {
-        fn_factory(move || ok(Connector::new(cfg.clone(), opts)))
-    }
-}
-
-impl Clone for Connector {
-    fn clone(&self) -> Self {
-        Connector {
-            resolver: self.resolver.clone(),
-        }
-    }
-}
-
-impl Service for Connector {
-    type Request = Connect;
-    type Response = (Connect, TcpStream);
-    type Error = ConnectorError;
-    type Future = Either<ConnectorFuture, ConnectorTcpFuture>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        Ok(Async::Ready(()))
-    }
-
-    fn call(&mut self, req: Connect) -> Self::Future {
-        match req.kind {
-            ConnectKind::Host { .. } => Either::A(ConnectorFuture {
-                fut: self.resolver.call(req),
-                fut2: None,
-            }),
-            ConnectKind::Addr { addr, .. } => {
-                let mut addrs = VecDeque::new();
-                addrs.push_back(addr.ip());
-                Either::B(ConnectorTcpFuture {
-                    fut: TcpConnectorResponse::new(req, addrs),
-                })
-            }
-        }
-    }
-}
-
-#[doc(hidden)]
-pub struct ConnectorFuture {
-    fut: ResolverFuture<Connect>,
-    fut2: Option<TcpConnectorResponse<Connect>>,
-}
-
-impl Future for ConnectorFuture {
-    type Item = (Connect, TcpStream);
-    type Error = ConnectorError;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if let Some(ref mut fut) = self.fut2 {
-            return fut.poll().map_err(ConnectorError::from);
-        }
-        match self.fut.poll().map_err(ConnectorError::from)? {
-            Async::Ready((req, addrs)) => {
-                if addrs.is_empty() {
-                    Err(ConnectorError::NoRecords)
-                } else {
-                    self.fut2 = Some(TcpConnectorResponse::new(req, addrs));
-                    self.poll()
-                }
-            }
-            Async::NotReady => Ok(Async::NotReady),
-        }
-    }
-}
-
-#[doc(hidden)]
-pub struct ConnectorTcpFuture {
-    fut: TcpConnectorResponse<Connect>,
-}
-
-impl Future for ConnectorTcpFuture {
-    type Item = (Connect, TcpStream);
-    type Error = ConnectorError;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        self.fut.poll().map_err(ConnectorError::IoError)
-    }
-}
-
-/// Tcp stream connector service
-pub struct TcpConnector<T: RequestPort>(PhantomData<T>);
-
-impl<T: RequestPort> Default for TcpConnector<T> {
-    fn default() -> TcpConnector<T> {
-        TcpConnector(PhantomData)
-    }
-}
-
-impl<T: RequestPort> Service for TcpConnector<T> {
-    type Request = (T, VecDeque<IpAddr>);
-    type Response = (T, TcpStream);
-    type Error = io::Error;
-    type Future = TcpConnectorResponse<T>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        Ok(Async::Ready(()))
-    }
-
-    fn call(&mut self, (req, addrs): (T, VecDeque<IpAddr>)) -> Self::Future {
-        TcpConnectorResponse::new(req, addrs)
-    }
-}
-
-#[doc(hidden)]
-/// Tcp stream connector response future
-pub struct TcpConnectorResponse<T: RequestPort> {
-    port: u16,
-    req: Option<T>,
-    addr: Option<SocketAddr>,
-    addrs: VecDeque<IpAddr>,
-    stream: Option<ConnectFuture>,
-}
-
-impl<T: RequestPort> TcpConnectorResponse<T> {
-    pub fn new(req: T, addrs: VecDeque<IpAddr>) -> TcpConnectorResponse<T> {
-        TcpConnectorResponse {
-            addrs,
-            port: req.port(),
-            req: Some(req),
-            addr: None,
-            stream: None,
-        }
-    }
-}
-
-impl<T: RequestPort> Future for TcpConnectorResponse<T> {
-    type Item = (T, TcpStream);
-    type Error = io::Error;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        // connect
-        loop {
-            if let Some(new) = self.stream.as_mut() {
-                match new.poll() {
-                    Ok(Async::Ready(sock)) => {
-                        return Ok(Async::Ready((self.req.take().unwrap(), sock)));
-                    }
-                    Ok(Async::NotReady) => return Ok(Async::NotReady),
-                    Err(err) => {
-                        if self.addrs.is_empty() {
-                            return Err(err);
-                        }
-                    }
-                }
-            }
-
-            // try to connect
-            let addr = SocketAddr::new(self.addrs.pop_front().unwrap(), self.port);
-            self.stream = Some(TcpStream::connect(&addr));
-            self.addr = Some(addr)
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct DefaultConnector(Connector);
-
-impl Default for DefaultConnector {
-    fn default() -> Self {
-        DefaultConnector(Connector::default())
-    }
-}
-
-impl DefaultConnector {
-    pub fn new(cfg: ResolverConfig, opts: ResolverOpts) -> Self {
-        DefaultConnector(Connector::new(cfg, opts))
-    }
-}
-
-impl Service for DefaultConnector {
-    type Request = Connect;
-    type Response = TcpStream;
-    type Error = ConnectorError;
-    type Future = DefaultConnectorFuture;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        self.0.poll_ready()
-    }
-
-    fn call(&mut self, req: Connect) -> Self::Future {
-        DefaultConnectorFuture {
-            fut: self.0.call(req),
-        }
-    }
-}
-
-#[doc(hidden)]
-pub struct DefaultConnectorFuture {
-    fut: Either<ConnectorFuture, ConnectorTcpFuture>,
-}
-
-impl Future for DefaultConnectorFuture {
-    type Item = TcpStream;
-    type Error = ConnectorError;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        Ok(Async::Ready(try_ready!(self.fut.poll()).1))
-    }
-}

actix-connector/src/lib.rs

@@ -1,16 +0,0 @@
-//! Actix Connector - tcp connector service
-//!
-//! ## Package feature
-//!
-//! * `tls` - enables ssl support via `native-tls` crate
-//! * `ssl` - enables ssl support via `openssl` crate
-//! * `rust-tls` - enables ssl support via `rustls` crate
-
-mod connector;
-mod resolver;
-pub mod ssl;
-
-pub use self::connector::{
-    Connect, Connector, ConnectorError, DefaultConnector, RequestPort, TcpConnector,
-};
-pub use self::resolver::{RequestHost, Resolver};

actix-connector/src/resolver.rs

@@ -1,129 +0,0 @@
-use std::collections::VecDeque;
-use std::marker::PhantomData;
-use std::net::IpAddr;
-
-use actix_service::Service;
-use futures::{Async, Future, Poll};
-use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
-pub use trust_dns_resolver::error::ResolveError;
-use trust_dns_resolver::lookup_ip::LookupIpFuture;
-use trust_dns_resolver::system_conf::read_system_conf;
-use trust_dns_resolver::{AsyncResolver, Background};
-
-/// Host name of the request
-pub trait RequestHost {
-    fn host(&self) -> &str;
-}
-
-impl RequestHost for String {
-    fn host(&self) -> &str {
-        self.as_ref()
-    }
-}
-
-pub struct Resolver<T = String> {
-    resolver: AsyncResolver,
-    req: PhantomData<T>,
-}
-
-impl<T: RequestHost> Default for Resolver<T> {
-    fn default() -> Self {
-        let (cfg, opts) = if let Ok((cfg, opts)) = read_system_conf() {
-            (cfg, opts)
-        } else {
-            (ResolverConfig::default(), ResolverOpts::default())
-        };
-
-        Resolver::new(cfg, opts)
-    }
-}
-
-impl<T: RequestHost> Resolver<T> {
-    /// Create new resolver instance with custom configuration and options.
-    pub fn new(cfg: ResolverConfig, opts: ResolverOpts) -> Self {
-        let (resolver, bg) = AsyncResolver::new(cfg, opts);
-        tokio_current_thread::spawn(bg);
-        Resolver {
-            resolver,
-            req: PhantomData,
-        }
-    }
-
-    /// Change type of resolver request.
-    pub fn into_request<T2: RequestHost>(&self) -> Resolver<T2> {
-        Resolver {
-            resolver: self.resolver.clone(),
-            req: PhantomData,
-        }
-    }
-}
-
-impl<T> Clone for Resolver<T> {
-    fn clone(&self) -> Self {
-        Resolver {
-            resolver: self.resolver.clone(),
-            req: PhantomData,
-        }
-    }
-}
-
-impl<T: RequestHost> Service for Resolver<T> {
-    type Request = T;
-    type Response = (T, VecDeque<IpAddr>);
-    type Error = ResolveError;
-    type Future = ResolverFuture<T>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        Ok(Async::Ready(()))
-    }
-
-    fn call(&mut self, req: T) -> Self::Future {
-        if let Ok(ip) = req.host().parse() {
-            let mut addrs = VecDeque::new();
-            addrs.push_back(ip);
-            ResolverFuture::new(req, &self.resolver, Some(addrs))
-        } else {
-            ResolverFuture::new(req, &self.resolver, None)
-        }
-    }
-}
-
-#[doc(hidden)]
-/// Resolver future
-pub struct ResolverFuture<T> {
-    req: Option<T>,
-    lookup: Option<Background<LookupIpFuture>>,
-    addrs: Option<VecDeque<IpAddr>>,
-}
-
-impl<T: RequestHost> ResolverFuture<T> {
-    pub fn new(addr: T, resolver: &AsyncResolver, addrs: Option<VecDeque<IpAddr>>) -> Self {
-        // we need to do dns resolution
-        let lookup = Some(resolver.lookup_ip(addr.host()));
-        ResolverFuture {
-            lookup,
-            addrs,
-            req: Some(addr),
-        }
-    }
-}
-
-impl<T: RequestHost> Future for ResolverFuture<T> {
-    type Item = (T, VecDeque<IpAddr>);
-    type Error = ResolveError;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if let Some(addrs) = self.addrs.take() {
-            Ok(Async::Ready((self.req.take().unwrap(), addrs)))
-        } else {
-            match self.lookup.as_mut().unwrap().poll() {
-                Ok(Async::NotReady) => Ok(Async::NotReady),
-                Ok(Async::Ready(ips)) => Ok(Async::Ready((
-                    self.req.take().unwrap(),
-                    ips.iter().collect(),
-                ))),
-                Err(err) => Err(err),
-            }
-        }
-    }
-}

actix-connector/src/ssl/openssl.rs

@@ -1,107 +0,0 @@
-use std::marker::PhantomData;
-
-use actix_codec::{AsyncRead, AsyncWrite};
-use actix_service::{NewService, Service};
-use futures::{future::ok, future::FutureResult, Async, Future, Poll};
-use openssl::ssl::{HandshakeError, SslConnector};
-use tokio_openssl::{ConnectAsync, SslConnectorExt, SslStream};
-
-use crate::resolver::RequestHost;
-
-/// Openssl connector factory
-pub struct OpensslConnector<R, T, E> {
-    connector: SslConnector,
-    _t: PhantomData<(R, T, E)>,
-}
-
-impl<R, T, E> OpensslConnector<R, T, E> {
-    pub fn new(connector: SslConnector) -> Self {
-        OpensslConnector {
-            connector,
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<R: RequestHost, T: AsyncRead + AsyncWrite> OpensslConnector<R, T, ()> {
-    pub fn service(
-        connector: SslConnector,
-    ) -> impl Service<Request = (R, T), Response = (R, SslStream<T>), Error = HandshakeError<T>>
-    {
-        OpensslConnectorService {
-            connector: connector,
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<R, T, E> Clone for OpensslConnector<R, T, E> {
-    fn clone(&self) -> Self {
-        Self {
-            connector: self.connector.clone(),
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<R: RequestHost, T: AsyncRead + AsyncWrite, E> NewService<()>
-    for OpensslConnector<R, T, E>
-{
-    type Request = (R, T);
-    type Response = (R, SslStream<T>);
-    type Error = HandshakeError<T>;
-    type Service = OpensslConnectorService<R, T>;
-    type InitError = E;
-    type Future = FutureResult<Self::Service, Self::InitError>;
-
-    fn new_service(&self, _: &()) -> Self::Future {
-        ok(OpensslConnectorService {
-            connector: self.connector.clone(),
-            _t: PhantomData,
-        })
-    }
-}
-
-pub struct OpensslConnectorService<R, T> {
-    connector: SslConnector,
-    _t: PhantomData<(R, T)>,
-}
-
-impl<R: RequestHost, T: AsyncRead + AsyncWrite> Service for OpensslConnectorService<R, T> {
-    type Request = (R, T);
-    type Response = (R, SslStream<T>);
-    type Error = HandshakeError<T>;
-    type Future = ConnectAsyncExt<R, T>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        Ok(Async::Ready(()))
-    }
-
-    fn call(&mut self, (req, stream): (R, T)) -> Self::Future {
-        ConnectAsyncExt {
-            fut: SslConnectorExt::connect_async(&self.connector, req.host(), stream),
-            req: Some(req),
-        }
-    }
-}
-
-pub struct ConnectAsyncExt<R, T> {
-    req: Option<R>,
-    fut: ConnectAsync<T>,
-}
-
-impl<R, T> Future for ConnectAsyncExt<R, T>
-where
-    R: RequestHost,
-    T: AsyncRead + AsyncWrite,
-{
-    type Item = (R, SslStream<T>);
-    type Error = HandshakeError<T>;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        match self.fut.poll()? {
-            Async::Ready(stream) => Ok(Async::Ready((self.req.take().unwrap(), stream))),
-            Async::NotReady => Ok(Async::NotReady),
-        }
-    }
-}

actix-rt/CHANGES.md

@@ -1,5 +1,11 @@
 # Changes
 
+## [0.2.2] - 2019-03-28
+
+### Changed
+
+* Moved `blocking` module to `actix-threadpool` crate
+
 ## [0.2.1] - 2019-03-11
 
 ### Added

actix-rt/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-rt"
-version = "0.2.1"
+version = "0.2.2"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix runtime"
 keywords = ["network", "framework", "async", "futures"]
@@ -11,21 +11,15 @@ categories = ["network-programming", "asynchronous"]
 license = "MIT/Apache-2.0"
 exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
 edition = "2018"
-workspace = "../"
+workspace = ".."
 
 [lib]
 name = "actix_rt"
 path = "src/lib.rs"
 
 [dependencies]
-bytes = "0.4"
-derive_more = "0.14"
+actix-threadpool = "0.1.0"
 futures = "0.1.25"
-parking_lot = "0.7"
-lazy_static = "1.2"
-log = "0.4"
-num_cpus = "1.10"
-threadpool = "1.7"
 tokio-current-thread = "0.1"
 tokio-executor = "0.1.5"
 tokio-reactor = "0.1.7"

actix-rt/src/arbiter.rs

@@ -36,6 +36,9 @@ impl fmt::Debug for ArbiterCommand {
 }
 
 #[derive(Debug, Clone)]
+/// Arbiters provide an asynchronous execution environment for actors, functions
+/// and futures. When an Arbiter is created, they spawn a new OS thread, and
+/// host an event loop. Some Arbiter functions execute on the current thread.
 pub struct Arbiter(UnboundedSender<ArbiterCommand>);
 
 impl Default for Arbiter {
@@ -56,7 +59,8 @@ impl Arbiter {
         arb
     }
 
-    /// Returns current arbiter's address
+    /// 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(),
@@ -64,7 +68,7 @@ impl Arbiter {
         })
     }
 
-    /// Stop arbiter
+    /// Stop arbiter from continuing it's event loop.
     pub fn stop(&self) {
         let _ = self.0.unbounded_send(ArbiterCommand::Stop);
     }
@@ -128,7 +132,9 @@ impl Arbiter {
         RUNNING.with(|cell| cell.set(false));
     }
 
-    /// Spawn a future on the current thread.
+    /// Spawn a future on the current thread. This does not create a new Arbiter
+    /// or Arbiter address, it is simply a helper for spawning futures on the current
+    /// thread.
     pub fn spawn<F>(future: F)
     where
         F: Future<Item = (), Error = ()> + 'static,
@@ -142,7 +148,9 @@ impl Arbiter {
         });
     }
 
-    /// Executes a future on the current thread.
+    /// Executes a future on the current thread. This does not create a new Arbiter
+    /// or Arbiter address, it is simply a helper for executing futures on the current
+    /// thread.
     pub fn spawn_fn<F, R>(f: F)
     where
         F: FnOnce() -> R + 'static,
@@ -151,7 +159,7 @@ impl Arbiter {
         Arbiter::spawn(future::lazy(f))
     }
 
-    /// Send a future on the arbiter's thread and spawn.
+    /// Send a future to the Arbiter's thread, and spawn it.
     pub fn send<F>(&self, future: F)
     where
         F: Future<Item = (), Error = ()> + Send + 'static,
@@ -161,7 +169,8 @@ impl Arbiter {
             .unbounded_send(ArbiterCommand::Execute(Box::new(future)));
     }
 
-    /// Send a function to the arbiter's thread and exeute.
+    /// Send a function to the Arbiter's thread, and execute it. Any result from the function
+    /// is discarded.
     pub fn exec_fn<F>(&self, f: F)
     where
         F: FnOnce() + Send + 'static,
@@ -173,7 +182,9 @@ impl Arbiter {
             })));
     }
 
-    /// Send a function to the arbiter's thread, exeute and return result.
+    /// Send a function to the Arbiter's thread. This function will be executed asynchronously.
+    /// A future is created, and when resolved will contain the result of the function sent
+    /// to the Arbiters thread.
     pub fn exec<F, R>(&self, f: F) -> impl Future<Item = R, Error = Canceled>
     where
         F: FnOnce() -> R + Send + 'static,

actix-rt/src/builder.rs

@@ -86,8 +86,7 @@ impl Builder {
         let (stop_tx, stop) = channel();
         let (sys_sender, sys_receiver) = unbounded();
 
-        let arbiter = Arbiter::new_system();
-        let system = System::construct(sys_sender, arbiter.clone(), self.stop_on_panic);
+        let system = System::construct(sys_sender, Arbiter::new_system(), self.stop_on_panic);
 
         // system arbiter
         let arb = SystemArbiter::new(stop_tx, sys_receiver);

actix-rt/src/lib.rs

@@ -1,7 +1,6 @@
 //! A runtime implementation that runs everything on the current thread.
 
 mod arbiter;
-pub mod blocking;
 mod builder;
 mod runtime;
 mod system;
@@ -11,6 +10,9 @@ pub use self::builder::{Builder, SystemRunner};
 pub use self::runtime::Runtime;
 pub use self::system::System;
 
+#[doc(hidden)]
+pub use actix_threadpool as blocking;
+
 /// Spawns a future on the current arbiter.
 ///
 /// # Panics

actix-rt/src/runtime.rs

@@ -41,7 +41,7 @@ impl Error for RunError {
         self.inner.description()
     }
     fn cause(&self) -> Option<&Error> {
-        self.inner.cause()
+        self.inner.source()
     }
 }
 

actix-rt/src/system.rs

@@ -1,13 +1,13 @@
 use std::cell::RefCell;
 use std::io;
-use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
+use std::sync::atomic::{AtomicUsize, Ordering};
 
 use futures::sync::mpsc::UnboundedSender;
 
 use crate::arbiter::{Arbiter, SystemCommand};
 use crate::builder::{Builder, SystemRunner};
 
-static SYSTEM_COUNT: AtomicUsize = ATOMIC_USIZE_INIT;
+static SYSTEM_COUNT: AtomicUsize = AtomicUsize::new(0);
 
 /// System is a runtime manager.
 #[derive(Clone, Debug)]

actix-server/CHANGES.md

@@ -1,5 +1,19 @@
 # Changes
 
+## [0.4.2] - 2019-03-30
+
+### Fixed
+
+* Fix SIGINT force shutdown
+
+
+## [0.4.1] - 2019-03-14
+
+### Added
+
+* `SystemRuntime::on_start()` - allow to run future before server service initialization
+
+
 ## [0.4.0] - 2019-03-12
 
 ### Changed

actix-server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-server"
-version = "0.4.0"
+version = "0.4.2"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix server - General purpose tcp server"
 keywords = ["network", "framework", "async", "futures"]

actix-server/src/builder.rs

@@ -12,8 +12,8 @@ use num_cpus;
 use tokio_timer::sleep;
 
 use crate::accept::{AcceptLoop, AcceptNotify, Command};
+use crate::config::{ConfiguredService, ServiceConfig};
 use crate::server::{Server, ServerCommand};
-use crate::service_config::{ConfiguredService, ServiceConfig};
 use crate::services::{InternalServiceFactory, ServiceFactory, StreamNewService};
 use crate::signals::{Signal, Signals};
 use crate::worker::{self, Worker, WorkerAvailability, WorkerClient};
@@ -328,7 +328,7 @@ impl ServerBuilder {
                 self.accept.send(Command::Stop);
 
                 // stop workers
-                if !self.workers.is_empty() {
+                if !self.workers.is_empty() && graceful {
                     spawn(
                         futures_unordered(
                             self.workers

actix-server/src/config.rs

@@ -114,16 +114,44 @@ impl InternalServiceFactory for ConfiguredService {
         self.rt.configure(&mut rt);
         rt.validate();
 
-        // construct services
-        let mut fut = Vec::new();
-        for (token, ns) in rt.services {
-            let config = ServerConfig::new(self.names[&token].1);
-            fut.push(ns.new_service(&config).map(move |service| (token, service)));
-        }
+        let services = rt.services;
 
-        Box::new(join_all(fut).map_err(|e| {
-            error!("Can not construct service: {:?}", e);
-        }))
+        // on start futures
+        if rt.onstart.is_empty() {
+            // construct services
+            let mut fut = Vec::new();
+            for (token, ns) in services {
+                let config = ServerConfig::new(self.names[&token].1);
+                fut.push(ns.new_service(&config).map(move |service| (token, service)));
+            }
+
+            Box::new(join_all(fut).map_err(|e| {
+                error!("Can not construct service: {:?}", e);
+            }))
+        } else {
+            let names = self.names.clone();
+
+            // run onstart future and then construct services
+            Box::new(
+                join_all(rt.onstart)
+                    .map_err(|e| {
+                        error!("Can not construct service: {:?}", e);
+                    })
+                    .and_then(move |_| {
+                        // construct services
+                        let mut fut = Vec::new();
+                        for (token, ns) in services {
+                            let config = ServerConfig::new(names[&token].1);
+                            fut.push(
+                                ns.new_service(&config).map(move |service| (token, service)),
+                            );
+                        }
+                        join_all(fut).map_err(|e| {
+                            error!("Can not construct service: {:?}", e);
+                        })
+                    }),
+            )
+        }
     }
 }
 
@@ -153,6 +181,7 @@ fn not_configured(_: &mut ServiceRuntime) {
 pub struct ServiceRuntime {
     names: HashMap<String, Token>,
     services: HashMap<Token, BoxedNewService>,
+    onstart: Vec<Box<Future<Item = (), Error = ()>>>,
 }
 
 impl ServiceRuntime {
@@ -160,6 +189,7 @@ impl ServiceRuntime {
         ServiceRuntime {
             names,
             services: HashMap::new(),
+            onstart: Vec::new(),
         }
     }
 
@@ -171,6 +201,10 @@ impl ServiceRuntime {
         }
     }
 
+    /// Register service.
+    ///
+    /// Name of the service must be registered during configuration stage with
+    /// *ServiceConfig::bind()* or *ServiceConfig::listen()* methods.
     pub fn service<T, F>(&mut self, name: &str, service: F)
     where
         F: IntoNewService<T, ServerConfig>,
@@ -191,6 +225,14 @@ impl ServiceRuntime {
             panic!("Unknown service: {:?}", name);
         }
     }
+
+    /// Execute future before services initialization.
+    pub fn on_start<F>(&mut self, fut: F)
+    where
+        F: Future<Item = (), Error = ()> + 'static,
+    {
+        self.onstart.push(Box::new(fut))
+    }
 }
 
 type BoxedNewService = Box<

actix-server/src/lib.rs

@@ -2,9 +2,9 @@
 
 mod accept;
 mod builder;
+mod config;
 mod counter;
 mod server;
-mod service_config;
 mod services;
 mod signals;
 pub mod ssl;
@@ -13,8 +13,8 @@ mod worker;
 pub use actix_server_config::{Io, Protocol, ServerConfig};
 
 pub use self::builder::ServerBuilder;
+pub use self::config::{ServiceConfig, ServiceRuntime};
 pub use self::server::Server;
-pub use self::service_config::{ServiceConfig, ServiceRuntime};
 pub use self::services::ServiceFactory;
 
 #[doc(hidden)]

actix-server/tests/test_server.rs

@@ -22,9 +22,11 @@ fn unused_addr() -> net::SocketAddr {
 #[test]
 fn test_bind() {
     let addr = unused_addr();
+    let (tx, rx) = mpsc::channel();
 
-    thread::spawn(move || {
-        Server::build()
+    let h = thread::spawn(move || {
+        let sys = actix_rt::System::new("test");
+        let srv = Server::build()
             .bind("test", addr, move || {
                 fn_cfg_factory(move |cfg: &ServerConfig| {
                     assert_eq!(cfg.local_addr(), addr);
@@ -32,11 +34,16 @@ fn test_bind() {
                 })
             })
             .unwrap()
-            .run()
+            .start();
+        let _ = tx.send((srv, actix_rt::System::current()));
+        let _ = sys.run();
     });
+    let (_, sys) = rx.recv().unwrap();
 
     thread::sleep(time::Duration::from_millis(500));
     assert!(net::TcpStream::connect(addr).is_ok());
+    let _ = sys.stop();
+    let _ = h.join();
 }
 
 #[test]
@@ -44,7 +51,7 @@ fn test_bind_no_config() {
     let addr = unused_addr();
     let (tx, rx) = mpsc::channel();
 
-    thread::spawn(move || {
+    let h = thread::spawn(move || {
         let sys = actix_rt::System::new("test");
         let srv = Server::build()
             .bind("test", addr, move || fn_service(|_| Ok::<_, ()>(())))
@@ -56,15 +63,18 @@ fn test_bind_no_config() {
     let (_, sys) = rx.recv().unwrap();
     assert!(net::TcpStream::connect(addr).is_ok());
     let _ = sys.stop();
+    let _ = h.join();
 }
 
 #[test]
 fn test_listen() {
     let addr = unused_addr();
+    let (tx, rx) = mpsc::channel();
 
-    thread::spawn(move || {
+    let h = thread::spawn(move || {
+        let sys = actix_rt::System::new("test");
         let lst = net::TcpListener::bind(addr).unwrap();
-        Server::build()
+        let srv = Server::build()
             .listen("test", lst, move || {
                 fn_cfg_factory(move |cfg: &ServerConfig| {
                     assert_eq!(cfg.local_addr(), addr);
@@ -72,11 +82,16 @@ fn test_listen() {
                 })
             })
             .unwrap()
-            .run()
+            .start();
+        let _ = tx.send((srv, actix_rt::System::current()));
+        let _ = sys.run();
     });
+    let (_, sys) = rx.recv().unwrap();
 
     thread::sleep(time::Duration::from_millis(500));
     assert!(net::TcpStream::connect(addr).is_ok());
+    let _ = sys.stop();
+    let _ = h.join();
 }
 
 #[test]
@@ -85,9 +100,8 @@ fn test_start() {
     let addr = unused_addr();
     let (tx, rx) = mpsc::channel();
 
-    thread::spawn(move || {
+    let h = thread::spawn(move || {
         let sys = actix_rt::System::new("test");
-
         let srv = Server::build()
             .backlog(100)
             .bind("test", addr, move || {
@@ -144,4 +158,5 @@ fn test_start() {
 
     thread::sleep(time::Duration::from_millis(100));
     let _ = sys.stop();
+    let _ = h.join();
 }

actix-service/CHANGES.md

@@ -1,5 +1,12 @@
 # Changes
 
+## [0.3.5] - 2019-03-29
+
+### Added
+
+* Add `impl<S: Service> Service for Rc<RefCell<S>>`
+
+
 ## [0.3.4] - 2019-03-12
 
 ### Added

actix-service/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-service"
-version = "0.3.4"
+version = "0.3.5"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix Service"
 keywords = ["network", "framework", "async", "futures"]

actix-service/src/lib.rs

@@ -1,3 +1,4 @@
+use std::cell::RefCell;
 use std::rc::Rc;
 use std::sync::Arc;
 
@@ -391,6 +392,24 @@ where
     }
 }
 
+impl<S> Service for Rc<RefCell<S>>
+where
+    S: Service,
+{
+    type Request = S::Request;
+    type Response = S::Response;
+    type Error = S::Error;
+    type Future = S::Future;
+
+    fn poll_ready(&mut self) -> Poll<(), S::Error> {
+        self.borrow_mut().poll_ready()
+    }
+
+    fn call(&mut self, request: Self::Request) -> S::Future {
+        self.borrow_mut().call(request)
+    }
+}
+
 impl<S, C> NewService<C> for Rc<S>
 where
     S: NewService<C>,

actix-test-server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-test-server"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix test server"
 keywords = ["network", "framework", "async", "futures"]
@@ -33,9 +33,9 @@ ssl = ["openssl", "actix-server/ssl"]
 rust-tls = ["rustls", "tokio-rustls", "webpki", "webpki-roots"]
 
 [dependencies]
-actix-rt = "0.2.0"
-# actix-server = "0.3.3"
-actix-server = { path="../actix-server" }
+actix-rt = "0.2.1"
+actix-server = "0.4.0"
+actix-server-config = "0.1.0"
 
 log = "0.4"
 net2 = "0.2"
@@ -56,4 +56,4 @@ webpki = { version = "0.19", optional = true }
 webpki-roots = { version = "0.16", optional = true }
 
 [dev-dependencies]
-actix-service = "0.3.3"
+actix-service = "0.3.4"

actix-test-server/src/lib.rs

@@ -4,6 +4,7 @@ use std::{net, thread};
 
 use actix_rt::{Runtime, System};
 use actix_server::{Server, StreamServiceFactory};
+pub use actix_server_config::{Io, ServerConfig};
 
 use futures::Future;
 use net2::TcpBuilder;

actix-threadpool/CHANGES.md

@@ -0,0 +1,5 @@
+# Changes
+
+## [0.1.0] - 2019-03-28
+
+* Move threadpool to separate crate

actix-threadpool/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "actix-threadpool"
+version = "0.1.0"
+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/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.14"
+futures = "0.1.25"
+parking_lot = "0.7"
+lazy_static = "1.2"
+log = "0.4"
+num_cpus = "1.10"
+threadpool = "1.7"

actix-threadpool/src/lib.rs

@@ -9,7 +9,7 @@ use parking_lot::Mutex;
 use threadpool::ThreadPool;
 
 /// Env variable for default cpu pool size
-const ENV_CPU_POOL_VAR: &str = "ACTIX_CPU_POOL";
+const ENV_CPU_POOL_VAR: &str = "ACTIX_THREADPOOL";
 
 lazy_static::lazy_static! {
     pub(crate) static ref DEFAULT_POOL: Mutex<ThreadPool> = {
@@ -18,7 +18,7 @@ lazy_static::lazy_static! {
                 if let Ok(val) = val.parse() {
                     val
                 } else {
-                    log::error!("Can not parse ACTIX_CPU_POOL value");
+                    log::error!("Can not parse ACTIX_THREADPOOL value");
                     num_cpus::get() * 5
                 }
             }

actix-utils/CHANGES.md

@@ -1,5 +1,10 @@
 # Changes
 
+### Added
+
+* Allow to send messages to `FramedTransport` via mpsc channel.
+
+
 ## [0.3.4] - 2019-03-12
 
 ### Changed

actix-utils/src/framed.rs

@@ -7,6 +7,7 @@ use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
 use actix_service::{IntoNewService, IntoService, NewService, Service};
 use futures::future::{ok, FutureResult};
 use futures::task::AtomicTask;
+use futures::unsync::mpsc;
 use futures::{Async, Future, IntoFuture, Poll, Sink, Stream};
 use log::debug;
 
@@ -178,6 +179,11 @@ impl<E, U: Encoder + Decoder> From<E> for FramedTransportError<E, U> {
     }
 }
 
+pub enum FramedMessage<T> {
+    Message(T),
+    Close,
+}
+
 /// FramedTransport - is a future that reads frames from Framed object
 /// and pass then to the service.
 pub struct FramedTransport<S, T, U>
@@ -193,6 +199,7 @@ where
     service: S,
     state: TransportState<S, U>,
     framed: Framed<T, U>,
+    rx: Option<mpsc::UnboundedReceiver<FramedMessage<<U as Encoder>::Item>>>,
     inner: Cell<FramedTransportInner<<U as Encoder>::Item, S::Error>>,
 }
 
@@ -200,6 +207,7 @@ enum TransportState<S: Service, U: Encoder + Decoder> {
     Processing,
     Error(FramedTransportError<S::Error, U>),
     FramedError(FramedTransportError<S::Error, U>),
+    FlushAndStop,
     Stopping,
 }
 
@@ -257,10 +265,12 @@ where
     /// write to framed object
     fn poll_write(&mut self) -> bool {
         let inner = self.inner.get_mut();
+        let mut rx_done = self.rx.is_none();
+        let mut buf_empty = inner.buf.is_empty();
         loop {
             while !self.framed.is_write_buf_full() {
-                if let Some(msg) = inner.buf.pop_front() {
-                    match msg {
+                if !buf_empty {
+                    match inner.buf.pop_front().unwrap() {
                         Ok(msg) => {
                             if let Err(err) = self.framed.force_send(msg) {
                                 self.state = TransportState::FramedError(
@@ -268,6 +278,7 @@ where
                                 );
                                 return true;
                             }
+                            buf_empty = inner.buf.is_empty();
                         }
                         Err(err) => {
                             self.state =
@@ -275,7 +286,33 @@ where
                             return true;
                         }
                     }
-                } else {
+                }
+
+                if !rx_done && self.rx.is_some() {
+                    match self.rx.as_mut().unwrap().poll() {
+                        Ok(Async::Ready(Some(FramedMessage::Message(msg)))) => {
+                            if let Err(err) = self.framed.force_send(msg) {
+                                self.state = TransportState::FramedError(
+                                    FramedTransportError::Encoder(err),
+                                );
+                                return true;
+                            }
+                        }
+                        Ok(Async::Ready(Some(FramedMessage::Close))) => {
+                            self.state = TransportState::FlushAndStop;
+                            return true;
+                        }
+                        Ok(Async::Ready(None)) => {
+                            let _ = self.rx.take();
+                        }
+                        Ok(Async::NotReady) => rx_done = true,
+                        Err(_e) => {
+                            let _ = self.rx.take();
+                        }
+                    }
+                }
+
+                if rx_done && buf_empty {
                     break;
                 }
             }
@@ -313,6 +350,7 @@ where
     pub fn new<F: IntoService<S>>(framed: Framed<T, U>, service: F) -> Self {
         FramedTransport {
             framed,
+            rx: None,
             service: service.into_service(),
             state: TransportState::Processing,
             inner: Cell::new(FramedTransportInner {
@@ -322,6 +360,15 @@ where
         }
     }
 
+    /// Get Sender
+    pub fn set_receiver(
+        mut self,
+        rx: mpsc::UnboundedReceiver<FramedMessage<<U as Encoder>::Item>>,
+    ) -> Self {
+        self.rx = Some(rx);
+        self
+    }
+
     /// Get reference to a service wrapped by `FramedTransport` instance.
     pub fn get_ref(&self) -> &S {
         &self.service
@@ -378,6 +425,20 @@ where
                     Ok(Async::NotReady)
                 }
             }
+            TransportState::FlushAndStop => {
+                if !self.framed.is_write_buf_empty() {
+                    match self.framed.poll_complete() {
+                        Err(err) => {
+                            debug!("Error sending data: {:?}", err);
+                            Ok(Async::Ready(()))
+                        }
+                        Ok(Async::NotReady) => Ok(Async::NotReady),
+                        Ok(Async::Ready(_)) => Ok(Async::Ready(())),
+                    }
+                } else {
+                    Ok(Async::Ready(()))
+                }
+            }
             TransportState::FramedError(err) => Err(err),
             TransportState::Stopping => Ok(Async::Ready(())),
         }

actix-utils/src/order.rs

@@ -245,7 +245,7 @@ mod tests {
         let (tx3, rx3) = oneshot::channel();
         let (tx_stop, rx_stop) = oneshot::channel();
 
-        std::thread::spawn(move || {
+        let h = std::thread::spawn(move || {
             let rx1 = rx1;
             let rx2 = rx2;
             let rx3 = rx3;
@@ -263,6 +263,7 @@ mod tests {
                     .and_then(move |res: Vec<_>| {
                         assert_eq!(res, vec![1, 2, 3]);
                         let _ = tx_stop.send(());
+                        actix_rt::System::current().stop();
                         Ok(())
                     })
             }));
@@ -274,5 +275,6 @@ mod tests {
         let _ = tx1.send(1);
 
         let _ = rx_stop.wait();
+        let _ = h.join();
     }
 }

router/CHANGES.txt

@@ -1,5 +1,9 @@
 # Changes
 
+## [0.1.1] - 2019-04-03
+
+* Get dynamic segment by name instead of iterator.
+
 ## [0.1.0] - 2019-03-09
 
 * Initial release

router/Cargo.toml

@@ -1,16 +1,16 @@
 [package]
 name = "actix-router"
-version = "0.1.0"
+version = "0.1.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Path router"
 keywords = ["actix"]
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-net.git"
-documentation = "https://actix.rs/api/actix-net/stable/actix_router/"
+documentation = "https://docs.rs/actix-router/"
 license = "MIT/Apache-2.0"
 exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
 edition = "2018"
-workspace = "../"
+workspace = ".."
 
 [lib]
 name = "actix_router"
@@ -23,7 +23,8 @@ default = ["http"]
 bytes = "0.4"
 regex = "1.0"
 serde = "1.0.80"
-string = "0.1.3"
+string = "0.2.0"
+log = "0.4"
 http = { version="0.1.14", optional=true }
 
 [dev-dependencies]

router/src/resource.rs

@@ -196,18 +196,17 @@ impl ResourceDef {
                     [PathItem::Static(""); MAX_DYNAMIC_SEGMENTS];
 
                 if let Some(captures) = re.captures(path.path()) {
-                    let mut passed = false;
-
-                    for capture in captures.iter() {
-                        if let Some(ref m) = capture {
-                            if !passed {
-                                passed = true;
-                                continue;
-                            }
-
-                            segments[idx] = PathItem::Segment(m.start() as u16, m.end() as u16);
+                    for (no, name) in names.iter().enumerate() {
+                        if let Some(m) = captures.name(&name) {
                             idx += 1;
                             pos = m.end();
+                            segments[no] = PathItem::Segment(m.start() as u16, m.end() as u16);
+                        } else {
+                            log::error!(
+                                "Dynamic path match but not all segments found: {}",
+                                name
+                            );
+                            false;
                         }
                     }
                 } else {