248 lines
9.2 KiB
Go
248 lines
9.2 KiB
Go
package api
|
|
|
|
import (
|
|
"encoding/json"
|
|
"net/http"
|
|
"strconv"
|
|
|
|
"codex-pool/internal/database"
|
|
"codex-pool/internal/logger"
|
|
)
|
|
|
|
// MonitorSettings 监控设置
|
|
type MonitorSettings struct {
|
|
Target int `json:"target"`
|
|
AutoAdd bool `json:"auto_add"`
|
|
AutoRegister bool `json:"auto_register"` // 母号不足时自动注册
|
|
AutoRegConcurrency int `json:"auto_reg_concurrency"` // 自动注册并发数
|
|
AutoRegUseProxy bool `json:"auto_reg_use_proxy"` // 自动注册时使用代理
|
|
MinInterval int `json:"min_interval"`
|
|
CheckInterval int `json:"check_interval"` // 自动补号检查间隔（秒）
|
|
PollingEnabled bool `json:"polling_enabled"`
|
|
PollingInterval int `json:"polling_interval"`
|
|
ReplenishUseProxy bool `json:"replenish_use_proxy"` // 补号时使用代理
|
|
BrowserType string `json:"browser_type"` // 授权浏览器引擎: chromedp 或 rod
|
|
MembersPerTeam int `json:"members_per_team"` // 每 Team 成员数
|
|
ConcurrentTeams int `json:"concurrent_teams"` // 并发 Team 数
|
|
S2AConcurrency int `json:"s2a_concurrency"` // 入库并发数
|
|
}
|
|
|
|
// HandleGetMonitorSettings 获取监控设置
|
|
func HandleGetMonitorSettings(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodGet {
|
|
Error(w, http.StatusMethodNotAllowed, "仅支持 GET")
|
|
return
|
|
}
|
|
|
|
if database.Instance == nil {
|
|
Error(w, http.StatusInternalServerError, "数据库未初始化")
|
|
return
|
|
}
|
|
|
|
settings := MonitorSettings{
|
|
Target: 50,
|
|
AutoAdd: false,
|
|
AutoRegister: false,
|
|
AutoRegConcurrency: 2,
|
|
AutoRegUseProxy: false,
|
|
MinInterval: 300,
|
|
CheckInterval: 60,
|
|
PollingEnabled: false,
|
|
PollingInterval: 60,
|
|
ReplenishUseProxy: false,
|
|
BrowserType: "chromedp", // 默认使用 chromedp
|
|
MembersPerTeam: 4, // 默认每 Team 4 个成员
|
|
ConcurrentTeams: 2, // 默认并发 2 个 Team
|
|
S2AConcurrency: 2, // 默认入库并发 2
|
|
}
|
|
|
|
if val, _ := database.Instance.GetConfig("monitor_target"); val != "" {
|
|
if v, err := strconv.Atoi(val); err == nil {
|
|
settings.Target = v
|
|
}
|
|
}
|
|
if val, _ := database.Instance.GetConfig("monitor_auto_add"); val == "true" {
|
|
settings.AutoAdd = true
|
|
}
|
|
if val, _ := database.Instance.GetConfig("monitor_auto_register"); val == "true" {
|
|
settings.AutoRegister = true
|
|
}
|
|
if val, _ := database.Instance.GetConfig("monitor_auto_reg_concurrency"); val != "" {
|
|
if v, err := strconv.Atoi(val); err == nil {
|
|
settings.AutoRegConcurrency = v
|
|
}
|
|
}
|
|
if val, _ := database.Instance.GetConfig("monitor_auto_reg_use_proxy"); val == "true" {
|
|
settings.AutoRegUseProxy = true
|
|
}
|
|
if val, _ := database.Instance.GetConfig("monitor_min_interval"); val != "" {
|
|
if v, err := strconv.Atoi(val); err == nil {
|
|
settings.MinInterval = v
|
|
}
|
|
}
|
|
if val, _ := database.Instance.GetConfig("monitor_check_interval"); val != "" {
|
|
if v, err := strconv.Atoi(val); err == nil {
|
|
settings.CheckInterval = v
|
|
}
|
|
}
|
|
if val, _ := database.Instance.GetConfig("monitor_polling_enabled"); val == "true" {
|
|
settings.PollingEnabled = true
|
|
}
|
|
if val, _ := database.Instance.GetConfig("monitor_polling_interval"); val != "" {
|
|
if v, err := strconv.Atoi(val); err == nil {
|
|
settings.PollingInterval = v
|
|
}
|
|
}
|
|
if val, _ := database.Instance.GetConfig("monitor_replenish_use_proxy"); val == "true" {
|
|
settings.ReplenishUseProxy = true
|
|
}
|
|
if val, _ := database.Instance.GetConfig("monitor_browser_type"); val != "" {
|
|
settings.BrowserType = val
|
|
}
|
|
if val, _ := database.Instance.GetConfig("monitor_members_per_team"); val != "" {
|
|
if v, err := strconv.Atoi(val); err == nil {
|
|
settings.MembersPerTeam = v
|
|
}
|
|
}
|
|
if val, _ := database.Instance.GetConfig("monitor_concurrent_teams"); val != "" {
|
|
if v, err := strconv.Atoi(val); err == nil {
|
|
settings.ConcurrentTeams = v
|
|
}
|
|
}
|
|
if val, _ := database.Instance.GetConfig("monitor_s2a_concurrency"); val != "" {
|
|
if v, err := strconv.Atoi(val); err == nil {
|
|
settings.S2AConcurrency = v
|
|
}
|
|
}
|
|
|
|
Success(w, settings)
|
|
}
|
|
|
|
// HandleSaveMonitorSettings 保存监控设置
|
|
func HandleSaveMonitorSettings(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodPost {
|
|
Error(w, http.StatusMethodNotAllowed, "仅支持 POST")
|
|
return
|
|
}
|
|
|
|
if database.Instance == nil {
|
|
logger.Error("保存监控设置失败: 数据库未初始化", "", "monitor")
|
|
Error(w, http.StatusInternalServerError, "数据库未初始化")
|
|
return
|
|
}
|
|
|
|
var settings MonitorSettings
|
|
if err := json.NewDecoder(r.Body).Decode(&settings); err != nil {
|
|
logger.Error("保存监控设置失败: 解析请求失败 - "+err.Error(), "", "monitor")
|
|
Error(w, http.StatusBadRequest, "解析请求失败")
|
|
return
|
|
}
|
|
|
|
logger.Info("收到保存监控设置请求: target="+strconv.Itoa(settings.Target)+
|
|
", auto_add="+strconv.FormatBool(settings.AutoAdd)+
|
|
", check_interval="+strconv.Itoa(settings.CheckInterval)+
|
|
", polling="+strconv.FormatBool(settings.PollingEnabled), "", "monitor")
|
|
|
|
// 保存到数据库
|
|
var saveErrors []string
|
|
if err := database.Instance.SetConfig("monitor_target", strconv.Itoa(settings.Target)); err != nil {
|
|
saveErrors = append(saveErrors, "target: "+err.Error())
|
|
}
|
|
if err := database.Instance.SetConfig("monitor_auto_add", strconv.FormatBool(settings.AutoAdd)); err != nil {
|
|
saveErrors = append(saveErrors, "auto_add: "+err.Error())
|
|
}
|
|
if err := database.Instance.SetConfig("monitor_auto_register", strconv.FormatBool(settings.AutoRegister)); err != nil {
|
|
saveErrors = append(saveErrors, "auto_register: "+err.Error())
|
|
}
|
|
// 自动注册并发数 (1-10)
|
|
autoRegConcurrency := settings.AutoRegConcurrency
|
|
if autoRegConcurrency < 1 {
|
|
autoRegConcurrency = 1
|
|
} else if autoRegConcurrency > 10 {
|
|
autoRegConcurrency = 10
|
|
}
|
|
if err := database.Instance.SetConfig("monitor_auto_reg_concurrency", strconv.Itoa(autoRegConcurrency)); err != nil {
|
|
saveErrors = append(saveErrors, "auto_reg_concurrency: "+err.Error())
|
|
}
|
|
if err := database.Instance.SetConfig("monitor_auto_reg_use_proxy", strconv.FormatBool(settings.AutoRegUseProxy)); err != nil {
|
|
saveErrors = append(saveErrors, "auto_reg_use_proxy: "+err.Error())
|
|
}
|
|
if err := database.Instance.SetConfig("monitor_min_interval", strconv.Itoa(settings.MinInterval)); err != nil {
|
|
saveErrors = append(saveErrors, "min_interval: "+err.Error())
|
|
}
|
|
// 检查间隔最小10秒
|
|
checkInterval := settings.CheckInterval
|
|
if checkInterval < 10 {
|
|
checkInterval = 10
|
|
}
|
|
if err := database.Instance.SetConfig("monitor_check_interval", strconv.Itoa(checkInterval)); err != nil {
|
|
saveErrors = append(saveErrors, "check_interval: "+err.Error())
|
|
}
|
|
if err := database.Instance.SetConfig("monitor_polling_enabled", strconv.FormatBool(settings.PollingEnabled)); err != nil {
|
|
saveErrors = append(saveErrors, "polling_enabled: "+err.Error())
|
|
}
|
|
if err := database.Instance.SetConfig("monitor_polling_interval", strconv.Itoa(settings.PollingInterval)); err != nil {
|
|
saveErrors = append(saveErrors, "polling_interval: "+err.Error())
|
|
}
|
|
if err := database.Instance.SetConfig("monitor_replenish_use_proxy", strconv.FormatBool(settings.ReplenishUseProxy)); err != nil {
|
|
saveErrors = append(saveErrors, "replenish_use_proxy: "+err.Error())
|
|
}
|
|
// 浏览器类型默认为 chromedp
|
|
browserType := settings.BrowserType
|
|
if browserType != "chromedp" && browserType != "rod" {
|
|
browserType = "chromedp"
|
|
}
|
|
if err := database.Instance.SetConfig("monitor_browser_type", browserType); err != nil {
|
|
saveErrors = append(saveErrors, "browser_type: "+err.Error())
|
|
}
|
|
// 每 Team 成员数 (1-10)
|
|
membersPerTeam := settings.MembersPerTeam
|
|
if membersPerTeam < 1 {
|
|
membersPerTeam = 1
|
|
} else if membersPerTeam > 10 {
|
|
membersPerTeam = 10
|
|
}
|
|
if err := database.Instance.SetConfig("monitor_members_per_team", strconv.Itoa(membersPerTeam)); err != nil {
|
|
saveErrors = append(saveErrors, "members_per_team: "+err.Error())
|
|
}
|
|
// 并发 Team 数 (1-10)
|
|
concurrentTeams := settings.ConcurrentTeams
|
|
if concurrentTeams < 1 {
|
|
concurrentTeams = 1
|
|
} else if concurrentTeams > 10 {
|
|
concurrentTeams = 10
|
|
}
|
|
if err := database.Instance.SetConfig("monitor_concurrent_teams", strconv.Itoa(concurrentTeams)); err != nil {
|
|
saveErrors = append(saveErrors, "concurrent_teams: "+err.Error())
|
|
}
|
|
// 入库并发数 (1-4)
|
|
s2aConcurrency := settings.S2AConcurrency
|
|
if s2aConcurrency < 1 {
|
|
s2aConcurrency = 1
|
|
} else if s2aConcurrency > 4 {
|
|
s2aConcurrency = 4
|
|
}
|
|
if err := database.Instance.SetConfig("monitor_s2a_concurrency", strconv.Itoa(s2aConcurrency)); err != nil {
|
|
saveErrors = append(saveErrors, "s2a_concurrency: "+err.Error())
|
|
}
|
|
|
|
if len(saveErrors) > 0 {
|
|
errMsg := "保存监控设置部分失败: " + saveErrors[0]
|
|
logger.Error(errMsg, "", "monitor")
|
|
Error(w, http.StatusInternalServerError, errMsg)
|
|
return
|
|
}
|
|
|
|
// 输出日志
|
|
logger.Success("监控设置已保存: target="+strconv.Itoa(settings.Target)+
|
|
", auto_add="+strconv.FormatBool(settings.AutoAdd)+
|
|
", check_interval="+strconv.Itoa(checkInterval)+"s"+
|
|
", polling="+strconv.FormatBool(settings.PollingEnabled)+
|
|
", polling_interval="+strconv.Itoa(settings.PollingInterval)+"s", "", "monitor")
|
|
|
|
Success(w, map[string]interface{}{
|
|
"message": "设置已保存",
|
|
"settings": settings,
|
|
})
|
|
}
|