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 {
	// 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

	// 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 oldest time is used.
	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
}

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"`
	// 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
}