Struct trillium_testing::RuntimelessServer

pub struct RuntimelessServer { /* private fields */ }

A Server for testing that does not depend on any runtime

Trait Implementations

impl Debug for RuntimelessServer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for RuntimelessServer

fn drop(&mut self)

Executes the destructor for this type.

impl Server for RuntimelessServer

type Transport = TestTransport

the individual byte stream that http will be communicated over. This is often an async “stream” like TcpStream or UnixStream. See Transport

const DESCRIPTION: &'static str = "test server"

The description of this server, to be appended to the Info and potentially logged.

fn accept( &mut self, ) -> Pin<Box<dyn Future<Output = Result<Self::Transport>> + Send + '_>>

Asynchronously return a single Self::Transport from a Self::Listener. Must be implemented.

fn build_listener<A>(config: &Config<Self, A>) -> Self

where A: Acceptor<Self::Transport>,

Build a listener from the config. The default logic for this is described elsewhere. To override the default logic, server implementations could potentially implement this directly. To use this default logic, implement Server::listener_from_tcp and Server::listener_from_unix.

fn info(&self) -> Info

Build an Info from the Self::Listener type. See Info for more details.

fn block_on(fut: impl Future<Output = ()> + 'static)

Runtime implementation hook for blocking on a top level future.

fn spawn(fut: impl Future<Output = ()> + Send + 'static)

Runtime implementation hook for spawning a task.

fn clean_up(self) -> Pin<Box<dyn Future<Output = ()> + Send>>

After the server has shut down, perform any housekeeping, eg unlinking a unix socket.

fn listener_from_tcp(_tcp: TcpListener) -> Self

Build a Self::Listener from a tcp listener. This is called by the Server::build_listener default implementation, and is mandatory if the default implementation is used.

fn listener_from_unix(_tcp: UnixListener) -> Self

Build a Self::Listener from a tcp listener. This is called by the Server::build_listener default implementation. You will want to tag an implementation of this with #[cfg(unix)].

fn handle_signals(_stopper: Stopper) -> Pin<Box<dyn Future<Output = ()> + Send>>

Implementation hook for listening for any os signals and stopping the provided [Stopper]. The returned future will be spawned using Server::spawn

fn run<A, H>(config: Config<Self, A>, handler: H)

where A: Acceptor<Self::Transport>, H: Handler,

Run a trillium application from a sync context

fn run_async<A, H>( config: Config<Self, A>, handler: H, ) -> Pin<Box<dyn Future<Output = ()> + Send>>

where A: Acceptor<Self::Transport>, H: Handler,

Run a trillium application from an async context. The default implementation of this method contains the core logic of this Trait.