176 lines
5.7 KiB
Rust
176 lines
5.7 KiB
Rust
//! Implémentation du trait CoverCacheExt pour le serveur pmoserver
|
|
//!
|
|
//! Ce module enrichit `pmoserver::Server` avec les fonctionnalités de cache d'images en
|
|
//! implémentant le trait [`CoverCacheExt`](crate::CoverCacheExt). Cette implémentation
|
|
//! permet d'initialiser facilement le cache et d'enregistrer les routes HTTP.
|
|
//!
|
|
//! ## Architecture
|
|
//!
|
|
//! `pmocovers` étend `pmoserver::Server` sans que `pmoserver` connaisse `pmocovers`.
|
|
//! C'est le pattern d'extension : `pmocovers` ajoute des fonctionnalités à un type
|
|
//! externe via un trait, similaire au pattern utilisé par `pmoapp` pour `WebAppExt`.
|
|
//!
|
|
//! ## Exemple d'utilisation
|
|
//!
|
|
//! ```rust,no_run
|
|
//! use pmocovers::CoverCacheExt;
|
|
//! use pmoserver::ServerBuilder;
|
|
//!
|
|
//! # async fn example() -> anyhow::Result<()> {
|
|
//! let mut server = ServerBuilder::new("MyApp", "http://localhost:3000", 3000).build();
|
|
//!
|
|
//! // Le trait CoverCacheExt est automatiquement disponible
|
|
//! let cache = server.init_cover_cache("./cache", 1000).await?;
|
|
//!
|
|
//! server.start().await;
|
|
//! # Ok(())
|
|
//! # }
|
|
//! ```
|
|
|
|
use crate::{api, Cache, CoverCacheExt};
|
|
use axum::{
|
|
body::Body,
|
|
extract::State,
|
|
http::{Request, StatusCode},
|
|
response::{IntoResponse, Response},
|
|
routing::{delete, get, post},
|
|
Json, Router,
|
|
};
|
|
use pmoserver::Server;
|
|
use tracing::{debug, info, warn};
|
|
use std::sync::Arc;
|
|
use utoipa::OpenApi;
|
|
|
|
|
|
|
|
/// Handler pour GET /covers/images/{pk}
|
|
async fn get_cover_image(
|
|
State(cache): State<Arc<Cache>>,
|
|
req: Request<Body>,
|
|
) -> Response {
|
|
// Extraire pk du path
|
|
let path = req.uri().path();
|
|
let parts: Vec<&str> = path.split('/').collect();
|
|
|
|
warn!("{:?}",parts);
|
|
|
|
if parts.len() != 2 {
|
|
return (StatusCode::BAD_REQUEST, "Invalid path").into_response();
|
|
}
|
|
|
|
let pk = parts[1];
|
|
|
|
match cache.get(pk).await {
|
|
Ok(file_path) => {
|
|
match tokio::fs::read(&file_path).await {
|
|
Ok(data) => (
|
|
StatusCode::OK,
|
|
[("content-type", "image/webp")],
|
|
data,
|
|
)
|
|
.into_response(),
|
|
Err(_) => (StatusCode::NOT_FOUND, "File not found").into_response(),
|
|
}
|
|
}
|
|
Err(_) => (StatusCode::NOT_FOUND, "Image not found").into_response(),
|
|
}
|
|
}
|
|
|
|
/// Handler pour GET /covers/images/{pk}/{size}
|
|
async fn get_cover_variant(
|
|
State(cache): State<Arc<Cache>>,
|
|
req: Request<Body>,
|
|
) -> Response {
|
|
// Extraire pk et size du path
|
|
let path = req.uri().path();
|
|
let parts: Vec<&str> = path.split('/').collect();
|
|
|
|
if parts.len() != 3 {
|
|
return (StatusCode::BAD_REQUEST, "Invalid path").into_response();
|
|
}
|
|
|
|
let pk = parts[1];
|
|
let size = match parts[2].parse::<usize>() {
|
|
Ok(s) => s,
|
|
Err(_) => return (StatusCode::BAD_REQUEST, "Invalid size").into_response(),
|
|
};
|
|
|
|
match crate::webp::generate_variant(&cache, pk, size).await {
|
|
Ok(data) => (
|
|
StatusCode::OK,
|
|
[("content-type", "image/webp")],
|
|
data,
|
|
)
|
|
.into_response(),
|
|
Err(_) => (StatusCode::INTERNAL_SERVER_ERROR, "Cannot generate variant").into_response(),
|
|
}
|
|
}
|
|
|
|
/// Handler pour GET /covers/stats
|
|
async fn get_cover_stats(State(cache): State<Arc<Cache>>) -> Response {
|
|
match cache.db.get_all() {
|
|
Ok(entries) => Json(entries).into_response(),
|
|
Err(_) => (StatusCode::INTERNAL_SERVER_ERROR, "Cannot retrieve stats").into_response(),
|
|
}
|
|
}
|
|
|
|
impl CoverCacheExt for Server {
|
|
async fn init_cover_cache(&mut self, cache_dir: &str, limit: usize) -> anyhow::Result<Arc<Cache>> {
|
|
let cache = Arc::new(Cache::new(cache_dir, limit)?);
|
|
|
|
// Enregistrer les routes HTTP classiques pour servir les images
|
|
let image_router = Router::new()
|
|
.route("/{pk}", get(get_cover_image))
|
|
.route("/{pk}/{size}", get(get_cover_variant))
|
|
.with_state(cache.clone());
|
|
|
|
self.add_router("/covers/images", image_router).await;
|
|
self.add_handler_with_state("/covers/stats", get_cover_stats, cache.clone()).await;
|
|
|
|
// Router API RESTful
|
|
// Router API RESTful qui sera nesté sous /api/covers par add_openapi
|
|
let api_router = Router::new()
|
|
// Liste et ajout
|
|
.route(
|
|
"/",
|
|
get(api::list_images) // GET /api/covers
|
|
.post(api::add_image) // POST /api/covers
|
|
.delete(api::purge_cache), // DELETE /api/covers
|
|
)
|
|
// Ressource unique
|
|
.route(
|
|
"/{pk}",
|
|
get(api::get_image_info) // GET /api/covers/{pk}
|
|
.delete(api::delete_image), // DELETE /api/covers/{pk}
|
|
)
|
|
// Action spécifique
|
|
.route(
|
|
"/consolidate",
|
|
post(api::consolidate_cache), // POST /api/covers/consolidate
|
|
)
|
|
.with_state(cache.clone());
|
|
|
|
// Documentation OpenAPI via Utoipa
|
|
let openapi = crate::ApiDoc::openapi();
|
|
|
|
// Enregistrer l'API avec Swagger UI
|
|
// Le router sera nesté automatiquement sous /api/covers par add_openapi
|
|
// Routes finales: /api/covers, /api/covers/{pk}, /api/covers/consolidate
|
|
// Swagger UI sera disponible à /swagger-ui/covers
|
|
self.add_openapi(api_router, openapi, "covers").await;
|
|
|
|
Ok(cache)
|
|
}
|
|
|
|
async fn init_cover_cache_configured(&mut self) -> anyhow::Result<Arc<Cache>> {
|
|
let config = pmoconfig::get_config();
|
|
|
|
let cache_dir = config.get_cover_cache_dir()?;
|
|
let limit = config.get_cover_cache_size()?;
|
|
|
|
info!("cache directory {}, size {}",cache_dir,limit);
|
|
|
|
self.init_cover_cache(&cache_dir, limit).await
|
|
}
|
|
}
|