Switched s3 crates

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::<BaseUrl>().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<RedisConnection, ServiceError> {
   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<ResponseData, ServiceError> {
+  let response = BUCKET.put_object(path, content).await?;
+  Ok(response)
+}
+
+pub async fn delete_file(path: &str) -> Result<ResponseData, ServiceError> {
+  let response = BUCKET.delete_object(path).await?;
+  Ok(response)
 }