From d14bfda77e69bf8d7688613529c8cb1474a49cf4 Mon Sep 17 00:00:00 2001 From: Gabriel Simmer Date: Mon, 2 Oct 2023 15:33:19 +0100 Subject: [PATCH] cargo fmt --- src/cache/memory.rs | 12 ++++++---- src/cache/mod.rs | 56 ++++++++++++++++++++++++++++----------------- src/cache/sqlite.rs | 17 +++++++++----- src/main.rs | 16 +++++++------ src/posts.rs | 13 +++++++---- 5 files changed, 70 insertions(+), 44 deletions(-) diff --git a/src/cache/memory.rs b/src/cache/memory.rs index 605f957..acc5445 100644 --- a/src/cache/memory.rs +++ b/src/cache/memory.rs @@ -3,7 +3,7 @@ use std::collections::HashMap; use async_trait::async_trait; use tokio::sync::Mutex; -use super::{CacheMechanism, CachedItem, should_use, Tier}; +use super::{should_use, CacheMechanism, CachedItem, Tier}; #[derive(Clone, Debug)] pub struct Memory {} @@ -13,7 +13,7 @@ lazy_static! { } pub fn new() -> Memory { - return Memory{}; + return Memory {}; } #[async_trait] @@ -26,9 +26,11 @@ impl CacheMechanism for Memory { let mut r = c.clone(); r.tier = Some(Tier::Memory); Some(r) - } else { None } - }, - None => None + } else { + None + } + } + None => None, } } diff --git a/src/cache/mod.rs b/src/cache/mod.rs index 7c3aff8..93d81e6 100644 --- a/src/cache/mod.rs +++ b/src/cache/mod.rs @@ -1,9 +1,12 @@ mod memory; mod sqlite; -use std::{time::{SystemTime, UNIX_EPOCH}, fmt}; use async_trait::async_trait; use sqlx::FromRow; +use std::{ + fmt, + time::{SystemTime, UNIX_EPOCH}, +}; use self::{memory::Memory, sqlite::Sqlite}; @@ -14,7 +17,10 @@ pub struct Cache { } pub async fn init_cache() -> Cache { - Cache{ memory: memory::new(), sqlite: sqlite::new().await } + Cache { + memory: memory::new(), + sqlite: sqlite::new().await, + } } /// Tier enums take an i64, which is the amount of time in seconds @@ -24,7 +30,7 @@ pub enum Tier { Memory, Sqlite, External, - None + None, } impl fmt::Display for Tier { @@ -44,7 +50,7 @@ pub struct CachedItem { pub content: String, cached: i64, #[sqlx(default)] - tier: Option + tier: Option, } impl CachedItem { @@ -54,7 +60,7 @@ impl CachedItem { } #[async_trait] -pub trait CacheMechanism: Sized + Clone + Send + Sync + 'static { +pub trait CacheMechanism: Sized + Clone + Send + Sync + 'static { async fn get(&self, key: &String) -> Option; async fn rm(&mut self, key: String); async fn set(&self, key: String, item: CachedItem); @@ -68,7 +74,8 @@ impl Cache { } if self.sqlite.is_some() { let sq = self.sqlite.clone().unwrap(); - let s = sq.get(key).await; if s.is_some() { + let s = sq.get(key).await; + if s.is_some() { let current_time = SystemTime::now() .duration_since(UNIX_EPOCH) .expect("SystemTime before UNIX EPOCH!") @@ -78,44 +85,51 @@ impl Cache { let mut refresh_memory = s.clone().unwrap(); refresh_memory.cached = current_time; let _ = self.memory.set(key.clone(), refresh_memory).await; - return s + return s; } } - return None + return None; } - pub async fn set(&self, key: String, content_type: String, content: String) -> bool { + pub async fn set(&self, key: String, content_type: String, content: String) -> bool { let current_time = SystemTime::now() .duration_since(UNIX_EPOCH) .expect("SystemTime before UNIX EPOCH!") .as_secs() .try_into() .unwrap(); - let cached_item = CachedItem{ content_type, content, cached: current_time, tier: None }; - self.memory.set(key.clone(), cached_item.clone()).await; - if self.sqlite.is_some() { - let sq = self.sqlite.clone().unwrap(); - sq.set(key.clone(), cached_item.clone()).await; - } - true - } + let cached_item = CachedItem { + content_type, + content, + cached: current_time, + tier: None, + }; + self.memory.set(key.clone(), cached_item.clone()).await; + if self.sqlite.is_some() { + let sq = self.sqlite.clone().unwrap(); + sq.set(key.clone(), cached_item.clone()).await; + } + true + } } /// Determine whether we should actually use the cached item or not. fn should_use(item: &CachedItem, tier: Tier) -> bool { // TODO: Make configurable. let cache_time = match tier { - Tier::Memory => 2*60, - Tier::Sqlite => 10*60, + Tier::Memory => 2 * 60, + Tier::Sqlite => 10 * 60, Tier::External => 0, Tier::None => 0, }; - + let current_time: i64 = SystemTime::now() .duration_since(UNIX_EPOCH) .expect("SystemTime before UNIX EPOCH!") - .as_secs().try_into().unwrap(); + .as_secs() + .try_into() + .unwrap(); current_time <= (item.cached + cache_time) && item.content != "" } diff --git a/src/cache/sqlite.rs b/src/cache/sqlite.rs index 699bcfa..3663490 100644 --- a/src/cache/sqlite.rs +++ b/src/cache/sqlite.rs @@ -1,23 +1,27 @@ use std::{env, str::FromStr}; use async_trait::async_trait; -use sqlx::{Pool, sqlite::{SqlitePoolOptions, SqliteJournalMode, SqliteConnectOptions}}; +use sqlx::{ + sqlite::{SqliteConnectOptions, SqliteJournalMode, SqlitePoolOptions}, + Pool, +}; -use super::{CacheMechanism, CachedItem, should_use, Tier}; +use super::{should_use, CacheMechanism, CachedItem, Tier}; #[derive(Clone, Debug)] pub struct Sqlite { - pool: Pool + pool: Pool, } pub async fn new() -> Option { let path = env::var("DATABASE_PATH").unwrap_or("gs.db".to_owned()); - let opts = SqliteConnectOptions::from_str(&path).unwrap() + let opts = SqliteConnectOptions::from_str(&path) + .unwrap() .journal_mode(SqliteJournalMode::Wal) .create_if_missing(true); let pool = SqlitePoolOptions::new().connect_with(opts).await.unwrap(); - return Some(Sqlite{ pool }); + return Some(Sqlite { pool }); } #[async_trait] @@ -25,7 +29,8 @@ impl CacheMechanism for Sqlite { async fn get(&self, key: &String) -> Option { let res = sqlx::query_as::<_, CachedItem>("SELECT * FROM cached WHERE route = $1") .bind(&key) - .fetch_one(&self.pool).await; + .fetch_one(&self.pool) + .await; if res.is_ok() { let c = res.unwrap(); if should_use(&c, Tier::Sqlite) { diff --git a/src/main.rs b/src/main.rs index db5ba5f..8438541 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,8 +1,8 @@ #[macro_use] extern crate lazy_static; -mod posts; mod cache; +mod posts; use axum::extract::Path; use axum::response::IntoResponse; @@ -89,7 +89,9 @@ async fn main() -> Result<(), sqlx::Error> { sqlx::migrate!("./migrations").run(&pool).await?; env::set_var("DATABASE_PATH", &args.database_path); - let state = AppState { cache: init_cache().await }; + let state = AppState { + cache: init_cache().await, + }; let app = Router::new() .route("/", get(homepage)) @@ -142,10 +144,10 @@ async fn render_blog_post(Path(post): Path) -> Result Result { @@ -284,7 +286,7 @@ async fn cached_page( .header("cache", "miss") .status(StatusCode::OK) .body(Full::from(bytes)) - .unwrap() + .unwrap(); } else { let i = item.unwrap(); return Response::builder() diff --git a/src/posts.rs b/src/posts.rs index b047379..2e515af 100644 --- a/src/posts.rs +++ b/src/posts.rs @@ -1,6 +1,9 @@ -use std::{fs::{self, File}, io::Read}; +use std::{ + fs::{self, File}, + io::Read, +}; -use maud::{Render, Markup, html}; +use maud::{html, Markup, Render}; use orgize::Org; pub struct PostMetadata { @@ -13,7 +16,7 @@ pub struct PostContent { pub title: String, pub date: String, pub content: String, - pub html: String + pub html: String, } impl Render for PostMetadata { @@ -110,11 +113,11 @@ pub fn blog_post(post: String) -> Result { parsed.write_html(&mut writer).unwrap(); html = String::from_utf8(writer).unwrap(); } - return Ok(PostContent{ + return Ok(PostContent { title, date, content, - html + html, }); } }