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
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
131
132
133
134

use super::*;

#[test]
fn runtime_inventory_query_resumes_from_continuation_token() {
    let mut runtime = runtime();
    runtime.set_clock_epoch_seconds(169);
    runtime.create_local_user("root");
    runtime
        .assign_operator_role("root", "root", OperatorRole::ClusterAdmin, "*")
        .expect("cluster admin");
    let alice_tenant = runtime.principal_tenant_id("alice");
    runtime
        .create_bucket("alice", "archive-001")
        .expect("alice bucket");

    for (key, body) in [
        ("records/a.json", br#"{"v":1}"#.as_slice()),
        ("records/b.json", br#"{"v":2}"#.as_slice()),
        ("records/c.json", br#"{"v":3}"#.as_slice()),
    ] {
        runtime
            .put_object(
                "alice",
                PutObjectRequest {
                    bucket: "archive-001".to_string(),
                    key: key.to_string(),
                    body: body.to_vec(),
                    metadata: ObjectMetadata::default(),
                },
                ObjectLock::none(),
            )
            .expect("put runtime object");
    }

    let first_page = runtime
        .runtime_inventory_query(
            "root",
            RuntimeInventoryRequest {
                tenant_prefix: Some(alice_tenant.clone()),
                bucket_prefix: Some("archive-".to_string()),
                key_prefix: Some("records/".to_string()),
                include_delete_markers: false,
                include_noncurrent_versions: true,
                max_entries: Some(2),
                continuation_token: None,
            },
        )
        .expect("first page");
    let continuation_token = first_page
        .next_continuation_token
        .clone()
        .expect("continuation token");
    assert_eq!(first_page.returned_count, 2);
    assert!(first_page.truncated);

    let second_page = runtime
        .runtime_inventory_query(
            "root",
            RuntimeInventoryRequest {
                tenant_prefix: Some(alice_tenant),
                bucket_prefix: Some("archive-".to_string()),
                key_prefix: Some("records/".to_string()),
                include_delete_markers: false,
                include_noncurrent_versions: true,
                max_entries: Some(2),
                continuation_token: Some(continuation_token),
            },
        )
        .expect("second page");

    assert_eq!(second_page.returned_count, 1);
    assert!(!second_page.truncated);
    assert_eq!(second_page.next_continuation_token, None);

    let first_keys = first_page
        .entries
        .iter()
        .map(|entry| entry.key.as_str())
        .collect::<Vec<_>>();
    let second_keys = second_page
        .entries
        .iter()
        .map(|entry| entry.key.as_str())
        .collect::<Vec<_>>();
    assert_eq!(first_keys, vec!["records/a.json", "records/b.json"]);
    assert_eq!(second_keys, vec!["records/c.json"]);
}

#[test]
fn runtime_inventory_query_rejects_unknown_continuation_token() {
    let mut runtime = runtime();
    runtime.create_local_user("root");
    runtime
        .assign_operator_role("root", "root", OperatorRole::ClusterAdmin, "*")
        .expect("cluster admin");
    runtime
        .create_bucket("alice", "archive-001")
        .expect("alice bucket");
    runtime
        .put_object(
            "alice",
            PutObjectRequest {
                bucket: "archive-001".to_string(),
                key: "records/a.json".to_string(),
                body: br#"{"v":1}"#.to_vec(),
                metadata: ObjectMetadata::default(),
            },
            ObjectLock::none(),
        )
        .expect("put runtime object");

    let error = runtime
        .runtime_inventory_query(
            "root",
            RuntimeInventoryRequest {
                tenant_prefix: None,
                bucket_prefix: Some("archive-".to_string()),
                key_prefix: Some("records/".to_string()),
                include_delete_markers: false,
                include_noncurrent_versions: true,
                max_entries: Some(1),
                continuation_token: Some(
                    r#"{"tenant_id":"tenant-missing","bucket":"archive-001","key":"records/a.json","version_id":"v999"}"#
                        .to_string(),
                ),
            },
        )
        .expect_err("invalid token");

    assert!(matches!(
        error,
        RuntimeError::InvalidListParameter { ref name, .. } if name == "continuation-token"
    ));
}