all servers minor feature: add support for Config::with_prebound_server

async-std/src/lib.rs

@@ -35,7 +35,7 @@ async fn main() {
 use std::future::Future;
 
 use trillium::Handler;
-pub use trillium_server_common::{CloneCounterObserver, Stopper};
+pub use trillium_server_common::{Binding, CloneCounterObserver, Stopper};
 
 mod client;
 pub use client::ClientConfig;

async-std/src/server/tcp.rs

@@ -8,6 +8,16 @@ use trillium_server_common::Server;
 /// Tcp-only Trillium server for Async-std
 #[derive(Debug)]
 pub struct AsyncStdServer(TcpListener);
+impl From<TcpListener> for AsyncStdServer {
+    fn from(value: TcpListener) -> Self {
+        Self(value)
+    }
+}
+impl From<std::net::TcpListener> for AsyncStdServer {
+    fn from(value: std::net::TcpListener) -> Self {
+        TcpListener::from(value).into()
+    }
+}
 
 impl Server for AsyncStdServer {
     type Transport = AsyncStdTransport<TcpStream>;

async-std/src/server/unix.rs

@@ -15,6 +15,27 @@ use trillium_server_common::{
 /// Tcp/Unix Trillium server adapter for Async-Std
 #[derive(Debug)]
 pub struct AsyncStdServer(Binding<TcpListener, UnixListener>);
+impl From<TcpListener> for AsyncStdServer {
+    fn from(value: TcpListener) -> Self {
+        Self(Tcp(value))
+    }
+}
+
+impl From<UnixListener> for AsyncStdServer {
+    fn from(value: UnixListener) -> Self {
+        Self(Unix(value))
+    }
+}
+impl From<std::net::TcpListener> for AsyncStdServer {
+    fn from(value: std::net::TcpListener) -> Self {
+        TcpListener::from(value).into()
+    }
+}
+impl From<std::os::unix::net::UnixListener> for AsyncStdServer {
+    fn from(value: std::os::unix::net::UnixListener) -> Self {
+        UnixListener::from(value).into()
+    }
+}
 
 #[cfg(unix)]
 impl Server for AsyncStdServer {

server-common/src/config.rs

@@ -66,7 +66,8 @@ pub struct Config<ServerType, AcceptorType> {
     pub(crate) max_connections: Option<usize>,
     pub(crate) info: Arc<AsyncCell<Info>>,
     pub(crate) completion_future: CompletionFuture,
-    server: PhantomData<ServerType>,
+    pub(crate) binding: Option<ServerType>,
+    pub(crate) server: PhantomData<ServerType>,
 }
 
 impl<ServerType, AcceptorType> Config<ServerType, AcceptorType>
@@ -119,6 +120,9 @@ where
     /// Configures the server to listen on this port. The default is
     /// the PORT environment variable or 8080
     pub fn with_port(mut self, port: u16) -> Self {
+        if self.binding.is_some() {
+            eprintln!("constructing a config with both a port and a pre-bound listener will ignore the port. this may be a panic in the future");
+        }
         self.port = Some(port);
         self
     }
@@ -127,6 +131,9 @@ where
     /// address. The default is the HOST environment variable or
     /// "localhost"
     pub fn with_host(mut self, host: &str) -> Self {
+        if self.binding.is_some() {
+            eprintln!("constructing a config with both a host and a pre-bound listener will ignore the host. this may be a panic in the future");
+        }
         self.host = Some(host.into());
         self
     }
@@ -144,6 +151,10 @@ where
     /// <https://en.wikipedia.org/wiki/Nagle%27s_algorithm> for more
     /// information on this setting.
     pub fn with_nodelay(mut self) -> Self {
+        if self.binding.is_some() {
+            eprintln!("constructing a config with both nodelay and a pre-bound listener will ignore the nodelay setting. this may be a panic in the future");
+        }
+
         self.nodelay = true;
         self
     }
@@ -173,6 +184,7 @@ where
             max_connections: self.max_connections,
             info: self.info,
             completion_future: self.completion_future,
+            binding: self.binding,
         }
     }
 
@@ -198,17 +210,51 @@ where
         self.max_connections = max_connections;
         self
     }
+
+    /// Use a pre-bound transport stream as server.
+    ///
+    /// The argument to this varies for different servers, but usually accepts the runtime's
+    /// TcpListener and, on unix platforms, the UnixListener.
+    ///
+    /// ## Note well
+    ///
+    /// Many of the other options on this config will be ignored if
+    /// you provide a listener. In particular, `host`, `port`, and
+    /// `nodelay` will be ignored. All of the other options will be
+    /// used.
+    ///
+    /// Additionally, cloning this config will not clone the listener.
+    pub fn with_prebound_server(mut self, server: impl Into<ServerType>) -> Self {
+        if self.host.is_some() {
+            eprintln!("constructing a config with both a host and a pre-bound listener will ignore the host. this may be a panic in the future");
+        }
+
+        if self.port.is_some() {
+            eprintln!("constructing a config with both a port and a pre-bound listener will ignore the port. this may be a panic in the future");
+        }
+
+        if self.nodelay {
+            eprintln!("constructing a config with nodelay and a pre-bound listener will ignore nodelay. this may be a panic in the future");
+        }
+
+        self.binding = Some(server.into());
+        self
+    }
 }
 
-impl<ServerType> Config<ServerType, ()> {
+impl<ServerType: ?Sized + Server> Config<ServerType, ()> {
     /// build a new config with default acceptor
     pub fn new() -> Self {
         Self::default()
     }
 }
 
-impl<ServerType, AcceptorType: Clone> Clone for Config<ServerType, AcceptorType> {
+impl<ServerType: ?Sized + Server, AcceptorType: Clone> Clone for Config<ServerType, AcceptorType> {
     fn clone(&self) -> Self {
+        if self.binding.is_some() {
+            eprintln!("cloning a Config with a pre-bound listener will not clone the listener. this may be a panic in the future.");
+        }
+
         Self {
             acceptor: self.acceptor.clone(),
             port: self.port,
@@ -221,11 +267,12 @@ impl<ServerType, AcceptorType: Clone> Clone for Config<ServerType, AcceptorType>
             max_connections: self.max_connections,
             info: AsyncCell::shared(),
             completion_future: CompletionFuture::new(),
+            binding: None,
         }
     }
 }
 
-impl<ServerType> Default for Config<ServerType, ()> {
+impl<ServerType: ?Sized + Server> Default for Config<ServerType, ()> {
     fn default() -> Self {
         #[cfg(unix)]
         let max_connections = {
@@ -252,6 +299,7 @@ impl<ServerType> Default for Config<ServerType, ()> {
             max_connections,
             info: AsyncCell::shared(),
             completion_future: CompletionFuture::new(),
+            binding: None,
         }
     }
 }

server-common/src/server.rs

@@ -40,10 +40,15 @@ pub trait Server: Sized + Send + Sync + 'static {
     /// [`Server::listener_from_tcp`] and
     /// [`Server::listener_from_unix`].
     #[cfg(unix)]
-    fn build_listener<A>(config: &Config<Self, A>) -> Self
+    fn build_listener<A>(config: &mut Config<Self, A>) -> Self
     where
         A: Acceptor<Self::Transport>,
     {
+        if let Some(listener) = config.binding.take() {
+            log::debug!("taking prebound listener");
+            return listener;
+        }
+
         use std::os::unix::prelude::FromRawFd;
         let host = config.host();
         if host.starts_with(|c| c == '/' || c == '.' || c == '~') {
@@ -69,10 +74,15 @@ pub trait Server: Sized + Send + Sync + 'static {
     /// implementations could potentially implement this directly.  To
     /// use this default logic, implement [`Server::listener_from_tcp`]
     #[cfg(not(unix))]
-    fn build_listener<A>(config: &Config<Self, A>) -> Self
+    fn build_listener<A>(config: &mut Config<Self, A>) -> Self
     where
         A: Acceptor<Self::Transport>,
     {
+        if let Some(listener) = config.binding.take() {
+            log::debug!("taking prebound listener");
+            return listener;
+        }
+
         let tcp_listener = std::net::TcpListener::bind((config.host(), config.port())).unwrap();
         tcp_listener.set_nonblocking(true).unwrap();
         Self::listener_from_tcp(tcp_listener)
@@ -119,7 +129,7 @@ pub trait Server: Sized + Send + Sync + 'static {
     /// implementation of this method contains the core logic of this
     /// Trait.
     fn run_async<A, H>(
-        config: Config<Self, A>,
+        mut config: Config<Self, A>,
         mut handler: H,
     ) -> Pin<Box<dyn Future<Output = ()> + Send + 'static>>
     where
@@ -135,7 +145,7 @@ pub trait Server: Sized + Send + Sync + 'static {
                 log::error!("signals handling not supported on windows yet");
             }
 
-            let mut listener = Self::build_listener(&config);
+            let mut listener = Self::build_listener(&mut config);
             let mut info = Self::info(&listener);
             info.server_description_mut().push_str(Self::DESCRIPTION);
             handler.init(&mut info).await;

smol/src/lib.rs

@@ -60,7 +60,7 @@ trillium_testing::with_server("ok", |url| async move {
 */
 
 use trillium::Handler;
-pub use trillium_server_common::{CloneCounterObserver, Stopper};
+pub use trillium_server_common::{Binding, CloneCounterObserver, Stopper};
 
 mod client;
 pub use client::ClientConfig;

smol/src/server/tcp.rs

@@ -8,6 +8,11 @@ use trillium_server_common::Server;
 
 #[derive(Debug)]
 pub struct SmolServer(TcpListener);
+impl From<TcpListener> for SmolServer {
+    fn from(value: TcpListener) -> Self {
+        Self(value)
+    }
+}
 
 impl Server for SmolServer {
     type Transport = SmolTransport<TcpStream>;

smol/src/server/unix.rs

@@ -14,6 +14,16 @@ use trillium_server_common::{
 
 #[derive(Debug, Clone)]
 pub struct SmolServer(Binding<TcpListener, UnixListener>);
+impl From<TcpListener> for SmolServer {
+    fn from(value: TcpListener) -> Self {
+        Self(Tcp(value))
+    }
+}
+impl From<UnixListener> for SmolServer {
+    fn from(value: UnixListener) -> Self {
+        Self(Unix(value))
+    }
+}
 
 #[cfg(unix)]
 impl Server for SmolServer {

testing/src/runtimeless.rs

@@ -34,7 +34,7 @@ impl Server for RuntimelessServer {
         })
     }
 
-    fn build_listener<A>(config: &Config<Self, A>) -> Self
+    fn build_listener<A>(config: &mut Config<Self, A>) -> Self
     where
         A: Acceptor<Self::Transport>,
     {

tokio/examples/tokio_binding.rs

@@ -0,0 +1,24 @@
+pub fn app() -> impl trillium::Handler {
+    |conn: trillium::Conn| async move {
+        let response = tokio::task::spawn(async {
+            tokio::time::sleep(std::time::Duration::from_millis(10)).await;
+            "successfully spawned a task"
+        })
+        .await
+        .unwrap();
+        conn.ok(response)
+    }
+}
+
+#[tokio::main]
+pub async fn main() {
+    env_logger::init();
+    let server = tokio::net::TcpListener::bind("localhost:8080")
+        .await
+        .unwrap();
+
+    trillium_tokio::config()
+        .with_prebound_server(server)
+        .run_async(app())
+        .await;
+}

tokio/src/lib.rs

@@ -34,7 +34,8 @@ async fn main() {
 use std::future::Future;
 
 use trillium::Handler;
-pub use trillium_server_common::{CloneCounterObserver, Stopper};
+
+pub use trillium_server_common::{Binding, CloneCounterObserver, Stopper};
 
 mod client;
 pub use client::ClientConfig;

tokio/src/server/tcp.rs

@@ -12,6 +12,12 @@ use trillium_server_common::Server;
 #[derive(Debug)]
 pub struct TokioServer(TcpListener);
 
+impl From<TcpListener> for TokioServer {
+    fn from(value: TcpListener) -> Self {
+        Self(value)
+    }
+}
+
 impl Server for TokioServer {
     type Transport = TokioTransport<Compat<TcpStream>>;
     const DESCRIPTION: &'static str = concat!(

tokio/src/server/unix.rs

@@ -15,6 +15,18 @@ use trillium_server_common::{
 #[derive(Debug)]
 pub struct TokioServer(Binding<TcpListener, UnixListener>);
 
+impl From<TcpListener> for TokioServer {
+    fn from(value: TcpListener) -> Self {
+        Self(Tcp(value))
+    }
+}
+
+impl From<UnixListener> for TokioServer {
+    fn from(value: UnixListener) -> Self {
+        Self(Unix(value))
+    }
+}
+
 impl Server for TokioServer {
     type Transport = Binding<TokioTransport<Compat<TcpStream>>, TokioTransport<Compat<UnixStream>>>;
     const DESCRIPTION: &'static str = concat!(