worker

Documentation

Index

• Variables
• func Stop(worker Worker) error
• func WaitForEnviron(w apiwatcher.NotifyWatcher, st EnvironConfigGetter, dying <-chan struct{}) (environs.Environ, error)
• type EnvironConfigGetter
• type EnvironConfigObserver
• type EnvironObserver
  • func NewEnvironObserver(st EnvironConfigObserver) (*EnvironObserver, error)
  • func (obs *EnvironObserver) Environ() environs.Environ
  • func (obs *EnvironObserver) Kill()
  • func (obs *EnvironObserver) Wait() error
• type NotifyWatchHandler
• type PeriodicWorkerCall
• type Runner
  • func NewRunner(isFatal func(error) bool, moreImportant func(err0, err1 error) bool) Runner
• type StringsWatchHandler
• type Worker
  • func NewNoOpWorker() Worker
  • func NewNotifyWorker(handler NotifyWatchHandler) Worker
  • func NewPeriodicWorker(call PeriodicWorkerCall, period time.Duration) Worker
  • func NewSimpleWorker(doWork func(stopCh <-chan struct{}) error) Worker
  • func NewStringsWorker(handler StringsWatchHandler) Worker

Variables

var ErrDead = errors.New("worker runner is not running")

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

var ErrRebootMachine = errors.New("machine needs to reboot")

var ErrShutdownMachine = errors.New("machine needs to shutdown")

var ErrTerminateAgent = errors.New("agent should be terminated")

var RestartDelay = 3 * time.Second

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

Functions

func Stop

func Stop(worker Worker) error

Stop kills the given worker and waits for it to exit.

func WaitForEnviron

func WaitForEnviron(w apiwatcher.NotifyWatcher, st EnvironConfigGetter, dying <-chan struct{}) (environs.Environ, error)

WaitForEnviron waits for an valid environment to arrive from the given watcher. It terminates with tomb.ErrDying if it receives a value on dying.

Types

type EnvironConfigGetter

type EnvironConfigGetter interface {
	EnvironConfig() (*config.Config, error)
}

EnvironConfigGetter interface defines a way to read the environment configuration.

type EnvironConfigObserver

type EnvironConfigObserver interface {
	EnvironConfigGetter
	WatchForEnvironConfigChanges() (apiwatcher.NotifyWatcher, error)
}

EnvironConfigObserver interface defines a way to read the environment configuration and watch for changes.

type EnvironObserver

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

EnvironObserver watches the current environment configuration and makes it available. It discards invalid environment configurations.

func NewEnvironObserver

func NewEnvironObserver(st EnvironConfigObserver) (*EnvironObserver, error)

NewEnvironObserver waits for the environment to have a valid environment configuration and returns a new environment observer. While waiting for the first environment configuration, it will return with tomb.ErrDying if it receives a value on dying.

func (*EnvironObserver) Environ

func (obs *EnvironObserver) Environ() environs.Environ

Environ returns the most recent valid Environ.

func (*EnvironObserver) Kill

func (obs *EnvironObserver) Kill()

func (*EnvironObserver) Wait

func (obs *EnvironObserver) Wait() error

type NotifyWatchHandler

type NotifyWatchHandler interface {
	// SetUp starts the handler, this should create the watcher we
	// will be waiting on for more events. SetUp can return a Watcher
	// even if there is an error, and the notify Worker will make sure
	// to stop the watcher.
	SetUp() (apiWatcher.NotifyWatcher, error)

	// TearDown should cleanup any resources that are left around
	TearDown() error

	// Handle is called when the Watcher has indicated there are changes, do
	// whatever work is necessary to process it. The done channel is closed if
	// the worker is being interrupted to finish. Any worker should avoid any
	// bare channel reads or writes, but instead use a select with the done
	// channel.
	Handle(done <-chan struct{}) error
}

NotifyWatchHandler implements the business logic that is triggered as part of watching a NotifyWatcher.

type PeriodicWorkerCall

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

type Runner

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

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

func NewRunner

func NewRunner(isFatal func(error) bool, moreImportant func(err0, err1 error) bool) Runner

NewRunner creates a new Runner. When a worker finishes, if its error is deemed fatal (determined by calling isFatal), all the other workers will be stopped and the runner itself will finish. Of all the fatal errors returned by the stopped workers, only the most important one, determined by calling moreImportant, will be returned from Runner.Wait. Non-fatal errors will not be returned.

The function isFatal(err) returns whether err is a fatal error. The function moreImportant(err0, err1) returns whether err0 is considered more important than err1.

type StringsWatchHandler

type StringsWatchHandler interface {
	// SetUp starts the handler, this should create the watcher we
	// will be waiting on for more events. SetUp can return a Watcher
	// even if there is an error, and strings Worker will make sure to
	// stop the watcher.
	SetUp() (apiWatcher.StringsWatcher, error)

	// TearDown should cleanup any resources that are left around
	TearDown() error

	// Handle is called when the Watcher has indicated there are
	// changes, do whatever work is necessary to process it
	Handle(changes []string) error
}

StringsWatchHandler implements the business logic triggered as part of watching a StringsWatcher.

type Worker

type Worker interface {
	// Kill asks the worker to stop without necessarily
	// waiting for it to do so.
	Kill()
	// Wait waits for the worker to exit and returns any
	// error encountered when it was running.
	Wait() error
}

Worker is implemented by a running worker.

func NewNoOpWorker

func NewNoOpWorker() Worker

func NewNotifyWorker

func NewNotifyWorker(handler NotifyWatchHandler) Worker

NewNotifyWorker starts a new worker running the business logic from the handler. The worker loop is started in another goroutine as a side effect of calling this.

func NewPeriodicWorker

func NewPeriodicWorker(call PeriodicWorkerCall, period time.Duration) 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

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.

func NewStringsWorker

func NewStringsWorker(handler StringsWatchHandler) Worker

NewStringsWorker starts a new worker running the business logic from the handler. The worker loop is started in another goroutine as a side effect of calling this.