proxy-reworked

2024-10-22 19:34:08 +03:00
parent 30a2672ca8
commit 1c27714455
7 changed files with 125 additions and 116 deletions
--- a/src/handlers/proxy.rs
+++ b/src/handlers/proxy.rs
@@ -1,9 +1,8 @@
 use actix_web::{error::ErrorInternalServerError, web, HttpRequest, HttpResponse, Result};
-use log::{info, warn, error};

 use crate::app_state::AppState;
-use crate::thumbnail::{parse_thumbnail_request, find_closest_width, generate_thumbnails};
-use crate::s3_utils::{load_file_from_s3, upload_to_s3};
+use crate::thumbnail::{find_closest_width, generate_thumbnails, parse_image_request};
+use crate::s3_utils::{check_file_exists, load_file_from_s3, upload_to_s3};
 use crate::handlers::serve_file::serve_file;

 /// Обработчик для скачивания файла и генерации миниатюры, если она недоступна.
@@ -12,82 +11,105 @@ pub async fn proxy_handler(
    requested_res: web::Path<String>,
    state: web::Data<AppState>,
 ) -> Result<HttpResponse, actix_web::Error> {
-    info!("requested_path: {}", requested_res);
-    let requested_path = requested_res.replace("/webp", "");
-    let parts = requested_path.split('/').collect::<Vec<&str>>(); // Explicit type annotation
-    let filename = parts[parts.len()-1];
-
-    let stored_path = match state.get_path(&filename).await {
-        Ok(Some(path)) => path,
-        Ok(None) => {
-            warn!("wrong filename: {}", filename);
-            return Ok(HttpResponse::NotFound().finish());
-        }
-        Err(e) => {
-            warn!("error: {}", e);
-            return Ok(HttpResponse::InternalServerError().finish());
-        }
+    let normalized_path = match requested_res.ends_with("/webp") {
+        true => requested_res.replace("/webp", ""),
+        false => requested_res.to_string(),
    };
-    info!("stored path: {}", stored_path);

-    // Проверяем, запрошена ли миниатюра
-    if let Some((base_filename, requested_width, extension)) =
-        parse_thumbnail_request(&requested_res)
-    {
-        info!("thumbnail requested: {}  width: {} ext: {}", base_filename, requested_width, extension);
+    // парсим GET запрос
+    if let Some((base_filename, requested_width, extension)) = parse_image_request(&normalized_path) {
+        let filekey = format!("{}.{}", base_filename, extension);
+        let content_type = match extension.as_str() {
+            "jpg" | "jpeg" => "image/jpeg",
+            "png" => "image/png",
+            "webp" => "image/webp",
+            "gif" => "image/gif",
+            "mp3" => "audio/mpeg",
+            "wav" => "audio/x-wav",
+            "ogg" => "audio/ogg",
+            "aac" => "audio/aac",
+            "m4a" => "audio/m4a",
+            "flac" => "audio/flac",
+            _ => return Err(ErrorInternalServerError("unsupported file format"))
+        };

-        // Находим ближайший подходящий размер
-        let closest_width = find_closest_width(requested_width);
-        let thumb_filename = format!("{}_{}.jpg", base_filename, closest_width);
-        info!("closest width: {}, thumb_filename: {}", closest_width, thumb_filename);
+        return match state.get_path(&filekey).await {
+            Ok(Some(stored_path)) => {

-        // Проверяем наличие миниатюры в кэше
-        let cached_files = state.get_cached_file_list().await;
-        if !cached_files.contains(&thumb_filename) {
-            info!("no thumb found");
-            if cached_files.contains(&base_filename) {
-                info!("no original file found");
-                // Загружаем оригинальный файл из S3
-                let original_data: Vec<u8> =
-                    load_file_from_s3(&state.storj_client, &state.storj_bucket, &base_filename).await?;
+                // we have stored file path in storj
+                if check_file_exists(&state.storj_client, &state.bucket, &stored_path).await? {
+                    if content_type.starts_with("image") {
+                        return match requested_width == 0 {
+                            true => serve_file(&stored_path, &state).await,
+                            false => {
+                                // find closest thumb width
+                                let closest: u32 = find_closest_width(requested_width as u32);
+                                let thumb_filename = &format!("{}_{}.{}", base_filename, closest, extension);
+    
+                                return match check_file_exists(&state.storj_client, &state.bucket, thumb_filename).await {
+                                    Ok(true) => serve_file(thumb_filename, &state).await,
+                                    Ok(false) => {
+                                        if let Ok(filedata) = load_file_from_s3(
+                                            &state.storj_client, &state.bucket, &stored_path).await {
+                                                thumbdata_save(&filedata, &state, &base_filename, content_type).await;
+                                                serve_file(thumb_filename, &state).await
+                                            } else {
+                                                Err(ErrorInternalServerError("cannot generate thumbnail"))
+                                            }
+                                    }
+                                    Err(_) => Err(ErrorInternalServerError("failed to load thumbnail"))
+                                }
+                            }
+                        }
+                    }
+                    // not image passing thumb generation
+                }

-                // Генерируем миниатюру для ближайшего подходящего размера
-                let image = image::load_from_memory(&original_data).map_err(|_| {
-                    ErrorInternalServerError("Failed to load image for thumbnail generation")
-                })?;
-                let thumbnails_bytes =
-                    generate_thumbnails(&image).await?;
-                let thumbnail_bytes = thumbnails_bytes[&closest_width].clone();
-
-                // Загружаем миниатюру в S3
-                upload_to_s3(
-                    &state.storj_client,
-                    &state.storj_bucket,
-                    &thumb_filename,
-                    thumbnail_bytes.clone(),
-                    "image/jpeg",
-                )
-                .await?;
-                info!("thumb was saved in storj");
-                return Ok(HttpResponse::Ok()
-                    .content_type("image/jpeg")
-                    .body(thumbnail_bytes));
-            } else {
-                warn!("original was not found");
-            }
-        } else {
-            info!("thumb was found");
-            return serve_file(&thumb_filename, &state).await;
+                // 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) => {
+                            let _ = upload_to_s3(&state.storj_client, &state.bucket, &filekey, filedata.clone(), content_type).await;
+                            thumbdata_save(&filedata, &state, &base_filename, content_type).await;
+                            
+                            Ok(HttpResponse::Ok()
+                                .content_type(content_type)
+                                .body(filedata)
+                            )
+                        },
+                        Err(err) => Err(ErrorInternalServerError(err)),
+                    }
+            },
+            Ok(None) => Err(ErrorInternalServerError("requested file path was not found")),
+            Err(e) => Err(ErrorInternalServerError(e))
        }
    }

-    // Если запрошен целый файл
-    info!("serving full file: {}", requested_path);
-    match serve_file(&requested_path, &state).await {
-        Ok(response) => Ok(response),
-        Err(e) => {
-            error!("error: {}", e);
-            Err(e)
-        }
-    }
+    Err(ErrorInternalServerError("invalid file key"))
+    
 }
+
+async fn thumbdata_save(original_data: &[u8], state: &AppState, original_filename: &str, content_type: &str) {
+    if content_type.starts_with("image") {
+        let ext = original_filename.split('.').last().unwrap();
+        let img = image::load_from_memory(&original_data).unwrap();
+        
+        if let Ok(thumbnails_bytes) = generate_thumbnails(&img).await {
+            for (thumb_width, thumbnail) in thumbnails_bytes {
+                let thumb_filename = &format!("{}_{}.{}", original_filename, thumb_width, ext);
+                let thumbnail_bytes = thumbnail.clone();
+                // Загружаем миниатюру в S3
+                let _ = upload_to_s3(
+                    &state.storj_client,
+                    &state.bucket,
+                    thumb_filename,
+                    thumbnail_bytes,
+                    content_type,
+                )
+                .await;
+            }
+        }
+    }
+}
--- a/src/handlers/serve_file.rs
+++ b/src/handlers/serve_file.rs
@@ -11,7 +11,7 @@ pub async fn serve_file(filepath: &str, state: &AppState) -> Result<HttpResponse
    }

    // Проверяем наличие файла в Storj S3
-    let exists = check_file_exists(&state.storj_client, &state.storj_bucket, &filepath).await?;
+    let exists = check_file_exists(&state.storj_client, &state.bucket, &filepath).await?;
    if !exists {
        return Err(ErrorInternalServerError(format!("File {} not found in Storj", filepath)));
    }
@@ -20,7 +20,7 @@ pub async fn serve_file(filepath: &str, state: &AppState) -> Result<HttpResponse
    let get_object_output = state
        .storj_client
        .get_object()
-        .bucket(&state.storj_bucket)
+        .bucket(&state.bucket)
        .key(filepath)
        .send()
        .await
--- a/src/handlers/upload.rs
+++ b/src/handlers/upload.rs
@@ -62,7 +62,7 @@ pub async fn upload_handler(
            // Загружаем файл в S3
            upload_to_s3(
                &state.storj_client,
-                &state.storj_bucket,
+                &state.bucket,
                &body,
                file_bytes,
                &content_type,