1use 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
46pub 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}