wonder/xinfra
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #125 from 2311719626/fix/logs

Browse Source 
fix(server): 修复 task log 模块多个问题并添加单元测试
This commit is contained in:
Wonder
2026-07-29 14:38:55 +08:00
committed by GitHub
parent f4a0a75ca1 11a92c429f
commit 179d80604c
6 changed files with 1308 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/internal/handler/task_log.go
+152 -17
View File
@@ -8,6 +8,7 @@ import (
"strings"
"time"
"github.com/1024XEngineer/xinfra/server/internal/auth"
"github.com/1024XEngineer/xinfra/server/internal/model"
"github.com/1024XEngineer/xinfra/server/internal/service"
"github.com/gin-gonic/gin"
@@ -55,6 +56,16 @@ func (h *TaskLogHandler) List(c *gin.Context) {
source := strings.ToLower(strings.TrimSpace(c.DefaultQuery("source", "all")))
businessLineID, _ := strconv.ParseUint(c.Query("business_line_id"), 10, 64)
// 分页参数
page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "20"))
if page < 1 {
page = 1
}
if pageSize < 1 || pageSize > 100 {
pageSize = 20
}
items := make([]taskLogSummary, 0)
if source == "" || source == "all" || source == "awx" {
awxItems, err := h.listAWXTasks(c, claims.UserID, claims.IsAdmin, businessLineID)
@@ -73,10 +84,27 @@ func (h *TaskLogHandler) List(c *gin.Context) {
items = append(items, wayneItems...)
}
sortTaskLogSummaries(items)
if len(items) > 100 {
items = items[:100]
// 计算分页
total := len(items)
start := (page - 1) * pageSize
if start >= total {
items = make([]taskLogSummary, 0)
} else {
end := start + pageSize
if end > total {
end = total
}
items = items[start:end]
}
c.JSON(http.StatusOK, gin.H{"items": items})
c.JSON(http.StatusOK, gin.H{
"items": items,
"total": total,
"page": page,
"page_size": pageSize,
"total_pages": (total + pageSize - 1) / pageSize,
})
}
func (h *TaskLogHandler) Get(c *gin.Context) {
@@ -211,7 +239,7 @@ func wayneTaskSummary(history service.WayneDeploymentHistory) taskLogSummary {
Service: "wayne-deployment",
Name: wayneDeploymentTaskName(history),
Runner: "Wayne Native API",
Status: strconv.Itoa(history.Status),
Status: wayneStatusToString(history.Status),
StatusText: textForWaynePublishStatus(history.Status),
StatusClass: classForWaynePublishStatus(history.Status),
BusinessLineID: history.BusinessLineID,
@@ -325,6 +353,18 @@ func classForWaynePublishStatus(status int) string {
}
}
// wayneStatusToString 将 Wayne 数字状态映射为与 AWX 一致的字符串状态
func wayneStatusToString(status int) string {
switch status {
case 1:
return model.TaskFinished
case 0:
return model.TaskExecutionFailed
default:
return "unknown"
}
}
func splitStdoutLines(stdout string) []taskLogLine {
lines := make([]taskLogLine, 0)
for _, line := range strings.Split(stdout, "\n") {
@@ -352,6 +392,7 @@ func classForOutputLine(line string) string {
}
// Stream SSE 端点，用于实时推送任务日志。
// AWX 任务使用 pub/sub 模式，Wayne 任务使用轮询模式。
func (h *TaskLogHandler) Stream(c *gin.Context) {
claims, ok := CurrentClaims(c)
if !ok {
@@ -373,10 +414,94 @@ func (h *TaskLogHandler) Stream(c *gin.Context) {
ctx := c.Request.Context()
// AWX 任务使用 pub/sub 模式
if strings.HasPrefix(taskID, "awx:") {
h.streamAWXTask(c, taskID, ctx, claims)
return
}
// Wayne 任务使用轮询模式（因为 Wayne API 不支持推送）
if strings.HasPrefix(taskID, "wayne:") {
h.streamWayneTask(c, taskID, ctx, claims)
return
}
c.SSEvent("message", gin.H{"type": "error", "error": "invalid task_id format"})
c.Writer.Flush()
}
// streamAWXTask AWX 任务使用 pub/sub 模式
func (h *TaskLogHandler) streamAWXTask(c *gin.Context, taskID string, ctx context.Context, claims *auth.Claims) {
actualTaskID := strings.TrimPrefix(taskID, "awx:")
// 发送初始日志
initialLines, taskStatus, err := h.fetchTaskLogLines(ctx, taskID, claims.UserID, claims.IsAdmin)
if err != nil {
c.SSEvent("message", gin.H{"type": "error", "error": err.Error()})
c.Writer.Flush()
return
}
// 发送初始数据
c.SSEvent("message", gin.H{"type": "init", "lines": initialLines})
c.Writer.Flush()
// 如果任务已完成，直接发送结束事件
if isTerminalStatus(taskStatus) {
c.SSEvent("message", gin.H{"type": "finished"})
c.Writer.Flush()
return
}
// 订阅任务更新（使用 pub/sub 模式）
updates, cancel := h.delivery.SubscribeTask(actualTaskID)
defer cancel()
heartbeatTicker := time.NewTicker(15 * time.Second)
defer heartbeatTicker.Stop()
for {
select {
case <-ctx.Done():
return
case _, ok := <-updates:
if !ok {
return
}
// 重新获取日志行
lines, status, err := h.fetchTaskLogLines(ctx, taskID, claims.UserID, claims.IsAdmin)
if err != nil {
c.SSEvent("message", gin.H{"type": "error", "error": err.Error()})
c.Writer.Flush()
continue
}
// 发送完整日志
c.SSEvent("message", gin.H{"type": "update", "lines": lines})
c.Writer.Flush()
// 如果任务完成，发送结束事件
if isTerminalStatus(status) {
c.SSEvent("message", gin.H{"type": "finished"})
c.Writer.Flush()
return
}
case <-heartbeatTicker.C:
c.SSEvent("heartbeat", nil)
c.Writer.Flush()
}
}
}
// streamWayneTask Wayne 任务使用轮询模式
func (h *TaskLogHandler) streamWayneTask(c *gin.Context, taskID string, ctx context.Context, claims *auth.Claims) {
// 发送初始日志
initialLines, taskStatus, err := h.fetchTaskLogLines(ctx, taskID, claims.UserID, claims.IsAdmin)
if err != nil {
c.SSEvent("message", gin.H{"type": "error", "error": err.Error()})
c.Writer.Flush()
return
}
@@ -392,14 +517,12 @@ func (h *TaskLogHandler) Stream(c *gin.Context) {
}
// 轮询循环
ticker := time.NewTicker(2 * time.Second)
ticker := time.NewTicker(5 * time.Second)
defer ticker.Stop()
heartbeatTicker := time.NewTicker(15 * time.Second)
defer heartbeatTicker.Stop()
lastLineCount := len(initialLines)
for {
select {
case <-ctx.Done():
@@ -407,19 +530,14 @@ func (h *TaskLogHandler) Stream(c *gin.Context) {
case <-ticker.C:
lines, status, err := h.fetchTaskLogLines(ctx, taskID, claims.UserID, claims.IsAdmin)
if err != nil {
// 发送错误但不关闭连接
c.SSEvent("message", gin.H{"type": "error", "error": err.Error()})
c.Writer.Flush()
continue
}
// 发送增量日志
if len(lines) > lastLineCount {
newLines := lines[lastLineCount:]
c.SSEvent("message", gin.H{"type": "update", "lines": newLines})
c.Writer.Flush()
lastLineCount = len(lines)
}
// 发送完整日志
c.SSEvent("message", gin.H{"type": "update", "lines": lines})
c.Writer.Flush()
// 如果任务完成，发送结束事件
if isTerminalStatus(status) {
@@ -429,13 +547,29 @@ func (h *TaskLogHandler) Stream(c *gin.Context) {
}
case <-heartbeatTicker.C:
// 发送心跳保持连接
c.SSEvent("heartbeat", nil)
c.Writer.Flush()
}
}
}
// parseActualTaskID 从 task log ID 解析出实际的任务 ID
func (h *TaskLogHandler) parseActualTaskID(taskID string) string {
switch {
case strings.HasPrefix(taskID, "awx:"):
return strings.TrimPrefix(taskID, "awx:")
case strings.HasPrefix(taskID, "wayne:publish:"):
// Wayne 任务需要使用 resourceID 作为订阅 key
parts := strings.Split(taskID, ":")
if len(parts) == 4 {
return "wayne:" + parts[2]
}
return ""
default:
return ""
}
}
// fetchTaskLogLines 获取任务的日志行和状态。
func (h *TaskLogHandler) fetchTaskLogLines(ctx context.Context, taskID string, userID uint64, isAdmin bool) ([]taskLogLine, string, error) {
switch {
@@ -513,7 +647,8 @@ func (h *TaskLogHandler) fetchWayneLogLines(ctx context.Context, id string, user
lines = append(lines, taskLogLine{Time: formatTaskLogTime(history.CreatedAt), Message: "[message] " + history.Message, Class: classForWaynePublishStatus(history.Status)})
}
statusText := strconv.Itoa(history.Status)
// 将 Wayne 数字状态映射为与 AWX 一致的字符串状态
statusText := wayneStatusToString(history.Status)
return lines, statusText, nil
}
server/internal/handler/task_log_test.go
+506
View File
@@ -0,0 +1,506 @@
package handler
import (
"testing"
"time"
"github.com/1024XEngineer/xinfra/server/internal/model"
"github.com/1024XEngineer/xinfra/server/internal/service"
)
func TestWayneStatusToString(t *testing.T) {
for name, tc := range map[string]struct {
input int
want string
}{
"success": {input: 1, want: model.TaskFinished},
"failed": {input: 0, want: model.TaskExecutionFailed},
"unknown": {input: -1, want: "unknown"},
"large number": {input: 99, want: "unknown"},
} {
t.Run(name, func(t *testing.T) {
got := wayneStatusToString(tc.input)
if got != tc.want {
t.Fatalf("wayneStatusToString(%d) = %q, want %q", tc.input, got, tc.want)
}
})
}
}
func TestParseWaynePublishTaskID(t *testing.T) {
for name, tc := range map[string]struct {
input string
wantResID int64
wantHisID int64
wantOk bool
}{
"valid": {input: "wayne:publish:123:456", wantResID: 123, wantHisID: 456, wantOk: true},
"large ids": {input: "wayne:publish:999999999:888888888", wantResID: 999999999, wantHisID: 888888888, wantOk: true},
"wrong prefix": {input: "awx:publish:123:456", wantOk: false},
"missing parts": {input: "wayne:publish:123", wantOk: false},
"extra parts": {input: "wayne:publish:123:456:789", wantOk: false},
"non-numeric": {input: "wayne:publish:abc:456", wantOk: false},
"non-numeric hist": {input: "wayne:publish:123:abc", wantOk: false},
"empty": {input: "", wantOk: false},
"random string": {input: "hello", wantOk: false},
} {
t.Run(name, func(t *testing.T) {
resID, hisID, ok := parseWaynePublishTaskID(tc.input)
if ok != tc.wantOk {
t.Fatalf("parseWaynePublishTaskID(%q) ok=%v, want %v", tc.input, ok, tc.wantOk)
}
if ok && (resID != tc.wantResID || hisID != tc.wantHisID) {
t.Fatalf("parseWaynePublishTaskID(%q) = (%d, %d), want (%d, %d)", tc.input, resID, hisID, tc.wantResID, tc.wantHisID)
}
})
}
}
func TestWaynePublishTaskID(t *testing.T) {
history := service.WayneDeploymentHistory{ResourceID: 42, ID: 100}
got := waynePublishTaskID(history)
want := "wayne:publish:42:100"
if got != want {
t.Fatalf("waynePublishTaskID() = %q, want %q", got, want)
}
}
func TestWayneDeploymentTaskName(t *testing.T) {
for name, tc := range map[string]struct {
history service.WayneDeploymentHistory
want string
}{
"with name": {
history: service.WayneDeploymentHistory{ResourceName: "my-service", ResourceID: 10},
want: "Wayne 服务部署 · my-service",
},
"empty name uses ID": {
history: service.WayneDeploymentHistory{ResourceName: "", ResourceID: 42},
want: "Wayne 服务部署 · 42",
},
"whitespace name uses ID": {
history: service.WayneDeploymentHistory{ResourceName: " ", ResourceID: 7},
want: "Wayne 服务部署 · 7",
},
} {
t.Run(name, func(t *testing.T) {
got := wayneDeploymentTaskName(tc.history)
if got != tc.want {
t.Fatalf("wayneDeploymentTaskName() = %q, want %q", got, tc.want)
}
})
}
}
func TestTextForTaskStatus(t *testing.T) {
for name, tc := range map[string]struct {
status string
want string
}{
"pending": {status: model.TaskPending, want: "等待"},
"validating": {status: model.TaskValidating, want: "等待"},
"dispatching": {status: model.TaskDispatching, want: "等待"},
"running": {status: model.TaskRunning, want: "执行中"},
"registering": {status: model.TaskRegistering, want: "执行中"},
"canceling": {status: model.TaskCanceling, want: "执行中"},
"rollback_pending": {status: model.TaskRollbackPending, want: "回退中"},
"rolling_back": {status: model.TaskRollingBack, want: "回退中"},
"finished": {status: model.TaskFinished, want: "成功"},
"rolled_back": {status: model.TaskRolledBack, want: "已回退"},
"rollback_failed": {status: model.TaskRollbackFailed, want: "回退失败"},
"rollback_ack": {status: model.TaskRollbackAck, want: "已确认释放"},
"register_failed": {status: model.TaskRegisterFailed, want: "注册失败（实例保留）"},
"canceled": {status: model.TaskCanceled, want: "已取消"},
"execution_failed": {status: model.TaskExecutionFailed, want: "失败"},
"validation_failed": {status: model.TaskValidationFailed, want: "失败"},
"unknown": {status: "unknown_status", want: "失败"},
} {
t.Run(name, func(t *testing.T) {
got := textForTaskStatus(tc.status)
if got != tc.want {
t.Fatalf("textForTaskStatus(%q) = %q, want %q", tc.status, got, tc.want)
}
})
}
}
func TestClassForTaskStatus(t *testing.T) {
for name, tc := range map[string]struct {
status string
want string
}{
"finished": {status: model.TaskFinished, want: "ok"},
"rolled_back": {status: model.TaskRolledBack, want: "ok"},
"execution_failed": {status: model.TaskExecutionFailed, want: "err"},
"validation_failed": {status: model.TaskValidationFailed, want: "err"},
"canceled": {status: model.TaskCanceled, want: "err"},
"rollback_failed": {status: model.TaskRollbackFailed, want: "err"},
"rollback_ack": {status: model.TaskRollbackAck, want: "warn"},
"register_failed": {status: model.TaskRegisterFailed, want: "warn"},
"running": {status: model.TaskRunning, want: "warn"},
"dispatching": {status: model.TaskDispatching, want: "warn"},
"pending": {status: model.TaskPending, want: ""},
"unknown": {status: "unknown_status", want: ""},
} {
t.Run(name, func(t *testing.T) {
got := classForTaskStatus(tc.status)
if got != tc.want {
t.Fatalf("classForTaskStatus(%q) = %q, want %q", tc.status, got, tc.want)
}
})
}
}
func TestTextForWaynePublishStatus(t *testing.T) {
for name, tc := range map[string]struct {
status int
want string
}{
"success": {status: 1, want: "成功"},
"failed": {status: 0, want: "失败"},
"unknown": {status: -1, want: "未知"},
"large": {status: 99, want: "未知"},
} {
t.Run(name, func(t *testing.T) {
got := textForWaynePublishStatus(tc.status)
if got != tc.want {
t.Fatalf("textForWaynePublishStatus(%d) = %q, want %q", tc.status, got, tc.want)
}
})
}
}
func TestClassForWaynePublishStatus(t *testing.T) {
for name, tc := range map[string]struct {
status int
want string
}{
"success": {status: 1, want: "ok"},
"failed": {status: 0, want: "err"},
"unknown": {status: -1, want: ""},
} {
t.Run(name, func(t *testing.T) {
got := classForWaynePublishStatus(tc.status)
if got != tc.want {
t.Fatalf("classForWaynePublishStatus(%d) = %q, want %q", tc.status, got, tc.want)
}
})
}
}
func TestSplitStdoutLines(t *testing.T) {
for name, tc := range map[string]struct {
input string
want []taskLogLine
}{
"single line": {
input: "hello world",
want: []taskLogLine{{Time: "", Message: "hello world", Class: ""}},
},
"multiple lines": {
input: "line1\nline2\nline3",
want: []taskLogLine{
{Time: "", Message: "line1", Class: ""},
{Time: "", Message: "line2", Class: ""},
{Time: "", Message: "line3", Class: ""},
},
},
"skip blank lines": {
input: "line1\n\n\nline2",
want: []taskLogLine{
{Time: "", Message: "line1", Class: ""},
{Time: "", Message: "line2", Class: ""},
},
},
"trim cr": {
input: "line1\r\nline2\r\n",
want: []taskLogLine{
{Time: "", Message: "line1", Class: ""},
{Time: "", Message: "line2", Class: ""},
},
},
"error line": {
input: "TASK FAILED: something went wrong",
want: []taskLogLine{{Time: "", Message: "TASK FAILED: something went wrong", Class: "err"}},
},
"ok line": {
input: "ok: [task 1] Apply role",
want: []taskLogLine{{Time: "", Message: "ok: [task 1] Apply role", Class: "ok"}},
},
"changed line": {
input: "changed: [host1] Task result changed",
want: []taskLogLine{{Time: "", Message: "changed: [host1] Task result changed", Class: "tag-ok"}},
},
"empty input": {
input: "",
want: []taskLogLine{},
},
"only whitespace": {
input: " \n \n ",
want: []taskLogLine{},
},
} {
t.Run(name, func(t *testing.T) {
got := splitStdoutLines(tc.input)
if len(got) != len(tc.want) {
t.Fatalf("splitStdoutLines(%q) returned %d lines, want %d", tc.input, len(got), len(tc.want))
}
for i := range got {
if got[i] != tc.want[i] {
t.Fatalf("splitStdoutLines(%q)[%d] = %+v, want %+v", tc.input, i, got[i], tc.want[i])
}
}
})
}
}
func TestClassForOutputLine(t *testing.T) {
for name, tc := range map[string]struct {
input string
want string
}{
"failed keyword": {input: "TASK FAILED: error occurred", want: "err"},
"fatal keyword": {input: "fatal: [host] unresolvable", want: "err"},
"error keyword": {input: "ERROR: something bad", want: "err"},
"error uppercase": {input: "ConnectionError: timeout", want: "err"},
"ok keyword": {input: "ok: [host1] Apply task", want: "ok"},
"successful": {input: "PLAY RECAP: successful", want: "ok"},
"success keyword": {input: "task completed with success", want: "ok"},
"changed keyword": {input: "changed: [host1] Executed task", want: "tag-ok"},
"plain line": {input: "some random output", want: ""},
"mixed case error": {input: "FAILED: task failed", want: "err"},
} {
t.Run(name, func(t *testing.T) {
got := classForOutputLine(tc.input)
if got != tc.want {
t.Fatalf("classForOutputLine(%q) = %q, want %q", tc.input, got, tc.want)
}
})
}
}
func TestIsTerminalStatus(t *testing.T) {
terminalStatuses := []string{
model.TaskFinished,
model.TaskCanceled,
model.TaskExecutionFailed,
model.TaskValidationFailed,
model.TaskRegisterFailed,
model.TaskRolledBack,
model.TaskRollbackFailed,
model.TaskRollbackAck,
}
for _, status := range terminalStatuses {
t.Run("terminal_"+status, func(t *testing.T) {
if !isTerminalStatus(status) {
t.Fatalf("isTerminalStatus(%q) = false, want true", status)
}
})
}
nonTerminalStatuses := []string{
model.TaskPending,
model.TaskValidating,
model.TaskDispatching,
model.TaskRunning,
model.TaskRegistering,
model.TaskCanceling,
model.TaskRollbackPending,
model.TaskRollingBack,
"unknown",
"",
}
for _, status := range nonTerminalStatuses {
t.Run("non_terminal_"+status, func(t *testing.T) {
if isTerminalStatus(status) {
t.Fatalf("isTerminalStatus(%q) = true, want false", status)
}
})
}
}
func TestFormatTaskLogTime(t *testing.T) {
t.Run("zero time", func(t *testing.T) {
got := formatTaskLogTime(time.Time{})
if got != "" {
t.Fatalf("formatTaskLogTime(zero) = %q, want empty", got)
}
})
t.Run("normal time", func(t *testing.T) {
ts := time.Date(2026, 7, 29, 14, 30, 45, 0, time.UTC)
got := formatTaskLogTime(ts)
if got != "14:30:45" {
t.Fatalf("formatTaskLogTime() = %q, want %q", got, "14:30:45")
}
})
t.Run("midnight", func(t *testing.T) {
ts := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)
got := formatTaskLogTime(ts)
if got != "00:00:00" {
t.Fatalf("formatTaskLogTime() = %q, want %q", got, "00:00:00")
}
})
}
func TestSortTaskLogSummaries(t *testing.T) {
t.Run("empty", func(t *testing.T) {
items := []taskLogSummary{}
sortTaskLogSummaries(items)
if len(items) != 0 {
t.Fatalf("sortTaskLogSummaries(empty) produced %d items", len(items))
}
})
t.Run("single", func(t *testing.T) {
items := []taskLogSummary{{UpdatedAt: time.Now()}}
sortTaskLogSummaries(items)
if len(items) != 1 {
t.Fatalf("sortTaskLogSummaries(single) produced %d items", len(items))
}
})
t.Run("sorts descending by UpdatedAt", func(t *testing.T) {
now := time.Now()
items := []taskLogSummary{
{ID: "oldest", UpdatedAt: now.Add(-3 * time.Hour)},
{ID: "newest", UpdatedAt: now},
{ID: "middle", UpdatedAt: now.Add(-1 * time.Hour)},
}
sortTaskLogSummaries(items)
if items[0].ID != "newest" || items[1].ID != "middle" || items[2].ID != "oldest" {
t.Fatalf("sortTaskLogSummaries order wrong: got IDs [%s, %s, %s]", items[0].ID, items[1].ID, items[2].ID)
}
})
t.Run("already sorted", func(t *testing.T) {
now := time.Now()
items := []taskLogSummary{
{ID: "a", UpdatedAt: now.Add(-2 * time.Hour)},
{ID: "b", UpdatedAt: now.Add(-1 * time.Hour)},
{ID: "c", UpdatedAt: now},
}
sortTaskLogSummaries(items)
if items[0].ID != "c" || items[1].ID != "b" || items[2].ID != "a" {
t.Fatalf("sortTaskLogSummaries order wrong: got IDs [%s, %s, %s]", items[0].ID, items[1].ID, items[2].ID)
}
})
}
func TestAwxTaskSummary(t *testing.T) {
now := time.Now()
task := model.DeliveryTask{
ID: "task-123",
BusinessLineID: 5,
Status: model.TaskFinished,
InstanceName: "mysql-01",
TargetID: 10,
CreatedAt: now.Add(-1 * time.Hour),
UpdatedAt: now,
}
summary := awxTaskSummary(task)
if summary.ID != "awx:task-123" {
t.Fatalf("awxTaskSummary ID = %q, want %q", summary.ID, "awx:task-123")
}
if summary.Source != "awx" {
t.Fatalf("awxTaskSummary Source = %q, want %q", summary.Source, "awx")
}
if summary.Service != "mysql" {
t.Fatalf("awxTaskSummary Service = %q, want %q", summary.Service, "mysql")
}
if summary.Name != "MySQL 标准化交付 · mysql-01" {
t.Fatalf("awxTaskSummary Name = %q, want %q", summary.Name, "MySQL 标准化交付 · mysql-01")
}
if summary.Runner != "AWX Job Template #10" {
t.Fatalf("awxTaskSummary Runner = %q, want %q", summary.Runner, "AWX Job Template #10")
}
if summary.Status != model.TaskFinished {
t.Fatalf("awxTaskSummary Status = %q, want %q", summary.Status, model.TaskFinished)
}
if summary.StatusText != "成功" {
t.Fatalf("awxTaskSummary StatusText = %q, want %q", summary.StatusText, "成功")
}
if summary.StatusClass != "ok" {
t.Fatalf("awxTaskSummary StatusClass = %q, want %q", summary.StatusClass, "ok")
}
if summary.BusinessLineID != 5 {
t.Fatalf("awxTaskSummary BusinessLineID = %d, want 5", summary.BusinessLineID)
}
if summary.ReferenceID != "task-123" {
t.Fatalf("awxTaskSummary ReferenceID = %q, want %q", summary.ReferenceID, "task-123")
}
if !summary.CreatedAt.Equal(now.Add(-1 * time.Hour)) {
t.Fatalf("awxTaskSummary CreatedAt = %v, want %v", summary.CreatedAt, now.Add(-1*time.Hour))
}
if !summary.UpdatedAt.Equal(now) {
t.Fatalf("awxTaskSummary UpdatedAt = %v, want %v", summary.UpdatedAt, now)
}
}
func TestWayneTaskSummary(t *testing.T) {
now := time.Now()
history := service.WayneDeploymentHistory{
ID: 200,
ResourceID: 42,
ResourceName: "my-service",
Status: 1,
BusinessLineID: 3,
CreatedAt: now,
}
summary := wayneTaskSummary(history)
if summary.ID != "wayne:publish:42:200" {
t.Fatalf("wayneTaskSummary ID = %q, want %q", summary.ID, "wayne:publish:42:200")
}
if summary.Source != "wayne" {
t.Fatalf("wayneTaskSummary Source = %q, want %q", summary.Source, "wayne")
}
if summary.Service != "wayne-deployment" {
t.Fatalf("wayneTaskSummary Service = %q, want %q", summary.Service, "wayne-deployment")
}
if summary.Name != "Wayne 服务部署 · my-service" {
t.Fatalf("wayneTaskSummary Name = %q, want %q", summary.Name, "Wayne 服务部署 · my-service")
}
if summary.Runner != "Wayne Native API" {
t.Fatalf("wayneTaskSummary Runner = %q, want %q", summary.Runner, "Wayne Native API")
}
if summary.Status != model.TaskFinished {
t.Fatalf("wayneTaskSummary Status = %q, want %q", summary.Status, model.TaskFinished)
}
if summary.StatusText != "成功" {
t.Fatalf("wayneTaskSummary StatusText = %q, want %q", summary.StatusText, "成功")
}
if summary.StatusClass != "ok" {
t.Fatalf("wayneTaskSummary StatusClass = %q, want %q", summary.StatusClass, "ok")
}
if summary.BusinessLineID != 3 {
t.Fatalf("wayneTaskSummary BusinessLineID = %d, want 3", summary.BusinessLineID)
}
if summary.ReferenceID != "200" {
t.Fatalf("wayneTaskSummary ReferenceID = %q, want %q", summary.ReferenceID, "200")
}
}
func TestParseActualTaskID(t *testing.T) {
h := &TaskLogHandler{}
for name, tc := range map[string]struct {
input string
want string
}{
"awx task": {input: "awx:task-123", want: "task-123"},
"wayne task": {input: "wayne:publish:42:200", want: "wayne:42"},
"empty": {input: "", want: ""},
"unknown": {input: "unknown:id", want: ""},
"awx no prefix": {input: "awx:", want: ""},
} {
t.Run(name, func(t *testing.T) {
got := h.parseActualTaskID(tc.input)
if got != tc.want {
t.Fatalf("parseActualTaskID(%q) = %q, want %q", tc.input, got, tc.want)
}
})
}
}
server/internal/service/delivery.go
+98 -6
View File
@@ -332,6 +332,12 @@ func allocatePort(requested int, used []int) (int, error) {
return 0, fmt.Errorf("mysql port pool %d-%d is exhausted on the target host", mysqlPortPoolStart, mysqlPortPoolEnd)
}
// stdoutCacheItem 缓存 AWX Job stdout 的结果
type stdoutCacheItem struct {
stdout string
createdAt time.Time
}
type DeliveryService struct {
db *gorm.DB
cfg config.Config
@@ -340,12 +346,21 @@ type DeliveryService struct {
executionMu sync.Mutex
streamMu sync.Mutex
streams map[string]map[chan DeliveryTaskSnapshot]struct{}
stdoutCache map[string]*stdoutCacheItem
cacheMu sync.RWMutex
}
func (s *DeliveryService) DB() *gorm.DB { return s.db }
func NewDeliveryService(cfg config.Config, db *gorm.DB, audit *AuditService) *DeliveryService {
return &DeliveryService{db: db, cfg: cfg, awx: NewAWXClient(cfg.AWXBaseURL, cfg.AWXToken, cfg.AWXUsername, cfg.AWXPassword), audit: audit, streams: make(map[string]map[chan DeliveryTaskSnapshot]struct{})}
return &DeliveryService{
db: db,
cfg: cfg,
awx: NewAWXClient(cfg.AWXBaseURL, cfg.AWXToken, cfg.AWXUsername, cfg.AWXPassword),
audit: audit,
streams: make(map[string]map[chan DeliveryTaskSnapshot]struct{}),
stdoutCache: make(map[string]*stdoutCacheItem),
}
}
func (s *DeliveryService) ListTargets(ctx context.Context, component string) ([]DeliveryTarget, error) {
@@ -992,18 +1007,95 @@ func (s *DeliveryService) broadcastTask(ctx context.Context, taskID string) {
if err != nil {
return
}
// 任务状态变化时清除 stdout 缓存
s.invalidateStdoutCacheForTask(taskID)
s.streamMu.Lock()
defer s.streamMu.Unlock()
// 收集需要清理的 closed channel
var closedChannels []chan DeliveryTaskSnapshot
for ch := range s.streams[taskID] {
select {
case ch <- snapshot:
default:
}
// 使用 recover 捕获 send on closed channel 的错误
func() {
defer func() {
if r := recover(); r != nil {
// channel 已关闭，标记需要清理
closedChannels = append(closedChannels, ch)
}
}()
select {
case ch <- snapshot:
default:
}
}()
}
// 清理 closed channels
for _, ch := range closedChannels {
delete(s.streams[taskID], ch)
}
if len(s.streams[taskID]) == 0 {
delete(s.streams, taskID)
}
}
// invalidateStdoutCacheForTask 清除与任务相关的 stdout 缓存
func (s *DeliveryService) invalidateStdoutCacheForTask(taskID string) {
var execution model.ExecutionJob
var rollback model.RollbackJob
s.cacheMu.Lock()
defer s.cacheMu.Unlock()
// 清除 execution job 的缓存
if err := s.db.Where("task_id = ?", taskID).First(&execution).Error; err == nil && execution.ExecutorJobID != "" {
delete(s.stdoutCache, execution.ExecutorJobID)
}
// 清除 rollback job 的缓存
if err := s.db.Where("task_id = ?", taskID).First(&rollback).Error; err == nil && rollback.ExecutorJobID != "" {
delete(s.stdoutCache, rollback.ExecutorJobID)
}
}
const stdoutCacheTTL = 30 * time.Second
func (s *DeliveryService) AWXJobStdout(ctx context.Context, jobID string) (string, error) {
return s.awx.JobStdout(ctx, jobID)
// 检查缓存
s.cacheMu.RLock()
if item, ok := s.stdoutCache[jobID]; ok {
if time.Since(item.createdAt) < stdoutCacheTTL {
s.cacheMu.RUnlock()
return item.stdout, nil
}
}
s.cacheMu.RUnlock()
// 缓存未命中或已过期，重新获取
stdout, err := s.awx.JobStdout(ctx, jobID)
if err != nil {
return "", err
}
// 更新缓存
s.cacheMu.Lock()
s.stdoutCache[jobID] = &stdoutCacheItem{
stdout: stdout,
createdAt: time.Now(),
}
s.cacheMu.Unlock()
return stdout, nil
}
// InvalidateStdoutCache 清除指定 jobID 的 stdout 缓存
func (s *DeliveryService) InvalidateStdoutCache(jobID string) {
s.cacheMu.Lock()
delete(s.stdoutCache, jobID)
s.cacheMu.Unlock()
}
func (s *DeliveryService) Cancel(ctx context.Context, taskID string, userID uint64, isAdmin bool) error {
server/internal/service/delivery_task_test.go
+440
View File
@@ -0,0 +1,440 @@
package service
import (
"context"
"sync"
"testing"
"time"
"github.com/1024XEngineer/xinfra/server/internal/model"
)
// newTestDeliveryService 创建一个用于测试的 DeliveryService，不需要真实的 DB 和配置。
// 仅适用于测试 pub/sub、缓存等内存逻辑。
func newTestDeliveryService() *DeliveryService {
return &DeliveryService{
streams: make(map[string]map[chan DeliveryTaskSnapshot]struct{}),
stdoutCache: make(map[string]*stdoutCacheItem),
}
}
func TestSubscribeTask(t *testing.T) {
svc := newTestDeliveryService()
ctx := context.Background()
_ = ctx
taskID := "test-task-1"
// 订阅任务
ch, cancel := svc.SubscribeTask(taskID)
defer cancel()
// 验证 channel 已注册
svc.streamMu.Lock()
if _, ok := svc.streams[taskID]; !ok {
svc.streamMu.Unlock()
t.Fatal("SubscribeTask did not register channel in streams map")
}
svc.streamMu.Unlock()
// 模拟 broadcastTask 推送 snapshot
snapshot := DeliveryTaskSnapshot{
Task: &model.DeliveryTask{ID: taskID, Status: model.TaskRunning},
}
svc.streamMu.Lock()
for ch := range svc.streams[taskID] {
select {
case ch <- snapshot:
default:
}
}
svc.streamMu.Unlock()
// 接收推送
select {
case received := <-ch:
if received.Task == nil || received.Task.ID != taskID {
t.Fatalf("received snapshot task ID = %v, want %q", received.Task, taskID)
}
if received.Task.Status != model.TaskRunning {
t.Fatalf("received snapshot status = %q, want %q", received.Task.Status, model.TaskRunning)
}
case <-time.After(time.Second):
t.Fatal("timeout waiting for snapshot from SubscribeTask")
}
}
func TestSubscribeTask_Cancel(t *testing.T) {
svc := newTestDeliveryService()
taskID := "test-task-cancel"
ch, cancel := svc.SubscribeTask(taskID)
// 调用 cancel
cancel()
// 验证 channel 已关闭
select {
case _, ok := <-ch:
if ok {
t.Fatal("channel should be closed after cancel, but got a value")
}
case <-time.After(time.Second):
t.Fatal("timeout waiting for channel close")
}
// 验证已从 streams 中移除
svc.streamMu.Lock()
if subs := svc.streams[taskID]; subs != nil && len(subs) > 0 {
svc.streamMu.Unlock()
t.Fatal("cancel did not remove channel from streams map")
}
svc.streamMu.Unlock()
}
func TestSubscribeTask_MultipleSubscribers(t *testing.T) {
svc := newTestDeliveryService()
taskID := "test-task-multi"
ch1, cancel1 := svc.SubscribeTask(taskID)
defer cancel1()
ch2, cancel2 := svc.SubscribeTask(taskID)
defer cancel2()
ch3, cancel3 := svc.SubscribeTask(taskID)
defer cancel3()
// 验证三个订阅者都已注册
svc.streamMu.Lock()
subs := svc.streams[taskID]
if len(subs) != 3 {
svc.streamMu.Unlock()
t.Fatalf("expected 3 subscribers, got %d", len(subs))
}
svc.streamMu.Unlock()
// 推送 snapshot
snapshot := DeliveryTaskSnapshot{
Task: &model.DeliveryTask{ID: taskID, Status: model.TaskFinished},
}
svc.streamMu.Lock()
for ch := range svc.streams[taskID] {
select {
case ch <- snapshot:
default:
}
}
svc.streamMu.Unlock()
// 验证三个订阅者都收到
for i, ch := range []<-chan DeliveryTaskSnapshot{ch1, ch2, ch3} {
select {
case received := <-ch:
if received.Task == nil || received.Task.Status != model.TaskFinished {
t.Fatalf("subscriber %d: expected TaskFinished, got %+v", i+1, received)
}
case <-time.After(time.Second):
t.Fatalf("subscriber %d: timeout waiting for snapshot", i+1)
}
}
}
func TestSubscribeTask_CancelOneDoesNotAffectOthers(t *testing.T) {
svc := newTestDeliveryService()
taskID := "test-task-cancel-one"
ch1, cancel1 := svc.SubscribeTask(taskID)
_, cancel2 := svc.SubscribeTask(taskID)
_ = cancel2
// 取消第一个订阅者
cancel1()
// 验证还剩一个订阅者
svc.streamMu.Lock()
subs := svc.streams[taskID]
if len(subs) != 1 {
svc.streamMu.Unlock()
t.Fatalf("expected 1 subscriber after cancel, got %d", len(subs))
}
svc.streamMu.Unlock()
// 推送 snapshot
snapshot := DeliveryTaskSnapshot{
Task: &model.DeliveryTask{ID: taskID, Status: model.TaskRunning},
}
svc.streamMu.Lock()
for ch := range svc.streams[taskID] {
select {
case ch <- snapshot:
default:
}
}
svc.streamMu.Unlock()
// ch1 已关闭，不应收到消息
select {
case _, ok := <-ch1:
if ok {
t.Fatal("ch1 should be closed after cancel")
}
case <-time.After(100 * time.Millisecond):
// OK: channel is closed, no value received
}
}
func TestBroadcastTask_ClosedChannelCleanup(t *testing.T) {
svc := newTestDeliveryService()
taskID := "test-task-cleanup"
// 创建一个订阅者并立即关闭
_, cancel := svc.SubscribeTask(taskID)
cancel()
// 等待 cancel 完成
time.Sleep(10 * time.Millisecond)
// 创建一个新的正常订阅者
ch2, cancel2 := svc.SubscribeTask(taskID)
defer cancel2()
// 模拟 broadcastTask 行为（带 recover）
snapshot := DeliveryTaskSnapshot{
Task: &model.DeliveryTask{ID: taskID, Status: model.TaskRunning},
}
svc.streamMu.Lock()
var closedChannels []chan DeliveryTaskSnapshot
for ch := range svc.streams[taskID] {
func() {
defer func() {
if r := recover(); r != nil {
closedChannels = append(closedChannels, ch)
}
}()
select {
case ch <- snapshot:
default:
}
}()
}
for _, ch := range closedChannels {
delete(svc.streams[taskID], ch)
}
if len(svc.streams[taskID]) == 0 {
delete(svc.streams, taskID)
}
svc.streamMu.Unlock()
// 验证 closed channel 被清理
svc.streamMu.Lock()
if subs := svc.streams[taskID]; subs != nil && len(subs) != 1 {
svc.streamMu.Unlock()
t.Fatalf("expected 1 subscriber after cleanup, got %d", len(subs))
}
svc.streamMu.Unlock()
// 正常订阅者应该收到消息
select {
case received := <-ch2:
if received.Task == nil || received.Task.ID != taskID {
t.Fatalf("expected task ID %q, got %+v", taskID, received)
}
case <-time.After(time.Second):
t.Fatal("timeout waiting for snapshot from normal subscriber")
}
}
func TestInvalidateStdoutCache(t *testing.T) {
svc := newTestDeliveryService()
// 填充缓存
svc.cacheMu.Lock()
svc.stdoutCache["job-1"] = &stdoutCacheItem{stdout: "cached output", createdAt: time.Now()}
svc.cacheMu.Unlock()
// 验证缓存命中
svc.cacheMu.RLock()
item, ok := svc.stdoutCache["job-1"]
svc.cacheMu.RUnlock()
if !ok {
t.Fatal("cache entry not found before invalidation")
}
if item.stdout != "cached output" {
t.Fatalf("cache stdout = %q, want %q", item.stdout, "cached output")
}
// 失效缓存
svc.InvalidateStdoutCache("job-1")
// 验证缓存已失效
svc.cacheMu.RLock()
_, ok = svc.stdoutCache["job-1"]
svc.cacheMu.RUnlock()
if ok {
t.Fatal("cache entry still exists after invalidation")
}
}
func TestInvalidateStdoutCache_NonExistent(t *testing.T) {
svc := newTestDeliveryService()
// 对不存在的 key 调用 invalidate 不应 panic
svc.InvalidateStdoutCache("non-existent-job")
// 验证缓存为空
svc.cacheMu.RLock()
size := len(svc.stdoutCache)
svc.cacheMu.RUnlock()
if size != 0 {
t.Fatalf("cache size = %d, want 0", size)
}
}
func TestStdoutCache_TTLExpiry(t *testing.T) {
svc := newTestDeliveryService()
// 填充一个已过期的缓存条目
svc.cacheMu.Lock()
svc.stdoutCache["job-expired"] = &stdoutCacheItem{
stdout: "old output",
createdAt: time.Now().Add(-stdoutCacheTTL - time.Second),
}
svc.cacheMu.Unlock()
// 模拟 AWXJobStdout 的缓存检查逻辑
svc.cacheMu.RLock()
cacheHit := false
if item, ok := svc.stdoutCache["job-expired"]; ok {
if time.Since(item.createdAt) < stdoutCacheTTL {
cacheHit = true
}
}
svc.cacheMu.RUnlock()
if cacheHit {
t.Fatal("expired cache entry should not be a hit")
}
}
func TestStdoutCache_FreshEntry(t *testing.T) {
svc := newTestDeliveryService()
// 填充一个新鲜的缓存条目
svc.cacheMu.Lock()
svc.stdoutCache["job-fresh"] = &stdoutCacheItem{
stdout: "fresh output",
createdAt: time.Now(),
}
svc.cacheMu.Unlock()
// 模拟 AWXJobStdout 的缓存检查逻辑
svc.cacheMu.RLock()
cacheHit := false
var cachedStdout string
if item, ok := svc.stdoutCache["job-fresh"]; ok {
if time.Since(item.createdAt) < stdoutCacheTTL {
cacheHit = true
cachedStdout = item.stdout
}
}
svc.cacheMu.RUnlock()
if !cacheHit {
t.Fatal("fresh cache entry should be a hit")
}
if cachedStdout != "fresh output" {
t.Fatalf("cached stdout = %q, want %q", cachedStdout, "fresh output")
}
}
func TestSubscribeTask_ConcurrentSafety(t *testing.T) {
svc := newTestDeliveryService()
taskID := "test-concurrent"
var wg sync.WaitGroup
const goroutines = 50
// 并发订阅
cancels := make([]func(), 0, goroutines)
for i := 0; i < goroutines; i++ {
wg.Add(1)
go func() {
defer wg.Done()
_, cancel := svc.SubscribeTask(taskID)
cancels = append(cancels, cancel)
}()
}
wg.Wait()
// 验证所有订阅者都已注册
svc.streamMu.Lock()
subs := svc.streams[taskID]
if len(subs) != goroutines {
svc.streamMu.Unlock()
t.Fatalf("expected %d subscribers, got %d", goroutines, len(subs))
}
svc.streamMu.Unlock()
// 并发取消
for _, cancel := range cancels {
wg.Add(1)
go func(c func()) {
defer wg.Done()
c()
}(cancel)
}
wg.Wait()
// 验证所有订阅者都已移除
svc.streamMu.Lock()
if subs := svc.streams[taskID]; subs != nil && len(subs) > 0 {
svc.streamMu.Unlock()
t.Fatalf("expected 0 subscribers after concurrent cancel, got %d", len(subs))
}
svc.streamMu.Unlock()
}
func TestStdoutCache_ConcurrentAccess(t *testing.T) {
svc := newTestDeliveryService()
var wg sync.WaitGroup
const goroutines = 50
// 并发写入缓存
for i := 0; i < goroutines; i++ {
wg.Add(1)
go func(idx int) {
defer wg.Done()
jobID := "job-" + string(rune('A'+idx%26))
svc.cacheMu.Lock()
svc.stdoutCache[jobID] = &stdoutCacheItem{
stdout: "output",
createdAt: time.Now(),
}
svc.cacheMu.Unlock()
}(i)
}
// 并发读取缓存
for i := 0; i < goroutines; i++ {
wg.Add(1)
go func(idx int) {
defer wg.Done()
jobID := "job-" + string(rune('A'+idx%26))
svc.cacheMu.RLock()
_ = svc.stdoutCache[jobID]
svc.cacheMu.RUnlock()
}(i)
}
// 并发失效缓存
for i := 0; i < goroutines; i++ {
wg.Add(1)
go func(idx int) {
defer wg.Done()
jobID := "job-" + string(rune('A'+idx%26))
svc.InvalidateStdoutCache(jobID)
}(i)
}
wg.Wait()
}