s3m-core 0.18.0

Reusable S3 client and streaming engine behind the s3m CLI
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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use bytes::Bytes;
use crc32c::{crc32c, crc32c_append};
use crc32fast::Hasher;
use ring::digest::{Context, SHA1_FOR_LEGACY_USE_ONLY, SHA256};

/// A trait for checksum calculation.
pub trait ChecksumHasher: Send + Sync {
    fn new() -> Self
    where
        Self: Sized;

    fn update(&mut self, bytes: &[u8]);

    fn finalize(self: Box<Self>) -> Bytes;
}

// CRC32
pub struct Crc32Hasher(Hasher);

impl ChecksumHasher for Crc32Hasher {
    fn new() -> Self {
        Self::default()
    }

    fn update(&mut self, bytes: &[u8]) {
        self.0.update(bytes);
    }

    fn finalize(self: Box<Self>) -> Bytes {
        Bytes::from(self.0.finalize().to_be_bytes().to_vec())
    }
}

impl Default for Crc32Hasher {
    fn default() -> Self {
        Self(crc32fast::Hasher::new())
    }
}

// CRC32C
pub struct Crc32cHasher(u32);

impl ChecksumHasher for Crc32cHasher {
    fn new() -> Self {
        Self::default()
    }

    fn update(&mut self, bytes: &[u8]) {
        self.0 = crc32c_append(self.0, bytes);
    }

    fn finalize(self: Box<Self>) -> Bytes {
        Bytes::from(self.0.to_be_bytes().to_vec())
    }
}

impl Default for Crc32cHasher {
    fn default() -> Self {
        Self(crc32c(&[]))
    }
}

// Md5
pub struct Md5Hasher(md5::Context);

impl ChecksumHasher for Md5Hasher {
    fn new() -> Self {
        Self::default()
    }

    fn update(&mut self, bytes: &[u8]) {
        self.0.consume(bytes);
    }

    fn finalize(self: Box<Self>) -> Bytes {
        Bytes::from(self.0.finalize().0.to_vec())
    }
}

impl Default for Md5Hasher {
    fn default() -> Self {
        Self(md5::Context::new())
    }
}

// SHA1
pub struct Sha1Hasher(Context);

impl ChecksumHasher for Sha1Hasher {
    fn new() -> Self {
        Self::default()
    }

    fn update(&mut self, bytes: &[u8]) {
        self.0.update(bytes);
    }

    fn finalize(self: Box<Self>) -> Bytes {
        Bytes::from(self.0.finish().as_ref().to_vec())
    }
}

impl Default for Sha1Hasher {
    fn default() -> Self {
        Self(Context::new(&SHA1_FOR_LEGACY_USE_ONLY))
    }
}

// SHA256
pub struct Sha256Hasher(Context);

impl ChecksumHasher for Sha256Hasher {
    fn new() -> Self {
        Self::default()
    }

    fn update(&mut self, bytes: &[u8]) {
        self.0.update(bytes);
    }

    fn finalize(self: Box<Self>) -> Bytes {
        Bytes::from(self.0.finish().as_ref().to_vec())
    }
}

impl Default for Sha256Hasher {
    fn default() -> Self {
        Self(Context::new(&SHA256))
    }
}