juju: github.com/wallyworld/juju/worker/modelcache Index | Files

package modelcache

import "github.com/wallyworld/juju/worker/modelcache"


Package Files

manifold.go worker.go

func ExtractCacheController Uses

func ExtractCacheController(in worker.Worker, out interface{}) error

ExtractCacheController extracts a *cache.Controller from a *cacheWorker.

func Manifold Uses

func Manifold(config ManifoldConfig) dependency.Manifold

Manifold returns a dependency.Manifold that will run a model cache worker. The manifold outputs a *cache.Controller, primarily for the apiserver to depend on and use.

func NewWorker Uses

func NewWorker(config Config) (worker.Worker, error)

NewWorker creates a new cacheWorker, and starts an all model watcher.

type Clock Uses

type Clock interface {
    // After waits for the duration to elapse and then sends the
    // current time on the returned channel.
    After(time.Duration) <-chan time.Time

Clock provides an interface for dealing with clocks.

type Config Uses

type Config struct {
    StatePool            *state.StatePool
    Hub                  Hub
    InitializedGate      Unlocker
    Logger               Logger
    PrometheusRegisterer prometheus.Registerer
    Cleanup              func()

    // Notify is used primarily for testing, and is passed through
    // to the cache.Controller. It is called every time the controller
    // processes an event.
    Notify func(interface{})

    // WatcherFactory supplies the watcher that supplies deltas from state.
    // We use a factory because we do not allow the worker loop to be crashed
    // by a watcher that stops in an error state.
    // Watcher acquisition my occur multiple times during a worker life-cycle.
    WatcherFactory func() multiwatcher.Watcher

    // WatcherRestartDelayMin is the minimum duration of the worker pause
    // before instantiating a new all-watcher when the previous one returns an
    // error.
    // This is intended to prevent log flooding in the case of unrecoverable
    // watcher errors.
    WatcherRestartDelayMin time.Duration

    // WatcherRestartDelayMax is the maximum duration of the worker pause
    // before instantiating a new all-watcher when the previous one returns an
    // error.
    WatcherRestartDelayMax time.Duration

    // Clock is used to enforce watcher restart delays.
    Clock Clock

Config describes the necessary fields for NewWorker.

func (*Config) Validate Uses

func (c *Config) Validate() error

Validate ensures all the necessary values are specified

func (Config) WithDefaultRestartStrategy Uses

func (c Config) WithDefaultRestartStrategy() Config

WithDefaultRestartStrategy returns a new config with production-use settings for the all-watcher restart strategy.

type Hub Uses

type Hub interface {
    Subscribe(topic string, handler interface{}) (func(), error)

Hub defines the methods of the apiserver centralhub that the peer grouper uses.

type Logger Uses

type Logger interface {
    IsTraceEnabled() bool
    Tracef(string, ...interface{})
    Errorf(string, ...interface{})
    Criticalf(string, ...interface{})

Logger describes the logging methods used in this package by the worker.

type ManifoldConfig Uses

type ManifoldConfig struct {
    StateName           string
    CentralHubName      string
    MultiwatcherName    string
    InitializedGateName string
    Logger              Logger

    PrometheusRegisterer prometheus.Registerer

    NewWorker func(Config) (worker.Worker, error)

ManifoldConfig holds the information necessary to run a model cache worker in a dependency.Engine.

func (ManifoldConfig) Validate Uses

func (config ManifoldConfig) Validate() error

Validate validates the manifold configuration.

type Unlocker Uses

type Unlocker interface {

Unlocker is used to indicate that the model cache is ready to be used.

Package modelcache imports 19 packages (graph). Updated 2020-08-06. Refresh now. Tools for package owners.