runner

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 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) 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 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) 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 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 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
}