ebpf/config/euspaceCfg.go

package config

import (
	"fmt"
	"github.com/coroot/coroot-node-agent/flags"
	"github.com/coroot/coroot-node-agent/utils"
	"github.com/coroot/coroot-node-agent/utils/enums"
	"github.com/fsnotify/fsnotify"
	log "github.com/sirupsen/logrus"
	"github.com/spf13/viper"
	"reflect"
)

type euspaceCfgRecord struct {
	LogLevel        string `mapstructure:"logLevel"`
	NetDataInterval int    `mapstructure:"netDataInterval"`
	ConfigServer    string `mapstructure:"configServer"`
	DataServer      string `mapstructure:"dataServer"`
}

type euspaceCfg struct {
	runtimeV      *viper.Viper
	watchedV      *viper.Viper
	cfgRecordLast *euspaceCfgRecord
}

func initEuspaceCfg() (*euspaceCfg, error) {
	v := viper.New()
	v.SetConfigName("config")
	v.SetConfigType("yaml")
	v.AddConfigPath(utils.GetDefaultConfPath())
	if err := v.ReadInConfig(); err != nil {
		/*if _, ok := err.(viper.ConfigFileNotFoundError); !ok {
			return nil, err
		}*/
		return nil, err
	}

	sv := viper.New()
	sv.SetConfigFile(v.ConfigFileUsed())

	ec := &euspaceCfg{
		runtimeV:      v,
		watchedV:      sv,
		cfgRecordLast: new(euspaceCfgRecord),
	}
	ec.setDefault()
	return ec, nil
}

func (ec *euspaceCfg) setDefault() {
	ec.runtimeV.SetDefault("logLevel", enums.DefaultLogLevel)
	ec.runtimeV.SetDefault("netDataInterval", enums.DefaultNetDataInterval1Min)
	ec.runtimeV.SetDefault("configServer", "")
	ec.runtimeV.SetDefault("dataServer", "")
}

func (ec *euspaceCfg) syncConfToFile(ecr *euspaceCfgRecord) error {
	if ecr != nil {

		syncV := viper.New()
		syncV.SetConfigFile(ec.watchedV.ConfigFileUsed())
		syncV.Set("logLevel", ecr.LogLevel)
		syncV.Set("netDataInterval", ecr.NetDataInterval)
		syncV.Set("configServer", ecr.ConfigServer)
		syncV.Set("dataServer", ecr.DataServer)
		err := syncV.WriteConfig()
		if err != nil {
			return fmt.Errorf("sync Config to [%s] failed : %s", ec.watchedV.ConfigFileUsed(), err.Error())
		}
		return nil
	}
	return fmt.Errorf("sync Config to [%s] euspaceCfgRecord is nil", ec.watchedV.ConfigFileUsed())
}

func (ec *euspaceCfg) watchConfig(c *Config) {
	ec.watchedV.OnConfigChange(func(e fsnotify.Event) {
		//fmt.Printf("euspaceCfg Config file changed [%s],Op:%d ,AllKeys:%#v======> \n", e.Name, e.Op, ec.watchedV.AllSettings())

		if !e.Op.Has(fsnotify.Create) && !e.Op.Has(fsnotify.Write) {
			return
		}

		c.m.Lock()
		//defer c.m.Unlock()
		cr := new(euspaceCfgRecord)
		if err := ec.watchedV.Unmarshal(cr); err != nil {
			log.Warningf("on-Config-change, `watchedV` unmarshal `euspaceCfgRecord` failed : %s", err.Error())
			c.m.Unlock()
			return
		}

		if reflect.DeepEqual(ec.cfgRecordLast, cr) {
			c.m.Unlock()
			return
		}
		//拷贝ec.cfgRecordLast 到临时变量，目的是及时释放锁
		crLast := ec.cfgRecordLast
		//update cfgRecordLast
		ec.cfgRecordLast = cr
		c.m.Unlock()

		if *flags.ConfigServer == "" {
			if crLast.ConfigServer != cr.ConfigServer {
				c.m.Lock()
				ec.runtimeV.Set("configServer", cr.ConfigServer)
				c.m.Unlock()
				c.noticeSubscribers(ScbTypeConfigServerChg)
			}
		}

		if *flags.DataServer == "" {
			if crLast.DataServer != cr.DataServer {
				c.m.Lock()
				ec.runtimeV.Set("dataServer", cr.DataServer)
				c.m.Unlock()
				c.noticeSubscribers(ScbTypeDataServerChg)
				c.noticeSubscribers(ScbTypeTracesEndpointChg)
			}
		}

		if *flags.LogLevel == "" {
			if crLast.LogLevel != cr.LogLevel {
				c.m.Lock()
				ec.runtimeV.Set("logLevel", cr.LogLevel)
				c.m.Unlock()
				c.noticeSubscribers(ScbTypeLogLevelChg)
			}
		}

		if crLast.NetDataInterval != cr.NetDataInterval {
			c.m.Lock()
			ec.runtimeV.Set("netDataInterval", cr.NetDataInterval)
			c.m.Unlock()
			c.noticeSubscribers(ScbTypeNetDataIntervalChg)
		}
	})
	ec.watchedV.WatchConfig()
}