workqueue

type Client interface {
	WorkqueueServiceClient

	Close() error
}

type DeadLetteredKey interface {
	Key

	// GetFailedTime returns the time when the key was dead-lettered.
	GetFailedTime() time.Time

	// GetAttempts returns the number of attempts before the key was dead-lettered.
	GetAttempts() int
}

type GetKeyStateRequest struct {

	// The key to retrieve information for
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// contains filtered or unexported fields
}

type InProgressKey interface {
	Key

	// Requeue returns this key to the queue.
	Requeue(context.Context) error

	// RequeueWithOptions returns this key to the queue with custom options.
	RequeueWithOptions(context.Context, Options) error
}

type Interface interface {
	// Identity returns the identity recorded as the owner of keys started by
	// this queue, or an empty string if no identity was configured.
	Identity() string

	// Queue adds an item to the workqueue.
	Queue(ctx context.Context, key string, opts Options) error

	// Enumerate returns:
	// - a list of all of the in-progress keys,
	// - a list of the next "N" keys in the queue (according to its configured ordering),
	// - a list of all dead-lettered keys, or
	// - an error if the workqueue is unable to enumerate the keys.
	Enumerate(ctx context.Context) ([]ObservedInProgressKey, []QueuedKey, []DeadLetteredKey, error)

	// Get retrieves the current state and metadata for a specific key.
	Get(ctx context.Context, key string) (*KeyState, error)
}

type Key interface {
	// Name is the name of the key.
	Name() string

	// Priority is the priority of the key.
	Priority() int64
}

type KeyState struct {

	// The key name
	Key    string          `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Status KeyState_Status `protobuf:"varint,2,opt,name=status,proto3,enum=chainguard.workqueue.KeyState_Status" json:"status,omitempty"`
	// Priority of the key (if queued or in progress)
	Priority int64 `protobuf:"varint,3,opt,name=priority,proto3" json:"priority,omitempty"`
	// Number of attempts made (if in progress)
	Attempts int32 `protobuf:"varint,4,opt,name=attempts,proto3" json:"attempts,omitempty"`
	// Time when the key was first queued
	QueuedTime int64 `protobuf:"varint,5,opt,name=queued_time,json=queuedTime,proto3" json:"queued_time,omitempty"`
	// Time when the key should be processed (NotBefore)
	NotBeforeTime int64 `protobuf:"varint,6,opt,name=not_before_time,json=notBeforeTime,proto3" json:"not_before_time,omitempty"`
	// contains filtered or unexported fields
}

type KeyState_Status int32

type NoRetryDetails struct {
	Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` // A message describing why the key should not be retried.
	// contains filtered or unexported fields
}

type ObservedInProgressKey interface {
	InProgressKey

	// Owner returns the identity recorded when the key was claimed, or an empty
	// string if no owner was recorded.
	Owner() string

	// IsOrphaned checks whether the key has been orphaned by it's owner.
	IsOrphaned() bool
}

type Options struct {
	// Priority is the priority of the key.
	// Higher values are processed first.
	Priority int64

	// NotBefore is the earliest time that the key should be processed.
	// When deduplicating, the earliest time is used unless NotBeforeFloor is set
	// on the queued entry (see NotBeforeFloor).
	NotBefore time.Time

	// Delay is an optional duration to wait before processing the key.
	// This is used when requeueing with a custom delay.
	Delay time.Duration

	// BackoffDelay is an optional duration to wait before reprocessing a key
	// on a failure retry. Unlike Delay it does NOT reset the attempt count,
	// so the dispatcher's attempts >= maxRetry dead-letter cutoff keeps
	// firing, and it is applied regardless of priority. When zero (the
	// default) the requeue path is unchanged: callers that never set it get
	// the existing linear/priority backoff behavior. A caller that wants
	// custom failure-retry backoff (e.g. decorrelated exponential jitter)
	// computes the delay itself and passes it here, leaving the attempt
	// counter intact. Takes precedence over Delay and the priority backoff
	// when set.
	BackoffDelay time.Duration

	// NotBeforeFloor, when true, marks NotBefore as a floor that a non-floor
	// enqueue of the same key cannot dedup to an earlier time. Merge rules for a
	// queued entry:
	//   - a floored enqueue over a non-floored entry replaces its NotBefore
	//     outright (in either direction) and marks it floored — the non-floored
	//     time was undercuttable anyway;
	//   - a floored enqueue over a floored entry takes the later NotBefore;
	//   - a non-floor enqueue over a floored entry leaves it untouched (neither
	//     earlier nor later);
	//   - between two non-floor enqueues the earliest NotBefore wins (the default).
	// Set via RequeueNotBefore.
	NotBeforeFloor bool
}

type OwnedInProgressKey interface {
	InProgressKey

	// Complete marks the key as successfully completed, and removes it from
	// the in-progress key set.
	Complete(context.Context) error

	// Deadletter permanently removes this key from the queue, indicating it has
	// failed after exceeding the maximum retry attempts.
	Deadletter(context.Context) error

	// GetAttempts returns the current attempt count for the key.
	GetAttempts() int

	// Context is the context of the process heartbeating the key.
	Context() context.Context
}

type ProcessRequest struct {

	// The key of the work item
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// The (optional) priority of the work item, where higher numbers are processed first.
	Priority int64 `protobuf:"varint,2,opt,name=priority,proto3" json:"priority,omitempty"`
	// The (optional) delay in second to wait before processing the work item.
	DelaySeconds int64 `protobuf:"varint,3,opt,name=delay_seconds,json=delaySeconds,proto3" json:"delay_seconds,omitempty"`
	// contains filtered or unexported fields
}

type ProcessResponse struct {

	// Optional: If set, indicates the work item should be requeued after the specified delay.
	// If not set or 0, the default behavior applies (success if no error, or exponential backoff on error).
	// This field is only honored when the RPC returns successfully (no error).
	RequeueAfterSeconds int64 `protobuf:"varint,1,opt,name=requeue_after_seconds,json=requeueAfterSeconds,proto3" json:"requeue_after_seconds,omitempty"`
	// Optional: When true, requeue_after_seconds is treated as a floor that a
	// subsequent enqueue cannot pull earlier (RequeueNotBefore semantics), rather
	// than an undercuttable delay (RequeueAfter). Only meaningful when
	// requeue_after_seconds > 0.
	RequeueFloor bool `protobuf:"varint,3,opt,name=requeue_floor,json=requeueFloor,proto3" json:"requeue_floor,omitempty"`
	// Optional: Additional keys to queue as a result of processing this item.
	// These keys are queued BEFORE the current key is completed, ensuring dependent
	// work is guaranteed to be queued before we mark the triggering work as done.
	// If any queue operation fails, the current key will be retried.
	QueueKeys []*QueueKeyRequest `protobuf:"bytes,2,rep,name=queue_keys,json=queueKeys,proto3" json:"queue_keys,omitempty"`
	// contains filtered or unexported fields
}

type QueueKey struct {
	Key          string
	Priority     int64
	DelaySeconds int64
}

type QueueKeyRequest struct {

	// The key to queue.
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// Optional priority (default: 0). Higher values are processed first.
	Priority int64 `protobuf:"varint,2,opt,name=priority,proto3" json:"priority,omitempty"`
	// Optional delay in seconds before the key becomes eligible for processing.
	DelaySeconds int64 `protobuf:"varint,3,opt,name=delay_seconds,json=delaySeconds,proto3" json:"delay_seconds,omitempty"`
	// contains filtered or unexported fields
}

type QueuedKey interface {
	Key

	// Start initiates processing of the key, returning an OwnedInProgressKey
	// on success and an error on failure.
	Start(context.Context) (OwnedInProgressKey, error)
}

type UnimplementedWorkqueueServiceServer struct{}

type UnsafeWorkqueueServiceServer interface {
	// contains filtered or unexported methods
}

type WorkqueueServiceClient interface {
	Process(ctx context.Context, in *ProcessRequest, opts ...grpc.CallOption) (*ProcessResponse, error)
	GetKeyState(ctx context.Context, in *GetKeyStateRequest, opts ...grpc.CallOption) (*KeyState, error)
}

type WorkqueueServiceServer interface {
	Process(context.Context, *ProcessRequest) (*ProcessResponse, error)
	GetKeyState(context.Context, *GetKeyStateRequest) (*KeyState, error)
	// contains filtered or unexported methods
}