gitee.com/woood2/luca@v1.0.4/internal/conf/attr.go

package conf

import (
	"gitee.com/woood2/luca/internal/util"
	"github.com/hashicorp/consul/api"
	"gopkg.in/yaml.v2"
	"log"
	"path/filepath"
)

const (
	DevEnv  = "dev"
	DemoEnv = "demo"
	TestEnv = "test"
	PreEnv  = "pre"
	ProEnv  = "pro"
)

const (
	ConfigTypeFile   = "file"
	ConfigTypeConsul = "consul"
)

func IsPro(env string) bool {
	return env == ProEnv
}

type Config struct {
	//stub part.总是在application.yml
	Host       string  `yaml:"host"`
	ConfigType string  `yaml:"configType"` //file|consul
	DataKey    string  `yaml:"dataKey"`    //consul kv key, such as "config/luca/attr"
	Consul     *Consul `yaml:"consul"`
	//detail part.当configType=file，下列配置项位于application.yml；当configType=consul，下列配置项位于consul kv存储
	Project    string `yaml:"project"`
	Env        string `yaml:"env"`
	ConsoleLog bool   `yaml:"consoleLog"` //本地dev通常使用console，远程dev通常使用file。且本地经常需要切换试验。
	//components
	Pprof  *Pprof  `yaml:"pprof"`
	Mysql  *Mysql  `yaml:"mysql"`
	Mongo  *Mongo  `yaml:"mongo"`
	Redis  *Redis  `yaml:"redis"`
	Zipkin *Zipkin `yaml:"zipkin"`
	Kafka  *Kafka  `yaml:"kafka"`
	//entries
	Backend  *Restful  `yaml:"backend"`
	Micro    *Micro    `yaml:"micro"`
	Consumer *Consumer `yaml:"consumer"`
	Cron     *Cron     `yaml:"cron"`
}

type Pprof struct {
	User string `yaml:"user"`
	Pwd  string `yaml:"pwd"`
}

type Mysql struct {
	User         string `yaml:"user"`
	Pwd          string `yaml:"pwd"`
	Host         string `yaml:"host"`
	Port         int    `yaml:"port"`
	DB           string `yaml:"db"`
	MaxOpenConns int    `yaml:"maxOpenConns"` //yml中若不设置，则最大连接数无限制
	MaxIdleConns int    `yaml:"maxIdleConns"` //yml中若不设置，则不保持任何空闲连接
}

type Mongo struct {
	User        string `yaml:"user"`
	Pwd         string `yaml:"pwd"`
	Host        string `yaml:"host"`
	Port        int    `yaml:"port"`
	DB          string `yaml:"db"`
	MaxPoolSize int    `yaml:"maxPoolSize"` //yml中若不设置，则最大连接数为math.MaxInt64，等于无限制
	MinPoolSize int    `yaml:"minPoolSize"` //yml中若不设置，则最小连接数为0，允许不保持任何空闲连接
}

type Redis struct {
	/**
	single-mode ":7001"
	cluster-mode ":7001,:7002,:7003"
	*/
	Addr         string `yaml:"addr"`
	Pwd          string `yaml:"pwd"`
	PoolSize     int    `yaml:"poolSize"`     //yml中若不设置，则最大连接数为 10 * runtime.NumCPU()
	MinIdleConns int    `yaml:"minIdleConns"` //yml中若不设置，则最小空闲连接数为0，允许不保持任何空闲连接
}

type Zipkin struct {
	ReporterAddr string `yaml:"reporterAddr"`
}

type Consul struct {
	Host string `yaml:"host"`
	Port int    `yaml:"port"`
}

type Kafka struct {
	Version    string   `yaml:"version"`
	Brokers    []string `yaml:"brokers"`
	EnableSASL bool     `yaml:"enableSASL"`
	User       string   `yaml:"user"`
	Password   string   `yaml:"password"`
	Algorithm  string   `yaml:"algorithm"` //"sha512" | "sha256"
}

type Restful struct {
	Addr        string `yaml:"addr"`
	Register    bool   `yaml:"register"`
	PprofAddr   string `yaml:"pprofAddr"`
	MetricsAddr string `yaml:"metricsAddr"`
	HystrixPort int    `yaml:"hystrixPort"`
	/**
	multi: ["http://google.com", "http://facebook.com"]
	all: ["*"]
	*/
	AllowOrigins []string `yaml:"allowOrigins"`
}

type Micro struct {
	Port        int    `yaml:"port"`
	Register    bool   `yaml:"register"`
	PprofAddr   string `yaml:"pprofAddr"`
	MetricsAddr string `yaml:"metricsAddr"`
	HystrixPort int    `yaml:"hystrixPort"`
}

type Consumer struct {
	PprofAddr   string `yaml:"pprofAddr"`
	MetricsAddr string `yaml:"metricsAddr"`
	HystrixPort int    `yaml:"hystrixPort"`
}

type Cron struct {
	PprofAddr   string `yaml:"pprofAddr"`
	HystrixPort int    `yaml:"hystrixPort"`
}

func Load(relativePaths ...string) (cnf *Config) {
	var c = new(Config)
	for _, path := range relativePaths {
		p := []string{path}
		for i := 0; i < 10; i++ {
			if i > 0 {
				p = append([]string{".."}, p...)
			}
			f := filepath.Join(p...)
			err := util.LoadYAML(f, &c)
			if err == nil {
				log.Printf("%s loaded successfully\n", f)
				return c
			}
		}
	}
	log.Panicln("Failed to load configuration file")
	return nil
}

func MergeConsul(attr *Config, client *api.Client) {
	if attr.ConfigType == ConfigTypeConsul {
		data, _, _ := client.KV().Get(attr.DataKey, nil)
		if data == nil {
			log.Panicf("Consul key does not exist: %s\n", attr.DataKey)
		}
		dataString := string(data.Value)
		detail := new(Config)
		if err := yaml.Unmarshal([]byte(dataString), &detail); err != nil {
			log.Panicf("yaml.Unmarshal(%s, ...) error: %v\n", dataString, err)
		}
		attr.Project = detail.Project
		attr.Env = detail.Env
		attr.ConsoleLog = detail.ConsoleLog
		attr.Pprof = detail.Pprof

		attr.Mysql = detail.Mysql
		attr.Mongo = detail.Mongo
		attr.Redis = detail.Redis
		attr.Zipkin = detail.Zipkin
		attr.Kafka = detail.Kafka

		attr.Backend = detail.Backend
		attr.Micro = detail.Micro
		attr.Consumer = detail.Consumer
		attr.Cron = detail.Cron
		log.Printf("Consul data merged, key=%s\n", attr.DataKey)
	} else if attr.ConfigType != ConfigTypeFile {
		log.Panicf("Invalid configType: %s\n", attr.ConfigType)
	}
}