snapshot of https://github.com/seaweedfs/seaweedfs.git (master, 2026-09-16; blobs > 131072B omitted)

weed/s3api/s3lifecycle/engine/engine.go

@@ -0,0 +1,132 @@
+// Package engine compiles per-bucket lifecycle rules into a CompiledAction
+// snapshot. One XML <Rule> expands into N compiled actions (one per populated
+// action sub-element); each is keyed by ActionKey{bucket, rule_hash,
+// action_kind} so sibling actions schedule and degrade independently.
+package engine
+
+import (
+	"sync/atomic"
+	"time"
+
+	"github.com/seaweedfs/seaweedfs/weed/s3api/s3lifecycle"
+)
+
+type Engine struct {
+	current atomic.Pointer[Snapshot]
+}
+
+func New() *Engine {
+	e := &Engine{}
+	e.current.Store(&Snapshot{actions: map[s3lifecycle.ActionKey]*CompiledAction{}})
+	return e
+}
+
+func (e *Engine) Snapshot() *Snapshot { return e.current.Load() }
+
+// Snapshot fields are append-only after Compile except CompiledAction.engineState,
+// which transitions inactive -> active atomically via markActive.
+type Snapshot struct {
+	id      uint64
+	buckets map[string]*BucketIndex
+	actions map[s3lifecycle.ActionKey]*CompiledAction
+
+	allActionsSorted []*CompiledAction
+
+	// Routing indexes hold every ActionKey by mode regardless of activation;
+	// dispatch filters on IsActive().
+	originalDelayGroups map[time.Duration][]s3lifecycle.ActionKey
+	predicateActions    []s3lifecycle.ActionKey
+	dateActions         map[s3lifecycle.ActionKey]time.Time
+}
+
+func (s *Snapshot) SnapshotID() uint64 { return s.id }
+
+type BucketIndex struct {
+	bucket     string
+	versioned  bool
+	actionKeys []s3lifecycle.ActionKey
+}
+
+type CompiledAction struct {
+	Rule               *s3lifecycle.Rule
+	Bucket             string
+	Key                s3lifecycle.ActionKey
+	Delay              time.Duration
+	PredicateSensitive bool
+	Mode               RuleMode
+	engineState        atomic.Uint32
+}
+
+const (
+	engineStateInactive uint32 = 0
+	engineStateActive   uint32 = 1
+)
+
+func (a *CompiledAction) IsActive() bool {
+	return a.engineState.Load() == engineStateActive
+}
+
+func (a *CompiledAction) markActive() {
+	a.engineState.Store(engineStateActive)
+}
+
+// MarkActive mirrors the in-memory hint after a durable bootstrap_complete
+// write. No-op if the key isn't in the snapshot.
+func (s *Snapshot) MarkActive(key s3lifecycle.ActionKey) {
+	if a, ok := s.actions[key]; ok {
+		a.markActive()
+	}
+}
+
+func (s *Snapshot) Action(key s3lifecycle.ActionKey) *CompiledAction {
+	return s.actions[key]
+}
+
+// AllActions: caller must not mutate.
+func (s *Snapshot) AllActions() []*CompiledAction {
+	return s.allActionsSorted
+}
+
+// OriginalDelayGroups / PredicateActions / DateActions return defensive copies.
+func (s *Snapshot) OriginalDelayGroups() map[time.Duration][]s3lifecycle.ActionKey {
+	out := make(map[time.Duration][]s3lifecycle.ActionKey, len(s.originalDelayGroups))
+	for d, keys := range s.originalDelayGroups {
+		copied := make([]s3lifecycle.ActionKey, len(keys))
+		copy(copied, keys)
+		out[d] = copied
+	}
+	return out
+}
+
+func (s *Snapshot) PredicateActions() []s3lifecycle.ActionKey {
+	out := make([]s3lifecycle.ActionKey, len(s.predicateActions))
+	copy(out, s.predicateActions)
+	return out
+}
+
+func (s *Snapshot) DateActions() map[s3lifecycle.ActionKey]time.Time {
+	out := make(map[s3lifecycle.ActionKey]time.Time, len(s.dateActions))
+	for k, v := range s.dateActions {
+		out[k] = v
+	}
+	return out
+}
+
+func (s *Snapshot) BucketVersioned(bucket string) bool {
+	if bi, ok := s.buckets[bucket]; ok {
+		return bi.versioned
+	}
+	return false
+}
+
+// BucketActionKeys returns a defensive copy of the action keys for bucket,
+// or nil if the bucket has no compiled actions in this snapshot.
+func (s *Snapshot) BucketActionKeys(bucket string) []s3lifecycle.ActionKey {
+	bi, ok := s.buckets[bucket]
+	if !ok {
+		return nil
+	}
+	out := make([]s3lifecycle.ActionKey, len(bi.actionKeys))
+	copy(out, bi.actionKeys)
+	return out
+}