Feat/put object

.github/workflows/rust.yml

@@ -32,4 +32,5 @@ jobs:
           sleep 10
           aws --endpoint-url http://localhost:9090 s3 mb s3://sardo
           aws --endpoint-url http://localhost:9090 s3 ls
+          aws --endpoint-url http://localhost:9090 s3 cp ./Cargo.toml s3://sardo
 

Cargo.toml

@@ -8,7 +8,9 @@ authors = ["Sardorbek Pulatov <[email protected]>"]
 
 [dependencies]
 actix-web = "4.3"
-clap = { version = "4.2.7", features = ["derive"] }
+actix-router = "0.5"
+clap = { version = "4.2", features = ["derive"] }
+futures = "0.3"
 tracing = "0.1"
 tracing-subscriber = "0.3"
 serde = { version = "1.0", features = ["derive"] }

README.md

@@ -127,7 +127,7 @@ $ ./s3-chelak --server-url "my_custom_url" --server-port "8080" --working-folder
 | PutBucketTagging                            |        :x:         |
 | PutBucketVersioning                         |        :x:         |
 | PutBucketWebsite                            |        :x:         |
-| PutObject                                   |        :x:         |
+| PutObject                                   | :white_check_mark: |
 | PutObjectAcl                                |        :x:         |
 | PutObjectLegalHold                          |        :x:         |
 | PutObjectLockConfiguration                  |        :x:         |

src/apis/create_bucket.rs

@@ -1,4 +1,4 @@
-use actix_web::{error, put, web, Error, HttpRequest, HttpResponse};
+use actix_web::{error, put, web, Error, HttpResponse};
 use serde::{Deserialize, Serialize};
 
 #[derive(Deserialize, Serialize, Debug)]
@@ -23,12 +23,10 @@ pub struct BucketError {
     pub host_id: String,
 }
 
-#[put("/{bucket_name}")]
 pub async fn create_bucket(
-    bucket_name: web::Path<String>,
+    bucket_name: String,
     data: web::Data<crate::AppState>,
 ) -> Result<HttpResponse, Error> {
-    let bucket_name = bucket_name.into_inner();
     let working_folder = &data.working_folder;
 
     let bucket_path = format!("{}/{}", working_folder, bucket_name);

src/apis/mod.rs

@@ -1,2 +1,4 @@
-pub mod list_buckets;
 pub mod create_bucket;
+pub mod list_buckets;
+pub mod put_object;
+pub mod put_handler;

src/apis/put_handler.rs

@@ -0,0 +1,42 @@
+use actix_router::{Path, Resource, ResourceDef, Url};
+
+use crate::apis::create_bucket::create_bucket;
+use crate::apis::put_object::put_object;
+use actix_web::{put, web, Error, HttpRequest, HttpResponse};
+
+#[put("/{tail}*")]
+pub async fn handle_put(
+    _: web::Path<String>,
+    req: HttpRequest,
+    data: web::Data<crate::AppState>,
+    mut payload: Option<web::Payload>,
+) -> Result<HttpResponse, Error> {
+    let mut path = Path::new(Url::new(req.uri().clone()));
+
+    let routes = [
+        ("/{bucket}/{object_name}", "bucket and object"),
+        ("/{bucket}", "bucket"),
+    ];
+
+    for (pattern, description) in &routes {
+        if ResourceDef::new(*pattern).capture_match_info(&mut path) {
+            return match (path.get("bucket"), path.get("object_name")) {
+                (Some(bucket), Some(object_name)) if *description == "bucket and object" => {
+                    put_object(
+                        bucket.to_string(),
+                        object_name.to_string(),
+                        data,
+                        payload.unwrap(),
+                    )
+                    .await
+                }
+                (Some(bucket), None) if *description == "bucket" => {
+                    create_bucket(bucket.to_string(), data).await
+                }
+                _ => return Ok(HttpResponse::InternalServerError().finish()),
+            };
+        }
+    }
+
+    Err(actix_web::error::ErrorNotFound("Not Found"))
+}

src/apis/put_object.rs

@@ -0,0 +1,23 @@
+use actix_web::{put, web, Error, FromRequest, HttpRequest, HttpResponse};
+use futures::StreamExt;
+use std::fs::File;
+use std::io::Write;
+
+pub async fn put_object(
+    bucket_name: String,
+    object_name: String,
+    data: web::Data<crate::AppState>,
+    mut payload: web::Payload,
+) -> Result<HttpResponse, Error> {
+    let working_folder = &data.working_folder;
+
+    let filepath = format!("{}/{}/{}", working_folder, bucket_name, object_name);
+    let mut file = File::create(&filepath)?;
+
+    while let Some(bytes) = payload.next().await {
+        let data = bytes.unwrap();
+        file.write_all(&data)?;
+    }
+
+    Ok(HttpResponse::Ok().finish())
+}

src/main.rs

@@ -2,11 +2,16 @@ use std::fs;
 
 use actix_web::{middleware, web, App, HttpRequest, HttpResponse, HttpServer, Responder};
 use clap::Parser;
+use tracing::error;
+use tracing::log::warn;
 
 pub mod apis;
 pub mod utils;
 
 async fn not_found(request: HttpRequest) -> impl Responder {
+    error!("Headers {:?}.", request.headers());
+    warn!("Cannot find {}.", request.path());
+    error!("Request Body {:?}.", request);
     HttpResponse::NotFound().body(format!("Cannot find {}.", request.path()))
 }
 
@@ -38,12 +43,14 @@ async fn main() -> std::io::Result<()> {
     let server = HttpServer::new(move || {
         App::new()
             .wrap(middleware::Logger::default())
-            .service(apis::create_bucket::create_bucket)
+            .service(apis::put_handler::handle_put)
+            // .service(apis::create_bucket::create_bucket)
             .service(apis::list_buckets::list_buckets)
             .default_service(web::route().to(not_found))
             .app_data(web::Data::new(AppState {
                 working_folder: config.working_folder.clone(),
             }))
+            .wrap(middleware::Logger::default())
     });
 
     let server_url = format!("{}:{}", config.server_url, config.server_port);