2021-06-07 22:52:59 +08:00
|
|
|
// Copyright 2021 The Gitea Authors. All rights reserved.
|
2022-11-28 02:20:29 +08:00
|
|
|
// SPDX-License-Identifier: MIT
|
2021-06-07 22:52:59 +08:00
|
|
|
|
|
|
|
package repository
|
|
|
|
|
|
|
|
import (
|
2021-12-09 03:08:16 +08:00
|
|
|
"context"
|
2021-06-07 22:52:59 +08:00
|
|
|
"errors"
|
2021-11-17 23:17:31 +08:00
|
|
|
"fmt"
|
2021-12-09 03:08:16 +08:00
|
|
|
"strings"
|
2021-06-07 22:52:59 +08:00
|
|
|
|
|
|
|
"code.gitea.io/gitea/models"
|
2024-01-13 05:50:38 +08:00
|
|
|
actions_model "code.gitea.io/gitea/models/actions"
|
2023-06-29 18:03:20 +08:00
|
|
|
"code.gitea.io/gitea/models/db"
|
2022-06-12 23:51:54 +08:00
|
|
|
git_model "code.gitea.io/gitea/models/git"
|
2023-06-29 18:03:20 +08:00
|
|
|
issues_model "code.gitea.io/gitea/models/issues"
|
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"
|
2024-03-08 18:21:24 +08:00
|
|
|
"code.gitea.io/gitea/modules/cache"
|
2021-06-07 22:52:59 +08:00
|
|
|
"code.gitea.io/gitea/modules/git"
|
Simplify how git repositories are opened (#28937)
## Purpose
This is a refactor toward building an abstraction over managing git
repositories.
Afterwards, it does not matter anymore if they are stored on the local
disk or somewhere remote.
## What this PR changes
We used `git.OpenRepository` everywhere previously.
Now, we should split them into two distinct functions:
Firstly, there are temporary repositories which do not change:
```go
git.OpenRepository(ctx, diskPath)
```
Gitea managed repositories having a record in the database in the
`repository` table are moved into the new package `gitrepo`:
```go
gitrepo.OpenRepository(ctx, repo_model.Repo)
```
Why is `repo_model.Repository` the second parameter instead of file
path?
Because then we can easily adapt our repository storage strategy.
The repositories can be stored locally, however, they could just as well
be stored on a remote server.
## Further changes in other PRs
- A Git Command wrapper on package `gitrepo` could be created. i.e.
`NewCommand(ctx, repo_model.Repository, commands...)`. `git.RunOpts{Dir:
repo.RepoPath()}`, the directory should be empty before invoking this
method and it can be filled in the function only. #28940
- Remove the `RepoPath()`/`WikiPath()` functions to reduce the
possibility of mistakes.
---------
Co-authored-by: delvh <dev.lh@web.de>
2024-01-28 04:09:51 +08:00
|
|
|
"code.gitea.io/gitea/modules/gitrepo"
|
2023-06-29 18:03:20 +08:00
|
|
|
"code.gitea.io/gitea/modules/graceful"
|
2024-03-08 18:21:24 +08:00
|
|
|
"code.gitea.io/gitea/modules/json"
|
2021-06-07 22:52:59 +08:00
|
|
|
"code.gitea.io/gitea/modules/log"
|
2024-02-23 10:18:33 +08:00
|
|
|
"code.gitea.io/gitea/modules/optional"
|
2023-06-29 18:03:20 +08:00
|
|
|
"code.gitea.io/gitea/modules/queue"
|
2021-06-07 22:52:59 +08:00
|
|
|
repo_module "code.gitea.io/gitea/modules/repository"
|
Also sync DB branches on push if necessary (#28361)
Fix #28056
This PR will check whether the repo has zero branch when pushing a
branch. If that, it means this repository hasn't been synced.
The reason caused that is after user upgrade from v1.20 -> v1.21, he
just push branches without visit the repository user interface. Because
all repositories routers will check whether a branches sync is necessary
but push has not such check.
For every repository, it has two states, synced or not synced. If there
is zero branch for a repository, then it will be assumed as non-sync
state. Otherwise, it's synced state. So if we think it's synced, we just
need to update branch/insert new branch. Otherwise do a full sync. So
that, for every push, there will be almost no extra load added. It's
high performance than yours.
For the implementation, we in fact will try to update the branch first,
if updated success with affect records > 0, then all are done. Because
that means the branch has been in the database. If no record is
affected, that means the branch does not exist in database. So there are
two possibilities. One is this is a new branch, then we just need to
insert the record. Another is the branches haven't been synced, then we
need to sync all the branches into database.
2023-12-09 21:30:56 +08:00
|
|
|
"code.gitea.io/gitea/modules/timeutil"
|
2024-04-13 16:38:44 +08:00
|
|
|
"code.gitea.io/gitea/modules/util"
|
2024-01-13 05:50:38 +08:00
|
|
|
webhook_module "code.gitea.io/gitea/modules/webhook"
|
2023-09-06 02:37:47 +08:00
|
|
|
notify_service "code.gitea.io/gitea/services/notify"
|
2023-06-29 18:03:20 +08:00
|
|
|
files_service "code.gitea.io/gitea/services/repository/files"
|
|
|
|
|
|
|
|
"xorm.io/builder"
|
2021-06-07 22:52:59 +08:00
|
|
|
)
|
|
|
|
|
2021-11-17 23:17:31 +08:00
|
|
|
// CreateNewBranch creates a new repository branch
|
Also sync DB branches on push if necessary (#28361)
Fix #28056
This PR will check whether the repo has zero branch when pushing a
branch. If that, it means this repository hasn't been synced.
The reason caused that is after user upgrade from v1.20 -> v1.21, he
just push branches without visit the repository user interface. Because
all repositories routers will check whether a branches sync is necessary
but push has not such check.
For every repository, it has two states, synced or not synced. If there
is zero branch for a repository, then it will be assumed as non-sync
state. Otherwise, it's synced state. So if we think it's synced, we just
need to update branch/insert new branch. Otherwise do a full sync. So
that, for every push, there will be almost no extra load added. It's
high performance than yours.
For the implementation, we in fact will try to update the branch first,
if updated success with affect records > 0, then all are done. Because
that means the branch has been in the database. If no record is
affected, that means the branch does not exist in database. So there are
two possibilities. One is this is a new branch, then we just need to
insert the record. Another is the branches haven't been synced, then we
need to sync all the branches into database.
2023-12-09 21:30:56 +08:00
|
|
|
func CreateNewBranch(ctx context.Context, doer *user_model.User, repo *repo_model.Repository, gitRepo *git.Repository, oldBranchName, branchName string) (err error) {
|
|
|
|
branch, err := git_model.GetBranch(ctx, repo.ID, oldBranchName)
|
2023-09-22 07:43:29 +08:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
Also sync DB branches on push if necessary (#28361)
Fix #28056
This PR will check whether the repo has zero branch when pushing a
branch. If that, it means this repository hasn't been synced.
The reason caused that is after user upgrade from v1.20 -> v1.21, he
just push branches without visit the repository user interface. Because
all repositories routers will check whether a branches sync is necessary
but push has not such check.
For every repository, it has two states, synced or not synced. If there
is zero branch for a repository, then it will be assumed as non-sync
state. Otherwise, it's synced state. So if we think it's synced, we just
need to update branch/insert new branch. Otherwise do a full sync. So
that, for every push, there will be almost no extra load added. It's
high performance than yours.
For the implementation, we in fact will try to update the branch first,
if updated success with affect records > 0, then all are done. Because
that means the branch has been in the database. If no record is
affected, that means the branch does not exist in database. So there are
two possibilities. One is this is a new branch, then we just need to
insert the record. Another is the branches haven't been synced, then we
need to sync all the branches into database.
2023-12-09 21:30:56 +08:00
|
|
|
return CreateNewBranchFromCommit(ctx, doer, repo, gitRepo, branch.CommitID, branchName)
|
2021-11-17 23:17:31 +08:00
|
|
|
}
|
|
|
|
|
2023-06-29 18:03:20 +08:00
|
|
|
// Branch contains the branch information
|
|
|
|
type Branch struct {
|
|
|
|
DBBranch *git_model.Branch
|
|
|
|
IsProtected bool
|
|
|
|
IsIncluded bool
|
|
|
|
CommitsAhead int
|
|
|
|
CommitsBehind int
|
|
|
|
LatestPullRequest *issues_model.PullRequest
|
|
|
|
MergeMovedOn bool
|
|
|
|
}
|
|
|
|
|
|
|
|
// LoadBranches loads branches from the repository limited by page & pageSize.
|
2024-03-02 23:42:31 +08:00
|
|
|
func LoadBranches(ctx context.Context, repo *repo_model.Repository, gitRepo *git.Repository, isDeletedBranch optional.Option[bool], keyword string, page, pageSize int) (*Branch, []*Branch, int64, error) {
|
2023-06-29 18:03:20 +08:00
|
|
|
defaultDBBranch, err := git_model.GetBranch(ctx, repo.ID, repo.DefaultBranch)
|
|
|
|
if err != nil {
|
|
|
|
return nil, nil, 0, err
|
|
|
|
}
|
|
|
|
|
|
|
|
branchOpts := git_model.FindBranchOptions{
|
|
|
|
RepoID: repo.ID,
|
2024-03-02 23:42:31 +08:00
|
|
|
IsDeletedBranch: isDeletedBranch,
|
2023-06-29 18:03:20 +08:00
|
|
|
ListOptions: db.ListOptions{
|
|
|
|
Page: page,
|
|
|
|
PageSize: pageSize,
|
|
|
|
},
|
2024-01-21 22:08:31 +08:00
|
|
|
Keyword: keyword,
|
|
|
|
ExcludeBranchNames: []string{repo.DefaultBranch},
|
2023-06-29 18:03:20 +08:00
|
|
|
}
|
|
|
|
|
2023-12-11 16:56:48 +08:00
|
|
|
dbBranches, totalNumOfBranches, err := db.FindAndCount[git_model.Branch](ctx, branchOpts)
|
2023-06-29 18:03:20 +08:00
|
|
|
if err != nil {
|
|
|
|
return nil, nil, 0, err
|
|
|
|
}
|
|
|
|
|
2023-12-11 16:56:48 +08:00
|
|
|
if err := git_model.BranchList(dbBranches).LoadDeletedBy(ctx); err != nil {
|
2023-06-29 18:03:20 +08:00
|
|
|
return nil, nil, 0, err
|
|
|
|
}
|
2023-12-11 16:56:48 +08:00
|
|
|
if err := git_model.BranchList(dbBranches).LoadPusher(ctx); err != nil {
|
2023-06-29 18:03:20 +08:00
|
|
|
return nil, nil, 0, err
|
|
|
|
}
|
|
|
|
|
|
|
|
rules, err := git_model.FindRepoProtectedBranchRules(ctx, repo.ID)
|
|
|
|
if err != nil {
|
|
|
|
return nil, nil, 0, err
|
|
|
|
}
|
|
|
|
|
|
|
|
repoIDToRepo := map[int64]*repo_model.Repository{}
|
|
|
|
repoIDToRepo[repo.ID] = repo
|
|
|
|
|
|
|
|
repoIDToGitRepo := map[int64]*git.Repository{}
|
|
|
|
repoIDToGitRepo[repo.ID] = gitRepo
|
|
|
|
|
|
|
|
branches := make([]*Branch, 0, len(dbBranches))
|
|
|
|
for i := range dbBranches {
|
|
|
|
branch, err := loadOneBranch(ctx, repo, dbBranches[i], &rules, repoIDToRepo, repoIDToGitRepo)
|
|
|
|
if err != nil {
|
|
|
|
return nil, nil, 0, fmt.Errorf("loadOneBranch: %v", err)
|
|
|
|
}
|
|
|
|
branches = append(branches, branch)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Always add the default branch
|
|
|
|
log.Debug("loadOneBranch: load default: '%s'", defaultDBBranch.Name)
|
|
|
|
defaultBranch, err := loadOneBranch(ctx, repo, defaultDBBranch, &rules, repoIDToRepo, repoIDToGitRepo)
|
|
|
|
if err != nil {
|
|
|
|
return nil, nil, 0, fmt.Errorf("loadOneBranch: %v", err)
|
|
|
|
}
|
|
|
|
return defaultBranch, branches, totalNumOfBranches, nil
|
|
|
|
}
|
|
|
|
|
2024-03-08 18:21:24 +08:00
|
|
|
func getDivergenceCacheKey(repoID int64, branchName string) string {
|
|
|
|
return fmt.Sprintf("%d-%s", repoID, branchName)
|
|
|
|
}
|
|
|
|
|
|
|
|
// getDivergenceFromCache gets the divergence from cache
|
|
|
|
func getDivergenceFromCache(repoID int64, branchName string) (*git.DivergeObject, bool) {
|
2024-04-13 16:38:44 +08:00
|
|
|
data, ok := cache.GetCache().Get(getDivergenceCacheKey(repoID, branchName))
|
2024-03-08 18:21:24 +08:00
|
|
|
res := git.DivergeObject{
|
|
|
|
Ahead: -1,
|
|
|
|
Behind: -1,
|
|
|
|
}
|
2024-04-13 16:38:44 +08:00
|
|
|
if !ok || data == "" {
|
2024-03-08 18:21:24 +08:00
|
|
|
return &res, false
|
|
|
|
}
|
2024-04-13 16:38:44 +08:00
|
|
|
if err := json.Unmarshal(util.UnsafeStringToBytes(data), &res); err != nil {
|
2024-03-08 18:21:24 +08:00
|
|
|
log.Error("json.UnMarshal failed: %v", err)
|
|
|
|
return &res, false
|
|
|
|
}
|
|
|
|
return &res, true
|
|
|
|
}
|
|
|
|
|
|
|
|
func putDivergenceFromCache(repoID int64, branchName string, divergence *git.DivergeObject) error {
|
|
|
|
bs, err := json.Marshal(divergence)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2024-04-13 16:38:44 +08:00
|
|
|
return cache.GetCache().Put(getDivergenceCacheKey(repoID, branchName), util.UnsafeBytesToString(bs), 30*24*60*60)
|
2024-03-08 18:21:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
func DelDivergenceFromCache(repoID int64, branchName string) error {
|
|
|
|
return cache.GetCache().Delete(getDivergenceCacheKey(repoID, branchName))
|
|
|
|
}
|
|
|
|
|
2024-07-20 01:12:23 +08:00
|
|
|
// DelRepoDivergenceFromCache deletes all divergence caches of a repository
|
|
|
|
func DelRepoDivergenceFromCache(ctx context.Context, repoID int64) error {
|
|
|
|
dbBranches, err := db.Find[git_model.Branch](ctx, git_model.FindBranchOptions{
|
|
|
|
RepoID: repoID,
|
|
|
|
ListOptions: db.ListOptionsAll,
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
for i := range dbBranches {
|
|
|
|
if err := DelDivergenceFromCache(repoID, dbBranches[i].Name); err != nil {
|
|
|
|
log.Error("DelDivergenceFromCache: %v", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2023-06-29 18:03:20 +08:00
|
|
|
func loadOneBranch(ctx context.Context, repo *repo_model.Repository, dbBranch *git_model.Branch, protectedBranches *git_model.ProtectedBranchRules,
|
|
|
|
repoIDToRepo map[int64]*repo_model.Repository,
|
|
|
|
repoIDToGitRepo map[int64]*git.Repository,
|
|
|
|
) (*Branch, error) {
|
|
|
|
log.Trace("loadOneBranch: '%s'", dbBranch.Name)
|
|
|
|
|
|
|
|
branchName := dbBranch.Name
|
|
|
|
p := protectedBranches.GetFirstMatched(branchName)
|
|
|
|
isProtected := p != nil
|
|
|
|
|
2024-03-20 23:38:22 +08:00
|
|
|
var divergence *git.DivergeObject
|
2023-06-29 18:03:20 +08:00
|
|
|
|
|
|
|
// it's not default branch
|
|
|
|
if repo.DefaultBranch != dbBranch.Name && !dbBranch.IsDeleted {
|
2024-03-08 18:21:24 +08:00
|
|
|
var cached bool
|
|
|
|
divergence, cached = getDivergenceFromCache(repo.ID, dbBranch.Name)
|
|
|
|
if !cached {
|
|
|
|
var err error
|
|
|
|
divergence, err = files_service.CountDivergingCommits(ctx, repo, git.BranchPrefix+branchName)
|
|
|
|
if err != nil {
|
|
|
|
log.Error("CountDivergingCommits: %v", err)
|
|
|
|
} else {
|
|
|
|
if err = putDivergenceFromCache(repo.ID, dbBranch.Name, divergence); err != nil {
|
|
|
|
log.Error("putDivergenceFromCache: %v", err)
|
|
|
|
}
|
|
|
|
}
|
2023-06-29 18:03:20 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-03-20 23:38:22 +08:00
|
|
|
if divergence == nil {
|
|
|
|
// tolerate the error that we cannot get divergence
|
|
|
|
divergence = &git.DivergeObject{Ahead: -1, Behind: -1}
|
|
|
|
}
|
|
|
|
|
2023-10-11 12:24:07 +08:00
|
|
|
pr, err := issues_model.GetLatestPullRequestByHeadInfo(ctx, repo.ID, branchName)
|
2023-06-29 18:03:20 +08:00
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("GetLatestPullRequestByHeadInfo: %v", err)
|
|
|
|
}
|
|
|
|
headCommit := dbBranch.CommitID
|
|
|
|
|
|
|
|
mergeMovedOn := false
|
|
|
|
if pr != nil {
|
|
|
|
pr.HeadRepo = repo
|
|
|
|
if err := pr.LoadIssue(ctx); err != nil {
|
|
|
|
return nil, fmt.Errorf("LoadIssue: %v", err)
|
|
|
|
}
|
|
|
|
if repo, ok := repoIDToRepo[pr.BaseRepoID]; ok {
|
|
|
|
pr.BaseRepo = repo
|
|
|
|
} else if err := pr.LoadBaseRepo(ctx); err != nil {
|
|
|
|
return nil, fmt.Errorf("LoadBaseRepo: %v", err)
|
|
|
|
} else {
|
|
|
|
repoIDToRepo[pr.BaseRepoID] = pr.BaseRepo
|
|
|
|
}
|
|
|
|
pr.Issue.Repo = pr.BaseRepo
|
|
|
|
|
|
|
|
if pr.HasMerged {
|
|
|
|
baseGitRepo, ok := repoIDToGitRepo[pr.BaseRepoID]
|
|
|
|
if !ok {
|
Simplify how git repositories are opened (#28937)
## Purpose
This is a refactor toward building an abstraction over managing git
repositories.
Afterwards, it does not matter anymore if they are stored on the local
disk or somewhere remote.
## What this PR changes
We used `git.OpenRepository` everywhere previously.
Now, we should split them into two distinct functions:
Firstly, there are temporary repositories which do not change:
```go
git.OpenRepository(ctx, diskPath)
```
Gitea managed repositories having a record in the database in the
`repository` table are moved into the new package `gitrepo`:
```go
gitrepo.OpenRepository(ctx, repo_model.Repo)
```
Why is `repo_model.Repository` the second parameter instead of file
path?
Because then we can easily adapt our repository storage strategy.
The repositories can be stored locally, however, they could just as well
be stored on a remote server.
## Further changes in other PRs
- A Git Command wrapper on package `gitrepo` could be created. i.e.
`NewCommand(ctx, repo_model.Repository, commands...)`. `git.RunOpts{Dir:
repo.RepoPath()}`, the directory should be empty before invoking this
method and it can be filled in the function only. #28940
- Remove the `RepoPath()`/`WikiPath()` functions to reduce the
possibility of mistakes.
---------
Co-authored-by: delvh <dev.lh@web.de>
2024-01-28 04:09:51 +08:00
|
|
|
baseGitRepo, err = gitrepo.OpenRepository(ctx, pr.BaseRepo)
|
2023-06-29 18:03:20 +08:00
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("OpenRepository: %v", err)
|
|
|
|
}
|
|
|
|
defer baseGitRepo.Close()
|
|
|
|
repoIDToGitRepo[pr.BaseRepoID] = baseGitRepo
|
|
|
|
}
|
|
|
|
pullCommit, err := baseGitRepo.GetRefCommitID(pr.GetGitRefName())
|
|
|
|
if err != nil && !git.IsErrNotExist(err) {
|
|
|
|
return nil, fmt.Errorf("GetBranchCommitID: %v", err)
|
|
|
|
}
|
|
|
|
if err == nil && headCommit != pullCommit {
|
|
|
|
// the head has moved on from the merge - we shouldn't delete
|
|
|
|
mergeMovedOn = true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
isIncluded := divergence.Ahead == 0 && repo.DefaultBranch != branchName
|
|
|
|
return &Branch{
|
|
|
|
DBBranch: dbBranch,
|
|
|
|
IsProtected: isProtected,
|
|
|
|
IsIncluded: isIncluded,
|
|
|
|
CommitsAhead: divergence.Ahead,
|
|
|
|
CommitsBehind: divergence.Behind,
|
|
|
|
LatestPullRequest: pr,
|
|
|
|
MergeMovedOn: mergeMovedOn,
|
|
|
|
}, nil
|
2021-11-17 23:17:31 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// checkBranchName validates branch name with existing repository branches
|
2021-12-10 09:27:50 +08:00
|
|
|
func checkBranchName(ctx context.Context, repo *repo_model.Repository, name string) error {
|
Simplify how git repositories are opened (#28937)
## Purpose
This is a refactor toward building an abstraction over managing git
repositories.
Afterwards, it does not matter anymore if they are stored on the local
disk or somewhere remote.
## What this PR changes
We used `git.OpenRepository` everywhere previously.
Now, we should split them into two distinct functions:
Firstly, there are temporary repositories which do not change:
```go
git.OpenRepository(ctx, diskPath)
```
Gitea managed repositories having a record in the database in the
`repository` table are moved into the new package `gitrepo`:
```go
gitrepo.OpenRepository(ctx, repo_model.Repo)
```
Why is `repo_model.Repository` the second parameter instead of file
path?
Because then we can easily adapt our repository storage strategy.
The repositories can be stored locally, however, they could just as well
be stored on a remote server.
## Further changes in other PRs
- A Git Command wrapper on package `gitrepo` could be created. i.e.
`NewCommand(ctx, repo_model.Repository, commands...)`. `git.RunOpts{Dir:
repo.RepoPath()}`, the directory should be empty before invoking this
method and it can be filled in the function only. #28940
- Remove the `RepoPath()`/`WikiPath()` functions to reduce the
possibility of mistakes.
---------
Co-authored-by: delvh <dev.lh@web.de>
2024-01-28 04:09:51 +08:00
|
|
|
_, err := gitrepo.WalkReferences(ctx, repo, func(_, refName string) error {
|
2021-12-09 03:08:16 +08:00
|
|
|
branchRefName := strings.TrimPrefix(refName, git.BranchPrefix)
|
|
|
|
switch {
|
|
|
|
case branchRefName == name:
|
2023-06-29 18:03:20 +08:00
|
|
|
return git_model.ErrBranchAlreadyExists{
|
2021-12-09 03:08:16 +08:00
|
|
|
BranchName: name,
|
2021-11-17 23:17:31 +08:00
|
|
|
}
|
2021-12-09 03:08:16 +08:00
|
|
|
// If branchRefName like a/b but we want to create a branch named a then we have a conflict
|
|
|
|
case strings.HasPrefix(branchRefName, name+"/"):
|
2023-06-29 18:03:20 +08:00
|
|
|
return git_model.ErrBranchNameConflict{
|
2021-12-09 03:08:16 +08:00
|
|
|
BranchName: branchRefName,
|
|
|
|
}
|
|
|
|
// Conversely if branchRefName like a but we want to create a branch named a/b then we also have a conflict
|
|
|
|
case strings.HasPrefix(name, branchRefName+"/"):
|
2023-06-29 18:03:20 +08:00
|
|
|
return git_model.ErrBranchNameConflict{
|
2021-12-09 03:08:16 +08:00
|
|
|
BranchName: branchRefName,
|
|
|
|
}
|
|
|
|
case refName == git.TagPrefix+name:
|
|
|
|
return models.ErrTagAlreadyExists{
|
|
|
|
TagName: name,
|
2021-11-17 23:17:31 +08:00
|
|
|
}
|
|
|
|
}
|
2021-12-09 03:08:16 +08:00
|
|
|
return nil
|
|
|
|
})
|
2021-11-17 23:17:31 +08:00
|
|
|
|
2021-12-09 03:08:16 +08:00
|
|
|
return err
|
2021-11-17 23:17:31 +08:00
|
|
|
}
|
|
|
|
|
2024-03-06 16:47:52 +08:00
|
|
|
// SyncBranchesToDB sync the branch information in the database.
|
|
|
|
// It will check whether the branches of the repository have never been synced before.
|
|
|
|
// If so, it will sync all branches of the repository.
|
|
|
|
// Otherwise, it will sync the branches that need to be updated.
|
|
|
|
func SyncBranchesToDB(ctx context.Context, repoID, pusherID int64, branchNames, commitIDs []string, getCommit func(commitID string) (*git.Commit, error)) error {
|
|
|
|
// Some designs that make the code look strange but are made for performance optimization purposes:
|
|
|
|
// 1. Sync branches in a batch to reduce the number of DB queries.
|
|
|
|
// 2. Lazy load commit information since it may be not necessary.
|
|
|
|
// 3. Exit early if synced all branches of git repo when there's no branch in DB.
|
|
|
|
// 4. Check the branches in DB if they are already synced.
|
|
|
|
//
|
|
|
|
// If the user pushes many branches at once, the Git hook will call the internal API in batches, rather than all at once.
|
|
|
|
// See https://github.com/go-gitea/gitea/blob/cb52b17f92e2d2293f7c003649743464492bca48/cmd/hook.go#L27
|
|
|
|
// For the first batch, it will hit optimization 3.
|
|
|
|
// For other batches, it will hit optimization 4.
|
|
|
|
|
|
|
|
if len(branchNames) != len(commitIDs) {
|
|
|
|
return fmt.Errorf("branchNames and commitIDs length not match")
|
Also sync DB branches on push if necessary (#28361)
Fix #28056
This PR will check whether the repo has zero branch when pushing a
branch. If that, it means this repository hasn't been synced.
The reason caused that is after user upgrade from v1.20 -> v1.21, he
just push branches without visit the repository user interface. Because
all repositories routers will check whether a branches sync is necessary
but push has not such check.
For every repository, it has two states, synced or not synced. If there
is zero branch for a repository, then it will be assumed as non-sync
state. Otherwise, it's synced state. So if we think it's synced, we just
need to update branch/insert new branch. Otherwise do a full sync. So
that, for every push, there will be almost no extra load added. It's
high performance than yours.
For the implementation, we in fact will try to update the branch first,
if updated success with affect records > 0, then all are done. Because
that means the branch has been in the database. If no record is
affected, that means the branch does not exist in database. So there are
two possibilities. One is this is a new branch, then we just need to
insert the record. Another is the branches haven't been synced, then we
need to sync all the branches into database.
2023-12-09 21:30:56 +08:00
|
|
|
}
|
|
|
|
|
2024-03-06 16:47:52 +08:00
|
|
|
return db.WithTx(ctx, func(ctx context.Context) error {
|
|
|
|
branches, err := git_model.GetBranches(ctx, repoID, branchNames)
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("git_model.GetBranches: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(branches) == 0 {
|
|
|
|
// if user haven't visit UI but directly push to a branch after upgrading from 1.20 -> 1.21,
|
|
|
|
// we cannot simply insert the branch but need to check we have branches or not
|
|
|
|
hasBranch, err := db.Exist[git_model.Branch](ctx, git_model.FindBranchOptions{
|
|
|
|
RepoID: repoID,
|
|
|
|
IsDeletedBranch: optional.Some(false),
|
|
|
|
}.ToConds())
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if !hasBranch {
|
|
|
|
if _, err = repo_module.SyncRepoBranches(ctx, repoID, pusherID); err != nil {
|
|
|
|
return fmt.Errorf("repo_module.SyncRepoBranches %d failed: %v", repoID, err)
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
Also sync DB branches on push if necessary (#28361)
Fix #28056
This PR will check whether the repo has zero branch when pushing a
branch. If that, it means this repository hasn't been synced.
The reason caused that is after user upgrade from v1.20 -> v1.21, he
just push branches without visit the repository user interface. Because
all repositories routers will check whether a branches sync is necessary
but push has not such check.
For every repository, it has two states, synced or not synced. If there
is zero branch for a repository, then it will be assumed as non-sync
state. Otherwise, it's synced state. So if we think it's synced, we just
need to update branch/insert new branch. Otherwise do a full sync. So
that, for every push, there will be almost no extra load added. It's
high performance than yours.
For the implementation, we in fact will try to update the branch first,
if updated success with affect records > 0, then all are done. Because
that means the branch has been in the database. If no record is
affected, that means the branch does not exist in database. So there are
two possibilities. One is this is a new branch, then we just need to
insert the record. Another is the branches haven't been synced, then we
need to sync all the branches into database.
2023-12-09 21:30:56 +08:00
|
|
|
}
|
|
|
|
|
2024-03-06 16:47:52 +08:00
|
|
|
branchMap := make(map[string]*git_model.Branch, len(branches))
|
|
|
|
for _, branch := range branches {
|
|
|
|
branchMap[branch.Name] = branch
|
|
|
|
}
|
|
|
|
|
|
|
|
newBranches := make([]*git_model.Branch, 0, len(branchNames))
|
|
|
|
|
|
|
|
for i, branchName := range branchNames {
|
|
|
|
commitID := commitIDs[i]
|
|
|
|
branch, exist := branchMap[branchName]
|
2024-03-20 09:45:27 +08:00
|
|
|
if exist && branch.CommitID == commitID && !branch.IsDeleted {
|
2024-03-06 16:47:52 +08:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
2024-03-20 09:45:27 +08:00
|
|
|
commit, err := getCommit(commitID)
|
2024-03-06 16:47:52 +08:00
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("get commit of %s failed: %v", branchName, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
if exist {
|
|
|
|
if _, err := git_model.UpdateBranch(ctx, repoID, pusherID, branchName, commit); err != nil {
|
|
|
|
return fmt.Errorf("git_model.UpdateBranch %d:%s failed: %v", repoID, branchName, err)
|
|
|
|
}
|
2024-05-30 15:04:42 +08:00
|
|
|
continue
|
2024-03-06 16:47:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// if database have branches but not this branch, it means this is a new branch
|
|
|
|
newBranches = append(newBranches, &git_model.Branch{
|
|
|
|
RepoID: repoID,
|
|
|
|
Name: branchName,
|
|
|
|
CommitID: commit.ID.String(),
|
|
|
|
CommitMessage: commit.Summary(),
|
|
|
|
PusherID: pusherID,
|
|
|
|
CommitTime: timeutil.TimeStamp(commit.Committer.When.Unix()),
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(newBranches) > 0 {
|
|
|
|
return db.Insert(ctx, newBranches)
|
|
|
|
}
|
|
|
|
return nil
|
Also sync DB branches on push if necessary (#28361)
Fix #28056
This PR will check whether the repo has zero branch when pushing a
branch. If that, it means this repository hasn't been synced.
The reason caused that is after user upgrade from v1.20 -> v1.21, he
just push branches without visit the repository user interface. Because
all repositories routers will check whether a branches sync is necessary
but push has not such check.
For every repository, it has two states, synced or not synced. If there
is zero branch for a repository, then it will be assumed as non-sync
state. Otherwise, it's synced state. So if we think it's synced, we just
need to update branch/insert new branch. Otherwise do a full sync. So
that, for every push, there will be almost no extra load added. It's
high performance than yours.
For the implementation, we in fact will try to update the branch first,
if updated success with affect records > 0, then all are done. Because
that means the branch has been in the database. If no record is
affected, that means the branch does not exist in database. So there are
two possibilities. One is this is a new branch, then we just need to
insert the record. Another is the branches haven't been synced, then we
need to sync all the branches into database.
2023-12-09 21:30:56 +08:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2021-11-17 23:17:31 +08:00
|
|
|
// CreateNewBranchFromCommit creates a new repository branch
|
Also sync DB branches on push if necessary (#28361)
Fix #28056
This PR will check whether the repo has zero branch when pushing a
branch. If that, it means this repository hasn't been synced.
The reason caused that is after user upgrade from v1.20 -> v1.21, he
just push branches without visit the repository user interface. Because
all repositories routers will check whether a branches sync is necessary
but push has not such check.
For every repository, it has two states, synced or not synced. If there
is zero branch for a repository, then it will be assumed as non-sync
state. Otherwise, it's synced state. So if we think it's synced, we just
need to update branch/insert new branch. Otherwise do a full sync. So
that, for every push, there will be almost no extra load added. It's
high performance than yours.
For the implementation, we in fact will try to update the branch first,
if updated success with affect records > 0, then all are done. Because
that means the branch has been in the database. If no record is
affected, that means the branch does not exist in database. So there are
two possibilities. One is this is a new branch, then we just need to
insert the record. Another is the branches haven't been synced, then we
need to sync all the branches into database.
2023-12-09 21:30:56 +08:00
|
|
|
func CreateNewBranchFromCommit(ctx context.Context, doer *user_model.User, repo *repo_model.Repository, gitRepo *git.Repository, commitID, branchName string) (err error) {
|
2023-09-22 07:43:29 +08:00
|
|
|
err = repo.MustNotBeArchived()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2021-11-17 23:17:31 +08:00
|
|
|
// Check if branch name can be used
|
2022-01-20 07:26:57 +08:00
|
|
|
if err := checkBranchName(ctx, repo, branchName); err != nil {
|
2021-11-17 23:17:31 +08:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2023-12-28 15:28:57 +08:00
|
|
|
if err := git.Push(ctx, repo.RepoPath(), git.PushOptions{
|
|
|
|
Remote: repo.RepoPath(),
|
|
|
|
Branch: fmt.Sprintf("%s:%s%s", commitID, git.BranchPrefix, branchName),
|
|
|
|
Env: repo_module.PushingEnvironment(doer, repo),
|
|
|
|
}); err != nil {
|
|
|
|
if git.IsErrPushOutOfDate(err) || git.IsErrPushRejected(err) {
|
2021-11-17 23:17:31 +08:00
|
|
|
return err
|
|
|
|
}
|
2023-12-28 15:28:57 +08:00
|
|
|
return fmt.Errorf("push: %w", err)
|
|
|
|
}
|
|
|
|
return nil
|
2021-11-17 23:17:31 +08:00
|
|
|
}
|
|
|
|
|
2021-10-09 01:03:04 +08:00
|
|
|
// RenameBranch rename a branch
|
2023-03-01 06:17:51 +08:00
|
|
|
func RenameBranch(ctx context.Context, repo *repo_model.Repository, doer *user_model.User, gitRepo *git.Repository, from, to string) (string, error) {
|
2023-09-22 07:43:29 +08:00
|
|
|
err := repo.MustNotBeArchived()
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
2021-10-09 01:03:04 +08:00
|
|
|
if from == to {
|
|
|
|
return "target_exist", nil
|
|
|
|
}
|
|
|
|
|
|
|
|
if gitRepo.IsBranchExist(to) {
|
|
|
|
return "target_exist", nil
|
|
|
|
}
|
|
|
|
|
|
|
|
if !gitRepo.IsBranchExist(from) {
|
|
|
|
return "from_not_exist", nil
|
|
|
|
}
|
|
|
|
|
2024-01-13 05:50:38 +08:00
|
|
|
if err := git_model.RenameBranch(ctx, repo, from, to, func(ctx context.Context, isDefault bool) error {
|
2021-10-09 01:03:04 +08:00
|
|
|
err2 := gitRepo.RenameBranch(from, to)
|
|
|
|
if err2 != nil {
|
|
|
|
return err2
|
|
|
|
}
|
|
|
|
|
|
|
|
if isDefault {
|
2024-01-13 05:50:38 +08:00
|
|
|
// if default branch changed, we need to delete all schedules and cron jobs
|
|
|
|
if err := actions_model.DeleteScheduleTaskByRepo(ctx, repo.ID); err != nil {
|
|
|
|
log.Error("DeleteCronTaskByRepo: %v", err)
|
|
|
|
}
|
|
|
|
// cancel running cron jobs of this repository and delete old schedules
|
2024-03-21 15:01:35 +08:00
|
|
|
if err := actions_model.CancelPreviousJobs(
|
2024-01-13 05:50:38 +08:00
|
|
|
ctx,
|
|
|
|
repo.ID,
|
|
|
|
from,
|
|
|
|
"",
|
|
|
|
webhook_module.HookEventSchedule,
|
|
|
|
); err != nil {
|
2024-03-21 15:01:35 +08:00
|
|
|
log.Error("CancelPreviousJobs: %v", err)
|
2024-01-13 05:50:38 +08:00
|
|
|
}
|
|
|
|
|
2024-03-08 15:30:10 +08:00
|
|
|
err2 = gitrepo.SetDefaultBranch(ctx, repo, to)
|
2021-10-09 01:03:04 +08:00
|
|
|
if err2 != nil {
|
|
|
|
return err2
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}); err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
2023-05-26 09:04:48 +08:00
|
|
|
refNameTo := git.RefNameFromBranch(to)
|
|
|
|
refID, err := gitRepo.GetRefCommitID(refNameTo.String())
|
2022-01-20 07:26:57 +08:00
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
2021-10-09 01:03:04 +08:00
|
|
|
|
2023-09-06 02:37:47 +08:00
|
|
|
notify_service.DeleteRef(ctx, doer, repo, git.RefNameFromBranch(from))
|
|
|
|
notify_service.CreateRef(ctx, doer, repo, refNameTo, refID)
|
2021-10-09 01:03:04 +08:00
|
|
|
|
|
|
|
return "", nil
|
|
|
|
}
|
|
|
|
|
2021-06-07 22:52:59 +08:00
|
|
|
// enmuerates all branch related errors
|
|
|
|
var (
|
2023-01-16 16:00:22 +08:00
|
|
|
ErrBranchIsDefault = errors.New("branch is default")
|
2021-06-07 22:52:59 +08:00
|
|
|
)
|
|
|
|
|
|
|
|
// DeleteBranch delete branch
|
2023-03-01 06:17:51 +08:00
|
|
|
func DeleteBranch(ctx context.Context, doer *user_model.User, repo *repo_model.Repository, gitRepo *git.Repository, branchName string) error {
|
2023-09-22 07:43:29 +08:00
|
|
|
err := repo.MustNotBeArchived()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2021-06-07 22:52:59 +08:00
|
|
|
if branchName == repo.DefaultBranch {
|
|
|
|
return ErrBranchIsDefault
|
|
|
|
}
|
|
|
|
|
2023-03-01 06:17:51 +08:00
|
|
|
isProtected, err := git_model.IsBranchProtected(ctx, repo.ID, branchName)
|
2021-06-07 22:52:59 +08:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if isProtected {
|
2023-01-16 16:00:22 +08:00
|
|
|
return git_model.ErrBranchIsProtected
|
2021-06-07 22:52:59 +08:00
|
|
|
}
|
|
|
|
|
2023-06-29 18:03:20 +08:00
|
|
|
rawBranch, err := git_model.GetBranch(ctx, repo.ID, branchName)
|
2024-09-24 17:01:05 +08:00
|
|
|
if err != nil && !git_model.IsErrBranchNotExist(err) {
|
2023-06-29 18:03:20 +08:00
|
|
|
return fmt.Errorf("GetBranch: %vc", err)
|
|
|
|
}
|
|
|
|
|
2024-09-24 17:01:05 +08:00
|
|
|
// database branch record not exist or it's a deleted branch
|
|
|
|
notExist := git_model.IsErrBranchNotExist(err) || rawBranch.IsDeleted
|
2023-06-29 18:03:20 +08:00
|
|
|
|
2021-06-07 22:52:59 +08:00
|
|
|
commit, err := gitRepo.GetBranchCommit(branchName)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2023-06-29 18:03:20 +08:00
|
|
|
if err := db.WithTx(ctx, func(ctx context.Context) error {
|
2024-09-24 17:01:05 +08:00
|
|
|
if !notExist {
|
|
|
|
if err := git_model.AddDeletedBranch(ctx, repo.ID, branchName, doer.ID); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2023-06-29 18:03:20 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return gitRepo.DeleteBranch(branchName, git.DeleteBranchOptions{
|
|
|
|
Force: true,
|
|
|
|
})
|
2021-06-07 22:52:59 +08:00
|
|
|
}); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2024-02-24 14:55:19 +08:00
|
|
|
objectFormat := git.ObjectFormatFromName(repo.ObjectFormatName)
|
|
|
|
|
2021-06-07 22:52:59 +08:00
|
|
|
// Don't return error below this
|
|
|
|
if err := PushUpdate(
|
|
|
|
&repo_module.PushUpdateOptions{
|
2023-05-26 09:04:48 +08:00
|
|
|
RefFullName: git.RefNameFromBranch(branchName),
|
2021-06-07 22:52:59 +08:00
|
|
|
OldCommitID: commit.ID.String(),
|
2023-12-17 19:56:08 +08:00
|
|
|
NewCommitID: objectFormat.EmptyObjectID().String(),
|
2021-06-07 22:52:59 +08:00
|
|
|
PusherID: doer.ID,
|
|
|
|
PusherName: doer.Name,
|
|
|
|
RepoUserName: repo.OwnerName,
|
|
|
|
RepoName: repo.Name,
|
|
|
|
}); err != nil {
|
|
|
|
log.Error("Update: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
2023-06-29 18:03:20 +08:00
|
|
|
|
|
|
|
type BranchSyncOptions struct {
|
|
|
|
RepoID int64
|
|
|
|
}
|
|
|
|
|
|
|
|
// branchSyncQueue represents a queue to handle branch sync jobs.
|
|
|
|
var branchSyncQueue *queue.WorkerPoolQueue[*BranchSyncOptions]
|
|
|
|
|
|
|
|
func handlerBranchSync(items ...*BranchSyncOptions) []*BranchSyncOptions {
|
|
|
|
for _, opts := range items {
|
|
|
|
_, err := repo_module.SyncRepoBranches(graceful.GetManager().ShutdownContext(), opts.RepoID, 0)
|
|
|
|
if err != nil {
|
|
|
|
log.Error("syncRepoBranches [%d] failed: %v", opts.RepoID, err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func addRepoToBranchSyncQueue(repoID, doerID int64) error {
|
|
|
|
return branchSyncQueue.Push(&BranchSyncOptions{
|
|
|
|
RepoID: repoID,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
func initBranchSyncQueue(ctx context.Context) error {
|
|
|
|
branchSyncQueue = queue.CreateUniqueQueue(ctx, "branch_sync", handlerBranchSync)
|
|
|
|
if branchSyncQueue == nil {
|
|
|
|
return errors.New("unable to create branch_sync queue")
|
|
|
|
}
|
|
|
|
go graceful.GetManager().RunWithCancel(branchSyncQueue)
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func AddAllRepoBranchesToSyncQueue(ctx context.Context, doerID int64) error {
|
|
|
|
if err := db.Iterate(ctx, builder.Eq{"is_empty": false}, func(ctx context.Context, repo *repo_model.Repository) error {
|
|
|
|
return addRepoToBranchSyncQueue(repo.ID, doerID)
|
|
|
|
}); err != nil {
|
|
|
|
return fmt.Errorf("run sync all branches failed: %v", err)
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
2024-01-13 05:50:38 +08:00
|
|
|
|
|
|
|
func SetRepoDefaultBranch(ctx context.Context, repo *repo_model.Repository, gitRepo *git.Repository, newBranchName string) error {
|
|
|
|
if repo.DefaultBranch == newBranchName {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
if !gitRepo.IsBranchExist(newBranchName) {
|
|
|
|
return git_model.ErrBranchNotExist{
|
|
|
|
BranchName: newBranchName,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
oldDefaultBranchName := repo.DefaultBranch
|
|
|
|
repo.DefaultBranch = newBranchName
|
|
|
|
if err := db.WithTx(ctx, func(ctx context.Context) error {
|
|
|
|
if err := repo_model.UpdateDefaultBranch(ctx, repo); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := actions_model.DeleteScheduleTaskByRepo(ctx, repo.ID); err != nil {
|
|
|
|
log.Error("DeleteCronTaskByRepo: %v", err)
|
|
|
|
}
|
|
|
|
// cancel running cron jobs of this repository and delete old schedules
|
2024-03-21 15:01:35 +08:00
|
|
|
if err := actions_model.CancelPreviousJobs(
|
2024-01-13 05:50:38 +08:00
|
|
|
ctx,
|
|
|
|
repo.ID,
|
|
|
|
oldDefaultBranchName,
|
|
|
|
"",
|
|
|
|
webhook_module.HookEventSchedule,
|
|
|
|
); err != nil {
|
2024-03-21 15:01:35 +08:00
|
|
|
log.Error("CancelPreviousJobs: %v", err)
|
2024-01-13 05:50:38 +08:00
|
|
|
}
|
|
|
|
|
2024-03-08 15:30:10 +08:00
|
|
|
if err := gitrepo.SetDefaultBranch(ctx, repo, newBranchName); err != nil {
|
2024-01-13 05:50:38 +08:00
|
|
|
if !git.IsErrUnsupportedVersion(err) {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
notify_service.ChangeDefaultBranch(ctx, repo)
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|