Fix back-pressure handling for concurrent connections

CHANGES.md

@@ -1,5 +1,68 @@
 # Changes
 
+## [0.2.6] - 2018-12-21
+
+### Fixed
+
+* Fix back-pressure handling for concurrent connections
+
+
+## [0.2.5] - 2018-12-12
+
+### Fixed
+
+* Fix back-pressure for concurrent ssl handshakes
+
+* Drop completed future for .then and .and_then combinators
+
+
+## [0.2.4] - 2018-11-21
+
+### Added
+
+* Allow to skip name resolution stage in Connector
+
+
+## [0.2.3] - 2018-11-17
+
+### Added
+
+* Framed::is_write_buf_empty() checks if write buffer is flushed
+
+## [0.2.2] - 2018-11-14
+
+### Added
+
+* Add low/high caps to Framed
+
+### Changed
+
+* Refactor Connector and Resolver services
+
+
+### Fixed
+
+* Fix wrong service to socket binding
+
+
+## [0.2.0] - 2018-11-08
+
+### Added
+
+* Timeout service
+
+* Added ServiceConfig and ServiceRuntime for server service configuration
+
+
+### Changed
+
+* Connector has been refactored
+
+* timer and LowResTimer renamed to time and LowResTime
+
+* Refactored `Server::configure()` method
+
+
 ## [0.1.1] - 2018-10-10
 
 ### Changed

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-net"
-version = "0.2.0"
+version = "0.2.6"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix net - framework for the compisible network services for Rust (experimental)"
 readme = "README.md"
@@ -39,7 +39,7 @@ rust-tls = ["rustls", "tokio-rustls", "webpki", "webpki-roots"]
 cell = []
 
 [dependencies]
-actix = "^0.7.5"
+actix = "0.7.6"
 
 log = "0.4"
 num_cpus = "1.0"
@@ -58,8 +58,7 @@ tokio-timer = "0.2"
 tokio-reactor = "0.1"
 tokio-current-thread = "0.1"
 tower-service = "0.1"
-trust-dns-proto = "^0.5.0"
-trust-dns-resolver = "^0.10.0"
+trust-dns-resolver = "^0.10.2"
 
 # native-tls
 native-tls = { version="0.2", optional = true }

examples/basic.rs

@@ -80,7 +80,8 @@ fn main() {
                     future::ok(())
                 })
             },
-        ).unwrap()
+        )
+        .unwrap()
         .start();
 
     sys.run();

examples/ssl.rs

@@ -61,7 +61,8 @@ fn main() {
                     println!("got ssl connection {:?}", num);
                     future::ok(())
                 })
-        }).unwrap()
+        })
+        .unwrap()
         .start();
 
     sys.run();

src/codec/framed.rs

@@ -11,6 +11,9 @@ use tokio_io::{AsyncRead, AsyncWrite};
 use super::framed_read::{framed_read2, framed_read2_with_buffer, FramedRead2};
 use super::framed_write::{framed_write2, framed_write2_with_buffer, FramedWrite2};
 
+const LW: usize = 1024;
+const HW: usize = 8 * 1024;
+
 /// A unified `Stream` and `Sink` interface to an underlying I/O object, using
 /// the `Encoder` and `Decoder` traits to encode and decode frames.
 ///
@@ -45,9 +48,25 @@ where
     /// break them into separate objects, allowing them to interact more easily.
     pub fn new(inner: T, codec: U) -> Framed<T, U> {
         Framed {
-            inner: framed_read2(framed_write2(Fuse(inner, codec))),
+            inner: framed_read2(framed_write2(Fuse(inner, codec), LW, HW)),
         }
     }
+
+    /// Same as `Framed::new()` with ability to specify write buffer low/high capacity watermarks.
+    pub fn new_with_caps(inner: T, codec: U, lw: usize, hw: usize) -> Framed<T, U> {
+        debug_assert!((lw < hw) && hw != 0);
+        Framed {
+            inner: framed_read2(framed_write2(Fuse(inner, codec), lw, hw)),
+        }
+    }
+
+    /// Force send item
+    pub fn force_send(
+        &mut self,
+        item: <U as Encoder>::Item,
+    ) -> Result<(), <U as Encoder>::Error> {
+        self.inner.get_mut().force_send(item)
+    }
 }
 
 impl<T, U> Framed<T, U> {
@@ -75,7 +94,12 @@ impl<T, U> Framed<T, U> {
     pub fn from_parts(parts: FramedParts<T, U>) -> Framed<T, U> {
         Framed {
             inner: framed_read2_with_buffer(
-                framed_write2_with_buffer(Fuse(parts.io, parts.codec), parts.write_buf),
+                framed_write2_with_buffer(
+                    Fuse(parts.io, parts.codec),
+                    parts.write_buf,
+                    parts.write_buf_lw,
+                    parts.write_buf_hw,
+                ),
                 parts.read_buf,
             ),
         }
@@ -111,6 +135,16 @@ impl<T, U> Framed<T, U> {
         &mut self.inner.get_mut().get_mut().0
     }
 
+    /// Check if write buffer is empty.
+    pub fn is_write_buf_empty(&self) -> bool {
+        self.inner.get_ref().is_empty()
+    }
+
+    /// Check if write buffer is full.
+    pub fn is_write_buf_full(&self) -> bool {
+        self.inner.get_ref().is_full()
+    }
+
     /// Consumes the `Frame`, returning its underlying I/O stream.
     ///
     /// Note that care should be taken to not tamper with the underlying stream
@@ -123,11 +157,27 @@ impl<T, U> Framed<T, U> {
     /// Consume the `Frame`, returning `Frame` with different codec.
     pub fn into_framed<U2>(self, codec: U2) -> Framed<T, U2> {
         let (inner, read_buf) = self.inner.into_parts();
-        let (inner, write_buf) = inner.into_parts();
+        let (inner, write_buf, lw, hw) = inner.into_parts();
 
         Framed {
             inner: framed_read2_with_buffer(
-                framed_write2_with_buffer(Fuse(inner.0, codec), write_buf),
+                framed_write2_with_buffer(Fuse(inner.0, codec), 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
+        F: Fn(U) -> U2,
+    {
+        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(inner.0, f(inner.1)), write_buf, lw, hw),
                 read_buf,
             ),
         }
@@ -141,13 +191,15 @@ impl<T, U> Framed<T, U> {
     /// being worked with.
     pub fn into_parts(self) -> FramedParts<T, U> {
         let (inner, read_buf) = self.inner.into_parts();
-        let (inner, write_buf) = inner.into_parts();
+        let (inner, write_buf, write_buf_lw, write_buf_hw) = inner.into_parts();
 
         FramedParts {
             io: inner.0,
             codec: inner.1,
-            read_buf: read_buf,
-            write_buf: write_buf,
+            read_buf,
+            write_buf,
+            write_buf_lw,
+            write_buf_hw,
             _priv: (),
         }
     }
@@ -273,6 +325,12 @@ pub struct FramedParts<T, U> {
     /// A buffer with unprocessed data which are not written yet.
     pub write_buf: BytesMut,
 
+    /// A buffer low watermark capacity
+    pub write_buf_lw: usize,
+
+    /// A buffer high watermark capacity
+    pub write_buf_hw: usize,
+
     /// This private field allows us to add additional fields in the future in a
     /// backwards compatible way.
     _priv: (),
@@ -286,6 +344,8 @@ impl<T, U> FramedParts<T, U> {
             codec,
             read_buf: BytesMut::new(),
             write_buf: BytesMut::new(),
+            write_buf_lw: LW,
+            write_buf_hw: HW,
             _priv: (),
         }
     }

src/codec/framed_write.rs

@@ -16,20 +16,19 @@ pub struct FramedWrite<T, E> {
 pub struct FramedWrite2<T> {
     inner: T,
     buffer: BytesMut,
+    low_watermark: usize,
+    high_watermark: usize,
 }
 
-const INITIAL_CAPACITY: usize = 8 * 1024;
-const BACKPRESSURE_BOUNDARY: usize = INITIAL_CAPACITY;
-
 impl<T, E> FramedWrite<T, E>
 where
     T: AsyncWrite,
     E: Encoder,
 {
     /// Creates a new `FramedWrite` with the given `encoder`.
-    pub fn new(inner: T, encoder: E) -> FramedWrite<T, E> {
+    pub fn new(inner: T, encoder: E, lw: usize, hw: usize) -> FramedWrite<T, E> {
         FramedWrite {
-            inner: framed_write2(Fuse(inner, encoder)),
+            inner: framed_write2(Fuse(inner, encoder), lw, hw),
         }
     }
 }
@@ -73,6 +72,26 @@ impl<T, E> FramedWrite<T, E> {
     pub fn encoder_mut(&mut self) -> &mut E {
         &mut self.inner.inner.1
     }
+
+    /// Check if write buffer is full
+    pub fn is_full(&self) -> bool {
+        self.inner.is_full()
+    }
+
+    /// Check if write buffer is empty.
+    pub fn is_empty(&self) -> bool {
+        self.inner.is_empty()
+    }
+}
+
+impl<T, E> FramedWrite<T, E>
+where
+    E: Encoder,
+{
+    /// Force send item
+    pub fn force_send(&mut self, item: E::Item) -> Result<(), E::Error> {
+        self.inner.force_send(item)
+    }
 }
 
 impl<T, E> Sink for FramedWrite<T, E>
@@ -124,21 +143,34 @@ where
 
 // ===== impl FramedWrite2 =====
 
-pub fn framed_write2<T>(inner: T) -> FramedWrite2<T> {
+pub fn framed_write2<T>(
+    inner: T,
+    low_watermark: usize,
+    high_watermark: usize,
+) -> FramedWrite2<T> {
     FramedWrite2 {
-        inner: inner,
-        buffer: BytesMut::with_capacity(INITIAL_CAPACITY),
+        inner,
+        low_watermark,
+        high_watermark,
+        buffer: BytesMut::with_capacity(high_watermark),
     }
 }
 
-pub fn framed_write2_with_buffer<T>(inner: T, mut buf: BytesMut) -> FramedWrite2<T> {
-    if buf.capacity() < INITIAL_CAPACITY {
-        let bytes_to_reserve = INITIAL_CAPACITY - buf.capacity();
-        buf.reserve(bytes_to_reserve);
+pub fn framed_write2_with_buffer<T>(
+    inner: T,
+    mut buffer: BytesMut,
+    low_watermark: usize,
+    high_watermark: usize,
+) -> FramedWrite2<T> {
+    if buffer.capacity() < high_watermark {
+        let bytes_to_reserve = high_watermark - buffer.capacity();
+        buffer.reserve(bytes_to_reserve);
     }
     FramedWrite2 {
-        inner: inner,
-        buffer: buf,
+        inner,
+        buffer,
+        low_watermark,
+        high_watermark,
     }
 }
 
@@ -151,13 +183,40 @@ impl<T> FramedWrite2<T> {
         self.inner
     }
 
-    pub fn into_parts(self) -> (T, BytesMut) {
-        (self.inner, self.buffer)
+    pub fn into_parts(self) -> (T, BytesMut, usize, usize) {
+        (
+            self.inner,
+            self.buffer,
+            self.low_watermark,
+            self.high_watermark,
+        )
     }
 
     pub fn get_mut(&mut self) -> &mut T {
         &mut self.inner
     }
+
+    pub fn is_full(&self) -> bool {
+        self.buffer.len() >= self.high_watermark
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.buffer.is_empty()
+    }
+}
+
+impl<T> FramedWrite2<T>
+where
+    T: Encoder,
+{
+    pub fn force_send(&mut self, item: T::Item) -> Result<(), T::Error> {
+        let len = self.buffer.len();
+        if len < self.low_watermark {
+            self.buffer.reserve(self.high_watermark - len)
+        }
+        self.inner.encode(item, &mut self.buffer)?;
+        Ok(())
+    }
 }
 
 impl<T> Sink for FramedWrite2<T>
@@ -168,18 +227,16 @@ where
     type SinkError = T::Error;
 
     fn start_send(&mut self, item: T::Item) -> StartSend<T::Item, T::Error> {
-        // If the buffer is already over 8KiB, then attempt to flush it. If after
-        // flushing it's *still* over 8KiB, then apply backpressure (reject the
-        // send).
-        if self.buffer.len() >= BACKPRESSURE_BOUNDARY {
-            try!(self.poll_complete());
-
-            if self.buffer.len() >= BACKPRESSURE_BOUNDARY {
-                return Ok(AsyncSink::NotReady(item));
-            }
+        // Check the buffer capacity
+        let len = self.buffer.len();
+        if len >= self.high_watermark {
+            return Ok(AsyncSink::NotReady(item));
+        }
+        if len < self.low_watermark {
+            self.buffer.reserve(self.high_watermark - len)
         }
 
-        try!(self.inner.encode(item, &mut self.buffer));
+        self.inner.encode(item, &mut self.buffer)?;
 
         Ok(AsyncSink::Ready)
     }
@@ -197,7 +254,8 @@ where
                     io::ErrorKind::WriteZero,
                     "failed to \
                      write frame to transport",
-                ).into());
+                )
+                .into());
             }
 
             // TODO: Add a way to `bytes` to do this w/o returning the drained

src/codec/mod.rs

@@ -14,12 +14,12 @@
 
 mod bcodec;
 mod framed;
-mod framed2;
+// mod framed2;
 mod framed_read;
 mod framed_write;
 
 pub use self::bcodec::BytesCodec;
 pub use self::framed::{Framed, FramedParts};
-pub use self::framed2::{Framed2, FramedParts2};
+// pub use self::framed2::{Framed2, FramedParts2};
 pub use self::framed_read::FramedRead;
 pub use self::framed_write::FramedWrite;

src/connector.rs

@@ -1,19 +1,24 @@
 use std::collections::VecDeque;
-use std::net::SocketAddr;
+use std::marker::PhantomData;
+use std::net::{IpAddr, SocketAddr};
 use std::time::Duration;
 use std::{fmt, io};
 
-use futures::{
-    future::{ok, FutureResult},
-    Async, Future, Poll,
-};
+use futures::future::{ok, Either, FutureResult};
+use futures::{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::{HostAware, ResolveError, Resolver, ResolverFuture};
+use super::resolver::{RequestHost, ResolveError, Resolver, ResolverFuture};
 use super::service::{NewService, Service};
 
+/// Port of the request
+pub trait RequestPort {
+    fn port(&self) -> u16;
+}
+
 // #[derive(Fail, Debug)]
 #[derive(Debug)]
 pub enum ConnectorError {
@@ -22,7 +27,7 @@ pub enum ConnectorError {
     Resolver(ResolveError),
 
     /// No dns records
-    // #[fail(display = "Invalid input: {}", _0)]
+    // #[fail(display = "No dns records found for the input")]
     NoRecords,
 
     /// Connecting took too long
@@ -43,20 +48,33 @@ impl From<ResolveError> for ConnectorError {
     }
 }
 
+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 host: String,
-    pub port: u16,
+    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 {
-            port,
-            host: host.as_ref().to_owned(),
+            kind: ConnectKind::Host {
+                host: host.as_ref().to_owned(),
+                port,
+            },
             timeout: Duration::from_secs(1),
         }
     }
@@ -70,12 +88,25 @@ impl Connect {
             .parse::<u16>()
             .map_err(|_| ConnectorError::InvalidInput)?;
         Ok(Connect {
-            port,
-            host: host.to_owned(),
+            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.
@@ -85,15 +116,27 @@ impl Connect {
     }
 }
 
-impl HostAware for Connect {
+impl RequestHost for Connect {
     fn host(&self) -> &str {
-        &self.host
+        match self.kind {
+            ConnectKind::Host { ref host, port: _ } => host,
+            ConnectKind::Addr { ref host, addr: _ } => host,
+        }
+    }
+}
+
+impl RequestPort for Connect {
+    fn port(&self) -> u16 {
+        match self.kind {
+            ConnectKind::Host { host: _, port } => port,
+            ConnectKind::Addr { host: _, addr } => addr.port(),
+        }
     }
 }
 
 impl fmt::Display for Connect {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}:{}", self.host, self.port)
+        write!(f, "{}:{}", self.host(), self.port())
     }
 }
 
@@ -156,16 +199,25 @@ impl Service for Connector {
     type Request = Connect;
     type Response = (Connect, TcpStream);
     type Error = ConnectorError;
-    type Future = ConnectorFuture;
+    type Future = Either<ConnectorFuture, ConnectorTcpFuture>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         Ok(Async::Ready(()))
     }
 
     fn call(&mut self, req: Self::Request) -> Self::Future {
-        ConnectorFuture {
-            fut: self.resolver.call(req),
-            fut2: None,
+        match req.kind {
+            ConnectKind::Host { host: _, port: _ } => Either::A(ConnectorFuture {
+                fut: self.resolver.call(req),
+                fut2: None,
+            }),
+            ConnectKind::Addr { host: _, addr } => {
+                let mut addrs = VecDeque::new();
+                addrs.push_back(addr.ip());
+                Either::B(ConnectorTcpFuture {
+                    fut: TcpConnectorResponse::new(req, addrs),
+                })
+            }
         }
     }
 }
@@ -173,7 +225,7 @@ impl Service for Connector {
 #[doc(hidden)]
 pub struct ConnectorFuture {
     fut: ResolverFuture<Connect>,
-    fut2: Option<TcpConnector>,
+    fut2: Option<TcpConnectorResponse<Connect>>,
 }
 
 impl Future for ConnectorFuture {
@@ -182,20 +234,14 @@ impl Future for ConnectorFuture {
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
         if let Some(ref mut fut) = self.fut2 {
-            return fut.poll();
+            return fut.poll().map_err(ConnectorError::from);
         }
         match self.fut.poll().map_err(ConnectorError::from)? {
-            Async::Ready((req, mut addrs)) => {
+            Async::Ready((req, addrs)) => {
                 if addrs.is_empty() {
                     Err(ConnectorError::NoRecords)
                 } else {
-                    for addr in &mut addrs {
-                        match addr {
-                            SocketAddr::V4(ref mut addr) => addr.set_port(req.port),
-                            SocketAddr::V6(ref mut addr) => addr.set_port(req.port),
-                        }
-                    }
-                    self.fut2 = Some(TcpConnector::new(req, addrs));
+                    self.fut2 = Some(TcpConnectorResponse::new(req, addrs));
                     self.poll()
                 }
             }
@@ -205,18 +251,58 @@ impl Future for ConnectorFuture {
 }
 
 #[doc(hidden)]
-/// Tcp stream connector
-pub struct TcpConnector {
-    req: Option<Connect>,
+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): Self::Request) -> 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<SocketAddr>,
+    addrs: VecDeque<IpAddr>,
     stream: Option<ConnectFuture>,
 }
 
-impl TcpConnector {
-    pub fn new(req: Connect, addrs: VecDeque<SocketAddr>) -> TcpConnector {
-        TcpConnector {
+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,
@@ -224,9 +310,9 @@ impl TcpConnector {
     }
 }
 
-impl Future for TcpConnector {
-    type Item = (Connect, TcpStream);
-    type Error = ConnectorError;
+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
@@ -239,14 +325,14 @@ impl Future for TcpConnector {
                     Ok(Async::NotReady) => return Ok(Async::NotReady),
                     Err(err) => {
                         if self.addrs.is_empty() {
-                            return Err(ConnectorError::IoError(err));
+                            return Err(err);
                         }
                     }
                 }
             }
 
             // try to connect
-            let addr = self.addrs.pop_front().unwrap();
+            let addr = SocketAddr::new(self.addrs.pop_front().unwrap(), self.port);
             self.stream = Some(TcpStream::connect(&addr));
             self.addr = Some(addr)
         }
@@ -287,7 +373,7 @@ impl Service for DefaultConnector {
 
 #[doc(hidden)]
 pub struct DefaultConnectorFuture {
-    fut: ConnectorFuture,
+    fut: Either<ConnectorFuture, ConnectorTcpFuture>,
 }
 
 impl Future for DefaultConnectorFuture {

src/counter.rs

@@ -9,6 +9,7 @@ use futures::task::AtomicTask;
 /// Counter could be cloned, total ncount is shared across all clones.
 pub struct Counter(Rc<CounterInner>);
 
+#[derive(Debug)]
 struct CounterInner {
     count: Cell<usize>,
     capacity: usize,
@@ -40,6 +41,7 @@ impl Counter {
     }
 }
 
+#[derive(Debug)]
 pub struct CounterGuard(Rc<CounterInner>);
 
 impl CounterGuard {
@@ -57,11 +59,7 @@ impl Drop for CounterGuard {
 
 impl CounterInner {
     fn inc(&self) {
-        let num = self.count.get() + 1;
-        self.count.set(num);
-        if num == self.capacity {
-            self.task.register();
-        }
+        self.count.set(self.count.get() + 1);
     }
 
     fn dec(&self) {
@@ -73,6 +71,10 @@ impl CounterInner {
     }
 
     fn available(&self) -> bool {
-        self.count.get() < self.capacity
+        let avail = self.count.get() < self.capacity;
+        if !avail {
+            self.task.register();
+        }
+        avail
     }
 }

src/keepalive.rs

@@ -106,7 +106,7 @@ where
                 if self.expire <= now {
                     Err((self.f)())
                 } else {
-                    self.delay = Delay::new(self.expire);
+                    self.delay.reset(self.expire);
                     let _ = self.delay.poll();
                     Ok(Async::Ready(()))
                 }

src/lib.rs

@@ -9,10 +9,7 @@
 
 #![cfg_attr(
     feature = "cargo-clippy",
-    allow(
-        declare_interior_mutable_const,
-        borrow_interior_mutable_const
-    )
+    allow(declare_interior_mutable_const, borrow_interior_mutable_const)
 )]
 
 #[macro_use]

src/resolver.rs

@@ -1,6 +1,6 @@
 use std::collections::VecDeque;
 use std::marker::PhantomData;
-use std::net::SocketAddr;
+use std::net::IpAddr;
 
 use futures::{Async, Future, Poll};
 
@@ -13,11 +13,12 @@ use trust_dns_resolver::{AsyncResolver, Background};
 
 use super::service::Service;
 
-pub trait HostAware {
+/// Host name of the request
+pub trait RequestHost {
     fn host(&self) -> &str;
 }
 
-impl HostAware for String {
+impl RequestHost for String {
     fn host(&self) -> &str {
         self.as_ref()
     }
@@ -28,7 +29,7 @@ pub struct Resolver<T = String> {
     req: PhantomData<T>,
 }
 
-impl<T: HostAware> Default for Resolver<T> {
+impl<T: RequestHost> Default for Resolver<T> {
     fn default() -> Self {
         let (cfg, opts) = if let Ok((cfg, opts)) = read_system_conf() {
             (cfg, opts)
@@ -40,7 +41,8 @@ impl<T: HostAware> Default for Resolver<T> {
     }
 }
 
-impl<T: HostAware> Resolver<T> {
+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);
         spawn(bg);
@@ -50,7 +52,8 @@ impl<T: HostAware> Resolver<T> {
         }
     }
 
-    pub fn change_request<T2: HostAware>(&self) -> Resolver<T2> {
+    /// Change type of resolver request.
+    pub fn into_request<T2: RequestHost>(&self) -> Resolver<T2> {
         Resolver {
             resolver: self.resolver.clone(),
             req: PhantomData,
@@ -67,9 +70,9 @@ impl<T> Clone for Resolver<T> {
     }
 }
 
-impl<T: HostAware> Service for Resolver<T> {
+impl<T: RequestHost> Service for Resolver<T> {
     type Request = T;
-    type Response = (T, VecDeque<SocketAddr>);
+    type Response = (T, VecDeque<IpAddr>);
     type Error = ResolveError;
     type Future = ResolverFuture<T>;
 
@@ -87,10 +90,10 @@ impl<T: HostAware> Service for Resolver<T> {
 pub struct ResolverFuture<T> {
     req: Option<T>,
     lookup: Option<Background<LookupIpFuture>>,
-    addrs: Option<VecDeque<SocketAddr>>,
+    addrs: Option<VecDeque<IpAddr>>,
 }
 
-impl<T: HostAware> ResolverFuture<T> {
+impl<T: RequestHost> ResolverFuture<T> {
     pub fn new(addr: T, resolver: &AsyncResolver) -> Self {
         // we need to do dns resolution
         let lookup = Some(resolver.lookup_ip(addr.host()));
@@ -102,8 +105,8 @@ impl<T: HostAware> ResolverFuture<T> {
     }
 }
 
-impl<T: HostAware> Future for ResolverFuture<T> {
-    type Item = (T, VecDeque<SocketAddr>);
+impl<T: RequestHost> Future for ResolverFuture<T> {
+    type Item = (T, VecDeque<IpAddr>);
     type Error = ResolveError;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
@@ -112,11 +115,10 @@ impl<T: HostAware> Future for ResolverFuture<T> {
         } else {
             match self.lookup.as_mut().unwrap().poll() {
                 Ok(Async::NotReady) => Ok(Async::NotReady),
-                Ok(Async::Ready(ips)) => {
-                    let addrs: VecDeque<_> =
-                        ips.iter().map(|ip| SocketAddr::new(ip, 0)).collect();
-                    Ok(Async::Ready((self.req.take().unwrap(), addrs)))
-                }
+                Ok(Async::Ready(ips)) => Ok(Async::Ready((
+                    self.req.take().unwrap(),
+                    ips.iter().collect(),
+                ))),
                 Err(err) => Err(err),
             }
         }

src/server/mod.rs

@@ -40,7 +40,9 @@ impl Message for StopServer {
 pub(crate) struct Token(usize);
 
 impl Token {
-    pub(crate) fn next(&self) -> Token {
-        Token(self.0 + 1)
+    pub(crate) fn next(&mut self) -> Token {
+        let token = Token(self.0 + 1);
+        self.0 += 1;
+        token
     }
 }

src/server/server.rs

@@ -144,8 +144,15 @@ impl Server {
     {
         let sockets = bind_addr(addr)?;
 
+        let token = self.token.next();
+        self.services.push(StreamNewService::create(
+            name.as_ref().to_string(),
+            token,
+            factory,
+        ));
+
         for lst in sockets {
-            self = self.listen(name.as_ref(), lst, factory.clone())
+            self.sockets.push((token, lst));
         }
         Ok(self)
     }
@@ -337,7 +344,6 @@ impl Handler<StopServer> for Server {
     type Result = Response<(), ()>;
 
     fn handle(&mut self, msg: StopServer, ctx: &mut Context<Self>) -> Self::Result {
-        println!("STOP command");
         // stop accept thread
         self.accept.send(Command::Stop);
 

src/server/services.rs

@@ -83,9 +83,9 @@ where
                 });
 
                 if let Ok(stream) = stream {
-                    spawn(self.service.call(stream).map_err(|_| ()).map(move |val| {
+                    spawn(self.service.call(stream).then(move |res| {
                         drop(guard);
-                        val
+                        res.map_err(|_| ())
                     }));
                     ok(())
                 } else {
@@ -123,9 +123,9 @@ where
     }
 
     fn call(&mut self, (guard, req): (Option<CounterGuard>, ServerMessage)) -> Self::Future {
-        spawn(self.service.call(req).map_err(|_| ()).map(move |val| {
+        spawn(self.service.call(req).then(move |res| {
             drop(guard);
-            val
+            res.map_err(|_| ())
         }));
         ok(())
     }

src/server/worker.rs

@@ -167,7 +167,8 @@ impl Worker {
                 .map_err(|e| {
                     error!("Can not start worker: {:?}", e);
                     Arbiter::current().do_send(StopArbiter(0));
-                }).and_then(move |services| {
+                })
+                .and_then(move |services| {
                     for item in services {
                         for (idx, token, service) in item {
                             while token.0 >= wrk.services.len() {

src/service/and_then.rs

@@ -63,7 +63,7 @@ where
 {
     b: Cell<B>,
     fut_b: Option<B::Future>,
-    fut_a: A::Future,
+    fut_a: Option<A::Future>,
 }
 
 impl<A, B> AndThenFuture<A, B>
@@ -71,10 +71,10 @@ where
     A: Service,
     B: Service<Request = A::Response, Error = A::Error>,
 {
-    fn new(fut_a: A::Future, b: Cell<B>) -> Self {
+    fn new(a: A::Future, b: Cell<B>) -> Self {
         AndThenFuture {
             b,
-            fut_a,
+            fut_a: Some(a),
             fut_b: None,
         }
     }
@@ -94,8 +94,9 @@ where
             return fut.poll();
         }
 
-        match self.fut_a.poll() {
+        match self.fut_a.as_mut().expect("actix-net bug").poll() {
             Ok(Async::Ready(resp)) => {
+                let _ = self.fut_a.take();
                 self.fut_b = Some(self.b.borrow_mut().call(resp));
                 self.poll()
             }

src/service/then.rs

@@ -63,7 +63,7 @@ where
 {
     b: Cell<B>,
     fut_b: Option<B::Future>,
-    fut_a: A::Future,
+    fut_a: Option<A::Future>,
 }
 
 impl<A, B> ThenFuture<A, B>
@@ -71,10 +71,10 @@ where
     A: Service,
     B: Service<Request = Result<A::Response, A::Error>>,
 {
-    fn new(fut_a: A::Future, b: Cell<B>) -> Self {
+    fn new(a: A::Future, b: Cell<B>) -> Self {
         ThenFuture {
             b,
-            fut_a,
+            fut_a: Some(a),
             fut_b: None,
         }
     }
@@ -93,12 +93,14 @@ where
             return fut.poll();
         }
 
-        match self.fut_a.poll() {
+        match self.fut_a.as_mut().expect("actix-net bug").poll() {
             Ok(Async::Ready(resp)) => {
+                let _ = self.fut_a.take();
                 self.fut_b = Some(self.b.borrow_mut().call(Ok(resp)));
                 self.poll()
             }
             Err(err) => {
+                let _ = self.fut_a.take();
                 self.fut_b = Some(self.b.borrow_mut().call(Err(err)));
                 self.poll()
             }

src/ssl/openssl.rs

@@ -6,8 +6,8 @@ use tokio_io::{AsyncRead, AsyncWrite};
 use tokio_openssl::{AcceptAsync, ConnectAsync, SslAcceptorExt, SslConnectorExt, SslStream};
 
 use super::MAX_CONN_COUNTER;
-use connector::Connect;
 use counter::{Counter, CounterGuard};
+use resolver::RequestHost;
 use service::{NewService, Service};
 
 /// Support `SSL` connections via openssl package
@@ -102,12 +102,12 @@ impl<T: AsyncRead + AsyncWrite> Future for OpensslAcceptorServiceFut<T> {
 }
 
 /// Openssl connector factory
-pub struct OpensslConnector<T, E> {
+pub struct OpensslConnector<R, T, E> {
     connector: SslConnector,
-    _t: PhantomData<(T, E)>,
+    _t: PhantomData<(R, T, E)>,
 }
 
-impl<T, E> OpensslConnector<T, E> {
+impl<R, T, E> OpensslConnector<R, T, E> {
     pub fn new(connector: SslConnector) -> Self {
         OpensslConnector {
             connector,
@@ -116,11 +116,10 @@ impl<T, E> OpensslConnector<T, E> {
     }
 }
 
-impl<T: AsyncRead + AsyncWrite> OpensslConnector<T, ()> {
+impl<R: RequestHost, T: AsyncRead + AsyncWrite> OpensslConnector<R, T, ()> {
     pub fn service(
         connector: SslConnector,
-    ) -> impl Service<Request = (Connect, T), Response = (Connect, SslStream<T>), Error = Error>
-    {
+    ) -> impl Service<Request = (R, T), Response = (R, SslStream<T>), Error = Error> {
         OpensslConnectorService {
             connector: connector,
             _t: PhantomData,
@@ -128,7 +127,7 @@ impl<T: AsyncRead + AsyncWrite> OpensslConnector<T, ()> {
     }
 }
 
-impl<T, E> Clone for OpensslConnector<T, E> {
+impl<R, T, E> Clone for OpensslConnector<R, T, E> {
     fn clone(&self) -> Self {
         Self {
             connector: self.connector.clone(),
@@ -137,11 +136,11 @@ impl<T, E> Clone for OpensslConnector<T, E> {
     }
 }
 
-impl<T: AsyncRead + AsyncWrite, E> NewService for OpensslConnector<T, E> {
-    type Request = (Connect, T);
-    type Response = (Connect, SslStream<T>);
+impl<R: RequestHost, T: AsyncRead + AsyncWrite, E> NewService for OpensslConnector<R, T, E> {
+    type Request = (R, T);
+    type Response = (R, SslStream<T>);
     type Error = Error;
-    type Service = OpensslConnectorService<T>;
+    type Service = OpensslConnectorService<R, T>;
     type InitError = E;
     type Future = FutureResult<Self::Service, Self::InitError>;
 
@@ -153,16 +152,16 @@ impl<T: AsyncRead + AsyncWrite, E> NewService for OpensslConnector<T, E> {
     }
 }
 
-pub struct OpensslConnectorService<T> {
+pub struct OpensslConnectorService<R, T> {
     connector: SslConnector,
-    _t: PhantomData<T>,
+    _t: PhantomData<(R, T)>,
 }
 
-impl<T: AsyncRead + AsyncWrite> Service for OpensslConnectorService<T> {
-    type Request = (Connect, T);
-    type Response = (Connect, SslStream<T>);
+impl<R: RequestHost, T: AsyncRead + AsyncWrite> Service for OpensslConnectorService<R, T> {
+    type Request = (R, T);
+    type Response = (R, SslStream<T>);
     type Error = Error;
-    type Future = ConnectAsyncExt<T>;
+    type Future = ConnectAsyncExt<R, T>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         Ok(Async::Ready(()))
@@ -170,22 +169,23 @@ impl<T: AsyncRead + AsyncWrite> Service for OpensslConnectorService<T> {
 
     fn call(&mut self, (req, stream): Self::Request) -> Self::Future {
         ConnectAsyncExt {
-            fut: SslConnectorExt::connect_async(&self.connector, &req.host, stream),
+            fut: SslConnectorExt::connect_async(&self.connector, req.host(), stream),
             req: Some(req),
         }
     }
 }
 
-pub struct ConnectAsyncExt<T> {
+pub struct ConnectAsyncExt<R, T> {
+    req: Option<R>,
     fut: ConnectAsync<T>,
-    req: Option<Connect>,
 }
 
-impl<T> Future for ConnectAsyncExt<T>
+impl<R, T> Future for ConnectAsyncExt<R, T>
 where
+    R: RequestHost,
     T: AsyncRead + AsyncWrite,
 {
-    type Item = (Connect, SslStream<T>);
+    type Item = (R, SslStream<T>);
     type Error = Error;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {