From 8d5d1dbf6ffedefc73d0ad7fe01494a0c0175626 Mon Sep 17 00:00:00 2001 From: Rob Ede Date: Mon, 17 Jul 2023 03:05:39 +0100 Subject: [PATCH 01/10] bump MSRV to 1.65 (#485) --- .github/workflows/ci.yml | 2 +- .rustfmt.toml | 3 ++ Cargo.toml | 4 ++ README.md | 2 +- actix-codec/CHANGES.md | 2 +- actix-codec/Cargo.toml | 4 +- actix-codec/src/framed.rs | 10 +---- actix-codec/src/lib.rs | 18 +++++---- actix-codec/tests/test_framed_sink.rs | 5 +-- actix-macros/CHANGES.md | 2 +- actix-macros/Cargo.toml | 4 +- actix-macros/tests/trybuild.rs | 2 +- .../tests/trybuild/main-02-only-async.stderr | 11 ++---- actix-rt/CHANGES.md | 2 +- actix-rt/Cargo.toml | 4 +- actix-rt/examples/hyper.rs | 3 +- actix-rt/src/arbiter.rs | 11 ++---- actix-rt/src/lib.rs | 22 ++++++----- actix-rt/src/system.rs | 4 +- actix-server/CHANGES.md | 2 +- actix-server/Cargo.toml | 6 +-- actix-server/src/builder.rs | 7 +--- actix-server/src/lib.rs | 9 ++--- actix-server/src/service.rs | 2 +- actix-server/src/socket.rs | 5 +-- actix-server/src/worker.rs | 13 ++++--- actix-service/CHANGES.md | 2 +- actix-service/Cargo.toml | 4 +- actix-service/src/and_then.rs | 33 +++------------- actix-service/src/apply.rs | 3 +- actix-service/src/apply_cfg.rs | 3 +- actix-service/src/boxed.rs | 3 +- actix-service/src/fn_service.rs | 16 +++----- actix-service/src/lib.rs | 14 ++++--- actix-service/src/map_err.rs | 3 +- actix-service/src/pipeline.rs | 19 +++++----- actix-tls/CHANGES.md | 2 +- actix-tls/Cargo.toml | 4 +- actix-tls/src/accept/mod.rs | 38 +++++++++---------- actix-tls/src/accept/rustls.rs | 3 +- actix-tls/src/connect/mod.rs | 16 ++++---- actix-tls/src/connect/native_tls.rs | 3 +- actix-tls/src/connect/openssl.rs | 4 +- actix-tls/src/connect/rustls.rs | 11 +++--- actix-tls/tests/accept-openssl.rs | 8 ++-- actix-tls/tests/accept-rustls.rs | 14 +++---- actix-tls/tests/test_resolvers.rs | 3 +- actix-tracing/CHANGES.md | 2 +- actix-tracing/Cargo.toml | 4 +- actix-tracing/src/lib.rs | 8 ++-- actix-utils/CHANGES.md | 2 +- actix-utils/Cargo.toml | 4 +- actix-utils/src/future/mod.rs | 8 ++-- bytestring/Cargo.toml | 4 +- bytestring/src/lib.rs | 6 ++- local-channel/CHANGES.md | 2 +- local-channel/Cargo.toml | 4 +- local-waker/CHANGES.md | 2 +- local-waker/Cargo.toml | 4 +- rustfmt.toml | 2 - 60 files changed, 188 insertions(+), 229 deletions(-) create mode 100644 .rustfmt.toml delete mode 100644 rustfmt.toml diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f59d79e9..cd9c5848 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -23,7 +23,7 @@ jobs: - { name: Windows (MinGW), os: windows-latest, triple: x86_64-pc-windows-gnu } - { name: Windows (32-bit), os: windows-latest, triple: i686-pc-windows-msvc } version: - - 1.60.0 + - 1.65.0 # MSRV - stable name: ${{ matrix.target.name }} / ${{ matrix.version }} diff --git a/.rustfmt.toml b/.rustfmt.toml new file mode 100644 index 00000000..71b9be3a --- /dev/null +++ b/.rustfmt.toml @@ -0,0 +1,3 @@ +group_imports = "StdExternalCrate" +imports_granularity = "Crate" +use_field_init_shorthand = true diff --git a/Cargo.toml b/Cargo.toml index ccd36595..62897764 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -14,6 +14,10 @@ members = [ ] resolver = "2" +[workspace.package] +edition = "2021" +rust-version = "1.65" + [patch.crates-io] actix-codec = { path = "actix-codec" } actix-macros = { path = "actix-macros" } diff --git a/README.md b/README.md index fdf829f5..9d99d5ee 100644 --- a/README.md +++ b/README.md @@ -13,7 +13,7 @@ See example folders for [`actix-server`](./actix-server/examples) and [`actix-tl ## MSRV -Crates in this repo currently have a Minimum Supported Rust Version (MSRV) of 1.60. As a policy, we permit MSRV increases in non-breaking releases. +Crates in this repo currently have a Minimum Supported Rust Version (MSRV) of 1.65. As a policy, we permit MSRV increases in non-breaking releases. ## License diff --git a/actix-codec/CHANGES.md b/actix-codec/CHANGES.md index ebb867cf..14dc78c5 100644 --- a/actix-codec/CHANGES.md +++ b/actix-codec/CHANGES.md @@ -2,7 +2,7 @@ ## Unreleased - 2023-xx-xx -- Minimum supported Rust version (MSRV) is now 1.60. +- Minimum supported Rust version (MSRV) is now 1.65. ## 0.5.1 - 2022-03-15 diff --git a/actix-codec/Cargo.toml b/actix-codec/Cargo.toml index 565bc830..d8f072df 100644 --- a/actix-codec/Cargo.toml +++ b/actix-codec/Cargo.toml @@ -10,8 +10,8 @@ keywords = ["network", "framework", "async", "futures"] repository = "https://github.com/actix/actix-net" categories = ["network-programming", "asynchronous"] license = "MIT OR Apache-2.0" -edition = "2021" -rust-version = "1.60" +edition.workspace = true +rust-version.workspace = true [dependencies] bitflags = "2" diff --git a/actix-codec/src/framed.rs b/actix-codec/src/framed.rs index 0d62a61c..6d6e1478 100644 --- a/actix-codec/src/framed.rs +++ b/actix-codec/src/framed.rs @@ -234,10 +234,7 @@ impl Framed { } /// Flush write buffer to underlying I/O stream. - pub fn flush( - mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - ) -> Poll> + pub fn flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> where T: AsyncWrite, U: Encoder, @@ -270,10 +267,7 @@ impl Framed { } /// Flush write buffer and shutdown underlying I/O stream. - pub fn close( - mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - ) -> Poll> + pub fn close(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> where T: AsyncWrite, U: Encoder, diff --git a/actix-codec/src/lib.rs b/actix-codec/src/lib.rs index 020e40e2..7dc28b35 100644 --- a/actix-codec/src/lib.rs +++ b/actix-codec/src/lib.rs @@ -11,14 +11,18 @@ #![doc(html_logo_url = "https://actix.rs/img/logo.png")] #![doc(html_favicon_url = "https://actix.rs/favicon.ico")] +pub use tokio::io::{AsyncRead, AsyncWrite, ReadBuf}; +pub use tokio_util::{ + codec::{Decoder, Encoder}, + io::poll_read_buf, +}; + mod bcodec; mod framed; mod lines; -pub use tokio::io::{AsyncRead, AsyncWrite, ReadBuf}; -pub use tokio_util::codec::{Decoder, Encoder}; -pub use tokio_util::io::poll_read_buf; - -pub use self::bcodec::BytesCodec; -pub use self::framed::{Framed, FramedParts}; -pub use self::lines::LinesCodec; +pub use self::{ + bcodec::BytesCodec, + framed::{Framed, FramedParts}, + lines::LinesCodec, +}; diff --git a/actix-codec/tests/test_framed_sink.rs b/actix-codec/tests/test_framed_sink.rs index 390aebf2..8c98ff18 100644 --- a/actix-codec/tests/test_framed_sink.rs +++ b/actix-codec/tests/test_framed_sink.rs @@ -81,10 +81,7 @@ impl AsyncWrite for Bilateral { other => Ready(other), } } - fn poll_shutdown( - self: Pin<&mut Self>, - _cx: &mut Context<'_>, - ) -> Poll> { + fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll> { unimplemented!() } } diff --git a/actix-macros/CHANGES.md b/actix-macros/CHANGES.md index 1badd6b7..9385808c 100644 --- a/actix-macros/CHANGES.md +++ b/actix-macros/CHANGES.md @@ -3,7 +3,7 @@ ## Unreleased - 2023-xx-xx - Update `syn` dependency to `2`. -- Minimum supported Rust version (MSRV) is now 1.60. +- Minimum supported Rust version (MSRV) is now 1.65. ## 0.2.3 - 2021-10-19 diff --git a/actix-macros/Cargo.toml b/actix-macros/Cargo.toml index 902a6dd1..4aba5e53 100644 --- a/actix-macros/Cargo.toml +++ b/actix-macros/Cargo.toml @@ -10,8 +10,8 @@ description = "Macros for Actix system and runtime" repository = "https://github.com/actix/actix-net.git" categories = ["network-programming", "asynchronous"] license = "MIT OR Apache-2.0" -edition = "2021" -rust-version = "1.60" +edition.workspace = true +rust-version.workspace = true [lib] proc-macro = true diff --git a/actix-macros/tests/trybuild.rs b/actix-macros/tests/trybuild.rs index 7e399d49..b37b84ba 100644 --- a/actix-macros/tests/trybuild.rs +++ b/actix-macros/tests/trybuild.rs @@ -1,4 +1,4 @@ -#[rustversion::stable(1.60)] // MSRV +#[rustversion::stable(1.65)] // MSRV #[test] fn compile_macros() { let t = trybuild::TestCases::new(); diff --git a/actix-macros/tests/trybuild/main-02-only-async.stderr b/actix-macros/tests/trybuild/main-02-only-async.stderr index fc060071..2b15ecaa 100644 --- a/actix-macros/tests/trybuild/main-02-only-async.stderr +++ b/actix-macros/tests/trybuild/main-02-only-async.stderr @@ -1,14 +1,11 @@ error: the async keyword is missing from the function declaration - --> $DIR/main-02-only-async.rs:2:1 + --> tests/trybuild/main-02-only-async.rs:2:1 | 2 | fn main() { | ^^ error[E0601]: `main` function not found in crate `$CRATE` - --> $DIR/main-02-only-async.rs:1:1 + --> tests/trybuild/main-02-only-async.rs:4:2 | -1 | / #[actix_rt::main] -2 | | fn main() { -3 | | futures_util::future::ready(()).await -4 | | } - | |_^ consider adding a `main` function to `$DIR/tests/trybuild/main-02-only-async.rs` +4 | } + | ^ consider adding a `main` function to `$DIR/tests/trybuild/main-02-only-async.rs` diff --git a/actix-rt/CHANGES.md b/actix-rt/CHANGES.md index 547b7524..0cedbaa6 100644 --- a/actix-rt/CHANGES.md +++ b/actix-rt/CHANGES.md @@ -2,7 +2,7 @@ ## Unreleased - 2023-xx-xx -- Minimum supported Rust version (MSRV) is now 1.60. +- Minimum supported Rust version (MSRV) is now 1.65. ## 2.8.0 - 2022-12-21 diff --git a/actix-rt/Cargo.toml b/actix-rt/Cargo.toml index fa5fc204..1256eefd 100644 --- a/actix-rt/Cargo.toml +++ b/actix-rt/Cargo.toml @@ -11,8 +11,8 @@ homepage = "https://actix.rs" repository = "https://github.com/actix/actix-net.git" categories = ["network-programming", "asynchronous"] license = "MIT OR Apache-2.0" -edition = "2021" -rust-version = "1.60" +edition.workspace = true +rust-version.workspace = true [features] default = ["macros"] diff --git a/actix-rt/examples/hyper.rs b/actix-rt/examples/hyper.rs index 45b5e551..41c5a7d8 100644 --- a/actix-rt/examples/hyper.rs +++ b/actix-rt/examples/hyper.rs @@ -20,8 +20,7 @@ fn main() { let make_service = make_service_fn(|_conn| async { Ok::<_, Infallible>(service_fn(handle)) }); - let server = - Server::bind(&SocketAddr::from(([127, 0, 0, 1], 3000))).serve(make_service); + let server = Server::bind(&SocketAddr::from(([127, 0, 0, 1], 3000))).serve(make_service); if let Err(err) = server.await { eprintln!("server error: {}", err); diff --git a/actix-rt/src/arbiter.rs b/actix-rt/src/arbiter.rs index a84e25ea..48cc752f 100644 --- a/actix-rt/src/arbiter.rs +++ b/actix-rt/src/arbiter.rs @@ -99,8 +99,7 @@ impl Arbiter { #[allow(clippy::new_without_default)] pub fn new() -> Arbiter { Self::with_tokio_rt(|| { - crate::runtime::default_tokio_runtime() - .expect("Cannot create new Arbiter's Runtime.") + crate::runtime::default_tokio_runtime().expect("Cannot create new Arbiter's Runtime.") }) } @@ -149,9 +148,7 @@ impl Arbiter { .send(SystemCommand::DeregisterArbiter(arb_id)); } }) - .unwrap_or_else(|err| { - panic!("Cannot spawn Arbiter's thread: {:?}. {:?}", &name, err) - }); + .unwrap_or_else(|err| panic!("Cannot spawn Arbiter's thread: {name:?}: {err:?}")); ready_rx.recv().unwrap(); @@ -201,9 +198,7 @@ impl Arbiter { .send(SystemCommand::DeregisterArbiter(arb_id)); } }) - .unwrap_or_else(|err| { - panic!("Cannot spawn Arbiter's thread: {:?}. {:?}", &name, err) - }); + .unwrap_or_else(|err| panic!("Cannot spawn Arbiter's thread: {name:?}: {err:?}")); ready_rx.recv().unwrap(); diff --git a/actix-rt/src/lib.rs b/actix-rt/src/lib.rs index 23dd01e8..6f8057de 100644 --- a/actix-rt/src/lib.rs +++ b/actix-rt/src/lib.rs @@ -65,9 +65,11 @@ mod system; pub use tokio::pin; use tokio::task::JoinHandle; -pub use self::arbiter::{Arbiter, ArbiterHandle}; -pub use self::runtime::Runtime; -pub use self::system::{System, SystemRunner}; +pub use self::{ + arbiter::{Arbiter, ArbiterHandle}, + runtime::Runtime, + system::{System, SystemRunner}, +}; pub mod signal { //! Asynchronous signal handling (Tokio re-exports). @@ -89,12 +91,13 @@ pub mod net { task::{Context, Poll}, }; - pub use tokio::io::Ready; use tokio::io::{AsyncRead, AsyncWrite, Interest}; - pub use tokio::net::UdpSocket; - pub use tokio::net::{TcpListener, TcpSocket, TcpStream}; #[cfg(unix)] pub use tokio::net::{UnixDatagram, UnixListener, UnixStream}; + pub use tokio::{ + io::Ready, + net::{TcpListener, TcpSocket, TcpStream, UdpSocket}, + }; /// Extension trait over async read+write types that can also signal readiness. #[doc(hidden)] @@ -153,10 +156,9 @@ pub mod net { pub mod time { //! Utilities for tracking time (Tokio re-exports). - pub use tokio::time::Instant; - pub use tokio::time::{interval, interval_at, Interval}; - pub use tokio::time::{sleep, sleep_until, Sleep}; - pub use tokio::time::{timeout, Timeout}; + pub use tokio::time::{ + interval, interval_at, sleep, sleep_until, timeout, Instant, Interval, Sleep, Timeout, + }; } pub mod task { diff --git a/actix-rt/src/system.rs b/actix-rt/src/system.rs index d0494a22..7423a01e 100644 --- a/actix-rt/src/system.rs +++ b/actix-rt/src/system.rs @@ -226,9 +226,7 @@ impl SystemRunner { /// Runs the event loop until [stopped](System::stop_with_code), returning the exit code. pub fn run_with_code(self) -> io::Result { - unimplemented!( - "SystemRunner::run_with_code is not implemented for io-uring feature yet" - ); + unimplemented!("SystemRunner::run_with_code is not implemented for io-uring feature yet"); } /// Runs the provided future, blocking the current thread until the future completes. diff --git a/actix-server/CHANGES.md b/actix-server/CHANGES.md index 1147dcbd..e98f9d2b 100644 --- a/actix-server/CHANGES.md +++ b/actix-server/CHANGES.md @@ -2,7 +2,7 @@ ## Unreleased - 2023-xx-xx -- Minimum supported Rust version (MSRV) is now 1.60. +- Minimum supported Rust version (MSRV) is now 1.65. ## 2.2.0 - 2022-12-21 diff --git a/actix-server/Cargo.toml b/actix-server/Cargo.toml index ade711f4..62f13107 100755 --- a/actix-server/Cargo.toml +++ b/actix-server/Cargo.toml @@ -12,8 +12,8 @@ categories = ["network-programming", "asynchronous"] homepage = "https://actix.rs" repository = "https://github.com/actix/actix-net.git" license = "MIT OR Apache-2.0" -edition = "2021" -rust-version = "1.60" +edition.workspace = true +rust-version.workspace = true [features] default = [] @@ -28,7 +28,7 @@ futures-core = { version = "0.3.17", default-features = false, features = ["allo futures-util = { version = "0.3.17", default-features = false, features = ["alloc"] } mio = { version = "0.8", features = ["os-poll", "net"] } num_cpus = "1.13" -socket2 = "0.4.2" # TODO(MSRV 1.64) update to 0.5 +socket2 = "0.5" tokio = { version = "1.23.1", features = ["sync"] } tracing = { version = "0.1.30", default-features = false, features = ["log"] } diff --git a/actix-server/src/builder.rs b/actix-server/src/builder.rs index b6646081..badac77b 100644 --- a/actix-server/src/builder.rs +++ b/actix-server/src/builder.rs @@ -7,9 +7,7 @@ use tracing::{info, trace}; use crate::{ server::ServerCommand, service::{InternalServiceFactory, ServerServiceFactory, StreamNewService}, - socket::{ - create_mio_tcp_listener, MioListener, MioTcpListener, StdTcpListener, ToSocketAddrs, - }, + socket::{create_mio_tcp_listener, MioListener, MioTcpListener, StdTcpListener, ToSocketAddrs}, worker::ServerWorkerConfig, Server, }; @@ -246,8 +244,7 @@ impl ServerBuilder { use std::net::{IpAddr, Ipv4Addr}; lst.set_nonblocking(true)?; let token = self.next_token(); - let addr = - crate::socket::StdSocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080); + let addr = crate::socket::StdSocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080); self.factories.push(StreamNewService::create( name.as_ref().to_string(), token, diff --git a/actix-server/src/lib.rs b/actix-server/src/lib.rs index 532313b6..5e265d74 100644 --- a/actix-server/src/lib.rs +++ b/actix-server/src/lib.rs @@ -18,13 +18,12 @@ mod test_server; mod waker_queue; mod worker; -pub use self::builder::ServerBuilder; -pub use self::handle::ServerHandle; -pub use self::server::Server; -pub use self::service::ServerServiceFactory; #[doc(hidden)] pub use self::socket::FromStream; -pub use self::test_server::TestServer; +pub use self::{ + builder::ServerBuilder, handle::ServerHandle, server::Server, service::ServerServiceFactory, + test_server::TestServer, +}; /// Start server building process #[doc(hidden)] diff --git a/actix-server/src/service.rs b/actix-server/src/service.rs index f07ec3e5..eba1470e 100644 --- a/actix-server/src/service.rs +++ b/actix-server/src/service.rs @@ -78,7 +78,7 @@ where Ok(()) } Err(err) => { - error!("can not convert to an async TCP stream: {}", err); + error!("can not convert to an async TCP stream: {err}"); Err(()) } }) diff --git a/actix-server/src/socket.rs b/actix-server/src/socket.rs index 8d2ffe8f..f0942e38 100644 --- a/actix-server/src/socket.rs +++ b/actix-server/src/socket.rs @@ -8,8 +8,7 @@ pub(crate) use mio::net::TcpListener as MioTcpListener; use mio::{event::Source, Interest, Registry, Token}; #[cfg(unix)] pub(crate) use { - mio::net::UnixListener as MioUnixListener, - std::os::unix::net::UnixListener as StdUnixListener, + mio::net::UnixListener as MioUnixListener, std::os::unix::net::UnixListener as StdUnixListener, }; pub(crate) enum MioListener { @@ -105,7 +104,7 @@ impl fmt::Debug for MioListener { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match *self { MioListener::Tcp(ref lst) => write!(f, "{:?}", lst), - #[cfg(all(unix))] + #[cfg(unix)] MioListener::Uds(ref lst) => write!(f, "{:?}", lst), } } diff --git a/actix-server/src/worker.rs b/actix-server/src/worker.rs index 2765ae4a..a9ae97a0 100644 --- a/actix-server/src/worker.rs +++ b/actix-server/src/worker.rs @@ -625,8 +625,8 @@ impl Future for ServerWorker { let factory_id = restart.factory_id; let token = restart.token; - let (token_new, service) = ready!(restart.fut.as_mut().poll(cx)) - .unwrap_or_else(|_| { + let (token_new, service) = + ready!(restart.fut.as_mut().poll(cx)).unwrap_or_else(|_| { panic!( "Can not restart {:?} service", this.factories[factory_id].name(token) @@ -697,7 +697,10 @@ impl Future for ServerWorker { match ready!(this.conn_rx.poll_recv(cx)) { Some(msg) => { let guard = this.counter.guard(); - let _ = this.services[msg.token].service.call((guard, msg.io)); + let _ = this.services[msg.token] + .service + .call((guard, msg.io)) + .into_inner(); } None => return Poll::Ready(()), }; @@ -706,9 +709,7 @@ impl Future for ServerWorker { } } -fn wrap_worker_services( - services: Vec<(usize, usize, BoxedServerService)>, -) -> Vec { +fn wrap_worker_services(services: Vec<(usize, usize, BoxedServerService)>) -> Vec { services .into_iter() .fold(Vec::new(), |mut services, (idx, token, service)| { diff --git a/actix-service/CHANGES.md b/actix-service/CHANGES.md index 0640c1cd..ee549941 100644 --- a/actix-service/CHANGES.md +++ b/actix-service/CHANGES.md @@ -2,7 +2,7 @@ ## Unreleased - 2023-xx-xx -- Minimum supported Rust version (MSRV) is now 1.60. +- Minimum supported Rust version (MSRV) is now 1.65. ## 2.0.2 - 2021-12-18 diff --git a/actix-service/Cargo.toml b/actix-service/Cargo.toml index 74904634..dcb6652f 100644 --- a/actix-service/Cargo.toml +++ b/actix-service/Cargo.toml @@ -10,8 +10,8 @@ keywords = ["network", "framework", "async", "futures", "service"] categories = ["network-programming", "asynchronous", "no-std"] repository = "https://github.com/actix/actix-net" license = "MIT OR Apache-2.0" -edition = "2021" -rust-version = "1.60" +edition.workspace = true +rust-version.workspace = true [dependencies] futures-core = { version = "0.3.17", default-features = false } diff --git a/actix-service/src/and_then.rs b/actix-service/src/and_then.rs index 38980079..28a17044 100644 --- a/actix-service/src/and_then.rs +++ b/actix-service/src/and_then.rs @@ -121,12 +121,7 @@ pub struct AndThenServiceFactory where A: ServiceFactory, A::Config: Clone, - B: ServiceFactory< - A::Response, - Config = A::Config, - Error = A::Error, - InitError = A::InitError, - >, + B: ServiceFactory, { inner: Rc<(A, B)>, _phantom: PhantomData, @@ -136,12 +131,7 @@ impl AndThenServiceFactory where A: ServiceFactory, A::Config: Clone, - B: ServiceFactory< - A::Response, - Config = A::Config, - Error = A::Error, - InitError = A::InitError, - >, + B: ServiceFactory, { /// Create new `AndThenFactory` combinator pub(crate) fn new(a: A, b: B) -> Self { @@ -156,12 +146,7 @@ impl ServiceFactory for AndThenServiceFactory where A: ServiceFactory, A::Config: Clone, - B: ServiceFactory< - A::Response, - Config = A::Config, - Error = A::Error, - InitError = A::InitError, - >, + B: ServiceFactory, { type Response = B::Response; type Error = A::Error; @@ -184,12 +169,7 @@ impl Clone for AndThenServiceFactory where A: ServiceFactory, A::Config: Clone, - B: ServiceFactory< - A::Response, - Config = A::Config, - Error = A::Error, - InitError = A::InitError, - >, + B: ServiceFactory, { fn clone(&self) -> Self { Self { @@ -334,9 +314,8 @@ mod tests { async fn test_new_service() { let cnt = Rc::new(Cell::new(0)); let cnt2 = cnt.clone(); - let new_srv = - pipeline_factory(fn_factory(move || ready(Ok::<_, ()>(Srv1(cnt2.clone()))))) - .and_then(move || ready(Ok(Srv2(cnt.clone())))); + let new_srv = pipeline_factory(fn_factory(move || ready(Ok::<_, ()>(Srv1(cnt2.clone()))))) + .and_then(move || ready(Ok(Srv2(cnt.clone())))); let srv = new_srv.new_service(()).await.unwrap(); let res = srv.call("srv1").await; diff --git a/actix-service/src/apply.rs b/actix-service/src/apply.rs index c77f4242..d33bdcd8 100644 --- a/actix-service/src/apply.rs +++ b/actix-service/src/apply.rs @@ -140,8 +140,7 @@ where } } -impl ServiceFactory - for ApplyFactory +impl ServiceFactory for ApplyFactory where SF: ServiceFactory, F: Fn(Req, &SF::Service) -> Fut + Clone, diff --git a/actix-service/src/apply_cfg.rs b/actix-service/src/apply_cfg.rs index 25fc5fc2..028fb317 100644 --- a/actix-service/src/apply_cfg.rs +++ b/actix-service/src/apply_cfg.rs @@ -198,8 +198,7 @@ pin_project! { } } -impl Future - for ApplyConfigServiceFactoryResponse +impl Future for ApplyConfigServiceFactoryResponse where SF: ServiceFactory, SF::InitError: From, diff --git a/actix-service/src/boxed.rs b/actix-service/src/boxed.rs index 3141c5e4..cc9ad410 100644 --- a/actix-service/src/boxed.rs +++ b/actix-service/src/boxed.rs @@ -91,8 +91,7 @@ type Inner = Box< >, >; -impl ServiceFactory - for BoxServiceFactory +impl ServiceFactory for BoxServiceFactory where Req: 'static, Res: 'static, diff --git a/actix-service/src/fn_service.rs b/actix-service/src/fn_service.rs index a2379270..2dac8697 100644 --- a/actix-service/src/fn_service.rs +++ b/actix-service/src/fn_service.rs @@ -3,9 +3,7 @@ use core::{future::Future, marker::PhantomData}; use crate::{ok, IntoService, IntoServiceFactory, Ready, Service, ServiceFactory}; /// Create `ServiceFactory` for function that can act as a `Service` -pub fn fn_service( - f: F, -) -> FnServiceFactory +pub fn fn_service(f: F) -> FnServiceFactory where F: Fn(Req) -> Fut + Clone, Fut: Future>, @@ -48,9 +46,7 @@ where /// Ok(()) /// } /// ``` -pub fn fn_factory( - f: F, -) -> FnServiceNoConfig +pub fn fn_factory(f: F) -> FnServiceNoConfig where F: Fn() -> Fut, Fut: Future>, @@ -265,8 +261,7 @@ where } } -impl ServiceFactory - for FnServiceConfig +impl ServiceFactory for FnServiceConfig where F: Fn(Cfg) -> Fut, Fut: Future>, @@ -404,9 +399,8 @@ mod tests { ok::<_, Rc>(fn_service(|_: Rc| ok::<_, Rc>(Rc::new(0u8)))) }); - let fac_2 = fn_factory(|| { - ok::<_, Rc>(fn_service(|_: Rc| ok::<_, Rc>(Rc::new(0u8)))) - }); + let fac_2 = + fn_factory(|| ok::<_, Rc>(fn_service(|_: Rc| ok::<_, Rc>(Rc::new(0u8))))); fn is_send(_: &T) {} diff --git a/actix-service/src/lib.rs b/actix-service/src/lib.rs index 091a7fd7..fbbdfeb8 100644 --- a/actix-service/src/lib.rs +++ b/actix-service/src/lib.rs @@ -33,14 +33,16 @@ mod then; mod transform; mod transform_err; -pub use self::apply::{apply_fn, apply_fn_factory}; -pub use self::apply_cfg::{apply_cfg, apply_cfg_factory}; -pub use self::ext::{ServiceExt, ServiceFactoryExt, TransformExt}; -pub use self::fn_service::{fn_factory, fn_factory_with_config, fn_service}; -pub use self::map_config::{map_config, unit_config}; #[allow(unused_imports)] use self::ready::{err, ok, ready, Ready}; -pub use self::transform::{apply, ApplyTransform, Transform}; +pub use self::{ + apply::{apply_fn, apply_fn_factory}, + apply_cfg::{apply_cfg, apply_cfg_factory}, + ext::{ServiceExt, ServiceFactoryExt, TransformExt}, + fn_service::{fn_factory, fn_factory_with_config, fn_service}, + map_config::{map_config, unit_config}, + transform::{apply, ApplyTransform, Transform}, +}; /// An asynchronous operation from `Request` to a `Response`. /// diff --git a/actix-service/src/map_err.rs b/actix-service/src/map_err.rs index 3ce6f418..780a64c7 100644 --- a/actix-service/src/map_err.rs +++ b/actix-service/src/map_err.rs @@ -206,8 +206,7 @@ mod tests { use super::*; use crate::{ - err, ok, IntoServiceFactory, Ready, Service, ServiceExt, ServiceFactory, - ServiceFactoryExt, + err, ok, IntoServiceFactory, Ready, Service, ServiceExt, ServiceFactory, ServiceFactoryExt, }; struct Srv; diff --git a/actix-service/src/pipeline.rs b/actix-service/src/pipeline.rs index 2617d0ed..118f9797 100644 --- a/actix-service/src/pipeline.rs +++ b/actix-service/src/pipeline.rs @@ -6,12 +6,14 @@ use core::{ task::{Context, Poll}, }; -use crate::and_then::{AndThenService, AndThenServiceFactory}; -use crate::map::{Map, MapServiceFactory}; -use crate::map_err::{MapErr, MapErrServiceFactory}; -use crate::map_init_err::MapInitErr; -use crate::then::{ThenService, ThenServiceFactory}; -use crate::{IntoService, IntoServiceFactory, Service, ServiceFactory}; +use crate::{ + and_then::{AndThenService, AndThenServiceFactory}, + map::{Map, MapServiceFactory}, + map_err::{MapErr, MapErrServiceFactory}, + map_init_err::MapInitErr, + then::{ThenService, ThenServiceFactory}, + IntoService, IntoServiceFactory, Service, ServiceFactory, +}; /// Construct new pipeline with one service in pipeline chain. pub(crate) fn pipeline(service: I) -> Pipeline @@ -252,10 +254,7 @@ where } /// Map this service's error to a different error, returning a new service. - pub fn map_err( - self, - f: F, - ) -> PipelineFactory, Req> + pub fn map_err(self, f: F) -> PipelineFactory, Req> where Self: Sized, F: Fn(SF::Error) -> E + Clone, diff --git a/actix-tls/CHANGES.md b/actix-tls/CHANGES.md index f4f248b2..0381e6de 100644 --- a/actix-tls/CHANGES.md +++ b/actix-tls/CHANGES.md @@ -2,7 +2,7 @@ ## Unreleased - 2023-xx-xx -- Minimum supported Rust version (MSRV) is now 1.60. +- Minimum supported Rust version (MSRV) is now 1.65. ## 3.0.4 - 2022-03-15 diff --git a/actix-tls/Cargo.toml b/actix-tls/Cargo.toml index 9c463e2c..d65d675b 100755 --- a/actix-tls/Cargo.toml +++ b/actix-tls/Cargo.toml @@ -10,8 +10,8 @@ keywords = ["network", "tls", "ssl", "async", "transport"] repository = "https://github.com/actix/actix-net.git" categories = ["network-programming", "asynchronous", "cryptography"] license = "MIT OR Apache-2.0" -edition = "2021" -rust-version = "1.60" +edition.workspace = true +rust-version.workspace = true [package.metadata.docs.rs] all-features = true diff --git a/actix-tls/src/accept/mod.rs b/actix-tls/src/accept/mod.rs index 13c4db37..1eee6720 100644 --- a/actix-tls/src/accept/mod.rs +++ b/actix-tls/src/accept/mod.rs @@ -56,6 +56,25 @@ pub enum TlsError { Service(SvcErr), } +impl TlsError { + /// Casts the infallible service error type returned from acceptors into caller's type. + /// + /// # Examples + /// ``` + /// # use std::convert::Infallible; + /// # use actix_tls::accept::TlsError; + /// let a: TlsError = TlsError::Tls(42); + /// let _b: TlsError = a.into_service_error(); + /// ``` + pub fn into_service_error(self) -> TlsError { + match self { + Self::Timeout => TlsError::Timeout, + Self::Tls(err) => TlsError::Tls(err), + Self::Service(err) => match err {}, + } + } +} + impl fmt::Display for TlsError { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { @@ -80,25 +99,6 @@ where } } -impl TlsError { - /// Casts the infallible service error type returned from acceptors into caller's type. - /// - /// # Examples - /// ``` - /// # use std::convert::Infallible; - /// # use actix_tls::accept::TlsError; - /// let a: TlsError = TlsError::Tls(42); - /// let _b: TlsError = a.into_service_error(); - /// ``` - pub fn into_service_error(self) -> TlsError { - match self { - Self::Timeout => TlsError::Timeout, - Self::Tls(err) => TlsError::Tls(err), - Self::Service(err) => match err {}, - } - } -} - #[cfg(test)] mod tests { use super::*; diff --git a/actix-tls/src/accept/rustls.rs b/actix-tls/src/accept/rustls.rs index bf324e3c..85cf5b00 100644 --- a/actix-tls/src/accept/rustls.rs +++ b/actix-tls/src/accept/rustls.rs @@ -23,8 +23,7 @@ use actix_utils::{ }; use pin_project_lite::pin_project; use tokio::io::{AsyncRead, AsyncWrite, ReadBuf}; -use tokio_rustls::rustls::ServerConfig; -use tokio_rustls::{Accept, TlsAcceptor}; +use tokio_rustls::{rustls::ServerConfig, Accept, TlsAcceptor}; use super::{TlsError, DEFAULT_TLS_HANDSHAKE_TIMEOUT, MAX_CONN_COUNTER}; diff --git a/actix-tls/src/connect/mod.rs b/actix-tls/src/connect/mod.rs index df002585..dae1f7b1 100644 --- a/actix-tls/src/connect/mod.rs +++ b/actix-tls/src/connect/mod.rs @@ -33,10 +33,12 @@ pub mod rustls; #[cfg(feature = "native-tls")] pub mod native_tls; -pub use self::connection::Connection; -pub use self::connector::{Connector, ConnectorService}; -pub use self::error::ConnectError; -pub use self::host::Host; -pub use self::info::ConnectInfo; -pub use self::resolve::Resolve; -pub use self::resolver::{Resolver, ResolverService}; +pub use self::{ + connection::Connection, + connector::{Connector, ConnectorService}, + error::ConnectError, + host::Host, + info::ConnectInfo, + resolve::Resolve, + resolver::{Resolver, ResolverService}, +}; diff --git a/actix-tls/src/connect/native_tls.rs b/actix-tls/src/connect/native_tls.rs index 37b9ffa4..16863ce0 100644 --- a/actix-tls/src/connect/native_tls.rs +++ b/actix-tls/src/connect/native_tls.rs @@ -19,8 +19,7 @@ use crate::connect::{Connection, Host}; pub mod reexports { //! Re-exports from `native-tls` and `tokio-native-tls` that are useful for connectors. - pub use tokio_native_tls::native_tls::TlsConnector; - pub use tokio_native_tls::TlsStream as AsyncTlsStream; + pub use tokio_native_tls::{native_tls::TlsConnector, TlsStream as AsyncTlsStream}; } /// Connector service and factory using `native-tls`. diff --git a/actix-tls/src/connect/openssl.rs b/actix-tls/src/connect/openssl.rs index caff4f0f..ab2841bb 100644 --- a/actix-tls/src/connect/openssl.rs +++ b/actix-tls/src/connect/openssl.rs @@ -22,9 +22,7 @@ use crate::connect::{Connection, Host}; pub mod reexports { //! Re-exports from `openssl` and `tokio-openssl` that are useful for connectors. - pub use openssl::ssl::{ - Error, HandshakeError, SslConnector, SslConnectorBuilder, SslMethod, - }; + pub use openssl::ssl::{Error, HandshakeError, SslConnector, SslConnectorBuilder, SslMethod}; pub use tokio_openssl::SslStream as AsyncSslStream; } diff --git a/actix-tls/src/connect/rustls.rs b/actix-tls/src/connect/rustls.rs index 0a44479a..5706047d 100644 --- a/actix-tls/src/connect/rustls.rs +++ b/actix-tls/src/connect/rustls.rs @@ -15,9 +15,11 @@ use actix_rt::net::ActixStream; use actix_service::{Service, ServiceFactory}; use actix_utils::future::{ok, Ready}; use futures_core::ready; -use tokio_rustls::rustls::{client::ServerName, OwnedTrustAnchor, RootCertStore}; -use tokio_rustls::{client::TlsStream as AsyncTlsStream, rustls::ClientConfig}; -use tokio_rustls::{Connect as RustlsConnect, TlsConnector as RustlsTlsConnector}; +use tokio_rustls::{ + client::TlsStream as AsyncTlsStream, + rustls::{client::ServerName, ClientConfig, OwnedTrustAnchor, RootCertStore}, + Connect as RustlsConnect, TlsConnector as RustlsTlsConnector, +}; use tracing::trace; use webpki_roots::TLS_SERVER_ROOTS; @@ -26,8 +28,7 @@ use crate::connect::{Connection, Host}; pub mod reexports { //! Re-exports from `rustls` and `webpki_roots` that are useful for connectors. - pub use tokio_rustls::client::TlsStream as AsyncTlsStream; - pub use tokio_rustls::rustls::ClientConfig; + pub use tokio_rustls::{client::TlsStream as AsyncTlsStream, rustls::ClientConfig}; pub use webpki_roots::TLS_SERVER_ROOTS; } diff --git a/actix-tls/tests/accept-openssl.rs b/actix-tls/tests/accept-openssl.rs index a4180f4d..ff707f65 100644 --- a/actix-tls/tests/accept-openssl.rs +++ b/actix-tls/tests/accept-openssl.rs @@ -17,11 +17,9 @@ use actix_utils::future::ok; use tokio_rustls::rustls::{Certificate, ClientConfig, RootCertStore, ServerName}; fn new_cert_and_key() -> (String, String) { - let cert = rcgen::generate_simple_self_signed(vec![ - "127.0.0.1".to_owned(), - "localhost".to_owned(), - ]) - .unwrap(); + let cert = + rcgen::generate_simple_self_signed(vec!["127.0.0.1".to_owned(), "localhost".to_owned()]) + .unwrap(); let key = cert.serialize_private_key_pem(); let cert = cert.serialize_pem().unwrap(); diff --git a/actix-tls/tests/accept-rustls.rs b/actix-tls/tests/accept-rustls.rs index 521af7f9..7955b36f 100644 --- a/actix-tls/tests/accept-rustls.rs +++ b/actix-tls/tests/accept-rustls.rs @@ -14,19 +14,19 @@ use std::io::{BufReader, Write}; use actix_rt::net::TcpStream; use actix_server::TestServer; use actix_service::ServiceFactoryExt as _; -use actix_tls::accept::rustls::{Acceptor, TlsStream}; -use actix_tls::connect::openssl::reexports::SslConnector; +use actix_tls::{ + accept::rustls::{Acceptor, TlsStream}, + connect::openssl::reexports::SslConnector, +}; use actix_utils::future::ok; use rustls_pemfile::{certs, pkcs8_private_keys}; use tls_openssl::ssl::SslVerifyMode; use tokio_rustls::rustls::{self, Certificate, PrivateKey, ServerConfig}; fn new_cert_and_key() -> (String, String) { - let cert = rcgen::generate_simple_self_signed(vec![ - "127.0.0.1".to_owned(), - "localhost".to_owned(), - ]) - .unwrap(); + let cert = + rcgen::generate_simple_self_signed(vec!["127.0.0.1".to_owned(), "localhost".to_owned()]) + .unwrap(); let key = cert.serialize_private_key_pem(); let cert = cert.serialize_pem().unwrap(); diff --git a/actix-tls/tests/test_resolvers.rs b/actix-tls/tests/test_resolvers.rs index f0674383..24f22732 100644 --- a/actix-tls/tests/test_resolvers.rs +++ b/actix-tls/tests/test_resolvers.rs @@ -51,8 +51,7 @@ async fn custom_resolver_connect() { use trust_dns_resolver::TokioAsyncResolver; - let srv = - TestServer::start(|| fn_service(|_io: TcpStream| async { Ok::<_, io::Error>(()) })); + let srv = TestServer::start(|| fn_service(|_io: TcpStream| async { Ok::<_, io::Error>(()) })); struct MyResolver { trust_dns: TokioAsyncResolver, diff --git a/actix-tracing/CHANGES.md b/actix-tracing/CHANGES.md index f672659a..f61d3f2b 100644 --- a/actix-tracing/CHANGES.md +++ b/actix-tracing/CHANGES.md @@ -2,7 +2,7 @@ ## Unreleased - 2023-xx-xx -- Minimum supported Rust version (MSRV) is now 1.60. +- Minimum supported Rust version (MSRV) is now 1.65. ## 0.1.0 - 2020-01-15 diff --git a/actix-tracing/Cargo.toml b/actix-tracing/Cargo.toml index 27dfbc22..829a4b85 100644 --- a/actix-tracing/Cargo.toml +++ b/actix-tracing/Cargo.toml @@ -9,8 +9,8 @@ repository = "https://github.com/actix/actix-net.git" documentation = "https://docs.rs/actix-tracing" categories = ["network-programming", "asynchronous"] license = "MIT OR Apache-2.0" -edition = "2021" -rust-version = "1.60" +edition.workspace = true +rust-version.workspace = true [dependencies] actix-service = "2" diff --git a/actix-tracing/src/lib.rs b/actix-tracing/src/lib.rs index f5b08927..b1b9061b 100644 --- a/actix-tracing/src/lib.rs +++ b/actix-tracing/src/lib.rs @@ -118,9 +118,11 @@ where #[cfg(test)] mod test { - use std::cell::RefCell; - use std::collections::{BTreeMap, BTreeSet}; - use std::sync::{Arc, RwLock}; + use std::{ + cell::RefCell, + collections::{BTreeMap, BTreeSet}, + sync::{Arc, RwLock}, + }; use actix_service::{fn_factory, fn_service}; use slab::Slab; diff --git a/actix-utils/CHANGES.md b/actix-utils/CHANGES.md index af6434ab..fc7df208 100644 --- a/actix-utils/CHANGES.md +++ b/actix-utils/CHANGES.md @@ -2,7 +2,7 @@ ## Unreleased - 2023-xx-xx -- Minimum supported Rust version (MSRV) is now 1.60. +- Minimum supported Rust version (MSRV) is now 1.65. ## 3.0.1 - 2022-10-21 diff --git a/actix-utils/Cargo.toml b/actix-utils/Cargo.toml index 38d8af5e..e3c2553f 100644 --- a/actix-utils/Cargo.toml +++ b/actix-utils/Cargo.toml @@ -10,8 +10,8 @@ keywords = ["network", "framework", "async", "futures"] categories = ["network-programming", "asynchronous"] repository = "https://github.com/actix/actix-net" license = "MIT OR Apache-2.0" -edition = "2021" -rust-version = "1.60" +edition.workspace = true +rust-version.workspace = true [dependencies] pin-project-lite = "0.2" diff --git a/actix-utils/src/future/mod.rs b/actix-utils/src/future/mod.rs index 399b54d2..ec87428d 100644 --- a/actix-utils/src/future/mod.rs +++ b/actix-utils/src/future/mod.rs @@ -4,6 +4,8 @@ mod either; mod poll_fn; mod ready; -pub use self::either::Either; -pub use self::poll_fn::{poll_fn, PollFn}; -pub use self::ready::{err, ok, ready, Ready}; +pub use self::{ + either::Either, + poll_fn::{poll_fn, PollFn}, + ready::{err, ok, ready, Ready}, +}; diff --git a/bytestring/Cargo.toml b/bytestring/Cargo.toml index 21da5a95..ab0e43c6 100644 --- a/bytestring/Cargo.toml +++ b/bytestring/Cargo.toml @@ -11,8 +11,8 @@ categories = ["no-std", "web-programming"] homepage = "https://actix.rs" repository = "https://github.com/actix/actix-net.git" license = "MIT OR Apache-2.0" -edition = "2021" -rust-version = "1.60" +edition.workspace = true +rust-version.workspace = true [dependencies] bytes = { version = "1.2", default-features = false } diff --git a/bytestring/src/lib.rs b/bytestring/src/lib.rs index 3892d09e..9c0007a2 100644 --- a/bytestring/src/lib.rs +++ b/bytestring/src/lib.rs @@ -253,8 +253,10 @@ impl fmt::Display for ByteString { mod serde { use alloc::string::String; - use serde::de::{Deserialize, Deserializer}; - use serde::ser::{Serialize, Serializer}; + use serde::{ + de::{Deserialize, Deserializer}, + ser::{Serialize, Serializer}, + }; use super::ByteString; diff --git a/local-channel/CHANGES.md b/local-channel/CHANGES.md index b1bad2f5..957adfd9 100644 --- a/local-channel/CHANGES.md +++ b/local-channel/CHANGES.md @@ -2,7 +2,7 @@ ## Unreleased - 2023-xx-xx -- Minimum supported Rust version (MSRV) is now 1.60. +- Minimum supported Rust version (MSRV) is now 1.65. ## 0.1.3 - 2022-05-03 diff --git a/local-channel/Cargo.toml b/local-channel/Cargo.toml index 04a4b9b5..9e0f21b4 100644 --- a/local-channel/Cargo.toml +++ b/local-channel/Cargo.toml @@ -9,8 +9,8 @@ authors = [ repository = "https://github.com/actix/actix-net.git" keywords = ["channel", "local", "futures"] license = "MIT OR Apache-2.0" -edition = "2021" -rust-version = "1.60" +edition.workspace = true +rust-version.workspace = true [dependencies] futures-core = "0.3.17" diff --git a/local-waker/CHANGES.md b/local-waker/CHANGES.md index 68f4348b..f8aadaa6 100644 --- a/local-waker/CHANGES.md +++ b/local-waker/CHANGES.md @@ -2,7 +2,7 @@ ## Unreleased - 2023-xx-xx -- Minimum supported Rust version (MSRV) is now 1.60. +- Minimum supported Rust version (MSRV) is now 1.65. ## 0.1.3 - 2022-05-03 diff --git a/local-waker/Cargo.toml b/local-waker/Cargo.toml index 1baa08c0..640c47e1 100644 --- a/local-waker/Cargo.toml +++ b/local-waker/Cargo.toml @@ -10,7 +10,7 @@ repository = "https://github.com/actix/actix-net.git" keywords = ["waker", "local", "futures", "no-std"] categories = ["asynchronous", "no-std"] license = "MIT OR Apache-2.0" -edition = "2021" -rust-version = "1.60" +edition.workspace = true +rust-version.workspace = true [dependencies] diff --git a/rustfmt.toml b/rustfmt.toml deleted file mode 100644 index a8758a07..00000000 --- a/rustfmt.toml +++ /dev/null @@ -1,2 +0,0 @@ -max_width = 96 -group_imports = "StdExternalCrate" From 755b231e0049e31706141d4da2aeec6109f52555 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Martin=20Andr=C3=A9?= Date: Mon, 17 Jul 2023 05:10:36 +0200 Subject: [PATCH 02/10] add MPTCP socket protocol (optional) (#466) Co-authored-by: Rob Ede --- actix-server/CHANGES.md | 1 + actix-server/src/builder.rs | 41 +++++++++++++++++++++++++++++++++++-- actix-server/src/lib.rs | 5 ++++- actix-server/src/socket.rs | 26 +++++++++++++++++++++-- 4 files changed, 68 insertions(+), 5 deletions(-) diff --git a/actix-server/CHANGES.md b/actix-server/CHANGES.md index e98f9d2b..1f9f7b3c 100644 --- a/actix-server/CHANGES.md +++ b/actix-server/CHANGES.md @@ -2,6 +2,7 @@ ## Unreleased - 2023-xx-xx +- Add support for MultiPath TCP (MPTCP) with `MpTcp` enum and `ServerBuilder::mptcp()` method. - Minimum supported Rust version (MSRV) is now 1.65. ## 2.2.0 - 2022-12-21 diff --git a/actix-server/src/builder.rs b/actix-server/src/builder.rs index badac77b..e1d3a2d3 100644 --- a/actix-server/src/builder.rs +++ b/actix-server/src/builder.rs @@ -12,6 +12,22 @@ use crate::{ Server, }; +/// Multipath TCP (MPTCP) preference. +/// +/// Also see [`ServerBuilder::mptcp()`]. +#[derive(Debug, Clone)] +pub enum MpTcp { + /// MPTCP will not be used when binding sockets. + Disabled, + + /// MPTCP will be attempted when binding sockets. If errors occur, regular TCP will be + /// attempted, too. + TcpFallback, + + /// MPTCP will be used when binding sockets (with no fallback). + NoFallback, +} + /// [Server] builder. pub struct ServerBuilder { pub(crate) threads: usize, @@ -19,6 +35,7 @@ pub struct ServerBuilder { pub(crate) backlog: u32, pub(crate) factories: Vec>, pub(crate) sockets: Vec<(usize, String, MioListener)>, + pub(crate) mptcp: MpTcp, pub(crate) exit: bool, pub(crate) listen_os_signals: bool, pub(crate) cmd_tx: UnboundedSender, @@ -43,6 +60,7 @@ impl ServerBuilder { factories: Vec::new(), sockets: Vec::new(), backlog: 2048, + mptcp: MpTcp::Disabled, exit: false, listen_os_signals: true, cmd_tx, @@ -96,6 +114,24 @@ impl ServerBuilder { self } + /// Sets MultiPath TCP (MPTCP) preference on bound sockets. + /// + /// Multipath TCP (MPTCP) builds on top of TCP to improve connection redundancy and performance + /// by sharing a network data stream across multiple underlying TCP sessions. See [mptcp.dev] + /// for more info about MPTCP itself. + /// + /// MPTCP is available on Linux kernel version 5.6 and higher. In addition, you'll also need to + /// ensure the kernel option is enabled using `sysctl net.mptcp.enabled=1`. + /// + /// This method will have no effect if called after a `bind()`. + /// + /// [mptcp.dev]: https://www.mptcp.dev + #[cfg(target_os = "linux")] + pub fn mptcp(mut self, mptcp_enabled: MpTcp) -> Self { + self.mptcp = mptcp_enabled; + self + } + /// Sets the maximum per-worker number of concurrent connections. /// /// All socket listeners will stop accepting connections when this limit is reached for @@ -144,7 +180,7 @@ impl ServerBuilder { U: ToSocketAddrs, N: AsRef, { - let sockets = bind_addr(addr, self.backlog)?; + let sockets = bind_addr(addr, self.backlog, &self.mptcp)?; trace!("binding server to: {:?}", &sockets); @@ -260,13 +296,14 @@ impl ServerBuilder { pub(super) fn bind_addr( addr: S, backlog: u32, + mptcp: &MpTcp, ) -> io::Result> { let mut opt_err = None; let mut success = false; let mut sockets = Vec::new(); for addr in addr.to_socket_addrs()? { - match create_mio_tcp_listener(addr, backlog) { + match create_mio_tcp_listener(addr, backlog, mptcp) { Ok(lst) => { success = true; sockets.push(lst); diff --git a/actix-server/src/lib.rs b/actix-server/src/lib.rs index 5e265d74..24adf8ff 100644 --- a/actix-server/src/lib.rs +++ b/actix-server/src/lib.rs @@ -21,7 +21,10 @@ mod worker; #[doc(hidden)] pub use self::socket::FromStream; pub use self::{ - builder::ServerBuilder, handle::ServerHandle, server::Server, service::ServerServiceFactory, + builder::{MpTcp, ServerBuilder}, + handle::ServerHandle, + server::Server, + service::ServerServiceFactory, test_server::TestServer, }; diff --git a/actix-server/src/socket.rs b/actix-server/src/socket.rs index f0942e38..486c0d46 100644 --- a/actix-server/src/socket.rs +++ b/actix-server/src/socket.rs @@ -11,6 +11,8 @@ pub(crate) use { mio::net::UnixListener as MioUnixListener, std::os::unix::net::UnixListener as StdUnixListener, }; +use crate::builder::MpTcp; + pub(crate) enum MioListener { Tcp(MioTcpListener), #[cfg(unix)] @@ -223,10 +225,30 @@ mod unix_impl { pub(crate) fn create_mio_tcp_listener( addr: StdSocketAddr, backlog: u32, + mptcp: &MpTcp, ) -> io::Result { use socket2::{Domain, Protocol, Socket, Type}; - let socket = Socket::new(Domain::for_address(addr), Type::STREAM, Some(Protocol::TCP))?; + #[cfg(not(target_os = "linux"))] + let protocol = Protocol::TCP; + #[cfg(target_os = "linux")] + let protocol = if matches!(mptcp, MpTcp::Disabled) { + Protocol::TCP + } else { + Protocol::MPTCP + }; + + let socket = match Socket::new(Domain::for_address(addr), Type::STREAM, Some(protocol)) { + Ok(sock) => sock, + + Err(err) if matches!(mptcp, MpTcp::TcpFallback) => { + tracing::warn!("binding socket as MPTCP failed: {err}"); + tracing::warn!("falling back to TCP"); + Socket::new(Domain::for_address(addr), Type::STREAM, Some(Protocol::TCP))? + } + + Err(err) => return Err(err), + }; socket.set_reuse_address(true)?; socket.set_nonblocking(true)?; @@ -247,7 +269,7 @@ mod tests { assert_eq!(format!("{}", addr), "127.0.0.1:8080"); let addr: StdSocketAddr = "127.0.0.1:0".parse().unwrap(); - let lst = create_mio_tcp_listener(addr, 128).unwrap(); + let lst = create_mio_tcp_listener(addr, 128, &MpTcp::Disabled).unwrap(); let lst = MioListener::Tcp(lst); assert!(format!("{:?}", lst).contains("TcpListener")); assert!(format!("{}", lst).contains("127.0.0.1")); From e539f83615b4cc853cd49c58be15c3bc25fec177 Mon Sep 17 00:00:00 2001 From: Rob Ede Date: Tue, 18 Jul 2023 01:47:37 +0100 Subject: [PATCH 03/10] attempt windows CI fix --- .github/workflows/ci.yml | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index cd9c5848..ce5250c5 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -40,10 +40,12 @@ jobs: - name: Install OpenSSL if: matrix.target.os == 'windows-latest' - run: choco install openssl + run: choco install openssl -y --forcex64 --no-progress - name: Set OpenSSL dir in env if: matrix.target.os == 'windows-latest' - run: echo 'OPENSSL_DIR=C:\Program Files\OpenSSL-Win64' | Out-File -FilePath $env:GITHUB_ENV -Append + run: | + echo 'OPENSSL_DIR=C:\Program Files\OpenSSL-Win64' | Out-File -FilePath $env:GITHUB_ENV -Append + echo 'OPENSSL_DIR=C:\Program Files\OpenSSL' | Out-File -FilePath $env:GITHUB_ENV -Append - name: Install Rust (${{ matrix.version }}) uses: actions-rust-lang/setup-rust-toolchain@v1 From 462ab6a4f091f9b3468569e521240c2dcb4021bc Mon Sep 17 00:00:00 2001 From: Rob Ede Date: Tue, 18 Jul 2023 02:06:01 +0100 Subject: [PATCH 04/10] ci: try to fix master jobs on windows --- .github/workflows/ci-master.yml | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci-master.yml b/.github/workflows/ci-master.yml index 66bc042e..1fae5c39 100644 --- a/.github/workflows/ci-master.yml +++ b/.github/workflows/ci-master.yml @@ -39,10 +39,12 @@ jobs: - name: Install OpenSSL if: matrix.target.os == 'windows-latest' - run: choco install openssl + run: choco install openssl -y --forcex64 --no-progress - name: Set OpenSSL dir in env if: matrix.target.os == 'windows-latest' - run: echo 'OPENSSL_DIR=C:\Program Files\OpenSSL-Win64' | Out-File -FilePath $env:GITHUB_ENV -Append + run: | + echo 'OPENSSL_DIR=C:\Program Files\OpenSSL-Win64' | Out-File -FilePath $env:GITHUB_ENV -Append + echo 'OPENSSL_DIR=C:\Program Files\OpenSSL' | Out-File -FilePath $env:GITHUB_ENV -Append - name: Install Rust (${{ matrix.version }}) uses: actions-rust-lang/setup-rust-toolchain@v1 From 3c4b0c275584f76acf5c0e12b3a4557dddf4c9a6 Mon Sep 17 00:00:00 2001 From: Rob Ede Date: Wed, 19 Jul 2023 23:49:31 +0100 Subject: [PATCH 05/10] ci: rename post-merge workflow --- .github/workflows/{ci-master.yml => ci-post-merge.yml} | 9 +++------ .github/workflows/ci.yml | 2 +- 2 files changed, 4 insertions(+), 7 deletions(-) rename .github/workflows/{ci-master.yml => ci-post-merge.yml} (94%) diff --git a/.github/workflows/ci-master.yml b/.github/workflows/ci-post-merge.yml similarity index 94% rename from .github/workflows/ci-master.yml rename to .github/workflows/ci-post-merge.yml index 1fae5c39..c107bb53 100644 --- a/.github/workflows/ci-master.yml +++ b/.github/workflows/ci-post-merge.yml @@ -51,7 +51,7 @@ jobs: with: toolchain: ${{ matrix.version }} - - uses: taiki-e/cache-cargo-install-action@v1 + - uses: taiki-e/install-action@v2 with: { tool: cargo-hack } - name: check lib @@ -121,11 +121,8 @@ jobs: uses: actions-rust-lang/setup-rust-toolchain@v1 with: { toolchain: nightly } - - uses: taiki-e/cache-cargo-install-action@v1 - with: { tool: cargo-minimal-versions } - - - uses: taiki-e/cache-cargo-install-action@v1 - with: { tool: cargo-hack } + - uses: taiki-e/install-action@v1 + with: { tool: cargo-hack, cargo-minimal-versions } - name: Check With Minimal Versions run: cargo minimal-versions check diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index ce5250c5..866ed107 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -52,7 +52,7 @@ jobs: with: toolchain: ${{ matrix.version }} - - uses: taiki-e/cache-cargo-install-action@v1 + - uses: taiki-e/install-action@v1 with: { tool: cargo-hack } - name: Generate Cargo.lock From 3eba5b152e889ab45e24fcabdc1ddb4f06799d6f Mon Sep 17 00:00:00 2001 From: Rob Ede Date: Wed, 19 Jul 2023 23:52:56 +0100 Subject: [PATCH 06/10] prepare actix-macros release 0.2.4 --- actix-macros/CHANGES.md | 18 ++++++++++-------- actix-macros/Cargo.toml | 2 +- 2 files changed, 11 insertions(+), 9 deletions(-) diff --git a/actix-macros/CHANGES.md b/actix-macros/CHANGES.md index 9385808c..570c4e1e 100644 --- a/actix-macros/CHANGES.md +++ b/actix-macros/CHANGES.md @@ -1,48 +1,50 @@ # Changes -## Unreleased - 2023-xx-xx +## Unreleased + +## 0.2.4 - Update `syn` dependency to `2`. - Minimum supported Rust version (MSRV) is now 1.65. -## 0.2.3 - 2021-10-19 +## 0.2.3 - Fix test macro in presence of other imports named "test". [#399] [#399]: https://github.com/actix/actix-net/pull/399 -## 0.2.2 - 2021-10-14 +## 0.2.2 - Improve error recovery potential when macro input is invalid. [#391] - Allow custom `System`s on test macro. [#391] [#391]: https://github.com/actix/actix-net/pull/391 -## 0.2.1 - 2021-02-02 +## 0.2.1 - Add optional argument `system` to `main` macro which can be used to specify the path to `actix_rt::System` (useful for re-exports). [#363] [#363]: https://github.com/actix/actix-net/pull/363 -## 0.2.0 - 2021-02-02 +## 0.2.0 - Update to latest `actix_rt::System::new` signature. [#261] [#261]: https://github.com/actix/actix-net/pull/261 -## 0.2.0-beta.1 - 2021-01-09 +## 0.2.0-beta.1 - Remove `actix-reexport` feature. [#218] [#218]: https://github.com/actix/actix-net/pull/218 -## 0.1.3 - 2020-12-03 +## 0.1.3 - Add `actix-reexport` feature. [#218] [#218]: https://github.com/actix/actix-net/pull/218 -## 0.1.2 - 2020-05-18 +## 0.1.2 - Forward actix_rt::test arguments to test function [#127] diff --git a/actix-macros/Cargo.toml b/actix-macros/Cargo.toml index 4aba5e53..4ec4867d 100644 --- a/actix-macros/Cargo.toml +++ b/actix-macros/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "actix-macros" -version = "0.2.3" +version = "0.2.4" authors = [ "Nikolay Kim ", "Ibraheem Ahmed ", From 9017de439f5c660ecd5710188d8646bb29510d9d Mon Sep 17 00:00:00 2001 From: Rob Ede Date: Thu, 20 Jul 2023 00:22:55 +0100 Subject: [PATCH 07/10] ci: fix post-merge tool installs --- .github/workflows/ci-post-merge.yml | 16 ++++++++++------ actix-macros/src/lib.rs | 4 ++-- 2 files changed, 12 insertions(+), 8 deletions(-) diff --git a/.github/workflows/ci-post-merge.yml b/.github/workflows/ci-post-merge.yml index c107bb53..27f541a3 100644 --- a/.github/workflows/ci-post-merge.yml +++ b/.github/workflows/ci-post-merge.yml @@ -101,11 +101,13 @@ jobs: uses: actions-rust-lang/setup-rust-toolchain@v1 with: { toolchain: nightly } + - name: Install cargo-tarpaulin + uses: taiki-e/install-action@v1 + with: { tool: cargo-tarpaulin } + - name: Generate coverage file if: github.ref == 'refs/heads/master' - run: | - cargo install cargo-tarpaulin - cargo tarpaulin --out Xml --verbose + run: cargo tarpaulin --out Xml --verbose - name: Upload to Codecov if: github.ref == 'refs/heads/master' uses: codecov/codecov-action@v3 @@ -121,8 +123,9 @@ jobs: uses: actions-rust-lang/setup-rust-toolchain@v1 with: { toolchain: nightly } - - uses: taiki-e/install-action@v1 - with: { tool: cargo-hack, cargo-minimal-versions } + - name: Install cargo-hack & cargo-minimal-versions + uses: taiki-e/install-action@v1 + with: { tool: 'cargo-hack,cargo-minimal-versions' } - name: Check With Minimal Versions run: cargo minimal-versions check @@ -137,7 +140,8 @@ jobs: uses: actions-rust-lang/setup-rust-toolchain@v1 - name: Install cargo-nextest - run: cargo install cargo-nextest + uses: taiki-e/install-action@v1 + with: { tool: cargo-nextest } - name: Test with cargo-nextest run: cargo nextest run diff --git a/actix-macros/src/lib.rs b/actix-macros/src/lib.rs index 020b16db..481d1145 100644 --- a/actix-macros/src/lib.rs +++ b/actix-macros/src/lib.rs @@ -28,8 +28,8 @@ type AttributeArgs = syn::punctuated::Punctuated; /// println!("Hello world"); /// } /// ``` -// #[allow(clippy::needless_doctest_main)] -// #[cfg(not(test))] // Work around for rust-lang/rust#62127 +#[allow(clippy::needless_doctest_main)] +#[cfg(not(test))] // Work around for rust-lang/rust#62127 #[proc_macro_attribute] pub fn main(args: TokenStream, item: TokenStream) -> TokenStream { let mut input = match syn::parse::(item.clone()) { From 9cb8a1fadcc5caf11243609f6da4f0cd57b0094d Mon Sep 17 00:00:00 2001 From: Rob Ede Date: Mon, 24 Jul 2023 03:27:44 +0100 Subject: [PATCH 08/10] remove lint exception --- actix-macros/src/lib.rs | 2 -- 1 file changed, 2 deletions(-) diff --git a/actix-macros/src/lib.rs b/actix-macros/src/lib.rs index 481d1145..cd546f0e 100644 --- a/actix-macros/src/lib.rs +++ b/actix-macros/src/lib.rs @@ -28,8 +28,6 @@ type AttributeArgs = syn::punctuated::Punctuated; /// println!("Hello world"); /// } /// ``` -#[allow(clippy::needless_doctest_main)] -#[cfg(not(test))] // Work around for rust-lang/rust#62127 #[proc_macro_attribute] pub fn main(args: TokenStream, item: TokenStream) -> TokenStream { let mut input = match syn::parse::(item.clone()) { From 6ce830706054700db778134e7daa4426d582891c Mon Sep 17 00:00:00 2001 From: Rob Ede Date: Thu, 24 Aug 2023 00:56:31 +0100 Subject: [PATCH 09/10] remove num_cpus dependency (#488) --- .github/workflows/ci.yml | 4 ++ actix-server/CHANGES.md | 88 ++++++++++++++++++------------------- actix-server/Cargo.toml | 1 - actix-server/src/builder.rs | 10 ++++- actix-server/src/worker.rs | 8 +++- scripts/free-disk-space.sh | 53 ++++++++++++++++++++++ 6 files changed, 115 insertions(+), 49 deletions(-) create mode 100755 scripts/free-disk-space.sh diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 866ed107..20632f63 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -37,6 +37,10 @@ jobs: run: sudo ifconfig lo0 alias 127.0.0.3 - uses: actions/checkout@v3 + + - name: Free Disk Space + if: matrix.target.os == 'ubuntu-latest' + run: ./scripts/free-disk-space.sh - name: Install OpenSSL if: matrix.target.os == 'windows-latest' diff --git a/actix-server/CHANGES.md b/actix-server/CHANGES.md index 1f9f7b3c..ffe3f2a1 100644 --- a/actix-server/CHANGES.md +++ b/actix-server/CHANGES.md @@ -1,22 +1,22 @@ # Changes -## Unreleased - 2023-xx-xx +## Unreleased - Add support for MultiPath TCP (MPTCP) with `MpTcp` enum and `ServerBuilder::mptcp()` method. - Minimum supported Rust version (MSRV) is now 1.65. -## 2.2.0 - 2022-12-21 +## 2.2.0 - Minimum supported Rust version (MSRV) is now 1.59. - Update `tokio-uring` dependency to `0.4`. [#473] [#473]: https://github.com/actix/actix-net/pull/473 -## 2.1.1 - 2022-03-09 +## 2.1.1 - No significant changes since `2.1.0`. -## 2.1.0 - 2022-03-08 +## 2.1.0 - Update `tokio-uring` dependency to `0.3`. [#448] - Logs emitted now use the `tracing` crate with `log` compatibility. [#448] @@ -25,27 +25,27 @@ [#443]: https://github.com/actix/actix-net/pull/443 [#448]: https://github.com/actix/actix-net/pull/448 -## 2.0.0 - 2022-01-19 +## 2.0.0 - No significant changes since `2.0.0-rc.4`. -## 2.0.0-rc.4 - 2022-01-12 +## 2.0.0-rc.4 - Update `tokio-uring` dependency to `0.2`. [#436] [#436]: https://github.com/actix/actix-net/pull/436 -## 2.0.0-rc.3 - 2021-12-31 +## 2.0.0-rc.3 - No significant changes since `2.0.0-rc.2`. -## 2.0.0-rc.2 - 2021-12-27 +## 2.0.0-rc.2 - Simplify `TestServer`. [#431] [#431]: https://github.com/actix/actix-net/pull/431 -## 2.0.0-rc.1 - 2021-12-05 +## 2.0.0-rc.1 - Hide implementation details of `Server`. [#424] - `Server` now runs only after awaiting it. [#425] @@ -53,19 +53,19 @@ [#424]: https://github.com/actix/actix-net/pull/424 [#425]: https://github.com/actix/actix-net/pull/425 -## 2.0.0-beta.9 - 2021-11-15 +## 2.0.0-beta.9 - Restore `Arbiter` support lost in `beta.8`. [#417] [#417]: https://github.com/actix/actix-net/pull/417 -## 2.0.0-beta.8 - 2021-11-05 _(YANKED)_ +## 2.0.0-beta.8 - Fix non-unix signal handler. [#410] [#410]: https://github.com/actix/actix-net/pull/410 -## 2.0.0-beta.7 - 2021-11-05 _(YANKED)_ +## 2.0.0-beta.7 - Server can be started in regular Tokio runtime. [#408] - Expose new `Server` type whose `Future` impl resolves when server stops. [#408] @@ -78,7 +78,7 @@ [#407]: https://github.com/actix/actix-net/pull/407 [#408]: https://github.com/actix/actix-net/pull/408 -## 2.0.0-beta.6 - 2021-10-11 +## 2.0.0-beta.6 - Add experimental (semver-exempt) `io-uring` feature for enabling async file I/O on linux. [#374] - Server no long listens to `SIGHUP` signal. Previously, the received was not used but did block subsequent exit signals from working. [#389] @@ -89,19 +89,19 @@ [#349]: https://github.com/actix/actix-net/pull/349 [#389]: https://github.com/actix/actix-net/pull/389 -## 2.0.0-beta.5 - 2021-04-20 +## 2.0.0-beta.5 - Server shutdown notifies all workers to exit regardless if shutdown is graceful. This causes all workers to shutdown immediately in force shutdown case. [#333] [#333]: https://github.com/actix/actix-net/pull/333 -## 2.0.0-beta.4 - 2021-04-01 +## 2.0.0-beta.4 - Prevent panic when `shutdown_timeout` is very large. [f9262db] [f9262db]: https://github.com/actix/actix-net/commit/f9262db -## 2.0.0-beta.3 - 2021-02-06 +## 2.0.0-beta.3 - Hidden `ServerBuilder::start` method has been removed. Use `ServerBuilder::run`. [#246] - Add retry for EINTR signal (`io::Interrupted`) in `Accept`'s poll loop. [#264] @@ -113,13 +113,13 @@ [#265]: https://github.com/actix/actix-net/pull/265 [#273]: https://github.com/actix/actix-net/pull/273 -## 2.0.0-beta.2 - 2021-01-03 +## 2.0.0-beta.2 - Merge `actix-testing` to `actix-server` as `test_server` mod. [#242] [#242]: https://github.com/actix/actix-net/pull/242 -## 2.0.0-beta.1 - 2020-12-28 +## 2.0.0-beta.1 - Added explicit info log message on accept queue pause. [#215] - Prevent double registration of sockets when back-pressure is resolved. [#223] @@ -134,127 +134,127 @@ [#223]: https://github.com/actix/actix-net/pull/223 [#239]: https://github.com/actix/actix-net/pull/239 -## 1.0.4 - 2020-09-12 +## 1.0.4 - Update actix-codec to 0.3.0. - Workers must be greater than 0. [#167] [#167]: https://github.com/actix/actix-net/pull/167 -## 1.0.3 - 2020-05-19 +## 1.0.3 - Replace deprecated `net2` crate with `socket2` [#140] [#140]: https://github.com/actix/actix-net/pull/140 -## 1.0.2 - 2020-02-26 +## 1.0.2 - Avoid error by calling `reregister()` on Windows [#103] [#103]: https://github.com/actix/actix-net/pull/103 -## 1.0.1 - 2019-12-29 +## 1.0.1 - Rename `.start()` method to `.run()` -## 1.0.0 - 2019-12-11 +## 1.0.0 - Use actix-net releases -## 1.0.0-alpha.4 - 2019-12-08 +## 1.0.0-alpha.4 - Use actix-service 1.0.0-alpha.4 -## 1.0.0-alpha.3 - 2019-12-07 +## 1.0.0-alpha.3 - Migrate to tokio 0.2 - Fix compilation on non-unix platforms - Better handling server configuration -## 1.0.0-alpha.2 - 2019-12-02 +## 1.0.0-alpha.2 - Simplify server service (remove actix-server-config) - Allow to wait on `Server` until server stops -## 0.8.0-alpha.1 - 2019-11-22 +## 0.8.0-alpha.1 - Migrate to `std::future` -## 0.7.0 - 2019-10-04 +## 0.7.0 - Update `rustls` to 0.16 - Minimum required Rust version upped to 1.37.0 -## 0.6.1 - 2019-09-25 +## 0.6.1 - Add UDS listening support to `ServerBuilder` -## 0.6.0 - 2019-07-18 +## 0.6.0 - Support Unix domain sockets #3 -## 0.5.1 - 2019-05-18 +## 0.5.1 - ServerBuilder::shutdown_timeout() accepts u64 -## 0.5.0 - 2019-05-12 +## 0.5.0 - Add `Debug` impl for `SslError` - Derive debug for `Server` and `ServerCommand` - Upgrade to actix-service 0.4 -## 0.4.3 - 2019-04-16 +## 0.4.3 - Re-export `IoStream` trait - Depend on `ssl` and `rust-tls` features from actix-server-config -## 0.4.2 - 2019-03-30 +## 0.4.2 - Fix SIGINT force shutdown -## 0.4.1 - 2019-03-14 +## 0.4.1 - `SystemRuntime::on_start()` - allow to run future before server service initialization -## 0.4.0 - 2019-03-12 +## 0.4.0 - Use `ServerConfig` for service factory - Wrap tcp socket to `Io` type - Upgrade actix-service -## 0.3.1 - 2019-03-04 +## 0.3.1 - Add `ServerBuilder::maxconnrate` sets the maximum per-worker number of concurrent connections - Add helper ssl error `SslError` - Rename `StreamServiceFactory` to `ServiceFactory` - Deprecate `StreamServiceFactory` -## 0.3.0 - 2019-03-02 +## 0.3.0 - Use new `NewService` trait -## 0.2.1 - 2019-02-09 +## 0.2.1 - Drop service response -## 0.2.0 - 2019-02-01 +## 0.2.0 - Migrate to actix-service 0.2 - Updated rustls dependency -## 0.1.3 - 2018-12-21 +## 0.1.3 - Fix max concurrent connections handling -## 0.1.2 - 2018-12-12 +## 0.1.2 - rename ServiceConfig::rt() to ServiceConfig::apply() - Fix back-pressure for concurrent ssl handshakes -## 0.1.1 - 2018-12-11 +## 0.1.1 - Fix signal handling on windows -## 0.1.0 - 2018-12-09 +## 0.1.0 - Move server to separate crate diff --git a/actix-server/Cargo.toml b/actix-server/Cargo.toml index 62f13107..53f54f79 100755 --- a/actix-server/Cargo.toml +++ b/actix-server/Cargo.toml @@ -27,7 +27,6 @@ actix-utils = "3" futures-core = { version = "0.3.17", default-features = false, features = ["alloc"] } futures-util = { version = "0.3.17", default-features = false, features = ["alloc"] } mio = { version = "0.8", features = ["os-poll", "net"] } -num_cpus = "1.13" socket2 = "0.5" tokio = { version = "1.23.1", features = ["sync"] } tracing = { version = "0.1.30", default-features = false, features = ["log"] } diff --git a/actix-server/src/builder.rs b/actix-server/src/builder.rs index e1d3a2d3..42addafc 100644 --- a/actix-server/src/builder.rs +++ b/actix-server/src/builder.rs @@ -1,4 +1,4 @@ -use std::{io, time::Duration}; +use std::{io, num::NonZeroUsize, time::Duration}; use actix_rt::net::TcpStream; use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender}; @@ -55,7 +55,7 @@ impl ServerBuilder { let (cmd_tx, cmd_rx) = unbounded_channel(); ServerBuilder { - threads: num_cpus::get_physical(), + threads: std::thread::available_parallelism().map_or(2, NonZeroUsize::get), token: 0, factories: Vec::new(), sockets: Vec::new(), @@ -76,6 +76,12 @@ impl ServerBuilder { /// The default worker count is the number of physical CPU cores available. If your benchmark /// testing indicates that simultaneous multi-threading is beneficial to your app, you can use /// the [`num_cpus`] crate to acquire the _logical_ core count instead. + /// + /// # Panics + /// + /// Panics if `num` is 0. + /// + /// [`num_cpus`]: https://docs.rs/num_cpus pub fn workers(mut self, num: usize) -> Self { assert_ne!(num, 0, "workers must be greater than 0"); self.threads = num; diff --git a/actix-server/src/worker.rs b/actix-server/src/worker.rs index a9ae97a0..d72cd2db 100644 --- a/actix-server/src/worker.rs +++ b/actix-server/src/worker.rs @@ -1,6 +1,7 @@ use std::{ future::Future, io, mem, + num::NonZeroUsize, pin::Pin, rc::Rc, sync::{ @@ -249,8 +250,11 @@ pub(crate) struct ServerWorkerConfig { impl Default for ServerWorkerConfig { fn default() -> Self { - // 512 is the default max blocking thread count of tokio runtime. - let max_blocking_threads = std::cmp::max(512 / num_cpus::get_physical(), 1); + let parallelism = std::thread::available_parallelism().map_or(2, NonZeroUsize::get); + + // 512 is the default max blocking thread count of a Tokio runtime. + let max_blocking_threads = std::cmp::max(512 / parallelism, 1); + Self { shutdown_timeout: Duration::from_secs(30), max_blocking_threads, diff --git a/scripts/free-disk-space.sh b/scripts/free-disk-space.sh new file mode 100755 index 00000000..2946cfcf --- /dev/null +++ b/scripts/free-disk-space.sh @@ -0,0 +1,53 @@ +#!/usr/bin/env bash + +# Licensed to the Apache Software Foundation (ASF) under one or more +# contributor license agreements. See the NOTICE file distributed with +# this work for additional information regarding copyright ownership. +# The ASF licenses this file to You under the Apache License, Version 2.0 +# (the "License"); you may not use this file except in compliance with +# the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# The Azure provided machines typically have the following disk allocation: +# Total space: 85GB +# Allocated: 67 GB +# Free: 17 GB +# This script frees up 28 GB of disk space by deleting unneeded packages and +# large directories. +# The Flink end to end tests download and generate more than 17 GB of files, +# causing unpredictable behavior and build failures. + +echo "==============================================================================" +echo "Freeing up disk space on CI system" +echo "==============================================================================" + +echo "Listing 100 largest packages" +dpkg-query -Wf '${Installed-Size}\t${Package}\n' | sort -n | tail -n 100 +df -h + +echo "Removing large packages" +sudo apt-get remove -y '^dotnet-.*' +sudo apt-get remove -y 'php.*' +sudo apt-get remove -y '^mongodb-.*' +sudo apt-get remove -y '^mysql-.*' +sudo apt-get remove -y azure-cli google-cloud-sdk hhvm google-chrome-stable firefox powershell mono-devel libgl1-mesa-dri +sudo apt-get autoremove -y +sudo apt-get clean +df -h + +echo "Removing large directories" +sudo rm -rf /usr/share/dotnet/ +sudo rm -rf /usr/local/graalvm/ +sudo rm -rf /usr/local/.ghcup/ +sudo rm -rf /usr/local/share/powershell +sudo rm -rf /usr/local/share/chromium +sudo rm -rf /usr/local/lib/android +sudo rm -rf /usr/local/lib/node_modules +df -h From 0bc310a656160d8425764bbef46ff9afe92f28bc Mon Sep 17 00:00:00 2001 From: Rob Ede Date: Sat, 26 Aug 2023 14:59:51 +0100 Subject: [PATCH 10/10] Rustls v0.21 support (#480) --- .cargo/config.toml | 6 +- .github/workflows/ci-post-merge.yml | 16 +- .github/workflows/ci.yml | 16 +- Cargo.toml | 1 + actix-server/src/worker.rs | 3 + actix-tls/CHANGES.md | 49 +++-- actix-tls/Cargo.toml | 30 ++- actix-tls/examples/accept-rustls.rs | 20 +- actix-tls/src/accept/mod.rs | 18 +- .../src/accept/{rustls.rs => rustls_0_20.rs} | 5 +- actix-tls/src/accept/rustls_0_21.rs | 198 ++++++++++++++++++ actix-tls/src/connect/mod.rs | 11 +- .../src/connect/{rustls.rs => rustls_0_20.rs} | 33 +-- actix-tls/src/connect/rustls_0_21.rs | 154 ++++++++++++++ actix-tls/tests/accept-openssl.rs | 5 +- actix-tls/tests/accept-rustls.rs | 5 +- actix-tls/tests/test_connect.rs | 4 +- actix-utils/src/counter.rs | 4 +- actix-utils/src/future/poll_fn.rs | 1 + 19 files changed, 504 insertions(+), 75 deletions(-) rename actix-tls/src/accept/{rustls.rs => rustls_0_20.rs} (97%) create mode 100644 actix-tls/src/accept/rustls_0_21.rs rename actix-tls/src/connect/{rustls.rs => rustls_0_20.rs} (78%) create mode 100644 actix-tls/src/connect/rustls_0_21.rs diff --git a/.cargo/config.toml b/.cargo/config.toml index c4f6e3f6..a114083f 100644 --- a/.cargo/config.toml +++ b/.cargo/config.toml @@ -15,9 +15,11 @@ ci-check-linux = "hack --workspace --feature-powerset check --tests --examples" # tests avoiding io-uring feature ci-test = "hack --feature-powerset --exclude-features=io-uring test --lib --tests --no-fail-fast -- --nocapture" +ci-test-rustls-020 = "hack --feature-powerset --exclude-features=io-uring,rustls-0_21 test --lib --tests --no-fail-fast -- --nocapture" +ci-test-rustls-021 = "hack --feature-powerset --exclude-features=io-uring,rustls-0_20 test --lib --tests --no-fail-fast -- --nocapture" # tests avoiding io-uring feature on Windows -ci-test-win = "hack --feature-powerset --depth 2 --exclude-features=io-uring test --lib --tests --no-fail-fast -- --nocapture" +ci-test-win = "hack --feature-powerset --depth=2 --exclude-features=io-uring test --lib --tests --no-fail-fast -- --nocapture" # test with io-uring feature -ci-test-linux = "hack --feature-powerset test --lib --tests --no-fail-fast -- --nocapture" +ci-test-linux = "hack --feature-powerset --exclude-features=rustls-0_20 test --lib --tests --no-fail-fast -- --nocapture" diff --git a/.github/workflows/ci-post-merge.yml b/.github/workflows/ci-post-merge.yml index 27f541a3..30bca39e 100644 --- a/.github/workflows/ci-post-merge.yml +++ b/.github/workflows/ci-post-merge.yml @@ -16,6 +16,7 @@ jobs: strategy: fail-fast: false matrix: + # prettier-ignore target: - { name: Linux, os: ubuntu-latest, triple: x86_64-unknown-linux-gnu } - { name: macOS, os: macos-latest, triple: x86_64-apple-darwin } @@ -37,6 +38,10 @@ jobs: - uses: actions/checkout@v3 + - name: Free Disk Space + if: matrix.target.os == 'ubuntu-latest' + run: ./scripts/free-disk-space.sh + - name: Install OpenSSL if: matrix.target.os == 'windows-latest' run: choco install openssl -y --forcex64 --no-progress @@ -83,8 +88,15 @@ jobs: run: cargo ci-test - name: tests if: matrix.target.os == 'ubuntu-latest' - run: | - sudo bash -c "ulimit -Sl 512 && ulimit -Hl 512 && PATH=$PATH:/usr/share/rust/.cargo/bin && RUSTUP_TOOLCHAIN=${{ matrix.version }} cargo ci-test && RUSTUP_TOOLCHAIN=${{ matrix.version }} cargo ci-test-linux" + run: >- + sudo bash -c " + ulimit -Sl 512 + && ulimit -Hl 512 + && PATH=$PATH:/usr/share/rust/.cargo/bin + && RUSTUP_TOOLCHAIN=${{ matrix.version }} cargo ci-test-rustls-020 + && RUSTUP_TOOLCHAIN=${{ matrix.version }} cargo ci-test-rustls-021 + && RUSTUP_TOOLCHAIN=${{ matrix.version }} cargo ci-test-linux + " - name: Clear the cargo caches run: | diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 20632f63..74315e6a 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -1,6 +1,6 @@ name: CI -on: +on: pull_request: {} push: { branches: [master] } @@ -16,6 +16,7 @@ jobs: strategy: fail-fast: false matrix: + # prettier-ignore target: - { name: Linux, os: ubuntu-latest, triple: x86_64-unknown-linux-gnu } - { name: macOS, os: macos-latest, triple: x86_64-apple-darwin } @@ -37,7 +38,7 @@ jobs: run: sudo ifconfig lo0 alias 127.0.0.3 - uses: actions/checkout@v3 - + - name: Free Disk Space if: matrix.target.os == 'ubuntu-latest' run: ./scripts/free-disk-space.sh @@ -99,8 +100,15 @@ jobs: run: cargo ci-test-win - name: tests if: matrix.target.os == 'ubuntu-latest' - run: | - sudo bash -c "ulimit -Sl 512 && ulimit -Hl 512 && PATH=$PATH:/usr/share/rust/.cargo/bin && RUSTUP_TOOLCHAIN=${{ matrix.version }} cargo ci-test && RUSTUP_TOOLCHAIN=${{ matrix.version }} cargo ci-test-linux" + run: >- + sudo bash -c " + ulimit -Sl 512 + && ulimit -Hl 512 + && PATH=$PATH:/usr/share/rust/.cargo/bin + && RUSTUP_TOOLCHAIN=${{ matrix.version }} cargo ci-test-rustls-020 + && RUSTUP_TOOLCHAIN=${{ matrix.version }} cargo ci-test-rustls-021 + && RUSTUP_TOOLCHAIN=${{ matrix.version }} cargo ci-test-linux + " - name: Clear the cargo caches run: | diff --git a/Cargo.toml b/Cargo.toml index 62897764..696de4a5 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -15,6 +15,7 @@ members = [ resolver = "2" [workspace.package] +license = "MIT OR Apache-2.0" edition = "2021" rust-version = "1.65" diff --git a/actix-server/src/worker.rs b/actix-server/src/worker.rs index d72cd2db..7050fcd2 100644 --- a/actix-server/src/worker.rs +++ b/actix-server/src/worker.rs @@ -625,6 +625,7 @@ impl Future for ServerWorker { self.poll(cx) } }, + WorkerState::Restarting(ref mut restart) => { let factory_id = restart.factory_id; let token = restart.token; @@ -649,6 +650,7 @@ impl Future for ServerWorker { self.poll(cx) } + WorkerState::Shutdown(ref mut shutdown) => { // drop all pending connections in rx channel. while let Poll::Ready(Some(conn)) = this.conn_rx.poll_recv(cx) { @@ -682,6 +684,7 @@ impl Future for ServerWorker { shutdown.timer.as_mut().poll(cx) } } + // actively poll stream and handle worker command WorkerState::Available => loop { match this.check_readiness(cx) { diff --git a/actix-tls/CHANGES.md b/actix-tls/CHANGES.md index 0381e6de..556d498b 100644 --- a/actix-tls/CHANGES.md +++ b/actix-tls/CHANGES.md @@ -1,40 +1,43 @@ # Changes -## Unreleased - 2023-xx-xx +## Unreleased +- Support Rustls v0.21. +- Added `{accept, connect}::rustls_0_21` modules. +- Added `{accept, connect}::rustls_0_20` alias for `{accept, connect}::rustls` modules. - Minimum supported Rust version (MSRV) is now 1.65. -## 3.0.4 - 2022-03-15 +## 3.0.4 - Logs emitted now use the `tracing` crate with `log` compatibility. [#451] [#451]: https://github.com/actix/actix-net/pull/451 -## 3.0.3 - 2022-02-15 +## 3.0.3 - No significant changes since `3.0.2`. -## 3.0.2 - 2022-01-28 +## 3.0.2 - Expose `connect::Connection::new`. [#439] [#439]: https://github.com/actix/actix-net/pull/439 -## 3.0.1 - 2022-01-11 +## 3.0.1 - No significant changes since `3.0.0`. -## 3.0.0 - 2021-12-26 +## 3.0.0 - No significant changes since `3.0.0-rc.2`. -## 3.0.0-rc.2 - 2021-12-10 +## 3.0.0-rc.2 - Re-export `openssl::SslConnectorBuilder` in `connect::openssl::reexports`. [#429] [#429]: https://github.com/actix/actix-net/pull/429 -## 3.0.0-rc.1 - 2021-11-29 +## 3.0.0-rc.1 ### Added @@ -72,7 +75,7 @@ [#422]: https://github.com/actix/actix-net/pull/422 [#423]: https://github.com/actix/actix-net/pull/423 -## 3.0.0-beta.9 - 2021-11-22 +## 3.0.0-beta.9 - Add configurable timeout for accepting TLS connection. [#393] - Added `TlsError::Timeout` variant. [#393] @@ -82,20 +85,20 @@ [#393]: https://github.com/actix/actix-net/pull/393 [#420]: https://github.com/actix/actix-net/pull/420 -## 3.0.0-beta.8 - 2021-11-15 +## 3.0.0-beta.8 - Add `Connect::request` for getting a reference to the connection request. [#415] [#415]: https://github.com/actix/actix-net/pull/415 -## 3.0.0-beta.7 - 2021-10-20 +## 3.0.0-beta.7 - Add `webpki_roots_cert_store()` to get rustls compatible webpki roots cert store. [#401] - Alias `connect::ssl` to `connect::tls`. [#401] [#401]: https://github.com/actix/actix-net/pull/401 -## 3.0.0-beta.6 - 2021-10-19 +## 3.0.0-beta.6 - Update `tokio-rustls` to `0.23` which uses `rustls` `0.20`. [#396] - Removed a re-export of `Session` from `rustls` as it no longer exist. [#396] @@ -103,7 +106,7 @@ [#396]: https://github.com/actix/actix-net/pull/396 -## 3.0.0-beta.5 - 2021-03-29 +## 3.0.0-beta.5 - Changed `connect::ssl::rustls::RustlsConnectorService` to return error when `DNSNameRef` generation failed instead of panic. [#296] - Remove `connect::ssl::openssl::OpensslConnectServiceFactory`. [#297] @@ -117,7 +120,7 @@ [#297]: https://github.com/actix/actix-net/pull/297 [#299]: https://github.com/actix/actix-net/pull/299 -## 3.0.0-beta.4 - 2021-02-24 +## 3.0.0-beta.4 - Rename `accept::openssl::{SslStream => TlsStream}`. - Add `connect::Connect::set_local_addr` to attach local `IpAddr`. [#282] @@ -125,7 +128,7 @@ [#282]: https://github.com/actix/actix-net/pull/282 -## 3.0.0-beta.3 - 2021-02-06 +## 3.0.0-beta.3 - Remove `trust-dns-proto` and `trust-dns-resolver`. [#248] - Use `std::net::ToSocketAddrs` as simple and basic default resolver. [#248] @@ -139,13 +142,13 @@ [#248]: https://github.com/actix/actix-net/pull/248 [#273]: https://github.com/actix/actix-net/pull/273 -## 3.0.0-beta.2 - 2022-xx-xx +## 3.0.0-beta.2 - Depend on stable trust-dns packages. [#204] [#204]: https://github.com/actix/actix-net/pull/204 -## 3.0.0-beta.1 - 2020-12-29 +## 3.0.0-beta.1 - Move acceptors under `accept` module. [#238] - Merge `actix-connect` crate under `connect` module. [#238] @@ -153,7 +156,7 @@ [#238]: https://github.com/actix/actix-net/pull/238 -## 2.0.0 - 2020-09-03 +## 2.0.0 - `nativetls::NativeTlsAcceptor` is renamed to `nativetls::Acceptor`. - Where possible, "SSL" terminology is replaced with "TLS". @@ -161,28 +164,28 @@ - `TlsError::Ssl` enum variant is renamed to `TlsError::Tls`. - `max_concurrent_ssl_connect` is renamed to `max_concurrent_tls_connect`. -## 2.0.0-alpha.2 - 2020-08-17 +## 2.0.0-alpha.2 - Update `rustls` dependency to 0.18 - Update `tokio-rustls` dependency to 0.14 - Update `webpki-roots` dependency to 0.20 -## [2.0.0-alpha.1] - 2020-03-03 +## [2.0.0-alpha.1] - Update `rustls` dependency to 0.17 - Update `tokio-rustls` dependency to 0.13 - Update `webpki-roots` dependency to 0.19 -## [1.0.0] - 2019-12-11 +## [1.0.0] - 1.0.0 release -## [1.0.0-alpha.3] - 2019-12-07 +## [1.0.0-alpha.3] - Migrate to tokio 0.2 - Enable rustls acceptor service - Enable native-tls acceptor service -## [1.0.0-alpha.1] - 2019-12-02 +## [1.0.0-alpha.1] - Split openssl acceptor from actix-server package diff --git a/actix-tls/Cargo.toml b/actix-tls/Cargo.toml index d65d675b..0c5a148e 100755 --- a/actix-tls/Cargo.toml +++ b/actix-tls/Cargo.toml @@ -9,7 +9,7 @@ description = "TLS acceptor and connector services for Actix ecosystem" keywords = ["network", "tls", "ssl", "async", "transport"] repository = "https://github.com/actix/actix-net.git" categories = ["network-programming", "asynchronous", "cryptography"] -license = "MIT OR Apache-2.0" +license.workspace = true edition.workspace = true rust-version.workspace = true @@ -29,8 +29,14 @@ connect = [] # use openssl impls openssl = ["tls-openssl", "tokio-openssl"] -# use rustls impls -rustls = ["tokio-rustls", "webpki-roots"] +# alias for backwards compat +rustls = ["rustls-0_20"] + +# use rustls v0.20 impls +rustls-0_20 = ["tokio-rustls-023", "webpki-roots-022"] + +# use rustls v0.21 impls +rustls-0_21 = ["tokio-rustls-024", "webpki-roots-025"] # use native-tls impls native-tls = ["tokio-native-tls"] @@ -57,9 +63,13 @@ http = { version = "0.2.3", optional = true } tls-openssl = { package = "openssl", version = "0.10.48", optional = true } tokio-openssl = { version = "0.6", optional = true } -# rustls -tokio-rustls = { version = "0.23", optional = true } -webpki-roots = { version = "0.22", optional = true } +# rustls v0.20 +tokio-rustls-023 = { package = "tokio-rustls", version = "0.23", optional = true } +webpki-roots-022 = { package = "webpki-roots", version = "0.22", optional = true } + +# rustls v0.21 +tokio-rustls-024 = { package = "tokio-rustls", version = "0.24", optional = true } +webpki-roots-025 = { package = "webpki-roots", version = "0.25", optional = true } # native-tls tokio-native-tls = { version = "0.3", optional = true } @@ -72,11 +82,11 @@ bytes = "1" env_logger = "0.10" futures-util = { version = "0.3.17", default-features = false, features = ["sink"] } log = "0.4" -rcgen = "0.10" +rcgen = "0.11" rustls-pemfile = "1" -tokio-rustls = { version = "0.23", features = ["dangerous_configuration"] } -trust-dns-resolver = "0.22" +tokio-rustls-024 = { package = "tokio-rustls", version = "0.24", features = ["dangerous_configuration"] } +trust-dns-resolver = "0.23" [[example]] name = "accept-rustls" -required-features = ["accept", "rustls"] +required-features = ["accept", "rustls-0_21"] diff --git a/actix-tls/examples/accept-rustls.rs b/actix-tls/examples/accept-rustls.rs index 6424e64a..40f51753 100644 --- a/actix-tls/examples/accept-rustls.rs +++ b/actix-tls/examples/accept-rustls.rs @@ -17,12 +17,13 @@ #[rustfmt::skip] // this `use` is only exists because of how we have organised the crate -// it is not necessary for your actual code; you should import from `rustls` directly -use tokio_rustls::rustls; +// it is not necessary for your actual code; you should import from `rustls` normally +use tokio_rustls_024::rustls; use std::{ fs::File, io::{self, BufReader}, + path::PathBuf, sync::{ atomic::{AtomicUsize, Ordering}, Arc, @@ -32,7 +33,7 @@ use std::{ use actix_rt::net::TcpStream; use actix_server::Server; use actix_service::ServiceFactoryExt as _; -use actix_tls::accept::rustls::{Acceptor as RustlsAcceptor, TlsStream}; +use actix_tls::accept::rustls_0_21::{Acceptor as RustlsAcceptor, TlsStream}; use futures_util::future::ok; use rustls::{server::ServerConfig, Certificate, PrivateKey}; use rustls_pemfile::{certs, rsa_private_keys}; @@ -42,9 +43,16 @@ use tracing::info; async fn main() -> io::Result<()> { env_logger::init_from_env(env_logger::Env::default().default_filter_or("info")); + let root_path = env!("CARGO_MANIFEST_DIR") + .parse::() + .unwrap() + .join("examples"); + let cert_path = root_path.clone().join("cert.pem"); + let key_path = root_path.clone().join("key.pem"); + // Load TLS key and cert files - let cert_file = &mut BufReader::new(File::open("./examples/cert.pem").unwrap()); - let key_file = &mut BufReader::new(File::open("./examples/key.pem").unwrap()); + let cert_file = &mut BufReader::new(File::open(cert_path).unwrap()); + let key_file = &mut BufReader::new(File::open(key_path).unwrap()); let cert_chain = certs(cert_file) .unwrap() @@ -64,7 +72,7 @@ async fn main() -> io::Result<()> { let count = Arc::new(AtomicUsize::new(0)); let addr = ("127.0.0.1", 8443); - info!("starting server on port: {}", &addr.0); + info!("starting server at: {addr:?}"); Server::build() .bind("tls-example", addr, move || { diff --git a/actix-tls/src/accept/mod.rs b/actix-tls/src/accept/mod.rs index 1eee6720..18585970 100644 --- a/actix-tls/src/accept/mod.rs +++ b/actix-tls/src/accept/mod.rs @@ -12,15 +12,27 @@ use actix_utils::counter::Counter; #[cfg(feature = "openssl")] pub mod openssl; -#[cfg(feature = "rustls")] -pub mod rustls; +#[cfg(feature = "rustls-0_20")] +pub mod rustls_0_20; + +#[doc(hidden)] +#[cfg(feature = "rustls-0_20")] +pub use rustls_0_20 as rustls; + +#[cfg(feature = "rustls-0_21")] +pub mod rustls_0_21; #[cfg(feature = "native-tls")] pub mod native_tls; pub(crate) static MAX_CONN: AtomicUsize = AtomicUsize::new(256); -#[cfg(any(feature = "openssl", feature = "rustls", feature = "native-tls"))] +#[cfg(any( + feature = "openssl", + feature = "rustls-0_20", + feature = "rustls-0_21", + feature = "native-tls", +))] pub(crate) const DEFAULT_TLS_HANDSHAKE_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(3); diff --git a/actix-tls/src/accept/rustls.rs b/actix-tls/src/accept/rustls_0_20.rs similarity index 97% rename from actix-tls/src/accept/rustls.rs rename to actix-tls/src/accept/rustls_0_20.rs index 85cf5b00..d06f1799 100644 --- a/actix-tls/src/accept/rustls.rs +++ b/actix-tls/src/accept/rustls_0_20.rs @@ -1,4 +1,4 @@ -//! `rustls` based TLS connection acceptor service. +//! `rustls` v0.20 based TLS connection acceptor service. //! //! See [`Acceptor`] for main service factory docs. @@ -24,13 +24,14 @@ use actix_utils::{ use pin_project_lite::pin_project; use tokio::io::{AsyncRead, AsyncWrite, ReadBuf}; use tokio_rustls::{rustls::ServerConfig, Accept, TlsAcceptor}; +use tokio_rustls_023 as tokio_rustls; use super::{TlsError, DEFAULT_TLS_HANDSHAKE_TIMEOUT, MAX_CONN_COUNTER}; pub mod reexports { //! Re-exports from `rustls` that are useful for acceptors. - pub use tokio_rustls::rustls::ServerConfig; + pub use tokio_rustls_023::rustls::ServerConfig; } /// Wraps a `rustls` based async TLS stream in order to implement [`ActixStream`]. diff --git a/actix-tls/src/accept/rustls_0_21.rs b/actix-tls/src/accept/rustls_0_21.rs new file mode 100644 index 00000000..27db8cdd --- /dev/null +++ b/actix-tls/src/accept/rustls_0_21.rs @@ -0,0 +1,198 @@ +//! `rustls` v0.21 based TLS connection acceptor service. +//! +//! See [`Acceptor`] for main service factory docs. + +use std::{ + convert::Infallible, + future::Future, + io::{self, IoSlice}, + pin::Pin, + sync::Arc, + task::{Context, Poll}, + time::Duration, +}; + +use actix_rt::{ + net::{ActixStream, Ready}, + time::{sleep, Sleep}, +}; +use actix_service::{Service, ServiceFactory}; +use actix_utils::{ + counter::{Counter, CounterGuard}, + future::{ready, Ready as FutReady}, +}; +use pin_project_lite::pin_project; +use tokio::io::{AsyncRead, AsyncWrite, ReadBuf}; +use tokio_rustls::{rustls::ServerConfig, Accept, TlsAcceptor}; +use tokio_rustls_024 as tokio_rustls; + +use super::{TlsError, DEFAULT_TLS_HANDSHAKE_TIMEOUT, MAX_CONN_COUNTER}; + +pub mod reexports { + //! Re-exports from `rustls` that are useful for acceptors. + + pub use tokio_rustls_024::rustls::ServerConfig; +} + +/// Wraps a `rustls` based async TLS stream in order to implement [`ActixStream`]. +pub struct TlsStream(tokio_rustls::server::TlsStream); + +impl_more::impl_from!( in tokio_rustls::server::TlsStream => TlsStream); +impl_more::impl_deref_and_mut!( in TlsStream => tokio_rustls::server::TlsStream); + +impl AsyncRead for TlsStream { + fn poll_read( + self: Pin<&mut Self>, + cx: &mut Context<'_>, + buf: &mut ReadBuf<'_>, + ) -> Poll> { + Pin::new(&mut **self.get_mut()).poll_read(cx, buf) + } +} + +impl AsyncWrite for TlsStream { + fn poll_write( + self: Pin<&mut Self>, + cx: &mut Context<'_>, + buf: &[u8], + ) -> Poll> { + Pin::new(&mut **self.get_mut()).poll_write(cx, buf) + } + + fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { + Pin::new(&mut **self.get_mut()).poll_flush(cx) + } + + fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { + Pin::new(&mut **self.get_mut()).poll_shutdown(cx) + } + + fn poll_write_vectored( + self: Pin<&mut Self>, + cx: &mut Context<'_>, + bufs: &[IoSlice<'_>], + ) -> Poll> { + Pin::new(&mut **self.get_mut()).poll_write_vectored(cx, bufs) + } + + fn is_write_vectored(&self) -> bool { + (**self).is_write_vectored() + } +} + +impl ActixStream for TlsStream { + fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll> { + IO::poll_read_ready((**self).get_ref().0, cx) + } + + fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll> { + IO::poll_write_ready((**self).get_ref().0, cx) + } +} + +/// Accept TLS connections via the `rustls` crate. +pub struct Acceptor { + config: Arc, + handshake_timeout: Duration, +} + +impl Acceptor { + /// Constructs `rustls` based acceptor service factory. + pub fn new(config: ServerConfig) -> Self { + Acceptor { + config: Arc::new(config), + handshake_timeout: DEFAULT_TLS_HANDSHAKE_TIMEOUT, + } + } + + /// Limit the amount of time that the acceptor will wait for a TLS handshake to complete. + /// + /// Default timeout is 3 seconds. + pub fn set_handshake_timeout(&mut self, handshake_timeout: Duration) -> &mut Self { + self.handshake_timeout = handshake_timeout; + self + } +} + +impl Clone for Acceptor { + fn clone(&self) -> Self { + Self { + config: self.config.clone(), + handshake_timeout: self.handshake_timeout, + } + } +} + +impl ServiceFactory for Acceptor { + type Response = TlsStream; + type Error = TlsError; + type Config = (); + type Service = AcceptorService; + type InitError = (); + type Future = FutReady>; + + fn new_service(&self, _: ()) -> Self::Future { + let res = MAX_CONN_COUNTER.with(|conns| { + Ok(AcceptorService { + acceptor: self.config.clone().into(), + conns: conns.clone(), + handshake_timeout: self.handshake_timeout, + }) + }); + + ready(res) + } +} + +/// Rustls based acceptor service. +pub struct AcceptorService { + acceptor: TlsAcceptor, + conns: Counter, + handshake_timeout: Duration, +} + +impl Service for AcceptorService { + type Response = TlsStream; + type Error = TlsError; + type Future = AcceptFut; + + fn poll_ready(&self, cx: &mut Context<'_>) -> Poll> { + if self.conns.available(cx) { + Poll::Ready(Ok(())) + } else { + Poll::Pending + } + } + + fn call(&self, req: IO) -> Self::Future { + AcceptFut { + fut: self.acceptor.accept(req), + timeout: sleep(self.handshake_timeout), + _guard: self.conns.get(), + } + } +} + +pin_project! { + /// Accept future for Rustls service. + #[doc(hidden)] + pub struct AcceptFut { + fut: Accept, + #[pin] + timeout: Sleep, + _guard: CounterGuard, + } +} + +impl Future for AcceptFut { + type Output = Result, TlsError>; + + fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + let mut this = self.project(); + match Pin::new(&mut this.fut).poll(cx) { + Poll::Ready(Ok(stream)) => Poll::Ready(Ok(TlsStream(stream))), + Poll::Ready(Err(err)) => Poll::Ready(Err(TlsError::Tls(err))), + Poll::Pending => this.timeout.poll(cx).map(|_| Err(TlsError::Timeout)), + } + } +} diff --git a/actix-tls/src/connect/mod.rs b/actix-tls/src/connect/mod.rs index dae1f7b1..79cbb295 100644 --- a/actix-tls/src/connect/mod.rs +++ b/actix-tls/src/connect/mod.rs @@ -27,8 +27,15 @@ mod uri; #[cfg(feature = "openssl")] pub mod openssl; -#[cfg(feature = "rustls")] -pub mod rustls; +#[cfg(feature = "rustls-0_20")] +pub mod rustls_0_20; + +#[doc(hidden)] +#[cfg(feature = "rustls-0_20")] +pub use rustls_0_20 as rustls; + +#[cfg(feature = "rustls-0_21")] +pub mod rustls_0_21; #[cfg(feature = "native-tls")] pub mod native_tls; diff --git a/actix-tls/src/connect/rustls.rs b/actix-tls/src/connect/rustls_0_20.rs similarity index 78% rename from actix-tls/src/connect/rustls.rs rename to actix-tls/src/connect/rustls_0_20.rs index 5706047d..4547854e 100644 --- a/actix-tls/src/connect/rustls.rs +++ b/actix-tls/src/connect/rustls_0_20.rs @@ -20,22 +20,21 @@ use tokio_rustls::{ rustls::{client::ServerName, ClientConfig, OwnedTrustAnchor, RootCertStore}, Connect as RustlsConnect, TlsConnector as RustlsTlsConnector, }; -use tracing::trace; -use webpki_roots::TLS_SERVER_ROOTS; +use tokio_rustls_023 as tokio_rustls; use crate::connect::{Connection, Host}; pub mod reexports { //! Re-exports from `rustls` and `webpki_roots` that are useful for connectors. - pub use tokio_rustls::{client::TlsStream as AsyncTlsStream, rustls::ClientConfig}; - pub use webpki_roots::TLS_SERVER_ROOTS; + pub use tokio_rustls_023::{client::TlsStream as AsyncTlsStream, rustls::ClientConfig}; + pub use webpki_roots_022::TLS_SERVER_ROOTS; } /// Returns standard root certificates from `webpki-roots` crate as a rustls certificate store. pub fn webpki_roots_cert_store() -> RootCertStore { let mut root_certs = RootCertStore::empty(); - for cert in TLS_SERVER_ROOTS.0 { + for cert in webpki_roots_022::TLS_SERVER_ROOTS.0 { let cert = OwnedTrustAnchor::from_subject_spki_name_constraints( cert.subject, cert.spki, @@ -102,12 +101,13 @@ where actix_service::always_ready!(); fn call(&self, connection: Connection) -> Self::Future { - trace!("TLS handshake start for: {:?}", connection.hostname()); + tracing::trace!("TLS handshake start for: {:?}", connection.hostname()); let (stream, connection) = connection.replace_io(()); match ServerName::try_from(connection.hostname()) { Ok(host) => ConnectFut::Future { - connect: RustlsTlsConnector::from(self.connector.clone()).connect(host, stream), + connect: RustlsTlsConnector::from(Arc::clone(&self.connector)) + .connect(host, stream), connection: Some(connection), }, Err(_) => ConnectFut::InvalidDns, @@ -117,6 +117,7 @@ where /// Connect future for Rustls service. #[doc(hidden)] +#[allow(clippy::large_enum_variant)] pub enum ConnectFut { /// See issue InvalidDns, @@ -131,17 +132,23 @@ where R: Host, IO: ActixStream, { - type Output = Result>, io::Error>; + type Output = io::Result>>; fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { match self.get_mut() { - Self::InvalidDns => Poll::Ready(Err( - io::Error::new(io::ErrorKind::Other, "rustls currently only handles hostname-based connections. See https://github.com/briansmith/webpki/issues/54") - )), - Self::Future { connect, connection } => { + Self::InvalidDns => Poll::Ready(Err(io::Error::new( + io::ErrorKind::Other, + "Rustls v0.20 can only handle hostname-based connections. Enable the `rustls-0_21` \ + feature and use the Rustls v0.21 utilities to gain this feature.", + ))), + + Self::Future { + connect, + connection, + } => { let stream = ready!(Pin::new(connect).poll(cx))?; let connection = connection.take().unwrap(); - trace!("TLS handshake success: {:?}", connection.hostname()); + tracing::trace!("TLS handshake success: {:?}", connection.hostname()); Poll::Ready(Ok(connection.replace_io(stream).1)) } } diff --git a/actix-tls/src/connect/rustls_0_21.rs b/actix-tls/src/connect/rustls_0_21.rs new file mode 100644 index 00000000..cc0d6de3 --- /dev/null +++ b/actix-tls/src/connect/rustls_0_21.rs @@ -0,0 +1,154 @@ +//! Rustls based connector service. +//! +//! See [`TlsConnector`] for main connector service factory docs. + +use std::{ + convert::TryFrom, + future::Future, + io, + pin::Pin, + sync::Arc, + task::{Context, Poll}, +}; + +use actix_rt::net::ActixStream; +use actix_service::{Service, ServiceFactory}; +use actix_utils::future::{ok, Ready}; +use futures_core::ready; +use tokio_rustls::{ + client::TlsStream as AsyncTlsStream, + rustls::{client::ServerName, ClientConfig, OwnedTrustAnchor, RootCertStore}, + Connect as RustlsConnect, TlsConnector as RustlsTlsConnector, +}; +use tokio_rustls_024 as tokio_rustls; + +use crate::connect::{Connection, Host}; + +pub mod reexports { + //! Re-exports from `rustls` and `webpki_roots` that are useful for connectors. + + pub use tokio_rustls_024::{client::TlsStream as AsyncTlsStream, rustls::ClientConfig}; + pub use webpki_roots_025::TLS_SERVER_ROOTS; +} + +/// Returns standard root certificates from `webpki-roots` crate as a rustls certificate store. +pub fn webpki_roots_cert_store() -> RootCertStore { + let mut root_certs = RootCertStore::empty(); + for cert in webpki_roots_025::TLS_SERVER_ROOTS { + let cert = OwnedTrustAnchor::from_subject_spki_name_constraints( + cert.subject, + cert.spki, + cert.name_constraints, + ); + let certs = vec![cert].into_iter(); + root_certs.add_trust_anchors(certs); + } + root_certs +} + +/// Connector service factory using `rustls`. +#[derive(Clone)] +pub struct TlsConnector { + connector: Arc, +} + +impl TlsConnector { + /// Constructs new connector service factory from a `rustls` client configuration. + pub fn new(connector: Arc) -> Self { + TlsConnector { connector } + } + + /// Constructs new connector service from a `rustls` client configuration. + pub fn service(connector: Arc) -> TlsConnectorService { + TlsConnectorService { connector } + } +} + +impl ServiceFactory> for TlsConnector +where + R: Host, + IO: ActixStream + 'static, +{ + type Response = Connection>; + type Error = io::Error; + type Config = (); + type Service = TlsConnectorService; + type InitError = (); + type Future = Ready>; + + fn new_service(&self, _: ()) -> Self::Future { + ok(TlsConnectorService { + connector: self.connector.clone(), + }) + } +} + +/// Connector service using `rustls`. +#[derive(Clone)] +pub struct TlsConnectorService { + connector: Arc, +} + +impl Service> for TlsConnectorService +where + R: Host, + IO: ActixStream, +{ + type Response = Connection>; + type Error = io::Error; + type Future = ConnectFut; + + actix_service::always_ready!(); + + fn call(&self, connection: Connection) -> Self::Future { + tracing::trace!("TLS handshake start for: {:?}", connection.hostname()); + let (stream, connection) = connection.replace_io(()); + + match ServerName::try_from(connection.hostname()) { + Ok(host) => ConnectFut::Future { + connect: RustlsTlsConnector::from(Arc::clone(&self.connector)) + .connect(host, stream), + connection: Some(connection), + }, + Err(_) => ConnectFut::InvalidServerName, + } + } +} + +/// Connect future for Rustls service. +#[doc(hidden)] +#[allow(clippy::large_enum_variant)] +pub enum ConnectFut { + InvalidServerName, + Future { + connect: RustlsConnect, + connection: Option>, + }, +} + +impl Future for ConnectFut +where + R: Host, + IO: ActixStream, +{ + type Output = io::Result>>; + + fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + match self.get_mut() { + Self::InvalidServerName => Poll::Ready(Err(io::Error::new( + io::ErrorKind::InvalidInput, + "connection parameters specified invalid server name", + ))), + + Self::Future { + connect, + connection, + } => { + let stream = ready!(Pin::new(connect).poll(cx))?; + let connection = connection.take().unwrap(); + tracing::trace!("TLS handshake success: {:?}", connection.hostname()); + Poll::Ready(Ok(connection.replace_io(stream).1)) + } + } + } +} diff --git a/actix-tls/tests/accept-openssl.rs b/actix-tls/tests/accept-openssl.rs index ff707f65..ca57e17d 100644 --- a/actix-tls/tests/accept-openssl.rs +++ b/actix-tls/tests/accept-openssl.rs @@ -3,7 +3,7 @@ #![cfg(all( feature = "accept", feature = "connect", - feature = "rustls", + feature = "rustls-0_21", feature = "openssl" ))] @@ -15,6 +15,7 @@ use actix_service::ServiceFactoryExt as _; use actix_tls::accept::openssl::{Acceptor, TlsStream}; use actix_utils::future::ok; use tokio_rustls::rustls::{Certificate, ClientConfig, RootCertStore, ServerName}; +use tokio_rustls_024 as tokio_rustls; fn new_cert_and_key() -> (String, String) { let cert = @@ -49,7 +50,7 @@ fn openssl_acceptor(cert: String, key: String) -> tls_openssl::ssl::SslAcceptor mod danger { use std::time::SystemTime; - use tokio_rustls::rustls::{ + use tokio_rustls_024::rustls::{ self, client::{ServerCertVerified, ServerCertVerifier}, }; diff --git a/actix-tls/tests/accept-rustls.rs b/actix-tls/tests/accept-rustls.rs index 7955b36f..40d38b7d 100644 --- a/actix-tls/tests/accept-rustls.rs +++ b/actix-tls/tests/accept-rustls.rs @@ -3,7 +3,7 @@ #![cfg(all( feature = "accept", feature = "connect", - feature = "rustls", + feature = "rustls-0_21", feature = "openssl" ))] @@ -15,13 +15,14 @@ use actix_rt::net::TcpStream; use actix_server::TestServer; use actix_service::ServiceFactoryExt as _; use actix_tls::{ - accept::rustls::{Acceptor, TlsStream}, + accept::rustls_0_21::{Acceptor, TlsStream}, connect::openssl::reexports::SslConnector, }; use actix_utils::future::ok; use rustls_pemfile::{certs, pkcs8_private_keys}; use tls_openssl::ssl::SslVerifyMode; use tokio_rustls::rustls::{self, Certificate, PrivateKey, ServerConfig}; +use tokio_rustls_024 as tokio_rustls; fn new_cert_and_key() -> (String, String) { let cert = diff --git a/actix-tls/tests/test_connect.rs b/actix-tls/tests/test_connect.rs index 5e73fd2d..1c969fec 100644 --- a/actix-tls/tests/test_connect.rs +++ b/actix-tls/tests/test_connect.rs @@ -30,7 +30,7 @@ async fn test_string() { assert_eq!(con.peer_addr().unwrap(), srv.addr()); } -#[cfg(feature = "rustls")] +#[cfg(feature = "rustls-0_21")] #[actix_rt::test] async fn test_rustls_string() { let srv = TestServer::start(|| { @@ -114,7 +114,7 @@ async fn test_openssl_uri() { assert_eq!(con.peer_addr().unwrap(), srv.addr()); } -#[cfg(all(feature = "rustls", feature = "uri"))] +#[cfg(all(feature = "rustls-0_21", feature = "uri"))] #[actix_rt::test] async fn test_rustls_uri() { use std::convert::TryFrom; diff --git a/actix-utils/src/counter.rs b/actix-utils/src/counter.rs index a61ef90e..4259fd6d 100644 --- a/actix-utils/src/counter.rs +++ b/actix-utils/src/counter.rs @@ -29,7 +29,7 @@ impl Counter { /// Returns true if counter is below capacity. Otherwise, register to wake task when it is. #[inline] - pub fn available(&self, cx: &mut task::Context<'_>) -> bool { + pub fn available(&self, cx: &task::Context<'_>) -> bool { self.0.available(cx) } @@ -59,7 +59,7 @@ impl CounterInner { } } - fn available(&self, cx: &mut task::Context<'_>) -> bool { + fn available(&self, cx: &task::Context<'_>) -> bool { if self.count.get() < self.capacity { true } else { diff --git a/actix-utils/src/future/poll_fn.rs b/actix-utils/src/future/poll_fn.rs index 15d93dbd..0c798f46 100644 --- a/actix-utils/src/future/poll_fn.rs +++ b/actix-utils/src/future/poll_fn.rs @@ -62,6 +62,7 @@ where fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { // SAFETY: we are not moving out of the pinned field // see https://github.com/rust-lang/rust/pull/102737 + #[allow(clippy::needless_borrow)] (unsafe { &mut self.get_unchecked_mut().f })(cx) } }