update version

CHANGES.md

@@ -1,5 +1,21 @@
 # Changes
 
+## [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

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-net"
-version = "0.2.0"
+version = "0.2.2"
 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"

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,11 @@ impl<T, U> Framed<T, U> {
         &mut self.inner.get_mut().get_mut().0
     }
 
+    /// 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 +152,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 +186,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 +320,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 +339,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,21 @@ 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()
+    }
+}
+
+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 +138,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 +178,36 @@ 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
+    }
+}
+
+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 +218,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)
     }

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,5 +1,6 @@
 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};
 
@@ -11,9 +12,14 @@ 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 +28,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,6 +49,12 @@ 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 {
@@ -85,12 +97,18 @@ impl Connect {
     }
 }
 
-impl HostAware for Connect {
+impl RequestHost for Connect {
     fn host(&self) -> &str {
         &self.host
     }
 }
 
+impl RequestPort for Connect {
+    fn port(&self) -> u16 {
+        self.port
+    }
+}
+
 impl fmt::Display for Connect {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}:{}", self.host, self.port)
@@ -173,7 +191,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 +200,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()
                 }
             }
@@ -204,19 +216,45 @@ impl Future for ConnectorFuture {
     }
 }
 
+/// 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
-pub struct TcpConnector {
-    req: Option<Connect>,
+/// 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 +262,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 +277,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)
         }

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/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> {