sulfite-tools 0.0.6

A high-level S3 client built on AWS SDK for Rust for bandwidth saturation (CLI tools)
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

use anyhow::Context;
use sulfite::S3Client;

use crate::ObjCommand;

pub async fn run_obj(client: S3Client, command: ObjCommand) -> anyhow::Result<()> {
    match command {
        ObjCommand::Head(a) => {
            let obj = client.head_object(&a.bucket, &a.key).await?;
            println!("{:?}", obj);
        }
        ObjCommand::Download(a) => {
            let local_path = match &a.local_path {
                Some(p) => p.as_str(),
                None => std::path::Path::new(&a.key)
                    .file_name()
                    .and_then(|os_str| os_str.to_str())
                    .context("key has no file name")?,
            };
            let start_end_offsets = a.start_offset.zip(a.end_offset);
            client
                .download_object(&a.bucket, &a.key, local_path, start_end_offsets)
                .await?;
        }
        ObjCommand::DownloadMultipart(a) => {
            let local_path = match &a.local_path {
                Some(p) => p.as_str(),
                None => std::path::Path::new(&a.key)
                    .file_name()
                    .and_then(|os_str| os_str.to_str())
                    .context("key has no file name")?,
            };
            client
                .download_object_multipart(&a.bucket, &a.key, local_path, Some(a.n_workers))
                .await?;
        }
        ObjCommand::Upload(a) => {
            client
                .upload_object(&a.bucket, &a.key, &a.local_path, a.storage_class.as_deref())
                .await?;
        }
        ObjCommand::UploadMultipart(a) => {
            client
                .upload_object_multipart(
                    &a.bucket,
                    &a.key,
                    &a.local_path,
                    Some(a.n_workers),
                    a.storage_class.as_deref(),
                )
                .await?;
        }
        ObjCommand::Delete(a) => {
            client.delete_object(&a.bucket, &a.key).await?;
        }
        ObjCommand::Copy(a) => {
            client
                .copy_object(
                    &a.src_bucket,
                    &a.src_key,
                    &a.dst_bucket,
                    &a.dst_key,
                    a.storage_class.as_deref(),
                )
                .await?;
        }
        ObjCommand::Restore(a) => {
            client
                .restore_object(&a.bucket, &a.key, a.restore_days, &a.restore_tier)
                .await?;
        }
    }

    Ok(())
}