Initial QSfera import

Server/vendor/go-micro.dev/v4/config/README.md

@@ -0,0 +1,24 @@
+# Config [![GoDoc](https://godoc.org/github.com/micro/go-micro/config?status.svg)](https://godoc.org/github.com/micro/go-micro/config)
+
+Config is a pluggable dynamic config package
+
+Most config in applications are statically configured or include complex logic to load from multiple sources.
+Go Config makes this easy, pluggable and mergeable. You'll never have to deal with config in the same way again.
+
+## Features
+
+- **Dynamic Loading** - Load configuration from multiple source as and when needed. Go Config manages watching config sources
+  in the background and automatically merges and updates an in memory view.
+
+- **Pluggable Sources** - Choose from any number of sources to load and merge config. The backend source is abstracted away into
+  a standard format consumed internally and decoded via encoders. Sources can be env vars, flags, file, etcd, k8s configmap, etc.
+
+- **Mergeable Config** - If you specify multiple sources of config, regardless of format, they will be merged and presented in
+  a single view. This massively simplifies priority order loading and changes based on environment.
+
+- **Observe Changes** - Optionally watch the config for changes to specific values. Hot reload your app using Go Config's watcher.
+  You don't have to handle ad-hoc hup reloading or whatever else, just keep reading the config and watch for changes if you need
+  to be notified.
+
+- **Sane Defaults** - In case config loads badly or is completely wiped away for some unknown reason, you can specify fallback
+  values when accessing any config values directly. This ensures you'll always be reading some sane default in the event of a problem.

Server/vendor/go-micro.dev/v4/config/config.go

@@ -0,0 +1,101 @@
+// Package config is an interface for dynamic configuration.
+package config
+
+import (
+	"context"
+
+	"go-micro.dev/v4/config/loader"
+	"go-micro.dev/v4/config/reader"
+	"go-micro.dev/v4/config/source"
+	"go-micro.dev/v4/config/source/file"
+)
+
+// Config is an interface abstraction for dynamic configuration.
+type Config interface {
+	// provide the reader.Values interface
+	reader.Values
+	// Init the config
+	Init(opts ...Option) error
+	// Options in the config
+	Options() Options
+	// Stop the config loader/watcher
+	Close() error
+	// Load config sources
+	Load(source ...source.Source) error
+	// Force a source changeset sync
+	Sync() error
+	// Watch a value for changes
+	Watch(path ...string) (Watcher, error)
+}
+
+// Watcher is the config watcher.
+type Watcher interface {
+	Next() (reader.Value, error)
+	Stop() error
+}
+
+type Options struct {
+	Loader loader.Loader
+	Reader reader.Reader
+
+	// for alternative data
+	Context context.Context
+
+	Source []source.Source
+
+	WithWatcherDisabled bool
+}
+
+type Option func(o *Options)
+
+var (
+	// Default Config Manager.
+	DefaultConfig, _ = NewConfig()
+)
+
+// NewConfig returns new config.
+func NewConfig(opts ...Option) (Config, error) {
+	return newConfig(opts...)
+}
+
+// Return config as raw json.
+func Bytes() []byte {
+	return DefaultConfig.Bytes()
+}
+
+// Return config as a map.
+func Map() map[string]interface{} {
+	return DefaultConfig.Map()
+}
+
+// Scan values to a go type.
+func Scan(v interface{}) error {
+	return DefaultConfig.Scan(v)
+}
+
+// Force a source changeset sync.
+func Sync() error {
+	return DefaultConfig.Sync()
+}
+
+// Get a value from the config.
+func Get(path ...string) reader.Value {
+	return DefaultConfig.Get(path...)
+}
+
+// Load config sources.
+func Load(source ...source.Source) error {
+	return DefaultConfig.Load(source...)
+}
+
+// Watch a value for changes.
+func Watch(path ...string) (Watcher, error) {
+	return DefaultConfig.Watch(path...)
+}
+
+// LoadFile is short hand for creating a file source and loading it.
+func LoadFile(path string) error {
+	return Load(file.NewSource(
+		file.WithPath(path),
+	))
+}

Server/vendor/go-micro.dev/v4/config/default.go

@@ -0,0 +1,309 @@
+package config
+
+import (
+	"bytes"
+	"fmt"
+	"go-micro.dev/v4/config/loader"
+	"go-micro.dev/v4/config/loader/memory"
+	"go-micro.dev/v4/config/reader"
+	"go-micro.dev/v4/config/reader/json"
+	"go-micro.dev/v4/config/source"
+	"sync"
+	"time"
+)
+
+type config struct {
+	// the current values
+	vals reader.Values
+	exit chan bool
+	// the current snapshot
+	snap *loader.Snapshot
+	opts Options
+
+	sync.RWMutex
+}
+
+type watcher struct {
+	lw    loader.Watcher
+	rd    reader.Reader
+	value reader.Value
+	path  []string
+}
+
+func newConfig(opts ...Option) (Config, error) {
+	var c config
+
+	err := c.Init(opts...)
+	if err != nil {
+		return nil, err
+	}
+	if !c.opts.WithWatcherDisabled {
+		go c.run()
+	}
+	return &c, nil
+}
+
+func (c *config) Init(opts ...Option) error {
+	c.opts = Options{
+		Reader: json.NewReader(),
+	}
+	c.exit = make(chan bool)
+	for _, o := range opts {
+		o(&c.opts)
+	}
+
+	// default loader uses the configured reader
+	if c.opts.Loader == nil {
+		loaderOpts := []loader.Option{memory.WithReader(c.opts.Reader)}
+		if c.opts.WithWatcherDisabled {
+			loaderOpts = append(loaderOpts, memory.WithWatcherDisabled())
+		}
+
+		c.opts.Loader = memory.NewLoader(loaderOpts...)
+	}
+
+	err := c.opts.Loader.Load(c.opts.Source...)
+	if err != nil {
+		return err
+	}
+
+	c.snap, err = c.opts.Loader.Snapshot()
+	if err != nil {
+		return err
+	}
+
+	c.vals, err = c.opts.Reader.Values(c.snap.ChangeSet)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (c *config) Options() Options {
+	return c.opts
+}
+
+func (c *config) run() {
+	watch := func(w loader.Watcher) error {
+		for {
+			// get changeset
+			snap, err := w.Next()
+			if err != nil {
+				return err
+			}
+
+			c.Lock()
+
+			if c.snap.Version >= snap.Version {
+				c.Unlock()
+				continue
+			}
+
+			// save
+			c.snap = snap
+
+			// set values
+			c.vals, _ = c.opts.Reader.Values(snap.ChangeSet)
+
+			c.Unlock()
+		}
+	}
+
+	for {
+		w, err := c.opts.Loader.Watch()
+		if err != nil {
+			time.Sleep(time.Second)
+			continue
+		}
+
+		done := make(chan bool)
+
+		// the stop watch func
+		go func() {
+			select {
+			case <-done:
+			case <-c.exit:
+			}
+			err := w.Stop()
+			fmt.Println(err.Error())
+		}()
+
+		// block watch
+		if err := watch(w); err != nil {
+			// do something better
+			time.Sleep(time.Second)
+		}
+
+		// close done chan
+		close(done)
+
+		// if the config is closed exit
+		select {
+		case <-c.exit:
+			return
+		default:
+		}
+	}
+}
+
+func (c *config) Map() map[string]interface{} {
+	c.RLock()
+	defer c.RUnlock()
+	return c.vals.Map()
+}
+
+func (c *config) Scan(v interface{}) error {
+	c.RLock()
+	defer c.RUnlock()
+	return c.vals.Scan(v)
+}
+
+// sync loads all the sources, calls the parser and updates the config.
+func (c *config) Sync() error {
+	if err := c.opts.Loader.Sync(); err != nil {
+		return err
+	}
+
+	snap, err := c.opts.Loader.Snapshot()
+	if err != nil {
+		return err
+	}
+
+	c.Lock()
+	defer c.Unlock()
+
+	c.snap = snap
+	vals, err := c.opts.Reader.Values(snap.ChangeSet)
+	if err != nil {
+		return err
+	}
+	c.vals = vals
+
+	return nil
+}
+
+func (c *config) Close() error {
+	select {
+	case <-c.exit:
+		return nil
+	default:
+		close(c.exit)
+	}
+	return nil
+}
+
+func (c *config) Get(path ...string) reader.Value {
+	c.RLock()
+	defer c.RUnlock()
+
+	// did sync actually work?
+	if c.vals != nil {
+		return c.vals.Get(path...)
+	}
+
+	// no value
+	return newValue()
+}
+
+func (c *config) Set(val interface{}, path ...string) {
+	c.Lock()
+	defer c.Unlock()
+
+	if c.vals != nil {
+		c.vals.Set(val, path...)
+	}
+
+	return
+}
+
+func (c *config) Del(path ...string) {
+	c.Lock()
+	defer c.Unlock()
+
+	if c.vals != nil {
+		c.vals.Del(path...)
+	}
+
+	return
+}
+
+func (c *config) Bytes() []byte {
+	c.RLock()
+	defer c.RUnlock()
+
+	if c.vals == nil {
+		return []byte{}
+	}
+
+	return c.vals.Bytes()
+}
+
+func (c *config) Load(sources ...source.Source) error {
+	c.Lock()
+	defer c.Unlock()
+
+	if err := c.opts.Loader.Load(sources...); err != nil {
+		return err
+	}
+
+	snap, err := c.opts.Loader.Snapshot()
+	if err != nil {
+		return err
+	}
+
+	c.snap = snap
+	vals, err := c.opts.Reader.Values(snap.ChangeSet)
+	if err != nil {
+		return err
+	}
+	c.vals = vals
+
+	return nil
+}
+
+func (c *config) Watch(path ...string) (Watcher, error) {
+	value := c.Get(path...)
+
+	w, err := c.opts.Loader.Watch(path...)
+	if err != nil {
+		return nil, err
+	}
+
+	return &watcher{
+		lw:    w,
+		rd:    c.opts.Reader,
+		path:  path,
+		value: value,
+	}, nil
+}
+
+func (c *config) String() string {
+	return "config"
+}
+
+func (w *watcher) Next() (reader.Value, error) {
+	for {
+		s, err := w.lw.Next()
+		if err != nil {
+			return nil, err
+		}
+
+		// only process changes
+		if bytes.Equal(w.value.Bytes(), s.ChangeSet.Data) {
+			continue
+		}
+
+		v, err := w.rd.Values(s.ChangeSet)
+		if err != nil {
+			return nil, err
+		}
+
+		w.value = v.Get()
+		return w.value, nil
+	}
+}
+
+func (w *watcher) Stop() error {
+	return w.lw.Stop()
+}

Server/vendor/go-micro.dev/v4/config/encoder/encoder.go

@@ -0,0 +1,8 @@
+// Package encoder handles source encoding formats
+package encoder
+
+type Encoder interface {
+	Encode(interface{}) ([]byte, error)
+	Decode([]byte, interface{}) error
+	String() string
+}

Server/vendor/go-micro.dev/v4/config/encoder/json/json.go

@@ -0,0 +1,25 @@
+package json
+
+import (
+	"encoding/json"
+
+	"go-micro.dev/v4/config/encoder"
+)
+
+type jsonEncoder struct{}
+
+func (j jsonEncoder) Encode(v interface{}) ([]byte, error) {
+	return json.Marshal(v)
+}
+
+func (j jsonEncoder) Decode(d []byte, v interface{}) error {
+	return json.Unmarshal(d, v)
+}
+
+func (j jsonEncoder) String() string {
+	return "json"
+}
+
+func NewEncoder() encoder.Encoder {
+	return jsonEncoder{}
+}

Server/vendor/go-micro.dev/v4/config/loader/loader.go

@@ -0,0 +1,68 @@
+// Package loader manages loading from multiple sources
+package loader
+
+import (
+	"context"
+
+	"go-micro.dev/v4/config/reader"
+	"go-micro.dev/v4/config/source"
+)
+
+// Loader manages loading sources.
+type Loader interface {
+	// Stop the loader
+	Close() error
+	// Load the sources
+	Load(...source.Source) error
+	// A Snapshot of loaded config
+	Snapshot() (*Snapshot, error)
+	// Force sync of sources
+	Sync() error
+	// Watch for changes
+	Watch(...string) (Watcher, error)
+	// Name of loader
+	String() string
+}
+
+// Watcher lets you watch sources and returns a merged ChangeSet.
+type Watcher interface {
+	// First call to next may return the current Snapshot
+	// If you are watching a path then only the data from
+	// that path is returned.
+	Next() (*Snapshot, error)
+	// Stop watching for changes
+	Stop() error
+}
+
+// Snapshot is a merged ChangeSet.
+type Snapshot struct {
+	// The merged ChangeSet
+	ChangeSet *source.ChangeSet
+	// Deterministic and comparable version of the snapshot
+	Version string
+}
+
+// Options contains all options for a config loader.
+type Options struct {
+	Reader reader.Reader
+
+	// for alternative data
+	Context context.Context
+
+	Source []source.Source
+
+	WithWatcherDisabled bool
+}
+
+// Option is a helper for a single option.
+type Option func(o *Options)
+
+// Copy snapshot.
+func Copy(s *Snapshot) *Snapshot {
+	cs := *(s.ChangeSet)
+
+	return &Snapshot{
+		ChangeSet: &cs,
+		Version:   s.Version,
+	}
+}

Server/vendor/go-micro.dev/v4/config/loader/memory/memory.go

@@ -0,0 +1,470 @@
+package memory
+
+import (
+	"bytes"
+	"container/list"
+	"errors"
+	"fmt"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"go-micro.dev/v4/config/loader"
+	"go-micro.dev/v4/config/reader"
+	"go-micro.dev/v4/config/reader/json"
+	"go-micro.dev/v4/config/source"
+)
+
+type memory struct {
+	// the current values
+	vals reader.Values
+	exit chan bool
+	// the current snapshot
+	snap *loader.Snapshot
+
+	watchers *list.List
+	opts     loader.Options
+
+	// all the sets
+	sets []*source.ChangeSet
+	// all the sources
+	sources []source.Source
+
+	sync.RWMutex
+}
+
+type updateValue struct {
+	value   reader.Value
+	version string
+}
+
+type watcher struct {
+	value   reader.Value
+	reader  reader.Reader
+	version atomic.Value
+	exit    chan bool
+	updates chan updateValue
+	path    []string
+}
+
+func (w *watcher) getVersion() string {
+	return w.version.Load().(string)
+}
+
+func (m *memory) watch(idx int, s source.Source) {
+	// watches a source for changes
+	watch := func(idx int, s source.Watcher) error {
+		for {
+			// get changeset
+			cs, err := s.Next()
+			if err != nil {
+				return err
+			}
+
+			m.Lock()
+
+			// save
+			m.sets[idx] = cs
+
+			// merge sets
+			set, err := m.opts.Reader.Merge(m.sets...)
+			if err != nil {
+				m.Unlock()
+				return err
+			}
+
+			// set values
+			m.vals, _ = m.opts.Reader.Values(set)
+			m.snap = &loader.Snapshot{
+				ChangeSet: set,
+				Version:   genVer(),
+			}
+			m.Unlock()
+
+			// send watch updates
+			m.update()
+		}
+	}
+
+	for {
+		// watch the source
+		w, err := s.Watch()
+		if err != nil {
+			time.Sleep(time.Second)
+			continue
+		}
+
+		done := make(chan bool)
+
+		// the stop watch func
+		go func() {
+			select {
+			case <-done:
+			case <-m.exit:
+			}
+			w.Stop()
+		}()
+
+		// block watch
+		if err := watch(idx, w); err != nil {
+			// do something better
+			time.Sleep(time.Second)
+		}
+
+		// close done chan
+		close(done)
+
+		// if the config is closed exit
+		select {
+		case <-m.exit:
+			return
+		default:
+		}
+	}
+}
+
+func (m *memory) loaded() bool {
+	var loaded bool
+	m.RLock()
+	if m.vals != nil {
+		loaded = true
+	}
+	m.RUnlock()
+	return loaded
+}
+
+// reload reads the sets and creates new values.
+func (m *memory) reload() error {
+	m.Lock()
+
+	// merge sets
+	set, err := m.opts.Reader.Merge(m.sets...)
+	if err != nil {
+		m.Unlock()
+		return err
+	}
+
+	// set values
+	if vals, err := m.opts.Reader.Values(set); err != nil {
+		m.vals = vals
+	}
+	m.snap = &loader.Snapshot{
+		ChangeSet: set,
+		Version:   genVer(),
+	}
+
+	m.Unlock()
+
+	// update watchers
+	m.update()
+
+	return nil
+}
+
+func (m *memory) update() {
+	m.RLock()
+
+	watchers := make([]*watcher, 0, m.watchers.Len())
+
+	for e := m.watchers.Front(); e != nil; e = e.Next() {
+		watchers = append(watchers, e.Value.(*watcher))
+	}
+
+	vals := m.vals
+	snap := m.snap
+	m.RUnlock()
+
+	for _, w := range watchers {
+		if w.getVersion() >= snap.Version {
+			continue
+		}
+
+		uv := updateValue{
+			version: m.snap.Version,
+			value:   vals.Get(w.path...),
+		}
+
+		select {
+		case w.updates <- uv:
+		default:
+		}
+	}
+}
+
+// Snapshot returns a snapshot of the current loaded config.
+func (m *memory) Snapshot() (*loader.Snapshot, error) {
+	if m.loaded() {
+		m.RLock()
+		snap := loader.Copy(m.snap)
+		m.RUnlock()
+		return snap, nil
+	}
+
+	// not loaded, sync
+	if err := m.Sync(); err != nil {
+		return nil, err
+	}
+
+	// make copy
+	m.RLock()
+	snap := loader.Copy(m.snap)
+	m.RUnlock()
+
+	return snap, nil
+}
+
+// Sync loads all the sources, calls the parser and updates the config.
+func (m *memory) Sync() error {
+	//nolint:prealloc
+	var sets []*source.ChangeSet
+
+	m.Lock()
+
+	// read the source
+	var gerr []string
+
+	for _, source := range m.sources {
+		ch, err := source.Read()
+		if err != nil {
+			gerr = append(gerr, err.Error())
+			continue
+		}
+		sets = append(sets, ch)
+	}
+
+	// merge sets
+	set, err := m.opts.Reader.Merge(sets...)
+	if err != nil {
+		m.Unlock()
+		return err
+	}
+
+	// set values
+	vals, err := m.opts.Reader.Values(set)
+	if err != nil {
+		m.Unlock()
+		return err
+	}
+	m.vals = vals
+	m.snap = &loader.Snapshot{
+		ChangeSet: set,
+		Version:   genVer(),
+	}
+
+	m.Unlock()
+
+	// update watchers
+	m.update()
+
+	if len(gerr) > 0 {
+		return fmt.Errorf("source loading errors: %s", strings.Join(gerr, "\n"))
+	}
+
+	return nil
+}
+
+func (m *memory) Close() error {
+	select {
+	case <-m.exit:
+		return nil
+	default:
+		close(m.exit)
+	}
+	return nil
+}
+
+func (m *memory) Get(path ...string) (reader.Value, error) {
+	if !m.loaded() {
+		if err := m.Sync(); err != nil {
+			return nil, err
+		}
+	}
+
+	m.Lock()
+	defer m.Unlock()
+
+	// did sync actually work?
+	if m.vals != nil {
+		return m.vals.Get(path...), nil
+	}
+
+	// assuming vals is nil
+	// create new vals
+
+	ch := m.snap.ChangeSet
+
+	// we are truly screwed, trying to load in a hacked way
+	v, err := m.opts.Reader.Values(ch)
+	if err != nil {
+		return nil, err
+	}
+
+	// lets set it just because
+	m.vals = v
+
+	if m.vals != nil {
+		return m.vals.Get(path...), nil
+	}
+
+	// ok we're going hardcore now
+
+	return nil, errors.New("no values")
+}
+
+func (m *memory) Load(sources ...source.Source) error {
+	var gerrors []string
+
+	for _, source := range sources {
+		set, err := source.Read()
+		if err != nil {
+			gerrors = append(gerrors,
+				fmt.Sprintf("error loading source %s: %v",
+					source,
+					err))
+			// continue processing
+			continue
+		}
+		m.Lock()
+		m.sources = append(m.sources, source)
+		m.sets = append(m.sets, set)
+		idx := len(m.sets) - 1
+		m.Unlock()
+		if !m.opts.WithWatcherDisabled {
+			go m.watch(idx, source)
+		}
+	}
+
+	if err := m.reload(); err != nil {
+		gerrors = append(gerrors, err.Error())
+	}
+
+	// Return errors
+	if len(gerrors) != 0 {
+		return errors.New(strings.Join(gerrors, "\n"))
+	}
+	return nil
+}
+
+func (m *memory) Watch(path ...string) (loader.Watcher, error) {
+	if m.opts.WithWatcherDisabled {
+		return nil, errors.New("watcher is disabled")
+	}
+
+	value, err := m.Get(path...)
+	if err != nil {
+		return nil, err
+	}
+
+	m.Lock()
+
+	w := &watcher{
+		exit:    make(chan bool),
+		path:    path,
+		value:   value,
+		reader:  m.opts.Reader,
+		updates: make(chan updateValue, 1),
+	}
+	w.version.Store(m.snap.Version)
+
+	e := m.watchers.PushBack(w)
+
+	m.Unlock()
+
+	go func() {
+		<-w.exit
+		m.Lock()
+		m.watchers.Remove(e)
+		m.Unlock()
+	}()
+
+	return w, nil
+}
+
+func (m *memory) String() string {
+	return "memory"
+}
+
+func (w *watcher) Next() (*loader.Snapshot, error) {
+	update := func(v reader.Value) *loader.Snapshot {
+		w.value = v
+
+		cs := &source.ChangeSet{
+			Data:      v.Bytes(),
+			Format:    w.reader.String(),
+			Source:    "memory",
+			Timestamp: time.Now(),
+		}
+		cs.Checksum = cs.Sum()
+
+		return &loader.Snapshot{
+			ChangeSet: cs,
+			Version:   w.getVersion(),
+		}
+	}
+
+	for {
+		select {
+		case <-w.exit:
+			return nil, errors.New("watcher stopped")
+
+		case uv := <-w.updates:
+			if uv.version <= w.getVersion() {
+				continue
+			}
+
+			v := uv.value
+
+			w.version.Store(uv.version)
+
+			if bytes.Equal(w.value.Bytes(), v.Bytes()) {
+				continue
+			}
+
+			return update(v), nil
+		}
+	}
+}
+
+func (w *watcher) Stop() error {
+	select {
+	case <-w.exit:
+	default:
+		close(w.exit)
+		close(w.updates)
+	}
+
+	return nil
+}
+
+func genVer() string {
+	return fmt.Sprintf("%d", time.Now().UnixNano())
+}
+
+func NewLoader(opts ...loader.Option) loader.Loader {
+	options := loader.Options{
+		Reader: json.NewReader(),
+	}
+
+	for _, o := range opts {
+		o(&options)
+	}
+
+	m := &memory{
+		exit:     make(chan bool),
+		opts:     options,
+		watchers: list.New(),
+		sources:  options.Source,
+	}
+
+	m.sets = make([]*source.ChangeSet, len(options.Source))
+
+	for i, s := range options.Source {
+		m.sets[i] = &source.ChangeSet{Source: s.String()}
+		if !options.WithWatcherDisabled {
+			go m.watch(i, s)
+		}
+	}
+
+	return m
+}

Server/vendor/go-micro.dev/v4/config/loader/memory/options.go

@@ -0,0 +1,27 @@
+package memory
+
+import (
+	"go-micro.dev/v4/config/loader"
+	"go-micro.dev/v4/config/reader"
+	"go-micro.dev/v4/config/source"
+)
+
+// WithSource appends a source to list of sources.
+func WithSource(s source.Source) loader.Option {
+	return func(o *loader.Options) {
+		o.Source = append(o.Source, s)
+	}
+}
+
+// WithReader sets the config reader.
+func WithReader(r reader.Reader) loader.Option {
+	return func(o *loader.Options) {
+		o.Reader = r
+	}
+}
+
+func WithWatcherDisabled() loader.Option {
+	return func(o *loader.Options) {
+		o.WithWatcherDisabled = true
+	}
+}

Server/vendor/go-micro.dev/v4/config/options.go

@@ -0,0 +1,34 @@
+package config
+
+import (
+	"go-micro.dev/v4/config/loader"
+	"go-micro.dev/v4/config/reader"
+	"go-micro.dev/v4/config/source"
+)
+
+// WithLoader sets the loader for manager config.
+func WithLoader(l loader.Loader) Option {
+	return func(o *Options) {
+		o.Loader = l
+	}
+}
+
+// WithSource appends a source to list of sources.
+func WithSource(s source.Source) Option {
+	return func(o *Options) {
+		o.Source = append(o.Source, s)
+	}
+}
+
+// WithReader sets the config reader.
+func WithReader(r reader.Reader) Option {
+	return func(o *Options) {
+		o.Reader = r
+	}
+}
+
+func WithWatcherDisabled() Option {
+	return func(o *Options) {
+		o.WithWatcherDisabled = true
+	}
+}

Server/vendor/go-micro.dev/v4/config/reader/json/json.go

@@ -0,0 +1,83 @@
+package json
+
+import (
+	"errors"
+	"time"
+
+	"github.com/imdario/mergo"
+	"go-micro.dev/v4/config/encoder"
+	"go-micro.dev/v4/config/encoder/json"
+	"go-micro.dev/v4/config/reader"
+	"go-micro.dev/v4/config/source"
+)
+
+type jsonReader struct {
+	opts reader.Options
+	json encoder.Encoder
+}
+
+func (j *jsonReader) Merge(changes ...*source.ChangeSet) (*source.ChangeSet, error) {
+	var merged map[string]interface{}
+
+	for _, m := range changes {
+		if m == nil {
+			continue
+		}
+
+		if len(m.Data) == 0 {
+			continue
+		}
+
+		codec, ok := j.opts.Encoding[m.Format]
+		if !ok {
+			// fallback
+			codec = j.json
+		}
+
+		var data map[string]interface{}
+		if err := codec.Decode(m.Data, &data); err != nil {
+			return nil, err
+		}
+		if err := mergo.Map(&merged, data, mergo.WithOverride); err != nil {
+			return nil, err
+		}
+	}
+
+	b, err := j.json.Encode(merged)
+	if err != nil {
+		return nil, err
+	}
+
+	cs := &source.ChangeSet{
+		Timestamp: time.Now(),
+		Data:      b,
+		Source:    "json",
+		Format:    j.json.String(),
+	}
+	cs.Checksum = cs.Sum()
+
+	return cs, nil
+}
+
+func (j *jsonReader) Values(ch *source.ChangeSet) (reader.Values, error) {
+	if ch == nil {
+		return nil, errors.New("changeset is nil")
+	}
+	if ch.Format != "json" {
+		return nil, errors.New("unsupported format")
+	}
+	return newValues(ch)
+}
+
+func (j *jsonReader) String() string {
+	return "json"
+}
+
+// NewReader creates a json reader.
+func NewReader(opts ...reader.Option) reader.Reader {
+	options := reader.NewOptions(opts...)
+	return &jsonReader{
+		json: json.NewEncoder(),
+		opts: options,
+	}
+}

Server/vendor/go-micro.dev/v4/config/reader/json/values.go

@@ -0,0 +1,201 @@
+package json
+
+import (
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	simple "github.com/bitly/go-simplejson"
+	"go-micro.dev/v4/config/reader"
+	"go-micro.dev/v4/config/source"
+)
+
+type jsonValues struct {
+	ch *source.ChangeSet
+	sj *simple.Json
+}
+
+type jsonValue struct {
+	*simple.Json
+}
+
+func newValues(ch *source.ChangeSet) (reader.Values, error) {
+	sj := simple.New()
+	data, _ := reader.ReplaceEnvVars(ch.Data)
+	if err := sj.UnmarshalJSON(data); err != nil {
+		sj.SetPath(nil, string(ch.Data))
+	}
+	return &jsonValues{ch, sj}, nil
+}
+
+func (j *jsonValues) Get(path ...string) reader.Value {
+	return &jsonValue{j.sj.GetPath(path...)}
+}
+
+func (j *jsonValues) Del(path ...string) {
+	// delete the tree?
+	if len(path) == 0 {
+		j.sj = simple.New()
+		return
+	}
+
+	if len(path) == 1 {
+		j.sj.Del(path[0])
+		return
+	}
+
+	vals := j.sj.GetPath(path[:len(path)-1]...)
+	vals.Del(path[len(path)-1])
+	j.sj.SetPath(path[:len(path)-1], vals.Interface())
+	return
+}
+
+func (j *jsonValues) Set(val interface{}, path ...string) {
+	j.sj.SetPath(path, val)
+}
+
+func (j *jsonValues) Bytes() []byte {
+	b, _ := j.sj.MarshalJSON()
+	return b
+}
+
+func (j *jsonValues) Map() map[string]interface{} {
+	m, _ := j.sj.Map()
+	return m
+}
+
+func (j *jsonValues) Scan(v interface{}) error {
+	b, err := j.sj.MarshalJSON()
+	if err != nil {
+		return err
+	}
+	return json.Unmarshal(b, v)
+}
+
+func (j *jsonValues) String() string {
+	return "json"
+}
+
+func (j *jsonValue) Bool(def bool) bool {
+	b, err := j.Json.Bool()
+	if err == nil {
+		return b
+	}
+
+	str, ok := j.Interface().(string)
+	if !ok {
+		return def
+	}
+
+	b, err = strconv.ParseBool(str)
+	if err != nil {
+		return def
+	}
+
+	return b
+}
+
+func (j *jsonValue) Int(def int) int {
+	i, err := j.Json.Int()
+	if err == nil {
+		return i
+	}
+
+	str, ok := j.Interface().(string)
+	if !ok {
+		return def
+	}
+
+	i, err = strconv.Atoi(str)
+	if err != nil {
+		return def
+	}
+
+	return i
+}
+
+func (j *jsonValue) String(def string) string {
+	return j.Json.MustString(def)
+}
+
+func (j *jsonValue) Float64(def float64) float64 {
+	f, err := j.Json.Float64()
+	if err == nil {
+		return f
+	}
+
+	str, ok := j.Interface().(string)
+	if !ok {
+		return def
+	}
+
+	f, err = strconv.ParseFloat(str, 64)
+	if err != nil {
+		return def
+	}
+
+	return f
+}
+
+func (j *jsonValue) Duration(def time.Duration) time.Duration {
+	v, err := j.Json.String()
+	if err != nil {
+		return def
+	}
+
+	value, err := time.ParseDuration(v)
+	if err != nil {
+		return def
+	}
+
+	return value
+}
+
+func (j *jsonValue) StringSlice(def []string) []string {
+	v, err := j.Json.String()
+	if err == nil {
+		sl := strings.Split(v, ",")
+		if len(sl) > 0 {
+			return sl
+		}
+	}
+	return j.Json.MustStringArray(def)
+}
+
+func (j *jsonValue) StringMap(def map[string]string) map[string]string {
+	m, err := j.Json.Map()
+	if err != nil {
+		return def
+	}
+
+	res := map[string]string{}
+
+	for k, v := range m {
+		res[k] = fmt.Sprintf("%v", v)
+	}
+
+	return res
+}
+
+func (j *jsonValue) Scan(v interface{}) error {
+	b, err := j.Json.MarshalJSON()
+	if err != nil {
+		return err
+	}
+	return json.Unmarshal(b, v)
+}
+
+func (j *jsonValue) Bytes() []byte {
+	b, err := j.Json.Bytes()
+	if err != nil {
+		// try return marshaled
+		b, err = j.Json.MarshalJSON()
+		if err != nil {
+			return []byte{}
+		}
+		return b
+	}
+	return b
+}

Server/vendor/go-micro.dev/v4/config/reader/options.go

@@ -0,0 +1,33 @@
+package reader
+
+import (
+	"go-micro.dev/v4/config/encoder"
+	"go-micro.dev/v4/config/encoder/json"
+)
+
+type Options struct {
+	Encoding map[string]encoder.Encoder
+}
+
+type Option func(o *Options)
+
+func NewOptions(opts ...Option) Options {
+	options := Options{
+		Encoding: map[string]encoder.Encoder{
+			"json": json.NewEncoder(),
+		},
+	}
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}
+
+func WithEncoder(e encoder.Encoder) Option {
+	return func(o *Options) {
+		if o.Encoding == nil {
+			o.Encoding = make(map[string]encoder.Encoder)
+		}
+		o.Encoding[e.String()] = e
+	}
+}

Server/vendor/go-micro.dev/v4/config/reader/preprocessor.go

@@ -0,0 +1,23 @@
+package reader
+
+import (
+	"os"
+	"regexp"
+)
+
+func ReplaceEnvVars(raw []byte) ([]byte, error) {
+	re := regexp.MustCompile(`\$\{([A-Za-z0-9_]+)\}`)
+	if re.Match(raw) {
+		dataS := string(raw)
+		res := re.ReplaceAllStringFunc(dataS, replaceEnvVars)
+		return []byte(res), nil
+	} else {
+		return raw, nil
+	}
+}
+
+func replaceEnvVars(element string) string {
+	v := element[2 : len(element)-1]
+	el := os.Getenv(v)
+	return el
+}

Server/vendor/go-micro.dev/v4/config/reader/reader.go

@@ -0,0 +1,38 @@
+// Package reader parses change sets and provides config values
+package reader
+
+import (
+	"time"
+
+	"go-micro.dev/v4/config/source"
+)
+
+// Reader is an interface for merging changesets.
+type Reader interface {
+	Merge(...*source.ChangeSet) (*source.ChangeSet, error)
+	Values(*source.ChangeSet) (Values, error)
+	String() string
+}
+
+// Values is returned by the reader.
+type Values interface {
+	Bytes() []byte
+	Get(path ...string) Value
+	Set(val interface{}, path ...string)
+	Del(path ...string)
+	Map() map[string]interface{}
+	Scan(v interface{}) error
+}
+
+// Value represents a value of any type.
+type Value interface {
+	Bool(def bool) bool
+	Int(def int) int
+	String(def string) string
+	Float64(def float64) float64
+	Duration(def time.Duration) time.Duration
+	StringSlice(def []string) []string
+	StringMap(def map[string]string) map[string]string
+	Scan(val interface{}) error
+	Bytes() []byte
+}

Server/vendor/go-micro.dev/v4/config/source/changeset.go

@@ -0,0 +1,13 @@
+package source
+
+import (
+	"crypto/md5"
+	"fmt"
+)
+
+// Sum returns the md5 checksum of the ChangeSet data.
+func (c *ChangeSet) Sum() string {
+	h := md5.New()
+	h.Write(c.Data)
+	return fmt.Sprintf("%x", h.Sum(nil))
+}

Server/vendor/go-micro.dev/v4/config/source/file/README.md

@@ -0,0 +1,69 @@
+# File Source
+
+The file source reads config from a file.
+
+It uses the File extension to determine the Format e.g `config.yaml` has the yaml format.
+It does not make use of encoders or interpet the file data. If a file extension is not present
+the source Format will default to the Encoder in options.
+
+## Example
+
+A config file format in json
+
+```json
+{
+  "hosts": {
+    "database": {
+      "address": "10.0.0.1",
+      "port": 3306
+    },
+    "cache": {
+      "address": "10.0.0.2",
+      "port": 6379
+    }
+  }
+}
+```
+
+## New Source
+
+Specify file source with path to file. Path is optional and will default to `config.json`
+
+```go
+fileSource := file.NewSource(
+	file.WithPath("/tmp/config.json"),
+)
+```
+
+## File Format
+
+To load different file formats e.g yaml, toml, xml simply specify them with their extension
+
+```go
+fileSource := file.NewSource(
+        file.WithPath("/tmp/config.yaml"),
+)
+```
+
+If you want to specify a file without extension, ensure you set the encoder to the same format
+
+```go
+e := toml.NewEncoder()
+
+fileSource := file.NewSource(
+        file.WithPath("/tmp/config"),
+        source.WithEncoder(e),
+)
+```
+
+## Load Source
+
+Load the source into config
+
+```go
+// Create new config
+conf := config.NewConfig()
+
+// Load file source
+conf.Load(fileSource)
+```

Server/vendor/go-micro.dev/v4/config/source/file/file.go

@@ -0,0 +1,87 @@
+// Package file is a file source. Expected format is json
+package file
+
+import (
+	"io"
+	"io/fs"
+	"os"
+
+	"go-micro.dev/v4/config/source"
+)
+
+type file struct {
+	opts source.Options
+	fs   fs.FS
+	path string
+}
+
+var (
+	DefaultPath = "config.json"
+)
+
+func (f *file) Read() (*source.ChangeSet, error) {
+	var fh fs.File
+	var err error
+
+	if f.fs != nil {
+		fh, err = f.fs.Open(f.path)
+	} else {
+		fh, err = os.Open(f.path)
+	}
+
+	if err != nil {
+		return nil, err
+	}
+	defer fh.Close()
+	b, err := io.ReadAll(fh)
+	if err != nil {
+		return nil, err
+	}
+	info, err := fh.Stat()
+	if err != nil {
+		return nil, err
+	}
+
+	cs := &source.ChangeSet{
+		Format:    format(f.path, f.opts.Encoder),
+		Source:    f.String(),
+		Timestamp: info.ModTime(),
+		Data:      b,
+	}
+	cs.Checksum = cs.Sum()
+
+	return cs, nil
+}
+
+func (f *file) String() string {
+	return "file"
+}
+
+func (f *file) Watch() (source.Watcher, error) {
+	// do not watch if fs.FS instance is provided
+	if f.fs != nil {
+		return source.NewNoopWatcher()
+	}
+
+	if _, err := os.Stat(f.path); err != nil {
+		return nil, err
+	}
+	return newWatcher(f)
+}
+
+func (f *file) Write(cs *source.ChangeSet) error {
+	return nil
+}
+
+func NewSource(opts ...source.Option) source.Source {
+	options := source.NewOptions(opts...)
+
+	fs, _ := options.Context.Value(fsKey{}).(fs.FS)
+
+	path := DefaultPath
+	f, ok := options.Context.Value(filePathKey{}).(string)
+	if ok {
+		path = f
+	}
+	return &file{opts: options, fs: fs, path: path}
+}

Server/vendor/go-micro.dev/v4/config/source/file/format.go

@@ -0,0 +1,15 @@
+package file
+
+import (
+	"strings"
+
+	"go-micro.dev/v4/config/encoder"
+)
+
+func format(p string, e encoder.Encoder) string {
+	parts := strings.Split(p, ".")
+	if len(parts) > 1 {
+		return parts[len(parts)-1]
+	}
+	return e.String()
+}

Server/vendor/go-micro.dev/v4/config/source/file/options.go

@@ -0,0 +1,31 @@
+package file
+
+import (
+	"context"
+	"io/fs"
+
+	"go-micro.dev/v4/config/source"
+)
+
+type filePathKey struct{}
+type fsKey struct{}
+
+// WithPath sets the path to file.
+func WithPath(p string) source.Option {
+	return func(o *source.Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, filePathKey{}, p)
+	}
+}
+
+// WithFS sets the underlying filesystem to lookup file from  (default os.FS).
+func WithFS(fs fs.FS) source.Option {
+	return func(o *source.Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, fsKey{}, fs)
+	}
+}

Server/vendor/go-micro.dev/v4/config/source/file/watcher.go

@@ -0,0 +1,68 @@
+//go:build !linux
+// +build !linux
+
+package file
+
+import (
+	"os"
+
+	"github.com/fsnotify/fsnotify"
+	"go-micro.dev/v4/config/source"
+)
+
+type watcher struct {
+	f *file
+
+	fw *fsnotify.Watcher
+}
+
+func newWatcher(f *file) (source.Watcher, error) {
+	fw, err := fsnotify.NewWatcher()
+	if err != nil {
+		return nil, err
+	}
+
+	fw.Add(f.path)
+
+	return &watcher{
+		f:  f,
+		fw: fw,
+	}, nil
+}
+
+func (w *watcher) Next() (*source.ChangeSet, error) {
+	// try get the event
+	select {
+	case event, ok := <-w.fw.Events:
+		// check if channel was closed (i.e. Watcher.Close() was called).
+		if !ok {
+			return nil, source.ErrWatcherStopped
+		}
+
+		if event.Has(fsnotify.Rename) {
+			// check existence of file, and add watch again
+			_, err := os.Stat(event.Name)
+			if err == nil || os.IsExist(err) {
+				w.fw.Add(event.Name)
+			}
+		}
+
+		c, err := w.f.Read()
+		if err != nil {
+			return nil, err
+		}
+
+		return c, nil
+	case err, ok := <-w.fw.Errors:
+		// check if channel was closed (i.e. Watcher.Close() was called).
+		if !ok {
+			return nil, source.ErrWatcherStopped
+		}
+
+		return nil, err
+	}
+}
+
+func (w *watcher) Stop() error {
+	return w.fw.Close()
+}

Server/vendor/go-micro.dev/v4/config/source/file/watcher_linux.go

@@ -0,0 +1,71 @@
+//go:build linux
+// +build linux
+
+package file
+
+import (
+	"os"
+
+	"github.com/fsnotify/fsnotify"
+	"go-micro.dev/v4/config/source"
+)
+
+type watcher struct {
+	f *file
+
+	fw *fsnotify.Watcher
+}
+
+func newWatcher(f *file) (source.Watcher, error) {
+	fw, err := fsnotify.NewWatcher()
+	if err != nil {
+		return nil, err
+	}
+
+	fw.Add(f.path)
+
+	return &watcher{
+		f:  f,
+		fw: fw,
+	}, nil
+}
+
+func (w *watcher) Next() (*source.ChangeSet, error) {
+	// try get the event
+	select {
+	case event, ok := <-w.fw.Events:
+		// check if channel was closed (i.e. Watcher.Close() was called).
+		if !ok {
+			return nil, source.ErrWatcherStopped
+		}
+
+		if event.Has(fsnotify.Rename) {
+			// check existence of file, and add watch again
+			_, err := os.Stat(event.Name)
+			if err == nil || os.IsExist(err) {
+				w.fw.Add(event.Name)
+			}
+		}
+
+		c, err := w.f.Read()
+		if err != nil {
+			return nil, err
+		}
+
+		// add path again for the event bug of fsnotify
+		w.fw.Add(w.f.path)
+
+		return c, nil
+	case err, ok := <-w.fw.Errors:
+		// check if channel was closed (i.e. Watcher.Close() was called).
+		if !ok {
+			return nil, source.ErrWatcherStopped
+		}
+
+		return nil, err
+	}
+}
+
+func (w *watcher) Stop() error {
+	return w.fw.Close()
+}

Server/vendor/go-micro.dev/v4/config/source/noop.go

@@ -0,0 +1,25 @@
+package source
+
+import (
+	"errors"
+)
+
+type noopWatcher struct {
+	exit chan struct{}
+}
+
+func (w *noopWatcher) Next() (*ChangeSet, error) {
+	<-w.exit
+
+	return nil, errors.New("noopWatcher stopped")
+}
+
+func (w *noopWatcher) Stop() error {
+	close(w.exit)
+	return nil
+}
+
+// NewNoopWatcher returns a watcher that blocks on Next() until Stop() is called.
+func NewNoopWatcher() (Watcher, error) {
+	return &noopWatcher{exit: make(chan struct{})}, nil
+}

Server/vendor/go-micro.dev/v4/config/source/options.go

@@ -0,0 +1,50 @@
+package source
+
+import (
+	"context"
+
+	"go-micro.dev/v4/client"
+	"go-micro.dev/v4/config/encoder"
+	"go-micro.dev/v4/config/encoder/json"
+)
+
+type Options struct {
+	// Encoder
+	Encoder encoder.Encoder
+
+	// for alternative data
+	Context context.Context
+
+	// Client to use for RPC
+	Client client.Client
+}
+
+type Option func(o *Options)
+
+func NewOptions(opts ...Option) Options {
+	options := Options{
+		Encoder: json.NewEncoder(),
+		Context: context.Background(),
+		Client:  client.DefaultClient,
+	}
+
+	for _, o := range opts {
+		o(&options)
+	}
+
+	return options
+}
+
+// WithEncoder sets the source encoder.
+func WithEncoder(e encoder.Encoder) Option {
+	return func(o *Options) {
+		o.Encoder = e
+	}
+}
+
+// WithClient sets the source client.
+func WithClient(c client.Client) Option {
+	return func(o *Options) {
+		o.Client = c
+	}
+}

Server/vendor/go-micro.dev/v4/config/source/source.go

@@ -0,0 +1,35 @@
+// Package source is the interface for sources
+package source
+
+import (
+	"errors"
+	"time"
+)
+
+var (
+	// ErrWatcherStopped is returned when source watcher has been stopped.
+	ErrWatcherStopped = errors.New("watcher stopped")
+)
+
+// Source is the source from which config is loaded.
+type Source interface {
+	Read() (*ChangeSet, error)
+	Write(*ChangeSet) error
+	Watch() (Watcher, error)
+	String() string
+}
+
+// ChangeSet represents a set of changes from a source.
+type ChangeSet struct {
+	Timestamp time.Time
+	Checksum  string
+	Format    string
+	Source    string
+	Data      []byte
+}
+
+// Watcher watches a source for changes.
+type Watcher interface {
+	Next() (*ChangeSet, error)
+	Stop() error
+}

Server/vendor/go-micro.dev/v4/config/value.go

@@ -0,0 +1,49 @@
+package config
+
+import (
+	"time"
+
+	"go-micro.dev/v4/config/reader"
+)
+
+type value struct{}
+
+func newValue() reader.Value {
+	return new(value)
+}
+
+func (v *value) Bool(def bool) bool {
+	return false
+}
+
+func (v *value) Int(def int) int {
+	return 0
+}
+
+func (v *value) String(def string) string {
+	return ""
+}
+
+func (v *value) Float64(def float64) float64 {
+	return 0.0
+}
+
+func (v *value) Duration(def time.Duration) time.Duration {
+	return time.Duration(0)
+}
+
+func (v *value) StringSlice(def []string) []string {
+	return nil
+}
+
+func (v *value) StringMap(def map[string]string) map[string]string {
+	return map[string]string{}
+}
+
+func (v *value) Scan(val interface{}) error {
+	return nil
+}
+
+func (v *value) Bytes() []byte {
+	return nil
+}