runner

type ControlAwareCommander ¶ added in v0.15.0

type ControlAwareCommander[T any] interface {
	ExecuteWithControl(ctx context.Context, msg T, ctl ExecutionControl) error
}

ControlAwareCommander extends command execution with execution-control support.

type DeadlineGetter ¶ added in v0.1.0

type DeadlineGetter interface {
	GetDeadline() time.Time
}

type DoneHandlerGetter ¶ added in v0.1.0

type DoneHandlerGetter interface {
	GetDoneHandler() func(*Handler)
}

type ErrorHandlerGetter ¶ added in v0.1.0

type ErrorHandlerGetter interface {
	GetErrorHandler() func(error)
}

type ExecutionControl ¶ added in v0.15.0

type ExecutionControl interface {
	WaitIfPaused(ctx context.Context) error
	Done() <-chan struct{}
	CancelCause() error
}

ExecutionControl provides cooperative execution control for handlers.

type ExitOnErrorGetter ¶ added in v0.3.0

type ExitOnErrorGetter interface {
	GetExitOnError() bool
}

type ExponentialBackoffStrategy ¶

type ExponentialBackoffStrategy struct {
	// Base is the starting delay (e.g., 100ms)
	Base time.Duration
	// Factor is multiplied each iteration (e.g., 2 => 100ms, 200ms, 400ms, ...)
	Factor float64
	// Max is the maximum delay allowed (caps the exponential growth)
	Max time.Duration
}

ExponentialBackoffStrategy implements a backoff strategy. Usage example:

WithRetryStrategy(ExponentialBackoffStrategy{
    Base:   100 * time.Millisecond,
    Factor: 2,
    Max:    5 * time.Second,
})

func (e ExponentialBackoffStrategy) Decide(attempt int, err error) RetryDecision

func (e ExponentialBackoffStrategy) SleepDuration(attempt int, _ error) time.Duration

type Handler ¶

type Handler struct {
	EntryID int
	// contains filtered or unexported fields
}

Handler wraps configuration options so that we can later call a function with known behavior in terms of handling errors, rtries, timeouts, etc We do so by providing a Run method:

Run(ctx context.Context, fn func(context.Context) error)

This ensures consistent execution behavior

func NewHandler(opts ...Option) *Handler

func (h *Handler) Run(ctx context.Context, fn func(context.Context) error) error

func (h *Handler) ShouldStopOnErr() bool

type Logger ¶

type Logger interface {
	Info(msg string, args ...any)
	Error(msg string, args ...any)
}

Logger interface shared across packages

type LoggerGetter ¶ added in v0.1.0

type LoggerGetter interface {
	GetLogger() Logger
}

type ManualExecutionControl ¶ added in v0.15.0

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

ManualExecutionControl is a cooperative control implementation useful for orchestration and tests.

func NewManualExecutionControl() *ManualExecutionControl

func (c *ManualExecutionControl) Cancel(cause error)

func (c *ManualExecutionControl) CancelCause() error

func (c *ManualExecutionControl) Done() <-chan struct{}

func (c *ManualExecutionControl) Pause()

func (c *ManualExecutionControl) Resume()

func (c *ManualExecutionControl) WaitIfPaused(ctx context.Context) error

type MaxRetriesGetter ¶ added in v0.1.0

type MaxRetriesGetter interface {
	GetMaxRetries() int
}

type MaxRunsGetter ¶ added in v0.1.0

type MaxRunsGetter interface {
	GetMaxRuns() int
}

type Middleware ¶ added in v0.3.0

type Middleware func(next func(context.Context) error) func(context.Context) error

Middleware defines a function that wraps/enhances the behavior of a handler function. It allows you to intercept and modify the execution of the function passed to Handler.Run (business logic) without changing its implementation. Each middleware receives the next function in the chain and returns a new function that can perform additional actions before or after calling the next function. This pattern enables composable concerns such as logging, telemetry, authentication, retry logic, in a clean and decoupled manner, similar to middleware in HTTP routers or RPC frameworks.

type NoDelayStrategy ¶

type NoDelayStrategy struct{}

NoDelayStrategy is a simple retry strategy that performs all retries immediately without waiting.

func (n NoDelayStrategy) Decide(_ int, _ error) RetryDecision

func (n NoDelayStrategy) SleepDuration(_ int, _ error) time.Duration

type Option ¶

type Option func(*Handler)

func WithConfigurator(i interface{}) Option

func WithDeadline(d time.Time) Option

func WithDeadlineSetter(s DeadlineGetter) Option

func WithDoneHandler(d func(*Handler)) Option

func WithDoneHandlerSetter(s DoneHandlerGetter) Option

func WithErrorHandler(h func(error)) Option

func WithErrorHandlerSetter(s ErrorHandlerGetter) Option

func WithExecutionControl(control ExecutionControl) Option

func WithExitOnError(exit bool) Option

func WithExitOnErrorSetter(s ExitOnErrorGetter) Option

func WithLogger(l Logger) Option

func WithLoggerSetter(s LoggerGetter) Option

func WithMaxRetries(max int) Option

func WithMaxRetriesSetter(s MaxRetriesGetter) Option

func WithMaxRuns(max int) Option

func WithMaxRunsSetter(s MaxRunsGetter) Option

func WithMiddleware(mw ...Middleware) Option

func WithNoTimeout() Option

func WithRetryStrategy(s RetryStrategy) Option

func WithRetryStrategySetter(s RetryStrategyGetter) Option

func WithRunOnce(once bool) Option

func WithRunOnceSetter(s RunOnceGetter) Option

func WithTimeout(t time.Duration) Option

func WithTimeoutSetter(s TimeoutGetter) Option

type RetryDecider ¶ added in v0.15.0

type RetryDecider interface {
	Decide(attempt int, err error) RetryDecision
}

RetryDecider is an optional richer strategy contract.

type RetryDecision ¶ added in v0.15.0

type RetryDecision struct {
	ShouldRetry bool
	Delay       time.Duration
	Metadata    map[string]any
}

RetryDecision captures retry decision outputs for one failed attempt.

func DecideRetry(strategy RetryStrategy, attempt int, err error) RetryDecision

type RetryStrategy ¶

type RetryStrategy interface {
	// SleepDuration returns how long to wait before the next retry attempt.
	// The attempt index starts at 0, incrementing after each failure.
	SleepDuration(attempt int, err error) time.Duration
}

RetryStrategy encapsulates the decision and delay between retries.

type RetryStrategyGetter ¶ added in v0.1.0

type RetryStrategyGetter interface {
	GetRetryStrategy() RetryStrategy
}

type RunOnceGetter ¶ added in v0.1.0

type RunOnceGetter interface {
	GetRunOnce() bool
}

type TimeoutGetter ¶ added in v0.1.0

type TimeoutGetter interface {
	GetTimeout() time.Duration
}