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