jobs

type Controller interface {
	// Start starts a controller that reports errors on errCh and
	// optionally stopped status on shutdownCh if the channel is provided.
	// The controller blokcs waiting on tasks in its queue untill
	// interrupted by context (ctx) or a Shutdown/Stop function call.
	Start(ctx context.Context, errCh chan<- error, shutdownCh chan struct{})
	// Enqueue adds a task to this controller's queue for workers to
	// process. The function is non-blocking and can be interrupted by
	// context.
	Enqueue(ctx context.Context, task interface{})
	// Shutdown will singal a started controller to quit waiting continuously
	// for task and work on tasks until its queue is drained, then exit.
	// The shutdownCh parameter is an optional channel to notify when
	// shutdown is complete.
	Stop(shutdownCh chan struct{})
	// Stops the controller and its workers, regardless of whether there
	// are tasks in the queue waiting processing.
	Shutdown()
}

type Job struct {
	// ID is job identifier used in log messages
	ID string
	// MaxWorkers is the maximum number of workers processing a batch of tasks in parallel
	MaxWorkers int
	// MinWorkers is the minimum number of workers processing a batch of tasks in parallel
	MinWorkers int
	// Worker for processing tasks
	Worker Worker
	// FailFast controls the behavior of this Job upon errors. If set to true, it will quit
	// further processing upon the first error that occurs. For fault tolerant applications
	// use false.
	FailFast bool
	// WorkQueue is the queue for tasks picked up by the workers in this Job. The Dispatch
	// method will feed its tasks argument elements to the queue, and it may be fed
	// from other sources in parallel, including the workers.
	Queue WorkQueue
	// IsWorkerExitsOnEmptyQueue controls whether a worker exits right after its Work function is
	// done and no more tasks are available in the queue, or will loop waiting for more tasks.
	// Note that this flag does not prevent the worker from block waiting for a task. This
	// can be interrupted only by the workqueue with a task or stop signal. However, after a taks
	// is processed it will be consulted whether to continue or exit before block waiting for
	// another.
	IsWorkerExitsOnEmptyQueue bool
}

type WorkQueue interface {
	// Get block waits for items from the workqueue and
	// returns an item .
	Get() interface{}
	// Stops sends a stop signal to thework queue
	Stop() bool
	// Add adds a task to this workqueue
	Add(task interface{})
	// Count returns the current number of items in the queue
	Count() int
}

type Worker interface {
	// Work processes the task within the given context.
	Work(ctx context.Context, task interface{}, wq WorkQueue) *WorkerError
}

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

type WorkerFunc func(ctx context.Context, task interface{}, wq WorkQueue) *WorkerError