main.rs

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

//! mon をそのまま動かす。土台だけで、機能は載っていない。
//!
//! mon はパスを 1 つも持たないので、`/health` も `/api/session` も `/relay` も `/static` も
//! ここで置いている。名前を変えたい、置きたくない、というときはこの並びをいじる。

use anyhow::Context;
use axum::Router;
use axum::routing::get;
use mon::state::AppState;
use mon::{conf, database, log, page, relay, route, server, session};
use std::net::SocketAddr;
use std::sync::Arc;
use tokio::net::TcpListener;


#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // ログレベルは RUST_LOG で決める（例: RUST_LOG=debug cargo run）。
    // guard は終わりまで持つ。落とすと書き出しのスレッドが止まる
    let _log = log::start("info,tower_http=debug");

    let conf = Arc::new(conf::load()?);
    let database = database::connect(&conf.database_url).await?;
    let client = relay::client(&conf).context("中継に使うクライアントを作れません")?;
    let store = session::store(&conf, &database);
    session::prepare(&store).await?;
    session::start_sweep(store.clone(), conf.session_max_age);

    // どのパスに何を置くかは、mon ではなくこちらが決める
    let routes = Router::new()
        .route("/health", get(route::health))
        .nest("/api/session", session::router())
        .nest("/relay", relay::router())
        .nest_service("/static", route::assets(&conf))
        .fallback(page::not_found);

    let state = AppState {
        database,
        client,
        session: store,
        conf: conf.clone(),
    };

    // HOST の既定は 127.0.0.1 なので、前段の nginx などを通らないリクエストは届かない
    let address = SocketAddr::new(conf.host, conf.port);
    let listener = TcpListener::bind(address)
        .await
        .with_context(|| format!("{address} で待ち受けられません"))?;
    tracing::info!("listening on http://{address}");

    server::run(listener, route::wrap(routes, state), &conf, shutdown_signal()).await?;

    Ok(())
}


/// Ctrl+C と SIGTERM を受けたら、処理中のリクエストを終えてから止まる
async fn shutdown_signal() {
    let interrupt = async {
        tokio::signal::ctrl_c()
            .await
            .expect("Ctrl+C を受け取る用意ができません");
    };

    #[cfg(unix)]
    let terminate = async {
        tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())
            .expect("SIGTERM を受け取る用意ができません")
            .recv()
            .await;
    };

    #[cfg(not(unix))]
    let terminate = std::future::pending::<()>();

    tokio::select! {
        _ = interrupt => {},
        _ = terminate => {},
    }
}