diff --git a/service/Cargo.toml b/service/Cargo.toml index 36385a4..8a4eedb 100644 --- a/service/Cargo.toml +++ b/service/Cargo.toml @@ -29,7 +29,6 @@ jsonwebtoken = "9.0.0" redis = { version = "0.23.3", features = ["tokio-comp", "connection-manager", "r2d2"] } base64 = "0.21.4" rust-s3 = "0.33.0" -minio = "0.1.0" [dependencies.tokio] version = "1.32.0" diff --git a/service/src/lib.rs b/service/src/lib.rs index 9f87271..02f2ecb 100644 --- a/service/src/lib.rs +++ b/service/src/lib.rs @@ -124,12 +124,6 @@ impl From for ServiceError { } } -impl From for ServiceError { - fn from(error: minio::s3::error::Error) -> ServiceError { - ServiceError::new(500, format!("Unknown minio error: {}", error)) - } -} - impl ResponseError for ServiceError { fn error_response(&self) -> HttpResponse { let status_code = match StatusCode::from_u16(self.status) { diff --git a/service/src/main.rs b/service/src/main.rs index d114881..492d25f 100644 --- a/service/src/main.rs +++ b/service/src/main.rs @@ -27,7 +27,7 @@ mod storage; async fn main() -> std::io::Result<()> { dotenv().ok(); env_logger::init_from_env(env_logger::Env::default().filter_or("RUST_LOG", "warn,siren=info")); - storage::init(); + storage::init().await; match env::var("DATA_DIR_PATH") { Ok(data_dir_path) => dnd::load_data(&data_dir_path), Err(err) => warn!("Unable to load initial database data: {}", err) @@ -111,10 +111,8 @@ async fn main() -> std::io::Result<()> { let host = env::var("SERVICE_HOST").unwrap_or("localhost".to_string()); let port = env::var("SERVICE_PORT").unwrap_or("5000".to_string()); - match crate::storage::create_bucket("siren").await { - Ok(_) => {}, - Err(err) => {} - }; + crate::storage::upload_file("test.txt", b"Test").await.unwrap(); + crate::storage::delete_file("test.txt").await.unwrap(); let server = match HttpServer::new(move || { let cors = Cors::default() diff --git a/service/src/storage/mod.rs b/service/src/storage/mod.rs index 6205dc2..619978f 100644 --- a/service/src/storage/mod.rs +++ b/service/src/storage/mod.rs @@ -1,10 +1,10 @@ use diesel::{r2d2::ConnectionManager as DieselConnectionManager, PgConnection}; -use minio::s3::{client::Client as MinioClient, http::BaseUrl, creds::StaticProvider, args::{MakeBucketArgs, BucketExistsArgs}}; use redis::{Client as RedisClient, aio::Connection as RedisConnection}; +use s3::{Region, creds::Credentials, Bucket, BucketConfiguration, request::ResponseData}; use siren::ServiceError; use crate::diesel_migrations::MigrationHarness; use lazy_static::lazy_static; -use log::{error, info}; +use log::{error, info, warn}; use r2d2; use std::env; @@ -34,33 +34,35 @@ lazy_static! { let url = format!("redis://{}:{}", host, port); RedisClient::open(url).expect("Failed to create redis client") }; - static ref MINIO: MinioClient = { + static ref BUCKET: Bucket = { let url = env::var("MINIO_URL").unwrap_or("localhost".to_string()); let port = env::var("MINIO_PORT").unwrap_or("9000".to_string()); - let base_url = format!("http://{}:{}", url, port).parse::().unwrap(); - let user = env::var("MINIO_ROOT_USER").expect("MINIO_ROOT_USER is not set"); let password = env::var("MINIO_ROOT_PASSWORD").expect("MINIO_ROOT_PASSWORD is not set"); - - let static_provider = StaticProvider::new( - &user, - &password, - None - ); - - MinioClient::new( - base_url, - Some(Box::new(static_provider)), - None, - None - ).expect("Failed to create minio client") + let base_url = format!("http://{}:{}", url, port); + + let region = Region::Custom { + region: "".to_string(), + endpoint: base_url, + }; + + let credentials = Credentials { + access_key: Some(user), + secret_key: Some(password), + security_token: None, + session_token: None, + expiration: None + }; + + Bucket::new("siren", region.clone(), credentials.clone()).expect("Failed to create S3 Bucket").with_path_style() }; } -pub fn init() { +pub async fn init() { lazy_static::initialize(&POOL); lazy_static::initialize(&REDIS); - lazy_static::initialize(&MINIO); + lazy_static::initialize(&BUCKET); + create_bucket().await; let mut pool: DbConnection = connection().expect("Failed to get db connection"); match pool.run_pending_migrations(MIGRATIONS) { Ok(_) => info!("Database initialized"), @@ -83,11 +85,34 @@ pub async fn redis_async_connection() -> Result { Ok(conn) } -pub async fn create_bucket(bucket_name: &str) -> Result<(), ServiceError> { - let exists = MINIO.bucket_exists(&BucketExistsArgs::new(&bucket_name).unwrap()).await?; - if !exists { - MINIO.make_bucket(&MakeBucketArgs::new(&bucket_name).unwrap()).await?; - } +async fn create_bucket() { + let url = env::var("MINIO_URL").unwrap_or("localhost".to_string()); + let port = env::var("MINIO_PORT").unwrap_or("9000".to_string()); + let user = env::var("MINIO_ROOT_USER").expect("MINIO_ROOT_USER is not set"); + let password = env::var("MINIO_ROOT_PASSWORD").expect("MINIO_ROOT_PASSWORD is not set"); + let base_url = format!("http://{}:{}", url, port); - Ok(()) + let region = Region::Custom { + region: "".to_string(), + endpoint: base_url, + }; + + let credentials = Credentials { + access_key: Some(user), + secret_key: Some(password), + security_token: None, + session_token: None, + expiration: None + }; + let _ = Bucket::create_with_path_style("siren", region, credentials, BucketConfiguration::default()).await; +} + +pub async fn upload_file(path: &str, content: &[u8]) -> Result { + let response = BUCKET.put_object(path, content).await?; + Ok(response) +} + +pub async fn delete_file(path: &str) -> Result { + let response = BUCKET.delete_object(path).await?; + Ok(response) } diff --git a/ui/src/api/auth.ts b/ui/src/api/auth.ts index f757fd6..89a31ca 100644 --- a/ui/src/api/auth.ts +++ b/ui/src/api/auth.ts @@ -54,10 +54,8 @@ export function refreshLoggedIn(interval = 840000) { if (cookie != loggedIn) { loggedIn = cookie; const response = await refresh(true); - if (response) { - Cookies.set('logged_in', 'true'); - } else { - Cookies.set('test', 'failed'); + if (!response) { + Cookies.remove('logged_in'); } } }, interval);