Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

8.6 KB
Raw Blame
use anyhow::{Context, Result};
use aws_sdk_s3::{self, presigning::PresigningConfig};
use std::time::Duration;

#[derive(Debug)]
pub struct S3Client {
    inner: aws_sdk_s3::Client,
    storage_bucket: String,
}

impl S3Client {
    pub fn new(inner: aws_sdk_s3::Client, storage_bucket: String) -> Self {
        S3Client {
            inner,
            storage_bucket,
        }
    }

    #[tracing::instrument(skip(self))]
    pub async fn put_presigned_url(
        &self,
        key: String,
        content_type: String,
        content_length: Option<u64>,
    ) -> Result<String> {
        let duration = Duration::from_secs(2 * 60);
        let content_length = content_length
            .map(i64::try_from)
            .transpose()
            .context("content length is out of range")?;
        let presigned_url = self
            .inner
            .put_object()
            .key(key)
            .content_type(content_type)
            .set_content_length(content_length)
            .bucket(self.storage_bucket.clone())
            .presigned(PresigningConfig::expires_in(duration)?)
            .await
            .context("failed to create presigned url")?;

        Ok(macro_aws_config::transform_aws_url(presigned_url.uri()))
    }

    #[tracing::instrument(skip(self))]
    pub async fn hard_delete_object(&self, key: String) -> Result<()> {
        self.inner
            .delete_object()
            .key(key)
            .bucket(self.storage_bucket.clone())
            .send()
            .await
            .context("failed to delete object")?;
        Ok(())
    }

    #[tracing::instrument(skip(self))]
    pub async fn get_presigned_url(&self, key: String) -> Result<String> {
        let presigned_url = self
            .inner
            .get_object()
            .bucket(self.storage_bucket.clone())
            .key(key)
            .presigned(
                aws_sdk_s3::presigning::PresigningConfig::expires_in(
                    std::time::Duration::from_secs(3600), // 1 hour
                )
                .context("failed to create presigning config")?,
            )
            .await
            .context("failed to create presigned URL")?;

        Ok(macro_aws_config::transform_aws_url(presigned_url.uri()))
    }

    #[tracing::instrument(skip(self), err)]
    pub async fn delete_objects_by_prefix(&self, prefix: &str) -> Result<()> {
        let mut continuation_token: Option<String> = None;

        loop {
            let mut req = self
                .inner
                .list_objects_v2()
                .bucket(&self.storage_bucket)
                .prefix(prefix);

            if let Some(token) = &continuation_token {
                req = req.continuation_token(token);
            }

            let response = req.send().await.context("failed to list objects")?;
            let keys: Vec<String> = response
                .contents()
                .iter()
                .filter_map(|obj| obj.key().map(String::from))
                .collect();

            if !keys.is_empty() {
                self.bulk_hard_delete_objects(keys).await;
            }

            match response.next_continuation_token() {
                Some(token) => continuation_token = Some(token.to_string()),
                None => break,
            }
        }

        Ok(())
    }

    #[tracing::instrument(skip(self), fields(count = keys.len()))]
    pub async fn bulk_hard_delete_objects(&self, keys: Vec<String>) -> Vec<Result<()>> {
        if keys.is_empty() {
            return Vec::new();
        }

        // S3 delete_objects has a limit of 1000 keys per request
        let chunk_size = 1000;
        let mut all_results = Vec::with_capacity(keys.len());

        for chunk in keys.chunks(chunk_size) {
            let mut object_identifiers = Vec::new();
            for key in chunk {
                object_identifiers.push(
                    aws_sdk_s3::types::ObjectIdentifier::builder()
                        .key(key.clone())
                        .build()
                        .expect("failed to build ObjectIdentifier"),
                );
            }

            let delete_request = aws_sdk_s3::types::Delete::builder()
                .set_objects(Some(object_identifiers))
                .build()
                .context("failed to build Delete request");

            match delete_request {
                Ok(delete_req) => {
                    match self
                        .inner
                        .delete_objects()
                        .bucket(self.storage_bucket.clone())
                        .delete(delete_req)
                        .send()
                        .await
                    {
                        Ok(output) => {
                            // Build a map of error keys to their error messages
                            let errors = output.errors();
                            let error_map: std::collections::HashMap<&str, String> = errors
                                .iter()
                                .filter_map(|e| {
                                    e.key().map(|key| {
                                        let msg =
                                            e.message().unwrap_or("unknown error").to_string();
                                        (key, msg)
                                    })
                                })
                                .collect();

                            // Log errors
                            for error in errors {
                                if let Some(key) = error.key() {
                                    tracing::warn!(
                                        key = key,
                                        error = ?error,
                                        "failed to delete object from S3"
                                    );
                                }
                            }

                            // Add results in the same order as the input keys
                            for key in chunk {
                                if let Some(error_msg) = error_map.get(key.as_str()) {
                                    all_results.push(Err(anyhow::anyhow!(
                                        "failed to delete {}: {}",
                                        key,
                                        error_msg
                                    )));
                                } else {
                                    all_results.push(Ok(()));
                                }
                            }
                        }
                        Err(e) => {
                            tracing::error!(error = ?e, "failed to delete batch of objects from S3");
                            // Add error for each key in this chunk
                            for _ in chunk {
                                all_results
                                    .push(Err(anyhow::anyhow!("batch delete failed: {}", e)));
                            }
                        }
                    }
                }
                Err(e) => {
                    let err_msg = e.to_string();
                    tracing::error!(error = ?e, "failed to build delete request");
                    for _ in chunk {
                        all_results.push(Err(anyhow::anyhow!(
                            "failed to build delete request: {}",
                            err_msg
                        )));
                    }
                }
            }
        }

        all_results
    }
}

#[cfg(test)]
mod test {
    use aws_sdk_s3::config::{BehaviorVersion, Credentials, Region};

    use super::*;

    fn client() -> S3Client {
        let config = aws_sdk_s3::Config::builder()
            .behavior_version(BehaviorVersion::latest())
            .region(Region::new("us-east-1"))
            .credentials_provider(Credentials::new("id", "secret", None, None, "test"))
            .build();
        S3Client::new(aws_sdk_s3::Client::from_conf(config), "bucket".to_string())
    }

    #[tokio::test]
    async fn a_declared_length_is_signed_so_storage_rejects_other_sizes() {
        let url = client()
            .put_presigned_url("key".to_string(), "image/png".to_string(), Some(5))
            .await
            .unwrap();

        assert!(
            url.to_lowercase()
                .contains("x-amz-signedheaders=content-length"),
            "{url}"
        );
    }

    #[tokio::test]
    async fn no_declared_length_leaves_the_size_unsigned() {
        let url = client()
            .put_presigned_url("key".to_string(), "image/png".to_string(), None)
            .await
            .unwrap();

        assert!(!url.to_lowercase().contains("content-length"), "{url}");
    }
}