119 lines
3.9 KiB
Rust
119 lines
3.9 KiB
Rust
mod config;
|
|
mod routes;
|
|
mod tasks;
|
|
|
|
use axum::Router;
|
|
use database::{ConnectOptions, get_connection};
|
|
use tracing::{debug, info};
|
|
use tracing_subscriber::fmt::format::{DefaultFields, Format};
|
|
|
|
use crate::config::{LoggingSettings, ProgramSettings, get_program_settings};
|
|
|
|
#[tokio::main]
|
|
async fn main() {
|
|
// Temporary subscriber for initial logging during configuration reading
|
|
let make_temporary_subscriber = || {
|
|
tracing_subscriber::fmt()
|
|
.with_max_level(tracing::Level::DEBUG)
|
|
.with_target(false)
|
|
.with_level(true)
|
|
.finish()
|
|
};
|
|
|
|
let settings =
|
|
tracing::subscriber::with_default(make_temporary_subscriber(), || -> ProgramSettings {
|
|
debug!("Temporary subscriber installed.");
|
|
info!("Reading configuration...");
|
|
let settings = get_program_settings();
|
|
info!("Configuration read successfully.");
|
|
debug!("Resetting global subscriber...");
|
|
|
|
let subscriber = get_global_tracing_subscriber_builder(&settings.logging).finish();
|
|
tracing::subscriber::set_global_default(subscriber)
|
|
.expect("Failed to set global default subscriber");
|
|
|
|
debug!(
|
|
"Global subscriber set with logging level: {:?}",
|
|
settings.logging.level
|
|
);
|
|
|
|
settings
|
|
});
|
|
|
|
tasks::startup::run_startup_tasks(&settings)
|
|
.await
|
|
.expect("Failed to run startup tasks");
|
|
|
|
// setup database connection pool
|
|
info!("Establishing database connection...");
|
|
debug!("Database URL: {}", settings.database.url);
|
|
|
|
let db_options = |options: &mut ConnectOptions| {
|
|
options.max_connections(settings.database.max_connections);
|
|
};
|
|
|
|
let db_connection = get_connection(&settings.database.url, Some(db_options))
|
|
.await
|
|
.expect("Failed to establish database connection");
|
|
|
|
info!("Database connection established.");
|
|
|
|
// build the axum app and run the server...
|
|
info!("Starting application...");
|
|
let app: Router = routes::get_root_router(routes::AppState {
|
|
database_connection: db_connection,
|
|
service: std::sync::Arc::new(routes::AppService {}),
|
|
});
|
|
|
|
let address = format!("{}:{}", settings.server.address, settings.server.port);
|
|
info!("Starting server at http://{}", address);
|
|
|
|
let listener = tokio::net::TcpListener::bind(address)
|
|
.await
|
|
.expect("Failed to bind to address");
|
|
|
|
axum::serve(listener, app)
|
|
.await
|
|
.expect("Failed to run the server");
|
|
}
|
|
|
|
fn get_global_tracing_subscriber_builder(
|
|
settings: &LoggingSettings,
|
|
) -> tracing_subscriber::fmt::SubscriberBuilder<
|
|
DefaultFields,
|
|
Format<tracing_subscriber::fmt::format::Full, BoxedTimer>,
|
|
> {
|
|
// After configuration is read, install the global subscriber
|
|
let builder = tracing_subscriber::fmt()
|
|
.with_max_level(settings.level)
|
|
.with_target(false)
|
|
.with_level(true);
|
|
|
|
if settings.utc {
|
|
builder.with_timer(BoxedTimer(Box::new(
|
|
tracing_subscriber::fmt::time::UtcTime::rfc_3339(),
|
|
)))
|
|
} else {
|
|
builder.with_timer(BoxedTimer(Box::new(
|
|
tracing_subscriber::fmt::time::ChronoLocal::rfc_3339(),
|
|
)))
|
|
}
|
|
}
|
|
|
|
// A small wrapper that holds a boxed `FormatTime` trait object and itself
|
|
// implements `FormatTime`, allowing us to use it as a concrete type with
|
|
// `builder.with_timer` while still picking the concrete timer implementation
|
|
// at runtime.
|
|
// wrapper type to hold boxed timers and implement the `FormatTime` trait for
|
|
// a concrete type so `with_timer` may be called once outside the conditional.
|
|
struct BoxedTimer(Box<dyn tracing_subscriber::fmt::time::FormatTime + Send + Sync + 'static>);
|
|
|
|
impl tracing_subscriber::fmt::time::FormatTime for BoxedTimer {
|
|
fn format_time(
|
|
&self,
|
|
w: &mut tracing_subscriber::fmt::format::Writer<'_>,
|
|
) -> std::result::Result<(), std::fmt::Error> {
|
|
self.0.format_time(w)
|
|
}
|
|
}
|