workers

type DumbConfig ¶

type DumbConfig struct {
	Factory Factory
	Logger  loggo.Logger
}

DumbConfig holds a DumbWorkers' dependencies.

func (config DumbConfig) Validate() error

type DumbWorkers ¶

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

DumbWorkers holds references to standard state workers. The workers are not guaranteed to be running; but they are guaranteed to be stopped when the DumbWorkers is stopped.

func NewDumbWorkers(config DumbConfig) (_ *DumbWorkers, err error)

func (dw *DumbWorkers) Kill()

func (dw *DumbWorkers) LeadershipManager() LeaseManager

func (dw *DumbWorkers) PresenceWatcher() PresenceWatcher

func (dw *DumbWorkers) SingularManager() LeaseManager

func (dw *DumbWorkers) TxnLogWatcher() TxnLogWatcher

func (dw *DumbWorkers) Wait() error

type DynamicLeaseManager ¶

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

DynamicLeaseManager is a workers.LeaseManager that calls a given function to acquire a fresh LeaseManager for each method call. This enables us to hide the fact that workers returned from RestartManager may become stale.

func (d DynamicLeaseManager) Claim(leaseName, holderName string, duration time.Duration) error

func (d DynamicLeaseManager) Token(leaseName, holderName string) lease.Token

func (d DynamicLeaseManager) Underlying() LeaseManager

func (d DynamicLeaseManager) WaitUntilExpired(leaseName string) error

type ExposedFailer ¶

type ExposedFailer interface {
	Dead() <-chan struct{}
	Err() error
}

ExposedFailer encapsulates methods for shutdown detection and handling, used widely inside state watcher types.

Would be lovely to remove this dependency -- by adding new watchers to something that tracked watcher and/or state validity, and stopped them automatically -- but that's likely to have impacts reverberating through state and apiserver and deserves its own careful analysis.

type Factory ¶

type Factory interface {
	NewTxnLogWorker() (TxnLogWorker, error)
	NewPresenceWorker() (PresenceWorker, error)
	NewLeadershipWorker() (LeaseWorker, error)
	NewSingularWorker() (LeaseWorker, error)
}

Factory supplies implementations of various workers used in state, and is generally a critical dependency of a Workers implementation such as DumbWorkers or RestartWorkers.

It'll generally just be a thin wrapper over a *State -- this package exists only to paper over worker-lifetime issues that are hard to address in the state package, not really to pave the way to alternate backends or anything.

type LeaseManager ¶

type LeaseManager interface {
	lease.Claimer
	lease.Checker
}

LeaseManager exposes the methods of lease.Manager that are needed by the state package.

type LeaseWorker ¶

type LeaseWorker interface {
	worker.Worker
	LeaseManager
}

LeaseWorker includes the lease.Manager's worker.Worker methods, so that a Workers implementation can manage its lifetime.

type PresenceWatcher ¶

type PresenceWatcher interface {
	ExposedFailer

	// Horrible hack for goosing it into activity. Not clear why
	// this is used by state in place of StartSync, but it is.
	Sync()

	// Presence-reading and -watching.
	Alive(key string) (bool, error)
	Watch(key string, ch chan<- presence.Change)
	Unwatch(key string, ch chan<- presence.Change)
}

PresenceWatcher exposes the methods of presence.Watcher that are needed by the state package.

type PresenceWorker ¶

type PresenceWorker interface {
	worker.Worker
	PresenceWatcher
}

PresenceWorker includes the presence.Watcher's worker.Worker methods, so that a Workers implementation can manage its lifetime.

type RestartConfig ¶

type RestartConfig struct {
	Factory Factory
	Logger  loggo.Logger
	Clock   clock.Clock
	Delay   time.Duration
}

RestartConfig holds a RestartWorkers' dependencies and configuration.

func (config RestartConfig) Validate() error

type RestartWorkers ¶

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

RestartWorkers wraps a DumbWorkers and restarts/replaces workers as they fail.

func NewRestartWorkers(config RestartConfig) (*RestartWorkers, error)

func (rw *RestartWorkers) Kill()

func (rw *RestartWorkers) LeadershipManager() LeaseManager

func (rw *RestartWorkers) PresenceWatcher() PresenceWatcher

func (rw *RestartWorkers) SingularManager() LeaseManager

func (rw *RestartWorkers) TxnLogWatcher() TxnLogWatcher

func (rw *RestartWorkers) Wait() error

type TxnLogWatcher ¶

type TxnLogWatcher interface {
	ExposedFailer

	// horrible hack for goosing it into activity (for tests).
	StartSync()

	// single-document watching
	Watch(coll string, id interface{}, revno int64, ch chan<- watcher.Change)
	Unwatch(coll string, id interface{}, ch chan<- watcher.Change)

	// collection-watching
	WatchCollection(coll string, ch chan<- watcher.Change)
	WatchCollectionWithFilter(coll string, ch chan<- watcher.Change, filter func(interface{}) bool)
	UnwatchCollection(coll string, ch chan<- watcher.Change)
}

TxnLogWatcher exposes the methods of watcher.Watcher that are needed by the state package.

type TxnLogWorker ¶

type TxnLogWorker interface {
	worker.Worker
	TxnLogWatcher
}

TxnLogWorker includes the watcher.Watcher's worker.Worker methods, so that a Workers implementation can manage its lifetime.

type Workers ¶

type Workers interface {
	worker.Worker

	TxnLogWatcher() TxnLogWatcher
	PresenceWatcher() PresenceWatcher
	LeadershipManager() LeaseManager
	SingularManager() LeaseManager
}

Workers doesn't really need to exist -- it could basically just exist in the state package -- but that'd entail duplication of the TxnLogWatcher, PresenceWatcher, and LeaseManager interfaces in both packages to avoid import cycles, and, yuck.

See the DumbWorkers and RestartWorkers types for implementations.