discours.io/quoter
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

infolog
All checks were successful
deploy / deploy (push) Successful in 1m3s
Details

Browse Source
This commit is contained in:
Untone 2024-11-02 05:26:24 +03:00
parent 349403d9fe
commit 02d40bee51
6 changed files with 51 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/app_state.rs
View File

@ -3,7 +3,7 @@ use aws_config::BehaviorVersion;
use aws_sdk_s3::{config::Credentials, Client as S3Client};
use redis::{aio::MultiplexedConnection, AsyncCommands, Client as RedisClient};
use std::env;
use log::warn;
use log::info;
use crate::s3_utils::get_s3_filelist;
@ -89,7 +89,7 @@ impl AppState {
/// Кэширует список файлов из Storj S3 в Redis.
pub async fn cache_filelist(&self) {
warn!("caching AWS filelist...");
info!("caching AWS filelist...");
let mut redis = self.redis.clone();
// Запрашиваем список файлов из Storj S3
@ -103,7 +103,7 @@ impl AppState {
.expect(&format!("Failed to cache file {} in Redis", filename));
}
warn!("cached {} files", filelist.len());
info!("cached {} files", filelist.len());
}
/// Получает путь из ключа (имени файла) в Redis.

52
src/handlers/proxy.rs
View File

@ -1,6 +1,6 @@
use actix_web::error::ErrorNotFound;
use actix_web::{error::ErrorInternalServerError, web, HttpRequest, HttpResponse, Result};
use log::{error, warn};
use log::{error, info};
use crate::app_state::AppState;
use crate::handlers::serve_file::serve_file;
@ -13,7 +13,7 @@ pub async fn proxy_handler(
requested_res: web::Path<String>,
state: web::Data<AppState>,
) -> Result<HttpResponse, actix_web::Error> {
warn!("\t>>>\tGET {}", requested_res);
info!("\t>>>\tGET {}", requested_res);
let normalized_path = if requested_res.ends_with("/webp") {
requested_res.replace("/webp", "")
} else {
@ -22,13 +22,13 @@ pub async fn proxy_handler(
// парсим GET запрос
let (base_filename, requested_width, extension) = parse_file_path(&normalized_path);
warn!("detected file extension: {}", extension);
warn!("base_filename: {}", base_filename);
warn!("requested width: {}", requested_width);
info!("detected file extension: {}", extension);
info!("base_filename: {}", base_filename);
info!("requested width: {}", requested_width);
let ext = extension.as_str().to_lowercase();
warn!("normalized to lowercase: {}", ext);
info!("normalized to lowercase: {}", ext);
let filekey = format!("{}.{}", base_filename, &ext);
warn!("filekey: {}", filekey);
info!("filekey: {}", filekey);
let content_type = match ext.as_str() {
"jpg" | "jpeg" => "image/jpeg",
"png" => "image/png",
@ -47,7 +47,7 @@ pub async fn proxy_handler(
}
};
warn!("content_type: {}", content_type);
info!("content_type: {}", content_type);
let shout_id = match req.query_string().contains("s=") {
true => req
@ -61,16 +61,16 @@ pub async fn proxy_handler(
return match state.get_path(&filekey).await {
Ok(Some(stored_path)) => {
warn!("stored_path: {}", stored_path);
info!("stored_path: {}", stored_path);
// Проверяем, существует ли файл в Storj
if check_file_exists(&state.storj_client, &state.bucket, &stored_path).await? {
if content_type.starts_with("image") {
if requested_width == 0 {
return serve_file(&stored_path, &state, shout_id).await;
}
warn!("base_filename: {}", base_filename);
warn!("requested width: {}", requested_width);
warn!("extension: {}", extension);
info!("base_filename: {}", base_filename);
info!("requested width: {}", requested_width);
info!("extension: {}", extension);
// Получаем оригинальное изображение для проверки размера
let original_key = format!("{}.{}", base_filename, extension);
if let Ok(original_data) =
@ -79,7 +79,7 @@ pub async fn proxy_handler(
if let Ok(img) = image::load_from_memory(&original_data) {
// Если запрошенная ширина больше оригинала, возвращаем оригинал
if requested_width >= img.width() {
warn!(
info!(
"requested width {} >= original width {}, serving original",
requested_width,
img.width()
@ -89,7 +89,7 @@ pub async fn proxy_handler(
// Находим ближайшую поддерживаемую ширину
let target_width = find_closest_width(requested_width);
warn!("normalized requested width {} to closest supported width {}", requested_width, target_width);
info!("normalized requested width {} to closest supported width {}", requested_width, target_width);
// Проверяем/генерируем миниатюру
let thumb_filename =
@ -103,7 +103,7 @@ pub async fn proxy_handler(
.await
{
Ok(true) => {
warn!("serve existed thumb file: {}", thumb_filename);
info!("serve existed thumb file: {}", thumb_filename);
return serve_file(&thumb_filename, &state, shout_id).await;
}
Ok(false) => {
@ -115,8 +115,8 @@ pub async fn proxy_handler(
)
.await
{
warn!("generate new thumb files: {}", stored_path);
warn!("{} bytes", filedata.len());
info!("generate new thumb files: {}", stored_path);
info!("{} bytes", filedata.len());
// Генерируем миниатюру и сохраняем
if let Ok(_) = thumbdata_save(
@ -127,7 +127,7 @@ pub async fn proxy_handler(
)
.await
{
warn!("serve new thumb file: {}", thumb_filename);
info!("serve new thumb file: {}", thumb_filename);
return serve_file(&thumb_filename, &state, shout_id)
.await;
} else {
@ -154,13 +154,13 @@ pub async fn proxy_handler(
}
}
// Если файл не изображение, продолжаем обработку
warn!("file is not an image");
info!("file is not an image");
}
// we need to download what stored_path keeping in aws
return match load_file_from_s3(&state.aws_client, &state.bucket, &stored_path).await {
Ok(filedata) => {
warn!("download stored_path from aws: {:?}", stored_path);
info!("download stored_path from aws: {:?}", stored_path);
if let Err(e) = upload_to_s3(
&state.storj_client,
&state.bucket,
@ -172,7 +172,7 @@ pub async fn proxy_handler(
{
error!("cannot upload to storj: {}", e);
} else {
warn!("file {} uploaded to storj", filekey);
info!("file {} uploaded to storj", filekey);
state.set_path(&filekey, &filekey).await;
}
let _ = thumbdata_save(
@ -192,7 +192,7 @@ pub async fn proxy_handler(
};
}
Ok(None) => {
warn!("cannot find stored path for: {}", filekey);
info!("cannot find stored path for: {}", filekey);
let ct_parts = content_type.split("/").collect::<Vec<&str>>();
let filepath = format!("production/{}/{}.{}", ct_parts[0], base_filename, extension); // NOTE: original ext
@ -200,7 +200,7 @@ pub async fn proxy_handler(
check_file_exists(&state.storj_client, &state.bucket, &filepath).await?;
if exists_in_storj {
warn!(
info!(
"file {} exists in storj, try to generate thumbnails",
filepath
);
@ -221,7 +221,7 @@ pub async fn proxy_handler(
}
}
} else {
warn!("file {} does not exist in storj", filepath);
info!("file {} does not exist in storj", filepath);
}
let exists_in_aws =
@ -245,9 +245,9 @@ pub async fn proxy_handler(
)
.await
{
warn!("cannot upload to storj: {}", e);
info!("cannot upload to storj: {}", e);
} else {
warn!("file {} uploaded to storj", filekey);
info!("file {} uploaded to storj", filekey);
state.set_path(&filekey, &filepath).await;
}
Ok(HttpResponse::Ok().content_type(content_type).body(filedata))

6
src/handlers/upload.rs
View File

@ -1,6 +1,6 @@
use actix_multipart::Multipart;
use actix_web::{web, HttpRequest, HttpResponse, Result};
use log::warn;
use log::info;
use crate::app_state::AppState;
use crate::auth::{get_id_by_token, user_added_file};
@ -69,9 +69,9 @@ pub async fn upload_handler(
&content_type,
)
.await {
warn!("cannot upload to storj: {}", e);
info!("cannot upload to storj: {}", e);
} else {
warn!("file {} uploaded to storj", body);
info!("file {} uploaded to storj", body);
// Сохраняем информацию о загруженном файле для пользователя
user_added_file(&mut state.redis.clone(), &user_id, &body).await?;
state.set_path(&body, &body).await;

4
src/main.rs
View File

@ -9,7 +9,7 @@ mod overlay;
use actix_web::{middleware::Logger, web, App, HttpServer};
use app_state::AppState;
use handlers::{proxy_handler, upload_handler};
use log::warn;
use log::info;
use tokio::task::spawn_blocking;
use std::env;
use env_logger;
@ -17,7 +17,7 @@ use env_logger;
#[actix_web::main]
async fn main() -> std::io::Result<()> {
env_logger::init();
warn!("Started");
info!("Started");
let port = env::var("PORT").unwrap_or_else(|_| "8080".to_string());
let addr = format!("0.0.0.0:{}", port);

4
src/overlay.rs
View File

@ -1,6 +1,6 @@
use std::{error::Error, io::Cursor};
use actix_web::web::Bytes;
use log::warn;
use log::info;
use image::Rgba;
use imageproc::drawing::{draw_text_mut, draw_filled_rect_mut};
use imageproc::rect::Rect;
@ -86,7 +86,7 @@ pub async fn generate_overlay<'a>(shout_id: &'a str, filedata: Bytes) -> Result<
Ok(Bytes::from(buffer))
},
Err(e) => {
warn!("Error getting shout: {}", e);
info!("Error getting shout: {}", e);
Ok(filedata)
}
}

30
src/thumbnail.rs
View File

@ -1,6 +1,6 @@
use actix_web::error::ErrorInternalServerError;
use image::{imageops::FilterType, DynamicImage, ImageFormat};
use log::{warn, error};
use log::{info, error};
use std::{collections::HashMap, io::Cursor};
use crate::{app_state::AppState, s3_utils::upload_to_s3};
@ -69,13 +69,13 @@ pub async fn generate_thumbnails(
// Генерируем миниатюры только для размеров меньше оригинала
for &width in THUMB_WIDTHS.iter().filter(|&&w| w < original_width) {
warn!("[THUMB] Generating thumbnail width: {}", width);
info!("[THUMB] Generating thumbnail width: {}", width);
let thumbnail = image.resize(width, u32::MAX, FilterType::Lanczos3);
let mut buffer = Vec::new();
match thumbnail.write_to(&mut Cursor::new(&mut buffer), format) {
Ok(_) => {
warn!("[THUMB] Successfully generated thumbnail: {}x{}", width, thumbnail.height());
info!("[THUMB] Successfully generated thumbnail: {}x{}", width, thumbnail.height());
thumbnails.insert(width, buffer);
},
Err(e) => {
@ -86,9 +86,9 @@ pub async fn generate_thumbnails(
}
if thumbnails.is_empty() {
warn!("[THUMB] No thumbnails generated, image width: {}", original_width);
info!("[THUMB] No thumbnails generated, image width: {}", original_width);
} else {
warn!("[THUMB] Generated {} thumbnails", thumbnails.len());
info!("[THUMB] Generated {} thumbnails", thumbnails.len());
}
Ok(thumbnails)
@ -121,17 +121,17 @@ pub async fn thumbdata_save(
content_type: String,
) -> Result<(), actix_web::Error> {
if content_type.starts_with("image") {
warn!("[THUMB] Processing image: {}", original_filename);
info!("[THUMB] Processing image: {}", original_filename);
let (base_filename, _, extension) = parse_file_path(&original_filename);
warn!("[THUMB] Parsed: base={}, ext={}", base_filename, extension);
info!("[THUMB] Parsed: base={}, ext={}", base_filename, extension);
let ext = extension.to_lowercase();
let filename = format!("{}.{}", base_filename, ext);
warn!("[THUMB] Normalized filename: {}", filename);
info!("[THUMB] Normalized filename: {}", filename);
let img = match image::load_from_memory(&original_data) {
Ok(img) => {
warn!("[THUMB] Successfully loaded image from memory, size: {}x{}",
info!("[THUMB] Successfully loaded image from memory, size: {}x{}",
img.width(), img.height());
img
},
@ -143,7 +143,7 @@ pub async fn thumbdata_save(
let format = match determine_image_format(&ext) {
Ok(f) => {
warn!("[THUMB] Using format: {:?}", f);
info!("[THUMB] Using format: {:?}", f);
f
},
Err(e) => {
@ -154,11 +154,11 @@ pub async fn thumbdata_save(
match generate_thumbnails(&img, format).await {
Ok(thumbnails_bytes) => {
warn!("[THUMB] Generated {} thumbnails", thumbnails_bytes.len());
info!("[THUMB] Generated {} thumbnails", thumbnails_bytes.len());
for (thumb_width, thumbnail) in thumbnails_bytes {
let thumb_filename = format!("{}_{}.{}", base_filename, thumb_width, ext);
warn!("[THUMB] Saving thumbnail: {}", thumb_filename);
info!("[THUMB] Saving thumbnail: {}", thumb_filename);
match upload_to_s3(
&state.storj_client,
@ -168,10 +168,10 @@ pub async fn thumbdata_save(
&content_type,
).await {
Ok(_) => {
warn!("[THUMB] Successfully saved thumbnail: {}", thumb_filename);
info!("[THUMB] Successfully saved thumbnail: {}", thumb_filename);
// Сохраняем путь к миниатюре в Redis
state.set_path(&thumb_filename, &thumb_filename).await;
warn!("[THUMB] Cached path in Redis: {}", thumb_filename);
info!("[THUMB] Cached path in Redis: {}", thumb_filename);
},
Err(e) => {
error!("[THUMB] Failed to save thumbnail {}: {}", thumb_filename, e);
@ -186,7 +186,7 @@ pub async fn thumbdata_save(
}
}
} else {
warn!("[THUMB] Skipping non-image content type: {}", content_type);
info!("[THUMB] Skipping non-image content type: {}", content_type);
Ok(())
}
}