yvan/kra-oa
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

优化结构

Browse Source
This commit is contained in:
Yvan
2026-08-22 15:53:14 +08:00
parent ca52de5db0
commit 491ed21d48
72 changed files with 746 additions and 695 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/worker/task_executor.go
+16 -15
View File
@@ -7,7 +7,6 @@ import (
"errors"
"fmt"
"io"
"kra/internal/biz/system"
"net"
"net/http"
"net/url"
@@ -15,23 +14,25 @@ import (
"syscall"
"time"
"kra/internal/biz/system"
taskbiz "kra/internal/biz/task"
"kra/internal/conf"
)
type TaskExecutor struct {
tasks *system.TaskUsecase
tasks *taskbiz.TaskUsecase
media *system.MediaUsecase
runtime *conf.Runtime
methods system.TaskMethodRegistry
methods taskbiz.TaskMethodRegistry
}
func NewTaskExecutor(tasks *system.TaskUsecase, media *system.MediaUsecase, runtime *conf.Runtime) *TaskExecutor {
return NewTaskExecutorWithRegistry(tasks, media, runtime, system.DefaultTaskMethodRegistry())
func NewTaskExecutor(tasks *taskbiz.TaskUsecase, media *system.MediaUsecase, runtime *conf.Runtime) *TaskExecutor {
return NewTaskExecutorWithRegistry(tasks, media, runtime, taskbiz.DefaultTaskMethodRegistry())
}
func NewTaskExecutorWithRegistry(tasks *system.TaskUsecase, media *system.MediaUsecase, runtime *conf.Runtime, methods system.TaskMethodRegistry) *TaskExecutor {
func NewTaskExecutorWithRegistry(tasks *taskbiz.TaskUsecase, media *system.MediaUsecase, runtime *conf.Runtime, methods taskbiz.TaskMethodRegistry) *TaskExecutor {
if methods == nil {
methods = system.DefaultTaskMethodRegistry()
methods = taskbiz.DefaultTaskMethodRegistry()
}
return &TaskExecutor{tasks: tasks, media: media, runtime: runtime, methods: methods}
}
@@ -61,7 +62,7 @@ func taskHTTPClient(allowPrivate bool) *http.Client {
return &http.Client{Timeout: 30 * time.Second, Transport: &http.Transport{Proxy: nil, DialContext: dialer.DialContext}}
}
func (e *TaskExecutor) runHTTP(ctx context.Context, task *system.TimedTask) (string, error) {
func (e *TaskExecutor) runHTTP(ctx context.Context, task *taskbiz.TimedTask) (string, error) {
parsed, err := url.Parse(task.HTTPURL)
if err != nil {
return "", fmt.Errorf("URL 非法: %w", err)
@@ -109,13 +110,13 @@ func truncateTaskText(value string) string {
return value[:limit] + "...(截断)"
}
func (e *TaskExecutor) runMethod(ctx context.Context, task *system.TimedTask) error {
var method system.TaskMethodFunc
func (e *TaskExecutor) runMethod(ctx context.Context, task *taskbiz.TimedTask) error {
var method taskbiz.TaskMethodFunc
var ok bool
if e.methods != nil {
method, ok = e.methods.Lookup(task.MethodName)
} else {
method, ok = system.TaskMethodByName(task.MethodName)
method, ok = taskbiz.TaskMethodByName(task.MethodName)
}
if !ok {
return fmt.Errorf("方法 %s 未注册(需通过 platform/task.Registry 注册)", task.MethodName)
@@ -145,12 +146,12 @@ func (e *TaskExecutor) runMethod(ctx context.Context, task *system.TimedTask) er
}
}
func (e *TaskExecutor) Run(ctx context.Context, task *system.TimedTask, trigger string) (log *system.TimedTaskLog) {
func (e *TaskExecutor) Run(ctx context.Context, task *taskbiz.TimedTask, trigger string) (log *taskbiz.TimedTaskLog) {
if ctx == nil {
ctx = context.Background()
}
started := time.Now()
log = &system.TimedTaskLog{TaskID: task.ID, TaskName: task.Name, TriggerType: trigger, StartedAt: started, Status: "success"}
log = &taskbiz.TimedTaskLog{TaskID: task.ID, TaskName: task.Name, TriggerType: trigger, StartedAt: started, Status: "success"}
defer func() {
if recovered := recover(); recovered != nil {
log.Status = "fail"
@@ -165,9 +166,9 @@ func (e *TaskExecutor) Run(ctx context.Context, task *system.TimedTask, trigger
}()
var err error
switch task.ExecutorType {
case system.TaskExecutorMethod:
case taskbiz.TaskExecutorMethod:
err = e.runMethod(ctx, task)
case system.TaskExecutorHTTP:
case taskbiz.TaskExecutorHTTP:
runCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
log.Output, err = e.runHTTP(runCtx, task)
cancel()
internal/worker/task_executor_test.go
+10 -9
View File
@@ -4,11 +4,12 @@ import (
"context"
"encoding/json"
"errors"
"kra/internal/biz/system"
"net"
"strings"
"testing"
"time"
taskbiz "kra/internal/biz/task"
)
func TestPrivateIP(t *testing.T) {
@@ -24,25 +25,25 @@ func TestPrivateIP(t *testing.T) {
func TestRunMethodReportsParentDeadlineAsTimeout(t *testing.T) {
const methodName = "worker-test-parent-deadline"
system.RegisterTaskMethod(methodName, "test", func(ctx context.Context, _ json.RawMessage) error {
taskbiz.RegisterTaskMethod(methodName, "test", func(ctx context.Context, _ json.RawMessage) error {
<-ctx.Done()
return ctx.Err()
})
executor := &TaskExecutor{}
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Millisecond)
defer cancel()
if err := executor.runMethod(ctx, &system.TimedTask{MethodName: methodName}); !errors.Is(err, errTaskTimeout) {
if err := executor.runMethod(ctx, &taskbiz.TimedTask{MethodName: methodName}); !errors.Is(err, errTaskTimeout) {
t.Fatalf("runMethod() error = %v, want errTaskTimeout", err)
}
}
func TestRunMethodConvertsPanicToError(t *testing.T) {
const methodName = "worker-test-panic"
system.RegisterTaskMethod(methodName, "test", func(context.Context, json.RawMessage) error {
taskbiz.RegisterTaskMethod(methodName, "test", func(context.Context, json.RawMessage) error {
panic("boom")
})
executor := &TaskExecutor{}
err := executor.runMethod(context.Background(), &system.TimedTask{MethodName: methodName})
err := executor.runMethod(context.Background(), &taskbiz.TimedTask{MethodName: methodName})
if err == nil || !strings.Contains(err.Error(), "panic: boom") {
t.Fatalf("runMethod() error = %v, want recovered panic", err)
}
@@ -51,7 +52,7 @@ func TestRunMethodConvertsPanicToError(t *testing.T) {
func TestRunMethodUsesParentContext(t *testing.T) {
const methodName = "worker-test-parent-context"
started := make(chan struct{})
system.RegisterTaskMethod(methodName, "test", func(ctx context.Context, _ json.RawMessage) error {
taskbiz.RegisterTaskMethod(methodName, "test", func(ctx context.Context, _ json.RawMessage) error {
close(started)
<-ctx.Done()
return ctx.Err()
@@ -60,7 +61,7 @@ func TestRunMethodUsesParentContext(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
done := make(chan error, 1)
go func() {
done <- executor.runMethod(ctx, &system.TimedTask{MethodName: methodName})
done <- executor.runMethod(ctx, &taskbiz.TimedTask{MethodName: methodName})
}()
select {
case <-started:
@@ -81,14 +82,14 @@ func TestRunMethodUsesParentContext(t *testing.T) {
func TestRunMethodHonorsDeadlineWhenMethodIgnoresContext(t *testing.T) {
const methodName = "worker-test-ignores-context"
release := make(chan struct{})
system.RegisterTaskMethod(methodName, "test", func(context.Context, json.RawMessage) error {
taskbiz.RegisterTaskMethod(methodName, "test", func(context.Context, json.RawMessage) error {
<-release
return nil
})
executor := &TaskExecutor{}
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Millisecond)
defer cancel()
if err := executor.runMethod(ctx, &system.TimedTask{MethodName: methodName}); !errors.Is(err, errTaskTimeout) {
if err := executor.runMethod(ctx, &taskbiz.TimedTask{MethodName: methodName}); !errors.Is(err, errTaskTimeout) {
close(release)
t.Fatalf("runMethod() error = %v, want errTaskTimeout", err)
}
internal/worker/task_registry.go
+5 -4
View File
@@ -4,6 +4,7 @@ import (
"context"
"encoding/json"
"kra/internal/biz/system"
taskbiz "kra/internal/biz/task"
"kra/internal/conf"
platformtask "kra/pkg/task"
@@ -12,12 +13,12 @@ import (
// TaskMethods is the system module's dependency-bearing task contribution.
// Other modules provide their own contributor instead of editing this file.
type TaskMethods struct {
tasks *system.TaskUsecase
tasks *taskbiz.TaskUsecase
media *system.MediaUsecase
runtime *conf.Runtime
}
func NewTaskMethods(tasks *system.TaskUsecase, media *system.MediaUsecase, runtime *conf.Runtime) *TaskMethods {
func NewTaskMethods(tasks *taskbiz.TaskUsecase, media *system.MediaUsecase, runtime *conf.Runtime) *TaskMethods {
return &TaskMethods{tasks: tasks, media: media, runtime: runtime}
}
@@ -28,12 +29,12 @@ func (methods *TaskMethods) RegisterTasks(registry *platformtask.Registry) {
return
}
registry.Register(platformtask.Method{
Name: system.TaskMethodClearDB, Description: "清理数据库过期日志(操作记录/JWT黑名单/定时任务执行日志)", Run: func(ctx context.Context, _ json.RawMessage) error {
Name: taskbiz.TaskMethodClearDB, Description: "清理数据库过期日志(操作记录/JWT黑名单/定时任务执行日志)", Run: func(ctx context.Context, _ json.RawMessage) error {
return methods.tasks.CleanupLogs(ctx)
},
})
registry.Register(platformtask.Method{
Name: system.TaskMethodUploads, Description: "清理过期大文件上传会话", Run: func(ctx context.Context, _ json.RawMessage) error {
Name: taskbiz.TaskMethodUploads, Description: "清理过期大文件上传会话", Run: func(ctx context.Context, _ json.RawMessage) error {
ttl := 24
config := methods.runtime.Admin()
if config != nil && config.Media != nil && config.Media.SessionTtl > 0 {
internal/worker/task_runtime_test.go
+24 -23
View File
@@ -5,30 +5,31 @@ import (
"encoding/json"
"errors"
"io"
"kra/internal/biz/system"
"log/slog"
"sync"
"sync/atomic"
"testing"
"time"
taskbiz "kra/internal/biz/task"
)
type workerTaskRepo struct {
mu sync.Mutex
items []*system.TimedTask
items []*taskbiz.TimedTask
listErr error
logs chan *system.TimedTaskLog
logs chan *taskbiz.TimedTaskLog
}
func (r *workerTaskRepo) CreateTask(context.Context, *system.TimedTask) error { return nil }
func (r *workerTaskRepo) UpdateTask(context.Context, *system.TimedTask) error { return nil }
func (r *workerTaskRepo) DeleteTask(context.Context, uint) error { return nil }
func (r *workerTaskRepo) ToggleTask(context.Context, uint, bool) error { return nil }
func (r *workerTaskRepo) CleanupLogs(context.Context) error { return nil }
func (r *workerTaskRepo) CreateTask(context.Context, *taskbiz.TimedTask) error { return nil }
func (r *workerTaskRepo) UpdateTask(context.Context, *taskbiz.TimedTask) error { return nil }
func (r *workerTaskRepo) DeleteTask(context.Context, uint) error { return nil }
func (r *workerTaskRepo) ToggleTask(context.Context, uint, bool) error { return nil }
func (r *workerTaskRepo) CleanupLogs(context.Context) error { return nil }
func (r *workerTaskRepo) TaskNameExists(context.Context, string, uint) (bool, error) {
return false, nil
}
func (r *workerTaskRepo) FindTask(_ context.Context, id uint) (*system.TimedTask, error) {
func (r *workerTaskRepo) FindTask(_ context.Context, id uint) (*taskbiz.TimedTask, error) {
r.mu.Lock()
defer r.mu.Unlock()
for _, item := range r.items {
@@ -38,31 +39,31 @@ func (r *workerTaskRepo) FindTask(_ context.Context, id uint) (*system.TimedTask
}
return nil, errors.New("task not found")
}
func (r *workerTaskRepo) ListTasks(context.Context, int, int, *system.TimedTask) ([]*system.TimedTask, int64, error) {
func (r *workerTaskRepo) ListTasks(context.Context, int, int, *taskbiz.TimedTask) ([]*taskbiz.TimedTask, int64, error) {
r.mu.Lock()
defer r.mu.Unlock()
if r.listErr != nil {
return nil, 0, r.listErr
}
items := make([]*system.TimedTask, 0, len(r.items))
items := make([]*taskbiz.TimedTask, 0, len(r.items))
for _, item := range r.items {
items = append(items, cloneTimedTask(item))
}
return items, int64(len(items)), nil
}
func (r *workerTaskRepo) RecordTaskLog(_ context.Context, value *system.TimedTaskLog) error {
func (r *workerTaskRepo) RecordTaskLog(_ context.Context, value *taskbiz.TimedTaskLog) error {
if r.logs != nil {
copy := *value
r.logs <- &copy
}
return nil
}
func (r *workerTaskRepo) ListTaskLogs(context.Context, int, int, uint, string) ([]*system.TimedTaskLog, int64, error) {
func (r *workerTaskRepo) ListTaskLogs(context.Context, int, int, uint, string) ([]*taskbiz.TimedTaskLog, int64, error) {
return nil, 0, nil
}
func newTestTaskScheduler(repo *workerTaskRepo) *TaskScheduler {
tasks := system.NewTaskUsecase(repo)
tasks := taskbiz.NewTaskUsecase(repo)
executor := &TaskExecutor{tasks: tasks}
logger := slog.New(slog.NewTextHandler(io.Discard, nil))
return NewTaskScheduler(tasks, nil, executor, logger)
@@ -71,7 +72,7 @@ func newTestTaskScheduler(repo *workerTaskRepo) *TaskScheduler {
func TestReloadPreservesExistingScheduleOnPreparationFailure(t *testing.T) {
repo := &workerTaskRepo{}
scheduler := newTestTaskScheduler(repo)
old := &system.TimedTask{ID: 1, Name: "old", Spec: "0 0 * * *", Enabled: true}
old := &taskbiz.TimedTask{ID: 1, Name: "old", Spec: "0 0 * * *", Enabled: true}
if err := scheduler.Schedule(old); err != nil {
t.Fatalf("schedule old task: %v", err)
}
@@ -89,7 +90,7 @@ func TestReloadPreservesExistingScheduleOnPreparationFailure(t *testing.T) {
t.Run("invalid cron", func(t *testing.T) {
repo.mu.Lock()
repo.listErr = nil
repo.items = []*system.TimedTask{{ID: 2, Name: "invalid", Spec: "bad cron", Enabled: true}}
repo.items = []*taskbiz.TimedTask{{ID: 2, Name: "invalid", Spec: "bad cron", Enabled: true}}
repo.mu.Unlock()
if err := scheduler.Reload(context.Background()); err == nil {
t.Fatal("Reload() error = nil, want cron error")
@@ -121,7 +122,7 @@ func TestConcurrentScheduleKeepsSingleEntry(t *testing.T) {
wg.Add(1)
go func() {
defer wg.Done()
if err := scheduler.Schedule(&system.TimedTask{ID: 7, Name: "same", Spec: "0 0 * * *", Enabled: true}); err != nil {
if err := scheduler.Schedule(&taskbiz.TimedTask{ID: 7, Name: "same", Spec: "0 0 * * *", Enabled: true}); err != nil {
t.Errorf("Schedule() error = %v", err)
}
}()
@@ -135,15 +136,15 @@ func TestManualTriggerSkipsOverlappingExecution(t *testing.T) {
started := make(chan struct{}, 2)
release := make(chan struct{})
var calls atomic.Int32
system.RegisterTaskMethod(methodName, "test", func(context.Context, json.RawMessage) error {
taskbiz.RegisterTaskMethod(methodName, "test", func(context.Context, json.RawMessage) error {
calls.Add(1)
started <- struct{}{}
<-release
return nil
})
task := &system.TimedTask{ID: 9, Name: "single", ExecutorType: system.TaskExecutorMethod, MethodName: methodName}
repo := &workerTaskRepo{items: []*system.TimedTask{task}, logs: make(chan *system.TimedTaskLog, 2)}
task := &taskbiz.TimedTask{ID: 9, Name: "single", ExecutorType: taskbiz.TaskExecutorMethod, MethodName: methodName}
repo := &workerTaskRepo{items: []*taskbiz.TimedTask{task}, logs: make(chan *taskbiz.TimedTaskLog, 2)}
scheduler := newTestTaskScheduler(repo)
if err := scheduler.TriggerID(context.Background(), task.ID); err != nil {
t.Fatalf("first manual trigger failed: %v", err)
@@ -192,15 +193,15 @@ func TestAutomaticAndManualTriggersShareOverlapGate(t *testing.T) {
started := make(chan struct{}, 1)
release := make(chan struct{})
var calls atomic.Int32
system.RegisterTaskMethod(methodName, "test", func(context.Context, json.RawMessage) error {
taskbiz.RegisterTaskMethod(methodName, "test", func(context.Context, json.RawMessage) error {
calls.Add(1)
started <- struct{}{}
<-release
return nil
})
task := &system.TimedTask{ID: 10, Name: "shared-gate", ExecutorType: system.TaskExecutorMethod, MethodName: methodName}
repo := &workerTaskRepo{logs: make(chan *system.TimedTaskLog, 1)}
task := &taskbiz.TimedTask{ID: 10, Name: "shared-gate", ExecutorType: taskbiz.TaskExecutorMethod, MethodName: methodName}
repo := &workerTaskRepo{logs: make(chan *taskbiz.TimedTaskLog, 1)}
scheduler := newTestTaskScheduler(repo)
if !scheduler.dispatch(task, "auto", true) {
t.Fatal("automatic dispatch was rejected while idle")
internal/worker/task_scheduler.go
+12 -11
View File
@@ -6,6 +6,7 @@ import (
"errors"
"fmt"
"kra/internal/biz/system"
taskbiz "kra/internal/biz/task"
"log/slog"
"sync"
"time"
@@ -14,7 +15,7 @@ import (
)
type TaskScheduler struct {
tasks *system.TaskUsecase
tasks *taskbiz.TaskUsecase
authorities *system.AuthorityUsecase
executor *TaskExecutor
logger *slog.Logger
@@ -38,13 +39,13 @@ type scheduledEntry struct {
entry cron.EntryID
}
func NewTaskScheduler(tasks *system.TaskUsecase, authorities *system.AuthorityUsecase, executor *TaskExecutor, logger *slog.Logger) *TaskScheduler {
func NewTaskScheduler(tasks *taskbiz.TaskUsecase, authorities *system.AuthorityUsecase, executor *TaskExecutor, logger *slog.Logger) *TaskScheduler {
idle := make(chan struct{})
close(idle)
return &TaskScheduler{tasks: tasks, authorities: authorities, executor: executor, logger: logger.With("mod", "timedTask"), standard: cron.New(), seconds: cron.New(cron.WithSeconds()), entries: map[uint]scheduledEntry{}, running: map[uint]struct{}{}, idle: idle, subscribers: map[uint]map[chan []byte]struct{}{}}
}
func NewTaskRuntime(scheduler *TaskScheduler) system.TaskRuntime { return scheduler }
func NewTaskRuntime(scheduler *TaskScheduler) taskbiz.TaskRuntime { return scheduler }
func NewTaskReloader(scheduler *TaskScheduler) system.TaskReloader { return scheduler }
@@ -118,7 +119,7 @@ func (s *TaskScheduler) Reload(ctx context.Context) error {
return err
}
type preparedTask struct {
task *system.TimedTask
task *taskbiz.TimedTask
schedule cron.Schedule
}
prepared := make([]preparedTask, 0, len(items))
@@ -183,7 +184,7 @@ func (s *TaskScheduler) finishRun(id uint) {
}
}
func (s *TaskScheduler) dispatch(task *system.TimedTask, trigger string, async bool) bool {
func (s *TaskScheduler) dispatch(task *taskbiz.TimedTask, trigger string, async bool) bool {
ctx, ok := s.beginRun(task.ID)
if !ok {
s.logger.Warn("timed task skipped because it is already running or the scheduler is stopping", "task_id", task.ID, "task_name", task.Name, "trigger_type", trigger)
@@ -201,7 +202,7 @@ func (s *TaskScheduler) dispatch(task *system.TimedTask, trigger string, async b
return true
}
func (s *TaskScheduler) run(ctx context.Context, task *system.TimedTask, trigger string) {
func (s *TaskScheduler) run(ctx context.Context, task *taskbiz.TimedTask, trigger string) {
log := s.executor.Run(ctx, task, trigger)
attributes := []any{"task_id", log.TaskID, "task_name", log.TaskName, "trigger_type", log.TriggerType, "status", log.Status, "duration_ms", log.DurationMS, "started_at", log.StartedAt, "finished_at", log.FinishedAt}
if log.ErrorMsg != "" {
@@ -224,7 +225,7 @@ func (s *TaskScheduler) run(ctx context.Context, task *system.TimedTask, trigger
}
}
func (s *TaskScheduler) Schedule(task *system.TimedTask) error {
func (s *TaskScheduler) Schedule(task *taskbiz.TimedTask) error {
if task == nil {
return errors.New("定时任务不能为空")
}
@@ -246,21 +247,21 @@ func (s *TaskScheduler) Schedule(task *system.TimedTask) error {
return nil
}
func parseTaskSchedule(task *system.TimedTask) (cron.Schedule, error) {
func parseTaskSchedule(task *taskbiz.TimedTask) (cron.Schedule, error) {
if task.WithSeconds {
return cron.NewParser(cron.Second | cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow | cron.Descriptor).Parse(task.Spec)
}
return cron.ParseStandard(task.Spec)
}
func cloneTimedTask(task *system.TimedTask) *system.TimedTask {
func cloneTimedTask(task *taskbiz.TimedTask) *taskbiz.TimedTask {
copy := *task
copy.Params = append([]byte(nil), task.Params...)
copy.HTTPHeader = append([]byte(nil), task.HTTPHeader...)
return &copy
}
func (s *TaskScheduler) scheduleLocked(task *system.TimedTask, schedule cron.Schedule) {
func (s *TaskScheduler) scheduleLocked(task *taskbiz.TimedTask, schedule cron.Schedule) {
run := func() {
s.dispatch(task, "auto", false)
}
@@ -319,7 +320,7 @@ func (s *TaskScheduler) NextRuns() map[uint]time.Time {
return out
}
func (s *TaskScheduler) Trigger(task *system.TimedTask) bool {
func (s *TaskScheduler) Trigger(task *taskbiz.TimedTask) bool {
if task == nil {
return false
}