From 3ab8ae5807775a81069005a5abbd20bacfa0a15f Mon Sep 17 00:00:00 2001 From: Zettat123 Date: Wed, 29 Oct 2025 19:08:59 -0600 Subject: [PATCH] Fix actions rerun bug (#35783) Related issues: #35780, #35782 Rerunning a job or a run is only allowed when the job is done and the run is done. Related PR: #34970 --- routers/web/repo/actions/view.go | 94 ++++++++++--------- tests/integration/actions_rerun_test.go | 118 ++++++++++++++++++++++++ 2 files changed, 166 insertions(+), 46 deletions(-) create mode 100644 tests/integration/actions_rerun_test.go diff --git a/routers/web/repo/actions/view.go b/routers/web/repo/actions/view.go index f7e57c91a8..cc70cd4e06 100644 --- a/routers/web/repo/actions/view.go +++ b/routers/web/repo/actions/view.go @@ -412,6 +412,12 @@ func Rerun(ctx *context_module.Context) { return } + // rerun is not allowed if the run is not done + if !run.Status.IsDone() { + ctx.JSONError(ctx.Locale.Tr("actions.runs.not_done")) + return + } + // can not rerun job when workflow is disabled cfgUnit := ctx.Repo.Repository.MustGetUnit(ctx, unit.TypeActions) cfg := cfgUnit.ActionsConfig() @@ -420,57 +426,53 @@ func Rerun(ctx *context_module.Context) { return } - // check run (workflow-level) concurrency + // reset run's start and stop time + run.PreviousDuration = run.Duration() + run.Started = 0 + run.Stopped = 0 + run.Status = actions_model.StatusWaiting + + vars, err := actions_model.GetVariablesOfRun(ctx, run) + if err != nil { + ctx.ServerError("GetVariablesOfRun", fmt.Errorf("get run %d variables: %w", run.ID, err)) + return + } + + if run.RawConcurrency != "" { + var rawConcurrency model.RawConcurrency + if err := yaml.Unmarshal([]byte(run.RawConcurrency), &rawConcurrency); err != nil { + ctx.ServerError("UnmarshalRawConcurrency", fmt.Errorf("unmarshal raw concurrency: %w", err)) + return + } + + err = actions_service.EvaluateRunConcurrencyFillModel(ctx, run, &rawConcurrency, vars) + if err != nil { + ctx.ServerError("EvaluateRunConcurrencyFillModel", err) + return + } + + run.Status, err = actions_service.PrepareToStartRunWithConcurrency(ctx, run) + if err != nil { + ctx.ServerError("PrepareToStartRunWithConcurrency", err) + return + } + } + if err := actions_model.UpdateRun(ctx, run, "started", "stopped", "previous_duration", "status", "concurrency_group", "concurrency_cancel"); err != nil { + ctx.ServerError("UpdateRun", err) + return + } + + if err := run.LoadAttributes(ctx); err != nil { + ctx.ServerError("run.LoadAttributes", err) + return + } + notify_service.WorkflowRunStatusUpdate(ctx, run.Repo, run.TriggerUser, run) job, jobs := getRunJobs(ctx, runIndex, jobIndex) if ctx.Written() { return } - // reset run's start and stop time when it is done - if run.Status.IsDone() { - run.PreviousDuration = run.Duration() - run.Started = 0 - run.Stopped = 0 - run.Status = actions_model.StatusWaiting - - vars, err := actions_model.GetVariablesOfRun(ctx, run) - if err != nil { - ctx.ServerError("GetVariablesOfRun", fmt.Errorf("get run %d variables: %w", run.ID, err)) - return - } - - if run.RawConcurrency != "" { - var rawConcurrency model.RawConcurrency - if err := yaml.Unmarshal([]byte(run.RawConcurrency), &rawConcurrency); err != nil { - ctx.ServerError("UnmarshalRawConcurrency", fmt.Errorf("unmarshal raw concurrency: %w", err)) - return - } - - err = actions_service.EvaluateRunConcurrencyFillModel(ctx, run, &rawConcurrency, vars) - if err != nil { - ctx.ServerError("EvaluateRunConcurrencyFillModel", err) - return - } - - run.Status, err = actions_service.PrepareToStartRunWithConcurrency(ctx, run) - if err != nil { - ctx.ServerError("PrepareToStartRunWithConcurrency", err) - return - } - } - if err := actions_model.UpdateRun(ctx, run, "started", "stopped", "previous_duration", "status", "concurrency_group", "concurrency_cancel"); err != nil { - ctx.ServerError("UpdateRun", err) - return - } - - if err := run.LoadAttributes(ctx); err != nil { - ctx.ServerError("run.LoadAttributes", err) - return - } - notify_service.WorkflowRunStatusUpdate(ctx, run.Repo, run.TriggerUser, run) - } - isRunBlocked := run.Status == actions_model.StatusBlocked if jobIndexStr == "" { // rerun all jobs for _, j := range jobs { @@ -501,7 +503,7 @@ func Rerun(ctx *context_module.Context) { func rerunJob(ctx *context_module.Context, job *actions_model.ActionRunJob, shouldBlock bool) error { status := job.Status - if !status.IsDone() || !job.Run.Status.IsDone() { + if !status.IsDone() { return nil } diff --git a/tests/integration/actions_rerun_test.go b/tests/integration/actions_rerun_test.go new file mode 100644 index 0000000000..690d661e6c --- /dev/null +++ b/tests/integration/actions_rerun_test.go @@ -0,0 +1,118 @@ +// Copyright 2025 The Gitea Authors. All rights reserved. +// SPDX-License-Identifier: MIT + +package integration + +import ( + "fmt" + "net/http" + "net/url" + "testing" + + auth_model "code.gitea.io/gitea/models/auth" + repo_model "code.gitea.io/gitea/models/repo" + "code.gitea.io/gitea/models/unittest" + user_model "code.gitea.io/gitea/models/user" + + runnerv1 "code.gitea.io/actions-proto-go/runner/v1" +) + +func TestActionsRerun(t *testing.T) { + onGiteaRun(t, func(t *testing.T, u *url.URL) { + user2 := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2}) + session := loginUser(t, user2.Name) + token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser) + + apiRepo := createActionsTestRepo(t, token, "actions-rerun", false) + repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: apiRepo.ID}) + httpContext := NewAPITestContext(t, user2.Name, repo.Name, auth_model.AccessTokenScopeWriteRepository) + defer doAPIDeleteRepository(httpContext)(t) + + runner := newMockRunner() + runner.registerAsRepoRunner(t, repo.OwnerName, repo.Name, "mock-runner", []string{"ubuntu-latest"}, false) + + wfTreePath := ".gitea/workflows/actions-rerun-workflow-1.yml" + wfFileContent := `name: actions-rerun-workflow-1 +on: + push: + paths: + - '.gitea/workflows/actions-rerun-workflow-1.yml' +jobs: + job1: + runs-on: ubuntu-latest + steps: + - run: echo 'job1' + job2: + runs-on: ubuntu-latest + needs: [job1] + steps: + - run: echo 'job2' +` + + opts := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create"+wfTreePath, wfFileContent) + createWorkflowFile(t, token, user2.Name, repo.Name, wfTreePath, opts) + + // fetch and exec job1 + job1Task := runner.fetchTask(t) + _, _, run := getTaskAndJobAndRunByTaskID(t, job1Task.Id) + runner.execTask(t, job1Task, &mockTaskOutcome{ + result: runnerv1.Result_RESULT_SUCCESS, + }) + // RERUN-FAILURE: the run is not done + req := NewRequestWithValues(t, "POST", fmt.Sprintf("/%s/%s/actions/runs/%d/rerun", user2.Name, repo.Name, run.Index), map[string]string{ + "_csrf": GetUserCSRFToken(t, session), + }) + session.MakeRequest(t, req, http.StatusBadRequest) + // fetch and exec job2 + job2Task := runner.fetchTask(t) + runner.execTask(t, job2Task, &mockTaskOutcome{ + result: runnerv1.Result_RESULT_SUCCESS, + }) + + // RERUN-1: rerun the run + req = NewRequestWithValues(t, "POST", fmt.Sprintf("/%s/%s/actions/runs/%d/rerun", user2.Name, repo.Name, run.Index), map[string]string{ + "_csrf": GetUserCSRFToken(t, session), + }) + session.MakeRequest(t, req, http.StatusOK) + // fetch and exec job1 + job1TaskR1 := runner.fetchTask(t) + runner.execTask(t, job1TaskR1, &mockTaskOutcome{ + result: runnerv1.Result_RESULT_SUCCESS, + }) + // fetch and exec job2 + job2TaskR1 := runner.fetchTask(t) + runner.execTask(t, job2TaskR1, &mockTaskOutcome{ + result: runnerv1.Result_RESULT_SUCCESS, + }) + + // RERUN-2: rerun job1 + req = NewRequestWithValues(t, "POST", fmt.Sprintf("/%s/%s/actions/runs/%d/jobs/%d/rerun", user2.Name, repo.Name, run.Index, 0), map[string]string{ + "_csrf": GetUserCSRFToken(t, session), + }) + session.MakeRequest(t, req, http.StatusOK) + // job2 needs job1, so rerunning job1 will also rerun job2 + // fetch and exec job1 + job1TaskR2 := runner.fetchTask(t) + runner.execTask(t, job1TaskR2, &mockTaskOutcome{ + result: runnerv1.Result_RESULT_SUCCESS, + }) + // fetch and exec job2 + job2TaskR2 := runner.fetchTask(t) + runner.execTask(t, job2TaskR2, &mockTaskOutcome{ + result: runnerv1.Result_RESULT_SUCCESS, + }) + + // RERUN-3: rerun job2 + req = NewRequestWithValues(t, "POST", fmt.Sprintf("/%s/%s/actions/runs/%d/jobs/%d/rerun", user2.Name, repo.Name, run.Index, 1), map[string]string{ + "_csrf": GetUserCSRFToken(t, session), + }) + session.MakeRequest(t, req, http.StatusOK) + // only job2 will rerun + // fetch and exec job2 + job2TaskR3 := runner.fetchTask(t) + runner.execTask(t, job2TaskR3, &mockTaskOutcome{ + result: runnerv1.Result_RESULT_SUCCESS, + }) + runner.fetchNoTask(t) + }) +}