Struct humphrey::app::App

pub struct App<State> where
    State: Send + Sync + 'static,  { /* fields omitted */ }

Represents the Humphrey app.

The type parameter represents the app state, which is shared between threads. It must implement the Send and Sync traits to be sent between threads. The state is given to every request as an Arc<State>.

Implementations

impl<State> App<State> where
    State: Send + Sync + 'static, 

pub fn new() -> Self where
    State: Default, 

Initialises a new Humphrey app.

pub fn new_with_config(threads: usize, state: State) -> Self

Initialises a new Humphrey app with the given configuration options.

pub fn run<A>(self, addr: A) -> Result<(), HumphreyError> where
    A: ToSocketAddrs, 

Runs the Humphrey app on the given socket address. This function will only return if a fatal error is thrown such as the port being in use.

pub fn with_state(self, state: State) -> Self

Sets the default state for the server. Should only be used in cases where the Default trait cannot be implemented for State. For example, if the default state is dynamically generated as it is in the CLI.

pub fn with_route(self, route: &str, handler: RequestHandler<State>) -> Self

Adds a route and associated handler to the server. Routes can include wildcards, for example /blog/*.

Panics

This function will panic if the route string cannot be converted to a Uri object.

pub fn with_error_handler(self, handler: ErrorHandler) -> Self

Sets the error handler for the server.

pub fn with_connection_condition(
    self,
    condition: ConnectionCondition<State>
) -> Self

Sets the connection condition, a function which decides whether to accept the connection. For example, this could be used for implementing whitelists and blacklists.

pub fn with_websocket_handler(self, handler: WebsocketHandler<State>) -> Self

Sets the websocket handler, a function which processes WebSocket handshakes. This is passed the stream, state, and the request which triggered its calling.

pub fn with_custom_connection_handler(
    self,
    handler: ConnectionHandler<State>
) -> Self

Overrides the default connection handler, allowing for manual control over the TCP requests and responses. Not recommended as it basically disables most of the server’s features.

pub fn get_state(&self) -> &Arc<State>

Gets a reference to the app’s state. This should only be used in the main thread, as the state is passed to request handlers otherwise.