simplify code

Author: Zettat123

models/actions/run.go

@@ -374,3 +374,35 @@ func UpdateRun(ctx context.Context, run *ActionRun, cols ...string) error {
 }
 
 type ActionRunIndex db.ResourceIndex
+
+func ShouldBlockRunByConcurreny(ctx context.Context, actionRun *ActionRun) (bool, error) {
+	if len(actionRun.ConcurrencyGroup) == 0 {
+		return false, nil
+	}
+	if actionRun.ConcurrencyCancel {
+		return false, CancelConcurrentRuns(ctx, actionRun)
+	}
+
+	concurrentRunsNum, err := db.Count[ActionRun](ctx, &FindRunOptions{
+		RepoID:           actionRun.RepoID,
+		ConcurrencyGroup: actionRun.ConcurrencyGroup,
+		Status:           []Status{StatusWaiting, StatusRunning},
+	})
+	if err != nil {
+		return false, fmt.Errorf("count running and waiting runs: %w", err)
+	}
+
+	return concurrentRunsNum > 0, nil
+}
+
+func CancelConcurrentRuns(ctx context.Context, actionRun *ActionRun) error {
+	return CancelPreviousJobsWithOpts(ctx, &FindRunOptions{
+		RepoID:           actionRun.RepoID,
+		ConcurrencyGroup: actionRun.ConcurrencyGroup,
+		Status: []Status{
+			StatusRunning,
+			StatusWaiting,
+			StatusBlocked,
+		},
+	})
+}

models/actions/run_job.go

@@ -192,7 +192,7 @@ func AggregateJobStatus(jobs []*ActionRunJob) Status {
 	}
 }
 
-func ShouldJobBeBlockedByConcurrentJobs(ctx context.Context, actionRunJob *ActionRunJob) (bool, error) {
+func ShouldBlockJobByConcurreny(ctx context.Context, actionRunJob *ActionRunJob) (bool, error) {
 	if len(actionRunJob.RawConcurrencyGroup) == 0 {
 		return false, nil
 	}
@@ -212,7 +212,7 @@ func ShouldJobBeBlockedByConcurrentJobs(ctx context.Context, actionRunJob *Actio
 		Statuses:         []Status{StatusRunning, StatusWaiting},
 	})
 	if err != nil {
-		return false, fmt.Errorf("count waiting jobs: %w", err)
+		return false, fmt.Errorf("count running and waiting jobs: %w", err)
 	}
 
 	return concurrentJobsNum > 0, nil

routers/web/repo/actions/view.go

@@ -560,7 +560,7 @@ func Approve(ctx *context_module.Context) {
 			return err
 		}
 		for _, job := range jobs {
-			blockedByConcurrency, err := actions_model.ShouldJobBeBlockedByConcurrentJobs(ctx, job)
+			blockedByConcurrency, err := actions_model.ShouldBlockJobByConcurreny(ctx, job)
 			if err != nil {
 				return err
 			}

services/actions/job_emitter.go

@@ -69,15 +69,15 @@ func checkJobsByRunID(ctx context.Context, runID int64) error {
 			if err != nil {
 				return err
 			}
-			for _, cRun := range concurrentRuns {
-				concurrentRunIDs.Add(cRun.ID)
-				if cRun.NeedApproval {
+			for _, concurrentRun := range concurrentRuns {
+				concurrentRunIDs.Add(concurrentRun.ID)
+				if concurrentRun.NeedApproval {
 					continue
 				}
-				if err := checkJobsOfRun(ctx, cRun); err != nil {
+				if err := checkJobsOfRun(ctx, concurrentRun); err != nil {
 					return err
 				}
-				updatedRun, err := actions_model.GetRunByID(ctx, cRun.ID)
+				updatedRun, err := actions_model.GetRunByID(ctx, concurrentRun.ID)
 				if err != nil {
 					return err
 				}
@@ -103,21 +103,21 @@ func checkJobsByRunID(ctx context.Context, runID int64) error {
 				if err != nil {
 					return err
 				}
-				for _, cJob := range concurrentJobs {
-					if concurrentRunIDs.Contains(cJob.RunID) {
+				for _, concurrentJob := range concurrentJobs {
+					if concurrentRunIDs.Contains(concurrentJob.RunID) {
 						continue
 					}
-					cRun, err := actions_model.GetRunByID(ctx, cJob.RunID)
+					concurrentRun, err := actions_model.GetRunByID(ctx, concurrentJob.RunID)
 					if err != nil {
 						return err
 					}
-					if cRun.NeedApproval {
+					if concurrentRun.NeedApproval {
 						continue
 					}
-					if err := checkJobsOfRun(ctx, cRun); err != nil {
+					if err := checkJobsOfRun(ctx, concurrentRun); err != nil {
 						return err
 					}
-					updatedJob, err := actions_model.GetRunJobByID(ctx, cJob.ID)
+					updatedJob, err := actions_model.GetRunJobByID(ctx, concurrentJob.ID)
 					if err != nil {
 						return err
 					}
@@ -309,5 +309,5 @@ func checkConcurrencyForJobWithNeeds(ctx context.Context, actionRunJob *actions_
 		}
 	}
 
-	return actions_model.ShouldJobBeBlockedByConcurrentJobs(ctx, actionRunJob)
+	return actions_model.ShouldBlockJobByConcurreny(ctx, actionRunJob)
 }

services/actions/run.go

@@ -31,33 +31,13 @@ func InsertRun(ctx context.Context, run *actions_model.ActionRun, jobs []*jobpar
 	run.Index = index
 	run.Title = util.EllipsisDisplayString(run.Title, 255)
 
-	// check workflow concurrency
-	if len(run.ConcurrencyGroup) > 0 {
-		if run.ConcurrencyCancel {
-			if err := actions_model.CancelPreviousJobsWithOpts(ctx, &actions_model.FindRunOptions{
-				RepoID:           run.RepoID,
-				ConcurrencyGroup: run.ConcurrencyGroup,
-				Status: []actions_model.Status{
-					actions_model.StatusRunning,
-					actions_model.StatusWaiting,
-					actions_model.StatusBlocked,
-				},
-			}); err != nil {
-				return err
-			}
-		} else {
-			concurrentRunsNum, err := db.Count[actions_model.ActionRun](ctx, &actions_model.FindRunOptions{
-				RepoID:           run.RepoID,
-				ConcurrencyGroup: run.ConcurrencyGroup,
-				Status:           []actions_model.Status{actions_model.StatusWaiting, actions_model.StatusRunning},
-			})
-			if err != nil {
-				return err
-			}
-			if concurrentRunsNum > 0 {
-				run.Status = actions_model.StatusBlocked
-			}
-		}
+	// check run (workflow-level) concurrency
+	shouldBlockRunByConcurreny, err := actions_model.ShouldBlockRunByConcurreny(ctx, run)
+	if err != nil {
+		return err
+	}
+	if shouldBlockRunByConcurreny {
+		run.Status = actions_model.StatusBlocked
 	}
 
 	if err := db.Insert(ctx, run); err != nil {
@@ -125,7 +105,7 @@ func InsertRun(ctx context.Context, run *actions_model.ActionRun, jobs []*jobpar
 				}
 				runJob.IsConcurrencyEvaluated = true
 				// check if the job should be blocked by job concurrency
-				shouldBlock, err := actions_model.ShouldJobBeBlockedByConcurrentJobs(ctx, runJob)
+				shouldBlock, err := actions_model.ShouldBlockJobByConcurreny(ctx, runJob)
 				if err != nil {
 					return err
 				}