bwilliams
67215a6aaa
CODE_CONVENTIONS.md sets out the conventions for Go code in this repository: naming, layout, comments, errors, logging, configuration and tests. .golangci.json enables the linters that check the parts that can be checked (each limited to the rules the conventions use); the rest is applied by hand. Applied across the codebase: - Naming: full-word names in application code, initialisms in one case (BuyerID, PrintJSON, PrintYAML, ocdsGetBuyerID), no names shadowing built-ins (min/max are minGap/maxGap), mustRaw renamed rawJSON as it returns nil rather than panicking, and config.ConfigLevelToLogLevel renamed LevelToLogLevel. - Layout: lines kept to 80 characters where possible, assignments taken out of if and for statements that don't fit, wrapped arguments all on one line or one per line, steps separated by blank lines, no else after a return, function and struct literals wrapped. - Comments: doc comments on every exported name (including each section's Map, Flatten, TypeOf, ValueOf and SetValue), section banners, British spelling. - Errors: a created error starts with its package name, a wrapping error adds only what was being done, sentinels in one commented var block, errors.Is and errors.As in place of == and type assertions, and no err := shadowing of a named result. That fixes the mock server losing its access log's close error. - Logging: the fetcher passes its workers an untagged logger, so findatender's lines are tagged with their own component rather than with fetcher's as well; cmd/mock-fts logs "stopped" with slog. - Configuration: util.WithTimeout (moved from the websocket package) applies a timeout of 0 or less as no limit, used for the websocket write and ping, TCP close and tcpserver shutdown timeouts; every setting documents what 0 or empty means, including the rate limit rule's keys in internal/config/README.md. - Tests: related tests merged into table-driven ones with named cases. Separately from CODE_CONVENTIONS.md, internal/store/README.md gains a soft SQL style convention for the queries in internal/store/queries.go, and the queries are reformatted to follow it.
115 lines
3.0 KiB
Go
115 lines
3.0 KiB
Go
package config
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"log/slog"
|
|
"os"
|
|
"strings"
|
|
|
|
"github.com/joho/godotenv"
|
|
"github.com/spf13/viper"
|
|
)
|
|
|
|
// envKeyReplacer turns a dotted key into its environment variable's suffix
|
|
// (logging.level to LOGGING_LEVEL, once upper-cased).
|
|
var envKeyReplacer = strings.NewReplacer(".", "_")
|
|
|
|
// envVarName returns the environment variable that sets key, e.g.
|
|
// JOBSEARCH_LOGGING_LEVEL for logging.level.
|
|
func envVarName(key string) string {
|
|
return EnvPrefix + "_" + strings.ToUpper(envKeyReplacer.Replace(key))
|
|
}
|
|
|
|
// isExplicitlySet reports whether key's value in Viper was set by the config
|
|
// file or by its environment variable, rather than coming from its default.
|
|
// As Viper does, it ignores an empty environment variable. Values set with
|
|
// viper.Set (e.g. by StoreValue) are not counted.
|
|
func isExplicitlySet(key string) bool {
|
|
if viper.InConfig(key) {
|
|
return true
|
|
}
|
|
value, ok := os.LookupEnv(envVarName(key))
|
|
return ok && value != ""
|
|
}
|
|
|
|
// loadEnv loads environment variables from a .env file in the working
|
|
// directory.
|
|
func loadEnv() error {
|
|
if err := godotenv.Load(); err != nil {
|
|
return fmt.Errorf("invalid .env file: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// loadConfig sets up Viper with the defaults, configFile (or config.* found in
|
|
// EtcConfigPath or the working directory) and JOBSEARCH_* environment
|
|
// variables. A missing config file is only a warning.
|
|
func loadConfig(configFile string) error {
|
|
if configFile != "" {
|
|
// Use config file from the flag.
|
|
viper.SetConfigFile(configFile)
|
|
} else {
|
|
// Search config in /etc or local directory.
|
|
viper.AddConfigPath(EtcConfigPath)
|
|
viper.AddConfigPath(".")
|
|
|
|
viper.SetConfigName("config")
|
|
}
|
|
|
|
// Load default configuration
|
|
LoadDefaultConfig()
|
|
|
|
viper.SetEnvPrefix(EnvPrefix)
|
|
viper.SetEnvKeyReplacer(envKeyReplacer)
|
|
viper.AutomaticEnv() // read in environment variables that match
|
|
|
|
err := viper.ReadInConfig()
|
|
var notFound viper.ConfigFileNotFoundError
|
|
switch {
|
|
case errors.As(err, ¬Found):
|
|
// No config file was found in any search path.
|
|
slog.Warn("no config file found; using defaults")
|
|
case err != nil:
|
|
// A config file was found but couldn't be read or parsed.
|
|
return err
|
|
default:
|
|
slog.Info("using config file", "file", viper.ConfigFileUsed())
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Init loads the .env file and the configuration (see loadConfig) into conf.
|
|
// A debug or error log level already set in conf, from --debug or --quiet,
|
|
// is kept over the loaded one.
|
|
func Init(configFile string, conf *JobSearchConfig) error {
|
|
if err := loadEnv(); err != nil {
|
|
return err
|
|
}
|
|
if conf.Logging.LogLevel() <= slog.LevelDebug {
|
|
printEnv()
|
|
}
|
|
|
|
if err := loadConfig(configFile); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Load configuration from Viper, ensure -debug and -quiet are retained
|
|
oldLogLevel := conf.Logging.LogLevel()
|
|
LoadFromViper(conf)
|
|
if oldLogLevel == slog.LevelDebug {
|
|
conf.Logging.Level = "debug"
|
|
}
|
|
if oldLogLevel == slog.LevelError {
|
|
conf.Logging.Level = "error"
|
|
}
|
|
|
|
if conf.Logging.LogLevel() <= slog.LevelDebug {
|
|
printLoadedConfig()
|
|
printConfig(*conf)
|
|
}
|
|
|
|
return nil
|
|
}
|