gatway

service/task_service.go

@@ -58,9 +58,10 @@ func (s *taskService) Create(ctx context.Context, req *dto.CreateTaskReq) (res *
 		State:          0,
 		BizName:        req.BizName,
 		CallbackURL:    req.CallbackUrl,
-		ModelKey:       req.ModelKey,
+		ModelKey:       m.ApiKey,
 		InputRef:       req.InputRef,
 		RequestPayload: storedPayload,
+		EpicycleId:     req.EpicycleId,
 	}
 	_, err = dao.Task.Insert(ctx, t)
 	if err != nil {
@@ -80,7 +81,7 @@ func (s *taskService) Create(ctx context.Context, req *dto.CreateTaskReq) (res *
 		apiPath = r.URL.Path
 		httpMethod = r.Method
 	}
-	_, _ = dao.OpLog.Insert(ctx, &entity.AsynchOpLog{
+	_, _ = dao.OpLog.Insert(ctx, &entity.LogsModelOp{
 		IP:             ip,
 		UserAgent:      ua,
 		APIPath:        apiPath,
@@ -97,9 +98,80 @@ func (s *taskService) Create(ctx context.Context, req *dto.CreateTaskReq) (res *
 			"taskId": taskID,
 		},
 	})
+
+	// 4) 创建成功后立即异步尝试执行当前任务，并仅在任务仍处于 pending(state=0) 时做定向轮询。
+	// 一旦任务进入 running/success/failed/downloaded，就停止轮询，避免一直空转。
+	go s.pollAndRunUntilPicked(context.WithoutCancel(ctx), taskID, req.EpicycleId)
+
 	return &dto.CreateTaskRes{TaskID: taskID}, nil
 }
 
+// pollAndRunUntilPicked 用于 createTask 创建后的“轻量级定向轮询”：
+// - 目标：尽快把刚创建的任务拉起来执行
+// - 只在任务仍为 pending(state=0) 时继续尝试抢占
+// - 一旦任务进入 running(1) / success(2) / failed(3) / downloaded(4)，立即停止
+// - 这样不会无限轮询；runWork 仍负责处理积压队列和未处理到的任务
+func (s *taskService) pollAndRunUntilPicked(ctx context.Context, taskID string, epicycleId int64) {
+	if taskID == "" {
+		return
+	}
+	interval := g.Cfg().MustGet(ctx, "asynch.worker.intervalSeconds").Int()
+	if interval <= 0 {
+		interval = 5
+	}
+	g.Log().Infof(ctx, "[task-auto-run][start] taskId=%s interval=%ds", taskID, interval)
+
+	ticker := time.NewTicker(time.Duration(interval) * time.Second)
+	defer ticker.Stop()
+
+	tryRun := func() bool {
+		t, err := dao.Task.GetByTaskID(ctx, taskID)
+		if err != nil {
+			g.Log().Warningf(ctx, "[task-auto-run][stop] taskId=%s reason=query_failed err=%v", taskID, err)
+			return true
+		}
+		if t == nil {
+			g.Log().Warningf(ctx, "[task-auto-run][stop] taskId=%s reason=task_not_found", taskID)
+			return true
+		}
+		switch t.State {
+		case 0:
+			if err := AsyncWorker.RunByTaskID(ctx, taskID, epicycleId); err != nil {
+				g.Log().Warningf(ctx, "[task-auto-run][retry] taskId=%s state=0 err=%v", taskID, err)
+			} else {
+				g.Log().Infof(ctx, "[task-auto-run][triggered] taskId=%s state=0", taskID)
+			}
+			return false
+		case 1:
+			g.Log().Infof(ctx, "[task-auto-run][stop] taskId=%s reason=running", taskID)
+			return true
+		case 2, 3, 4:
+			g.Log().Infof(ctx, "[task-auto-run][stop] taskId=%s reason=terminal state=%d", taskID, t.State)
+			return true
+		default:
+			g.Log().Infof(ctx, "[task-auto-run][stop] taskId=%s reason=unknown_state state=%d", taskID, t.State)
+			return true
+		}
+	}
+
+	// 先立即尝试一次
+	if stop := tryRun(); stop {
+		return
+	}
+
+	for {
+		select {
+		case <-ctx.Done():
+			g.Log().Infof(ctx, "[task-auto-run][stop] taskId=%s reason=context_done", taskID)
+			return
+		case <-ticker.C:
+			if stop := tryRun(); stop {
+				return
+			}
+		}
+	}
+}
+
 func (s *taskService) GetResult(ctx context.Context, taskID string) (res *dto.GetTaskResultRes, err error) {
 	t, err := dao.Task.GetByTaskID(ctx, taskID)
 	if err != nil {
@@ -168,12 +240,12 @@ func (s *taskService) GetBatch(ctx context.Context, req *dto.GetTaskBatchReq) (r
 
 func (s *taskService) List(ctx context.Context, req *dto.ListTaskReq) (res *dto.ListTaskRes, err error) {
 	pageNum, pageSize := 1, 10
-	if req != nil && req.Page != nil {
-		if req.Page.PageNum > 0 {
-			pageNum = int(req.Page.PageNum)
+	if req != nil {
+		if req.PageNum > 0 {
+			pageNum = req.PageNum
 		}
-		if req.Page.PageSize > 0 {
-			pageSize = int(req.Page.PageSize)
+		if req.PageSize > 0 {
+			pageSize = req.PageSize
 		}
 	}
 	modelName := ""