sawe 0.1.0

wrapper for salvo with handlebars, ufs, uiicons & SEO rendering
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

mod tls;



use tokio::signal;




use salvo::prelude::*;
use salvo::catcher::Catcher;
use salvo::server::ServerHandle;



pub async fn http3_server(
    r: Router,
    c: Catcher,
    addr: (&'static str, u16),
    path: impl AsRef<std::path::Path>
) -> Result<(), ServerError> {

    let config = tls::create_rustls_config(path.as_ref(), None)?;

    let listener = TcpListener::new(addr).rustls(config.clone());

    let acceptor = QuinnListener::new(config.build_quinn_config().unwrap(), addr).join(listener).bind().await;

    let service = Service::new(r).hoop(ForceHttps::new().https_port(addr.1));

    let server = Server::new(acceptor);

    let handle = server.handle();

    tokio::spawn(listen_shutdown_signal(handle));

    Ok(server.serve(service.catcher(c)).await)

}



async fn listen_shutdown_signal(handle: ServerHandle) -> Result<(), ServerError> {
    
    let ctrl_c = async {
        signal::ctrl_c().await.expect("failed to install Ctrl+C handler");
    };

    #[cfg(unix)]
    let terminate = async {
        signal::unix::signal(signal::unix::SignalKind::terminate()).expect("failed to install signal handler").recv().await;
    };

    #[cfg(windows)]
    let terminate = async {
        signal::windows::ctrl_c().expect("failed to install signal handler").recv().await;
    };

    tokio::select! {
        _ = ctrl_c => tracing::info!("ctrl_c signal received"),
        _ = terminate => tracing::info!("terminate signal received"),
    }

    handle.stop_graceful(None);

    Ok(())
}



#[derive(Debug, thiserror::Error)]
pub enum ServerError {
    #[error(transparent)]
    Io(#[from] std::io::Error),
    #[error(transparent)]
    Fmt(#[from] std::fmt::Error),
    #[error(transparent)]
    SalvoError(#[from] salvo::Error),
    #[error(transparent)]
    Join(#[from] tokio::task::JoinError),
    
    #[error(transparent)]
    TlsServerError(#[from] tls::TlsServerError),
}