Struct hyper_server::Server

pub struct Server<A = DefaultAcceptor> { /* private fields */ }

Represents an HTTP server with customization capabilities for handling incoming requests.

Implementations

impl Server

pub fn bind(addr: SocketAddr) -> Self

Constructs a server bound to the provided address.

pub fn from_tcp(listener: TcpListener) -> Self

Constructs a server from an existing std::net::TcpListener.

impl<A> Server<A>

pub fn acceptor<Acceptor>(self, acceptor: Acceptor) -> Server<Acceptor>

Replace the current acceptor with a new one.

Examples found in repository

examples/rustls_session.rs (line 32)

async fn main() {
    let app = Router::new().route("/", get(handler));

    let config = RustlsConfig::from_pem_file(
        "examples/self-signed-certs/cert.pem",
        "examples/self-signed-certs/key.pem",
    )
    .await
    .unwrap();

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));

    println!("listening on {}", addr);

    let acceptor = CustomAcceptor::new(RustlsAcceptor::new(config));
    let server = hyper_server::bind(addr).acceptor(acceptor);

    server.serve(app.into_make_service()).await.unwrap();
}

pub fn map<Acceptor, F>(self, acceptor: F) -> Server<Acceptor>

where F: FnOnce(A) -> Acceptor,

Maps the current acceptor to a new type.

pub fn get_ref(&self) -> &A

Retrieves a reference to the server’s acceptor.

pub fn get_mut(&mut self) -> &mut A

Retrieves a mutable reference to the server’s acceptor.

pub fn handle(self, handle: Handle) -> Self

Provides the server with a handle for extra utilities.

Examples found in repository

examples/shutdown.rs (line 24)

async fn main() {
    let app = Router::new().route("/", get(|| async { "Hello, world!" }));

    let handle = Handle::new();

    // Spawn a task to shutdown server.
    tokio::spawn(shutdown(handle.clone()));

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    println!("listening on {}", addr);
    hyper_server::bind(addr)
        .handle(handle)
        .serve(app.into_make_service())
        .await
        .unwrap();

    println!("server is shut down");
}

examples/graceful_shutdown.rs (line 27)

async fn main() {
    let app = Router::new().route("/", get(|| async { "Hello, world!" }));

    let handle = Handle::new();

    // Spawn a task to gracefully shutdown server.
    tokio::spawn(graceful_shutdown(handle.clone()));

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    println!("listening on {}", addr);
    hyper_server::bind(addr)
        .handle(handle)
        .serve(app.into_make_service())
        .await
        .unwrap();

    println!("server is shut down");
}

pub fn http_config(self, config: HttpConfig) -> Self

Replaces the current HTTP configuration.

Examples found in repository

examples/configure_http.rs (line 22)

async fn main() {
    let app = Router::new().route("/", get(|| async { "Hello, world!" }));

    let config = HttpConfig::new()
        .http1_only(true)
        .http2_only(false)
        .max_buf_size(8192)
        .build();

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    println!("listening on {}", addr);
    hyper_server::bind(addr)
        .http_config(config)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

pub fn addr_incoming_config(self, config: AddrIncomingConfig) -> Self

Replaces the current incoming address configuration.

Examples found in repository

examples/configure_addr_incoming.rs (line 25)

async fn main() {
    let app = Router::new().route("/", get(|| async { "Hello, world!" }));

    let config = AddrIncomingConfig::new()
        .tcp_nodelay(true)
        .tcp_sleep_on_accept_errors(true)
        .tcp_keepalive(Some(Duration::from_secs(32)))
        .tcp_keepalive_interval(Some(Duration::from_secs(1)))
        .tcp_keepalive_retries(Some(1))
        .build();

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    println!("listening on {}", addr);
    hyper_server::bind(addr)
        .addr_incoming_config(config)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

pub async fn serve<M>(self, make_service: M) -> Result<()>

where M: MakeServiceRef<AddrStream, Request<Body>>, A: Accept<AddrStream, M::Service> + Clone + Send + Sync + 'static, A::Stream: AsyncRead + AsyncWrite + Unpin + Send, A::Service: SendService<Request<Body>> + Send, A::Future: Send,

Serves the provided MakeService.

The MakeService is responsible for constructing services for each incoming connection. Each service is then used to handle requests from that specific connection.

Arguments

• make_service: A mutable reference to a type implementing the MakeServiceRef trait. This will be used to produce a service for each incoming connection.

Errors

This method can return errors in the following scenarios:

• When binding to an address fails.
• If the make_service function encounters an error during its poll_ready call. It’s worth noting that this error scenario doesn’t typically occur with axum make services.

Examples found in repository

examples/multiple_addresses.rs (line 22)

async fn start_server(addr: SocketAddr) {
    let app = Router::new().route("/", get(|| async { "Hello, world!" }));

    hyper_server::bind(addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

examples/remote_address.rs (line 16)

async fn main() {
    let app = Router::new()
        .route("/", get(handler))
        .into_make_service_with_connect_info::<SocketAddr>();

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));

    hyper_server::bind(addr).serve(app).await.unwrap();
}

examples/http_and_https.rs (line 25)

async fn http_server() {
    let app = Router::new().route("/", get(http_handler));

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    println!("http listening on {}", addr);
    hyper_server::bind(addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

async fn http_handler(uri: Uri) -> Redirect {
    let uri = format!("https://127.0.0.1:3443{}", uri.path());

    Redirect::temporary(&uri)
}

async fn https_server() {
    let app = Router::new().route("/", get(|| async { "Hello, world!" }));

    let config = RustlsConfig::from_pem_file(
        "examples/self-signed-certs/cert.pem",
        "examples/self-signed-certs/key.pem",
    )
    .await
    .unwrap();

    let addr = SocketAddr::from(([127, 0, 0, 1], 3443));
    println!("https listening on {}", addr);
    hyper_server::bind_rustls(addr, config)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

examples/hello_world.rs (line 15)

async fn main() {
    let app = Router::new().route("/", get(|| async { "Hello, world!" }));

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    println!("listening on {}", addr);
    hyper_server::bind(addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

examples/from_std_listener.rs (line 16)

async fn main() {
    let app = Router::new().route("/", get(|| async { "Hello, world!" }));

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    let listener = TcpListener::bind(addr).unwrap();
    println!("listening on {}", addr);
    hyper_server::from_tcp(listener)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

examples/configure_http.rs (line 23)

async fn main() {
    let app = Router::new().route("/", get(|| async { "Hello, world!" }));

    let config = HttpConfig::new()
        .http1_only(true)
        .http2_only(false)
        .max_buf_size(8192)
        .build();

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    println!("listening on {}", addr);
    hyper_server::bind(addr)
        .http_config(config)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

Additional examples can be found in:

• examples/shutdown.rs
• examples/rustls_server.rs
• examples/graceful_shutdown.rs
• examples/rustls_session.rs
• examples/from_std_listener_rustls.rs
• examples/rustls_reload.rs
• examples/remote_address_using_tower.rs
• examples/configure_addr_incoming.rs

Trait Implementations

impl<A: Debug> Debug for Server<A>

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

Formats the value using the given formatter.