webringer 1.0.3

A bin/lib crate for a webring site
Documentation 
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

#![warn(clippy::pedantic, clippy::all, clippy::cargo)]
#![allow(clippy::module_name_repetitions, clippy::multiple_crate_versions)]
use axum::{
	Router,
	routing::{get, post},
};
use axum_login::AuthManagerLayerBuilder;
use axum_login::tower_sessions::{MemoryStore, SessionManagerLayer};
use axum_messages::MessagesManagerLayer;
use clap::Parser;
use tokio::signal;
use tracing::{Instrument, error, info, info_span, instrument, warn};

use webringer::ring;
use webringer::site;

mod args;
mod database;
mod embed;

#[tokio::main(flavor = "current_thread")]
#[instrument]
async fn main() {
	tracing_subscriber::fmt::init();
	let args = args::Args::parse();

	if let Err(e) = dotenvy::dotenv() {
		warn!("No .env file found: {}", e);
	}

	let address = format!("{}:{}", args.address, args.port);

	let db_pool = database::get_db_pool();

	let session_store = MemoryStore::default();
	let session_layer = SessionManagerLayer::new(session_store);
	let backend = ring::RingState::new(db_pool.await);
	let auth_layer = AuthManagerLayerBuilder::new(backend.clone(), session_layer).build();

	let router = Router::new()
		.route("/", get(site::index))
		.route("/join", get(site::join::get))
		.route("/join", post(site::join::post))
		.route("/leave", get(site::leave::get))
		.route("/leave", post(site::leave::post))
		.route("/next", get(site::ring::next))
		.route("/prev", get(site::ring::prev))
		.route("/random", get(site::ring::random))
		.route("/list", get(site::ring::list))
		.route("/login", get(site::login::get))
		.route("/login", post(site::login::post))
		.with_state(backend.clone())
		.nest("/admin", site::admin::router(backend))
		.layer(MessagesManagerLayer)
		.layer(auth_layer)
		.route("/static/{*file}", get(embed::static_handler))
		.fallback_service(get(embed::not_found));

	info!("Binding to {}", address);
	let listener = match tokio::net::TcpListener::bind(address)
		.instrument(info_span!("TcpListener bind"))
		.await
	{
		Ok(listener) => listener,
		Err(e) => {
			error!("Tcp binding error: {}", e);
			panic!()
		}
	};
	if let Err(e) = axum::serve(listener, router)
		.with_graceful_shutdown(async {
			if let Err(e) = signal::ctrl_c().await {
				error!("Failed to listen for ctrl_c signal: {}", e);
				panic!()
			}
			info!("Gracefully shutting down from SIGINT");
		})
		.await
	{
		error!("Axum serving error: {}", e);
	}
}