Struct ehttpd::Server

pub struct Server<const STACK_SIZE: usize = 65536> { /* private fields */ }

A HTTP server

Implementations

impl<const STACK_SIZE: usize> Server<STACK_SIZE>

pub fn new<T>(worker_max: usize, handler: T) -> Selfwhere
T: Fn(Request<'_>) -> Response + Send + Sync + 'static,

Creates a new server bound on the given address

Examples found in repository

examples/helloworld.rs (line 16)

fn main() {
    // Define our request handler
    let request_handler = |_: Request| {
        let mut response = Response::new_200_ok();
        response.set_body(Source::from(b"Hello world\r\n")).expect("failed to set body");
        response
    };

    // Create a server that listens at [::]:9999 with up to 2048 worker threads under load if necessary
    let server: Server = Server::new(2048, request_handler);
    server.accept("[::]:9999").expect("server failed");
}

examples/helloworld-nokeepalive.rs (line 17)

fn main() {
    // Define our request handler
    let request_handler = |_: Request| {
        let mut response = Response::new_200_ok();
        response.set_body(Source::from(b"Hello World")).expect("failed to get set body");
        response.set_connection_close();
        response
    };

    // Create a server that listens at [::]:9999 with up to 2048 worker threads under load if necessary
    let server: Server = Server::new(2048, request_handler);
    server.accept("[::]:9999").expect("server failed");
}

examples/teapot.rs (line 22)

fn main() {
    // Define our request handler
    let request_handler = |request: Request| {
        // Create the response body
        let mut message = b"There are only teapots in ".to_vec();
        message.extend_from_slice(&request.target);
        message.extend_from_slice(b"\r\n");

        // Send the response
        let mut response = Response::new_status_reason(418, "I'm a teapot");
        response.set_body(Source::from(message)).expect("failed to set body");
        response
    };

    // Create a server that listens at [::]:9999 with up to 2048 worker threads under load if necessary
    let server: Server = Server::new(2048, request_handler);
    server.accept("[::]:9999").expect("server failed");
}

pub fn dispatch(&self, connection: TcpStream) -> Result<(), Error>

Dispatches an incoming TCP stream

pub fn accept<T>(self, address: T) -> Result<Infallible, Error>where
T: ToSocketAddrs,

Listens on the given address and accepts forever

Examples found in repository

examples/helloworld.rs (line 17)

fn main() {
    // Define our request handler
    let request_handler = |_: Request| {
        let mut response = Response::new_200_ok();
        response.set_body(Source::from(b"Hello world\r\n")).expect("failed to set body");
        response
    };

    // Create a server that listens at [::]:9999 with up to 2048 worker threads under load if necessary
    let server: Server = Server::new(2048, request_handler);
    server.accept("[::]:9999").expect("server failed");
}

examples/helloworld-nokeepalive.rs (line 18)

fn main() {
    // Define our request handler
    let request_handler = |_: Request| {
        let mut response = Response::new_200_ok();
        response.set_body(Source::from(b"Hello World")).expect("failed to get set body");
        response.set_connection_close();
        response
    };

    // Create a server that listens at [::]:9999 with up to 2048 worker threads under load if necessary
    let server: Server = Server::new(2048, request_handler);
    server.accept("[::]:9999").expect("server failed");
}

examples/teapot.rs (line 23)

fn main() {
    // Define our request handler
    let request_handler = |request: Request| {
        // Create the response body
        let mut message = b"There are only teapots in ".to_vec();
        message.extend_from_slice(&request.target);
        message.extend_from_slice(b"\r\n");

        // Send the response
        let mut response = Response::new_status_reason(418, "I'm a teapot");
        response.set_body(Source::from(message)).expect("failed to set body");
        response
    };

    // Create a server that listens at [::]:9999 with up to 2048 worker threads under load if necessary
    let server: Server = Server::new(2048, request_handler);
    server.accept("[::]:9999").expect("server failed");
}