mirror of
https://github.com/seaweedfs/seaweedfs.git
synced 2026-11-18 17:55:26 +01:00
* docs(s3/lifecycle): event-driven redesign
Replaces the synchronous PUT-handler walk with an event-driven worker
model: meta-log reader subscribed to one filer, client-side heap merge
with per-filer-shard MessagePosition cursors, bucket-level bootstrap
with inline delete, blocked-cursor handling for fatal events, durable
retry budget for sustained-transient promotion, retention mode gate
that downgrades reader-driven rules to scan_only when log retention
falls below the rule's event-log horizon.
* docs(s3/lifecycle): record Phase 0 verified assumptions
ReadPersistedLogBuffer payload carries Extended (event marshaled via
SubscribeMetadataResponse → ToProtoEntry). Meta-log files at
topics/.system/log/<date>/<HH-MM>.<filerId> are written without TtlSec
in filer_notify_append.go; retention is unbounded by default and only
shrinks if an operator sets a filer.conf rule with a TTL on the
SystemLogDir prefix. .versions/ filenames are v_<16h-ts><16h-rand>
with old/new (inverted) format distinguished by threshold
0x4000000000000000; getVersionTimestamp / compareVersionIds give
format-agnostic ordering for successor-version discovery.
* feat(s3/lifecycle): rule evaluator and dueAt helper
Evaluate(rule, info, now) returns the EvalResult by object shape:
IsMPUInit -> AbortMultipartUpload, IsDeleteMarker -> ExpireDeleteMarker
when sole survivor, IsLatest -> DeleteObject (Days or Date), non-current
-> DeleteVersion (Days fallback to ModTime when SuccessorModTime is
zero; NewerNoncurrent retention enforced when both are set).
ComputeDueAt mirrors Evaluate's shape and returns the earliest eligible
wall-clock time for the same (rule, info), used by the reader/bootstrap
to decide pending vs inline-delete.
Adds StatusEnabled/Disabled and SmallDelay consts and an IsMPUInit
flag on ObjectInfo so .uploads/<id>/ entries route to AbortMPU without
overloading IsLatest.
No callers; package compiles standalone.
* feat(s3/lifecycle): MinTriggerAge for safety-scan cadence
Returns the smallest non-zero day threshold across the rule's actions.
Used as max(MinTriggerAge, kindFloor) for the per-kind cadence; date,
count-only, and delete-marker-only rules return 0 so callers fall
through to their kind-specific floor.
* feat(s3/lifecycle): EventLogHorizon for retention mode gate
Returns the maximum event age the reader needs for a rule. Days-based
kinds return their day threshold; pure NewerNoncurrent (count) and
ExpiredObjectDeleteMarker return SmallDelay. Date rules return 0 (the
gate skips them). Multi-action rules take the max — strictest horizon
wins.
Drives the Phase 2 mode gate: metaLogRetention < EventLogHorizon(rule)
+ bootstrapLookbackMin -> scan_only with RETENTION_BELOW_HORIZON.
* feat(s3/lifecycle): RuleHash for per-rule state CAS
sha256 over canonicalized form, first 8 bytes. Stable across tag-key
reorder, prefix trailing-slash variation, ID renames, and Status flips
(state continuity is preserved when an operator toggles
Enabled/Disabled). Different action shapes — different days, filter,
or action type — hash differently.
Used by the per-rule state directory layout
/etc/s3/lifecycle/<bucket>/<rule_hash_hex>/ and by the bootstrap
detector's reconcile-on-PUT.
* feat(s3/lifecycle): add s3_lifecycle.proto storage schema
Defines the durable types backing the lifecycle worker:
LifecycleState (per-rule mode + bootstrap_complete + degraded_reason
incl. RETENTION_BELOW_HORIZON / LOST_LOG), PendingItem, EntryIdentity,
BootstrapState, ReaderState (per-filer-shard cursors plus
tail_drained_streams marker), BlockerRecord (rule_hash optional for
pre-evaluation failures), RetryBudgetEntry with the four-shape
StreamKey oneof, and RetryTarget (no action / no expected_identity —
retry replays handler against current state).
No callers; schema only. Wired into the pb Makefile.
* feat(s3/lifecycle): add S3LifecycleParams to TaskParams
Wires lifecycle subroutines into the existing worker dispatch.
Subtype is READ (cluster-singleton meta-log reader), BOOTSTRAP
(per-bucket walker), or DRAIN (per-rule pending). bucket / rule_hash
populated for the latter two; ContinuationHint is an advisory resume
point for kill-resumable BOOTSTRAP / READ.
oneof tag = 14, after the existing ec_balance_params at 13.
* fix(s3/lifecycle): noncurrent delete markers honor NoncurrentDays
A non-current delete marker is just another version per AWS S3 spec
and is eligible under NoncurrentVersionExpirationDays. The
IsDeleteMarker special case is meant only for the *current* delete
marker (sole-survivor ExpiredObjectDeleteMarker action), so guard
that switch arm with IsLatest. Without IsLatest, the bootstrap walker
silently skipped pre-existing non-current delete markers under a
NoncurrentDays rule because ComputeDueAt returned zero.
Mirrors the same fix in evaluate.go so the runtime decision matches.
* fix(s3/lifecycle): preserve prefix trailing slash in RuleHash
"logs" and "logs/" match different object sets under literal
strings.HasPrefix semantics: "logs" matches "logsmore/x", "logs/" does
not. Collapsing them in the hash would let an XML edit silently bind
the new rule to the previous rule's durable state directory, causing
stale bootstrap_complete and stale pending entries against a rule
that now matches a different set.
* fix(s3/lifecycle): add UNSPECIFIED sentinels to enum zero values
Proto3 best practice: enum 0 should be an _UNSPECIFIED sentinel, not
an active value. Persisted state schemas care most: a partially
populated payload (or one written by an older binary that didn't set
the field) would otherwise silently default to a semantically active
value.
- LifecycleState.RuleKind: shifts EXPIRATION_DAYS..EXPIRED_DELETE_MARKER
from 0..5 to 1..6, with RULE_KIND_UNSPECIFIED at 0.
- LifecycleState.RuleMode: shifts EVENT_DRIVEN..PENDING_BOOTSTRAP from
0..4 to 1..5.
- LifecycleState.DegradedReason: replaces NONE=0 with
DEGRADED_REASON_UNSPECIFIED=0 (operators treat both as healthy).
- StreamKind: shifts ORIGINAL..PENDING from 0..3 to 1..4.
- S3LifecycleParams.Subtype: shifts READ..DRAIN from 0..2 to 1..3, so
an unset subtype no longer routes into the cluster-singleton READ task.
No on-disk state has been written yet; renumbering is safe.
* docs(s3/lifecycle): per-action state, not per-rule
A single AWS lifecycle XML <Rule> can declare multiple actions in
parallel (e.g. ExpirationDays=90 + AbortMPU=7 + NoncurrentDays=30).
Each must drive its own delay/horizon/mode/pending stream
independently. Modeling the rule as one compiled entry with one kind
collapses these — picking the smallest delay (7d MPU) means the 90d
expiration cursor advances past objects that aren't yet due, and the
90d action never re-fires.
Restructure storage to per-action: every XML rule expands into N
compiled actions; state lives at <bucket>/<rule_hash>/<action_kind>/.
The intermediate rule_hash directory keeps a rule's actions grouped
for operator listing. Each action has its own state file with its own
mode + bootstrap_complete + degraded_reason; sibling actions of the
same rule can degrade independently.
* fix(s3/lifecycle): per-action proto schema + safety-scan counters
Realigns the durable schema with the per-action storage model and the
safety-scan contract in the design doc.
- Promote LifecycleState.RuleKind to a top-level ActionKind enum and
rename rule_kind -> action_kind. The same enum now also keys
BootstrapKey, PendingKey, and BlockerRecord so per-action streams
under one rule never collapse.
- LifecycleState now keyed by (rule_hash, action_kind). Added
last_safety_scan_ts_ns / next_safety_scan_ts_ns and the four
observability counters the design specifies (evaluated_total,
expired_total, metadata_only_total, error_total). Dropped
last_evaluated_ns, deleted_total, skipped_object_lock_total, and
pending_size — subsumed or out-of-band.
- BlockerRecord.action_kind is OPTIONAL (UNSPECIFIED for
pre-evaluation failures, just like rule_hash).
No on-disk state has been written yet; the renumbering / rename is
free.
* fix(s3/lifecycle): per-action MinTriggerAge / EventLogHorizon helpers
The retention mode gate and safety-scan cadence run on each compiled
action independently. Taking a "min/max across all actions in the
rule" — as the previous helpers did — was wrong: a 90d ExpirationDays
sibling alongside a 7d AbortMPU action would cause the 90d cursor to
advance at 7d (because MinTriggerAge picked the smallest), and the
ExpirationDays action would never re-fire on objects that aged past
the 7d sweep window before reaching 90d.
Both helpers now take an ActionKind and return the threshold for that
specific action only. Returns 0 if the rule does not declare the
requested kind, which makes the gate a no-op and the cadence fall
through to the kind floor.
Also adds RuleActionKinds(rule), the canonical expansion that the
engine uses at compile time to turn one XML rule into N compiled
actions. NewerNoncurrentVersions paired with NoncurrentDays is
subsumed into a single NONCURRENT_DAYS action (AWS-paired
conditions); only when NewerNoncurrent stands alone does it become
NEWER_NONCURRENT.
* fix(s3/lifecycle): length-prefix RuleHash to remove delimiter ambiguity
The previous encoding used "tag=K=V\n" lines, which is ambiguous: a
tag (a=b, c) serializes identically to (a, b=c). A prefix containing
"\nexp_days=99" could likewise forge an action field. Either could
silently bind two semantically different rules to the same per-rule
state directory.
Switch to a length-prefixed canonical form: each scalar is written as
<field-tag-byte> <uvarint-length> <bytes>. Field-tag bytes namespace
each scalar so ("a=b" tag-key) and ("a" tag-key with "=b" leakage)
can't collide. Three regression tests pin the resistance.
* docs(s3/lifecycle): ActionKey is the engine identity, not rule_hash
Finishes the per-action restructure across the engine pseudocode,
bootstrap completion, drain locks, detector paths, policy CAS, and
Phase 2 plan. Every per-action data structure — engine indexes,
target modes, newly-completed sets, bootstrap completion bits, drain
keys, locks, metrics, status — is now keyed by
ActionKey{rule_hash, action_kind}, not by rule_hash alone.
Without this, sibling actions under one XML rule still shared
scheduling state in the engine: originalDelayGroups holding
[]ruleHash means a rule's 7d AbortMPU and 90d ExpirationDays
collapse into one entry, the smaller delay wins for cursor advance,
and the larger sibling never re-fires.
Helper API tightened: EvaluateAction(rule, kind, info, now) and
ComputeDueAt(rule, kind, info) replace the aggregate-rule signatures
so a caller asks one specific action's eligibility against one
entry, never "any action of this rule." Drain task lock includes
action_kind so siblings have independent re-arm timers. Policy CAS
moves from rule_hash to ActionKey membership.
* fix(s3/lifecycle): kind-aware EvaluateAction / ComputeDueAt
Replaces the aggregate-rule signatures with per-action ones:
EvaluateAction(rule, kind, info, now) and ComputeDueAt(rule, kind,
info). The old Evaluate(rule, info, now) could return the verdict of
ANY action declared on the rule, which sat wrong with the per-action
engine indexing (each ActionKey has its own delay group, mode, and
pending stream).
Each helper now decides exactly one (rule, kind) compiled action's
fate against one entry. Asking for a kind the rule doesn't declare,
or asking against the wrong object shape for that kind, returns
ActionNone / zero — never silently routes to a sibling.
Multi-action regression test: a rule with ExpirationDays=90 and
AbortMPU=7 evaluates each kind independently for the same entry; the
7d window has no influence on the 90d eligibility decision.
1921 lines
63 KiB
Go
1921 lines
63 KiB
Go
// Code generated by protoc-gen-go. DO NOT EDIT.
|
|
// versions:
|
|
// protoc-gen-go v1.36.6
|
|
// protoc v6.33.4
|
|
// source: s3_lifecycle.proto
|
|
|
|
package s3_lifecycle_pb
|
|
|
|
import (
|
|
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
|
|
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
|
|
reflect "reflect"
|
|
sync "sync"
|
|
unsafe "unsafe"
|
|
)
|
|
|
|
const (
|
|
// Verify that this generated code is sufficiently up-to-date.
|
|
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
|
|
// Verify that runtime/protoimpl is sufficiently up-to-date.
|
|
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
|
|
)
|
|
|
|
// ActionKind classifies the lifecycle action a single compiled entry
|
|
// represents. A single XML rule may produce multiple compiled entries —
|
|
// one per populated action.
|
|
type ActionKind int32
|
|
|
|
const (
|
|
ActionKind_ACTION_KIND_UNSPECIFIED ActionKind = 0
|
|
ActionKind_EXPIRATION_DAYS ActionKind = 1 // Expiration.Days
|
|
ActionKind_EXPIRATION_DATE ActionKind = 2 // Expiration.Date
|
|
ActionKind_NONCURRENT_DAYS ActionKind = 3 // NoncurrentVersionExpiration.NoncurrentDays (with optional NewerNoncurrent retention)
|
|
ActionKind_NEWER_NONCURRENT ActionKind = 4 // NoncurrentVersionExpiration.NewerNoncurrentVersions, count-only (no NoncurrentDays)
|
|
ActionKind_ABORT_MPU ActionKind = 5 // AbortIncompleteMultipartUpload.DaysAfterInitiation
|
|
ActionKind_EXPIRED_DELETE_MARKER ActionKind = 6 // Expiration.ExpiredObjectDeleteMarker
|
|
)
|
|
|
|
// Enum value maps for ActionKind.
|
|
var (
|
|
ActionKind_name = map[int32]string{
|
|
0: "ACTION_KIND_UNSPECIFIED",
|
|
1: "EXPIRATION_DAYS",
|
|
2: "EXPIRATION_DATE",
|
|
3: "NONCURRENT_DAYS",
|
|
4: "NEWER_NONCURRENT",
|
|
5: "ABORT_MPU",
|
|
6: "EXPIRED_DELETE_MARKER",
|
|
}
|
|
ActionKind_value = map[string]int32{
|
|
"ACTION_KIND_UNSPECIFIED": 0,
|
|
"EXPIRATION_DAYS": 1,
|
|
"EXPIRATION_DATE": 2,
|
|
"NONCURRENT_DAYS": 3,
|
|
"NEWER_NONCURRENT": 4,
|
|
"ABORT_MPU": 5,
|
|
"EXPIRED_DELETE_MARKER": 6,
|
|
}
|
|
)
|
|
|
|
func (x ActionKind) Enum() *ActionKind {
|
|
p := new(ActionKind)
|
|
*p = x
|
|
return p
|
|
}
|
|
|
|
func (x ActionKind) String() string {
|
|
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
|
|
}
|
|
|
|
func (ActionKind) Descriptor() protoreflect.EnumDescriptor {
|
|
return file_s3_lifecycle_proto_enumTypes[0].Descriptor()
|
|
}
|
|
|
|
func (ActionKind) Type() protoreflect.EnumType {
|
|
return &file_s3_lifecycle_proto_enumTypes[0]
|
|
}
|
|
|
|
func (x ActionKind) Number() protoreflect.EnumNumber {
|
|
return protoreflect.EnumNumber(x)
|
|
}
|
|
|
|
// Deprecated: Use ActionKind.Descriptor instead.
|
|
func (ActionKind) EnumDescriptor() ([]byte, []int) {
|
|
return file_s3_lifecycle_proto_rawDescGZIP(), []int{0}
|
|
}
|
|
|
|
// StreamKind classifies the four blockable streams. ORIGINAL/PREDICATE pause
|
|
// reader cursors; BOOTSTRAP pauses a bucket walker; PENDING pauses a rule's
|
|
// drain task. Zero is an UNSPECIFIED sentinel — a BlockerRecord whose
|
|
// stream_kind reads as UNSPECIFIED is a corruption signal, not a default.
|
|
type StreamKind int32
|
|
|
|
const (
|
|
StreamKind_STREAM_KIND_UNSPECIFIED StreamKind = 0
|
|
StreamKind_ORIGINAL StreamKind = 1
|
|
StreamKind_PREDICATE StreamKind = 2
|
|
StreamKind_BOOTSTRAP StreamKind = 3
|
|
StreamKind_PENDING StreamKind = 4
|
|
)
|
|
|
|
// Enum value maps for StreamKind.
|
|
var (
|
|
StreamKind_name = map[int32]string{
|
|
0: "STREAM_KIND_UNSPECIFIED",
|
|
1: "ORIGINAL",
|
|
2: "PREDICATE",
|
|
3: "BOOTSTRAP",
|
|
4: "PENDING",
|
|
}
|
|
StreamKind_value = map[string]int32{
|
|
"STREAM_KIND_UNSPECIFIED": 0,
|
|
"ORIGINAL": 1,
|
|
"PREDICATE": 2,
|
|
"BOOTSTRAP": 3,
|
|
"PENDING": 4,
|
|
}
|
|
)
|
|
|
|
func (x StreamKind) Enum() *StreamKind {
|
|
p := new(StreamKind)
|
|
*p = x
|
|
return p
|
|
}
|
|
|
|
func (x StreamKind) String() string {
|
|
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
|
|
}
|
|
|
|
func (StreamKind) Descriptor() protoreflect.EnumDescriptor {
|
|
return file_s3_lifecycle_proto_enumTypes[1].Descriptor()
|
|
}
|
|
|
|
func (StreamKind) Type() protoreflect.EnumType {
|
|
return &file_s3_lifecycle_proto_enumTypes[1]
|
|
}
|
|
|
|
func (x StreamKind) Number() protoreflect.EnumNumber {
|
|
return protoreflect.EnumNumber(x)
|
|
}
|
|
|
|
// Deprecated: Use StreamKind.Descriptor instead.
|
|
func (StreamKind) EnumDescriptor() ([]byte, []int) {
|
|
return file_s3_lifecycle_proto_rawDescGZIP(), []int{1}
|
|
}
|
|
|
|
// Proto3 best practice: zero value is an UNSPECIFIED sentinel so that
|
|
// legacy / partially-populated payloads don't silently default to a
|
|
// semantically active value. Persisted state files always set explicit
|
|
// non-zero values; reading UNSPECIFIED indicates corruption or a missing
|
|
// field.
|
|
type LifecycleState_RuleMode int32
|
|
|
|
const (
|
|
LifecycleState_RULE_MODE_UNSPECIFIED LifecycleState_RuleMode = 0
|
|
LifecycleState_EVENT_DRIVEN LifecycleState_RuleMode = 1
|
|
LifecycleState_SCAN_AT_DATE LifecycleState_RuleMode = 2
|
|
LifecycleState_SCAN_ONLY LifecycleState_RuleMode = 3
|
|
LifecycleState_DISABLED LifecycleState_RuleMode = 4
|
|
LifecycleState_PENDING_BOOTSTRAP LifecycleState_RuleMode = 5
|
|
)
|
|
|
|
// Enum value maps for LifecycleState_RuleMode.
|
|
var (
|
|
LifecycleState_RuleMode_name = map[int32]string{
|
|
0: "RULE_MODE_UNSPECIFIED",
|
|
1: "EVENT_DRIVEN",
|
|
2: "SCAN_AT_DATE",
|
|
3: "SCAN_ONLY",
|
|
4: "DISABLED",
|
|
5: "PENDING_BOOTSTRAP",
|
|
}
|
|
LifecycleState_RuleMode_value = map[string]int32{
|
|
"RULE_MODE_UNSPECIFIED": 0,
|
|
"EVENT_DRIVEN": 1,
|
|
"SCAN_AT_DATE": 2,
|
|
"SCAN_ONLY": 3,
|
|
"DISABLED": 4,
|
|
"PENDING_BOOTSTRAP": 5,
|
|
}
|
|
)
|
|
|
|
func (x LifecycleState_RuleMode) Enum() *LifecycleState_RuleMode {
|
|
p := new(LifecycleState_RuleMode)
|
|
*p = x
|
|
return p
|
|
}
|
|
|
|
func (x LifecycleState_RuleMode) String() string {
|
|
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
|
|
}
|
|
|
|
func (LifecycleState_RuleMode) Descriptor() protoreflect.EnumDescriptor {
|
|
return file_s3_lifecycle_proto_enumTypes[2].Descriptor()
|
|
}
|
|
|
|
func (LifecycleState_RuleMode) Type() protoreflect.EnumType {
|
|
return &file_s3_lifecycle_proto_enumTypes[2]
|
|
}
|
|
|
|
func (x LifecycleState_RuleMode) Number() protoreflect.EnumNumber {
|
|
return protoreflect.EnumNumber(x)
|
|
}
|
|
|
|
// Deprecated: Use LifecycleState_RuleMode.Descriptor instead.
|
|
func (LifecycleState_RuleMode) EnumDescriptor() ([]byte, []int) {
|
|
return file_s3_lifecycle_proto_rawDescGZIP(), []int{3, 0}
|
|
}
|
|
|
|
// DEGRADED_REASON_UNSPECIFIED replaces the old NONE sentinel: an unset
|
|
// / zero degraded_reason means "no active degradation" — operators
|
|
// treat UNSPECIFIED as healthy.
|
|
type LifecycleState_DegradedReason int32
|
|
|
|
const (
|
|
LifecycleState_DEGRADED_REASON_UNSPECIFIED LifecycleState_DegradedReason = 0
|
|
LifecycleState_LAG_HIGH LifecycleState_DegradedReason = 1
|
|
LifecycleState_PENDING_FULL LifecycleState_DegradedReason = 2
|
|
LifecycleState_DELETE_FAILURES LifecycleState_DegradedReason = 3
|
|
LifecycleState_OPERATOR_PAUSED LifecycleState_DegradedReason = 4
|
|
LifecycleState_RETENTION_BELOW_HORIZON LifecycleState_DegradedReason = 5
|
|
LifecycleState_LOST_LOG LifecycleState_DegradedReason = 6
|
|
)
|
|
|
|
// Enum value maps for LifecycleState_DegradedReason.
|
|
var (
|
|
LifecycleState_DegradedReason_name = map[int32]string{
|
|
0: "DEGRADED_REASON_UNSPECIFIED",
|
|
1: "LAG_HIGH",
|
|
2: "PENDING_FULL",
|
|
3: "DELETE_FAILURES",
|
|
4: "OPERATOR_PAUSED",
|
|
5: "RETENTION_BELOW_HORIZON",
|
|
6: "LOST_LOG",
|
|
}
|
|
LifecycleState_DegradedReason_value = map[string]int32{
|
|
"DEGRADED_REASON_UNSPECIFIED": 0,
|
|
"LAG_HIGH": 1,
|
|
"PENDING_FULL": 2,
|
|
"DELETE_FAILURES": 3,
|
|
"OPERATOR_PAUSED": 4,
|
|
"RETENTION_BELOW_HORIZON": 5,
|
|
"LOST_LOG": 6,
|
|
}
|
|
)
|
|
|
|
func (x LifecycleState_DegradedReason) Enum() *LifecycleState_DegradedReason {
|
|
p := new(LifecycleState_DegradedReason)
|
|
*p = x
|
|
return p
|
|
}
|
|
|
|
func (x LifecycleState_DegradedReason) String() string {
|
|
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
|
|
}
|
|
|
|
func (LifecycleState_DegradedReason) Descriptor() protoreflect.EnumDescriptor {
|
|
return file_s3_lifecycle_proto_enumTypes[3].Descriptor()
|
|
}
|
|
|
|
func (LifecycleState_DegradedReason) Type() protoreflect.EnumType {
|
|
return &file_s3_lifecycle_proto_enumTypes[3]
|
|
}
|
|
|
|
func (x LifecycleState_DegradedReason) Number() protoreflect.EnumNumber {
|
|
return protoreflect.EnumNumber(x)
|
|
}
|
|
|
|
// Deprecated: Use LifecycleState_DegradedReason.Descriptor instead.
|
|
func (LifecycleState_DegradedReason) EnumDescriptor() ([]byte, []int) {
|
|
return file_s3_lifecycle_proto_rawDescGZIP(), []int{3, 1}
|
|
}
|
|
|
|
// MessagePosition mirrors weed/util/log_buffer.MessagePosition for durable
|
|
// storage. ts_ns + offset uniquely identifies a position within a per-filer
|
|
// log buffer; per-shard cursors (see ReaderState) use this shape to skip past
|
|
// already-processed events when replaying.
|
|
type MessagePosition struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
TsNs int64 `protobuf:"varint,1,opt,name=ts_ns,json=tsNs,proto3" json:"ts_ns,omitempty"`
|
|
Offset int64 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *MessagePosition) Reset() {
|
|
*x = MessagePosition{}
|
|
mi := &file_s3_lifecycle_proto_msgTypes[0]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *MessagePosition) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*MessagePosition) ProtoMessage() {}
|
|
|
|
func (x *MessagePosition) ProtoReflect() protoreflect.Message {
|
|
mi := &file_s3_lifecycle_proto_msgTypes[0]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use MessagePosition.ProtoReflect.Descriptor instead.
|
|
func (*MessagePosition) Descriptor() ([]byte, []int) {
|
|
return file_s3_lifecycle_proto_rawDescGZIP(), []int{0}
|
|
}
|
|
|
|
func (x *MessagePosition) GetTsNs() int64 {
|
|
if x != nil {
|
|
return x.TsNs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *MessagePosition) GetOffset() int64 {
|
|
if x != nil {
|
|
return x.Offset
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// Cursor map keyed by filer_id. Each delay group's cursor (ReaderState) and
|
|
// the predicate cursor (ReaderState) are per-filer-shard maps because
|
|
// LogEntry.Offset is per-filer and not globally unique.
|
|
type FilerShardCursor struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
FilerId string `protobuf:"bytes,1,opt,name=filer_id,json=filerId,proto3" json:"filer_id,omitempty"`
|
|
Position *MessagePosition `protobuf:"bytes,2,opt,name=position,proto3" json:"position,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *FilerShardCursor) Reset() {
|
|
*x = FilerShardCursor{}
|
|
mi := &file_s3_lifecycle_proto_msgTypes[1]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *FilerShardCursor) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*FilerShardCursor) ProtoMessage() {}
|
|
|
|
func (x *FilerShardCursor) ProtoReflect() protoreflect.Message {
|
|
mi := &file_s3_lifecycle_proto_msgTypes[1]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use FilerShardCursor.ProtoReflect.Descriptor instead.
|
|
func (*FilerShardCursor) Descriptor() ([]byte, []int) {
|
|
return file_s3_lifecycle_proto_rawDescGZIP(), []int{1}
|
|
}
|
|
|
|
func (x *FilerShardCursor) GetFilerId() string {
|
|
if x != nil {
|
|
return x.FilerId
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *FilerShardCursor) GetPosition() *MessagePosition {
|
|
if x != nil {
|
|
return x.Position
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// EntryIdentity is the CAS witness used by LifecycleDelete to detect that
|
|
// the live entry hasn't changed between worker decision and server execution.
|
|
// Mismatch -> STALE_IDENTITY -> NOOP_RESOLVED.
|
|
type EntryIdentity struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
MtimeNs int64 `protobuf:"varint,1,opt,name=mtime_ns,json=mtimeNs,proto3" json:"mtime_ns,omitempty"`
|
|
Size int64 `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"`
|
|
HeadFid string `protobuf:"bytes,3,opt,name=head_fid,json=headFid,proto3" json:"head_fid,omitempty"`
|
|
ExtendedHash []byte `protobuf:"bytes,4,opt,name=extended_hash,json=extendedHash,proto3" json:"extended_hash,omitempty"` // sha256 over sorted Extended map; cheap and stable
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *EntryIdentity) Reset() {
|
|
*x = EntryIdentity{}
|
|
mi := &file_s3_lifecycle_proto_msgTypes[2]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *EntryIdentity) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*EntryIdentity) ProtoMessage() {}
|
|
|
|
func (x *EntryIdentity) ProtoReflect() protoreflect.Message {
|
|
mi := &file_s3_lifecycle_proto_msgTypes[2]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use EntryIdentity.ProtoReflect.Descriptor instead.
|
|
func (*EntryIdentity) Descriptor() ([]byte, []int) {
|
|
return file_s3_lifecycle_proto_rawDescGZIP(), []int{2}
|
|
}
|
|
|
|
func (x *EntryIdentity) GetMtimeNs() int64 {
|
|
if x != nil {
|
|
return x.MtimeNs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *EntryIdentity) GetSize() int64 {
|
|
if x != nil {
|
|
return x.Size
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *EntryIdentity) GetHeadFid() string {
|
|
if x != nil {
|
|
return x.HeadFid
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *EntryIdentity) GetExtendedHash() []byte {
|
|
if x != nil {
|
|
return x.ExtendedHash
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// LifecycleState captures the durable per-action scheduling state. Keyed by
|
|
// (rule_hash, action_kind); persisted at
|
|
//
|
|
// /etc/s3/lifecycle/<bucket>/<rule_hash_hex>/<action_kind>/state
|
|
//
|
|
// A single XML <Rule> with N populated action sub-elements expands into N
|
|
// LifecycleState records, one per sibling action.
|
|
type LifecycleState struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
RuleHash []byte `protobuf:"bytes,1,opt,name=rule_hash,json=ruleHash,proto3" json:"rule_hash,omitempty"` // 8 bytes; matches the parent rule dir
|
|
ActionKind ActionKind `protobuf:"varint,2,opt,name=action_kind,json=actionKind,proto3,enum=s3_lifecycle_pb.ActionKind" json:"action_kind,omitempty"` // matches the leaf dir name
|
|
RuleId string `protobuf:"bytes,3,opt,name=rule_id,json=ruleId,proto3" json:"rule_id,omitempty"` // display only; identical across sibling actions
|
|
Mode LifecycleState_RuleMode `protobuf:"varint,4,opt,name=mode,proto3,enum=s3_lifecycle_pb.LifecycleState_RuleMode" json:"mode,omitempty"`
|
|
DegradedReason LifecycleState_DegradedReason `protobuf:"varint,5,opt,name=degraded_reason,json=degradedReason,proto3,enum=s3_lifecycle_pb.LifecycleState_DegradedReason" json:"degraded_reason,omitempty"`
|
|
DegradedSinceNs int64 `protobuf:"varint,6,opt,name=degraded_since_ns,json=degradedSinceNs,proto3" json:"degraded_since_ns,omitempty"`
|
|
BootstrapComplete bool `protobuf:"varint,7,opt,name=bootstrap_complete,json=bootstrapComplete,proto3" json:"bootstrap_complete,omitempty"`
|
|
BootstrapStartedAtNs int64 `protobuf:"varint,8,opt,name=bootstrap_started_at_ns,json=bootstrapStartedAtNs,proto3" json:"bootstrap_started_at_ns,omitempty"`
|
|
BootstrapCompletedAtNs int64 `protobuf:"varint,9,opt,name=bootstrap_completed_at_ns,json=bootstrapCompletedAtNs,proto3" json:"bootstrap_completed_at_ns,omitempty"`
|
|
// Safety-scan scheduling. Set by the safety-scan job when a SCAN_ONLY
|
|
// (or periodic safety-scan) bootstrap pass completes; consulted by the
|
|
// detector to decide whether to emit the next bootstrap task.
|
|
LastSafetyScanTsNs int64 `protobuf:"varint,10,opt,name=last_safety_scan_ts_ns,json=lastSafetyScanTsNs,proto3" json:"last_safety_scan_ts_ns,omitempty"`
|
|
NextSafetyScanTsNs int64 `protobuf:"varint,11,opt,name=next_safety_scan_ts_ns,json=nextSafetyScanTsNs,proto3" json:"next_safety_scan_ts_ns,omitempty"`
|
|
// Counters for observability; no behavior depends on these.
|
|
// - evaluated_total: live entries the worker considered for this action
|
|
// (filter-matched + due-checked); includes objects that ended up not
|
|
// yet eligible.
|
|
// - expired_total: successful DONE outcomes (object/version/marker/MPU
|
|
// removed) under this action.
|
|
// - metadata_only_total: subset of expired_total where the worker
|
|
// short-circuited via volume-TTL routing (chunks left to volume GC).
|
|
// - error_total: outcomes that did NOT advance the cursor under this
|
|
// action (RETRY_LATER, BLOCKED, FATAL_EVENT_ERROR).
|
|
EvaluatedTotal int64 `protobuf:"varint,12,opt,name=evaluated_total,json=evaluatedTotal,proto3" json:"evaluated_total,omitempty"`
|
|
ExpiredTotal int64 `protobuf:"varint,13,opt,name=expired_total,json=expiredTotal,proto3" json:"expired_total,omitempty"`
|
|
MetadataOnlyTotal int64 `protobuf:"varint,14,opt,name=metadata_only_total,json=metadataOnlyTotal,proto3" json:"metadata_only_total,omitempty"`
|
|
ErrorTotal int64 `protobuf:"varint,15,opt,name=error_total,json=errorTotal,proto3" json:"error_total,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *LifecycleState) Reset() {
|
|
*x = LifecycleState{}
|
|
mi := &file_s3_lifecycle_proto_msgTypes[3]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *LifecycleState) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*LifecycleState) ProtoMessage() {}
|
|
|
|
func (x *LifecycleState) ProtoReflect() protoreflect.Message {
|
|
mi := &file_s3_lifecycle_proto_msgTypes[3]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use LifecycleState.ProtoReflect.Descriptor instead.
|
|
func (*LifecycleState) Descriptor() ([]byte, []int) {
|
|
return file_s3_lifecycle_proto_rawDescGZIP(), []int{3}
|
|
}
|
|
|
|
func (x *LifecycleState) GetRuleHash() []byte {
|
|
if x != nil {
|
|
return x.RuleHash
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *LifecycleState) GetActionKind() ActionKind {
|
|
if x != nil {
|
|
return x.ActionKind
|
|
}
|
|
return ActionKind_ACTION_KIND_UNSPECIFIED
|
|
}
|
|
|
|
func (x *LifecycleState) GetRuleId() string {
|
|
if x != nil {
|
|
return x.RuleId
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *LifecycleState) GetMode() LifecycleState_RuleMode {
|
|
if x != nil {
|
|
return x.Mode
|
|
}
|
|
return LifecycleState_RULE_MODE_UNSPECIFIED
|
|
}
|
|
|
|
func (x *LifecycleState) GetDegradedReason() LifecycleState_DegradedReason {
|
|
if x != nil {
|
|
return x.DegradedReason
|
|
}
|
|
return LifecycleState_DEGRADED_REASON_UNSPECIFIED
|
|
}
|
|
|
|
func (x *LifecycleState) GetDegradedSinceNs() int64 {
|
|
if x != nil {
|
|
return x.DegradedSinceNs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LifecycleState) GetBootstrapComplete() bool {
|
|
if x != nil {
|
|
return x.BootstrapComplete
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *LifecycleState) GetBootstrapStartedAtNs() int64 {
|
|
if x != nil {
|
|
return x.BootstrapStartedAtNs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LifecycleState) GetBootstrapCompletedAtNs() int64 {
|
|
if x != nil {
|
|
return x.BootstrapCompletedAtNs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LifecycleState) GetLastSafetyScanTsNs() int64 {
|
|
if x != nil {
|
|
return x.LastSafetyScanTsNs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LifecycleState) GetNextSafetyScanTsNs() int64 {
|
|
if x != nil {
|
|
return x.NextSafetyScanTsNs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LifecycleState) GetEvaluatedTotal() int64 {
|
|
if x != nil {
|
|
return x.EvaluatedTotal
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LifecycleState) GetExpiredTotal() int64 {
|
|
if x != nil {
|
|
return x.ExpiredTotal
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LifecycleState) GetMetadataOnlyTotal() int64 {
|
|
if x != nil {
|
|
return x.MetadataOnlyTotal
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *LifecycleState) GetErrorTotal() int64 {
|
|
if x != nil {
|
|
return x.ErrorTotal
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// PendingItem records a not-yet-due eligibility for late-predicate exceptions
|
|
// (e.g. tag added at age 30d on a 60d rule). Drained by s3.lifecycle.drain.
|
|
// One use only — not the steady-state path.
|
|
type PendingItem struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
ObjectPath string `protobuf:"bytes,1,opt,name=object_path,json=objectPath,proto3" json:"object_path,omitempty"`
|
|
VersionId string `protobuf:"bytes,2,opt,name=version_id,json=versionId,proto3" json:"version_id,omitempty"`
|
|
DueAtNs int64 `protobuf:"varint,3,opt,name=due_at_ns,json=dueAtNs,proto3" json:"due_at_ns,omitempty"`
|
|
ExpectedIdentity *EntryIdentity `protobuf:"bytes,4,opt,name=expected_identity,json=expectedIdentity,proto3" json:"expected_identity,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *PendingItem) Reset() {
|
|
*x = PendingItem{}
|
|
mi := &file_s3_lifecycle_proto_msgTypes[4]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *PendingItem) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*PendingItem) ProtoMessage() {}
|
|
|
|
func (x *PendingItem) ProtoReflect() protoreflect.Message {
|
|
mi := &file_s3_lifecycle_proto_msgTypes[4]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use PendingItem.ProtoReflect.Descriptor instead.
|
|
func (*PendingItem) Descriptor() ([]byte, []int) {
|
|
return file_s3_lifecycle_proto_rawDescGZIP(), []int{4}
|
|
}
|
|
|
|
func (x *PendingItem) GetObjectPath() string {
|
|
if x != nil {
|
|
return x.ObjectPath
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *PendingItem) GetVersionId() string {
|
|
if x != nil {
|
|
return x.VersionId
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *PendingItem) GetDueAtNs() int64 {
|
|
if x != nil {
|
|
return x.DueAtNs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *PendingItem) GetExpectedIdentity() *EntryIdentity {
|
|
if x != nil {
|
|
return x.ExpectedIdentity
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// BootstrapState tracks the bucket walker's resume point. Operator-resolution
|
|
// of a BOOTSTRAP-stream blocker does NOT mutate this field — the next
|
|
// scheduled bootstrap task picks up from last_scanned_path and re-walks.
|
|
type BootstrapState struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
LastScannedPath string `protobuf:"bytes,1,opt,name=last_scanned_path,json=lastScannedPath,proto3" json:"last_scanned_path,omitempty"`
|
|
StartedAtNs int64 `protobuf:"varint,2,opt,name=started_at_ns,json=startedAtNs,proto3" json:"started_at_ns,omitempty"`
|
|
CompletedAtNs int64 `protobuf:"varint,3,opt,name=completed_at_ns,json=completedAtNs,proto3" json:"completed_at_ns,omitempty"` // zero while in progress
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *BootstrapState) Reset() {
|
|
*x = BootstrapState{}
|
|
mi := &file_s3_lifecycle_proto_msgTypes[5]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *BootstrapState) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*BootstrapState) ProtoMessage() {}
|
|
|
|
func (x *BootstrapState) ProtoReflect() protoreflect.Message {
|
|
mi := &file_s3_lifecycle_proto_msgTypes[5]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use BootstrapState.ProtoReflect.Descriptor instead.
|
|
func (*BootstrapState) Descriptor() ([]byte, []int) {
|
|
return file_s3_lifecycle_proto_rawDescGZIP(), []int{5}
|
|
}
|
|
|
|
func (x *BootstrapState) GetLastScannedPath() string {
|
|
if x != nil {
|
|
return x.LastScannedPath
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *BootstrapState) GetStartedAtNs() int64 {
|
|
if x != nil {
|
|
return x.StartedAtNs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *BootstrapState) GetCompletedAtNs() int64 {
|
|
if x != nil {
|
|
return x.CompletedAtNs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// ReaderState is the cluster-singleton reader's durable cursors. One file at
|
|
// /etc/s3/lifecycle/_reader/reader_state, written by the singleton task.
|
|
type ReaderState struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
PrimaryFilerEndpoint string `protobuf:"bytes,1,opt,name=primary_filer_endpoint,json=primaryFilerEndpoint,proto3" json:"primary_filer_endpoint,omitempty"`
|
|
// Per-delay-group, per-filer-shard cursors. Outer key is delay_seconds.
|
|
// Inner FilerShardCursor list maps filer_id -> MessagePosition.
|
|
LastProcessedOriginal map[int64]*FilerShardCursorList `protobuf:"bytes,2,rep,name=last_processed_original,json=lastProcessedOriginal,proto3" json:"last_processed_original,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
|
|
// Predicate-change pass cursor, keyed by filer_id.
|
|
LastProcessedPredicate []*FilerShardCursor `protobuf:"bytes,3,rep,name=last_processed_predicate,json=lastProcessedPredicate,proto3" json:"last_processed_predicate,omitempty"`
|
|
// Filer-shard keys whose cursor reached range.latest and were safely GC'd.
|
|
// Used by the lost-log gate at task entry to distinguish "F was tail-drained
|
|
// safely then pruned" from "F's logs vanished before catch-up". Encoded as
|
|
// stream-specific keys (same shape as RetryBudgetEntry.StreamKey).
|
|
TailDrainedStreams []*TailDrainedKey `protobuf:"bytes,4,rep,name=tail_drained_streams,json=tailDrainedStreams,proto3" json:"tail_drained_streams,omitempty"`
|
|
LastCheckpointNs int64 `protobuf:"varint,5,opt,name=last_checkpoint_ns,json=lastCheckpointNs,proto3" json:"last_checkpoint_ns,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *ReaderState) Reset() {
|
|
*x = ReaderState{}
|
|
mi := &file_s3_lifecycle_proto_msgTypes[6]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *ReaderState) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*ReaderState) ProtoMessage() {}
|
|
|
|
func (x *ReaderState) ProtoReflect() protoreflect.Message {
|
|
mi := &file_s3_lifecycle_proto_msgTypes[6]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use ReaderState.ProtoReflect.Descriptor instead.
|
|
func (*ReaderState) Descriptor() ([]byte, []int) {
|
|
return file_s3_lifecycle_proto_rawDescGZIP(), []int{6}
|
|
}
|
|
|
|
func (x *ReaderState) GetPrimaryFilerEndpoint() string {
|
|
if x != nil {
|
|
return x.PrimaryFilerEndpoint
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *ReaderState) GetLastProcessedOriginal() map[int64]*FilerShardCursorList {
|
|
if x != nil {
|
|
return x.LastProcessedOriginal
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *ReaderState) GetLastProcessedPredicate() []*FilerShardCursor {
|
|
if x != nil {
|
|
return x.LastProcessedPredicate
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *ReaderState) GetTailDrainedStreams() []*TailDrainedKey {
|
|
if x != nil {
|
|
return x.TailDrainedStreams
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *ReaderState) GetLastCheckpointNs() int64 {
|
|
if x != nil {
|
|
return x.LastCheckpointNs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type FilerShardCursorList struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Cursors []*FilerShardCursor `protobuf:"bytes,1,rep,name=cursors,proto3" json:"cursors,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *FilerShardCursorList) Reset() {
|
|
*x = FilerShardCursorList{}
|
|
mi := &file_s3_lifecycle_proto_msgTypes[7]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *FilerShardCursorList) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*FilerShardCursorList) ProtoMessage() {}
|
|
|
|
func (x *FilerShardCursorList) ProtoReflect() protoreflect.Message {
|
|
mi := &file_s3_lifecycle_proto_msgTypes[7]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use FilerShardCursorList.ProtoReflect.Descriptor instead.
|
|
func (*FilerShardCursorList) Descriptor() ([]byte, []int) {
|
|
return file_s3_lifecycle_proto_rawDescGZIP(), []int{7}
|
|
}
|
|
|
|
func (x *FilerShardCursorList) GetCursors() []*FilerShardCursor {
|
|
if x != nil {
|
|
return x.Cursors
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// TailDrainedKey identifies a (stream_kind, shard, [delay]) tuple whose
|
|
// cursor previously caught up to range.latest. Persisted in ReaderState so
|
|
// the lost-log gate can distinguish safe drain from data loss.
|
|
type TailDrainedKey struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
StreamKind StreamKind `protobuf:"varint,1,opt,name=stream_kind,json=streamKind,proto3,enum=s3_lifecycle_pb.StreamKind" json:"stream_kind,omitempty"`
|
|
FilerId string `protobuf:"bytes,2,opt,name=filer_id,json=filerId,proto3" json:"filer_id,omitempty"`
|
|
DelaySeconds int64 `protobuf:"varint,3,opt,name=delay_seconds,json=delaySeconds,proto3" json:"delay_seconds,omitempty"` // populated when stream_kind == ORIGINAL
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *TailDrainedKey) Reset() {
|
|
*x = TailDrainedKey{}
|
|
mi := &file_s3_lifecycle_proto_msgTypes[8]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *TailDrainedKey) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*TailDrainedKey) ProtoMessage() {}
|
|
|
|
func (x *TailDrainedKey) ProtoReflect() protoreflect.Message {
|
|
mi := &file_s3_lifecycle_proto_msgTypes[8]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use TailDrainedKey.ProtoReflect.Descriptor instead.
|
|
func (*TailDrainedKey) Descriptor() ([]byte, []int) {
|
|
return file_s3_lifecycle_proto_rawDescGZIP(), []int{8}
|
|
}
|
|
|
|
func (x *TailDrainedKey) GetStreamKind() StreamKind {
|
|
if x != nil {
|
|
return x.StreamKind
|
|
}
|
|
return StreamKind_STREAM_KIND_UNSPECIFIED
|
|
}
|
|
|
|
func (x *TailDrainedKey) GetFilerId() string {
|
|
if x != nil {
|
|
return x.FilerId
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *TailDrainedKey) GetDelaySeconds() int64 {
|
|
if x != nil {
|
|
return x.DelaySeconds
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// BlockerRecord is the durable record of a paused stream. The cursor stays
|
|
// at the failing position until the operator clears it via
|
|
// `s3.lifecycle.blockers retry|resume|quarantine`. There is no automatic
|
|
// dead-letter — silently routing a failed delete decision aside is unsafe
|
|
// for lifecycle.
|
|
type BlockerRecord struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
StreamKind StreamKind `protobuf:"varint,1,opt,name=stream_kind,json=streamKind,proto3,enum=s3_lifecycle_pb.StreamKind" json:"stream_kind,omitempty"`
|
|
// Stream-specific scoping; populated per stream_kind.
|
|
Shard string `protobuf:"bytes,2,opt,name=shard,proto3" json:"shard,omitempty"` // filer_id; ORIGINAL/PREDICATE only
|
|
DelaySeconds int64 `protobuf:"varint,3,opt,name=delay_seconds,json=delaySeconds,proto3" json:"delay_seconds,omitempty"` // ORIGINAL only
|
|
Position *MessagePosition `protobuf:"bytes,4,opt,name=position,proto3" json:"position,omitempty"` // ORIGINAL/PREDICATE only
|
|
// Common context. bucket/object_path/version_id always populated.
|
|
// rule_hash and action_kind are OPTIONAL: empty / UNSPECIFIED for
|
|
// pre-evaluation failures (e.g. handleEvent fetchLive FATAL where no
|
|
// action has been evaluated). When populated, both are set together —
|
|
// the failure is bound to a specific (rule, action) pair.
|
|
RuleHash []byte `protobuf:"bytes,5,opt,name=rule_hash,json=ruleHash,proto3" json:"rule_hash,omitempty"`
|
|
Bucket string `protobuf:"bytes,6,opt,name=bucket,proto3" json:"bucket,omitempty"`
|
|
ObjectPath string `protobuf:"bytes,7,opt,name=object_path,json=objectPath,proto3" json:"object_path,omitempty"`
|
|
VersionId string `protobuf:"bytes,8,opt,name=version_id,json=versionId,proto3" json:"version_id,omitempty"`
|
|
ActionKind ActionKind `protobuf:"varint,14,opt,name=action_kind,json=actionKind,proto3,enum=s3_lifecycle_pb.ActionKind" json:"action_kind,omitempty"` // optional; UNSPECIFIED for pre-evaluation failures
|
|
Reason string `protobuf:"bytes,9,opt,name=reason,proto3" json:"reason,omitempty"` // "FATAL_EVENT_ERROR: malformed entry"
|
|
LastError string `protobuf:"bytes,10,opt,name=last_error,json=lastError,proto3" json:"last_error,omitempty"` // raw error string from the last attempt
|
|
FirstSeenAtNs int64 `protobuf:"varint,11,opt,name=first_seen_at_ns,json=firstSeenAtNs,proto3" json:"first_seen_at_ns,omitempty"`
|
|
LastRetryAtNs int64 `protobuf:"varint,12,opt,name=last_retry_at_ns,json=lastRetryAtNs,proto3" json:"last_retry_at_ns,omitempty"`
|
|
RetryCount int32 `protobuf:"varint,13,opt,name=retry_count,json=retryCount,proto3" json:"retry_count,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *BlockerRecord) Reset() {
|
|
*x = BlockerRecord{}
|
|
mi := &file_s3_lifecycle_proto_msgTypes[9]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *BlockerRecord) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*BlockerRecord) ProtoMessage() {}
|
|
|
|
func (x *BlockerRecord) ProtoReflect() protoreflect.Message {
|
|
mi := &file_s3_lifecycle_proto_msgTypes[9]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use BlockerRecord.ProtoReflect.Descriptor instead.
|
|
func (*BlockerRecord) Descriptor() ([]byte, []int) {
|
|
return file_s3_lifecycle_proto_rawDescGZIP(), []int{9}
|
|
}
|
|
|
|
func (x *BlockerRecord) GetStreamKind() StreamKind {
|
|
if x != nil {
|
|
return x.StreamKind
|
|
}
|
|
return StreamKind_STREAM_KIND_UNSPECIFIED
|
|
}
|
|
|
|
func (x *BlockerRecord) GetShard() string {
|
|
if x != nil {
|
|
return x.Shard
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *BlockerRecord) GetDelaySeconds() int64 {
|
|
if x != nil {
|
|
return x.DelaySeconds
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *BlockerRecord) GetPosition() *MessagePosition {
|
|
if x != nil {
|
|
return x.Position
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *BlockerRecord) GetRuleHash() []byte {
|
|
if x != nil {
|
|
return x.RuleHash
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *BlockerRecord) GetBucket() string {
|
|
if x != nil {
|
|
return x.Bucket
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *BlockerRecord) GetObjectPath() string {
|
|
if x != nil {
|
|
return x.ObjectPath
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *BlockerRecord) GetVersionId() string {
|
|
if x != nil {
|
|
return x.VersionId
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *BlockerRecord) GetActionKind() ActionKind {
|
|
if x != nil {
|
|
return x.ActionKind
|
|
}
|
|
return ActionKind_ACTION_KIND_UNSPECIFIED
|
|
}
|
|
|
|
func (x *BlockerRecord) GetReason() string {
|
|
if x != nil {
|
|
return x.Reason
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *BlockerRecord) GetLastError() string {
|
|
if x != nil {
|
|
return x.LastError
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *BlockerRecord) GetFirstSeenAtNs() int64 {
|
|
if x != nil {
|
|
return x.FirstSeenAtNs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *BlockerRecord) GetLastRetryAtNs() int64 {
|
|
if x != nil {
|
|
return x.LastRetryAtNs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *BlockerRecord) GetRetryCount() int32 {
|
|
if x != nil {
|
|
return x.RetryCount
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// StreamKey is the shape used by retry-budget tracking. One of four shapes
|
|
// per stream_kind, since the identifying tuple differs.
|
|
type StreamKey struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
// Types that are valid to be assigned to Key:
|
|
//
|
|
// *StreamKey_Original
|
|
// *StreamKey_Predicate
|
|
// *StreamKey_Bootstrap
|
|
// *StreamKey_Pending
|
|
Key isStreamKey_Key `protobuf_oneof:"key"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *StreamKey) Reset() {
|
|
*x = StreamKey{}
|
|
mi := &file_s3_lifecycle_proto_msgTypes[10]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *StreamKey) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*StreamKey) ProtoMessage() {}
|
|
|
|
func (x *StreamKey) ProtoReflect() protoreflect.Message {
|
|
mi := &file_s3_lifecycle_proto_msgTypes[10]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use StreamKey.ProtoReflect.Descriptor instead.
|
|
func (*StreamKey) Descriptor() ([]byte, []int) {
|
|
return file_s3_lifecycle_proto_rawDescGZIP(), []int{10}
|
|
}
|
|
|
|
func (x *StreamKey) GetKey() isStreamKey_Key {
|
|
if x != nil {
|
|
return x.Key
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *StreamKey) GetOriginal() *OriginalKey {
|
|
if x != nil {
|
|
if x, ok := x.Key.(*StreamKey_Original); ok {
|
|
return x.Original
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *StreamKey) GetPredicate() *PredicateKey {
|
|
if x != nil {
|
|
if x, ok := x.Key.(*StreamKey_Predicate); ok {
|
|
return x.Predicate
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *StreamKey) GetBootstrap() *BootstrapKey {
|
|
if x != nil {
|
|
if x, ok := x.Key.(*StreamKey_Bootstrap); ok {
|
|
return x.Bootstrap
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *StreamKey) GetPending() *PendingKey {
|
|
if x != nil {
|
|
if x, ok := x.Key.(*StreamKey_Pending); ok {
|
|
return x.Pending
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type isStreamKey_Key interface {
|
|
isStreamKey_Key()
|
|
}
|
|
|
|
type StreamKey_Original struct {
|
|
Original *OriginalKey `protobuf:"bytes,1,opt,name=original,proto3,oneof"`
|
|
}
|
|
|
|
type StreamKey_Predicate struct {
|
|
Predicate *PredicateKey `protobuf:"bytes,2,opt,name=predicate,proto3,oneof"`
|
|
}
|
|
|
|
type StreamKey_Bootstrap struct {
|
|
Bootstrap *BootstrapKey `protobuf:"bytes,3,opt,name=bootstrap,proto3,oneof"`
|
|
}
|
|
|
|
type StreamKey_Pending struct {
|
|
Pending *PendingKey `protobuf:"bytes,4,opt,name=pending,proto3,oneof"`
|
|
}
|
|
|
|
func (*StreamKey_Original) isStreamKey_Key() {}
|
|
|
|
func (*StreamKey_Predicate) isStreamKey_Key() {}
|
|
|
|
func (*StreamKey_Bootstrap) isStreamKey_Key() {}
|
|
|
|
func (*StreamKey_Pending) isStreamKey_Key() {}
|
|
|
|
type OriginalKey struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Shard string `protobuf:"bytes,1,opt,name=shard,proto3" json:"shard,omitempty"`
|
|
DelaySeconds int64 `protobuf:"varint,2,opt,name=delay_seconds,json=delaySeconds,proto3" json:"delay_seconds,omitempty"`
|
|
Position *MessagePosition `protobuf:"bytes,3,opt,name=position,proto3" json:"position,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *OriginalKey) Reset() {
|
|
*x = OriginalKey{}
|
|
mi := &file_s3_lifecycle_proto_msgTypes[11]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *OriginalKey) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*OriginalKey) ProtoMessage() {}
|
|
|
|
func (x *OriginalKey) ProtoReflect() protoreflect.Message {
|
|
mi := &file_s3_lifecycle_proto_msgTypes[11]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use OriginalKey.ProtoReflect.Descriptor instead.
|
|
func (*OriginalKey) Descriptor() ([]byte, []int) {
|
|
return file_s3_lifecycle_proto_rawDescGZIP(), []int{11}
|
|
}
|
|
|
|
func (x *OriginalKey) GetShard() string {
|
|
if x != nil {
|
|
return x.Shard
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *OriginalKey) GetDelaySeconds() int64 {
|
|
if x != nil {
|
|
return x.DelaySeconds
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *OriginalKey) GetPosition() *MessagePosition {
|
|
if x != nil {
|
|
return x.Position
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type PredicateKey struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Shard string `protobuf:"bytes,1,opt,name=shard,proto3" json:"shard,omitempty"`
|
|
Position *MessagePosition `protobuf:"bytes,2,opt,name=position,proto3" json:"position,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *PredicateKey) Reset() {
|
|
*x = PredicateKey{}
|
|
mi := &file_s3_lifecycle_proto_msgTypes[12]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *PredicateKey) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*PredicateKey) ProtoMessage() {}
|
|
|
|
func (x *PredicateKey) ProtoReflect() protoreflect.Message {
|
|
mi := &file_s3_lifecycle_proto_msgTypes[12]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use PredicateKey.ProtoReflect.Descriptor instead.
|
|
func (*PredicateKey) Descriptor() ([]byte, []int) {
|
|
return file_s3_lifecycle_proto_rawDescGZIP(), []int{12}
|
|
}
|
|
|
|
func (x *PredicateKey) GetShard() string {
|
|
if x != nil {
|
|
return x.Shard
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *PredicateKey) GetPosition() *MessagePosition {
|
|
if x != nil {
|
|
return x.Position
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type BootstrapKey struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Bucket string `protobuf:"bytes,1,opt,name=bucket,proto3" json:"bucket,omitempty"`
|
|
ObjectPath string `protobuf:"bytes,2,opt,name=object_path,json=objectPath,proto3" json:"object_path,omitempty"`
|
|
VersionId string `protobuf:"bytes,3,opt,name=version_id,json=versionId,proto3" json:"version_id,omitempty"`
|
|
RuleHash []byte `protobuf:"bytes,4,opt,name=rule_hash,json=ruleHash,proto3" json:"rule_hash,omitempty"`
|
|
ActionKind ActionKind `protobuf:"varint,5,opt,name=action_kind,json=actionKind,proto3,enum=s3_lifecycle_pb.ActionKind" json:"action_kind,omitempty"` // distinguishes per-action streams under one rule
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *BootstrapKey) Reset() {
|
|
*x = BootstrapKey{}
|
|
mi := &file_s3_lifecycle_proto_msgTypes[13]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *BootstrapKey) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*BootstrapKey) ProtoMessage() {}
|
|
|
|
func (x *BootstrapKey) ProtoReflect() protoreflect.Message {
|
|
mi := &file_s3_lifecycle_proto_msgTypes[13]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use BootstrapKey.ProtoReflect.Descriptor instead.
|
|
func (*BootstrapKey) Descriptor() ([]byte, []int) {
|
|
return file_s3_lifecycle_proto_rawDescGZIP(), []int{13}
|
|
}
|
|
|
|
func (x *BootstrapKey) GetBucket() string {
|
|
if x != nil {
|
|
return x.Bucket
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *BootstrapKey) GetObjectPath() string {
|
|
if x != nil {
|
|
return x.ObjectPath
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *BootstrapKey) GetVersionId() string {
|
|
if x != nil {
|
|
return x.VersionId
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *BootstrapKey) GetRuleHash() []byte {
|
|
if x != nil {
|
|
return x.RuleHash
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *BootstrapKey) GetActionKind() ActionKind {
|
|
if x != nil {
|
|
return x.ActionKind
|
|
}
|
|
return ActionKind_ACTION_KIND_UNSPECIFIED
|
|
}
|
|
|
|
type PendingKey struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Bucket string `protobuf:"bytes,1,opt,name=bucket,proto3" json:"bucket,omitempty"`
|
|
RuleHash []byte `protobuf:"bytes,2,opt,name=rule_hash,json=ruleHash,proto3" json:"rule_hash,omitempty"`
|
|
ObjectPath string `protobuf:"bytes,3,opt,name=object_path,json=objectPath,proto3" json:"object_path,omitempty"`
|
|
VersionId string `protobuf:"bytes,4,opt,name=version_id,json=versionId,proto3" json:"version_id,omitempty"`
|
|
ActionKind ActionKind `protobuf:"varint,5,opt,name=action_kind,json=actionKind,proto3,enum=s3_lifecycle_pb.ActionKind" json:"action_kind,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *PendingKey) Reset() {
|
|
*x = PendingKey{}
|
|
mi := &file_s3_lifecycle_proto_msgTypes[14]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *PendingKey) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*PendingKey) ProtoMessage() {}
|
|
|
|
func (x *PendingKey) ProtoReflect() protoreflect.Message {
|
|
mi := &file_s3_lifecycle_proto_msgTypes[14]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use PendingKey.ProtoReflect.Descriptor instead.
|
|
func (*PendingKey) Descriptor() ([]byte, []int) {
|
|
return file_s3_lifecycle_proto_rawDescGZIP(), []int{14}
|
|
}
|
|
|
|
func (x *PendingKey) GetBucket() string {
|
|
if x != nil {
|
|
return x.Bucket
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *PendingKey) GetRuleHash() []byte {
|
|
if x != nil {
|
|
return x.RuleHash
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *PendingKey) GetObjectPath() string {
|
|
if x != nil {
|
|
return x.ObjectPath
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *PendingKey) GetVersionId() string {
|
|
if x != nil {
|
|
return x.VersionId
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *PendingKey) GetActionKind() ActionKind {
|
|
if x != nil {
|
|
return x.ActionKind
|
|
}
|
|
return ActionKind_ACTION_KIND_UNSPECIFIED
|
|
}
|
|
|
|
// RetryBudgetEntry tracks consecutive RETRY_LATER outcomes for a stream key.
|
|
// Promotes to BLOCKED when consecutive_retries >= retryBudgetMax (30) or age
|
|
// >= retryBudgetMaxAge (4h). Compacts on success (clearRetryBudget).
|
|
type RetryBudgetEntry struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Key *StreamKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
|
|
ConsecutiveRetries int32 `protobuf:"varint,2,opt,name=consecutive_retries,json=consecutiveRetries,proto3" json:"consecutive_retries,omitempty"`
|
|
FirstSeenAtNs int64 `protobuf:"varint,3,opt,name=first_seen_at_ns,json=firstSeenAtNs,proto3" json:"first_seen_at_ns,omitempty"`
|
|
LastRetryAtNs int64 `protobuf:"varint,4,opt,name=last_retry_at_ns,json=lastRetryAtNs,proto3" json:"last_retry_at_ns,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *RetryBudgetEntry) Reset() {
|
|
*x = RetryBudgetEntry{}
|
|
mi := &file_s3_lifecycle_proto_msgTypes[15]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *RetryBudgetEntry) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*RetryBudgetEntry) ProtoMessage() {}
|
|
|
|
func (x *RetryBudgetEntry) ProtoReflect() protoreflect.Message {
|
|
mi := &file_s3_lifecycle_proto_msgTypes[15]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use RetryBudgetEntry.ProtoReflect.Descriptor instead.
|
|
func (*RetryBudgetEntry) Descriptor() ([]byte, []int) {
|
|
return file_s3_lifecycle_proto_rawDescGZIP(), []int{15}
|
|
}
|
|
|
|
func (x *RetryBudgetEntry) GetKey() *StreamKey {
|
|
if x != nil {
|
|
return x.Key
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *RetryBudgetEntry) GetConsecutiveRetries() int32 {
|
|
if x != nil {
|
|
return x.ConsecutiveRetries
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *RetryBudgetEntry) GetFirstSeenAtNs() int64 {
|
|
if x != nil {
|
|
return x.FirstSeenAtNs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *RetryBudgetEntry) GetLastRetryAtNs() int64 {
|
|
if x != nil {
|
|
return x.LastRetryAtNs
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// RetryTarget carries routing info needed to (a) write a BlockerRecord on
|
|
// promotion and (b) re-invoke the right primitive on operator retry. We
|
|
// deliberately do NOT carry expected_identity or action: the handler
|
|
// re-fetches live state and re-evaluates from scratch.
|
|
type RetryTarget struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Key *StreamKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
|
|
Bucket string `protobuf:"bytes,2,opt,name=bucket,proto3" json:"bucket,omitempty"`
|
|
ObjectPath string `protobuf:"bytes,3,opt,name=object_path,json=objectPath,proto3" json:"object_path,omitempty"`
|
|
VersionId string `protobuf:"bytes,4,opt,name=version_id,json=versionId,proto3" json:"version_id,omitempty"`
|
|
RuleHash []byte `protobuf:"bytes,5,opt,name=rule_hash,json=ruleHash,proto3" json:"rule_hash,omitempty"`
|
|
ActionKind ActionKind `protobuf:"varint,6,opt,name=action_kind,json=actionKind,proto3,enum=s3_lifecycle_pb.ActionKind" json:"action_kind,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *RetryTarget) Reset() {
|
|
*x = RetryTarget{}
|
|
mi := &file_s3_lifecycle_proto_msgTypes[16]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *RetryTarget) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*RetryTarget) ProtoMessage() {}
|
|
|
|
func (x *RetryTarget) ProtoReflect() protoreflect.Message {
|
|
mi := &file_s3_lifecycle_proto_msgTypes[16]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use RetryTarget.ProtoReflect.Descriptor instead.
|
|
func (*RetryTarget) Descriptor() ([]byte, []int) {
|
|
return file_s3_lifecycle_proto_rawDescGZIP(), []int{16}
|
|
}
|
|
|
|
func (x *RetryTarget) GetKey() *StreamKey {
|
|
if x != nil {
|
|
return x.Key
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *RetryTarget) GetBucket() string {
|
|
if x != nil {
|
|
return x.Bucket
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *RetryTarget) GetObjectPath() string {
|
|
if x != nil {
|
|
return x.ObjectPath
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *RetryTarget) GetVersionId() string {
|
|
if x != nil {
|
|
return x.VersionId
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *RetryTarget) GetRuleHash() []byte {
|
|
if x != nil {
|
|
return x.RuleHash
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *RetryTarget) GetActionKind() ActionKind {
|
|
if x != nil {
|
|
return x.ActionKind
|
|
}
|
|
return ActionKind_ACTION_KIND_UNSPECIFIED
|
|
}
|
|
|
|
var File_s3_lifecycle_proto protoreflect.FileDescriptor
|
|
|
|
const file_s3_lifecycle_proto_rawDesc = "" +
|
|
"\n" +
|
|
"\x12s3_lifecycle.proto\x12\x0fs3_lifecycle_pb\">\n" +
|
|
"\x0fMessagePosition\x12\x13\n" +
|
|
"\x05ts_ns\x18\x01 \x01(\x03R\x04tsNs\x12\x16\n" +
|
|
"\x06offset\x18\x02 \x01(\x03R\x06offset\"k\n" +
|
|
"\x10FilerShardCursor\x12\x19\n" +
|
|
"\bfiler_id\x18\x01 \x01(\tR\afilerId\x12<\n" +
|
|
"\bposition\x18\x02 \x01(\v2 .s3_lifecycle_pb.MessagePositionR\bposition\"~\n" +
|
|
"\rEntryIdentity\x12\x19\n" +
|
|
"\bmtime_ns\x18\x01 \x01(\x03R\amtimeNs\x12\x12\n" +
|
|
"\x04size\x18\x02 \x01(\x03R\x04size\x12\x19\n" +
|
|
"\bhead_fid\x18\x03 \x01(\tR\aheadFid\x12#\n" +
|
|
"\rextended_hash\x18\x04 \x01(\fR\fextendedHash\"\x97\b\n" +
|
|
"\x0eLifecycleState\x12\x1b\n" +
|
|
"\trule_hash\x18\x01 \x01(\fR\bruleHash\x12<\n" +
|
|
"\vaction_kind\x18\x02 \x01(\x0e2\x1b.s3_lifecycle_pb.ActionKindR\n" +
|
|
"actionKind\x12\x17\n" +
|
|
"\arule_id\x18\x03 \x01(\tR\x06ruleId\x12<\n" +
|
|
"\x04mode\x18\x04 \x01(\x0e2(.s3_lifecycle_pb.LifecycleState.RuleModeR\x04mode\x12W\n" +
|
|
"\x0fdegraded_reason\x18\x05 \x01(\x0e2..s3_lifecycle_pb.LifecycleState.DegradedReasonR\x0edegradedReason\x12*\n" +
|
|
"\x11degraded_since_ns\x18\x06 \x01(\x03R\x0fdegradedSinceNs\x12-\n" +
|
|
"\x12bootstrap_complete\x18\a \x01(\bR\x11bootstrapComplete\x125\n" +
|
|
"\x17bootstrap_started_at_ns\x18\b \x01(\x03R\x14bootstrapStartedAtNs\x129\n" +
|
|
"\x19bootstrap_completed_at_ns\x18\t \x01(\x03R\x16bootstrapCompletedAtNs\x122\n" +
|
|
"\x16last_safety_scan_ts_ns\x18\n" +
|
|
" \x01(\x03R\x12lastSafetyScanTsNs\x122\n" +
|
|
"\x16next_safety_scan_ts_ns\x18\v \x01(\x03R\x12nextSafetyScanTsNs\x12'\n" +
|
|
"\x0fevaluated_total\x18\f \x01(\x03R\x0eevaluatedTotal\x12#\n" +
|
|
"\rexpired_total\x18\r \x01(\x03R\fexpiredTotal\x12.\n" +
|
|
"\x13metadata_only_total\x18\x0e \x01(\x03R\x11metadataOnlyTotal\x12\x1f\n" +
|
|
"\verror_total\x18\x0f \x01(\x03R\n" +
|
|
"errorTotal\"}\n" +
|
|
"\bRuleMode\x12\x19\n" +
|
|
"\x15RULE_MODE_UNSPECIFIED\x10\x00\x12\x10\n" +
|
|
"\fEVENT_DRIVEN\x10\x01\x12\x10\n" +
|
|
"\fSCAN_AT_DATE\x10\x02\x12\r\n" +
|
|
"\tSCAN_ONLY\x10\x03\x12\f\n" +
|
|
"\bDISABLED\x10\x04\x12\x15\n" +
|
|
"\x11PENDING_BOOTSTRAP\x10\x05\"\xa6\x01\n" +
|
|
"\x0eDegradedReason\x12\x1f\n" +
|
|
"\x1bDEGRADED_REASON_UNSPECIFIED\x10\x00\x12\f\n" +
|
|
"\bLAG_HIGH\x10\x01\x12\x10\n" +
|
|
"\fPENDING_FULL\x10\x02\x12\x13\n" +
|
|
"\x0fDELETE_FAILURES\x10\x03\x12\x13\n" +
|
|
"\x0fOPERATOR_PAUSED\x10\x04\x12\x1b\n" +
|
|
"\x17RETENTION_BELOW_HORIZON\x10\x05\x12\f\n" +
|
|
"\bLOST_LOG\x10\x06\"\xb6\x01\n" +
|
|
"\vPendingItem\x12\x1f\n" +
|
|
"\vobject_path\x18\x01 \x01(\tR\n" +
|
|
"objectPath\x12\x1d\n" +
|
|
"\n" +
|
|
"version_id\x18\x02 \x01(\tR\tversionId\x12\x1a\n" +
|
|
"\tdue_at_ns\x18\x03 \x01(\x03R\adueAtNs\x12K\n" +
|
|
"\x11expected_identity\x18\x04 \x01(\v2\x1e.s3_lifecycle_pb.EntryIdentityR\x10expectedIdentity\"\x88\x01\n" +
|
|
"\x0eBootstrapState\x12*\n" +
|
|
"\x11last_scanned_path\x18\x01 \x01(\tR\x0flastScannedPath\x12\"\n" +
|
|
"\rstarted_at_ns\x18\x02 \x01(\x03R\vstartedAtNs\x12&\n" +
|
|
"\x0fcompleted_at_ns\x18\x03 \x01(\x03R\rcompletedAtNs\"\x83\x04\n" +
|
|
"\vReaderState\x124\n" +
|
|
"\x16primary_filer_endpoint\x18\x01 \x01(\tR\x14primaryFilerEndpoint\x12o\n" +
|
|
"\x17last_processed_original\x18\x02 \x03(\v27.s3_lifecycle_pb.ReaderState.LastProcessedOriginalEntryR\x15lastProcessedOriginal\x12[\n" +
|
|
"\x18last_processed_predicate\x18\x03 \x03(\v2!.s3_lifecycle_pb.FilerShardCursorR\x16lastProcessedPredicate\x12Q\n" +
|
|
"\x14tail_drained_streams\x18\x04 \x03(\v2\x1f.s3_lifecycle_pb.TailDrainedKeyR\x12tailDrainedStreams\x12,\n" +
|
|
"\x12last_checkpoint_ns\x18\x05 \x01(\x03R\x10lastCheckpointNs\x1ao\n" +
|
|
"\x1aLastProcessedOriginalEntry\x12\x10\n" +
|
|
"\x03key\x18\x01 \x01(\x03R\x03key\x12;\n" +
|
|
"\x05value\x18\x02 \x01(\v2%.s3_lifecycle_pb.FilerShardCursorListR\x05value:\x028\x01\"S\n" +
|
|
"\x14FilerShardCursorList\x12;\n" +
|
|
"\acursors\x18\x01 \x03(\v2!.s3_lifecycle_pb.FilerShardCursorR\acursors\"\x8e\x01\n" +
|
|
"\x0eTailDrainedKey\x12<\n" +
|
|
"\vstream_kind\x18\x01 \x01(\x0e2\x1b.s3_lifecycle_pb.StreamKindR\n" +
|
|
"streamKind\x12\x19\n" +
|
|
"\bfiler_id\x18\x02 \x01(\tR\afilerId\x12#\n" +
|
|
"\rdelay_seconds\x18\x03 \x01(\x03R\fdelaySeconds\"\xa3\x04\n" +
|
|
"\rBlockerRecord\x12<\n" +
|
|
"\vstream_kind\x18\x01 \x01(\x0e2\x1b.s3_lifecycle_pb.StreamKindR\n" +
|
|
"streamKind\x12\x14\n" +
|
|
"\x05shard\x18\x02 \x01(\tR\x05shard\x12#\n" +
|
|
"\rdelay_seconds\x18\x03 \x01(\x03R\fdelaySeconds\x12<\n" +
|
|
"\bposition\x18\x04 \x01(\v2 .s3_lifecycle_pb.MessagePositionR\bposition\x12\x1b\n" +
|
|
"\trule_hash\x18\x05 \x01(\fR\bruleHash\x12\x16\n" +
|
|
"\x06bucket\x18\x06 \x01(\tR\x06bucket\x12\x1f\n" +
|
|
"\vobject_path\x18\a \x01(\tR\n" +
|
|
"objectPath\x12\x1d\n" +
|
|
"\n" +
|
|
"version_id\x18\b \x01(\tR\tversionId\x12<\n" +
|
|
"\vaction_kind\x18\x0e \x01(\x0e2\x1b.s3_lifecycle_pb.ActionKindR\n" +
|
|
"actionKind\x12\x16\n" +
|
|
"\x06reason\x18\t \x01(\tR\x06reason\x12\x1d\n" +
|
|
"\n" +
|
|
"last_error\x18\n" +
|
|
" \x01(\tR\tlastError\x12'\n" +
|
|
"\x10first_seen_at_ns\x18\v \x01(\x03R\rfirstSeenAtNs\x12'\n" +
|
|
"\x10last_retry_at_ns\x18\f \x01(\x03R\rlastRetryAtNs\x12\x1f\n" +
|
|
"\vretry_count\x18\r \x01(\x05R\n" +
|
|
"retryCount\"\x85\x02\n" +
|
|
"\tStreamKey\x12:\n" +
|
|
"\boriginal\x18\x01 \x01(\v2\x1c.s3_lifecycle_pb.OriginalKeyH\x00R\boriginal\x12=\n" +
|
|
"\tpredicate\x18\x02 \x01(\v2\x1d.s3_lifecycle_pb.PredicateKeyH\x00R\tpredicate\x12=\n" +
|
|
"\tbootstrap\x18\x03 \x01(\v2\x1d.s3_lifecycle_pb.BootstrapKeyH\x00R\tbootstrap\x127\n" +
|
|
"\apending\x18\x04 \x01(\v2\x1b.s3_lifecycle_pb.PendingKeyH\x00R\apendingB\x05\n" +
|
|
"\x03key\"\x86\x01\n" +
|
|
"\vOriginalKey\x12\x14\n" +
|
|
"\x05shard\x18\x01 \x01(\tR\x05shard\x12#\n" +
|
|
"\rdelay_seconds\x18\x02 \x01(\x03R\fdelaySeconds\x12<\n" +
|
|
"\bposition\x18\x03 \x01(\v2 .s3_lifecycle_pb.MessagePositionR\bposition\"b\n" +
|
|
"\fPredicateKey\x12\x14\n" +
|
|
"\x05shard\x18\x01 \x01(\tR\x05shard\x12<\n" +
|
|
"\bposition\x18\x02 \x01(\v2 .s3_lifecycle_pb.MessagePositionR\bposition\"\xc1\x01\n" +
|
|
"\fBootstrapKey\x12\x16\n" +
|
|
"\x06bucket\x18\x01 \x01(\tR\x06bucket\x12\x1f\n" +
|
|
"\vobject_path\x18\x02 \x01(\tR\n" +
|
|
"objectPath\x12\x1d\n" +
|
|
"\n" +
|
|
"version_id\x18\x03 \x01(\tR\tversionId\x12\x1b\n" +
|
|
"\trule_hash\x18\x04 \x01(\fR\bruleHash\x12<\n" +
|
|
"\vaction_kind\x18\x05 \x01(\x0e2\x1b.s3_lifecycle_pb.ActionKindR\n" +
|
|
"actionKind\"\xbf\x01\n" +
|
|
"\n" +
|
|
"PendingKey\x12\x16\n" +
|
|
"\x06bucket\x18\x01 \x01(\tR\x06bucket\x12\x1b\n" +
|
|
"\trule_hash\x18\x02 \x01(\fR\bruleHash\x12\x1f\n" +
|
|
"\vobject_path\x18\x03 \x01(\tR\n" +
|
|
"objectPath\x12\x1d\n" +
|
|
"\n" +
|
|
"version_id\x18\x04 \x01(\tR\tversionId\x12<\n" +
|
|
"\vaction_kind\x18\x05 \x01(\x0e2\x1b.s3_lifecycle_pb.ActionKindR\n" +
|
|
"actionKind\"\xc3\x01\n" +
|
|
"\x10RetryBudgetEntry\x12,\n" +
|
|
"\x03key\x18\x01 \x01(\v2\x1a.s3_lifecycle_pb.StreamKeyR\x03key\x12/\n" +
|
|
"\x13consecutive_retries\x18\x02 \x01(\x05R\x12consecutiveRetries\x12'\n" +
|
|
"\x10first_seen_at_ns\x18\x03 \x01(\x03R\rfirstSeenAtNs\x12'\n" +
|
|
"\x10last_retry_at_ns\x18\x04 \x01(\x03R\rlastRetryAtNs\"\xee\x01\n" +
|
|
"\vRetryTarget\x12,\n" +
|
|
"\x03key\x18\x01 \x01(\v2\x1a.s3_lifecycle_pb.StreamKeyR\x03key\x12\x16\n" +
|
|
"\x06bucket\x18\x02 \x01(\tR\x06bucket\x12\x1f\n" +
|
|
"\vobject_path\x18\x03 \x01(\tR\n" +
|
|
"objectPath\x12\x1d\n" +
|
|
"\n" +
|
|
"version_id\x18\x04 \x01(\tR\tversionId\x12\x1b\n" +
|
|
"\trule_hash\x18\x05 \x01(\fR\bruleHash\x12<\n" +
|
|
"\vaction_kind\x18\x06 \x01(\x0e2\x1b.s3_lifecycle_pb.ActionKindR\n" +
|
|
"actionKind*\xa8\x01\n" +
|
|
"\n" +
|
|
"ActionKind\x12\x1b\n" +
|
|
"\x17ACTION_KIND_UNSPECIFIED\x10\x00\x12\x13\n" +
|
|
"\x0fEXPIRATION_DAYS\x10\x01\x12\x13\n" +
|
|
"\x0fEXPIRATION_DATE\x10\x02\x12\x13\n" +
|
|
"\x0fNONCURRENT_DAYS\x10\x03\x12\x14\n" +
|
|
"\x10NEWER_NONCURRENT\x10\x04\x12\r\n" +
|
|
"\tABORT_MPU\x10\x05\x12\x19\n" +
|
|
"\x15EXPIRED_DELETE_MARKER\x10\x06*b\n" +
|
|
"\n" +
|
|
"StreamKind\x12\x1b\n" +
|
|
"\x17STREAM_KIND_UNSPECIFIED\x10\x00\x12\f\n" +
|
|
"\bORIGINAL\x10\x01\x12\r\n" +
|
|
"\tPREDICATE\x10\x02\x12\r\n" +
|
|
"\tBOOTSTRAP\x10\x03\x12\v\n" +
|
|
"\aPENDING\x10\x04B\\\n" +
|
|
"\x10seaweedfs.clientB\x10S3LifecycleProtoZ6github.com/seaweedfs/seaweedfs/weed/pb/s3_lifecycle_pbb\x06proto3"
|
|
|
|
var (
|
|
file_s3_lifecycle_proto_rawDescOnce sync.Once
|
|
file_s3_lifecycle_proto_rawDescData []byte
|
|
)
|
|
|
|
func file_s3_lifecycle_proto_rawDescGZIP() []byte {
|
|
file_s3_lifecycle_proto_rawDescOnce.Do(func() {
|
|
file_s3_lifecycle_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_s3_lifecycle_proto_rawDesc), len(file_s3_lifecycle_proto_rawDesc)))
|
|
})
|
|
return file_s3_lifecycle_proto_rawDescData
|
|
}
|
|
|
|
var file_s3_lifecycle_proto_enumTypes = make([]protoimpl.EnumInfo, 4)
|
|
var file_s3_lifecycle_proto_msgTypes = make([]protoimpl.MessageInfo, 18)
|
|
var file_s3_lifecycle_proto_goTypes = []any{
|
|
(ActionKind)(0), // 0: s3_lifecycle_pb.ActionKind
|
|
(StreamKind)(0), // 1: s3_lifecycle_pb.StreamKind
|
|
(LifecycleState_RuleMode)(0), // 2: s3_lifecycle_pb.LifecycleState.RuleMode
|
|
(LifecycleState_DegradedReason)(0), // 3: s3_lifecycle_pb.LifecycleState.DegradedReason
|
|
(*MessagePosition)(nil), // 4: s3_lifecycle_pb.MessagePosition
|
|
(*FilerShardCursor)(nil), // 5: s3_lifecycle_pb.FilerShardCursor
|
|
(*EntryIdentity)(nil), // 6: s3_lifecycle_pb.EntryIdentity
|
|
(*LifecycleState)(nil), // 7: s3_lifecycle_pb.LifecycleState
|
|
(*PendingItem)(nil), // 8: s3_lifecycle_pb.PendingItem
|
|
(*BootstrapState)(nil), // 9: s3_lifecycle_pb.BootstrapState
|
|
(*ReaderState)(nil), // 10: s3_lifecycle_pb.ReaderState
|
|
(*FilerShardCursorList)(nil), // 11: s3_lifecycle_pb.FilerShardCursorList
|
|
(*TailDrainedKey)(nil), // 12: s3_lifecycle_pb.TailDrainedKey
|
|
(*BlockerRecord)(nil), // 13: s3_lifecycle_pb.BlockerRecord
|
|
(*StreamKey)(nil), // 14: s3_lifecycle_pb.StreamKey
|
|
(*OriginalKey)(nil), // 15: s3_lifecycle_pb.OriginalKey
|
|
(*PredicateKey)(nil), // 16: s3_lifecycle_pb.PredicateKey
|
|
(*BootstrapKey)(nil), // 17: s3_lifecycle_pb.BootstrapKey
|
|
(*PendingKey)(nil), // 18: s3_lifecycle_pb.PendingKey
|
|
(*RetryBudgetEntry)(nil), // 19: s3_lifecycle_pb.RetryBudgetEntry
|
|
(*RetryTarget)(nil), // 20: s3_lifecycle_pb.RetryTarget
|
|
nil, // 21: s3_lifecycle_pb.ReaderState.LastProcessedOriginalEntry
|
|
}
|
|
var file_s3_lifecycle_proto_depIdxs = []int32{
|
|
4, // 0: s3_lifecycle_pb.FilerShardCursor.position:type_name -> s3_lifecycle_pb.MessagePosition
|
|
0, // 1: s3_lifecycle_pb.LifecycleState.action_kind:type_name -> s3_lifecycle_pb.ActionKind
|
|
2, // 2: s3_lifecycle_pb.LifecycleState.mode:type_name -> s3_lifecycle_pb.LifecycleState.RuleMode
|
|
3, // 3: s3_lifecycle_pb.LifecycleState.degraded_reason:type_name -> s3_lifecycle_pb.LifecycleState.DegradedReason
|
|
6, // 4: s3_lifecycle_pb.PendingItem.expected_identity:type_name -> s3_lifecycle_pb.EntryIdentity
|
|
21, // 5: s3_lifecycle_pb.ReaderState.last_processed_original:type_name -> s3_lifecycle_pb.ReaderState.LastProcessedOriginalEntry
|
|
5, // 6: s3_lifecycle_pb.ReaderState.last_processed_predicate:type_name -> s3_lifecycle_pb.FilerShardCursor
|
|
12, // 7: s3_lifecycle_pb.ReaderState.tail_drained_streams:type_name -> s3_lifecycle_pb.TailDrainedKey
|
|
5, // 8: s3_lifecycle_pb.FilerShardCursorList.cursors:type_name -> s3_lifecycle_pb.FilerShardCursor
|
|
1, // 9: s3_lifecycle_pb.TailDrainedKey.stream_kind:type_name -> s3_lifecycle_pb.StreamKind
|
|
1, // 10: s3_lifecycle_pb.BlockerRecord.stream_kind:type_name -> s3_lifecycle_pb.StreamKind
|
|
4, // 11: s3_lifecycle_pb.BlockerRecord.position:type_name -> s3_lifecycle_pb.MessagePosition
|
|
0, // 12: s3_lifecycle_pb.BlockerRecord.action_kind:type_name -> s3_lifecycle_pb.ActionKind
|
|
15, // 13: s3_lifecycle_pb.StreamKey.original:type_name -> s3_lifecycle_pb.OriginalKey
|
|
16, // 14: s3_lifecycle_pb.StreamKey.predicate:type_name -> s3_lifecycle_pb.PredicateKey
|
|
17, // 15: s3_lifecycle_pb.StreamKey.bootstrap:type_name -> s3_lifecycle_pb.BootstrapKey
|
|
18, // 16: s3_lifecycle_pb.StreamKey.pending:type_name -> s3_lifecycle_pb.PendingKey
|
|
4, // 17: s3_lifecycle_pb.OriginalKey.position:type_name -> s3_lifecycle_pb.MessagePosition
|
|
4, // 18: s3_lifecycle_pb.PredicateKey.position:type_name -> s3_lifecycle_pb.MessagePosition
|
|
0, // 19: s3_lifecycle_pb.BootstrapKey.action_kind:type_name -> s3_lifecycle_pb.ActionKind
|
|
0, // 20: s3_lifecycle_pb.PendingKey.action_kind:type_name -> s3_lifecycle_pb.ActionKind
|
|
14, // 21: s3_lifecycle_pb.RetryBudgetEntry.key:type_name -> s3_lifecycle_pb.StreamKey
|
|
14, // 22: s3_lifecycle_pb.RetryTarget.key:type_name -> s3_lifecycle_pb.StreamKey
|
|
0, // 23: s3_lifecycle_pb.RetryTarget.action_kind:type_name -> s3_lifecycle_pb.ActionKind
|
|
11, // 24: s3_lifecycle_pb.ReaderState.LastProcessedOriginalEntry.value:type_name -> s3_lifecycle_pb.FilerShardCursorList
|
|
25, // [25:25] is the sub-list for method output_type
|
|
25, // [25:25] is the sub-list for method input_type
|
|
25, // [25:25] is the sub-list for extension type_name
|
|
25, // [25:25] is the sub-list for extension extendee
|
|
0, // [0:25] is the sub-list for field type_name
|
|
}
|
|
|
|
func init() { file_s3_lifecycle_proto_init() }
|
|
func file_s3_lifecycle_proto_init() {
|
|
if File_s3_lifecycle_proto != nil {
|
|
return
|
|
}
|
|
file_s3_lifecycle_proto_msgTypes[10].OneofWrappers = []any{
|
|
(*StreamKey_Original)(nil),
|
|
(*StreamKey_Predicate)(nil),
|
|
(*StreamKey_Bootstrap)(nil),
|
|
(*StreamKey_Pending)(nil),
|
|
}
|
|
type x struct{}
|
|
out := protoimpl.TypeBuilder{
|
|
File: protoimpl.DescBuilder{
|
|
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
|
|
RawDescriptor: unsafe.Slice(unsafe.StringData(file_s3_lifecycle_proto_rawDesc), len(file_s3_lifecycle_proto_rawDesc)),
|
|
NumEnums: 4,
|
|
NumMessages: 18,
|
|
NumExtensions: 0,
|
|
NumServices: 0,
|
|
},
|
|
GoTypes: file_s3_lifecycle_proto_goTypes,
|
|
DependencyIndexes: file_s3_lifecycle_proto_depIdxs,
|
|
EnumInfos: file_s3_lifecycle_proto_enumTypes,
|
|
MessageInfos: file_s3_lifecycle_proto_msgTypes,
|
|
}.Build()
|
|
File_s3_lifecycle_proto = out.File
|
|
file_s3_lifecycle_proto_goTypes = nil
|
|
file_s3_lifecycle_proto_depIdxs = nil
|
|
}
|