260 lines
7.9 KiB
Go
260 lines
7.9 KiB
Go
package config
|
|
|
|
import (
|
|
"fmt"
|
|
"net"
|
|
"os"
|
|
"strings"
|
|
|
|
"go.yaml.in/yaml/v3"
|
|
)
|
|
|
|
// MaxBodyBytesCap 是 max_body_bytes 的硬上限（DEVELOPMENT 11.1）。
|
|
const MaxBodyBytesCap = 262144
|
|
|
|
// Config 对应 DEVELOPMENT 第 11.1 节的配置文件。
|
|
type Config struct {
|
|
Listen string `yaml:"listen"`
|
|
AdminListen string `yaml:"admin_listen"`
|
|
TLS TLSConfig `yaml:"tls"`
|
|
TrustedProxies []string `yaml:"trusted_proxies"`
|
|
DataDir string `yaml:"data_dir"`
|
|
Limits LimitsConfig `yaml:"limits"`
|
|
SessionIdleDays int `yaml:"session_idle_days"`
|
|
RecordRetentionDays int `yaml:"record_retention_days"`
|
|
IdempotencyHours int `yaml:"idempotency_hours"`
|
|
ReceiptRetentionDays int `yaml:"receipt_retention_days"`
|
|
SQLiteSynchronous string `yaml:"sqlite_synchronous"`
|
|
Metrics MetricsConfig `yaml:"metrics"`
|
|
Log LogConfig `yaml:"log"`
|
|
}
|
|
|
|
type TLSConfig struct {
|
|
CertFile string `yaml:"cert_file"`
|
|
KeyFile string `yaml:"key_file"`
|
|
AllowPlaintext bool `yaml:"allow_plaintext"`
|
|
}
|
|
|
|
type LimitsConfig struct {
|
|
MaxBodyBytes int `yaml:"max_body_bytes"`
|
|
MaxMetaBytes int `yaml:"max_meta_bytes"`
|
|
MaxFrameBytes int `yaml:"max_frame_bytes"`
|
|
MaxTTLSeconds int `yaml:"max_ttl_seconds"`
|
|
MaxScheduleSeconds int `yaml:"max_schedule_seconds"`
|
|
MaxGroupMembers int `yaml:"max_group_members"`
|
|
GraceSeconds int `yaml:"grace_seconds"`
|
|
AckTimeoutSeconds int `yaml:"ack_timeout_seconds"`
|
|
DeliveryWindow int `yaml:"delivery_window"`
|
|
ReceiptWindow int `yaml:"receipt_window"`
|
|
RequestsPerSecond int `yaml:"requests_per_second"`
|
|
MaxPendingPerSender int `yaml:"max_pending_per_sender"`
|
|
MaxPendingPerReceiver int `yaml:"max_pending_per_receiver"`
|
|
}
|
|
|
|
type MetricsConfig struct {
|
|
Token string `yaml:"token"`
|
|
}
|
|
|
|
type LogConfig struct {
|
|
Level string `yaml:"level"`
|
|
}
|
|
|
|
// Default 返回与 DEVELOPMENT 11.1 示例一致的默认值。
|
|
func Default() Config {
|
|
return Config{
|
|
Listen: ":7443",
|
|
AdminListen: "",
|
|
TLS: TLSConfig{
|
|
AllowPlaintext: false,
|
|
},
|
|
TrustedProxies: nil,
|
|
DataDir: "./data",
|
|
Limits: LimitsConfig{
|
|
MaxBodyBytes: MaxBodyBytesCap,
|
|
MaxMetaBytes: 4096,
|
|
MaxFrameBytes: 786432,
|
|
MaxTTLSeconds: 2592000,
|
|
MaxScheduleSeconds: 31536000,
|
|
MaxGroupMembers: 1000,
|
|
GraceSeconds: 60,
|
|
AckTimeoutSeconds: 300,
|
|
DeliveryWindow: 32,
|
|
ReceiptWindow: 64,
|
|
RequestsPerSecond: 50,
|
|
MaxPendingPerSender: 10000,
|
|
MaxPendingPerReceiver: 10000,
|
|
},
|
|
SessionIdleDays: 30,
|
|
RecordRetentionDays: 7,
|
|
IdempotencyHours: 24,
|
|
ReceiptRetentionDays: 7,
|
|
SQLiteSynchronous: "FULL",
|
|
Metrics: MetricsConfig{},
|
|
Log: LogConfig{
|
|
Level: "info",
|
|
},
|
|
}
|
|
}
|
|
|
|
// Load 从路径加载 YAML 配置；空字段保留默认值。
|
|
func Load(path string) (Config, error) {
|
|
cfg := Default()
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return Config{}, fmt.Errorf("read config: %w", err)
|
|
}
|
|
if err := yaml.Unmarshal(data, &cfg); err != nil {
|
|
return Config{}, fmt.Errorf("parse config: %w", err)
|
|
}
|
|
applyEmptyDefaults(&cfg)
|
|
return cfg, nil
|
|
}
|
|
|
|
func applyEmptyDefaults(cfg *Config) {
|
|
def := Default()
|
|
if cfg.Listen == "" {
|
|
cfg.Listen = def.Listen
|
|
}
|
|
if cfg.DataDir == "" {
|
|
cfg.DataDir = def.DataDir
|
|
}
|
|
if cfg.SQLiteSynchronous == "" {
|
|
cfg.SQLiteSynchronous = def.SQLiteSynchronous
|
|
}
|
|
if cfg.Log.Level == "" {
|
|
cfg.Log.Level = def.Log.Level
|
|
}
|
|
if cfg.Limits.MaxBodyBytes == 0 {
|
|
cfg.Limits.MaxBodyBytes = def.Limits.MaxBodyBytes
|
|
}
|
|
if cfg.Limits.MaxMetaBytes == 0 {
|
|
cfg.Limits.MaxMetaBytes = def.Limits.MaxMetaBytes
|
|
}
|
|
if cfg.Limits.MaxFrameBytes == 0 {
|
|
cfg.Limits.MaxFrameBytes = def.Limits.MaxFrameBytes
|
|
}
|
|
if cfg.Limits.MaxTTLSeconds == 0 {
|
|
cfg.Limits.MaxTTLSeconds = def.Limits.MaxTTLSeconds
|
|
}
|
|
if cfg.Limits.MaxScheduleSeconds == 0 {
|
|
cfg.Limits.MaxScheduleSeconds = def.Limits.MaxScheduleSeconds
|
|
}
|
|
if cfg.Limits.MaxGroupMembers == 0 {
|
|
cfg.Limits.MaxGroupMembers = def.Limits.MaxGroupMembers
|
|
}
|
|
if cfg.Limits.GraceSeconds == 0 {
|
|
cfg.Limits.GraceSeconds = def.Limits.GraceSeconds
|
|
}
|
|
if cfg.Limits.AckTimeoutSeconds == 0 {
|
|
cfg.Limits.AckTimeoutSeconds = def.Limits.AckTimeoutSeconds
|
|
}
|
|
if cfg.Limits.DeliveryWindow == 0 {
|
|
cfg.Limits.DeliveryWindow = def.Limits.DeliveryWindow
|
|
}
|
|
if cfg.Limits.ReceiptWindow == 0 {
|
|
cfg.Limits.ReceiptWindow = def.Limits.ReceiptWindow
|
|
}
|
|
if cfg.Limits.RequestsPerSecond == 0 {
|
|
cfg.Limits.RequestsPerSecond = def.Limits.RequestsPerSecond
|
|
}
|
|
}
|
|
|
|
// Validate 校验 DEVELOPMENT 11.1 全部字段；拒绝 max_body_bytes > 262144。
|
|
func (c Config) Validate() error {
|
|
var errs []string
|
|
if strings.TrimSpace(c.Listen) == "" {
|
|
errs = append(errs, "listen is required")
|
|
}
|
|
if strings.TrimSpace(c.DataDir) == "" {
|
|
errs = append(errs, "data_dir is required")
|
|
}
|
|
sync := strings.ToUpper(strings.TrimSpace(c.SQLiteSynchronous))
|
|
if sync != "FULL" && sync != "NORMAL" {
|
|
errs = append(errs, "sqlite_synchronous must be FULL or NORMAL")
|
|
}
|
|
switch strings.ToLower(strings.TrimSpace(c.Log.Level)) {
|
|
case "debug", "info", "warn", "warning", "error":
|
|
default:
|
|
errs = append(errs, "log.level must be debug, info, warn, or error")
|
|
}
|
|
if c.Limits.MaxBodyBytes <= 0 {
|
|
errs = append(errs, "limits.max_body_bytes must be > 0")
|
|
}
|
|
if c.Limits.MaxBodyBytes > MaxBodyBytesCap {
|
|
errs = append(errs, fmt.Sprintf("limits.max_body_bytes must be <= %d", MaxBodyBytesCap))
|
|
}
|
|
if c.Limits.MaxMetaBytes <= 0 {
|
|
errs = append(errs, "limits.max_meta_bytes must be > 0")
|
|
}
|
|
if c.Limits.MaxFrameBytes <= 0 {
|
|
errs = append(errs, "limits.max_frame_bytes must be > 0")
|
|
}
|
|
if c.Limits.MaxFrameBytes < c.Limits.MaxBodyBytes {
|
|
errs = append(errs, "limits.max_frame_bytes must be >= limits.max_body_bytes")
|
|
}
|
|
if c.Limits.MaxTTLSeconds <= 0 {
|
|
errs = append(errs, "limits.max_ttl_seconds must be > 0")
|
|
}
|
|
if c.Limits.MaxScheduleSeconds <= 0 {
|
|
errs = append(errs, "limits.max_schedule_seconds must be > 0")
|
|
}
|
|
if c.Limits.MaxGroupMembers <= 0 {
|
|
errs = append(errs, "limits.max_group_members must be > 0")
|
|
}
|
|
if c.Limits.GraceSeconds < 0 {
|
|
errs = append(errs, "limits.grace_seconds must be >= 0")
|
|
}
|
|
if c.Limits.AckTimeoutSeconds <= 0 {
|
|
errs = append(errs, "limits.ack_timeout_seconds must be > 0")
|
|
}
|
|
if c.Limits.DeliveryWindow <= 0 {
|
|
errs = append(errs, "limits.delivery_window must be > 0")
|
|
}
|
|
if c.Limits.ReceiptWindow <= 0 {
|
|
errs = append(errs, "limits.receipt_window must be > 0")
|
|
}
|
|
if c.Limits.RequestsPerSecond <= 0 {
|
|
errs = append(errs, "limits.requests_per_second must be > 0")
|
|
}
|
|
if c.Limits.MaxPendingPerSender < 0 {
|
|
errs = append(errs, "limits.max_pending_per_sender must be >= 0")
|
|
}
|
|
if c.Limits.MaxPendingPerReceiver < 0 {
|
|
errs = append(errs, "limits.max_pending_per_receiver must be >= 0")
|
|
}
|
|
if c.SessionIdleDays < 0 {
|
|
errs = append(errs, "session_idle_days must be >= 0")
|
|
}
|
|
if c.RecordRetentionDays < 0 {
|
|
errs = append(errs, "record_retention_days must be >= 0")
|
|
}
|
|
if c.IdempotencyHours < 0 {
|
|
errs = append(errs, "idempotency_hours must be >= 0")
|
|
}
|
|
if c.ReceiptRetentionDays < 0 {
|
|
errs = append(errs, "receipt_retention_days must be >= 0")
|
|
}
|
|
cert := strings.TrimSpace(c.TLS.CertFile)
|
|
key := strings.TrimSpace(c.TLS.KeyFile)
|
|
if (cert == "") != (key == "") {
|
|
errs = append(errs, "tls.cert_file and tls.key_file must both be set or both empty")
|
|
}
|
|
for _, cidr := range c.TrustedProxies {
|
|
if _, _, err := net.ParseCIDR(strings.TrimSpace(cidr)); err != nil {
|
|
errs = append(errs, fmt.Sprintf("trusted_proxies entry %q is not a valid CIDR", cidr))
|
|
}
|
|
}
|
|
if len(errs) > 0 {
|
|
return fmt.Errorf("invalid config: %s", strings.Join(errs, "; "))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// PathFromEnv 返回 NIXMSG_CONFIG 或默认 ./config.yaml。
|
|
func PathFromEnv() string {
|
|
if p := os.Getenv("NIXMSG_CONFIG"); p != "" {
|
|
return p
|
|
}
|
|
return "./config.yaml"
|
|
}
|