115 lines
3.5 KiB
Go
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
|
|
}
|