undeprecate framed transport

Future's can be pretty big (> 1500 bytes) so this probably worth doing.

I confirmed with memcpy-find that this did infact eliminate two ~1500
byte copies from the actix-web basic example.

.travis.yml

@@ -10,9 +10,9 @@ matrix:
   include:
     - rust: stable
     - rust: beta
-    - rust: nightly-2019-03-02
+    - rust: nightly-2019-06-15
   allow_failures:
-    - rust: nightly-2019-03-02
+    - rust: nightly-2019-06-15
 
 env:
   global:
@@ -25,8 +25,8 @@ before_install:
   - 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
+  if [[ "$TRAVIS_RUST_VERSION" == "nightly-2019-06-15" ]]; then
+    RUSTFLAGS="--cfg procmacro2_semver_exempt" cargo install --version 0.6.11 cargo-tarpaulin
   fi
 
 # Add clippy
@@ -35,14 +35,14 @@ before_script:
 
 script:
   - |
-    if [[ "$TRAVIS_RUST_VERSION" != "nightly-2019-03-02" ]]; then
+    if [[ "$TRAVIS_RUST_VERSION" != "nightly-2019-06-15" ]]; then
     cargo clean
     cargo test --all --all-features -- --nocapture
     fi
 
 after_success:
   - |
-    if [[ "$TRAVIS_RUST_VERSION" == "nightly-2019-03-02" ]]; then
+    if [[ "$TRAVIS_RUST_VERSION" == "nightly-2019-06-15" ]]; then
     taskset -c 0 cargo tarpaulin --all --all-features --out Xml
     echo "Uploaded code coverage"
     bash <(curl -s https://codecov.io/bash)

Cargo.toml

@@ -24,6 +24,7 @@ members = [
   "actix-test-server",
   "actix-threadpool",
   "actix-tower",
+  "actix-ioframe",
   "actix-utils",
   "router",
 ]

actix-connect/CHANGES.md

@@ -1,9 +1,16 @@
 # Changes
 
+## [0.2.1] - 2019-07-17
+
+### Added
+
+* Expose Connect addrs #30
+
 ### Changed
 
 * Update `derive_more` to 0.15
 
+
 ## [0.2.0] - 2019-05-12
 
 ### Changed

actix-connect/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-connect"
-version = "0.2.0"
+version = "0.2.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix Connector - tcp connector service"
 keywords = ["network", "framework", "async", "futures"]

actix-connect/src/connect.rs

@@ -1,5 +1,6 @@
-use std::collections::VecDeque;
+use std::collections::{vec_deque, VecDeque};
 use std::fmt;
+use std::iter::{FromIterator, FusedIterator};
 use std::net::SocketAddr;
 
 use either::Either;
@@ -77,6 +78,20 @@ impl<T: Address> Connect<T> {
         self
     }
 
+    /// Use addresses.
+    pub fn set_addrs<I>(mut self, addrs: I) -> Self
+    where
+        I: IntoIterator<Item = SocketAddr>,
+    {
+        let mut addrs = VecDeque::from_iter(addrs);
+        self.addr = if addrs.len() < 2 {
+            addrs.pop_front().map(Either::Left)
+        } else {
+            Some(Either::Right(addrs))
+        };
+        self
+    }
+
     /// Host name
     pub fn host(&self) -> &str {
         self.req.host()
@@ -86,6 +101,28 @@ impl<T: Address> Connect<T> {
     pub fn port(&self) -> u16 {
         self.req.port().unwrap_or(self.port)
     }
+
+    /// Preresolved addresses of the request.
+    pub fn addrs(&self) -> ConnectAddrsIter<'_> {
+        let inner = match self.addr {
+            None => Either::Left(None),
+            Some(Either::Left(addr)) => Either::Left(Some(addr)),
+            Some(Either::Right(ref addrs)) => Either::Right(addrs.iter()),
+        };
+
+        ConnectAddrsIter { inner }
+    }
+
+    /// Takes preresolved addresses of the request.
+    pub fn take_addrs(&mut self) -> ConnectTakeAddrsIter {
+        let inner = match self.addr.take() {
+            None => Either::Left(None),
+            Some(Either::Left(addr)) => Either::Left(Some(addr)),
+            Some(Either::Right(addrs)) => Either::Right(addrs.into_iter()),
+        };
+
+        ConnectTakeAddrsIter { inner }
+    }
 }
 
 impl<T: Address> From<T> for Connect<T> {
@@ -100,6 +137,70 @@ impl<T: Address> fmt::Display for Connect<T> {
     }
 }
 
+/// Iterator over addresses in a [`Connect`](struct.Connect.html) request.
+#[derive(Clone)]
+pub struct ConnectAddrsIter<'a> {
+    inner: Either<Option<SocketAddr>, vec_deque::Iter<'a, SocketAddr>>,
+}
+
+impl Iterator for ConnectAddrsIter<'_> {
+    type Item = SocketAddr;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self.inner {
+            Either::Left(ref mut opt) => opt.take(),
+            Either::Right(ref mut iter) => iter.next().copied(),
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        match self.inner {
+            Either::Left(Some(_)) => (1, Some(1)),
+            Either::Left(None) => (0, Some(0)),
+            Either::Right(ref iter) => iter.size_hint(),
+        }
+    }
+}
+
+impl fmt::Debug for ConnectAddrsIter<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_list().entries(self.clone()).finish()
+    }
+}
+
+impl ExactSizeIterator for ConnectAddrsIter<'_> {}
+
+impl FusedIterator for ConnectAddrsIter<'_> {}
+
+/// Owned iterator over addresses in a [`Connect`](struct.Connect.html) request.
+#[derive(Debug)]
+pub struct ConnectTakeAddrsIter {
+    inner: Either<Option<SocketAddr>, vec_deque::IntoIter<SocketAddr>>,
+}
+
+impl Iterator for ConnectTakeAddrsIter {
+    type Item = SocketAddr;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self.inner {
+            Either::Left(ref mut opt) => opt.take(),
+            Either::Right(ref mut iter) => iter.next(),
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        match self.inner {
+            Either::Left(Some(_)) => (1, Some(1)),
+            Either::Left(None) => (0, Some(0)),
+            Either::Right(ref iter) => iter.size_hint(),
+        }
+    }
+}
+
+impl ExactSizeIterator for ConnectTakeAddrsIter {}
+
+impl FusedIterator for ConnectTakeAddrsIter {}
+
 fn parse(host: &str) -> (&str, Option<u16>) {
     let mut parts_iter = host.splitn(2, ':');
     if let Some(host) = parts_iter.next() {

actix-connect/src/resolver.rs

@@ -1,4 +1,3 @@
-use std::collections::VecDeque;
 use std::marker::PhantomData;
 use std::net::SocketAddr;
 
@@ -162,23 +161,20 @@ impl<T: Address> Future for ResolverFuture<T> {
         })? {
             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();
+                let req = self.req.take().unwrap();
+
+                let port = req.port();
+                let req = req.set_addrs(ips.iter().map(|ip| SocketAddr::new(ip, port)));
+
                 trace!(
                     "DNS resolver: host {:?} resolved to {:?}",
                     req.host(),
-                    addrs
+                    req.addrs()
                 );
-                if addrs.is_empty() {
+
+                if req.addr.is_none() {
                     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-ioframe/CHANGES.md

@@ -0,0 +1,5 @@
+# Changes
+
+## [0.1.0] - 2019-07-17
+
+* Initial release

actix-ioframe/Cargo.toml

@@ -0,0 +1,35 @@
+[package]
+name = "actix-ioframe"
+version = "0.1.0"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Actix framed service"
+keywords = ["network", "framework", "async", "futures"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-net.git"
+documentation = "https://docs.rs/actix-ioframed/"
+categories = ["network-programming", "asynchronous"]
+license = "MIT/Apache-2.0"
+exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
+edition = "2018"
+workspace = ".."
+
+[lib]
+name = "actix_ioframe"
+path = "src/lib.rs"
+
+[dependencies]
+actix-service = "0.4.1"
+actix-codec = "0.1.2"
+bytes = "0.4"
+either = "1.5.2"
+futures = "0.1.25"
+tokio-current-thread = "0.1.4"
+log = "0.4"
+
+[dev-dependencies]
+actix-rt = "0.2.2"
+actix-connect = "0.2.0"
+actix-test-server = "0.2.2"
+actix-server-config = "0.1.1"
+tokio-tcp = "0.1"
+tokio-timer = "0.2"

actix-ioframe/LICENSE-APACHE

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

actix-ioframe/LICENSE-MIT

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

actix-ioframe/src/cell.rs

@@ -0,0 +1,35 @@
+//! Custom cell impl
+
+use std::cell::UnsafeCell;
+use std::fmt;
+use std::rc::Rc;
+
+pub(crate) struct Cell<T> {
+    inner: Rc<UnsafeCell<T>>,
+}
+
+impl<T> Clone for Cell<T> {
+    fn clone(&self) -> Self {
+        Self {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+impl<T: fmt::Debug> fmt::Debug for Cell<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.inner.fmt(f)
+    }
+}
+
+impl<T> Cell<T> {
+    pub fn new(inner: T) -> Self {
+        Self {
+            inner: Rc::new(UnsafeCell::new(inner)),
+        }
+    }
+
+    pub(crate) unsafe fn get_mut(&mut self) -> &mut T {
+        &mut *self.inner.as_ref().get()
+    }
+}

actix-ioframe/src/connect.rs

@@ -0,0 +1,110 @@
+use std::marker::PhantomData;
+
+use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
+use futures::unsync::mpsc;
+
+use crate::dispatcher::FramedMessage;
+use crate::sink::Sink;
+
+pub struct Connect<Io, St = (), Codec = ()> {
+    io: Io,
+    _t: PhantomData<(St, Codec)>,
+}
+
+impl<Io> Connect<Io>
+where
+    Io: AsyncRead + AsyncWrite,
+{
+    pub(crate) fn new(io: Io) -> Self {
+        Self {
+            io,
+            _t: PhantomData,
+        }
+    }
+
+    pub fn codec<Codec>(self, codec: Codec) -> ConnectResult<Io, (), Codec>
+    where
+        Codec: Encoder + Decoder,
+    {
+        let (tx, rx) = mpsc::unbounded();
+        let sink = Sink::new(tx);
+
+        ConnectResult {
+            state: (),
+            framed: Framed::new(self.io, codec),
+            rx,
+            sink,
+        }
+    }
+}
+
+pub struct ConnectResult<Io, St, Codec: Encoder + Decoder> {
+    pub(crate) state: St,
+    pub(crate) framed: Framed<Io, Codec>,
+    pub(crate) rx: mpsc::UnboundedReceiver<FramedMessage<<Codec as Encoder>::Item>>,
+    pub(crate) sink: Sink<<Codec as Encoder>::Item>,
+}
+
+impl<Io, St, Codec: Encoder + Decoder> ConnectResult<Io, St, Codec> {
+    #[inline]
+    pub fn sink(&self) -> &Sink<<Codec as Encoder>::Item> {
+        &self.sink
+    }
+
+    #[inline]
+    pub fn get_ref(&self) -> &Io {
+        self.framed.get_ref()
+    }
+
+    #[inline]
+    pub fn get_mut(&mut self) -> &mut Io {
+        self.framed.get_mut()
+    }
+
+    #[inline]
+    pub fn state<S>(self, state: S) -> ConnectResult<Io, S, Codec> {
+        ConnectResult {
+            state,
+            framed: self.framed,
+            rx: self.rx,
+            sink: self.sink,
+        }
+    }
+}
+
+impl<Io, St, Codec> futures::Stream for ConnectResult<Io, St, Codec>
+where
+    Io: AsyncRead + AsyncWrite,
+    Codec: Encoder + Decoder,
+{
+    type Item = <Codec as Decoder>::Item;
+    type Error = <Codec as Decoder>::Error;
+
+    fn poll(&mut self) -> futures::Poll<Option<Self::Item>, Self::Error> {
+        self.framed.poll()
+    }
+}
+
+impl<Io, St, Codec> futures::Sink for ConnectResult<Io, St, Codec>
+where
+    Io: AsyncRead + AsyncWrite,
+    Codec: Encoder + Decoder,
+{
+    type SinkItem = <Codec as Encoder>::Item;
+    type SinkError = <Codec as Encoder>::Error;
+
+    fn start_send(
+        &mut self,
+        item: Self::SinkItem,
+    ) -> futures::StartSend<Self::SinkItem, Self::SinkError> {
+        self.framed.start_send(item)
+    }
+
+    fn poll_complete(&mut self) -> futures::Poll<(), Self::SinkError> {
+        self.framed.poll_complete()
+    }
+
+    fn close(&mut self) -> futures::Poll<(), Self::SinkError> {
+        self.framed.close()
+    }
+}

actix-ioframe/src/dispatcher.rs

@@ -0,0 +1,325 @@
+//! Framed dispatcher service and related utilities
+use std::collections::VecDeque;
+use std::mem;
+use std::rc::Rc;
+
+use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
+use actix_service::{IntoService, Service};
+use futures::task::AtomicTask;
+use futures::unsync::{mpsc, oneshot};
+use futures::{Async, Future, Poll, Sink as FutureSink, Stream};
+use log::debug;
+
+use crate::cell::Cell;
+use crate::error::ServiceError;
+use crate::item::Item;
+use crate::sink::Sink;
+use crate::state::State;
+
+type Request<S, U> = Item<S, U>;
+type Response<U> = <U as Encoder>::Item;
+
+pub(crate) enum FramedMessage<T> {
+    Message(T),
+    Close,
+    WaitClose(oneshot::Sender<()>),
+}
+
+/// FramedTransport - is a future that reads frames from Framed object
+/// and pass then to the service.
+pub(crate) struct FramedDispatcher<St, S, T, U>
+where
+    S: Service<Request = Request<St, U>, Response = Option<Response<U>>>,
+    S::Error: 'static,
+    S::Future: 'static,
+    T: AsyncRead + AsyncWrite,
+    U: Encoder + Decoder,
+    <U as Encoder>::Item: 'static,
+    <U as Encoder>::Error: std::fmt::Debug,
+{
+    service: S,
+    sink: Sink<<U as Encoder>::Item>,
+    state: State<St>,
+    dispatch_state: FramedState<S, U>,
+    framed: Framed<T, U>,
+    rx: Option<mpsc::UnboundedReceiver<FramedMessage<<U as Encoder>::Item>>>,
+    inner: Cell<FramedDispatcherInner<<U as Encoder>::Item, S::Error>>,
+    disconnect: Option<Rc<Fn(&mut St, bool)>>,
+}
+
+impl<St, S, T, U> FramedDispatcher<St, S, T, U>
+where
+    S: Service<Request = Request<St, U>, Response = Option<Response<U>>>,
+    S::Error: 'static,
+    S::Future: 'static,
+    T: AsyncRead + AsyncWrite,
+    U: Decoder + Encoder,
+    <U as Encoder>::Item: 'static,
+    <U as Encoder>::Error: std::fmt::Debug,
+{
+    pub(crate) fn new<F: IntoService<S>>(
+        framed: Framed<T, U>,
+        state: State<St>,
+        service: F,
+        rx: mpsc::UnboundedReceiver<FramedMessage<<U as Encoder>::Item>>,
+        sink: Sink<<U as Encoder>::Item>,
+        disconnect: Option<Rc<Fn(&mut St, bool)>>,
+    ) -> Self {
+        FramedDispatcher {
+            framed,
+            state,
+            sink,
+            disconnect,
+            rx: Some(rx),
+            service: service.into_service(),
+            dispatch_state: FramedState::Processing,
+            inner: Cell::new(FramedDispatcherInner {
+                buf: VecDeque::new(),
+                task: AtomicTask::new(),
+            }),
+        }
+    }
+}
+
+enum FramedState<S: Service, U: Encoder + Decoder> {
+    Processing,
+    Error(ServiceError<S::Error, U>),
+    FramedError(ServiceError<S::Error, U>),
+    FlushAndStop(Vec<oneshot::Sender<()>>),
+    Stopping,
+}
+
+impl<S: Service, U: Encoder + Decoder> FramedState<S, U> {
+    fn stop(&mut self, tx: Option<oneshot::Sender<()>>) {
+        match self {
+            FramedState::FlushAndStop(ref mut vec) => {
+                if let Some(tx) = tx {
+                    vec.push(tx)
+                }
+            }
+            FramedState::Processing => {
+                *self = FramedState::FlushAndStop(if let Some(tx) = tx {
+                    vec![tx]
+                } else {
+                    Vec::new()
+                })
+            }
+            FramedState::Error(_) | FramedState::FramedError(_) | FramedState::Stopping => {
+                if let Some(tx) = tx {
+                    let _ = tx.send(());
+                }
+            }
+        }
+    }
+}
+
+struct FramedDispatcherInner<I, E> {
+    buf: VecDeque<Result<I, E>>,
+    task: AtomicTask,
+}
+
+impl<St, S, T, U> FramedDispatcher<St, S, T, U>
+where
+    S: Service<Request = Request<St, U>, Response = Option<Response<U>>>,
+    S::Error: 'static,
+    S::Future: 'static,
+    T: AsyncRead + AsyncWrite,
+    U: Decoder + Encoder,
+    <U as Encoder>::Item: 'static,
+    <U as Encoder>::Error: std::fmt::Debug,
+{
+    fn disconnect(&mut self, error: bool) {
+        if let Some(ref disconnect) = self.disconnect {
+            (&*disconnect)(&mut *self.state.get_mut(), error);
+        }
+    }
+
+    fn poll_read(&mut self) -> bool {
+        loop {
+            match self.service.poll_ready() {
+                Ok(Async::Ready(_)) => {
+                    let item = match self.framed.poll() {
+                        Ok(Async::Ready(Some(el))) => el,
+                        Err(err) => {
+                            self.dispatch_state =
+                                FramedState::FramedError(ServiceError::Decoder(err));
+                            return true;
+                        }
+                        Ok(Async::NotReady) => return false,
+                        Ok(Async::Ready(None)) => {
+                            self.dispatch_state = FramedState::Stopping;
+                            return true;
+                        }
+                    };
+
+                    let mut cell = self.inner.clone();
+                    unsafe { cell.get_mut().task.register() };
+                    tokio_current_thread::spawn(
+                        self.service
+                            .call(Item::new(self.state.clone(), self.sink.clone(), item))
+                            .then(move |item| {
+                                let item = match item {
+                                    Ok(Some(item)) => Ok(item),
+                                    Ok(None) => return Ok(()),
+                                    Err(err) => Err(err),
+                                };
+                                unsafe {
+                                    let inner = cell.get_mut();
+                                    inner.buf.push_back(item);
+                                    inner.task.notify();
+                                }
+                                Ok(())
+                            }),
+                    );
+                }
+                Ok(Async::NotReady) => return false,
+                Err(err) => {
+                    self.dispatch_state = FramedState::Error(ServiceError::Service(err));
+                    return true;
+                }
+            }
+        }
+    }
+
+    /// write to framed object
+    fn poll_write(&mut self) -> bool {
+        let inner = unsafe { 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 !buf_empty {
+                    match inner.buf.pop_front().unwrap() {
+                        Ok(msg) => {
+                            if let Err(err) = self.framed.force_send(msg) {
+                                self.dispatch_state =
+                                    FramedState::FramedError(ServiceError::Encoder(err));
+                                return true;
+                            }
+                            buf_empty = inner.buf.is_empty();
+                        }
+                        Err(err) => {
+                            self.dispatch_state =
+                                FramedState::Error(ServiceError::Service(err));
+                            return true;
+                        }
+                    }
+                }
+
+                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.dispatch_state =
+                                    FramedState::FramedError(ServiceError::Encoder(err));
+                                return true;
+                            }
+                        }
+                        Ok(Async::Ready(Some(FramedMessage::Close))) => {
+                            self.dispatch_state.stop(None);
+                            return true;
+                        }
+                        Ok(Async::Ready(Some(FramedMessage::WaitClose(tx)))) => {
+                            self.dispatch_state.stop(Some(tx));
+                            return true;
+                        }
+                        Ok(Async::Ready(None)) => {
+                            rx_done = true;
+                            let _ = self.rx.take();
+                        }
+                        Ok(Async::NotReady) => rx_done = true,
+                        Err(_e) => {
+                            rx_done = true;
+                            let _ = self.rx.take();
+                        }
+                    }
+                }
+
+                if rx_done && buf_empty {
+                    break;
+                }
+            }
+
+            if !self.framed.is_write_buf_empty() {
+                match self.framed.poll_complete() {
+                    Ok(Async::NotReady) => break,
+                    Err(err) => {
+                        debug!("Error sending data: {:?}", err);
+                        self.dispatch_state =
+                            FramedState::FramedError(ServiceError::Encoder(err));
+                        return true;
+                    }
+                    Ok(Async::Ready(_)) => (),
+                }
+            } else {
+                break;
+            }
+        }
+
+        false
+    }
+}
+
+impl<St, S, T, U> Future for FramedDispatcher<St, S, T, U>
+where
+    S: Service<Request = Request<St, U>, Response = Option<Response<U>>>,
+    S::Error: 'static,
+    S::Future: 'static,
+    T: AsyncRead + AsyncWrite,
+    U: Decoder + Encoder,
+    <U as Encoder>::Item: 'static,
+    <U as Encoder>::Error: std::fmt::Debug,
+{
+    type Item = ();
+    type Error = ServiceError<S::Error, U>;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        match mem::replace(&mut self.dispatch_state, FramedState::Processing) {
+            FramedState::Processing => {
+                if self.poll_read() || self.poll_write() {
+                    self.poll()
+                } else {
+                    Ok(Async::NotReady)
+                }
+            }
+            FramedState::Error(err) => {
+                if self.framed.is_write_buf_empty()
+                    || (self.poll_write() || self.framed.is_write_buf_empty())
+                {
+                    self.disconnect(true);
+                    Err(err)
+                } else {
+                    self.dispatch_state = FramedState::Error(err);
+                    Ok(Async::NotReady)
+                }
+            }
+            FramedState::FlushAndStop(mut vec) => {
+                if !self.framed.is_write_buf_empty() {
+                    match self.framed.poll_complete() {
+                        Err(err) => {
+                            debug!("Error sending data: {:?}", err);
+                        }
+                        Ok(Async::NotReady) => {
+                            self.dispatch_state = FramedState::FlushAndStop(vec);
+                            return Ok(Async::NotReady);
+                        }
+                        Ok(Async::Ready(_)) => (),
+                    }
+                };
+                for tx in vec.drain(..) {
+                    let _ = tx.send(());
+                }
+                self.disconnect(false);
+                Ok(Async::Ready(()))
+            }
+            FramedState::FramedError(err) => {
+                self.disconnect(true);
+                Err(err)
+            }
+            FramedState::Stopping => {
+                self.disconnect(false);
+                Ok(Async::Ready(()))
+            }
+        }
+    }
+}

actix-ioframe/src/error.rs

@@ -0,0 +1,49 @@
+use std::fmt;
+
+use actix_codec::{Decoder, Encoder};
+
+/// Framed service errors
+pub enum ServiceError<E, U: Encoder + Decoder> {
+    /// Inner service error
+    Service(E),
+    /// Encoder parse error
+    Encoder(<U as Encoder>::Error),
+    /// Decoder parse error
+    Decoder(<U as Decoder>::Error),
+}
+
+impl<E, U: Encoder + Decoder> From<E> for ServiceError<E, U> {
+    fn from(err: E) -> Self {
+        ServiceError::Service(err)
+    }
+}
+
+impl<E, U: Encoder + Decoder> fmt::Debug for ServiceError<E, U>
+where
+    E: fmt::Debug,
+    <U as Encoder>::Error: fmt::Debug,
+    <U as Decoder>::Error: fmt::Debug,
+{
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            ServiceError::Service(ref e) => write!(fmt, "ServiceError::Service({:?})", e),
+            ServiceError::Encoder(ref e) => write!(fmt, "ServiceError::Encoder({:?})", e),
+            ServiceError::Decoder(ref e) => write!(fmt, "ServiceError::Encoder({:?})", e),
+        }
+    }
+}
+
+impl<E, U: Encoder + Decoder> fmt::Display for ServiceError<E, U>
+where
+    E: fmt::Display,
+    <U as Encoder>::Error: fmt::Debug,
+    <U as Decoder>::Error: fmt::Debug,
+{
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            ServiceError::Service(ref e) => write!(fmt, "{}", e),
+            ServiceError::Encoder(ref e) => write!(fmt, "{:?}", e),
+            ServiceError::Decoder(ref e) => write!(fmt, "{:?}", e),
+        }
+    }
+}

actix-ioframe/src/item.rs

@@ -0,0 +1,90 @@
+use std::cell::{Ref, RefMut};
+use std::fmt;
+use std::ops::{Deref, DerefMut};
+
+use actix_codec::{Decoder, Encoder};
+
+use crate::sink::Sink;
+use crate::state::State;
+
+pub struct Item<St, Codec: Encoder + Decoder> {
+    state: State<St>,
+    sink: Sink<<Codec as Encoder>::Item>,
+    item: <Codec as Decoder>::Item,
+}
+
+impl<St, Codec> Item<St, Codec>
+where
+    Codec: Encoder + Decoder,
+{
+    pub(crate) fn new(
+        state: State<St>,
+        sink: Sink<<Codec as Encoder>::Item>,
+        item: <Codec as Decoder>::Item,
+    ) -> Self {
+        Item { state, sink, item }
+    }
+
+    #[inline]
+    pub fn state(&self) -> Ref<St> {
+        self.state.get_ref()
+    }
+
+    #[inline]
+    pub fn state_mut(&mut self) -> RefMut<St> {
+        self.state.get_mut()
+    }
+
+    #[inline]
+    pub fn sink(&self) -> &Sink<<Codec as Encoder>::Item> {
+        &self.sink
+    }
+
+    #[inline]
+    pub fn into_inner(self) -> <Codec as Decoder>::Item {
+        self.item
+    }
+
+    #[inline]
+    pub fn into_parts(
+        self,
+    ) -> (
+        State<St>,
+        Sink<<Codec as Encoder>::Item>,
+        <Codec as Decoder>::Item,
+    ) {
+        (self.state, self.sink, self.item)
+    }
+}
+
+impl<St, Codec> Deref for Item<St, Codec>
+where
+    Codec: Encoder + Decoder,
+{
+    type Target = <Codec as Decoder>::Item;
+
+    #[inline]
+    fn deref(&self) -> &<Codec as Decoder>::Item {
+        &self.item
+    }
+}
+
+impl<St, Codec> DerefMut for Item<St, Codec>
+where
+    Codec: Encoder + Decoder,
+{
+    #[inline]
+    fn deref_mut(&mut self) -> &mut <Codec as Decoder>::Item {
+        &mut self.item
+    }
+}
+
+impl<St, Codec> fmt::Debug for Item<St, Codec>
+where
+    Codec: Encoder + Decoder,
+    <Codec as Decoder>::Item: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_tuple("FramedItem").field(&self.item).finish()
+    }
+}

actix-ioframe/src/lib.rs

@@ -0,0 +1,15 @@
+mod cell;
+mod connect;
+mod dispatcher;
+mod error;
+mod item;
+mod service;
+mod sink;
+mod state;
+
+pub use self::connect::{Connect, ConnectResult};
+pub use self::error::ServiceError;
+pub use self::item::Item;
+pub use self::service::{Builder, NewServiceBuilder, ServiceBuilder};
+pub use self::sink::Sink;
+pub use self::state::State;

actix-ioframe/src/service.rs

@@ -0,0 +1,363 @@
+use std::marker::PhantomData;
+use std::rc::Rc;
+
+use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder};
+use actix_service::{IntoNewService, IntoService, NewService, Service};
+use futures::{Async, Future, Poll};
+
+use crate::connect::{Connect, ConnectResult};
+use crate::dispatcher::FramedDispatcher;
+use crate::error::ServiceError;
+use crate::item::Item;
+use crate::state::State;
+
+type RequestItem<S, U> = Item<S, U>;
+type ResponseItem<U> = Option<<U as Encoder>::Item>;
+
+/// Service builder - structure that follows the builder pattern
+/// for building instances for framed services.
+pub struct Builder<St, Codec>(PhantomData<(St, Codec)>);
+
+impl<St, Codec> Builder<St, Codec> {
+    pub fn new() -> Builder<St, Codec> {
+        Builder(PhantomData)
+    }
+
+    /// Construct framed handler service with specified connect service
+    pub fn service<Io, C, F>(self, connect: F) -> ServiceBuilder<St, C, Io, Codec>
+    where
+        F: IntoService<C>,
+        Io: AsyncRead + AsyncWrite,
+        C: Service<Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
+        Codec: Decoder + Encoder,
+    {
+        ServiceBuilder {
+            connect: connect.into_service(),
+            disconnect: None,
+            _t: PhantomData,
+        }
+    }
+
+    /// Construct framed handler new service with specified connect service
+    pub fn factory<Io, C, F>(self, connect: F) -> NewServiceBuilder<St, C, Io, Codec>
+    where
+        F: IntoNewService<C>,
+        Io: AsyncRead + AsyncWrite,
+        C: NewService<
+            Config = (),
+            Request = Connect<Io>,
+            Response = ConnectResult<Io, St, Codec>,
+        >,
+        C::Error: 'static,
+        C::Future: 'static,
+        Codec: Decoder + Encoder,
+    {
+        NewServiceBuilder {
+            connect: connect.into_new_service(),
+            disconnect: None,
+            _t: PhantomData,
+        }
+    }
+}
+
+pub struct ServiceBuilder<St, C, Io, Codec> {
+    connect: C,
+    disconnect: Option<Rc<Fn(&mut St, bool)>>,
+    _t: PhantomData<(St, Io, Codec)>,
+}
+
+impl<St, C, Io, Codec> ServiceBuilder<St, C, Io, Codec>
+where
+    St: 'static,
+    Io: AsyncRead + AsyncWrite,
+    C: Service<Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
+    C::Error: 'static,
+    Codec: Decoder + Encoder,
+    <Codec as Encoder>::Item: 'static,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+{
+    /// Callback to execute on disconnect
+    ///
+    /// Second parameter indicates error occured during disconnect.
+    pub fn disconnect<F, Out>(mut self, disconnect: F) -> Self
+    where
+        F: Fn(&mut St, bool) + 'static,
+    {
+        self.disconnect = Some(Rc::new(disconnect));
+        self
+    }
+
+    /// Provide stream items handler service and construct service factory.
+    pub fn finish<F, T>(
+        self,
+        service: F,
+    ) -> impl Service<Request = Io, Response = (), Error = ServiceError<C::Error, Codec>>
+    where
+        F: IntoNewService<T>,
+        T: NewService<
+                Config = St,
+                Request = RequestItem<St, Codec>,
+                Response = ResponseItem<Codec>,
+                Error = C::Error,
+                InitError = C::Error,
+            > + 'static,
+    {
+        FramedServiceImpl {
+            connect: self.connect,
+            handler: Rc::new(service.into_new_service()),
+            disconnect: self.disconnect.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+pub struct NewServiceBuilder<St, C, Io, Codec> {
+    connect: C,
+    disconnect: Option<Rc<Fn(&mut St, bool)>>,
+    _t: PhantomData<(St, Io, Codec)>,
+}
+
+impl<St, C, Io, Codec> NewServiceBuilder<St, C, Io, Codec>
+where
+    St: 'static,
+    Io: AsyncRead + AsyncWrite,
+    C: NewService<Config = (), Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
+    C::Error: 'static,
+    C::Future: 'static,
+    Codec: Decoder + Encoder,
+    <Codec as Encoder>::Item: 'static,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+{
+    /// Callback to execute on disconnect
+    ///
+    /// Second parameter indicates error occured during disconnect.
+    pub fn disconnect<F>(mut self, disconnect: F) -> Self
+    where
+        F: Fn(&mut St, bool) + 'static,
+    {
+        self.disconnect = Some(Rc::new(disconnect));
+        self
+    }
+
+    pub fn finish<F, T, Cfg>(
+        self,
+        service: F,
+    ) -> impl NewService<
+        Config = Cfg,
+        Request = Io,
+        Response = (),
+        Error = ServiceError<C::Error, Codec>,
+    >
+    where
+        F: IntoNewService<T>,
+        T: NewService<
+                Config = St,
+                Request = RequestItem<St, Codec>,
+                Response = ResponseItem<Codec>,
+                Error = C::Error,
+                InitError = C::Error,
+            > + 'static,
+    {
+        FramedService {
+            connect: self.connect,
+            handler: Rc::new(service.into_new_service()),
+            disconnect: self.disconnect,
+            _t: PhantomData,
+        }
+    }
+}
+
+pub(crate) struct FramedService<St, C, T, Io, Codec, Cfg> {
+    connect: C,
+    handler: Rc<T>,
+    disconnect: Option<Rc<Fn(&mut St, bool)>>,
+    _t: PhantomData<(St, Io, Codec, Cfg)>,
+}
+
+impl<St, C, T, Io, Codec, Cfg> NewService for FramedService<St, C, T, Io, Codec, Cfg>
+where
+    St: 'static,
+    Io: AsyncRead + AsyncWrite,
+    C: NewService<Config = (), Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
+    C::Error: 'static,
+    C::Future: 'static,
+    T: NewService<
+            Config = St,
+            Request = RequestItem<St, Codec>,
+            Response = ResponseItem<Codec>,
+            Error = C::Error,
+            InitError = C::Error,
+        > + 'static,
+    Codec: Decoder + Encoder,
+    <Codec as Encoder>::Item: 'static,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+{
+    type Config = Cfg;
+    type Request = Io;
+    type Response = ();
+    type Error = ServiceError<C::Error, Codec>;
+    type InitError = C::InitError;
+    type Service = FramedServiceImpl<St, C::Service, T, Io, Codec>;
+    type Future = Box<Future<Item = Self::Service, Error = Self::InitError>>;
+
+    fn new_service(&self, _: &Cfg) -> Self::Future {
+        let handler = self.handler.clone();
+        let disconnect = self.disconnect.clone();
+
+        // create connect service and then create service impl
+        Box::new(
+            self.connect
+                .new_service(&())
+                .map(move |connect| FramedServiceImpl {
+                    connect,
+                    handler,
+                    disconnect,
+                    _t: PhantomData,
+                }),
+        )
+    }
+}
+
+pub struct FramedServiceImpl<St, C, T, Io, Codec> {
+    connect: C,
+    handler: Rc<T>,
+    disconnect: Option<Rc<Fn(&mut St, bool)>>,
+    _t: PhantomData<(St, Io, Codec)>,
+}
+
+impl<St, C, T, Io, Codec> Service for FramedServiceImpl<St, C, T, Io, Codec>
+where
+    Io: AsyncRead + AsyncWrite,
+    C: Service<Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
+    C::Error: 'static,
+    T: NewService<
+        Config = St,
+        Request = RequestItem<St, Codec>,
+        Response = ResponseItem<Codec>,
+        Error = C::Error,
+        InitError = C::Error,
+    >,
+    <<T as NewService>::Service as Service>::Future: 'static,
+    Codec: Decoder + Encoder,
+    <Codec as Encoder>::Item: 'static,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+{
+    type Request = Io;
+    type Response = ();
+    type Error = ServiceError<C::Error, Codec>;
+    type Future = FramedServiceImplResponse<St, Io, Codec, C, T>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        self.connect.poll_ready().map_err(|e| e.into())
+    }
+
+    fn call(&mut self, req: Io) -> Self::Future {
+        FramedServiceImplResponse {
+            inner: FramedServiceImplResponseInner::Connect(
+                self.connect.call(Connect::new(req)),
+                self.handler.clone(),
+            ),
+            disconnect: self.disconnect.clone(),
+        }
+    }
+}
+
+pub struct FramedServiceImplResponse<St, Io, Codec, C, T>
+where
+    C: Service<Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
+    C::Error: 'static,
+    T: NewService<
+        Config = St,
+        Request = RequestItem<St, Codec>,
+        Response = ResponseItem<Codec>,
+        Error = C::Error,
+        InitError = C::Error,
+    >,
+    <<T as NewService>::Service as Service>::Future: 'static,
+    Io: AsyncRead + AsyncWrite,
+    Codec: Encoder + Decoder,
+    <Codec as Encoder>::Item: 'static,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+{
+    inner: FramedServiceImplResponseInner<St, Io, Codec, C, T>,
+    disconnect: Option<Rc<Fn(&mut St, bool)>>,
+}
+
+enum FramedServiceImplResponseInner<St, Io, Codec, C, T>
+where
+    C: Service<Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
+    C::Error: 'static,
+    T: NewService<
+        Config = St,
+        Request = RequestItem<St, Codec>,
+        Response = ResponseItem<Codec>,
+        Error = C::Error,
+        InitError = C::Error,
+    >,
+    <<T as NewService>::Service as Service>::Future: 'static,
+    Io: AsyncRead + AsyncWrite,
+    Codec: Encoder + Decoder,
+    <Codec as Encoder>::Item: 'static,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+{
+    Connect(C::Future, Rc<T>),
+    Handler(T::Future, Option<ConnectResult<Io, St, Codec>>),
+    Dispatcher(FramedDispatcher<St, T::Service, Io, Codec>),
+}
+
+impl<St, Io, Codec, C, T> Future for FramedServiceImplResponse<St, Io, Codec, C, T>
+where
+    C: Service<Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
+    C::Error: 'static,
+    T: NewService<
+        Config = St,
+        Request = RequestItem<St, Codec>,
+        Response = ResponseItem<Codec>,
+        Error = C::Error,
+        InitError = C::Error,
+    >,
+    <<T as NewService>::Service as Service>::Future: 'static,
+    Io: AsyncRead + AsyncWrite,
+    Codec: Encoder + Decoder,
+    <Codec as Encoder>::Item: 'static,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+{
+    type Item = ();
+    type Error = ServiceError<C::Error, Codec>;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        match self.inner {
+            FramedServiceImplResponseInner::Connect(ref mut fut, ref handler) => {
+                match fut.poll()? {
+                    Async::Ready(res) => {
+                        self.inner = FramedServiceImplResponseInner::Handler(
+                            handler.new_service(&res.state),
+                            Some(res),
+                        );
+                        self.poll()
+                    }
+                    Async::NotReady => Ok(Async::NotReady),
+                }
+            }
+            FramedServiceImplResponseInner::Handler(ref mut fut, ref mut res) => {
+                match fut.poll()? {
+                    Async::Ready(handler) => {
+                        let res = res.take().unwrap();
+                        self.inner =
+                            FramedServiceImplResponseInner::Dispatcher(FramedDispatcher::new(
+                                res.framed,
+                                State::new(res.state),
+                                handler,
+                                res.rx,
+                                res.sink,
+                                self.disconnect.clone(),
+                            ));
+                        self.poll()
+                    }
+                    Async::NotReady => Ok(Async::NotReady),
+                }
+            }
+            FramedServiceImplResponseInner::Dispatcher(ref mut fut) => fut.poll(),
+        }
+    }
+}

actix-ioframe/src/sink.rs

@@ -0,0 +1,44 @@
+use std::fmt;
+
+use futures::unsync::{mpsc, oneshot};
+use futures::Future;
+
+use crate::dispatcher::FramedMessage;
+
+pub struct Sink<T>(mpsc::UnboundedSender<FramedMessage<T>>);
+
+impl<T> Clone for Sink<T> {
+    fn clone(&self) -> Self {
+        Sink(self.0.clone())
+    }
+}
+
+impl<T> Sink<T> {
+    pub(crate) fn new(tx: mpsc::UnboundedSender<FramedMessage<T>>) -> Self {
+        Sink(tx)
+    }
+
+    /// Close connection
+    pub fn close(&self) {
+        let _ = self.0.unbounded_send(FramedMessage::Close);
+    }
+
+    /// Close connection
+    pub fn wait_close(&self) -> impl Future<Item = (), Error = ()> {
+        let (tx, rx) = oneshot::channel();
+        let _ = self.0.unbounded_send(FramedMessage::WaitClose(tx));
+
+        rx.map_err(|_| ())
+    }
+
+    /// Send item
+    pub fn send(&self, item: T) {
+        let _ = self.0.unbounded_send(FramedMessage::Message(item));
+    }
+}
+
+impl<T> fmt::Debug for Sink<T> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("Sink").finish()
+    }
+}

actix-ioframe/src/state.rs

@@ -0,0 +1,30 @@
+use std::cell::{Ref, RefCell, RefMut};
+use std::rc::Rc;
+
+/// Connection state
+///
+/// Connection state is an arbitrary data attached to the each incoming message.
+#[derive(Debug)]
+pub struct State<T>(Rc<RefCell<T>>);
+
+impl<T> State<T> {
+    pub(crate) fn new(st: T) -> Self {
+        State(Rc::new(RefCell::new(st)))
+    }
+
+    #[inline]
+    pub fn get_ref(&self) -> Ref<T> {
+        self.0.borrow()
+    }
+
+    #[inline]
+    pub fn get_mut(&mut self) -> RefMut<T> {
+        self.0.borrow_mut()
+    }
+}
+
+impl<T> Clone for State<T> {
+    fn clone(&self) -> Self {
+        State(self.0.clone())
+    }
+}

actix-ioframe/tests/test_server.rs

@@ -0,0 +1,60 @@
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+use std::time::Duration;
+
+use actix_codec::BytesCodec;
+use actix_server_config::Io;
+use actix_service::{new_apply_fn, Service};
+use actix_test_server::TestServer;
+use futures::Future;
+use tokio_tcp::TcpStream;
+use tokio_timer::sleep;
+
+use actix_ioframe::{Builder, Connect};
+
+struct State;
+
+#[test]
+fn test_disconnect() -> std::io::Result<()> {
+    let disconnect = Arc::new(AtomicBool::new(false));
+    let disconnect1 = disconnect.clone();
+
+    let mut srv = TestServer::with(move || {
+        let disconnect1 = disconnect1.clone();
+
+        new_apply_fn(
+            Builder::new()
+                .factory(|conn: Connect<_>| Ok(conn.codec(BytesCodec).state(State)))
+                .disconnect(move |_, _| {
+                    disconnect1.store(true, Ordering::Relaxed);
+                })
+                .finish(|_t| Ok(None)),
+            |io: Io<TcpStream>, srv| srv.call(io.into_parts().0),
+        )
+    });
+
+    let mut client = Builder::new()
+        .service(|conn: Connect<_>| {
+            let conn = conn.codec(BytesCodec).state(State);
+            conn.sink().close();
+            Ok(conn)
+        })
+        .finish(|_t| Ok(None));
+
+    let conn = srv
+        .block_on(
+            actix_connect::default_connector()
+                .call(actix_connect::Connect::with(String::new(), srv.addr())),
+        )
+        .unwrap();
+
+    srv.block_on(client.call(conn.into_parts().0)).unwrap();
+    let _ = srv.block_on(
+        sleep(Duration::from_millis(100))
+            .map(|_| ())
+            .map_err(|_| ()),
+    );
+    assert!(disconnect.load(Ordering::Relaxed));
+
+    Ok(())
+}

actix-rt/CHANGES.md

@@ -1,5 +1,12 @@
 # Changes
 
+## [0.2.4] - 2019-07-17
+
+### Changed
+
+* Avoid a copy of the Future when initializing the Box. #29
+
+
 ## [0.2.3] - 2019-06-22
 
 ### Added

actix-rt/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-rt"
-version = "0.2.3"
+version = "0.2.4"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix runtime"
 keywords = ["network", "framework", "async", "futures"]
@@ -24,3 +24,4 @@ tokio-current-thread = "0.1"
 tokio-executor = "0.1.5"
 tokio-reactor = "0.1.7"
 tokio-timer = "0.2.8"
+copyless = "0.1.4"

actix-rt/src/arbiter.rs

@@ -11,6 +11,8 @@ use tokio_current_thread::spawn;
 use crate::builder::Builder;
 use crate::system::System;
 
+use copyless::BoxHelper;
+
 thread_local!(
     static ADDR: RefCell<Option<Arbiter>> = RefCell::new(None);
     static RUNNING: Cell<bool> = Cell::new(false);
@@ -141,9 +143,9 @@ impl Arbiter {
     {
         RUNNING.with(move |cell| {
             if cell.get() {
-                spawn(Box::new(future));
+                spawn(Box::alloc().init(future));
             } else {
-                Q.with(move |cell| cell.borrow_mut().push(Box::new(future)));
+                Q.with(move |cell| cell.borrow_mut().push(Box::alloc().init(future)));
             }
         });
     }

actix-service/src/transform.rs

@@ -6,17 +6,11 @@ use futures::{Async, Future, IntoFuture, Poll};
 use crate::transform_err::{TransformFromErr, TransformMapInitErr};
 use crate::{IntoNewService, NewService, Service};
 
-/// The `Transform` trait defines the interface of a Service factory.  `Transform`
-/// is often implemented for middleware, defining how to manufacture a
-/// middleware Service.  A Service that is manufactured by the factory takes
+/// The `Transform` trait defines the interface of a Service factory. `Transform`
+/// is often implemented for middleware, defining how to construct a
+/// middleware Service. A Service that is constructed by the factory takes
 /// the Service that follows it during execution as a parameter, assuming
-/// ownership of the next Service.  A Service can be a variety of types, such
-/// as (but not limited to) another middleware Service, an extractor Service,
-/// other helper Services, or the request handler endpoint Service.
-///
-/// A Service is created by the factory during server initialization.
-///
-/// `Config` is a service factory configuration type.
+/// ownership of the next Service.
 pub trait Transform<S> {
     /// Requests handled by the service.
     type Request;

actix-tower/src/lib.rs

@@ -81,7 +81,7 @@ impl<S, R> ActixCompat<S, R> {
 
 /// Extension trait for wrapping a `tower_service::Service` instance for use as
 /// an `actix_service::Service`.
-pub trait TowerServiceExt<R> : TowerService<R> + Sized {
+pub trait TowerServiceExt<R>: TowerService<R> + Sized {
     /// Wraps a `tower_service::Service` in a compatibility wrapper.
     ///
     /// ```
@@ -167,16 +167,13 @@ pub trait TowerServiceExt<R> : TowerService<R> + Sized {
     fn wrap_with_actix_middleware<F, U>(self, f: F) -> TowerCompat<U>
     where
         F: FnOnce(ActixCompat<Self, R>) -> U,
-        U: ActixService<Request = R>
+        U: ActixService<Request = R>,
     {
         f(self.into_actix_service()).into_tower_service()
     }
 }
 
-impl<S, R> TowerServiceExt<R> for S
-where
-    S: TowerService<R> + Sized
-{}
+impl<S, R> TowerServiceExt<R> for S where S: TowerService<R> + Sized {}
 
 impl<S, R> ActixService for ActixCompat<S, R>
 where
@@ -207,9 +204,7 @@ pub struct TowerCompat<S> {
 impl<S> TowerCompat<S> {
     /// Wraps an `actix_service::Service` in a compatibility wrapper.
     pub fn new(inner: S) -> Self {
-        TowerCompat {
-            inner,
-        }
+        TowerCompat { inner }
     }
 }
 
@@ -302,16 +297,13 @@ pub trait ActixServiceExt: ActixService + Sized {
     fn wrap_with_tower_middleware<F, U>(self, f: F) -> ActixCompat<U, Self::Request>
     where
         F: FnOnce(TowerCompat<Self>) -> U,
-        U: TowerService<Self::Request>
+        U: TowerService<Self::Request>,
     {
         f(self.into_tower_service()).into_actix_service()
     }
 }
 
-impl<S> ActixServiceExt for S
-where
-    S: ActixService + Sized
-{}
+impl<S> ActixServiceExt for S where S: ActixService + Sized {}
 
 impl<S> TowerService<S::Request> for TowerCompat<S>
 where
@@ -335,10 +327,9 @@ mod tests {
     mod tower_service_into_actix_service {
         use crate::TowerServiceExt;
         use actix_service::{Service as ActixService, ServiceExt, Transform};
-        use futures::{future::FutureResult, Async, Poll, Future};
+        use futures::{future::FutureResult, Async, Future, Poll};
         use tower_service::Service as TowerService;
 
-
         #[test]
         fn random_service_returns_4() {
             let mut s = RandomService.into_actix_service();
@@ -397,7 +388,10 @@ mod tests {
         fn random_service_can_be_transformed_to_do_math() {
             let transform = DoMath;
 
-            let mut s = transform.new_transform(RandomService.into_actix_service()).wait().unwrap();
+            let mut s = transform
+                .new_transform(RandomService.into_actix_service())
+                .wait()
+                .unwrap();
 
             assert_eq!(Ok(Async::Ready(())), s.poll_ready());
 
@@ -477,10 +471,9 @@ mod tests {
     mod actix_service_into_tower_service {
         use crate::{ActixServiceExt, TowerServiceExt};
         use actix_service::{Service as ActixService, ServiceExt};
-        use futures::{future::FutureResult, Async, Poll, Future};
+        use futures::{future::FutureResult, Async, Future, Poll};
         use tower_service::Service as TowerService;
 
-
         #[test]
         fn random_service_returns_4() {
             let mut s = RandomService.into_tower_service();
@@ -492,7 +485,8 @@ mod tests {
 
         #[test]
         fn random_service_can_use_tower_middleware() {
-            let mut s = AddOneService::wrap(RandomService.into_tower_service()).into_actix_service();
+            let mut s =
+                AddOneService::wrap(RandomService.into_tower_service()).into_actix_service();
 
             assert_eq!(Ok(Async::Ready(())), s.poll_ready());
 
@@ -501,7 +495,8 @@ mod tests {
 
         #[test]
         fn do_math_service_can_use_tower_middleware() {
-            let mut s = AddOneService::wrap(DoMathService.into_tower_service()).into_actix_service();
+            let mut s =
+                AddOneService::wrap(DoMathService.into_tower_service()).into_actix_service();
 
             assert_eq!(Ok(Async::Ready(())), s.poll_ready());
 
@@ -537,14 +532,12 @@ mod tests {
         }
 
         struct AddOneService<S> {
-            inner: S
+            inner: S,
         }
 
         impl<S> AddOneService<S> {
             fn wrap(inner: S) -> Self {
-                AddOneService {
-                    inner,
-                }
+                AddOneService { inner }
             }
         }
 
@@ -562,8 +555,7 @@ mod tests {
             }
 
             fn call(&mut self, req: R) -> Self::Future {
-                let fut = self.inner.call(req)
-                    .map(|x| x + 1);
+                let fut = self.inner.call(req).map(|x| x + 1);
 
                 Box::new(fut)
             }
@@ -583,5 +575,6 @@ mod tests {
             fn call(&mut self, req: Self::Request) -> Self::Future {
                 futures::finished(req * 17)
             }
-        }}
-}
+        }
+    }
+}

actix-utils/CHANGES.md

@@ -1,6 +1,29 @@
 # Changes
 
-##[0.4.1] - 2019-05-15
+## [0.4.4] - 2019-07-17
+
+### Changed
+
+* Undeprecate `FramedTransport` as it is actually useful
+
+
+## [0.4.3] - 2019-07-17
+
+### Deprecated
+
+* Deprecate `CloneableService` as it is not safe and in general not very useful
+
+* Deprecate `FramedTransport` in favor of `actix-ioframe`
+
+
+## [0.4.2] - 2019-06-26
+
+### Fixed
+
+* Do not block on sink drop for FramedTransport
+
+
+## [0.4.1] - 2019-05-15
 
 ### Changed
 

actix-utils/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-utils"
-version = "0.4.1"
+version = "0.4.4"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix utils - various actix net related services"
 keywords = ["network", "framework", "async", "futures"]
@@ -18,8 +18,8 @@ name = "actix_utils"
 path = "src/lib.rs"
 
 [dependencies]
-actix-service = "0.4.0"
-actix-codec = "0.1.1"
+actix-service = "0.4.1"
+actix-codec = "0.1.2"
 bytes = "0.4"
 either = "1.5.2"
 futures = "0.1.25"

actix-utils/src/cloneable.rs

@@ -1,3 +1,4 @@
+#![allow(deprecated)]
 use std::marker::PhantomData;
 use std::rc::Rc;
 
@@ -6,6 +7,8 @@ use futures::Poll;
 
 use super::cell::Cell;
 
+#[doc(hidden)]
+#[deprecated(since = "0.4.3", note = "support will be removed in actix-utils 0.4.5")]
 /// Service that allows to turn non-clone service to a service with `Clone` impl
 pub struct CloneableService<T> {
     service: Cell<T>,

actix-utils/src/framed.rs

@@ -187,10 +187,12 @@ where
                             return true;
                         }
                         Ok(Async::Ready(None)) => {
+                            rx_done = true;
                             let _ = self.rx.take();
                         }
                         Ok(Async::NotReady) => rx_done = true,
                         Err(_e) => {
+                            rx_done = true;
                             let _ = self.rx.take();
                         }
                     }