godns/settings/settings.go

package settings

import (
	"flag"
	"fmt"
	"meow.tf/joker/godns/log"
	"os"
	"strconv"

	"github.com/BurntSushi/toml"
	"github.com/caarlos0/env"
)

var (
	settings Settings
)

var LogLevelMap = map[string]int{
	"DEBUG":  log.LevelDebug,
	"INFO":   log.LevelInfo,
	"NOTICE": log.LevelNotice,
	"WARN":   log.LevelWarn,
	"ERROR":  log.LevelError,
}

type HostsSettings struct {
	Enable          bool `toml:"enable" env:"HOSTS_ENABLE"`
	HostsFile       string `toml:"host-file" env:"HOSTS_FILE"`
	RedisEnable     bool   `toml:"redis-enable" env:"REDIS_HOSTS_ENABLE"`
	RedisKey        string `toml:"redis-key" env:"REDIS_HOSTS_KEY"`
	TTL             uint32 `toml:"ttl" env:"HOSTS_TTL"`
	RefreshInterval uint32 `toml:"refresh-interval" env:"HOSTS_REFRESH_INTERVAL"`
}

type Settings struct {
	Version      string `toml:"version"`
	Debug        bool `toml:"debug"`
	Server       DNSServerSettings `toml:"server"`
	ResolvConfig ResolvSettings    `toml:"resolv"`
	Redis        RedisSettings     `toml:"redis"`
	Memcache     MemcacheSettings  `toml:"memcache"`
	Log          LogSettings       `toml:"log"`
	Cache        CacheSettings     `toml:"cache"`
	Hosts        HostsSettings     `toml:"hosts"`
}

type ResolvSettings struct {
	Timeout        int `toml:"timeout" env:"RESOLV_TIMEOUT"`
	Interval       int `toml:"interval" env:"RESOLV_INTERVAL"`
	SetEDNS0       bool `toml:"setedns0" env:"RESOLV_EDNS0"`
	ServerListFile string `toml:"server-list-file" env:"SERVER_LIST_FILE"`
	ResolvFile     string `toml:"resolv-file" env:"RESOLV_FILE"`
	DOHServer      string `toml:"dns-over-https" env:"DNS_HTTPS_SERVER"`
}

type DNSServerSettings struct {
	Host string `toml:"host" env:"SERVER_BIND"`
	Port int `toml:"port" env:"SERVER_PORT"`
}

type RedisSettings struct {
	Host     string `toml:"host" env:"REDIS_HOST"`
	Port     int `toml:"port" env:"REDIS_PORT"`
	DB       int `toml:"db" env:"REDIS_DB"`
	Password string `toml:"password" env:"REDIS_PASSWORD"`
}

type MemcacheSettings struct {
	Servers []string `toml:"servers" env:"MEMCACHE_SERVERS"`
}

func (s RedisSettings) Addr() string {
	return s.Host + ":" + strconv.Itoa(s.Port)
}

type LogSettings struct {
	Stdout bool `toml:"stdout" env:"LOG_STDOUT"`
	File   string `toml:"file" env:"LOG_FILE"`
	Level  string `toml:"level" env:"LOG_LEVEL"`
}

func (ls LogSettings) LogLevel() int {
	l, ok := LogLevelMap[ls.Level]
	if !ok {
		panic("Config error: invalid log level: " + ls.Level)
	}
	return l
}

type CacheSettings struct {
	Backend  string `toml:"backend" env:"CACHE_BACKEND"`
	Expire   int `toml:"expire" env:"CACHE_EXPIRE"`
	Maxcount int `toml:"maxcount" env:"CACHE_MAX_COUNT"`
}

func init() {
	var configFile string

	flag.StringVar(&configFile, "c", "/etc/godns.conf", "Look for godns toml-formatting config file in this directory")
	flag.Parse()

	if _, err := toml.DecodeFile(configFile, &settings); err != nil {
		fmt.Printf("%s is not a valid toml config file\n", configFile)
		fmt.Println(err)
		os.Exit(1)
	}

	env.Parse(&settings.ResolvConfig)
	env.Parse(&settings.Redis)
	env.Parse(&settings.Memcache)
	env.Parse(&settings.Log)
	env.Parse(&settings.Cache)
	env.Parse(&settings.Hosts)
}

func Resolver() ResolvSettings {
	return settings.ResolvConfig
}

func Cache() CacheSettings {
	return settings.Cache
}

func Server() DNSServerSettings {
	return settings.Server
}

func Hosts() HostsSettings {
	return settings.Hosts
}

func Redis() RedisSettings {
	return settings.Redis
}

func Memcache() MemcacheSettings {
	return settings.Memcache
}

func Debug() bool {
	return settings.Debug
}

func Log() LogSettings {
	return settings.Log
}