Struct salvo::Server

pub struct Server<L> { /* fields omitted */ }

Server

Implementations

impl<L> Server<L> where
    L: Listener,
    <L as Accept>::Conn: 'static,
    <L as Accept>::Conn: Transport,
    <L as Accept>::Conn: Send,
    <L as Accept>::Conn: Unpin,
    <L as Accept>::Error: Into<Box<dyn Error + Send + Sync + 'static, Global>>, 

pub fn new(listener: L) -> Server<L>

Create new Server.

pub async fn serve<S>(self, service: S) where
    S: Into<Service>, 

Serve a service

pub async fn try_serve<S>(self, service: S) -> Result<(), Error> where
    S: Into<Service>, 

Try to serve a service

pub async fn serve_with_graceful_shutdown<S, G>(self, addr: S, signal: G) where
    S: Into<Service>,
    G: 'static + Future<Output = ()> + Send, 

Serve with graceful shutdown signal.

Example

use salvo_core::prelude::*;
use salvo_macros::fn_handler;
use tokio::sync::oneshot;

#[fn_handler]
async fn hello_world(res: &mut Response) {
    res.render_plain_text("Hello World!");
}

#[tokio::main]
async fn main() {
    let (tx, rx) = oneshot::channel();
    let router = Router::new().get(hello_world);
    let server = Server::new(TcpListener::bind(([0, 0, 0, 0], 7878))).serve_with_graceful_shutdown(router, async {
        rx.await.ok();
    });

    // Spawn the server into a runtime
    tokio::task::spawn(server);

    // Later, start the shutdown...
    let _ = tx.send(());
}

pub async fn try_serve_with_graceful_shutdown<S, G>(
    self,
    service: S,
    signal: G
) -> Result<(), Error> where
    S: Into<Service>,
    G: 'static + Future<Output = ()> + Send, 

Serve with graceful shutdown signal.