forked from longtao.wu/droboticflow
102 lines
3.5 KiB
Go
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
|
|
}
|