Struct spike::Server

pub struct Server<'a> { /* private fields */ }

A listening HTTP server that accepts HTTP 1 connections.

Implementations

impl<'a> Server<'a>

pub fn builder() -> ServerBuilder

Starts the ServerBuilder.

pub fn bind<A>(addr: A) -> Server<'static>where A: ToSocketAddrs,

Binds the Server to the given addr.

Panics

This method will panic if binding to the address fails. For a non panic method to bind the server, see ServerBuilder::try_bind.

pub fn serve<S>(self, service: S) -> Result<(), Error>where S: Service + Send + Clone + 'static,

Serves an Service on a thread per connection model, backed by a thread pool.

Example

Server::bind("0.0.0.0:4444").serve(|req: Request<_>| {
    Response::builder()
        .status(StatusCode::OK)
        .body(req.into_body())
})

pub fn serve_single_thread<S>(self, service: S) -> Result<(), Error>where S: Service + Clone,

Serves an Service on a single thread. This is useful when your Service is not Send. Note that if a connection is kept alive on this mode, no other request may be served before the said connection is closed.

Example

Server::bind("0.0.0.0:4444").serve_single_thread(|req: Request<_>| {
    Response::builder()
        .status(StatusCode::OK)
        .body(req.into_body())
})

pub fn make_service<M>(self, make_service: M) -> Result<(), Error>where M: MakeService + Clone + 'static, <M as MakeService>::Service: Send,

Serves an Connection. This should be used when you need to execute some logic on every connection.

Example

Server::builder()
    .bind("0.0.0.0:4444")
    .make_service(|conn: &Connection| {
        println!("New connection arrived: {:?}", conn.peer_addr());

        Ok::<_, Infallible>(|_req| {
            Response::builder()
                .status(StatusCode::OK)
                .body(())
        })
    })

Trait Implementations

impl From<TcpListener> for Server<'static>

fn from(listener: TcpListener) -> Server<'static>

Converts to this type from the input type.