Cleanup ActionRun creation

routers/api/actions/runner/runner.go

@@ -217,10 +217,7 @@ func (s *Service) UpdateTask(
 return nil, status.Errorf(codes.Internal, "load run: %v", err)
 }
 
-// don't create commit status for cron job
-if task.Job.Run.ScheduleID == 0 {
-actions_service.CreateCommitStatus(ctx, task.Job)
-}
+actions_service.CreateCommitStatusForRunJobs(ctx, task.Job.Run, task.Job)
 
 if task.Status.IsDone() {
 notify_service.WorkflowJobStatusUpdate(ctx, task.Job.Run.Repo, task.Job.Run.TriggerUser, task.Job, task)

routers/web/repo/actions/view.go

@@ -541,7 +541,7 @@ func rerunJob(ctx *context_module.Context, job *actions_model.ActionRunJob, shou
 return err
 }
 
-actions_service.CreateCommitStatus(ctx, job)
+actions_service.CreateCommitStatusForRunJobs(ctx, job.Run, job)
 notify_service.WorkflowJobStatusUpdate(ctx, job.Run.Repo, job.Run.TriggerUser, job, nil)
 
 return nil
@@ -569,7 +569,7 @@ func Logs(ctx *context_module.Context) {
 func Cancel(ctx *context_module.Context) {
 runIndex := getRunIndex(ctx)
 
-_, jobs := getRunJobs(ctx, runIndex, -1)
+firstJob, jobs := getRunJobs(ctx, runIndex, -1)
 if ctx.Written() {
 return
 }
@@ -588,7 +588,7 @@ func Cancel(ctx *context_module.Context) {
 return
 }
 
-actions_service.CreateCommitStatus(ctx, jobs...)
+actions_service.CreateCommitStatusForRunJobs(ctx, firstJob.Run, jobs...)
 actions_service.EmitJobsIfReadyByJobs(updatedJobs)
 
 for _, job := range updatedJobs {
@@ -642,7 +642,7 @@ func Approve(ctx *context_module.Context) {
 return
 }
 
-actions_service.CreateCommitStatus(ctx, jobs...)
+actions_service.CreateCommitStatusForRunJobs(ctx, current.Run, jobs...)
 
 if len(updatedJobs) > 0 {
 job := updatedJobs[0]

services/actions/clear_tasks.go

@@ -37,13 +37,19 @@ func StopEndlessTasks(ctx context.Context) error {
 }
 
 func notifyWorkflowJobStatusUpdate(ctx context.Context, jobs []*actions_model.ActionRunJob) {
-if len(jobs) > 0 {
-CreateCommitStatus(ctx, jobs...)
-for _, job := range jobs {
-_ = job.LoadAttributes(ctx)
-notify_service.WorkflowJobStatusUpdate(ctx, job.Run.Repo, job.Run.TriggerUser, job, nil)
+if len(jobs) == 0 {
+return
+}
+for _, job := range jobs {
+if err := job.LoadAttributes(ctx); err != nil {
+log.Error("Failed to load job attributes: %v", err)
+continue
 }
-job := jobs[0]
+CreateCommitStatusForRunJobs(ctx, job.Run, job)
+notify_service.WorkflowJobStatusUpdate(ctx, job.Run.Repo, job.Run.TriggerUser, job, nil)
+}
+
+if job := jobs[0]; job.Run != nil && job.Run.Repo != nil {
 notify_service.WorkflowRunStatusUpdate(ctx, job.Run.Repo, job.Run.TriggerUser, job.Run)
 }
 }
@@ -208,7 +214,10 @@ func CancelAbandonedJobs(ctx context.Context) error {
 log.Warn("cancel abandoned job %v: %v", job.ID, err)
 // go on
 }
-CreateCommitStatus(ctx, job)
+if job.Run == nil || job.Run.Repo == nil {
+continue // error occurs during loading attributes, the following code that depends on "Run.Repo" will fail, so ignore and skip
+}
+CreateCommitStatusForRunJobs(ctx, job.Run, job)
 if updated {
 updatedJobs = append(updatedJobs, job)
 notify_service.WorkflowJobStatusUpdate(ctx, job.Run.Repo, job.Run.TriggerUser, job, nil)

services/actions/commit_status.go

@@ -8,53 +8,62 @@ import (
 "errors"
 "fmt"
 "path"
+"strconv"
 
 actions_model "code.gitea.io/gitea/models/actions"
 "code.gitea.io/gitea/models/db"
 git_model "code.gitea.io/gitea/models/git"
+repo_model "code.gitea.io/gitea/models/repo"
 user_model "code.gitea.io/gitea/models/user"
 actions_module "code.gitea.io/gitea/modules/actions"
 "code.gitea.io/gitea/modules/commitstatus"
-git "code.gitea.io/gitea/modules/git"
 "code.gitea.io/gitea/modules/log"
 webhook_module "code.gitea.io/gitea/modules/webhook"
 commitstatus_service "code.gitea.io/gitea/services/repository/commitstatus"
 
 "github.com/nektos/act/pkg/jobparser"
 )
 
-// CreateCommitStatus creates a commit status for the given job.
+// CreateCommitStatusForRunJobs creates a commit status for the given job if it has a supported event and related commit.
 // It won't return an error failed, but will log it, because it's not critical.
-func CreateCommitStatus(ctx context.Context, jobs ...*actions_model.ActionRunJob) {
+func CreateCommitStatusForRunJobs(ctx context.Context, run *actions_model.ActionRun, jobs ...*actions_model.ActionRunJob) {
+// don't create commit status for cron job
+if run.ScheduleID != 0 {
+return
+}
+
+event, commitID, err := getCommitStatusEventNameAndCommitID(run)
+if err != nil {
+log.Error("GetCommitStatusEventNameAndSHA: %v", err)
+}
+if event == "" || commitID == "" {
+return // unsupported event, or no commit id, or error occurs, do nothing
+}
+
+if err = run.LoadAttributes(ctx); err != nil {
+log.Error("run.LoadAttributes: %v", err)
+return
+}
+
 for _, job := range jobs {
-if err := createCommitStatus(ctx, job); err != nil {
+if err = createCommitStatus(ctx, run.Repo, event, commitID, run, job); err != nil {
 log.Error("Failed to create commit status for job %d: %v", job.ID, err)
 }
 }
 }
 
-func createCommitStatus(ctx context.Context, job *actions_model.ActionRunJob) error {
-if err := job.LoadAttributes(ctx); err != nil {
-return fmt.Errorf("load run: %w", err)
-}
-
-run := job.Run
-
-var (
-sha string
-event string
-)
+func getCommitStatusEventNameAndCommitID(run *actions_model.ActionRun) (event, commitID string, _ error) {
 switch run.Event {
 case webhook_module.HookEventPush:
 event = "push"
 payload, err := run.GetPushEventPayload()
 if err != nil {
-return fmt.Errorf("GetPushEventPayload: %w", err)
+return "", "", fmt.Errorf("GetPushEventPayload: %w", err)
 }
 if payload.HeadCommit == nil {
-return errors.New("head commit is missing in event payload")
+return "", "", errors.New("head commit is missing in event payload")
 }
-sha = payload.HeadCommit.ID
+commitID = payload.HeadCommit.ID
 case // pull_request
 webhook_module.HookEventPullRequest,
 webhook_module.HookEventPullRequestSync,
@@ -69,32 +78,33 @@ func createCommitStatus(ctx context.Context, job *actions_model.ActionRunJob) er
 }
 payload, err := run.GetPullRequestEventPayload()
 if err != nil {
-return fmt.Errorf("GetPullRequestEventPayload: %w", err)
+return "", "", fmt.Errorf("GetPullRequestEventPayload: %w", err)
 }
 if payload.PullRequest == nil {
-return errors.New("pull request is missing in event payload")
+return "", "", errors.New("pull request is missing in event payload")
 } else if payload.PullRequest.Head == nil {
-return errors.New("head of pull request is missing in event payload")
+return "", "", errors.New("head of pull request is missing in event payload")
 }
-sha = payload.PullRequest.Head.Sha
+commitID = payload.PullRequest.Head.Sha
 case webhook_module.HookEventRelease:
 event = string(run.Event)
-sha = run.CommitSHA
-default:
-return nil
+commitID = run.CommitSHA
+default: // do nothing, return empty
 }
+return event, commitID, nil
+}
 
-repo := run.Repo
+func createCommitStatus(ctx context.Context, repo *repo_model.Repository, event, commitID string, run *actions_model.ActionRun, job *actions_model.ActionRunJob) error {
 // TODO: store workflow name as a field in ActionRun to avoid parsing
 runName := path.Base(run.WorkflowID)
 if wfs, err := jobparser.Parse(job.WorkflowPayload); err == nil && len(wfs) > 0 {
 runName = wfs[0].Name
 }
-ctxname := fmt.Sprintf("%s / %s (%s)", runName, job.Name, event)
+ctxName := fmt.Sprintf("%s / %s (%s)", runName, job.Name, event)
 state := toCommitStatus(job.Status)
-if statuses, err := git_model.GetLatestCommitStatus(ctx, repo.ID, sha, db.ListOptionsAll); err == nil {
+if statuses, err := git_model.GetLatestCommitStatus(ctx, repo.ID, commitID, db.ListOptionsAll); err == nil {
 for _, v := range statuses {
-if v.Context == ctxname {
+if v.Context == ctxName {
 if v.State == state {
 // no need to update
 return nil
@@ -106,7 +116,7 @@ func createCommitStatus(ctx context.Context, job *actions_model.ActionRunJob) er
 return fmt.Errorf("GetLatestCommitStatus: %w", err)
 }
 
-description := ""
+var description string
 switch job.Status {
 // TODO: if we want support description in different languages, we need to support i18n placeholders in it
 case actions_model.StatusSuccess:
@@ -123,6 +133,8 @@ func createCommitStatus(ctx context.Context, job *actions_model.ActionRunJob) er
 description = "Waiting to run"
 case actions_model.StatusBlocked:
 description = "Blocked by required conditions"
+default:
+description = "Unknown status: " + strconv.Itoa(int(job.Status))
 }
 
 index, err := getIndexOfJob(ctx, job)
@@ -131,20 +143,16 @@ func createCommitStatus(ctx context.Context, job *actions_model.ActionRunJob) er
 }
 
 creator := user_model.NewActionsUser()
-commitID, err := git.NewIDFromString(sha)
-if err != nil {
-return fmt.Errorf("HashTypeInterfaceFromHashString: %w", err)
-}
 status := git_model.CommitStatus{
-SHA: sha,
+SHA: commitID,
 TargetURL: fmt.Sprintf("%s/jobs/%d", run.Link(), index),
 Description: description,
-Context: ctxname,
+Context: ctxName,
 CreatorID: creator.ID,
 State: state,
 }
 
-return commitstatus_service.CreateCommitStatus(ctx, repo, creator, commitID.String(), &status)
+return commitstatus_service.CreateCommitStatus(ctx, repo, creator, commitID, &status)
 }
 
 func toCommitStatus(status actions_model.Status) commitstatus.CommitStatusState {

services/actions/job_emitter.go

@@ -89,7 +89,7 @@ func checkJobsByRunID(ctx context.Context, runID int64) error {
 }); err != nil {
 return err
 }
-CreateCommitStatus(ctx, jobs...)
+CreateCommitStatusForRunJobs(ctx, run, jobs...)
 for _, job := range updatedJobs {
 _ = job.LoadAttributes(ctx)
 notify_service.WorkflowJobStatusUpdate(ctx, job.Run.Repo, job.Run.TriggerUser, job, nil)

services/actions/notifier_helper.go

@@ -27,9 +27,7 @@ import (
 api "code.gitea.io/gitea/modules/structs"
 webhook_module "code.gitea.io/gitea/modules/webhook"
 "code.gitea.io/gitea/services/convert"
-notify_service "code.gitea.io/gitea/services/notify"
 
-"github.com/nektos/act/pkg/jobparser"
 "github.com/nektos/act/pkg/model"
 )
 
@@ -346,65 +344,10 @@ func handleWorkflows(
 
 run.NeedApproval = need
 
-if err := run.LoadAttributes(ctx); err != nil {
-log.Error("LoadAttributes: %v", err)
+if err := PrepareRunAndInsert(ctx, dwf.Content, run, nil); err != nil {
+log.Error("PrepareRunAndInsert: %v", err)
 continue
 }
-
-vars, err := actions_model.GetVariablesOfRun(ctx, run)
-if err != nil {
-log.Error("GetVariablesOfRun: %v", err)
-continue
-}
-
-wfRawConcurrency, err := jobparser.ReadWorkflowRawConcurrency(dwf.Content)
-if err != nil {
-log.Error("ReadWorkflowRawConcurrency: %v", err)
-continue
-}
-if wfRawConcurrency != nil {
-err = EvaluateRunConcurrencyFillModel(ctx, run, wfRawConcurrency, vars)
-if err != nil {
-log.Error("EvaluateRunConcurrencyFillModel: %v", err)
-continue
-}
-}
-
-giteaCtx := GenerateGiteaContext(run, nil)
-
-jobs, err := jobparser.Parse(dwf.Content, jobparser.WithVars(vars), jobparser.WithGitContext(giteaCtx.ToGitHubContext()))
-if err != nil {
-log.Error("jobparser.Parse: %v", err)
-continue
-}
-
-if len(jobs) > 0 && jobs[0].RunName != "" {
-run.Title = jobs[0].RunName
-}
-
-if err := InsertRun(ctx, run, jobs); err != nil {
-log.Error("InsertRun: %v", err)
-continue
-}
-
-alljobs, err := db.Find[actions_model.ActionRunJob](ctx, actions_model.FindRunJobOptions{RunID: run.ID})
-if err != nil {
-log.Error("FindRunJobs: %v", err)
-continue
-}
-CreateCommitStatus(ctx, alljobs...)
-if len(alljobs) > 0 {
-job := alljobs[0]
-err := job.LoadRun(ctx)
-if err != nil {
-log.Error("LoadRun: %v", err)
-continue
-}
-notify_service.WorkflowRunStatusUpdate(ctx, job.Run.Repo, job.Run.TriggerUser, job.Run)
-}
-for _, job := range alljobs {
-notify_service.WorkflowJobStatusUpdate(ctx, input.Repo, input.Doer, job, nil)
-}
 }
 return nil
 }
@@ -559,24 +502,6 @@ func handleSchedules(
 Content: dwf.Content,
 }
 
-vars, err := actions_model.GetVariablesOfRun(ctx, run.ToActionRun())
-if err != nil {
-log.Error("GetVariablesOfRun: %v", err)
-continue
-}
-
-giteaCtx := GenerateGiteaContext(run.ToActionRun(), nil)
-
-jobs, err := jobparser.Parse(dwf.Content, jobparser.WithVars(vars), jobparser.WithGitContext(giteaCtx.ToGitHubContext()))
-if err != nil {
-log.Error("jobparser.Parse: %v", err)
-continue
-}
-
-if len(jobs) > 0 && jobs[0].RunName != "" {
-run.Title = jobs[0].RunName
-}
-
 crons = append(crons, run)
 }