website/src/main.rs

#![warn(clippy::pedantic)]
#![allow(clippy::unused_async)] // axum handlers needs async, even if no awaiting happens
use std::{collections::HashMap, fmt::Display, sync::Arc, time::Duration};

use axum::{
    body::Body,
    extract::{MatchedPath, OriginalUri},
    http::{uri::PathAndQuery, Request, Uri},
    response::Response,
};
use chrono::DateTime;
use color_eyre::eyre::{Error, Result};

use post::Post;

use tag::Tag;
use tera::Tera;
use tower_http::{compression::CompressionLayer, cors::CorsLayer};
use tracing::{field::Empty, info_span, log::info, Span};

use tracing_subscriber::{prelude::*, EnvFilter};

mod feed;
mod handlers;
mod helpers;
mod hilighting;
mod markdown;
mod post;
mod tag;

#[derive(Default)]
pub struct AppState {
    startup_time: DateTime<chrono::offset::Utc>,
    base_url: Uri,
    posts: HashMap<String, Post>,
    tags: HashMap<String, Tag>,
    tera: Tera,
}

#[tokio::main]
async fn main() -> Result<()> {
    color_eyre::install()?;
    init_tracing();

    info!("Starting server...");

    let base_url: Uri = option_env!("SITE_BASE_URL")
        .unwrap_or("http://localhost:8080")
        .parse()
        .unwrap();
    let tera = Tera::new("templates/**/*")?;
    let mut state = AppState {
        startup_time: chrono::offset::Utc::now(),
        base_url,
        tera,
        ..Default::default()
    };
    let posts = post::load_all(&state).await?;
    let tags = tag::get_tags(posts.values());
    state.posts = posts;
    state.tags = tags;
    let state = Arc::new(state);

    let app = handlers::routes(&state)
        .layer(CorsLayer::permissive())
        .layer(CompressionLayer::new())
        .layer(
            tower_http::trace::TraceLayer::new_for_http()
                .make_span_with(make_span)
                .on_response(on_response),
        )
        .with_state(state.clone());

    info!("Now listening at {}", state.base_url);

    axum::Server::bind(&"0.0.0.0:8080".parse().unwrap())
        .serve(app.into_make_service())
        .await?;

    Ok(())
}

fn init_tracing() {
    let filter = EnvFilter::builder()
        .with_default_directive("into".parse().unwrap())
        .from_env_lossy();

    tracing_subscriber::registry()
        .with(filter)
        .with(tracing_subscriber::fmt::layer())
        .init();
}

fn make_span(request: &Request<Body>) -> Span {
    let uri = if let Some(OriginalUri(uri)) = request.extensions().get::<OriginalUri>() {
        uri
    } else {
        request.uri()
    };
    let route = request
        .extensions()
        .get::<MatchedPath>()
        .map_or(uri.path(), axum::extract::MatchedPath::as_str);
    let method = request.method().as_str();
    let target = uri
        .path_and_query()
        .map_or(uri.path(), PathAndQuery::as_str);
    let name = format!("{method} {route}");

    info_span!(
        "request",
        otel.name = %name,
        http.route = %route,
        http.method = %method,
        http.target = %target,
        http.status_code = Empty
    )
}

fn on_response(response: &Response, _latency: Duration, span: &Span) {
    span.record("http.status_code", response.status().as_str());
}

#[derive(Debug)]
pub enum WebsiteError {
    NotFound,
    InternalError(Error),
}

impl std::error::Error for WebsiteError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            WebsiteError::NotFound => None,
            WebsiteError::InternalError(e) => Some(e.as_ref()),
        }
    }
}

impl Display for WebsiteError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            WebsiteError::NotFound => write!(f, "Not found"),
            WebsiteError::InternalError(e) => write!(f, "Internal error: {e}"),
        }
    }
}

impl From<tera::Error> for WebsiteError {
    fn from(value: tera::Error) -> Self {
        WebsiteError::InternalError(value.into())
    }
}

impl From<color_eyre::Report> for WebsiteError {
    fn from(value: color_eyre::Report) -> Self {
        WebsiteError::InternalError(value)
    }
}
cargo clippy -- -W clippy::pedantic 2023-07-29 12:04:37 +02:00			`#![warn(clippy::pedantic)]`
			`#![allow(clippy::unused_async)] // axum handlers needs async, even if no awaiting happens`
make use of the base_url in appstate 2023-04-10 00:46:58 +02:00			`use std::{collections::HashMap, fmt::Display, sync::Arc, time::Duration};`
cargo fix & fmt 2022-09-05 00:05:24 +02:00
convert relative to absolute links everywhere 2023-07-29 15:32:05 +02:00			`use axum::{`
			`body::Body,`
			`extract::{MatchedPath, OriginalUri},`
			`http::{uri::PathAndQuery, Request, Uri},`
			`response::Response,`
			`};`
i don't know 2023-07-29 11:51:04 +02:00			`use chrono::DateTime;`
add tests for rendering the index pages 2023-03-26 13:05:39 +02:00			`use color_eyre::eyre::{Error, Result};`
cargo fix & cargo fmt 2023-03-29 18:20:51 +02:00
things 2023-03-25 12:23:11 +01:00			`use post::Post;`
cargo fix & cargo fmt 2023-03-29 18:20:51 +02:00
add tags 2023-03-29 21:48:27 +02:00			`use tag::Tag;`
some random progress 2022-08-31 23:20:59 +02:00			`use tera::Tera;`
telemetry & metrics stuff 2023-04-02 15:26:20 +02:00			`use tower_http::{compression::CompressionLayer, cors::CorsLayer};`
cargo clippy -- -W clippy::pedantic 2023-07-29 12:04:37 +02:00			`use tracing::{field::Empty, info_span, log::info, Span};`

telemetry & metrics stuff 2023-04-02 15:26:20 +02:00			`use tracing_subscriber::{prelude::*, EnvFilter};`
Initial commit 2022-06-16 23:44:37 +02:00
cargo fmt 2023-04-03 23:33:43 +02:00			`mod feed;`
some random progress 2022-08-31 23:20:59 +02:00			`mod handlers;`
convert relative to absolute links everywhere 2023-07-29 15:32:05 +02:00			`mod helpers;`
Code hilighting 2023-06-18 11:34:08 +02:00			`mod hilighting;`
			`mod markdown;`
things 2023-03-25 12:23:11 +01:00			`mod post;`
add tags 2023-03-29 21:48:27 +02:00			`mod tag;`
some random progress 2022-08-31 23:20:59 +02:00
make use of the base_url in appstate 2023-04-10 00:46:58 +02:00			`#[derive(Default)]`
make metrics into middleware, use .with_state 2023-03-29 18:03:54 +02:00			`pub struct AppState {`
i don't know 2023-07-29 11:51:04 +02:00			`startup_time: DateTime<chrono::offset::Utc>,`
convert relative to absolute links everywhere 2023-07-29 15:32:05 +02:00			`base_url: Uri,`
lotsastuff 2023-03-25 16:14:53 +01:00			`posts: HashMap<String, Post>,`
add tags 2023-03-29 21:48:27 +02:00			`tags: HashMap<String, Tag>,`
some random progress 2022-08-31 23:20:59 +02:00			`tera: Tera,`
			`}`

Initial commit 2022-06-16 23:44:37 +02:00			`#[tokio::main]`
			`async fn main() -> Result<()> {`
			`color_eyre::install()?;`
telemetry & metrics stuff 2023-04-02 15:26:20 +02:00			`init_tracing();`

Initial commit 2022-06-16 23:44:37 +02:00			`info!("Starting server...");`

convert relative to absolute links everywhere 2023-07-29 15:32:05 +02:00			`let base_url: Uri = option_env!("SITE_BASE_URL")`
i don't know 2023-07-29 11:51:04 +02:00			`.unwrap_or("http://localhost:8080")`
convert relative to absolute links everywhere 2023-07-29 15:32:05 +02:00			`.parse()`
			`.unwrap();`
make metrics into middleware, use .with_state 2023-03-29 18:03:54 +02:00			`let tera = Tera::new("templates/*/")?;`
convert relative to absolute links everywhere 2023-07-29 15:32:05 +02:00			`let mut state = AppState {`
i don't know 2023-07-29 11:51:04 +02:00			`startup_time: chrono::offset::Utc::now(),`
cargo fmt 2023-04-03 23:33:43 +02:00			`base_url,`
			`tera,`
convert relative to absolute links everywhere 2023-07-29 15:32:05 +02:00			`..Default::default()`
			`};`
			`let posts = post::load_all(&state).await?;`
			`let tags = tag::get_tags(posts.values());`
			`state.posts = posts;`
			`state.tags = tags;`
			`let state = Arc::new(state);`
make metrics into middleware, use .with_state 2023-03-29 18:03:54 +02:00
implement post aliases 2023-03-29 18:19:39 +02:00			`let app = handlers::routes(&state)`
add tags 2023-03-29 21:48:27 +02:00			`.layer(CorsLayer::permissive())`
make metrics into middleware, use .with_state 2023-03-29 18:03:54 +02:00			`.layer(CompressionLayer::new())`
cargo fmt 2023-04-02 15:27:06 +02:00			`.layer(`
			`tower_http::trace::TraceLayer::new_for_http()`
			`.make_span_with(make_span)`
			`.on_response(on_response),`
			`)`
make use of the base_url in appstate 2023-04-10 00:46:58 +02:00			`.with_state(state.clone());`
Progress 2022-09-05 00:02:58 +02:00
make use of the base_url in appstate 2023-04-10 00:46:58 +02:00			`info!("Now listening at {}", state.base_url);`
lotsastuff 2023-03-25 16:14:53 +01:00
i don't know 2023-07-29 11:51:04 +02:00			`axum::Server::bind(&"0.0.0.0:8080".parse().unwrap())`
lotsastuff 2023-03-25 16:14:53 +01:00			`.serve(app.into_make_service())`
			`.await?;`

			`Ok(())`
			`}`

telemetry & metrics stuff 2023-04-02 15:26:20 +02:00			`fn init_tracing() {`
			`let filter = EnvFilter::builder()`
			`.with_default_directive("into".parse().unwrap())`
add atom feeds 2023-04-03 23:33:25 +02:00			`.from_env_lossy();`
telemetry & metrics stuff 2023-04-02 15:26:20 +02:00
			`tracing_subscriber::registry()`
			`.with(filter)`
			`.with(tracing_subscriber::fmt::layer())`
			`.init();`
			`}`

			`fn make_span(request: &Request<Body>) -> Span {`
convert relative to absolute links everywhere 2023-07-29 15:32:05 +02:00			`let uri = if let Some(OriginalUri(uri)) = request.extensions().get::<OriginalUri>() {`
			`uri`
			`} else {`
			`request.uri()`
			`};`
telemetry & metrics stuff 2023-04-02 15:26:20 +02:00			`let route = request`
			`.extensions()`
			`.get::<MatchedPath>()`
convert relative to absolute links everywhere 2023-07-29 15:32:05 +02:00			`.map_or(uri.path(), axum::extract::MatchedPath::as_str);`
telemetry & metrics stuff 2023-04-02 15:26:20 +02:00			`let method = request.method().as_str();`
cargo fmt 2023-07-29 12:12:46 +02:00			`let target = uri`
			`.path_and_query()`
convert relative to absolute links everywhere 2023-07-29 15:32:05 +02:00			`.map_or(uri.path(), PathAndQuery::as_str);`
telemetry & metrics stuff 2023-04-02 15:26:20 +02:00			`let name = format!("{method} {route}");`

			`info_span!(`
			`"request",`
			`otel.name = %name,`
			`http.route = %route,`
			`http.method = %method,`
			`http.target = %target,`
			`http.status_code = Empty`
			`)`
			`}`

convert relative to absolute links everywhere 2023-07-29 15:32:05 +02:00			`fn on_response(response: &Response, _latency: Duration, span: &Span) {`
telemetry & metrics stuff 2023-04-02 15:26:20 +02:00			`span.record("http.status_code", response.status().as_str());`
			`}`

So much stuff 2023-03-25 21:38:16 +01:00			`#[derive(Debug)]`
			`pub enum WebsiteError {`
			`NotFound,`
polish 2023-03-26 12:40:25 +02:00			`InternalError(Error),`
So much stuff 2023-03-25 21:38:16 +01:00			`}`

make use of the base_url in appstate 2023-04-10 00:46:58 +02:00			`impl std::error::Error for WebsiteError {`
			`fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {`
			`match self {`
			`WebsiteError::NotFound => None,`
			`WebsiteError::InternalError(e) => Some(e.as_ref()),`
			`}`
			`}`
			`}`

			`impl Display for WebsiteError {`
			`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
			`match self {`
			`WebsiteError::NotFound => write!(f, "Not found"),`
cargo clippy -- -W clippy::pedantic 2023-07-29 12:04:37 +02:00			`WebsiteError::InternalError(e) => write!(f, "Internal error: {e}"),`
make use of the base_url in appstate 2023-04-10 00:46:58 +02:00			`}`
			`}`
			`}`

			`impl From<tera::Error> for WebsiteError {`
			`fn from(value: tera::Error) -> Self {`
So much stuff 2023-03-25 21:38:16 +01:00			`WebsiteError::InternalError(value.into())`
			`}`
			`}`
make use of the base_url in appstate 2023-04-10 00:46:58 +02:00
			`impl From<color_eyre::Report> for WebsiteError {`
			`fn from(value: color_eyre::Report) -> Self {`
			`WebsiteError::InternalError(value)`
			`}`
			`}`