resolver

Documentation

Index

• Variables
• func Loop(cfg LoopConfig, localState *LocalState) error
• type LocalState
• type LoopConfig
• type Resolver
• type ResolverFunc
  • func (f ResolverFunc) NextOp(local LocalState, remote remotestate.Snapshot, opFactory operation.Factory) (operation.Operation, error)

Variables

var ErrNoOperation = errors.New("no operations")

ErrNoOperation is used to indicate that there are no currently pending operations to run.

var ErrRestart = errors.New("restarting resolver")

ErrRestart indicates that the resolver loop should be restarted with a new remote state watcher.

var ErrTerminate = errors.New("terminate resolver")

ErrTerminate is used when the unit has been marked as dead and so there will never be any more operations to run for that unit.

var ErrWaiting = errors.New("waiting for remote state change")

ErrWaiting indicates that the resolver loop should not execute any more operations until a remote state event has occurred.

Functions

func Loop

func Loop(cfg LoopConfig, localState *LocalState) error

Loop repeatedly waits for remote state changes, feeding the local and remote state to the provided Resolver to generate Operations which are then run with the provided Executor.

The provided "onIdle" function will be called when the loop is waiting for remote state changes due to a lack of work to perform. It will not be called when a change is anticipated (i.e. due to ErrWaiting).

The resolver loop can be controlled in the following ways:

• if the "dying" channel is signalled, then the loop will exit with tomb.ErrDying
• if the resolver returns ErrWaiting, then no operations will be executed until the remote state has changed again
• if the resolver returns ErrNoOperation, then "onIdle" will be invoked and the loop will wait until the remote state has changed again
• if the resolver, onIdle, or executor return some other error, the loop will exit immediately

Types

type LocalState

type LocalState struct {
	operation.State

	// CharmURL reports the currently installed charm URL. This is set
	// by the committing of deploy (install/upgrade) ops.
	CharmURL *charm.URL

	// Conflicted indicates that the uniter is in a conflicted state,
	// and needs either resolution or a forced upgrade to continue.
	Conflicted bool

	// Restart indicates that the resolver should exit with ErrRestart
	// at the earliest opportunity.
	Restart bool

	// UpdateStatusVersion is the version of update status from remotestate.Snapshot
	// for which an update-status hook has been committed.
	UpdateStatusVersion int

	// ConfigVersion is the version of config from remotestate.Snapshot
	// for which a config-changed hook has been committed.
	ConfigVersion int

	// LeaderSettingsVersion is the version of leader settings from
	// remotestate.Snapshot for which a leader-settings-changed hook has
	// been committed.
	LeaderSettingsVersion int

	// CompletedActions is the set of actions that have been completed.
	// This is used to prevent us re running actions requested by the
	// state server.
	CompletedActions map[string]struct{}
}

type LoopConfig

type LoopConfig struct {
	Resolver       Resolver
	Watcher        remotestate.Watcher
	Executor       operation.Executor
	Factory        operation.Factory
	Dying          <-chan struct{}
	OnIdle         func() error
	CharmDirLocker charmdir.Locker
}

LoopConfig contains configuration parameters for the resolver loop.

type Resolver

type Resolver interface {
	// NextOp returns the next operation to run to reconcile
	// the local state with the remote, desired state. The
	// operations returned must be created using the given
	// operation.Factory.
	//
	// This method must return ErrNoOperation if there are no
	// operations to perform.
	//
	// By returning ErrTerminate, the resolver indicates that
	// it will never have any more operations to perform,
	// and the caller can cease calling.
	NextOp(
		LocalState,
		remotestate.Snapshot,
		operation.Factory,
	) (operation.Operation, error)
}

Resolver instances use local (as is) and remote (to be) state to provide operations to run in order to progress towards the desired state.

type ResolverFunc

type ResolverFunc func(
	LocalState,
	remotestate.Snapshot,
	operation.Factory,
) (operation.Operation, error)

func (ResolverFunc) NextOp

func (f ResolverFunc) NextOp(
	local LocalState,
	remote remotestate.Snapshot,
	opFactory operation.Factory,
) (operation.Operation, error)