let's encrypt - wip

.travis.yml

@@ -10,7 +10,6 @@ matrix:
   include:
     - rust: stable
     - rust: beta
-    - rust: 1.36.0
     - rust: nightly-2019-06-15
   allow_failures:
     - rust: nightly-2019-06-15

CHANGES.md

@@ -6,7 +6,6 @@
 
 * Use new `Service<Request>` trait
 
-* Add UDS listening support to `ServerBuilder`
 
 ## [0.2.4] - 2018-11-21
 

Cargo.toml

@@ -17,15 +17,15 @@ edition = "2018"
 members = [
   "actix-codec",
   "actix-connect",
-  "actix-ioframe",
+  "actix-lets-encrypt",
   "actix-rt",
   "actix-service",
   "actix-server",
   "actix-server-config",
-  "actix-testing",
   "actix-test-server",
   "actix-threadpool",
   "actix-tower",
+  "actix-ioframe",
   "actix-utils",
   "router",
 ]

README.md

@@ -1,4 +1,4 @@
-# Actix net [![Build Status](https://travis-ci.org/actix/actix-net.svg?branch=master)](https://travis-ci.org/actix/actix-net) [![codecov](https://codecov.io/gh/actix/actix-net/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-net) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+# Actix net [![Build Status](https://travis-ci.org/actix/actix-net.svg?branch=master)](https://travis-ci.org/actix/actix-net) [![codecov](https://codecov.io/gh/actix/actix-net/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-net) [![crates.io](https://meritbadge.herokuapp.com/actix-net)](https://crates.io/crates/actix-net) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 Actix net - framework for composable network services
 
@@ -7,7 +7,7 @@ Actix net - framework for composable network services
 * [API Documentation (Development)](https://actix.rs/actix-net/actix_net/)
 * [Chat on gitter](https://gitter.im/actix/actix)
 * Cargo package: [actix-net](https://crates.io/crates/actix-net)
-* Minimum supported Rust version: 1.36 or later
+* Minimum supported Rust version: 1.32 or later
 
 ## Example
 

actix-connect/CHANGES.md

@@ -1,13 +1,5 @@
 # Changes
 
-## [0.2.5] - 2019-09-05
-
-* Add `TcpConnectService`
-
-## [0.2.4] - 2019-09-02
-
-* Use arbiter's storage for default async resolver
-
 ## [0.2.3] - 2019-08-05
 
 * Add `ConnectService` and `OpensslConnectService`

actix-connect/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-connect"
-version = "0.2.5"
+version = "0.2.3"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix Connector - tcp connector service"
 keywords = ["network", "framework", "async", "futures"]
@@ -36,7 +36,6 @@ uri = ["http"]
 actix-service = "0.4.0"
 actix-codec = "0.1.2"
 actix-utils = "0.4.0"
-actix-rt = "0.2.5"
 derive_more = "0.15"
 either = "1.5.2"
 futures = "0.1.25"

actix-connect/src/connector.rs

@@ -52,7 +52,7 @@ impl<T: Address> NewService for TcpConnectorFactory<T> {
 }
 
 /// Tcp connector service
-#[derive(Default, Debug)]
+#[derive(Debug)]
 pub struct TcpConnector<T>(PhantomData<T>);
 
 impl<T> TcpConnector<T> {

actix-connect/src/lib.rs

@@ -10,6 +10,8 @@
 #[macro_use]
 extern crate log;
 
+use std::cell::RefCell;
+
 mod connect;
 mod connector;
 mod error;
@@ -28,9 +30,8 @@ pub use self::connect::{Address, Connect, Connection};
 pub use self::connector::{TcpConnector, TcpConnectorFactory};
 pub use self::error::ConnectError;
 pub use self::resolver::{Resolver, ResolverFactory};
-pub use self::service::{ConnectService, ConnectServiceFactory, TcpConnectService};
+pub use self::service::{ConnectService, ConnectServiceFactory};
 
-use actix_rt::Arbiter;
 use actix_service::{NewService, Service, ServiceExt};
 use tokio_tcp::TcpStream;
 
@@ -40,12 +41,16 @@ pub fn start_resolver(cfg: ResolverConfig, opts: ResolverOpts) -> AsyncResolver
     resolver
 }
 
-struct DefaultResolver(AsyncResolver);
+thread_local! {
+    static DEFAULT_RESOLVER: RefCell<Option<AsyncResolver>> = RefCell::new(None);
+}
 
 pub(crate) fn get_default_resolver() -> AsyncResolver {
-    if Arbiter::contains_item::<DefaultResolver>() {
-        return Arbiter::get_item(|item: &DefaultResolver| item.0.clone());
-    } else {
+    DEFAULT_RESOLVER.with(|cell| {
+        if let Some(ref resolver) = *cell.borrow() {
+            return resolver.clone();
+        }
+
         let (cfg, opts) = match read_system_conf() {
             Ok((cfg, opts)) => (cfg, opts),
             Err(e) => {
@@ -57,9 +62,9 @@ pub(crate) fn get_default_resolver() -> AsyncResolver {
         let (resolver, bg) = AsyncResolver::new(cfg, opts);
         tokio_current_thread::spawn(bg);
 
-        Arbiter::set_item(DefaultResolver(resolver.clone()));
+        *cell.borrow_mut() = Some(resolver.clone());
         resolver
-    }
+    })
 }
 
 pub fn start_default_resolver() -> AsyncResolver {

actix-connect/src/resolver.rs

@@ -113,15 +113,17 @@ impl<T: Address> Service for Resolver<T> {
     fn call(&mut self, mut req: Connect<T>) -> Self::Future {
         if req.addr.is_some() {
             Either::B(ok(req))
-        } else if let Ok(ip) = req.host().parse() {
-            req.addr = Some(either::Either::Left(SocketAddr::new(ip, req.port())));
-            Either::B(ok(req))
         } else {
-            trace!("DNS resolver: resolving host {:?}", req.host());
-            if self.resolver.is_none() {
-                self.resolver = Some(get_default_resolver());
+            if let Ok(ip) = req.host().parse() {
+                req.addr = Some(either::Either::Left(SocketAddr::new(ip, req.port())));
+                Either::B(ok(req))
+            } else {
+                trace!("DNS resolver: resolving host {:?}", req.host());
+                if self.resolver.is_none() {
+                    self.resolver = Some(get_default_resolver());
+                }
+                Either::A(ResolverFuture::new(req, self.resolver.as_ref().unwrap()))
             }
-            Either::A(ResolverFuture::new(req, self.resolver.as_ref().unwrap()))
         }
     }
 }

actix-connect/src/service.rs

@@ -38,14 +38,6 @@ impl<T> ConnectServiceFactory<T> {
             resolver: self.resolver.service(),
         }
     }
-
-    /// Construct new tcp stream service
-    pub fn tcp_service(&self) -> TcpConnectService<T> {
-        TcpConnectService {
-            tcp: self.tcp.service(),
-            resolver: self.resolver.service(),
-        }
-    }
 }
 
 impl<T> Default for ConnectServiceFactory<T> {
@@ -129,55 +121,3 @@ impl<T: Address> Future for ConnectServiceResponse<T> {
         Ok(Async::NotReady)
     }
 }
-
-#[derive(Clone)]
-pub struct TcpConnectService<T> {
-    tcp: TcpConnector<T>,
-    resolver: Resolver<T>,
-}
-
-impl<T: Address> Service for TcpConnectService<T> {
-    type Request = Connect<T>;
-    type Response = TcpStream;
-    type Error = ConnectError;
-    type Future = TcpConnectServiceResponse<T>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        Ok(Async::Ready(()))
-    }
-
-    fn call(&mut self, req: Connect<T>) -> Self::Future {
-        TcpConnectServiceResponse {
-            fut1: Some(self.resolver.call(req)),
-            fut2: None,
-            tcp: self.tcp.clone(),
-        }
-    }
-}
-
-pub struct TcpConnectServiceResponse<T: Address> {
-    fut1: Option<<Resolver<T> as Service>::Future>,
-    fut2: Option<<TcpConnector<T> as Service>::Future>,
-    tcp: TcpConnector<T>,
-}
-
-impl<T: Address> Future for TcpConnectServiceResponse<T> {
-    type Item = TcpStream;
-    type Error = ConnectError;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if let Some(ref mut fut) = self.fut1 {
-            let res = try_ready!(fut.poll());
-            let _ = self.fut1.take();
-            self.fut2 = Some(self.tcp.call(res));
-        }
-
-        if let Some(ref mut fut) = self.fut2 {
-            if let Async::Ready(conn) = fut.poll()? {
-                return Ok(Async::Ready(conn.into_parts().0));
-            }
-        }
-
-        Ok(Async::NotReady)
-    }
-}

actix-ioframe/src/dispatcher.rs

@@ -44,7 +44,7 @@ where
     framed: Framed<T, U>,
     rx: Option<mpsc::UnboundedReceiver<FramedMessage<<U as Encoder>::Item>>>,
     inner: Cell<FramedDispatcherInner<<U as Encoder>::Item, S::Error>>,
-    disconnect: Option<Rc<dyn Fn(&mut St, bool)>>,
+    disconnect: Option<Rc<Fn(&mut St, bool)>>,
 }
 
 impl<St, S, T, U> FramedDispatcher<St, S, T, U>
@@ -63,7 +63,7 @@ where
         service: F,
         rx: mpsc::UnboundedReceiver<FramedMessage<<U as Encoder>::Item>>,
         sink: Sink<<U as Encoder>::Item>,
-        disconnect: Option<Rc<dyn Fn(&mut St, bool)>>,
+        disconnect: Option<Rc<Fn(&mut St, bool)>>,
     ) -> Self {
         FramedDispatcher {
             framed,

actix-ioframe/src/service.rs

@@ -62,7 +62,7 @@ impl<St, Codec> Builder<St, Codec> {
 
 pub struct ServiceBuilder<St, C, Io, Codec> {
     connect: C,
-    disconnect: Option<Rc<dyn Fn(&mut St, bool)>>,
+    disconnect: Option<Rc<Fn(&mut St, bool)>>,
     _t: PhantomData<(St, Io, Codec)>,
 }
 
@@ -113,7 +113,7 @@ where
 
 pub struct NewServiceBuilder<St, C, Io, Codec> {
     connect: C,
-    disconnect: Option<Rc<dyn Fn(&mut St, bool)>>,
+    disconnect: Option<Rc<Fn(&mut St, bool)>>,
     _t: PhantomData<(St, Io, Codec)>,
 }
 
@@ -170,7 +170,7 @@ where
 pub(crate) struct FramedService<St, C, T, Io, Codec, Cfg> {
     connect: C,
     handler: Rc<T>,
-    disconnect: Option<Rc<dyn Fn(&mut St, bool)>>,
+    disconnect: Option<Rc<Fn(&mut St, bool)>>,
     _t: PhantomData<(St, Io, Codec, Cfg)>,
 }
 
@@ -198,7 +198,7 @@ where
     type Error = ServiceError<C::Error, Codec>;
     type InitError = C::InitError;
     type Service = FramedServiceImpl<St, C::Service, T, Io, Codec>;
-    type Future = Box<dyn Future<Item = Self::Service, Error = Self::InitError>>;
+    type Future = Box<Future<Item = Self::Service, Error = Self::InitError>>;
 
     fn new_service(&self, _: &Cfg) -> Self::Future {
         let handler = self.handler.clone();
@@ -221,7 +221,7 @@ where
 pub struct FramedServiceImpl<St, C, T, Io, Codec> {
     connect: C,
     handler: Rc<T>,
-    disconnect: Option<Rc<dyn Fn(&mut St, bool)>>,
+    disconnect: Option<Rc<Fn(&mut St, bool)>>,
     _t: PhantomData<(St, Io, Codec)>,
 }
 
@@ -280,7 +280,7 @@ where
     <Codec as Encoder>::Error: std::fmt::Debug,
 {
     inner: FramedServiceImplResponseInner<St, Io, Codec, C, T>,
-    disconnect: Option<Rc<dyn Fn(&mut St, bool)>>,
+    disconnect: Option<Rc<Fn(&mut St, bool)>>,
 }
 
 enum FramedServiceImplResponseInner<St, Io, Codec, C, T>

actix-lets-encrypt/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "actix-lets-encrypt"
+version = "0.1.0"
+authors = ["Jordan Deitch <jd@rsa.pub>"]
+description = "Actix Let's Encrypt"
+keywords = ["network", "framework", "async", "futures"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-net.git"
+documentation = "https://docs.rs/actix-lets-encrypt/"
+categories = ["network-programming", "asynchronous"]
+license = "MIT/Apache-2.0"
+exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
+edition = "2018"
+workspace = ".."
+
+[lib]
+name = "actix_lets_encrypt"
+path = "src/lib.rs"
+
+[dependencies]
+acme-client = {version = "0.5", default-features = false}

actix-lets-encrypt/src/certificate_signer.rs

@@ -0,0 +1,64 @@
+use acme_client::Directory;
+
+struct CertificateError {
+    message: String,
+}
+
+impl std::error::Error for CertificateError {
+    fn description(&self) -> &str { self.message.as_str() }
+    fn cause(&self) -> Option<&dyn std::error::Error> { None }
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
+}
+
+impl std::fmt::Display for CertificateError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "An Error Occurred, Please Try Again!")
+    }
+}
+
+impl std::fmt::Debug for CertificateError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{{ file: {}, line: {} }}", file!(), line!())
+    }
+}
+
+impl CertificateError {
+    fn new(message: String) -> Self {
+        CertificateError { message }
+    }
+}
+
+impl std::convert::From<acme_client::error::Error> for CertificateError {
+    fn from(e: acme_client::error::Error) -> Self {
+        return CertificateError::new(e.to_string());
+    }
+}
+
+struct CertificateRequest<'a> {
+    domain: &'a str,
+    email: &'a str,
+}
+
+impl<'a> CertificateRequest<'a> {
+    fn new(email: &'a str, domain: &'a str) -> Self {
+        return CertificateRequest { domain, email };
+    }
+
+    fn sign(self: &Self) -> Result<(), CertificateError> {
+        let directory = Directory::lets_encrypt()?;
+        let account = directory.account_registration()
+            .email(self.email)
+            .register()?;
+        let authorization = account.authorization(self.domain)?;
+
+        let http_challenge = authorization.get_http_challenge().ok_or("HTTP challenge failed")?;
+        http_challenge.save_key_authorization("/var/www")?;
+        http_challenge.validate()?;
+
+        let cert = account.certificate_signer(&[self.domain]).sign_certificate()?;
+        cert.save_signed_certificate("certificate.pem")?;
+        cert.save_private_key("certificate.key")?;
+
+        Ok(())
+    }
+}

actix-lets-encrypt/src/lib.rs

@@ -0,0 +1,2 @@
+mod certificate_signer;
+mod authorization;

actix-rt/CHANGES.md

@@ -1,12 +1,5 @@
 # Changes
 
-## [0.2.5] - 2019-09-02
-
-### Added
-
-* Add arbiter specific storage
-
-
 ## [0.2.4] - 2019-07-17
 
 ### Changed

actix-rt/Cargo.toml

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

actix-rt/src/arbiter.rs

@@ -1,4 +1,3 @@
-use std::any::{Any, TypeId};
 use std::cell::{Cell, RefCell};
 use std::collections::HashMap;
 use std::sync::atomic::{AtomicUsize, Ordering};
@@ -17,16 +16,15 @@ use copyless::BoxHelper;
 thread_local!(
     static ADDR: RefCell<Option<Arbiter>> = RefCell::new(None);
     static RUNNING: Cell<bool> = Cell::new(false);
-    static Q: RefCell<Vec<Box<dyn Future<Item = (), Error = ()>>>> = RefCell::new(Vec::new());
-    static STORAGE: RefCell<HashMap<TypeId, Box<dyn Any>>> = RefCell::new(HashMap::new());
+    static Q: RefCell<Vec<Box<Future<Item = (), Error = ()>>>> = RefCell::new(Vec::new());
 );
 
 pub(crate) static COUNT: AtomicUsize = AtomicUsize::new(0);
 
 pub(crate) enum ArbiterCommand {
     Stop,
-    Execute(Box<dyn Future<Item = (), Error = ()> + Send>),
-    ExecuteFn(Box<dyn FnExec>),
+    Execute(Box<Future<Item = (), Error = ()> + Send>),
+    ExecuteFn(Box<FnExec>),
 }
 
 impl fmt::Debug for ArbiterCommand {
@@ -58,7 +56,6 @@ impl Arbiter {
         let arb = Arbiter(tx);
         ADDR.with(|cell| *cell.borrow_mut() = Some(arb.clone()));
         RUNNING.with(|cell| cell.set(false));
-        STORAGE.with(|cell| cell.borrow_mut().clear());
         Arbiter::spawn(ArbiterController { stop: None, rx });
 
         arb
@@ -93,7 +90,6 @@ impl Arbiter {
 
             let (stop, stop_rx) = channel();
             RUNNING.with(|cell| cell.set(true));
-            STORAGE.with(|cell| cell.borrow_mut().clear());
 
             System::set_current(sys);
 
@@ -184,7 +180,7 @@ impl Arbiter {
         let _ = self
             .0
             .unbounded_send(ArbiterCommand::ExecuteFn(Box::new(move || {
-                f();
+                let _ = f();
             })));
     }
 
@@ -206,50 +202,6 @@ impl Arbiter {
             })));
         rx
     }
-
-    /// Set item to arbiter storage
-    pub fn set_item<T: 'static>(item: T) {
-        STORAGE.with(move |cell| cell.borrow_mut().insert(TypeId::of::<T>(), Box::new(item)));
-    }
-
-    /// Check if arbiter storage contains item
-    pub fn contains_item<T: 'static>() -> bool {
-        STORAGE.with(move |cell| cell.borrow().get(&TypeId::of::<T>()).is_some())
-    }
-
-    /// Get a reference to a type previously inserted on this arbiter's storage.
-    ///
-    /// Panics is item is not inserted
-    pub fn get_item<T: 'static, F, R>(mut f: F) -> R
-    where
-        F: FnMut(&T) -> R,
-    {
-        STORAGE.with(move |cell| {
-            let st = cell.borrow();
-            let item = st
-                .get(&TypeId::of::<T>())
-                .and_then(|boxed| (&**boxed as &(dyn Any + 'static)).downcast_ref())
-                .unwrap();
-            f(item)
-        })
-    }
-
-    /// Get a mutable reference to a type previously inserted on this arbiter's storage.
-    ///
-    /// Panics is item is not inserted
-    pub fn get_mut_item<T: 'static, F, R>(mut f: F) -> R
-    where
-        F: FnMut(&mut T) -> R,
-    {
-        STORAGE.with(move |cell| {
-            let mut st = cell.borrow_mut();
-            let item = st
-                .get_mut(&TypeId::of::<T>())
-                .and_then(|boxed| (&mut **boxed as &mut (dyn Any + 'static)).downcast_mut())
-                .unwrap();
-            f(item)
-        })
-    }
 }
 
 struct ArbiterController {
@@ -360,7 +312,7 @@ impl<F> FnExec for F
 where
     F: FnOnce() + Send + 'static,
 {
-    #[allow(clippy::boxed_local)]
+    #[cfg_attr(feature = "cargo-clippy", allow(boxed_local))]
     fn call_box(self: Box<Self>) {
         (*self)()
     }

actix-rt/src/runtime.rs

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

actix-server/src/builder.rs

@@ -185,41 +185,20 @@ impl ServerBuilder {
 
     #[cfg(all(unix, feature = "uds"))]
     /// Add new unix domain service to the server.
-    pub fn bind_uds<F, U, N>(self, name: N, addr: U, factory: F) -> io::Result<Self>
+    pub fn bind_uds<F, U, N>(mut self, name: N, addr: U, factory: F) -> io::Result<Self>
     where
         F: ServiceFactory<tokio_uds::UnixStream>,
         N: AsRef<str>,
         U: AsRef<std::path::Path>,
     {
+        use std::net::{IpAddr, Ipv4Addr, SocketAddr};
         use std::os::unix::net::UnixListener;
 
-        // The path must not exist when we try to bind.
-        // Try to remove it to avoid bind error.
-        if let Err(e) = std::fs::remove_file(addr.as_ref()) {
-            // NotFound is expected and not an issue. Anything else is.
-            if e.kind() != std::io::ErrorKind::NotFound {
-                return Err(e);
-            }
-        }
+        // TODO: need to do something with existing paths
+        let _ = std::fs::remove_file(addr.as_ref());
 
         let lst = UnixListener::bind(addr)?;
-        self.listen_uds(name, lst, factory)
-    }
 
-    #[cfg(all(unix, feature = "uds"))]
-    /// Add new unix domain service to the server.
-    /// Useful when running as a systemd service and
-    /// a socket FD can be acquired using the systemd crate.
-    pub fn listen_uds<F, N: AsRef<str>>(
-        mut self,
-        name: N,
-        lst: std::os::unix::net::UnixListener,
-        factory: F,
-    ) -> io::Result<Self>
-    where
-        F: ServiceFactory<tokio_uds::UnixStream>,
-    {
-        use std::net::{IpAddr, Ipv4Addr, SocketAddr};
         let token = self.token.next();
         let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
         self.services.push(StreamNewService::create(

actix-service/CHANGES.md

@@ -1,12 +1,5 @@
 # Changes
 
-## [0.4.2] - 2019-08-27
-
-### Fixed
-
-* Check service readiness for `new_apply_cfg` combinator
-
-
 ## [0.4.1] - 2019-06-06
 
 ### Added

actix-service/Cargo.toml

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

actix-service/src/apply_cfg.rs

@@ -49,7 +49,6 @@ where
     C: Clone,
     F: FnMut(&C, &mut T::Service) -> R,
     T: NewService<Config = ()>,
-    T::InitError: From<T::Error>,
     R: IntoFuture<Error = T::InitError>,
     R::Item: IntoService<S>,
     S: Service,
@@ -180,7 +179,6 @@ where
     C: Clone,
     F: FnMut(&C, &mut T::Service) -> R,
     T: NewService<Config = ()>,
-    T::InitError: From<T::Error>,
     R: IntoFuture<Error = T::InitError>,
     R::Item: IntoService<S>,
     S: Service,
@@ -198,9 +196,8 @@ where
         ApplyConfigNewServiceFut {
             f: self.f.clone(),
             cfg: cfg.clone(),
+            srv: Some(self.srv.get_ref().new_service(&())),
             fut: None,
-            srv: None,
-            srv_fut: Some(self.srv.get_ref().new_service(&())),
             _t: PhantomData,
         }
     }
@@ -211,15 +208,13 @@ where
     C: Clone,
     F: FnMut(&C, &mut T::Service) -> R,
     T: NewService<Config = ()>,
-    T::InitError: From<T::Error>,
     R: IntoFuture<Error = T::InitError>,
     R::Item: IntoService<S>,
     S: Service,
 {
     cfg: C,
     f: Cell<F>,
-    srv: Option<T::Service>,
-    srv_fut: Option<T::Future>,
+    srv: Option<T::Future>,
     fut: Option<R::Future>,
     _t: PhantomData<(S,)>,
 }
@@ -229,7 +224,6 @@ where
     C: Clone,
     F: FnMut(&C, &mut T::Service) -> R,
     T: NewService<Config = ()>,
-    T::InitError: From<T::Error>,
     R: IntoFuture<Error = T::InitError>,
     R::Item: IntoService<S>,
     S: Service,
@@ -238,12 +232,12 @@ where
     type Error = R::Error;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if let Some(ref mut fut) = self.srv_fut {
+        if let Some(ref mut fut) = self.srv {
             match fut.poll()? {
                 Async::NotReady => return Ok(Async::NotReady),
-                Async::Ready(srv) => {
-                    let _ = self.srv_fut.take();
-                    self.srv = Some(srv);
+                Async::Ready(mut srv) => {
+                    let _ = self.srv.take();
+                    self.fut = Some(self.f.get_mut()(&self.cfg, &mut srv).into_future());
                     return self.poll();
                 }
             }
@@ -251,14 +245,6 @@ where
 
         if let Some(ref mut fut) = self.fut {
             Ok(Async::Ready(try_ready!(fut.poll()).into_service()))
-        } else if let Some(ref mut srv) = self.srv {
-            match srv.poll_ready()? {
-                Async::NotReady => Ok(Async::NotReady),
-                Async::Ready(_) => {
-                    self.fut = Some(self.f.get_mut()(&self.cfg, srv).into_future());
-                    return self.poll();
-                }
-            }
         } else {
             Ok(Async::NotReady)
         }

actix-service/src/boxed.rs

@@ -4,7 +4,7 @@ use futures::{Async, Future, IntoFuture, Poll};
 use crate::{NewService, Service};
 
 pub type BoxedService<Req, Res, Err> = Box<
-    dyn Service<
+    Service<
         Request = Req,
         Response = Res,
         Error = Err,
@@ -13,7 +13,7 @@ pub type BoxedService<Req, Res, Err> = Box<
 >;
 
 pub type BoxedServiceResponse<Res, Err> =
-    Either<FutureResult<Res, Err>, Box<dyn Future<Item = Res, Error = Err>>>;
+    Either<FutureResult<Res, Err>, Box<Future<Item = Res, Error = Err>>>;
 
 pub struct BoxedNewService<C, Req, Res, Err, InitErr>(Inner<C, Req, Res, Err, InitErr>);
 
@@ -46,14 +46,14 @@ where
 }
 
 type Inner<C, Req, Res, Err, InitErr> = Box<
-    dyn NewService<
+    NewService<
         Config = C,
         Request = Req,
         Response = Res,
         Error = Err,
         InitError = InitErr,
         Service = BoxedService<Req, Res, Err>,
-        Future = Box<dyn Future<Item = BoxedService<Req, Res, Err>, Error = InitErr>>,
+        Future = Box<Future<Item = BoxedService<Req, Res, Err>, Error = InitErr>>,
     >,
 >;
 
@@ -70,7 +70,7 @@ where
     type InitError = InitErr;
     type Config = C;
     type Service = BoxedService<Req, Res, Err>;
-    type Future = Box<dyn Future<Item = Self::Service, Error = Self::InitError>>;
+    type Future = Box<Future<Item = Self::Service, Error = Self::InitError>>;
 
     fn new_service(&self, cfg: &C) -> Self::Future {
         self.0.new_service(cfg)
@@ -99,7 +99,7 @@ where
     type InitError = InitErr;
     type Config = C;
     type Service = BoxedService<Req, Res, Err>;
-    type Future = Box<dyn Future<Item = Self::Service, Error = Self::InitError>>;
+    type Future = Box<Future<Item = Self::Service, Error = Self::InitError>>;
 
     fn new_service(&self, cfg: &C) -> Self::Future {
         Box::new(
@@ -133,7 +133,7 @@ where
     type Error = Err;
     type Future = Either<
         FutureResult<Self::Response, Self::Error>,
-        Box<dyn Future<Item = Self::Response, Error = Self::Error>>,
+        Box<Future<Item = Self::Response, Error = Self::Error>>,
     >;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {

actix-service/src/cell.rs

@@ -34,7 +34,6 @@ impl<T> Cell<T> {
         unsafe { &mut *self.inner.as_ref().get() }
     }
 
-    #[allow(clippy::mut_from_ref)]
     pub(crate) unsafe fn get_mut_unsafe(&self) -> &mut T {
         &mut *self.inner.as_ref().get()
     }

actix-test-server/Cargo.toml

@@ -13,10 +13,25 @@ exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
 edition = "2018"
 workspace = ".."
 
+[package.metadata.docs.rs]
+features = ["ssl", "tls", "rust-tls"]
+
 [lib]
 name = "actix_test_server"
 path = "src/lib.rs"
 
+[features]
+default = []
+
+# tls
+tls = ["native-tls", "actix-server/tls"]
+
+# openssl
+ssl = ["openssl", "actix-server/ssl"]
+
+# rustls
+rust-tls = ["rustls", "tokio-rustls", "webpki", "webpki-roots"]
+
 [dependencies]
 actix-rt = "0.2.1"
 actix-server = "0.5.0"
@@ -28,5 +43,17 @@ futures = "0.1"
 tokio-tcp = "0.1"
 tokio-reactor = "0.1"
 
+# native-tls
+native-tls = { version="0.2", optional = true }
+
+# openssl
+openssl = { version="0.10", optional = true }
+
+#rustls
+rustls = { version = "^0.15", optional = true }
+tokio-rustls = { version = "^0.9", optional = true }
+webpki = { version = "0.19", optional = true }
+webpki-roots = { version = "0.16", optional = true }
+
 [dev-dependencies]
 actix-service = "0.4.0"

actix-test-server/README.md

@@ -1,3 +0,0 @@
-# Actix test server (Deprecated)
-
-Use [actix-testing](https://docs.rs/actix-testing/) instead

actix-testing/CHANGES.md

@@ -1,5 +0,0 @@
-# Changes
-
-## [0.1.0] - 2019-09-25
-
-* Initial impl

actix-testing/Cargo.toml

@@ -1,29 +0,0 @@
-[package]
-name = "actix-testing"
-version = "0.1.0"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix testing utils"
-keywords = ["network", "framework", "async", "futures"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-net.git"
-documentation = "https://docs.rs/actix-testing/"
-categories = ["network-programming", "asynchronous"]
-license = "MIT/Apache-2.0"
-edition = "2018"
-workspace = ".."
-
-[lib]
-name = "actix_testing"
-path = "src/lib.rs"
-
-[dependencies]
-actix-rt = "0.2.1"
-actix-server = "0.6.0"
-actix-server-config = "0.1.0"
-actix-service = "0.4.0"
-
-log = "0.4"
-net2 = "0.2"
-futures = "0.1"
-tokio-tcp = "0.1"
-tokio-reactor = "0.1"

actix-testing/LICENSE-APACHE

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

actix-testing/LICENSE-MIT

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

actix-testing/README.md

@@ -1,9 +0,0 @@
-# Actix test utilities [![crates.io](https://meritbadge.herokuapp.com/actix-testing)](https://crates.io/crates/actix-testint) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-
-## Documentation & community resources
-
-* [User Guide](https://actix.rs/docs/)
-* [API Documentation](https://docs.rs/actix-testing/)
-* [Chat on gitter](https://gitter.im/actix/actix)
-* Cargo package: [actix-http-test](https://crates.io/crates/actix-testing)
-* Minimum supported Rust version: 1.37 or later

actix-testing/src/lib.rs

@@ -1,152 +0,0 @@
-//! Various helpers for Actix applications to use during testing.
-use std::sync::mpsc;
-use std::{net, thread};
-
-use actix_rt::System;
-use actix_server::{Server, ServerBuilder, StreamServiceFactory};
-pub use actix_server_config::{Io, ServerConfig};
-
-use net2::TcpBuilder;
-use tokio_reactor::Handle;
-use tokio_tcp::TcpStream;
-
-mod rt;
-pub use self::rt::*;
-
-/// The `TestServer` type.
-///
-/// `TestServer` is very simple test server that simplify process of writing
-/// integration tests for actix-net applications.
-///
-/// # Examples
-///
-/// ```rust
-/// use actix_service::{service_fn, IntoNewService};
-/// use actix_testing::TestServer;
-///
-/// fn main() {
-///     let srv = TestServer::with(|| service_fn(
-///         |sock| {
-///             println!("New connection: {:?}", sock);
-///             Ok::<_, ()>(())
-///         }
-///     ));
-///
-///     println!("SOCKET: {:?}", srv.connect());
-/// }
-/// ```
-pub struct TestServer;
-
-/// Test server runstime
-pub struct TestServerRuntime {
-    addr: net::SocketAddr,
-    host: String,
-    port: u16,
-    system: System,
-}
-
-impl TestServer {
-    /// Start new server with server builder
-    pub fn new<F>(mut factory: F) -> TestServerRuntime
-    where
-        F: FnMut(ServerBuilder) -> ServerBuilder + Send + 'static,
-    {
-        let (tx, rx) = mpsc::channel();
-
-        // run server in separate thread
-        thread::spawn(move || {
-            let sys = System::new("actix-test-server");
-            factory(Server::build())
-                .workers(1)
-                .disable_signals()
-                .start();
-
-            tx.send(System::current()).unwrap();
-            sys.run()
-        });
-        let system = rx.recv().unwrap();
-
-        TestServerRuntime {
-            system,
-            addr: "127.0.0.1:0".parse().unwrap(),
-            host: "127.0.0.1".to_string(),
-            port: 0,
-        }
-    }
-
-    /// Start new test server with application factory
-    pub fn with<F: StreamServiceFactory<TcpStream>>(factory: F) -> TestServerRuntime {
-        let (tx, rx) = mpsc::channel();
-
-        // run server in separate thread
-        thread::spawn(move || {
-            let sys = System::new("actix-test-server");
-            let tcp = net::TcpListener::bind("127.0.0.1:0").unwrap();
-            let local_addr = tcp.local_addr().unwrap();
-
-            Server::build()
-                .listen("test", tcp, factory)?
-                .workers(1)
-                .disable_signals()
-                .start();
-
-            tx.send((System::current(), local_addr)).unwrap();
-            sys.run()
-        });
-
-        let (system, addr) = rx.recv().unwrap();
-
-        let host = format!("{}", addr.ip());
-        let port = addr.port();
-
-        TestServerRuntime {
-            system,
-            addr,
-            host,
-            port,
-        }
-    }
-
-    /// Get firat available unused local address
-    pub fn unused_addr() -> net::SocketAddr {
-        let addr: net::SocketAddr = "127.0.0.1:0".parse().unwrap();
-        let socket = TcpBuilder::new_v4().unwrap();
-        socket.bind(&addr).unwrap();
-        socket.reuse_address(true).unwrap();
-        let tcp = socket.to_tcp_listener().unwrap();
-        tcp.local_addr().unwrap()
-    }
-}
-
-impl TestServerRuntime {
-    /// Test server host
-    pub fn host(&self) -> &str {
-        &self.host
-    }
-
-    /// Test server port
-    pub fn port(&self) -> u16 {
-        self.port
-    }
-
-    /// Get test server address
-    pub fn addr(&self) -> net::SocketAddr {
-        self.addr
-    }
-
-    /// Stop http server
-    fn stop(&mut self) {
-        self.system.stop();
-    }
-
-    /// Connect to server, return tokio TcpStream
-    pub fn connect(&self) -> std::io::Result<TcpStream> {
-        TcpStream::from_std(net::TcpStream::connect(self.addr)?, &Handle::default())
-    }
-}
-
-impl Drop for TestServerRuntime {
-    fn drop(&mut self) {
-        self.stop()
-    }
-}

actix-testing/src/rt.rs

@@ -1,116 +0,0 @@
-//! Various helpers for Actix applications to use during testing.
-use std::cell::RefCell;
-
-use actix_rt::{System, SystemRunner};
-use actix_service::Service;
-use futures::future::{lazy, Future, IntoFuture};
-
-thread_local! {
-    static RT: RefCell<Inner> = {
-        RefCell::new(Inner(Some(System::builder().build())))
-    };
-}
-
-struct Inner(Option<SystemRunner>);
-
-impl Inner {
-    fn get_mut(&mut self) -> &mut SystemRunner {
-        self.0.as_mut().unwrap()
-    }
-}
-
-impl Drop for Inner {
-    fn drop(&mut self) {
-        std::mem::forget(self.0.take().unwrap())
-    }
-}
-
-/// Runs the provided future, blocking the current thread until the future
-/// completes.
-///
-/// This function can be used to synchronously block the current thread
-/// until the provided `future` has resolved either successfully or with an
-/// error. The result of the future is then returned from this function
-/// call.
-///
-/// Note that this function is intended to be used only for testing purpose.
-/// This function panics on nested call.
-pub fn block_on<F>(f: F) -> Result<F::Item, F::Error>
-where
-    F: IntoFuture,
-{
-    RT.with(move |rt| rt.borrow_mut().get_mut().block_on(f.into_future()))
-}
-
-/// Runs the provided function, blocking the current thread until the result
-/// future completes.
-///
-/// This function can be used to synchronously block the current thread
-/// until the provided `future` has resolved either successfully or with an
-/// error. The result of the future is then returned from this function
-/// call.
-///
-/// Note that this function is intended to be used only for testing purpose.
-/// This function panics on nested call.
-pub fn block_fn<F, R>(f: F) -> Result<R::Item, R::Error>
-where
-    F: FnOnce() -> R,
-    R: IntoFuture,
-{
-    RT.with(move |rt| rt.borrow_mut().get_mut().block_on(lazy(f)))
-}
-
-/// Spawn future to the current test runtime.
-pub fn spawn<F>(fut: F)
-where
-    F: Future<Item = (), Error = ()> + 'static,
-{
-    run_on(move || {
-        actix_rt::spawn(fut);
-    });
-}
-
-/// Runs the provided function, with runtime enabled.
-///
-/// Note that this function is intended to be used only for testing purpose.
-/// This function panics on nested call.
-pub fn run_on<F, R>(f: F) -> R
-where
-    F: FnOnce() -> R,
-{
-    RT.with(move |rt| {
-        rt.borrow_mut()
-            .get_mut()
-            .block_on(lazy(|| Ok::<_, ()>(f())))
-    })
-    .unwrap()
-}
-
-/// Calls service and waits for response future completion.
-///
-/// ```rust,ignore
-/// use actix_web::{test, App, HttpResponse, http::StatusCode};
-/// use actix_service::Service;
-///
-/// #[test]
-/// fn test_response() {
-///     let mut app = test::init_service(
-///         App::new()
-///             .service(web::resource("/test").to(|| HttpResponse::Ok()))
-///     );
-///
-///     // Create request object
-///     let req = test::TestRequest::with_uri("/test").to_request();
-///
-///     // Call application
-///     let resp = test::call_service(&mut app, req);
-///     assert_eq!(resp.status(), StatusCode::OK);
-/// }
-/// ```
-pub fn call_service<S, R>(app: &mut S, req: R) -> S::Response
-where
-    S: Service<Request = R>,
-    S::Error: std::fmt::Debug,
-{
-    block_on(run_on(move || app.call(req))).unwrap()
-}

actix-utils/src/inflight.rs

@@ -119,7 +119,7 @@ mod tests {
         type Request = ();
         type Response = ();
         type Error = ();
-        type Future = Box<dyn Future<Item = (), Error = ()>>;
+        type Future = Box<Future<Item = (), Error = ()>>;
 
         fn poll_ready(&mut self) -> Poll<(), Self::Error> {
             Ok(Async::Ready(()))

actix-utils/src/order.rs

@@ -214,7 +214,7 @@ mod tests {
         type Request = oneshot::Receiver<usize>;
         type Response = usize;
         type Error = ();
-        type Future = Box<dyn Future<Item = usize, Error = ()>>;
+        type Future = Box<Future<Item = usize, Error = ()>>;
 
         fn poll_ready(&mut self) -> Poll<(), Self::Error> {
             Ok(Async::Ready(()))

actix-utils/src/stream.rs

@@ -45,7 +45,7 @@ where
     type Request = S;
     type Response = ();
     type Error = E;
-    type Future = Box<dyn Future<Item = (), Error = E>>;
+    type Future = Box<Future<Item = (), Error = E>>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         Ok(Async::Ready(()))

actix-utils/src/timeout.rs

@@ -190,7 +190,7 @@ mod tests {
         type Request = ();
         type Response = ();
         type Error = ();
-        type Future = Box<dyn Future<Item = (), Error = ()>>;
+        type Future = Box<Future<Item = (), Error = ()>>;
 
         fn poll_ready(&mut self) -> Poll<(), Self::Error> {
             Ok(Async::Ready(()))

router/src/de.rs

@@ -151,7 +151,7 @@ impl<'de, T: ResourcePath + 'de> Deserializer<'de> for PathDeserializer<'de, T>
     where
         V: Visitor<'de>,
     {
-        if self.path.is_empty() {
+        if self.path.len() < 1 {
             Err(de::value::Error::custom(
                 "expeceted at least one parameters",
             ))

router/src/path.rs

@@ -93,7 +93,7 @@ impl<T: ResourcePath> Path<T> {
     #[inline]
     /// Skip first `n` chars in path
     pub fn skip(&mut self, n: u16) {
-        self.skip += n;
+        self.skip = self.skip + n;
     }
 
     pub(crate) fn add(&mut self, name: Rc<String>, value: PathItem) {

router/src/resource.rs

@@ -207,7 +207,7 @@ impl ResourceDef {
                                 "Dynamic path match but not all segments found: {}",
                                 name
                             );
-                            return false;
+                            false;
                         }
                     }
                 } else {
@@ -279,7 +279,7 @@ impl ResourceDef {
                                 "Dynamic path match but not all segments found: {}",
                                 name
                             );
-                            return false;
+                            false;
                         }
                     }
                 } else {