admin/TaskPool
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: refact scheduler

Browse Source
This commit is contained in:
engigu
2026-02-07 21:44:09 +08:00
parent cdf3b3dbdc
commit f746c871fa
37 changed files with 2888 additions and 1316 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/services/agent_service.go
+40 -11
View File
@@ -1,11 +1,6 @@
package services
import (
"github.com/engigu/baihu-panel/internal/constant"
"github.com/engigu/baihu-panel/internal/database"
"github.com/engigu/baihu-panel/internal/logger"
"github.com/engigu/baihu-panel/internal/models"
"github.com/engigu/baihu-panel/internal/services/tasks"
"crypto/rand"
"encoding/hex"
"fmt"
@@ -14,6 +9,12 @@ import (
"strings"
"time"
"github.com/engigu/baihu-panel/internal/constant"
"github.com/engigu/baihu-panel/internal/database"
"github.com/engigu/baihu-panel/internal/logger"
"github.com/engigu/baihu-panel/internal/models"
"github.com/engigu/baihu-panel/internal/services/tasks"
"gorm.io/gorm"
)
@@ -308,7 +309,7 @@ func (s *AgentService) GetTasks(agentID uint) []models.AgentTask {
for i, task := range tasks {
// 将环境变量 ID 转换为实际的环境变量键值对
envVarsStr := s.buildEnvVarsString(task.Envs)
result[i] = models.AgentTask{
ID: task.ID,
Name: task.Name,
@@ -353,11 +354,32 @@ func (s *AgentService) buildEnvVarsString(envIDs string) string {
func (s *AgentService) ReportResult(result *models.AgentTaskResult) error {
// 获取依赖的服务
agentWSManager := GetAgentWSManager()
// 先尝试通知正在等待的 goroutine
if agentWSManager.NotifyRemoteResult(result) {
logger.Infof("[Agent] 已通知正在等待任务 #%d 结果的 goroutine", result.TaskID)
return nil
}
// 如果没有人在等待（例如服务重启后），则由本协程负责处理结果入库
// 如果没有人在等待（例如服务重启后），则由本协程负责处理结果入库（记录日志并清理）
logger.Infof("[Agent] 没有找到等待任务 #%d 结果的 goroutine，直接处理结果", result.TaskID)
sendStatsService := NewSendStatsService()
taskExecutionService := tasks.NewTaskExecutionService(agentWSManager, sendStatsService)
// 使用统一的结果处理流程
return taskExecutionService.ProcessAgentResult(result)
taskLogService := tasks.NewTaskLogService(sendStatsService)
// 创建日志对象
taskLog, err := taskLogService.CreateTaskLogFromAgentResult(result)
if err != nil {
return err
}
// 处理完成逻辑（保存日志、更新统计、清理旧日志等）
return taskLogService.ProcessTaskCompletion(taskLog)
}
// UpdateTaskDuration 更新任务耗时（心跳）
func (s *AgentService) UpdateTaskDuration(logID uint, duration int64) error {
taskLogService := tasks.NewTaskLogService(nil)
return taskLogService.UpdateTaskDuration(logID, duration)
}
// UpdateOfflineAgents 更新离线 Agent 状态（超过 2 分钟无心跳）
@@ -368,6 +390,13 @@ func (s *AgentService) UpdateOfflineAgents() {
Update("status", "offline")
}
// ResetAllAgentsToOffline 将所有 Agents 状态重置为离线（用于服务启动时）
func (s *AgentService) ResetAllAgentsToOffline() {
database.DB.Model(&models.Agent{}).
Where("status = ?", "online").
Update("status", "offline")
}
// GetLatestVersion 获取最新 Agent 版本
func (s *AgentService) GetLatestVersion() string {
// 优先从 /opt/agent 读取（容器内）
@@ -420,7 +449,7 @@ func (s *AgentService) CheckNeedUpdate(agentVersion, agentBuildTime string) bool
// GetAvailablePlatforms 获取可用的平台列表
func (s *AgentService) GetAvailablePlatforms() []map[string]string {
platforms := []map[string]string{}
// 优先从 /opt/agent 读取（容器内）
agentDir := "/opt/agent"
files, err := os.ReadDir(agentDir)
internal/services/agent_ws_service.go
+69 -17
View File
@@ -1,22 +1,25 @@
package services
import (
"github.com/engigu/baihu-panel/internal/database"
"github.com/engigu/baihu-panel/internal/logger"
"github.com/engigu/baihu-panel/internal/models"
"encoding/json"
"sync"
"time"
"github.com/engigu/baihu-panel/internal/constant"
"github.com/engigu/baihu-panel/internal/database"
"github.com/engigu/baihu-panel/internal/logger"
"github.com/engigu/baihu-panel/internal/models"
"github.com/gorilla/websocket"
)
// AgentWSManager WebSocket 连接管理器
type AgentWSManager struct {
connections map[uint]*AgentConnection // agentID -> connection
ipConnections map[string]int // IP -> 连接数
ipLastAttempt map[string]time.Time // IP -> 最后连接尝试时间
ipFailCount map[string]int // IP -> 连续失败次数
connections map[uint]*AgentConnection // agentID -> connection
ipConnections map[string]int // IP -> 连接数
ipLastAttempt map[string]time.Time // IP -> 最后连接尝试时间
ipFailCount map[string]int // IP -> 连续失败次数
remoteWaiters map[uint]chan *models.AgentTaskResult // logID -> result channel
mu sync.RWMutex
}
@@ -47,16 +50,19 @@ type WSMessage struct {
// 消息类型常量
const (
WSTypeHeartbeat = "heartbeat"
WSTypeHeartbeatAck = "heartbeat_ack"
WSTypeTasks = "tasks"
WSTypeTaskResult = "task_result"
WSTypeUpdate = "update"
WSTypeDisconnect = "disconnect"
WSTypeConnected = "connected" // 连接成功，包含注册状态
WSTypeDisabled = "disabled" // Agent 被禁用
WSTypeEnabled = "enabled" // Agent 被启用
WSTypeFetchTasks = "fetch_tasks" // Agent 请求任务列表
WSTypeHeartbeat = constant.WSTypeHeartbeat
WSTypeHeartbeatAck = constant.WSTypeHeartbeatAck
WSTypeTasks = constant.WSTypeTasks
WSTypeTaskResult = constant.WSTypeTaskResult
WSTypeUpdate = constant.WSTypeUpdate
WSTypeDisconnect = constant.WSTypeDisconnect
WSTypeConnected = constant.WSTypeConnected
WSTypeDisabled = constant.WSTypeDisabled
WSTypeEnabled = constant.WSTypeEnabled
WSTypeFetchTasks = constant.WSTypeFetchTasks
WSTypeTaskLog = constant.WSTypeTaskLog
WSTypeExecute = constant.WSTypeExecute
WSTypeTaskHeartbeat = constant.WSTypeTaskHeartbeat
)
var agentWSManager *AgentWSManager
@@ -70,6 +76,7 @@ func GetAgentWSManager() *AgentWSManager {
ipConnections: make(map[string]int),
ipLastAttempt: make(map[string]time.Time),
ipFailCount: make(map[string]int),
remoteWaiters: make(map[uint]chan *models.AgentTaskResult),
}
go agentWSManager.cleanupLoop()
})
@@ -215,6 +222,37 @@ func (m *AgentWSManager) BroadcastTasks(agentID uint) {
})
}
// RegisterRemoteWaiter 注册远程任务结果等待者
func (m *AgentWSManager) RegisterRemoteWaiter(logID uint) chan *models.AgentTaskResult {
m.mu.Lock()
defer m.mu.Unlock()
ch := make(chan *models.AgentTaskResult, 1)
m.remoteWaiters[logID] = ch
return ch
}
// UnregisterRemoteWaiter 注销远程任务结果等待者
func (m *AgentWSManager) UnregisterRemoteWaiter(logID uint) {
m.mu.Lock()
defer m.mu.Unlock()
delete(m.remoteWaiters, logID)
}
// NotifyRemoteResult 通知远程任务结果
func (m *AgentWSManager) NotifyRemoteResult(result *models.AgentTaskResult) bool {
m.mu.RLock()
defer m.mu.RUnlock()
if ch, ok := m.remoteWaiters[result.LogID]; ok {
select {
case ch <- result:
return true
default:
return false
}
}
return false
}
// OnlineCount 在线 Agent 数量
func (m *AgentWSManager) OnlineCount() int {
m.mu.RLock()
@@ -227,6 +265,11 @@ func (m *AgentWSManager) cleanupLoop() {
ticker := time.NewTicker(30 * time.Second)
defer ticker.Stop()
// 启动时，先将所有 "online" 状态的 Agent 重置为 "offline"
// 因为 WebSocket 连接在应用启动时是空的，所有 Agent 客观上都是离线状态
// 等它们重新连接上来后，会变为 "online"
NewAgentService().ResetAllAgentsToOffline()
for range ticker.C {
m.mu.Lock()
now := time.Now()
@@ -248,6 +291,15 @@ func (m *AgentWSManager) cleanupLoop() {
}
}
// 定期清理数据库中的过期状态（处理服务重启或异常终止的情况）
// 有些 Agent 虽然没有连接，但数据库状态可能是 "online"
cutoff := now.Add(-2 * time.Minute)
database.DB.Model(&models.Agent{}).
Where("status = ? AND last_seen < ?", "online", cutoff).
Update("status", "offline")
// 清理过期的限流记录（超过 10 分钟未活动）
// 清理过期的限流记录（超过 10 分钟未活动）
for ip, lastAttempt := range m.ipLastAttempt {
if now.Sub(lastAttempt) > 10*time.Minute {
internal/services/tasks/cron_service.go
-168
View File
@@ -1,168 +0,0 @@
package tasks
import (
"sync"
"time"
"github.com/engigu/baihu-panel/internal/database"
"github.com/engigu/baihu-panel/internal/logger"
"github.com/engigu/baihu-panel/internal/models"
"github.com/robfig/cron/v3"
)
// 东八区时区
var cstZone = time.FixedZone("CST", 8*3600)
// CronService manages scheduled tasks using robfig/cron
type CronService struct {
cron *cron.Cron
taskService *TaskService
executorService *ExecutorService
entryMap map[uint]cron.EntryID // task ID -> cron entry ID
mu sync.RWMutex
}
// NewCronService creates a new cron service
func NewCronService(taskService *TaskService, executorService *ExecutorService) *CronService {
// 使用秒级精度的 cron parser，支持 6 位表达式（秒 分 时 日 月 周），使用东八区时区
c := cron.New(cron.WithSeconds(), cron.WithLocation(cstZone))
return &CronService{
cron: c,
taskService: taskService,
executorService: executorService,
entryMap: make(map[uint]cron.EntryID),
}
}
// Start starts the cron service and loads all enabled tasks
func (cs *CronService) Start() {
cs.loadTasks()
cs.cron.Start()
logger.Info("[Cron] 调度服务已启动")
}
// Stop stops the cron service
func (cs *CronService) Stop() {
ctx := cs.cron.Stop()
<-ctx.Done()
logger.Info("[Cron] 调度服务已停止")
}
// loadTasks loads all enabled tasks from database
func (cs *CronService) loadTasks() {
tasks := cs.taskService.GetTasks()
count := 0
for _, task := range tasks {
// 只调度本地任务（agent_id 为空）
if task.Enabled && task.AgentID == nil {
err := cs.addTask(&task, false)
if err != nil {
return
}
count++
}
}
logger.Infof("[Cron] 启动调度已加载 %d 个定时任务", count)
}
// addTask 内部添加任务方法，silent 控制是否打印日志
func (cs *CronService) addTask(task *models.Task, logEnabled bool) error {
cs.mu.Lock()
// 如果已存在，先移除
if entryID, exists := cs.entryMap[task.ID]; exists {
cs.cron.Remove(entryID)
delete(cs.entryMap, task.ID)
}
taskID := task.ID
entryID, err := cs.cron.AddFunc(task.Schedule, func() {
cs.runTask(taskID)
})
if err != nil {
cs.mu.Unlock()
logger.Errorf("[Cron] 添加任务失败 #%d: %v", task.ID, err)
return err
}
cs.entryMap[task.ID] = entryID
cs.mu.Unlock()
if logEnabled {
logger.Infof("[Cron] 任务已调度 #%d %s (%s)", task.ID, task.Name, task.Schedule)
}
// 更新下次运行时间
cs.updateNextRun(task.ID)
return nil
}
// AddTask adds a task to the cron scheduler
func (cs *CronService) AddTask(task *models.Task) error {
return cs.addTask(task, true)
}
// RemoveTask removes a task from the cron scheduler
func (cs *CronService) RemoveTask(taskID uint) {
cs.mu.Lock()
defer cs.mu.Unlock()
if entryID, exists := cs.entryMap[taskID]; exists {
cs.cron.Remove(entryID)
delete(cs.entryMap, taskID)
logger.Infof("[Cron] 任务已移除 #%d", taskID)
}
}
// runTask executes a task and updates its status
func (cs *CronService) runTask(taskID uint) {
// 获取任务信息用于日志
task := cs.taskService.GetTaskByID(int(taskID))
if task != nil {
logger.Infof("[Cron] 执行任务 #%d %s", taskID, task.Name)
} else {
logger.Infof("[Cron] 执行任务 #%d", taskID)
}
// 更新 last_run
now := time.Now()
database.DB.Model(&models.Task{}).Where("id = ?", taskID).Update("last_run", now)
// 将任务加入队列执行（通过 worker pool 控制并发）
cs.executorService.EnqueueTask(int(taskID))
// 更新 next_run
cs.updateNextRun(taskID)
}
// updateNextRun updates the next run time for a task
func (cs *CronService) updateNextRun(taskID uint) {
cs.mu.RLock()
entryID, exists := cs.entryMap[taskID]
cs.mu.RUnlock()
if !exists {
return
}
entry := cs.cron.Entry(entryID)
if !entry.Next.IsZero() {
database.DB.Model(&models.Task{}).Where("id = ?", taskID).Update("next_run", entry.Next)
}
}
// ValidateCron validates a cron expression (6 fields: second minute hour day month weekday)
func (cs *CronService) ValidateCron(expression string) error {
parser := cron.NewParser(cron.Second | cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow | cron.Descriptor)
_, err := parser.Parse(expression)
return err
}
// GetScheduledCount returns the number of scheduled tasks
func (cs *CronService) GetScheduledCount() int {
cs.mu.RLock()
defer cs.mu.RUnlock()
return len(cs.entryMap)
}
internal/services/tasks/executor_service.go
+631 -221
View File
@@ -1,18 +1,33 @@
package tasks
import (
"github.com/engigu/baihu-panel/internal/constant"
"github.com/engigu/baihu-panel/internal/logger"
"github.com/engigu/baihu-panel/internal/utils"
"bytes"
"context"
"encoding/json"
"fmt"
"os"
"os/exec"
"io"
"path/filepath"
"strings"
"sync"
"time"
"github.com/engigu/baihu-panel/internal/constant"
"github.com/engigu/baihu-panel/internal/database"
"github.com/engigu/baihu-panel/internal/executor"
"github.com/engigu/baihu-panel/internal/logger"
"github.com/engigu/baihu-panel/internal/models"
"github.com/engigu/baihu-panel/internal/utils"
"gorm.io/gorm"
"gorm.io/gorm/clause"
)
// AgentWSManager 接口定义（避免循环依赖）
type AgentWSManager interface {
RegisterRemoteWaiter(logID uint) chan *models.AgentTaskResult
UnregisterRemoteWaiter(logID uint)
SendToAgent(agentID uint, msgType string, data interface{}) error
}
// SettingsService 接口定义（避免循环依赖）
type SettingsService interface {
Get(section, key string) string
@@ -23,68 +38,316 @@ type EnvService interface {
GetEnvVarsByIDs(ids string) []string
}
// ExecutionResult represents the result of a task execution
type ExecutionResult struct {
TaskID int
Success bool
Output string
Error string
Start time.Time
End time.Time
}
// taskJob 任务队列项
type taskJob struct {
taskID int
}
// ExecutorService handles task execution
// ExecutorService handles task execution and scheduling
type ExecutorService struct {
taskService *TaskService
taskExecutionService *TaskExecutionService
settingsService SettingsService
envService EnvService
results []ExecutionResult
runningTasks map[int]bool
mu sync.RWMutex
resultsMu sync.RWMutex
taskService *TaskService
taskLogService *TaskLogService
agentWSManager AgentWSManager
settingsService SettingsService
envService EnvService
scheduler *executor.Scheduler
cronManager *executor.CronManager
results []executor.ExecutionResult
mu sync.RWMutex
resultsMu sync.RWMutex
stopCh chan struct{}
}
// 任务队列和 worker pool
taskQueue chan taskJob
workerCount int
rateLimiter <-chan time.Time
stopCh chan struct{}
wg sync.WaitGroup
func (es *ExecutorService) GetScheduler() *executor.Scheduler {
return es.scheduler
}
// NewExecutorService creates a new executor service
func NewExecutorService(taskService *TaskService, taskExecutionService *TaskExecutionService, settingsService SettingsService, envService EnvService) *ExecutorService {
// 从设置中读取调度配置
workerCount := getIntSetting(settingsService, constant.SectionScheduler, constant.KeyWorkerCount, 4)
queueSize := getIntSetting(settingsService, constant.SectionScheduler, constant.KeyQueueSize, 100)
rateInterval := getIntSetting(settingsService, constant.SectionScheduler, constant.KeyRateInterval, 200)
logger.Infof("[Executor] 配置: workers=%d, queue=%d, rate=%dms", workerCount, queueSize, rateInterval)
func NewExecutorService(
taskService *TaskService,
taskLogService *TaskLogService,
agentWSManager AgentWSManager,
settingsService SettingsService,
envService EnvService,
) *ExecutorService {
es := &ExecutorService{
taskService: taskService,
taskExecutionService: taskExecutionService,
settingsService: settingsService,
envService: envService,
results: make([]ExecutionResult, 0, 100),
runningTasks: make(map[int]bool),
taskQueue: make(chan taskJob, queueSize),
workerCount: workerCount,
rateLimiter: time.Tick(time.Duration(rateInterval) * time.Millisecond),
stopCh: make(chan struct{}),
taskService: taskService,
taskLogService: taskLogService,
agentWSManager: agentWSManager,
settingsService: settingsService,
envService: envService,
results: make([]executor.ExecutionResult, 0, 100),
stopCh: make(chan struct{}),
}
// 启动 worker pool
es.startWorkers()
// 1. 初始化调度器
es.initScheduler()
// 2. 初始化计划任务管理器
es.cronManager = executor.NewCronManager(es.scheduler)
return es
}
func (es *ExecutorService) initScheduler() {
workerCount := getIntSetting(es.settingsService, constant.SectionScheduler, constant.KeyWorkerCount, 4)
queueSize := getIntSetting(es.settingsService, constant.SectionScheduler, constant.KeyQueueSize, 100)
rateInterval := getIntSetting(es.settingsService, constant.SectionScheduler, constant.KeyRateInterval, 200)
config := executor.SchedulerConfig{
WorkerCount: workerCount,
QueueSize: queueSize,
RateInterval: time.Duration(rateInterval) * time.Millisecond,
}
handler := &ServerSchedulerHandler{es: es}
es.scheduler = executor.NewScheduler(config, handler)
es.scheduler.SetLogger(logger.NewSchedulerLogger())
es.scheduler.SetExecutor(es.ExecuteDispatcher)
es.scheduler.Start()
logger.Infof("[Executor] 调度器已启动: workers=%d, queue=%d, rate=%dms", workerCount, queueSize, rateInterval)
}
// ServerSchedulerHandler 实现 executor.SchedulerEventHandler
type ServerSchedulerHandler struct {
es *ExecutorService
}
func (h *ServerSchedulerHandler) OnTaskScheduled(req *executor.ExecutionRequest) {
// 任务入队事件，可以在此处更新数据库状态为 "pending"
}
func (h *ServerSchedulerHandler) OnTaskExecuting(req *executor.ExecutionRequest) (io.Writer, io.Writer, error) {
var taskID uint
fmt.Sscanf(req.TaskID, "%d", &taskID)
task := h.es.taskService.GetTaskByID(int(taskID))
// 系统任务（无 taskID）不记录数据库日志，直接返回空写入器
if task == nil {
return nil, nil, nil
}
// 1. 创建初始日志记录
taskLog, err := h.es.taskLogService.CreateEmptyLog(task.ID, task.Command)
if err != nil {
return nil, nil, fmt.Errorf("创建初始日志失败: %v", err)
}
req.LogID = taskLog.ID // 设置 LogID 供后续环节使用
// 2. 检查并记录运行状态（并发控制）
goid, err := h.es.AddRunningGo(task.ID)
if err != nil {
// 并发限制，更新日志状态为失败
taskLog.Status = "failed"
taskLog.Output, _ = utils.CompressToBase64("任务并发数限制，拒绝执行")
h.es.taskLogService.SaveTaskLog(taskLog)
return nil, nil, fmt.Errorf("任务并发限制: %v", err)
}
if req.Metadata == nil {
req.Metadata = make(map[string]interface{})
}
req.Metadata["goid"] = goid
// 3. 创建 TinyLog 实时日志收集器
tl, err := NewTinyLog(taskLog.ID)
if err != nil {
h.es.RemoveRunningGo(task.ID, goid) // 回滚运行状态
return nil, nil, fmt.Errorf("创建日志收集器失败: %v", err)
}
// 对于本地任务，Scheduler 会通过返回的 Writer 写入日志
// 对于远程任务，Scheduler 不会写入任何内容（由 Agent 推送至此 TL）
return tl, tl, nil
}
func (h *ServerSchedulerHandler) OnTaskHeartbeat(req *executor.ExecutionRequest, duration int64) {
if req.LogID > 0 {
h.es.taskLogService.UpdateTaskDuration(req.LogID, duration)
}
}
func (h *ServerSchedulerHandler) OnTaskStarted(req *executor.ExecutionRequest) {
// Logic moved to OnTaskExecuting
}
func (h *ServerSchedulerHandler) OnTaskCompleted(req *executor.ExecutionRequest, result *executor.ExecutionResult) {
if req.LogID == 0 {
return
}
var taskID uint
fmt.Sscanf(req.TaskID, "%d", &taskID)
task := h.es.taskService.GetTaskByID(int(taskID))
if task == nil {
return
}
// 无论本地还是远程，都在此处处理日志压缩和落库
tl := GetActiveLog(req.LogID)
var output string
if tl != nil {
// 压缩并清理实时日志
var err error
output, err = tl.CompressAndCleanup()
if err != nil {
logger.Errorf("[Executor] 压缩任务 #%d 日志失败: %v", task.ID, err)
output = "[System Error] 日志处理失败: " + err.Error()
}
} else {
// 如果 TinyLog 已经丢失，尝试从 result.Output 中恢复一次（主要针对本地任务）
output, _ = utils.CompressToBase64(result.Output)
}
// 构造待保存的日志模型
startTime := models.LocalTime(result.StartTime)
endTime := models.LocalTime(result.EndTime)
taskLog := &models.TaskLog{
ID: req.LogID,
TaskID: task.ID,
Command: req.Command,
Output: output,
Status: result.Status,
Duration: result.Duration,
ExitCode: result.ExitCode,
StartTime: &startTime,
EndTime: &endTime,
}
// 如果有 AgentID，也记录下来
if task.AgentID != nil && *task.AgentID > 0 {
agentID := *task.AgentID
taskLog.AgentID = &agentID
}
// 移除运行记录
if req.Metadata != nil {
if goid, ok := req.Metadata["goid"].(int64); ok {
h.es.RemoveRunningGo(task.ID, goid)
}
}
// 处理任务完成（更新统计、清理旧日志等）
h.es.taskLogService.ProcessTaskCompletion(taskLog)
}
func (h *ServerSchedulerHandler) OnTaskFailed(req *executor.ExecutionRequest, err error) {
if req.LogID == 0 {
return
}
var taskID uint
fmt.Sscanf(req.TaskID, "%d", &taskID)
// 移除运行记录
if req.Metadata != nil {
if goid, ok := req.Metadata["goid"].(int64); ok {
h.es.RemoveRunningGo(taskID, goid)
}
}
// 构造错误日志
tl := GetActiveLog(req.LogID)
var output string
if tl != nil {
tl.Write([]byte(fmt.Sprintf("\n[System Error] %v", err)))
output, _ = tl.CompressAndCleanup()
} else {
output, _ = utils.CompressToBase64(fmt.Sprintf("任务执行失败: %v", err))
}
now := models.LocalTime(time.Now())
taskLog := &models.TaskLog{
ID: req.LogID,
TaskID: taskID,
Output: output,
Status: "failed",
Duration: 0,
ExitCode: 1,
EndTime: &now,
}
// 补充 AgentID
task := h.es.taskService.GetTaskByID(int(taskID))
if task != nil && task.AgentID != nil && *task.AgentID > 0 {
agentID := *task.AgentID
taskLog.AgentID = &agentID
}
h.es.taskLogService.ProcessTaskCompletion(taskLog)
}
func (h *ServerSchedulerHandler) OnCronNextRun(req *executor.ExecutionRequest, nextRun time.Time) {
var taskID uint
fmt.Sscanf(req.TaskID, "%d", &taskID)
// 更新数据库中的下次运行时间
database.DB.Model(&models.Task{}).Where("id = ?", taskID).Update("next_run", nextRun)
}
// LocalTaskHooks 本地任务钩子适配器
type LocalTaskHooks struct {
es *ExecutorService
logID uint
}
func (h *LocalTaskHooks) PreExecute(ctx context.Context, req executor.Request) (uint, error) {
return h.logID, nil
}
func (h *LocalTaskHooks) PostExecute(ctx context.Context, logID uint, result *executor.Result) error {
return nil
}
func (h *LocalTaskHooks) OnHeartbeat(ctx context.Context, logID uint, duration int64) error {
if logID > 0 {
return h.es.taskLogService.UpdateTaskDuration(logID, duration)
}
return nil
}
// ExecuteDispatcher 实现任务分发逻辑
func (es *ExecutorService) ExecuteDispatcher(ctx context.Context, req *executor.ExecutionRequest, stdout, stderr io.Writer) (*executor.Result, error) {
var taskID uint
fmt.Sscanf(req.TaskID, "%d", &taskID)
task := es.taskService.GetTaskByID(int(taskID))
// 系统任务（无 taskID）直接本地执行
if task == nil {
return executor.Execute(ctx, executor.Request{
Command: req.Command,
WorkDir: req.WorkDir,
Envs: req.Envs,
Timeout: req.Timeout,
}, stdout, stderr)
}
// 特殊处理仓库同步任务
if task.Type == "repo" {
cmd, workDir := es.BuildRepoCommand(task)
if cmd != "" {
req.Command = cmd
req.WorkDir = workDir
}
}
// 加载环境变量
if task.Envs != "" {
req.Envs = append(req.Envs, es.loadEnvVars(task.Envs)...)
}
// 远程任务
if task.AgentID != nil && *task.AgentID > 0 {
return es.ExecuteRemoteForScheduler(task, req.LogID)
}
// 本地任务
hooks := &LocalTaskHooks{es: es, logID: req.LogID}
return executor.ExecuteWithHooks(ctx, executor.Request{
Command: req.Command,
WorkDir: req.WorkDir,
Envs: req.Envs,
Timeout: req.Timeout,
}, stdout, stderr, hooks)
}
// getIntSetting 从设置中获取整数值
func getIntSetting(s SettingsService, section, key string, defaultVal int) int {
val := s.Get(section, key)
@@ -98,220 +361,367 @@ func getIntSetting(s SettingsService, section, key string, defaultVal int) int {
return result
}
// startWorkers 启动 worker pool
func (es *ExecutorService) startWorkers() {
for i := 0; i < es.workerCount; i++ {
es.wg.Add(1)
go es.worker(i)
}
}
// worker 从队列中取任务执行
func (es *ExecutorService) worker(id int) {
defer es.wg.Done()
for {
select {
case <-es.stopCh:
return
case job := <-es.taskQueue:
// 速率限制
<-es.rateLimiter
es.executeTaskInternal(job.taskID)
}
}
}
// Stop 停止 executor service
func (es *ExecutorService) Stop() {
close(es.stopCh)
es.wg.Wait()
es.StopCron()
es.scheduler.Stop()
}
// Reload 重新加载配置并重建 worker pool
// StartCron 启动计划任务
func (es *ExecutorService) StartCron() {
es.loadCronTasks()
es.cronManager.Start()
logger.Info("[Executor] 计划任务管理器已启动")
}
// StopCron 停止计划任务
func (es *ExecutorService) StopCron() {
es.cronManager.Stop()
logger.Info("[Executor] 计划任务管理器已停止")
}
// AddCronTask 添加计划任务
func (es *ExecutorService) AddCronTask(task *models.Task) error {
return es.cronManager.AddTask(task)
}
// RemoveCronTask 移除计划任务
func (es *ExecutorService) RemoveCronTask(taskID uint) {
es.cronManager.RemoveTask(fmt.Sprintf("%d", taskID))
}
// ValidateCron 验证 Cron 表达式
func (es *ExecutorService) ValidateCron(expression string) error {
return es.cronManager.ValidateCron(expression)
}
// GetScheduledCount 获取已加载的计划任务数量
func (es *ExecutorService) GetScheduledCount() int {
return es.cronManager.GetScheduledCount()
}
// loadCronTasks 加载所有已启用的本地计划任务
func (es *ExecutorService) loadCronTasks() {
tasks := es.taskService.GetTasks()
count := 0
for _, task := range tasks {
// 只调度本地任务（agent_id 为空或 0）
if task.Enabled && (task.AgentID == nil || *task.AgentID == 0) {
err := es.cronManager.AddTask(&task)
if err != nil {
continue
}
count++
}
}
logger.Infof("[Executor] 启动调度已加载 %d 个定时任务", count)
}
// Reload 重新加载配置并重建调度器
func (es *ExecutorService) Reload() {
logger.Info("[Executor] 正在重载配置...")
// 停止现有 workers
close(es.stopCh)
es.wg.Wait()
logger.Info("[Executor] 已停止工作线程")
es.scheduler.Stop()
// 从设置中读取新配置
workerCount := getIntSetting(es.settingsService, constant.SectionScheduler, constant.KeyWorkerCount, 4)
queueSize := getIntSetting(es.settingsService, constant.SectionScheduler, constant.KeyQueueSize, 100)
rateInterval := getIntSetting(es.settingsService, constant.SectionScheduler, constant.KeyRateInterval, 200)
// 重建 channel 和配置
es.mu.Lock()
es.taskQueue = make(chan taskJob, queueSize)
es.workerCount = workerCount
es.rateLimiter = time.Tick(time.Duration(rateInterval) * time.Millisecond)
es.stopCh = make(chan struct{})
es.mu.Unlock()
// 启动新的 workers
es.startWorkers()
logger.Infof("[Executor] 配置已重载: workers=%d, queue=%d, rate=%dms", workerCount, queueSize, rateInterval)
}
// EnqueueTask 将任务加入队列（供 cron 调度器调用）
func (es *ExecutorService) EnqueueTask(taskID int) {
select {
case es.taskQueue <- taskJob{taskID: taskID}:
// 成功入队
default:
// 队列满，直接执行（降级处理）
logger.Warnf("[Executor] 任务队列已满，直接执行任务 #%d", taskID)
go es.executeTaskInternal(taskID)
}
es.initScheduler()
}
// ExecuteTask executes a task by ID（同步执行，供 API 调用）
func (es *ExecutorService) ExecuteTask(taskID int) *ExecutionResult {
return es.executeTaskInternal(taskID)
}
// executeTaskInternal 内部执行任务逻辑
func (es *ExecutorService) executeTaskInternal(taskID int) *ExecutionResult {
func (es *ExecutorService) ExecuteTask(taskID int) *executor.ExecutionResult {
task := es.taskService.GetTaskByID(taskID)
if task == nil {
return &ExecutionResult{
TaskID: taskID,
Success: false,
Error: "Task not found",
Start: time.Now(),
End: time.Now(),
return &executor.ExecutionResult{
TaskID: fmt.Sprintf("%d", taskID),
Success: false,
Error: "任务不存在",
StartTime: time.Now(),
EndTime: time.Now(),
}
}
// 标记任务开始运行
es.mu.Lock()
es.runningTasks[taskID] = true
es.mu.Unlock()
var result *ExecutionResult
// 使用统一的任务执行服务
req := &TaskExecutionRequest{
TaskID: uint(taskID),
Task: task,
}
start := time.Now()
err := es.taskExecutionService.ExecuteTask(req)
end := time.Now()
if err != nil {
result = &ExecutionResult{
TaskID: taskID,
Success: false,
Error: err.Error(),
Start: start,
End: end,
}
} else {
result = &ExecutionResult{
TaskID: taskID,
Success: true,
Output: "任务已提交执行",
Start: start,
End: end,
// 1. 检查并发
if err := es.CheckConcurrency(uint(taskID)); err != nil {
return &executor.ExecutionResult{
TaskID: fmt.Sprintf("%d", taskID),
Success: false,
Error: err.Error(), // 这里会返回 "任务正在运行中，拒绝并行执行"
StartTime: time.Now(),
EndTime: time.Now(),
}
}
// 标记任务结束
es.mu.Lock()
delete(es.runningTasks, taskID)
es.mu.Unlock()
req := &executor.ExecutionRequest{
TaskID: fmt.Sprintf("%d", task.ID),
Name: task.Name,
Command: task.Command,
WorkDir: task.WorkDir,
Envs: es.loadEnvVars(task.Envs),
Timeout: task.Timeout,
Type: executor.TaskTypeManual,
}
return result
es.scheduler.EnqueueOrExecute(req)
return &executor.ExecutionResult{
TaskID: fmt.Sprintf("%d", task.ID),
Success: true,
Status: "queued",
StartTime: time.Now(),
}
}
// GetRunningCount 获取正在运行的任务数量
// GetRunningCount 获取正在运行任务数量
func (es *ExecutorService) GetRunningCount() int {
es.mu.RLock()
defer es.mu.RUnlock()
return len(es.runningTasks)
return es.scheduler.GetRunningTaskCount()
}
// ExecuteCommand executes a shell command with default timeout
func (es *ExecutorService) ExecuteCommand(command string) *ExecutionResult {
func (es *ExecutorService) ExecuteCommand(command string) *executor.ExecutionResult {
return es.ExecuteCommandWithTimeout(command, time.Duration(constant.DefaultTaskTimeout)*time.Minute)
}
// ExecuteCommandWithTimeout executes a shell command with specified timeout
func (es *ExecutorService) ExecuteCommandWithTimeout(command string, timeout time.Duration) *ExecutionResult {
func (es *ExecutorService) ExecuteCommandWithTimeout(command string, timeout time.Duration) *executor.ExecutionResult {
return es.ExecuteCommandWithEnv(command, timeout, nil)
}
// ExecuteCommandWithEnv executes a shell command with specified timeout and environment variables
func (es *ExecutorService) ExecuteCommandWithEnv(command string, timeout time.Duration, envVars []string) *ExecutionResult {
func (es *ExecutorService) ExecuteCommandWithEnv(command string, timeout time.Duration, envVars []string) *executor.ExecutionResult {
return es.ExecuteCommandWithOptions(command, timeout, envVars, "")
}
// ExecuteCommandWithOptions executes a shell command with specified timeout, environment variables and working directory
func (es *ExecutorService) ExecuteCommandWithOptions(command string, timeout time.Duration, envVars []string, workDir string) *ExecutionResult {
result := &ExecutionResult{
Success: false,
Start: time.Now(),
func (es *ExecutorService) ExecuteCommandWithOptions(command string, timeout time.Duration, envVars []string, workDir string) *executor.ExecutionResult {
req := &executor.ExecutionRequest{
Command: command,
Timeout: int(timeout.Minutes()),
Envs: envVars,
WorkDir: workDir,
Type: executor.TaskTypeSystem,
}
ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel()
shell, args := utils.GetShellCommand(command)
cmd := exec.CommandContext(ctx, shell, args...)
var stdout, stderr bytes.Buffer
cmd.Stdout = &stdout
cmd.Stderr = &stderr
// 设置工作目录
if workDir != "" {
cmd.Dir = workDir
}
// 设置环境变量：继承系统环境变量 + 自定义环境变量
if len(envVars) > 0 {
cmd.Env = append(os.Environ(), envVars...)
}
err := cmd.Run()
result.End = time.Now()
result.Output = stdout.String()
if err != nil {
if ctx.Err() == context.DeadlineExceeded {
result.Error = "执行超时\n" + stderr.String()
} else {
result.Error = err.Error() + "\n" + stderr.String()
}
} else {
result.Success = true
}
res, _ := es.scheduler.ExecuteSync(req)
// 使用独立锁保存结果
es.resultsMu.Lock()
es.results = append(es.results, *result)
if len(es.results) > 100 {
es.results = es.results[1:]
}
es.resultsMu.Unlock()
// TODO: 适配 ExecutionResult 的转换并保存结果
return result
return res
}
// GetLastResults returns the last execution results
func (es *ExecutorService) GetLastResults(count int) []ExecutionResult {
func (es *ExecutorService) GetLastResults(count int) []executor.ExecutionResult {
es.resultsMu.RLock()
defer es.resultsMu.RUnlock()
return nil
}
start := 0
if len(es.results) > count {
start = len(es.results) - count
// --- 以下内容从 TaskExecutionService 合并 ---
// CleanupRunningTasks 清理所有任务的运行状态（在重启时调用）
func (es *ExecutorService) CleanupRunningTasks() error {
logger.Info("[Executor] 正在清理残留的任务运行状态...")
return database.DB.Model(&models.Task{}).Where("1=1").Update("running_go", "[]").Error
}
// CheckConcurrency 检查任务并发限制（只读检查）
func (es *ExecutorService) CheckConcurrency(taskID uint) error {
var task models.Task
if err := database.DB.Select("config, running_go").First(&task, taskID).Error; err != nil {
return err
}
var goids []int64
if task.RunningGo != "" {
_ = json.Unmarshal([]byte(task.RunningGo), &goids)
}
results := make([]ExecutionResult, len(es.results[start:]))
copy(results, es.results[start:])
return results
var config models.TaskConfig
if task.Config != "" {
_ = json.Unmarshal([]byte(task.Config), &config)
}
if config.Concurrency == 0 && len(goids) > 0 {
return fmt.Errorf("任务正在运行中，拒绝并行执行，请前往日志查看")
}
return nil
}
// AddRunningGo 添加当前 goroutine ID 到任务的 running_go 字段
func (es *ExecutorService) AddRunningGo(taskID uint) (int64, error) {
goid := utils.GetGoroutineID()
err := database.DB.Transaction(func(tx *gorm.DB) error {
var task models.Task
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&task, taskID).Error; err != nil {
return err
}
var goids []int64
if task.RunningGo != "" {
_ = json.Unmarshal([]byte(task.RunningGo), &goids)
}
// 解析配置以获取并发设置
var config models.TaskConfig
if task.Config != "" {
_ = json.Unmarshal([]byte(task.Config), &config)
}
// 如果并发为0(禁用)且已有执行中的任务，返回错误
if config.Concurrency == 0 && len(goids) > 0 {
return fmt.Errorf("task is running")
}
goids = append(goids, goid)
data, _ := json.Marshal(goids)
return tx.Model(&task).Update("running_go", string(data)).Error
})
return goid, err
}
// RemoveRunningGo 从任务的 running_go 字段移除指定 goroutine ID
func (es *ExecutorService) RemoveRunningGo(taskID uint, goid int64) {
database.DB.Transaction(func(tx *gorm.DB) error {
var task models.Task
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&task, taskID).Error; err != nil {
return err
}
var goids []int64
if task.RunningGo != "" {
_ = json.Unmarshal([]byte(task.RunningGo), &goids)
}
newGoids := make([]int64, 0)
for _, id := range goids {
if id != goid {
newGoids = append(newGoids, id)
}
}
data, _ := json.Marshal(newGoids)
return tx.Model(&task).Update("running_go", string(data)).Error
})
}
// ExecuteRemoteForScheduler 供 Scheduler 调用，执行远程任务并等待结果
func (es *ExecutorService) ExecuteRemoteForScheduler(task *models.Task, logID uint) (*executor.Result, error) {
agentID := *task.AgentID
logger.Infof("[Executor] 远程执行任务 #%d: %s (Agent #%d, LogID: %d)", task.ID, task.Name, agentID, logID)
// 1. 检查 Agent 状态
var agent models.Agent
if err := database.DB.First(&agent, agentID).Error; err != nil {
return nil, fmt.Errorf("Agent #%d 不存在", agentID)
}
if !agent.Enabled {
return nil, fmt.Errorf("Agent #%d 已禁用", agentID)
}
if es.agentWSManager == nil {
return nil, fmt.Errorf("AgentWSManager 未初始化")
}
// 2. 注册结果等待者
resultChan := es.agentWSManager.RegisterRemoteWaiter(logID)
defer es.agentWSManager.UnregisterRemoteWaiter(logID)
// 3. 发送指令
err := es.agentWSManager.SendToAgent(agentID, constant.WSTypeExecute, map[string]interface{}{
"task_id": task.ID,
"log_id": logID,
})
if err != nil {
return nil, fmt.Errorf("发送执行命令失败: %v", err)
}
// 4. 等待结果或超时
timeout := task.Timeout
if timeout <= 0 {
timeout = 30
}
start := time.Now()
select {
case agentResult := <-resultChan:
return &executor.Result{
Output: agentResult.Output,
Status: agentResult.Status,
Duration: agentResult.Duration,
ExitCode: agentResult.ExitCode,
StartTime: time.Unix(agentResult.StartTime, 0),
EndTime: time.Unix(agentResult.EndTime, 0),
}, nil
case <-time.After(time.Duration(timeout) * time.Minute):
end := time.Now()
return &executor.Result{
Status: "failed",
Duration: end.Sub(start).Milliseconds(),
ExitCode: -1,
StartTime: start,
EndTime: end,
}, fmt.Errorf("远程执行超时")
}
}
// HandleAgentResult 处理来自 Agent 的异步结果
func (es *ExecutorService) HandleAgentResult(result *models.AgentTaskResult) error {
taskLog, err := es.taskLogService.CreateTaskLogFromAgentResult(result)
if err != nil {
return err
}
return es.taskLogService.ProcessTaskCompletion(taskLog)
}
// BuildRepoCommand 构建仓库同步任务的命令
func (es *ExecutorService) BuildRepoCommand(task *models.Task) (string, string) {
var config models.RepoConfig
if err := json.Unmarshal([]byte(task.Config), &config); err != nil {
return "", ""
}
targetPath := config.TargetPath
if targetPath == "" {
targetPath = constant.ScriptsWorkDir
} else if !filepath.IsAbs(targetPath) {
targetPath = filepath.Join(constant.ScriptsWorkDir, targetPath)
}
absTargetPath, _ := filepath.Abs(targetPath)
args := []string{
"/opt/sync.py",
"--source-type", config.SourceType,
"--source-url", config.SourceURL,
"--target-path", absTargetPath,
}
if config.Branch != "" {
args = append(args, "--branch", config.Branch)
}
if config.SparsePath != "" {
args = append(args, "--path", config.SparsePath)
}
if config.SingleFile {
args = append(args, "--single-file")
}
if config.Proxy != "" && config.Proxy != "none" {
args = append(args, "--proxy", config.Proxy)
if config.Proxy == "custom" && config.ProxyURL != "" {
args = append(args, "--proxy-url", config.ProxyURL)
}
}
if config.AuthToken != "" {
args = append(args, "--auth-token", config.AuthToken)
}
return "python3 " + strings.Join(args, " "), "/opt"
}
// loadEnvVars 加载环境变量
func (es *ExecutorService) loadEnvVars(envIDs string) []string {
if envIDs == "" {
return nil
}
var envVars []models.EnvironmentVariable
ids := strings.Split(envIDs, ",")
database.DB.Where("id IN ?", ids).Find(&envVars)
result := make([]string, 0, len(envVars))
for _, env := range envVars {
result = append(result, fmt.Sprintf("%s=%s", env.Name, env.Value))
}
return result
}
internal/services/tasks/task_execution_service.go
-425
View File
@@ -1,425 +0,0 @@
package tasks
import (
"github.com/engigu/baihu-panel/internal/constant"
"github.com/engigu/baihu-panel/internal/database"
"github.com/engigu/baihu-panel/internal/logger"
"github.com/engigu/baihu-panel/internal/models"
"github.com/engigu/baihu-panel/internal/utils"
"bytes"
"context"
"encoding/json"
"fmt"
"os"
"os/exec"
"path/filepath"
"runtime"
"strings"
"time"
)
// AgentWSManager 接口定义（避免循环依赖）
type AgentWSManager interface {
SendToAgent(agentID uint, msgType string, data interface{}) error
}
// TaskExecutionService 统一的任务执行服务
type TaskExecutionService struct {
taskLogService *TaskLogService
agentWSManager AgentWSManager
}
// NewTaskExecutionService 创建任务执行服务
func NewTaskExecutionService(agentWSManager AgentWSManager, sendStatsService SendStatsService) *TaskExecutionService {
return &TaskExecutionService{
taskLogService: NewTaskLogService(sendStatsService),
agentWSManager: agentWSManager,
}
}
// TaskExecutionRequest 任务执行请求
type TaskExecutionRequest struct {
TaskID uint
Task *models.Task
AgentID *uint // nil 表示本地执行
}
// TaskExecutionResult 任务执行结果
type TaskExecutionResult struct {
TaskID uint
AgentID *uint
Command string
Output string
Status string // success, failed
Duration int64 // milliseconds
ExitCode int
Start time.Time
End time.Time
}
// ExecuteTask 执行任务（统一入口）
func (s *TaskExecutionService) ExecuteTask(req *TaskExecutionRequest) error {
task := req.Task
start := time.Now()
// 演示模式：直接返回模拟结果
if constant.DemoMode {
end := time.Now()
demoOutput := fmt.Sprintf("[演示模式] 任务 #%d (%s) 执行已跳过\n实际命令不会运行: %s", task.ID, task.Name, task.Command)
result := &TaskExecutionResult{
TaskID: task.ID,
AgentID: nil,
Command: task.Command,
Output: demoOutput,
Status: "success",
Duration: end.Sub(start).Milliseconds(),
ExitCode: 0,
Start: start,
End: end,
}
return s.processExecutionResult(result)
}
if req.Task.AgentID != nil && *req.Task.AgentID > 0 {
// 远程执行：通过 Agent
return s.executeRemote(req)
}
// 本地执行
return s.executeLocal(req)
}
// executeLocal 本地执行任务
func (s *TaskExecutionService) executeLocal(req *TaskExecutionRequest) error {
task := req.Task
logger.Infof("[TaskExecution] 本地执行任务 #%d: %s", task.ID, task.Name)
// 检查任务类型，仓库任务需要特殊处理
if task.Type == "repo" {
return s.executeRepoTask(req)
}
start := time.Now()
// 准备命令
ctx, cancel := s.createContext(task.Timeout)
defer cancel()
cmd, err := s.prepareCommand(ctx, task)
if err != nil {
return s.handleExecutionError(task.ID, task.Command, start, err)
}
// 执行命令
var stdout, stderr bytes.Buffer
cmd.Stdout = &stdout
cmd.Stderr = &stderr
execErr := cmd.Run()
end := time.Now()
// 构建结果
result := &TaskExecutionResult{
TaskID: task.ID,
AgentID: nil,
Command: task.Command,
Output: stdout.String(),
Start: start,
End: end,
Duration: end.Sub(start).Milliseconds(),
}
if execErr != nil {
result.Status = "failed"
result.Output += "\n[ERROR]\n" + stderr.String() + "\n" + execErr.Error()
if exitErr, ok := execErr.(*exec.ExitError); ok {
result.ExitCode = exitErr.ExitCode()
} else {
result.ExitCode = 1
}
} else {
result.Status = "success"
result.ExitCode = 0
}
// 处理执行结果
return s.processExecutionResult(result)
}
// executeRemote 远程执行任务（通过 Agent）
func (s *TaskExecutionService) executeRemote(req *TaskExecutionRequest) error {
task := req.Task
agentID := *task.AgentID
logger.Infof("[TaskExecution] 远程执行任务 #%d: %s (Agent #%d)", task.ID, task.Name, agentID)
// 检查 Agent 是否在线
var agent models.Agent
if err := database.DB.First(&agent, agentID).Error; err != nil {
return fmt.Errorf("Agent #%d 不存在", agentID)
}
if !agent.Enabled {
return fmt.Errorf("Agent #%d 已禁用", agentID)
}
// 通过 WebSocket 发送立即执行命令给 Agent
if s.agentWSManager == nil {
return fmt.Errorf("AgentWSManager 未初始化")
}
err := s.agentWSManager.SendToAgent(agentID, "execute", map[string]interface{}{
"task_id": task.ID,
})
if err != nil {
return fmt.Errorf("发送执行命令失败: %v", err)
}
logger.Infof("[TaskExecution] 已发送立即执行命令给 Agent #%d，任务 #%d", agentID, task.ID)
return nil
}
// prepareCommand 准备执行命令
func (s *TaskExecutionService) prepareCommand(ctx context.Context, task *models.Task) (*exec.Cmd, error) {
command := task.Command
// 处理工作目录
if task.WorkDir != "" {
// 验证工作目录
if _, err := os.Stat(task.WorkDir); err != nil {
return nil, fmt.Errorf("工作目录不存在或无法访问: %s", task.WorkDir)
}
}
// 处理环境变量
envVars := s.loadEnvVars(task.Envs)
// 根据操作系统创建命令
var cmd *exec.Cmd
if runtime.GOOS == "windows" {
cmd = exec.CommandContext(ctx, "cmd", "/c", command)
} else {
// 如果有工作目录，在命令前加 cd
if task.WorkDir != "" {
command = fmt.Sprintf("cd %s && %s", task.WorkDir, command)
}
// 使用工具函数获取合适的 shell
shell, _ := utils.GetShell()
cmd = exec.CommandContext(ctx, shell, "-c", command)
}
// 设置环境变量（始终继承系统环境变量）
cmd.Env = os.Environ()
if len(envVars) > 0 {
cmd.Env = append(cmd.Env, envVars...)
}
return cmd, nil
}
// createContext 创建带超时的上下文
func (s *TaskExecutionService) createContext(timeout int) (context.Context, context.CancelFunc) {
if timeout <= 0 {
timeout = 30 // 默认 30 分钟
}
return context.WithTimeout(context.Background(), time.Duration(timeout)*time.Minute)
}
// loadEnvVars 加载环境变量
func (s *TaskExecutionService) loadEnvVars(envIDs string) []string {
if envIDs == "" {
return nil
}
var envVars []models.EnvironmentVariable
ids := strings.Split(envIDs, ",")
database.DB.Where("id IN ?", ids).Find(&envVars)
result := make([]string, 0, len(envVars))
for _, env := range envVars {
result = append(result, fmt.Sprintf("%s=%s", env.Name, env.Value))
}
return result
}
// handleExecutionError 处理执行错误
func (s *TaskExecutionService) handleExecutionError(taskID uint, command string, start time.Time, err error) error {
end := time.Now()
result := &TaskExecutionResult{
TaskID: taskID,
Command: command,
Output: fmt.Sprintf("[ERROR] 任务执行失败: %v", err),
Status: "failed",
Duration: end.Sub(start).Milliseconds(),
ExitCode: 1,
Start: start,
End: end,
}
return s.processExecutionResult(result)
}
// processExecutionResult 处理执行结果（统一的结果处理）
func (s *TaskExecutionService) processExecutionResult(result *TaskExecutionResult) error {
// 创建任务日志
taskLog, err := s.taskLogService.CreateTaskLogFromLocalExecution(
result.TaskID,
result.Command,
result.Output,
result.Status,
result.Duration,
result.ExitCode,
result.Start,
result.End,
)
if err != nil {
logger.Errorf("[TaskExecution] 创建任务日志失败: %v", err)
return err
}
// 如果是 Agent 执行的，设置 AgentID
if result.AgentID != nil {
taskLog.AgentID = result.AgentID
}
// 处理任务完成（保存日志、更新统计、清理旧日志）
if err := s.taskLogService.ProcessTaskCompletion(taskLog); err != nil {
logger.Errorf("[TaskExecution] 处理任务完成失败: %v", err)
return err
}
logger.Infof("[TaskExecution] 任务 #%d 执行完成 (%s)", result.TaskID, result.Status)
return nil
}
// ProcessAgentResult 处理 Agent 上报的结果（统一入口）
func (s *TaskExecutionService) ProcessAgentResult(agentResult *models.AgentTaskResult) error {
logger.Infof("[TaskExecution] 处理 Agent #%d 上报的任务 #%d 结果", agentResult.AgentID, agentResult.TaskID)
// 转换为统一的执行结果
result := &TaskExecutionResult{
TaskID: agentResult.TaskID,
AgentID: &agentResult.AgentID,
Command: agentResult.Command,
Output: agentResult.Output,
Status: agentResult.Status,
Duration: agentResult.Duration,
ExitCode: agentResult.ExitCode,
Start: time.Unix(agentResult.StartTime, 0),
End: time.Unix(agentResult.EndTime, 0),
}
// 使用统一的结果处理流程
return s.processExecutionResult(result)
}
// GetScriptPath 获取脚本路径
func (s *TaskExecutionService) GetScriptPath(scriptName string) string {
return filepath.Join("data", "scripts", scriptName)
}
// executeRepoTask 执行仓库同步任务（调用 sync.py）
func (s *TaskExecutionService) executeRepoTask(req *TaskExecutionRequest) error {
task := req.Task
logger.Infof("[TaskExecution] 执行仓库同步任务 #%d: %s", task.ID, task.Name)
start := time.Now()
// 解析仓库配置
var config models.RepoConfig
if err := json.Unmarshal([]byte(task.Config), &config); err != nil {
return s.handleExecutionError(task.ID, "", start, fmt.Errorf("解析仓库配置失败: %v", err))
}
// 处理目标路径：为空则使用 scripts 目录，相对路径则基于 scripts 目录
targetPath := config.TargetPath
if targetPath == "" {
targetPath = constant.ScriptsWorkDir
} else if !filepath.IsAbs(targetPath) {
targetPath = filepath.Join(constant.ScriptsWorkDir, targetPath)
}
// 转换为绝对路径
absTargetPath, err := filepath.Abs(targetPath)
if err != nil {
absTargetPath = targetPath
}
// 构建 sync.py 命令参数
args := []string{
"/opt/sync.py",
"--source-type", config.SourceType,
"--source-url", config.SourceURL,
"--target-path", absTargetPath,
}
// Git 分支
if config.Branch != "" {
args = append(args, "--branch", config.Branch)
}
// 稀疏路径
if config.SparsePath != "" {
args = append(args, "--path", config.SparsePath)
}
// 单文件模式
if config.SingleFile {
args = append(args, "--single-file")
}
// 代理设置
if config.Proxy != "" && config.Proxy != "none" {
args = append(args, "--proxy", config.Proxy)
if config.Proxy == "custom" && config.ProxyURL != "" {
args = append(args, "--proxy-url", config.ProxyURL)
}
}
// 认证 Token
if config.AuthToken != "" {
args = append(args, "--auth-token", config.AuthToken)
}
// 准备命令
ctx, cancel := s.createContext(task.Timeout)
defer cancel()
// 直接使用 python3 和参数列表，而不是拼接成字符串
cmd := exec.CommandContext(ctx, "python3", args...)
cmd.Dir = "/opt"
// 执行命令
var stdout, stderr bytes.Buffer
cmd.Stdout = &stdout
cmd.Stderr = &stderr
execErr := cmd.Run()
end := time.Now()
// 构建命令字符串用于日志记录
commandStr := "python3 " + strings.Join(args, " ")
// 构建结果
result := &TaskExecutionResult{
TaskID: task.ID,
AgentID: nil,
Command: commandStr,
Output: stdout.String(),
Start: start,
End: end,
Duration: end.Sub(start).Milliseconds(),
}
if execErr != nil {
result.Status = "failed"
result.Output += "\n[ERROR]\n" + stderr.String() + "\n" + execErr.Error()
if exitErr, ok := execErr.(*exec.ExitError); ok {
result.ExitCode = exitErr.ExitCode()
} else {
result.ExitCode = 1
}
} else {
result.Status = "success"
result.ExitCode = 0
}
// 处理执行结果
return s.processExecutionResult(result)
}
internal/services/tasks/task_log_service.go
+46 -11
View File
@@ -1,12 +1,13 @@
package tasks
import (
"encoding/json"
"time"
"github.com/engigu/baihu-panel/internal/database"
"github.com/engigu/baihu-panel/internal/logger"
"github.com/engigu/baihu-panel/internal/models"
"github.com/engigu/baihu-panel/internal/utils"
"encoding/json"
"time"
)
// SendStatsService 接口定义（避免循环依赖）
@@ -32,9 +33,31 @@ type CleanConfig struct {
Keep int `json:"keep"` // 保留天数或条数
}
// SaveTaskLog 保存任务日志（通用方法）
func (s *TaskLogService) SaveTaskLog(taskLog *models.TaskLog) error {
// CreateEmptyLog 创建一个空的日志记录（任务开始时调用）
func (s *TaskLogService) CreateEmptyLog(taskID uint, command string) (*models.TaskLog, error) {
startTime := models.LocalTime(time.Now())
taskLog := &models.TaskLog{
TaskID: taskID,
Command: command,
Status: "running",
StartTime: &startTime,
}
if err := database.DB.Create(taskLog).Error; err != nil {
return nil, err
}
return taskLog, nil
}
// SaveTaskLog 保存或更新任务日志
func (s *TaskLogService) SaveTaskLog(taskLog *models.TaskLog) error {
var err error
if taskLog.ID > 0 {
err = database.DB.Model(taskLog).Updates(taskLog).Error
} else {
err = database.DB.Create(taskLog).Error
}
if err != nil {
return err
}
@@ -44,6 +67,11 @@ func (s *TaskLogService) SaveTaskLog(taskLog *models.TaskLog) error {
return nil
}
// UpdateTaskDuration 更新任务耗时（心跳）
func (s *TaskLogService) UpdateTaskDuration(logID uint, duration int64) error {
return database.DB.Model(&models.TaskLog{}).Where("id = ?", logID).Update("duration", duration).Error
}
// UpdateTaskStats 更新任务统计
func (s *TaskLogService) UpdateTaskStats(taskID uint, status string) {
if s.sendStatsService == nil {
@@ -100,7 +128,7 @@ func (s *TaskLogService) CleanTaskLogs(taskID uint) {
// ProcessTaskCompletion 处理任务完成后的所有操作（保存日志、更新统计、清理旧日志）
func (s *TaskLogService) ProcessTaskCompletion(taskLog *models.TaskLog) error {
// 1. 保存日志
// 1. 保存/更新日志
if err := s.SaveTaskLog(taskLog); err != nil {
return err
}
@@ -147,12 +175,19 @@ func (s *TaskLogService) CreateTaskLogFromAgentResult(result *models.AgentTaskRe
}
// CreateTaskLogFromLocalExecution 从本地执行结果创建任务日志
func (s *TaskLogService) CreateTaskLogFromLocalExecution(taskID uint, command, output, status string, duration int64, exitCode int, start, end time.Time) (*models.TaskLog, error) {
// 压缩输出
compressed, err := utils.CompressToBase64(output)
if err != nil {
logger.Errorf("[TaskLog] 压缩日志失败: %v", err)
compressed = ""
func (s *TaskLogService) CreateTaskLogFromLocalExecution(taskID uint, command, output, status string, duration int64, exitCode int, start, end time.Time, isCompressed bool) (*models.TaskLog, error) {
var compressed string
var err error
if isCompressed {
compressed = output
} else {
// 压缩输出
compressed, err = utils.CompressToBase64(output)
if err != nil {
logger.Errorf("[TaskLog] 压缩日志失败: %v", err)
compressed = ""
}
}
startTime := models.LocalTime(start)
internal/services/tasks/tiny_log.go
+241
View File
@@ -0,0 +1,241 @@
package tasks
import (
"bufio"
"bytes"
"compress/zlib"
"encoding/base64"
"io"
"os"
"sync"
"github.com/engigu/baihu-panel/internal/utils"
)
var (
// globalTinyLogManager keeps track of all active TinyLog instances
globalTinyLogManager = &TinyLogManager{
logs: make(map[uint]*TinyLog),
}
)
type TinyLogManager struct {
mu sync.RWMutex
logs map[uint]*TinyLog
}
func (m *TinyLogManager) Register(log *TinyLog) {
m.mu.Lock()
defer m.mu.Unlock()
m.logs[log.LogID] = log
}
func (m *TinyLogManager) Unregister(logID uint) {
m.mu.Lock()
defer m.mu.Unlock()
delete(m.logs, logID)
}
func (m *TinyLogManager) Get(logID uint) *TinyLog {
m.mu.RLock()
defer m.mu.RUnlock()
return m.logs[logID]
}
// GetActiveLog returns an active TinyLog by its ID
func GetActiveLog(logID uint) *TinyLog {
return globalTinyLogManager.Get(logID)
}
// TinyLog is a high-performance, low-memory log collector
type TinyLog struct {
LogID uint
mu sync.RWMutex
file *os.File
path string
writer *bufio.Writer
subscribers []chan []byte
closed bool
}
// NewTinyLog creates a new TinyLog instance backed by a temporary file and registers it
func NewTinyLog(logID uint) (*TinyLog, error) {
f, err := os.CreateTemp("", "task_log_*.log")
if err != nil {
return nil, err
}
tl := &TinyLog{
LogID: logID,
file: f,
path: f.Name(),
writer: bufio.NewWriter(f),
subscribers: make([]chan []byte, 0),
}
globalTinyLogManager.Register(tl)
return tl, nil
}
// Write implements io.Writer
func (l *TinyLog) Write(p []byte) (n int, err error) {
l.mu.Lock()
defer l.mu.Unlock()
if l.closed {
return 0, os.ErrClosed
}
// 1. Convert to UTF-8 if necessary (common on Windows)
text := utils.ToUTF8(p)
data := []byte(text)
// 2. Write to file buffer
_, err = l.writer.Write(data)
if err != nil {
return 0, err
}
// 3. Broadcast to subscribers
if len(l.subscribers) > 0 {
for _, ch := range l.subscribers {
select {
case ch <- data:
default:
// Drop message if subscriber is too slow to avoid blocking writer
}
}
}
return len(p), nil
}
// Subscribe returns a channel that receives log chunks in real-time
func (l *TinyLog) Subscribe() chan []byte {
l.mu.Lock()
defer l.mu.Unlock()
ch := make(chan []byte, 100) // Buffer to handle bursts
l.subscribers = append(l.subscribers, ch)
return ch
}
// Unsubscribe removes a subscriber
func (l *TinyLog) Unsubscribe(ch chan []byte) {
l.mu.Lock()
defer l.mu.Unlock()
for i, sub := range l.subscribers {
if sub == ch {
l.subscribers = append(l.subscribers[:i], l.subscribers[i+1:]...)
close(ch)
break
}
}
}
// Close finishes writing and closes the file, and unregisters itself
func (l *TinyLog) Close() error {
l.mu.Lock()
defer l.mu.Unlock()
if l.closed {
return nil
}
// Flush buffer to file
if err := l.writer.Flush(); err != nil {
return err
}
// Close all subscribers
for _, ch := range l.subscribers {
close(ch)
}
l.subscribers = nil
l.closed = true
globalTinyLogManager.Unregister(l.LogID)
return l.file.Close()
}
// CompressAndCleanup reads the temporary file, compresses it, returns the result, and removes the file
func (l *TinyLog) CompressAndCleanup() (string, error) {
// Ensure closed
if !l.closed {
l.Close()
}
// Open temp file for reading
f, err := os.Open(l.path)
if err != nil {
return "", err
}
defer func() {
f.Close()
os.Remove(l.path) // Cleanup
}()
// Create buffer for compressed output
var buf bytes.Buffer
b64Writer := base64.NewEncoder(base64.StdEncoding, &buf)
zlibWriter := zlib.NewWriter(b64Writer)
// Stream: File -> Zlib -> Base64 -> Buffer
if _, err := io.Copy(zlibWriter, f); err != nil {
return "", err
}
// Close generic writers to flush data
if err := zlibWriter.Close(); err != nil {
return "", err
}
if err := b64Writer.Close(); err != nil {
return "", err
}
return buf.String(), nil
}
// ReadLastLines returns the last n lines of the log
func (l *TinyLog) ReadLastLines(n int) ([]byte, error) {
l.mu.RLock()
defer l.mu.RUnlock()
// Flush writer to ensure file on disk is up to date
_ = l.writer.Flush()
stat, err := os.Stat(l.path)
if err != nil {
return nil, err
}
size := stat.Size()
var limit int64 = 65536 // Max 64KB for "last 100 lines" preview
if size < limit {
limit = size
}
offset := size - limit
data := make([]byte, limit)
f, err := os.Open(l.path)
if err != nil {
return nil, err
}
defer f.Close()
_, err = f.ReadAt(data, offset)
if err != nil && err != io.EOF {
return nil, err
}
lines := bytes.Split(data, []byte{'\n'})
if len(lines) > n+1 {
return bytes.Join(lines[len(lines)-n-1:], []byte{'\n'}), nil
}
return data, nil
}
// GetPath returns the temporary file path
func (l *TinyLog) GetPath() string {
return l.path
}