Struct Server 

pub struct Server<Addr: Address, A = DefaultAcceptor> { /* private fields */ }

HTTP server.

Implementations

impl<A: Address> Server<A>

pub fn bind(addr: A) -> Self

Create a server that will bind to provided address.

pub fn from_listener(listener: A::Listener) -> Self

Create a server from an existing AddrListener.

impl<A: Address, Acc> Server<A, Acc>

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

Overwrite acceptor.

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 = axum_server::bind(addr).acceptor(acceptor);

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

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

where F: FnOnce(Acc) -> Acceptor,

Map acceptor.

pub fn get_ref(&self) -> &Acc

Returns a reference to the acceptor.

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

Returns a mutable reference to the acceptor.

pub fn http_builder(&mut self) -> &mut Builder<TokioExecutor>

Returns a mutable reference to the Http builder.

pub fn http1_only(self) -> Self

Only accepts HTTP/1

pub fn http2_only(self) -> Self

Only accepts HTTP/2

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

Provide a handle for additional 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);
    axum_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);
    axum_server::bind(addr)
        .handle(handle)
        .serve(app.into_make_service())
        .await
        .unwrap();

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

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

where M: MakeService<A, Request<Incoming>>, A: Send + 'static, A::Stream: Send, Acc: Accept<A::Stream, M::Service> + Clone + Send + Sync + 'static, Acc::Stream: AsyncRead + AsyncWrite + Unpin + Send, Acc::Service: SendService<Request<Incoming>> + Send, Acc::Future: Send,

Serve provided MakeService.

To create MakeService easily, Shared from tower can be used.

Errors

An error will be returned when:

• Binding to an address fails.
• make_service returns an error when poll_ready is called. This never happens on 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!" }));

    axum_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));

    axum_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);
    axum_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);
    axum_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);
    axum_server::bind(addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

examples/hello_world_unix.rs (line 15)

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

    let addr = SocketAddr::from_pathname("/tmp/axum-server.sock").unwrap();
    println!("listening on {}", addr.as_pathname().unwrap().display());
    axum_server::bind(addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

examples/from_std_listener.rs (line 17)

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);
    axum_server::from_tcp(listener)
        .unwrap()
        .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/remote_address_using_tower.rs
• examples/rustls_session.rs
• examples/rustls_reload.rs
• examples/from_std_listener_rustls.rs

Trait Implementations

impl<A: Address, B> Debug for Server<A, B>

where Listener<A>: Debug, Handle<A>: Debug, B: Debug,

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

Formats the value using the given formatter.