fix: Remove MatrixID and Capacity functionality

models/actions/run_job.go

@@ -55,6 +55,8 @@ type ActionRunJob struct {
 	// Org/repo clamps are enforced when the token is used at runtime.
 	// It is JSON-encoded repo_model.ActionsTokenPermissions and may be empty if not specified.
 	TokenPermissions *repo_model.ActionsTokenPermissions `xorm:"JSON TEXT"`
+	// Matrix job support
+	MaxParallel int // Max parallel jobs from strategy.max-parallel (0 = unlimited)
 
 	Started timeutil.TimeStamp
 	Stopped timeutil.TimeStamp

models/actions/run_job_maxparallel_test.go

@@ -51,25 +51,6 @@ func TestActionRunJob_MaxParallel(t *testing.T) {
 		assert.Equal(t, 3, retrieved.MaxParallel)
 	})
 
-	t.Run("MatrixID", func(t *testing.T) {
-		job := &ActionRunJob{
-			RunID:       1,
-			RepoID:      1,
-			OwnerID:     1,
-			JobID:       "test-job-3",
-			Name:        "Matrix Job with ID",
-			Status:      StatusWaiting,
-			MaxParallel: 2,
-			MatrixID:    "os:ubuntu,node:16",
-		}
-		assert.NoError(t, db.Insert(ctx, job))
-
-		retrieved, err := GetRunJobByID(ctx, job.ID)
-		assert.NoError(t, err)
-		assert.Equal(t, 2, retrieved.MaxParallel)
-		assert.Equal(t, "os:ubuntu,node:16", retrieved.MatrixID)
-	})
-
 	t.Run("UpdateMaxParallel", func(t *testing.T) {
 		// Create ActionRun first
 		run := &ActionRun{
@@ -124,10 +105,10 @@ func TestActionRunJob_MaxParallelEnforcement(t *testing.T) {
 
 		// Create jobs simulating matrix execution
 		jobs := []*ActionRunJob{
-			{RunID: runID, RepoID: 1, OwnerID: 1, JobID: jobID, Name: "Job 1", Status: StatusRunning, MaxParallel: maxParallel, MatrixID: "version:1"},
-			{RunID: runID, RepoID: 1, OwnerID: 1, JobID: jobID, Name: "Job 2", Status: StatusRunning, MaxParallel: maxParallel, MatrixID: "version:2"},
-			{RunID: runID, RepoID: 1, OwnerID: 1, JobID: jobID, Name: "Job 3", Status: StatusWaiting, MaxParallel: maxParallel, MatrixID: "version:3"},
-			{RunID: runID, RepoID: 1, OwnerID: 1, JobID: jobID, Name: "Job 4", Status: StatusWaiting, MaxParallel: maxParallel, MatrixID: "version:4"},
+			{RunID: runID, RepoID: 1, OwnerID: 1, JobID: jobID, Name: "Job 1", Status: StatusRunning, MaxParallel: maxParallel},
+			{RunID: runID, RepoID: 1, OwnerID: 1, JobID: jobID, Name: "Job 2", Status: StatusRunning, MaxParallel: maxParallel},
+			{RunID: runID, RepoID: 1, OwnerID: 1, JobID: jobID, Name: "Job 3", Status: StatusWaiting, MaxParallel: maxParallel},
+			{RunID: runID, RepoID: 1, OwnerID: 1, JobID: jobID, Name: "Job 4", Status: StatusWaiting, MaxParallel: maxParallel},
 		}
 
 		for _, job := range jobs {

models/actions/task.go

@@ -539,15 +539,6 @@ func getTaskIDFromCache(token string) int64 {
 	return t
 }
 
-// CountRunningTasksByRunner counts the number of running tasks assigned to a specific runner
-func CountRunningTasksByRunner(ctx context.Context, runnerID int64) (int, error) {
-	count, err := db.GetEngine(ctx).
-		Where("runner_id = ?", runnerID).
-		And("status = ?", StatusRunning).
-		Count(new(ActionTask))
-	return int(count), err
-}
-
 // CountRunningJobsByWorkflowAndRun counts running jobs for a specific workflow/run combo
 // Used to enforce max-parallel limits on matrix jobs
 func CountRunningJobsByWorkflowAndRun(ctx context.Context, runID int64, jobID string) (int, error) {

models/actions/task_count_test.go

@@ -13,89 +13,6 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestCountRunningTasksByRunner(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-	ctx := context.Background()
-
-	t.Run("NoRunningTasks", func(t *testing.T) {
-		count, err := CountRunningTasksByRunner(ctx, 999999)
-		assert.NoError(t, err)
-		assert.Equal(t, 0, count)
-	})
-
-	t.Run("WithRunningTasks", func(t *testing.T) {
-		// Create a runner
-		runner := &ActionRunner{
-			UUID:      "test-runner-tasks",
-			Name:      "Test Runner",
-			OwnerID:   0,
-			RepoID:    0,
-			TokenHash: "test_hash_tasks",
-			Token:     "test_token_tasks",
-		}
-		assert.NoError(t, db.Insert(ctx, runner))
-
-		// Create running tasks
-		task1 := &ActionTask{
-			JobID:     1,
-			RunnerID:  runner.ID,
-			Status:    StatusRunning,
-			RepoID:    1,
-			OwnerID:   1,
-			TokenHash: "task1_hash",
-			Token:     "task1_token",
-		}
-		assert.NoError(t, db.Insert(ctx, task1))
-
-		task2 := &ActionTask{
-			JobID:     2,
-			RunnerID:  runner.ID,
-			Status:    StatusRunning,
-			RepoID:    1,
-			OwnerID:   1,
-			TokenHash: "task2_hash",
-			Token:     "task2_token",
-		}
-		assert.NoError(t, db.Insert(ctx, task2))
-
-		// Count should be 2
-		count, err := CountRunningTasksByRunner(ctx, runner.ID)
-		assert.NoError(t, err)
-		assert.Equal(t, 2, count)
-	})
-
-	t.Run("MixedStatusTasks", func(t *testing.T) {
-		runner := &ActionRunner{
-			UUID:      "test-runner-mixed",
-			Name:      "Mixed Status Runner",
-			Capacity:  5,
-			TokenHash: "mixed_runner_hash",
-			Token:     "mixed_runner_token",
-		}
-		assert.NoError(t, db.Insert(ctx, runner))
-
-		// Create tasks with different statuses
-		statuses := []Status{StatusRunning, StatusSuccess, StatusRunning, StatusFailure, StatusWaiting}
-		for i, status := range statuses {
-			task := &ActionTask{
-				JobID:     int64(100 + i),
-				RunnerID:  runner.ID,
-				Status:    status,
-				RepoID:    1,
-				OwnerID:   1,
-				TokenHash: "mixed_task_hash_" + string(rune('a'+i)),
-				Token:     "mixed_task_token_" + string(rune('a'+i)),
-			}
-			assert.NoError(t, db.Insert(ctx, task))
-		}
-
-		// Only 2 running tasks
-		count, err := CountRunningTasksByRunner(ctx, runner.ID)
-		assert.NoError(t, err)
-		assert.Equal(t, 2, count)
-	})
-}
-
 func TestCountRunningJobsByWorkflowAndRun(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 	ctx := context.Background()