fine tune

Author: wxiaoguang

models/actions/run.go

@@ -391,19 +391,6 @@ func UpdateRun(ctx context.Context, run *ActionRun, cols ...string) error {
 
 type ActionRunIndex db.ResourceIndex
 
-func ShouldBlockRunByConcurrency(ctx context.Context, actionRun *ActionRun) (bool, error) {
-	if actionRun.ConcurrencyGroup == "" || actionRun.ConcurrencyCancel {
-		return false, nil
-	}
-
-	runs, jobs, err := GetConcurrentRunsAndJobs(ctx, actionRun.RepoID, actionRun.ConcurrencyGroup, []Status{StatusRunning})
-	if err != nil {
-		return false, fmt.Errorf("find concurrent runs and jobs: %w", err)
-	}
-
-	return len(runs) > 0 || len(jobs) > 0, nil
-}
-
 func GetConcurrentRunsAndJobs(ctx context.Context, repoID int64, concurrencyGroup string, status []Status) ([]*ActionRun, []*ActionRunJob, error) {
 	runs, err := db.Find[ActionRun](ctx, &FindRunOptions{
 		RepoID:           repoID,

models/actions/run_job.go

@@ -11,6 +11,7 @@ import (
 
 	"code.gitea.io/gitea/models/db"
 	repo_model "code.gitea.io/gitea/models/repo"
+	"code.gitea.io/gitea/modules/setting"
 	"code.gitea.io/gitea/modules/timeutil"
 	"code.gitea.io/gitea/modules/util"
 
@@ -213,27 +214,6 @@ func AggregateJobStatus(jobs []*ActionRunJob) Status {
 	}
 }
 
-func ShouldWaitJobForConcurrencyEvaluation(job *ActionRunJob) bool {
-	return job.RawConcurrency != "" && !job.IsConcurrencyEvaluated
-}
-
-func ShouldBlockJobByConcurrency(ctx context.Context, job *ActionRunJob) (bool, error) {
-	if ShouldWaitJobForConcurrencyEvaluation(job) {
-		panic("job concurrency not evaluated, this function shouldn't be called")
-	}
-
-	if job.ConcurrencyGroup == "" || job.ConcurrencyCancel {
-		return false, nil
-	}
-
-	runs, jobs, err := GetConcurrentRunsAndJobs(ctx, job.RepoID, job.ConcurrencyGroup, []Status{StatusRunning})
-	if err != nil {
-		return false, fmt.Errorf("GetConcurrentRunsAndJobs: %w", err)
-	}
-
-	return len(runs) > 0 || len(jobs) > 0, nil
-}
-
 func CancelPreviousJobsByJobConcurrency(ctx context.Context, job *ActionRunJob) (jobsToCancel []*ActionRunJob, _ error) {
 	if job.RawConcurrency == "" {
 		return nil, nil

routers/web/repo/actions/view.go

@@ -522,7 +522,7 @@ func rerunJob(ctx *context_module.Context, job *actions_model.ActionRunJob, shou
 		return fmt.Errorf("get run %d variables: %w", job.Run.ID, err)
 	}
 
-	if job.RawConcurrency != "" && job.Status != actions_model.StatusBlocked {
+	if job.RawConcurrency != "" && job.Status == actions_model.StatusWaiting {
 		err = actions_service.EvaluateJobConcurrencyAndFillJobModel(ctx, job.Run, job, vars)
 		if err != nil {
 			return fmt.Errorf("evaluate job concurrency: %w", err)

services/actions/clear_tasks.go

@@ -61,13 +61,28 @@ func CleanRepoScheduleTasks(ctx context.Context, repo *repo_model.Repository) er
 	return err
 }
 
-// PrepareToStartJobWithConcurrency prepares a job to start by evaluating its concurrency group and cancelling previous jobs if necessary.
+func shouldBlockJobByConcurrency(ctx context.Context, job *actions_model.ActionRunJob) (bool, error) {
+	if job.RawConcurrency != "" && !job.IsConcurrencyEvaluated {
+		// when the job depends on other jobs, we cannot evaluate its concurrency, so it should be blocked and will be evaluated again when its dependencies are done
+		return true, nil
+	}
+
+	if job.ConcurrencyGroup == "" || job.ConcurrencyCancel {
+		return false, nil
+	}
+
+	runs, jobs, err := actions_model.GetConcurrentRunsAndJobs(ctx, job.RepoID, job.ConcurrencyGroup, []actions_model.Status{actions_model.StatusRunning})
+	if err != nil {
+		return false, fmt.Errorf("GetConcurrentRunsAndJobs: %w", err)
+	}
+
+	return len(runs) > 0 || len(jobs) > 0, nil
+}
+
+// PrepareToStartJobWithConcurrency prepares a job to start by its evaluated concurrency group and cancelling previous jobs if necessary.
 // It returns the new status of the job (either StatusBlocked or StatusWaiting) and any error encountered during the process.
 func PrepareToStartJobWithConcurrency(ctx context.Context, job *actions_model.ActionRunJob) (actions_model.Status, error) {
-	if actions_model.ShouldWaitJobForConcurrencyEvaluation(job) {
-		return actions_model.StatusBlocked, nil
-	}
-	shouldBlock, err := actions_model.ShouldBlockJobByConcurrency(ctx, job)
+	shouldBlock, err := shouldBlockJobByConcurrency(ctx, job)
 	if err != nil {
 		return actions_model.StatusBlocked, err
 	}
@@ -79,10 +94,23 @@ func PrepareToStartJobWithConcurrency(ctx context.Context, job *actions_model.Ac
 	return actions_model.StatusWaiting, err
 }
 
+func shouldBlockRunByConcurrency(ctx context.Context, actionRun *actions_model.ActionRun) (bool, error) {
+	if actionRun.ConcurrencyGroup == "" || actionRun.ConcurrencyCancel {
+		return false, nil
+	}
+
+	runs, jobs, err := actions_model.GetConcurrentRunsAndJobs(ctx, actionRun.RepoID, actionRun.ConcurrencyGroup, []actions_model.Status{actions_model.StatusRunning})
+	if err != nil {
+		return false, fmt.Errorf("find concurrent runs and jobs: %w", err)
+	}
+
+	return len(runs) > 0 || len(jobs) > 0, nil
+}
+
 // PrepareToStartRunWithConcurrency prepares a run to start by its evaluated concurrency group and cancelling previous jobs if necessary.
 // It returns the new status of the job (either StatusBlocked or StatusWaiting) and any error encountered during the process.
 func PrepareToStartRunWithConcurrency(ctx context.Context, run *actions_model.ActionRun) (actions_model.Status, error) {
-	shouldBlock, err := actions_model.ShouldBlockRunByConcurrency(ctx, run)
+	shouldBlock, err := shouldBlockRunByConcurrency(ctx, run)
 	if err != nil {
 		return actions_model.StatusBlocked, err
 	}

services/actions/job_emitter.go

@@ -358,10 +358,6 @@ func (r *jobStatusResolver) resolve(ctx context.Context) map[int64]actions_model
 }
 
 func updateConcurrencyEvaluationForJobWithNeeds(ctx context.Context, actionRunJob *actions_model.ActionRunJob, vars map[string]string) error {
-	if !actions_model.ShouldWaitJobForConcurrencyEvaluation(actionRunJob) {
-		return nil
-	}
-
 	if err := actionRunJob.LoadAttributes(ctx); err != nil {
 		return err
 	}