worker

Documentation

Index

• Constants
• Variables
• func NewNoOpWorker() worker.Worker
• func NewPeriodicWorker(call PeriodicWorkerCall, period time.Duration, timerFunc NewTimerFunc, ...) worker.Worker
• func NewSimpleWorker(doWork func(stopCh <-chan struct{}) error) worker.Worker
• type FinishedWorker
  • func (w FinishedWorker) Kill()
  • func (w FinishedWorker) Wait() error
• type NewTimerFunc
• type PeriodicTimer
  • func NewTimer(d time.Duration) PeriodicTimer
• type PeriodicWorkerCall
• type PeriodicWorkerOption
  • func Jitter(amount float64) PeriodicWorkerOption
• type Runner
• type Timer
  • func (t *Timer) CountDown() <-chan time.Time
  • func (t *Timer) Reset(d time.Duration) bool

Constants

const RestartDelay = 3 * time.Second

RestartDelay holds the length of time that a worker will wait between exiting and restarting.

Variables

var (
	ErrRestartAgent    = errors.New("agent should be restarted")
	ErrTerminateAgent  = errors.New("agent should be terminated")
	ErrRebootMachine   = errors.New("machine needs to reboot")
	ErrShutdownMachine = errors.New("machine needs to shutdown")
)

These errors are returned by various specific workers in the hope that they will have some specific effect on the top-level agent running that worker.

It should be clear that they don't belong here, and certainly shouldn't be used as they are today: e.g. a uniter has *no fricking idea* whether its host agent should shut down. A uniter can return ErrUnitDead, and its host might need to respond to that, perhaps by returning an error specific to *its* host; depending on these values punching right through N layers (but only when we want them to!) is kinda terrible.

var ErrKilled = errors.New("worker killed")

ErrKilled can be returned by the PeriodicWorkerCall to signify that the function has returned as a result of a Stop() or Kill() signal and that the function was able to stop cleanly

Functions

func NewNoOpWorker

func NewNoOpWorker() worker.Worker

func NewPeriodicWorker

func NewPeriodicWorker(call PeriodicWorkerCall, period time.Duration, timerFunc NewTimerFunc, options ...PeriodicWorkerOption) worker.Worker

NewPeriodicWorker returns a worker that runs the given function continually sleeping for sleepDuration in between each call, until Kill() is called The stopCh argument will be closed when the worker is killed. The error returned by the doWork function will be returned by the worker's Wait function.

func NewSimpleWorker

func NewSimpleWorker(doWork func(stopCh <-chan struct{}) error) worker.Worker

NewSimpleWorker returns a worker that runs the given function. The stopCh argument will be closed when the worker is killed. The error returned by the doWork function will be returned by the worker's Wait function.

Types

type FinishedWorker

type FinishedWorker struct{}

FinishedWorker is a worker that stops immediately with no error when started by a Runner, which then removes it from the list of workers without restarting it. Simply return FinishedWorker{} where you need to avoid starting a worker at all.

func (FinishedWorker) Kill

func (w FinishedWorker) Kill()

Kill implements Worker.Kill() and does nothing.

func (FinishedWorker) Wait

func (w FinishedWorker) Wait() error

Wait implements Worker.Wait() and immediately returns no error.

type NewTimerFunc

type NewTimerFunc func(time.Duration) PeriodicTimer

NewTimerFunc is a constructor used to obtain the instance of PeriodicTimer periodicWorker uses on its loop. TODO(fwereade): 2016-03-17 lp:1558657

type PeriodicTimer

type PeriodicTimer interface {
	// Reset changes the timer to expire after duration d.
	// It returns true if the timer had been active, false
	// if the timer had expired or been stopped.
	Reset(time.Duration) bool
	// CountDown returns the channel used to signal expiration of
	// the timer duration. The channel is called C in the base
	// implementation of timer but the name is confusing.
	CountDown() <-chan time.Time
}

PeriodicTimer is an interface for the timer that periodicworker will use to handle the calls.

func NewTimer

func NewTimer(d time.Duration) PeriodicTimer

NewTimer is the default implementation of NewTimerFunc.

type PeriodicWorkerCall

type PeriodicWorkerCall func(stop <-chan struct{}) error

PeriodicWorkerCall represents the callable to be passed to the periodic worker to be run every elapsed period.

type PeriodicWorkerOption

type PeriodicWorkerOption func(w *periodicWorker)

PeriodicWorkerOption is an optional parameter of the NewPeriodicWorker function and can be used to set optional parameters of the new periodic worker.

func Jitter

func Jitter(amount float64) PeriodicWorkerOption

Jitter will introduce a jitter in the worker's period by the specified amount (as percents - i.e. between 0 and 1).

type Runner

type Runner interface {
	worker.Worker
	StartWorker(id string, startFunc func() (worker.Worker, error)) error
	StopWorker(id string) error
}

Runner is implemented by instances capable of starting and stopping workers.

type Timer

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

Timer implements PeriodicTimer.

func (*Timer) CountDown

func (t *Timer) CountDown() <-chan time.Time

CountDown implements PeriodicTimer.

func (*Timer) Reset

func (t *Timer) Reset(d time.Duration) bool

Reset implements PeriodicTimer.