simpler-auth+no-overlay

src/handlers/proxy.rs

@@ -1,6 +1,6 @@
 use actix_web::error::ErrorNotFound;
 use actix_web::{error::ErrorInternalServerError, web, HttpRequest, HttpResponse, Result};
-use log::{error, warn};
+use log::{info, error, warn};
 
 use crate::app_state::AppState;
 use crate::handlers::serve_file::serve_file;
@@ -8,29 +8,51 @@ use crate::lookup::{find_file_by_pattern, get_mime_type};
 use crate::s3_utils::{check_file_exists, load_file_from_s3, upload_to_s3};
 use crate::thumbnail::{find_closest_width, parse_file_path, thumbdata_save};
 
+/// Создает HTTP ответ с оптимальными заголовками кэширования
+fn create_cached_response(content_type: &str, data: Vec<u8>, file_etag: &str) -> HttpResponse {
+    HttpResponse::Ok()
+        .content_type(content_type)
+        .insert_header(("etag", file_etag))
+        .insert_header(("cache-control", "public, max-age=31536000, immutable")) // 1 год
+        .insert_header(("access-control-allow-origin", "*"))
+        .body(data)
+}
+
 /// Обработчик для скачивания файла и генерации миниатюры, если она недоступна.
 pub async fn proxy_handler(
     req: HttpRequest,
     requested_res: web::Path<String>,
     state: web::Data<AppState>,
 ) -> Result<HttpResponse, actix_web::Error> {
-    warn!("\t>>>\tGET {} [START]", requested_res);
+    let start_time = std::time::Instant::now();
+    info!("GET {} [START]", requested_res);
+    
     let normalized_path = if requested_res.ends_with("/webp") {
-        warn!("Removing /webp suffix from path");
+        info!("Converting to WebP format: {}", requested_res);
         requested_res.replace("/webp", "")
     } else {
         requested_res.to_string()
     };
 
+    // Проверяем If-None-Match заголовок для кэширования
+    let client_etag = req.headers().get("if-none-match")
+        .and_then(|h| h.to_str().ok());
+
     // парсим 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);
     let ext = extension.as_str().to_lowercase();
-    warn!("normalized to lowercase: {}", ext);
     let filekey = format!("{}.{}", base_filename, &ext);
-    warn!("filekey: {}", filekey);
+    
+    info!("Parsed request - base: {}, width: {}, ext: {}", base_filename, requested_width, ext);
+    
+    // Генерируем ETag для кэширования
+    let file_etag = format!("\"{}\"", &filekey);
+    if let Some(etag) = client_etag {
+        if etag == file_etag {
+            info!("Cache hit for {}, returning 304", filekey);
+            return Ok(HttpResponse::NotModified().finish());
+        }
+    }
     let content_type = match get_mime_type(&ext) {
         Some(mime) => mime.to_string(),
         None => {
@@ -46,24 +68,15 @@ pub async fn proxy_handler(
                     }
                 }
                 _ => {
-                    error!("unsupported file format");
-                    return Err(ErrorInternalServerError("unsupported file format"));
+                    error!("Unsupported file format for: {}", base_filename);
+                    return Err(ErrorInternalServerError("Unsupported file format"));
                 }
             }
         }
     };
 
-    warn!("content_type: {}", content_type);
+    info!("Content-Type: {}", content_type);
 
-    let shout_id = match req.query_string().contains("s=") {
-        true => req
-            .query_string()
-            .split("s=")
-            .collect::<Vec<&str>>()
-            .pop()
-            .unwrap_or(""),
-        false => "",
-    };
 
     return match state.get_path(&filekey).await {
         Ok(Some(stored_path)) => {
@@ -78,7 +91,7 @@ pub async fn proxy_handler(
                     warn!("Processing image file with width: {}", requested_width);
                     if requested_width == 0 {
                         warn!("Serving original file without resizing");
-                        serve_file(&stored_path, &state, shout_id).await
+                        serve_file(&stored_path, &state).await
                     } else {
                         let closest: u32 = find_closest_width(requested_width);
                         warn!(
@@ -94,12 +107,12 @@ pub async fn proxy_handler(
                         {
                             Ok(true) => {
                                 warn!("serve existed thumb file: {}", thumb_filename);
-                                serve_file(thumb_filename, &state, shout_id).await
+                                serve_file(thumb_filename, &state).await
                             }
                             Ok(false) => {
                                 // Миниатюра не существует, возвращаем оригинал и запускаем генерацию миниатюры
                                 let original_file =
-                                    serve_file(&stored_path, &state, shout_id).await?;
+                                    serve_file(&stored_path, &state).await?;
 
                                 // Запускаем асинхронную задачу для генерации миниатюры
                                 let state_clone = state.clone();
@@ -139,7 +152,7 @@ pub async fn proxy_handler(
                     }
                 } else {
                     warn!("File is not an image, proceeding with normal serving");
-                    serve_file(&stored_path, &state, shout_id).await
+                    serve_file(&stored_path, &state).await
                 }
             } else {
                 warn!(
@@ -193,9 +206,9 @@ pub async fn proxy_handler(
                                 warn!("Successfully uploaded to Storj: {}", filekey);
                             }
 
-                            return Ok(HttpResponse::Ok()
-                                .content_type(content_type)
-                                .body(filedata));
+                            let elapsed = start_time.elapsed();
+                            info!("File served from AWS in {:?}: {}", elapsed, path);
+                            return Ok(create_cached_response(&content_type, filedata, &file_etag));
                         }
                         Err(err) => {
                             warn!("Failed to load from AWS path {}: {:?}", path, err);
@@ -299,7 +312,9 @@ pub async fn proxy_handler(
                             warn!("file {} uploaded to storj", filekey);
                             state.set_path(&filekey, &filepath).await;
                         }
-                        Ok(HttpResponse::Ok().content_type(content_type).body(filedata))
+                        let elapsed = start_time.elapsed();
+                        info!("File served from AWS in {:?}: {}", elapsed, filepath);
+                        Ok(create_cached_response(&content_type, filedata, &file_etag))
                     }
                     Err(e) => {
                         error!("Failed to download from AWS: {} - Error: {}", filepath, e);
@@ -312,9 +327,10 @@ pub async fn proxy_handler(
             }
         }
         Err(e) => {
+            let elapsed = start_time.elapsed();
             error!(
-                "Database error while getting path: {} - Full error: {:?}",
-                filekey, e
+                "Database error while getting path: {} in {:?} - Full error: {:?}",
+                filekey, elapsed, e
             );
             Err(ErrorInternalServerError(e))
         }