common

type Backoff ¶

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

Backoff tracks per-key exponential backoff state. It is safe for concurrent use.

func NewBackoff(config BackoffConfig) *Backoff

func (b *Backoff) RecordFailure(key string)

func (b *Backoff) RecordSuccess(key string)

func (b *Backoff) ShouldRetry(key string) bool

type BackoffConfig ¶

type BackoffConfig struct {
	// Initial is the initial backoff duration after the first failure.
	Initial time.Duration
	// Multiplier is the geometric progression factor applied on each failure.
	Multiplier float64
	// Max is the maximum backoff duration.
	Max time.Duration
	// JitterFrac adds randomization to prevent thundering herd. A value of 0.2
	// means the actual delay is within ±20% of the computed backoff.
	JitterFrac float64
}

BackoffConfig configures the exponential backoff parameters.

func DefaultBackoffConfig() BackoffConfig

type Controller ¶

type Controller interface {
	// NewInstanceJWTToken returns a new instance JWT token used by runners to identify themselves
	// against the GARM API. Instance names are unique.
	NewInstanceJWTToken(instanceName string) (string, error)
}

type ToolsGetter ¶

type ToolsGetter interface {
	GetTools() ([]commonParams.RunnerApplicationDownload, error)
}

type UnboundedChan ¶

type UnboundedChan[T any] struct {
	// contains filtered or unexported fields
}

UnboundedChan provides an unbounded FIFO channel backed by an internal slice-based queue. A router goroutine absorbs sends into the queue immediately and feeds them to the output one at a time. This ensures the producer is never blocked (beyond a brief channel send), while the consumer processes events sequentially. In theory, this does have the potential to grow forever but in practice it should not happen as we consume the queue and process it. Regardless of result, the queue should shrink. The only way this never shrinks is if the consumer is deadlocked for whatever reason.

Use In() to send events and Out() to receive them.

func NewUnboundedChan[T any](ctx context.Context, quit <-chan struct{}) *UnboundedChan[T]

func (u *UnboundedChan[T]) In() chan<- T

func (u *UnboundedChan[T]) Out() <-chan T

func (u *UnboundedChan[T]) Process(handler func(T))