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 ErrLoopAborted = errors.New("resolver loop aborted")

ErrLoopAborted is used to signal that the loop is exiting because it received a value on its config's Abort chan.

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 "abort" channel is signalled, then the loop will exit with ErrLoopAborted
• 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

	// CharmModifiedVersion increases any time the charm,
	// or any part of it, is changed in some way.
	CharmModifiedVersion int

	// 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

	// RetryHookVersion is the version of hook-retries from
	// remotestate.Snapshot for which a hook has been retried.
	RetryHookVersion 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
	// controller.
	CompletedActions map[string]struct{}
}

LocalState is a cache of the state of the local unit, as needed by the Uniter. It is generally compared to the remote state of the expected state of the unit as stored in the controller.

type LoopConfig

type LoopConfig struct {
	Resolver      Resolver
	Watcher       remotestate.Watcher
	Executor      operation.Executor
	Factory       operation.Factory
	Abort         <-chan struct{}
	OnIdle        func() error
	CharmDirGuard fortress.Guard
}

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)