432 lines
13 KiB
Go
432 lines
13 KiB
Go
package config
|
|
|
|
import (
|
|
"fmt"
|
|
"gpt-load/internal/db"
|
|
"gpt-load/internal/models"
|
|
"reflect"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
|
|
"github.com/sirupsen/logrus"
|
|
"gorm.io/datatypes"
|
|
"gorm.io/gorm/clause"
|
|
)
|
|
|
|
// SystemSettings 定义所有系统配置项
|
|
// 使用结构体标签作为唯一事实来源
|
|
type SystemSettings struct {
|
|
// 负载均衡和重试配置
|
|
BlacklistThreshold int `json:"blacklist_threshold" default:"1" name:"黑名单阈值" category:"失败重试" desc:"一个 Key 连续失败多少次后进入黑名单" validate:"min=0"`
|
|
MaxRetries int `json:"max_retries" default:"3" name:"最大重试次数" category:"失败重试" desc:"单个请求使用不同 Key 的最大重试次数" validate:"min=0"`
|
|
|
|
// 服务器超时配置 (秒)
|
|
ServerReadTimeout int `json:"server_read_timeout" default:"120" name:"读取超时" category:"服务器配置" desc:"HTTP 服务器读取超时时间（秒）" validate:"min=1"`
|
|
ServerWriteTimeout int `json:"server_write_timeout" default:"1800" name:"写入超时" category:"服务器配置" desc:"HTTP 服务器写入超时时间（秒）" validate:"min=1"`
|
|
ServerIdleTimeout int `json:"server_idle_timeout" default:"120" name:"空闲超时" category:"服务器配置" desc:"HTTP 服务器空闲超时时间（秒）" validate:"min=1"`
|
|
ServerGracefulShutdownTimeout int `json:"server_graceful_shutdown_timeout" default:"60" name:"优雅关闭超时" category:"服务器配置" desc:"服务优雅关闭的等待超时时间（秒）" validate:"min=1"`
|
|
|
|
// 请求超时配置 (秒)
|
|
RequestTimeout int `json:"request_timeout" default:"30" name:"请求超时" category:"请求配置" desc:"请求处理的总体超时时间（秒）" validate:"min=1"`
|
|
ResponseTimeout int `json:"response_timeout" default:"30" name:"响应超时" category:"请求配置" desc:"TLS 握手和响应头的超时时间（秒）" validate:"min=1"`
|
|
IdleConnTimeout int `json:"idle_conn_timeout" default:"120" name:"空闲连接超时" category:"请求配置" desc:"空闲连接的超时时间（秒）" validate:"min=1"`
|
|
|
|
// 请求日志配置（数据库日志）
|
|
RequestLogRetentionDays int `json:"request_log_retention_days" default:"30" name:"日志保留天数" category:"日志配置" desc:"请求日志在数据库中的保留天数" validate:"min=1"`
|
|
}
|
|
|
|
// GenerateSettingsMetadata 使用反射从 SystemSettings 结构体动态生成元数据
|
|
func GenerateSettingsMetadata(s *SystemSettings) []models.SystemSettingInfo {
|
|
var settingsInfo []models.SystemSettingInfo
|
|
v := reflect.ValueOf(s).Elem()
|
|
t := v.Type()
|
|
|
|
for i := 0; i < t.NumField(); i++ {
|
|
field := t.Field(i)
|
|
fieldValue := v.Field(i)
|
|
|
|
jsonTag := field.Tag.Get("json")
|
|
if jsonTag == "" {
|
|
continue
|
|
}
|
|
|
|
nameTag := field.Tag.Get("name")
|
|
descTag := field.Tag.Get("desc")
|
|
defaultTag := field.Tag.Get("default")
|
|
validateTag := field.Tag.Get("validate")
|
|
categoryTag := field.Tag.Get("category")
|
|
|
|
var minValue *int
|
|
if strings.HasPrefix(validateTag, "min=") {
|
|
valStr := strings.TrimPrefix(validateTag, "min=")
|
|
if val, err := strconv.Atoi(valStr); err == nil {
|
|
minValue = &val
|
|
}
|
|
}
|
|
|
|
info := models.SystemSettingInfo{
|
|
Key: jsonTag,
|
|
Name: nameTag,
|
|
Value: fieldValue.Interface(),
|
|
Type: field.Type.String(),
|
|
DefaultValue: defaultTag,
|
|
Description: descTag,
|
|
Category: categoryTag,
|
|
MinValue: minValue,
|
|
}
|
|
settingsInfo = append(settingsInfo, info)
|
|
}
|
|
return settingsInfo
|
|
}
|
|
|
|
// DefaultSystemSettings 返回默认的系统配置
|
|
func DefaultSystemSettings() SystemSettings {
|
|
s := SystemSettings{}
|
|
v := reflect.ValueOf(&s).Elem()
|
|
t := v.Type()
|
|
|
|
for i := 0; i < t.NumField(); i++ {
|
|
field := t.Field(i)
|
|
defaultTag := field.Tag.Get("default")
|
|
if defaultTag == "" {
|
|
continue
|
|
}
|
|
|
|
fieldValue := v.Field(i)
|
|
if fieldValue.CanSet() {
|
|
if err := setFieldFromString(fieldValue, defaultTag); err != nil {
|
|
logrus.Warnf("Failed to set default value for field %s: %v", field.Name, err)
|
|
}
|
|
}
|
|
}
|
|
return s
|
|
}
|
|
|
|
// SystemSettingsManager 管理系统配置
|
|
type SystemSettingsManager struct {
|
|
settings SystemSettings
|
|
mu sync.RWMutex
|
|
}
|
|
|
|
var globalSystemSettings *SystemSettingsManager
|
|
var once sync.Once
|
|
|
|
// GetSystemSettingsManager 获取全局系统配置管理器单例
|
|
func GetSystemSettingsManager() *SystemSettingsManager {
|
|
once.Do(func() {
|
|
globalSystemSettings = &SystemSettingsManager{}
|
|
})
|
|
return globalSystemSettings
|
|
}
|
|
|
|
// InitializeSystemSettings 初始化系统配置到数据库
|
|
func (sm *SystemSettingsManager) InitializeSystemSettings() error {
|
|
if db.DB == nil {
|
|
return fmt.Errorf("database not initialized")
|
|
}
|
|
|
|
defaultSettings := DefaultSystemSettings()
|
|
metadata := GenerateSettingsMetadata(&defaultSettings)
|
|
|
|
for _, meta := range metadata {
|
|
var existing models.SystemSetting
|
|
err := db.DB.Where("setting_key = ?", meta.Key).First(&existing).Error
|
|
if err != nil { // Not found
|
|
setting := models.SystemSetting{
|
|
SettingKey: meta.Key,
|
|
SettingValue: fmt.Sprintf("%v", meta.DefaultValue),
|
|
Description: meta.Description,
|
|
}
|
|
if err := db.DB.Create(&setting).Error; err != nil {
|
|
logrus.Errorf("Failed to initialize setting %s: %v", setting.SettingKey, err)
|
|
return err
|
|
}
|
|
logrus.Infof("Initialized system setting: %s = %s", setting.SettingKey, setting.SettingValue)
|
|
}
|
|
}
|
|
|
|
// 加载配置到内存
|
|
return sm.LoadFromDatabase()
|
|
}
|
|
|
|
// LoadFromDatabase 从数据库加载系统配置到内存
|
|
func (sm *SystemSettingsManager) LoadFromDatabase() error {
|
|
if db.DB == nil {
|
|
return fmt.Errorf("database not initialized")
|
|
}
|
|
|
|
var settings []models.SystemSetting
|
|
if err := db.DB.Find(&settings).Error; err != nil {
|
|
return fmt.Errorf("failed to load system settings: %w", err)
|
|
}
|
|
|
|
settingsMap := make(map[string]string)
|
|
for _, setting := range settings {
|
|
settingsMap[setting.SettingKey] = setting.SettingValue
|
|
}
|
|
|
|
sm.mu.Lock()
|
|
defer sm.mu.Unlock()
|
|
|
|
// 使用默认值，然后用数据库中的值覆盖
|
|
sm.settings = DefaultSystemSettings()
|
|
sm.mapToStruct(settingsMap, &sm.settings)
|
|
|
|
logrus.Info("System settings loaded from database")
|
|
return nil
|
|
}
|
|
|
|
// GetSettings 获取当前系统配置
|
|
func (sm *SystemSettingsManager) GetSettings() SystemSettings {
|
|
sm.mu.RLock()
|
|
defer sm.mu.RUnlock()
|
|
return sm.settings
|
|
}
|
|
|
|
// UpdateSettings 更新系统配置
|
|
func (sm *SystemSettingsManager) UpdateSettings(settingsMap map[string]any) error {
|
|
if db.DB == nil {
|
|
return fmt.Errorf("database not initialized")
|
|
}
|
|
|
|
// 验证配置项
|
|
if err := sm.ValidateSettings(settingsMap); err != nil {
|
|
return err
|
|
}
|
|
|
|
// 更新数据库
|
|
var settingsToUpdate []models.SystemSetting
|
|
for key, value := range settingsMap {
|
|
settingsToUpdate = append(settingsToUpdate, models.SystemSetting{
|
|
SettingKey: key,
|
|
SettingValue: fmt.Sprintf("%v", value), // Convert interface{} to string
|
|
})
|
|
}
|
|
|
|
if len(settingsToUpdate) > 0 {
|
|
if err := db.DB.Clauses(clause.OnConflict{
|
|
Columns: []clause.Column{{Name: "setting_key"}},
|
|
DoUpdates: clause.AssignmentColumns([]string{"setting_value", "updated_at"}),
|
|
}).Create(&settingsToUpdate).Error; err != nil {
|
|
return fmt.Errorf("failed to update system settings: %w", err)
|
|
}
|
|
}
|
|
|
|
// 重新加载配置到内存
|
|
return sm.LoadFromDatabase()
|
|
}
|
|
|
|
// GetEffectiveConfig 获取有效配置 (系统配置 + 分组覆盖)
|
|
func (sm *SystemSettingsManager) GetEffectiveConfig(groupConfig datatypes.JSONMap) SystemSettings {
|
|
sm.mu.RLock()
|
|
defer sm.mu.RUnlock()
|
|
|
|
// 从系统配置开始
|
|
effectiveConfig := sm.settings
|
|
v := reflect.ValueOf(&effectiveConfig).Elem()
|
|
t := v.Type()
|
|
|
|
// 创建一个从 json 标签到字段名的映射
|
|
jsonToField := make(map[string]string)
|
|
for i := 0; i < t.NumField(); i++ {
|
|
field := t.Field(i)
|
|
jsonTag := strings.Split(field.Tag.Get("json"), ",")[0]
|
|
if jsonTag != "" {
|
|
jsonToField[jsonTag] = field.Name
|
|
}
|
|
}
|
|
|
|
// 应用分组配置覆盖
|
|
for key, val := range groupConfig {
|
|
if fieldName, ok := jsonToField[key]; ok {
|
|
fieldValue := v.FieldByName(fieldName)
|
|
if fieldValue.IsValid() && fieldValue.CanSet() {
|
|
switch fieldValue.Kind() {
|
|
case reflect.Int:
|
|
if intVal, err := interfaceToInt(val); err == nil {
|
|
fieldValue.SetInt(int64(intVal))
|
|
}
|
|
case reflect.String:
|
|
if strVal, ok := interfaceToString(val); ok {
|
|
fieldValue.SetString(strVal)
|
|
}
|
|
case reflect.Bool:
|
|
if boolVal, ok := interfaceToBool(val); ok {
|
|
fieldValue.SetBool(boolVal)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return effectiveConfig
|
|
}
|
|
|
|
// ValidateSettings 验证系统配置的有效性
|
|
func (sm *SystemSettingsManager) ValidateSettings(settingsMap map[string]any) error {
|
|
tempSettings := DefaultSystemSettings()
|
|
v := reflect.ValueOf(&tempSettings).Elem()
|
|
t := v.Type()
|
|
jsonToField := make(map[string]reflect.StructField)
|
|
for i := 0; i < t.NumField(); i++ {
|
|
field := t.Field(i)
|
|
jsonTag := field.Tag.Get("json")
|
|
if jsonTag != "" {
|
|
jsonToField[jsonTag] = field
|
|
}
|
|
}
|
|
|
|
for key, value := range settingsMap {
|
|
field, ok := jsonToField[key]
|
|
if !ok {
|
|
return fmt.Errorf("invalid setting key: %s", key)
|
|
}
|
|
|
|
validateTag := field.Tag.Get("validate")
|
|
|
|
switch field.Type.Kind() {
|
|
case reflect.Int:
|
|
// JSON numbers are decoded as float64
|
|
floatVal, ok := value.(float64)
|
|
if !ok {
|
|
return fmt.Errorf("invalid type for %s: expected a number, got %T", key, value)
|
|
}
|
|
intVal := int(floatVal)
|
|
if floatVal != float64(intVal) {
|
|
return fmt.Errorf("invalid value for %s: must be an integer", key)
|
|
}
|
|
|
|
if strings.HasPrefix(validateTag, "min=") {
|
|
minValStr := strings.TrimPrefix(validateTag, "min=")
|
|
minVal, _ := strconv.Atoi(minValStr)
|
|
if intVal < minVal {
|
|
return fmt.Errorf("value for %s (%d) is below minimum value (%d)", key, intVal, minVal)
|
|
}
|
|
}
|
|
case reflect.Bool:
|
|
if _, ok := value.(bool); !ok {
|
|
return fmt.Errorf("invalid type for %s: expected a boolean, got %T", key, value)
|
|
}
|
|
case reflect.String:
|
|
if _, ok := value.(string); !ok {
|
|
return fmt.Errorf("invalid type for %s: expected a string, got %T", key, value)
|
|
}
|
|
default:
|
|
return fmt.Errorf("unsupported type for setting key validation: %s", key)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// DisplayCurrentSettings 显示当前系统配置信息
|
|
func (sm *SystemSettingsManager) DisplayCurrentSettings() {
|
|
sm.mu.RLock()
|
|
defer sm.mu.RUnlock()
|
|
|
|
logrus.Info("Current System Settings:")
|
|
logrus.Infof(" Blacklist threshold: %d", sm.settings.BlacklistThreshold)
|
|
logrus.Infof(" Max retries: %d", sm.settings.MaxRetries)
|
|
logrus.Infof(" Server timeouts: read=%ds, write=%ds, idle=%ds, shutdown=%ds",
|
|
sm.settings.ServerReadTimeout, sm.settings.ServerWriteTimeout,
|
|
sm.settings.ServerIdleTimeout, sm.settings.ServerGracefulShutdownTimeout)
|
|
logrus.Infof(" Request timeouts: request=%ds, response=%ds, idle_conn=%ds",
|
|
sm.settings.RequestTimeout, sm.settings.ResponseTimeout, sm.settings.IdleConnTimeout)
|
|
logrus.Infof(" Request log retention: %d days", sm.settings.RequestLogRetentionDays)
|
|
}
|
|
|
|
// 辅助方法
|
|
|
|
func (sm *SystemSettingsManager) mapToStruct(m map[string]string, s *SystemSettings) {
|
|
v := reflect.ValueOf(s).Elem()
|
|
t := v.Type()
|
|
|
|
// 创建一个从 json 标签到字段名的映射
|
|
jsonToField := make(map[string]string)
|
|
for i := 0; i < t.NumField(); i++ {
|
|
field := t.Field(i)
|
|
jsonTag := strings.Split(field.Tag.Get("json"), ",")[0]
|
|
if jsonTag != "" {
|
|
jsonToField[jsonTag] = field.Name
|
|
}
|
|
}
|
|
|
|
for key, valStr := range m {
|
|
if fieldName, ok := jsonToField[key]; ok {
|
|
fieldValue := v.FieldByName(fieldName)
|
|
if fieldValue.IsValid() && fieldValue.CanSet() {
|
|
if err := setFieldFromString(fieldValue, valStr); err != nil {
|
|
logrus.Warnf("Failed to set value from map for field %s: %v", fieldName, err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// setFieldFromString sets a struct field's value from a string, based on the field's kind.
|
|
func setFieldFromString(fieldValue reflect.Value, value string) error {
|
|
if !fieldValue.CanSet() {
|
|
return fmt.Errorf("field cannot be set")
|
|
}
|
|
|
|
switch fieldValue.Kind() {
|
|
case reflect.Int:
|
|
intVal, err := strconv.ParseInt(value, 10, 64)
|
|
if err != nil {
|
|
return fmt.Errorf("invalid integer value '%s': %w", value, err)
|
|
}
|
|
fieldValue.SetInt(int64(intVal))
|
|
case reflect.Bool:
|
|
boolVal, err := strconv.ParseBool(value)
|
|
if err != nil {
|
|
return fmt.Errorf("invalid boolean value '%s': %w", value, err)
|
|
}
|
|
fieldValue.SetBool(boolVal)
|
|
case reflect.String:
|
|
fieldValue.SetString(value)
|
|
default:
|
|
return fmt.Errorf("unsupported field kind: %s", fieldValue.Kind())
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// 工具函数
|
|
|
|
func interfaceToInt(val interface{}) (int, error) {
|
|
switch v := val.(type) {
|
|
case int:
|
|
return v, nil
|
|
case float64:
|
|
// JSON unmarshals numbers into float64
|
|
if v != float64(int(v)) {
|
|
return 0, fmt.Errorf("value is a float, not an integer: %v", v)
|
|
}
|
|
return int(v), nil
|
|
case string:
|
|
return strconv.Atoi(v)
|
|
default:
|
|
return 0, fmt.Errorf("cannot convert %T to int", v)
|
|
}
|
|
}
|
|
|
|
// interfaceToString is kept for GetEffectiveConfig
|
|
func interfaceToString(val interface{}) (string, bool) {
|
|
s, ok := val.(string)
|
|
return s, ok
|
|
}
|
|
|
|
// interfaceToBool is kept for GetEffectiveConfig
|
|
func interfaceToBool(val interface{}) (bool, bool) {
|
|
switch v := val.(type) {
|
|
case bool:
|
|
return v, true
|
|
case string:
|
|
b, err := strconv.ParseBool(v)
|
|
if err == nil {
|
|
return b, true
|
|
}
|
|
}
|
|
return false, false
|
|
}
|