package worker import ( "context" "time" "droboticflow/internal/domain" "droboticflow/internal/store" ) func (runtime *Runtime) dispatchCandidates(ctx context.Context, settings *domain.SettingsRecord, counts store.WorkerRunCounts) ([]string, error) { available := globalConcurrencyLimit(settings) - counts.ActiveTotal if available <= 0 { return nil, nil } active := make(map[string]int, len(counts.ActiveByWorkflow)) for id, n := range counts.ActiveByWorkflow { active[id] = n } selected := []string{} collect := func(target int, triggerIn, triggerNotIn []domain.RunTrigger) error { if target <= 0 { return nil } passSelected := 0 excluded := []string{} known := map[string]domain.WorkflowRecord{} query := store.WorkerDispatchQuery{ Now: time.Now().UTC(), TriggerIn: triggerIn, TriggerNotIn: triggerNotIn, Limit: workerQueuedRunLimit, } for passSelected < target { page, err := runtime.store.ListQueuedRunsForDispatch(ctx, query) if err != nil { return err } if len(page) == 0 { break } ids := []string{} for _, run := range page { if _, exists := known[run.WorkflowID]; !exists { ids = append(ids, run.WorkflowID) known[run.WorkflowID] = domain.WorkflowRecord{ID: run.WorkflowID} } } // Exact workflow lookup avoids the automation discovery query and its // independent 500-workflow limit on the hot dispatch path. workflows := make([]domain.WorkflowRecord, 0, len(ids)) for _, id := range ids { workflow, err := runtime.store.GetWorkflow(ctx, id) if err != nil { return err } if workflow != nil { workflows = append(workflows, *workflow) } } runtime.applyWorkflowRuntimePolicies(ctx, workflows) for _, workflow := range workflows { known[workflow.ID] = workflow } allWorkflows := make([]domain.WorkflowRecord, 0, len(known)) for _, workflow := range known { allWorkflows = append(allWorkflows, workflow) } // Limit this pass without changing the configured global limit. The // shared active map still tracks workflow capacity across both passes. selectionActiveTotal := counts.ActiveTotal + (available - target) + passSelected next := selectQueuedRunsForDispatchSnapshot(runRecordsFromSummaries(page), allWorkflows, settings, active, selectionActiveTotal) remaining := target - passSelected if len(next) > remaining { next = next[:remaining] } selected = append(selected, next...) passSelected += len(next) if len(page) < workerQueuedRunLimit { break } // Continue past saturated workflows, but preserve the human-release // bypass and keep scanning a workflow whose own capacity exceeds a page. excluded = excluded[:0] for id, workflow := range known { if active[id] >= effectiveWorkflowConcurrencyLimit(&workflow, settings) { excluded = append(excluded, id) } } query.ExcludedWorkflowIDs = excluded last := page[len(page)-1] query.After = &domain.RunSummaryCursor{CreatedAt: last.CreatedAt, ID: last.ID} } return nil } reserved := runtime.recoveryReservedSlots if reserved > available { reserved = available } if reserved > 0 { if err := collect(reserved, []domain.RunTrigger{domain.RunTriggerRetry}, nil); err != nil { return nil, err } } var normalTriggerIn, normalTriggerNotIn []domain.RunTrigger if reserved > 0 { normalTriggerNotIn = []domain.RunTrigger{domain.RunTriggerRetry} } if err := collect(available-len(selected), normalTriggerIn, normalTriggerNotIn); err != nil { return nil, err } return selected, nil }