Support named parameters for ResourceDef::resource_path() in form of ((&k, &v), ...)

.github/workflows/main.yml

@@ -2,6 +2,9 @@ name: CI
 
 on: [push, pull_request]
 
+env:
+  VCPKGRS_DYNAMIC: 1
+
 jobs:
   build_and_test:
     strategy:
@@ -18,10 +21,12 @@ jobs:
         include:
         - toolchain: x86_64-pc-windows-msvc
           os: windows-latest
+          arch: x64
         - toolchain: x86_64-pc-windows-gnu
           os: windows-latest
         - toolchain: i686-pc-windows-msvc
           os: windows-latest
+          arch: x86
         - toolchain: x86_64-apple-darwin
           os: macOS-latest
 
@@ -37,6 +42,13 @@ jobs:
           toolchain: ${{ matrix.version }}-${{ matrix.toolchain }}
           default: true
 
+
+      - name: Install OpenSSL
+        if: matrix.toolchain == 'x86_64-pc-windows-msvc' || matrix.toolchain == 'i686-pc-windows-msvc'
+        run: |
+          vcpkg integrate install
+          vcpkg install openssl:${{ matrix.arch }}-windows
+
       - name: check nightly
         if: matrix.version == 'nightly'
         uses: actions-rs/cargo@v1
@@ -52,6 +64,14 @@ jobs:
           args: --all --bins --examples --tests
 
       - name: tests
+        if: matrix.toolchain != 'x86_64-pc-windows-gnu'
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --all --all-features -- --nocapture
+
+      - name: tests on x86_64-pc-windows-gnu
+        if: matrix.toolchain == 'x86_64-pc-windows-gnu'
         uses: actions-rs/cargo@v1
         with:
           command: test

actix-codec/CHANGES.md

@@ -1,5 +1,7 @@
 # Changes
 
+* Use `.advance()` intead of `.split_to()`
+
 ## [0.2.0] - 2019-12-10
 
 * Use specific futures dependencies

actix-codec/src/framed.rs

@@ -2,7 +2,7 @@ use std::pin::Pin;
 use std::task::{Context, Poll};
 use std::{fmt, io};
 
-use bytes::BytesMut;
+use bytes::{Buf, BytesMut};
 use futures_core::{ready, Stream};
 use futures_sink::Sink;
 
@@ -288,7 +288,7 @@ impl<T, U> Framed<T, U> {
             }
 
             // remove written data
-            let _ = self.write_buf.split_to(n);
+            self.write_buf.advance(n);
         }
 
         // Try flushing the underlying IO

actix-connect/CHANGES.md

@@ -1,5 +1,13 @@
 # Changes
 
+## [1.0.1] - 2019-12-15
+
+* Fix trust-dns-resolver compilation
+
+## [1.0.0] - 2019-12-11
+
+* Release
+
 ## [1.0.0-alpha.3] - 2019-12-07
 
 ### Changed

actix-connect/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-connect"
-version = "1.0.0-alpha.3"
+version = "1.0.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix connect - tcp connector service"
 keywords = ["network", "framework", "async", "futures"]
@@ -9,7 +9,6 @@ repository = "https://github.com/actix/actix-net.git"
 documentation = "https://docs.rs/actix-connect/"
 categories = ["network-programming", "asynchronous"]
 license = "MIT/Apache-2.0"
-exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
 edition = "2018"
 workspace = ".."
 
@@ -35,14 +34,15 @@ uri = ["http"]
 [dependencies]
 actix-service = "1.0.0"
 actix-codec = "0.2.0"
-actix-utils = "1.0.0-alpha.3"
+actix-utils = "1.0.3"
 actix-rt = "1.0.0"
 derive_more = "0.99.2"
 either = "1.5.2"
 futures = "0.3.1"
 http = { version = "0.2.0", optional = true }
 log = "0.4"
-trust-dns-resolver = { version="0.18.0-alpha.2", default-features = false, features=["tokio"] }
+trust-dns-proto = "=0.18.0-alpha.2"
+trust-dns-resolver = "=0.18.0-alpha.2"
 
 # openssl
 open-ssl = { version="0.10", package = "openssl", optional = true }
@@ -54,5 +54,5 @@ tokio-rustls = { version = "0.12.0", optional = true }
 webpki = { version = "0.21", optional = true }
 
 [dev-dependencies]
-bytes = "0.5.2"
-actix-testing = { version="1.0.0-alpha.2" }
+bytes = "0.5.3"
+actix-testing = { version="1.0.0" }

actix-ioframe/CHANGES.md

@@ -1,5 +1,21 @@
 # Changes
 
+## [0.5.0] - 2019-12-29
+
+* Simplify state management
+
+* Allow to set custom output stream
+
+* Removed disconnect callback
+
+## [0.4.1] - 2019-12-11
+
+* Disconnect callback accepts owned state
+
+## [0.4.0] - 2019-12-11
+
+* Remove `E` param
+
 ## [0.3.0-alpha.3] - 2019-12-07
 
 * Migrate to tokio 0.2

actix-ioframe/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-ioframe"
-version = "0.3.0-alpha.3"
+version = "0.5.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix framed service"
 keywords = ["network", "framework", "async", "futures"]
@@ -9,25 +9,23 @@ repository = "https://github.com/actix/actix-net.git"
 documentation = "https://docs.rs/actix-ioframe/"
 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 = "1.0.0"
+actix-service = "1.0.1"
 actix-codec = "0.2.0"
-actix-utils = "1.0.0-alpha.2"
+actix-utils = "1.0.4"
 actix-rt = "1.0.0"
-bytes = "0.5"
-either = "1.5.2"
+bytes = "0.5.3"
+either = "1.5.3"
 futures = "0.3.1"
 pin-project = "0.4.6"
 log = "0.4"
 
 [dev-dependencies]
-actix-connect = "1.0.0-alpha.2"
-actix-testing = "1.0.0-alpha.2"
+actix-connect = "1.0.0"
+actix-testing = "1.0.0"

actix-ioframe/src/connect.rs

@@ -3,54 +3,49 @@ use std::pin::Pin;
 use std::task::{Context, Poll};
 
 use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
+use actix_utils::mpsc::Receiver;
 use futures::Stream;
 
-use crate::sink::Sink;
-
-pub struct Connect<Io, Codec, Err, St = ()>
+pub struct Connect<Io, Codec>
 where
     Codec: Encoder + Decoder,
 {
     io: Io,
-    sink: Sink<<Codec as Encoder>::Item, Err>,
-    _t: PhantomData<(St, Codec)>,
+    _t: PhantomData<Codec>,
 }
 
-impl<Io, Codec, Err> Connect<Io, Codec, Err>
+impl<Io, Codec> Connect<Io, Codec>
 where
     Io: AsyncRead + AsyncWrite,
     Codec: Encoder + Decoder,
 {
-    pub(crate) fn new(io: Io, sink: Sink<<Codec as Encoder>::Item, Err>) -> Self {
+    pub(crate) fn new(io: Io) -> Self {
         Self {
             io,
-            sink,
             _t: PhantomData,
         }
     }
 
-    pub fn codec(self, codec: Codec) -> ConnectResult<Io, (), Codec, Err> {
+    pub fn codec(
+        self,
+        codec: Codec,
+    ) -> ConnectResult<Io, (), Codec, Receiver<<Codec as Encoder>::Item>> {
         ConnectResult {
             state: (),
-            sink: self.sink,
+            out: None,
             framed: Framed::new(self.io, codec),
         }
     }
 }
 
 #[pin_project::pin_project]
-pub struct ConnectResult<Io, St, Codec: Encoder + Decoder, Err> {
+pub struct ConnectResult<Io, St, Codec: Encoder + Decoder, Out> {
     pub(crate) state: St,
+    pub(crate) out: Option<Out>,
     pub(crate) framed: Framed<Io, Codec>,
-    pub(crate) sink: Sink<<Codec as Encoder>::Item, Err>,
 }
 
-impl<Io, St, Codec: Encoder + Decoder, Err> ConnectResult<Io, St, Codec, Err> {
-    #[inline]
-    pub fn sink(&self) -> &Sink<<Codec as Encoder>::Item, Err> {
-        &self.sink
-    }
-
+impl<Io, St, Codec: Encoder + Decoder, Out: Unpin> ConnectResult<Io, St, Codec, Out> {
     #[inline]
     pub fn get_ref(&self) -> &Io {
         self.framed.get_ref()
@@ -61,17 +56,28 @@ impl<Io, St, Codec: Encoder + Decoder, Err> ConnectResult<Io, St, Codec, Err> {
         self.framed.get_mut()
     }
 
+    pub fn out<U>(self, out: U) -> ConnectResult<Io, St, Codec, U>
+    where
+        U: Stream<Item = <Codec as Encoder>::Item> + Unpin,
+    {
+        ConnectResult {
+            state: self.state,
+            framed: self.framed,
+            out: Some(out),
+        }
+    }
+
     #[inline]
-    pub fn state<S>(self, state: S) -> ConnectResult<Io, S, Codec, Err> {
+    pub fn state<S>(self, state: S) -> ConnectResult<Io, S, Codec, Out> {
         ConnectResult {
             state,
             framed: self.framed,
-            sink: self.sink,
+            out: self.out,
         }
     }
 }
 
-impl<Io, St, Codec, Err> Stream for ConnectResult<Io, St, Codec, Err>
+impl<Io, St, Codec, Out> Stream for ConnectResult<Io, St, Codec, Out>
 where
     Io: AsyncRead + AsyncWrite,
     Codec: Encoder + Decoder,
@@ -83,8 +89,8 @@ where
     }
 }
 
-impl<Io, St, Codec, Err> futures::Sink<<Codec as Encoder>::Item>
-    for ConnectResult<Io, St, Codec, Err>
+impl<Io, St, Codec, Out> futures::Sink<<Codec as Encoder>::Item>
+    for ConnectResult<Io, St, Codec, Out>
 where
     Io: AsyncRead + AsyncWrite,
     Codec: Encoder + Decoder,

actix-ioframe/src/dispatcher.rs

@@ -1,81 +1,56 @@
 //! Framed dispatcher service and related utilities
 use std::pin::Pin;
-use std::rc::Rc;
 use std::task::{Context, Poll};
 
 use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
-use actix_service::{IntoService, Service};
-use actix_utils::{mpsc, oneshot};
-use futures::{FutureExt, Stream};
+use actix_service::Service;
+use actix_utils::mpsc;
+use futures::Stream;
 use log::debug;
 
 use crate::error::ServiceError;
-use crate::item::Item;
-use crate::sink::Sink;
 
-type Request<S, U, E> = Item<S, U, E>;
+type Request<U> = <U as Decoder>::Item;
 type Response<U> = <U as Encoder>::Item;
 
-pub(crate) enum Message<T> {
-    Item(T),
-    WaitClose(oneshot::Sender<()>),
-    Close,
-}
-
 /// FramedTransport - is a future that reads frames from Framed object
 /// and pass then to the service.
-#[pin_project::pin_project]
-pub(crate) struct Dispatcher<St, S, T, U, E>
+pub(crate) struct Dispatcher<S, T, U, Out>
 where
-    St: Clone,
-    S: Service<Request = Request<St, U, E>, Response = Option<Response<U>>, Error = E>,
+    S: Service<Request = Request<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,
+    Out: Stream<Item = <U as Encoder>::Item> + Unpin,
 {
     service: S,
-    sink: Sink<<U as Encoder>::Item, E>,
-    state: St,
-    dispatch_state: FramedState<S, U>,
+    sink: Option<Out>,
+    state: FramedState<S, U>,
     framed: Framed<T, U>,
-    rx: mpsc::Receiver<Result<Message<<U as Encoder>::Item>, E>>,
-    tx: mpsc::Sender<Result<Message<<U as Encoder>::Item>, E>>,
-    disconnect: Option<Rc<dyn Fn(&mut St, bool)>>,
+    rx: mpsc::Receiver<Result<<U as Encoder>::Item, S::Error>>,
 }
 
-impl<St, S, T, U, E> Dispatcher<St, S, T, U, E>
+impl<S, T, U, Out> Dispatcher<S, T, U, Out>
 where
-    St: Clone,
-    S: Service<Request = Request<St, U, E>, Response = Option<Response<U>>, Error = E>,
+    S: Service<Request = Request<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,
+    Out: Stream<Item = <U as Encoder>::Item> + Unpin,
 {
-    pub(crate) fn new<F: IntoService<S>>(
-        framed: Framed<T, U>,
-        state: St,
-        service: F,
-        sink: Sink<<U as Encoder>::Item, E>,
-        rx: mpsc::Receiver<Result<Message<<U as Encoder>::Item>, E>>,
-        disconnect: Option<Rc<dyn Fn(&mut St, bool)>>,
-    ) -> Self {
-        let tx = rx.sender();
-
+    pub(crate) fn new(framed: Framed<T, U>, service: S, sink: Option<Out>) -> Self {
         Dispatcher {
-            framed,
-            state,
             sink,
-            disconnect,
-            rx,
-            tx,
-            service: service.into_service(),
-            dispatch_state: FramedState::Processing,
+            service,
+            framed,
+            rx: mpsc::channel().1,
+            state: FramedState::Processing,
         }
     }
 }
@@ -84,33 +59,11 @@ enum FramedState<S: Service, U: Encoder + Decoder> {
     Processing,
     Error(ServiceError<S::Error, U>),
     FramedError(ServiceError<S::Error, U>),
-    FlushAndStop(Vec<oneshot::Sender<()>>),
+    FlushAndStop,
     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(());
-                }
-            }
-        }
-    }
-
     fn take_error(&mut self) -> ServiceError<S::Error, U> {
         match std::mem::replace(self, FramedState::Processing) {
             FramedState::Error(err) => err,
@@ -126,16 +79,16 @@ impl<S: Service, U: Encoder + Decoder> FramedState<S, U> {
     }
 }
 
-impl<St, S, T, U, E> Dispatcher<St, S, T, U, E>
+impl<S, T, U, Out> Dispatcher<S, T, U, Out>
 where
-    St: Clone,
-    S: Service<Request = Request<St, U, E>, Response = Option<Response<U>>, Error = E>,
+    S: Service<Request = Request<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,
+    Out: Stream<Item = <U as Encoder>::Item> + Unpin,
 {
     fn poll_read(&mut self, cx: &mut Context<'_>) -> bool {
         loop {
@@ -144,35 +97,32 @@ where
                     let item = match self.framed.next_item(cx) {
                         Poll::Ready(Some(Ok(el))) => el,
                         Poll::Ready(Some(Err(err))) => {
-                            self.dispatch_state =
-                                FramedState::FramedError(ServiceError::Decoder(err));
+                            self.state = FramedState::FramedError(ServiceError::Decoder(err));
                             return true;
                         }
                         Poll::Pending => return false,
                         Poll::Ready(None) => {
                             log::trace!("Client disconnected");
-                            self.dispatch_state = FramedState::Stopping;
+                            self.state = FramedState::Stopping;
                             return true;
                         }
                     };
 
-                    let tx = self.tx.clone();
-                    actix_rt::spawn(
-                        self.service
-                            .call(Item::new(self.state.clone(), self.sink.clone(), item))
-                            .map(move |item| {
-                                let item = match item {
-                                    Ok(Some(item)) => Ok(Message::Item(item)),
-                                    Ok(None) => return,
-                                    Err(err) => Err(err),
-                                };
-                                let _ = tx.send(item);
-                            }),
-                    );
+                    let tx = self.rx.sender();
+                    let fut = self.service.call(item);
+                    actix_rt::spawn(async move {
+                        let item = fut.await;
+                        let item = match item {
+                            Ok(Some(item)) => Ok(item),
+                            Ok(None) => return,
+                            Err(err) => Err(err),
+                        };
+                        let _ = tx.send(item);
+                    });
                 }
                 Poll::Pending => return false,
                 Poll::Ready(Err(err)) => {
-                    self.dispatch_state = FramedState::Error(ServiceError::Service(err));
+                    self.state = FramedState::Error(ServiceError::Service(err));
                     return true;
                 }
             }
@@ -184,27 +134,39 @@ where
         loop {
             while !self.framed.is_write_buf_full() {
                 match Pin::new(&mut self.rx).poll_next(cx) {
-                    Poll::Ready(Some(Ok(Message::Item(msg)))) => {
+                    Poll::Ready(Some(Ok(msg))) => {
                         if let Err(err) = self.framed.write(msg) {
-                            self.dispatch_state =
-                                FramedState::FramedError(ServiceError::Encoder(err));
+                            self.state = FramedState::FramedError(ServiceError::Encoder(err));
                             return true;
                         }
-                    }
-                    Poll::Ready(Some(Ok(Message::Close))) => {
-                        self.dispatch_state.stop(None);
-                        return true;
-                    }
-                    Poll::Ready(Some(Ok(Message::WaitClose(tx)))) => {
-                        self.dispatch_state.stop(Some(tx));
-                        return true;
+                        continue;
                     }
                     Poll::Ready(Some(Err(err))) => {
-                        self.dispatch_state = FramedState::Error(ServiceError::Service(err));
+                        self.state = FramedState::Error(ServiceError::Service(err));
                         return true;
                     }
-                    Poll::Ready(None) | Poll::Pending => break,
+                    Poll::Ready(None) | Poll::Pending => (),
                 }
+
+                if self.sink.is_some() {
+                    match Pin::new(self.sink.as_mut().unwrap()).poll_next(cx) {
+                        Poll::Ready(Some(msg)) => {
+                            if let Err(err) = self.framed.write(msg) {
+                                self.state =
+                                    FramedState::FramedError(ServiceError::Encoder(err));
+                                return true;
+                            }
+                            continue;
+                        }
+                        Poll::Ready(None) => {
+                            let _ = self.sink.take();
+                            self.state = FramedState::FlushAndStop;
+                            return true;
+                        }
+                        Poll::Pending => (),
+                    }
+                }
+                break;
             }
 
             if !self.framed.is_write_buf_empty() {
@@ -213,8 +175,7 @@ where
                     Poll::Ready(Ok(_)) => (),
                     Poll::Ready(Err(err)) => {
                         debug!("Error sending data: {:?}", err);
-                        self.dispatch_state =
-                            FramedState::FramedError(ServiceError::Encoder(err));
+                        self.state = FramedState::FramedError(ServiceError::Encoder(err));
                         return true;
                     }
                 }
@@ -229,14 +190,16 @@ where
         &mut self,
         cx: &mut Context<'_>,
     ) -> Poll<Result<(), ServiceError<S::Error, U>>> {
-        match self.dispatch_state {
-            FramedState::Processing => {
-                if self.poll_read(cx) || self.poll_write(cx) {
-                    self.poll(cx)
+        match self.state {
+            FramedState::Processing => loop {
+                let read = self.poll_read(cx);
+                let write = self.poll_write(cx);
+                if read || write {
+                    continue;
                 } else {
-                    Poll::Pending
+                    return Poll::Pending;
                 }
-            }
+            },
             FramedState::Error(_) => {
                 // flush write buffer
                 if !self.framed.is_write_buf_empty() {
@@ -244,12 +207,21 @@ where
                         return Poll::Pending;
                     }
                 }
-                if let Some(ref disconnect) = self.disconnect {
-                    (&*disconnect)(&mut self.state, true);
-                }
-                Poll::Ready(Err(self.dispatch_state.take_error()))
+                Poll::Ready(Err(self.state.take_error()))
             }
-            FramedState::FlushAndStop(ref mut vec) => {
+            FramedState::FlushAndStop => {
+                // drain service responses
+                match Pin::new(&mut self.rx).poll_next(cx) {
+                    Poll::Ready(Some(Ok(msg))) => {
+                        if let Err(_) = self.framed.write(msg) {
+                            return Poll::Ready(Ok(()));
+                        }
+                    }
+                    Poll::Ready(Some(Err(_))) => return Poll::Ready(Ok(())),
+                    Poll::Ready(None) | Poll::Pending => (),
+                }
+
+                // flush io
                 if !self.framed.is_write_buf_empty() {
                     match self.framed.flush(cx) {
                         Poll::Ready(Err(err)) => {
@@ -261,26 +233,10 @@ where
                         Poll::Ready(_) => (),
                     }
                 };
-                for tx in vec.drain(..) {
-                    let _ = tx.send(());
-                }
-                if let Some(ref disconnect) = self.disconnect {
-                    (&*disconnect)(&mut self.state, false);
-                }
-                Poll::Ready(Ok(()))
-            }
-            FramedState::FramedError(_) => {
-                if let Some(ref disconnect) = self.disconnect {
-                    (&*disconnect)(&mut self.state, true);
-                }
-                Poll::Ready(Err(self.dispatch_state.take_framed_error()))
-            }
-            FramedState::Stopping => {
-                if let Some(ref disconnect) = self.disconnect {
-                    (&*disconnect)(&mut self.state, false);
-                }
                 Poll::Ready(Ok(()))
             }
+            FramedState::FramedError(_) => Poll::Ready(Err(self.state.take_framed_error())),
+            FramedState::Stopping => Poll::Ready(Ok(())),
         }
     }
 }

actix-ioframe/src/item.rs

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

actix-ioframe/src/lib.rs

@@ -1,15 +1,11 @@
-#![deny(rust_2018_idioms, warnings)]
+// #![deny(rust_2018_idioms, warnings)]
 #![allow(clippy::type_complexity, clippy::too_many_arguments)]
 
 mod connect;
 mod dispatcher;
 mod error;
-mod item;
 mod service;
-mod sink;
 
 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::service::{Builder, FactoryBuilder};

actix-ioframe/src/service.rs

@@ -4,345 +4,322 @@ use std::pin::Pin;
 use std::rc::Rc;
 use std::task::{Context, Poll};
 
-use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder};
+use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
 use actix_service::{IntoService, IntoServiceFactory, Service, ServiceFactory};
-use actix_utils::mpsc;
 use either::Either;
-use futures::future::{FutureExt, LocalBoxFuture};
+use futures::{ready, Stream};
 use pin_project::project;
 
 use crate::connect::{Connect, ConnectResult};
-use crate::dispatcher::{Dispatcher, Message};
+use crate::dispatcher::Dispatcher;
 use crate::error::ServiceError;
-use crate::item::Item;
-use crate::sink::Sink;
 
-type RequestItem<S, U, E> = Item<S, U, E>;
+type RequestItem<U> = <U as Decoder>::Item;
 type ResponseItem<U> = Option<<U as Encoder>::Item>;
-type ServiceResult<U, E> = Result<Message<<U as Encoder>::Item>, E>;
 
 /// Service builder - structure that follows the builder pattern
 /// for building instances for framed services.
-pub struct Builder<St, Codec>(PhantomData<(St, Codec)>);
-
-impl<St: Clone, Codec> Default for Builder<St, Codec> {
-    fn default() -> Builder<St, Codec> {
-        Builder::new()
-    }
-}
-
-impl<St: Clone, 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, E>(self, connect: F) -> ServiceBuilder<St, C, Io, Codec, E>
-    where
-        F: IntoService<C>,
-        Io: AsyncRead + AsyncWrite,
-        C: Service<
-            Request = Connect<Io, Codec, E>,
-            Response = ConnectResult<Io, St, Codec, E>,
-            Error = E,
-        >,
-        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, E>(self, connect: F) -> NewServiceBuilder<St, C, Io, Codec, E>
-    where
-        F: IntoServiceFactory<C>,
-        E: 'static,
-        Io: AsyncRead + AsyncWrite,
-        C: ServiceFactory<
-            Config = (),
-            Request = Connect<Io, Codec, E>,
-            Response = ConnectResult<Io, St, Codec, E>,
-            Error = E,
-        >,
-        C::Future: 'static,
-        Codec: Decoder + Encoder,
-    {
-        NewServiceBuilder {
-            connect: connect.into_factory(),
-            disconnect: None,
-            _t: PhantomData,
-        }
-    }
-}
-
-pub struct ServiceBuilder<St, C, Io, Codec, Err> {
+pub struct Builder<St, C, Io, Codec, Out> {
     connect: C,
-    disconnect: Option<Rc<dyn Fn(&mut St, bool)>>,
-    _t: PhantomData<(St, Io, Codec, Err)>,
+    _t: PhantomData<(St, Io, Codec, Out)>,
 }
 
-impl<St, C, Io, Codec, Err> ServiceBuilder<St, C, Io, Codec, Err>
+impl<St, C, Io, Codec, Out> Builder<St, C, Io, Codec, Out>
 where
-    St: Clone,
-    C: Service<
-        Request = Connect<Io, Codec, Err>,
-        Response = ConnectResult<Io, St, Codec, Err>,
-        Error = Err,
-    >,
+    C: Service<Request = Connect<Io, Codec>, Response = ConnectResult<Io, St, Codec, Out>>,
     Io: AsyncRead + AsyncWrite,
     Codec: Decoder + Encoder,
     <Codec as Encoder>::Item: 'static,
     <Codec as Encoder>::Error: std::fmt::Debug,
+    Out: Stream<Item = <Codec as Encoder>::Item> + Unpin,
 {
-    /// Callback to execute on disconnect
-    ///
-    /// Second parameter indicates error occured during disconnect.
-    pub fn disconnect<F, Out>(mut self, disconnect: F) -> Self
+    /// Construct framed handler service with specified connect service
+    pub fn new<F>(connect: F) -> Builder<St, C, Io, Codec, Out>
     where
-        F: Fn(&mut St, bool) + 'static,
+        F: IntoService<C>,
+        Io: AsyncRead + AsyncWrite,
+        C: Service<Request = Connect<Io, Codec>, Response = ConnectResult<Io, St, Codec, Out>>,
+        Codec: Decoder + Encoder,
+        Out: Stream<Item = <Codec as Encoder>::Item>,
     {
-        self.disconnect = Some(Rc::new(disconnect));
-        self
+        Builder {
+            connect: connect.into_service(),
+            _t: PhantomData,
+        }
     }
 
     /// Provide stream items handler service and construct service factory.
-    pub fn finish<F, T>(self, service: F) -> FramedServiceImpl<St, C, T, Io, Codec, Err>
+    pub fn build<F, T>(self, service: F) -> FramedServiceImpl<St, C, T, Io, Codec, Out>
     where
         F: IntoServiceFactory<T>,
         T: ServiceFactory<
             Config = St,
-            Request = RequestItem<St, Codec, Err>,
+            Request = RequestItem<Codec>,
             Response = ResponseItem<Codec>,
-            Error = Err,
-            InitError = Err,
+            Error = C::Error,
+            InitError = C::Error,
         >,
     {
         FramedServiceImpl {
             connect: self.connect,
             handler: Rc::new(service.into_factory()),
-            disconnect: self.disconnect.clone(),
             _t: PhantomData,
         }
     }
 }
 
-pub struct NewServiceBuilder<St, C, Io, Codec, Err> {
+/// Service builder - structure that follows the builder pattern
+/// for building instances for framed services.
+pub struct FactoryBuilder<St, C, Io, Codec, Out> {
     connect: C,
-    disconnect: Option<Rc<dyn Fn(&mut St, bool)>>,
-    _t: PhantomData<(St, Io, Codec, Err)>,
+    _t: PhantomData<(St, Io, Codec, Out)>,
 }
 
-impl<St, C, Io, Codec, Err> NewServiceBuilder<St, C, Io, Codec, Err>
+impl<St, C, Io, Codec, Out> FactoryBuilder<St, C, Io, Codec, Out>
 where
-    St: Clone,
     Io: AsyncRead + AsyncWrite,
-    Err: 'static,
     C: ServiceFactory<
         Config = (),
-        Request = Connect<Io, Codec, Err>,
-        Response = ConnectResult<Io, St, Codec, Err>,
-        Error = Err,
+        Request = Connect<Io, Codec>,
+        Response = ConnectResult<Io, St, Codec, Out>,
     >,
-    C::Future: 'static,
     Codec: Decoder + Encoder,
-    <Codec as Encoder>::Item: 'static,
     <Codec as Encoder>::Error: std::fmt::Debug,
+    Out: Stream<Item = <Codec as Encoder>::Item> + Unpin,
 {
-    /// Callback to execute on disconnect
-    ///
-    /// Second parameter indicates error occured during disconnect.
-    pub fn disconnect<F>(mut self, disconnect: F) -> Self
+    /// Construct framed handler new service with specified connect service
+    pub fn new<F>(connect: F) -> FactoryBuilder<St, C, Io, Codec, Out>
     where
-        F: Fn(&mut St, bool) + 'static,
+        F: IntoServiceFactory<C>,
+        Io: AsyncRead + AsyncWrite,
+        C: ServiceFactory<
+            Config = (),
+            Request = Connect<Io, Codec>,
+            Response = ConnectResult<Io, St, Codec, Out>,
+        >,
+        Codec: Decoder + Encoder,
+        Out: Stream<Item = <Codec as Encoder>::Item> + Unpin,
     {
-        self.disconnect = Some(Rc::new(disconnect));
-        self
+        FactoryBuilder {
+            connect: connect.into_factory(),
+            _t: PhantomData,
+        }
     }
 
-    pub fn finish<F, T, Cfg>(self, service: F) -> FramedService<St, C, T, Io, Codec, Err, Cfg>
+    pub fn build<F, T, Cfg>(self, service: F) -> FramedService<St, C, T, Io, Codec, Out, Cfg>
     where
         F: IntoServiceFactory<T>,
         T: ServiceFactory<
-                Config = St,
-                Request = RequestItem<St, Codec, Err>,
-                Response = ResponseItem<Codec>,
-                Error = Err,
-                InitError = Err,
-            > + 'static,
+            Config = St,
+            Request = RequestItem<Codec>,
+            Response = ResponseItem<Codec>,
+            Error = C::Error,
+            InitError = C::Error,
+        >,
     {
         FramedService {
             connect: self.connect,
             handler: Rc::new(service.into_factory()),
-            disconnect: self.disconnect,
             _t: PhantomData,
         }
     }
 }
 
-pub struct FramedService<St, C, T, Io, Codec, Err, Cfg> {
+pub struct FramedService<St, C, T, Io, Codec, Out, Cfg> {
     connect: C,
     handler: Rc<T>,
-    disconnect: Option<Rc<dyn Fn(&mut St, bool)>>,
-    _t: PhantomData<(St, Io, Codec, Err, Cfg)>,
+    _t: PhantomData<(St, Io, Codec, Out, Cfg)>,
 }
 
-impl<St, C, T, Io, Codec, Err, Cfg> ServiceFactory
-    for FramedService<St, C, T, Io, Codec, Err, Cfg>
+impl<St, C, T, Io, Codec, Out, Cfg> ServiceFactory
+    for FramedService<St, C, T, Io, Codec, Out, Cfg>
 where
-    St: Clone + 'static,
     Io: AsyncRead + AsyncWrite,
     C: ServiceFactory<
         Config = (),
-        Request = Connect<Io, Codec, Err>,
-        Response = ConnectResult<Io, St, Codec, Err>,
-        Error = Err,
+        Request = Connect<Io, Codec>,
+        Response = ConnectResult<Io, St, Codec, Out>,
     >,
-    C::Future: 'static,
     T: ServiceFactory<
-            Config = St,
-            Request = RequestItem<St, Codec, Err>,
-            Response = ResponseItem<Codec>,
-            Error = Err,
-            InitError = Err,
-        > + 'static,
+        Config = St,
+        Request = RequestItem<Codec>,
+        Response = ResponseItem<Codec>,
+        Error = C::Error,
+        InitError = C::Error,
+    >,
+    <T::Service as Service>::Error: 'static,
     <T::Service as Service>::Future: 'static,
-    Err: 'static,
     Codec: Decoder + Encoder,
     <Codec as Encoder>::Item: 'static,
     <Codec as Encoder>::Error: std::fmt::Debug,
+    Out: Stream<Item = <Codec as Encoder>::Item> + Unpin,
 {
     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, Err>;
-    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
+    type Service = FramedServiceImpl<St, C::Service, T, Io, Codec, Out>;
+    type Future = FramedServiceResponse<St, C, T, Io, Codec, Out>;
 
     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
-        self.connect
-            .new_service(())
-            .map(move |result| {
-                result.map(move |connect| FramedServiceImpl {
-                    connect,
-                    handler,
-                    disconnect,
-                    _t: PhantomData,
-                })
-            })
-            .boxed_local()
+        FramedServiceResponse {
+            fut: self.connect.new_service(()),
+            handler: self.handler.clone(),
+        }
     }
 }
 
-pub struct FramedServiceImpl<St, C, T, Io, Codec, Err> {
-    connect: C,
-    handler: Rc<T>,
-    disconnect: Option<Rc<dyn Fn(&mut St, bool)>>,
-    _t: PhantomData<(St, Io, Codec, Err)>,
-}
-
-impl<St, C, T, Io, Codec, Err> Service for FramedServiceImpl<St, C, T, Io, Codec, Err>
+#[pin_project::pin_project]
+pub struct FramedServiceResponse<St, C, T, Io, Codec, Out>
 where
-    St: Clone,
     Io: AsyncRead + AsyncWrite,
-    C: Service<
-        Request = Connect<Io, Codec, Err>,
-        Response = ConnectResult<Io, St, Codec, Err>,
-        Error = Err,
+    C: ServiceFactory<
+        Config = (),
+        Request = Connect<Io, Codec>,
+        Response = ConnectResult<Io, St, Codec, Out>,
     >,
-    Err: 'static,
     T: ServiceFactory<
         Config = St,
-        Request = RequestItem<St, Codec, Err>,
+        Request = RequestItem<Codec>,
         Response = ResponseItem<Codec>,
-        Error = Err,
-        InitError = Err,
+        Error = C::Error,
+        InitError = C::Error,
     >,
+    <T::Service as Service>::Error: 'static,
     <T::Service as Service>::Future: 'static,
     Codec: Decoder + Encoder,
     <Codec as Encoder>::Item: 'static,
     <Codec as Encoder>::Error: std::fmt::Debug,
+    Out: Stream<Item = <Codec as Encoder>::Item> + Unpin,
+{
+    #[pin]
+    fut: C::Future,
+    handler: Rc<T>,
+}
+
+impl<St, C, T, Io, Codec, Out> Future for FramedServiceResponse<St, C, T, Io, Codec, Out>
+where
+    Io: AsyncRead + AsyncWrite,
+    C: ServiceFactory<
+        Config = (),
+        Request = Connect<Io, Codec>,
+        Response = ConnectResult<Io, St, Codec, Out>,
+    >,
+    T: ServiceFactory<
+        Config = St,
+        Request = RequestItem<Codec>,
+        Response = ResponseItem<Codec>,
+        Error = C::Error,
+        InitError = C::Error,
+    >,
+    <T::Service as Service>::Error: 'static,
+    <T::Service as Service>::Future: 'static,
+    Codec: Decoder + Encoder,
+    <Codec as Encoder>::Item: 'static,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+    Out: Stream<Item = <Codec as Encoder>::Item> + Unpin,
+{
+    type Output = Result<FramedServiceImpl<St, C::Service, T, Io, Codec, Out>, C::InitError>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.project();
+        let connect = ready!(this.fut.poll(cx))?;
+
+        Poll::Ready(Ok(FramedServiceImpl {
+            connect,
+            handler: this.handler.clone(),
+            _t: PhantomData,
+        }))
+    }
+}
+
+pub struct FramedServiceImpl<St, C, T, Io, Codec, Out> {
+    connect: C,
+    handler: Rc<T>,
+    _t: PhantomData<(St, Io, Codec, Out)>,
+}
+
+impl<St, C, T, Io, Codec, Out> Service for FramedServiceImpl<St, C, T, Io, Codec, Out>
+where
+    Io: AsyncRead + AsyncWrite,
+    C: Service<Request = Connect<Io, Codec>, Response = ConnectResult<Io, St, Codec, Out>>,
+    T: ServiceFactory<
+        Config = St,
+        Request = RequestItem<Codec>,
+        Response = ResponseItem<Codec>,
+        Error = C::Error,
+        InitError = C::Error,
+    >,
+    <T::Service as Service>::Error: 'static,
+    <T::Service as Service>::Future: 'static,
+    Codec: Decoder + Encoder,
+    <Codec as Encoder>::Item: 'static,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+    Out: Stream<Item = <Codec as Encoder>::Item> + Unpin,
 {
     type Request = Io;
     type Response = ();
-    type Error = ServiceError<Err, Codec>;
-    type Future = FramedServiceImplResponse<St, Io, Codec, Err, C, T>;
+    type Error = ServiceError<C::Error, Codec>;
+    type Future = FramedServiceImplResponse<St, Io, Codec, Out, C, T>;
 
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         self.connect.poll_ready(cx).map_err(|e| e.into())
     }
 
     fn call(&mut self, req: Io) -> Self::Future {
-        let (tx, rx) = mpsc::channel();
-        let sink = Sink::new(tx);
         FramedServiceImplResponse {
             inner: FramedServiceImplResponseInner::Connect(
-                self.connect.call(Connect::new(req, sink.clone())),
+                self.connect.call(Connect::new(req)),
                 self.handler.clone(),
-                self.disconnect.clone(),
-                Some(rx),
             ),
         }
     }
 }
 
 #[pin_project::pin_project]
-pub struct FramedServiceImplResponse<St, Io, Codec, Err, C, T>
+pub struct FramedServiceImplResponse<St, Io, Codec, Out, C, T>
 where
-    St: Clone,
-    C: Service<
-        Request = Connect<Io, Codec, Err>,
-        Response = ConnectResult<Io, St, Codec, Err>,
-        Error = Err,
-    >,
-    Err: 'static,
+    C: Service<Request = Connect<Io, Codec>, Response = ConnectResult<Io, St, Codec, Out>>,
     T: ServiceFactory<
         Config = St,
-        Request = RequestItem<St, Codec, Err>,
+        Request = RequestItem<Codec>,
         Response = ResponseItem<Codec>,
-        Error = Err,
-        InitError = Err,
+        Error = C::Error,
+        InitError = C::Error,
     >,
+    <T::Service as Service>::Error: 'static,
     <T::Service as Service>::Future: 'static,
     Io: AsyncRead + AsyncWrite,
     Codec: Encoder + Decoder,
     <Codec as Encoder>::Item: 'static,
     <Codec as Encoder>::Error: std::fmt::Debug,
+    Out: Stream<Item = <Codec as Encoder>::Item> + Unpin,
 {
     #[pin]
-    inner: FramedServiceImplResponseInner<St, Io, Codec, Err, C, T>,
+    inner: FramedServiceImplResponseInner<St, Io, Codec, Out, C, T>,
 }
 
-impl<St, Io, Codec, Err, C, T> Future for FramedServiceImplResponse<St, Io, Codec, Err, C, T>
+impl<St, Io, Codec, Out, C, T> Future for FramedServiceImplResponse<St, Io, Codec, Out, C, T>
 where
-    St: Clone,
-    C: Service<
-        Request = Connect<Io, Codec, Err>,
-        Response = ConnectResult<Io, St, Codec, Err>,
-        Error = Err,
-    >,
-    Err: 'static,
+    C: Service<Request = Connect<Io, Codec>, Response = ConnectResult<Io, St, Codec, Out>>,
     T: ServiceFactory<
         Config = St,
-        Request = RequestItem<St, Codec, Err>,
+        Request = RequestItem<Codec>,
         Response = ResponseItem<Codec>,
-        Error = Err,
-        InitError = Err,
+        Error = C::Error,
+        InitError = C::Error,
     >,
+    <T::Service as Service>::Error: 'static,
     <T::Service as Service>::Future: 'static,
     Io: AsyncRead + AsyncWrite,
     Codec: Encoder + Decoder,
     <Codec as Encoder>::Item: 'static,
     <Codec as Encoder>::Error: std::fmt::Debug,
+    Out: Stream<Item = <Codec as Encoder>::Item> + Unpin,
 {
-    type Output = Result<(), ServiceError<Err, Codec>>;
+    type Output = Result<(), ServiceError<C::Error, Codec>>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let mut this = self.as_mut().project();
@@ -360,102 +337,71 @@ where
 }
 
 #[pin_project::pin_project]
-enum FramedServiceImplResponseInner<St, Io, Codec, Err, C, T>
+enum FramedServiceImplResponseInner<St, Io, Codec, Out, C, T>
 where
-    St: Clone,
-    C: Service<
-        Request = Connect<Io, Codec, Err>,
-        Response = ConnectResult<Io, St, Codec, Err>,
-        Error = Err,
-    >,
-    Err: 'static,
+    C: Service<Request = Connect<Io, Codec>, Response = ConnectResult<Io, St, Codec, Out>>,
     T: ServiceFactory<
         Config = St,
-        Request = RequestItem<St, Codec, Err>,
+        Request = RequestItem<Codec>,
         Response = ResponseItem<Codec>,
-        Error = Err,
-        InitError = Err,
+        Error = C::Error,
+        InitError = C::Error,
     >,
+    <T::Service as Service>::Error: 'static,
     <T::Service as Service>::Future: 'static,
     Io: AsyncRead + AsyncWrite,
     Codec: Encoder + Decoder,
     <Codec as Encoder>::Item: 'static,
     <Codec as Encoder>::Error: std::fmt::Debug,
+    Out: Stream<Item = <Codec as Encoder>::Item> + Unpin,
 {
-    Connect(
-        #[pin] C::Future,
-        Rc<T>,
-        Option<Rc<dyn Fn(&mut St, bool)>>,
-        Option<mpsc::Receiver<ServiceResult<Codec, Err>>>,
-    ),
-    Handler(
-        #[pin] T::Future,
-        Option<ConnectResult<Io, St, Codec, Err>>,
-        Option<Rc<dyn Fn(&mut St, bool)>>,
-        Option<mpsc::Receiver<ServiceResult<Codec, Err>>>,
-    ),
-    Dispatcher(Dispatcher<St, T::Service, Io, Codec, Err>),
+    Connect(#[pin] C::Future, Rc<T>),
+    Handler(#[pin] T::Future, Option<Framed<Io, Codec>>, Option<Out>),
+    Dispatcher(Dispatcher<T::Service, Io, Codec, Out>),
 }
 
-impl<St, Io, Codec, Err, C, T> FramedServiceImplResponseInner<St, Io, Codec, Err, C, T>
+impl<St, Io, Codec, Out, C, T> FramedServiceImplResponseInner<St, Io, Codec, Out, C, T>
 where
-    St: Clone,
-    C: Service<
-        Request = Connect<Io, Codec, Err>,
-        Response = ConnectResult<Io, St, Codec, Err>,
-        Error = Err,
-    >,
-    Err: 'static,
+    C: Service<Request = Connect<Io, Codec>, Response = ConnectResult<Io, St, Codec, Out>>,
     T: ServiceFactory<
         Config = St,
-        Request = RequestItem<St, Codec, Err>,
+        Request = RequestItem<Codec>,
         Response = ResponseItem<Codec>,
-        Error = Err,
-        InitError = Err,
+        Error = C::Error,
+        InitError = C::Error,
     >,
+    <T::Service as Service>::Error: 'static,
     <T::Service as Service>::Future: 'static,
     Io: AsyncRead + AsyncWrite,
     Codec: Encoder + Decoder,
     <Codec as Encoder>::Item: 'static,
     <Codec as Encoder>::Error: std::fmt::Debug,
+    Out: Stream<Item = <Codec as Encoder>::Item> + Unpin,
 {
     #[project]
     fn poll(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Either<
-        FramedServiceImplResponseInner<St, Io, Codec, Err, C, T>,
-        Poll<Result<(), ServiceError<Err, Codec>>>,
+        FramedServiceImplResponseInner<St, Io, Codec, Out, C, T>,
+        Poll<Result<(), ServiceError<C::Error, Codec>>>,
     > {
         #[project]
         match self.project() {
-            FramedServiceImplResponseInner::Connect(fut, handler, disconnect, rx) => {
-                match fut.poll(cx) {
-                    Poll::Ready(Ok(res)) => {
-                        Either::Left(FramedServiceImplResponseInner::Handler(
-                            handler.new_service(res.state.clone()),
-                            Some(res),
-                            disconnect.take(),
-                            rx.take(),
-                        ))
-                    }
-                    Poll::Pending => Either::Right(Poll::Pending),
-                    Poll::Ready(Err(e)) => Either::Right(Poll::Ready(Err(e.into()))),
-                }
-            }
-            FramedServiceImplResponseInner::Handler(fut, res, disconnect, rx) => {
+            FramedServiceImplResponseInner::Connect(fut, handler) => match fut.poll(cx) {
+                Poll::Ready(Ok(res)) => Either::Left(FramedServiceImplResponseInner::Handler(
+                    handler.new_service(res.state),
+                    Some(res.framed),
+                    res.out,
+                )),
+                Poll::Pending => Either::Right(Poll::Pending),
+                Poll::Ready(Err(e)) => Either::Right(Poll::Ready(Err(e.into()))),
+            },
+            FramedServiceImplResponseInner::Handler(fut, framed, out) => {
                 match fut.poll(cx) {
                     Poll::Ready(Ok(handler)) => {
-                        let res = res.take().unwrap();
                         Either::Left(FramedServiceImplResponseInner::Dispatcher(
-                            Dispatcher::new(
-                                res.framed,
-                                res.state,
-                                handler,
-                                res.sink,
-                                rx.take().unwrap(),
-                                disconnect.take(),
-                            ),
+                            Dispatcher::new(framed.take().unwrap(), handler, out.take()),
                         ))
                     }
                     Poll::Pending => Either::Right(Poll::Pending),

actix-ioframe/src/sink.rs

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

actix-ioframe/tests/test_server.rs

@@ -1,43 +1,49 @@
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::Arc;
-use std::time::Duration;
+use std::cell::Cell;
+use std::rc::Rc;
 
 use actix_codec::BytesCodec;
-use actix_rt::time::delay_for;
-use actix_service::{fn_service, Service};
+use actix_service::{fn_factory_with_config, fn_service, IntoService, Service};
 use actix_testing::TestServer;
+use actix_utils::mpsc;
+use bytes::{Bytes, BytesMut};
 use futures::future::ok;
 
-use actix_ioframe::{Builder, Connect};
+use actix_ioframe::{Builder, Connect, FactoryBuilder};
 
 #[derive(Clone)]
-struct State;
+struct State(Option<mpsc::Sender<Bytes>>);
 
 #[actix_rt::test]
-async fn test_disconnect() -> std::io::Result<()> {
-    let disconnect = Arc::new(AtomicBool::new(false));
-    let disconnect1 = disconnect.clone();
+async fn test_basic() {
+    let client_item = Rc::new(Cell::new(false));
 
     let srv = TestServer::with(move || {
-        let disconnect1 = disconnect1.clone();
-
-        Builder::new()
-            .factory(fn_service(|conn: Connect<_, _, _>| {
-                ok(conn.codec(BytesCodec).state(State))
-            }))
-            .disconnect(move |_, _| {
-                disconnect1.store(true, Ordering::Relaxed);
-            })
-            .finish(fn_service(|_t| ok(None)))
+        FactoryBuilder::new(fn_service(|conn: Connect<_, _>| {
+            ok(conn.codec(BytesCodec).state(State(None)))
+        }))
+        // echo
+        .build(fn_service(|t: BytesMut| ok(Some(t.freeze()))))
     });
 
-    let mut client = Builder::new()
-        .service(|conn: Connect<_, _, _>| {
-            let conn = conn.codec(BytesCodec).state(State);
-            conn.sink().close();
-            ok(conn)
+    let item = client_item.clone();
+    let mut client = Builder::new(fn_service(move |conn: Connect<_, _>| {
+        async move {
+            let (tx, rx) = mpsc::channel();
+            let _ = tx.send(Bytes::from_static(b"Hello"));
+            Ok(conn.codec(BytesCodec).out(rx).state(State(Some(tx))))
+        }
+    }))
+    .build(fn_factory_with_config(move |mut cfg: State| {
+        let item = item.clone();
+        ok((move |t: BytesMut| {
+            assert_eq!(t.freeze(), Bytes::from_static(b"Hello"));
+            item.set(true);
+            // drop Sender, which will close connection
+            cfg.0.take();
+            ok::<_, ()>(None)
         })
-        .finish(fn_service(|_t| ok(None)));
+        .into_service())
+    }));
 
     let conn = actix_connect::default_connector()
         .call(actix_connect::Connect::with(String::new(), srv.addr()))
@@ -45,8 +51,5 @@ async fn test_disconnect() -> std::io::Result<()> {
         .unwrap();
 
     client.call(conn.into_parts().0).await.unwrap();
-    let _ = delay_for(Duration::from_millis(100)).await;
-    assert!(disconnect.load(Ordering::Relaxed));
-
-    Ok(())
+    assert!(client_item.get());
 }

actix-macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-macros"
-version = "0.1.0"
+version = "0.1.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix runtime macros"
 repository = "https://github.com/actix/actix-net"

actix-macros/LICENSE-APACHE

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

actix-macros/LICENSE-MIT

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

actix-macros/src/lib.rs

@@ -71,7 +71,7 @@ pub fn test(_: TokenStream, item: TokenStream) -> TokenStream {
     if input.sig.asyncness.is_none() {
         return syn::Error::new_spanned(
             input.sig.fn_token,
-            format!("only async fn is supported, {:?}", input.sig.ident),
+            format!("only async fn is supported, {}", input.sig.ident),
         )
         .to_compile_error()
         .into();

actix-rt/Cargo.toml

@@ -10,7 +10,6 @@ documentation = "https://docs.rs/actix-rt/"
 categories = ["network-programming", "asynchronous"]
 license = "MIT/Apache-2.0"
 edition = "2018"
-workspace = ".."
 
 [lib]
 name = "actix_rt"
@@ -21,4 +20,4 @@ actix-macros = "0.1.0"
 actix-threadpool = "0.3"
 futures = "0.3.1"
 copyless = "0.1.4"
-tokio = { version = "0.2.4", default-features=false, features = ["rt-core", "rt-util", "io-driver", "tcp", "uds", "udp", "time", "signal", "stream"] }
+tokio = { version = "0.2.6", default-features=false, features = ["rt-core", "rt-util", "io-driver", "tcp", "uds", "udp", "time", "signal", "stream"] }

actix-server/CHANGES.md

@@ -1,5 +1,18 @@
 # Changes
 
+## [1.0.1] - 2019-12-29
+
+### Changed
+
+* Rename `.start()` method to `.run()`
+
+## [1.0.0] - 2019-12-11
+
+### Changed
+
+* Use actix-net releases
+
+
 ## [1.0.0-alpha.4] - 2019-12-08
 
 ### Changed

actix-server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-server"
-version = "1.0.0-alpha.4"
+version = "1.0.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix server - General purpose tcp server"
 keywords = ["network", "framework", "async", "futures"]
@@ -21,13 +21,13 @@ path = "src/lib.rs"
 default = []
 
 [dependencies]
-actix-service = "1.0.0"
+actix-service = "1.0.1"
 actix-rt = "1.0.0"
 actix-codec = "0.2.0"
-actix-utils = "1.0.0-alpha.3"
+actix-utils = "1.0.4"
 
 log = "0.4"
-num_cpus = "1.0"
+num_cpus = "1.11"
 mio = "0.6.19"
 net2 = "0.2"
 futures = "0.3.1"
@@ -38,5 +38,5 @@ mio-uds = { version = "0.6.7" }
 
 [dev-dependencies]
 bytes = "0.5"
-env_logger = "0.6"
-actix-testing = "1.0.0-alpha.3"
+env_logger = "0.7"
+actix-testing = "1.0.0"

actix-server/src/builder.rs

@@ -31,7 +31,7 @@ pub struct ServerBuilder {
     backlog: i32,
     workers: Vec<(usize, WorkerClient)>,
     services: Vec<Box<dyn InternalServiceFactory>>,
-    sockets: Vec<(Token, StdListener)>,
+    sockets: Vec<(Token, String, StdListener)>,
     accept: AcceptLoop,
     exit: bool,
     shutdown_timeout: Duration,
@@ -146,8 +146,8 @@ impl ServerBuilder {
             let mut srv = ConfiguredService::new(apply);
             for (name, lst) in cfg.services {
                 let token = self.token.next();
-                srv.stream(token, name, lst.local_addr()?);
-                self.sockets.push((token, StdListener::Tcp(lst)));
+                srv.stream(token, name.clone(), lst.local_addr()?);
+                self.sockets.push((token, name, StdListener::Tcp(lst)));
             }
             self.services.push(Box::new(srv));
         }
@@ -172,7 +172,8 @@ impl ServerBuilder {
                 factory.clone(),
                 lst.local_addr()?,
             ));
-            self.sockets.push((token, StdListener::Tcp(lst)));
+            self.sockets
+                .push((token, name.as_ref().to_string(), StdListener::Tcp(lst)));
         }
         Ok(self)
     }
@@ -222,7 +223,8 @@ impl ServerBuilder {
             factory.clone(),
             addr,
         ));
-        self.sockets.push((token, StdListener::Uds(lst)));
+        self.sockets
+            .push((token, name.as_ref().to_string(), StdListener::Uds(lst)));
         Ok(self)
     }
 
@@ -243,36 +245,18 @@ impl ServerBuilder {
             factory,
             lst.local_addr()?,
         ));
-        self.sockets.push((token, StdListener::Tcp(lst)));
+        self.sockets
+            .push((token, name.as_ref().to_string(), StdListener::Tcp(lst)));
         Ok(self)
     }
 
-    /// Spawn new thread and start listening for incoming connections.
-    ///
-    /// This method spawns new thread and starts new actix system. Other than
-    /// that it is similar to `start()` method. This method blocks.
-    ///
-    /// This methods panics if no socket addresses get bound.
-    ///
-    /// ```rust,ignore
-    /// use actix_web::*;
-    ///
-    /// fn main() -> std::io::Result<()> {
-    ///     Server::new().
-    ///         .service(
-    ///            HttpServer::new(|| App::new().service(web::service("/").to(|| HttpResponse::Ok())))
-    ///                .bind("127.0.0.1:0")
-    ///         .run()
-    /// }
-    /// ```
-    pub fn run(self) -> io::Result<()> {
-        let sys = System::new("http-server");
-        self.start();
-        sys.run()
+    #[doc(hidden)]
+    pub fn start(self) -> Server {
+        self.run()
     }
 
     /// Starts processing incoming connections and return server controller.
-    pub fn start(mut self) -> Server {
+    pub fn run(mut self) -> Server {
         if self.sockets.is_empty() {
             panic!("Server should have at least one bound socket");
         } else {
@@ -288,10 +272,15 @@ impl ServerBuilder {
 
             // start accept thread
             for sock in &self.sockets {
-                info!("Starting server on {}", sock.1);
+                info!("Starting \"{}\" service on {}", sock.1, sock.2);
             }
-            self.accept
-                .start(mem::replace(&mut self.sockets, Vec::new()), workers);
+            self.accept.start(
+                mem::replace(&mut self.sockets, Vec::new())
+                    .into_iter()
+                    .map(|t| (t.0, t.2))
+                    .collect(),
+                workers,
+            );
 
             // handle signals
             if !self.no_signals {
@@ -391,7 +380,7 @@ impl ServerBuilder {
                                             .await;
                                             System::current().stop();
                                         }
-                                            .boxed(),
+                                        .boxed(),
                                     );
                                 }
                                 ready(())

actix-server/src/config.rs

@@ -153,7 +153,7 @@ impl InternalServiceFactory for ConfiguredService {
             }
             return Ok(res);
         }
-            .boxed_local()
+        .boxed_local()
     }
 }
 
@@ -280,6 +280,6 @@ where
                 }
             };
         }
-            .boxed_local()
+        .boxed_local()
     }
 }

actix-server/src/worker.rs

@@ -217,7 +217,7 @@ impl Worker {
                     wrk.await
                 });
             }
-                .boxed(),
+            .boxed(),
         );
 
         WorkerClient::new(idx, tx1, tx2, avail)

actix-service/CHANGES.md

@@ -1,5 +1,12 @@
 # Changes
 
+## [1.0.1] - 2019-12-22
+
+### Changed
+
+* `map_config()` and `unit_config()` accepts `IntoServiceFactory` type
+
+
 ## [1.0.0] - 2019-12-11
 
 ### Added

actix-service/Cargo.toml

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

actix-service/src/map_config.rs

@@ -1,28 +1,30 @@
 use std::marker::PhantomData;
 
-use super::ServiceFactory;
+use super::{IntoServiceFactory, ServiceFactory};
 
 /// Adapt external config argument to a config for provided service factory
 ///
 /// Note that this function consumes the receiving service factory and returns
 /// a wrapped version of it.
-pub fn map_config<T, F, C>(factory: T, f: F) -> MapConfig<T, F, C>
+pub fn map_config<T, U, F, C>(factory: U, f: F) -> MapConfig<T, F, C>
 where
     T: ServiceFactory,
+    U: IntoServiceFactory<T>,
     F: Fn(C) -> T::Config,
 {
-    MapConfig::new(factory, f)
+    MapConfig::new(factory.into_factory(), f)
 }
 
 /// Replace config with unit
-pub fn unit_config<T, C>(new_service: T) -> UnitConfig<T, C>
+pub fn unit_config<T, U, C>(factory: U) -> UnitConfig<T, C>
 where
     T: ServiceFactory<Config = ()>,
+    U: IntoServiceFactory<T>,
 {
-    UnitConfig::new(new_service)
+    UnitConfig::new(factory.into_factory())
 }
 
-/// `.map_config()` service combinator
+/// `map_config()` adapter service factory
 pub struct MapConfig<A, F, C> {
     a: A,
     f: F,

actix-testing/CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+## [1.0.0] - 2019-12-11
+
+* Update actix-server to 1.0.0
+
 ## [1.0.0-alpha.3] - 2019-12-07
 
 * Migrate to tokio 0.2

actix-testing/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-testing"
-version = "1.0.0-alpha.3"
+version = "1.0.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix testing utils"
 keywords = ["network", "framework", "async", "futures"]
@@ -19,7 +19,7 @@ path = "src/lib.rs"
 [dependencies]
 actix-rt = "1.0.0"
 actix-macros = "0.1.0"
-actix-server = "1.0.0-alpha.3"
+actix-server = "1.0.0"
 actix-service = "1.0.0"
 
 log = "0.4"

actix-threadpool/CHANGES.md

@@ -1,5 +1,11 @@
 # Changes
 
+## [0.3.1] - 2019-12-12
+
+### Changed
+
+* Use parking_lot 0.10
+
 ## [0.3.0] - 2019-12-02
 
 ### Changed

actix-threadpool/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-threadpool"
-version = "0.3.0"
+version = "0.3.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix thread pool for sync code"
 keywords = ["actix", "network", "framework", "async", "futures"]
@@ -19,9 +19,9 @@ path = "src/lib.rs"
 
 [dependencies]
 derive_more = "0.99.2"
-futures = "0.3.1"
-parking_lot = "0.9"
-lazy_static = "1.2"
+futures-channel = "0.3.1"
+parking_lot = "0.10"
+lazy_static = "1.3"
 log = "0.4"
 num_cpus = "1.10"
 threadpool = "1.7"

actix-threadpool/src/lib.rs

@@ -6,7 +6,7 @@ use std::pin::Pin;
 use std::task::{Context, Poll};
 
 use derive_more::Display;
-use futures::channel::oneshot;
+use futures_channel::oneshot;
 use parking_lot::Mutex;
 use threadpool::ThreadPool;
 
@@ -79,9 +79,12 @@ impl<I, E: fmt::Debug> Future for CpuFuture<I, E> {
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let rx = Pin::new(&mut self.rx);
-        let res = futures::ready!(rx.poll(cx))
-            .map_err(|_| BlockingError::Canceled)
-            .and_then(|res| res.map_err(BlockingError::Error));
+        let res = match rx.poll(cx) {
+            Poll::Pending => return Poll::Pending,
+            Poll::Ready(res) => res
+                .map_err(|_| BlockingError::Canceled)
+                .and_then(|res| res.map_err(BlockingError::Error)),
+        };
         Poll::Ready(res)
     }
 }

actix-tls/CHANGES.md

@@ -1,6 +1,10 @@
 # Changes
 
-[1.0.0-alpha.3] - 2019-12-07
+## [1.0.0] - 2019-12-11
+
+* 1.0.0 release
+
+## [1.0.0-alpha.3] - 2019-12-07
 
 ### Changed
 

actix-tls/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-tls"
-version = "1.0.0-alpha.3"
+version = "1.0.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix tls services"
 keywords = ["network", "framework", "async", "futures"]
@@ -34,7 +34,7 @@ nativetls = ["native-tls", "tokio-tls"]
 [dependencies]
 actix-service = "1.0.0"
 actix-codec = "0.2.0"
-actix-utils = "1.0.0-alpha.3"
+actix-utils = "1.0.0"
 actix-rt = "1.0.0"
 derive_more = "0.99.2"
 either = "1.5.2"
@@ -57,4 +57,4 @@ tokio-tls = { version="0.3", optional = true }
 
 [dev-dependencies]
 bytes = "0.5"
-actix-testing = { version="1.0.0-alpha.3" }
+actix-testing = { version="1.0.0" }

actix-tls/src/openssl.rs

@@ -88,7 +88,7 @@ impl<T: AsyncRead + AsyncWrite + Unpin + 'static> Service for AcceptorService<T>
                 let acc = acc;
                 tokio_openssl::accept(&acc, req).await
             }
-                .boxed_local(),
+            .boxed_local(),
         }
     }
 }

actix-utils/CHANGES.md

@@ -1,5 +1,23 @@
 # Changes
 
+## [1.0.4] - 2019-12-20
+
+* Add methods to check `LocalWaker` registration state.
+
+## [1.0.3] - 2019-12-11
+
+* Revert InOrder service changes
+
+## [1.0.2] - 2019-12-11
+
+* Allow to create `framed::Dispatcher` with custom `mpsc::Receiver`
+
+* Add `oneshot::Sender::is_canceled()` method
+
+## [1.0.1] - 2019-12-11
+
+* Optimize InOrder service
+
 ## [1.0.0] - 2019-12-11
 
 * Simplify oneshot and mpsc implementations

actix-utils/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-utils"
-version = "1.0.0"
+version = "1.0.4"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix utils - various actix net related services"
 keywords = ["network", "framework", "async", "futures"]
@@ -10,7 +10,6 @@ documentation = "https://docs.rs/actix-utils/"
 categories = ["network-programming", "asynchronous"]
 license = "MIT/Apache-2.0"
 edition = "2018"
-workspace = ".."
 
 [lib]
 name = "actix_utils"
@@ -20,8 +19,8 @@ path = "src/lib.rs"
 actix-service = "1.0.0"
 actix-rt = "1.0.0"
 actix-codec = "0.2.0"
-bytes = "0.5.2"
-either = "1.5.2"
+bytes = "0.5.3"
+either = "1.5.3"
 futures = "0.3.1"
 pin-project = "0.4.6"
 log = "0.4"

actix-utils/src/framed.rs

@@ -127,30 +127,44 @@ where
         }
     }
 
+    /// Construct new `Dispatcher` instance with customer `mpsc::Receiver`
+    pub fn with_rx<F: IntoService<S>>(
+        framed: Framed<T, U>,
+        service: F,
+        rx: mpsc::Receiver<Result<Message<<U as Encoder>::Item>, S::Error>>,
+    ) -> Self {
+        let tx = rx.sender();
+        Dispatcher {
+            framed,
+            rx,
+            tx,
+            service: service.into_service(),
+            state: State::Processing,
+        }
+    }
+
     /// Get sink
     pub fn get_sink(&self) -> mpsc::Sender<Result<Message<<U as Encoder>::Item>, S::Error>> {
         self.tx.clone()
     }
 
-    /// Get reference to a service wrapped by `FramedTransport` instance.
+    /// Get reference to a service wrapped by `Dispatcher` instance.
     pub fn get_ref(&self) -> &S {
         &self.service
     }
 
-    /// Get mutable reference to a service wrapped by `FramedTransport`
-    /// instance.
+    /// Get mutable reference to a service wrapped by `Dispatcher` instance.
     pub fn get_mut(&mut self) -> &mut S {
         &mut self.service
     }
 
-    /// Get reference to a framed instance wrapped by `FramedTransport`
+    /// Get reference to a framed instance wrapped by `Dispatcher`
     /// instance.
     pub fn get_framed(&self) -> &Framed<T, U> {
         &self.framed
     }
 
-    /// Get mutable reference to a framed instance wrapped by `FramedTransport`
-    /// instance.
+    /// Get mutable reference to a framed instance wrapped by `Dispatcher` instance.
     pub fn get_framed_mut(&mut self) -> &mut Framed<T, U> {
         &mut self.framed
     }

actix-utils/src/oneshot.rs

@@ -67,6 +67,12 @@ impl<T> Sender<T> {
             Err(val)
         }
     }
+
+    /// Tests to see whether this `Sender`'s corresponding `Receiver`
+    /// has gone away.
+    pub fn is_canceled(&self) -> bool {
+        self.inner.strong_count() == 1
+    }
 }
 
 impl<T> Drop for Sender<T> {
@@ -110,7 +116,9 @@ mod tests {
         assert_eq!(rx.await.unwrap(), "test");
 
         let (tx, rx) = channel();
+        assert!(!tx.is_canceled());
         drop(rx);
+        assert!(tx.is_canceled());
         assert!(tx.send("test").is_err());
 
         let (tx, rx) = channel::<&'static str>();

actix-utils/src/order.rs

@@ -105,7 +105,7 @@ where
 
 pub struct InOrderService<S: Service> {
     service: S,
-    task: Rc<LocalWaker>,
+    waker: Rc<LocalWaker>,
     acks: VecDeque<Record<S::Response, S::Error>>,
 }
 
@@ -123,7 +123,7 @@ where
         Self {
             service: service.into_service(),
             acks: VecDeque::new(),
-            task: Rc::new(LocalWaker::new()),
+            waker: Rc::new(LocalWaker::new()),
         }
     }
 }
@@ -142,7 +142,7 @@ where
 
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         // poll_ready could be called from different task
-        self.task.register(cx.waker());
+        self.waker.register(cx.waker());
 
         // check acks
         while !self.acks.is_empty() {
@@ -172,11 +172,11 @@ where
         let (tx2, rx2) = oneshot::channel();
         self.acks.push_back(Record { rx: rx1, tx: tx2 });
 
-        let task = self.task.clone();
+        let waker = self.waker.clone();
         let fut = self.service.call(request);
         actix_rt::spawn(async move {
             let res = fut.await;
-            task.wake();
+            waker.wake();
             let _ = tx1.send(res);
         });
 
@@ -211,7 +211,7 @@ mod tests {
     use super::*;
     use actix_service::Service;
     use futures::channel::oneshot;
-    use futures::future::{lazy, FutureExt, LocalBoxFuture};
+    use futures::future::{lazy, poll_fn, FutureExt, LocalBoxFuture};
 
     struct Srv;
 
@@ -245,15 +245,18 @@ mod tests {
             let _ = actix_rt::System::new("test").block_on(async {
                 let mut srv = InOrderService::new(Srv);
 
+                let _ = lazy(|cx| srv.poll_ready(cx)).await;
                 let res1 = srv.call(rx1);
                 let res2 = srv.call(rx2);
                 let res3 = srv.call(rx3);
 
-                let _ = lazy(|cx| srv.poll_ready(cx)).await;
-
-                // dispatcher do this
-                actix_rt::time::delay_for(Duration::from_millis(100)).await;
-                let _ = lazy(|cx| srv.poll_ready(cx)).await;
+                actix_rt::spawn(async move {
+                    let _ = poll_fn(|cx| {
+                        let _ = srv.poll_ready(cx);
+                        Poll::<()>::Pending
+                    })
+                    .await;
+                });
 
                 assert_eq!(res1.await.unwrap(), 1);
                 assert_eq!(res2.await.unwrap(), 2);

actix-utils/src/task.rs

@@ -34,11 +34,22 @@ impl LocalWaker {
         }
     }
 
+    #[inline]
+    /// Check if waker has been registered.
+    pub fn is_registed(&self) -> bool {
+        unsafe { (*self.waker.get()).is_some() }
+    }
+
     #[inline]
     /// Registers the waker to be notified on calls to `wake`.
-    pub fn register(&self, waker: &Waker) {
+    ///
+    /// Returns `true` if waker was registered before.
+    pub fn register(&self, waker: &Waker) -> bool {
         unsafe {
-            *self.waker.get() = Some(waker.clone());
+            let w = self.waker.get();
+            let is_registered = (*w).is_some();
+            *w = Some(waker.clone());
+            is_registered
         }
     }
 

router/CHANGES.txt

@@ -1,5 +1,23 @@
 # Changes
 
+## [0.3.0] - 2019-12-31
+
+* Support named parameters for `ResourceDef::resource_path()` in form of `((&k, &v), ...)`
+
+## [0.2.3] - 2019-12-25
+
+* Add impl `IntoPattern` for `&String`
+
+## [0.2.2] - 2019-12-25
+
+* Use `IntoPattern` for `RouterBuilder::path()`
+
+## [0.2.1] - 2019-12-25
+
+* Add `IntoPattern` trait
+
+* Add multi-pattern resources
+
 ## [0.2.0] - 2019-12-07
 
 * Update http to 0.2

router/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-router"
-version = "0.2.0"
+version = "0.3.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Path router"
 keywords = ["actix"]
@@ -8,9 +8,7 @@ homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-net.git"
 documentation = "https://docs.rs/actix-router/"
 license = "MIT/Apache-2.0"
-exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
 edition = "2018"
-workspace = ".."
 
 [lib]
 name = "actix_router"
@@ -20,10 +18,11 @@ path = "src/lib.rs"
 default = ["http"]
 
 [dependencies]
+bytestring = "0.1.2"
+either = "1.5.3"
 regex = "1.3.1"
-serde = "1.0.80"
-bytestring = "0.1.0"
 log = "0.4.8"
+serde = "1.0.104"
 http = { version="0.2.0", optional=true }
 
 [dev-dependencies]

router/src/de.rs

@@ -492,7 +492,7 @@ mod tests {
 
     #[derive(Deserialize)]
     struct Id {
-        id: String,
+        _id: String,
     }
 
     #[derive(Debug, Deserialize)]

router/src/lib.rs

@@ -4,6 +4,8 @@ mod path;
 mod resource;
 mod router;
 
+use either::Either;
+
 pub use self::de::PathDeserializer;
 pub use self::path::Path;
 pub use self::resource::ResourceDef;
@@ -35,6 +37,221 @@ impl ResourcePath for bytestring::ByteString {
     }
 }
 
+pub trait ResourceElements {
+    fn elements<F, R>(self, for_each: F) -> Option<R>
+    where
+        F: FnMut(Either<&str, (&str, &str)>) -> Option<R>;
+}
+
+impl<'a, T: AsRef<str>> ResourceElements for &'a [T] {
+    fn elements<F, R>(self, mut for_each: F) -> Option<R>
+    where
+        F: FnMut(Either<&str, (&str, &str)>) -> Option<R>,
+    {
+        for t in self {
+            if let Some(res) = for_each(Either::Left(t.as_ref())) {
+                return Some(res);
+            }
+        }
+        None
+    }
+}
+
+impl<'a, U, I> ResourceElements for &'a U
+where
+    &'a U: IntoIterator<Item = I>,
+    I: AsRef<str>,
+{
+    fn elements<F, R>(self, mut for_each: F) -> Option<R>
+    where
+        F: FnMut(Either<&str, (&str, &str)>) -> Option<R>,
+    {
+        for t in self.into_iter() {
+            if let Some(res) = for_each(Either::Left(t.as_ref())) {
+                return Some(res);
+            }
+        }
+        None
+    }
+}
+
+impl<I> ResourceElements for Vec<I>
+where
+    I: AsRef<str>,
+{
+    fn elements<F, R>(self, mut for_each: F) -> Option<R>
+    where
+        F: FnMut(Either<&str, (&str, &str)>) -> Option<R>,
+    {
+        for t in self.iter() {
+            if let Some(res) = for_each(Either::Left(t.as_ref())) {
+                return Some(res);
+            }
+        }
+        None
+    }
+}
+
+impl<'a, K, V, S> ResourceElements for std::collections::HashMap<K, V, S>
+where
+    K: AsRef<str>,
+    V: AsRef<str>,
+    S: std::hash::BuildHasher,
+{
+    fn elements<F, R>(self, mut for_each: F) -> Option<R>
+    where
+        F: FnMut(Either<&str, (&str, &str)>) -> Option<R>,
+    {
+        for t in self.iter() {
+            if let Some(res) = for_each(Either::Right((t.0.as_ref(), t.1.as_ref()))) {
+                return Some(res);
+            }
+        }
+        None
+    }
+}
+
+#[rustfmt::skip]
+mod _m {
+use super::*;
+// macro_rules! elements_tuple ({ $(($n:tt, $T:ident)),+} => {
+//     impl<$($T: AsRef<str>,)+> ResourceElements for ($($T,)+) {
+//         fn elements<F_, R_>(self, mut for_each: F_) -> Option<R_>
+//         where
+//             F_: FnMut(Either<&str, (&str, &str)>) -> Option<R_>,
+//         {
+//             $(
+//                 if let Some(res) = for_each(Either::Left(self.$n.as_ref())) {
+//                     return Some(res)
+//                 }
+//             )+
+//                 None
+//         }
+//     }
+// });
+
+macro_rules! elements_2tuple ({ $(($n:tt, $V:ident)),+} => {
+    impl<'a, $($V: AsRef<str>,)+> ResourceElements for ($((&'a str, $V),)+) {
+        fn elements<F_, R_>(self, mut for_each: F_) -> Option<R_>
+        where
+            F_: FnMut(Either<&str, (&str, &str)>) -> Option<R_>,
+        {
+            $(
+                if let Some(res) = for_each(Either::Right((self.$n.0, self.$n.1.as_ref()))) {
+                    return Some(res)
+                }
+            )+
+                None
+        }
+    }
+});
+
+elements_2tuple!((0, A));
+elements_2tuple!((0, A), (1, B));
+elements_2tuple!((0, A), (1, B), (2, C));
+elements_2tuple!((0, A), (1, B), (2, C), (3, D));
+elements_2tuple!((0, A), (1, B), (2, C), (3, D), (4, E));
+elements_2tuple!((0, A), (1, B), (2, C), (3, D), (4, E), (5, F));
+elements_2tuple!((0, A), (1, B), (2, C), (3, D), (4, E), (5, F), (6, G));
+elements_2tuple!((0, A), (1, B), (2, C), (3, D), (4, E), (5, F), (6, G), (7, H));
+elements_2tuple!((0, A), (1, B), (2, C), (3, D), (4, E), (5, F), (6, G), (7, H), (8, I));
+elements_2tuple!((0, A), (1, B), (2, C), (3, D), (4, E), (5, F), (6, G), (7, H), (8, I), (9, J));
+}
+
+/// Helper trait for type that could be converted to path pattern
+pub trait IntoPattern {
+    /// Signle patter
+    fn is_single(&self) -> bool;
+
+    fn patterns(&self) -> Vec<String>;
+}
+
+impl IntoPattern for String {
+    fn is_single(&self) -> bool {
+        true
+    }
+
+    fn patterns(&self) -> Vec<String> {
+        vec![self.clone()]
+    }
+}
+
+impl<'a> IntoPattern for &'a String {
+    fn is_single(&self) -> bool {
+        true
+    }
+
+    fn patterns(&self) -> Vec<String> {
+        vec![self.as_str().to_string()]
+    }
+}
+
+impl<'a> IntoPattern for &'a str {
+    fn is_single(&self) -> bool {
+        true
+    }
+
+    fn patterns(&self) -> Vec<String> {
+        vec![self.to_string()]
+    }
+}
+
+impl<T: AsRef<str>> IntoPattern for Vec<T> {
+    fn is_single(&self) -> bool {
+        self.len() == 1
+    }
+
+    fn patterns(&self) -> Vec<String> {
+        self.into_iter().map(|v| v.as_ref().to_string()).collect()
+    }
+}
+
+macro_rules! array_patterns (($tp:ty, $num:tt) => {
+    impl IntoPattern for [$tp; $num] {
+        fn is_single(&self) -> bool {
+            $num == 1
+        }
+
+        fn patterns(&self) -> Vec<String> {
+            self.iter().map(|v| v.to_string()).collect()
+        }
+    }
+});
+
+array_patterns!(&str, 1);
+array_patterns!(&str, 2);
+array_patterns!(&str, 3);
+array_patterns!(&str, 4);
+array_patterns!(&str, 5);
+array_patterns!(&str, 6);
+array_patterns!(&str, 7);
+array_patterns!(&str, 8);
+array_patterns!(&str, 9);
+array_patterns!(&str, 10);
+array_patterns!(&str, 11);
+array_patterns!(&str, 12);
+array_patterns!(&str, 13);
+array_patterns!(&str, 14);
+array_patterns!(&str, 15);
+array_patterns!(&str, 16);
+
+array_patterns!(String, 1);
+array_patterns!(String, 2);
+array_patterns!(String, 3);
+array_patterns!(String, 4);
+array_patterns!(String, 5);
+array_patterns!(String, 6);
+array_patterns!(String, 7);
+array_patterns!(String, 8);
+array_patterns!(String, 9);
+array_patterns!(String, 10);
+array_patterns!(String, 11);
+array_patterns!(String, 12);
+array_patterns!(String, 13);
+array_patterns!(String, 14);
+array_patterns!(String, 15);
+array_patterns!(String, 16);
+
 #[cfg(feature = "http")]
 mod url;
 

router/src/path.rs

@@ -1,5 +1,4 @@
 use std::ops::Index;
-use std::rc::Rc;
 
 use serde::de;
 
@@ -19,7 +18,7 @@ pub(crate) enum PathItem {
 pub struct Path<T> {
     path: T,
     pub(crate) skip: u16,
-    pub(crate) segments: Vec<(Rc<String>, PathItem)>,
+    pub(crate) segments: Vec<(&'static str, PathItem)>,
 }
 
 impl<T: Default> Default for Path<T> {
@@ -96,7 +95,7 @@ impl<T: ResourcePath> Path<T> {
         self.skip += n;
     }
 
-    pub(crate) fn add(&mut self, name: Rc<String>, value: PathItem) {
+    pub(crate) fn add(&mut self, name: &'static str, value: PathItem) {
         match value {
             PathItem::Static(s) => self.segments.push((name, PathItem::Static(s))),
             PathItem::Segment(begin, end) => self
@@ -106,9 +105,8 @@ impl<T: ResourcePath> Path<T> {
     }
 
     #[doc(hidden)]
-    pub fn add_static(&mut self, name: &str, value: &'static str) {
-        self.segments
-            .push((Rc::new(name.to_string()), PathItem::Static(value)));
+    pub fn add_static(&mut self, name: &'static str, value: &'static str) {
+        self.segments.push((name, PathItem::Static(value)));
     }
 
     #[inline]
@@ -126,7 +124,7 @@ impl<T: ResourcePath> Path<T> {
     /// Get matched parameter by name without type conversion
     pub fn get(&self, key: &str) -> Option<&str> {
         for item in self.segments.iter() {
-            if key == item.0.as_str() {
+            if key == item.0 {
                 return match item.1 {
                     PathItem::Static(ref s) => Some(&s),
                     PathItem::Segment(s, e) => {

router/src/resource.rs

@@ -1,11 +1,11 @@
 use std::cmp::min;
+use std::collections::HashMap;
 use std::hash::{Hash, Hasher};
-use std::rc::Rc;
 
-use regex::{escape, Regex};
+use regex::{escape, Regex, RegexSet};
 
 use crate::path::{Path, PathItem};
-use crate::{Resource, ResourcePath};
+use crate::{IntoPattern, Resource, ResourceElements, ResourcePath};
 
 const MAX_DYNAMIC_SEGMENTS: usize = 16;
 
@@ -31,22 +31,56 @@ enum PatternElement {
 enum PatternType {
     Static(String),
     Prefix(String),
-    Dynamic(Regex, Vec<Rc<String>>, usize),
+    Dynamic(Regex, Vec<&'static str>, usize),
+    DynamicSet(RegexSet, Vec<(Regex, Vec<&'static str>, usize)>),
 }
 
 impl ResourceDef {
     /// Parse path pattern and create new `Pattern` instance.
     ///
-    /// Panics if path pattern is wrong.
-    pub fn new(path: &str) -> Self {
-        ResourceDef::with_prefix(path, false)
+    /// Panics if path pattern is malformed.
+    pub fn new<T: IntoPattern>(path: T) -> Self {
+        if path.is_single() {
+            let patterns = path.patterns();
+            ResourceDef::with_prefix(&patterns[0], false)
+        } else {
+            let set = path.patterns();
+            let mut data = Vec::new();
+            let mut re_set = Vec::new();
+
+            for path in set {
+                let (pattern, _, _, len) = ResourceDef::parse(&path, false);
+
+                let re = match Regex::new(&pattern) {
+                    Ok(re) => re,
+                    Err(err) => panic!("Wrong path pattern: \"{}\" {}", path, err),
+                };
+                // actix creates one router per thread
+                let names: Vec<_> = re
+                    .capture_names()
+                    .filter_map(|name| {
+                        name.map(|name| Box::leak(Box::new(name.to_owned())).as_str())
+                    })
+                    .collect();
+                data.push((re, names, len));
+                re_set.push(pattern);
+            }
+
+            ResourceDef {
+                id: 0,
+                tp: PatternType::DynamicSet(RegexSet::new(re_set).unwrap(), data),
+                elements: Vec::new(),
+                name: String::new(),
+                pattern: "".to_owned(),
+            }
+        }
     }
 
     /// Parse path pattern and create new `Pattern` instance.
     ///
     /// Use `prefix` type instead of `static`.
     ///
-    /// Panics if path regex pattern is wrong.
+    /// Panics if path regex pattern is malformed.
     pub fn prefix(path: &str) -> Self {
         ResourceDef::with_prefix(path, true)
     }
@@ -57,7 +91,7 @@ impl ResourceDef {
     ///
     /// Use `prefix` type instead of `static`.
     ///
-    /// Panics if path regex pattern is wrong.
+    /// Panics if path regex pattern is malformed.
     pub fn root_prefix(path: &str) -> Self {
         ResourceDef::with_prefix(&insert_slash(path), true)
     }
@@ -85,7 +119,9 @@ impl ResourceDef {
             // actix creates one router per thread
             let names = re
                 .capture_names()
-                .filter_map(|name| name.map(|name| Rc::new(name.to_owned())))
+                .filter_map(|name| {
+                    name.map(|name| Box::leak(Box::new(name.to_owned())).as_str())
+                })
                 .collect();
             PatternType::Dynamic(re, names, len)
         } else if for_prefix {
@@ -123,8 +159,9 @@ impl ResourceDef {
     pub fn is_match(&self, path: &str) -> bool {
         match self.tp {
             PatternType::Static(ref s) => s == path,
-            PatternType::Dynamic(ref re, _, _) => re.is_match(path),
             PatternType::Prefix(ref s) => path.starts_with(s),
+            PatternType::Dynamic(ref re, _, _) => re.is_match(path),
+            PatternType::DynamicSet(ref re, _) => re.is_match(path),
         }
     }
 
@@ -176,6 +213,30 @@ impl ResourceDef {
                 };
                 Some(min(plen, len))
             }
+            PatternType::DynamicSet(ref re, ref params) => {
+                if let Some(idx) = re.matches(path).into_iter().next() {
+                    let (ref pattern, _, len) = params[idx];
+                    if let Some(captures) = pattern.captures(path) {
+                        let mut pos = 0;
+                        let mut passed = false;
+                        for capture in captures.iter() {
+                            if let Some(ref m) = capture {
+                                if !passed {
+                                    passed = true;
+                                    continue;
+                                }
+
+                                pos = m.end();
+                            }
+                        }
+                        Some(pos + len)
+                    } else {
+                        None
+                    }
+                } else {
+                    None
+                }
+            }
         }
     }
 
@@ -190,6 +251,25 @@ impl ResourceDef {
                     false
                 }
             }
+            PatternType::Prefix(ref s) => {
+                let rpath = path.path();
+                let len = if s == rpath {
+                    s.len()
+                } else if rpath.starts_with(s)
+                    && (s.ends_with('/') || rpath.split_at(s.len()).1.starts_with('/'))
+                {
+                    if s.ends_with('/') {
+                        s.len() - 1
+                    } else {
+                        s.len()
+                    }
+                } else {
+                    return false;
+                };
+                let rpath_len = rpath.len();
+                path.skip(min(rpath_len, len) as u16);
+                true
+            }
             PatternType::Dynamic(ref re, ref names, len) => {
                 let mut idx = 0;
                 let mut pos = 0;
@@ -219,24 +299,40 @@ impl ResourceDef {
                 path.skip((pos + len) as u16);
                 true
             }
-            PatternType::Prefix(ref s) => {
-                let rpath = path.path();
-                let len = if s == rpath {
-                    s.len()
-                } else if rpath.starts_with(s)
-                    && (s.ends_with('/') || rpath.split_at(s.len()).1.starts_with('/'))
-                {
-                    if s.ends_with('/') {
-                        s.len() - 1
+            PatternType::DynamicSet(ref re, ref params) => {
+                if let Some(idx) = re.matches(path.path()).into_iter().next() {
+                    let (ref pattern, ref names, len) = params[idx];
+                    let mut idx = 0;
+                    let mut pos = 0;
+                    let mut segments: [PathItem; MAX_DYNAMIC_SEGMENTS] =
+                        [PathItem::Static(""); MAX_DYNAMIC_SEGMENTS];
+
+                    if let Some(captures) = pattern.captures(path.path()) {
+                        for (no, name) in names.iter().enumerate() {
+                            if let Some(m) = captures.name(&name) {
+                                idx += 1;
+                                pos = m.end();
+                                segments[no] =
+                                    PathItem::Segment(m.start() as u16, m.end() as u16);
+                            } else {
+                                log::error!(
+                                    "Dynamic path match but not all segments found: {}",
+                                    name
+                                );
+                                return false;
+                            }
+                        }
                     } else {
-                        s.len()
+                        return false;
                     }
+                    for idx in 0..idx {
+                        path.add(names[idx].clone(), segments[idx]);
+                    }
+                    path.skip((pos + len) as u16);
+                    true
                 } else {
-                    return false;
-                };
-                let rpath_len = rpath.len();
-                path.skip(min(rpath_len, len) as u16);
-                true
+                    false
+                }
             }
         }
     }
@@ -263,6 +359,30 @@ impl ResourceDef {
                     false
                 }
             }
+            PatternType::Prefix(ref s) => {
+                let len = {
+                    let rpath = res.resource_path().path();
+                    if s == rpath {
+                        s.len()
+                    } else if rpath.starts_with(s)
+                        && (s.ends_with('/') || rpath.split_at(s.len()).1.starts_with('/'))
+                    {
+                        if s.ends_with('/') {
+                            s.len() - 1
+                        } else {
+                            s.len()
+                        }
+                    } else {
+                        return false;
+                    }
+                };
+                if !check(res, user_data) {
+                    return false;
+                }
+                let path = res.resource_path();
+                path.skip(min(path.path().len(), len) as u16);
+                true
+            }
             PatternType::Dynamic(ref re, ref names, len) => {
                 let mut idx = 0;
                 let mut pos = 0;
@@ -298,57 +418,118 @@ impl ResourceDef {
                 path.skip((pos + len) as u16);
                 true
             }
-            PatternType::Prefix(ref s) => {
-                let len = {
-                    let rpath = res.resource_path().path();
-                    if s == rpath {
-                        s.len()
-                    } else if rpath.starts_with(s)
-                        && (s.ends_with('/') || rpath.split_at(s.len()).1.starts_with('/'))
-                    {
-                        if s.ends_with('/') {
-                            s.len() - 1
-                        } else {
-                            s.len()
+            PatternType::DynamicSet(ref re, ref params) => {
+                let path = res.resource_path().path();
+                if let Some(idx) = re.matches(path).into_iter().next() {
+                    let (ref pattern, ref names, len) = params[idx];
+                    let mut idx = 0;
+                    let mut pos = 0;
+                    let mut segments: [PathItem; MAX_DYNAMIC_SEGMENTS] =
+                        [PathItem::Static(""); MAX_DYNAMIC_SEGMENTS];
+
+                    if let Some(captures) = pattern.captures(path) {
+                        for (no, name) in names.iter().enumerate() {
+                            if let Some(m) = captures.name(&name) {
+                                idx += 1;
+                                pos = m.end();
+                                segments[no] =
+                                    PathItem::Segment(m.start() as u16, m.end() as u16);
+                            } else {
+                                log::error!(
+                                    "Dynamic path match but not all segments found: {}",
+                                    name
+                                );
+                                return false;
+                            }
                         }
                     } else {
                         return false;
                     }
-                };
-                if !check(res, user_data) {
-                    return false;
+
+                    if !check(res, user_data) {
+                        return false;
+                    }
+
+                    let path = res.resource_path();
+                    for idx in 0..idx {
+                        path.add(names[idx].clone(), segments[idx]);
+                    }
+                    path.skip((pos + len) as u16);
+                    true
+                } else {
+                    false
                 }
-                let path = res.resource_path();
-                path.skip(min(path.path().len(), len) as u16);
-                true
             }
         }
     }
 
     /// Build resource path from elements. Returns `true` on success.
-    pub fn resource_path<U, I>(&self, path: &mut String, elements: &mut U) -> bool
-    where
-        U: Iterator<Item = I>,
-        I: AsRef<str>,
-    {
+    pub fn resource_path<U: ResourceElements>(&self, path: &mut String, data: U) -> bool {
         match self.tp {
             PatternType::Prefix(ref p) => path.push_str(p),
             PatternType::Static(ref p) => path.push_str(p),
             PatternType::Dynamic(..) => {
-                for el in &self.elements {
-                    match *el {
-                        PatternElement::Str(ref s) => path.push_str(s),
-                        PatternElement::Var(_) => {
-                            if let Some(val) = elements.next() {
-                                path.push_str(val.as_ref())
+                let mut iter = self.elements.iter();
+                let mut map = HashMap::new();
+
+                let result = data.elements(|item| match item {
+                    either::Either::Left(val) => loop {
+                        if let Some(el) = iter.next() {
+                            match *el {
+                                PatternElement::Str(ref s) => path.push_str(s),
+                                PatternElement::Var(_) => {
+                                    path.push_str(val.as_ref());
+                                    return None;
+                                }
+                            }
+                        } else {
+                            return Some(false);
+                        }
+                    },
+                    either::Either::Right((name, val)) => {
+                        map.insert(name.to_string(), val.to_string());
+                        None
+                    }
+                });
+
+                if result.is_some() {
+                    return true;
+                } else {
+                    if map.is_empty() {
+                        // push static sections
+                        loop {
+                            if let Some(el) = iter.next() {
+                                match *el {
+                                    PatternElement::Str(ref s) => path.push_str(s),
+                                    PatternElement::Var(_) => {
+                                        return false;
+                                    }
+                                }
                             } else {
-                                return false;
+                                break;
+                            }
+                        }
+                    } else {
+                        for el in iter {
+                            match *el {
+                                PatternElement::Str(ref s) => path.push_str(s),
+                                PatternElement::Var(ref name) => {
+                                    if let Some(val) = map.get(name) {
+                                        path.push_str(val);
+                                        continue;
+                                    }
+                                    return false;
+                                }
                             }
                         }
                     }
+                    return true;
                 }
             }
-        };
+            PatternType::DynamicSet(..) => {
+                return false;
+            }
+        }
         true
     }
 
@@ -476,7 +657,7 @@ impl<'a> From<&'a str> for ResourceDef {
 
 impl From<String> for ResourceDef {
     fn from(path: String) -> ResourceDef {
-        ResourceDef::new(&path)
+        ResourceDef::new(path)
     }
 }
 
@@ -492,6 +673,7 @@ pub(crate) fn insert_slash(path: &str) -> String {
 mod tests {
     use super::*;
     use http::Uri;
+    use std::collections::HashMap;
     use std::convert::TryFrom;
 
     #[test]
@@ -558,6 +740,65 @@ mod tests {
         assert_eq!(path.get("id").unwrap(), "012345");
     }
 
+    #[test]
+    fn test_dynamic_set() {
+        let re = ResourceDef::new(vec![
+            "/user/{id}",
+            "/v{version}/resource/{id}",
+            "/{id:[[:digit:]]{6}}",
+        ]);
+        assert!(re.is_match("/user/profile"));
+        assert!(re.is_match("/user/2345"));
+        assert!(!re.is_match("/user/2345/"));
+        assert!(!re.is_match("/user/2345/sdg"));
+
+        let mut path = Path::new("/user/profile");
+        assert!(re.match_path(&mut path));
+        assert_eq!(path.get("id").unwrap(), "profile");
+
+        let mut path = Path::new("/user/1245125");
+        assert!(re.match_path(&mut path));
+        assert_eq!(path.get("id").unwrap(), "1245125");
+
+        assert!(re.is_match("/v1/resource/320120"));
+        assert!(!re.is_match("/v/resource/1"));
+        assert!(!re.is_match("/resource"));
+
+        let mut path = Path::new("/v151/resource/adahg32");
+        assert!(re.match_path(&mut path));
+        assert_eq!(path.get("version").unwrap(), "151");
+        assert_eq!(path.get("id").unwrap(), "adahg32");
+
+        assert!(re.is_match("/012345"));
+        assert!(!re.is_match("/012"));
+        assert!(!re.is_match("/01234567"));
+        assert!(!re.is_match("/XXXXXX"));
+
+        let mut path = Path::new("/012345");
+        assert!(re.match_path(&mut path));
+        assert_eq!(path.get("id").unwrap(), "012345");
+
+        let re = ResourceDef::new([
+            "/user/{id}",
+            "/v{version}/resource/{id}",
+            "/{id:[[:digit:]]{6}}",
+        ]);
+        assert!(re.is_match("/user/profile"));
+        assert!(re.is_match("/user/2345"));
+        assert!(!re.is_match("/user/2345/"));
+        assert!(!re.is_match("/user/2345/sdg"));
+
+        let re = ResourceDef::new([
+            "/user/{id}".to_string(),
+            "/v{version}/resource/{id}".to_string(),
+            "/{id:[[:digit:]]{6}}".to_string(),
+        ]);
+        assert!(re.is_match("/user/profile"));
+        assert!(re.is_match("/user/2345"));
+        assert!(!re.is_match("/user/2345/"));
+        assert!(!re.is_match("/user/2345/sdg"));
+    }
+
     #[test]
     fn test_parse_tail() {
         let re = ResourceDef::new("/user/-{id}*");
@@ -659,4 +900,71 @@ mod tests {
         assert_eq!(&path["name"], "test2");
         assert_eq!(&path[0], "test2");
     }
+
+    #[test]
+    fn test_resource_path() {
+        let mut s = String::new();
+        let resource = ResourceDef::new("/user/{item1}/test");
+        assert!(resource.resource_path(&mut s, &["user1"]));
+        assert_eq!(s, "/user/user1/test");
+
+        let mut s = String::new();
+        assert!(resource.resource_path(&mut s, (("item1", "user1"),)));
+        assert_eq!(s, "/user/user1/test");
+
+        let mut s = String::new();
+        let resource = ResourceDef::new("/user/{item1}/{item2}/test");
+        assert!(resource.resource_path(&mut s, &["item", "item2"]));
+        assert_eq!(s, "/user/item/item2/test");
+
+        let mut s = String::new();
+        assert!(resource.resource_path(&mut s, (("item1", "item"), ("item2", "item2"))));
+        assert_eq!(s, "/user/item/item2/test");
+
+        let mut s = String::new();
+        let resource = ResourceDef::new("/user/{item1}/{item2}");
+        assert!(resource.resource_path(&mut s, &["item", "item2"]));
+        assert_eq!(s, "/user/item/item2");
+
+        let mut s = String::new();
+        assert!(resource.resource_path(&mut s, (("item1", "item"), ("item2", "item2"))));
+        assert_eq!(s, "/user/item/item2");
+
+        let mut s = String::new();
+        let resource = ResourceDef::new("/user/{item1}/{item2}/");
+        assert!(resource.resource_path(&mut s, &["item", "item2"]));
+        assert_eq!(s, "/user/item/item2/");
+
+        let mut s = String::new();
+        assert!(!resource.resource_path(&mut s, &["item"]));
+
+        let mut s = String::new();
+        assert!(resource.resource_path(&mut s, &["item", "item2"]));
+        assert_eq!(s, "/user/item/item2/");
+        assert!(!resource.resource_path(&mut s, &["item"]));
+
+        let mut s = String::new();
+        assert!(resource.resource_path(&mut s, vec!["item", "item2"]));
+        assert_eq!(s, "/user/item/item2/");
+
+        let mut s = String::new();
+        assert!(resource.resource_path(&mut s, &vec!["item", "item2"]));
+        assert_eq!(s, "/user/item/item2/");
+
+        let mut s = String::new();
+        assert!(resource.resource_path(&mut s, &vec!["item", "item2"][..]));
+        assert_eq!(s, "/user/item/item2/");
+
+        let mut map = HashMap::new();
+        map.insert("item1", "item");
+        map.insert("item2", "item2");
+
+        let mut s = String::new();
+        assert!(resource.resource_path(&mut s, map));
+        assert_eq!(s, "/user/item/item2/");
+
+        let mut s = String::new();
+        assert!(resource.resource_path(&mut s, (("item1", "item"), ("item2", "item2"))));
+        assert_eq!(s, "/user/item/item2/");
+    }
 }

router/src/router.rs

@@ -1,4 +1,4 @@
-use crate::{Resource, ResourceDef, ResourcePath};
+use crate::{IntoPattern, Resource, ResourceDef, ResourcePath};
 
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub struct ResourceId(pub u16);
@@ -70,7 +70,11 @@ pub struct RouterBuilder<T, U = ()> {
 
 impl<T, U> RouterBuilder<T, U> {
     /// Register resource for specified path.
-    pub fn path(&mut self, path: &str, resource: T) -> &mut (ResourceDef, T, Option<U>) {
+    pub fn path<P: IntoPattern>(
+        &mut self,
+        path: P,
+        resource: T,
+    ) -> &mut (ResourceDef, T, Option<U>) {
         self.resources
             .push((ResourceDef::new(path), resource, None));
         self.resources.last_mut().unwrap()

string/CHANGES.md

@@ -1,9 +1,15 @@
 # Changes
 
-[0.1.1] - 2019-12-07
+## [0.1.2] - 2019-12-22
+
+* Fix `new()` method
+
+* Make `ByteString::from_static()` and `ByteString::from_bytes_unchecked()` methods const.
+
+## [0.1.1] - 2019-12-07
 
 * Fix hash impl
 
-[0.1.0] - 2019-12-07
+## [0.1.0] - 2019-12-07
 
 * Initial release

string/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bytestring"
-version = "0.1.1"
+version = "0.1.2"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "A UTF-8 encoded string with Bytes as a storage"
 keywords = ["actix"]
@@ -9,11 +9,10 @@ repository = "https://github.com/actix/actix-net.git"
 documentation = "https://docs.rs/bytestring/"
 license = "MIT/Apache-2.0"
 edition = "2018"
-workspace = ".."
 
 [lib]
 name = "bytestring"
 path = "src/lib.rs"
 
 [dependencies]
-bytes = "0.5.2"
+bytes = "0.5.3"

string/src/lib.rs

@@ -6,14 +6,14 @@ use bytes::Bytes;
 
 /// A utf-8 encoded string with [`Bytes`] as a storage.
 ///
-/// [`Bytes`]: https://docs.rs/bytes/0.5.2/bytes/struct.Bytes.html
+/// [`Bytes`]: https://docs.rs/bytes/0.5.3/bytes/struct.Bytes.html
 #[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Default)]
 pub struct ByteString(Bytes);
 
 impl ByteString {
     /// Creates a new `ByteString`.
-    pub fn new() -> String {
-        String::default()
+    pub fn new() -> Self {
+        ByteString(Bytes::new())
     }
 
     /// Get a reference to the underlying bytes object.
@@ -27,12 +27,12 @@ impl ByteString {
     }
 
     /// Creates a new `ByteString` from a static str.
-    pub fn from_static(src: &'static str) -> ByteString {
-        Self(Bytes::from_static(src.as_ref()))
+    pub const fn from_static(src: &'static str) -> ByteString {
+        Self(Bytes::from_static(src.as_bytes()))
     }
 
     /// Creates a new `ByteString` from a Bytes.
-    pub unsafe fn from_bytes_unchecked(src: Bytes) -> ByteString {
+    pub const unsafe fn from_bytes_unchecked(src: Bytes) -> ByteString {
         Self(src)
     }
 }
@@ -147,6 +147,11 @@ mod test {
     use std::collections::hash_map::DefaultHasher;
     use std::hash::{Hash, Hasher};
 
+    #[test]
+    fn test_new() {
+        let _: ByteString = ByteString::new();
+    }
+
     #[test]
     fn test_hash() {
         let mut hasher1 = DefaultHasher::default();
@@ -171,6 +176,7 @@ mod test {
 
     #[test]
     fn test_from_static_str() {
+        const _S: ByteString = ByteString::from_static("hello");
         let _ = ByteString::from_static("str");
     }