move the rest of markdown-related stuff into it's own file

This commit is contained in:
slonkazoid 2024-05-14 12:26:43 +03:00
parent 897e1cbf88
commit cf102126b3
Signed by: slonk
SSH key fingerprint: SHA256:tbZfJX4IOvZ0LGWOWu5Ijo8jfMPi78TU7x1VoEeCIjM
5 changed files with 128 additions and 92 deletions

View file

@ -38,7 +38,8 @@ the default configuration with comments looks like this
```toml ```toml
title = "bingus-blog" # title of the website title = "bingus-blog" # title of the website
description = "blazingly fast markdown blog software written in rust memory safe" # description of the website description = "blazingly fast markdown blog software written in rust memory safe" # description of the website
raw_access = true # allow users to see the raw markdown of a post markdown_access = true # allow users to see the raw markdown of a post
# endpoint: /posts/<name>.md
[rss] [rss]
enable = false # serve an rss field under /feed.xml enable = false # serve an rss field under /feed.xml

View file

@ -3,13 +3,13 @@ use std::time::Duration;
use askama_axum::Template; use askama_axum::Template;
use axum::extract::{Path, Query, State}; use axum::extract::{Path, Query, State};
use axum::http::header::CONTENT_TYPE;
use axum::http::{header, Request}; use axum::http::{header, Request};
use axum::response::{IntoResponse, Redirect, Response}; use axum::response::{IntoResponse, Redirect, Response};
use axum::routing::get; use axum::routing::get;
use axum::{Json, Router}; use axum::{Json, Router};
use rss::{Category, ChannelBuilder, ItemBuilder}; use rss::{Category, ChannelBuilder, ItemBuilder};
use serde::Deserialize; use serde::Deserialize;
use tokio::io::AsyncReadExt;
use tower_http::services::ServeDir; use tower_http::services::ServeDir;
use tower_http::trace::TraceLayer; use tower_http::trace::TraceLayer;
use tracing::{info, info_span, Span}; use tracing::{info, info_span, Span};
@ -17,7 +17,7 @@ use tracing::{info, info_span, Span};
use crate::config::Config; use crate::config::Config;
use crate::error::{AppError, AppResult}; use crate::error::{AppError, AppResult};
use crate::filters; use crate::filters;
use crate::post::{MarkdownPosts, PostManager, PostMetadata, RenderStats}; use crate::post::{MarkdownPosts, PostManager, PostMetadata, RenderStats, ReturnedPost};
#[derive(Clone)] #[derive(Clone)]
pub struct AppState { pub struct AppState {
@ -138,26 +138,20 @@ async fn post(
State(AppState { config, posts }): State<AppState>, State(AppState { config, posts }): State<AppState>,
Path(name): Path<String>, Path(name): Path<String>,
) -> AppResult<Response> { ) -> AppResult<Response> {
if name.ends_with(".md") && config.raw_access { match posts.get_post(&name).await? {
let mut file = tokio::fs::OpenOptions::new() ReturnedPost::Rendered(meta, rendered, rendered_in) => {
.read(true) let page = PostTemplate {
.open(config.dirs.posts.join(&name)) meta,
.await?; rendered,
rendered_in,
markdown_access: config.markdown_access,
};
let mut buf = Vec::new(); Ok(page.into_response())
file.read_to_end(&mut buf).await?; }
ReturnedPost::Raw(body, content_type) => {
Ok(([("content-type", "text/plain")], buf).into_response()) Ok(([(CONTENT_TYPE, content_type)], body).into_response())
} else { }
let post = posts.get_post(&name).await?;
let page = PostTemplate {
meta: post.0,
rendered: post.1,
rendered_in: post.2,
markdown_access: config.raw_access,
};
Ok(page.into_response())
} }
} }

View file

@ -64,7 +64,7 @@ pub struct RssConfig {
pub struct Config { pub struct Config {
pub title: String, pub title: String,
pub description: String, pub description: String,
pub raw_access: bool, pub markdown_access: bool,
pub num_posts: usize, pub num_posts: usize,
pub rss: RssConfig, pub rss: RssConfig,
pub dirs: DirsConfig, pub dirs: DirsConfig,
@ -78,7 +78,7 @@ impl Default for Config {
Self { Self {
title: "bingus-blog".into(), title: "bingus-blog".into(),
description: "blazingly fast markdown blog software written in rust memory safe".into(), description: "blazingly fast markdown blog software written in rust memory safe".into(),
raw_access: true, markdown_access: true,
num_posts: 5, num_posts: 5,
// i have a love-hate relationship with serde // i have a love-hate relationship with serde
// it was engimatic at first, but then i started actually using it // it was engimatic at first, but then i started actually using it

View file

@ -1,11 +1,16 @@
use std::collections::BTreeSet;
use std::io::{self, Write}; use std::io::{self, Write};
use std::ops::Deref; use std::ops::Deref;
use std::path::Path; use std::path::Path;
use std::time::Duration; use std::time::Duration;
use std::time::Instant; use std::time::Instant;
use std::time::SystemTime;
use axum::http::HeaderValue;
use chrono::{DateTime, Utc};
use color_eyre::eyre::{self, Context}; use color_eyre::eyre::{self, Context};
use fronma::parser::{parse, ParsedData}; use fronma::parser::{parse, ParsedData};
use serde::Deserialize;
use tokio::fs; use tokio::fs;
use tokio::io::AsyncReadExt; use tokio::io::AsyncReadExt;
use tracing::{error, info, warn}; use tracing::{error, info, warn};
@ -13,9 +18,40 @@ use tracing::{error, info, warn};
use crate::config::Config; use crate::config::Config;
use crate::markdown_render::render; use crate::markdown_render::render;
use crate::post::cache::{load_cache, Cache, CACHE_VERSION}; use crate::post::cache::{load_cache, Cache, CACHE_VERSION};
use crate::post::{FrontMatter, PostError, PostManager, PostMetadata, RenderStats}; use crate::post::{PostError, PostManager, PostMetadata, RenderStats, ReturnedPost};
use crate::systemtime_as_secs::as_secs; use crate::systemtime_as_secs::as_secs;
#[derive(Deserialize)]
struct FrontMatter {
pub title: String,
pub description: String,
pub author: String,
pub icon: Option<String>,
pub created_at: Option<DateTime<Utc>>,
pub modified_at: Option<DateTime<Utc>>,
#[serde(default)]
pub tags: BTreeSet<String>,
}
impl FrontMatter {
pub fn into_full(
self,
name: String,
created: Option<SystemTime>,
modified: Option<SystemTime>,
) -> PostMetadata {
PostMetadata {
name,
title: self.title,
description: self.description,
author: self.author,
icon: self.icon,
created_at: self.created_at.or_else(|| created.map(|t| t.into())),
modified_at: self.modified_at.or_else(|| modified.map(|t| t.into())),
tags: self.tags.into_iter().collect(),
}
}
}
pub struct MarkdownPosts<C> pub struct MarkdownPosts<C>
where where
C: Deref<Target = Config>, C: Deref<Target = Config>,
@ -219,8 +255,10 @@ where
.to_string(); .to_string();
let post = self.get_post(&name).await?; let post = self.get_post(&name).await?;
if filter(&post.0, &post.1) { if let ReturnedPost::Rendered(meta, content, stats) = post
posts.push(post); && filter(&meta, &content)
{
posts.push((meta, content, stats));
} }
} }
} }
@ -228,39 +266,66 @@ where
Ok(posts) Ok(posts)
} }
async fn get_post(&self, name: &str) -> Result<(PostMetadata, String, RenderStats), PostError> { async fn get_post(&self, name: &str) -> Result<ReturnedPost, PostError> {
let start = Instant::now(); if self.config.markdown_access && name.ends_with(".md") {
let path = self.config.dirs.posts.join(name.to_owned() + ".md"); let path = self.config.dirs.posts.join(name);
let stat = match tokio::fs::metadata(&path).await { let mut file = match tokio::fs::OpenOptions::new().read(true).open(&path).await {
Ok(value) => value, Ok(value) => value,
Err(err) => match err.kind() { Err(err) => match err.kind() {
io::ErrorKind::NotFound => { io::ErrorKind::NotFound => {
if let Some(cache) = self.cache.as_ref() { if let Some(cache) = self.cache.as_ref() {
cache.remove(name).await; cache.remove(name).await;
}
return Err(PostError::NotFound(name.to_string()));
} }
return Err(PostError::NotFound(name.to_string())); _ => return Err(PostError::IoError(err)),
} },
_ => return Err(PostError::IoError(err)), };
},
};
let mtime = as_secs(&stat.modified()?);
if let Some(cache) = self.cache.as_ref() let mut buf = Vec::with_capacity(4096);
&& let Some(hit) = cache.lookup(name, mtime, &self.config.render).await
{ file.read_to_end(&mut buf).await?;
Ok((
hit.metadata, Ok(ReturnedPost::Raw(
hit.rendered, buf,
RenderStats::Cached(start.elapsed()), HeaderValue::from_static("text/plain"),
)) ))
} else { } else {
let (metadata, rendered, stats) = self.parse_and_render(name.to_string(), path).await?; let start = Instant::now();
Ok(( let path = self.config.dirs.posts.join(name.to_owned() + ".md");
metadata,
rendered, let stat = match tokio::fs::metadata(&path).await {
RenderStats::ParsedAndRendered(start.elapsed(), stats.0, stats.1), Ok(value) => value,
)) Err(err) => match err.kind() {
io::ErrorKind::NotFound => {
if let Some(cache) = self.cache.as_ref() {
cache.remove(name).await;
}
return Err(PostError::NotFound(name.to_string()));
}
_ => return Err(PostError::IoError(err)),
},
};
let mtime = as_secs(&stat.modified()?);
if let Some(cache) = self.cache.as_ref()
&& let Some(hit) = cache.lookup(name, mtime, &self.config.render).await
{
Ok(ReturnedPost::Rendered(
hit.metadata,
hit.rendered,
RenderStats::Cached(start.elapsed()),
))
} else {
let (metadata, rendered, stats) =
self.parse_and_render(name.to_string(), path).await?;
Ok(ReturnedPost::Rendered(
metadata,
rendered,
RenderStats::ParsedAndRendered(start.elapsed(), stats.0, stats.1),
))
}
} }
} }

View file

@ -1,47 +1,15 @@
pub mod cache; pub mod cache;
pub mod markdown_posts; pub mod markdown_posts;
use std::collections::BTreeSet; use std::time::Duration;
use std::time::{Duration, SystemTime};
use axum::http::HeaderValue;
use chrono::{DateTime, Utc}; use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use crate::error::PostError; use crate::error::PostError;
pub use crate::post::markdown_posts::MarkdownPosts; pub use crate::post::markdown_posts::MarkdownPosts;
#[derive(Deserialize)]
struct FrontMatter {
pub title: String,
pub description: String,
pub author: String,
pub icon: Option<String>,
pub created_at: Option<DateTime<Utc>>,
pub modified_at: Option<DateTime<Utc>>,
#[serde(default)]
pub tags: BTreeSet<String>,
}
impl FrontMatter {
pub fn into_full(
self,
name: String,
created: Option<SystemTime>,
modified: Option<SystemTime>,
) -> PostMetadata {
PostMetadata {
name,
title: self.title,
description: self.description,
author: self.author,
icon: self.icon,
created_at: self.created_at.or_else(|| created.map(|t| t.into())),
modified_at: self.modified_at.or_else(|| modified.map(|t| t.into())),
tags: self.tags.into_iter().collect(),
}
}
}
#[derive(Serialize, Deserialize, Clone, Debug)] #[derive(Serialize, Deserialize, Clone, Debug)]
pub struct PostMetadata { pub struct PostMetadata {
pub name: String, pub name: String,
@ -54,13 +22,18 @@ pub struct PostMetadata {
pub tags: Vec<String>, pub tags: Vec<String>,
} }
#[allow(unused)]
pub enum RenderStats { pub enum RenderStats {
Cached(Duration), Cached(Duration),
// format: Total, Parsed in, Rendered in // format: Total, Parsed in, Rendered in
ParsedAndRendered(Duration, Duration, Duration), ParsedAndRendered(Duration, Duration, Duration),
} }
#[allow(clippy::large_enum_variant)] // Raw will be returned very rarely
pub enum ReturnedPost {
Rendered(PostMetadata, String, RenderStats),
Raw(Vec<u8>, HeaderValue),
}
pub trait PostManager { pub trait PostManager {
async fn get_all_post_metadata( async fn get_all_post_metadata(
&self, &self,
@ -97,10 +70,13 @@ pub trait PostManager {
#[allow(unused)] #[allow(unused)]
async fn get_post_metadata(&self, name: &str) -> Result<PostMetadata, PostError> { async fn get_post_metadata(&self, name: &str) -> Result<PostMetadata, PostError> {
self.get_post(name).await.map(|(meta, ..)| meta) match self.get_post(name).await? {
ReturnedPost::Rendered(metadata, ..) => Ok(metadata),
ReturnedPost::Raw(..) => Err(PostError::NotFound(name.to_string())),
}
} }
async fn get_post(&self, name: &str) -> Result<(PostMetadata, String, RenderStats), PostError>; async fn get_post(&self, name: &str) -> Result<ReturnedPost, PostError>;
async fn cleanup(&self); async fn cleanup(&self);
} }