120 lines
3.1 KiB
Go
120 lines
3.1 KiB
Go
package configuration
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"strings"
|
|
|
|
"github.com/qdm12/golibs/params"
|
|
)
|
|
|
|
var (
|
|
ErrGetSecretFilepath = errors.New("cannot get secret file path from env")
|
|
ErrReadSecretFile = errors.New("cannot read secret file")
|
|
ErrSecretFileIsEmpty = errors.New("secret file is empty")
|
|
ErrReadNonSecretFile = errors.New("cannot read non secret file")
|
|
ErrFilesDoNotExist = errors.New("files do not exist")
|
|
)
|
|
|
|
func cleanSuffix(value string) string {
|
|
value = strings.TrimSuffix(value, "\n")
|
|
value = strings.TrimSuffix(value, "\r")
|
|
return value
|
|
}
|
|
|
|
func (r *reader) getFromEnvOrSecretFile(envKey string, compulsory bool, retroKeys []string) (value string, err error) {
|
|
envOptions := []params.OptionSetter{
|
|
params.Compulsory(), // to fallback on file reading
|
|
params.CaseSensitiveValue(),
|
|
params.Unset(),
|
|
params.RetroKeys(retroKeys, r.onRetroActive),
|
|
}
|
|
value, envErr := r.env.Get(envKey, envOptions...)
|
|
if envErr == nil {
|
|
value = cleanSuffix(value)
|
|
return value, nil
|
|
}
|
|
|
|
secretFilepathEnvKey := envKey + "_SECRETFILE"
|
|
defaultSecretFile := "/run/secrets/" + strings.ToLower(envKey)
|
|
filepath, err := r.env.Get(secretFilepathEnvKey,
|
|
params.CaseSensitiveValue(),
|
|
params.Default(defaultSecretFile),
|
|
)
|
|
if err != nil {
|
|
return "", fmt.Errorf("%w: environment variable %s: %s",
|
|
ErrGetSecretFilepath, secretFilepathEnvKey, err)
|
|
}
|
|
|
|
file, fileErr := os.OpenFile(filepath, os.O_RDONLY, 0)
|
|
if os.IsNotExist(fileErr) {
|
|
if compulsory {
|
|
return "", envErr
|
|
}
|
|
return "", nil
|
|
} else if fileErr != nil {
|
|
return "", fmt.Errorf("%w: %s", ErrReadSecretFile, fileErr)
|
|
}
|
|
|
|
b, err := io.ReadAll(file)
|
|
if err != nil {
|
|
return "", fmt.Errorf("%w: %s", ErrReadSecretFile, err)
|
|
}
|
|
|
|
value = string(b)
|
|
value = cleanSuffix(value)
|
|
if compulsory && value == "" {
|
|
return "", ErrSecretFileIsEmpty
|
|
}
|
|
|
|
return value, nil
|
|
}
|
|
|
|
// Tries to read from the secret file then the non secret file.
|
|
func (r *reader) getFromFileOrSecretFile(secretName, filepath string) (
|
|
b []byte, err error) {
|
|
defaultSecretFile := "/run/secrets/" + strings.ToLower(secretName)
|
|
key := strings.ToUpper(secretName) + "_SECRETFILE"
|
|
secretFilepath, err := r.env.Get(key,
|
|
params.CaseSensitiveValue(),
|
|
params.Default(defaultSecretFile),
|
|
)
|
|
if err != nil {
|
|
return b, fmt.Errorf("environment variable %s: %w: %s", key, ErrGetSecretFilepath, err)
|
|
}
|
|
|
|
b, err = readFromFile(secretFilepath)
|
|
if err != nil && !os.IsNotExist(err) {
|
|
return b, fmt.Errorf("%w: %s", ErrReadSecretFile, err)
|
|
} else if err == nil {
|
|
return b, nil
|
|
}
|
|
|
|
// Secret file does not exist, try the non secret file
|
|
b, err = readFromFile(filepath)
|
|
if err != nil && !os.IsNotExist(err) {
|
|
return nil, fmt.Errorf("%w: %s", ErrReadSecretFile, err)
|
|
} else if err == nil {
|
|
return b, nil
|
|
}
|
|
return nil, fmt.Errorf("%w: %s and %s", ErrFilesDoNotExist, secretFilepath, filepath)
|
|
}
|
|
|
|
func readFromFile(filepath string) (b []byte, err error) {
|
|
file, err := os.Open(filepath)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
b, err = io.ReadAll(file)
|
|
if err != nil {
|
|
_ = file.Close()
|
|
return nil, err
|
|
}
|
|
if err := file.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
return b, nil
|
|
}
|