juju: github.com/juju/juju/worker/uniter/resolver Index | Files

package resolver

import "github.com/juju/juju/worker/uniter/resolver"

Index

Package Files

func.go interface.go loop.go opfactory.go

Variables

var ErrDoNotProceed = errors.New("do not proceed")

ErrDoNotProceed is used to distinguish behaviour from resolver.ErrNoOperation. i.e do not run any operations versus this resolver has no operations to run.

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.

func Loop Uses

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

type LocalState Uses

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

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

    // UpgradeSeriesStatus is the current state of any currently running
    // upgrade series.
    UpgradeSeriesStatus model.UpgradeSeriesStatus
}

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 Uses

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 Uses

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 Uses

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

func (ResolverFunc) NextOp Uses

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

Package resolver imports 9 packages (graph) and is imported by 164 packages. Updated 2019-05-21. Refresh now. Tools for package owners.