Introduce `ActionRunAttempt` to represent each execution of a run #37119

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged

silverwind merged 167 commits into go-gitea:main from Zettat123:run-attempt

Apr 23, 2026

custom/conf/app.example.ini

-Original file line number
+Diff line change
@@ Expand Up / @@ -2973,6 +2973,8 @@ LEVEL = Info @@
     ;; Comma-separated list of workflow directories, the first one to exist
     ;; in a repo is used to find Actions workflow files
     ;WORKFLOW_DIRS = .gitea/workflows,.github/workflows
+    ;; Maximum number of attempts a single workflow run can have. Default value is 50.
+    ;MAX_RERUN_ATTEMPTS = 50
     ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ Expand Down @@

models/actions/artifact.go

            
                      Original file line number
                      Diff line number
                      Diff line change
                  
    @@ -12,6 +12,7 @@ import (
  
    	"time"

    	"code.gitea.io/gitea/models/db"

    	"code.gitea.io/gitea/modules/optional"

    	"code.gitea.io/gitea/modules/timeutil"

    	"code.gitea.io/gitea/modules/util"

    @@ -61,7 +62,8 @@ const (
  
    // ActionArtifact is a file that is stored in the artifact storage.

    type ActionArtifact struct {

    	ID                 int64 `xorm:"pk autoincr"`

    	RunID              int64 `xorm:"index unique(runid_name_path)"` // The run id of the artifact

    	RunID              int64 `xorm:"index unique(runid_attempt_name_path)"` // The run id of the artifact

    	RunAttemptID       int64 `xorm:"index unique(runid_attempt_name_path) NOT NULL DEFAULT 0"`

    	RunnerID           int64

    	RepoID             int64 `xorm:"index"`

    	OwnerID            int64

    @@ -80,9 +82,9 @@ type ActionArtifact struct {
  
    	//   * "application/pdf", "text/html", etc.: real content type of the artifact

    	ContentEncodingOrType string `xorm:"content_encoding"`

    	ArtifactPath string             `xorm:"index unique(runid_name_path)"` // The path to the artifact when runner uploads it

    	ArtifactName string             `xorm:"index unique(runid_name_path)"` // The name of the artifact when runner uploads it

    	Status       ArtifactStatus     `xorm:"index"`                         // The status of the artifact, uploading, expired or need-delete

    	ArtifactPath string             `xorm:"index unique(runid_attempt_name_path)"` // The path to the artifact when runner uploads it

    	ArtifactName string             `xorm:"index unique(runid_attempt_name_path)"` // The name of the artifact when runner uploads it

    	Status       ArtifactStatus     `xorm:"index"`                                 // The status of the artifact, uploading, expired or need-delete

    	CreatedUnix  timeutil.TimeStamp `xorm:"created"`

    	UpdatedUnix  timeutil.TimeStamp `xorm:"updated index"`

    	ExpiredUnix  timeutil.TimeStamp `xorm:"index"` // The time when the artifact will be expired

    @@ -92,12 +94,13 @@ func CreateArtifact(ctx context.Context, t *ActionTask, artifactName, artifactPa
  
    	if err := t.LoadJob(ctx); err != nil {

    		return nil, err

    	}

    	artifact, err := getArtifactByNameAndPath(ctx, t.Job.RunID, artifactName, artifactPath)

    	artifact, err := getArtifactByNameAndPath(ctx, t.Job.RunID, t.Job.RunAttemptID, artifactName, artifactPath)

    	if errors.Is(err, util.ErrNotExist) {

    		artifact := &ActionArtifact{

    			ArtifactName: artifactName,

    			ArtifactPath: artifactPath,

    			RunID:        t.Job.RunID,

    			RunAttemptID: t.Job.RunAttemptID,

    			RunnerID:     t.RunnerID,

    			RepoID:       t.RepoID,

    			OwnerID:      t.OwnerID,

    @@ -122,9 +125,9 @@ func CreateArtifact(ctx context.Context, t *ActionTask, artifactName, artifactPa
  
    	return artifact, nil

    }

    func getArtifactByNameAndPath(ctx context.Context, runID int64, name, fpath string) (*ActionArtifact, error) {

    func getArtifactByNameAndPath(ctx context.Context, runID, runAttemptID int64, name, fpath string) (*ActionArtifact, error) {

    	var art ActionArtifact

    	has, err := db.GetEngine(ctx).Where("run_id = ? AND artifact_name = ? AND artifact_path = ?", runID, name, fpath).Get(&art)

    	has, err := db.GetEngine(ctx).Where("run_id = ? AND run_attempt_id = ? AND artifact_name = ? AND artifact_path = ?", runID, runAttemptID, name, fpath).Get(&art)

    	if err != nil {

    		return nil, err

    	} else if !has {

    @@ -144,6 +147,7 @@ type FindArtifactsOptions struct {
  
    	db.ListOptions

    	RepoID               int64

    	RunID                int64

    	RunAttemptID         optional.Option[int64] // use optional to allow filtering by zero (legacy artifacts have run_attempt_id=0)

    	ArtifactName         string

    	Status               int

    	FinalizedArtifactsV4 bool

    @@ -163,6 +167,9 @@ func (opts FindArtifactsOptions) ToConds() builder.Cond {
  
    	if opts.RunID > 0 {

    		cond = cond.And(builder.Eq{"run_id": opts.RunID})

    	}

    	if opts.RunAttemptID.Has() {

    		cond = cond.And(builder.Eq{"run_attempt_id": opts.RunAttemptID.Value()})

    	}

    	if opts.ArtifactName != "" {

    		cond = cond.And(builder.Eq{"artifact_name": opts.ArtifactName})

    	}

    @@ -186,11 +193,12 @@ type ActionArtifactMeta struct {
  
    	ExpiredUnix  timeutil.TimeStamp

    }

    // ListUploadedArtifactsMeta returns all uploaded artifacts meta of a run

    func ListUploadedArtifactsMeta(ctx context.Context, repoID, runID int64) ([]*ActionArtifactMeta, error) {

    // ListUploadedArtifactsMetaByRunAttempt returns uploaded artifacts meta scoped to a specific run and attempt.

    // Pass runAttemptID=0 to target legacy artifacts (pre-v331) belonging to the run.

    func ListUploadedArtifactsMetaByRunAttempt(ctx context.Context, repoID, runID, runAttemptID int64) ([]*ActionArtifactMeta, error) {

    	arts := make([]*ActionArtifactMeta, 0, 10)

    	return arts, db.GetEngine(ctx).Table("action_artifact").

    		Where("repo_id=? AND run_id=? AND (status=? OR status=?)", repoID, runID, ArtifactStatusUploadConfirmed, ArtifactStatusExpired).

    		Where("repo_id=? AND run_id=? AND run_attempt_id=? AND (status=? OR status=?)", repoID, runID, runAttemptID, ArtifactStatusUploadConfirmed, ArtifactStatusExpired).

    		GroupBy("artifact_name").

    		Select("artifact_name, sum(file_size) as file_size, max(status) as status, max(expired_unix) as expired_unix").

    		Find(&arts)

    @@ -217,12 +225,29 @@ func SetArtifactExpired(ctx context.Context, artifactID int64) error {
  
    	return err

    }

    // SetArtifactNeedDelete sets an artifact to need-delete, cron job will delete it

    func SetArtifactNeedDelete(ctx context.Context, runID int64, name string) error {

    	_, err := db.GetEngine(ctx).Where("run_id=? AND artifact_name=? AND status = ?", runID, name, ArtifactStatusUploadConfirmed).Cols("status").Update(&ActionArtifact{Status: ArtifactStatusPendingDeletion})

    // SetArtifactNeedDeleteByID sets an artifact to need-delete by ID, cron job will delete it.

    func SetArtifactNeedDeleteByID(ctx context.Context, artifactID int64) error {

    	_, err := db.GetEngine(ctx).Where("id=? AND status = ?", artifactID, ArtifactStatusUploadConfirmed).Cols("status").Update(&ActionArtifact{Status: ArtifactStatusPendingDeletion})

    	return err

    }

    // SetArtifactNeedDeleteByRunAttempt sets an artifact to need-delete in a run attempt, cron job will delete it.

    // runAttemptID may be 0 for legacy artifacts created before ActionRunAttempt existed.

    func SetArtifactNeedDeleteByRunAttempt(ctx context.Context, runID, runAttemptID int64, name string) error {

    	_, err := db.GetEngine(ctx).Where("run_id=? AND run_attempt_id=? AND artifact_name=? AND status = ?", runID, runAttemptID, name, ArtifactStatusUploadConfirmed).Cols("status").Update(&ActionArtifact{Status: ArtifactStatusPendingDeletion})

    	return err

    }

    // GetArtifactsByRunAttemptAndName returns all artifacts with the given name in the specified run attempt.

    // This supports both attempt-scoped data and legacy artifacts with run_attempt_id=0.

    func GetArtifactsByRunAttemptAndName(ctx context.Context, runID, runAttemptID int64, artifactName string) ([]*ActionArtifact, error) {

    	arts := make([]*ActionArtifact, 0)

    	return arts, db.GetEngine(ctx).

    		Where("run_id = ? AND run_attempt_id = ? AND artifact_name = ?", runID, runAttemptID, artifactName).

    		OrderBy("id").

    		Find(&arts)

    }

    // SetArtifactDeleted sets an artifact to deleted

    func SetArtifactDeleted(ctx context.Context, artifactID int64) error {

    	_, err := db.GetEngine(ctx).ID(artifactID).Cols("status").Update(&ActionArtifact{Status: ArtifactStatusDeleted})

models/actions/run.go

            
                      Original file line number
                      Diff line number
                      Diff line change
                  
    @@ -30,7 +30,7 @@ import (
  
    type ActionRun struct {

    	ID                int64

    	Title             string

    	RepoID            int64                  `xorm:"unique(repo_index) index(repo_concurrency)"`

    	RepoID            int64                  `xorm:"unique(repo_index)"`

    	Repo              *repo_model.Repository `xorm:"-"`

    	OwnerID           int64                  `xorm:"index"`

    	WorkflowID        string                 `xorm:"index"`                    // the name of workflow file

    @@ -50,15 +50,20 @@ type ActionRun struct {
  
    	Status            Status                       `xorm:"index"`

    	Version           int                          `xorm:"version default 0"` // Status could be updated concomitantly, so an optimistic lock is needed

    	RawConcurrency    string                       // raw concurrency

    	ConcurrencyGroup  string                       `xorm:"index(repo_concurrency) NOT NULL DEFAULT ''"`

    	ConcurrencyCancel bool                         `xorm:"NOT NULL DEFAULT FALSE"`

    	// Started and Stopped is used for recording last run time, if rerun happened, they will be reset to 0

    	// Started and Stopped are identical to the latest attempt after ActionRunAttempt was introduced.

    	// When a rerun creates a new latest attempt, they are reset until the new attempt starts and stops.

    	Started timeutil.TimeStamp

    	Stopped timeutil.TimeStamp

    	// PreviousDuration is used for recording previous duration

    	// PreviousDuration is kept only for legacy runs created before ActionRunAttempt existed.

    	// New runs and reruns no longer update this field and use attempt-scoped durations instead.

    	PreviousDuration time.Duration

    	Created          timeutil.TimeStamp `xorm:"created"`

    	Updated          timeutil.TimeStamp `xorm:"updated"`

    	LatestAttemptID int64 `xorm:"index NOT NULL DEFAULT 0"`

    	Created timeutil.TimeStamp `xorm:"created"`

    	Updated timeutil.TimeStamp `xorm:"updated"`

    }

    func init() {

    @@ -160,6 +165,31 @@ func (run *ActionRun) Duration() time.Duration {
  
    	return d

    }

    // GetLatestAttempt returns

    //   - the latest attempt of the run

    //   - (nil, false, nil) for legacy runs that have no attempt records

    func (run *ActionRun) GetLatestAttempt(ctx context.Context) (*ActionRunAttempt, bool, error) {

    	if run.LatestAttemptID == 0 {

    		return nil, false, nil

    	}

    	attempt, err := GetRunAttemptByRepoAndID(ctx, run.RepoID, run.LatestAttemptID)

    	if err != nil {

    		return nil, false, err

    	}

    	return attempt, true, nil

    }

    func (run *ActionRun) GetEffectiveConcurrency(ctx context.Context) (string, bool, error) {

    	attempt, has, err := run.GetLatestAttempt(ctx)

    	if err != nil {

    		return "", false, err

    	}

    	if has {

    		return attempt.ConcurrencyGroup, attempt.ConcurrencyCancel, nil

    	}

    	return "", false, nil

    }

    func (run *ActionRun) GetPushEventPayload() (*api.PushPayload, error) {

    	if run.Event == webhook_module.HookEventPush {

    		var payload api.PushPayload

    @@ -406,14 +436,11 @@ func UpdateRun(ctx context.Context, run *ActionRun, cols ...string) error {
  
    type ActionRunIndex db.ResourceIndex

    func GetConcurrentRunsAndJobs(ctx context.Context, repoID int64, concurrencyGroup string, status []Status) ([]*ActionRun, []*ActionRunJob, error) {

    	runs, err := db.Find[ActionRun](ctx, &FindRunOptions{

    		RepoID:           repoID,

    		ConcurrencyGroup: concurrencyGroup,

    		Status:           status,

    	})

    // GetConcurrentRunAttemptsAndJobs returns run attempts and jobs in the same concurrency group by statuses.

    func GetConcurrentRunAttemptsAndJobs(ctx context.Context, repoID int64, concurrencyGroup string, status []Status) ([]*ActionRunAttempt, []*ActionRunJob, error) {

    	attempts, err := FindConcurrentRunAttempts(ctx, repoID, concurrencyGroup, status)

    	if err != nil {

    		return nil, nil, fmt.Errorf("find runs: %w", err)

    		return nil, nil, fmt.Errorf("find run attempts: %w", err)

    	}

    	jobs, err := db.Find[ActionRunJob](ctx, &FindRunJobOptions{

    @@ -425,36 +452,34 @@ func GetConcurrentRunsAndJobs(ctx context.Context, repoID int64, concurrencyGrou
  
    		return nil, nil, fmt.Errorf("find jobs: %w", err)

    	}

    	return runs, jobs, nil

    	return attempts, jobs, nil

    }

    func CancelPreviousJobsByRunConcurrency(ctx context.Context, actionRun *ActionRun) ([]*ActionRunJob, error) {

    	if actionRun.ConcurrencyGroup == "" {

    func CancelPreviousJobsByRunConcurrency(ctx context.Context, attempt *ActionRunAttempt) ([]*ActionRunJob, error) {

    	if attempt.ConcurrencyGroup == "" {

    		return nil, nil

    	}

    	var jobsToCancel []*ActionRunJob

    	statusFindOption := []Status{StatusWaiting, StatusBlocked}

    	if actionRun.ConcurrencyCancel {

    	if attempt.ConcurrencyCancel {

    		statusFindOption = append(statusFindOption, StatusRunning)

    	}

    	runs, jobs, err := GetConcurrentRunsAndJobs(ctx, actionRun.RepoID, actionRun.ConcurrencyGroup, statusFindOption)

    	attempts, jobs, err := GetConcurrentRunAttemptsAndJobs(ctx, attempt.RepoID, attempt.ConcurrencyGroup, statusFindOption)

    	if err != nil {

    		return nil, fmt.Errorf("find concurrent runs and jobs: %w", err)

    	}

    	jobsToCancel = append(jobsToCancel, jobs...)

    	// cancel runs in the same concurrency group

    	for _, run := range runs {

    		if run.ID == actionRun.ID {

    	for _, concurrentAttempt := range attempts {

    		if concurrentAttempt.RunID == attempt.RunID {

    			continue

    		}

    		jobs, err := db.Find[ActionRunJob](ctx, FindRunJobOptions{

    			RunID: run.ID,

    		})

    		jobs, err := GetRunJobsByRunAndAttemptID(ctx, concurrentAttempt.RunID, concurrentAttempt.ID)

    		if err != nil {

    			return nil, fmt.Errorf("find run %d jobs: %w", run.ID, err)

    			return nil, fmt.Errorf("find run %d attempt %d jobs: %w", concurrentAttempt.RunID, concurrentAttempt.ID, err)

    		}

    		jobsToCancel = append(jobsToCancel, jobs...)

    	}

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Introduce `ActionRunAttempt` to represent each execution of a run #37119

Uh oh!

Diff view

Diff view

There are no files selected for viewing

Uh oh!

Uh oh!

Introduce ActionRunAttempt to represent each execution of a run #37119

Uh oh!

Introduce ActionRunAttempt to represent each execution of a run #37119

Uh oh!

Uh oh!

Diff view

Diff view

There are no files selected for viewing

Uh oh!

Introduce `ActionRunAttempt` to represent each execution of a run #37119

Introduce `ActionRunAttempt` to represent each execution of a run #37119