freedakgmail
338 lines
9.7 KiB
Go
338 lines
9.7 KiB
Go
package config
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
|
|
"gopkg.in/yaml.v3"
|
|
)
|
|
|
|
// Config is the root configuration structure.
|
|
type Config struct {
|
|
Server ServerConfig `yaml:"server"`
|
|
Auth AuthConfig `yaml:"auth"`
|
|
Scheduler SchedulerConfig `yaml:"scheduler"`
|
|
Timeouts TimeoutConfig `yaml:"timeouts"`
|
|
Context ContextConfig `yaml:"context"`
|
|
Models map[string]ModelConfig `yaml:"models"`
|
|
Routing RoutingConfig `yaml:"routing"`
|
|
CircuitBreaker CircuitBreakerConfig `yaml:"circuit_breaker"`
|
|
Backpressure BackpressureConfig `yaml:"backpressure"`
|
|
Observability ObservabilityConfig `yaml:"observability"`
|
|
Storage StorageConfig `yaml:"storage"`
|
|
}
|
|
|
|
type ServerConfig struct {
|
|
Host string `yaml:"host"`
|
|
Port int `yaml:"port"`
|
|
AdminPort int `yaml:"admin_port"`
|
|
MaxRequestBodyMB int `yaml:"max_request_body_mb"`
|
|
}
|
|
|
|
type AuthConfig struct {
|
|
Enabled bool `yaml:"enabled"`
|
|
Methods []string `yaml:"methods"`
|
|
JWTIssuer string `yaml:"jwt_issuer"`
|
|
JWTSecretEnv string `yaml:"jwt_secret_env"`
|
|
}
|
|
|
|
type SchedulerConfig struct {
|
|
MaxRunningTasks int `yaml:"max_running_tasks"`
|
|
MaxQueuedTasks int `yaml:"max_queued_tasks"`
|
|
Fairness string `yaml:"fairness"`
|
|
PriorityAgingSeconds int `yaml:"priority_aging_seconds"`
|
|
ReservedRealtimeSlots int `yaml:"reserved_realtime_slots"`
|
|
}
|
|
|
|
type TimeoutConfig struct {
|
|
DefaultConnectMs int `yaml:"default_connect_ms"`
|
|
DefaultQueueMs int `yaml:"default_queue_ms"`
|
|
DefaultFirstTokenMs int `yaml:"default_first_token_ms"`
|
|
DefaultInferenceMs int `yaml:"default_inference_ms"`
|
|
DefaultIdleMs int `yaml:"default_idle_ms"`
|
|
DefaultTotalMs int `yaml:"default_total_ms"`
|
|
CancelGracePeriodMs int `yaml:"cancel_grace_period_ms"`
|
|
}
|
|
|
|
type ContextConfig struct {
|
|
SafetyMarginRatio float64 `yaml:"safety_margin_ratio"`
|
|
DefaultPolicy string `yaml:"default_policy"`
|
|
MaxSessionMessages int `yaml:"max_session_messages"`
|
|
SessionIdleTTLMinutes int `yaml:"session_idle_ttl_minutes"`
|
|
EnablePromptPersistence bool `yaml:"enable_prompt_persistence"`
|
|
}
|
|
|
|
type ModelConfig struct {
|
|
Provider string `yaml:"provider"`
|
|
ActualModel string `yaml:"actual_model"`
|
|
Endpoint string `yaml:"endpoint"`
|
|
ContextWindow int `yaml:"context_window"`
|
|
MaxOutputTokens int `yaml:"max_output_tokens"`
|
|
MaxConcurrency int `yaml:"max_concurrency"`
|
|
Residency string `yaml:"residency"`
|
|
CancelSupported bool `yaml:"cancel_supported"`
|
|
IdleUnloadSeconds int `yaml:"idle_unload_seconds"`
|
|
}
|
|
|
|
type RoutingConfig struct {
|
|
SensitiveDataLocalOnly bool `yaml:"sensitive_data_local_only"`
|
|
AllowCloudFallbackByDefault bool `yaml:"allow_cloud_fallback_by_default"`
|
|
OverloadStrategy []string `yaml:"overload_strategy"`
|
|
}
|
|
|
|
type CircuitBreakerConfig struct {
|
|
ErrorRateThreshold float64 `yaml:"error_rate_threshold"`
|
|
MinRequests int `yaml:"min_requests"`
|
|
WindowSeconds int `yaml:"window_seconds"`
|
|
OpenDurationSeconds int `yaml:"open_duration_seconds"`
|
|
HalfOpenMaxRequests int `yaml:"half_open_max_requests"`
|
|
}
|
|
|
|
type BackpressureConfig struct {
|
|
Level1Threshold float64 `yaml:"level1_threshold"`
|
|
Level2Threshold float64 `yaml:"level2_threshold"`
|
|
Level3Threshold float64 `yaml:"level3_threshold"`
|
|
}
|
|
|
|
type ObservabilityConfig struct {
|
|
MetricsEnabled bool `yaml:"metrics_enabled"`
|
|
MetricsPath string `yaml:"metrics_path"`
|
|
TracingEnabled bool `yaml:"tracing_enabled"`
|
|
PromptLogging string `yaml:"prompt_logging"`
|
|
AuditRetentionDays int `yaml:"audit_retention_days"`
|
|
LogLevel string `yaml:"log_level"`
|
|
}
|
|
|
|
type StorageConfig struct {
|
|
SessionDB string `yaml:"session_db"`
|
|
TaskState string `yaml:"task_state"`
|
|
Redis RedisConfig `yaml:"redis"`
|
|
}
|
|
|
|
type RedisConfig struct {
|
|
Enabled bool `yaml:"enabled"`
|
|
Endpoint string `yaml:"endpoint"`
|
|
}
|
|
|
|
var (
|
|
currentConfig *Config
|
|
configMu sync.RWMutex
|
|
)
|
|
|
|
// Load reads the config from the given YAML file path and applies env overrides.
|
|
func Load(path string) (*Config, error) {
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("read config file: %w", err)
|
|
}
|
|
|
|
cfg := &Config{}
|
|
if err := yaml.Unmarshal(data, cfg); err != nil {
|
|
return nil, fmt.Errorf("parse config yaml: %w", err)
|
|
}
|
|
|
|
applyDefaults(cfg)
|
|
if err := validate(cfg); err != nil {
|
|
return nil, fmt.Errorf("config validation: %w", err)
|
|
}
|
|
|
|
applyEnvOverrides(cfg)
|
|
|
|
configMu.Lock()
|
|
currentConfig = cfg
|
|
configMu.Unlock()
|
|
|
|
return cfg, nil
|
|
}
|
|
|
|
func applyDefaults(cfg *Config) {
|
|
if cfg.Server.Host == "" {
|
|
cfg.Server.Host = "0.0.0.0"
|
|
}
|
|
if cfg.Server.Port == 0 {
|
|
cfg.Server.Port = 8080
|
|
}
|
|
if cfg.Server.AdminPort == 0 {
|
|
cfg.Server.AdminPort = 8081
|
|
}
|
|
if cfg.Server.MaxRequestBodyMB == 0 {
|
|
cfg.Server.MaxRequestBodyMB = 20
|
|
}
|
|
if cfg.Scheduler.MaxRunningTasks == 0 {
|
|
cfg.Scheduler.MaxRunningTasks = 8
|
|
}
|
|
if cfg.Scheduler.MaxQueuedTasks == 0 {
|
|
cfg.Scheduler.MaxQueuedTasks = 500
|
|
}
|
|
if cfg.Scheduler.Fairness == "" {
|
|
cfg.Scheduler.Fairness = "weighted_fair_queue"
|
|
}
|
|
if cfg.Scheduler.PriorityAgingSeconds == 0 {
|
|
cfg.Scheduler.PriorityAgingSeconds = 30
|
|
}
|
|
if cfg.Timeouts.DefaultConnectMs == 0 {
|
|
cfg.Timeouts.DefaultConnectMs = 5000
|
|
}
|
|
if cfg.Timeouts.DefaultQueueMs == 0 {
|
|
cfg.Timeouts.DefaultQueueMs = 5000
|
|
}
|
|
if cfg.Timeouts.DefaultFirstTokenMs == 0 {
|
|
cfg.Timeouts.DefaultFirstTokenMs = 10000
|
|
}
|
|
if cfg.Timeouts.DefaultInferenceMs == 0 {
|
|
cfg.Timeouts.DefaultInferenceMs = 60000
|
|
}
|
|
if cfg.Timeouts.DefaultIdleMs == 0 {
|
|
cfg.Timeouts.DefaultIdleMs = 15000
|
|
}
|
|
if cfg.Timeouts.DefaultTotalMs == 0 {
|
|
cfg.Timeouts.DefaultTotalMs = 90000
|
|
}
|
|
if cfg.Timeouts.CancelGracePeriodMs == 0 {
|
|
cfg.Timeouts.CancelGracePeriodMs = 3000
|
|
}
|
|
if cfg.Context.SafetyMarginRatio == 0 {
|
|
cfg.Context.SafetyMarginRatio = 0.08
|
|
}
|
|
if cfg.Context.DefaultPolicy == "" {
|
|
cfg.Context.DefaultPolicy = "summary_and_recent"
|
|
}
|
|
if cfg.Context.MaxSessionMessages == 0 {
|
|
cfg.Context.MaxSessionMessages = 200
|
|
}
|
|
if cfg.Context.SessionIdleTTLMinutes == 0 {
|
|
cfg.Context.SessionIdleTTLMinutes = 60
|
|
}
|
|
if cfg.CircuitBreaker.ErrorRateThreshold == 0 {
|
|
cfg.CircuitBreaker.ErrorRateThreshold = 0.1
|
|
}
|
|
if cfg.CircuitBreaker.MinRequests == 0 {
|
|
cfg.CircuitBreaker.MinRequests = 10
|
|
}
|
|
if cfg.CircuitBreaker.WindowSeconds == 0 {
|
|
cfg.CircuitBreaker.WindowSeconds = 60
|
|
}
|
|
if cfg.CircuitBreaker.OpenDurationSeconds == 0 {
|
|
cfg.CircuitBreaker.OpenDurationSeconds = 30
|
|
}
|
|
if cfg.CircuitBreaker.HalfOpenMaxRequests == 0 {
|
|
cfg.CircuitBreaker.HalfOpenMaxRequests = 1
|
|
}
|
|
if cfg.Backpressure.Level1Threshold == 0 {
|
|
cfg.Backpressure.Level1Threshold = 0.70
|
|
}
|
|
if cfg.Backpressure.Level2Threshold == 0 {
|
|
cfg.Backpressure.Level2Threshold = 0.85
|
|
}
|
|
if cfg.Backpressure.Level3Threshold == 0 {
|
|
cfg.Backpressure.Level3Threshold = 0.95
|
|
}
|
|
if cfg.Observability.MetricsPath == "" {
|
|
cfg.Observability.MetricsPath = "/metrics"
|
|
}
|
|
if cfg.Observability.PromptLogging == "" {
|
|
cfg.Observability.PromptLogging = "metadata_only"
|
|
}
|
|
if cfg.Observability.LogLevel == "" {
|
|
cfg.Observability.LogLevel = "info"
|
|
}
|
|
if cfg.Observability.AuditRetentionDays == 0 {
|
|
cfg.Observability.AuditRetentionDays = 180
|
|
}
|
|
if cfg.Storage.SessionDB == "" {
|
|
cfg.Storage.SessionDB = "sqlite:///var/lib/edgeai/sessions.db"
|
|
}
|
|
if cfg.Storage.TaskState == "" {
|
|
cfg.Storage.TaskState = "sqlite:///var/lib/edgeai/tasks.db"
|
|
}
|
|
}
|
|
|
|
func validate(cfg *Config) error {
|
|
if cfg.Scheduler.MaxRunningTasks <= 0 {
|
|
return fmt.Errorf("scheduler.max_running_tasks must be positive")
|
|
}
|
|
if cfg.Scheduler.MaxQueuedTasks <= 0 {
|
|
return fmt.Errorf("scheduler.max_queued_tasks must be positive")
|
|
}
|
|
if cfg.Context.SafetyMarginRatio < 0 || cfg.Context.SafetyMarginRatio >= 1 {
|
|
return fmt.Errorf("context.safety_margin_ratio must be in [0, 1)")
|
|
}
|
|
if cfg.Backpressure.Level1Threshold >= cfg.Backpressure.Level2Threshold {
|
|
return fmt.Errorf("backpressure level1 threshold must be less than level2")
|
|
}
|
|
if cfg.Backpressure.Level2Threshold >= cfg.Backpressure.Level3Threshold {
|
|
return fmt.Errorf("backpressure level2 threshold must be less than level3")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func applyEnvOverrides(cfg *Config) {
|
|
if v := os.Getenv("EDGEAI_SERVER_PORT"); v != "" {
|
|
if port, err := strconv.Atoi(v); err == nil {
|
|
cfg.Server.Port = port
|
|
}
|
|
}
|
|
if v := os.Getenv("EDGEAI_ADMIN_PORT"); v != "" {
|
|
if port, err := strconv.Atoi(v); err == nil {
|
|
cfg.Server.AdminPort = port
|
|
}
|
|
}
|
|
if v := os.Getenv("EDGEAI_LOG_LEVEL"); v != "" {
|
|
cfg.Observability.LogLevel = v
|
|
}
|
|
if v := os.Getenv("EDGEAI_DB_PATH"); v != "" {
|
|
cfg.Storage.SessionDB = "sqlite://" + v + "/sessions.db"
|
|
cfg.Storage.TaskState = "sqlite://" + v + "/tasks.db"
|
|
}
|
|
if v := os.Getenv("EDGEAI_CONFIG_PATH"); v != "" {
|
|
// already handled by Load path
|
|
_ = v
|
|
}
|
|
}
|
|
|
|
// Get returns the current config (thread-safe).
|
|
func Get() *Config {
|
|
configMu.RLock()
|
|
defer configMu.RUnlock()
|
|
return currentConfig
|
|
}
|
|
|
|
// Update replaces the current config (thread-safe).
|
|
func Update(cfg *Config) {
|
|
configMu.Lock()
|
|
currentConfig = cfg
|
|
configMu.Unlock()
|
|
}
|
|
|
|
// ConfigPath returns the config file path from env or default.
|
|
func ConfigPath() string {
|
|
path := os.Getenv("EDGEAI_CONFIG_PATH")
|
|
if path == "" {
|
|
return "configs/config.yaml"
|
|
}
|
|
return path
|
|
}
|
|
|
|
// PriorityName returns the string name for a priority level.
|
|
func PriorityName(p int) string {
|
|
names := []string{"P0", "P1", "P2", "P3", "P4"}
|
|
if p >= 0 && p < len(names) {
|
|
return names[p]
|
|
}
|
|
return "P2"
|
|
}
|
|
|
|
// ParsePriority parses a priority string like "P0" to an int.
|
|
func ParsePriority(s string) int {
|
|
s = strings.ToUpper(s)
|
|
for i, name := range []string{"P0", "P1", "P2", "P3", "P4"} {
|
|
if s == name {
|
|
return i
|
|
}
|
|
}
|
|
return 2 // default P2
|
|
}
|