component

type Component ¶

type Component interface {
	Name() string
	Paused() bool

	IntervalElapsed() bool

	Reload() (bool, error)
	UpdateLastRan() error
}

type Coordinator ¶

type Coordinator struct {
	Locker    lock.LockFactory
	Component Component
	Runnable  Runnable
}

Coordinator ensures that the given component is not executed concurrently.

func (coordinator *Coordinator) RunImmediately(ctx context.Context)

func (coordinator *Coordinator) RunPeriodically(ctx context.Context)

type Drainable ¶

type Drainable interface {
	// Drain is invoked on shutdown.
	Drain(context.Context)
}

Drainable is an optional interface which component runners can implement in order to perform something on shutdown.

type NotificationsBus ¶

type NotificationsBus interface {
	Listen(string) (chan bool, error)
	Unlisten(string, chan bool) error
}

type RunFunc ¶

type RunFunc func(context.Context) error

RunFunc turns a simple function into a Runnable.

func (f RunFunc) Run(ctx context.Context) error

type Runnable ¶

type Runnable interface {
	// Run is invoked repeatedly. The component should perform whatever work is
	// available and return.
	Run(context.Context) error
}

Runnable represents a workload to execute.

type Runner ¶

type Runner struct {
	Logger lager.Logger

	Interval  time.Duration
	Component Component
	Bus       NotificationsBus

	Schedulable Schedulable
}

Runner runs a workload periodically, or immediately upon receiving a notification.

func (scheduler *Runner) Run(signals <-chan os.Signal, ready chan<- struct{}) error

type Schedulable ¶

type Schedulable interface {
	RunPeriodically(context.Context)
	RunImmediately(context.Context)
}

Schedulable represents a workload that is executed normally on a periodic schedule, but can also be run immediately.