151 lignes
3,7 Kio
Go
151 lignes
3,7 Kio
Go
package config
|
|
|
|
import (
|
|
"encoding/json"
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"log"
|
|
"os"
|
|
|
|
yaml "gopkg.in/yaml.v2"
|
|
)
|
|
|
|
var (
|
|
// DefaultConfigPath : path to the default config file (please do not change it)
|
|
DefaultConfigPath = "config/default_config.yml"
|
|
// ConfigPath : path to the user specific config file (please do not change it)
|
|
ConfigPath = "config/config.yml"
|
|
)
|
|
|
|
// Conf : Modified configuration
|
|
var Conf *Config
|
|
var privateConf Config
|
|
|
|
// IsSukebei : Tells if we are on the sukebei website
|
|
func IsSukebei() bool {
|
|
return Conf.Models.TorrentsTableName == "sukebei_torrents"
|
|
}
|
|
|
|
var allowedDatabaseTypes = map[string]bool{
|
|
"sqlite3": true,
|
|
"postgres": true,
|
|
"mysql": true,
|
|
"mssql": true,
|
|
}
|
|
|
|
var allowedDBLogModes = map[string]bool{
|
|
"default": true, // errors only
|
|
"detailed": true,
|
|
"silent": true,
|
|
}
|
|
|
|
func init() {
|
|
Parse()
|
|
}
|
|
|
|
// Parse : Parse config into a config variable
|
|
func Parse() {
|
|
getDefaultConfig()
|
|
privateConf = *DefaultConfig
|
|
Conf = &privateConf
|
|
overrideDefaults()
|
|
}
|
|
|
|
func overrideDefaults() {
|
|
data, err := ioutil.ReadFile(ConfigPath)
|
|
if err != nil {
|
|
log.Printf("can't read file '%s'", ConfigPath)
|
|
}
|
|
err = yaml.Unmarshal(data, &Conf)
|
|
if err != nil {
|
|
log.Printf("error: %v", err)
|
|
}
|
|
}
|
|
|
|
// BindFlags returns a function which is to be used after
|
|
// flag.Parse to check and copy the flags' values to the Config instance.
|
|
func (config *Config) BindFlags() func() error {
|
|
confFile := flag.String("conf", "", "path to the configuration file")
|
|
dbType := flag.String("dbtype", Conf.DBType, "database backend")
|
|
host := flag.String("host", Conf.Host, "binding address of the server")
|
|
port := flag.Int("port", Conf.Port, "port of the server")
|
|
dbParams := flag.String("dbparams", Conf.DBParams, "parameters to open the database (see Gorm's doc)")
|
|
dbLogMode := flag.String("dblogmode", Conf.DBLogMode, "database log verbosity (errors only by default)")
|
|
|
|
return func() error {
|
|
// You can override fields in the config file with flags.
|
|
config.Host = *host
|
|
config.Port = *port
|
|
config.DBParams = *dbParams
|
|
err := config.SetDBType(*dbType)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = config.SetDBLogMode(*dbLogMode)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = config.HandleConfFileFlag(*confFile)
|
|
return err
|
|
}
|
|
}
|
|
|
|
// HandleConfFileFlag : Read the config from a file
|
|
func (config *Config) HandleConfFileFlag(path string) error {
|
|
if path != "" {
|
|
file, err := os.Open(path)
|
|
if err != nil {
|
|
return fmt.Errorf("can't read file '%s'", path)
|
|
}
|
|
var b []byte
|
|
_, err = file.Read(b)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to parse file '%s' (%s)", path, err)
|
|
}
|
|
err = yaml.Unmarshal(b, config)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to parse file '%s' (%s)", path, err)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// SetDBType : Set the DataBase type in config
|
|
func (config *Config) SetDBType(dbType string) error {
|
|
if !allowedDatabaseTypes[dbType] {
|
|
return fmt.Errorf("unknown database backend '%s'", dbType)
|
|
}
|
|
config.DBType = dbType
|
|
return nil
|
|
}
|
|
|
|
// SetDBLogMode : Set the log mode in config
|
|
func (config *Config) SetDBLogMode(dbLogmode string) error {
|
|
if !allowedDBLogModes[dbLogmode] {
|
|
return fmt.Errorf("unknown database log mode '%s'", dbLogmode)
|
|
}
|
|
config.DBLogMode = dbLogmode
|
|
return nil
|
|
}
|
|
|
|
// Read : Decode config from json to config
|
|
func (config *Config) Read(input io.Reader) error {
|
|
return json.NewDecoder(input).Decode(config)
|
|
}
|
|
|
|
// Write : Encode config from json to config
|
|
func (config *Config) Write(output io.Writer) error {
|
|
return json.NewEncoder(output).Encode(config)
|
|
}
|
|
|
|
// Pretty : Write config json in a file
|
|
func (config *Config) Pretty(output io.Writer) error {
|
|
data, err := yaml.Marshal(config)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = output.Write(data)
|
|
return err
|
|
}
|