blargh

Cargo.lock

@@ -2624,7 +2624,6 @@ dependencies = [
  "cached",
  "chrono",
  "config",
- "glob",
  "opentelemetry",
  "opentelemetry-otlp",
  "opentelemetry_sdk",

Cargo.toml

@@ -11,7 +11,6 @@ axum = { version = "0.7.5", features = ["http2", "original-uri", "tracing"] }
 cached = "0.49.3"
 chrono = { version = "0.4.31", features = ["serde"] }
 config = "0.14.0"
-glob = "0.3.0"
 opentelemetry = { version = "0.22.0", features = ["trace", "metrics"] }
 opentelemetry-otlp = { version = "0.15.0", features = ["trace", "metrics", "logs"] }
 opentelemetry_sdk = { version = "0.22.1", features = ["rt-tokio", "trace", "metrics"] }

compose.yaml

@@ -6,6 +6,8 @@ services:
       - "8080:8080"
     depends_on:
       - otel-collector
+    environment:
+      TLX_OTLP_ENABLED: true
   otel-collector:
     image: otel/opentelemetry-collector:latest
     restart: always

src/handlers/mod.rs

@@ -8,13 +8,10 @@ use axum::{
 };
 use chrono::{DateTime, FixedOffset};
 use opentelemetry::{global, metrics::Counter, KeyValue};
-use tokio::sync::OnceCell;
 use std::sync::Arc;
+use tokio::sync::OnceCell;
 use tower_http::services::ServeDir;
-use tracing::{
-    instrument,
-    log::{debug, error, info},
-};
+use tracing::{instrument, log::error};
 
 use crate::{AppState, WebsiteError};
 
@@ -24,21 +21,19 @@ pub mod tags;
 pub static HIT_COUNTER: OnceCell<Counter<u64>> = OnceCell::const_new();
 
 async fn record_hit(method: String, path: String) {
-    let counter = HIT_COUNTER.get_or_init(|| async {
-        global::meter("tlxite").u64_counter("page_hit_count").init()
-    }).await;
+    let counter = HIT_COUNTER
+        .get_or_init(|| async { global::meter("tlxite").u64_counter("page_hit_count").init() })
+        .await;
 
     counter.add(1, &[KeyValue::new("path", format!("{method} {path}"))]);
 }
 
-pub fn routes(state: &Arc<AppState>) -> Router<Arc<AppState>> {
+pub fn routes() -> Router<Arc<AppState>> {
     Router::new()
         .route("/", get(index))
         .merge(pages::router())
         .merge(tags::router())
-        .merge(pages::alias_router(state.pages.values()))
         .route("/healthcheck", get(healthcheck))
-        .route_service("/posts/:slug/*path", ServeDir::new("./"))
         .route_service("/static/*path", ServeDir::new("./"))
         .layer(axum::middleware::from_fn(metrics_middleware))
 }
@@ -59,7 +54,13 @@ pub async fn index(
     })?;
     Ok((
         StatusCode::OK,
-        [(header::LAST_MODIFIED, state.startup_time.to_rfc2822())],
+        [
+            (
+                header::LAST_MODIFIED,
+                state.startup_time.to_rfc2822().as_str(),
+            ),
+            (header::CACHE_CONTROL, "no-cache"),
+        ],
         Html(res),
     )
         .into_response())
@@ -89,29 +90,23 @@ pub async fn metrics_middleware(request: Request, next: Next) -> Response {
 
 fn should_return_304(headers: &HeaderMap, last_changed: Option<DateTime<FixedOffset>>) -> bool {
     let Some(date) = last_changed else {
-        debug!("no last modified date");
         return false;
     };
     let Some(since) = headers.get(header::IF_MODIFIED_SINCE) else {
-        debug!("no IF_MODIFIED_SINCE header");
         return false;
     };
 
     let Ok(parsed) = DateTime::<FixedOffset>::parse_from_rfc2822(since.to_str().unwrap()) else {
-        debug!("failed to parse IF_MODIFIED_SINCE header");
         return false;
     };
 
-    date > parsed
+    date >= parsed
 }
 
 impl IntoResponse for WebsiteError {
     fn into_response(self) -> Response {
         match self {
-            WebsiteError::NotFound => {
-                info!("not found");
-                (StatusCode::NOT_FOUND, ()).into_response()
-            }
+            WebsiteError::NotFound => (StatusCode::NOT_FOUND, ()).into_response(),
             WebsiteError::InternalError(e) => {
                 if let Some(s) = e.source() {
                     error!("internal error: {}: {}", e, s);
@@ -148,11 +143,13 @@ mod tests {
         };
         // Load the actual posts, just to make this test fail if
         // aliases overlap with themselves or other routes
-        let posts = crate::page::load_all(&state, "posts/".into()).await.unwrap();
+        let posts = crate::page::load_all(&state, "pages/".into())
+            .await
+            .unwrap();
         state.tags = crate::tag::get_tags(posts.values());
         state.pages = posts;
         let state = Arc::new(state);
 
-        super::routes(&state).with_state(state).into_make_service();
+        super::routes().with_state(state).into_make_service();
     }
 }

src/handlers/pages.rs

@@ -1,18 +1,20 @@
 use std::sync::Arc;
 
 use axum::{
-    extract::{Path, State},
-    http::{header, HeaderMap, StatusCode},
+    extract::{OriginalUri, Path, Request, State},
+    http::{self, header, request, HeaderMap, StatusCode},
     response::{Html, IntoResponse, Redirect, Response},
     routing::get,
     Router,
 };
 
 use serde_derive::Serialize;
-use tracing::{instrument, log::warn};
+use tower::{Service, ServiceExt};
+use tower_http::{follow_redirect::policy::PolicyExt, services::ServeDir};
+use tracing::{debug, instrument};
 
 use crate::{
-    page::{render_post, Page},
+    page::{render_page, Page},
     AppState, WebsiteError,
 };
 
@@ -20,30 +22,10 @@ use super::should_return_304;
 
 pub fn router() -> Router<Arc<AppState>> {
     Router::new()
-        .route("/posts", get(|| async { Redirect::permanent("/") }))
         .route("/atom.xml", get(feed))
         .route("/posts/", get(index))
-        .route("/posts/:slug", get(redirect))
-        .route("/posts/:slug/", get(view))
-        .route("/posts/:slug/index.md", get(super::not_found))
-}
-
-pub fn alias_router<'a>(posts: impl IntoIterator<Item = &'a Page>) -> Router<Arc<AppState>> {
-    let mut router = Router::new();
-
-    for post in posts {
-        for alias in &post.aliases {
-            let path = post.absolute_path.clone();
-            router = router.route(
-                alias,
-                get(move || async {
-                    let p = path;
-                    Redirect::permanent(&p)
-                }),
-            );
-        }
-    }
-    router
+        .route("/posts", get(|| async { Redirect::permanent("/") }))
+        .route("/*path", get(view))
 }
 
 #[derive(Serialize, Debug)]
@@ -51,7 +33,7 @@ struct PageContext<'a> {
     title: &'a str,
 }
 
-#[instrument(skip(state))]
+#[instrument(skip(state, headers))]
 async fn index(
     State(state): State<Arc<AppState>>,
     headers: HeaderMap,
@@ -82,42 +64,83 @@ async fn index(
 
     Ok((
         StatusCode::OK,
-        [(
-            header::LAST_MODIFIED,
-            last_changed.map_or_else(|| state.startup_time.to_rfc2822(), |d| d.to_rfc2822()),
-        )],
+        [
+            (
+                header::LAST_MODIFIED,
+                last_changed
+                    .map_or_else(|| state.startup_time.to_rfc2822(), |d| d.to_rfc2822())
+                    .as_str(),
+            ),
+            (header::CACHE_CONTROL, "no-cache"),
+        ],
         Html(res),
     )
         .into_response())
 }
 
-#[instrument(skip(state))]
+#[instrument(skip(state, uri, method, headers, request))]
 async fn view(
-    Path(slug): Path<String>,
+    uri: OriginalUri,
     State(state): State<Arc<AppState>>,
+    method: http::method::Method,
     headers: HeaderMap,
-) -> Result<axum::response::Response, WebsiteError> {
-    let post = state.pages.get(&slug).ok_or(WebsiteError::NotFound)?;
+    request: Request,
+) -> Result<Response, WebsiteError> {
+    // Fetch post
+    let Some(post) = state.pages.get(uri.path()) else {
+        // Invalid path for a post, check aliases
+        if let Some(p) = state.aliases.get(uri.path()) {
+            return Ok(Redirect::permanent(p).into_response());
+        }
 
-    let last_changed = post.last_modified();
+        // No alias, check if there's an easy redirect
+        if !uri.path().ends_with('/') {
+            let p = format!("{}/", uri.path());
+            if state.pages.contains_key(&p) {
+                return Ok(Redirect::permanent(&p).into_response());
+            }
+        }
 
-    if should_return_304(&headers, last_changed) {
-        return Ok(StatusCode::NOT_MODIFIED.into_response());
-    }
+        // TODO: I don't like how we create a new oneshot for every 404 request, but I don't know if there's a better way
+        return Ok(ServeDir::new("pages")
+            .oneshot(request)
+            .await
+            .unwrap()
+            .into_response());
+    };
 
     if !post.is_published() {
-        warn!("attempted to view post before it has been published!");
         return Err(WebsiteError::NotFound);
     }
 
-    let res = render_post(&state, post).await?;
+    // Check if they have the current page cached
+    if let Some(etag) = headers.get(header::IF_NONE_MATCH) {
+        if let Ok(etag) = etag.to_str() {
+            if etag == post.etag {
+                return Ok(StatusCode::NOT_MODIFIED.into_response());
+            }
+        }
+    }
+
+    if method == http::method::Method::HEAD {
+        return Ok((
+            StatusCode::OK,
+            [
+                (header::ETAG, post.etag.as_str()),
+                (header::CACHE_CONTROL, "no-cache"),
+            ],
+        )
+            .into_response());
+    }
+
+    let res = render_page(&state, post).await?;
 
     Ok((
         StatusCode::OK,
-        [(
-            header::LAST_MODIFIED,
-            last_changed.map_or_else(|| state.startup_time.to_rfc2822(), |d| d.to_rfc2822()),
-        )],
+        [
+            (header::ETAG, post.etag.as_str()),
+            (header::CACHE_CONTROL, "no-cache"),
+        ],
         Html(res),
     )
         .into_response())
@@ -160,11 +183,13 @@ pub async fn feed(
 
 #[instrument(skip(state))]
 pub async fn redirect(
-    Path(slug): Path<String>,
+    uri: OriginalUri,
     State(state): State<Arc<AppState>>,
 ) -> Result<Redirect, WebsiteError> {
-    if state.pages.contains_key(&slug) {
-        Ok(Redirect::permanent(&format!("/posts/{slug}/")))
+    let path = uri.path();
+    let p = format!("{path}/");
+    if state.pages.contains_key(&p) {
+        Ok(Redirect::permanent(&format!("{path}/")))
     } else {
         Err(WebsiteError::NotFound)
     }

src/main.rs

@@ -10,9 +10,9 @@ use settings::Settings;
 use tag::Tag;
 use tera::Tera;
 
-use tokio::net::TcpListener;
+use tokio::{net::TcpListener, signal};
 use tower_http::{compression::CompressionLayer, cors::CorsLayer};
-use tracing::{instrument, log::info};
+use tracing::{debug, instrument, log::info};
 
 use anyhow::{Error, Result};
 
@@ -31,6 +31,7 @@ pub struct AppState {
     startup_time: DateTime<chrono::offset::Utc>,
     base_url: Uri,
     pages: HashMap<String, Page>,
+    aliases: HashMap<String, String>,
     tags: HashMap<String, Tag>,
     tera: Tera,
 }
@@ -44,7 +45,10 @@ async fn main() -> Result<()> {
     info!("Starting server...");
     let app = init_app(&cfg).await?;
     let listener = TcpListener::bind(&cfg.bind_address).await.unwrap();
-    axum::serve(listener, app.into_make_service()).await?;
+
+    axum::serve(listener, app.into_make_service())
+        .with_graceful_shutdown(shutdown_signal())
+        .await?;
 
     opentelemetry::global::shutdown_tracer_provider();
 
@@ -63,14 +67,27 @@ async fn init_app(cfg: &Settings) -> Result<axum::routing::Router> {
         ..Default::default()
     };
 
-    let posts = page::load_all(&state, "pages/".into()).await?;
-    let tags = tag::get_tags(posts.values());
-    state.pages = posts;
+    let pages = page::load_all(&state, "pages/".into()).await?;
+    info!("{} pages loaded", pages.len());
+    for page in pages.values() {
+        debug!("slug: {}, path: {}", page.slug, page.absolute_path);
+    }
+
+    let tags = tag::get_tags(pages.values());
+    state.aliases = pages
+        .values()
+        .flat_map(|p| {
+            p.aliases
+                .iter()
+                .map(|a| (a.clone(), p.absolute_path.clone()))
+        })
+        .collect();
+    state.pages = pages;
     state.tags = tags;
     let state = Arc::new(state);
 
     info!("Listening at {}", state.base_url);
-    Ok(handlers::routes(&state)
+    Ok(handlers::routes()
         .layer(CorsLayer::permissive())
         .layer(CompressionLayer::new())
         .layer(
@@ -81,6 +98,30 @@ async fn init_app(cfg: &Settings) -> Result<axum::routing::Router> {
         .with_state(state.clone()))
 }
 
+async fn shutdown_signal() {
+    let ctrl_c = async {
+        signal::ctrl_c()
+            .await
+            .expect("failed to install Ctrl+C handler");
+    };
+
+    #[cfg(unix)]
+    let terminate = async {
+        signal::unix::signal(signal::unix::SignalKind::terminate())
+            .expect("failed to install signal handler")
+            .recv()
+            .await;
+    };
+
+    #[cfg(not(unix))]
+    let terminate = std::future::pending::<()>();
+
+    tokio::select! {
+        () = ctrl_c => {},
+        () = terminate => {},
+    }
+}
+
 #[derive(Debug)]
 pub enum WebsiteError {
     NotFound,

src/markdown.rs

@@ -16,7 +16,7 @@ static EMAIL_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"^.+?@\w+(\.\w+)*$").unw
 
 pub struct RenderResult {
     pub content_html: String,
-    pub metadata: String
+    pub metadata: String,
 }
 
 #[instrument(skip(markdown))]

src/observability.rs

@@ -9,7 +9,10 @@ use axum::{
 use opentelemetry::{global, KeyValue};
 use opentelemetry_otlp::WithExportConfig;
 use opentelemetry_sdk::{
-    metrics::reader::{DefaultAggregationSelector, DefaultTemporalitySelector}, propagation::TraceContextPropagator, trace::{RandomIdGenerator, Sampler}, Resource
+    metrics::reader::{DefaultAggregationSelector, DefaultTemporalitySelector},
+    propagation::TraceContextPropagator,
+    trace::{RandomIdGenerator, Sampler},
+    Resource,
 };
 use tracing::{field::Empty, info_span, Span};
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
@@ -21,8 +24,6 @@ pub fn init(cfg: &Settings) -> Result<(), Error> {
         .with_default_directive("info".parse()?)
         .parse_lossy(&cfg.logging);
 
-
-
     if cfg.otlp.enabled {
         let tracer = opentelemetry_otlp::new_pipeline()
             .tracing()
@@ -42,7 +43,6 @@ pub fn init(cfg: &Settings) -> Result<(), Error> {
         global::set_text_map_propagator(TraceContextPropagator::new());
         let otel_tracer = tracing_opentelemetry::layer().with_tracer(tracer);
 
-
         let meter = opentelemetry_otlp::new_pipeline()
             .metrics(opentelemetry_sdk::runtime::Tokio)
             .with_exporter(
@@ -59,8 +59,6 @@ pub fn init(cfg: &Settings) -> Result<(), Error> {
 
         global::set_meter_provider(meter);
 
-
-
         // let logger = opentelemetry_otlp::new_pipeline()
         //     .logging()
         //     .with_exporter(
@@ -76,17 +74,13 @@ pub fn init(cfg: &Settings) -> Result<(), Error> {
             .with(otel_tracer)
             .with(tracing_subscriber::fmt::layer().compact())
             .init();
-    }
-    else {
+    } else {
         tracing_subscriber::registry()
             .with(filter)
             .with(tracing_subscriber::fmt::layer().compact())
             .init();
     }
 
-
-
-
     Ok(())
 }
 

src/page.rs

@@ -1,4 +1,9 @@
-use std::{collections::HashMap, fmt::Debug, path::{Path, PathBuf}};
+use std::{
+    collections::HashMap,
+    fmt::Debug,
+    hash::{Hash, Hasher},
+    path::{Path, PathBuf},
+};
 
 use anyhow::Result;
 
@@ -7,10 +12,7 @@ use chrono::{DateTime, FixedOffset};
 use serde_derive::{Deserialize, Serialize};
 use tokio::fs;
 
-use tracing::{
-    instrument,
-    log::debug,
-};
+use tracing::{instrument, log::debug};
 
 use crate::{helpers, markdown, AppState, WebsiteError};
 
@@ -35,13 +37,19 @@ pub struct Page {
     pub content: String,
     pub slug: String,
     pub absolute_path: String,
+    pub etag: String,
 }
 
 impl Page {
     pub fn new(slug: String, content: String, fm: TomlFrontMatter) -> Page {
+        let mut hasher = std::hash::DefaultHasher::default();
+        content.hash(&mut hasher);
+        let etag = format!("W/\"{:x}\"", hasher.finish());
+
         Page {
-            absolute_path: format!("/posts/{slug}/"),
+            absolute_path: format!("/{slug}/"),
             slug,
+            etag,
             content,
             title: fm.title,
             draft: fm.draft.unwrap_or(false),
@@ -72,56 +80,52 @@ impl Page {
 #[instrument(skip(state))]
 pub async fn load_all(state: &AppState, folder: PathBuf) -> Result<HashMap<String, Page>> {
     let mut pages = HashMap::<String, Page>::new();
-    let mut dirs: Vec<PathBuf> = vec![folder];
+    let mut dirs: Vec<PathBuf> = vec![folder.clone()];
 
     while let Some(dir) = dirs.pop() {
-        let mut read_dir = fs::read_dir(dbg!(dir)).await?;
+        let mut read_dir = fs::read_dir(&dir).await?;
 
         while let Some(entry) = read_dir.next_entry().await? {
             let path = entry.path();
             if path.is_dir() {
                 dirs.push(path);
-            }
-            else if let Some(ext) = path.extension() {
+            } else if let Some(ext) = path.extension() {
                 if ext == "md" {
                     // it's a page to load
-                    let page = load_page(state, &path).await?;
-                    pages.insert(page.slug.clone(), page);
+                    let page = load_page(state, &path, &folder).await?;
+                    pages.insert(page.absolute_path.clone(), page);
                 }
             }
         }
     }
 
-    // for path in --- {
-    //     let path = path.unwrap();
-    //     debug!("found page: {}", path.display());
-
-    //     let post = load_post(state, &path).await?;
-
-    //     res.insert(post.slug.clone(), post);
-    // }
     Ok(pages)
 }
 
 #[instrument(skip(state))]
-pub async fn load_page(state: &AppState, path: &Path) -> Result<Page> {
-    debug!("loading post: {path:?}");
+pub async fn load_page(state: &AppState, path: &Path, root_folder: &Path) -> Result<Page> {
+    debug!("loading page: {path:?}");
 
     let content = fs::read_to_string(path).await?;
 
-
-
     let path_str = path.to_string_lossy().replace('\\', "/");
+    let root = root_folder.to_string_lossy();
 
-    let slug = path_str
-        .trim_start_matches("posts/")
+    let slug = path_str[root.len()..]
         .trim_start_matches('/')
         .trim_end_matches(".html")
         .trim_end_matches(".md")
         .trim_end_matches("index")
         .trim_end_matches('/');
 
-    let base_uri = helpers::uri_with_path(&state.base_url, &format!("/{slug}/"));
+    let base_path = if let Some(i) = path_str.rfind('/') {
+        &path_str[root.len()..=i]
+    } else {
+        &path_str[root.len()..]
+    }
+    .trim_start_matches("pages/");
+
+    let base_uri = helpers::uri_with_path(&state.base_url, base_path);
 
     let content = markdown::render_markdown_to_html(Some(&base_uri), &content);
 
@@ -132,10 +136,10 @@ pub async fn load_page(state: &AppState, path: &Path) -> Result<Page> {
     ))
 }
 
-#[instrument(skip(state, post))]
-pub async fn render_post(state: &AppState, post: &Page) -> Result<String, WebsiteError> {
+#[instrument(skip(state, page))]
+pub async fn render_page(state: &AppState, page: &Page) -> Result<String, WebsiteError> {
     let mut ctx = tera::Context::new();
-    ctx.insert("page", &post);
+    ctx.insert("page", &page);
     ctx.insert("base_url", &state.base_url.to_string());
 
     state
@@ -158,9 +162,9 @@ mod tests {
             ..Default::default()
         };
 
-        state.pages = super::load_all(&state, "posts/".into()).await.unwrap();
+        state.pages = super::load_all(&state, "pages/".into()).await.unwrap();
         for post in state.pages.values() {
-            super::render_post(&state, post).await.unwrap();
+            super::render_page(&state, post).await.unwrap();
         }
     }
 }