2026-10-01 03:08:27 -07:00

115 lines
3.5 KiB
Go

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
}