Introduce ActionRunAttempt to represent each execution of a run (#37119)

This PR introduces a new `ActionRunAttempt` model and makes Actions
execution attempt-scoped.

**Main Changes**

- Each workflow run trigger generates a new `ActionRunAttempt`. The
triggered jobs are then associated with this new `ActionRunAttempt`
record.
- Each rerun now creates:
  - a new `ActionRunAttempt` record for the workflow run
- a full new set of `ActionRunJob` records for the new
`ActionRunAttempt`
- For jobs that need to be rerun, the new job records are created as
runnable jobs in the new attempt.
- For jobs that do not need to be rerun, new job records are still
created in the new attempt, but they reuse the result of the previous
attempt instead of executing again.
- Introduce `rerunPlan` to manage each rerun and refactored rerun flow
into a two-phase plan-based model:
  - `buildRerunPlan`
  - `execRerunPlan`
- `RerunFailedWorkflowRun` and `RerunFailed` no longer directly derives
all jobs that need to be rerun; this step is now handled by
`buildRerunPlan`.
- Converted artifacts from run-scoped to attempt-scoped:
  - uploads are now associated with `RunAttemptID`
  - listing, download, and deletion resolve against the current attempt
- Added attempt-aware web Actions views:
- the default run page shows the latest attempt
(`/actions/runs/{run_id}`)
- previous attempt pages show jobs and artifacts for that attempt
(`/actions/runs/{run_id}/attempts/{attempt_num}`)
- New APIs:
  - `/repos/{owner}/{repo}/actions/runs/{run}/attempts/{attempt}`
  - `/repos/{owner}/{repo}/actions/runs/{run}/attempts/{attempt}/jobs`
- New configuration `MAX_RERUN_ATTEMPTS`
  - https://gitea.com/gitea/docs/pulls/383

**Compatibility**

- Existing legacy runs use `LatestAttemptID = 0` and legacy jobs use
`RunAttemptID = 0`. Therefore, these fields can be used to identify
legacy runs and jobs and provide backward compatibility.
- If a legacy run is rerun, an `ActionRunAttempt` with `attempt=1` will
be created to represent the original execution. Then a new
`ActionRunAttempt` with `attempt=2` will be created for the real rerun.
- Existing artifact records are not backfilled; legacy artifacts
continue to use `RunAttemptID = 0`.

**Improvements**

- It is now easier to inspect and download logs from previous attempts.
-
[`run_attempt`](https://docs.github.com/en/actions/reference/workflows-and-actions/contexts#github-context)
semantics are now aligned with GitHub.
- > A unique number for each attempt of a particular workflow run in a
repository. This number begins at 1 for the workflow run's first
attempt, and increments with each re-run.
- Rerun behavior is now clearer and more explicit.
- Instead of mutating the status of previous jobs in place, each rerun
creates a new attempt with a full new set of job records.
- Artifacts produced by different reruns can now be listed separately.

Signed-off-by: Zettat123 <zettat123@gmail.com>
Co-authored-by: silverwind <me@silverwind.io>
Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>
Co-authored-by: wxiaoguang <wxiaoguang@gmail.com>
Co-authored-by: Giteabot <teabot@gitea.io>

services/actions/rerun_test.go

@@ -4,54 +4,17 @@
 package actions
 
 import (
-	"context"
 	"testing"
 
 	actions_model "code.gitea.io/gitea/models/actions"
+	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/util"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
-func TestGetAllRerunJobs(t *testing.T) {
-	job1 := &actions_model.ActionRunJob{JobID: "job1"}
-	job2 := &actions_model.ActionRunJob{JobID: "job2", Needs: []string{"job1"}}
-	job3 := &actions_model.ActionRunJob{JobID: "job3", Needs: []string{"job2"}}
-	job4 := &actions_model.ActionRunJob{JobID: "job4", Needs: []string{"job2", "job3"}}
-
-	jobs := []*actions_model.ActionRunJob{job1, job2, job3, job4}
-
-	testCases := []struct {
-		job       *actions_model.ActionRunJob
-		rerunJobs []*actions_model.ActionRunJob
-	}{
-		{
-			job1,
-			[]*actions_model.ActionRunJob{job1, job2, job3, job4},
-		},
-		{
-			job2,
-			[]*actions_model.ActionRunJob{job2, job3, job4},
-		},
-		{
-			job3,
-			[]*actions_model.ActionRunJob{job3, job4},
-		},
-		{
-			job4,
-			[]*actions_model.ActionRunJob{job4},
-		},
-	}
-
-	for _, tc := range testCases {
-		rerunJobs := GetAllRerunJobs(tc.job, jobs)
-		assert.ElementsMatch(t, tc.rerunJobs, rerunJobs)
-	}
-}
-
-func TestGetFailedRerunJobs(t *testing.T) {
-	// IDs must be non-zero to distinguish jobs in the dedup set.
+func TestGetFailedJobsForRerun(t *testing.T) {
 	makeJob := func(id int64, jobID string, status actions_model.Status, needs ...string) *actions_model.ActionRunJob {
 		return &actions_model.ActionRunJob{ID: id, JobID: jobID, Status: status, Needs: needs}
 	}
@@ -61,7 +24,7 @@ func TestGetFailedRerunJobs(t *testing.T) {
 			makeJob(1, "job1", actions_model.StatusSuccess),
 			makeJob(2, "job2", actions_model.StatusSkipped, "job1"),
 		}
-		assert.Empty(t, GetFailedRerunJobs(jobs))
+		assert.Empty(t, GetFailedJobsForRerun(jobs))
 	})
 
 	t.Run("single failed job with no dependents", func(t *testing.T) {
@@ -69,56 +32,50 @@ func TestGetFailedRerunJobs(t *testing.T) {
 		job2 := makeJob(2, "job2", actions_model.StatusSuccess)
 		jobs := []*actions_model.ActionRunJob{job1, job2}
 
-		result := GetFailedRerunJobs(jobs)
+		result := GetFailedJobsForRerun(jobs)
 		assert.ElementsMatch(t, []*actions_model.ActionRunJob{job1}, result)
 	})
 
-	t.Run("failed job pulls in downstream dependents", func(t *testing.T) {
-		// job1 failed; job2 depends on job1 (skipped); job3 depends on job2 (skipped)
+	t.Run("failed job does not pull in downstream dependents", func(t *testing.T) {
 		job1 := makeJob(1, "job1", actions_model.StatusFailure)
 		job2 := makeJob(2, "job2", actions_model.StatusSkipped, "job1")
 		job3 := makeJob(3, "job3", actions_model.StatusSkipped, "job2")
 		job4 := makeJob(4, "job4", actions_model.StatusSuccess) // unrelated, must not appear
 		jobs := []*actions_model.ActionRunJob{job1, job2, job3, job4}
 
-		result := GetFailedRerunJobs(jobs)
-		assert.ElementsMatch(t, []*actions_model.ActionRunJob{job1, job2, job3}, result)
+		result := GetFailedJobsForRerun(jobs)
+		assert.ElementsMatch(t, []*actions_model.ActionRunJob{job1}, result)
 	})
 
-	t.Run("multiple independent failed jobs each pull in their own dependents", func(t *testing.T) {
-		// job1 failed -> job3 depends on job1
-		// job2 failed -> job4 depends on job2
+	t.Run("multiple failed jobs are returned directly", func(t *testing.T) {
 		job1 := makeJob(1, "job1", actions_model.StatusFailure)
 		job2 := makeJob(2, "job2", actions_model.StatusFailure)
 		job3 := makeJob(3, "job3", actions_model.StatusSkipped, "job1")
 		job4 := makeJob(4, "job4", actions_model.StatusSkipped, "job2")
 		jobs := []*actions_model.ActionRunJob{job1, job2, job3, job4}
 
-		result := GetFailedRerunJobs(jobs)
-		assert.ElementsMatch(t, []*actions_model.ActionRunJob{job1, job2, job3, job4}, result)
+		result := GetFailedJobsForRerun(jobs)
+		assert.ElementsMatch(t, []*actions_model.ActionRunJob{job1, job2}, result)
 	})
 
-	t.Run("shared downstream dependent is not duplicated", func(t *testing.T) {
-		// job1 and job2 both failed; job3 depends on both
+	t.Run("shared downstream dependent is not included", func(t *testing.T) {
 		job1 := makeJob(1, "job1", actions_model.StatusFailure)
 		job2 := makeJob(2, "job2", actions_model.StatusFailure)
 		job3 := makeJob(3, "job3", actions_model.StatusSkipped, "job1", "job2")
 		jobs := []*actions_model.ActionRunJob{job1, job2, job3}
 
-		result := GetFailedRerunJobs(jobs)
-		assert.ElementsMatch(t, []*actions_model.ActionRunJob{job1, job2, job3}, result)
-		assert.Len(t, result, 3) // job3 must appear exactly once
+		result := GetFailedJobsForRerun(jobs)
+		assert.ElementsMatch(t, []*actions_model.ActionRunJob{job1, job2}, result)
+		assert.Len(t, result, 2)
 	})
 
-	t.Run("successful downstream job of a failed job is still included", func(t *testing.T) {
-		// job1 failed; job2 succeeded but depends on job1 — downstream is always rerun
-		// regardless of its own status (GetAllRerunJobs includes all transitive dependents)
+	t.Run("successful downstream job of a failed job is not included", func(t *testing.T) {
 		job1 := makeJob(1, "job1", actions_model.StatusFailure)
 		job2 := makeJob(2, "job2", actions_model.StatusSuccess, "job1")
 		jobs := []*actions_model.ActionRunJob{job1, job2}
 
-		result := GetFailedRerunJobs(jobs)
-		assert.ElementsMatch(t, []*actions_model.ActionRunJob{job1, job2}, result)
+		result := GetFailedJobsForRerun(jobs)
+		assert.ElementsMatch(t, []*actions_model.ActionRunJob{job1}, result)
 	})
 }
 
@@ -129,7 +86,7 @@ func TestRerunValidation(t *testing.T) {
 		jobs := []*actions_model.ActionRunJob{
 			{ID: 1, JobID: "job1"},
 		}
-		err := RerunWorkflowRunJobs(context.Background(), nil, runningRun, jobs)
+		_, err := RerunWorkflowRunJobs(t.Context(), nil, runningRun, &user_model.User{ID: 1}, jobs)
 		require.Error(t, err)
 		assert.ErrorIs(t, err, util.ErrInvalidArgument)
 	})
@@ -138,7 +95,7 @@ func TestRerunValidation(t *testing.T) {
 		jobs := []*actions_model.ActionRunJob{
 			{ID: 1, JobID: "job1", Status: actions_model.StatusFailure},
 		}
-		err := RerunWorkflowRunJobs(context.Background(), nil, runningRun, GetFailedRerunJobs(jobs))
+		_, err := RerunWorkflowRunJobs(t.Context(), nil, runningRun, &user_model.User{ID: 1}, GetFailedJobsForRerun(jobs))
 		require.Error(t, err)
 		assert.ErrorIs(t, err, util.ErrInvalidArgument)
 	})