0.0.3-desirable

src/app_state.rs

@@ -0,0 +1,263 @@
+// app_state.rs
+
+use actix_web::error::ErrorInternalServerError;
+use aws_config::BehaviorVersion;
+use aws_sdk_s3::{config::Credentials, Client as S3Client};
+use redis::{aio::MultiplexedConnection, AsyncCommands, Client as RedisClient};
+use std::{env, time::Duration};
+use tokio::time::interval;
+
+use crate::s3_utils::check_file_exists;
+
+#[derive(Clone)]
+pub struct AppState {
+    pub redis: MultiplexedConnection,
+    pub s3_client: S3Client,
+    pub s3_bucket: String,
+    pub aws_client: S3Client,
+    pub aws_bucket: String,
+}
+
+const FILE_LIST_CACHE_KEY: &str = "s3_file_list_cache"; // Ключ для хранения списка файлов в Redis
+const PATH_MAPPING_KEY: &str = "path_mapping"; // Ключ для хранения маппинга путей
+const CHECK_INTERVAL_SECONDS: u64 = 60 * 60; // Интервал обновления списка файлов: 1 час
+const WEEK_SECONDS: u64 = 604800;
+
+impl AppState {
+    /// Инициализация нового состояния приложения.
+    pub async fn new() -> Self {
+        // Получаем конфигурацию для Redis
+        let redis_url = env::var("REDIS_URL").expect("REDIS_URL must be set");
+        let redis_client = RedisClient::open(redis_url).expect("Invalid Redis URL");
+        let redis_connection = redis_client
+            .get_multiplexed_async_connection()
+            .await
+            .unwrap();
+
+        // Получаем конфигурацию для S3 (Storj)
+        let s3_access_key = env::var("STORJ_ACCESS_KEY").expect("STORJ_ACCESS_KEY must be set");
+        let s3_secret_key = env::var("STORJ_SECRET_KEY").expect("STORJ_SECRET_KEY must be set");
+        let s3_endpoint = env::var("STORJ_END_POINT").expect("STORJ_END_POINT must be set");
+        let s3_bucket = env::var("STORJ_BUCKET_NAME").expect("STORJ_BUCKET_NAME must be set");
+
+        // Получаем конфигурацию для AWS S3
+        let aws_access_key = env::var("AWS_ACCESS_KEY").expect("AWS_ACCESS_KEY must be set");
+        let aws_secret_key = env::var("AWS_SECRET_KEY").expect("AWS_SECRET_KEY must be set");
+        let aws_endpoint = env::var("AWS_END_POINT").expect("AWS_END_POINT must be set");
+        let aws_bucket = env::var("AWS_BUCKET_NAME").expect("AWS_BUCKET_NAME must be set");
+
+        // Конфигурируем клиент S3 для Storj
+        let storj_config = aws_config::defaults(BehaviorVersion::latest())
+            .region("eu-west-1")
+            .endpoint_url(s3_endpoint)
+            .credentials_provider(Credentials::new(
+                s3_access_key,
+                s3_secret_key,
+                None,
+                None,
+                "rust-s3-client",
+            ))
+            .load()
+            .await;
+
+        let s3_client = S3Client::new(&storj_config);
+
+        // Конфигурируем клиент S3 для AWS
+        let aws_config = aws_config::defaults(BehaviorVersion::latest())
+            .region("us-east-1")
+            .endpoint_url(aws_endpoint)
+            .credentials_provider(Credentials::new(
+                aws_access_key,
+                aws_secret_key,
+                None,
+                None,
+                "rust-aws-client",
+            ))
+            .load()
+            .await;
+
+        let aws_client = S3Client::new(&aws_config);
+
+        let app_state = AppState {
+            redis: redis_connection,
+            s3_client,
+            s3_bucket,
+            aws_client,
+            aws_bucket,
+        };
+
+        // Кэшируем список файлов из S3 при старте приложения
+        app_state.cache_file_list().await;
+
+        app_state
+    }
+
+    /// Кэширует список файлов из Storj S3 в Redis.
+    pub async fn cache_file_list(&self) {
+        let mut redis = self.redis.clone();
+
+        // Запрашиваем список файлов из Storj S3
+        let list_objects_v2 = self.s3_client.list_objects_v2();
+        let list_response = list_objects_v2
+            .bucket(&self.s3_bucket)
+            .send()
+            .await
+            .expect("Failed to list files from S3");
+
+        if let Some(objects) = list_response.contents {
+            // Формируем список файлов
+            let file_list: Vec<String> = objects
+                .iter()
+                .filter_map(|object| object.key.clone())
+                .collect();
+
+            // Сохраняем список файлов в Redis в формате JSON
+            let _: () = redis
+                .set(
+                    FILE_LIST_CACHE_KEY,
+                    serde_json::to_string(&file_list).unwrap(),
+                )
+                .await
+                .expect("Failed to cache file list in Redis");
+        }
+    }
+
+    /// Получает кэшированный список файлов из Redis.
+    pub async fn get_cached_file_list(&self) -> Vec<String> {
+        let mut redis = self.redis.clone();
+
+        // Пытаемся получить кэшированный список из Redis
+        let cached_list: Option<String> = redis.get(FILE_LIST_CACHE_KEY).await.unwrap_or(None);
+
+        if let Some(cached_list) = cached_list {
+            // Если список найден, возвращаем его в виде вектора строк
+            serde_json::from_str(&cached_list).unwrap_or_else(|_| vec![])
+        } else {
+            vec![]
+        }
+    }
+
+    /// Периодически обновляет кэшированный список файлов из Storj S3.
+    pub async fn refresh_file_list_periodically(&self) {
+        let mut interval = interval(Duration::from_secs(CHECK_INTERVAL_SECONDS));
+        loop {
+            interval.tick().await;
+            self.cache_file_list().await;
+        }
+    }
+
+    /// Сохраняет маппинг старого пути из AWS S3 на новый путь в Storj S3.
+    async fn save_path_by_filekey(
+        &self,
+        filekey: &str,
+        path: &str,
+    ) -> Result<(), actix_web::Error> {
+        let mut redis = self.redis.clone();
+        // Храним маппинг в формате Hash: old_path -> new_path
+        redis
+            .hset(PATH_MAPPING_KEY, filekey, path)
+            .await
+            .map_err(|_| ErrorInternalServerError("Failed to save path mapping in Redis"))?;
+        Ok(())
+    }
+
+    /// Получает путь в хранилище из ключа (имени файла) в Redis.
+    pub async fn get_path(&self, filekey: &str) -> Result<Option<String>, actix_web::Error> {
+        let mut redis = self.redis.clone();
+        let new_path: Option<String> = redis
+            .hget(PATH_MAPPING_KEY, filekey)
+            .await
+            .map_err(|_| ErrorInternalServerError("Failed to get path mapping from Redis"))?;
+        Ok(new_path)
+    }
+
+    /// Обновляет Storj S3 данными из Amazon S3
+    pub async fn update_filelist_from_aws(&self) {
+        // Получаем список объектов из AWS S3
+        let list_objects_v2 = self.aws_client.list_objects_v2();
+        let list_response = list_objects_v2
+            .bucket(&self.aws_bucket)
+            .send()
+            .await
+            .expect("Failed to list files from AWS S3");
+
+        // перебор списка файлов
+        if let Some(objects) = list_response.contents {
+            for object in objects {
+                if let Some(key) = object.key {
+                    let filename_with_extension = key.split('/').last().unwrap();
+
+                    // Убираем расширение файла
+                    let filename = filename_with_extension
+                        .rsplit_once('.')
+                        .map(|(name, _ext)| name)
+                        .unwrap_or(filename_with_extension); // Если расширение отсутствует, возвращаем оригинальное имя
+
+                    // Проверяем, существует ли файл на Storj S3
+                    if !check_file_exists(&self.s3_client, &self.s3_bucket, filename)
+                        .await
+                        .unwrap_or(false)
+                    {
+                        // Сохраняем маппинг пути
+                        self.save_path_by_filekey(filename, &key).await.unwrap();
+                    }
+                }
+            }
+        }
+    }
+
+    pub async fn get_or_create_quota(&self, user_id: &str) -> Result<u64, actix_web::Error> {
+        let mut redis = self.redis.clone();
+        let quota_key = format!("quota:{}", user_id);
+
+        // Попытка получить квоту из Redis
+        let quota: u64 = redis.get(&quota_key).await.unwrap_or(0);
+
+        if quota == 0 {
+            // Если квота не найдена, устанавливаем её в 0 байт и задаем TTL на одну неделю
+            redis
+                .set_ex(&quota_key, 0, WEEK_SECONDS)
+                .await
+                .map_err(|_| {
+                    ErrorInternalServerError("Failed to set initial user quota in Redis")
+                })?;
+
+            Ok(0) // Возвращаем 0 как начальную квоту
+        } else {
+            Ok(quota)
+        }
+    }
+
+    pub async fn increment_uploaded_bytes(
+        &self,
+        user_id: &str,
+        bytes: u64,
+    ) -> Result<u64, actix_web::Error> {
+        let mut redis = self.redis.clone();
+        let quota_key = format!("quota:{}", user_id);
+
+        // Проверяем, существует ли ключ в Redis
+        let exists: bool = redis.exists(&quota_key).await.map_err(|_| {
+            ErrorInternalServerError("Failed to check if user quota exists in Redis")
+        })?;
+
+        // Если ключ не существует, создаем его с начальным значением и устанавливаем TTL
+        if !exists {
+            redis
+                .set_ex(&quota_key, bytes, WEEK_SECONDS)
+                .await
+                .map_err(|_| {
+                    ErrorInternalServerError("Failed to set initial user quota in Redis")
+                })?;
+            return Ok(bytes);
+        }
+
+        // Если ключ существует, инкрементируем его значение на заданное количество байт
+        let new_quota: u64 = redis
+            .incr(&quota_key, bytes)
+            .await
+            .map_err(|_| ErrorInternalServerError("Failed to increment user quota in Redis"))?;
+
+        Ok(new_quota)
+    }
+}

src/auth.rs

@@ -0,0 +1,97 @@
+// auth.rs
+
+use actix_web::error::ErrorInternalServerError;
+use redis::{aio::MultiplexedConnection, AsyncCommands};
+use reqwest::header::{HeaderMap, HeaderValue, CONTENT_TYPE};
+use reqwest::Client as HTTPClient;
+use serde::Deserialize;
+use serde_json::json;
+use std::{collections::HashMap, env, error::Error};
+
+// Структура для десериализации ответа от сервиса аутентификации
+#[derive(Deserialize)]
+struct AuthResponse {
+    data: Option<AuthData>,
+}
+
+#[derive(Deserialize)]
+struct AuthData {
+    validate_jwt_token: Option<ValidateJWTToken>,
+}
+
+#[derive(Deserialize)]
+struct ValidateJWTToken {
+    is_valid: bool,
+    claims: Option<Claims>,
+}
+
+#[derive(Deserialize)]
+struct Claims {
+    sub: Option<String>,
+}
+
+/// Получает айди пользователя из токена в заголовке
+pub async fn get_id_by_token(token: &str) -> Result<String, Box<dyn Error>> {
+    let auth_api_base = env::var("AUTH_URL")?;
+    let query_name = "validate_jwt_token";
+    let operation = "ValidateToken";
+    let mut headers = HeaderMap::new();
+    headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
+
+    let mut variables = HashMap::<String, HashMap<String, String>>::new();
+    let mut params = HashMap::<String, String>::new();
+    params.insert("token".to_string(), token.to_string());
+    params.insert("token_type".to_string(), "access_token".to_string());
+    variables.insert("params".to_string(), params);
+
+    let gql = json!({
+        "query": format!("query {}($params: ValidateJWTTokenInput!) {{ {}(params: $params) {{ is_valid claims }} }}", operation, query_name),
+        "operationName": operation,
+        "variables": variables
+    });
+
+    let client = HTTPClient::new();
+    let response = client
+        .post(&auth_api_base)
+        .headers(headers)
+        .json(&gql)
+        .send()
+        .await?;
+
+    if response.status().is_success() {
+        let auth_response: AuthResponse = response.json().await?;
+        if let Some(auth_data) = auth_response.data {
+            if let Some(validate_jwt_token) = auth_data.validate_jwt_token {
+                if validate_jwt_token.is_valid {
+                    if let Some(claims) = validate_jwt_token.claims {
+                        if let Some(sub) = claims.sub {
+                            return Ok(sub);
+                        }
+                    }
+                }
+            }
+        }
+        Err(Box::new(std::io::Error::new(
+            std::io::ErrorKind::Other,
+            "Invalid token response",
+        )))
+    } else {
+        Err(Box::new(std::io::Error::new(
+            std::io::ErrorKind::Other,
+            format!("Request failed with status: {}", response.status()),
+        )))
+    }
+}
+
+/// Сохраняет имя файла в Redis для пользователя
+pub async fn user_added_file(
+    redis: &mut MultiplexedConnection,
+    user_id: &str,
+    filename: &str,
+) -> Result<(), actix_web::Error> {
+    redis
+        .sadd(user_id, filename)
+        .await
+        .map_err(|_| ErrorInternalServerError("Failed to save filename in Redis"))?; // Добавляем имя файла в набор пользователя
+    Ok(())
+}

src/handlers.rs

@@ -0,0 +1,183 @@
+// handlers.rs
+
+use crate::app_state::AppState;
+use crate::auth::{get_id_by_token, user_added_file};
+use crate::s3_utils::{
+    check_file_exists, generate_key_with_extension, load_file_from_s3, upload_to_s3,
+};
+use crate::thumbnail::{find_closest_width, generate_thumbnails, parse_thumbnail_request, ALLOWED_THUMBNAIL_WIDTHS};
+use actix_multipart::Multipart;
+use actix_web::error::ErrorInternalServerError;
+use actix_web::{web, HttpRequest, HttpResponse, Result};
+use futures::StreamExt;
+use mime_guess::MimeGuess;
+
+pub const MAX_WEEK_BYTES: u64 = 2 * 1024 * 1024 * 1024; // Лимит квоты на пользователя: 2 ГБ в неделю
+
+/// Функция для обслуживания файла по заданному пути.
+async fn serve_file(file_key: &str, state: &AppState) -> Result<HttpResponse, actix_web::Error> {
+    // Проверяем наличие файла в Storj S3
+    if !check_file_exists(&state.s3_client, &state.s3_bucket, file_key).await? {
+        return Err(ErrorInternalServerError("File not found in S3"));
+    }
+
+    let checked_filekey = state.get_path(file_key).await.unwrap().unwrap();
+
+    // Получаем объект из Storj S3
+    let get_object_output = state
+        .s3_client
+        .get_object()
+        .bucket(&state.s3_bucket)
+        .key(checked_filekey)
+        .send()
+        .await
+        .map_err(|_| ErrorInternalServerError("Failed to get object from S3"))?;
+
+    let data: aws_sdk_s3::primitives::AggregatedBytes = get_object_output
+        .body
+        .collect()
+        .await
+        .map_err(|_| ErrorInternalServerError("Failed to read object body"))?;
+
+    let data_bytes = data.into_bytes();
+    let mime_type = MimeGuess::from_path(file_key).first_or_octet_stream(); // Определяем MIME-тип файла
+
+    Ok(HttpResponse::Ok()
+        .content_type(mime_type.as_ref())
+        .body(data_bytes))
+}
+
+/// Обработчик для аплоада файлов.
+pub async fn upload_handler(
+    req: HttpRequest,
+    mut payload: Multipart,
+    state: web::Data<AppState>,
+) -> Result<HttpResponse, actix_web::Error> {
+    // Получаем токен из заголовка авторизации
+    let token = req
+        .headers()
+        .get("Authorization")
+        .and_then(|header_value| header_value.to_str().ok());
+    if token.is_none() {
+        return Err(actix_web::error::ErrorUnauthorized("Unauthorized")); // Если токен отсутствует, возвращаем ошибку
+    }
+
+    let user_id = get_id_by_token(token.unwrap()).await?;
+
+    // Получаем текущую квоту пользователя
+    let this_week_amount: u64 = state.get_or_create_quota(&user_id).await.unwrap_or(0);
+
+    while let Some(field) = payload.next().await {
+        let mut field = field?;
+        let content_type = field.content_type().unwrap().to_string();
+        let file_name = field
+            .content_disposition()
+            .unwrap()
+            .get_filename()
+            .map(|f| f.to_string());
+
+        if let Some(name) = file_name {
+            let mut file_bytes = Vec::new();
+            let mut file_size: u64 = 0;
+
+            // Читаем данные файла
+            while let Some(chunk) = field.next().await {
+                let data = chunk?;
+                file_size += data.len() as u64;
+                file_bytes.extend_from_slice(&data);
+            }
+
+            // Проверяем, что добавление файла не превышает лимит квоты
+            if this_week_amount + file_size > MAX_WEEK_BYTES {
+                return Err(actix_web::error::ErrorUnauthorized("Quota exceeded"));
+                // Квота превышена
+            }
+
+            // Инкрементируем квоту пользователя
+            let _ = state.increment_uploaded_bytes(&user_id, file_size).await?;
+
+            // Определяем правильное расширение и ключ для S3
+            let file_key = generate_key_with_extension(name, content_type.to_owned());
+
+            // Загружаем файл в S3
+            upload_to_s3(
+                &state.s3_client,
+                &state.s3_bucket,
+                &file_key,
+                file_bytes,
+                &content_type,
+            )
+            .await?;
+
+            // Сохраняем информацию о загруженном файле для пользователя
+            user_added_file(&mut state.redis.clone(), &user_id, &file_key).await?;
+        }
+    }
+
+    Ok(HttpResponse::Ok().json("File uploaded successfully"))
+}
+
+/// Обработчик для скачивания файла и генерации миниатюры, если она недоступна.
+pub async fn proxy_handler(
+    _req: HttpRequest,
+    path: web::Path<String>,
+    state: web::Data<AppState>,
+) -> Result<HttpResponse, actix_web::Error> {
+    // весь запрошенный путь
+    let requested_path = state.get_path(&path).await.unwrap().unwrap();
+
+    // имя файла
+    let filename_with_extension = requested_path.split("/").last().unwrap();
+
+    // убираем расширение файла
+    let requested_filekey = filename_with_extension
+        .rsplit_once('.')
+        .map(|(name, _ext)| name)
+        .unwrap_or(filename_with_extension); // Если расширение отсутствует, возвращаем оригинальное имя
+
+    // Проверяем, запрошена ли миниатюра
+    if let Some((base_filename, requested_width, _ext)) =
+        parse_thumbnail_request(&requested_filekey)
+    {
+        // Находим ближайший подходящий размер
+        let closest_width = find_closest_width(requested_width);
+        let thumbnail_key = format!("{}_{}", base_filename, closest_width);
+
+        // Проверяем наличие миниатюры в кэше
+        let cached_files = state.get_cached_file_list().await;
+        if !cached_files.contains(&thumbnail_key) {
+            if cached_files.contains(&base_filename) {
+                // Загружаем оригинальный файл из S3
+                let original_data =
+                    load_file_from_s3(&state.s3_client, &state.s3_bucket, &base_filename).await?;
+
+                // Генерируем миниатюру для ближайшего подходящего размера
+                let image = image::load_from_memory(&original_data).map_err(|_| {
+                    ErrorInternalServerError("Failed to load image for thumbnail generation")
+                })?;
+                let thumbnails_bytes =
+                    generate_thumbnails(&image, &ALLOWED_THUMBNAIL_WIDTHS).await?;
+                let thumbnail_bytes = thumbnails_bytes[&closest_width].clone();
+                // Загружаем миниатюру в S3
+                upload_to_s3(
+                    &state.s3_client,
+                    &state.s3_bucket,
+                    &thumbnail_key,
+                    thumbnail_bytes.clone(),
+                    "image/jpeg",
+                )
+                .await?;
+
+                return Ok(HttpResponse::Ok()
+                    .content_type("image/jpeg")
+                    .body(thumbnail_bytes));
+            }
+        } else {
+            // Если миниатюра уже есть в кэше, просто возвращаем её
+            return serve_file(&thumbnail_key, &state).await;
+        }
+    }
+
+    // Если запрошен целый файл
+    serve_file(&requested_filekey, &state).await
+}

src/main.rs

@@ -1,484 +1,29 @@
-use actix_web::{
-    error::{ErrorInternalServerError, ErrorUnauthorized},
-    middleware::Logger,
-    web, App, HttpRequest, HttpResponse, HttpServer, Result,
-};
-use aws_config::BehaviorVersion;
-use aws_sdk_s3::primitives::ByteStream;
-use aws_sdk_s3::{config::Credentials, error::SdkError, Client as S3Client};
-use image::{imageops::FilterType, DynamicImage};
-use mime_guess::MimeGuess;
-use redis::Client as RedisClient;
-use redis::{aio::MultiplexedConnection, AsyncCommands};
-use reqwest::{
-    header::{HeaderMap, HeaderValue, CONTENT_TYPE},
-    Client as HTTPClient,
-};
-use serde::Deserialize;
-use serde_json::json;
-use std::path::Path;
-use std::{collections::HashMap, error::Error, io::Cursor};
-use std::{env, time::Duration};
-use tokio::time::interval;
+mod app_state;
+mod auth;
+mod handlers;
+mod s3_utils;
+mod thumbnail;
 
-const MAX_QUOTA_BYTES: u64 = 2 * 1024 * 1024 * 1024; // Лимит квоты на пользователя: 2 ГБ в неделю
-const FILE_LIST_CACHE_KEY: &str = "s3_file_list_cache"; // Ключ для хранения списка файлов в Redis
-const PATH_MAPPING_KEY: &str = "path_mapping"; // Ключ для хранения маппинга путей
-const CHECK_INTERVAL_SECONDS: u64 = 60; // Интервал обновления кэша: 1 минута
-
-/// Структура состояния приложения, содержащая Redis и S3 клиенты.
-#[derive(Clone)]
-struct AppState {
-    redis: MultiplexedConnection, // Подключение к Redis
-    s3_client: S3Client,          // Клиент S3 для Storj
-    s3_bucket: String,            // Название бакета в Storj
-    aws_client: S3Client,         // Клиент S3 для AWS
-    aws_bucket: String,           // Название бакета в AWS
-}
-
-impl AppState {
-    /// Инициализация нового состояния приложения.
-    async fn new() -> Self {
-        // Получаем конфигурацию для Redis
-        let redis_url = env::var("REDIS_URL").expect("REDIS_URL must be set");
-        let redis_client = RedisClient::open(redis_url).expect("Invalid Redis URL");
-        let redis_connection = redis_client
-            .get_multiplexed_async_connection()
-            .await
-            .unwrap();
-
-        // Получаем конфигурацию для S3 (Storj)
-        let s3_access_key = env::var("STORJ_ACCESS_KEY").expect("STORJ_ACCESS_KEY must be set");
-        let s3_secret_key = env::var("STORJ_SECRET_KEY").expect("STORJ_SECRET_KEY must be set");
-        let s3_endpoint = env::var("STORJ_END_POINT").expect("STORJ_END_POINT must be set");
-        let s3_bucket = env::var("STORJ_BUCKET_NAME").expect("STORJ_BUCKET_NAME must be set");
-
-        // Получаем конфигурацию для AWS S3
-        let aws_access_key = env::var("AWS_ACCESS_KEY").expect("AWS_ACCESS_KEY must be set");
-        let aws_secret_key = env::var("AWS_SECRET_KEY").expect("AWS_SECRET_KEY must be set");
-        let aws_endpoint = env::var("AWS_END_POINT").expect("AWS_END_POINT must be set");
-        let aws_bucket = env::var("AWS_BUCKET_NAME").expect("AWS_BUCKET_NAME must be set");
-
-        // Конфигурируем клиент S3 для Storj
-        let storj_config = aws_config::defaults(BehaviorVersion::latest())
-            .region("eu-west-1")
-            .endpoint_url(s3_endpoint)
-            .credentials_provider(Credentials::new(
-                s3_access_key,
-                s3_secret_key,
-                None,
-                None,
-                "rust-s3-client",
-            ))
-            .load()
-            .await;
-
-        let s3_client = S3Client::new(&storj_config);
-
-        // Конфигурируем клиент S3 для AWS
-        let aws_config = aws_config::defaults(BehaviorVersion::latest())
-            .region("us-east-1")
-            .endpoint_url(aws_endpoint)
-            .credentials_provider(Credentials::new(
-                aws_access_key,
-                aws_secret_key,
-                None,
-                None,
-                "rust-aws-client",
-            ))
-            .load()
-            .await;
-
-        let aws_client = S3Client::new(&aws_config);
-
-        let app_state = AppState {
-            redis: redis_connection,
-            s3_client,
-            s3_bucket,
-            aws_client,
-            aws_bucket,
-        };
-
-        // Кэшируем список файлов из S3 при старте приложения
-        app_state.cache_file_list().await;
-
-        app_state
-    }
-
-    /// Кэширует список файлов из Storj S3 в Redis.
-    async fn cache_file_list(&self) {
-        let mut redis = self.redis.clone();
-
-        // Запрашиваем список файлов из Storj S3
-        let list_objects_v2 = self.s3_client.list_objects_v2();
-        let list_response = list_objects_v2
-            .bucket(&self.s3_bucket)
-            .send()
-            .await
-            .expect("Failed to list files from S3");
-
-        if let Some(objects) = list_response.contents {
-            // Формируем список файлов
-            let file_list: Vec<String> = objects
-                .iter()
-                .filter_map(|object| object.key.clone())
-                .collect();
-
-            // Сохраняем список файлов в Redis в формате JSON
-            let _: () = redis
-                .set(
-                    FILE_LIST_CACHE_KEY,
-                    serde_json::to_string(&file_list).unwrap(),
-                )
-                .await
-                .expect("Failed to cache file list in Redis");
-        }
-    }
-
-    /// Получает кэшированный список файлов из Redis.
-    async fn get_cached_file_list(&self) -> Vec<String> {
-        let mut redis = self.redis.clone();
-
-        // Пытаемся получить кэшированный список из Redis
-        let cached_list: Option<String> = redis.get(FILE_LIST_CACHE_KEY).await.unwrap_or(None);
-
-        if let Some(cached_list) = cached_list {
-            // Если список найден, возвращаем его в виде вектора строк
-            serde_json::from_str(&cached_list).unwrap_or_else(|_| vec![])
-        } else {
-            vec![]
-        }
-    }
-
-    /// Периодически обновляет кэшированный список файлов из Storj S3.
-    async fn refresh_file_list_periodically(&self) {
-        let mut interval = interval(Duration::from_secs(CHECK_INTERVAL_SECONDS));
-        loop {
-            interval.tick().await;
-            self.cache_file_list().await;
-        }
-    }
-
-    /// Сохраняет маппинг старого пути из AWS S3 на новый путь в Storj S3.
-    async fn save_path_mapping(
-        &self,
-        old_path: &str,
-        new_path: &str,
-    ) -> Result<(), actix_web::Error> {
-        let mut redis = self.redis.clone();
-        // Храним маппинг в формате Hash: old_path -> new_path
-        redis
-            .hset(PATH_MAPPING_KEY, old_path, new_path)
-            .await
-            .map_err(|_| ErrorInternalServerError("Failed to save path mapping in Redis"))?;
-        Ok(())
-    }
-
-    /// Получает новый путь для старого пути из маппинга в Redis.
-    async fn get_new_path(&self, old_path: &str) -> Result<Option<String>, actix_web::Error> {
-        let mut redis = self.redis.clone();
-        let new_path: Option<String> = redis
-            .hget(PATH_MAPPING_KEY, old_path)
-            .await
-            .map_err(|_| ErrorInternalServerError("Failed to get path mapping from Redis"))?;
-        Ok(new_path)
-    }
-}
-
-/// Генерирует миниатюру изображения с заданной шириной.
-async fn generate_thumbnail(image: &DynamicImage, width: u32) -> Result<Vec<u8>, actix_web::Error> {
-    let original_width = image.width();
-    let scale_factor = original_width / width;
-    let height = image.height() / scale_factor;
-    let thumbnail = image.resize(width, height, FilterType::Lanczos3); // Ресайз изображения с использованием фильтра Lanczos3
-    let mut buffer = Vec::new();
-    thumbnail
-        .write_to(&mut Cursor::new(&mut buffer), image::ImageFormat::Jpeg)
-        .map_err(|_| ErrorInternalServerError("Failed to generate thumbnail"))?; // Сохранение изображения в формате JPEG
-    Ok(buffer)
-}
-
-/// Загружает файл в S3 хранилище.
-async fn upload_to_s3(
-    s3_client: &S3Client,
-    bucket: &str,
-    key: &str,
-    body: Vec<u8>,
-    content_type: &str,
-) -> Result<String, actix_web::Error> {
-    let body_stream = ByteStream::from(body); // Преобразуем тело файла в поток байтов
-    s3_client
-        .put_object()
-        .bucket(bucket)
-        .key(key)
-        .body(body_stream)
-        .content_type(content_type)
-        .send()
-        .await
-        .map_err(|_| ErrorInternalServerError("Failed to upload file to S3"))?; // Загрузка файла в S3
-
-    Ok(key.to_string()) // Возвращаем ключ файла
-}
-
-/// Проверяет, существует ли файл в S3.
-async fn check_file_exists(
-    s3_client: &S3Client,
-    bucket: &str,
-    key: &str,
-) -> Result<bool, actix_web::Error> {
-    match s3_client.head_object().bucket(bucket).key(key).send().await {
-        Ok(_) => Ok(true), // Файл найден
-        Err(SdkError::ServiceError(service_error)) if service_error.err().is_not_found() => {
-            Ok(false) // Файл не найден
-        }
-        Err(e) => Err(ErrorInternalServerError(e.to_string())), // Ошибка при проверке
-    }
-}
-
-/// Проверяет и обновляет квоту пользователя.
-async fn check_and_update_quota(
-    redis: &mut MultiplexedConnection,
-    user_id: &str,
-    file_size: u64,
-) -> Result<(), actix_web::Error> {
-    let current_quota: u64 = redis.get(user_id).await.unwrap_or(0); // Получаем текущую квоту пользователя
-    if current_quota + file_size > MAX_QUOTA_BYTES {
-        return Err(ErrorUnauthorized("Quota exceeded")); // Квота превышена
-    }
-    redis
-        .incr(user_id, file_size)
-        .await
-        .map_err(|_| ErrorInternalServerError("Failed to update quota in Redis"))?; // Увеличиваем использованную квоту
-    Ok(())
-}
-
-/// Сохраняет имя файла в Redis для пользователя.
-async fn save_filename_in_redis(
-    redis: &mut MultiplexedConnection,
-    user_id: &str,
-    filename: &str,
-) -> Result<(), actix_web::Error> {
-    redis
-        .sadd(user_id, filename)
-        .await
-        .map_err(|_| ErrorInternalServerError("Failed to save filename in Redis"))?; // Добавляем имя файла в набор пользователя
-    Ok(())
-}
-
-/// Загружает файлы из AWS S3 в Storj S3 и сохраняет маппинг путей.
-async fn upload_files_from_aws(app_state: &AppState) -> Result<(), actix_web::Error> {
-    // Получаем список объектов из AWS S3
-    let list_objects_v2 = app_state.aws_client.list_objects_v2();
-    let list_response = list_objects_v2
-        .bucket(app_state.aws_bucket.clone())
-        .send()
-        .await
-        .map_err(|_| ErrorInternalServerError("Failed to list files from AWS S3"))?;
-
-    if let Some(objects) = list_response.contents {
-        for object in objects {
-            if let Some(key) = object.key {
-                // Получаем объект из AWS S3
-                let object_response = app_state
-                    .aws_client
-                    .get_object()
-                    .bucket(app_state.aws_bucket.clone())
-                    .key(&key)
-                    .send()
-                    .await
-                    .map_err(|_| ErrorInternalServerError("Failed to get object from AWS S3"))?;
-
-                let body = object_response
-                    .body
-                    .collect()
-                    .await
-                    .map_err(|_| ErrorInternalServerError("Failed to read object body"))?;
-                let content_type = object_response
-                    .content_type
-                    .unwrap_or_else(|| "application/octet-stream".to_string());
-
-                // Определяем новый ключ для Storj S3 (например, сохраняем в корне с тем же именем)
-                let new_key = Path::new(&key)
-                    .file_name()
-                    .and_then(|name| name.to_str())
-                    .unwrap_or(&key)
-                    .to_string();
-
-                // Загружаем объект в Storj S3
-                let storj_url = upload_to_s3(
-                    &app_state.s3_client,
-                    &app_state.s3_bucket,
-                    &new_key,
-                    body.into_bytes().to_vec(),
-                    &content_type,
-                )
-                .await?;
-
-                // Сохраняем маппинг старого пути на новый
-                app_state.save_path_mapping(&key, &new_key).await?;
-
-                println!("Uploaded {} to Storj at {}", key, storj_url);
-            }
-        }
-    }
-
-    Ok(())
-}
-
-// Структура для десериализации ответа от сервиса аутентификации
-#[derive(Deserialize)]
-struct AuthResponse {
-    data: Option<AuthData>,
-}
-
-#[derive(Deserialize)]
-struct AuthData {
-    validate_jwt_token: Option<ValidateJWTToken>,
-}
-
-#[derive(Deserialize)]
-struct ValidateJWTToken {
-    is_valid: bool,
-    claims: Option<Claims>,
-}
-
-#[derive(Deserialize)]
-struct Claims {
-    sub: Option<String>,
-}
-
-pub async fn get_id_by_token(token: &str) -> Result<String, Box<dyn Error>> {
-    let auth_api_base = env::var("AUTH_URL")?;
-    let query_name = "validate_jwt_token";
-    let operation = "ValidateToken";
-    let mut headers = HeaderMap::new();
-    headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
-
-    let mut variables = HashMap::<String, HashMap<String, String>>::new();
-    let mut params = HashMap::<String, String>::new();
-    params.insert("token".to_string(), token.to_string());
-    params.insert("token_type".to_string(), "access_token".to_string());
-    variables.insert("params".to_string(), params);
-
-    let gql = json!({
-        "query": format!("query {}($params: ValidateJWTTokenInput!) {{ {}(params: $params) {{ is_valid claims }} }}", operation, query_name),
-        "operationName": operation,
-        "variables": variables
-    });
-
-    let client = HTTPClient::new();
-    let response = client
-        .post(&auth_api_base)
-        .headers(headers)
-        .json(&gql)
-        .send()
-        .await?;
-
-    if response.status().is_success() {
-        let auth_response: AuthResponse = response.json().await?;
-        if let Some(auth_data) = auth_response.data {
-            if let Some(validate_jwt_token) = auth_data.validate_jwt_token {
-                if validate_jwt_token.is_valid {
-                    if let Some(claims) = validate_jwt_token.claims {
-                        if let Some(sub) = claims.sub {
-                            return Ok(sub);
-                        }
-                    }
-                }
-            }
-        }
-        Err(Box::new(std::io::Error::new(
-            std::io::ErrorKind::Other,
-            "Invalid token response",
-        )))
-    } else {
-        Err(Box::new(std::io::Error::new(
-            std::io::ErrorKind::Other,
-            format!("Request failed with status: {}", response.status()),
-        )))
-    }
-}
-
-/// Обработчик прокси-запросов.
-async fn proxy_handler(
-    req: HttpRequest,
-    path: web::Path<String>,
-    state: web::Data<AppState>,
-) -> Result<HttpResponse, actix_web::Error> {
-    // Получаем токен из заголовка авторизации
-    let token = req
-        .headers()
-        .get("Authorization")
-        .and_then(|header_value| header_value.to_str().ok());
-    if token.is_none() {
-        return Err(ErrorUnauthorized("Unauthorized")); // Если токен отсутствует, возвращаем ошибку
-    }
-
-    let user_id = get_id_by_token(token.unwrap()).await?;
-    let requested_path = path.into_inner(); // Полученный путь из запроса
-
-    // Проверяем, есть ли маппинг для старого пути
-    if let Some(new_path) = state.get_new_path(&requested_path).await? {
-        // Используем новый путь для доступа к файлу
-        return serve_file(&new_path, &state).await;
-    }
-
-    // Если маппинга нет, предполагаем, что путь является новым
-    serve_file(&requested_path, &state).await
-}
-
-/// Функция для обслуживания файла по заданному пути.
-async fn serve_file(file_key: &str, state: &AppState) -> Result<HttpResponse, actix_web::Error> {
-    // Проверяем наличие файла в Storj S3
-    if !check_file_exists(&state.s3_client, &state.s3_bucket, file_key).await? {
-        return Err(ErrorInternalServerError("File not found in S3"));
-    }
-
-    // Получаем объект из Storj S3
-    let get_object_output = state
-        .s3_client
-        .get_object()
-        .bucket(&state.s3_bucket)
-        .key(file_key)
-        .send()
-        .await
-        .map_err(|_| ErrorInternalServerError("Failed to get object from S3"))?;
-
-    let data = get_object_output
-        .body
-        .collect()
-        .await
-        .map_err(|_| ErrorInternalServerError("Failed to read object body"))?;
-
-    let mime_type = MimeGuess::from_path(file_key).first_or_octet_stream(); // Определяем MIME-тип файла
-
-    Ok(HttpResponse::Ok()
-        .content_type(mime_type.as_ref())
-        .body(data.into_bytes()))
-}
+use actix_web::{middleware::Logger, web, App, HttpServer};
+use app_state::AppState;
+use handlers::{proxy_handler, upload_handler};
 
 #[actix_web::main]
 async fn main() -> std::io::Result<()> {
-    // Инициализируем состояние приложения
     let app_state = AppState::new().await;
 
     let app_state_clone = app_state.clone();
     tokio::spawn(async move {
-        // Запускаем задачу обновления списка файлов в фоне
+        app_state_clone.update_filelist_from_aws().await;
         app_state_clone.refresh_file_list_periodically().await;
     });
 
-    // Загружаем файлы из AWS S3 в Storj S3 и сохраняем маппинг путей
-    upload_files_from_aws(&app_state)
-        .await
-        .expect("Failed to upload files from AWS to Storj");
-
-    // Запускаем HTTP сервер
     HttpServer::new(move || {
         App::new()
             .app_data(web::Data::new(app_state.clone()))
             .wrap(Logger::default())
-            .route("/{path:.*}", web::get().to(proxy_handler)) // Маршрутизация всех GET запросов на proxy_handler
+            .route("/{path:.*}", web::get().to(proxy_handler))
+            .route("/", web::post().to(upload_handler))
     })
     .bind("127.0.0.1:8080")?
     .run()

src/s3_utils.rs

@@ -0,0 +1,77 @@
+use std::str::FromStr;
+
+use actix_web::error::ErrorInternalServerError;
+use aws_sdk_s3::{error::SdkError, primitives::ByteStream, Client as S3Client};
+use mime_guess::mime;
+
+/// Загружает файл в S3 хранилище.
+pub async fn upload_to_s3(
+    s3_client: &S3Client,
+    bucket: &str,
+    key: &str,
+    body: Vec<u8>,
+    content_type: &str,
+) -> Result<String, actix_web::Error> {
+    let body_stream = ByteStream::from(body); // Преобразуем тело файла в поток байтов
+    s3_client
+        .put_object()
+        .bucket(bucket)
+        .key(key)
+        .body(body_stream)
+        .content_type(content_type)
+        .send()
+        .await
+        .map_err(|_| ErrorInternalServerError("Failed to upload file to S3"))?; // Загрузка файла в S3
+
+    Ok(key.to_string()) // Возвращаем ключ файла
+}
+
+/// Проверяет, существует ли файл в S3.
+pub async fn check_file_exists(
+    s3_client: &S3Client,
+    bucket: &str,
+    key: &str,
+) -> Result<bool, actix_web::Error> {
+    match s3_client.head_object().bucket(bucket).key(key).send().await {
+        Ok(_) => Ok(true), // Файл найден
+        Err(SdkError::ServiceError(service_error)) if service_error.err().is_not_found() => {
+            Ok(false) // Файл не найден
+        }
+        Err(e) => Err(ErrorInternalServerError(e.to_string())), // Ошибка при проверке
+    }
+}
+
+/// Загружает файл из S3.
+pub async fn load_file_from_s3(
+    s3_client: &S3Client,
+    bucket: &str,
+    key: &str,
+) -> Result<Vec<u8>, actix_web::Error> {
+    let get_object_output = s3_client
+        .get_object()
+        .bucket(bucket)
+        .key(key)
+        .send()
+        .await
+        .map_err(|_| ErrorInternalServerError("Failed to get object from S3"))?;
+
+    let data: aws_sdk_s3::primitives::AggregatedBytes = get_object_output
+        .body
+        .collect()
+        .await
+        .map_err(|_| ErrorInternalServerError("Failed to read object body"))?;
+
+    Ok(data.to_vec())
+}
+
+/// Генерирует ключ с правильным расширением на основе MIME-типа.
+pub fn generate_key_with_extension(base_key: String, mime_type: String) -> String {
+    let mime: mime::Mime =
+        mime::Mime::from_str(&mime_type).unwrap_or(mime::APPLICATION_OCTET_STREAM);
+    if let Some(extensions) = mime_guess::get_mime_extensions_str(mime.as_ref()) {
+        if let Some(extension) = extensions.first() {
+            return format!("{}.{}", base_key, extension);
+        }
+    }
+    base_key
+}

src/thumbnail.rs

@@ -0,0 +1,47 @@
+// thumbnail.rs
+
+use actix_web::error::ErrorInternalServerError;
+use image::{imageops::FilterType, DynamicImage};
+use std::{collections::HashMap, io::Cursor};
+
+pub const ALLOWED_THUMBNAIL_WIDTHS: [u32; 6] = [10, 40, 110, 300, 600, 800];
+
+/// Парсит запрос на миниатюру, извлекая оригинальное имя файла и требуемую ширину.
+/// Пример: "filename_150.ext" -> ("filename.ext", 150)
+pub fn parse_thumbnail_request(path: &str) -> Option<(String, u32, String)> {
+    if let Some((name_part, ext_part)) = path.rsplit_once('.') {
+        if let Some((base_name, width_str)) = name_part.rsplit_once('_') {
+            if let Ok(width) = width_str.parse::<u32>() {
+                return Some((base_name.to_string(), width, ext_part.to_string()));
+            }
+        }
+    }
+    None
+}
+
+/// Выбирает ближайший подходящий размер из предопределённых.
+pub fn find_closest_width(requested_width: u32) -> u32 {
+    *ALLOWED_THUMBNAIL_WIDTHS
+        .iter()
+        .min_by_key(|&&width| (width as i32 - requested_width as i32).abs())
+        .unwrap_or(&ALLOWED_THUMBNAIL_WIDTHS[0]) // Возвращаем самый маленький размер, если ничего не подошло
+}
+
+/// Генерирует миниатюры изображения для заданного набора ширин.
+pub async fn generate_thumbnails(
+    image: &DynamicImage,
+    widths: &[u32],
+) -> Result<HashMap<u32, Vec<u8>>, actix_web::Error> {
+    let mut thumbnails = HashMap::new();
+
+    for &width in widths {
+        let thumbnail = image.resize(width, u32::MAX, FilterType::Lanczos3); // Ресайз изображения по ширине
+        let mut buffer = Vec::new();
+        thumbnail
+            .write_to(&mut Cursor::new(&mut buffer), image::ImageFormat::Jpeg)
+            .map_err(|_| ErrorInternalServerError("Failed to generate thumbnail"))?; // Сохранение изображения в формате JPEG
+        thumbnails.insert(width, buffer);
+    }
+
+    Ok(thumbnails)
+}