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

use super::*;

pub(crate) fn website_object_response(
    result: &WebsiteObjectResult,
    head_only: bool,
) -> S3HttpResponse {
    let body = if head_only {
        Vec::new()
    } else {
        result.body.clone()
    };
    S3HttpResponse::new(result.status)
        .with_header("content-type", result.content_type.clone())
        .with_header("content-length", result.body.len().to_string())
        .with_header("x-bucketwarden-website-key", result.resolved_key.clone())
        .with_body(body)
}
pub(crate) fn acl_xml(result: &AclResult) -> String {
    let policy = AccessControlPolicy {
        owner: AccessControlOwner {
            id: result.owner.clone(),
            display_name: result.owner.clone(),
        },
        access_control_list: result.grants.clone(),
    };
    let grants = policy
        .access_control_list
        .iter()
        .map(|grant| {
            format!(
                "<Grant><Grantee><ID>{}</ID><DisplayName>{}</DisplayName></Grantee><Permission>{}</Permission></Grant>",
                xml_escape(&grant.grantee),
                xml_escape(&grant.grantee),
                xml_escape(&grant.permission)
            )
        })
        .collect::<String>();
    format!(
        "<AccessControlPolicy><Owner><ID>{}</ID><DisplayName>{}</DisplayName></Owner><AccessControlList>{grants}</AccessControlList></AccessControlPolicy>",
        xml_escape(&policy.owner.id),
        xml_escape(&policy.owner.display_name)
    )
}
pub(crate) fn bucket_ownership_controls_xml(result: &BucketOwnershipControls) -> String {
    format!(
        "<OwnershipControls><Rule><ObjectOwnership>{}</ObjectOwnership></Rule></OwnershipControls>",
        xml_escape(&result.object_ownership)
    )
}
pub(crate) fn bucket_object_lock_configuration_xml(
    result: &BucketObjectLockConfiguration,
) -> String {
    let default_retention = result
        .default_retention
        .as_ref()
        .map(|retention| {
            let days = retention
                .days
                .map(|value| format!("<Days>{value}</Days>"))
                .unwrap_or_default();
            let years = retention
                .years
                .map(|value| format!("<Years>{value}</Years>"))
                .unwrap_or_default();
            format!(
                "<Rule><DefaultRetention><Mode>{}</Mode>{days}{years}</DefaultRetention></Rule>",
                xml_escape(&retention.mode)
            )
        })
        .unwrap_or_default();
    let enabled = if result.enabled {
        "Enabled"
    } else {
        "Disabled"
    };
    format!(
        "<ObjectLockConfiguration><ObjectLockEnabled>{enabled}</ObjectLockEnabled>{default_retention}</ObjectLockConfiguration>"
    )
}
pub(crate) fn bucket_encryption_configuration_xml(
    result: &BucketEncryptionConfiguration,
) -> String {
    let kms_key_id = result
        .default_encryption
        .kms_key_id
        .as_ref()
        .map(|value| format!("<KMSMasterKeyID>{}</KMSMasterKeyID>", xml_escape(value)))
        .unwrap_or_default();
    format!(
        "<ServerSideEncryptionConfiguration><Rule><ApplyServerSideEncryptionByDefault><SSEAlgorithm>{}</SSEAlgorithm>{kms_key_id}</ApplyServerSideEncryptionByDefault></Rule></ServerSideEncryptionConfiguration>",
        xml_escape(&result.default_encryption.algorithm)
    )
}