mirror of
https://github.com/go-gitea/gitea.git
synced 2026-10-13 06:32:16 +09:00
d29364a4f6
Backport #39721 by @bircni Fixes a few Actions bugs where user input or nondeterminism caused failures: - The job log view indexed task steps with the client-supplied cursor step without a bounds check, so an out-of-range value panicked and returned a 500. - Workflow activity type filters (`types:`) were compiled with `glob.MustCompile`, so an invalid pattern in a workflow file panicked during event detection. Invalid patterns now simply don't match. - Listing workflow runs with an unknown `actor` returned a 500; it now returns 404. - The v4 artifact `ListArtifacts` response was built by ranging over a map, so its order changed between calls. It now follows database order. - The error from marshalling a workflow job when inserting run jobs was silently ignored. Co-authored-by: bircni <bircni@icloud.com> Co-authored-by: wxiaoguang <wxiaoguang@gmail.com>
108 lines
2.8 KiB
Go
108 lines
2.8 KiB
Go
// Copyright 2022 The Gitea Authors. All rights reserved.
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
package git
|
|
|
|
import (
|
|
"context"
|
|
"sort"
|
|
|
|
"gitea.dev/models/db"
|
|
"gitea.dev/modules/glob"
|
|
"gitea.dev/modules/log"
|
|
"gitea.dev/modules/optional"
|
|
)
|
|
|
|
type ProtectedBranchRules []*ProtectedBranch
|
|
|
|
func (rules ProtectedBranchRules) GetFirstMatched(branchName string) *ProtectedBranch {
|
|
for _, rule := range rules {
|
|
if rule.Match(branchName) {
|
|
return rule
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (rules ProtectedBranchRules) sort() {
|
|
sort.Slice(rules, func(i, j int) bool {
|
|
rules[i].loadGlob()
|
|
rules[j].loadGlob()
|
|
|
|
// if priority differ, use that to sort
|
|
if rules[i].Priority != rules[j].Priority {
|
|
return rules[i].Priority < rules[j].Priority
|
|
}
|
|
|
|
// now we sort the old way
|
|
if rules[i].isPlainName != rules[j].isPlainName {
|
|
return rules[i].isPlainName // plain name comes first, so plain name means "less"
|
|
}
|
|
return rules[i].CreatedUnix < rules[j].CreatedUnix
|
|
})
|
|
}
|
|
|
|
// FindRepoProtectedBranchRules load all repository's protected rules
|
|
func FindRepoProtectedBranchRules(ctx context.Context, repoID int64) (ProtectedBranchRules, error) {
|
|
var rules ProtectedBranchRules
|
|
err := db.GetEngine(ctx).Where("repo_id = ?", repoID).Asc("created_unix").Find(&rules)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
rules.sort() // to make non-glob rules have higher priority, and for same glob/non-glob rules, first created rules have higher priority
|
|
return rules, nil
|
|
}
|
|
|
|
// FindAllMatchedBranches find all matched branches
|
|
func FindAllMatchedBranches(ctx context.Context, repoID int64, ruleName string) ([]string, error) {
|
|
results := make([]string, 0, 10)
|
|
rule, err := glob.Compile(ruleName)
|
|
if err != nil {
|
|
log.Debug("Failed to compile rule %s: %v", ruleName, err)
|
|
return results, nil
|
|
}
|
|
|
|
const pageSize = 100
|
|
for page := 1; ; page++ {
|
|
branchNames, err := FindBranchNames(ctx, FindBranchOptions{
|
|
ListOptions: db.ListOptions{
|
|
PageSize: pageSize,
|
|
Page: page,
|
|
},
|
|
RepoID: repoID,
|
|
IsDeletedBranch: optional.Some(false),
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, branch := range branchNames {
|
|
if rule.Match(branch) {
|
|
results = append(results, branch)
|
|
}
|
|
}
|
|
if len(branchNames) < pageSize {
|
|
break
|
|
}
|
|
}
|
|
|
|
return results, nil
|
|
}
|
|
|
|
// GetFirstMatchProtectedBranchRule returns the first matched rules
|
|
func GetFirstMatchProtectedBranchRule(ctx context.Context, repoID int64, branchName string) (*ProtectedBranch, error) {
|
|
rules, err := FindRepoProtectedBranchRules(ctx, repoID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return rules.GetFirstMatched(branchName), nil
|
|
}
|
|
|
|
// IsBranchProtected checks if branch is protected
|
|
func IsBranchProtected(ctx context.Context, repoID int64, branchName string) (bool, error) {
|
|
rule, err := GetFirstMatchProtectedBranchRule(ctx, repoID, branchName)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
return rule != nil, nil
|
|
}
|