关于micro:go-micro-config

6次阅读

共计 2866 个字符，预计需要花费 8 分钟才能阅读完成。

micro.newService()中 newOptions

func newOptions(opts ...Option) Options {
    opt := Options{
        Auth:      auth.DefaultAuth,
        Broker:    broker.DefaultBroker,
        Cmd:       cmd.DefaultCmd,
        Config:    config.DefaultConfig,
        Client:    client.DefaultClient,
        Server:    server.DefaultServer,
        Store:     store.DefaultStore,
        Registry:  registry.DefaultRegistry,
        Router:    router.DefaultRouter,
        Runtime:   runtime.DefaultRuntime,
        Transport: transport.DefaultTransport,
        Context:   context.Background(),
        Signal:    true,
    }

    for _, o := range opts {o(&opt)
    }

    return opt
}

初始化了一堆根底设置，来看看 config
config.DefaultConfig,
在 config/config.go 中

var (
    // Default Config Manager
    DefaultConfig, _ = NewConfig())

// NewConfig returns new config
func NewConfig(opts ...Option) (Config, error) {return newConfig(opts...)
}

func newConfig(opts ...Option) (Config, error) {
    var c config

    c.Init(opts...)
    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 {c.opts.Loader = memory.NewLoader(memory.WithReader(c.opts.Reader))
    }

    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) 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:
            }
            w.Stop()}()

        // 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:
        }
    }
}

看看 Init() 左做了什么

初始化并设置 opts，创立 exit 用于监听退出信号，设置 opts
设置默认 loader，c.opts.Loader 默认是 memory memory.NewLoader()[config/loader/memory/memory.go]
1. 初始化并设置 opts，蕴含 Reader[默认 json]
2. 初始化 memory{}
3. 设置 m.sets, 并 watch() 每个 options.Source，看看 watch() 做了什么
  1. 定义 watch()函数
    1. 调用 watcher.Next(), 上面看看 next()做了什么
      1. 定义 update()函数，返回 loader.Snapshot{}
      2. 监听 watcher.exit，watcher.updates 信号，有更新时且版本更新时，调用下面的 update()函数，更新 watcher.value 并返回 loader.Snapshot{}
    2. 保留 m.sets[idx]，值为 loader.Snapshot{}
    3. 合并所有 m.sets
    4. 读取所有值到 m.vals, 保留快照到 m.snap
    5. 调用 update()
      1. 获取所有 watcher，如果版本有更新，则发送 watcher.updates 信号
  2. 调用 Watch()函数返回 watcher，留神 W 是大写, 调用的是 memory.Watch()
    1. 调用 Get()，返回 m.vals.Get(path…)
    2. 初始化 watcher，并增加到 m.watchers【双向链表】
    3. 开协程，监听 watcher.exit 信号, 收到信号从 watchers 中移除以后 watcher
  3. 开协程，监听实现信号 done 和 exit 信号，收到信号后执行 Stop(), 敞开 exit，updates 这 2 个 channel
  4. 调用下面定义的 watch()
  5. 敞开 done channel，监听 m.exit 信号
调用 c.opts.Loader.Load()
1. 循环所有 source，更新 m.sources,m.sets, 并 watch()所有 source
2. 调用reload()
  1. 合并所有 sets
  2. 设置 m.vals,m.snap
  3. 调用 m.update()
调用c.opts.Loader.Snapshot()
1. 如曾经 load，间接复制一份并返回 m.snap
2. 没载入就调用 Sync() 同步配置
3. 复制一份 m.snap 返回
调用 c.opts.Reader.Values()，赋值 config.vals【reader.Values 类型】