config

Documentation

Overview

Package config is an interface for dynamic configuration.

Index

• Variables
• func AfterInit(fn ...func(context.Context, Config) error) options.Option
• func AfterLoad(fn ...func(context.Context, Config) error) options.Option
• func AfterSave(fn ...func(context.Context, Config) error) options.Option
• func AllowFail(b bool) options.Option
• func BeforeInit(fn ...func(context.Context, Config) error) options.Option
• func BeforeLoad(fn ...func(context.Context, Config) error) options.Option
• func BeforeSave(fn ...func(context.Context, Config) error) options.Option
• func Load(ctx context.Context, cs []Config, opts ...options.Option) error
• func LoadAppend(b bool) options.Option
• func LoadOverride(b bool) options.Option
• func NewContext(ctx context.Context, c Config) context.Context
• func Struct(v interface{}) options.Option
• func StructTag(name string) options.Option
• func Validate(ctx context.Context, cfg interface{}) error
• func WatchCoalesce(b bool) options.Option
• func WatchInterval(min, max time.Duration) options.Option
• type Config
  • func FromContext(ctx context.Context) (Config, bool)
  • func NewConfig(opts ...options.Option) Config
• type LoadOptions
  • func NewLoadOptions(opts ...options.Option) LoadOptions
• type Options
  • func NewOptions(opts ...options.Option) Options
• type SaveOptions
  • func NewSaveOptions(opts ...options.Option) SaveOptions
• type Validator
• type WatchOptions
  • func NewWatchOptions(opts ...options.Option) WatchOptions
• type Watcher

Variables

var (
	// ErrCodecMissing is returned when codec needed and not specified
	ErrCodecMissing = errors.New("codec missing")
	// ErrInvalidStruct is returned when the target struct is invalid
	ErrInvalidStruct = errors.New("invalid struct specified")
	// ErrWatcherStopped is returned when source watcher has been stopped
	ErrWatcherStopped = errors.New("watcher stopped")
	// ErrWatcherNotImplemented returned when config does not implement watch
	ErrWatcherNotImplemented = errors.New("watcher not implemented")
)

var (
	// DefaultBeforeLoad default func that runs before config Load
	DefaultBeforeLoad = func(ctx context.Context, c Config) error {
		for _, fn := range c.Options().BeforeLoad {
			if fn == nil {
				return nil
			}
			if err := fn(ctx, c); err != nil {
				c.Options().Logger.Error(ctx, c.String()+" BeforeLoad error "+err.Error())
				if !c.Options().AllowFail {
					return err
				}
			}
		}
		return nil
	}
	// DefaultAfterLoad default func that runs after config Load
	DefaultAfterLoad = func(ctx context.Context, c Config) error {
		for _, fn := range c.Options().AfterLoad {
			if fn == nil {
				return nil
			}
			if err := fn(ctx, c); err != nil {
				c.Options().Logger.Error(ctx, c.String()+" AfterLoad error "+err.Error())
				if !c.Options().AllowFail {
					return err
				}
			}
		}
		return nil
	}
	// DefaultBeforeSave default func that runs befora config Save
	DefaultBeforeSave = func(ctx context.Context, c Config) error {
		for _, fn := range c.Options().BeforeSave {
			if fn == nil {
				return nil
			}
			if err := fn(ctx, c); err != nil {
				c.Options().Logger.Error(ctx, c.String()+" BeforeSave error "+err.Error())
				if !c.Options().AllowFail {
					return err
				}
			}
		}
		return nil
	}
	// DefaultAfterSave default func that runs after config Save
	DefaultAfterSave = func(ctx context.Context, c Config) error {
		for _, fn := range c.Options().AfterSave {
			if fn == nil {
				return nil
			}
			if err := fn(ctx, c); err != nil {
				c.Options().Logger.Error(ctx, c.String()+" AfterSave error "+err.Error())
				if !c.Options().AllowFail {
					return err
				}
			}
		}
		return nil
	}
	// DefaultBeforeInit default func that runs befora config Init
	DefaultBeforeInit = func(ctx context.Context, c Config) error {
		for _, fn := range c.Options().BeforeInit {
			if fn == nil {
				return nil
			}
			if err := fn(ctx, c); err != nil {
				c.Options().Logger.Error(ctx, c.String()+" BeforeInit error "+err.Error())
				if !c.Options().AllowFail {
					return err
				}
			}
		}
		return nil
	}
	// DefaultAfterInit default func that runs after config Init
	DefaultAfterInit = func(ctx context.Context, c Config) error {
		for _, fn := range c.Options().AfterSave {
			if fn == nil {
				return nil
			}
			if err := fn(ctx, c); err != nil {
				c.Options().Logger.Error(ctx, c.String()+" AfterInit error "+err.Error())
				if !c.Options().AllowFail {
					return err
				}
			}
		}
		return nil
	}
)

var DefaultConfig = NewConfig()

DefaultConfig default config

var DefaultWatcherMaxInterval = 9 * time.Second

DefaultWatcherMaxInterval default max interval for poll changes

var DefaultWatcherMinInterval = 5 * time.Second

DefaultWatcherMinInterval default min interval for poll changes

Functions

func AfterInit

func AfterInit(fn ...func(context.Context, Config) error) options.Option

AfterInit run funcs after config Init

func AfterLoad

func AfterLoad(fn ...func(context.Context, Config) error) options.Option

AfterLoad run funcs after config load

func AfterSave

func AfterSave(fn ...func(context.Context, Config) error) options.Option

AfterSave run fncs after save

func AllowFail

func AllowFail(b bool) options.Option

AllowFail allows config source to fail

func BeforeInit

func BeforeInit(fn ...func(context.Context, Config) error) options.Option

BeforeInit run funcs before config Init

func BeforeLoad

func BeforeLoad(fn ...func(context.Context, Config) error) options.Option

BeforeLoad run funcs before config load

func BeforeSave

func BeforeSave(fn ...func(context.Context, Config) error) options.Option

BeforeSave run funcs before save

func Load

func Load(ctx context.Context, cs []Config, opts ...options.Option) error

Load loads config from config sources

func LoadAppend

func LoadAppend(b bool) options.Option

LoadAppend override values when load

func LoadOverride

func LoadOverride(b bool) options.Option

LoadOverride override values when load

func NewContext

func NewContext(ctx context.Context, c Config) context.Context

NewContext put store in context

func Struct

func Struct(v interface{}) options.Option

Struct used as config

func StructTag

func StructTag(name string) options.Option

StructTag sets the struct tag that used for filling

func Validate

func Validate(ctx context.Context, cfg interface{}) error

Validate runs Validate() error func for each struct field

func WatchCoalesce

func WatchCoalesce(b bool) options.Option

Coalesce controls watch event combining

func WatchInterval

func WatchInterval(min, max time.Duration) options.Option

WatchInterval specifies min and max time.Duration for pulling changes

Types

type Config

type Config interface {
	// Name returns name of config
	Name() string
	// Init the config
	Init(opts ...options.Option) error
	// Options in the config
	Options() Options
	// Load config from sources
	Load(context.Context, ...options.Option) error
	// Save config to sources
	Save(context.Context, ...options.Option) error
	// Watch a config for changes
	Watch(context.Context, ...options.Option) (Watcher, error)
	// String returns config type name
	String() string
}

Config is an interface abstraction for dynamic configuration

func FromContext

func FromContext(ctx context.Context) (Config, bool)

FromContext returns store from context

func NewConfig

func NewConfig(opts ...options.Option) Config

NewConfig returns new default config source

type LoadOptions

type LoadOptions struct {
	Struct   interface{}
	Context  context.Context
	Override bool
	Append   bool
}

LoadOptions struct

func NewLoadOptions

func NewLoadOptions(opts ...options.Option) LoadOptions

NewLoadOptions create LoadOptions struct with provided opts

type Options

type Options struct {
	// Struct holds the destination config struct
	Struct interface{}
	// Codec that used for load/save
	Codec codec.Codec
	// Tracer that will be used
	Tracer tracer.Tracer
	// Meter that will be used
	Meter meter.Meter
	// Logger that will be used
	Logger logger.Logger
	// Context used for external options
	Context context.Context
	// Name of the config
	Name string
	// StructTag name
	StructTag string
	// BeforeSave contains slice of funcs that runs before Save
	BeforeSave []func(context.Context, Config) error
	// AfterSave contains slice of funcs that runs after Save
	AfterSave []func(context.Context, Config) error
	// BeforeLoad contains slice of funcs that runs before Load
	BeforeLoad []func(context.Context, Config) error
	// AfterLoad contains slice of funcs that runs after Load
	AfterLoad []func(context.Context, Config) error
	// BeforeInit contains slice of funcs that runs before Init
	BeforeInit []func(context.Context, Config) error
	// AfterInit contains slice of funcs that runs after Init
	AfterInit []func(context.Context, Config) error
	// AllowFail flag to allow fail in config source
	AllowFail bool
	// SkipLoad runs only if condition returns true
	SkipLoad func(context.Context, Config) bool
	// SkipSave runs only if condition returns true
	SkipSave func(context.Context, Config) bool
}

Options hold the config options

func NewOptions

func NewOptions(opts ...options.Option) Options

NewOptions new options struct with filed values

type SaveOptions

type SaveOptions struct {
	Struct  interface{}
	Context context.Context
}

SaveOptions struct

func NewSaveOptions

func NewSaveOptions(opts ...options.Option) SaveOptions

NewSaveOptions fill SaveOptions struct

type Validator

type Validator interface {
	Validate() error
}

type WatchOptions

type WatchOptions struct {
	// Context used by non default options
	Context context.Context
	// Struct for filling
	Struct interface{}
	// MinInterval specifies the min time.Duration interval for poll changes
	MinInterval time.Duration
	// MaxInterval specifies the max time.Duration interval for poll changes
	MaxInterval time.Duration
	// Coalesce multiple events to one
	Coalesce bool
}

WatchOptions struuct

func NewWatchOptions

func NewWatchOptions(opts ...options.Option) WatchOptions

NewWatchOptions create WatchOptions struct with provided opts

type Watcher

type Watcher interface {
	// Next blocks until update happens or error returned
	Next() (map[string]interface{}, error)
	// Stop stops watcher
	Stop() error
}

Watcher is the config watcher