Skip to main content

rustfs_lifecycle/
object_lock.rs

1// Copyright 2024 RustFS Team
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15use std::collections::HashMap;
16
17use rustfs_storage_api::metadata_keys;
18use s3s::dto::{ObjectLockConfiguration, ObjectLockRetentionMode};
19use time::{OffsetDateTime, format_description};
20
21pub fn is_object_locked_by_metadata(user_defined: &HashMap<String, String>, is_delete_marker: bool) -> bool {
22    if is_delete_marker {
23        return false;
24    }
25
26    if user_defined
27        .get(metadata_keys::OBJECT_LOCK_LEGAL_HOLD)
28        .is_some_and(|value| value.eq_ignore_ascii_case("ON"))
29    {
30        return true;
31    }
32
33    let Some(mode) = user_defined.get(metadata_keys::OBJECT_LOCK_MODE) else {
34        return false;
35    };
36    if !is_retention_mode(mode) {
37        return false;
38    }
39
40    user_defined
41        .get(metadata_keys::OBJECT_LOCK_RETAIN_UNTIL_DATE)
42        .and_then(|value| OffsetDateTime::parse(value, &format_description::well_known::Iso8601::DEFAULT).ok())
43        .is_some_and(|retain_until| retain_until.unix_timestamp() > OffsetDateTime::now_utc().unix_timestamp())
44}
45
46/// Check persisted object-lock metadata and the bucket default retention.
47///
48/// A configured default retention with missing or malformed input is treated
49/// as locked so a lifecycle worker cannot turn incomplete metadata into an
50/// unsafe delete.
51pub fn is_object_locked(
52    user_defined: &HashMap<String, String>,
53    is_delete_marker: bool,
54    config: Option<&ObjectLockConfiguration>,
55    mod_time: Option<OffsetDateTime>,
56) -> bool {
57    if is_delete_marker {
58        return false;
59    }
60    if is_object_locked_by_metadata(user_defined, false) {
61        return true;
62    }
63    if has_explicit_lock_metadata(user_defined) {
64        return !explicit_lock_metadata_is_well_formed(user_defined);
65    }
66
67    let Some(default_retention) = config.and_then(|config| config.rule.as_ref()?.default_retention.as_ref()) else {
68        return false;
69    };
70    let Some(mode) = default_retention.mode.as_ref() else {
71        return true;
72    };
73    if !is_retention_mode(mode.as_str()) {
74        return true;
75    }
76
77    let Some(mod_time) = mod_time else {
78        return true;
79    };
80    let Some(retain_until) = default_retention_until(mod_time, default_retention) else {
81        return true;
82    };
83
84    retain_until.unix_timestamp() > OffsetDateTime::now_utc().unix_timestamp()
85}
86
87fn has_explicit_lock_metadata(user_defined: &HashMap<String, String>) -> bool {
88    user_defined.contains_key(metadata_keys::OBJECT_LOCK_LEGAL_HOLD)
89        || user_defined.contains_key(metadata_keys::OBJECT_LOCK_MODE)
90        || user_defined.contains_key(metadata_keys::OBJECT_LOCK_RETAIN_UNTIL_DATE)
91}
92
93fn explicit_lock_metadata_is_well_formed(user_defined: &HashMap<String, String>) -> bool {
94    if user_defined
95        .get(metadata_keys::OBJECT_LOCK_LEGAL_HOLD)
96        .is_some_and(|value| !value.eq_ignore_ascii_case("ON") && !value.eq_ignore_ascii_case("OFF"))
97    {
98        return false;
99    }
100
101    match (
102        user_defined.get(metadata_keys::OBJECT_LOCK_MODE),
103        user_defined.get(metadata_keys::OBJECT_LOCK_RETAIN_UNTIL_DATE),
104    ) {
105        (None, None) => true,
106        (Some(mode), Some(retain_until)) => {
107            is_retention_mode(mode)
108                && OffsetDateTime::parse(retain_until, &format_description::well_known::Iso8601::DEFAULT).is_ok()
109        }
110        _ => false,
111    }
112}
113
114fn default_retention_until(mod_time: OffsetDateTime, retention: &s3s::dto::DefaultRetention) -> Option<OffsetDateTime> {
115    match (retention.days, retention.years) {
116        (Some(days), None) if days > 0 => Some(mod_time.saturating_add(time::Duration::days(i64::from(days)))),
117        (None, Some(years)) if years > 0 => add_years(mod_time, years),
118        _ => None,
119    }
120}
121
122fn add_years(mod_time: OffsetDateTime, years: i32) -> Option<OffsetDateTime> {
123    let target_year = mod_time.year().checked_add(years)?;
124    mod_time
125        .replace_year(target_year)
126        .or_else(|_| mod_time.replace_day(28).and_then(|date| date.replace_year(target_year)))
127        .ok()
128}
129
130fn is_retention_mode(mode: &str) -> bool {
131    mode.eq_ignore_ascii_case(ObjectLockRetentionMode::COMPLIANCE)
132        || mode.eq_ignore_ascii_case(ObjectLockRetentionMode::GOVERNANCE)
133}
134
135#[cfg(test)]
136mod tests {
137    use super::*;
138
139    use s3s::dto::{DefaultRetention, ObjectLockEnabled, ObjectLockRule};
140    use time::Duration;
141
142    #[test]
143    fn is_object_locked_by_metadata_preserves_object_lock_parser_behavior() {
144        let mut user_defined = HashMap::new();
145        user_defined.insert(metadata_keys::OBJECT_LOCK_LEGAL_HOLD.to_string(), "ON".to_string());
146
147        assert!(is_object_locked_by_metadata(&user_defined, false));
148        assert!(!is_object_locked_by_metadata(&user_defined, true));
149    }
150
151    fn default_retention_config(days: i32) -> ObjectLockConfiguration {
152        ObjectLockConfiguration {
153            object_lock_enabled: Some(ObjectLockEnabled::from_static(ObjectLockEnabled::ENABLED)),
154            rule: Some(ObjectLockRule {
155                default_retention: Some(DefaultRetention {
156                    days: Some(days),
157                    mode: Some(ObjectLockRetentionMode::from_static(ObjectLockRetentionMode::GOVERNANCE)),
158                    years: None,
159                }),
160            }),
161        }
162    }
163
164    #[test]
165    fn default_retention_blocks_lifecycle_delete_until_expired() {
166        let config = default_retention_config(30);
167        let created = OffsetDateTime::now_utc() - Duration::days(1);
168
169        assert!(is_object_locked(&HashMap::new(), false, Some(&config), Some(created)));
170    }
171
172    #[test]
173    fn expired_default_retention_allows_lifecycle_delete() {
174        let config = default_retention_config(1);
175        let created = OffsetDateTime::now_utc() - Duration::days(2);
176
177        assert!(!is_object_locked(&HashMap::new(), false, Some(&config), Some(created)));
178    }
179
180    #[test]
181    fn missing_mod_time_blocks_default_retention_delete() {
182        let config = default_retention_config(30);
183
184        assert!(is_object_locked(&HashMap::new(), false, Some(&config), None));
185    }
186
187    #[test]
188    fn zero_default_retention_days_fail_closed() {
189        let config = default_retention_config(0);
190        let created = OffsetDateTime::now_utc() - Duration::days(2);
191
192        assert!(is_object_locked(&HashMap::new(), false, Some(&config), Some(created)));
193    }
194
195    #[test]
196    fn zero_default_retention_years_fail_closed() {
197        let config = ObjectLockConfiguration {
198            object_lock_enabled: Some(ObjectLockEnabled::from_static(ObjectLockEnabled::ENABLED)),
199            rule: Some(ObjectLockRule {
200                default_retention: Some(DefaultRetention {
201                    days: None,
202                    mode: Some(ObjectLockRetentionMode::from_static(ObjectLockRetentionMode::GOVERNANCE)),
203                    years: Some(0),
204                }),
205            }),
206        };
207        let created = OffsetDateTime::now_utc() - Duration::days(2);
208
209        assert!(is_object_locked(&HashMap::new(), false, Some(&config), Some(created)));
210    }
211
212    #[test]
213    fn default_retention_years_block_lifecycle_delete_until_expired() {
214        let config = ObjectLockConfiguration {
215            object_lock_enabled: Some(ObjectLockEnabled::from_static(ObjectLockEnabled::ENABLED)),
216            rule: Some(ObjectLockRule {
217                default_retention: Some(DefaultRetention {
218                    days: None,
219                    mode: Some(ObjectLockRetentionMode::from_static(ObjectLockRetentionMode::COMPLIANCE)),
220                    years: Some(1),
221                }),
222            }),
223        };
224        let created = OffsetDateTime::now_utc() - Duration::days(1);
225
226        assert!(is_object_locked(&HashMap::new(), false, Some(&config), Some(created)));
227    }
228
229    #[test]
230    fn expired_explicit_retention_does_not_reapply_default_retention() {
231        let config = default_retention_config(30);
232        let mut user_defined = HashMap::new();
233        user_defined.insert(
234            metadata_keys::OBJECT_LOCK_MODE.to_string(),
235            ObjectLockRetentionMode::GOVERNANCE.to_string(),
236        );
237        user_defined.insert(
238            metadata_keys::OBJECT_LOCK_RETAIN_UNTIL_DATE.to_string(),
239            (OffsetDateTime::now_utc() - Duration::days(1))
240                .format(&format_description::well_known::Iso8601::DEFAULT)
241                .expect("expired retention date should format"),
242        );
243
244        assert!(!is_object_locked(&user_defined, false, Some(&config), Some(OffsetDateTime::now_utc())));
245    }
246
247    #[test]
248    fn malformed_explicit_retention_fails_closed() {
249        let config = default_retention_config(1);
250        let mut user_defined = HashMap::new();
251        user_defined.insert(
252            metadata_keys::OBJECT_LOCK_MODE.to_string(),
253            ObjectLockRetentionMode::GOVERNANCE.to_string(),
254        );
255        let created = OffsetDateTime::now_utc() - Duration::days(2);
256
257        assert!(is_object_locked(&user_defined, false, Some(&config), Some(created)));
258    }
259
260    #[test]
261    fn delete_markers_are_not_locked_by_default_retention() {
262        let config = default_retention_config(30);
263
264        assert!(!is_object_locked(&HashMap::new(), true, Some(&config), None));
265    }
266}