bucketwarden-server 0.1.0

BucketWarden storage server runtime.
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

pub(crate) fn versioning_status_text(status: BucketVersioningStatus) -> &'static str {
    match status {
        BucketVersioningStatus::Enabled => "Enabled",
        BucketVersioningStatus::Suspended => "Suspended",
    }
}

pub(crate) fn object_etag(body: &[u8]) -> String {
    sha256_hex(body)
}

pub(crate) fn extended_request_id(request_id: &str) -> String {
    base64_encode(sha256_hex(request_id.as_bytes()).as_bytes())
}

pub(crate) fn quote_etag(etag: &str) -> String {
    format!("\"{}\"", etag.trim_matches('"'))
}

pub(crate) fn bucket_owner(bucket: &BucketState) -> String {
    if bucket.owner.is_empty() {
        "bucket-owner".to_string()
    } else {
        bucket.owner.clone()
    }
}

pub(crate) fn bucket_region(bucket: &BucketState) -> String {
    if bucket.region.is_empty() {
        DEFAULT_BUCKET_REGION.to_string()
    } else {
        bucket.region.clone()
    }
}

pub(crate) fn stored_owner(bucket: &BucketState, version: &StoredVersion) -> String {
    if version.owner.is_empty() {
        bucket_owner(bucket)
    } else {
        version.owner.clone()
    }
}

pub(crate) fn owner_acl_result(
    bucket: &str,
    key: Option<String>,
    version_id: Option<String>,
    owner: String,
) -> AclResult {
    AclResult {
        bucket: bucket.to_string(),
        key,
        version_id,
        owner: owner.clone(),
        grants: vec![AclGrant {
            grantee: owner,
            permission: "FULL_CONTROL".to_string(),
        }],
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) enum ListingEntry {
    Object(ListedObject),
    CommonPrefix(CommonPrefix),
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) enum VersionListingEntry {
    Version(ListedObjectVersion),
    DeleteMarker(ListedDeleteMarker),
}

#[derive(Clone, Debug)]
pub(crate) struct ReplicationSourceVersion {
    pub(crate) key: String,
    pub(crate) version: StoredVersion,
}

impl VersionListingEntry {
    pub(crate) fn key(&self) -> &str {
        match self {
            Self::Version(version) => &version.key,
            Self::DeleteMarker(marker) => &marker.key,
        }
    }

    pub(crate) fn version_id(&self) -> &str {
        match self {
            Self::Version(version) => &version.version_id,
            Self::DeleteMarker(marker) => &marker.version_id,
        }
    }
}