Documentation
¶
Index ¶
- Variables
- func Stop(worker Worker) error
- func WaitForEnviron(w apiwatcher.NotifyWatcher, st EnvironConfigGetter, dying <-chan struct{}) (environs.Environ, error)
- type EnvironConfigGetter
- type EnvironObserver
- type NotifyWatchHandler
- type PeriodicWorkerCall
- type Runner
- type StringsWatchHandler
- type Worker
Constants ¶
This section is empty.
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 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 ¶
EnvironConfigGetter interface defines a way to read the environment configuration.
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 *state.State) (*EnvironObserver, error)
NewEnvironObserver waits for the state 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
Handle() 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
Dying() <-chan struct{}
}
Runner is implemented by instances capable of starting and stopping workers.
func NewRunner ¶
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 ¶
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.
Source Files
¶
Directories
¶
| Path | Synopsis |
|---|---|
|
Package diskformatter defines a worker that watches for block devices assigned to storage instances owned by the unit that runs this worker, and creates filesystems on them as necessary.
|
Package diskformatter defines a worker that watches for block devices assigned to storage instances owned by the unit that runs this worker, and creates filesystems on them as necessary. |
|
Package diskmanager defines a worker that periodically lists block devices on the machine it runs on.
|
Package diskmanager defines a worker that periodically lists block devices on the machine it runs on. |
|
hook
hook provides types that define the hooks known to the Uniter
|
hook provides types that define the hooks known to the Uniter |
|
relation
relation implements persistent local storage of a unit's relation state, and translation of relation changes into hooks that need to be run.
|
relation implements persistent local storage of a unit's relation state, and translation of relation changes into hooks that need to be run. |
|
runner/jujuc
The worker/uniter/runner/jujuc package implements the server side of the jujuc proxy tool, which forwards command invocations to the unit agent process so that they can be executed against specific state.
|
The worker/uniter/runner/jujuc package implements the server side of the jujuc proxy tool, which forwards command invocations to the unit agent process so that they can be executed against specific state. |