move cache to ram, fix cache poiter scoup

Author: TOwInOK

.cache/AmongUsBlack.png

@@ -23,6 +23,7 @@ regex = "1.12.2"
 rayon = "1.11.0"
 dotenvy = "0.15.7"
 futures = "0.3.31"
+bytes = "1.10.1"
 
 [dev-dependencies]
 tokio = { version = "1.48.0", features = ["full"] }

Cargo.toml

@@ -20,6 +20,7 @@
 //! - Мб рейтлимит
 //! - Бан лист (:))
 
+pub mod cache;
 pub mod lock;
 pub mod logger;
 pub mod png;
@@ -48,14 +49,14 @@ async fn doc() -> Html {
     Html(fs::read_to_string(DOC_HTML_PATH).await.expect("wtf"))
 }
 
-pub struct AppState<'a> {
+pub struct AppState {
     pub lock: Lock,
-    pub cache: Cache<'a>,
+    pub cache: Cache,
 }
 
 pub async fn app(
     lock: Lock,
-    cache: Cache<'static>,
+    cache: Cache,
 ) {
     let router = Ohkami::new((
         Context::new(Arc::new(AppState {

src/app.rs

@@ -0,0 +1,25 @@
+use std::sync::Arc;
+
+use ohkami::{IntoResponse, Json, fang::Context};
+use tracing::debug;
+
+use crate::{app::AppState, error::Error};
+
+#[inline(always)]
+/// Represent GET method to return list of skins
+pub async fn cache_handler<'a>(
+    Context(state): Context<'a, Arc<AppState>>
+) -> Result<impl IntoResponse + 'a, Error> {
+    Ok(Json(
+        state
+            .cache
+            .store
+            .iter()
+            .map(|x| {
+                let key = x.key().clone();
+                debug!(key=?key);
+                key
+            })
+            .collect::<Vec<_>>(),
+    ))
+}

src/app/cache.rs

@@ -7,15 +7,14 @@ use crate::{app::AppState, error::Error};
 #[inline(always)]
 /// Represent GET method to return list of skins
 pub async fn lock_handler<'a>(
-    Context(state): Context<'a, Arc<AppState<'a>>>
+    Context(state): Context<'a, Arc<AppState>>
 ) -> Result<impl IntoResponse + 'a, Error> {
-    Ok(Json(serde_json::to_string_pretty::<Vec<String>>(
+    Ok(Json(
         state
             .lock
             .store
             .iter()
             .map(|x| x.key().to_string())
-            .collect::<Vec<_>>()
-            .as_ref(),
-    )?))
+            .collect::<Vec<_>>(),
+    ))
 }

src/app/lock.rs

@@ -1,4 +1,4 @@
-use std::sync::Arc;
+use std::{fmt::Display, sync::Arc};
 
 use ohkami::{
     IntoResponse, Ohkami, Query, Route,
@@ -7,9 +7,11 @@ use ohkami::{
     openapi::{self, Schema},
     serde::Deserialize,
 };
+use serde::Serialize;
+use tracing::instrument;
 
 use crate::{
-    app::{AppState, lock::lock_handler, logger::LogRequest, png::Png},
+    app::{AppState, cache::cache_handler, lock::lock_handler, logger::LogRequest, png::Png},
     error::Error,
 };
 
@@ -20,26 +22,40 @@ pub fn skin_router() -> Ohkami {
         openapi::Tag("skin"),
         "/".GET(skin_handler),
         "/store".GET(lock_handler),
+        "/cache".GET(cache_handler),
     ))
 }
 
-#[derive(Debug, Clone, Copy, Deserialize, Schema, Hash, PartialEq, Eq)]
+#[derive(Debug, Clone, Deserialize, Schema, Hash, PartialEq, Eq, Serialize)]
 /// Params for expose Tee
-pub struct SkinQuery<'req> {
-    pub name: &'req str,
+pub struct SkinQuery {
+    pub name: String,
     pub body: Option<u32>,
     pub feet: Option<u32>,
 }
 
+impl Display for SkinQuery {
+    fn fmt(
+        &self,
+        f: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
+        f.debug_struct("SkinQuery")
+            .field("name", &self.name)
+            .field("body", &self.body)
+            .field("feet", &self.feet)
+            .finish()
+    }
+}
+
 #[inline(always)]
+#[instrument(skip(state))]
 /// Represent GET method to return a builded skin by query
 async fn skin_handler<'a>(
-    Context(state): Context<'a, Arc<AppState<'a>>>,
-    // Context(cache): Context<'a, Cache<'a>>,
-    Query(query): Query<SkinQuery<'a>>,
-) -> Result<impl IntoResponse + 'a, Error> {
-    Ok(Created(Png(match state.cache.get(query).await {
-        Ok(Some(e)) => e,
+    Context(state): Context<'a, Arc<AppState>>,
+    Query(query): Query<SkinQuery>,
+) -> Result<impl IntoResponse, Error> {
+    Ok(Created(Png(match state.cache.get(&query).await {
+        Ok(Some(e)) => e.to_vec(),
         _ => state.lock.get(state.cache.clone(), query).await?,
     })))
 }

src/app/skin.rs

@@ -9,14 +9,13 @@
 //! В коде храним DashMap с <(name,Option<body_color>, Option<feet_color>): Path (absolut)>
 
 use std::{
-    path::{Path, PathBuf},
     sync::Arc,
     time::{Duration, Instant},
 };
 
+use bytes::Bytes;
 use dashmap::DashMap;
-use tokio::fs;
-use tracing::{info, instrument};
+use tracing::info;
 
 pub const FIVE_MINUTES: Duration = Duration::from_secs(900);
 
@@ -25,15 +24,15 @@ use crate::{app::skin::SkinQuery, error::Error};
 pub struct CacheItem {
     /// Then it be placed to cache
     pub timestamp: Instant,
-    /// It is't relative, it absolute path
-    pub path: String,
+    /// `Tee`'s data
+    pub data: Bytes,
 }
 
 impl CacheItem {
-    pub fn new(path_to_skin: String) -> Self {
+    pub fn new(data: Bytes) -> Self {
         Self {
             timestamp: Instant::now(),
-            path: path_to_skin,
+            data,
         }
     }
 
@@ -43,48 +42,35 @@ impl CacheItem {
     }
 }
 #[derive(Debug)]
-pub struct CacheStore<'a> {
-    pub path: PathBuf,
-    pub store: DashMap<SkinQuery<'a>, CacheItem>,
+pub struct CacheStore {
+    pub store: DashMap<SkinQuery, CacheItem>,
 }
 
-impl<'a, 'b: 'a> CacheStore<'a> {
-    pub async fn new(path: impl AsRef<Path>) -> Self {
-        fs::create_dir(path.as_ref()).await.ok();
+impl CacheStore {
+    pub async fn new() -> Self {
         Self {
-            path: path.as_ref().to_path_buf(),
             store: DashMap::default(),
         }
     }
 
     pub async fn save(
         &self,
-        query: SkinQuery<'b>,
-        data: &[u8],
+        query: SkinQuery,
+        data: Bytes,
     ) -> Result<(), Error> {
-        let path = self
-            .path
-            .to_path_buf()
-            .join(query.name)
-            .with_extension("png");
-        fs::write(&path, data).await?;
-        self.store.insert(
-            query,
-            CacheItem::new(path.canonicalize()?.display().to_string()),
-        );
+        self.store.insert(query, CacheItem::new(data));
         Ok(())
     }
 
-    #[instrument(skip(self))]
     pub async fn get(
         &self,
-        query: SkinQuery<'b>,
-    ) -> Result<Option<Vec<u8>>, Error> {
+        query: &SkinQuery,
+    ) -> Result<Option<Bytes>, Error> {
         match self.store.get(&query) {
             Some(x) => {
                 if x.value().is_acutal() {
-                    info!("Take from cache");
-                    Ok(Some(fs::read(&x.value().path).await?))
+                    info!(query=%query, "Take from cache");
+                    Ok(Some(x.value().data.clone()))
                 } else {
                     Ok(None)
                 }
@@ -93,4 +79,4 @@ impl<'a, 'b: 'a> CacheStore<'a> {
         }
     }
 }
-pub type Cache<'a> = Arc<CacheStore<'a>>;
+pub type Cache = Arc<CacheStore>;

src/cache.rs

@@ -1,7 +1,7 @@
 use std::{sync::Arc, time::Duration};
 
 use tokio::{fs, time::sleep};
-use tracing::{Level, error, info};
+use tracing::{Level, info};
 
 use crate::{
     app::app,
@@ -41,9 +41,7 @@ async fn main() {
             .await
             .unwrap(),
     );
-    let cache = Arc::new(
-        CacheStore::new(std::env::var("CACHE_PATH").expect("CACHE_PATH must be set")).await,
-    );
+    let cache = Arc::new(CacheStore::new().await);
 
     fs::create_dir("static").await.ok();
 
@@ -75,14 +73,8 @@ async fn main() {
                     .collect();
 
                 for key in keys {
-                    if let Some(cached) = cache.store.get(&key) {
-                        if let Err(e) = fs::remove_file(&cached.path).await {
-                            error!(name=%key.name,body=?key.body, feet=?key.feet,path=?cached.path,"Delete failed: {e}" );
-                        } else {
-                            info!(name=%key.name, body=?key.body, feet=?key.feet, "Item has removed from cache");
-                            cache.store.remove(&key);
-                        }
-                    }
+                    info!(name=%key.name, body=?key.body, feet=?key.feet, "Item has removed from cache");
+                    cache.store.remove(&key);
                 }
                 tracing::info!("Cache cleared");
             }

src/main.rs

@@ -54,21 +54,18 @@ pub async fn try_sync_skins(lock: Arc<LockStore>) -> Result<(), Error> {
             .into_par_iter()
             .flat_map_iter(|v| v.into_iter())
             .fold(
-                || HashMap::new(),
+                HashMap::new,
                 |mut acc: HashMap<String, SkinMeta>, skin: SkinMeta| {
                     acc.entry(skin.name.to_string()).or_insert(skin);
                     acc
                 },
             )
-            .reduce(
-                || HashMap::new(),
-                |mut a, b| {
-                    for (k, v) in b {
-                        a.entry(k).or_insert(v);
-                    }
-                    a
-                },
-            )
+            .reduce(HashMap::new, |mut a, b| {
+                for (k, v) in b {
+                    a.entry(k).or_insert(v);
+                }
+                a
+            })
     })
     .await?;
 

src/rsync.rs

@@ -177,15 +177,15 @@ impl LockStore {
     }
 
     /// Return [Tee] by [SkinQuery] and cache reuslt to the [Cache]
-    pub async fn get<'a: 'b, 'b>(
+    pub async fn get(
         &self,
-        cache: Cache<'b>,
-        query: SkinQuery<'a>,
+        cache: Cache,
+        query: SkinQuery,
     ) -> Result<Vec<u8>, Error> {
         let uv = fs::read(
             &self
                 .store
-                .get(query.name)
+                .get(&query.name)
                 .ok_or(Error::QueryNameNotFound)?
                 .value()
                 .path,
@@ -213,7 +213,7 @@ impl LockStore {
             },
         )
         .await???;
-        cache.save(query, &tee).await?;
+        cache.save(query.clone(), tee.clone()).await?;
         Ok(tee.to_vec())
     }
 }