fix: file empty on mv (#54)

Author: venkat-ecov-dev

src/backends/azure.rs

@@ -328,4 +328,12 @@ impl Repository for AzureRepository {
 
         Ok(result)
     }
+    async fn copy_object(
+        &self,
+        _copy_identifier_path: String,
+        _key: String,
+        _range: Option<String>,
+    ) -> Result<(), Box<dyn APIError>> {
+        Ok(())
+    }
 }

src/backends/common.rs

@@ -82,6 +82,12 @@ pub trait Repository {
         delimiter: Option<String>,
         max_keys: NonZeroU32,
     ) -> Result<ListBucketResult, Box<dyn APIError>>;
+    async fn copy_object(
+        &self,
+        copy_identifier_path: String,
+        key: String,
+        range: Option<String>,
+    ) -> Result<(), Box<dyn APIError>>;
 }
 
 #[derive(Debug, Serialize)]

src/backends/s3.rs

@@ -617,4 +617,126 @@ impl Repository for S3Repository {
             }
         }
     }
+    async fn copy_object(
+        &self,
+        copy_identifier_path: String,
+        key: String,
+        range: Option<String>,
+    ) -> Result<(), Box<dyn APIError>> {
+        let client: S3Client;
+
+        if self.auth_method == "s3_access_key" {
+            let credentials = rusoto_credential::StaticProvider::new_minimal(
+                self.access_key_id.clone().unwrap(),
+                self.secret_access_key.clone().unwrap(),
+            );
+            client = S3Client::new_with(
+                rusoto_core::request::HttpClient::new().unwrap(),
+                credentials,
+                self.region.clone(),
+            );
+        } else if self.auth_method == "s3_ecs_task_role" {
+            let credentials = rusoto_credential::ContainerProvider::new();
+            client = S3Client::new_with(
+                rusoto_core::request::HttpClient::new().unwrap(),
+                credentials,
+                self.region.clone(),
+            );
+        } else if self.auth_method == "s3_local" {
+            let credentials = rusoto_credential::ChainProvider::new();
+            client = S3Client::new_with(
+                rusoto_core::request::HttpClient::new().unwrap(),
+                credentials,
+                self.region.clone(),
+            );
+        } else {
+            return Err(Box::new(InternalServerError {
+                message: format!("Internal Server Error"),
+            }));
+        }
+        let request = HeadObjectRequest {
+            bucket: self.bucket.clone(),
+            key: format!("{}", copy_identifier_path),
+            ..Default::default()
+        };
+
+        match client.head_object(request).await {
+            Ok(result) => {
+                let url_client = reqwest::Client::new();
+                let url: String;
+
+                if self.auth_method == "s3_local" {
+                    url = format!(
+                        "http://localhost:5050/{}/{}",
+                        self.bucket, copy_identifier_path
+                    )
+                } else {
+                    url = format!(
+                        "https://s3.{}.amazonaws.com/{}/{}",
+                        self.region.name(),
+                        self.bucket,
+                        copy_identifier_path
+                    );
+                }
+
+                let mut request = url_client.get(url);
+
+                if let Some(range_value) = range {
+                    request = request.header(RANGE, range_value);
+                }
+
+                match request.send().await {
+                    Ok(response) => {
+                        let content_bytes = response
+                            .bytes()
+                            .await
+                            .unwrap_or_else(|_| bytes::Bytes::from(vec![]));
+                        match self
+                            .put_object(key.clone(), content_bytes, result.content_type)
+                            .await
+                        {
+                            Ok(_put_res) => Ok(()),
+                            Err(err) => {
+                                return Err(err);
+                            }
+                        }
+                    }
+                    Err(error) => {
+                        if error.is_status() {
+                            let code = error.status().unwrap().as_u16();
+                            if code == 404 {
+                                return Err(Box::new(ObjectNotFoundError {
+                                    account_id: self.account_id.clone(),
+                                    repository_id: self.repository_id.clone(),
+                                    key,
+                                }));
+                            }
+                        }
+
+                        return Err(Box::new(InternalServerError {
+                            message: "Internal Server Error".to_string(),
+                        }));
+                    }
+                }
+            }
+            Err(error) => {
+                match error {
+                    RusotoError::Unknown(response) => {
+                        if response.status.eq(&404) {
+                            return Err(Box::new(ObjectNotFoundError {
+                                account_id: self.account_id.clone(),
+                                repository_id: self.repository_id.clone(),
+                                key,
+                            }));
+                        }
+                    }
+                    _ => (),
+                }
+
+                Err(Box::new(InternalServerError {
+                    message: format!("Internal Server Error"),
+                }))
+            }
+        }
+    }
 }

src/main.rs

@@ -259,21 +259,36 @@ async fn put_object(
         }
 
         if params.part_number.is_none() && params.upload_id.is_none() {
-            // Found the repository, now try to upload the object
-            match client
-                .put_object(
-                    key.clone(),
-                    bytes,
-                    headers
-                        .get(CONTENT_TYPE)
-                        .and_then(|h| h.to_str().ok())
-                        .map(|s| s.to_string()),
-                )
-                .await
-            {
-                Ok(_) => HttpResponse::NoContent().finish(),
-
-                Err(_) => HttpResponse::NotFound().finish(),
+            // Check if this is a server-side copy operation
+            if let Some(header_copy_identifier) = req.headers().get("x-amz-copy-source") {
+                let copy_identifier_path = header_copy_identifier.to_str().unwrap_or("");
+                match client
+                    .copy_object((&copy_identifier_path).to_string(), key.clone(), None)
+                    .await
+                {
+                    Ok(_) => HttpResponse::NoContent().finish(),
+                    Err(_) => {
+                        return HttpResponse::InternalServerError()
+                            .body("Failed to store copied object")
+                    }
+                }
+            } else {
+                // Found the repository, now try to upload the object
+                match client
+                    .put_object(
+                        key.clone(),
+                        bytes,
+                        headers
+                            .get(CONTENT_TYPE)
+                            .and_then(|h| h.to_str().ok())
+                            .map(|s| s.to_string()),
+                    )
+                    .await
+                {
+                    Ok(_) => HttpResponse::NoContent().finish(),
+
+                    Err(_) => HttpResponse::NotFound().finish(),
+                }
             }
         } else if params.part_number.is_some() && params.upload_id.is_some() {
             match client

src/utils/apache_logger.rs

@@ -0,0 +1,91 @@
+use actix_web::dev::{Service, ServiceRequest, ServiceResponse, Transform};
+use actix_web::{Error, HttpMessage};
+use chrono::Local;
+use futures::future::{ok, Ready};
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use crate::utils::auth::UserIdentity;
+
+/// Public struct to enable the middleware in your app
+pub struct ApacheLogger;
+
+impl<S, B> Transform<S, ServiceRequest> for ApacheLogger
+where
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static,
+    B: 'static,
+{
+    type Response = ServiceResponse<B>;
+    type Error = Error;
+    type Transform = ApacheLoggerMiddleware<S>;
+    type InitError = ();
+    type Future = Ready<Result<Self::Transform, Self::InitError>>;
+
+    fn new_transform(&self, service: S) -> Self::Future {
+        ok(ApacheLoggerMiddleware { service })
+    }
+}
+
+/// Middleware implementation that handles request logging in Apache log format
+pub struct ApacheLoggerMiddleware<S> {
+    pub service: S, // Make the field public if you need access to it
+}
+
+impl<S, B> Service<ServiceRequest> for ApacheLoggerMiddleware<S>
+where
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static,
+    B: 'static,
+{
+    type Response = ServiceResponse<B>;
+    type Error = Error;
+    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + 'static>>;
+
+    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.service.poll_ready(cx)
+    }
+
+    fn call(&self, req: ServiceRequest) -> Self::Future {
+        // Capture the start time
+        let start_time = Local::now();
+        let user_identity = req
+            .extensions_mut()
+            .get_mut::<UserIdentity>()
+            .map(|identity| identity.clone()) // If the value exists, clone it
+            .unwrap_or(UserIdentity { api_key: None }); // Otherwise, provide a default value
+
+        let fut = self.service.call(req);
+
+        Box::pin(async move {
+            // Format the time in Apache style: 10/Oct/2000:13:55:36 -0700
+            let formatted_time = start_time.format("%d/%b/%Y:%H:%M:%S %z").to_string();
+
+            let res = fut.await?;
+            let method = res.request().method().clone();
+            let path = res.request().uri().clone();
+            let status = res.response().status();
+
+            let client_ip = res
+                .request()
+                .connection_info()
+                .realip_remote_addr()
+                .unwrap_or("-")
+                .to_string();
+
+            println!(
+                "{} - {} [{}] \"{} {} HTTP/1.1\" {} 0",
+                client_ip,
+                match &user_identity.api_key {
+                    Some(api_key) => api_key.account_id.clone(), // Safely access account_id
+                    None => "default_account_id".to_string(),
+                },
+                formatted_time,
+                method,
+                path,
+                status.as_u16()
+            );
+
+            Ok(res)
+        })
+    }
+}