From dad8275bd57a42453301f81f9bc9a75c25c33960 Mon Sep 17 00:00:00 2001 From: baozhecheng Date: Wed, 10 Aug 2022 13:46:13 +0800 Subject: [PATCH] fix lint --- contrib/config/apollo/apollo.go | 306 ++++++++++++++++---------------- 1 file changed, 153 insertions(+), 153 deletions(-) diff --git a/contrib/config/apollo/apollo.go b/contrib/config/apollo/apollo.go index acf767cac..f5a674a67 100644 --- a/contrib/config/apollo/apollo.go +++ b/contrib/config/apollo/apollo.go @@ -1,228 +1,228 @@ package apollo import ( - "strings" + "strings" - "github.com/go-kratos/kratos/v2/config" - "github.com/go-kratos/kratos/v2/encoding" - "github.com/go-kratos/kratos/v2/log" + "github.com/go-kratos/kratos/v2/config" + "github.com/go-kratos/kratos/v2/encoding" + "github.com/go-kratos/kratos/v2/log" - "github.com/apolloconfig/agollo/v4" - apolloConfig "github.com/apolloconfig/agollo/v4/env/config" + "github.com/apolloconfig/agollo/v4" + apolloConfig "github.com/apolloconfig/agollo/v4/env/config" ) type apollo struct { - client agollo.Client - opt *options + client agollo.Client + opt *options } const ( - yaml = "yaml" - yml = "yml" - json = "json" - properties = "properties" + yaml = "yaml" + yml = "yml" + json = "json" + properties = "properties" ) // Option is apollo option type Option func(*options) type options struct { - appid string - secret string - cluster string - endpoint string - namespace string - isBackupConfig bool - backupPath string + appid string + secret string + cluster string + endpoint string + namespace string + isBackupConfig bool + backupPath string } // WithAppID with apollo config app id func WithAppID(appID string) Option { - return func(o *options) { - o.appid = appID - } + return func(o *options) { + o.appid = appID + } } // WithCluster with apollo config cluster func WithCluster(cluster string) Option { - return func(o *options) { - o.cluster = cluster - } + return func(o *options) { + o.cluster = cluster + } } // WithEndpoint with apollo config conf server ip func WithEndpoint(endpoint string) Option { - return func(o *options) { - o.endpoint = endpoint - } + return func(o *options) { + o.endpoint = endpoint + } } // WithEnableBackup with apollo config enable backup config func WithEnableBackup() Option { - return func(o *options) { - o.isBackupConfig = true - } + return func(o *options) { + o.isBackupConfig = true + } } // WithDisableBackup with apollo config enable backup config func WithDisableBackup() Option { - return func(o *options) { - o.isBackupConfig = false - } + return func(o *options) { + o.isBackupConfig = false + } } // WithSecret with apollo config app secret func WithSecret(secret string) Option { - return func(o *options) { - o.secret = secret - } + return func(o *options) { + o.secret = secret + } } // WithNamespace with apollo config namespace name func WithNamespace(name string) Option { - return func(o *options) { - o.namespace = name - } + return func(o *options) { + o.namespace = name + } } // WithBackupPath with apollo config backupPath func WithBackupPath(backupPath string) Option { - return func(o *options) { - o.backupPath = backupPath - } + return func(o *options) { + o.backupPath = backupPath + } } func NewSource(opts ...Option) config.Source { - op := options{} - for _, o := range opts { - o(&op) - } - client, err := agollo.StartWithConfig(func() (*apolloConfig.AppConfig, error) { - return &apolloConfig.AppConfig{ - AppID: op.appid, - Cluster: op.cluster, - NamespaceName: op.namespace, - IP: op.endpoint, - IsBackupConfig: op.isBackupConfig, - Secret: op.secret, - BackupConfigPath: op.backupPath, - }, nil - }) - if err != nil { - panic(err) - } - return &apollo{client: client, opt: &op} + op := options{} + for _, o := range opts { + o(&op) + } + client, err := agollo.StartWithConfig(func() (*apolloConfig.AppConfig, error) { + return &apolloConfig.AppConfig{ + AppID: op.appid, + Cluster: op.cluster, + NamespaceName: op.namespace, + IP: op.endpoint, + IsBackupConfig: op.isBackupConfig, + Secret: op.secret, + BackupConfigPath: op.backupPath, + }, nil + }) + if err != nil { + panic(err) + } + return &apollo{client: client, opt: &op} } func format(ns string) string { - arr := strings.Split(ns, ".") - if len(arr) <= 1 || arr[len(arr)-1] == properties { - return json - } - return arr[len(arr)-1] + arr := strings.Split(ns, ".") + if len(arr) <= 1 || arr[len(arr)-1] == properties { + return json + } + return arr[len(arr)-1] } func (e *apollo) load() []*config.KeyValue { - kv := make([]*config.KeyValue, 0) - namespaces := strings.Split(e.opt.namespace, ",") - - for _, ns := range namespaces { - if strings.Contains(ns, ".") && !strings.Contains(ns, properties) && - (format(ns) == yaml || format(ns) == yml || format(ns) == json) { - value, err := e.client.GetConfigCache(ns).Get("content") - if err != nil { - log.Errorf("apollo get config failed，err:%v", err) - continue - } - // serialize the namespace content KeyValue into bytes. - kv = append(kv, &config.KeyValue{ - Key: ns, - Value: []byte(value.(string)), - Format: format(ns), - }) - continue - } - next := map[string]interface{}{} - e.client.GetConfigCache(ns).Range(func(key, value interface{}) bool { - // all values are out properties format - resolve(genKey(ns, key.(string)), value, next) - return true - }) - f := format(ns) - codec := encoding.GetCodec(f) - val, err := codec.Marshal(next) - if err != nil { - log.Warnf("apollo could not handle namespace %s: %v", ns, err) - continue - } - kv = append(kv, &config.KeyValue{ - Key: ns, - Value: val, - Format: f, - }) - } - return kv + kv := make([]*config.KeyValue, 0) + namespaces := strings.Split(e.opt.namespace, ",") + + for _, ns := range namespaces { + if strings.Contains(ns, ".") && !strings.Contains(ns, properties) && + (format(ns) == yaml || format(ns) == yml || format(ns) == json) { + value, err := e.client.GetConfigCache(ns).Get("content") + if err != nil { + log.Errorf("apollo get config failed，err:%v", err) + continue + } + // serialize the namespace content KeyValue into bytes. + kv = append(kv, &config.KeyValue{ + Key: ns, + Value: []byte(value.(string)), + Format: format(ns), + }) + continue + } + next := map[string]interface{}{} + e.client.GetConfigCache(ns).Range(func(key, value interface{}) bool { + // all values are out properties format + resolve(genKey(ns, key.(string)), value, next) + return true + }) + f := format(ns) + codec := encoding.GetCodec(f) + val, err := codec.Marshal(next) + if err != nil { + log.Warnf("apollo could not handle namespace %s: %v", ns, err) + continue + } + kv = append(kv, &config.KeyValue{ + Key: ns, + Value: val, + Format: f, + }) + } + return kv } func (e *apollo) Load() (kv []*config.KeyValue, err error) { - return e.load(), nil + return e.load(), nil } func (e *apollo) Watch() (config.Watcher, error) { - w, err := newWatcher(e) - if err != nil { - return nil, err - } - return w, nil + w, err := newWatcher(e) + if err != nil { + return nil, err + } + return w, nil } // resolve convert kv pair into one map[string]interface{} by split key into different // map level. such as: app.name = "application" => map[app][name] = "application" func resolve(key string, value interface{}, target map[string]interface{}) { - // expand key "aaa.bbb" into map[aaa]map[bbb]interface{} - keys := strings.Split(key, ".") - last := len(keys) - 1 - cursor := target - - for i, k := range keys { - if i == last { - cursor[k] = value - break - } - - // not the last key, be deeper - v, ok := cursor[k] - if !ok { - // create a new map - deeper := make(map[string]interface{}) - cursor[k] = deeper - cursor = deeper - continue - } - - // current exists, then check existing value type, if it's not map - // that means duplicate keys, and at least one is not map instance. - if cursor, ok = v.(map[string]interface{}); !ok { - log.Warnf("duplicate key: %v\n", strings.Join(keys[:i+1], ".")) - break - } - } + // expand key "aaa.bbb" into map[aaa]map[bbb]interface{} + keys := strings.Split(key, ".") + last := len(keys) - 1 + cursor := target + + for i, k := range keys { + if i == last { + cursor[k] = value + break + } + + // not the last key, be deeper + v, ok := cursor[k] + if !ok { + // create a new map + deeper := make(map[string]interface{}) + cursor[k] = deeper + cursor = deeper + continue + } + + // current exists, then check existing value type, if it's not map + // that means duplicate keys, and at least one is not map instance. + if cursor, ok = v.(map[string]interface{}); !ok { + log.Warnf("duplicate key: %v\n", strings.Join(keys[:i+1], ".")) + break + } + } } // genKey got the key of config.KeyValue pair. // eg: namespace.ext with subKey got namespace.subKey func genKey(ns, sub string) string { - arr := strings.Split(ns, ".") - if len(arr) < 1 { - return sub - } - - if len(arr) == 1 { - if ns == "" { - return sub - } - return ns + "." + sub - } - - return strings.Join(arr[:len(arr)-1], ".") + "." + sub + arr := strings.Split(ns, ".") + if len(arr) < 1 { + return sub + } + + if len(arr) == 1 { + if ns == "" { + return sub + } + return ns + "." + sub + } + + return strings.Join(arr[:len(arr)-1], ".") + "." + sub }