RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.
Go agent-harnessagent-native-databaseagentic-aiagentic-retrievalagentic-searchaiai-agentscontext-enginecontext-engineeringcontext-managementharness-engineeringknowledge-compilationragretrieval-augmented-generationretrieval-harnesssearch-harness
Go: clear stale task cancel flag so first re-parse after cancel runs (#17708)
euvreda8cbca0245e
diff --git a/internal/service/ingestion_task_service.go b/internal/service/ingestion_task_service.goindex 1f60bde712..201957a5da 100644--- a/internal/service/ingestion_task_service.go+++ b/internal/service/ingestion_task_service.go@@ -229,7 +229,16 @@ func (s *IngestionTaskService) StartRunning(ctx context.Context, taskID string)}return task, nilcase common.STOPPING:- return s.transition(ctx, taskID, common.STOPPED)+ task, err = s.transition(ctx, taskID, common.STOPPED)+ if err != nil {+ return nil, err+ }+ // The stop is finalized here without a worker (e.g. MQ redelivery of+ // a task that was nacked before execution), so the Redis cancel flag+ // that RequestStop set would otherwise leak until TTL and cancel the+ // next run of this task at the worker's pre-start check.+ clearCancelFlag(ctx, taskID)+ return task, nilcase common.RUNNING, common.COMPLETED, common.STOPPED, common.FAILED:return task, nildefault:@@ -387,6 +396,11 @@ func (s *IngestionTaskService) CreateAndEnqueue(ctx context.Context, task *entitif err != nil {return nil, err}+ // The previous run is terminal, so any leftover Redis cancel flag+ // is stale: a genuine cancel of the new run can only come through+ // RequestStop once the task is RUNNING again. Clear it so the+ // re-queued task is not cancelled at the worker's pre-start check.+ clearCancelFlag(ctx, existing.ID)if err = s.enqueueTask(existing.ID); err != nil {if rollbackErr := s.rollbackRetriedTask(ctx, existing.ID, originalStatus); rollbackErr != nil {return nil, fmt.Errorf("enqueue task %s: %w (rollback failed: %v)", existing.ID, err, rollbackErr)@@ -427,6 +441,15 @@ func (s *IngestionTaskService) rollbackCreatedTask(ctx context.Context, taskID sreturn err}+// clearCancelFlag removes the Redis cancel marker ({task_id}-cancel) that+// RequestStop sets for a RUNNING task. No-op when Redis is unavailable —+// the DB STOPPING status remains the fallback cancel signal.+func clearCancelFlag(ctx context.Context, taskID string) {+ if rc := redis2.Get(); rc != nil {+ rc.Delete(ctx, fmt.Sprintf("%s-cancel", taskID))+ }+}+func (s *IngestionTaskService) enqueueTask(taskID string) error {taskMessage := common.TaskMessage{TaskID: taskID,diff --git a/internal/service/ingestion_task_service_test.go b/internal/service/ingestion_task_service_test.goindex aaee9a481e..53c8d1f217 100644--- a/internal/service/ingestion_task_service_test.go+++ b/internal/service/ingestion_task_service_test.go@@ -319,6 +319,30 @@ func TestStartRunningLeavesTerminalDocumentUntouched(t *testing.T) {}}+// TestStartRunningFinalizesStoppingTask locks in the redelivery path: a+// STOPPING task (cancelled after being nacked, before any worker ran it) is+// moved to STOPPED by StartRunning, so the task reaches a terminal state and+// a later re-parse can transition it back to CREATED.+func TestStartRunningFinalizesStoppingTask(t *testing.T) {+ db := setupServiceTestDB(t)+ pushServiceDB(t, db)+ insertTestIngestionTask(t, "task-1", "user-1", "doc-1", "kb-1")+ if err := db.Model(&entity.IngestionTask{}).Where("id = ?", "task-1").+ Update("status", common.STOPPING).Error; err != nil {+ t.Fatalf("set STOPPING: %v", err)+ }++ svc := NewIngestionTaskService()+ ctx := t.Context()+ task, err := svc.StartRunning(ctx, "task-1")+ if err != nil {+ t.Fatalf("StartRunning failed: %v", err)+ }+ if task.Status != common.STOPPED {+ t.Fatalf("status = %q, want %q", task.Status, common.STOPPED)+ }+}+func TestIngestionTaskServiceRequestStopTransitionsCreatedTaskToStopped(t *testing.T) {db := setupServiceTestDB(t)pushServiceDB(t, db)