1use rustfs_config::{DEFAULT_ILM_DAY_SECS, ENV_ILM_DEBUG_DAY_SECS, ENV_ILM_PROCESS_TIME, ENV_ILM_PROCESS_TIME_DEPRECATED};
16use rustfs_replication::{ReplicationStatusType, VersionPurgeStatusType};
17use s3s::dto::{
18 BucketLifecycleConfiguration, ExpirationStatus, LifecycleExpiration, LifecycleRule, LifecycleRuleFilter,
19 NoncurrentVersionTransition, ObjectLockConfiguration, ObjectLockEnabled, RestoreRequest, Transition,
20};
21use std::collections::{HashMap, HashSet};
22use std::sync::Arc;
23use time::macros::offset;
24use time::{self, Duration, OffsetDateTime};
25use tracing::{debug, warn};
26use uuid::Uuid;
27
28use crate::rule::{Filter, NoncurrentVersionTransitionOps, TransitionOps};
29
30pub const TRANSITION_COMPLETE: &str = "complete";
31pub const TRANSITION_PENDING: &str = "pending";
32const LOG_COMPONENT_ECSTORE: &str = "ecstore";
33const LOG_SUBSYSTEM_LIFECYCLE: &str = "lifecycle";
34const EVENT_LIFECYCLE_EXPIRY_COMPUTED: &str = "lifecycle_expiry_computed";
35const EVENT_LIFECYCLE_DEBUG_DAY_SECS: &str = "lifecycle_debug_day_secs";
36const EVENT_LIFECYCLE_NONCURRENT_EXPIRY_SKIPPED: &str = "lifecycle_noncurrent_expiry_skipped";
37const METRIC_LIFECYCLE_INVALID_MOD_TIME_TOTAL: &str = "rustfs_lifecycle_invalid_mod_time_total";
38const ERR_LIFECYCLE_NO_RULE: &str = "Lifecycle configuration should have at least one rule";
39const ERR_LIFECYCLE_DUPLICATE_ID: &str = "Rule ID must be unique. Found same ID for more than one rule";
40const _ERR_XML_NOT_WELL_FORMED: &str =
41 "The XML you provided was not well-formed or did not validate against our published schema";
42const ERR_LIFECYCLE_BUCKET_LOCKED: &str =
43 "ExpiredObjectAllVersions element and DelMarkerExpiration action cannot be used on an object locked bucket";
44const ERR_LIFECYCLE_TOO_MANY_RULES: &str = "Lifecycle configuration should have at most 1000 rules";
45const ERR_LIFECYCLE_INVALID_EXPIRATION_DAYS: &str = "'Days' for Expiration action must be a positive integer";
46const ERR_LIFECYCLE_EXPIRATION_DAYS_DATE_CONFLICT: &str = "Expiration cannot specify both Days and Date";
47const ERR_LIFECYCLE_MULTIPLE_TRANSITIONS: &str = "Only one Transition action per lifecycle rule is supported";
48const ERR_LIFECYCLE_MULTIPLE_NONCURRENT_TRANSITIONS: &str =
49 "Only one NoncurrentVersionTransition action per lifecycle rule is supported";
50const ERR_LIFECYCLE_INVALID_NONCURRENT_EXPIRATION_DAYS: &str =
51 "'NoncurrentDays' for NoncurrentVersionExpiration action must be a positive integer";
52const ERR_LIFECYCLE_INVALID_ABORT_INCOMPLETE_MPU_DAYS: &str =
53 "'DaysAfterInitiation' for AbortIncompleteMultipartUpload action must be a positive integer";
54const ERR_LIFECYCLE_INVALID_EXPIRATION_DATE_NOT_MIDNIGHT: &str = "Expiration.Date must be at midnight UTC";
55const ERR_LIFECYCLE_INVALID_EXPIRED_OBJECT_DELETE_MARKER: &str =
56 "ExpiredObjectDeleteMarker cannot be specified with Days or Date";
57const ERR_LIFECYCLE_INVALID_EXPIRED_OBJECT_ALL_VERSIONS: &str =
58 "Days must be a positive integer and Date must not be specified inside Expiration with ExpiredObjectAllVersions";
59const ERR_LIFECYCLE_INVALID_DEL_MARKER_EXPIRATION_DAYS: &str = "Days must be a positive integer with DelMarkerExpiration";
60const ERR_LIFECYCLE_INVALID_RULE_ID_TOO_LONG: &str = "Rule ID must be at most 255 characters";
61const ERR_LIFECYCLE_INVALID_RULE_ID_EMPTY: &str = "Rule ID must not be empty";
62const ERR_LIFECYCLE_INVALID_RULE_STATUS: &str = "Rule status must be either Enabled or Disabled";
63const ERR_LIFECYCLE_DEL_MARKER_WITH_TAGS: &str = "Rule with DelMarkerExpiration cannot have tags based filtering";
64const ERR_LIFECYCLE_EXPIRED_OBJECT_DELETE_MARKER_WITH_TAGS: &str =
65 "Rule with ExpiredObjectDeleteMarker cannot have tags based filtering";
66const ERR_LIFECYCLE_RULE_MUST_HAVE_ACTION: &str = "Rule must have at least one of Expiration, Transition, NoncurrentVersionExpiration, NoncurrentVersionTransition, or DelMarkerExpiration";
67const ERR_LIFECYCLE_PREFIX_FILTER_CONFLICT: &str = "Legacy Prefix and Filter cannot both be present in a lifecycle rule. Use Filter.Prefix instead of the top-level Prefix element.";
68const ERR_LIFECYCLE_INVALID_NEWER_NONCURRENT_VERSIONS: &str = "'NewerNoncurrentVersions' must be a non-negative integer";
69const ERR_LIFECYCLE_FILTER_AND_TOO_FEW_PREDICATES: &str = "Filter And must contain at least two predicates";
70const ERR_LIFECYCLE_FILTER_TOO_MANY_PREDICATES: &str = "Filter has too many predicates";
71const ERR_LIFECYCLE_FILTER_DUPLICATE_TAG_KEY: &str = "Filter must not repeat a tag key";
72const ERR_LIFECYCLE_FILTER_INVALID_TAG: &str = "Tag key must be 1-128 characters and tag value must be at most 256 characters";
73const ERR_LIFECYCLE_FILTER_NEGATIVE_SIZE: &str = "ObjectSizeGreaterThan and ObjectSizeLessThan must not be negative";
74const ERR_LIFECYCLE_FILTER_SIZE_RANGE: &str = "ObjectSizeGreaterThan must be smaller than ObjectSizeLessThan";
75const MAX_TAG_KEY_LEN: usize = 128;
77const MAX_TAG_VALUE_LEN: usize = 256;
79
80pub const LIFECYCLE_MALFORMED_XML_ERROR_KIND: std::io::ErrorKind = std::io::ErrorKind::InvalidData;
87
88pub const LIFECYCLE_CORRUPT_RULE_ERROR_KIND: std::io::ErrorKind = std::io::ErrorKind::InvalidData;
92
93fn malformed_xml_error(message: &'static str) -> std::io::Error {
94 std::io::Error::new(LIFECYCLE_MALFORMED_XML_ERROR_KIND, message)
95}
96
97pub fn retained_noncurrent_versions(count: i32) -> Option<usize> {
104 usize::try_from(count).ok()
105}
106
107pub fn lifecycle_has_corrupt_retention_count(lc: &BucketLifecycleConfiguration) -> bool {
109 lc.rules.iter().any(rule_has_corrupt_retention_count)
110}
111
112fn rule_has_corrupt_retention_count(rule: &LifecycleRule) -> bool {
113 let expiration_count = rule
114 .noncurrent_version_expiration
115 .as_ref()
116 .and_then(|expiration| expiration.newer_noncurrent_versions);
117 let transition_counts = rule
118 .noncurrent_version_transitions
119 .iter()
120 .flatten()
121 .filter_map(|transition| transition.newer_noncurrent_versions);
122 expiration_count
123 .into_iter()
124 .chain(transition_counts)
125 .any(|count| retained_noncurrent_versions(count).is_none())
126}
127
128pub use rustfs_scanner_metrics::metrics::IlmAction;
129
130#[async_trait::async_trait]
131pub trait RuleValidate {
132 fn validate(&self) -> Result<(), std::io::Error>;
133}
134
135#[async_trait::async_trait]
136impl RuleValidate for LifecycleRule {
137 fn validate(&self) -> Result<(), std::io::Error> {
195 let has_legacy_prefix = self.prefix.as_deref().is_some_and(|p| !p.is_empty());
198 let has_filter = self.filter.is_some();
199 if has_legacy_prefix && has_filter {
200 return Err(std::io::Error::other(ERR_LIFECYCLE_PREFIX_FILTER_CONFLICT));
201 }
202
203 if let Some(filter) = self.filter.as_ref() {
204 validate_lifecycle_filter(filter)?;
205 }
206
207 if rule_has_corrupt_retention_count(self) {
211 return Err(std::io::Error::other(ERR_LIFECYCLE_INVALID_NEWER_NONCURRENT_VERSIONS));
212 }
213
214 let has_tag_filter = self
216 .filter
217 .as_ref()
218 .is_some_and(|f| f.tag.is_some() || f.and.as_ref().and_then(|a| a.tags.as_ref()).is_some());
219 if has_tag_filter && self.del_marker_expiration.is_some() {
220 return Err(std::io::Error::other(ERR_LIFECYCLE_DEL_MARKER_WITH_TAGS));
221 }
222 if has_tag_filter
223 && self
224 .expiration
225 .as_ref()
226 .is_some_and(|expiration| expiration.expired_object_delete_marker.is_some_and(|v| v))
227 {
228 return Err(std::io::Error::other(ERR_LIFECYCLE_EXPIRED_OBJECT_DELETE_MARKER_WITH_TAGS));
229 }
230 if let Some(expiration) = &self.expiration
231 && expiration.expired_object_delete_marker.is_some()
232 && (expiration.days.is_some() || expiration.date.is_some())
233 {
234 return Err(std::io::Error::other(ERR_LIFECYCLE_INVALID_EXPIRED_OBJECT_DELETE_MARKER));
235 }
236 if self
237 .del_marker_expiration
238 .as_ref()
239 .is_some_and(|expiration| expiration.days.is_none_or(|days| days < 1))
240 {
241 return Err(std::io::Error::other(ERR_LIFECYCLE_INVALID_DEL_MARKER_EXPIRATION_DAYS));
242 }
243 let has_expiration = self.expiration.is_some();
245 let has_transition = self.transitions.as_ref().is_some_and(|t| !t.is_empty());
246 let has_noncurrent_expiration = self.noncurrent_version_expiration.as_ref().is_some_and(|expiration| {
252 expiration.noncurrent_days.is_some() || expiration.newer_noncurrent_versions.is_some_and(|count| count > 0)
253 });
254 let has_noncurrent_transition = self
255 .noncurrent_version_transitions
256 .as_ref()
257 .and_then(|t| t.first())
258 .and_then(|t| t.storage_class.as_ref())
259 .is_some();
260 let has_abort_incomplete_multipart_upload = self.abort_incomplete_multipart_upload.is_some();
261 let has_del_marker_expiration = self
262 .del_marker_expiration
263 .as_ref()
264 .and_then(|d| d.days)
265 .is_some_and(|d| d > 0);
266 if !has_expiration
267 && !has_transition
268 && !has_noncurrent_expiration
269 && !has_noncurrent_transition
270 && !has_abort_incomplete_multipart_upload
271 && !has_del_marker_expiration
272 {
273 return Err(std::io::Error::other(ERR_LIFECYCLE_RULE_MUST_HAVE_ACTION));
274 }
275 Ok(())
276 }
277}
278
279fn validate_lifecycle_filter(filter: &LifecycleRuleFilter) -> Result<(), std::io::Error> {
290 let top_level_predicates = usize::from(filter.prefix.is_some())
291 + usize::from(filter.tag.is_some())
292 + usize::from(filter.object_size_greater_than.is_some())
293 + usize::from(filter.object_size_less_than.is_some())
294 + usize::from(filter.and.is_some());
295 if top_level_predicates > 1 {
296 return Err(malformed_xml_error(ERR_LIFECYCLE_FILTER_TOO_MANY_PREDICATES));
297 }
298
299 if let Some(tag) = filter.tag.as_ref() {
300 validate_lifecycle_tag(tag)?;
301 }
302
303 if let Some(and) = filter.and.as_ref() {
304 let tags = and.tags.as_deref().unwrap_or(&[]);
305 let and_predicates = usize::from(and.prefix.is_some())
306 + tags.len()
307 + usize::from(and.object_size_greater_than.is_some())
308 + usize::from(and.object_size_less_than.is_some());
309 if and_predicates < 2 {
310 return Err(malformed_xml_error(ERR_LIFECYCLE_FILTER_AND_TOO_FEW_PREDICATES));
311 }
312 let mut seen_keys = HashSet::with_capacity(tags.len());
313 for tag in tags {
314 validate_lifecycle_tag(tag)?;
315 let key = tag.key.as_deref().unwrap_or_default();
316 if !seen_keys.insert(key) {
317 return Err(std::io::Error::other(ERR_LIFECYCLE_FILTER_DUPLICATE_TAG_KEY));
318 }
319 }
320 validate_lifecycle_size_bounds(and.object_size_greater_than, and.object_size_less_than)?;
321 }
322
323 validate_lifecycle_size_bounds(filter.object_size_greater_than, filter.object_size_less_than)?;
324
325 Ok(())
326}
327
328fn validate_lifecycle_tag(tag: &s3s::dto::Tag) -> Result<(), std::io::Error> {
332 let key = tag.key.as_deref().unwrap_or_default();
333 let Some(value) = tag.value.as_deref() else {
334 return Err(std::io::Error::other(ERR_LIFECYCLE_FILTER_INVALID_TAG));
335 };
336 if key.is_empty() || key.chars().count() > MAX_TAG_KEY_LEN || value.chars().count() > MAX_TAG_VALUE_LEN {
337 return Err(std::io::Error::other(ERR_LIFECYCLE_FILTER_INVALID_TAG));
338 }
339 Ok(())
340}
341
342fn validate_lifecycle_size_bounds(greater_than: Option<i64>, less_than: Option<i64>) -> Result<(), std::io::Error> {
343 if greater_than.is_some_and(|size| size < 0) || less_than.is_some_and(|size| size < 0) {
344 return Err(std::io::Error::other(ERR_LIFECYCLE_FILTER_NEGATIVE_SIZE));
345 }
346 if let (Some(greater_than), Some(less_than)) = (greater_than, less_than)
347 && greater_than >= less_than
348 {
349 return Err(std::io::Error::other(ERR_LIFECYCLE_FILTER_SIZE_RANGE));
350 }
351 Ok(())
352}
353
354fn lifecycle_rule_prefix(rule: &LifecycleRule) -> Option<&str> {
355 if let Some(p) = rule.prefix.as_deref()
357 && !p.is_empty()
358 {
359 return Some(p);
360 }
361
362 let filter = rule.filter.as_ref()?;
363
364 if let Some(p) = filter.prefix.as_deref() {
365 return Some(p);
366 }
367
368 filter.and.as_ref().and_then(|and| and.prefix.as_deref())
369}
370
371fn lifecycle_mod_time(obj: &ObjectOpts) -> Option<OffsetDateTime> {
372 let reason = match obj.mod_time {
373 None => "missing",
374 Some(mod_time) if mod_time < OffsetDateTime::UNIX_EPOCH => "before_unix_epoch",
375 Some(mod_time) if mod_time == OffsetDateTime::UNIX_EPOCH => "unix_epoch",
376 Some(mod_time) => return Some(mod_time),
377 };
378 metrics::counter!(
379 METRIC_LIFECYCLE_INVALID_MOD_TIME_TOTAL,
380 "reason" => reason
381 )
382 .increment(1);
383 None
384}
385
386#[async_trait::async_trait]
387pub trait Lifecycle {
388 async fn has_transition(&self) -> bool;
389 fn has_expiry(&self) -> bool;
390 fn has_active_rules(&self, prefix: &str) -> bool;
391 async fn validate(&self, lr: &ObjectLockConfiguration) -> Result<(), std::io::Error>;
392 async fn filter_rules(&self, obj: &ObjectOpts) -> Option<Vec<LifecycleRule>>;
393 async fn eval(&self, obj: &ObjectOpts) -> Event;
394 async fn predict_expiration(&self, obj: &ObjectOpts) -> Event;
395 async fn eval_inner(&self, obj: &ObjectOpts, now: OffsetDateTime, newer_noncurrent_versions: usize) -> Event;
396 async fn noncurrent_versions_expiration_limit(self: Arc<Self>, obj: &ObjectOpts) -> Event;
398}
399
400#[async_trait::async_trait]
401impl Lifecycle for BucketLifecycleConfiguration {
402 async fn has_transition(&self) -> bool {
403 for rule in self.rules.iter() {
404 if rule.transitions.as_ref().is_some_and(|transitions| !transitions.is_empty()) {
405 return true;
406 }
407 }
408 false
409 }
410
411 fn has_expiry(&self) -> bool {
412 for rule in self.rules.iter() {
413 if rule.expiration.is_some() || rule.noncurrent_version_expiration.is_some() {
414 return true;
415 }
416 }
417 false
418 }
419
420 fn has_active_rules(&self, prefix: &str) -> bool {
421 if self.rules.is_empty() {
422 return false;
423 }
424 for rule in self.rules.iter() {
425 if rule.status.as_str() == ExpirationStatus::DISABLED {
426 continue;
427 }
428
429 let rule_prefix = lifecycle_rule_prefix(rule).unwrap_or("");
430 if !prefix.is_empty()
431 && !rule_prefix.is_empty()
432 && !prefix.starts_with(rule_prefix)
433 && !rule_prefix.starts_with(prefix)
434 {
435 continue;
436 }
437
438 if let Some(rule_noncurrent_version_expiration) = &rule.noncurrent_version_expiration {
439 if let Some(noncurrent_days) = rule_noncurrent_version_expiration.noncurrent_days
440 && noncurrent_days >= 0
441 {
442 return true;
443 }
444 if let Some(newer_noncurrent_versions) = rule_noncurrent_version_expiration.newer_noncurrent_versions
449 && newer_noncurrent_versions > 0
450 {
451 return true;
452 }
453 }
454 if rule
455 .noncurrent_version_transitions
456 .as_ref()
457 .is_some_and(|transitions| !transitions.is_empty())
458 {
459 return true;
460 }
461 if rule
462 .del_marker_expiration
463 .as_ref()
464 .and_then(|expiration| expiration.days)
465 .is_some_and(|days| days > 0)
466 {
467 return true;
468 }
469 if let Some(rule_expiration) = &rule.expiration {
470 if let Some(date1) = rule_expiration.date.clone()
471 && OffsetDateTime::from(date1).unix_timestamp() < OffsetDateTime::now_utc().unix_timestamp()
472 {
473 return true;
474 }
475 if rule_expiration.date.is_some() {
476 return true;
477 }
478 if rule_expiration.days.is_some() {
479 return true;
480 }
481 if let Some(expired_object_delete_marker) = rule_expiration.expired_object_delete_marker
482 && expired_object_delete_marker
483 {
484 return true;
485 }
486 }
487 if let Some(rule_transition) = rule.transitions.as_ref().and_then(|transitions| transitions.first()) {
488 if let Some(date1) = rule_transition.date.clone()
489 && OffsetDateTime::from(date1).unix_timestamp() < OffsetDateTime::now_utc().unix_timestamp()
490 {
491 return true;
492 }
493 return true;
494 }
495 }
496 false
497 }
498
499 async fn validate(&self, lr: &ObjectLockConfiguration) -> Result<(), std::io::Error> {
500 if self.rules.len() > 1000 {
501 return Err(std::io::Error::other(ERR_LIFECYCLE_TOO_MANY_RULES));
502 }
503 if self.rules.is_empty() {
504 return Err(std::io::Error::other(ERR_LIFECYCLE_NO_RULE));
505 }
506
507 for r in &self.rules {
508 if r.status != ExpirationStatus::from_static(ExpirationStatus::ENABLED)
509 && r.status != ExpirationStatus::from_static(ExpirationStatus::DISABLED)
510 {
511 return Err(std::io::Error::other(ERR_LIFECYCLE_INVALID_RULE_STATUS));
512 }
513
514 if let Some(expiration) = &r.expiration {
515 if expiration.expired_object_all_versions.is_some()
516 && (expiration.days.is_none_or(|days| days < 1) || expiration.date.is_some())
517 {
518 return Err(std::io::Error::other(ERR_LIFECYCLE_INVALID_EXPIRED_OBJECT_ALL_VERSIONS));
519 }
520 if expiration.days.is_some() && expiration.date.is_some() {
521 return Err(std::io::Error::new(
522 std::io::ErrorKind::InvalidInput,
523 ERR_LIFECYCLE_EXPIRATION_DAYS_DATE_CONFLICT,
524 ));
525 }
526 if let Some(expiration_date) = &expiration.date {
527 let date = OffsetDateTime::from(expiration_date.clone());
528 if date.hour() != 0 || date.minute() != 0 || date.second() != 0 || date.nanosecond() != 0 {
529 return Err(std::io::Error::other(ERR_LIFECYCLE_INVALID_EXPIRATION_DATE_NOT_MIDNIGHT));
530 }
531 }
532 if let Some(days) = expiration.days
536 && days < 1
537 {
538 return Err(std::io::Error::other(ERR_LIFECYCLE_INVALID_EXPIRATION_DAYS));
539 }
540 }
541 if let Some(noncurrent_version_expiration) = &r.noncurrent_version_expiration
544 && let Some(noncurrent_days) = noncurrent_version_expiration.noncurrent_days
545 && noncurrent_days < 1
546 {
547 return Err(std::io::Error::other(ERR_LIFECYCLE_INVALID_NONCURRENT_EXPIRATION_DAYS));
548 }
549 if let Some(abort_incomplete_multipart_upload) = &r.abort_incomplete_multipart_upload {
553 match abort_incomplete_multipart_upload.days_after_initiation {
554 Some(days) if days >= 1 => {}
555 _ => return Err(std::io::Error::other(ERR_LIFECYCLE_INVALID_ABORT_INCOMPLETE_MPU_DAYS)),
556 }
557 }
558 if let Some(transitions) = &r.transitions {
559 if transitions.len() > 1 {
560 return Err(std::io::Error::new(std::io::ErrorKind::InvalidInput, ERR_LIFECYCLE_MULTIPLE_TRANSITIONS));
561 }
562 for transition in transitions {
563 TransitionOps::validate(transition)?;
564 }
565 }
566 if let Some(noncurrent_transitions) = &r.noncurrent_version_transitions {
567 if noncurrent_transitions.len() > 1 {
568 return Err(std::io::Error::new(
569 std::io::ErrorKind::InvalidInput,
570 ERR_LIFECYCLE_MULTIPLE_NONCURRENT_TRANSITIONS,
571 ));
572 }
573 for transition in noncurrent_transitions {
574 NoncurrentVersionTransitionOps::validate(transition)?;
575 }
576 }
577 if let Some(id) = &r.id {
578 if id.is_empty() {
579 return Err(std::io::Error::other(ERR_LIFECYCLE_INVALID_RULE_ID_EMPTY));
580 }
581 if id.len() > 255 {
582 return Err(std::io::Error::other(ERR_LIFECYCLE_INVALID_RULE_ID_TOO_LONG));
583 }
584 }
585 r.validate()?;
586 if let Some(object_lock_enabled) = lr.object_lock_enabled.as_ref()
587 && object_lock_enabled.as_str() == ObjectLockEnabled::ENABLED
588 {
589 if let Some(expiration) = r.expiration.as_ref() {
590 if expiration.expired_object_all_versions.is_some_and(|v| v) {
592 return Err(std::io::Error::other(ERR_LIFECYCLE_BUCKET_LOCKED));
593 }
594 }
595 if r.del_marker_expiration.is_some() {
597 return Err(std::io::Error::other(ERR_LIFECYCLE_BUCKET_LOCKED));
598 }
599 }
600 }
601 for (i, _) in self.rules.iter().enumerate() {
602 if i == self.rules.len() - 1 {
603 break;
604 }
605 let other_rules = &self.rules[i + 1..];
606 for other_rule in other_rules {
607 if let (Some(id1), Some(id2)) = (&self.rules[i].id, &other_rule.id)
608 && id1 == id2
609 {
610 return Err(std::io::Error::other(ERR_LIFECYCLE_DUPLICATE_ID));
611 }
612 }
613 }
614 Ok(())
615 }
616
617 async fn filter_rules(&self, obj: &ObjectOpts) -> Option<Vec<LifecycleRule>> {
618 if obj.name.is_empty() {
619 return None;
620 }
621 let mut rules = Vec::<LifecycleRule>::new();
622 for rule in self.rules.iter() {
623 if rule.status.as_str() == ExpirationStatus::DISABLED {
624 continue;
625 }
626 if let Some(rule_prefix) = lifecycle_rule_prefix(rule)
627 && !obj.name.starts_with(rule_prefix)
628 {
629 continue;
630 }
631 if let Some(filter) = rule.filter.as_ref() {
632 if !<LifecycleRuleFilter as Filter>::test_tags(filter, &obj.user_tags) {
633 continue;
634 }
635 if !obj.delete_marker
636 && !<LifecycleRuleFilter as Filter>::by_size(filter, i64::try_from(obj.size).unwrap_or(i64::MAX))
637 {
638 continue;
639 }
640 }
641 rules.push(rule.clone());
642 }
643 Some(rules)
644 }
645
646 async fn eval(&self, obj: &ObjectOpts) -> Event {
647 self.eval_inner(obj, OffsetDateTime::now_utc(), 0).await
650 }
651
652 async fn predict_expiration(&self, obj: &ObjectOpts) -> Event {
653 let Some(mod_time) = lifecycle_mod_time(obj) else {
654 return Event::default();
655 };
656
657 if obj.delete_marker || !obj.is_latest {
658 return Event::default();
659 }
660
661 let Some(lc_rules) = self.filter_rules(obj).await else {
662 return Event::default();
663 };
664
665 let mut event: Option<Event> = None;
666 for rule in lc_rules {
667 let Some(expiration) = rule.expiration else {
668 continue;
669 };
670 if expiration.expired_object_delete_marker.is_some_and(|v| v) {
671 continue;
672 }
673 let Some(due) = (match (&expiration.date, expiration.days) {
674 (Some(date), _) => Some(OffsetDateTime::from(date.clone())),
675 (None, Some(days)) => Some(expected_expiry_time(mod_time, days)),
676 _ => None,
677 }) else {
678 continue;
679 };
680
681 let predicted = Event {
682 action: IlmAction::DeleteAction,
683 rule_id: rule.id.clone().unwrap_or_default(),
684 due: Some(due),
685 noncurrent_days: 0,
686 newer_noncurrent_versions: 0,
687 storage_class: "".into(),
688 };
689 let predicted_due = predicted.due.unwrap_or(OffsetDateTime::UNIX_EPOCH).unix_timestamp();
690 let should_replace = event
691 .as_ref()
692 .is_none_or(|e| predicted_due < e.due.unwrap_or(OffsetDateTime::UNIX_EPOCH).unix_timestamp());
693 if should_replace {
694 event = Some(predicted);
695 }
696 }
697
698 event.unwrap_or_default()
699 }
700
701 async fn eval_inner(&self, obj: &ObjectOpts, now: OffsetDateTime, newer_noncurrent_versions: usize) -> Event {
702 let mut events = Vec::<Event>::new();
703 debug!(
704 "eval_inner: object={}, mod_time={:?}, successor_mod_time={:?}, now={:?}, is_latest={}, delete_marker={}",
705 obj.name, obj.mod_time, obj.successor_mod_time, now, obj.is_latest, obj.delete_marker
706 );
707
708 let Some(mod_time) = lifecycle_mod_time(obj) else {
709 return Event::default();
710 };
711
712 if let Some(event) = obj.restored_copy_expiry(now) {
713 events.push(event);
714 }
715
716 if let Some(ref lc_rules) = self.filter_rules(obj).await {
717 for rule in lc_rules.iter() {
718 if rule_has_corrupt_retention_count(rule) {
723 debug!(
724 event = EVENT_LIFECYCLE_NONCURRENT_EXPIRY_SKIPPED,
725 component = LOG_COMPONENT_ECSTORE,
726 subsystem = LOG_SUBSYSTEM_LIFECYCLE,
727 object = %obj.name,
728 rule_id = %rule.id.clone().unwrap_or_default(),
729 reason = "corrupt_newer_noncurrent_versions",
730 "Skipped lifecycle evaluation for a rule with an invalid retention count"
731 );
732 continue;
733 }
734
735 if obj.is_latest && obj.expired_object_deletemarker() {
736 if let Some(expiration) = rule.expiration.as_ref()
737 && expiration.expired_object_delete_marker.is_some_and(|v| v)
738 {
739 let due = expiration.next_due(obj).unwrap_or(now);
742 if now.unix_timestamp() >= due.unix_timestamp() {
743 events.push(Event {
744 action: IlmAction::DeleteVersionAction,
745 rule_id: rule.id.clone().unwrap_or_default(),
746 due: Some(due),
747 noncurrent_days: 0,
748 newer_noncurrent_versions: 0,
749 storage_class: "".into(),
750 });
751 break;
753 }
754 }
755 if let Some(days) = rule.expiration.as_ref().and_then(|expiration| expiration.days) {
756 let due = expected_expiry_time(mod_time, days);
757 if now.unix_timestamp() >= due.unix_timestamp() {
758 events.push(Event {
759 action: IlmAction::DeleteVersionAction,
760 rule_id: rule.id.clone().unwrap_or_default(),
761 due: Some(due),
762 noncurrent_days: 0,
763 newer_noncurrent_versions: 0,
764 storage_class: "".into(),
765 });
766 }
767 }
768 }
769
770 if obj.is_latest
771 && obj.delete_marker
772 && let Some(days) = rule.del_marker_expiration.as_ref().and_then(|expiration| expiration.days)
773 && days > 0
774 {
775 let due = expected_expiry_time(mod_time, days);
776 if now.unix_timestamp() >= due.unix_timestamp() {
777 events.push(Event {
778 action: IlmAction::DelMarkerDeleteAllVersionsAction,
779 rule_id: rule.id.clone().unwrap_or_default(),
780 due: Some(due),
781 noncurrent_days: 0,
782 newer_noncurrent_versions: 0,
783 storage_class: "".into(),
784 });
785 }
786 continue;
787 }
788
789 if !obj.is_latest
790 && let Some(ref noncurrent_version_expiration) = rule.noncurrent_version_expiration
791 && (noncurrent_version_expiration.noncurrent_days.is_some()
792 || noncurrent_version_expiration
793 .newer_noncurrent_versions
794 .is_some_and(|count| count > 0))
795 && noncurrent_version_expiration
796 .newer_noncurrent_versions
797 .is_none_or(|retain| usize::try_from(retain).is_ok_and(|retain| newer_noncurrent_versions >= retain))
798 {
799 let noncurrent_days = noncurrent_version_expiration.noncurrent_days.unwrap_or(0);
803 if let Some(successor_mod_time) = obj.successor_mod_time {
804 let expected_expiry = expected_expiry_time(successor_mod_time, noncurrent_days);
805 if now.unix_timestamp() >= expected_expiry.unix_timestamp() {
806 events.push(Event {
807 action: IlmAction::DeleteVersionAction,
808 rule_id: rule.id.clone().unwrap_or_default(),
809 due: Some(expected_expiry),
810 noncurrent_days: 0,
811 newer_noncurrent_versions: 0,
812 storage_class: "".into(),
813 });
814 }
815 } else {
816 debug!(
817 event = EVENT_LIFECYCLE_NONCURRENT_EXPIRY_SKIPPED,
818 component = LOG_COMPONENT_ECSTORE,
819 subsystem = LOG_SUBSYSTEM_LIFECYCLE,
820 object = %obj.name,
821 reason = "missing_successor_mod_time",
822 "Skipped noncurrent expiration for incomplete version chain"
823 );
824 }
825 }
826
827 if !obj.is_latest
828 && let Some(noncurrent_version_transition) = rule
829 .noncurrent_version_transitions
830 .as_ref()
831 .filter(|transitions| transitions.len() == 1)
832 .and_then(|transitions| transitions.first())
833 && noncurrent_version_transition
834 .newer_noncurrent_versions
835 .is_none_or(|retain| usize::try_from(retain).is_ok_and(|retain| newer_noncurrent_versions >= retain))
836 && let Some(storage_class) = noncurrent_version_transition.storage_class.as_ref()
837 && !storage_class.as_str().is_empty()
838 && !obj.delete_marker
839 && obj.transition_status != TRANSITION_COMPLETE
840 {
841 let due = noncurrent_version_transition.next_due(obj);
842 if let Some(due0) = due
843 && (now.unix_timestamp() == 0 || now.unix_timestamp() > due0.unix_timestamp())
844 {
845 events.push(Event {
846 action: IlmAction::TransitionVersionAction,
847 rule_id: rule.id.clone().unwrap_or_default(),
848 due,
849 storage_class: storage_class.as_str().to_string(),
850 ..Default::default()
851 });
852 }
853 }
854
855 debug!(
856 "eval_inner: checking expiration condition - is_latest={}, delete_marker={}, version_id={:?}, condition_met={}",
857 obj.is_latest,
858 obj.delete_marker,
859 obj.version_id,
860 obj.is_latest && !obj.delete_marker
861 );
862 if obj.is_latest && !obj.delete_marker {
865 debug!("eval_inner: entering expiration check");
866 if let Some(ref expiration) = rule.expiration {
867 if let Some(ref date) = expiration.date {
868 let date0 = OffsetDateTime::from(date.clone());
869 if date0.unix_timestamp() != 0 && (now.unix_timestamp() >= date0.unix_timestamp()) {
870 debug!("eval_inner: expiration by date - date0={:?}", date0);
871 events.push(Event {
872 action: IlmAction::DeleteAction,
873 rule_id: rule.id.clone().unwrap_or_default(),
874 due: Some(date0),
875 noncurrent_days: 0,
876 newer_noncurrent_versions: 0,
877 storage_class: "".into(),
878 });
879 }
880 } else if let Some(days) = expiration.days {
881 let expected_expiry: OffsetDateTime = expected_expiry_time(mod_time, days);
882 debug!(
883 "eval_inner: expiration check - days={}, obj_time={:?}, expiry_time={:?}, now={:?}, should_expire={}",
884 days,
885 mod_time,
886 expected_expiry,
887 now,
888 now.unix_timestamp() > expected_expiry.unix_timestamp()
889 );
890 if now.unix_timestamp() >= expected_expiry.unix_timestamp() {
891 debug!("eval_inner: object should expire, adding DeleteAction");
892 let mut event = Event {
893 action: IlmAction::DeleteAction,
894 rule_id: rule.id.clone().unwrap_or_default(),
895 due: Some(expected_expiry),
896 noncurrent_days: 0,
897 newer_noncurrent_versions: 0,
898 storage_class: "".into(),
899 };
900 if rule
902 .expiration
903 .as_ref()
904 .and_then(|e| e.expired_object_all_versions)
905 .unwrap_or(false)
906 {
907 event.action = IlmAction::DeleteAllVersionsAction;
908 }
909 events.push(event);
910 }
911 } else {
912 debug!("eval_inner: expiration.days is None");
913 }
914 } else {
915 debug!("eval_inner: rule.expiration is None");
916 }
917
918 if obj.transition_status != TRANSITION_COMPLETE
919 && let Some(transition) = rule
920 .transitions
921 .as_ref()
922 .filter(|transitions| transitions.len() == 1)
923 .and_then(|transitions| transitions.first())
924 && let Some(storage_class) = transition.storage_class.as_ref()
925 && !storage_class.as_str().is_empty()
926 {
927 let due = transition.next_due(obj);
928 if let Some(due0) = due
929 && (now.unix_timestamp() == 0 || now.unix_timestamp() > due0.unix_timestamp())
930 {
931 events.push(Event {
932 action: IlmAction::TransitionAction,
933 rule_id: rule.id.clone().unwrap_or_default(),
934 due,
935 storage_class: storage_class.as_str().to_string(),
936 noncurrent_days: 0,
937 newer_noncurrent_versions: 0,
938 });
939 }
940 }
941 }
942 }
943 }
944
945 if !events.is_empty() {
946 let event = events
950 .iter()
951 .min_by_key(|event| {
952 (
953 ilm_action_priority_rank(&event.action),
954 event.due.unwrap_or(OffsetDateTime::UNIX_EPOCH).unix_timestamp(),
955 )
956 })
957 .cloned()
958 .unwrap_or_default();
959 return event;
960 }
961
962 Event::default()
963 }
964
965 async fn noncurrent_versions_expiration_limit(self: Arc<Self>, obj: &ObjectOpts) -> Event {
966 if let Some(filter_rules) = self.filter_rules(obj).await {
967 for rule in filter_rules.iter() {
968 if let Some(ref noncurrent_version_expiration) = rule.noncurrent_version_expiration {
969 return if let Some(newer_noncurrent_versions) = noncurrent_version_expiration.newer_noncurrent_versions {
970 let Some(retained) = retained_noncurrent_versions(newer_noncurrent_versions).filter(|c| *c > 0) else {
974 continue;
975 };
976 Event {
977 action: IlmAction::DeleteVersionAction,
978 rule_id: rule.id.clone().unwrap_or_default(),
979 noncurrent_days: u32::try_from(noncurrent_version_expiration.noncurrent_days.unwrap_or(0))
980 .unwrap_or(u32::MAX),
981 newer_noncurrent_versions: retained,
982 due: Some(OffsetDateTime::UNIX_EPOCH),
983 storage_class: "".into(),
984 }
985 } else {
986 Event {
987 action: IlmAction::DeleteVersionAction,
988 rule_id: rule.id.clone().unwrap_or_default(),
989 noncurrent_days: u32::try_from(noncurrent_version_expiration.noncurrent_days.unwrap_or(0))
990 .unwrap_or(u32::MAX),
991 newer_noncurrent_versions: 0,
992 due: Some(OffsetDateTime::UNIX_EPOCH),
993 storage_class: "".into(),
994 }
995 };
996 }
997 }
998 }
999 Event::default()
1000 }
1001}
1002
1003#[async_trait::async_trait]
1004pub trait LifecycleCalculate {
1005 fn next_due(&self, obj: &ObjectOpts) -> Option<OffsetDateTime>;
1006}
1007
1008#[async_trait::async_trait]
1009impl LifecycleCalculate for LifecycleExpiration {
1010 fn next_due(&self, obj: &ObjectOpts) -> Option<OffsetDateTime> {
1011 if !obj.is_latest || !obj.delete_marker {
1012 return None;
1013 }
1014 if let Some(ref date) = self.date {
1017 let expiry_date = OffsetDateTime::from(date.clone());
1018 if expiry_date.unix_timestamp() != 0 {
1019 return Some(expiry_date);
1020 }
1021 }
1022 match self.days {
1023 Some(days) => obj.mod_time.map(|mod_time| expected_expiry_time(mod_time, days)),
1024 None => None,
1025 }
1026 }
1027}
1028
1029#[async_trait::async_trait]
1030impl LifecycleCalculate for NoncurrentVersionTransition {
1031 fn next_due(&self, obj: &ObjectOpts) -> Option<OffsetDateTime> {
1032 if obj.is_latest || self.storage_class.is_none() {
1033 return None;
1034 }
1035 match self.noncurrent_days {
1036 Some(noncurrent_days) => {
1037 if let Some(successor_mod_time) = obj.successor_mod_time {
1038 Some(expected_expiry_time(successor_mod_time, noncurrent_days))
1039 } else {
1040 Some(expected_expiry_time(OffsetDateTime::now_utc(), noncurrent_days))
1041 }
1042 }
1043 None => obj.successor_mod_time,
1044 }
1045 }
1046}
1047
1048#[async_trait::async_trait]
1049impl LifecycleCalculate for Transition {
1050 fn next_due(&self, obj: &ObjectOpts) -> Option<OffsetDateTime> {
1051 if !obj.is_latest {
1052 return None;
1053 }
1054
1055 if let Some(date) = self.date.clone() {
1056 return Some(date.into());
1057 }
1058
1059 match (self.days, obj.mod_time) {
1060 (Some(days), Some(mod_time)) => Some(expected_expiry_time(mod_time, days)),
1061 (Some(_), None) => None,
1062 (None, mod_time) => mod_time,
1063 }
1064 }
1065}
1066
1067pub fn expected_expiry_time(mod_time: OffsetDateTime, days: i32) -> OffsetDateTime {
1068 if days == 0 {
1069 debug!(
1070 event = EVENT_LIFECYCLE_EXPIRY_COMPUTED,
1071 component = LOG_COMPONENT_ECSTORE,
1072 subsystem = LOG_SUBSYSTEM_LIFECYCLE,
1073 days,
1074 result = "unix_epoch",
1075 "Computed immediate lifecycle expiry time"
1076 );
1077 return OffsetDateTime::UNIX_EPOCH; }
1079 let offset_secs = i64::from(days).saturating_mul(i64::from(ilm_day_secs()));
1083 let t = mod_time
1084 .to_offset(offset!(-0:00:00))
1085 .saturating_add(Duration::seconds(offset_secs));
1086
1087 let process_interval_secs = ilm_process_interval_secs();
1093
1094 let boundary_nanos = i128::from(process_interval_secs) * 1_000_000_000;
1095 let timestamp_nanos = t.unix_timestamp_nanos();
1096 let remainder = timestamp_nanos.rem_euclid(boundary_nanos);
1097 let rounded_nanos = if remainder == 0 {
1098 timestamp_nanos
1099 } else {
1100 timestamp_nanos + (boundary_nanos - remainder)
1101 };
1102 OffsetDateTime::from_unix_timestamp_nanos(rounded_nanos).unwrap_or(t)
1103}
1104
1105fn ilm_process_interval_secs() -> u32 {
1106 std::env::var(ENV_ILM_PROCESS_TIME)
1110 .ok()
1111 .or_else(|| std::env::var(ENV_ILM_PROCESS_TIME_DEPRECATED).ok())
1112 .and_then(|value| value.parse::<i32>().ok())
1113 .filter(|value| *value > 0)
1114 .and_then(|value| u32::try_from(value).ok())
1115 .unwrap_or_else(ilm_day_secs)
1116}
1117
1118fn ilm_day_secs() -> u32 {
1137 #[cfg(test)]
1138 {
1139 resolve_ilm_day_secs()
1140 }
1141 #[cfg(not(test))]
1142 {
1143 use std::sync::OnceLock;
1144 static CACHE: OnceLock<u32> = OnceLock::new();
1145 *CACHE.get_or_init(resolve_ilm_day_secs)
1146 }
1147}
1148
1149fn resolve_ilm_day_secs() -> u32 {
1150 match std::env::var(ENV_ILM_DEBUG_DAY_SECS) {
1151 Ok(raw) => parse_ilm_day_secs(&raw),
1152 Err(_) => DEFAULT_ILM_DAY_SECS,
1153 }
1154}
1155
1156fn parse_ilm_day_secs(raw: &str) -> u32 {
1159 match raw.trim().parse::<u32>() {
1160 Ok(secs) if secs > 0 => {
1161 warn!(
1162 event = EVENT_LIFECYCLE_DEBUG_DAY_SECS,
1163 component = LOG_COMPONENT_ECSTORE,
1164 subsystem = LOG_SUBSYSTEM_LIFECYCLE,
1165 day_secs = secs,
1166 "RUSTFS_ILM_DEBUG_DAY_SECS is set: lifecycle Days are accelerated to {secs}s/day. \
1167 TEST/DEBUG ONLY - this accelerates object deletion and must never be enabled in production."
1168 );
1169 secs
1170 }
1171 _ => {
1172 warn!(
1173 event = EVENT_LIFECYCLE_DEBUG_DAY_SECS,
1174 component = LOG_COMPONENT_ECSTORE,
1175 subsystem = LOG_SUBSYSTEM_LIFECYCLE,
1176 raw = raw,
1177 fallback_day_secs = DEFAULT_ILM_DAY_SECS,
1178 "Ignoring invalid RUSTFS_ILM_DEBUG_DAY_SECS value; falling back to 86400s/day."
1179 );
1180 DEFAULT_ILM_DAY_SECS
1181 }
1182 }
1183}
1184
1185pub async fn abort_incomplete_multipart_upload_due(
1186 lc: &BucketLifecycleConfiguration,
1187 obj: &ObjectOpts,
1188) -> Option<(OffsetDateTime, String)> {
1189 let initiated = obj.mod_time?;
1190 let rules = lc.filter_rules(obj).await?;
1191
1192 rules
1193 .into_iter()
1194 .filter_map(|rule| {
1195 let days = rule
1196 .abort_incomplete_multipart_upload
1197 .as_ref()?
1198 .days_after_initiation
1199 .filter(|days| *days >= 0)?;
1200 Some((expected_expiry_time(initiated, days), rule.id.unwrap_or_default()))
1201 })
1202 .min_by_key(|(due, _)| due.unix_timestamp_nanos())
1203}
1204
1205#[derive(Debug, Default)]
1206pub struct ObjectOpts {
1207 pub name: String,
1208 pub user_tags: String,
1209 pub mod_time: Option<OffsetDateTime>,
1210 pub size: usize,
1211 pub version_id: Option<Uuid>,
1212 pub is_latest: bool,
1213 pub delete_marker: bool,
1214 pub num_versions: usize,
1215 pub successor_mod_time: Option<OffsetDateTime>,
1216 pub transition_status: String,
1217 pub restore_ongoing: bool,
1218 pub restore_expires: Option<OffsetDateTime>,
1219 pub versioned: bool,
1220 pub version_suspended: bool,
1221 pub user_defined: HashMap<String, String>,
1222 pub version_purge_status: VersionPurgeStatusType,
1223 pub replication_status: ReplicationStatusType,
1224}
1225
1226impl ObjectOpts {
1227 pub fn expired_object_deletemarker(&self) -> bool {
1228 self.delete_marker && self.is_latest && self.num_versions == 1
1229 }
1230
1231 pub(crate) fn restored_copy_expiry(&self, now: OffsetDateTime) -> Option<Event> {
1232 let restore_expires = self.restore_expires?;
1233 if self.transition_status != TRANSITION_COMPLETE
1235 || restore_expires.unix_timestamp() == 0
1236 || now.unix_timestamp() <= restore_expires.unix_timestamp()
1237 {
1238 return None;
1239 }
1240 let action = if self.is_latest {
1241 IlmAction::DeleteRestoredAction
1242 } else {
1243 IlmAction::DeleteRestoredVersionAction
1244 };
1245 expiration_action_has_valid_target(action, self.version_id, self.is_latest, self.delete_marker).then(|| Event {
1246 action,
1247 due: Some(now),
1248 ..Default::default()
1249 })
1250 }
1251}
1252
1253pub fn expiration_action_has_valid_target(
1258 action: IlmAction,
1259 version_id: Option<Uuid>,
1260 is_latest: bool,
1261 delete_marker: bool,
1262) -> bool {
1263 match action {
1264 IlmAction::DeleteAction | IlmAction::DeleteRestoredAction => is_latest && !delete_marker,
1265 IlmAction::DeleteVersionAction => version_id.is_some() && (!is_latest || delete_marker),
1266 IlmAction::DeleteRestoredVersionAction => version_id.is_some() && !is_latest && !delete_marker,
1267 IlmAction::DeleteAllVersionsAction => is_latest && !delete_marker,
1268 IlmAction::DelMarkerDeleteAllVersionsAction => is_latest && delete_marker,
1269 _ => true,
1270 }
1271}
1272
1273fn ilm_action_priority_rank(action: &IlmAction) -> u8 {
1276 match action {
1277 IlmAction::DeleteAllVersionsAction
1278 | IlmAction::DelMarkerDeleteAllVersionsAction
1279 | IlmAction::DeleteAction
1280 | IlmAction::DeleteVersionAction => 0,
1281 _ => 1,
1282 }
1283}
1284
1285#[derive(Debug, Clone)]
1286pub struct Event {
1287 pub action: IlmAction,
1288 pub rule_id: String,
1289 pub due: Option<OffsetDateTime>,
1290 pub noncurrent_days: u32,
1291 pub newer_noncurrent_versions: usize,
1292 pub storage_class: String,
1293}
1294
1295impl Default for Event {
1296 fn default() -> Self {
1297 Self {
1298 action: IlmAction::NoneAction,
1299 rule_id: "".into(),
1300 due: Some(OffsetDateTime::UNIX_EPOCH),
1301 noncurrent_days: 0,
1302 newer_noncurrent_versions: 0,
1303 storage_class: "".into(),
1304 }
1305 }
1306}
1307
1308pub use rustfs_storage_api::ExpirationOptions;
1309
1310#[derive(Debug, Clone)]
1311pub struct TransitionOptions {
1312 pub status: String,
1313 pub tier: String,
1314 pub etag: String,
1315 pub expected_data_dir: Option<Uuid>,
1316 pub expected_remote_name: String,
1317 pub expected_remote_version_id: String,
1318 pub restore_request: RestoreRequest,
1319 pub restore_expiry: OffsetDateTime,
1320 pub expire_restored: bool,
1321}
1322
1323impl Default for TransitionOptions {
1324 fn default() -> Self {
1325 Self {
1326 status: Default::default(),
1327 tier: Default::default(),
1328 etag: Default::default(),
1329 expected_data_dir: Default::default(),
1330 expected_remote_name: Default::default(),
1331 expected_remote_version_id: Default::default(),
1332 restore_request: Default::default(),
1333 restore_expiry: OffsetDateTime::now_utc(),
1334 expire_restored: Default::default(),
1335 }
1336 }
1337}
1338
1339#[cfg(test)]
1340mod tests {
1341 use super::*;
1342 use metrics_util::MetricKind;
1343 use metrics_util::debugging::{DebugValue, DebuggingRecorder};
1344 use s3s::dto::{
1345 LifecycleRuleAndOperator, LifecycleRuleFilter, NoncurrentVersionExpiration, NoncurrentVersionTransition,
1346 TransitionStorageClass,
1347 };
1348 use s3s::xml::{Deserialize as XmlDeserialize, SerializeContent as XmlSerializeContent};
1349 use serial_test::serial;
1350 use std::sync::Arc;
1351 use time::macros::datetime;
1352
1353 fn with_default_ilm_process_time(test: impl FnOnce()) {
1354 temp_env::with_var_unset(ENV_ILM_DEBUG_DAY_SECS, || {
1357 temp_env::with_var_unset(ENV_ILM_PROCESS_TIME, || {
1358 temp_env::with_var_unset(ENV_ILM_PROCESS_TIME_DEPRECATED, test);
1359 });
1360 });
1361 }
1362
1363 fn enabled_rule(
1364 expiration: Option<LifecycleExpiration>,
1365 del_marker_expiration: Option<s3s::dto::DelMarkerExpiration>,
1366 id: Option<&str>,
1367 ) -> LifecycleRule {
1368 LifecycleRule {
1369 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1370 expiration,
1371 abort_incomplete_multipart_upload: None,
1372 del_marker_expiration,
1373 filter: None,
1374 id: id.map(str::to_string),
1375 noncurrent_version_expiration: None,
1376 noncurrent_version_transitions: None,
1377 prefix: None,
1378 transitions: None,
1379 }
1380 }
1381
1382 #[test]
1383 fn eval_inner_reports_invalid_mod_time_without_expiring_object() {
1384 let lifecycle = BucketLifecycleConfiguration {
1385 expiry_updated_at: None,
1386 rules: vec![LifecycleRule {
1387 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1388 expiration: Some(LifecycleExpiration {
1389 days: Some(1),
1390 ..Default::default()
1391 }),
1392 abort_incomplete_multipart_upload: None,
1393 del_marker_expiration: None,
1394 filter: None,
1395 id: Some("expire-after-one-day".to_string()),
1396 noncurrent_version_expiration: None,
1397 noncurrent_version_transitions: None,
1398 prefix: None,
1399 transitions: None,
1400 }],
1401 };
1402 let recorder = DebuggingRecorder::new();
1403 let snapshotter = recorder.snapshotter();
1404 let runtime = tokio::runtime::Builder::new_current_thread()
1405 .build()
1406 .expect("current-thread runtime should build");
1407
1408 let actions = metrics::with_local_recorder(&recorder, || {
1409 runtime.block_on(async {
1410 let now = OffsetDateTime::from_unix_timestamp(10 * 86_400).expect("fixed timestamp should be valid");
1411 let mut opts = ObjectOpts {
1412 name: "legacy-object".to_string(),
1413 is_latest: true,
1414 ..Default::default()
1415 };
1416 let mut actions = Vec::new();
1417 for mod_time in [
1418 None,
1419 Some(OffsetDateTime::UNIX_EPOCH),
1420 Some(OffsetDateTime::UNIX_EPOCH - Duration::nanoseconds(1)),
1421 Some(OffsetDateTime::UNIX_EPOCH + Duration::nanoseconds(1)),
1422 ] {
1423 opts.mod_time = mod_time;
1424 actions.push((
1425 lifecycle.eval_inner(&opts, now, 0).await.action,
1426 lifecycle.predict_expiration(&opts).await.action,
1427 ));
1428 }
1429 actions
1430 })
1431 });
1432
1433 assert_eq!(
1434 actions,
1435 [
1436 (IlmAction::NoneAction, IlmAction::NoneAction),
1437 (IlmAction::NoneAction, IlmAction::NoneAction),
1438 (IlmAction::NoneAction, IlmAction::NoneAction),
1439 (IlmAction::DeleteAction, IlmAction::DeleteAction)
1440 ]
1441 );
1442
1443 let invalid_mod_time_metrics = snapshotter
1444 .snapshot()
1445 .into_vec()
1446 .into_iter()
1447 .filter_map(|(composite, _unit, _description, value)| {
1448 (composite.kind() == MetricKind::Counter && composite.key().name() == METRIC_LIFECYCLE_INVALID_MOD_TIME_TOTAL)
1449 .then(|| {
1450 let reason = composite
1451 .key()
1452 .labels()
1453 .find(|label| label.key() == "reason")
1454 .map(|label| label.value().to_string())
1455 .expect("invalid mod_time metric should have a reason");
1456 (reason, value)
1457 })
1458 })
1459 .collect::<Vec<_>>();
1460 assert_eq!(invalid_mod_time_metrics.len(), 3);
1461 assert!(
1462 invalid_mod_time_metrics
1463 .iter()
1464 .all(|(_, value)| matches!(value, DebugValue::Counter(2)))
1465 );
1466 assert!(invalid_mod_time_metrics.iter().any(|(reason, _)| reason == "missing"));
1467 assert!(invalid_mod_time_metrics.iter().any(|(reason, _)| reason == "unix_epoch"));
1468 assert!(
1469 invalid_mod_time_metrics
1470 .iter()
1471 .any(|(reason, _)| reason == "before_unix_epoch")
1472 );
1473 }
1474
1475 #[tokio::test]
1476 async fn validate_rejects_zero_expiration_days() {
1477 let lc = BucketLifecycleConfiguration {
1482 expiry_updated_at: None,
1483 rules: vec![LifecycleRule {
1484 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1485 expiration: Some(LifecycleExpiration {
1486 days: Some(0),
1487 ..Default::default()
1488 }),
1489 abort_incomplete_multipart_upload: None,
1490 del_marker_expiration: None,
1491 filter: None,
1492 id: None,
1493 noncurrent_version_expiration: None,
1494 noncurrent_version_transitions: None,
1495 prefix: None,
1496 transitions: None,
1497 }],
1498 };
1499
1500 let err = lc
1501 .validate(&ObjectLockConfiguration::default())
1502 .await
1503 .expect_err("zero-day expiration should be rejected");
1504
1505 assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_EXPIRATION_DAYS);
1506 }
1507
1508 #[tokio::test]
1509 async fn validate_rejects_negative_expiration_days() {
1510 let lc = BucketLifecycleConfiguration {
1511 expiry_updated_at: None,
1512 rules: vec![LifecycleRule {
1513 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1514 expiration: Some(LifecycleExpiration {
1515 days: Some(-1),
1516 ..Default::default()
1517 }),
1518 abort_incomplete_multipart_upload: None,
1519 del_marker_expiration: None,
1520 filter: None,
1521 id: None,
1522 noncurrent_version_expiration: None,
1523 noncurrent_version_transitions: None,
1524 prefix: None,
1525 transitions: None,
1526 }],
1527 };
1528
1529 let err = lc
1530 .validate(&ObjectLockConfiguration::default())
1531 .await
1532 .expect_err("expected validation error");
1533
1534 assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_EXPIRATION_DAYS);
1535 }
1536
1537 #[tokio::test]
1538 async fn validate_accepts_positive_expiration_days() {
1539 let lc = BucketLifecycleConfiguration {
1540 expiry_updated_at: None,
1541 rules: vec![LifecycleRule {
1542 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1543 expiration: Some(LifecycleExpiration {
1544 days: Some(30),
1545 ..Default::default()
1546 }),
1547 abort_incomplete_multipart_upload: None,
1548 del_marker_expiration: None,
1549 filter: None,
1550 id: None,
1551 noncurrent_version_expiration: None,
1552 noncurrent_version_transitions: None,
1553 prefix: None,
1554 transitions: None,
1555 }],
1556 };
1557
1558 lc.validate(&ObjectLockConfiguration::default())
1559 .await
1560 .expect("expected validation to pass");
1561 }
1562
1563 #[tokio::test]
1564 async fn validate_accepts_one_day_boundary_values() {
1565 let lc = BucketLifecycleConfiguration {
1569 expiry_updated_at: None,
1570 rules: vec![LifecycleRule {
1571 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1572 expiration: Some(LifecycleExpiration {
1573 days: Some(1),
1574 ..Default::default()
1575 }),
1576 abort_incomplete_multipart_upload: Some(s3s::dto::AbortIncompleteMultipartUpload {
1577 days_after_initiation: Some(1),
1578 }),
1579 del_marker_expiration: None,
1580 filter: None,
1581 id: Some("one-day-boundary".to_string()),
1582 noncurrent_version_expiration: Some(s3s::dto::NoncurrentVersionExpiration {
1583 noncurrent_days: Some(1),
1584 newer_noncurrent_versions: None,
1585 }),
1586 noncurrent_version_transitions: None,
1587 prefix: Some("boundary/".to_string()),
1588 transitions: None,
1589 }],
1590 };
1591
1592 lc.validate(&ObjectLockConfiguration::default())
1593 .await
1594 .expect("one-day boundary values should be accepted");
1595 }
1596
1597 #[tokio::test]
1598 async fn has_active_rules_accepts_zero_day_expiration() {
1599 let lc = BucketLifecycleConfiguration {
1600 expiry_updated_at: None,
1601 rules: vec![LifecycleRule {
1602 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1603 expiration: Some(LifecycleExpiration {
1604 days: Some(0),
1605 ..Default::default()
1606 }),
1607 abort_incomplete_multipart_upload: None,
1608 del_marker_expiration: None,
1609 filter: None,
1610 id: Some("zero-day-active".to_string()),
1611 noncurrent_version_expiration: None,
1612 noncurrent_version_transitions: None,
1613 prefix: Some("test/".to_string()),
1614 transitions: None,
1615 }],
1616 };
1617
1618 assert!(lc.has_active_rules("test/"));
1619 }
1620
1621 #[test]
1622 fn has_active_rules_requires_valid_del_marker_expiration_days() {
1623 let lifecycle = |days| BucketLifecycleConfiguration {
1624 expiry_updated_at: None,
1625 rules: vec![enabled_rule(None, Some(s3s::dto::DelMarkerExpiration { days }), None)],
1626 };
1627
1628 assert!(lifecycle(Some(1)).has_active_rules(""));
1629 assert!(!lifecycle(Some(0)).has_active_rules(""));
1630 assert!(!lifecycle(None).has_active_rules(""));
1631 }
1632
1633 #[tokio::test]
1634 async fn validate_rejects_zero_noncurrent_expiration_days() {
1635 let lc = BucketLifecycleConfiguration {
1638 expiry_updated_at: None,
1639 rules: vec![LifecycleRule {
1640 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1641 expiration: None,
1642 abort_incomplete_multipart_upload: None,
1643 del_marker_expiration: None,
1644 filter: None,
1645 id: None,
1646 noncurrent_version_expiration: Some(s3s::dto::NoncurrentVersionExpiration {
1647 noncurrent_days: Some(0),
1648 newer_noncurrent_versions: None,
1649 }),
1650 noncurrent_version_transitions: None,
1651 prefix: None,
1652 transitions: None,
1653 }],
1654 };
1655
1656 let err = lc
1657 .validate(&ObjectLockConfiguration::default())
1658 .await
1659 .expect_err("zero-day noncurrent expiration should be rejected");
1660
1661 assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_NONCURRENT_EXPIRATION_DAYS);
1662 }
1663
1664 #[tokio::test]
1665 async fn validate_rejects_negative_noncurrent_expiration_days() {
1666 let lc = BucketLifecycleConfiguration {
1667 expiry_updated_at: None,
1668 rules: vec![LifecycleRule {
1669 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1670 expiration: None,
1671 abort_incomplete_multipart_upload: None,
1672 del_marker_expiration: None,
1673 filter: None,
1674 id: None,
1675 noncurrent_version_expiration: Some(s3s::dto::NoncurrentVersionExpiration {
1676 noncurrent_days: Some(-1),
1677 newer_noncurrent_versions: None,
1678 }),
1679 noncurrent_version_transitions: None,
1680 prefix: None,
1681 transitions: None,
1682 }],
1683 };
1684
1685 let err = lc
1686 .validate(&ObjectLockConfiguration::default())
1687 .await
1688 .expect_err("expected validation error");
1689
1690 assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_NONCURRENT_EXPIRATION_DAYS);
1691 }
1692
1693 #[tokio::test]
1694 async fn validate_accepts_abort_incomplete_multipart_upload_only_rule() {
1695 let lc = BucketLifecycleConfiguration {
1696 expiry_updated_at: None,
1697 rules: vec![LifecycleRule {
1698 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1699 expiration: None,
1700 abort_incomplete_multipart_upload: Some(s3s::dto::AbortIncompleteMultipartUpload {
1701 days_after_initiation: Some(2),
1702 }),
1703 del_marker_expiration: None,
1704 filter: None,
1705 id: Some("abort-only".to_string()),
1706 noncurrent_version_expiration: None,
1707 noncurrent_version_transitions: None,
1708 prefix: Some("test/".to_string()),
1709 transitions: None,
1710 }],
1711 };
1712
1713 lc.validate(&ObjectLockConfiguration::default())
1714 .await
1715 .expect("expected validation to pass");
1716 }
1717
1718 #[tokio::test]
1719 async fn validate_rejects_zero_abort_incomplete_multipart_upload_days() {
1720 let lc = BucketLifecycleConfiguration {
1723 expiry_updated_at: None,
1724 rules: vec![LifecycleRule {
1725 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1726 expiration: None,
1727 abort_incomplete_multipart_upload: Some(s3s::dto::AbortIncompleteMultipartUpload {
1728 days_after_initiation: Some(0),
1729 }),
1730 del_marker_expiration: None,
1731 filter: None,
1732 id: Some("abort-zero".to_string()),
1733 noncurrent_version_expiration: None,
1734 noncurrent_version_transitions: None,
1735 prefix: Some("test/".to_string()),
1736 transitions: None,
1737 }],
1738 };
1739
1740 let err = lc
1741 .validate(&ObjectLockConfiguration::default())
1742 .await
1743 .expect_err("zero-day abort incomplete multipart upload should be rejected");
1744
1745 assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_ABORT_INCOMPLETE_MPU_DAYS);
1746 }
1747
1748 #[tokio::test]
1749 async fn validate_rejects_missing_abort_incomplete_multipart_upload_days() {
1750 let lc = BucketLifecycleConfiguration {
1751 expiry_updated_at: None,
1752 rules: vec![LifecycleRule {
1753 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1754 expiration: None,
1755 abort_incomplete_multipart_upload: Some(s3s::dto::AbortIncompleteMultipartUpload {
1756 days_after_initiation: None,
1757 }),
1758 del_marker_expiration: None,
1759 filter: None,
1760 id: Some("abort-missing".to_string()),
1761 noncurrent_version_expiration: None,
1762 noncurrent_version_transitions: None,
1763 prefix: Some("test/".to_string()),
1764 transitions: None,
1765 }],
1766 };
1767
1768 let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
1769
1770 assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_ABORT_INCOMPLETE_MPU_DAYS);
1771 }
1772
1773 #[tokio::test]
1774 async fn validate_rejects_negative_abort_incomplete_multipart_upload_days() {
1775 let lc = BucketLifecycleConfiguration {
1776 expiry_updated_at: None,
1777 rules: vec![LifecycleRule {
1778 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1779 expiration: None,
1780 abort_incomplete_multipart_upload: Some(s3s::dto::AbortIncompleteMultipartUpload {
1781 days_after_initiation: Some(-1),
1782 }),
1783 del_marker_expiration: None,
1784 filter: None,
1785 id: Some("abort-negative".to_string()),
1786 noncurrent_version_expiration: None,
1787 noncurrent_version_transitions: None,
1788 prefix: Some("test/".to_string()),
1789 transitions: None,
1790 }],
1791 };
1792
1793 let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
1794
1795 assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_ABORT_INCOMPLETE_MPU_DAYS);
1796 }
1797
1798 #[tokio::test]
1799 #[serial]
1800 async fn abort_incomplete_multipart_upload_due_accepts_zero_days() {
1801 let initiated = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
1802 let lc = BucketLifecycleConfiguration {
1803 expiry_updated_at: None,
1804 rules: vec![LifecycleRule {
1805 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1806 expiration: None,
1807 abort_incomplete_multipart_upload: Some(s3s::dto::AbortIncompleteMultipartUpload {
1808 days_after_initiation: Some(0),
1809 }),
1810 del_marker_expiration: None,
1811 filter: None,
1812 id: Some("abort-zero".to_string()),
1813 noncurrent_version_expiration: None,
1814 noncurrent_version_transitions: None,
1815 prefix: Some("test/".to_string()),
1816 transitions: None,
1817 }],
1818 };
1819 let opts = ObjectOpts {
1820 name: "test/object".to_string(),
1821 mod_time: Some(initiated),
1822 ..Default::default()
1823 };
1824
1825 let (due, rule_id) = abort_incomplete_multipart_upload_due(&lc, &opts)
1826 .await
1827 .expect("zero-day abort rule should be due");
1828
1829 assert_eq!(rule_id, "abort-zero");
1830 assert_eq!(due, OffsetDateTime::UNIX_EPOCH);
1831 }
1832
1833 #[tokio::test]
1834 async fn validate_rejects_non_midnight_expiration_date() {
1835 let lc = BucketLifecycleConfiguration {
1836 expiry_updated_at: None,
1837 rules: vec![LifecycleRule {
1838 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1839 expiration: Some(LifecycleExpiration {
1840 date: Some(OffsetDateTime::from_unix_timestamp(20_000_101).unwrap().into()),
1841 ..Default::default()
1842 }),
1843 abort_incomplete_multipart_upload: None,
1844 del_marker_expiration: None,
1845 filter: None,
1846 id: None,
1847 noncurrent_version_expiration: None,
1848 noncurrent_version_transitions: None,
1849 prefix: None,
1850 transitions: None,
1851 }],
1852 };
1853
1854 let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
1855
1856 assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_EXPIRATION_DATE_NOT_MIDNIGHT);
1857 }
1858
1859 #[tokio::test]
1860 #[serial]
1861 async fn predict_expiration_selects_closest_expiry_for_put_object() {
1862 let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
1863 let lc = BucketLifecycleConfiguration {
1864 expiry_updated_at: None,
1865 rules: vec![
1866 LifecycleRule {
1867 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1868 expiration: Some(LifecycleExpiration {
1869 days: Some(30),
1870 ..Default::default()
1871 }),
1872 abort_incomplete_multipart_upload: None,
1873 del_marker_expiration: None,
1874 filter: None,
1875 id: Some("rule-days".to_string()),
1876 noncurrent_version_expiration: None,
1877 noncurrent_version_transitions: None,
1878 prefix: None,
1879 transitions: None,
1880 },
1881 LifecycleRule {
1882 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1883 expiration: Some(LifecycleExpiration {
1884 date: Some((base_time + Duration::days(1)).into()),
1885 ..Default::default()
1886 }),
1887 abort_incomplete_multipart_upload: None,
1888 del_marker_expiration: None,
1889 filter: None,
1890 id: Some("rule-date".to_string()),
1891 noncurrent_version_expiration: None,
1892 noncurrent_version_transitions: None,
1893 prefix: None,
1894 transitions: None,
1895 },
1896 ],
1897 };
1898 let opts = ObjectOpts {
1899 name: "obj".to_string(),
1900 mod_time: Some(base_time),
1901 is_latest: true,
1902 version_id: None,
1903 ..Default::default()
1904 };
1905
1906 let event = lc.predict_expiration(&opts).await;
1907 let expected = base_time + Duration::days(1);
1908
1909 assert_eq!(event.action, IlmAction::DeleteAction);
1910 assert_eq!(event.rule_id, "rule-date");
1911 assert_eq!(event.due, Some(expected));
1912 }
1913
1914 #[tokio::test]
1915 async fn validate_accepts_multiple_rules_without_ids() {
1916 let lc = BucketLifecycleConfiguration {
1917 expiry_updated_at: None,
1918 rules: vec![
1919 LifecycleRule {
1920 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1921 expiration: Some(LifecycleExpiration {
1922 days: Some(30),
1923 ..Default::default()
1924 }),
1925 abort_incomplete_multipart_upload: None,
1926 del_marker_expiration: None,
1927 filter: None,
1928 id: None,
1929 noncurrent_version_expiration: None,
1930 noncurrent_version_transitions: None,
1931 prefix: None,
1932 transitions: None,
1933 },
1934 LifecycleRule {
1935 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1936 expiration: Some(LifecycleExpiration {
1937 days: Some(31),
1938 ..Default::default()
1939 }),
1940 abort_incomplete_multipart_upload: None,
1941 del_marker_expiration: None,
1942 filter: None,
1943 id: None,
1944 noncurrent_version_expiration: None,
1945 noncurrent_version_transitions: None,
1946 prefix: None,
1947 transitions: None,
1948 },
1949 ],
1950 };
1951
1952 lc.validate(&ObjectLockConfiguration::default())
1953 .await
1954 .expect("expected validation to pass");
1955 }
1956
1957 #[tokio::test]
1958 async fn validate_rejects_rule_id_too_long() {
1959 let lc = BucketLifecycleConfiguration {
1960 expiry_updated_at: None,
1961 rules: vec![LifecycleRule {
1962 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1963 expiration: Some(LifecycleExpiration {
1964 days: Some(30),
1965 ..Default::default()
1966 }),
1967 abort_incomplete_multipart_upload: None,
1968 del_marker_expiration: None,
1969 filter: None,
1970 id: Some("a".repeat(256)),
1971 noncurrent_version_expiration: None,
1972 noncurrent_version_transitions: None,
1973 prefix: None,
1974 transitions: None,
1975 }],
1976 };
1977
1978 let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
1979
1980 assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_RULE_ID_TOO_LONG);
1981 }
1982
1983 #[tokio::test]
1984 async fn validate_rejects_duplicate_rule_ids() {
1985 let lc = BucketLifecycleConfiguration {
1986 expiry_updated_at: None,
1987 rules: vec![
1988 LifecycleRule {
1989 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1990 expiration: Some(LifecycleExpiration {
1991 days: Some(1),
1992 ..Default::default()
1993 }),
1994 abort_incomplete_multipart_upload: None,
1995 del_marker_expiration: None,
1996 filter: None,
1997 id: Some("dup-rule".to_string()),
1998 noncurrent_version_expiration: None,
1999 noncurrent_version_transitions: None,
2000 prefix: None,
2001 transitions: None,
2002 },
2003 LifecycleRule {
2004 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2005 expiration: Some(LifecycleExpiration {
2006 days: Some(2),
2007 ..Default::default()
2008 }),
2009 abort_incomplete_multipart_upload: None,
2010 filter: None,
2011 id: Some("dup-rule".to_string()),
2012 noncurrent_version_expiration: None,
2013 noncurrent_version_transitions: None,
2014 prefix: None,
2015 transitions: None,
2016 del_marker_expiration: None,
2017 },
2018 ],
2019 };
2020
2021 let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
2022 assert_eq!(err.to_string(), ERR_LIFECYCLE_DUPLICATE_ID);
2023 }
2024
2025 #[tokio::test]
2026 async fn validate_rejects_transition_without_storage_class() {
2027 let lc = BucketLifecycleConfiguration {
2028 expiry_updated_at: None,
2029 rules: vec![LifecycleRule {
2030 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2031 expiration: None,
2032 abort_incomplete_multipart_upload: None,
2033 del_marker_expiration: None,
2034 filter: None,
2035 id: Some("transition-no-storage".to_string()),
2036 noncurrent_version_expiration: None,
2037 noncurrent_version_transitions: None,
2038 prefix: None,
2039 transitions: Some(vec![Transition {
2040 days: Some(1),
2041 date: None,
2042 storage_class: None,
2043 }]),
2044 }],
2045 };
2046
2047 let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
2048
2049 assert_eq!(err.to_string(), "ERR_XML_NOT_WELL_FORMED");
2050 }
2051
2052 #[tokio::test]
2053 async fn validate_rejects_transition_without_date_or_days() {
2054 let lc = BucketLifecycleConfiguration {
2055 expiry_updated_at: None,
2056 rules: vec![LifecycleRule {
2057 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2058 expiration: None,
2059 abort_incomplete_multipart_upload: None,
2060 del_marker_expiration: None,
2061 filter: None,
2062 id: Some("transition-no-schedule".to_string()),
2063 noncurrent_version_expiration: None,
2064 noncurrent_version_transitions: None,
2065 prefix: None,
2066 transitions: Some(vec![Transition {
2067 days: None,
2068 date: None,
2069 storage_class: Some(TransitionStorageClass::from_static("WARM")),
2070 }]),
2071 }],
2072 };
2073
2074 let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
2075
2076 assert!(err.to_string().contains("Exactly one of Days"));
2077 }
2078
2079 #[tokio::test]
2080 async fn validate_rejects_noncurrent_transition_without_days() {
2081 let lc = BucketLifecycleConfiguration {
2082 expiry_updated_at: None,
2083 rules: vec![LifecycleRule {
2084 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2085 expiration: None,
2086 abort_incomplete_multipart_upload: None,
2087 del_marker_expiration: None,
2088 filter: None,
2089 id: Some("noncurrent-transition-no-days".to_string()),
2090 noncurrent_version_expiration: None,
2091 noncurrent_version_transitions: Some(vec![NoncurrentVersionTransition {
2092 noncurrent_days: None,
2093 newer_noncurrent_versions: None,
2094 storage_class: Some(TransitionStorageClass::from_static("COLD")),
2095 }]),
2096 prefix: None,
2097 transitions: None,
2098 }],
2099 };
2100
2101 let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
2102
2103 assert!(err.to_string().contains("Exactly one of Days"));
2104 }
2105
2106 #[tokio::test]
2107 #[serial]
2108 async fn empty_transition_vectors_are_not_active_or_due() {
2109 let lc = BucketLifecycleConfiguration {
2110 expiry_updated_at: None,
2111 rules: vec![LifecycleRule {
2112 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2113 expiration: None,
2114 abort_incomplete_multipart_upload: None,
2115 del_marker_expiration: None,
2116 filter: None,
2117 id: Some("empty-transition".to_string()),
2118 noncurrent_version_expiration: None,
2119 noncurrent_version_transitions: Some(vec![]),
2120 prefix: None,
2121 transitions: Some(vec![]),
2122 }],
2123 };
2124 let opts = ObjectOpts {
2125 name: "obj".to_string(),
2126 mod_time: Some(OffsetDateTime::from_unix_timestamp(1_000_000).unwrap()),
2127 is_latest: true,
2128 ..Default::default()
2129 };
2130
2131 assert!(!lc.has_transition().await);
2132 assert!(!lc.has_active_rules("obj"));
2133 assert_eq!(lc.eval_inner(&opts, OffsetDateTime::now_utc(), 0).await.action, IlmAction::NoneAction);
2134 }
2135
2136 #[tokio::test]
2137 #[serial]
2138 async fn eval_inner_expires_latest_object_after_days_due() {
2139 let base_time = datetime!(2025-01-15 10:30:45 UTC);
2140 let lc = BucketLifecycleConfiguration {
2141 expiry_updated_at: None,
2142 rules: vec![LifecycleRule {
2143 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2144 expiration: Some(LifecycleExpiration {
2145 days: Some(1),
2146 ..Default::default()
2147 }),
2148 abort_incomplete_multipart_upload: None,
2149 del_marker_expiration: None,
2150 filter: None,
2151 id: Some("expire-days".to_string()),
2152 noncurrent_version_expiration: None,
2153 noncurrent_version_transitions: None,
2154 prefix: None,
2155 transitions: None,
2156 }],
2157 };
2158
2159 let opts = ObjectOpts {
2160 name: "obj".to_string(),
2161 mod_time: Some(base_time),
2162 is_latest: true,
2163 ..Default::default()
2164 };
2165 let event = lc.eval_inner(&opts, datetime!(2025-01-17 00:00:00 UTC), 0).await;
2166
2167 assert_eq!(event.action, IlmAction::DeleteAction);
2168 assert_eq!(event.rule_id, "expire-days");
2169 assert_eq!(event.due, Some(datetime!(2025-01-17 00:00:00 UTC)));
2170 }
2171
2172 #[tokio::test]
2173 #[serial]
2174 async fn eval_inner_keeps_latest_object_before_days_due() {
2175 let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
2176 let lc = BucketLifecycleConfiguration {
2177 expiry_updated_at: None,
2178 rules: vec![LifecycleRule {
2179 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2180 expiration: Some(LifecycleExpiration {
2181 days: Some(2),
2182 ..Default::default()
2183 }),
2184 abort_incomplete_multipart_upload: None,
2185 del_marker_expiration: None,
2186 filter: None,
2187 id: Some("expire-days".to_string()),
2188 noncurrent_version_expiration: None,
2189 noncurrent_version_transitions: None,
2190 prefix: None,
2191 transitions: None,
2192 }],
2193 };
2194
2195 let opts = ObjectOpts {
2196 name: "obj".to_string(),
2197 mod_time: Some(base_time),
2198 is_latest: true,
2199 ..Default::default()
2200 };
2201 let event = lc.eval_inner(&opts, base_time + Duration::hours(12), 0).await;
2202
2203 assert_eq!(event.action, IlmAction::NoneAction);
2204 }
2205
2206 #[tokio::test]
2207 #[serial]
2208 async fn eval_inner_transitions_latest_object_after_days_due() {
2209 let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
2210 let lc = BucketLifecycleConfiguration {
2211 expiry_updated_at: None,
2212 rules: vec![LifecycleRule {
2213 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2214 expiration: None,
2215 abort_incomplete_multipart_upload: None,
2216 del_marker_expiration: None,
2217 filter: None,
2218 id: Some("transition-days".to_string()),
2219 noncurrent_version_expiration: None,
2220 noncurrent_version_transitions: None,
2221 prefix: None,
2222 transitions: Some(vec![Transition {
2223 days: Some(1),
2224 date: None,
2225 storage_class: Some(TransitionStorageClass::from_static("COLDTIER44")),
2226 }]),
2227 }],
2228 };
2229
2230 let opts = ObjectOpts {
2231 name: "obj".to_string(),
2232 mod_time: Some(base_time),
2233 is_latest: true,
2234 transition_status: "".to_string(),
2235 ..Default::default()
2236 };
2237 let event = lc.eval_inner(&opts, base_time + Duration::days(2), 0).await;
2238
2239 assert_eq!(event.action, IlmAction::TransitionAction);
2240 assert_eq!(event.rule_id, "transition-days");
2241 assert_eq!(event.storage_class, "COLDTIER44");
2242 }
2243
2244 #[tokio::test]
2245 #[serial]
2246 async fn eval_inner_transitions_latest_object_after_date_due() {
2247 let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
2248 let transition_date = base_time - Duration::days(1);
2249 let lc = BucketLifecycleConfiguration {
2250 expiry_updated_at: None,
2251 rules: vec![LifecycleRule {
2252 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2253 expiration: None,
2254 abort_incomplete_multipart_upload: None,
2255 del_marker_expiration: None,
2256 filter: None,
2257 id: Some("transition-date".to_string()),
2258 noncurrent_version_expiration: None,
2259 noncurrent_version_transitions: None,
2260 prefix: None,
2261 transitions: Some(vec![Transition {
2262 days: None,
2263 date: Some(transition_date.into()),
2264 storage_class: Some(TransitionStorageClass::from_static("WARM")),
2265 }]),
2266 }],
2267 };
2268
2269 let opts = ObjectOpts {
2270 name: "obj".to_string(),
2271 mod_time: Some(base_time),
2272 is_latest: true,
2273 transition_status: "".to_string(),
2274 ..Default::default()
2275 };
2276 let event = lc.eval_inner(&opts, base_time + Duration::days(1), 0).await;
2277
2278 assert_eq!(event.action, IlmAction::TransitionAction);
2279 assert_eq!(event.rule_id, "transition-date");
2280 assert_eq!(event.storage_class, "WARM");
2281 assert_eq!(event.due, Some(transition_date));
2282 }
2283
2284 #[tokio::test]
2285 #[serial]
2286 async fn eval_inner_selects_earliest_due_among_multiple_past_due_events() {
2287 let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
2288 let lc = BucketLifecycleConfiguration {
2292 expiry_updated_at: None,
2293 rules: vec![
2294 LifecycleRule {
2295 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2296 expiration: Some(LifecycleExpiration {
2297 days: Some(5),
2298 ..Default::default()
2299 }),
2300 abort_incomplete_multipart_upload: None,
2301 del_marker_expiration: None,
2302 filter: None,
2303 id: Some("delete-late".to_string()),
2304 noncurrent_version_expiration: None,
2305 noncurrent_version_transitions: None,
2306 prefix: None,
2307 transitions: None,
2308 },
2309 LifecycleRule {
2310 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2311 expiration: Some(LifecycleExpiration {
2312 days: Some(1),
2313 ..Default::default()
2314 }),
2315 abort_incomplete_multipart_upload: None,
2316 del_marker_expiration: None,
2317 filter: None,
2318 id: Some("delete-early".to_string()),
2319 noncurrent_version_expiration: None,
2320 noncurrent_version_transitions: None,
2321 prefix: None,
2322 transitions: None,
2323 },
2324 LifecycleRule {
2325 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2326 expiration: None,
2327 abort_incomplete_multipart_upload: None,
2328 del_marker_expiration: None,
2329 filter: None,
2330 id: Some("transition-mid".to_string()),
2331 noncurrent_version_expiration: None,
2332 noncurrent_version_transitions: None,
2333 prefix: None,
2334 transitions: Some(vec![Transition {
2335 days: Some(3),
2336 date: None,
2337 storage_class: Some(TransitionStorageClass::from_static("COLDTIER")),
2338 }]),
2339 },
2340 ],
2341 };
2342
2343 let opts = ObjectOpts {
2344 name: "obj".to_string(),
2345 mod_time: Some(base_time),
2346 is_latest: true,
2347 transition_status: "".to_string(),
2348 ..Default::default()
2349 };
2350 let event = lc.eval_inner(&opts, base_time + Duration::days(10), 0).await;
2351
2352 assert_eq!(event.action, IlmAction::DeleteAction);
2353 assert_eq!(event.rule_id, "delete-early");
2354 }
2355
2356 #[tokio::test]
2357 #[serial]
2358 async fn eval_inner_does_not_panic_on_many_equal_due_events() {
2359 let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
2360 let rules: Vec<LifecycleRule> = (0..25)
2365 .map(|i| LifecycleRule {
2366 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2367 expiration: Some(LifecycleExpiration {
2368 days: Some(1),
2369 ..Default::default()
2370 }),
2371 abort_incomplete_multipart_upload: None,
2372 del_marker_expiration: None,
2373 filter: None,
2374 id: Some(format!("rule-{i:02}")),
2375 noncurrent_version_expiration: None,
2376 noncurrent_version_transitions: None,
2377 prefix: None,
2378 transitions: None,
2379 })
2380 .collect();
2381 let lc = BucketLifecycleConfiguration {
2382 expiry_updated_at: None,
2383 rules,
2384 };
2385
2386 let opts = ObjectOpts {
2387 name: "obj".to_string(),
2388 mod_time: Some(base_time),
2389 is_latest: true,
2390 ..Default::default()
2391 };
2392 let event = lc.eval_inner(&opts, base_time + Duration::days(10), 0).await;
2393
2394 assert_eq!(event.action, IlmAction::DeleteAction);
2395 assert_eq!(event.rule_id, "rule-00");
2396 }
2397
2398 #[tokio::test]
2399 #[serial]
2400 async fn eval_inner_expires_noncurrent_version_after_due() {
2401 let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
2402 let lc = BucketLifecycleConfiguration {
2403 expiry_updated_at: None,
2404 rules: vec![LifecycleRule {
2405 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2406 expiration: None,
2407 abort_incomplete_multipart_upload: None,
2408 del_marker_expiration: None,
2409 filter: None,
2410 id: Some("noncurrent-expire".to_string()),
2411 noncurrent_version_expiration: Some(s3s::dto::NoncurrentVersionExpiration {
2412 noncurrent_days: Some(1),
2413 newer_noncurrent_versions: None,
2414 }),
2415 noncurrent_version_transitions: None,
2416 prefix: None,
2417 transitions: None,
2418 }],
2419 };
2420
2421 let opts = ObjectOpts {
2422 name: "obj".to_string(),
2423 mod_time: Some(base_time),
2424 successor_mod_time: Some(base_time),
2425 is_latest: false,
2426 version_id: Some(Uuid::new_v4()),
2427 ..Default::default()
2428 };
2429 let event = lc.eval_inner(&opts, base_time + Duration::days(2), 0).await;
2430
2431 assert_eq!(event.action, IlmAction::DeleteVersionAction);
2432 assert_eq!(event.rule_id, "noncurrent-expire");
2433 assert_eq!(event.due, Some(expected_expiry_time(base_time, 1)));
2434 }
2435
2436 #[tokio::test]
2437 #[serial]
2438 async fn eval_inner_skips_noncurrent_expiration_without_successor() {
2439 let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).expect("valid fixed test timestamp");
2440 let lc = BucketLifecycleConfiguration {
2441 expiry_updated_at: None,
2442 rules: vec![LifecycleRule {
2443 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2444 expiration: None,
2445 abort_incomplete_multipart_upload: None,
2446 del_marker_expiration: None,
2447 filter: None,
2448 id: Some("noncurrent-expire".to_string()),
2449 noncurrent_version_expiration: Some(s3s::dto::NoncurrentVersionExpiration {
2450 noncurrent_days: Some(1),
2451 newer_noncurrent_versions: None,
2452 }),
2453 noncurrent_version_transitions: None,
2454 prefix: None,
2455 transitions: None,
2456 }],
2457 };
2458
2459 let opts = ObjectOpts {
2460 name: "obj".to_string(),
2461 mod_time: Some(base_time),
2462 successor_mod_time: None,
2463 is_latest: false,
2464 version_id: Some(Uuid::new_v4()),
2465 ..Default::default()
2466 };
2467 let event = lc.eval_inner(&opts, base_time + Duration::days(2), 0).await;
2468
2469 assert_eq!(event.action, IlmAction::NoneAction);
2470 }
2471
2472 #[tokio::test]
2473 #[serial]
2474 async fn eval_inner_missing_successor_does_not_skip_noncurrent_transition() {
2475 let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).expect("valid fixed test timestamp");
2476 let lc = BucketLifecycleConfiguration {
2477 expiry_updated_at: None,
2478 rules: vec![LifecycleRule {
2479 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2480 expiration: None,
2481 abort_incomplete_multipart_upload: None,
2482 del_marker_expiration: None,
2483 filter: None,
2484 id: Some("noncurrent-expire-and-transition".to_string()),
2485 noncurrent_version_expiration: Some(s3s::dto::NoncurrentVersionExpiration {
2486 noncurrent_days: Some(1),
2487 newer_noncurrent_versions: None,
2488 }),
2489 noncurrent_version_transitions: Some(vec![NoncurrentVersionTransition {
2490 noncurrent_days: Some(1),
2491 newer_noncurrent_versions: None,
2492 storage_class: Some(TransitionStorageClass::from_static("COLDTIER44")),
2493 }]),
2494 prefix: None,
2495 transitions: None,
2496 }],
2497 };
2498
2499 let opts = ObjectOpts {
2500 name: "obj".to_string(),
2501 mod_time: Some(base_time),
2502 successor_mod_time: None,
2503 is_latest: false,
2504 transition_status: "".to_string(),
2505 version_id: Some(Uuid::new_v4()),
2506 ..Default::default()
2507 };
2508 let event = lc.eval_inner(&opts, datetime!(2100-01-01 00:00:00 UTC), 0).await;
2509
2510 assert_eq!(event.action, IlmAction::TransitionVersionAction);
2511 assert_eq!(event.rule_id, "noncurrent-expire-and-transition");
2512 assert_eq!(event.storage_class, "COLDTIER44");
2513 }
2514
2515 #[tokio::test]
2516 #[serial]
2517 async fn eval_inner_noncurrent_expiration_one_day_respects_due_boundary() {
2518 let successor_time = datetime!(2025-06-15 12:00:00 UTC);
2519 let due = expected_expiry_time(successor_time, 1);
2520 let lc = BucketLifecycleConfiguration {
2521 expiry_updated_at: None,
2522 rules: vec![LifecycleRule {
2523 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2524 expiration: None,
2525 abort_incomplete_multipart_upload: None,
2526 del_marker_expiration: None,
2527 filter: None,
2528 id: Some("noncurrent-one-day".to_string()),
2529 noncurrent_version_expiration: Some(s3s::dto::NoncurrentVersionExpiration {
2530 noncurrent_days: Some(1),
2531 newer_noncurrent_versions: None,
2532 }),
2533 noncurrent_version_transitions: None,
2534 prefix: None,
2535 transitions: None,
2536 }],
2537 };
2538
2539 let opts = ObjectOpts {
2540 name: "obj".to_string(),
2541 mod_time: Some(successor_time - Duration::seconds(1)),
2542 successor_mod_time: Some(successor_time),
2543 is_latest: false,
2544 version_id: Some(Uuid::new_v4()),
2545 ..Default::default()
2546 };
2547
2548 let before_due = lc.eval_inner(&opts, due - Duration::seconds(1), 0).await;
2549 let at_due = lc.eval_inner(&opts, due, 0).await;
2550
2551 assert_eq!(before_due.action, IlmAction::NoneAction);
2552 assert_eq!(at_due.action, IlmAction::DeleteVersionAction);
2553 assert_eq!(at_due.rule_id, "noncurrent-one-day");
2554 assert_eq!(at_due.due, Some(due));
2555 }
2556
2557 #[tokio::test]
2558 #[serial]
2559 async fn eval_inner_expires_noncurrent_version_immediately_when_zero_days() {
2560 let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
2561 let lc = BucketLifecycleConfiguration {
2562 expiry_updated_at: None,
2563 rules: vec![LifecycleRule {
2564 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2565 expiration: None,
2566 abort_incomplete_multipart_upload: None,
2567 del_marker_expiration: None,
2568 filter: None,
2569 id: Some("noncurrent-expire-immediate".to_string()),
2570 noncurrent_version_expiration: Some(s3s::dto::NoncurrentVersionExpiration {
2571 noncurrent_days: Some(0),
2572 newer_noncurrent_versions: None,
2573 }),
2574 noncurrent_version_transitions: None,
2575 prefix: None,
2576 transitions: None,
2577 }],
2578 };
2579
2580 let opts = ObjectOpts {
2581 name: "obj".to_string(),
2582 mod_time: Some(base_time),
2583 successor_mod_time: Some(base_time),
2584 is_latest: false,
2585 version_id: Some(Uuid::new_v4()),
2586 ..Default::default()
2587 };
2588 let event = lc.eval_inner(&opts, base_time, 0).await;
2589
2590 assert_eq!(event.action, IlmAction::DeleteVersionAction);
2591 assert_eq!(event.rule_id, "noncurrent-expire-immediate");
2592 assert_eq!(event.due, Some(expected_expiry_time(base_time, 0)));
2593 }
2594
2595 #[tokio::test]
2596 #[serial]
2597 async fn eval_inner_transitions_noncurrent_version_after_due() {
2598 let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
2599 let lc = BucketLifecycleConfiguration {
2600 expiry_updated_at: None,
2601 rules: vec![LifecycleRule {
2602 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2603 expiration: None,
2604 abort_incomplete_multipart_upload: None,
2605 del_marker_expiration: None,
2606 filter: None,
2607 id: Some("noncurrent-transition".to_string()),
2608 noncurrent_version_expiration: None,
2609 noncurrent_version_transitions: Some(vec![NoncurrentVersionTransition {
2610 noncurrent_days: Some(1),
2611 newer_noncurrent_versions: None,
2612 storage_class: Some(TransitionStorageClass::from_static("COLDTIER44")),
2613 }]),
2614 prefix: None,
2615 transitions: None,
2616 }],
2617 };
2618
2619 let opts = ObjectOpts {
2620 name: "obj".to_string(),
2621 mod_time: Some(base_time),
2622 successor_mod_time: Some(base_time),
2623 is_latest: false,
2624 transition_status: "".to_string(),
2625 version_id: Some(Uuid::new_v4()),
2626 ..Default::default()
2627 };
2628 let event = lc.eval_inner(&opts, base_time + Duration::days(2), 0).await;
2629
2630 assert_eq!(event.action, IlmAction::TransitionVersionAction);
2631 assert_eq!(event.rule_id, "noncurrent-transition");
2632 assert_eq!(event.storage_class, "COLDTIER44");
2633 }
2634
2635 #[tokio::test]
2636 async fn noncurrent_versions_expiration_limit_returns_configured_limits() {
2637 let lc = Arc::new(BucketLifecycleConfiguration {
2638 expiry_updated_at: None,
2639 rules: vec![LifecycleRule {
2640 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2641 expiration: None,
2642 abort_incomplete_multipart_upload: None,
2643 del_marker_expiration: None,
2644 filter: None,
2645 id: Some("noncurrent-limit".to_string()),
2646 noncurrent_version_expiration: Some(s3s::dto::NoncurrentVersionExpiration {
2647 noncurrent_days: Some(7),
2648 newer_noncurrent_versions: Some(3),
2649 }),
2650 noncurrent_version_transitions: None,
2651 prefix: None,
2652 transitions: None,
2653 }],
2654 });
2655
2656 let opts = ObjectOpts {
2657 name: "obj".to_string(),
2658 mod_time: Some(OffsetDateTime::from_unix_timestamp(1_000_000).unwrap()),
2659 is_latest: false,
2660 version_id: Some(Uuid::new_v4()),
2661 ..Default::default()
2662 };
2663 let event = lc.noncurrent_versions_expiration_limit(&opts).await;
2664
2665 assert_eq!(event.action, IlmAction::DeleteVersionAction);
2666 assert_eq!(event.rule_id, "noncurrent-limit");
2667 assert_eq!(event.noncurrent_days, 7);
2668 assert_eq!(event.newer_noncurrent_versions, 3);
2669 }
2670
2671 #[tokio::test]
2672 #[serial]
2673 async fn evaluator_honors_newer_noncurrent_versions_retention_count() {
2674 let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
2675 let lc = Arc::new(BucketLifecycleConfiguration {
2676 expiry_updated_at: None,
2677 rules: vec![LifecycleRule {
2678 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2679 expiration: None,
2680 abort_incomplete_multipart_upload: None,
2681 del_marker_expiration: None,
2682 filter: None,
2683 id: Some("retain-two-noncurrent".to_string()),
2684 noncurrent_version_expiration: Some(s3s::dto::NoncurrentVersionExpiration {
2685 noncurrent_days: Some(1),
2686 newer_noncurrent_versions: Some(2),
2687 }),
2688 noncurrent_version_transitions: None,
2689 prefix: None,
2690 transitions: None,
2691 }],
2692 });
2693 let mut objs = vec![ObjectOpts {
2694 name: "obj".to_string(),
2695 mod_time: Some(base_time + Duration::days(4)),
2696 successor_mod_time: None,
2697 is_latest: true,
2698 version_id: Some(Uuid::new_v4()),
2699 num_versions: 5,
2700 ..Default::default()
2701 }];
2702 for days_ago in (0..4).rev() {
2703 objs.push(ObjectOpts {
2704 name: "obj".to_string(),
2705 mod_time: Some(base_time + Duration::days(days_ago)),
2706 successor_mod_time: Some(base_time + Duration::days(days_ago + 1)),
2707 is_latest: false,
2708 version_id: Some(Uuid::new_v4()),
2709 num_versions: 5,
2710 ..Default::default()
2711 });
2712 }
2713
2714 let events = crate::evaluator::Evaluator::new(lc)
2715 .eval(&objs)
2716 .await
2717 .expect("version group should evaluate");
2718
2719 assert_eq!(events[1].action, IlmAction::NoneAction);
2720 assert_eq!(events[2].action, IlmAction::NoneAction);
2721 assert_eq!(events[3].action, IlmAction::DeleteVersionAction);
2722 assert_eq!(events[4].action, IlmAction::DeleteVersionAction);
2723 }
2724
2725 #[tokio::test]
2726 async fn validate_rejects_invalid_status_case_sensitive() {
2727 let lc = BucketLifecycleConfiguration {
2728 expiry_updated_at: None,
2729 rules: vec![LifecycleRule {
2730 status: ExpirationStatus::from_static("enabled"),
2731 expiration: Some(LifecycleExpiration {
2732 days: Some(30),
2733 ..Default::default()
2734 }),
2735 abort_incomplete_multipart_upload: None,
2736 del_marker_expiration: None,
2737 filter: None,
2738 id: None,
2739 noncurrent_version_expiration: None,
2740 noncurrent_version_transitions: None,
2741 prefix: None,
2742 transitions: None,
2743 }],
2744 };
2745
2746 let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
2747
2748 assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_RULE_STATUS);
2749 }
2750
2751 #[tokio::test]
2752 async fn filter_rules_respects_filter_prefix() {
2753 let filter = LifecycleRuleFilter {
2754 prefix: Some("prefix".to_string()),
2755 ..Default::default()
2756 };
2757 let lc = BucketLifecycleConfiguration {
2758 expiry_updated_at: None,
2759 rules: vec![LifecycleRule {
2760 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2761 expiration: Some(LifecycleExpiration {
2762 days: Some(30),
2763 ..Default::default()
2764 }),
2765 abort_incomplete_multipart_upload: None,
2766 filter: Some(filter),
2767 id: Some("rule".to_string()),
2768 noncurrent_version_expiration: None,
2769 noncurrent_version_transitions: None,
2770 prefix: None,
2771 transitions: None,
2772 del_marker_expiration: None,
2773 }],
2774 };
2775
2776 let match_obj = ObjectOpts {
2777 name: "prefix/file".to_string(),
2778 mod_time: Some(OffsetDateTime::from_unix_timestamp(1_000_000).unwrap()),
2779 is_latest: true,
2780 ..Default::default()
2781 };
2782 let matched = lc.filter_rules(&match_obj).await.unwrap();
2783 assert_eq!(matched.len(), 1);
2784
2785 let non_match_obj = ObjectOpts {
2786 name: "other/file".to_string(),
2787 mod_time: Some(OffsetDateTime::from_unix_timestamp(1_000_000).unwrap()),
2788 is_latest: true,
2789 ..Default::default()
2790 };
2791 let not_matched = lc.filter_rules(&non_match_obj).await.unwrap();
2792 assert_eq!(not_matched.len(), 0);
2793 }
2794
2795 #[tokio::test]
2796 async fn filter_rules_respects_filter_and_prefix() {
2797 let and = s3s::dto::LifecycleRuleAndOperator {
2798 prefix: Some("prefix".to_string()),
2799 ..Default::default()
2800 };
2801 let filter = LifecycleRuleFilter {
2802 and: Some(and),
2803 ..Default::default()
2804 };
2805
2806 let lc = BucketLifecycleConfiguration {
2807 expiry_updated_at: None,
2808 rules: vec![LifecycleRule {
2809 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2810 expiration: Some(LifecycleExpiration {
2811 days: Some(30),
2812 ..Default::default()
2813 }),
2814 abort_incomplete_multipart_upload: None,
2815 filter: Some(filter),
2816 id: Some("rule-and-prefix".to_string()),
2817 noncurrent_version_expiration: None,
2818 noncurrent_version_transitions: None,
2819 prefix: None,
2820 transitions: None,
2821 del_marker_expiration: None,
2822 }],
2823 };
2824
2825 let match_obj = ObjectOpts {
2826 name: "prefix/file".to_string(),
2827 mod_time: Some(OffsetDateTime::from_unix_timestamp(1_000_000).unwrap()),
2828 is_latest: true,
2829 ..Default::default()
2830 };
2831 let matched = lc.filter_rules(&match_obj).await.unwrap();
2832 assert_eq!(matched.len(), 1);
2833
2834 let non_match_obj = ObjectOpts {
2835 name: "other/file".to_string(),
2836 mod_time: Some(OffsetDateTime::from_unix_timestamp(1_000_000).unwrap()),
2837 is_latest: true,
2838 ..Default::default()
2839 };
2840 let not_matched = lc.filter_rules(&non_match_obj).await.unwrap();
2841 assert_eq!(not_matched.len(), 0);
2842 }
2843
2844 #[tokio::test]
2845 async fn filter_rules_respects_filter_tag() {
2846 let filter = LifecycleRuleFilter {
2847 tag: Some(s3s::dto::Tag {
2848 key: Some("env".to_string()),
2849 value: Some("prod".to_string()),
2850 }),
2851 ..Default::default()
2852 };
2853 let lc = BucketLifecycleConfiguration {
2854 expiry_updated_at: None,
2855 rules: vec![LifecycleRule {
2856 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2857 expiration: Some(LifecycleExpiration {
2858 days: Some(30),
2859 ..Default::default()
2860 }),
2861 abort_incomplete_multipart_upload: None,
2862 filter: Some(filter),
2863 id: Some("rule-tag".to_string()),
2864 noncurrent_version_expiration: None,
2865 noncurrent_version_transitions: None,
2866 prefix: None,
2867 transitions: None,
2868 del_marker_expiration: None,
2869 }],
2870 };
2871
2872 let matched = lc
2873 .filter_rules(&ObjectOpts {
2874 name: "obj".to_string(),
2875 user_tags: "env=prod&team=storage".to_string(),
2876 mod_time: Some(OffsetDateTime::from_unix_timestamp(1_000_000).unwrap()),
2877 is_latest: true,
2878 ..Default::default()
2879 })
2880 .await
2881 .unwrap();
2882 assert_eq!(matched.len(), 1);
2883
2884 let not_matched = lc
2885 .filter_rules(&ObjectOpts {
2886 name: "obj".to_string(),
2887 user_tags: "env=dev&team=storage".to_string(),
2888 mod_time: Some(OffsetDateTime::from_unix_timestamp(1_000_000).unwrap()),
2889 is_latest: true,
2890 ..Default::default()
2891 })
2892 .await
2893 .unwrap();
2894 assert_eq!(not_matched.len(), 0);
2895 }
2896
2897 #[tokio::test]
2898 async fn filter_rules_respects_filter_and_tags() {
2899 let filter = LifecycleRuleFilter {
2900 and: Some(s3s::dto::LifecycleRuleAndOperator {
2901 tags: Some(vec![
2902 s3s::dto::Tag {
2903 key: Some("env".to_string()),
2904 value: Some("prod".to_string()),
2905 },
2906 s3s::dto::Tag {
2907 key: Some("team".to_string()),
2908 value: Some("storage".to_string()),
2909 },
2910 ]),
2911 ..Default::default()
2912 }),
2913 ..Default::default()
2914 };
2915
2916 let lc = BucketLifecycleConfiguration {
2917 expiry_updated_at: None,
2918 rules: vec![LifecycleRule {
2919 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2920 expiration: Some(LifecycleExpiration {
2921 days: Some(30),
2922 ..Default::default()
2923 }),
2924 abort_incomplete_multipart_upload: None,
2925 filter: Some(filter),
2926 id: Some("rule-and-tags".to_string()),
2927 noncurrent_version_expiration: None,
2928 noncurrent_version_transitions: None,
2929 prefix: None,
2930 transitions: None,
2931 del_marker_expiration: None,
2932 }],
2933 };
2934
2935 let matched = lc
2936 .filter_rules(&ObjectOpts {
2937 name: "obj".to_string(),
2938 user_tags: "env=prod&team=storage".to_string(),
2939 mod_time: Some(OffsetDateTime::from_unix_timestamp(1_000_000).unwrap()),
2940 is_latest: true,
2941 ..Default::default()
2942 })
2943 .await
2944 .unwrap();
2945 assert_eq!(matched.len(), 1);
2946
2947 let not_matched = lc
2948 .filter_rules(&ObjectOpts {
2949 name: "obj".to_string(),
2950 user_tags: "env=prod&team=platform".to_string(),
2951 mod_time: Some(OffsetDateTime::from_unix_timestamp(1_000_000).unwrap()),
2952 is_latest: true,
2953 ..Default::default()
2954 })
2955 .await
2956 .unwrap();
2957 assert_eq!(not_matched.len(), 0);
2958 }
2959
2960 #[tokio::test]
2961 #[serial]
2962 async fn expired_object_delete_marker_ignores_marker_with_noncurrent_versions_present() {
2963 let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
2964 let lc = BucketLifecycleConfiguration {
2965 expiry_updated_at: None,
2966 rules: vec![LifecycleRule {
2967 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2968 expiration: Some(LifecycleExpiration {
2969 expired_object_delete_marker: Some(true),
2970 ..Default::default()
2971 }),
2972 abort_incomplete_multipart_upload: None,
2973 filter: None,
2974 id: Some("rule-expired-del-marker".to_string()),
2975 noncurrent_version_expiration: None,
2976 noncurrent_version_transitions: None,
2977 prefix: None,
2978 transitions: None,
2979 del_marker_expiration: None,
2980 }],
2981 };
2982
2983 let opts = ObjectOpts {
2984 name: "obj".to_string(),
2985 mod_time: Some(base_time),
2986 is_latest: true,
2987 delete_marker: true,
2988 num_versions: 2,
2989 version_id: Some(Uuid::new_v4()),
2990 ..Default::default()
2991 };
2992
2993 let now = base_time + Duration::days(2);
2994 let event = lc.eval_inner(&opts, now, 0).await;
2995 assert_eq!(event.action, IlmAction::NoneAction);
2996 assert_eq!(event.due, Some(OffsetDateTime::UNIX_EPOCH));
2997 }
2998
2999 #[tokio::test]
3000 async fn expired_object_delete_marker_ignores_unknown_version_count() {
3001 let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
3002 let lc = BucketLifecycleConfiguration {
3003 expiry_updated_at: None,
3004 rules: vec![LifecycleRule {
3005 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3006 expiration: Some(LifecycleExpiration {
3007 expired_object_delete_marker: Some(true),
3008 ..Default::default()
3009 }),
3010 abort_incomplete_multipart_upload: None,
3011 filter: None,
3012 id: Some("rule-expired-del-marker".to_string()),
3013 noncurrent_version_expiration: None,
3014 noncurrent_version_transitions: None,
3015 prefix: None,
3016 transitions: None,
3017 del_marker_expiration: None,
3018 }],
3019 };
3020
3021 let opts = ObjectOpts {
3022 name: "obj".to_string(),
3023 mod_time: Some(base_time),
3024 is_latest: true,
3025 delete_marker: true,
3026 num_versions: 0,
3027 version_id: Some(Uuid::new_v4()),
3028 ..Default::default()
3029 };
3030
3031 let now = base_time + Duration::days(2);
3032 let event = lc.eval_inner(&opts, now, 0).await;
3033 assert_eq!(event.action, IlmAction::NoneAction);
3034 assert_eq!(event.due, Some(OffsetDateTime::UNIX_EPOCH));
3035 }
3036
3037 #[tokio::test]
3038 #[serial]
3039 async fn expired_object_delete_marker_deletes_only_delete_marker_immediately() {
3040 let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
3041 let lc = BucketLifecycleConfiguration {
3042 expiry_updated_at: None,
3043 rules: vec![LifecycleRule {
3044 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3045 expiration: Some(LifecycleExpiration {
3046 expired_object_delete_marker: Some(true),
3047 ..Default::default()
3048 }),
3049 abort_incomplete_multipart_upload: None,
3050 filter: None,
3051 id: Some("rule-expired-del-marker".to_string()),
3052 noncurrent_version_expiration: None,
3053 noncurrent_version_transitions: None,
3054 prefix: None,
3055 transitions: None,
3056 del_marker_expiration: None,
3057 }],
3058 };
3059
3060 let opts = ObjectOpts {
3061 name: "obj".to_string(),
3062 mod_time: Some(base_time),
3063 is_latest: true,
3064 delete_marker: true,
3065 num_versions: 1,
3066 version_id: Some(Uuid::new_v4()),
3067 ..Default::default()
3068 };
3069
3070 let now = base_time + Duration::days(2);
3071 let event = lc.eval_inner(&opts, now, 0).await;
3072
3073 assert_eq!(event.action, IlmAction::DeleteVersionAction);
3074 assert_eq!(event.due, Some(now));
3075 }
3076
3077 #[tokio::test]
3078 async fn expired_object_delete_marker_without_date_or_days_deletes_immediately() {
3079 let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
3080 let lc = BucketLifecycleConfiguration {
3081 expiry_updated_at: None,
3082 rules: vec![LifecycleRule {
3083 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3084 expiration: Some(LifecycleExpiration {
3085 expired_object_delete_marker: Some(true),
3086 ..Default::default()
3087 }),
3088 abort_incomplete_multipart_upload: None,
3089 filter: None,
3090 id: Some("rule-expired-del-marker-immediate".to_string()),
3091 noncurrent_version_expiration: None,
3092 noncurrent_version_transitions: None,
3093 prefix: None,
3094 transitions: None,
3095 del_marker_expiration: None,
3096 }],
3097 };
3098
3099 let opts = ObjectOpts {
3100 name: "obj".to_string(),
3101 mod_time: Some(base_time),
3102 is_latest: true,
3103 delete_marker: true,
3104 num_versions: 1,
3105 version_id: Some(Uuid::new_v4()),
3106 ..Default::default()
3107 };
3108
3109 let now = base_time + Duration::days(2);
3110 let event = lc.eval_inner(&opts, now, 0).await;
3111 assert_eq!(event.action, IlmAction::DeleteVersionAction);
3112 assert_eq!(event.due, Some(now));
3113 }
3114
3115 #[tokio::test]
3116 #[serial]
3117 async fn expiration_days_deletes_only_expired_delete_marker_when_due() {
3118 let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
3119 let lc = BucketLifecycleConfiguration {
3120 expiry_updated_at: None,
3121 rules: vec![LifecycleRule {
3122 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3123 expiration: Some(LifecycleExpiration {
3124 days: Some(3),
3125 ..Default::default()
3126 }),
3127 abort_incomplete_multipart_upload: None,
3128 filter: None,
3129 id: Some("rule-expiration-days".to_string()),
3130 noncurrent_version_expiration: None,
3131 noncurrent_version_transitions: None,
3132 prefix: None,
3133 transitions: None,
3134 del_marker_expiration: None,
3135 }],
3136 };
3137 let only_delete_marker = ObjectOpts {
3138 name: "obj".to_string(),
3139 mod_time: Some(base_time),
3140 is_latest: true,
3141 delete_marker: true,
3142 num_versions: 1,
3143 version_id: Some(Uuid::new_v4()),
3144 ..Default::default()
3145 };
3146 let due = expected_expiry_time(base_time, 3);
3147
3148 let before_due = lc.eval_inner(&only_delete_marker, due - Duration::seconds(1), 0).await;
3149 assert_eq!(before_due.action, IlmAction::NoneAction);
3150
3151 let at_due = lc.eval_inner(&only_delete_marker, due, 0).await;
3152 assert_eq!(at_due.action, IlmAction::DeleteVersionAction);
3153 assert_eq!(at_due.rule_id, "rule-expiration-days");
3154 assert_eq!(at_due.due, Some(due));
3155
3156 let marker_with_older_version = ObjectOpts {
3157 num_versions: 2,
3158 ..only_delete_marker
3159 };
3160 let not_expired = lc
3161 .eval_inner(&marker_with_older_version, base_time + Duration::days(4), 0)
3162 .await;
3163 assert_eq!(not_expired.action, IlmAction::NoneAction);
3164 }
3165
3166 #[tokio::test]
3167 #[serial]
3168 async fn expiration_days_uses_earliest_due_rule_for_expired_delete_marker() {
3169 let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
3170 let make_rule = |id: &str, days| LifecycleRule {
3171 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3172 expiration: Some(LifecycleExpiration {
3173 days: Some(days),
3174 ..Default::default()
3175 }),
3176 abort_incomplete_multipart_upload: None,
3177 filter: None,
3178 id: Some(id.to_string()),
3179 noncurrent_version_expiration: None,
3180 noncurrent_version_transitions: None,
3181 prefix: None,
3182 transitions: None,
3183 del_marker_expiration: None,
3184 };
3185 let lc = BucketLifecycleConfiguration {
3186 expiry_updated_at: None,
3187 rules: vec![make_rule("rule-30-days", 30), make_rule("rule-3-days", 3)],
3188 };
3189 let opts = ObjectOpts {
3190 name: "obj".to_string(),
3191 mod_time: Some(base_time),
3192 is_latest: true,
3193 delete_marker: true,
3194 num_versions: 1,
3195 version_id: Some(Uuid::new_v4()),
3196 ..Default::default()
3197 };
3198
3199 let event = lc.eval_inner(&opts, base_time + Duration::days(31), 0).await;
3200
3201 assert_eq!(event.action, IlmAction::DeleteVersionAction);
3202 assert_eq!(event.rule_id, "rule-3-days");
3203 assert_eq!(event.due, Some(expected_expiry_time(base_time, 3)));
3204 }
3205
3206 #[tokio::test]
3207 async fn validate_rejects_expired_object_delete_marker_with_date() {
3208 let future_date = OffsetDateTime::from_unix_timestamp(86_400 * 10).expect("valid midnight UTC test timestamp");
3209 let lc = BucketLifecycleConfiguration {
3210 expiry_updated_at: None,
3211 rules: vec![LifecycleRule {
3212 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3213 expiration: Some(LifecycleExpiration {
3214 date: Some(future_date.into()),
3215 expired_object_delete_marker: Some(true),
3216 ..Default::default()
3217 }),
3218 abort_incomplete_multipart_upload: None,
3219 filter: None,
3220 id: Some("rule-date-del-marker".to_string()),
3221 noncurrent_version_expiration: None,
3222 noncurrent_version_transitions: None,
3223 prefix: None,
3224 transitions: None,
3225 del_marker_expiration: None,
3226 }],
3227 };
3228
3229 let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
3230
3231 assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_EXPIRED_OBJECT_DELETE_MARKER);
3232 }
3233
3234 #[tokio::test]
3235 async fn validate_rejects_expired_object_delete_marker_with_days() {
3236 let lc = BucketLifecycleConfiguration {
3237 expiry_updated_at: None,
3238 rules: vec![LifecycleRule {
3239 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3240 expiration: Some(LifecycleExpiration {
3241 days: Some(1),
3242 expired_object_delete_marker: Some(true),
3243 ..Default::default()
3244 }),
3245 abort_incomplete_multipart_upload: None,
3246 filter: None,
3247 id: Some("rule-days-del-marker".to_string()),
3248 noncurrent_version_expiration: None,
3249 noncurrent_version_transitions: None,
3250 prefix: None,
3251 transitions: None,
3252 del_marker_expiration: None,
3253 }],
3254 };
3255
3256 let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
3257
3258 assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_EXPIRED_OBJECT_DELETE_MARKER);
3259 }
3260
3261 #[tokio::test]
3262 async fn validate_rejects_false_expired_object_delete_marker_with_date() {
3263 let date = OffsetDateTime::from_unix_timestamp(86_400 * 10).expect("valid midnight UTC test timestamp");
3264 let lc = BucketLifecycleConfiguration {
3265 expiry_updated_at: None,
3266 rules: vec![LifecycleRule {
3267 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3268 expiration: Some(LifecycleExpiration {
3269 date: Some(date.into()),
3270 expired_object_delete_marker: Some(false),
3271 ..Default::default()
3272 }),
3273 abort_incomplete_multipart_upload: None,
3274 filter: None,
3275 id: Some("rule-date-false-del-marker".to_string()),
3276 noncurrent_version_expiration: None,
3277 noncurrent_version_transitions: None,
3278 prefix: None,
3279 transitions: None,
3280 del_marker_expiration: None,
3281 }],
3282 };
3283
3284 let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
3285
3286 assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_EXPIRED_OBJECT_DELETE_MARKER);
3287 }
3288
3289 #[tokio::test]
3290 async fn validate_rejects_false_expired_object_delete_marker_with_days() {
3291 let lc = BucketLifecycleConfiguration {
3292 expiry_updated_at: None,
3293 rules: vec![LifecycleRule {
3294 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3295 expiration: Some(LifecycleExpiration {
3296 days: Some(1),
3297 expired_object_delete_marker: Some(false),
3298 ..Default::default()
3299 }),
3300 abort_incomplete_multipart_upload: None,
3301 filter: None,
3302 id: Some("rule-days-false-del-marker".to_string()),
3303 noncurrent_version_expiration: None,
3304 noncurrent_version_transitions: None,
3305 prefix: None,
3306 transitions: None,
3307 del_marker_expiration: None,
3308 }],
3309 };
3310
3311 let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
3312
3313 assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_EXPIRED_OBJECT_DELETE_MARKER);
3314 }
3315
3316 #[tokio::test]
3317 async fn validate_rejects_expired_object_delete_marker_with_tag_filter() {
3318 let lc = BucketLifecycleConfiguration {
3319 expiry_updated_at: None,
3320 rules: vec![LifecycleRule {
3321 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3322 expiration: Some(LifecycleExpiration {
3323 expired_object_delete_marker: Some(true),
3324 ..Default::default()
3325 }),
3326 abort_incomplete_multipart_upload: None,
3327 filter: Some(LifecycleRuleFilter {
3328 tag: Some(s3s::dto::Tag {
3329 key: Some("env".to_string()),
3330 value: Some("prod".to_string()),
3331 }),
3332 ..Default::default()
3333 }),
3334 id: Some("rule-tag-del-marker".to_string()),
3335 noncurrent_version_expiration: None,
3336 noncurrent_version_transitions: None,
3337 prefix: None,
3338 transitions: None,
3339 del_marker_expiration: None,
3340 }],
3341 };
3342
3343 let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
3344
3345 assert_eq!(err.to_string(), ERR_LIFECYCLE_EXPIRED_OBJECT_DELETE_MARKER_WITH_TAGS);
3346 }
3347
3348 #[tokio::test]
3351 async fn validate_allows_expired_object_delete_marker_on_locked_bucket() {
3352 let lc = BucketLifecycleConfiguration {
3353 expiry_updated_at: None,
3354 rules: vec![LifecycleRule {
3355 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3356 expiration: Some(LifecycleExpiration {
3357 expired_object_delete_marker: Some(true),
3358 ..Default::default()
3359 }),
3360 abort_incomplete_multipart_upload: None,
3361 del_marker_expiration: None,
3362 filter: None,
3363 id: Some("test-rule".to_string()),
3364 noncurrent_version_expiration: None,
3365 noncurrent_version_transitions: None,
3366 prefix: None,
3367 transitions: None,
3368 }],
3369 };
3370
3371 let locked_config = ObjectLockConfiguration {
3372 object_lock_enabled: Some(ObjectLockEnabled::from_static(ObjectLockEnabled::ENABLED)),
3373 ..Default::default()
3374 };
3375
3376 lc.validate(&locked_config)
3377 .await
3378 .expect("expected validation to pass for ExpiredObjectDeleteMarker on locked bucket");
3379 }
3380
3381 #[tokio::test]
3382 async fn validate_allows_expired_object_delete_marker_on_unlocked_bucket() {
3383 let lc = BucketLifecycleConfiguration {
3384 expiry_updated_at: None,
3385 rules: vec![LifecycleRule {
3386 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3387 expiration: Some(LifecycleExpiration {
3388 expired_object_delete_marker: Some(true),
3389 ..Default::default()
3390 }),
3391 abort_incomplete_multipart_upload: None,
3392 del_marker_expiration: None,
3393 filter: None,
3394 id: Some("test-rule".to_string()),
3395 noncurrent_version_expiration: None,
3396 noncurrent_version_transitions: None,
3397 prefix: None,
3398 transitions: None,
3399 }],
3400 };
3401
3402 lc.validate(&ObjectLockConfiguration::default())
3404 .await
3405 .expect("expected validation to pass on unlocked bucket");
3406 }
3407
3408 #[tokio::test]
3409 async fn validate_allows_non_delete_marker_expiration_on_locked_bucket() {
3410 let lc = BucketLifecycleConfiguration {
3411 expiry_updated_at: None,
3412 rules: vec![LifecycleRule {
3413 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3414 expiration: Some(LifecycleExpiration {
3415 days: Some(30),
3416 ..Default::default()
3417 }),
3418 abort_incomplete_multipart_upload: None,
3419 del_marker_expiration: None,
3420 filter: None,
3421 id: Some("test-rule".to_string()),
3422 noncurrent_version_expiration: None,
3423 noncurrent_version_transitions: None,
3424 prefix: None,
3425 transitions: None,
3426 }],
3427 };
3428
3429 let locked_config = ObjectLockConfiguration {
3430 object_lock_enabled: Some(ObjectLockEnabled::from_static(ObjectLockEnabled::ENABLED)),
3431 ..Default::default()
3432 };
3433
3434 lc.validate(&locked_config)
3436 .await
3437 .expect("expected days-based expiration to pass on locked bucket");
3438 }
3439
3440 #[tokio::test]
3441 async fn validate_rejects_del_marker_expiration_on_locked_bucket() {
3442 let lc = BucketLifecycleConfiguration {
3443 expiry_updated_at: None,
3444 rules: vec![LifecycleRule {
3445 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3446 expiration: Some(LifecycleExpiration {
3447 days: Some(30),
3448 ..Default::default()
3449 }),
3450 abort_incomplete_multipart_upload: None,
3451 del_marker_expiration: Some(s3s::dto::DelMarkerExpiration { days: Some(1) }),
3452 filter: None,
3453 id: Some("test-rule".to_string()),
3454 noncurrent_version_expiration: None,
3455 noncurrent_version_transitions: None,
3456 prefix: None,
3457 transitions: None,
3458 }],
3459 };
3460
3461 let locked_config = ObjectLockConfiguration {
3462 object_lock_enabled: Some(ObjectLockEnabled::from_static(ObjectLockEnabled::ENABLED)),
3463 ..Default::default()
3464 };
3465
3466 let err = lc.validate(&locked_config).await.unwrap_err();
3467 assert_eq!(err.to_string(), ERR_LIFECYCLE_BUCKET_LOCKED);
3468 }
3469
3470 #[tokio::test]
3471 async fn validate_rejects_invalid_del_marker_expiration_days_even_with_another_action() {
3472 for days in [None, Some(0), Some(-1)] {
3473 let lc = BucketLifecycleConfiguration {
3474 expiry_updated_at: None,
3475 rules: vec![LifecycleRule {
3476 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3477 expiration: Some(LifecycleExpiration {
3478 days: Some(30),
3479 ..Default::default()
3480 }),
3481 abort_incomplete_multipart_upload: None,
3482 del_marker_expiration: Some(s3s::dto::DelMarkerExpiration { days }),
3483 filter: None,
3484 id: Some("test-rule".to_string()),
3485 noncurrent_version_expiration: None,
3486 noncurrent_version_transitions: None,
3487 prefix: None,
3488 transitions: None,
3489 }],
3490 };
3491
3492 let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
3493 assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_DEL_MARKER_EXPIRATION_DAYS);
3494 }
3495 }
3496
3497 #[tokio::test]
3498 #[serial]
3499 async fn del_marker_expiration_deletes_marker_and_older_versions_when_due() {
3500 let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).expect("fixed timestamp should be valid");
3501 let lc = BucketLifecycleConfiguration {
3502 expiry_updated_at: None,
3503 rules: vec![enabled_rule(
3504 None,
3505 Some(s3s::dto::DelMarkerExpiration { days: Some(3) }),
3506 Some("delete-marker-history"),
3507 )],
3508 };
3509 let marker_with_history = ObjectOpts {
3510 name: "obj".to_string(),
3511 mod_time: Some(base_time),
3512 is_latest: true,
3513 delete_marker: true,
3514 num_versions: 3,
3515 version_id: Some(Uuid::new_v4()),
3516 ..Default::default()
3517 };
3518 let due = expected_expiry_time(base_time, 3);
3519
3520 let before_due = lc.eval_inner(&marker_with_history, due - Duration::seconds(1), 0).await;
3521 assert_eq!(before_due.action, IlmAction::NoneAction);
3522
3523 let at_due = lc.eval_inner(&marker_with_history, due, 0).await;
3524 assert_eq!(at_due.action, IlmAction::DelMarkerDeleteAllVersionsAction);
3525 assert_eq!(at_due.rule_id, "delete-marker-history");
3526 assert_eq!(at_due.due, Some(due));
3527
3528 let current_data = ObjectOpts {
3529 delete_marker: false,
3530 ..marker_with_history
3531 };
3532 assert_eq!(lc.eval_inner(¤t_data, due, 0).await.action, IlmAction::NoneAction);
3533 }
3534
3535 #[test]
3538 #[serial]
3539 fn expected_expiry_time_rounds_up_to_next_midnight_utc() {
3540 with_default_ilm_process_time(|| {
3541 let mod_time = datetime!(2025-01-15 10:30:45 UTC);
3543 let result = expected_expiry_time(mod_time, 30);
3544
3545 assert_eq!(result.hour(), 0);
3547 assert_eq!(result.minute(), 0);
3548 assert_eq!(result.second(), 0);
3549 assert_eq!(result, datetime!(2025-02-15 00:00:00 UTC));
3550 });
3551 }
3552
3553 #[test]
3554 #[serial]
3555 fn expected_expiry_time_immediate_expiry_returns_epoch() {
3556 with_default_ilm_process_time(|| {
3557 let mod_time = datetime!(2025-06-01 12:00:00 UTC);
3558 let result = expected_expiry_time(mod_time, 0);
3559 assert_eq!(result, OffsetDateTime::UNIX_EPOCH);
3560 });
3561 }
3562
3563 #[test]
3564 #[serial]
3565 fn expected_expiry_time_preserves_exact_midnight_boundary() {
3566 with_default_ilm_process_time(|| {
3567 let mod_time = datetime!(2025-03-01 00:00:00 UTC);
3568 let result = expected_expiry_time(mod_time, 1);
3569 assert_eq!(result, datetime!(2025-03-02 00:00:00 UTC));
3570 });
3571 }
3572
3573 #[test]
3574 #[serial]
3575 fn expected_expiry_time_rounds_end_of_day_to_following_midnight() {
3576 with_default_ilm_process_time(|| {
3577 let mod_time = datetime!(2025-06-15 23:59:59 UTC);
3578 let result = expected_expiry_time(mod_time, 1);
3579 assert_eq!(result, datetime!(2025-06-17 00:00:00 UTC));
3580 });
3581 }
3582
3583 #[test]
3584 #[serial]
3585 fn expected_expiry_time_uses_canonical_process_time_boundary() {
3586 let mod_time = datetime!(2025-01-15 10:30:45 UTC);
3587
3588 temp_env::with_var(ENV_ILM_PROCESS_TIME, Some("3600"), || {
3589 temp_env::with_var_unset(ENV_ILM_PROCESS_TIME_DEPRECATED, || {
3590 let result = expected_expiry_time(mod_time, 1);
3591 assert_eq!(result, datetime!(2025-01-16 11:00:00 UTC));
3592 });
3593 });
3594 }
3595
3596 #[test]
3597 #[serial]
3598 fn expected_expiry_time_uses_deprecated_process_time_alias() {
3599 let mod_time = datetime!(2025-01-15 10:30:45 UTC);
3600
3601 temp_env::with_var_unset(ENV_ILM_PROCESS_TIME, || {
3602 temp_env::with_var(ENV_ILM_PROCESS_TIME_DEPRECATED, Some("3600"), || {
3603 let result = expected_expiry_time(mod_time, 1);
3604 assert_eq!(result, datetime!(2025-01-16 11:00:00 UTC));
3605 });
3606 });
3607 }
3608
3609 #[test]
3610 #[serial]
3611 fn expected_expiry_time_uses_default_boundary_when_process_time_is_zero_or_invalid() {
3612 let mod_time = datetime!(2025-01-15 10:30:45 UTC);
3613
3614 temp_env::with_var(ENV_ILM_PROCESS_TIME, Some("0"), || {
3615 temp_env::with_var_unset(ENV_ILM_PROCESS_TIME_DEPRECATED, || {
3616 let result = expected_expiry_time(mod_time, 30);
3617 assert_eq!(result, datetime!(2025-02-15 00:00:00 UTC));
3618 });
3619 });
3620
3621 temp_env::with_var(ENV_ILM_PROCESS_TIME, Some("not-a-number"), || {
3622 temp_env::with_var_unset(ENV_ILM_PROCESS_TIME_DEPRECATED, || {
3623 let result = expected_expiry_time(mod_time, 30);
3624 assert_eq!(result, datetime!(2025-02-15 00:00:00 UTC));
3625 });
3626 });
3627 }
3628
3629 #[test]
3633 #[serial]
3634 fn ilm_day_secs_defaults_to_86400_when_unset() {
3635 temp_env::with_var_unset(ENV_ILM_DEBUG_DAY_SECS, || {
3636 assert_eq!(ilm_day_secs(), DEFAULT_ILM_DAY_SECS);
3637 assert_eq!(ilm_day_secs(), 86400);
3638 });
3639 }
3640
3641 #[test]
3643 fn parse_ilm_day_secs_accepts_positive_values() {
3644 assert_eq!(parse_ilm_day_secs("1"), 1);
3645 assert_eq!(parse_ilm_day_secs("2"), 2);
3646 assert_eq!(parse_ilm_day_secs(" 10 "), 10);
3647 assert_eq!(parse_ilm_day_secs("3600"), 3600);
3648 }
3649
3650 #[test]
3652 fn parse_ilm_day_secs_rejects_invalid_and_zero() {
3653 assert_eq!(parse_ilm_day_secs("0"), DEFAULT_ILM_DAY_SECS);
3654 assert_eq!(parse_ilm_day_secs("-5"), DEFAULT_ILM_DAY_SECS);
3655 assert_eq!(parse_ilm_day_secs("not-a-number"), DEFAULT_ILM_DAY_SECS);
3656 assert_eq!(parse_ilm_day_secs(""), DEFAULT_ILM_DAY_SECS);
3657 assert_eq!(parse_ilm_day_secs("1.5"), DEFAULT_ILM_DAY_SECS);
3658 }
3659
3660 #[test]
3662 #[serial]
3663 fn ilm_day_secs_scales_when_env_set() {
3664 temp_env::with_var(ENV_ILM_DEBUG_DAY_SECS, Some("2"), || {
3665 assert_eq!(ilm_day_secs(), 2);
3666 });
3667 }
3668
3669 #[test]
3671 #[serial]
3672 fn ilm_day_secs_falls_back_on_invalid_env() {
3673 temp_env::with_var(ENV_ILM_DEBUG_DAY_SECS, Some("bogus"), || {
3674 assert_eq!(ilm_day_secs(), DEFAULT_ILM_DAY_SECS);
3675 });
3676 temp_env::with_var(ENV_ILM_DEBUG_DAY_SECS, Some("0"), || {
3677 assert_eq!(ilm_day_secs(), DEFAULT_ILM_DAY_SECS);
3678 });
3679 }
3680
3681 #[test]
3684 #[serial]
3685 fn expected_expiry_time_scales_with_debug_day_secs() {
3686 let mod_time = datetime!(2025-01-15 10:30:45 UTC);
3687 temp_env::with_var(ENV_ILM_DEBUG_DAY_SECS, Some("1"), || {
3688 temp_env::with_var_unset(ENV_ILM_PROCESS_TIME, || {
3689 temp_env::with_var_unset(ENV_ILM_PROCESS_TIME_DEPRECATED, || {
3690 assert_eq!(expected_expiry_time(mod_time, 1), mod_time + Duration::seconds(1));
3692 assert_eq!(expected_expiry_time(mod_time, 5), mod_time + Duration::seconds(5));
3693 });
3694 });
3695 });
3696 }
3697
3698 #[test]
3700 #[serial]
3701 fn expected_expiry_time_zero_days_ignores_debug_day_secs() {
3702 let mod_time = datetime!(2025-06-01 12:00:00 UTC);
3703 temp_env::with_var(ENV_ILM_DEBUG_DAY_SECS, Some("2"), || {
3704 assert_eq!(expected_expiry_time(mod_time, 0), OffsetDateTime::UNIX_EPOCH);
3705 });
3706 }
3707
3708 #[test]
3711 #[serial]
3712 fn expected_expiry_time_debug_day_secs_respects_explicit_process_time() {
3713 let mod_time = datetime!(2025-01-15 10:30:00 UTC);
3714 temp_env::with_var(ENV_ILM_DEBUG_DAY_SECS, Some("10"), || {
3716 temp_env::with_var(ENV_ILM_PROCESS_TIME, Some("60"), || {
3717 temp_env::with_var_unset(ENV_ILM_PROCESS_TIME_DEPRECATED, || {
3718 let result = expected_expiry_time(mod_time, 3);
3720 assert_eq!(result, datetime!(2025-01-15 10:31:00 UTC));
3721 });
3722 });
3723 });
3724 }
3725
3726 #[test]
3728 #[serial]
3729 fn expected_expiry_time_unset_debug_day_secs_matches_legacy_process_time() {
3730 let mod_time = datetime!(2025-01-15 10:30:45 UTC);
3731 temp_env::with_var_unset(ENV_ILM_DEBUG_DAY_SECS, || {
3732 temp_env::with_var(ENV_ILM_PROCESS_TIME, Some("3600"), || {
3733 temp_env::with_var_unset(ENV_ILM_PROCESS_TIME_DEPRECATED, || {
3734 assert_eq!(expected_expiry_time(mod_time, 1), datetime!(2025-01-16 11:00:00 UTC));
3735 });
3736 });
3737 });
3738 }
3739
3740 fn block_on_with_env<F: std::future::Future>(vars: &[(&str, Option<&str>)], fut_fn: impl FnOnce() -> F) -> F::Output {
3745 temp_env::with_vars(vars, || {
3746 let rt = tokio::runtime::Builder::new_current_thread()
3747 .enable_all()
3748 .build()
3749 .expect("build runtime");
3750 rt.block_on(fut_fn())
3751 })
3752 }
3753
3754 #[test]
3756 #[serial]
3757 fn abort_incomplete_multipart_due_scales_with_debug_day_secs() {
3758 use s3s::dto::AbortIncompleteMultipartUpload;
3759 let initiated = datetime!(2025-01-15 10:30:45 UTC);
3760 let lc = BucketLifecycleConfiguration {
3761 expiry_updated_at: None,
3762 rules: vec![LifecycleRule {
3763 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3764 expiration: None,
3765 abort_incomplete_multipart_upload: Some(AbortIncompleteMultipartUpload {
3766 days_after_initiation: Some(3),
3767 }),
3768 del_marker_expiration: None,
3769 filter: None,
3770 id: Some("abort-mpu".to_string()),
3771 noncurrent_version_expiration: None,
3772 noncurrent_version_transitions: None,
3773 prefix: None,
3774 transitions: None,
3775 }],
3776 };
3777 let opts = ObjectOpts {
3778 name: "obj".to_string(),
3779 mod_time: Some(initiated),
3780 is_latest: true,
3781 ..Default::default()
3782 };
3783
3784 block_on_with_env(
3785 &[
3786 (ENV_ILM_DEBUG_DAY_SECS, Some("1")),
3787 (ENV_ILM_PROCESS_TIME, None),
3788 (ENV_ILM_PROCESS_TIME_DEPRECATED, None),
3789 ],
3790 || async {
3791 let (due, id) = abort_incomplete_multipart_upload_due(&lc, &opts).await.expect("due");
3792 assert_eq!(due, initiated + Duration::seconds(3));
3793 assert_eq!(id, "abort-mpu");
3794 },
3795 );
3796 }
3797
3798 #[test]
3801 #[serial]
3802 fn eval_inner_expires_days_one_rule_under_debug_day_secs() {
3803 let lc = BucketLifecycleConfiguration {
3804 expiry_updated_at: None,
3805 rules: vec![LifecycleRule {
3806 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3807 expiration: Some(LifecycleExpiration {
3808 days: Some(1),
3809 ..Default::default()
3810 }),
3811 abort_incomplete_multipart_upload: None,
3812 del_marker_expiration: None,
3813 filter: None,
3814 id: Some("expire-days".to_string()),
3815 noncurrent_version_expiration: None,
3816 noncurrent_version_transitions: None,
3817 prefix: None,
3818 transitions: None,
3819 }],
3820 };
3821
3822 let mod_time = datetime!(2025-01-15 10:30:00 UTC);
3823 let opts = ObjectOpts {
3824 name: "obj".to_string(),
3825 mod_time: Some(mod_time),
3826 is_latest: true,
3827 ..Default::default()
3828 };
3829
3830 block_on_with_env(
3831 &[
3832 (ENV_ILM_DEBUG_DAY_SECS, Some("1")),
3833 (ENV_ILM_PROCESS_TIME, None),
3834 (ENV_ILM_PROCESS_TIME_DEPRECATED, None),
3835 ],
3836 || async {
3837 let now = mod_time + Duration::seconds(2);
3840 let event = lc.eval_inner(&opts, now, 0).await;
3841 assert_eq!(event.action, IlmAction::DeleteAction);
3842 assert_eq!(event.rule_id, "expire-days");
3843 assert_eq!(event.due, Some(mod_time + Duration::seconds(1)));
3844 },
3845 );
3846 }
3847
3848 #[test]
3850 #[serial]
3851 fn eval_inner_date_rule_ignores_debug_day_secs() {
3852 let expiry_date = datetime!(2025-06-01 00:00:00 UTC);
3853 let lc = BucketLifecycleConfiguration {
3854 expiry_updated_at: None,
3855 rules: vec![LifecycleRule {
3856 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3857 expiration: Some(LifecycleExpiration {
3858 date: Some(expiry_date.into()),
3859 ..Default::default()
3860 }),
3861 abort_incomplete_multipart_upload: None,
3862 del_marker_expiration: None,
3863 filter: None,
3864 id: Some("expire-date".to_string()),
3865 noncurrent_version_expiration: None,
3866 noncurrent_version_transitions: None,
3867 prefix: None,
3868 transitions: None,
3869 }],
3870 };
3871 let opts = ObjectOpts {
3872 name: "obj".to_string(),
3873 mod_time: Some(datetime!(2025-01-15 10:30:00 UTC)),
3874 is_latest: true,
3875 ..Default::default()
3876 };
3877
3878 block_on_with_env(&[(ENV_ILM_DEBUG_DAY_SECS, Some("1"))], || async {
3879 let now = datetime!(2025-01-15 10:30:05 UTC);
3881 let event = lc.eval_inner(&opts, now, 0).await;
3882 assert_eq!(event.action, IlmAction::NoneAction);
3883 });
3884 }
3885
3886 #[tokio::test]
3889 async fn validate_rejects_prefix_and_filter_both_present() {
3890 let lc = BucketLifecycleConfiguration {
3891 expiry_updated_at: None,
3892 rules: vec![LifecycleRule {
3893 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3894 expiration: Some(LifecycleExpiration {
3895 days: Some(30),
3896 ..Default::default()
3897 }),
3898 abort_incomplete_multipart_upload: None,
3899 del_marker_expiration: None,
3900 filter: Some(LifecycleRuleFilter {
3901 prefix: Some("logs/".to_string()),
3902 ..Default::default()
3903 }),
3904 id: Some("test-rule".to_string()),
3905 noncurrent_version_expiration: None,
3906 noncurrent_version_transitions: None,
3907 prefix: Some("archive/".to_string()),
3908 transitions: None,
3909 }],
3910 };
3911
3912 let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
3913 assert_eq!(err.to_string(), ERR_LIFECYCLE_PREFIX_FILTER_CONFLICT);
3914 }
3915
3916 #[tokio::test]
3917 async fn validate_allows_prefix_without_filter() {
3918 let lc = BucketLifecycleConfiguration {
3919 expiry_updated_at: None,
3920 rules: vec![LifecycleRule {
3921 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3922 expiration: Some(LifecycleExpiration {
3923 days: Some(30),
3924 ..Default::default()
3925 }),
3926 abort_incomplete_multipart_upload: None,
3927 del_marker_expiration: None,
3928 filter: None,
3929 id: Some("test-rule".to_string()),
3930 noncurrent_version_expiration: None,
3931 noncurrent_version_transitions: None,
3932 prefix: Some("logs/".to_string()),
3933 transitions: None,
3934 }],
3935 };
3936
3937 lc.validate(&ObjectLockConfiguration::default())
3938 .await
3939 .expect("prefix without filter should be valid");
3940 }
3941
3942 #[tokio::test]
3943 async fn validate_allows_filter_without_prefix() {
3944 let lc = BucketLifecycleConfiguration {
3945 expiry_updated_at: None,
3946 rules: vec![LifecycleRule {
3947 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3948 expiration: Some(LifecycleExpiration {
3949 days: Some(30),
3950 ..Default::default()
3951 }),
3952 abort_incomplete_multipart_upload: None,
3953 del_marker_expiration: None,
3954 filter: Some(LifecycleRuleFilter {
3955 prefix: Some("logs/".to_string()),
3956 ..Default::default()
3957 }),
3958 id: Some("test-rule".to_string()),
3959 noncurrent_version_expiration: None,
3960 noncurrent_version_transitions: None,
3961 prefix: None,
3962 transitions: None,
3963 }],
3964 };
3965
3966 lc.validate(&ObjectLockConfiguration::default())
3967 .await
3968 .expect("filter without prefix should be valid");
3969 }
3970
3971 #[tokio::test]
3972 async fn validate_allows_empty_prefix_with_filter() {
3973 let lc = BucketLifecycleConfiguration {
3975 expiry_updated_at: None,
3976 rules: vec![LifecycleRule {
3977 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3978 expiration: Some(LifecycleExpiration {
3979 days: Some(30),
3980 ..Default::default()
3981 }),
3982 abort_incomplete_multipart_upload: None,
3983 del_marker_expiration: None,
3984 filter: Some(LifecycleRuleFilter {
3985 prefix: Some("logs/".to_string()),
3986 ..Default::default()
3987 }),
3988 id: Some("test-rule".to_string()),
3989 noncurrent_version_expiration: None,
3990 noncurrent_version_transitions: None,
3991 prefix: Some("".to_string()), transitions: None,
3993 }],
3994 };
3995
3996 lc.validate(&ObjectLockConfiguration::default())
3997 .await
3998 .expect("empty prefix with filter should be valid");
3999 }
4000
4001 #[tokio::test]
4002 async fn validate_rejects_empty_rule_id() {
4003 let lc = BucketLifecycleConfiguration {
4004 expiry_updated_at: None,
4005 rules: vec![LifecycleRule {
4006 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
4007 expiration: Some(LifecycleExpiration {
4008 days: Some(30),
4009 ..Default::default()
4010 }),
4011 abort_incomplete_multipart_upload: None,
4012 del_marker_expiration: None,
4013 filter: None,
4014 id: Some(String::new()),
4015 noncurrent_version_expiration: None,
4016 noncurrent_version_transitions: None,
4017 prefix: None,
4018 transitions: None,
4019 }],
4020 };
4021
4022 let error = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
4023 assert_eq!(error.to_string(), ERR_LIFECYCLE_INVALID_RULE_ID_EMPTY);
4024 }
4025
4026 #[tokio::test]
4029 async fn validate_rejects_expired_object_all_versions_on_locked_bucket() {
4030 let lc = BucketLifecycleConfiguration {
4031 expiry_updated_at: None,
4032 rules: vec![LifecycleRule {
4033 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
4034 expiration: Some(LifecycleExpiration {
4035 days: Some(30),
4036 expired_object_all_versions: Some(true),
4037 ..Default::default()
4038 }),
4039 abort_incomplete_multipart_upload: None,
4040 del_marker_expiration: None,
4041 filter: None,
4042 id: Some("all-versions-rule".to_string()),
4043 noncurrent_version_expiration: None,
4044 noncurrent_version_transitions: None,
4045 prefix: None,
4046 transitions: None,
4047 }],
4048 };
4049
4050 let locked_config = ObjectLockConfiguration {
4051 object_lock_enabled: Some(ObjectLockEnabled::from_static(ObjectLockEnabled::ENABLED)),
4052 ..Default::default()
4053 };
4054
4055 let err = lc.validate(&locked_config).await.unwrap_err();
4056 assert_eq!(err.to_string(), ERR_LIFECYCLE_BUCKET_LOCKED);
4057 }
4058
4059 #[tokio::test]
4060 async fn validate_allows_expired_object_all_versions_on_unlocked_bucket() {
4061 let lc = BucketLifecycleConfiguration {
4062 expiry_updated_at: None,
4063 rules: vec![LifecycleRule {
4064 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
4065 expiration: Some(LifecycleExpiration {
4066 days: Some(30),
4067 expired_object_all_versions: Some(true),
4068 ..Default::default()
4069 }),
4070 abort_incomplete_multipart_upload: None,
4071 del_marker_expiration: None,
4072 filter: None,
4073 id: Some("all-versions-rule".to_string()),
4074 noncurrent_version_expiration: None,
4075 noncurrent_version_transitions: None,
4076 prefix: None,
4077 transitions: None,
4078 }],
4079 };
4080
4081 lc.validate(&ObjectLockConfiguration::default())
4082 .await
4083 .expect("ExpiredObjectAllVersions should be allowed on unlocked bucket");
4084 }
4085
4086 #[tokio::test]
4087 async fn validate_rejects_expired_object_all_versions_without_days_or_with_date() {
4088 let expiration_date = datetime!(2025-01-01 00:00:00 UTC);
4089 let invalid_expirations = [
4090 LifecycleExpiration {
4091 expired_object_all_versions: Some(true),
4092 ..Default::default()
4093 },
4094 LifecycleExpiration {
4095 date: Some(expiration_date.into()),
4096 days: Some(1),
4097 expired_object_all_versions: Some(true),
4098 ..Default::default()
4099 },
4100 ];
4101
4102 for expiration in invalid_expirations {
4103 let lc = BucketLifecycleConfiguration {
4104 expiry_updated_at: None,
4105 rules: vec![enabled_rule(Some(expiration), None, None)],
4106 };
4107
4108 let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
4109 assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_EXPIRED_OBJECT_ALL_VERSIONS);
4110 }
4111 }
4112
4113 #[tokio::test]
4114 async fn validate_rejects_false_expired_object_all_versions_with_date() {
4115 let lc = BucketLifecycleConfiguration {
4116 expiry_updated_at: None,
4117 rules: vec![enabled_rule(
4118 Some(LifecycleExpiration {
4119 date: Some(datetime!(2025-01-01 00:00:00 UTC).into()),
4120 expired_object_all_versions: Some(false),
4121 ..Default::default()
4122 }),
4123 None,
4124 None,
4125 )],
4126 };
4127
4128 let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
4129 assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_EXPIRED_OBJECT_ALL_VERSIONS);
4130 }
4131
4132 #[tokio::test]
4133 #[serial]
4134 async fn eval_inner_triggers_delete_all_versions_when_expired_object_all_versions_set() {
4135 let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
4136 let lc = BucketLifecycleConfiguration {
4137 expiry_updated_at: None,
4138 rules: vec![LifecycleRule {
4139 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
4140 expiration: Some(LifecycleExpiration {
4141 days: Some(1),
4142 expired_object_all_versions: Some(true),
4143 ..Default::default()
4144 }),
4145 abort_incomplete_multipart_upload: None,
4146 del_marker_expiration: None,
4147 filter: None,
4148 id: Some("all-versions-rule".to_string()),
4149 noncurrent_version_expiration: None,
4150 noncurrent_version_transitions: None,
4151 prefix: None,
4152 transitions: None,
4153 }],
4154 };
4155
4156 let opts = ObjectOpts {
4157 name: "obj".to_string(),
4158 mod_time: Some(base_time),
4159 is_latest: true,
4160 version_id: None,
4161 ..Default::default()
4162 };
4163
4164 let now = base_time + Duration::days(2);
4166 let event = lc.eval_inner(&opts, now, 0).await;
4167 assert_eq!(event.action, IlmAction::DeleteAllVersionsAction);
4168 assert_eq!(event.rule_id, "all-versions-rule");
4169 }
4170
4171 #[tokio::test]
4172 #[serial]
4173 async fn expired_object_all_versions_does_not_apply_to_current_delete_marker() {
4174 let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).expect("fixed timestamp should be valid");
4175 let lc = BucketLifecycleConfiguration {
4176 expiry_updated_at: None,
4177 rules: vec![enabled_rule(
4178 Some(LifecycleExpiration {
4179 days: Some(1),
4180 expired_object_all_versions: Some(true),
4181 ..Default::default()
4182 }),
4183 None,
4184 Some("all-versions-rule"),
4185 )],
4186 };
4187 let marker_with_history = ObjectOpts {
4188 name: "obj".to_string(),
4189 mod_time: Some(base_time),
4190 is_latest: true,
4191 delete_marker: true,
4192 num_versions: 2,
4193 version_id: Some(Uuid::new_v4()),
4194 ..Default::default()
4195 };
4196
4197 let event = lc.eval_inner(&marker_with_history, base_time + Duration::days(2), 0).await;
4198 assert_eq!(event.action, IlmAction::NoneAction);
4199 }
4200
4201 #[tokio::test]
4202 #[serial]
4203 async fn eval_inner_uses_delete_action_when_all_versions_not_set() {
4204 let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
4205 let lc = BucketLifecycleConfiguration {
4206 expiry_updated_at: None,
4207 rules: vec![LifecycleRule {
4208 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
4209 expiration: Some(LifecycleExpiration {
4210 days: Some(1),
4211 expired_object_all_versions: None, ..Default::default()
4213 }),
4214 abort_incomplete_multipart_upload: None,
4215 del_marker_expiration: None,
4216 filter: None,
4217 id: Some("normal-rule".to_string()),
4218 noncurrent_version_expiration: None,
4219 noncurrent_version_transitions: None,
4220 prefix: None,
4221 transitions: None,
4222 }],
4223 };
4224
4225 let opts = ObjectOpts {
4226 name: "obj".to_string(),
4227 mod_time: Some(base_time),
4228 is_latest: true,
4229 version_id: None,
4230 ..Default::default()
4231 };
4232
4233 let now = base_time + Duration::days(2);
4234 let event = lc.eval_inner(&opts, now, 0).await;
4235 assert_eq!(event.action, IlmAction::DeleteAction);
4237 }
4238
4239 #[tokio::test]
4240 async fn current_expiration_requires_latest_even_for_null_version_identity() {
4241 let base_time = datetime!(2025-01-01 00:00:00 UTC);
4242 let lc = BucketLifecycleConfiguration {
4243 expiry_updated_at: None,
4244 rules: vec![enabled_rule(
4245 Some(LifecycleExpiration {
4246 days: Some(1),
4247 ..Default::default()
4248 }),
4249 None,
4250 Some("expire-current"),
4251 )],
4252 };
4253 let now = base_time + Duration::days(2);
4254
4255 let unversioned_current = ObjectOpts {
4256 name: "object".to_string(),
4257 mod_time: Some(base_time),
4258 is_latest: true,
4259 version_id: None,
4260 ..Default::default()
4261 };
4262 assert_eq!(
4263 lc.eval_inner(&unversioned_current, now, 0).await.action,
4264 IlmAction::DeleteAction,
4265 "a truly unversioned current object must remain eligible"
4266 );
4267 assert_eq!(lc.predict_expiration(&unversioned_current).await.action, IlmAction::DeleteAction);
4268 assert!(expiration_action_has_valid_target(
4269 IlmAction::DeleteAction,
4270 unversioned_current.version_id,
4271 unversioned_current.is_latest,
4272 unversioned_current.delete_marker,
4273 ));
4274 assert!(!expiration_action_has_valid_target(
4275 IlmAction::DeleteVersionAction,
4276 unversioned_current.version_id,
4277 unversioned_current.is_latest,
4278 unversioned_current.delete_marker,
4279 ));
4280
4281 let historical_null = ObjectOpts {
4282 name: "object".to_string(),
4283 mod_time: Some(base_time),
4284 version_id: Some(Uuid::nil()),
4285 is_latest: false,
4286 versioned: true,
4287 ..Default::default()
4288 };
4289 assert_eq!(
4290 lc.eval_inner(&historical_null, now, 0).await.action,
4291 IlmAction::NoneAction,
4292 "an explicit null identity does not make a historical version current"
4293 );
4294 assert_eq!(lc.predict_expiration(&historical_null).await.action, IlmAction::NoneAction);
4295 assert!(!expiration_action_has_valid_target(
4296 IlmAction::DeleteAction,
4297 historical_null.version_id,
4298 historical_null.is_latest,
4299 historical_null.delete_marker,
4300 ));
4301 assert!(expiration_action_has_valid_target(
4302 IlmAction::DeleteVersionAction,
4303 historical_null.version_id,
4304 historical_null.is_latest,
4305 historical_null.delete_marker,
4306 ));
4307 }
4308
4309 #[tokio::test]
4315 async fn eval_inner_emits_delete_restored_action_when_restore_expired() {
4316 let lc = BucketLifecycleConfiguration {
4317 expiry_updated_at: None,
4318 rules: vec![],
4319 };
4320 let now = datetime!(2025-06-01 12:00:00 UTC);
4321
4322 let current = ObjectOpts {
4323 name: "docs/report.bin".to_string(),
4324 mod_time: Some(datetime!(2025-05-01 00:00:00 UTC)),
4325 is_latest: true,
4326 transition_status: TRANSITION_COMPLETE.to_string(),
4327 restore_expires: Some(now - Duration::hours(1)),
4328 ..Default::default()
4329 };
4330 let event = lc.eval_inner(¤t, now, 0).await;
4331 assert_eq!(event.action, IlmAction::DeleteRestoredAction);
4332
4333 let noncurrent = ObjectOpts {
4334 name: "docs/report.bin".to_string(),
4335 mod_time: Some(datetime!(2025-05-01 00:00:00 UTC)),
4336 is_latest: false,
4337 version_id: Some(Uuid::from_u128(9)),
4338 successor_mod_time: Some(datetime!(2025-05-02 00:00:00 UTC)),
4339 transition_status: TRANSITION_COMPLETE.to_string(),
4340 restore_expires: Some(now - Duration::hours(1)),
4341 ..Default::default()
4342 };
4343 let event = lc.eval_inner(&noncurrent, now, 0).await;
4344 assert_eq!(event.action, IlmAction::DeleteRestoredVersionAction);
4345 }
4346
4347 #[tokio::test]
4350 async fn eval_inner_keeps_unexpired_restore_copy() {
4351 let lc = BucketLifecycleConfiguration {
4352 expiry_updated_at: None,
4353 rules: vec![],
4354 };
4355 let now = datetime!(2025-06-01 12:00:00 UTC);
4356
4357 let current = ObjectOpts {
4358 name: "docs/report.bin".to_string(),
4359 mod_time: Some(datetime!(2025-05-01 00:00:00 UTC)),
4360 is_latest: true,
4361 transition_status: TRANSITION_COMPLETE.to_string(),
4362 restore_expires: Some(now + Duration::hours(1)),
4363 ..Default::default()
4364 };
4365 let event = lc.eval_inner(¤t, now, 0).await;
4366 assert_eq!(event.action, IlmAction::NoneAction);
4367 }
4368
4369 fn rule_with_noncurrent_expiration(expiration: NoncurrentVersionExpiration) -> LifecycleRule {
4372 LifecycleRule {
4373 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
4374 expiration: None,
4375 abort_incomplete_multipart_upload: None,
4376 del_marker_expiration: None,
4377 filter: None,
4378 id: Some("noncurrent".to_string()),
4379 noncurrent_version_expiration: Some(expiration),
4380 noncurrent_version_transitions: None,
4381 prefix: None,
4382 transitions: None,
4383 }
4384 }
4385
4386 fn rule_with_filter(filter: LifecycleRuleFilter) -> LifecycleRule {
4387 LifecycleRule {
4388 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
4389 expiration: Some(LifecycleExpiration {
4390 days: Some(1),
4391 ..Default::default()
4392 }),
4393 abort_incomplete_multipart_upload: None,
4394 del_marker_expiration: None,
4395 filter: Some(filter),
4396 id: Some("filtered".to_string()),
4397 noncurrent_version_expiration: None,
4398 noncurrent_version_transitions: None,
4399 prefix: None,
4400 transitions: None,
4401 }
4402 }
4403
4404 fn config_with_rules(rules: Vec<LifecycleRule>) -> BucketLifecycleConfiguration {
4405 BucketLifecycleConfiguration {
4406 expiry_updated_at: None,
4407 rules,
4408 }
4409 }
4410
4411 fn tag(key: &str, value: &str) -> s3s::dto::Tag {
4412 s3s::dto::Tag {
4413 key: Some(key.to_string()),
4414 value: Some(value.to_string()),
4415 }
4416 }
4417
4418 #[tokio::test]
4419 async fn validate_rejects_negative_newer_noncurrent_versions() {
4420 let lc = config_with_rules(vec![rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4424 noncurrent_days: Some(30),
4425 newer_noncurrent_versions: Some(-1),
4426 })]);
4427
4428 let err = lc
4429 .validate(&ObjectLockConfiguration::default())
4430 .await
4431 .expect_err("a negative retention count must be rejected");
4432
4433 assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_NEWER_NONCURRENT_VERSIONS);
4434 assert_ne!(err.kind(), LIFECYCLE_MALFORMED_XML_ERROR_KIND, "value errors stay InvalidArgument");
4435 }
4436
4437 #[tokio::test]
4438 async fn validate_rejects_negative_newer_noncurrent_versions_on_transition() {
4439 let mut rule = rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4440 noncurrent_days: Some(30),
4441 newer_noncurrent_versions: None,
4442 });
4443 rule.noncurrent_version_transitions = Some(vec![NoncurrentVersionTransition {
4444 newer_noncurrent_versions: Some(-3),
4445 noncurrent_days: Some(1),
4446 storage_class: Some(TransitionStorageClass::from_static(TransitionStorageClass::GLACIER)),
4447 }]);
4448
4449 config_with_rules(vec![rule])
4453 .validate(&ObjectLockConfiguration::default())
4454 .await
4455 .expect_err("a negative retention count on a transition must be rejected");
4456 }
4457
4458 #[tokio::test]
4459 async fn zero_newer_noncurrent_versions_means_no_count_constraint() {
4460 config_with_rules(vec![rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4464 noncurrent_days: Some(30),
4465 newer_noncurrent_versions: Some(0),
4466 })])
4467 .validate(&ObjectLockConfiguration::default())
4468 .await
4469 .expect("zero count alongside NoncurrentDays is valid");
4470
4471 let err = config_with_rules(vec![rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4472 noncurrent_days: None,
4473 newer_noncurrent_versions: Some(0),
4474 })])
4475 .validate(&ObjectLockConfiguration::default())
4476 .await
4477 .expect_err("a zero count on its own is not an action");
4478 assert_eq!(err.to_string(), ERR_LIFECYCLE_RULE_MUST_HAVE_ACTION);
4479 }
4480
4481 #[tokio::test]
4482 async fn validate_accepts_count_only_noncurrent_expiration() {
4483 let lc = config_with_rules(vec![rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4486 noncurrent_days: None,
4487 newer_noncurrent_versions: Some(2),
4488 })]);
4489
4490 lc.validate(&ObjectLockConfiguration::default())
4491 .await
4492 .expect("a count-only noncurrent expiration rule is accepted");
4493 }
4494
4495 #[tokio::test]
4496 async fn eval_inner_expires_versions_beyond_count_only_retention() {
4497 let lc = config_with_rules(vec![rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4500 noncurrent_days: None,
4501 newer_noncurrent_versions: Some(2),
4502 })]);
4503 let opts = ObjectOpts {
4504 name: "obj".to_string(),
4505 mod_time: Some(datetime!(2025-01-15 10:30:45 UTC)),
4506 successor_mod_time: Some(datetime!(2025-01-15 10:30:45 UTC)),
4507 is_latest: false,
4508 num_versions: 5,
4509 ..Default::default()
4510 };
4511
4512 let expired = lc.eval_inner(&opts, datetime!(2025-01-15 10:30:46 UTC), 2).await;
4514 assert_eq!(expired.action, IlmAction::DeleteVersionAction);
4515 assert_eq!(expired.rule_id, "noncurrent");
4516
4517 let retained = lc.eval_inner(&opts, datetime!(2025-01-15 10:30:46 UTC), 1).await;
4519 assert_eq!(retained.action, IlmAction::NoneAction);
4520 }
4521
4522 #[tokio::test]
4523 #[serial]
4524 async fn eval_inner_keeps_age_condition_when_count_and_days_are_set() {
4525 with_default_ilm_process_time(|| {});
4528 let lc = config_with_rules(vec![rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4529 noncurrent_days: Some(10),
4530 newer_noncurrent_versions: Some(1),
4531 })]);
4532 let opts = ObjectOpts {
4533 name: "obj".to_string(),
4534 mod_time: Some(datetime!(2025-01-01 00:00:00 UTC)),
4535 successor_mod_time: Some(datetime!(2025-01-01 00:00:00 UTC)),
4536 is_latest: false,
4537 num_versions: 3,
4538 ..Default::default()
4539 };
4540
4541 let too_young = lc.eval_inner(&opts, datetime!(2025-01-05 00:00:00 UTC), 2).await;
4542 assert_eq!(too_young.action, IlmAction::NoneAction, "the age condition still applies");
4543
4544 let due = lc.eval_inner(&opts, datetime!(2025-01-20 00:00:00 UTC), 2).await;
4545 assert_eq!(due.action, IlmAction::DeleteVersionAction);
4546 }
4547
4548 #[tokio::test]
4549 async fn eval_inner_takes_no_action_for_a_corrupt_retention_count() {
4550 let lc = config_with_rules(vec![rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4553 noncurrent_days: Some(1),
4554 newer_noncurrent_versions: Some(-1),
4555 })]);
4556 let opts = ObjectOpts {
4557 name: "obj".to_string(),
4558 mod_time: Some(datetime!(2025-01-01 00:00:00 UTC)),
4559 successor_mod_time: Some(datetime!(2025-01-01 00:00:00 UTC)),
4560 is_latest: false,
4561 num_versions: 3,
4562 ..Default::default()
4563 };
4564
4565 let event = lc.eval_inner(&opts, datetime!(2025-06-01 00:00:00 UTC), 2).await;
4566
4567 assert_eq!(event.action, IlmAction::NoneAction);
4568 }
4569
4570 #[tokio::test]
4571 async fn eval_inner_does_not_expire_latest_object_for_a_corrupt_retention_rule() {
4572 let mut rule = rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4573 noncurrent_days: Some(1),
4574 newer_noncurrent_versions: Some(-1),
4575 });
4576 rule.expiration = Some(LifecycleExpiration {
4577 days: Some(1),
4578 ..Default::default()
4579 });
4580 let lc = config_with_rules(vec![rule]);
4581 let opts = ObjectOpts {
4582 name: "obj".to_string(),
4583 mod_time: Some(datetime!(2025-01-01 00:00:00 UTC)),
4584 is_latest: true,
4585 ..Default::default()
4586 };
4587
4588 let event = lc.eval_inner(&opts, datetime!(2025-06-01 00:00:00 UTC), 0).await;
4589
4590 assert_eq!(event.action, IlmAction::NoneAction);
4591 }
4592
4593 #[tokio::test]
4594 async fn eval_inner_does_not_delete_latest_marker_for_a_corrupt_retention_rule() {
4595 let mut expired_marker_rule = rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4596 noncurrent_days: Some(1),
4597 newer_noncurrent_versions: Some(-1),
4598 });
4599 expired_marker_rule.expiration = Some(LifecycleExpiration {
4600 expired_object_delete_marker: Some(true),
4601 ..Default::default()
4602 });
4603
4604 let mut aged_marker_rule = rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4605 noncurrent_days: Some(1),
4606 newer_noncurrent_versions: Some(-1),
4607 });
4608 aged_marker_rule.del_marker_expiration = Some(s3s::dto::DelMarkerExpiration { days: Some(1) });
4609
4610 for rule in [expired_marker_rule, aged_marker_rule] {
4611 let lc = config_with_rules(vec![rule]);
4612 let opts = ObjectOpts {
4613 name: "obj".to_string(),
4614 mod_time: Some(datetime!(2025-01-01 00:00:00 UTC)),
4615 version_id: Some(Uuid::new_v4()),
4616 is_latest: true,
4617 delete_marker: true,
4618 num_versions: 1,
4619 ..Default::default()
4620 };
4621
4622 let event = lc.eval_inner(&opts, datetime!(2025-06-01 00:00:00 UTC), 0).await;
4623
4624 assert_eq!(event.action, IlmAction::NoneAction);
4625 }
4626 }
4627
4628 #[test]
4629 fn corrupt_retention_count_is_detected_on_either_action() {
4630 let mut transition_rule = rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4631 noncurrent_days: Some(1),
4632 newer_noncurrent_versions: Some(0),
4633 });
4634 transition_rule.noncurrent_version_transitions = Some(vec![NoncurrentVersionTransition {
4635 newer_noncurrent_versions: Some(-1),
4636 noncurrent_days: Some(1),
4637 storage_class: Some(TransitionStorageClass::from_static(TransitionStorageClass::GLACIER)),
4638 }]);
4639
4640 assert!(lifecycle_has_corrupt_retention_count(&config_with_rules(vec![
4641 rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4642 noncurrent_days: Some(1),
4643 newer_noncurrent_versions: Some(-1),
4644 })
4645 ])));
4646 assert!(lifecycle_has_corrupt_retention_count(&config_with_rules(vec![transition_rule])));
4647 assert!(!lifecycle_has_corrupt_retention_count(&config_with_rules(vec![
4648 rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4649 noncurrent_days: Some(1),
4650 newer_noncurrent_versions: Some(3),
4651 })
4652 ])));
4653 }
4654
4655 #[test]
4656 fn count_only_rules_are_active_only_for_a_positive_count() {
4657 let positive = config_with_rules(vec![rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4658 noncurrent_days: None,
4659 newer_noncurrent_versions: Some(2),
4660 })]);
4661 assert!(positive.has_active_rules(""));
4662
4663 let corrupt = config_with_rules(vec![rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4664 noncurrent_days: None,
4665 newer_noncurrent_versions: Some(-1),
4666 })]);
4667 assert!(!corrupt.has_active_rules(""), "a corrupt retention count must not make a rule active");
4668 }
4669
4670 #[tokio::test]
4671 async fn noncurrent_versions_expiration_limit_ignores_a_corrupt_count() {
4672 let lc = Arc::new(config_with_rules(vec![rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4674 noncurrent_days: Some(1),
4675 newer_noncurrent_versions: Some(-1),
4676 })]));
4677 let opts = ObjectOpts {
4678 name: "obj".to_string(),
4679 mod_time: Some(datetime!(2025-01-01 00:00:00 UTC)),
4680 is_latest: false,
4681 ..Default::default()
4682 };
4683
4684 let event = lc.noncurrent_versions_expiration_limit(&opts).await;
4685
4686 assert_eq!(event.action, IlmAction::NoneAction);
4687 assert_eq!(event.newer_noncurrent_versions, 0);
4688 }
4689
4690 #[tokio::test]
4691 async fn validate_covers_filter_invariants() {
4692 struct Case {
4693 name: &'static str,
4694 filter: LifecycleRuleFilter,
4695 expected: Option<(&'static str, std::io::ErrorKind)>,
4696 }
4697
4698 let cases = vec![
4699 Case {
4700 name: "empty filter applies to all objects",
4702 filter: LifecycleRuleFilter::default(),
4703 expected: None,
4704 },
4705 Case {
4706 name: "single prefix predicate",
4707 filter: LifecycleRuleFilter {
4708 prefix: Some("logs/".to_string()),
4709 ..Default::default()
4710 },
4711 expected: None,
4712 },
4713 Case {
4714 name: "two top-level predicates",
4715 filter: LifecycleRuleFilter {
4716 prefix: Some("logs/".to_string()),
4717 tag: Some(tag("env", "prod")),
4718 ..Default::default()
4719 },
4720 expected: Some((ERR_LIFECYCLE_FILTER_TOO_MANY_PREDICATES, LIFECYCLE_MALFORMED_XML_ERROR_KIND)),
4721 },
4722 Case {
4723 name: "prefix alongside And",
4724 filter: LifecycleRuleFilter {
4725 prefix: Some("logs/".to_string()),
4726 and: Some(LifecycleRuleAndOperator {
4727 prefix: Some("logs/".to_string()),
4728 tags: Some(vec![tag("env", "prod")]),
4729 ..Default::default()
4730 }),
4731 ..Default::default()
4732 },
4733 expected: Some((ERR_LIFECYCLE_FILTER_TOO_MANY_PREDICATES, LIFECYCLE_MALFORMED_XML_ERROR_KIND)),
4734 },
4735 Case {
4736 name: "And with a single member",
4737 filter: LifecycleRuleFilter {
4738 and: Some(LifecycleRuleAndOperator {
4739 prefix: Some("logs/".to_string()),
4740 ..Default::default()
4741 }),
4742 ..Default::default()
4743 },
4744 expected: Some((ERR_LIFECYCLE_FILTER_AND_TOO_FEW_PREDICATES, LIFECYCLE_MALFORMED_XML_ERROR_KIND)),
4745 },
4746 Case {
4747 name: "And with two members",
4748 filter: LifecycleRuleFilter {
4749 and: Some(LifecycleRuleAndOperator {
4750 prefix: Some("logs/".to_string()),
4751 tags: Some(vec![tag("env", "prod")]),
4752 ..Default::default()
4753 }),
4754 ..Default::default()
4755 },
4756 expected: None,
4757 },
4758 Case {
4759 name: "And with two tags",
4760 filter: LifecycleRuleFilter {
4761 and: Some(LifecycleRuleAndOperator {
4762 tags: Some(vec![tag("env", "prod"), tag("team", "storage")]),
4763 ..Default::default()
4764 }),
4765 ..Default::default()
4766 },
4767 expected: None,
4768 },
4769 Case {
4770 name: "And repeating a tag key",
4771 filter: LifecycleRuleFilter {
4772 and: Some(LifecycleRuleAndOperator {
4773 tags: Some(vec![tag("env", "prod"), tag("env", "dev")]),
4774 ..Default::default()
4775 }),
4776 ..Default::default()
4777 },
4778 expected: Some((ERR_LIFECYCLE_FILTER_DUPLICATE_TAG_KEY, std::io::ErrorKind::Other)),
4779 },
4780 Case {
4781 name: "empty tag key",
4782 filter: LifecycleRuleFilter {
4783 tag: Some(tag("", "prod")),
4784 ..Default::default()
4785 },
4786 expected: Some((ERR_LIFECYCLE_FILTER_INVALID_TAG, std::io::ErrorKind::Other)),
4787 },
4788 Case {
4789 name: "missing tag key",
4790 filter: LifecycleRuleFilter {
4791 tag: Some(s3s::dto::Tag {
4792 key: None,
4793 value: Some("prod".to_string()),
4794 }),
4795 ..Default::default()
4796 },
4797 expected: Some((ERR_LIFECYCLE_FILTER_INVALID_TAG, std::io::ErrorKind::Other)),
4798 },
4799 Case {
4800 name: "missing tag value",
4801 filter: LifecycleRuleFilter {
4802 tag: Some(s3s::dto::Tag {
4803 key: Some("env".to_string()),
4804 value: None,
4805 }),
4806 ..Default::default()
4807 },
4808 expected: Some((ERR_LIFECYCLE_FILTER_INVALID_TAG, std::io::ErrorKind::Other)),
4809 },
4810 Case {
4811 name: "empty tag value",
4812 filter: LifecycleRuleFilter {
4813 tag: Some(tag("env", "")),
4814 ..Default::default()
4815 },
4816 expected: None,
4817 },
4818 Case {
4819 name: "tag key at the limit",
4820 filter: LifecycleRuleFilter {
4821 tag: Some(tag(&"k".repeat(MAX_TAG_KEY_LEN), "prod")),
4822 ..Default::default()
4823 },
4824 expected: None,
4825 },
4826 Case {
4827 name: "tag key past the limit",
4828 filter: LifecycleRuleFilter {
4829 tag: Some(tag(&"k".repeat(MAX_TAG_KEY_LEN + 1), "prod")),
4830 ..Default::default()
4831 },
4832 expected: Some((ERR_LIFECYCLE_FILTER_INVALID_TAG, std::io::ErrorKind::Other)),
4833 },
4834 Case {
4835 name: "tag value past the limit",
4836 filter: LifecycleRuleFilter {
4837 tag: Some(tag("env", &"v".repeat(MAX_TAG_VALUE_LEN + 1))),
4838 ..Default::default()
4839 },
4840 expected: Some((ERR_LIFECYCLE_FILTER_INVALID_TAG, std::io::ErrorKind::Other)),
4841 },
4842 Case {
4843 name: "negative ObjectSizeGreaterThan",
4844 filter: LifecycleRuleFilter {
4845 object_size_greater_than: Some(-1),
4846 ..Default::default()
4847 },
4848 expected: Some((ERR_LIFECYCLE_FILTER_NEGATIVE_SIZE, std::io::ErrorKind::Other)),
4849 },
4850 Case {
4851 name: "negative ObjectSizeLessThan",
4852 filter: LifecycleRuleFilter {
4853 object_size_less_than: Some(-5),
4854 ..Default::default()
4855 },
4856 expected: Some((ERR_LIFECYCLE_FILTER_NEGATIVE_SIZE, std::io::ErrorKind::Other)),
4857 },
4858 Case {
4859 name: "inverted size range inside And",
4860 filter: LifecycleRuleFilter {
4861 and: Some(LifecycleRuleAndOperator {
4862 object_size_greater_than: Some(100),
4863 object_size_less_than: Some(100),
4864 ..Default::default()
4865 }),
4866 ..Default::default()
4867 },
4868 expected: Some((ERR_LIFECYCLE_FILTER_SIZE_RANGE, std::io::ErrorKind::Other)),
4869 },
4870 Case {
4871 name: "valid size range inside And",
4872 filter: LifecycleRuleFilter {
4873 and: Some(LifecycleRuleAndOperator {
4874 object_size_greater_than: Some(1),
4875 object_size_less_than: Some(2),
4876 ..Default::default()
4877 }),
4878 ..Default::default()
4879 },
4880 expected: None,
4881 },
4882 ];
4883
4884 for case in cases {
4885 let result = config_with_rules(vec![rule_with_filter(case.filter)])
4886 .validate(&ObjectLockConfiguration::default())
4887 .await;
4888 match (case.expected, result) {
4889 (None, Ok(())) => {}
4890 (None, Err(err)) => panic!("{}: expected acceptance, got {err}", case.name),
4891 (Some((message, _)), Ok(())) => panic!("{}: expected rejection with {message}", case.name),
4892 (Some((message, kind)), Err(err)) => {
4893 assert_eq!(err.to_string(), message, "{}", case.name);
4894 assert_eq!(err.kind(), kind, "{}: wrong S3 error category", case.name);
4895 }
4896 }
4897 }
4898 }
4899
4900 #[tokio::test]
4901 async fn validate_keeps_legacy_prefix_and_filter_mutually_exclusive() {
4902 let mut rule = rule_with_filter(LifecycleRuleFilter {
4903 prefix: Some("logs/".to_string()),
4904 ..Default::default()
4905 });
4906 rule.prefix = Some("legacy/".to_string());
4907
4908 let err = config_with_rules(vec![rule])
4909 .validate(&ObjectLockConfiguration::default())
4910 .await
4911 .expect_err("legacy Prefix and Filter cannot both be present");
4912
4913 assert_eq!(err.to_string(), ERR_LIFECYCLE_PREFIX_FILTER_CONFLICT);
4914 }
4915
4916 #[test]
4917 fn count_only_rule_round_trips_through_xml() {
4918 let xml = br#"<LifecycleConfiguration><Rule><ID>count-only</ID><Status>Enabled</Status><Filter></Filter><NoncurrentVersionExpiration><NewerNoncurrentVersions>2</NewerNoncurrentVersions></NoncurrentVersionExpiration></Rule></LifecycleConfiguration>"#;
4921 let mut deserializer = s3s::xml::Deserializer::new(xml);
4922 let parsed =
4923 <BucketLifecycleConfiguration as XmlDeserialize>::deserialize(&mut deserializer).expect("count-only XML parses");
4924
4925 let expiration = parsed.rules[0]
4926 .noncurrent_version_expiration
4927 .as_ref()
4928 .expect("noncurrent expiration is present");
4929 assert_eq!(expiration.newer_noncurrent_versions, Some(2));
4930 assert_eq!(expiration.noncurrent_days, None);
4931
4932 let mut buf = Vec::new();
4933 let mut serializer = s3s::xml::Serializer::new(&mut buf);
4934 XmlSerializeContent::serialize_content(&parsed, &mut serializer).expect("count-only config serializes");
4935 let serialized = String::from_utf8(buf).expect("serialized XML is UTF-8");
4936 assert!(
4937 serialized.contains("<NewerNoncurrentVersions>2</NewerNoncurrentVersions>"),
4938 "retention count survives the round trip: {serialized}"
4939 );
4940 assert!(
4941 !serialized.contains("<NoncurrentDays>"),
4942 "a count-only rule must not gain an age condition: {serialized}"
4943 );
4944 }
4945
4946 mod adversarial_regressions {
4947 use super::*;
4948 use s3s::dto::NoncurrentVersionExpiration;
4949
4950 fn run(test: impl std::future::Future<Output = ()>) {
4951 with_default_ilm_process_time(|| {
4952 tokio::runtime::Builder::new_current_thread()
4953 .build()
4954 .expect("lifecycle regression runtime should build")
4955 .block_on(test);
4956 });
4957 }
4958
4959 fn noncurrent_object() -> ObjectOpts {
4960 ObjectOpts {
4961 name: "logs/object".to_string(),
4962 mod_time: Some(datetime!(2020-01-01 00:00:00 UTC)),
4963 successor_mod_time: Some(datetime!(2020-01-02 00:00:00 UTC)),
4964 version_id: Some(Uuid::from_u128(1)),
4965 size: 1024 * 1024,
4966 ..Default::default()
4967 }
4968 }
4969
4970 #[test]
4971 #[serial]
4972 fn noncurrent_transition_retains_the_requested_newer_versions() {
4973 run(async {
4974 let mut rule = enabled_rule(None, None, Some("retain-two-hot-versions"));
4975 rule.filter = Some(LifecycleRuleFilter::default());
4976 rule.noncurrent_version_transitions = Some(vec![NoncurrentVersionTransition {
4977 noncurrent_days: Some(1),
4978 newer_noncurrent_versions: Some(2),
4979 storage_class: Some(TransitionStorageClass::from_static("WARM")),
4980 }]);
4981 let lc = Arc::new(BucketLifecycleConfiguration {
4982 rules: vec![rule],
4983 expiry_updated_at: None,
4984 });
4985 lc.validate(&ObjectLockConfiguration::default())
4986 .await
4987 .expect("valid noncurrent transition policy");
4988 let objects = (0..4)
4989 .map(|index| ObjectOpts {
4990 mod_time: Some(datetime!(2020-01-05 00:00:00 UTC) - Duration::days(index)),
4991 successor_mod_time: (index > 0).then_some(datetime!(2020-01-06 00:00:00 UTC) - Duration::days(index)),
4992 version_id: Some(Uuid::from_u128(u128::try_from(index + 1).expect("small version index"))),
4993 is_latest: index == 0,
4994 num_versions: 4,
4995 ..noncurrent_object()
4996 })
4997 .collect::<Vec<_>>();
4998 let actions = crate::Evaluator::new(lc)
4999 .eval(&objects)
5000 .await
5001 .expect("complete version chain should evaluate")
5002 .into_iter()
5003 .map(|event| event.action)
5004 .collect::<Vec<_>>();
5005 assert_eq!(
5006 actions,
5007 [
5008 IlmAction::NoneAction,
5009 IlmAction::NoneAction,
5010 IlmAction::NoneAction,
5011 IlmAction::TransitionVersionAction
5012 ],
5013 "the two newest noncurrent versions must remain in their current storage class"
5014 );
5015 });
5016 }
5017
5018 #[test]
5019 #[serial]
5020 fn noncurrent_transition_checks_count_age_and_single_object_context() {
5021 run(async {
5022 let mut rule = enabled_rule(None, None, Some("retain-two"));
5023 rule.filter = Some(LifecycleRuleFilter::default());
5024 rule.noncurrent_version_transitions = Some(vec![NoncurrentVersionTransition {
5025 noncurrent_days: Some(3),
5026 newer_noncurrent_versions: Some(2),
5027 storage_class: Some(TransitionStorageClass::from_static("WARM")),
5028 }]);
5029 let mut lc = BucketLifecycleConfiguration {
5030 rules: vec![rule],
5031 expiry_updated_at: None,
5032 };
5033 lc.validate(&ObjectLockConfiguration::default())
5034 .await
5035 .expect("valid counted transition");
5036 let object = noncurrent_object();
5037 let now = datetime!(2020-01-10 00:00:00 UTC);
5038 for (newer, expected) in [
5039 (0, IlmAction::NoneAction),
5040 (1, IlmAction::NoneAction),
5041 (2, IlmAction::TransitionVersionAction),
5042 (3, IlmAction::TransitionVersionAction),
5043 ] {
5044 assert_eq!(lc.eval_inner(&object, now, newer).await.action, expected, "newer count: {newer}");
5045 }
5046 assert_eq!(
5047 lc.eval_inner(&object, datetime!(2020-01-04 00:00:00 UTC), 2).await.action,
5048 IlmAction::NoneAction,
5049 "the retention count does not replace the age condition"
5050 );
5051 assert_eq!(
5052 lc.eval(&object).await.action,
5053 IlmAction::NoneAction,
5054 "a single-object lookup must not assume a complete version history"
5055 );
5056 for retain in [None, Some(0), Some(-1), Some(i32::MAX)] {
5057 lc.rules[0]
5058 .noncurrent_version_transitions
5059 .as_mut()
5060 .expect("transition exists")[0]
5061 .newer_noncurrent_versions = retain;
5062 let expected = if matches!(retain, None | Some(0)) {
5063 IlmAction::TransitionVersionAction
5064 } else {
5065 IlmAction::NoneAction
5066 };
5067 assert_eq!(lc.eval_inner(&object, now, 2).await.action, expected, "retention: {retain:?}");
5068 }
5069 });
5070 }
5071
5072 #[test]
5073 #[serial]
5074 fn noncurrent_expiration_and_transition_have_independent_retention_counts() {
5075 run(async {
5076 let mut rule = enabled_rule(None, None, Some("independent-counts"));
5077 rule.filter = Some(LifecycleRuleFilter::default());
5078 rule.noncurrent_version_expiration = Some(NoncurrentVersionExpiration {
5079 noncurrent_days: Some(90),
5080 newer_noncurrent_versions: Some(4),
5081 });
5082 rule.noncurrent_version_transitions = Some(vec![NoncurrentVersionTransition {
5083 noncurrent_days: Some(30),
5084 newer_noncurrent_versions: Some(2),
5085 storage_class: Some(TransitionStorageClass::from_static("WARM")),
5086 }]);
5087 let lc = BucketLifecycleConfiguration {
5088 rules: vec![rule],
5089 expiry_updated_at: None,
5090 };
5091 lc.validate(&ObjectLockConfiguration::default())
5092 .await
5093 .expect("valid independent retention limits");
5094 let object = noncurrent_object();
5095 let now = datetime!(2020-05-01 00:00:00 UTC);
5096 for (newer, expected) in [
5097 (1, IlmAction::NoneAction),
5098 (2, IlmAction::TransitionVersionAction),
5099 (3, IlmAction::TransitionVersionAction),
5100 (4, IlmAction::DeleteVersionAction),
5101 ] {
5102 assert_eq!(lc.eval_inner(&object, now, newer).await.action, expected, "newer count: {newer}");
5103 }
5104 });
5105 }
5106
5107 #[test]
5108 #[serial]
5109 fn expiration_retention_does_not_skip_an_independent_transition() {
5110 run(async {
5111 let mut rule = enabled_rule(None, None, Some("transition-then-expire"));
5112 rule.filter = Some(LifecycleRuleFilter::default());
5113 rule.noncurrent_version_transitions = Some(vec![NoncurrentVersionTransition {
5114 noncurrent_days: Some(1),
5115 newer_noncurrent_versions: None,
5116 storage_class: Some(TransitionStorageClass::from_static("WARM")),
5117 }]);
5118 let mut lc = BucketLifecycleConfiguration {
5119 rules: vec![rule],
5120 expiry_updated_at: None,
5121 };
5122 let object = noncurrent_object();
5123 let now = datetime!(2020-01-10 00:00:00 UTC);
5124 let transition_only = lc.eval_inner(&object, now, 0).await;
5125 assert_eq!(transition_only.action, IlmAction::TransitionVersionAction);
5126
5127 lc.rules[0].noncurrent_version_expiration = Some(NoncurrentVersionExpiration {
5128 noncurrent_days: Some(90),
5129 newer_noncurrent_versions: Some(2),
5130 });
5131 lc.validate(&ObjectLockConfiguration::default())
5132 .await
5133 .expect("valid combined policy");
5134 let combined = lc.eval_inner(&object, now, 0).await;
5135 assert_eq!(combined.action, transition_only.action, "retention limits expiration, not transition");
5136 assert_eq!(combined.storage_class, transition_only.storage_class);
5137 });
5138 }
5139
5140 #[test]
5141 #[serial]
5142 fn current_transition_rejects_multiple_stages_in_any_order() {
5143 run(async {
5144 let mut rule = enabled_rule(None, None, Some("two-current-transitions"));
5145 rule.transitions = Some(vec![
5146 Transition {
5147 date: Some(datetime!(2020-03-01 00:00:00 UTC).into()),
5148 days: None,
5149 storage_class: Some(TransitionStorageClass::from_static("COLD")),
5150 },
5151 Transition {
5152 date: Some(datetime!(2020-01-03 00:00:00 UTC).into()),
5153 days: None,
5154 storage_class: Some(TransitionStorageClass::from_static("WARM")),
5155 },
5156 ]);
5157 let mut lc = BucketLifecycleConfiguration {
5158 rules: vec![rule],
5159 expiry_updated_at: None,
5160 };
5161 let object = ObjectOpts {
5162 is_latest: true,
5163 ..noncurrent_object()
5164 };
5165 let now = datetime!(2020-01-10 00:00:00 UTC);
5166 for status in [ExpirationStatus::ENABLED, ExpirationStatus::DISABLED] {
5167 lc.rules[0].status = ExpirationStatus::from_static(status);
5168 for _ in 0..2 {
5169 let err = lc
5170 .validate(&ObjectLockConfiguration::default())
5171 .await
5172 .expect_err("multiple transition stages must be rejected");
5173 assert_eq!(err.kind(), std::io::ErrorKind::InvalidInput);
5174 assert_eq!(err.to_string(), ERR_LIFECYCLE_MULTIPLE_TRANSITIONS);
5175 assert_eq!(
5176 lc.eval_inner(&object, now, 0).await.action,
5177 IlmAction::NoneAction,
5178 "legacy multi-stage configurations must not silently execute their first stage"
5179 );
5180 lc.rules[0]
5181 .transitions
5182 .as_mut()
5183 .expect("transition array is present")
5184 .reverse();
5185 }
5186 }
5187 lc.rules[0]
5188 .transitions
5189 .as_mut()
5190 .expect("transition array is present")
5191 .remove(0);
5192 lc.rules[0].status = ExpirationStatus::from_static(ExpirationStatus::ENABLED);
5193 lc.validate(&ObjectLockConfiguration::default())
5194 .await
5195 .expect("one stage is supported");
5196 let event = lc.eval_inner(&object, now, 0).await;
5197 assert_eq!(event.action, IlmAction::TransitionAction);
5198 assert_eq!(event.storage_class, "WARM");
5199 });
5200 }
5201
5202 #[test]
5203 #[serial]
5204 fn noncurrent_transition_rejects_multiple_stages_in_any_order() {
5205 run(async {
5206 let mut rule = enabled_rule(None, None, Some("two-noncurrent-transitions"));
5207 rule.noncurrent_version_transitions = Some(vec![
5208 NoncurrentVersionTransition {
5209 noncurrent_days: Some(30),
5210 newer_noncurrent_versions: None,
5211 storage_class: Some(TransitionStorageClass::from_static("COLD")),
5212 },
5213 NoncurrentVersionTransition {
5214 noncurrent_days: Some(1),
5215 newer_noncurrent_versions: None,
5216 storage_class: Some(TransitionStorageClass::from_static("WARM")),
5217 },
5218 ]);
5219 let mut lc = BucketLifecycleConfiguration {
5220 rules: vec![rule],
5221 expiry_updated_at: None,
5222 };
5223 let object = noncurrent_object();
5224 let now = datetime!(2020-01-10 00:00:00 UTC);
5225 for status in [ExpirationStatus::ENABLED, ExpirationStatus::DISABLED] {
5226 lc.rules[0].status = ExpirationStatus::from_static(status);
5227 for _ in 0..2 {
5228 let err = lc
5229 .validate(&ObjectLockConfiguration::default())
5230 .await
5231 .expect_err("multiple noncurrent transition stages must be rejected");
5232 assert_eq!(err.kind(), std::io::ErrorKind::InvalidInput);
5233 assert_eq!(err.to_string(), ERR_LIFECYCLE_MULTIPLE_NONCURRENT_TRANSITIONS);
5234 assert_eq!(
5235 lc.eval_inner(&object, now, 0).await.action,
5236 IlmAction::NoneAction,
5237 "legacy multi-stage configurations must not silently execute their first stage"
5238 );
5239 lc.rules[0]
5240 .noncurrent_version_transitions
5241 .as_mut()
5242 .expect("transition array is present")
5243 .reverse();
5244 }
5245 }
5246 lc.rules[0]
5247 .noncurrent_version_transitions
5248 .as_mut()
5249 .expect("transition array is present")
5250 .remove(0);
5251 lc.rules[0].status = ExpirationStatus::from_static(ExpirationStatus::ENABLED);
5252 lc.validate(&ObjectLockConfiguration::default())
5253 .await
5254 .expect("one stage is supported");
5255 let event = lc.eval_inner(&object, now, 0).await;
5256 assert_eq!(event.action, IlmAction::TransitionVersionAction);
5257 assert_eq!(event.storage_class, "WARM");
5258 });
5259 }
5260
5261 #[test]
5262 #[serial]
5263 fn expiration_rejects_simultaneous_days_and_date() {
5264 run(async {
5265 let mut lc = BucketLifecycleConfiguration {
5266 rules: vec![enabled_rule(
5267 Some(LifecycleExpiration {
5268 days: Some(1),
5269 ..Default::default()
5270 }),
5271 None,
5272 Some("ambiguous-expiry"),
5273 )],
5274 expiry_updated_at: None,
5275 };
5276 lc.validate(&ObjectLockConfiguration::default())
5277 .await
5278 .expect("a single Days expiration is valid");
5279 lc.rules[0].expiration.as_mut().expect("expiration is present").date =
5280 Some(datetime!(2099-01-01 00:00:00 UTC).into());
5281 let err = lc
5282 .validate(&ObjectLockConfiguration::default())
5283 .await
5284 .expect_err("Days and Date are mutually exclusive; accepting both silently overrides Days");
5285 assert_eq!(err.kind(), std::io::ErrorKind::InvalidInput);
5286 assert_eq!(err.to_string(), ERR_LIFECYCLE_EXPIRATION_DAYS_DATE_CONFLICT);
5287 });
5288 }
5289
5290 #[test]
5291 #[serial]
5292 fn overdue_transition_does_not_starve_permanent_expiration() {
5293 run(async {
5294 let mut rule = enabled_rule(
5295 Some(LifecycleExpiration {
5296 days: Some(90),
5297 ..Default::default()
5298 }),
5299 None,
5300 Some("archive-then-delete"),
5301 );
5302 rule.transitions = Some(vec![Transition {
5303 days: Some(30),
5304 date: None,
5305 storage_class: Some(TransitionStorageClass::from_static("WARM")),
5306 }]);
5307 let lc = BucketLifecycleConfiguration {
5308 rules: vec![rule],
5309 expiry_updated_at: None,
5310 };
5311 lc.validate(&ObjectLockConfiguration::default())
5312 .await
5313 .expect("valid transition and expiration policy");
5314 let object = ObjectOpts {
5315 is_latest: true,
5316 version_id: None,
5317 transition_status: TRANSITION_PENDING.to_string(),
5318 ..noncurrent_object()
5319 };
5320 let before_expiration = lc.eval_inner(&object, datetime!(2020-02-15 00:00:00 UTC), 0).await;
5321 assert_eq!(before_expiration.action, IlmAction::TransitionAction);
5322 let overdue = lc.eval_inner(&object, datetime!(2020-05-01 00:00:00 UTC), 0).await;
5323 assert_eq!(
5324 overdue.action,
5325 IlmAction::DeleteAction,
5326 "an unavailable tier must not prevent permanent expiration indefinitely"
5327 );
5328 });
5329 }
5330 }
5331
5332 mod proptests {
5351 use super::*;
5352 use proptest::prelude::*;
5353 use s3s::dto::{NoncurrentVersionExpiration, Tag};
5354 use serial_test::serial;
5355
5356 const DAY_SECS: i64 = 86400;
5357
5358 fn base() -> OffsetDateTime {
5361 datetime!(2025-01-01 00:00:00 UTC)
5362 }
5363
5364 fn ts(offset_secs: i64) -> OffsetDateTime {
5365 base() + Duration::seconds(offset_secs)
5366 }
5367
5368 fn with_production_time_env<T>(f: impl FnOnce() -> T) -> T {
5372 temp_env::with_vars(
5373 [
5374 (ENV_ILM_DEBUG_DAY_SECS, None::<&str>),
5375 (ENV_ILM_PROCESS_TIME, None),
5376 (ENV_ILM_PROCESS_TIME_DEPRECATED, None),
5377 ],
5378 f,
5379 )
5380 }
5381
5382 fn arb_opt_time(window_secs: i64) -> impl Strategy<Value = Option<OffsetDateTime>> {
5383 prop_oneof![
5384 2 => Just(None),
5385 1 => Just(Some(OffsetDateTime::UNIX_EPOCH)),
5386 5 => (-window_secs..window_secs).prop_map(|s| Some(ts(s))),
5387 ]
5388 }
5389
5390 fn arb_object_name() -> impl Strategy<Value = String> {
5391 prop_oneof![
5392 1 => Just(String::new()),
5393 3 => Just("docs/report.txt".to_string()),
5394 2 => Just("logs/app.log".to_string()),
5395 1 => "[a-z]{1,12}",
5396 ]
5397 }
5398
5399 fn arb_user_tags() -> impl Strategy<Value = String> {
5400 prop_oneof![
5401 Just(String::new()),
5402 Just("env=prod".to_string()),
5403 Just("env=prod&team=storage".to_string()),
5404 Just("team=storage".to_string()),
5405 ]
5406 }
5407
5408 fn arb_transition_status() -> impl Strategy<Value = String> {
5409 prop_oneof![
5410 Just(String::new()),
5411 Just(TRANSITION_PENDING.to_string()),
5412 Just(TRANSITION_COMPLETE.to_string()),
5413 ]
5414 }
5415
5416 prop_compose! {
5417 fn arb_object_identity()(
5418 name in arb_object_name(),
5419 user_tags in arb_user_tags(),
5420 mod_time in arb_opt_time(4 * DAY_SECS),
5421 size in prop_oneof![Just(0usize), (1usize..1_048_576), Just(usize::MAX >> 1)],
5422 version_id in prop_oneof![Just(None), Just(Some(Uuid::nil())), Just(Some(Uuid::from_u128(7)))],
5423 is_latest in any::<bool>(),
5424 delete_marker in any::<bool>(),
5425 ) -> (String, String, Option<OffsetDateTime>, usize, Option<Uuid>, bool, bool) {
5426 (name, user_tags, mod_time, size, version_id, is_latest, delete_marker)
5427 }
5428 }
5429
5430 prop_compose! {
5431 fn arb_object_opts()(
5435 (name, user_tags, mod_time, size, version_id, is_latest, delete_marker) in arb_object_identity(),
5436 num_versions in 0usize..4,
5437 successor_mod_time in arb_opt_time(4 * DAY_SECS),
5438 transition_status in arb_transition_status(),
5439 restore_ongoing in any::<bool>(),
5440 restore_expires in arb_opt_time(2 * DAY_SECS),
5441 versioned in any::<bool>(),
5442 version_suspended in any::<bool>(),
5443 ) -> ObjectOpts {
5444 ObjectOpts {
5445 name,
5446 user_tags,
5447 mod_time,
5448 size,
5449 version_id,
5450 is_latest,
5451 delete_marker,
5452 num_versions,
5453 successor_mod_time,
5454 transition_status,
5455 restore_ongoing,
5456 restore_expires,
5457 versioned,
5458 version_suspended,
5459 ..Default::default()
5460 }
5461 }
5462 }
5463
5464 fn arb_prefix() -> impl Strategy<Value = Option<String>> {
5465 prop_oneof![
5466 3 => Just(None),
5467 1 => Just(Some(String::new())),
5468 2 => Just(Some("docs/".to_string())),
5469 1 => Just(Some("logs/".to_string())),
5470 ]
5471 }
5472
5473 fn arb_filter() -> impl Strategy<Value = Option<LifecycleRuleFilter>> {
5474 prop_oneof![
5475 4 => Just(None),
5476 1 => Just(Some(LifecycleRuleFilter {
5477 prefix: Some("docs/".to_string()),
5478 ..Default::default()
5479 })),
5480 1 => Just(Some(LifecycleRuleFilter {
5481 tag: Some(Tag {
5482 key: Some("env".to_string()),
5483 value: Some("prod".to_string()),
5484 }),
5485 ..Default::default()
5486 })),
5487 1 => (0i64..2048).prop_map(|gt| Some(LifecycleRuleFilter {
5488 object_size_greater_than: Some(gt),
5489 ..Default::default()
5490 })),
5491 ]
5492 }
5493
5494 prop_compose! {
5495 fn arb_expiration()(
5496 date_off in prop::option::of(-2 * DAY_SECS..2 * DAY_SECS),
5497 days in prop::option::of(0i32..4),
5498 delete_marker_flag in prop::option::of(any::<bool>()),
5499 all_versions in prop::option::of(any::<bool>()),
5500 ) -> LifecycleExpiration {
5501 LifecycleExpiration {
5502 date: date_off.map(|s| ts(s).into()),
5503 days,
5504 expired_object_delete_marker: delete_marker_flag,
5505 expired_object_all_versions: all_versions,
5506 }
5507 }
5508 }
5509
5510 prop_compose! {
5511 fn arb_transition()(
5512 date_off in prop::option::of(-2 * DAY_SECS..2 * DAY_SECS),
5513 days in prop::option::of(0i32..4),
5514 storage_class in prop_oneof![
5515 Just(None),
5516 Just(Some(TransitionStorageClass::from_static(""))),
5517 Just(Some(TransitionStorageClass::from_static("COLD"))),
5518 ],
5519 ) -> Transition {
5520 Transition {
5521 date: date_off.map(|s| ts(s).into()),
5522 days,
5523 storage_class,
5524 }
5525 }
5526 }
5527
5528 prop_compose! {
5529 fn arb_rule()(
5533 enabled in prop::bool::weighted(0.8),
5534 id in prop::option::of("[a-z]{1,6}"),
5535 prefix in arb_prefix(),
5536 filter in arb_filter(),
5537 expiration in prop::option::of(arb_expiration()),
5538 transitions in prop::option::of(prop::collection::vec(arb_transition(), 0..2)),
5539 nc_exp in prop::option::of((prop::option::of(0i32..4), prop::option::of(0i32..3))),
5540 nc_tr in prop::option::of((prop::option::of(0i32..4), any::<bool>())),
5541 dme_days in prop::option::of(0i32..3),
5542 abort_days in prop::option::of(0i32..3),
5543 ) -> LifecycleRule {
5544 LifecycleRule {
5545 status: if enabled {
5546 ExpirationStatus::from_static(ExpirationStatus::ENABLED)
5547 } else {
5548 ExpirationStatus::from_static(ExpirationStatus::DISABLED)
5549 },
5550 id,
5551 prefix,
5552 filter,
5553 expiration,
5554 transitions,
5555 noncurrent_version_expiration: nc_exp.map(|(noncurrent_days, newer_noncurrent_versions)| {
5556 NoncurrentVersionExpiration {
5557 noncurrent_days,
5558 newer_noncurrent_versions,
5559 }
5560 }),
5561 noncurrent_version_transitions: nc_tr.map(|(noncurrent_days, has_sc)| {
5562 vec![NoncurrentVersionTransition {
5563 noncurrent_days,
5564 newer_noncurrent_versions: None,
5565 storage_class: has_sc.then(|| TransitionStorageClass::from_static("COLD")),
5566 }]
5567 }),
5568 del_marker_expiration: dme_days.map(|days| s3s::dto::DelMarkerExpiration { days: Some(days) }),
5569 abort_incomplete_multipart_upload: abort_days.map(|days| {
5570 s3s::dto::AbortIncompleteMultipartUpload {
5571 days_after_initiation: Some(days),
5572 }
5573 }),
5574 }
5575 }
5576 }
5577
5578 proptest! {
5579 #![proptest_config(ProptestConfig::with_cases(96))]
5580
5581 #[test]
5585 #[serial]
5586 fn eval_inner_never_panics_and_is_deterministic(
5587 rules in prop::collection::vec(arb_rule(), 0..4),
5588 obj in arb_object_opts(),
5589 now_off in (-4 * DAY_SECS)..(8 * DAY_SECS),
5590 newer_noncurrent in 0usize..4,
5591 ) {
5592 let lc = BucketLifecycleConfiguration {
5593 expiry_updated_at: None,
5594 rules,
5595 };
5596 let now = ts(now_off);
5597 let (first, second) = block_on_with_env(&[], || async {
5598 let first = lc.eval_inner(&obj, now, newer_noncurrent).await;
5599 let second = lc.eval_inner(&obj, now, newer_noncurrent).await;
5600 (first, second)
5601 });
5602 prop_assert_eq!(first.action, second.action);
5603 prop_assert_eq!(&first.rule_id, &second.rule_id);
5604 prop_assert_eq!(first.due, second.due);
5605 prop_assert_eq!(&first.storage_class, &second.storage_class);
5606 }
5607 }
5608
5609 type Candidate = (i64, u8);
5612
5613 fn oracle_rank(action: &IlmAction) -> u8 {
5618 match action {
5619 IlmAction::DeleteAllVersionsAction
5620 | IlmAction::DelMarkerDeleteAllVersionsAction
5621 | IlmAction::DeleteAction
5622 | IlmAction::DeleteVersionAction => 0,
5623 _ => 1,
5624 }
5625 }
5626
5627 fn oracle_candidates(lc: &BucketLifecycleConfiguration, obj: &ObjectOpts, now: OffsetDateTime) -> Vec<Candidate> {
5634 let mod_time = obj.mod_time.expect("selection strategy always sets mod_time");
5635 let mut candidates = Vec::new();
5636 for rule in &lc.rules {
5637 if let Some(expiration) = &rule.expiration {
5638 if let Some(date) = &expiration.date {
5642 let due = OffsetDateTime::from(date.clone());
5643 if due.unix_timestamp() != 0 && now.unix_timestamp() >= due.unix_timestamp() {
5644 candidates.push((due.unix_timestamp(), 0));
5645 }
5646 } else if let Some(days) = expiration.days {
5647 let due = expected_expiry_time(mod_time, days);
5648 if now.unix_timestamp() >= due.unix_timestamp() {
5649 candidates.push((due.unix_timestamp(), 0));
5650 }
5651 }
5652 }
5653 if obj.transition_status != TRANSITION_COMPLETE
5654 && let Some(transition) = rule.transitions.as_ref().and_then(|transitions| transitions.first())
5655 && transition.storage_class.as_ref().is_some_and(|sc| !sc.as_str().is_empty())
5656 {
5657 let due = if let Some(date) = &transition.date {
5658 Some(OffsetDateTime::from(date.clone()))
5659 } else {
5660 transition.days.map(|days| expected_expiry_time(mod_time, days))
5661 };
5662 if let Some(due) = due
5663 && now.unix_timestamp() > due.unix_timestamp()
5664 {
5665 candidates.push((due.unix_timestamp(), 1));
5666 }
5667 }
5668 }
5669 candidates
5670 }
5671
5672 prop_compose! {
5673 fn arb_selection_rule()(
5677 kind in 0u8..3,
5678 exp_by_date in any::<bool>(),
5679 exp_date_off in (-2 * DAY_SECS)..(2 * DAY_SECS),
5680 exp_days in 0i32..4,
5681 all_versions in any::<bool>(),
5682 tr_by_date in any::<bool>(),
5683 tr_date_off in (-2 * DAY_SECS)..(2 * DAY_SECS),
5684 tr_days in 0i32..4,
5685 id in "[a-z]{1,6}",
5686 ) -> LifecycleRule {
5687 let expiration = (kind != 1).then(|| LifecycleExpiration {
5688 date: exp_by_date.then(|| ts(exp_date_off).into()),
5689 days: (!exp_by_date).then_some(exp_days),
5690 expired_object_delete_marker: None,
5691 expired_object_all_versions: all_versions.then_some(true),
5692 });
5693 let transitions = (kind != 0).then(|| {
5694 vec![Transition {
5695 date: tr_by_date.then(|| ts(tr_date_off).into()),
5696 days: (!tr_by_date).then_some(tr_days),
5697 storage_class: Some(TransitionStorageClass::from_static("COLD")),
5698 }]
5699 });
5700 LifecycleRule {
5701 status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
5702 id: Some(id),
5703 prefix: None,
5704 filter: None,
5705 expiration,
5706 transitions,
5707 noncurrent_version_expiration: None,
5708 noncurrent_version_transitions: None,
5709 del_marker_expiration: None,
5710 abort_incomplete_multipart_upload: None,
5711 }
5712 }
5713 }
5714
5715 proptest! {
5716 #![proptest_config(ProptestConfig::with_cases(128))]
5717
5718 #[test]
5725 #[serial]
5726 fn eval_inner_winner_matches_selection_oracle(
5727 rules in prop::collection::vec(arb_selection_rule(), 0..5),
5728 mod_off in 0i64..(2 * DAY_SECS),
5729 now_off in (-DAY_SECS)..(6 * DAY_SECS),
5730 already_transitioned in any::<bool>(),
5731 ) {
5732 let lc = BucketLifecycleConfiguration {
5733 expiry_updated_at: None,
5734 rules,
5735 };
5736 let obj = ObjectOpts {
5737 name: "docs/report.txt".to_string(),
5738 mod_time: Some(ts(mod_off)),
5739 is_latest: true,
5740 transition_status: if already_transitioned {
5741 TRANSITION_COMPLETE.to_string()
5742 } else {
5743 String::new()
5744 },
5745 ..Default::default()
5746 };
5747 let now = ts(now_off);
5748
5749 let (event, expected) = with_production_time_env(|| {
5751 let candidates = oracle_candidates(&lc, &obj, now);
5752 let expected = candidates
5753 .iter()
5754 .filter(|(_, rank)| *rank == 0)
5755 .min()
5756 .copied()
5757 .or_else(|| candidates.into_iter().min());
5758 let rt = tokio::runtime::Builder::new_current_thread()
5759 .enable_all()
5760 .build()
5761 .expect("build runtime");
5762 let event = rt.block_on(lc.eval_inner(&obj, now, 0));
5763 (event, expected)
5764 });
5765
5766 match expected {
5767 None => prop_assert_eq!(event.action, IlmAction::NoneAction),
5768 Some((due_ts, rank)) => {
5769 prop_assert_ne!(event.action, IlmAction::NoneAction);
5770 let actual_due = event.due.expect("winning event carries a due").unix_timestamp();
5771 prop_assert_eq!(actual_due, due_ts);
5772 prop_assert_eq!(oracle_rank(&event.action), rank);
5773 }
5774 }
5775 }
5776 }
5777
5778 proptest! {
5779 #![proptest_config(ProptestConfig::with_cases(256))]
5780
5781 #[test]
5785 #[serial]
5786 fn expected_expiry_time_is_monotonic_in_days(
5787 mod_off in 0i64..(3650 * DAY_SECS),
5788 d1 in 0i32..2000,
5789 d2 in 0i32..2000,
5790 ) {
5791 let (lo, hi) = if d1 <= d2 { (d1, d2) } else { (d2, d1) };
5792 let mod_time = ts(mod_off);
5793 let (e_lo, e_hi) = with_production_time_env(|| {
5794 (expected_expiry_time(mod_time, lo), expected_expiry_time(mod_time, hi))
5795 });
5796 prop_assert!(
5797 e_lo <= e_hi,
5798 "expected_expiry_time not monotonic: days={} -> {:?}, days={} -> {:?}",
5799 lo, e_lo, hi, e_hi
5800 );
5801 }
5802
5803 #[test]
5807 #[serial]
5808 fn expected_expiry_time_lands_on_default_day_boundary(
5809 mod_off in 0i64..(3650 * DAY_SECS),
5810 days in 1i32..2000,
5811 ) {
5812 let mod_time = ts(mod_off);
5813 let result = with_production_time_env(|| expected_expiry_time(mod_time, days));
5814 let boundary_nanos = i128::from(DAY_SECS) * 1_000_000_000;
5815 prop_assert_eq!(result.unix_timestamp_nanos().rem_euclid(boundary_nanos), 0);
5816 let raw = mod_time + Duration::seconds(i64::from(days) * DAY_SECS);
5817 prop_assert!(result >= raw);
5818 prop_assert!(result - raw < Duration::seconds(DAY_SECS));
5819 }
5820
5821 #[test]
5825 #[serial]
5826 fn expected_expiry_time_lands_on_explicit_process_boundary(
5827 mod_off in 0i64..(365 * DAY_SECS),
5828 days in 1i32..400,
5829 boundary in 1u32..7200,
5830 ) {
5831 let mod_time = ts(mod_off);
5832 let boundary_str = boundary.to_string();
5833 let result = temp_env::with_vars(
5834 [
5835 (ENV_ILM_DEBUG_DAY_SECS, None::<&str>),
5836 (ENV_ILM_PROCESS_TIME, Some(boundary_str.as_str())),
5837 (ENV_ILM_PROCESS_TIME_DEPRECATED, None),
5838 ],
5839 || expected_expiry_time(mod_time, days),
5840 );
5841 let boundary_nanos = i128::from(boundary) * 1_000_000_000;
5842 prop_assert_eq!(result.unix_timestamp_nanos().rem_euclid(boundary_nanos), 0);
5843 let raw = mod_time + Duration::seconds(i64::from(days) * DAY_SECS);
5844 prop_assert!(result >= raw);
5845 prop_assert!(result - raw < Duration::seconds(i64::from(boundary)));
5846 }
5847 }
5848 }
5849}