Files
mtusi2026lab5-fork/backend/internal/config/config.go
T

247 lines
6.4 KiB
Go

package config
import (
"fmt"
"os"
"strconv"
"strings"
"time"
)
type Config struct {
Host string
Port string
DatabaseURL string
SessionStore string
CacheURL string
SessionTTL time.Duration
IdempotencyTTL time.Duration
ShutdownDrain time.Duration
S3Endpoint string
S3Bucket string
S3UseSSL bool
S3Region string
S3AccessKey string
S3SecretKey string
MaxUploadBytes int64
MaxImagePixels int64
ReconcilerEnabled bool
ReconcilerInterval time.Duration
ReconcilerGracePeriod time.Duration
RabbitMQURL string
OutboxInterval time.Duration
}
func Load() (*Config, error) {
dsn, err := readSecret("DATABASE_URL_FILE", "DATABASE_URL")
if err != nil {
return nil, fmt.Errorf("database url: %w", err)
}
cacheURL, err := readSecretOptional("CACHE_URL_FILE", "CACHE_URL")
if err != nil {
return nil, fmt.Errorf("cache url: %w", err)
}
ttlSeconds, err := readInt("SESSION_TTL_SECONDS", 3600)
if err != nil {
return nil, fmt.Errorf("SESSION_TTL_SECONDS: %w", err)
}
if ttlSeconds <= 0 {
return nil, fmt.Errorf("SESSION_TTL_SECONDS должен быть положительным")
}
idemSeconds, err := readInt("IDEMPOTENCY_TTL_SECONDS", 86400)
if err != nil {
return nil, fmt.Errorf("IDEMPOTENCY_TTL_SECONDS: %w", err)
}
if idemSeconds <= 0 {
return nil, fmt.Errorf("IDEMPOTENCY_TTL_SECONDS должен быть положительным")
}
drainSeconds, err := readInt("SHUTDOWN_DRAIN_SECONDS", 3)
if err != nil {
return nil, fmt.Errorf("SHUTDOWN_DRAIN_SECONDS: %w", err)
}
if drainSeconds < 0 {
return nil, fmt.Errorf("SHUTDOWN_DRAIN_SECONDS не может быть отрицательным")
}
store := strings.ToLower(getenv("SESSION_STORE", "postgres"))
switch store {
case "postgres", "redis", "valkey":
default:
return nil, fmt.Errorf("SESSION_STORE=%q не поддерживается", store)
}
s3Endpoint := getenv("S3_ENDPOINT", "")
s3Bucket := getenv("S3_BUCKET", "")
s3UseSSL, err := readBool("S3_USE_SSL", false)
if err != nil {
return nil, fmt.Errorf("S3_USE_SSL: %w", err)
}
s3Region := getenv("S3_REGION", "us-east-1")
s3AccessKey, err := readSecretOptional("S3_ACCESS_KEY_ID_FILE", "S3_ACCESS_KEY_ID")
if err != nil {
return nil, fmt.Errorf("s3 access key: %w", err)
}
s3SecretKey, err := readSecretOptional("S3_SECRET_ACCESS_KEY_FILE", "S3_SECRET_ACCESS_KEY")
if err != nil {
return nil, fmt.Errorf("s3 secret key: %w", err)
}
maxUploadBytes, err := readInt64("MAX_UPLOAD_BYTES", 10485760)
if err != nil {
return nil, fmt.Errorf("MAX_UPLOAD_BYTES: %w", err)
}
if maxUploadBytes <= 0 {
return nil, fmt.Errorf("MAX_UPLOAD_BYTES должен быть положительным")
}
maxImagePixels, err := readInt64("MAX_IMAGE_PIXELS", 40000000)
if err != nil {
return nil, fmt.Errorf("MAX_IMAGE_PIXELS: %w", err)
}
if maxImagePixels <= 0 {
return nil, fmt.Errorf("MAX_IMAGE_PIXELS должен быть положительным")
}
reconcilerEnabled, err := readBool("RECONCILER_ENABLED", true)
if err != nil {
return nil, fmt.Errorf("RECONCILER_ENABLED: %w", err)
}
reconcilerIntervalSec, err := readInt("RECONCILER_INTERVAL_SECONDS", 300)
if err != nil {
return nil, fmt.Errorf("RECONCILER_INTERVAL_SECONDS: %w", err)
}
if reconcilerIntervalSec <= 0 {
return nil, fmt.Errorf("RECONCILER_INTERVAL_SECONDS должен быть положительным")
}
reconcilerGraceSec, err := readInt("RECONCILER_GRACE_SECONDS", 3600)
if err != nil {
return nil, fmt.Errorf("RECONCILER_GRACE_SECONDS: %w", err)
}
if reconcilerGraceSec <= 0 {
return nil, fmt.Errorf("RECONCILER_GRACE_SECONDS должен быть положительным")
}
rabbitURL, err := readSecretOptional("RABBITMQ_URL_FILE", "RABBITMQ_URL")
if err != nil {
return nil, fmt.Errorf("rabbitmq url: %w", err)
}
outboxMs, err := readInt("OUTBOX_INTERVAL_MS", 1000)
if err != nil {
return nil, fmt.Errorf("OUTBOX_INTERVAL_MS: %w", err)
}
return &Config{
Host: getenv("APP_HOST", "0.0.0.0"),
Port: getenv("APP_PORT", "8080"),
DatabaseURL: dsn,
SessionStore: store,
CacheURL: cacheURL,
SessionTTL: time.Duration(ttlSeconds) * time.Second,
IdempotencyTTL: time.Duration(idemSeconds) * time.Second,
ShutdownDrain: time.Duration(drainSeconds) * time.Second,
S3Endpoint: s3Endpoint,
S3Bucket: s3Bucket,
S3UseSSL: s3UseSSL,
S3Region: s3Region,
S3AccessKey: s3AccessKey,
S3SecretKey: s3SecretKey,
MaxUploadBytes: maxUploadBytes,
MaxImagePixels: maxImagePixels,
ReconcilerEnabled: reconcilerEnabled,
ReconcilerInterval: time.Duration(reconcilerIntervalSec) * time.Second,
ReconcilerGracePeriod: time.Duration(reconcilerGraceSec) * time.Second,
RabbitMQURL: rabbitURL,
OutboxInterval: time.Duration(outboxMs) * time.Millisecond,
}, nil
}
func (c *Config) S3Configured() bool {
return c.S3Endpoint != "" &&
c.S3Bucket != "" &&
c.S3AccessKey != "" &&
c.S3SecretKey != ""
}
func getenv(key, def string) string {
if v := os.Getenv(key); v != "" {
return v
}
return def
}
func readInt(key string, def int) (int, error) {
v := os.Getenv(key)
if v == "" {
return def, nil
}
n, err := strconv.Atoi(v)
if err != nil {
return 0, fmt.Errorf("не целое число: %q", v)
}
return n, nil
}
func readInt64(key string, def int64) (int64, error) {
v := os.Getenv(key)
if v == "" {
return def, nil
}
n, err := strconv.ParseInt(v, 10, 64)
if err != nil {
return 0, fmt.Errorf("не целое число: %q", v)
}
return n, nil
}
func readBool(key string, def bool) (bool, error) {
v := os.Getenv(key)
if v == "" {
return def, nil
}
b, err := strconv.ParseBool(v)
if err != nil {
return false, fmt.Errorf("не bool: %q", v)
}
return b, nil
}
func readSecret(fileEnv, envKey string) (string, error) {
v, err := readSecretOptional(fileEnv, envKey)
if err != nil {
return "", err
}
if v == "" {
return "", fmt.Errorf("не задан %s или %s", fileEnv, envKey)
}
return v, nil
}
func readSecretOptional(fileEnv, envKey string) (string, error) {
if path := os.Getenv(fileEnv); path != "" {
b, err := os.ReadFile(path)
if err != nil {
return "", fmt.Errorf("чтение %s=%s: %w", fileEnv, path, err)
}
s := strings.TrimSpace(string(b))
if s == "" {
return "", fmt.Errorf("файл %s пуст", path)
}
return s, nil
}
return os.Getenv(envKey), nil
}