remotestate

Documentation

Index

• type Application
• type Relation
• type RelationSnapshot
• type RemoteStateWatcher
  • func NewWatcher(config WatcherConfig) (*RemoteStateWatcher, error)
  • func (w *RemoteStateWatcher) ClearResolvedMode()
  • func (w *RemoteStateWatcher) CommandCompleted(completed string)
  • func (w *RemoteStateWatcher) Kill()
  • func (w *RemoteStateWatcher) RemoteStateChanged() <-chan struct{}
  • func (w *RemoteStateWatcher) Snapshot() Snapshot
  • func (w *RemoteStateWatcher) Wait() error
• type Snapshot
• type State
  • func NewAPIState(st *uniter.State) State
• type StorageAccessor
• type StorageSnapshot
• type Unit
• type UpdateStatusTimerFunc
• type Waiter
• type Watcher
• type WatcherConfig

Types

type Application

type Application interface {
	// CharmModifiedVersion returns a revision number for the charm that
	// increments whenever the charm or a resource for the charm changes.
	CharmModifiedVersion() (int, error)
	// CharmURL returns the url for the charm for this application.
	CharmURL() (*charm.URL, bool, error)
	// Life returns whether the application is alive.
	Life() params.Life
	// Refresh syncs this value with the api server.
	Refresh() error
	// Tag returns the tag for this application.
	Tag() names.ApplicationTag
	// Watch returns a watcher that fires when this application changes.
	Watch() (watcher.NotifyWatcher, error)
	// WatchLeadershipSettings returns a watcher that fires when the leadership
	// settings for this application change.
	WatchLeadershipSettings() (watcher.NotifyWatcher, error)
}

type Relation

type Relation interface {
	Id() int
	Life() params.Life
	Suspended() bool
	UpdateSuspended(bool)
}

type RelationSnapshot

type RelationSnapshot struct {
	Life      params.Life
	Suspended bool
	Members   map[string]int64
}

type RemoteStateWatcher

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

RemoteStateWatcher collects unit, application, and application config information from separate state watchers, and updates a Snapshot which is sent on a channel upon change.

func NewWatcher

func NewWatcher(config WatcherConfig) (*RemoteStateWatcher, error)

NewWatcher returns a RemoteStateWatcher that handles state changes pertaining to the supplied unit.

func (*RemoteStateWatcher) ClearResolvedMode

func (w *RemoteStateWatcher) ClearResolvedMode()

func (*RemoteStateWatcher) CommandCompleted

func (w *RemoteStateWatcher) CommandCompleted(completed string)

func (*RemoteStateWatcher) Kill

func (w *RemoteStateWatcher) Kill()

Kill is part of the worker.Worker interface.

func (*RemoteStateWatcher) RemoteStateChanged

func (w *RemoteStateWatcher) RemoteStateChanged() <-chan struct{}

func (*RemoteStateWatcher) Snapshot

func (w *RemoteStateWatcher) Snapshot() Snapshot

func (*RemoteStateWatcher) Wait

func (w *RemoteStateWatcher) Wait() error

Wait is part of the worker.Worker interface.

type Snapshot

type Snapshot struct {
	// Life is the lifecycle state of the unit.
	Life params.Life

	// Relations contains the lifecycle states of
	// each of the application's relations, keyed by
	// relation IDs.
	Relations map[int]RelationSnapshot

	// Storage contains the lifecycle and attached
	// states of each of the unit's storage attachments.
	Storage map[names.StorageTag]StorageSnapshot

	// CharmModifiedVersion is increased whenever the application's charm was
	// changed in some way.
	CharmModifiedVersion int

	// CharmURL is the charm URL that the unit is
	// expected to run.
	CharmURL *charm.URL

	// ForceCharmUpgrade reports whether the unit
	// should upgrade even in an error state.
	ForceCharmUpgrade bool

	// ResolvedMode reports the method of resolving
	// hook execution errors.
	ResolvedMode params.ResolvedMode

	// RetryHookVersion increments each time a failed
	// hook is meant to be retried if ResolvedMode is
	// set to ResolvedNone.
	RetryHookVersion int

	// ConfigHash is a hash of the last published version of the
	// unit's config settings.
	ConfigHash string

	// TrustHash is a hash of the last published version of the unit's
	// trust settings.
	TrustHash string

	// AddressesHash is a hash of the last published addresses for the
	// unit's machine/container.
	AddressesHash string

	// Leader indicates whether or not the unit is the
	// elected leader.
	Leader bool

	// LeaderSettingsVersion is the last published
	// version of the leader settings for the application.
	LeaderSettingsVersion int

	// UpdateStatusVersion increments each time an
	// update-status hook is supposed to run.
	UpdateStatusVersion int

	// Actions is the list of pending actions to
	// be performed by this unit.
	Actions []string

	// Commands is the list of IDs of commands to be
	// executed by this unit.
	Commands []string

	// UpgradeSeriesStatus is the preparation status of any currently running
	// series upgrade
	UpgradeSeriesStatus model.UpgradeSeriesStatus

	// UpgradeCharmProfileStatus represents the current upgrade charm profile
	// status for the currently running unit
	UpgradeCharmProfileStatus string
}

Snapshot is a snapshot of the remote state of the unit.

type State

type State interface {
	Relation(names.RelationTag) (Relation, error)
	StorageAttachment(names.StorageTag, names.UnitTag) (params.StorageAttachment, error)
	StorageAttachmentLife([]params.StorageAttachmentId) ([]params.LifeResult, error)
	Unit(names.UnitTag) (Unit, error)
	WatchRelationUnits(names.RelationTag, names.UnitTag) (watcher.RelationUnitsWatcher, error)
	WatchStorageAttachment(names.StorageTag, names.UnitTag) (watcher.NotifyWatcher, error)
	WatchUpdateStatusHookInterval() (watcher.NotifyWatcher, error)
	UpdateStatusHookInterval() (time.Duration, error)
}

func NewAPIState

func NewAPIState(st *uniter.State) State

type StorageAccessor

type StorageAccessor interface {
	// StorageAttachment returns the storage attachment with the specified
	// unit and storage tags.
	StorageAttachment(names.StorageTag, names.UnitTag) (params.StorageAttachment, error)
}

type StorageSnapshot

type StorageSnapshot struct {
	Kind     params.StorageKind
	Life     params.Life
	Attached bool
	Location string
}

StorageSnapshot has information relating to a storage instance belonging to a unit.

type Unit

type Unit interface {
	Life() params.Life
	Refresh() error
	Resolved() params.ResolvedMode
	Application() (Application, error)
	Tag() names.UnitTag
	Watch() (watcher.NotifyWatcher, error)
	WatchAddressesHash() (watcher.StringsWatcher, error)
	WatchConfigSettingsHash() (watcher.StringsWatcher, error)
	WatchTrustConfigSettingsHash() (watcher.StringsWatcher, error)
	WatchUpgradeSeriesNotifications() (watcher.NotifyWatcher, error)
	WatchLXDProfileUpgradeNotifications() (watcher.StringsWatcher, error)
	WatchStorage() (watcher.StringsWatcher, error)
	WatchActionNotifications() (watcher.StringsWatcher, error)
	// WatchRelation returns a watcher that fires when relations
	// relevant for this unit change.
	WatchRelations() (watcher.StringsWatcher, error)
	UpgradeSeriesStatus() (model.UpgradeSeriesStatus, error)
}

type UpdateStatusTimerFunc

type UpdateStatusTimerFunc func(time.Duration) Waiter

type Waiter

type Waiter interface {
	After() <-chan time.Time
}

type Watcher

type Watcher interface {
	// RemoteStateChanged returns a channel which is signalled
	// whenever the remote state is changed.
	RemoteStateChanged() <-chan struct{}

	// Snapshot returns the current snapshot of the remote state.
	Snapshot() Snapshot

	worker.Worker
}

type WatcherConfig

type WatcherConfig struct {
	State               State
	LeadershipTracker   leadership.Tracker
	UpdateStatusChannel UpdateStatusTimerFunc
	CommandChannel      <-chan string
	RetryHookChannel    watcher.NotifyChannel
	ApplicationChannel  watcher.NotifyChannel
	UnitTag             names.UnitTag
	ModelType           model.ModelType
}

WatcherConfig holds configuration parameters for the remote state watcher.