concurrent

type BatchOpts struct {
	// Concurrency specificies the maximum number of goroutines
	// that will be used to run all the operations in the batch
	Concurrency int
}

type BatchResult struct {
	Result
	// contains filtered or unexported fields
}

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

type CreateWorkerEvent struct {
	Key   string
	Value interface{}
	Opts  *CreateWorkerOpts
}

type CreateWorkerOpts struct {
	// WorkerHandler is the handler used by the worker to handle
	// incoming requests
	WorkerHandler WorkerHandler

	// ErrC is an error channel the worker can listen to and report errors
	// though events in case they happen
	ErrC <-chan error

	// UserData is data that the user can attach to the worker in case any
	// external context is required
	UserData interface{}

	// MaxInactivity is the maximum time the worker is allowed to exist
	// without serving any request. When this time expires the worker
	// should destroy itself
	MaxInactivity time.Duration
}

type DestroyWorkerEvent struct {
	Worker *Worker
	Key    string
}

type ErrCannotRecover struct {
	Cause error
}

type ErrMaxAttemptsReached struct {
	Causes []error
}

type ErrNoOccurrence struct{}

type ErrorWorkerEvent struct {
	Worker *Worker
	Error  error
}

type Master struct {

	// Error is set in case of exiting with an error
	Error error
	// contains filtered or unexported fields
}

type MasterEvent interface {
	WorkerKey() string
}

type MasterHandler interface {
	Handle(ctx context.Context, ev MasterEvent) error
}

type MasterHandlerFunc func(ctx context.Context, ev MasterEvent) error

type MasterOpts struct {
	// MasterHandler is the handler the master will use to provide access
	// to the master events
	MasterHandler MasterHandler

	// CreateWorkerOnRequest creates a worker if a request is received by
	// a worker and the worker was not created beforehand. Should only be
	// used if a worker does not need a specific request passed on to the
	// CreateWorkerEvent handler
	CreateWorkerOnRequest bool
}

type PoolInput struct {
	OutC     chan<- PoolResult
	Supplier Supplier
}

type PoolOpts struct {
	// Concurrency is the number of Suppliers that the pool can
	// run in parallel at most
	Concurrency int
}

type PoolResult struct {
	Result
}

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

type RequestWorkerEvent struct {
	Worker *Worker
	Value  interface{}
}

type Response struct {
	Value interface{}
	Key   string
	Error error
}

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

type RetryOpts struct {
	// Random sets the retry to wait a random time based on the
	// exponential back off
	Random bool

	// UnlimitedAttempts when set to true, Attempts will be ignored
	// and the action will be retried until it succeeds or the context
	// stops
	UnlimitedAttempts bool

	// Attempts is the maximum number of attempts allowed by a
	// Retry operation
	Attempts uint8

	// BaseExp is the base exponent for the calculation of the next
	// time an attempt must be triggered using exponential backoff
	BaseExp uint8

	// BaseTimeout is the initial timeout used after the first
	// attempt fails
	BaseTimeout time.Duration

	// MaxRetryTimeout sets an upper bound into the time that
	// the retry will wait until attempting an operation again.
	MaxRetryTimeout time.Duration
}

type Supplier interface {
	Supply() (interface{}, error)
}

type SupplierFunc func() (interface{}, error)

type Worker struct {

	// SharedC is the shared channel between the master and the worker
	// for requests met by the worker who is available
	SharedC <-chan executeRequest

	// C is the channel the worker only reads from
	C chan workerRequest

	// ShutdownC is a channel used by the worker to signal that it
	// has been completely shutdown and removed
	ShutdownC chan error

	// ErrC is an error channel the worker can listen to and report errors
	// though events in case they happen
	ErrC <-chan error

	// UserData is data that the user can attach to the worker in case any
	// external context is required
	UserData interface{}
	// contains filtered or unexported fields
}

type WorkerEvent interface {
	GetWorker() *Worker
}

type WorkerHandler interface {
	Handle(ctx context.Context, req WorkerEvent) (interface{}, error)
}

type WorkerHandlerFunc func(ctx context.Context, ev WorkerEvent) (interface{}, error)

type WorkerOpts struct {
	// Key that uniquely identifies the worker
	Key string

	// DoneC is a write once channel the worker uses to notify the master
	// that the worker has exited
	DoneC chan<- workerDestroyed

	// WorkerHandler is the handler used by the worker to handle
	// incoming requests
	WorkerHandler WorkerHandler

	// C is the channel the worker gets requests from
	C chan workerRequest

	// ErrC is an error channel the worker can listen to and report errors
	// though events in case they happen
	ErrC <-chan error

	// SharedC is the shared channel between the master and the worker
	// for requests met by the worker who is available
	SharedC <-chan executeRequest

	// UserData is data that the user can attach to the worker in case any
	// external context is required
	UserData interface{}

	// MaxInactivity is the maximum time the worker is allowed to exist
	// without serving any request. When this time expires the worker
	// should destroy itself
	MaxInactivity time.Duration
}