1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

use async_trait::async_trait;
use rusoto_core::RusotoError;
use rusoto_s3::{
    CreateBucketError, CreateBucketOutput, CreateBucketRequest, DeleteBucketError,
    DeleteBucketRequest, HeadBucketError, HeadBucketRequest, ListBucketsError, ListBucketsOutput,
    S3Client, S3,
};

#[async_trait]
pub trait Bucket: S3 {
    async fn create_s3_bucket(
        &self,
        bucket_name: String,
        bucket_req: Option<CreateBucketRequest>,
    ) -> Result<CreateBucketOutput, RusotoError<CreateBucketError>>;

    async fn drop_s3_bucket(
        &self,
        bucket_name: String,
    ) -> Result<(), RusotoError<DeleteBucketError>>;

    async fn has_s3_bucket(&self, bucket_name: String) -> Result<(), RusotoError<HeadBucketError>>;

    async fn show_s3_buckets(&self) -> Result<ListBucketsOutput, RusotoError<ListBucketsError>>;
}

#[async_trait]
impl Bucket for S3Client {
    async fn create_s3_bucket(
        &self,
        bucket_name: String,
        bucket_req: Option<CreateBucketRequest>,
    ) -> Result<CreateBucketOutput, RusotoError<CreateBucketError>> {
        if let Some(mut req) = bucket_req {
            if !bucket_name.is_empty() {
                req.bucket = bucket_name;
            }

            self.create_bucket(req).await
        } else {
            let create_bucket_req = CreateBucketRequest {
                bucket: bucket_name,
                ..Default::default()
            };

            self.create_bucket(create_bucket_req).await
        }
    }

    async fn drop_s3_bucket(
        &self,
        bucket_name: String,
    ) -> Result<(), RusotoError<DeleteBucketError>> {
        let delete_bucket_req = DeleteBucketRequest {
            bucket: bucket_name,
        };

        self.delete_bucket(delete_bucket_req).await
    }

    async fn has_s3_bucket(&self, bucket_name: String) -> Result<(), RusotoError<HeadBucketError>> {
        let delete_bucket_req = HeadBucketRequest {
            bucket: bucket_name,
        };

        self.head_bucket(delete_bucket_req).await
    }

    async fn show_s3_buckets(&self) -> Result<ListBucketsOutput, RusotoError<ListBucketsError>> {
        self.list_buckets().await
    }
}