raws-s3 0.0.5

RAWS s3 component
Documentation 
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
73
74
75
76
77
78
79
80
81
82

use super::*;

type S3Result<T> = Result<T, s3::Error>;

#[derive(Debug)]
pub(crate) struct S3Client {
    client: s3::Client,
}

impl S3Client {
    pub(crate) fn with_config(config: &Config) -> Self {
        let client = config.s3();
        Self { client }
    }

    pub(crate) async fn list_buckets(&self) -> S3Result<Vec<s3::types::Bucket>> {
        let buckets = self
            .client
            .list_buckets()
            .send()
            .await?
            .buckets
            .unwrap_or_default();

        Ok(buckets)
    }

    pub(crate) async fn list_all_objects(&self, bucket: &str) -> S3Result<Vec<s3::types::Object>> {
        self.list_objects_v2(bucket, Some(String::from('/')), None)
            .await
    }

    pub(crate) async fn list_objects_v2(
        &self,
        bucket: &str,
        delimiter: Option<String>,
        prefix: Option<String>,
    ) -> S3Result<Vec<s3::types::Object>> {
        let objects = self
            .client
            .list_objects_v2()
            .bucket(bucket)
            .set_delimiter(delimiter)
            .set_prefix(prefix)
            .into_paginator()
            .send()
            .try_collect()
            .await?
            .into_iter()
            .flat_map(|output| output.contents.unwrap_or_default())
            .collect::<Vec<_>>();

        Ok(objects)
    }

    pub(crate) async fn create_bucket(&self, bucket: &str) -> S3Result<Option<String>> {
        let location = self
            .client
            .create_bucket()
            .bucket(bucket)
            .send()
            .await?
            .location;

        Ok(location)
    }

    pub(crate) async fn delete_bucket(&self, bucket: &str) -> S3Result<()> {
        self.client.delete_bucket().bucket(bucket).send().await?;

        Ok(())
    }

    pub(crate) async fn remove_unversioned_objects(
        &self,
        bucket: &str,
    ) -> S3Result<s3::operation::delete_objects::DeleteObjectsOutput> {
        let output = self.client.delete_objects().bucket(bucket).send().await?;

        Ok(output)
    }
}