54dd4f091d
* s3api: extend lifecycle XML types with NoncurrentVersionExpiration, AbortIncompleteMultipartUpload Add missing S3 lifecycle rule types to the XML data model: - NoncurrentVersionExpiration with NoncurrentDays and NewerNoncurrentVersions - NoncurrentVersionTransition with NoncurrentDays and StorageClass - AbortIncompleteMultipartUpload with DaysAfterInitiation - Filter.ObjectSizeGreaterThan and ObjectSizeLessThan - And.ObjectSizeGreaterThan and ObjectSizeLessThan - Filter.UnmarshalXML to properly parse Tag, And, and size filter elements Each new type follows the existing set-field pattern for conditional XML marshaling. No behavior changes - these types are not yet wired into handlers or the lifecycle worker. * s3lifecycle: add lifecycle rule evaluator package New package weed/s3api/s3lifecycle/ provides a pure-function lifecycle rule evaluation engine. The evaluator accepts flattened Rule structs and ObjectInfo metadata, and returns the appropriate Action. Components: - evaluator.go: Evaluate() for per-object actions with S3 priority ordering (delete marker > noncurrent version > current expiration), ShouldExpireNoncurrentVersion() with NewerNoncurrentVersions support, EvaluateMPUAbort() for multipart upload rules - filter.go: prefix, tag, and size-based filter matching - tags.go: ExtractTags() extracts S3 tags from filer Extended metadata, HasTagRules() for scan-time optimization - version_time.go: GetVersionTimestamp() extracts timestamps from SeaweedFS version IDs (both old and new format) Comprehensive test coverage: 54 tests covering all action types, filter combinations, edge cases, and version ID formats. * s3api: add UnmarshalXML for Expiration, Transition, ExpireDeleteMarker Add UnmarshalXML methods that set the internal 'set' flag during XML parsing. Previously these flags were only set programmatically, causing XML round-trip to drop elements. This ensures lifecycle configurations stored as XML survive unmarshal/marshal cycles correctly. Add comprehensive XML round-trip tests for all lifecycle rule types including NoncurrentVersionExpiration, AbortIncompleteMultipartUpload, Filter with Tag/And/size constraints, and a complete Terraform-style lifecycle configuration. * s3lifecycle: address review feedback - Fix version_time.go overflow: guard timestampPart > MaxInt64 before the inversion subtraction to prevent uint64 wrap - Make all expiry checks inclusive (!now.Before instead of now.After) so actions trigger at the exact scheduled instant - Add NoncurrentIndex to ObjectInfo so Evaluate() can properly handle NewerNoncurrentVersions via ShouldExpireNoncurrentVersion() - Add test for high-bit overflow version ID * s3lifecycle: guard ShouldExpireNoncurrentVersion against zero SuccessorModTime Add early return when obj.IsLatest or obj.SuccessorModTime.IsZero() to prevent premature expiration of versions with uninitialized successor timestamps (zero value would compute to epoch, always expired). --------- Co-authored-by: Copilot <copilot@github.com>
75 lines
2.1 KiB
Go
75 lines
2.1 KiB
Go
package s3lifecycle
|
|
|
|
import (
|
|
"fmt"
|
|
"math"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestGetVersionTimestamp(t *testing.T) {
|
|
t.Run("new_format_inverted_timestamp", func(t *testing.T) {
|
|
// Simulate a new-format version ID (inverted timestamp above threshold).
|
|
now := time.Now()
|
|
inverted := math.MaxInt64 - now.UnixNano()
|
|
versionId := fmt.Sprintf("%016x", inverted) + "0000000000000000"
|
|
|
|
got := GetVersionTimestamp(versionId)
|
|
// Should recover the original timestamp within 1 second.
|
|
diff := got.Sub(now)
|
|
if diff < -time.Second || diff > time.Second {
|
|
t.Errorf("timestamp diff too large: %v (got %v, want ~%v)", diff, got, now)
|
|
}
|
|
})
|
|
|
|
t.Run("old_format_raw_timestamp", func(t *testing.T) {
|
|
// Simulate an old-format version ID (raw nanosecond timestamp below threshold).
|
|
// Use a timestamp from 2023 which would be below threshold.
|
|
ts := time.Date(2023, 6, 15, 12, 0, 0, 0, time.UTC)
|
|
versionId := fmt.Sprintf("%016x", ts.UnixNano()) + "abcdef0123456789"
|
|
|
|
got := GetVersionTimestamp(versionId)
|
|
if !got.Equal(ts) {
|
|
t.Errorf("expected %v, got %v", ts, got)
|
|
}
|
|
})
|
|
|
|
t.Run("null_version_id", func(t *testing.T) {
|
|
got := GetVersionTimestamp("null")
|
|
if !got.IsZero() {
|
|
t.Errorf("expected zero time for null version, got %v", got)
|
|
}
|
|
})
|
|
|
|
t.Run("empty_version_id", func(t *testing.T) {
|
|
got := GetVersionTimestamp("")
|
|
if !got.IsZero() {
|
|
t.Errorf("expected zero time for empty version, got %v", got)
|
|
}
|
|
})
|
|
|
|
t.Run("short_version_id", func(t *testing.T) {
|
|
got := GetVersionTimestamp("abc")
|
|
if !got.IsZero() {
|
|
t.Errorf("expected zero time for short version, got %v", got)
|
|
}
|
|
})
|
|
|
|
t.Run("high_bit_overflow_returns_zero", func(t *testing.T) {
|
|
// Version ID with first 16 hex chars > math.MaxInt64 should return zero,
|
|
// not a wrapped negative timestamp.
|
|
versionId := "80000000000000000000000000000000"
|
|
got := GetVersionTimestamp(versionId)
|
|
if !got.IsZero() {
|
|
t.Errorf("expected zero time for overflow version ID, got %v", got)
|
|
}
|
|
})
|
|
|
|
t.Run("invalid_hex", func(t *testing.T) {
|
|
got := GetVersionTimestamp("zzzzzzzzzzzzzzzz0000000000000000")
|
|
if !got.IsZero() {
|
|
t.Errorf("expected zero time for invalid hex, got %v", got)
|
|
}
|
|
})
|
|
}
|