server bind accepts types impling regular service traits

actix-server/CHANGES.md

@@ -1,8 +1,14 @@
 # Changes
 
 ## Unreleased - 2021-xx-xx
+* Rename `Server` to `ServerHandle`. [#403]
+* Rename `ServerBuilder::{maxconn => max_concurrent_connections}`. [#403]
+* Remove wrapper `service::ServiceFactory` trait. [#403]
+* `Server::bind` and related methods now take a regular `ServiceFactory` (from actix-service crate). [#403]
 * Minimum supported Rust version (MSRV) is now 1.52.
 
+[#403]: https://github.com/actix/actix-net/pull/403
+
 
 ## 2.0.0-beta.6 - 2021-10-11
 * Add experimental (semver-exempt) `io-uring` feature for enabling async file I/O on linux. [#374]

actix-server/Cargo.toml

@@ -38,4 +38,4 @@ actix-rt = "2.0.0"
 bytes = "1"
 env_logger = "0.9"
 futures-util = { version = "0.3.7", default-features = false, features = ["sink"] }
-tokio = { version = "1.5.1", features = ["io-util"] }
+tokio = { version = "1.5.1", features = ["io-util", "rt-multi-thread", "macros"] }

actix-server/examples/startup-fail.rs

@@ -0,0 +1,33 @@
+use std::io;
+
+use actix_rt::net::TcpStream;
+use actix_server::Server;
+use actix_service::{fn_factory, fn_service};
+use log::info;
+
+#[actix_rt::main]
+async fn main() -> io::Result<()> {
+ env_logger::Builder::from_env(env_logger::Env::new().default_filter_or("trace,mio=info"))
+ .init();
+
+ let addr = ("127.0.0.1", 8080);
+ info!("starting server on port: {}", &addr.0);
+
+ Server::build()
+ .bind(
+ "startup-fail",
+ addr,
+ fn_factory(|| async move {
+ if 1 > 2 {
+ Ok(fn_service(move |mut _stream: TcpStream| async move {
+ Ok::<u32, u32>(0)
+ }))
+ } else {
+ Err(42)
+ }
+ }),
+ )?
+ .workers(2)
+ .run()
+ .await
+}

actix-server/examples/tcp-echo.rs

@@ -21,7 +21,6 @@ use actix_rt::net::TcpStream;
 use actix_server::Server;
 use actix_service::{fn_service, ServiceFactoryExt as _};
 use bytes::BytesMut;
-use futures_util::future::ok;
 use log::{error, info};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 
@@ -39,11 +38,11 @@ async fn main() -> io::Result<()> {
  // logical CPU cores as the worker count. For this reason, the closure passed to bind needs
  // to return a service *factory*; so it can be created once per worker.
  Server::build()
- .bind("echo", addr, move || {
+ .bind("echo", addr, {
  let count = Arc::clone(&count);
  let num2 = Arc::clone(&count);
 
- fn_service(move |mut stream: TcpStream| {
+ let svc = fn_service(move |mut stream: TcpStream| {
  let count = Arc::clone(&count);
 
  async move {
@@ -78,13 +77,17 @@ async fn main() -> io::Result<()> {
  }
  })
  .map_err(|err| error!("Service Error: {:?}", err))
- .and_then(move |(_, size)| {
+ .and_then_send(move |(_, size)| {
  let num = num2.load(Ordering::SeqCst);
  info!("[{}] total bytes read: {}", num, size);
- ok(size)
- })
+ async move { Ok(size) }
+ });
+
+ let svc2 = svc.clone();
+
+ svc2
  })?
- .workers(1)
+ .workers(2)
  .run()
  .await
 }

actix-server/src/accept.rs

@@ -8,7 +8,7 @@ use actix_rt::{
 use log::{debug, error, info};
 use mio::{Interest, Poll, Token as MioToken};
 
-use crate::server::Server;
+use crate::server::ServerHandle;
 use crate::socket::MioListener;
 use crate::waker_queue::{WakerInterest, WakerQueue, WAKER_TOKEN};
 use crate::worker::{Conn, WorkerHandleAccept};
@@ -30,13 +30,13 @@ struct ServerSocketInfo {
 ///
 /// It would also listen to `ServerCommand` and push interests to `WakerQueue`.
 pub(crate) struct AcceptLoop {
- srv: Option<Server>,
+ srv: Option<ServerHandle>,
  poll: Option<Poll>,
  waker: WakerQueue,
 }
 
 impl AcceptLoop {
- pub fn new(srv: Server) -> Self {
+ pub fn new(srv: ServerHandle) -> Self {
  let poll = Poll::new().unwrap_or_else(|e| panic!("Can not create `mio::Poll`: {}", e));
  let waker = WakerQueue::new(poll.registry())
  .unwrap_or_else(|e| panic!("Can not create `mio::Waker`: {}", e));
@@ -74,7 +74,7 @@ struct Accept {
  poll: Poll,
  waker: WakerQueue,
  handles: Vec<WorkerHandleAccept>,
- srv: Server,
+ srv: ServerHandle,
  next: usize,
  avail: Availability,
  paused: bool,
@@ -153,7 +153,7 @@ impl Accept {
  poll: Poll,
  waker: WakerQueue,
  socks: Vec<(usize, MioListener)>,
- srv: Server,
+ srv: ServerHandle,
  handles: Vec<WorkerHandleAccept>,
  ) {
  // Accept runs in its own thread and would want to spawn additional futures to current
@@ -176,7 +176,7 @@ impl Accept {
  waker: WakerQueue,
  socks: Vec<(usize, MioListener)>,
  handles: Vec<WorkerHandleAccept>,
- srv: Server,
+ srv: ServerHandle,
  ) -> (Accept, Vec<ServerSocketInfo>) {
  let sockets = socks
  .into_iter()