fix

Author: Zettat123

models/actions/run.go

@@ -30,8 +30,7 @@ type ActionRun struct {
 	RepoID            int64                  `xorm:"unique(repo_index)"`
 	Repo              *repo_model.Repository `xorm:"-"`
 	OwnerID           int64                  `xorm:"index"`
-	WorkflowID        string                 `xorm:"index"`                    // the name of workflow file
-	WorkflowName      string                 `xorm:"NOT NULL DEFAULT ''"`      // the workflow `name:` (or file name)
+	WorkflowID        string                 `xorm:"index"`                    // the workflow file's entry name, e.g. ci.yaml (this run's workflow identity)
 	Index             int64                  `xorm:"index unique(repo_index)"` // a unique number for each run of a repository
 	TriggerUserID     int64                  `xorm:"index"`
 	TriggerUser       *user_model.User       `xorm:"-"`

models/actions/scoped_workflow.go

@@ -25,10 +25,8 @@ type ActionScopedWorkflowSource struct {
 	// SourceRepoID is the source repository providing the workflow files; always non-zero.
 	SourceRepoID int64 `xorm:"INDEX UNIQUE(owner_repo) NOT NULL DEFAULT 0"`
 
-	// RequiredFiles are entry names marked as required.
-	RequiredFiles []string `xorm:"JSON TEXT"`
-	// RequiredWorkflowNames holds the WorkflowName of each required workflow. Derived from RequiredFiles.
-	RequiredWorkflowNames []string `xorm:"JSON TEXT"`
+	// RequiredWorkflowIDs are the workflow IDs marked as required.
+	RequiredWorkflowIDs []string `xorm:"JSON TEXT 'required_workflow_ids'"`
 
 	CreatedUnix timeutil.TimeStamp `xorm:"created"`
 	UpdatedUnix timeutil.TimeStamp `xorm:"updated"`
@@ -38,9 +36,9 @@ func init() {
 	db.RegisterModel(new(ActionScopedWorkflowSource))
 }
 
-// IsFileRequired reports whether the given scoped workflow entry name is marked required in this source.
-func (s *ActionScopedWorkflowSource) IsFileRequired(file string) bool {
-	return slices.Contains(s.RequiredFiles, file)
+// IsWorkflowRequired reports whether the given workflow ID (entry name) is marked required in this source.
+func (s *ActionScopedWorkflowSource) IsWorkflowRequired(workflowID string) bool {
+	return slices.Contains(s.RequiredWorkflowIDs, workflowID)
 }
 
 type FindScopedWorkflowSourceOpts struct {
@@ -79,10 +77,10 @@ func IsScopedWorkflowSourceEffective(ctx context.Context, repoOwnerID, sourceRep
 	return db.Exist[ActionScopedWorkflowSource](ctx, FindScopedWorkflowSourceOpts{OwnerIDs: owners, SourceRepoID: sourceRepoID}.ToConds())
 }
 
-// IsFileRequiredInSources reports whether file from sourceRepoID is required by any of the given sources.
-func IsFileRequiredInSources(sources []*ActionScopedWorkflowSource, sourceRepoID int64, file string) bool {
+// IsWorkflowRequiredInSources reports whether workflowID from sourceRepoID is required by any of the given sources.
+func IsWorkflowRequiredInSources(sources []*ActionScopedWorkflowSource, sourceRepoID int64, workflowID string) bool {
 	for _, s := range sources {
-		if s.SourceRepoID == sourceRepoID && s.IsFileRequired(file) {
+		if s.SourceRepoID == sourceRepoID && s.IsWorkflowRequired(workflowID) {
 			return true
 		}
 	}
@@ -97,32 +95,20 @@ func ScopedStatusContextPrefix(ctx context.Context, sourceRepoID int64) string {
 	return fmt.Sprintf("scoped:%d", sourceRepoID)
 }
 
-// IsScopedFileRequired reports whether file from sourceRepoID is required for a repo owned by consumerOwnerID.
-func IsScopedFileRequired(ctx context.Context, consumerOwnerID, sourceRepoID int64, file string) (bool, error) {
+// IsScopedWorkflowRequired reports whether workflowID from sourceRepoID is required for a repo owned by consumerOwnerID.
+func IsScopedWorkflowRequired(ctx context.Context, consumerOwnerID, sourceRepoID int64, workflowID string) (bool, error) {
 	sources, err := GetEffectiveScopedWorkflowSources(ctx, consumerOwnerID)
 	if err != nil {
 		return false, err
 	}
-	return IsFileRequiredInSources(sources, sourceRepoID, file), nil
+	return IsWorkflowRequiredInSources(sources, sourceRepoID, workflowID), nil
 }
 
 // GetScopedWorkflowSourcesByOwner returns the sources an owner (user/org, or 0 for instance) registered.
 func GetScopedWorkflowSourcesByOwner(ctx context.Context, ownerID int64) ([]*ActionScopedWorkflowSource, error) {
 	return db.Find[ActionScopedWorkflowSource](ctx, FindScopedWorkflowSourceOpts{OwnerIDs: []int64{ownerID}})
 }
 
-// GetScopedWorkflowSourcesBySourceRepo returns every source registration backed by sourceRepoID (across owners and the instance).
-func GetScopedWorkflowSourcesBySourceRepo(ctx context.Context, sourceRepoID int64) ([]*ActionScopedWorkflowSource, error) {
-	return db.Find[ActionScopedWorkflowSource](ctx, FindScopedWorkflowSourceOpts{SourceRepoID: sourceRepoID})
-}
-
-// UpdateScopedWorkflowSourceRequiredNames replaces the captured required-workflow names for one source record.
-func UpdateScopedWorkflowSourceRequiredNames(ctx context.Context, id int64, runNames []string) error {
-	_, err := db.GetEngine(ctx).ID(id).Cols("required_workflow_names").
-		Update(&ActionScopedWorkflowSource{RequiredWorkflowNames: runNames})
-	return err
-}
-
 // GetScopedWorkflowSource returns the (owner, repo) source registration or a NotExist error.
 func GetScopedWorkflowSource(ctx context.Context, ownerID, repoID int64) (*ActionScopedWorkflowSource, error) {
 	src := &ActionScopedWorkflowSource{}
@@ -148,11 +134,11 @@ func AddScopedWorkflowSource(ctx context.Context, ownerID, repoID int64) error {
 	return db.Insert(ctx, &ActionScopedWorkflowSource{OwnerID: ownerID, SourceRepoID: repoID})
 }
 
-// SetScopedWorkflowSourceRequired replaces the required-workflow set.
-func SetScopedWorkflowSourceRequired(ctx context.Context, ownerID, repoID int64, files, runNames []string) error {
+// SetScopedWorkflowSourceRequired replaces the required-workflow set (the workflows' entry names / run WorkflowIDs).
+func SetScopedWorkflowSourceRequired(ctx context.Context, ownerID, repoID int64, workflowIDs []string) error {
 	_, err := db.GetEngine(ctx).Where("owner_id = ? AND source_repo_id = ?", ownerID, repoID).
-		Cols("required_files", "required_workflow_names").
-		Update(&ActionScopedWorkflowSource{RequiredFiles: files, RequiredWorkflowNames: runNames})
+		Cols("required_workflow_ids").
+		Update(&ActionScopedWorkflowSource{RequiredWorkflowIDs: workflowIDs})
 	return err
 }
 

models/actions/scoped_workflow_test.go

@@ -14,40 +14,40 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestScopedWorkflowSource_IsFileRequired(t *testing.T) {
-	src := &ActionScopedWorkflowSource{RequiredFiles: []string{"a.yml", "b.yml"}}
-	assert.True(t, src.IsFileRequired("a.yml"))
-	assert.True(t, src.IsFileRequired("b.yml"))
-	assert.False(t, src.IsFileRequired("c.yml"))
+func TestScopedWorkflowSource_IsWorkflowRequired(t *testing.T) {
+	src := &ActionScopedWorkflowSource{RequiredWorkflowIDs: []string{"a.yml", "b.yml"}}
+	assert.True(t, src.IsWorkflowRequired("a.yml"))
+	assert.True(t, src.IsWorkflowRequired("b.yml"))
+	assert.False(t, src.IsWorkflowRequired("c.yml"))
 
 	empty := &ActionScopedWorkflowSource{}
-	assert.False(t, empty.IsFileRequired("a.yml"))
+	assert.False(t, empty.IsWorkflowRequired("a.yml"))
 }
 
-func TestIsFileRequiredInSources(t *testing.T) {
+func TestIsWorkflowRequiredInSources(t *testing.T) {
 	// repo 100 registered twice (org optional + instance required).
 	sources := []*ActionScopedWorkflowSource{
-		{OwnerID: 2, SourceRepoID: 100, RequiredFiles: nil},
-		{OwnerID: 0, SourceRepoID: 100, RequiredFiles: []string{"a.yml"}},
-		{OwnerID: 0, SourceRepoID: 200, RequiredFiles: []string{"b.yml"}},
+		{OwnerID: 2, SourceRepoID: 100, RequiredWorkflowIDs: nil},
+		{OwnerID: 0, SourceRepoID: 100, RequiredWorkflowIDs: []string{"a.yml"}},
+		{OwnerID: 0, SourceRepoID: 200, RequiredWorkflowIDs: []string{"b.yml"}},
 	}
 
-	assert.True(t, IsFileRequiredInSources(sources, 100, "a.yml"), "required at instance level wins over org optional")
-	assert.False(t, IsFileRequiredInSources(sources, 100, "z.yml"))
-	assert.False(t, IsFileRequiredInSources(sources, 200, "a.yml"), "a.yml is required for repo 100, not repo 200")
-	assert.True(t, IsFileRequiredInSources(sources, 200, "b.yml"))
-	assert.False(t, IsFileRequiredInSources(sources, 999, "a.yml"), "unknown source repo")
+	assert.True(t, IsWorkflowRequiredInSources(sources, 100, "a.yml"), "required at instance level wins over org optional")
+	assert.False(t, IsWorkflowRequiredInSources(sources, 100, "z.yml"))
+	assert.False(t, IsWorkflowRequiredInSources(sources, 200, "a.yml"), "a.yml is required for repo 100, not repo 200")
+	assert.True(t, IsWorkflowRequiredInSources(sources, 200, "b.yml"))
+	assert.False(t, IsWorkflowRequiredInSources(sources, 999, "a.yml"), "unknown source repo")
 }
 
 func TestGetEffectiveScopedWorkflowSources(t *testing.T) {
 	require.NoError(t, unittest.PrepareTestDatabase())
 	ctx := t.Context()
 
 	rows := []*ActionScopedWorkflowSource{
-		{OwnerID: 2, SourceRepoID: 100, RequiredFiles: nil},               // org 2 registers repo 100 (optional)
-		{OwnerID: 0, SourceRepoID: 100, RequiredFiles: []string{"a.yml"}}, // instance also registers repo 100 (required)
-		{OwnerID: 0, SourceRepoID: 200, RequiredFiles: []string{"b.yml"}}, // instance source 200
-		{OwnerID: 3, SourceRepoID: 300, RequiredFiles: []string{"c.yml"}}, // a different owner's source
+		{OwnerID: 2, SourceRepoID: 100, RequiredWorkflowIDs: nil},               // org 2 registers repo 100 (optional)
+		{OwnerID: 0, SourceRepoID: 100, RequiredWorkflowIDs: []string{"a.yml"}}, // instance also registers repo 100 (required)
+		{OwnerID: 0, SourceRepoID: 200, RequiredWorkflowIDs: []string{"b.yml"}}, // instance source 200
+		{OwnerID: 3, SourceRepoID: 300, RequiredWorkflowIDs: []string{"c.yml"}}, // a different owner's source
 	}
 	for _, r := range rows {
 		require.NoError(t, db.Insert(ctx, r))
@@ -58,20 +58,20 @@ func TestGetEffectiveScopedWorkflowSources(t *testing.T) {
 	require.NoError(t, err)
 	assert.Len(t, owner2, 3)
 
-	required, err := IsScopedFileRequired(ctx, 2, 100, "a.yml")
+	required, err := IsScopedWorkflowRequired(ctx, 2, 100, "a.yml")
 	require.NoError(t, err)
 	assert.True(t, required, "instance marks a.yml required → required for owner 2 even though org left it optional")
 
-	required, err = IsScopedFileRequired(ctx, 2, 100, "x.yml")
+	required, err = IsScopedWorkflowRequired(ctx, 2, 100, "x.yml")
 	require.NoError(t, err)
 	assert.False(t, required)
 
-	required, err = IsScopedFileRequired(ctx, 2, 200, "b.yml")
+	required, err = IsScopedWorkflowRequired(ctx, 2, 200, "b.yml")
 	require.NoError(t, err)
 	assert.True(t, required)
 
 	// owner 3's source must not be effective for owner 2.
-	required, err = IsScopedFileRequired(ctx, 2, 300, "c.yml")
+	required, err = IsScopedWorkflowRequired(ctx, 2, 300, "c.yml")
 	require.NoError(t, err)
 	assert.False(t, required)
 
@@ -108,19 +108,17 @@ func TestScopedWorkflowSourceCRUD(t *testing.T) {
 	require.NoError(t, err)
 	assert.Len(t, sources, 1)
 
-	// set required files (with their workflow names used for the merge-gate globs)
-	require.NoError(t, SetScopedWorkflowSourceRequired(ctx, 5, 10, []string{"a.yml", "b.yml"}, []string{"A", "B"}))
+	// set the required workflows (by entry name / run WorkflowID)
+	require.NoError(t, SetScopedWorkflowSourceRequired(ctx, 5, 10, []string{"a.yml", "b.yml"}))
 	src, err := GetScopedWorkflowSource(ctx, 5, 10)
 	require.NoError(t, err)
-	assert.ElementsMatch(t, []string{"a.yml", "b.yml"}, src.RequiredFiles)
-	assert.ElementsMatch(t, []string{"A", "B"}, src.RequiredWorkflowNames)
+	assert.ElementsMatch(t, []string{"a.yml", "b.yml"}, src.RequiredWorkflowIDs)
 
-	// clearing required files works
-	require.NoError(t, SetScopedWorkflowSourceRequired(ctx, 5, 10, nil, nil))
+	// clearing the required set works
+	require.NoError(t, SetScopedWorkflowSourceRequired(ctx, 5, 10, nil))
 	src, err = GetScopedWorkflowSource(ctx, 5, 10)
 	require.NoError(t, err)
-	assert.Empty(t, src.RequiredFiles)
-	assert.Empty(t, src.RequiredWorkflowNames)
+	assert.Empty(t, src.RequiredWorkflowIDs)
 
 	// remove
 	require.NoError(t, RemoveScopedWorkflowSource(ctx, 5, 10))

models/migrations/v1_27/v341.go

@@ -13,21 +13,19 @@ import (
 func AddScopedWorkflowsSchema(x db.EngineMigration) error {
 	// Create the action_scoped_workflow_source table
 	type ActionScopedWorkflowSource struct {
-		ID                    int64              `xorm:"pk autoincr"`
-		OwnerID               int64              `xorm:"UNIQUE(owner_repo) NOT NULL DEFAULT 0"`
-		SourceRepoID          int64              `xorm:"INDEX UNIQUE(owner_repo) NOT NULL DEFAULT 0"`
-		RequiredFiles         []string           `xorm:"JSON TEXT"`
-		RequiredWorkflowNames []string           `xorm:"JSON TEXT"`
-		CreatedUnix           timeutil.TimeStamp `xorm:"created"`
-		UpdatedUnix           timeutil.TimeStamp `xorm:"updated"`
+		ID                  int64              `xorm:"pk autoincr"`
+		OwnerID             int64              `xorm:"UNIQUE(owner_repo) NOT NULL DEFAULT 0"`
+		SourceRepoID        int64              `xorm:"INDEX UNIQUE(owner_repo) NOT NULL DEFAULT 0"`
+		RequiredWorkflowIDs []string           `xorm:"JSON TEXT 'required_workflow_ids'"`
+		CreatedUnix         timeutil.TimeStamp `xorm:"created"`
+		UpdatedUnix         timeutil.TimeStamp `xorm:"updated"`
 	}
 	if err := x.Sync(new(ActionScopedWorkflowSource)); err != nil {
 		return err
 	}
 
 	// Add the columns that record where a run's workflow content came from
 	type ActionRun struct {
-		WorkflowName      string `xorm:"NOT NULL DEFAULT ''"`
 		WorkflowRepoID    int64  `xorm:"NOT NULL DEFAULT 0"`
 		WorkflowCommitSHA string `xorm:"VARCHAR(64) NOT NULL DEFAULT ''"`
 		IsScopedRun       bool   `xorm:"NOT NULL DEFAULT false"`

models/repo/repo_unit_actions.go

@@ -100,27 +100,27 @@ func (cfg *ActionsConfig) DisableWorkflow(file string) {
 	cfg.DisabledWorkflows = append(cfg.DisabledWorkflows, file)
 }
 
-func (cfg *ActionsConfig) IsScopedWorkflowDisabled(sourceRepoID int64, file string) bool {
-	return slices.Contains(cfg.DisabledScopedWorkflows[sourceRepoID], file)
+func (cfg *ActionsConfig) IsScopedWorkflowDisabled(sourceRepoID int64, workflowID string) bool {
+	return slices.Contains(cfg.DisabledScopedWorkflows[sourceRepoID], workflowID)
 }
 
-func (cfg *ActionsConfig) DisableScopedWorkflow(sourceRepoID int64, file string) {
-	if slices.Contains(cfg.DisabledScopedWorkflows[sourceRepoID], file) {
+func (cfg *ActionsConfig) DisableScopedWorkflow(sourceRepoID int64, workflowID string) {
+	if slices.Contains(cfg.DisabledScopedWorkflows[sourceRepoID], workflowID) {
 		return
 	}
 	if cfg.DisabledScopedWorkflows == nil {
 		cfg.DisabledScopedWorkflows = make(map[int64][]string)
 	}
-	cfg.DisabledScopedWorkflows[sourceRepoID] = append(cfg.DisabledScopedWorkflows[sourceRepoID], file)
+	cfg.DisabledScopedWorkflows[sourceRepoID] = append(cfg.DisabledScopedWorkflows[sourceRepoID], workflowID)
 }
 
-func (cfg *ActionsConfig) EnableScopedWorkflow(sourceRepoID int64, file string) {
-	files := util.SliceRemoveAll(cfg.DisabledScopedWorkflows[sourceRepoID], file)
-	if len(files) == 0 {
+func (cfg *ActionsConfig) EnableScopedWorkflow(sourceRepoID int64, workflowID string) {
+	workflowIDs := util.SliceRemoveAll(cfg.DisabledScopedWorkflows[sourceRepoID], workflowID)
+	if len(workflowIDs) == 0 {
 		delete(cfg.DisabledScopedWorkflows, sourceRepoID)
 		return
 	}
-	cfg.DisabledScopedWorkflows[sourceRepoID] = files
+	cfg.DisabledScopedWorkflows[sourceRepoID] = workflowIDs
 }
 
 func (cfg *ActionsConfig) AddCollaborativeOwner(ownerID int64) {

modules/actions/scoped_workflows.go

@@ -22,11 +22,16 @@ func ListScopedWorkflows(commit *git.Commit) (string, git.Entries, error) {
 	return listWorkflowsInDirs(commit, setting.Actions.ScopedWorkflowDirs)
 }
 
-// ParsedScopedWorkflow is one scoped workflow's source-side parse result: its file name, raw content, and decoded `on:` events.
+// ParsedScopedWorkflow is one scoped workflow's source-side parse result:
+//   - entry name
+//   - display name (the workflow `name:` or base file name)
+//   - raw content
+//   - decoded `on:` events
 type ParsedScopedWorkflow struct {
-	EntryName string
-	Content   []byte
-	Events    []*jobparser.Event
+	EntryName   string
+	DisplayName string
+	Content     []byte
+	Events      []*jobparser.Event
 }
 
 // ParseScopedWorkflows lists and parses the scoped workflow files at sourceCommit (under SCOPED_WORKFLOW_DIRS).
@@ -49,7 +54,12 @@ func ParseScopedWorkflows(sourceCommit *git.Commit) ([]*ParsedScopedWorkflow, er
 			log.Warn("ignore invalid scoped workflow %q: %v", entry.Name(), err)
 			continue
 		}
-		parsed = append(parsed, &ParsedScopedWorkflow{EntryName: entry.Name(), Content: content, Events: events})
+		parsed = append(parsed, &ParsedScopedWorkflow{
+			EntryName:   entry.Name(),
+			DisplayName: WorkflowDisplayName(entry.Name(), content),
+			Content:     content,
+			Events:      events,
+		})
 	}
 	return parsed, nil
 }

modules/actions/workflows.go

@@ -126,16 +126,16 @@ func ValidateWorkflowContent(content []byte) error {
 	return err
 }
 
-// WorkflowRunName returns the name a workflow contributes to its commit-status context:
-// the workflow's `name:` if non-blank, otherwise the base file name.
-func WorkflowRunName(file string, content []byte) string {
-	runName := path.Base(file)
+// WorkflowDisplayName returns a workflow's display name: its `name:` if non-blank, otherwise the base file name.
+// This is the value used as the workflow segment of its commit-status context.
+func WorkflowDisplayName(file string, content []byte) string {
+	displayName := path.Base(file)
 	if wfs, err := jobparser.Parse(content); err == nil && len(wfs) > 0 {
 		if name := strings.TrimSpace(wfs[0].Name); name != "" {
-			runName = name
+			displayName = name
 		}
 	}
-	return runName
+	return displayName
 }
 
 func DetectWorkflows(

routers/web/repo/actions/actions.go

@@ -301,8 +301,12 @@ func prepareScopedWorkflows(ctx *context.Context, curWorkflowID string, curWorkf
 			continue
 		}
 
-		entryNames := listScopedWorkflowEntryNames(ctx, sourceRepo)
-		if len(entryNames) == 0 {
+		_, entries, err := actions_service.LoadParsedScopedWorkflows(ctx, sourceRepo)
+		if err != nil {
+			log.Error("scoped workflows list: parse %s: %v", sourceRepo.FullName(), err)
+			continue
+		}
+		if len(entries) == 0 {
 			continue
 		}
 
@@ -312,19 +316,19 @@ func prepareScopedWorkflows(ctx *context.Context, curWorkflowID string, curWorkf
 			SourceRepoShortName: sourceRepo.Name,
 			FromInstance:        source.OwnerID == 0,
 		}
-		for _, name := range entryNames {
-			scopedNames.Add(name)
-			required := actions_model.IsFileRequiredInSources(sources, sourceRepo.ID, name)
-			disabled := actionsConfig.IsScopedWorkflowDisabled(sourceRepo.ID, name)
+		for _, e := range entries {
+			scopedNames.Add(e.EntryName)
+			required := actions_model.IsWorkflowRequiredInSources(sources, sourceRepo.ID, e.EntryName)
+			disabled := actionsConfig.IsScopedWorkflowDisabled(sourceRepo.ID, e.EntryName)
 			group.Workflows = append(group.Workflows, ScopedWorkflowInfo{
 				SourceRepoID: sourceRepo.ID,
-				EntryName:    name,
-				DisplayName:  name,
+				EntryName:    e.EntryName,
+				DisplayName:  e.DisplayName,
 				Required:     required,
 				Disabled:     disabled,
 			})
 
-			if curWorkflowID == name && curWorkflowRepoID == sourceRepo.ID {
+			if curWorkflowID == e.EntryName && curWorkflowRepoID == sourceRepo.ID {
 				ctx.Data["CurWorkflowDisabled"] = disabled
 				ctx.Data["CurWorkflowScopedRepoID"] = sourceRepo.ID
 				ctx.Data["CurWorkflowRequired"] = required
@@ -338,16 +342,6 @@ func prepareScopedWorkflows(ctx *context.Context, curWorkflowID string, curWorkf
 	return scopedNames
 }
 
-// listScopedWorkflowEntryNames returns a source's scoped workflow entry names for the list sidebar.
-func listScopedWorkflowEntryNames(ctx *context.Context, sourceRepo *repo_model.Repository) []string {
-	names, err := actions_service.ScopedWorkflowEntryNames(ctx, sourceRepo)
-	if err != nil {
-		log.Error("scoped workflows list: entry names of %s: %v", sourceRepo.FullName(), err)
-		return nil
-	}
-	return names
-}
-
 // loadScopedWorkflowModel reads and parses a scoped workflow's content from its source repo's default branch.
 func loadScopedWorkflowModel(ctx *context.Context, repo *repo_model.Repository, sourceRepoID int64, workflowID string) *act_model.Workflow {
 	effective, err := actions_model.IsScopedWorkflowSourceEffective(ctx, repo.OwnerID, sourceRepoID)