119 lines
3.1 KiB
Go
119 lines
3.1 KiB
Go
// Package config is an interface for dynamic configuration.
|
|
package config // import "go.unistack.org/micro/v3/config"
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"time"
|
|
)
|
|
|
|
// DefaultConfig default config
|
|
var DefaultConfig Config = NewConfig()
|
|
|
|
// DefaultWatcherMinInterval default min interval for poll changes
|
|
var DefaultWatcherMinInterval = 5 * time.Second
|
|
|
|
// DefaultWatcherMaxInterval default max interval for poll changes
|
|
var DefaultWatcherMaxInterval = 9 * time.Second
|
|
|
|
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")
|
|
)
|
|
|
|
// Config is an interface abstraction for dynamic configuration
|
|
type Config interface {
|
|
// Name returns name of config
|
|
Name() string
|
|
// Init the config
|
|
Init(opts ...Option) error
|
|
// Options in the config
|
|
Options() Options
|
|
// Load config from sources
|
|
Load(context.Context, ...LoadOption) error
|
|
// Save config to sources
|
|
Save(context.Context, ...SaveOption) error
|
|
// Watch a config for changes
|
|
Watch(context.Context, ...WatchOption) (Watcher, error)
|
|
// String returns config type name
|
|
String() string
|
|
}
|
|
|
|
// Watcher is the config watcher
|
|
type Watcher interface {
|
|
// Next blocks until update happens or error returned
|
|
Next() (map[string]interface{}, error)
|
|
// Stop stops watcher
|
|
Stop() error
|
|
}
|
|
|
|
// Load loads config from config sources
|
|
func Load(ctx context.Context, cs []Config, opts ...LoadOption) error {
|
|
var err error
|
|
for _, c := range cs {
|
|
if err = c.Init(); err != nil {
|
|
return err
|
|
}
|
|
if err = c.Load(ctx, opts...); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
var (
|
|
DefaultAfterLoad = func(ctx context.Context, c Config) error {
|
|
for _, fn := range c.Options().AfterLoad {
|
|
if err := fn(ctx, c); err != nil {
|
|
c.Options().Logger.Errorf(ctx, "%s AfterLoad err: %v", c.String(), err)
|
|
if !c.Options().AllowFail {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
DefaultAfterSave = func(ctx context.Context, c Config) error {
|
|
for _, fn := range c.Options().AfterSave {
|
|
if err := fn(ctx, c); err != nil {
|
|
c.Options().Logger.Errorf(ctx, "%s AfterSave err: %v", c.String(), err)
|
|
if !c.Options().AllowFail {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
DefaultBeforeLoad = func(ctx context.Context, c Config) error {
|
|
for _, fn := range c.Options().BeforeLoad {
|
|
if err := fn(ctx, c); err != nil {
|
|
c.Options().Logger.Errorf(ctx, "%s BeforeLoad err: %v", c.String(), err)
|
|
if !c.Options().AllowFail {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
DefaultBeforeSave = func(ctx context.Context, c Config) error {
|
|
for _, fn := range c.Options().BeforeSave {
|
|
if err := fn(ctx, c); err != nil {
|
|
c.Options().Logger.Errorf(ctx, "%s BeforeSavec err: %v", c.String(), err)
|
|
if !c.Options().AllowFail {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
)
|