droboticflow/internal/store/worker_dispatch.go
2026-10-01 03:08:27 -07:00

102 lines
3.5 KiB
Go

package store
import (
"context"
"sort"
"time"
"droboticflow/internal/domain"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo/options"
)
// Excluding exhausted workflows lets later pages use spare global capacity,
// even when thousands of older records belong to one saturated workflow.
func (store *MongoStore) ListQueuedRunsForDispatch(ctx context.Context, query WorkerDispatchQuery) ([]domain.RunSummary, error) {
stamp := query.Now.UTC().Format(time.RFC3339Nano)
filter := bson.M{
"status": domain.RunStatusQueued,
"$and": bson.A{
bson.M{"$or": bson.A{bson.M{"availableAt": bson.M{"$exists": false}}, bson.M{"availableAt": ""}, bson.M{"availableAt": bson.M{"$lte": stamp}}}},
bson.M{"$or": mongoRunLeaseAvailableFilter(stamp)},
},
}
if len(query.ExcludedWorkflowIDs) > 0 {
filter["$or"] = bson.A{bson.M{"workflowId": bson.M{"$nin": query.ExcludedWorkflowIDs}}, bson.M{"trigger": domain.RunTriggerHumanRelease}}
}
if len(query.TriggerIn) > 0 || len(query.TriggerNotIn) > 0 {
triggerFilter := bson.M{}
if len(query.TriggerIn) > 0 {
triggers := make([]any, 0, len(query.TriggerIn))
for _, trigger := range query.TriggerIn {
triggers = append(triggers, trigger)
}
triggerFilter["$in"] = triggers
}
if len(query.TriggerNotIn) > 0 {
triggers := make([]any, 0, len(query.TriggerNotIn))
for _, trigger := range query.TriggerNotIn {
triggers = append(triggers, trigger)
}
triggerFilter["$nin"] = triggers
}
filter["trigger"] = triggerFilter
}
if query.After != nil {
filter["$and"] = append(filter["$and"].(bson.A), bson.M{"$or": bson.A{
bson.M{"createdAt": bson.M{"$gt": query.After.CreatedAt}},
bson.M{"createdAt": query.After.CreatedAt, "id": bson.M{"$gt": query.After.ID}},
}})
}
cursor, err := store.runs.Find(ctx, filter, options.Find().SetProjection(runSummaryPageProjection()).SetSort(bson.D{{Key: "createdAt", Value: 1}, {Key: "id", Value: 1}}).SetLimit(int64(normalizedWorkerQueryLimit(query.Limit, 100, 1000))))
if err != nil {
return nil, err
}
return decodeMany[domain.RunSummary](ctx, cursor)
}
func (store *MemoryStore) ListQueuedRunsForDispatch(_ context.Context, query WorkerDispatchQuery) ([]domain.RunSummary, error) {
store.mu.Lock()
defer store.mu.Unlock()
skip := make(map[string]bool, len(query.ExcludedWorkflowIDs))
for _, id := range query.ExcludedWorkflowIDs {
skip[id] = true
}
items := make([]domain.RunSummary, 0)
for _, run := range store.runs {
if run.Status != domain.RunStatusQueued || (skip[run.WorkflowID] && run.Trigger != domain.RunTriggerHumanRelease) || !runIsAvailable(&run, query.Now) || runHasActiveLease(&run, query.Now) {
continue
}
if len(query.TriggerIn) > 0 && !containsRunTrigger(query.TriggerIn, run.Trigger) {
continue
}
if len(query.TriggerNotIn) > 0 && containsRunTrigger(query.TriggerNotIn, run.Trigger) {
continue
}
if query.After != nil && (run.CreatedAt < query.After.CreatedAt || (run.CreatedAt == query.After.CreatedAt && run.ID <= query.After.ID)) {
continue
}
items = append(items, compactRunSummary(summarizeRun(run)))
}
sort.Slice(items, func(i, j int) bool {
if items[i].CreatedAt == items[j].CreatedAt {
return items[i].ID < items[j].ID
}
return items[i].CreatedAt < items[j].CreatedAt
})
limit := normalizedWorkerQueryLimit(query.Limit, 100, 1000)
if len(items) > limit {
items = items[:limit]
}
return items, nil
}
func containsRunTrigger(triggers []domain.RunTrigger, want domain.RunTrigger) bool {
for _, trigger := range triggers {
if trigger == want {
return true
}
}
return false
}