website/src/handlers/mod.rs

use axum::{
    body,
    extract::State,
    middleware::Next,
    response::{Html, IntoResponse, Response},
    routing::get,
    Router,
};
use hyper::{header::CONTENT_TYPE, Request, StatusCode};
use lazy_static::lazy_static;
use prometheus::{opts, Encoder, IntCounterVec, TextEncoder};
use std::sync::Arc;
use tracing::{instrument, log::*};

use crate::{AppState, WebsiteError};

pub mod posts;

lazy_static! {
    pub static ref HIT_COUNTER: IntCounterVec = prometheus::register_int_counter_vec!(
        opts!(
            "http_requests_total",
            "Total amount of http requests received"
        ),
        &["route", "method", "status"]
    )
    .unwrap();
}

pub fn routes(state: &Arc<AppState>) -> Router<Arc<AppState>> {
    Router::new()
        .route("/", get(index))
        .nest("/posts", posts::router())
        .merge(posts::alias_router(state.posts.values()))
        .route("/healthcheck", get(healthcheck))
        .route("/metrics", get(metrics))
        .nest_service("/static", tower_http::services::ServeDir::new("./static"))
        .layer(axum::middleware::from_fn(metrics_middleware))
}

#[instrument(skip(state))]
pub async fn index(
    State(state): State<Arc<AppState>>,
) -> std::result::Result<Html<String>, WebsiteError> {
    let ctx = tera::Context::new();
    let res = state.tera.render("index.html", &ctx).map_err(|e| {
        error!("Failed rendering index: {}", e);
        WebsiteError::NotFound
    })?;
    Ok(Html(res))
}

async fn healthcheck() -> &'static str {
    "OK"
}

async fn metrics() -> impl IntoResponse {
    let encoder = TextEncoder::new();
    let metric_families = prometheus::gather();
    let mut buffer = vec![];
    encoder.encode(&metric_families, &mut buffer).unwrap();

    Response::builder()
        .status(200)
        .header(CONTENT_TYPE, encoder.format_type())
        .body(body::boxed(body::Full::from(buffer)))
        .unwrap()
}

pub async fn not_found() -> Response {
    (StatusCode::NOT_FOUND, ()).into_response()
}

pub async fn metrics_middleware<B>(request: Request<B>, next: Next<B>) -> Response {
    let path = request.uri().path().to_string();
    let method = request.method().to_string();
    let response = next.run(request).await;
    HIT_COUNTER
        .with_label_values(&[&path, &method, response.status().as_str()])
        .inc();
    response
}

impl IntoResponse for WebsiteError {
    fn into_response(self) -> Response {
        match self {
            WebsiteError::NotFound => {
                info!("not found");
                (StatusCode::NOT_FOUND, ()).into_response()
            }
            WebsiteError::InternalError(e) => {
                error!("internal error: {e}");
                (StatusCode::INTERNAL_SERVER_ERROR, ()).into_response()
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use std::sync::Arc;

    use crate::AppState;

    #[test]
    fn render_index() {
        let tera = tera::Tera::new("templates/**/*").unwrap();
        let ctx = tera::Context::new();
        let _res = tera.render("index.html", &ctx).unwrap();
    }

    #[tokio::test]
    async fn setup_routes() {
        // Load the actual posts, just to make this test fail if
        // aliases overlap with themselves or other routes
        let state = Arc::new(AppState {
            tera: tera::Tera::new("templates/**/*").unwrap(),
            posts: crate::post::load_all().await.unwrap(),
        });

        super::routes(&state)
            .with_state(state)
            .into_make_service();
    }
}