queue

type Batch struct {
	Tasks      []Task
	Ctx        context.Context
	OnDone     func()
	OnCanceled func()
	// contains filtered or unexported fields
}

type BeforeScheduleHook interface {
	BeforeSchedule() bool
}

type DiskQueue struct {
	// Logger for the queue. Wrappers of this queue should use this logger.
	Logger logrus.FieldLogger
	// contains filtered or unexported fields
}

type DiskQueueOptions struct {
	// Required
	ID          string
	Scheduler   *Scheduler
	Dir         string
	TaskDecoder TaskDecoder

	// Optional
	Logger           logrus.FieldLogger
	StaleTimeout     time.Duration
	InactivityPeriod time.Duration
	ChunkSize        uint64
	OnBatchProcessed func()
	Metrics          *Metrics
}

type Metrics struct {
	// contains filtered or unexported fields
}

type Queue interface {
	ID() string
	Size() int64
	DequeueBatch() (batch *Batch, err error)
	Metrics() *Metrics
}

type Scheduler struct {
	SchedulerOptions
	// contains filtered or unexported fields
}

type SchedulerOptions struct {
	Logger logrus.FieldLogger
	// Number of workers to process tasks. Defaults to the number of CPUs - 1.
	Workers int
	// The interval at which the scheduler checks the queues for tasks. Defaults to 1 second.
	ScheduleInterval time.Duration
	// The interval between retries for failed tasks.
	RetryInterval time.Duration
	// Function to be called when the scheduler is closed
	OnClose func()
}

type Task interface {
	// Op returns a uint8 representing the operation type of the task.
	// It is used for compressing tasks that implement the optional TaskGrouper interface.
	Op() uint8
	// Key returns a uint64 that can be used to influence task partitioning.
	// Tasks are assigned to workers based on the hash of their key, to ensure
	// that tasks with the same key are always processed by the same worker.
	// Implementations can also return a constant value to make sure all tasks are
	// processed by the same worker (e.g. for operations that must be serialized, like HFresh Merge operation).
	Key() uint64
	// Execute is called by a worker to process the task.
	// If a task returns a transient error from Execute (e.g. canceled context, not enough memory, etc.),
	// it will be retried using an exponential backoff strategy.
	// Otherwise, the error will be considered permanent and the task will not be retried.
	Execute(ctx context.Context) error
}

type TaskDecoder interface {
	DecodeTask([]byte) (Task, error)
}

type TaskGrouper interface {
	NewGroup(op uint8, tasks ...Task) Task
}

type Worker struct {
	// contains filtered or unexported fields
}