2017-04-21 19:32:31 +08:00
|
|
|
// Copyright 2017 Gitea. All rights reserved.
|
2022-11-28 02:20:29 +08:00
|
|
|
// SPDX-License-Identifier: MIT
|
2017-04-21 19:32:31 +08:00
|
|
|
|
2022-06-12 23:51:54 +08:00
|
|
|
package git
|
2017-04-21 19:32:31 +08:00
|
|
|
|
|
|
|
import (
|
2021-12-10 09:27:50 +08:00
|
|
|
"context"
|
2019-06-30 15:57:59 +08:00
|
|
|
"crypto/sha1"
|
2022-12-01 00:41:49 +08:00
|
|
|
"errors"
|
2017-04-21 19:32:31 +08:00
|
|
|
"fmt"
|
2021-11-17 02:18:25 +08:00
|
|
|
"net/url"
|
2022-12-02 11:15:36 +08:00
|
|
|
"strconv"
|
2017-04-21 19:32:31 +08:00
|
|
|
"strings"
|
2019-09-18 13:39:45 +08:00
|
|
|
"time"
|
2017-04-21 19:32:31 +08:00
|
|
|
|
2021-12-10 16:14:24 +08:00
|
|
|
asymkey_model "code.gitea.io/gitea/models/asymkey"
|
2021-09-19 19:49:59 +08:00
|
|
|
"code.gitea.io/gitea/models/db"
|
2021-12-10 09:27:50 +08:00
|
|
|
repo_model "code.gitea.io/gitea/models/repo"
|
2021-11-24 17:49:20 +08:00
|
|
|
user_model "code.gitea.io/gitea/models/user"
|
2022-06-12 23:51:54 +08:00
|
|
|
"code.gitea.io/gitea/modules/git"
|
2017-04-21 19:32:31 +08:00
|
|
|
"code.gitea.io/gitea/modules/log"
|
|
|
|
"code.gitea.io/gitea/modules/setting"
|
2019-05-11 18:21:34 +08:00
|
|
|
api "code.gitea.io/gitea/modules/structs"
|
2019-08-15 22:46:21 +08:00
|
|
|
"code.gitea.io/gitea/modules/timeutil"
|
2019-07-25 18:55:06 +08:00
|
|
|
|
2023-05-14 05:59:01 +08:00
|
|
|
"xorm.io/builder"
|
2019-10-17 17:26:49 +08:00
|
|
|
"xorm.io/xorm"
|
2017-04-21 19:32:31 +08:00
|
|
|
)
|
|
|
|
|
|
|
|
// CommitStatus holds a single Status of a single Commit
|
|
|
|
type CommitStatus struct {
|
2021-12-10 09:27:50 +08:00
|
|
|
ID int64 `xorm:"pk autoincr"`
|
|
|
|
Index int64 `xorm:"INDEX UNIQUE(repo_sha_index)"`
|
|
|
|
RepoID int64 `xorm:"INDEX UNIQUE(repo_sha_index)"`
|
|
|
|
Repo *repo_model.Repository `xorm:"-"`
|
|
|
|
State api.CommitStatusState `xorm:"VARCHAR(7) NOT NULL"`
|
|
|
|
SHA string `xorm:"VARCHAR(64) NOT NULL INDEX UNIQUE(repo_sha_index)"`
|
|
|
|
TargetURL string `xorm:"TEXT"`
|
|
|
|
Description string `xorm:"TEXT"`
|
|
|
|
ContextHash string `xorm:"char(40) index"`
|
|
|
|
Context string `xorm:"TEXT"`
|
|
|
|
Creator *user_model.User `xorm:"-"`
|
2017-04-21 19:32:31 +08:00
|
|
|
CreatorID int64
|
|
|
|
|
2019-08-15 22:46:21 +08:00
|
|
|
CreatedUnix timeutil.TimeStamp `xorm:"INDEX created"`
|
|
|
|
UpdatedUnix timeutil.TimeStamp `xorm:"INDEX updated"`
|
2017-04-21 19:32:31 +08:00
|
|
|
}
|
|
|
|
|
2021-09-19 19:49:59 +08:00
|
|
|
func init() {
|
|
|
|
db.RegisterModel(new(CommitStatus))
|
2021-09-23 18:50:06 +08:00
|
|
|
db.RegisterModel(new(CommitStatusIndex))
|
|
|
|
}
|
|
|
|
|
2022-12-02 11:15:36 +08:00
|
|
|
func postgresGetCommitStatusIndex(ctx context.Context, repoID int64, sha string) (int64, error) {
|
|
|
|
res, err := db.GetEngine(ctx).Query("INSERT INTO `commit_status_index` (repo_id, sha, max_index) "+
|
|
|
|
"VALUES (?,?,1) ON CONFLICT (repo_id, sha) DO UPDATE SET max_index = `commit_status_index`.max_index+1 RETURNING max_index",
|
|
|
|
repoID, sha)
|
|
|
|
if err != nil {
|
|
|
|
return 0, err
|
|
|
|
}
|
|
|
|
if len(res) == 0 {
|
|
|
|
return 0, db.ErrGetResourceIndexFailed
|
|
|
|
}
|
|
|
|
return strconv.ParseInt(string(res[0]["max_index"]), 10, 64)
|
|
|
|
}
|
|
|
|
|
2021-09-23 18:50:06 +08:00
|
|
|
// GetNextCommitStatusIndex retried 3 times to generate a resource index
|
2022-12-01 00:41:49 +08:00
|
|
|
func GetNextCommitStatusIndex(ctx context.Context, repoID int64, sha string) (int64, error) {
|
2023-03-07 18:51:06 +08:00
|
|
|
if setting.Database.Type.IsPostgreSQL() {
|
2022-12-02 11:15:36 +08:00
|
|
|
return postgresGetCommitStatusIndex(ctx, repoID, sha)
|
|
|
|
}
|
|
|
|
|
2022-12-01 00:41:49 +08:00
|
|
|
e := db.GetEngine(ctx)
|
2021-09-23 18:50:06 +08:00
|
|
|
|
2022-12-01 00:41:49 +08:00
|
|
|
// try to update the max_index to next value, and acquire the write-lock for the record
|
|
|
|
res, err := e.Exec("UPDATE `commit_status_index` SET max_index=max_index+1 WHERE repo_id=? AND sha=?", repoID, sha)
|
2021-09-23 18:50:06 +08:00
|
|
|
if err != nil {
|
|
|
|
return 0, err
|
|
|
|
}
|
2022-12-01 00:41:49 +08:00
|
|
|
affected, err := res.RowsAffected()
|
2021-09-23 18:50:06 +08:00
|
|
|
if err != nil {
|
|
|
|
return 0, err
|
|
|
|
}
|
2022-12-01 00:41:49 +08:00
|
|
|
if affected == 0 {
|
|
|
|
// this slow path is only for the first time of creating a resource index
|
|
|
|
_, errIns := e.Exec("INSERT INTO `commit_status_index` (repo_id, sha, max_index) VALUES (?, ?, 0)", repoID, sha)
|
|
|
|
res, err = e.Exec("UPDATE `commit_status_index` SET max_index=max_index+1 WHERE repo_id=? AND sha=?", repoID, sha)
|
|
|
|
if err != nil {
|
|
|
|
return 0, err
|
|
|
|
}
|
|
|
|
affected, err = res.RowsAffected()
|
|
|
|
if err != nil {
|
|
|
|
return 0, err
|
|
|
|
}
|
|
|
|
// if the update still can not update any records, the record must not exist and there must be some errors (insert error)
|
|
|
|
if affected == 0 {
|
|
|
|
if errIns == nil {
|
|
|
|
return 0, errors.New("impossible error when GetNextCommitStatusIndex, insert and update both succeeded but no record is updated")
|
|
|
|
}
|
|
|
|
return 0, errIns
|
|
|
|
}
|
2021-09-23 18:50:06 +08:00
|
|
|
}
|
|
|
|
|
2022-12-01 00:41:49 +08:00
|
|
|
// now, the new index is in database (protected by the transaction and write-lock)
|
|
|
|
var newIdx int64
|
|
|
|
has, err := e.SQL("SELECT max_index FROM `commit_status_index` WHERE repo_id=? AND sha=?", repoID, sha).Get(&newIdx)
|
2021-09-23 18:50:06 +08:00
|
|
|
if err != nil {
|
|
|
|
return 0, err
|
|
|
|
}
|
|
|
|
if !has {
|
2022-12-01 00:41:49 +08:00
|
|
|
return 0, errors.New("impossible error when GetNextCommitStatusIndex, upsert succeeded but no record can be selected")
|
2021-09-23 18:50:06 +08:00
|
|
|
}
|
2022-12-01 00:41:49 +08:00
|
|
|
return newIdx, nil
|
2021-09-19 19:49:59 +08:00
|
|
|
}
|
|
|
|
|
2021-12-10 09:27:50 +08:00
|
|
|
func (status *CommitStatus) loadAttributes(ctx context.Context) (err error) {
|
2017-04-21 19:32:31 +08:00
|
|
|
if status.Repo == nil {
|
2022-12-03 10:48:26 +08:00
|
|
|
status.Repo, err = repo_model.GetRepositoryByID(ctx, status.RepoID)
|
2017-04-21 19:32:31 +08:00
|
|
|
if err != nil {
|
2022-10-25 03:29:17 +08:00
|
|
|
return fmt.Errorf("getRepositoryByID [%d]: %w", status.RepoID, err)
|
2017-04-21 19:32:31 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if status.Creator == nil && status.CreatorID > 0 {
|
2022-12-03 10:48:26 +08:00
|
|
|
status.Creator, err = user_model.GetUserByID(ctx, status.CreatorID)
|
2017-04-21 19:32:31 +08:00
|
|
|
if err != nil {
|
2022-10-25 03:29:17 +08:00
|
|
|
return fmt.Errorf("getUserByID [%d]: %w", status.CreatorID, err)
|
2017-04-21 19:32:31 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// APIURL returns the absolute APIURL to this commit-status.
|
2023-01-09 11:50:54 +08:00
|
|
|
func (status *CommitStatus) APIURL(ctx context.Context) string {
|
|
|
|
_ = status.loadAttributes(ctx)
|
2021-11-17 02:18:25 +08:00
|
|
|
return status.Repo.APIURL() + "/statuses/" + url.PathEscape(status.SHA)
|
2017-04-21 19:32:31 +08:00
|
|
|
}
|
|
|
|
|
2017-09-14 14:51:32 +08:00
|
|
|
// CalcCommitStatus returns commit status state via some status, the commit statues should order by id desc
|
|
|
|
func CalcCommitStatus(statuses []*CommitStatus) *CommitStatus {
|
|
|
|
var lastStatus *CommitStatus
|
2020-01-22 11:46:04 +08:00
|
|
|
var state api.CommitStatusState
|
2017-09-14 14:51:32 +08:00
|
|
|
for _, status := range statuses {
|
2020-01-22 11:46:04 +08:00
|
|
|
if status.State.NoBetterThan(state) {
|
2017-09-14 14:51:32 +08:00
|
|
|
state = status.State
|
|
|
|
lastStatus = status
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if lastStatus == nil {
|
|
|
|
if len(statuses) > 0 {
|
|
|
|
lastStatus = statuses[0]
|
|
|
|
} else {
|
|
|
|
lastStatus = &CommitStatus{}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return lastStatus
|
|
|
|
}
|
|
|
|
|
2019-07-25 18:55:06 +08:00
|
|
|
// CommitStatusOptions holds the options for query commit statuses
|
|
|
|
type CommitStatusOptions struct {
|
2021-09-24 19:32:56 +08:00
|
|
|
db.ListOptions
|
2019-07-25 18:55:06 +08:00
|
|
|
State string
|
|
|
|
SortType string
|
|
|
|
}
|
|
|
|
|
2017-04-21 19:32:31 +08:00
|
|
|
// GetCommitStatuses returns all statuses for a given commit.
|
2023-01-09 11:50:54 +08:00
|
|
|
func GetCommitStatuses(ctx context.Context, repo *repo_model.Repository, sha string, opts *CommitStatusOptions) ([]*CommitStatus, int64, error) {
|
2019-07-25 18:55:06 +08:00
|
|
|
if opts.Page <= 0 {
|
|
|
|
opts.Page = 1
|
|
|
|
}
|
2020-01-25 03:00:29 +08:00
|
|
|
if opts.PageSize <= 0 {
|
2022-06-12 23:51:54 +08:00
|
|
|
opts.Page = setting.ItemsPerPage
|
2020-01-25 03:00:29 +08:00
|
|
|
}
|
2019-07-25 18:55:06 +08:00
|
|
|
|
2023-01-09 11:50:54 +08:00
|
|
|
countSession := listCommitStatusesStatement(ctx, repo, sha, opts)
|
2021-09-24 19:32:56 +08:00
|
|
|
countSession = db.SetSessionPagination(countSession, opts)
|
2019-07-25 18:55:06 +08:00
|
|
|
maxResults, err := countSession.Count(new(CommitStatus))
|
|
|
|
if err != nil {
|
|
|
|
log.Error("Count PRs: %v", err)
|
|
|
|
return nil, maxResults, err
|
|
|
|
}
|
|
|
|
|
2020-01-25 03:00:29 +08:00
|
|
|
statuses := make([]*CommitStatus, 0, opts.PageSize)
|
2023-01-09 11:50:54 +08:00
|
|
|
findSession := listCommitStatusesStatement(ctx, repo, sha, opts)
|
2021-09-24 19:32:56 +08:00
|
|
|
findSession = db.SetSessionPagination(findSession, opts)
|
2019-07-25 18:55:06 +08:00
|
|
|
sortCommitStatusesSession(findSession, opts.SortType)
|
|
|
|
return statuses, maxResults, findSession.Find(&statuses)
|
|
|
|
}
|
|
|
|
|
2023-01-09 11:50:54 +08:00
|
|
|
func listCommitStatusesStatement(ctx context.Context, repo *repo_model.Repository, sha string, opts *CommitStatusOptions) *xorm.Session {
|
|
|
|
sess := db.GetEngine(ctx).Where("repo_id = ?", repo.ID).And("sha = ?", sha)
|
2019-07-25 18:55:06 +08:00
|
|
|
switch opts.State {
|
|
|
|
case "pending", "success", "error", "failure", "warning":
|
|
|
|
sess.And("state = ?", opts.State)
|
|
|
|
}
|
|
|
|
return sess
|
|
|
|
}
|
|
|
|
|
|
|
|
func sortCommitStatusesSession(sess *xorm.Session, sortType string) {
|
|
|
|
switch sortType {
|
|
|
|
case "oldest":
|
|
|
|
sess.Asc("created_unix")
|
|
|
|
case "recentupdate":
|
|
|
|
sess.Desc("updated_unix")
|
|
|
|
case "leastupdate":
|
|
|
|
sess.Asc("updated_unix")
|
|
|
|
case "leastindex":
|
|
|
|
sess.Desc("index")
|
|
|
|
case "highestindex":
|
|
|
|
sess.Asc("index")
|
|
|
|
default:
|
|
|
|
sess.Desc("created_unix")
|
|
|
|
}
|
2017-04-21 19:32:31 +08:00
|
|
|
}
|
|
|
|
|
2021-09-23 18:50:06 +08:00
|
|
|
// CommitStatusIndex represents a table for commit status index
|
|
|
|
type CommitStatusIndex struct {
|
|
|
|
ID int64
|
|
|
|
RepoID int64 `xorm:"unique(repo_sha)"`
|
|
|
|
SHA string `xorm:"unique(repo_sha)"`
|
|
|
|
MaxIndex int64 `xorm:"index"`
|
|
|
|
}
|
|
|
|
|
2017-04-21 19:32:31 +08:00
|
|
|
// GetLatestCommitStatus returns all statuses with a unique context for a given commit.
|
2022-05-20 22:08:52 +08:00
|
|
|
func GetLatestCommitStatus(ctx context.Context, repoID int64, sha string, listOptions db.ListOptions) ([]*CommitStatus, int64, error) {
|
2017-05-07 22:40:31 +08:00
|
|
|
ids := make([]int64, 0, 10)
|
2022-04-28 19:48:48 +08:00
|
|
|
sess := db.GetEngine(ctx).Table(&CommitStatus{}).
|
2020-12-18 11:33:32 +08:00
|
|
|
Where("repo_id = ?", repoID).And("sha = ?", sha).
|
2017-05-07 22:40:31 +08:00
|
|
|
Select("max( id ) as id").
|
2020-12-18 11:33:32 +08:00
|
|
|
GroupBy("context_hash").OrderBy("max( id ) desc")
|
|
|
|
|
2021-09-24 19:32:56 +08:00
|
|
|
sess = db.SetSessionPagination(sess, &listOptions)
|
2020-12-18 11:33:32 +08:00
|
|
|
|
2021-12-15 13:39:34 +08:00
|
|
|
count, err := sess.FindAndCount(&ids)
|
2017-05-07 22:40:31 +08:00
|
|
|
if err != nil {
|
2021-12-15 13:39:34 +08:00
|
|
|
return nil, count, err
|
2017-05-07 22:40:31 +08:00
|
|
|
}
|
|
|
|
statuses := make([]*CommitStatus, 0, len(ids))
|
|
|
|
if len(ids) == 0 {
|
2021-12-15 13:39:34 +08:00
|
|
|
return statuses, count, nil
|
2017-05-07 22:40:31 +08:00
|
|
|
}
|
2022-04-28 19:48:48 +08:00
|
|
|
return statuses, count, db.GetEngine(ctx).In("id", ids).Find(&statuses)
|
2017-04-21 19:32:31 +08:00
|
|
|
}
|
|
|
|
|
2023-05-14 05:59:01 +08:00
|
|
|
// GetLatestCommitStatusForPairs returns all statuses with a unique context for a given list of repo-sha pairs
|
|
|
|
func GetLatestCommitStatusForPairs(ctx context.Context, repoIDsToLatestCommitSHAs map[int64]string, listOptions db.ListOptions) (map[int64][]*CommitStatus, error) {
|
|
|
|
type result struct {
|
|
|
|
ID int64
|
|
|
|
RepoID int64
|
|
|
|
}
|
|
|
|
|
|
|
|
results := make([]result, 0, len(repoIDsToLatestCommitSHAs))
|
|
|
|
|
|
|
|
sess := db.GetEngine(ctx).Table(&CommitStatus{})
|
|
|
|
|
|
|
|
// Create a disjunction of conditions for each repoID and SHA pair
|
|
|
|
conds := make([]builder.Cond, 0, len(repoIDsToLatestCommitSHAs))
|
|
|
|
for repoID, sha := range repoIDsToLatestCommitSHAs {
|
|
|
|
conds = append(conds, builder.Eq{"repo_id": repoID, "sha": sha})
|
|
|
|
}
|
|
|
|
sess = sess.Where(builder.Or(conds...)).
|
|
|
|
Select("max( id ) as id, repo_id").
|
|
|
|
GroupBy("context_hash, repo_id").OrderBy("max( id ) desc")
|
|
|
|
|
|
|
|
sess = db.SetSessionPagination(sess, &listOptions)
|
|
|
|
|
|
|
|
err := sess.Find(&results)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
ids := make([]int64, 0, len(results))
|
|
|
|
repoStatuses := make(map[int64][]*CommitStatus)
|
|
|
|
for _, result := range results {
|
|
|
|
ids = append(ids, result.ID)
|
|
|
|
}
|
|
|
|
|
|
|
|
statuses := make([]*CommitStatus, 0, len(ids))
|
|
|
|
if len(ids) > 0 {
|
|
|
|
err = db.GetEngine(ctx).In("id", ids).Find(&statuses)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Group the statuses by repo ID
|
|
|
|
for _, status := range statuses {
|
|
|
|
repoStatuses[status.RepoID] = append(repoStatuses[status.RepoID], status)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return repoStatuses, nil
|
|
|
|
}
|
|
|
|
|
2019-09-18 13:39:45 +08:00
|
|
|
// FindRepoRecentCommitStatusContexts returns repository's recent commit status contexts
|
2023-01-09 11:50:54 +08:00
|
|
|
func FindRepoRecentCommitStatusContexts(ctx context.Context, repoID int64, before time.Duration) ([]string, error) {
|
2019-09-18 13:39:45 +08:00
|
|
|
start := timeutil.TimeStampNow().AddDuration(-before)
|
|
|
|
ids := make([]int64, 0, 10)
|
2023-01-09 11:50:54 +08:00
|
|
|
if err := db.GetEngine(ctx).Table("commit_status").
|
2019-09-18 13:39:45 +08:00
|
|
|
Where("repo_id = ?", repoID).
|
|
|
|
And("updated_unix >= ?", start).
|
|
|
|
Select("max( id ) as id").
|
|
|
|
GroupBy("context_hash").OrderBy("max( id ) desc").
|
|
|
|
Find(&ids); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2021-03-15 02:52:12 +08:00
|
|
|
contexts := make([]string, 0, len(ids))
|
2019-09-18 13:39:45 +08:00
|
|
|
if len(ids) == 0 {
|
|
|
|
return contexts, nil
|
|
|
|
}
|
2023-01-09 11:50:54 +08:00
|
|
|
return contexts, db.GetEngine(ctx).Select("context").Table("commit_status").In("id", ids).Find(&contexts)
|
2019-09-18 13:39:45 +08:00
|
|
|
}
|
|
|
|
|
2017-04-21 19:32:31 +08:00
|
|
|
// NewCommitStatusOptions holds options for creating a CommitStatus
|
|
|
|
type NewCommitStatusOptions struct {
|
2021-12-10 09:27:50 +08:00
|
|
|
Repo *repo_model.Repository
|
2021-11-24 17:49:20 +08:00
|
|
|
Creator *user_model.User
|
2017-04-21 19:32:31 +08:00
|
|
|
SHA string
|
|
|
|
CommitStatus *CommitStatus
|
|
|
|
}
|
|
|
|
|
2019-06-30 15:57:59 +08:00
|
|
|
// NewCommitStatus save commit statuses into database
|
2023-01-09 11:50:54 +08:00
|
|
|
func NewCommitStatus(ctx context.Context, opts NewCommitStatusOptions) error {
|
2017-04-21 19:32:31 +08:00
|
|
|
if opts.Repo == nil {
|
2019-06-30 15:57:59 +08:00
|
|
|
return fmt.Errorf("NewCommitStatus[nil, %s]: no repository specified", opts.SHA)
|
2017-04-21 19:32:31 +08:00
|
|
|
}
|
|
|
|
|
2019-06-30 15:57:59 +08:00
|
|
|
repoPath := opts.Repo.RepoPath()
|
2017-04-21 19:32:31 +08:00
|
|
|
if opts.Creator == nil {
|
2019-06-30 15:57:59 +08:00
|
|
|
return fmt.Errorf("NewCommitStatus[%s, %s]: no user specified", repoPath, opts.SHA)
|
2017-04-21 19:32:31 +08:00
|
|
|
}
|
|
|
|
|
2022-12-27 21:12:49 +08:00
|
|
|
if _, err := git.NewIDFromString(opts.SHA); err != nil {
|
|
|
|
return fmt.Errorf("NewCommitStatus[%s, %s]: invalid sha: %w", repoPath, opts.SHA, err)
|
|
|
|
}
|
|
|
|
|
2023-01-09 11:50:54 +08:00
|
|
|
ctx, committer, err := db.TxContext(ctx)
|
2021-09-19 19:49:59 +08:00
|
|
|
if err != nil {
|
2022-10-25 03:29:17 +08:00
|
|
|
return fmt.Errorf("NewCommitStatus[repo_id: %d, user_id: %d, sha: %s]: %w", opts.Repo.ID, opts.Creator.ID, opts.SHA, err)
|
2017-04-21 19:32:31 +08:00
|
|
|
}
|
2021-09-19 19:49:59 +08:00
|
|
|
defer committer.Close()
|
2017-04-21 19:32:31 +08:00
|
|
|
|
2022-12-01 00:41:49 +08:00
|
|
|
// Get the next Status Index
|
|
|
|
idx, err := GetNextCommitStatusIndex(ctx, opts.Repo.ID, opts.SHA)
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("generate commit status index failed: %w", err)
|
|
|
|
}
|
|
|
|
|
2019-06-30 15:57:59 +08:00
|
|
|
opts.CommitStatus.Description = strings.TrimSpace(opts.CommitStatus.Description)
|
|
|
|
opts.CommitStatus.Context = strings.TrimSpace(opts.CommitStatus.Context)
|
|
|
|
opts.CommitStatus.TargetURL = strings.TrimSpace(opts.CommitStatus.TargetURL)
|
|
|
|
opts.CommitStatus.SHA = opts.SHA
|
|
|
|
opts.CommitStatus.CreatorID = opts.Creator.ID
|
|
|
|
opts.CommitStatus.RepoID = opts.Repo.ID
|
2021-09-23 18:50:06 +08:00
|
|
|
opts.CommitStatus.Index = idx
|
2019-06-30 15:57:59 +08:00
|
|
|
log.Debug("NewCommitStatus[%s, %s]: %d", repoPath, opts.SHA, opts.CommitStatus.Index)
|
|
|
|
|
|
|
|
opts.CommitStatus.ContextHash = hashCommitStatusContext(opts.CommitStatus.Context)
|
2017-04-21 19:32:31 +08:00
|
|
|
|
|
|
|
// Insert new CommitStatus
|
2021-09-23 23:45:36 +08:00
|
|
|
if _, err = db.GetEngine(ctx).Insert(opts.CommitStatus); err != nil {
|
2022-12-01 00:41:49 +08:00
|
|
|
return fmt.Errorf("insert CommitStatus[%s, %s]: %w", repoPath, opts.SHA, err)
|
2017-04-21 19:32:31 +08:00
|
|
|
}
|
|
|
|
|
2021-09-19 19:49:59 +08:00
|
|
|
return committer.Commit()
|
2017-04-21 19:32:31 +08:00
|
|
|
}
|
2017-05-07 22:40:31 +08:00
|
|
|
|
|
|
|
// SignCommitWithStatuses represents a commit with validation of signature and status state.
|
|
|
|
type SignCommitWithStatuses struct {
|
2020-12-20 11:13:12 +08:00
|
|
|
Status *CommitStatus
|
|
|
|
Statuses []*CommitStatus
|
2021-12-10 16:14:24 +08:00
|
|
|
*asymkey_model.SignCommit
|
2017-05-07 22:40:31 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// ParseCommitsWithStatus checks commits latest statuses and calculates its worst status state
|
2023-01-09 11:50:54 +08:00
|
|
|
func ParseCommitsWithStatus(ctx context.Context, oldCommits []*asymkey_model.SignCommit, repo *repo_model.Repository) []*SignCommitWithStatuses {
|
2021-08-10 02:08:51 +08:00
|
|
|
newCommits := make([]*SignCommitWithStatuses, 0, len(oldCommits))
|
|
|
|
|
|
|
|
for _, c := range oldCommits {
|
|
|
|
commit := &SignCommitWithStatuses{
|
|
|
|
SignCommit: c,
|
2017-05-07 22:40:31 +08:00
|
|
|
}
|
2023-01-09 11:50:54 +08:00
|
|
|
statuses, _, err := GetLatestCommitStatus(ctx, repo.ID, commit.ID.String(), db.ListOptions{})
|
2017-05-07 22:40:31 +08:00
|
|
|
if err != nil {
|
2019-04-02 15:48:31 +08:00
|
|
|
log.Error("GetLatestCommitStatus: %v", err)
|
2017-05-07 22:40:31 +08:00
|
|
|
} else {
|
2020-12-20 11:13:12 +08:00
|
|
|
commit.Statuses = statuses
|
2017-09-14 14:51:32 +08:00
|
|
|
commit.Status = CalcCommitStatus(statuses)
|
2017-05-07 22:40:31 +08:00
|
|
|
}
|
|
|
|
|
2021-08-10 02:08:51 +08:00
|
|
|
newCommits = append(newCommits, commit)
|
2017-05-07 22:40:31 +08:00
|
|
|
}
|
|
|
|
return newCommits
|
|
|
|
}
|
2019-06-30 15:57:59 +08:00
|
|
|
|
|
|
|
// hashCommitStatusContext hash context
|
|
|
|
func hashCommitStatusContext(context string) string {
|
|
|
|
return fmt.Sprintf("%x", sha1.Sum([]byte(context)))
|
|
|
|
}
|
2022-06-12 23:51:54 +08:00
|
|
|
|
|
|
|
// ConvertFromGitCommit converts git commits into SignCommitWithStatuses
|
2023-01-09 11:50:54 +08:00
|
|
|
func ConvertFromGitCommit(ctx context.Context, commits []*git.Commit, repo *repo_model.Repository) []*SignCommitWithStatuses {
|
|
|
|
return ParseCommitsWithStatus(ctx,
|
2022-06-12 23:51:54 +08:00
|
|
|
asymkey_model.ParseCommitsWithSignature(
|
Add context cache as a request level cache (#22294)
To avoid duplicated load of the same data in an HTTP request, we can set
a context cache to do that. i.e. Some pages may load a user from a
database with the same id in different areas on the same page. But the
code is hidden in two different deep logic. How should we share the
user? As a result of this PR, now if both entry functions accept
`context.Context` as the first parameter and we just need to refactor
`GetUserByID` to reuse the user from the context cache. Then it will not
be loaded twice on an HTTP request.
But of course, sometimes we would like to reload an object from the
database, that's why `RemoveContextData` is also exposed.
The core context cache is here. It defines a new context
```go
type cacheContext struct {
ctx context.Context
data map[any]map[any]any
lock sync.RWMutex
}
var cacheContextKey = struct{}{}
func WithCacheContext(ctx context.Context) context.Context {
return context.WithValue(ctx, cacheContextKey, &cacheContext{
ctx: ctx,
data: make(map[any]map[any]any),
})
}
```
Then you can use the below 4 methods to read/write/del the data within
the same context.
```go
func GetContextData(ctx context.Context, tp, key any) any
func SetContextData(ctx context.Context, tp, key, value any)
func RemoveContextData(ctx context.Context, tp, key any)
func GetWithContextCache[T any](ctx context.Context, cacheGroupKey string, cacheTargetID any, f func() (T, error)) (T, error)
```
Then let's take a look at how `system.GetString` implement it.
```go
func GetSetting(ctx context.Context, key string) (string, error) {
return cache.GetWithContextCache(ctx, contextCacheKey, key, func() (string, error) {
return cache.GetString(genSettingCacheKey(key), func() (string, error) {
res, err := GetSettingNoCache(ctx, key)
if err != nil {
return "", err
}
return res.SettingValue, nil
})
})
}
```
First, it will check if context data include the setting object with the
key. If not, it will query from the global cache which may be memory or
a Redis cache. If not, it will get the object from the database. In the
end, if the object gets from the global cache or database, it will be
set into the context cache.
An object stored in the context cache will only be destroyed after the
context disappeared.
2023-02-15 21:37:34 +08:00
|
|
|
ctx,
|
|
|
|
user_model.ValidateCommitsWithEmails(ctx, commits),
|
2022-06-12 23:51:54 +08:00
|
|
|
repo.GetTrustModel(),
|
|
|
|
func(user *user_model.User) (bool, error) {
|
|
|
|
return repo_model.IsOwnerMemberCollaborator(repo, user.ID)
|
|
|
|
},
|
|
|
|
),
|
|
|
|
repo,
|
|
|
|
)
|
|
|
|
}
|