done rsync, base roting

Author: TOwInOK

.env

@@ -0,0 +1,2 @@
+STORE_PATH=""
+CACHE_PATH=""

.gitignore

@@ -3,3 +3,7 @@ debug
 **/dist
 **/.DS_Store
 **/Cargo.lock
+.store/*
+.ref/*
+!.store/.gitkeep
+!.ref/.gitkeep

.ref/.gitkeep

@@ -0,0 +1 @@
+it store directory

.store/.gitkeep

@@ -11,10 +11,21 @@ license = "MIT"                                                   #"Apache-2.0"
 ohkami = { version = "0.24.2", features = ["openapi", "rt_tokio"] }
 tokio = { version = "1.48.0", features = ["full"] }
 tracing = "^0.1"
-tracing-subscriber = "^0.3"
+tracing-subscriber = { version = "^0.3", features = ["env-filter"] }
 serde = { version = "^1", features = ["derive"] }
 serde_json = { version = "1" }
 thiserror = "^2"
+tee_morphosis = "1.3.0"
+image = { version = "0.25.8", default-features = false }
+reqwest = "0.12.24"
+dashmap = { version = "6.1.0", features = ["rayon", "serde"] }
+regex = "1.12.2"
+rayon = "1.11.0"
+dotenvy = "0.15.7"
+futures = "0.3.31"
+
+[dev-dependencies]
+tokio = { version = "1.48.0", features = ["full"] }
 
 [profile.dev]
 opt-level = 0

Cargo.toml

@@ -19,3 +19,24 @@
 //! - Сбор статистики, кто, зачем
 //! - Мб рейтлимит
 //! - Бан лист (:))
+
+pub mod logger;
+pub mod png;
+pub mod skin;
+
+use ohkami::{Ohkami, Route, claw::status};
+
+use crate::app::skin::skin_router;
+async fn health_check() -> status::NoContent {
+    status::NoContent
+}
+
+pub async fn app() {
+    Ohkami::new((
+        "/skin".By(skin_router()),
+        "/uvs".GET(health_check),
+        "/health".GET(health_check),
+    ))
+    .howl("localhost:3000")
+    .await
+}

src/app.rs

@@ -0,0 +1,13 @@
+use ohkami::{FangAction, Request, Response};
+
+#[derive(Clone)]
+pub struct LogRequest;
+impl FangAction for LogRequest {
+    async fn fore<'a>(
+        &'a self,
+        req: &'a mut Request,
+    ) -> Result<(), Response> {
+        tracing::debug!("\nGot request: {req:#?}");
+        Ok(())
+    }
+}

src/app/logger.rs

@@ -0,0 +1,18 @@
+use std::borrow::Cow;
+
+use ohkami::{claw::content::IntoContent, openapi};
+
+/// Represents a PNG image content.
+pub struct Png(pub Vec<u8>);
+
+impl IntoContent for Png {
+    const CONTENT_TYPE: &'static str = "image/png";
+
+    fn into_content(self) -> Result<std::borrow::Cow<'static, [u8]>, impl std::fmt::Display> {
+        Result::<_, std::convert::Infallible>::Ok(Cow::Owned(self.0))
+    }
+
+    fn openapi_responsebody() -> impl Into<openapi::schema::SchemaRef> {
+        openapi::schema::SchemaRef::Reference("png")
+    }
+}

src/app/png.rs

@@ -0,0 +1,57 @@
+use std::path::PathBuf;
+
+use image::ImageFormat;
+use ohkami::{
+    IntoResponse, Ohkami, Query, Route,
+    claw::status::Created,
+    openapi::{self, Schema},
+    serde::Deserialize,
+};
+use tee_morphosis::tee::{Tee, hsl::ddnet_color_to_hsl, parts::TeePart, skin::TEE_SKIN_LAYOUT};
+use tokio::{fs, task::spawn_blocking};
+use tracing::info;
+
+use crate::{
+    app::{logger::LogRequest, png::Png},
+    error::Error,
+};
+
+pub fn skin_router() -> Ohkami {
+    Ohkami::new((LogRequest, openapi::Tag("skin"), "/".GET(skin_handler)))
+}
+
+#[derive(Debug, Deserialize, Schema)]
+pub struct SkinQuery<'req> {
+    pub body: Option<u32>,
+    pub feet: Option<u32>,
+    pub name: Option<&'req str>,
+}
+
+async fn skin_handler(Query(query): Query<SkinQuery<'_>>) -> Result<impl IntoResponse, Error> {
+    let path = PathBuf::from("./.ref")
+        .join(query.name.ok_or(Error::QueryNameNotFound)?)
+        .with_extension("png");
+    info!(path=%path.display());
+
+    let uv = fs::read(path.clone()).await.map_err(Error::Io)?;
+
+    let tee = spawn_blocking(move || {
+        Tee::new(uv.into(), ImageFormat::Png).map(|mut tee| {
+            if let Some(value) = query.body {
+                tee.apply_hsv_to_parts(
+                    ddnet_color_to_hsl(value),
+                    &[TeePart::Body, TeePart::BodyShadow],
+                );
+            }
+            if let Some(value) = query.feet {
+                tee.apply_hsv_to_parts(
+                    ddnet_color_to_hsl(value),
+                    &[TeePart::Feet, TeePart::FeetShadow],
+                );
+            }
+            tee.compose_default(TEE_SKIN_LAYOUT)
+        })
+    })
+    .await???;
+    Ok(Created(Png(tee.into())))
+}

src/app/skin.rs

@@ -0,0 +1,68 @@
+use std::path::PathBuf;
+
+use ohkami::{IntoResponse, Response};
+use reqwest::header::ToStrError;
+use thiserror::Error;
+use tokio::{io, task::JoinError};
+use tracing::error;
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("I/O error")]
+    Io(#[from] io::Error),
+    #[error("Fail to join task")]
+    TaskJoin(#[from] JoinError),
+    #[error("Tee error")]
+    Tee(#[from] tee_morphosis::error::TeeError),
+    #[error("Query expected name, but got none")]
+    QueryNameNotFound,
+    #[error("Reqwest error")]
+    Reqwest(#[from] reqwest::Error),
+    #[error("Reqwest header convertation error")]
+    ToStrError(#[from] ToStrError),
+    #[error("Fail to save: {name}, path {path:#?}, {error}")]
+    SaveFailed {
+        path: PathBuf,
+        name: String,
+        error: String,
+    },
+    #[error("Fail to download: {name}, {error}")]
+    DownloadFailed { name: String, error: String },
+}
+
+impl IntoResponse for Error {
+    fn into_response(self) -> Response {
+        match self {
+            Error::Io(e) => {
+                error!(error=%e,"I/O error");
+                Response::InternalServerError().with_text("Skin not found")
+            }
+            Error::Tee(e) => {
+                error!(error=%e,"Tee error");
+                Response::InternalServerError().with_text("Fail to render uv")
+            }
+            Error::QueryNameNotFound => {
+                error!("Query expected name, but got none");
+                Response::BadRequest().with_text("Query expected name, but got none")
+            }
+            Error::Reqwest(e) => {
+                error!(error=%e,"Reqwest error");
+                Response::InternalServerError()
+            }
+            Error::ToStrError(e) => {
+                error!(error=%e,"Reqwest ToStr error");
+                Response::InternalServerError()
+            }
+            Error::SaveFailed {
+                path,
+                name,
+                error,
+            } => todo!(),
+            Error::DownloadFailed {
+                name,
+                error,
+            } => todo!(),
+            Error::TaskJoin(join_error) => todo!(),
+        }
+    }
+}