executor

type AttemptResult int

type CallbackFunc func(Try)

type DelayFunc func(int) time.Duration

type DelayType string

type DiagnosticsCallback interface {
	// A task was accepted for execution. The value is the "width"
	// of the task. The width is one for calls to Exec or
	// ExecAndForget, and the number of Funcs passed to ExecMany
	// or ExecGathered.
	TaskStarted(int)

	// A task completed. The duration is the total time taken
	// executing the task, including delays between retries. Each
	// Func passed to ExecMany or ExecGathered will trigger a call
	// to this function.
	TaskCompleted(AttemptResult, time.Duration)

	// An attempt was started. The duration is the delay between
	// time an attempt was scheduled to start and when it actually
	// started. The attempt may time out before the actual Func is
	// invoked.
	AttemptStarted(time.Duration)

	// An attempt completed. The duration is the amount of time
	// spent executing the attempt.
	AttemptCompleted(AttemptResult, time.Duration)

	// The amount of time spent executing a task's callback.
	CallbackDuration(time.Duration)
}

type Executor interface {
	// Invoke the Func, possibly in parallel with other
	// invocations. The function's result is ignored.
	ExecAndForget(Func)

	// Invoke the Func, possibly in parallel with other
	// invocations. Calls back with the result of the call at some
	// future point.
	Exec(Func, CallbackFunc)

	// Invoke the given Funcs, possibly in parallel with other
	// invocations. Calls back with the result of each invocation
	// at some future point. If no Funcs are given, the callback
	// is never invoked.
	ExecMany([]Func, ManyCallbackFunc)

	// Invoke the given Funcs, as in ExecMany. Calls back with a
	// Try containing an []interface{} of the successful results
	// or the first error encountered. If no Funcs are given,
	// the callback is invoked with an empty []interface{}.
	ExecGathered([]Func, CallbackFunc)

	// Stop executor activity and release related resources. In
	// progress actions will complete their current
	// attempt. Pending actions and retries are dropped and
	// callbacks are not invoked.
	Stop()

	// Sets the DiagnosticsCallback for this Executor. Must be
	// called before the first invocation of any Exec
	// function. See also the WithDiagnostics Option to
	// NewRetryingExecutor and NewGoroutineExecutor.
	SetDiagnosticsCallback(DiagnosticsCallback)
}

type FromFlags interface {
	// Returns the configured Executor. Multiple invocations
	// return the same Executor even if the arguments
	// change. DiagnosticsCallback may be nil.
	Make(*log.Logger) Executor
}

type FromFlagsDefaults struct {
	DelayType      DelayType
	InitialDelay   time.Duration
	MaxDelay       time.Duration
	MaxAttempts    int
	Parallelism    int
	Timeout        time.Duration
	AttemptTimeout time.Duration
}

type Func func(context.Context) (interface{}, error)

type ManyCallbackFunc func(int, Try)

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

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

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

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

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

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

type Option func(*commonExec)

type Try interface {
	// if true, the computation produced a return value
	IsReturn() bool

	// if true, the computation resulted in failure
	IsError() bool

	// Get returns the successul result of the computation.
	// All calls to Get should be guarded by IsReturn; if the computation
	// produced an error, calls to Get will panic.
	Get() interface{}

	// Error returns the error that caused the compuation to fail.
	// All calls to Error should be guarded by IsError; if the computation
	// succeeded, calls to Error will panic.
	Error() error
}