123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453 |
- // Copyright 2021 The Gitea Authors. All rights reserved.
- // SPDX-License-Identifier: MIT
-
- package repository
-
- import (
- "context"
- "errors"
- "fmt"
- "strings"
-
- "code.gitea.io/gitea/models"
- "code.gitea.io/gitea/models/db"
- git_model "code.gitea.io/gitea/models/git"
- issues_model "code.gitea.io/gitea/models/issues"
- repo_model "code.gitea.io/gitea/models/repo"
- user_model "code.gitea.io/gitea/models/user"
- "code.gitea.io/gitea/modules/git"
- "code.gitea.io/gitea/modules/graceful"
- "code.gitea.io/gitea/modules/log"
- "code.gitea.io/gitea/modules/queue"
- repo_module "code.gitea.io/gitea/modules/repository"
- "code.gitea.io/gitea/modules/timeutil"
- "code.gitea.io/gitea/modules/util"
- notify_service "code.gitea.io/gitea/services/notify"
- files_service "code.gitea.io/gitea/services/repository/files"
-
- "xorm.io/builder"
- )
-
- // CreateNewBranch creates a new repository branch
- 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)
- if err != nil {
- return err
- }
-
- return CreateNewBranchFromCommit(ctx, doer, repo, gitRepo, branch.CommitID, branchName)
- }
-
- // 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.
- func LoadBranches(ctx context.Context, repo *repo_model.Repository, gitRepo *git.Repository, isDeletedBranch util.OptionalBool, keyword string, page, pageSize int) (*Branch, []*Branch, int64, error) {
- 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,
- IsDeletedBranch: isDeletedBranch,
- ListOptions: db.ListOptions{
- Page: page,
- PageSize: pageSize,
- },
- Keyword: keyword,
- }
-
- totalNumOfBranches, err := git_model.CountBranches(ctx, branchOpts)
- if err != nil {
- return nil, nil, 0, err
- }
-
- branchOpts.ExcludeBranchNames = []string{repo.DefaultBranch}
-
- dbBranches, err := git_model.FindBranches(ctx, branchOpts)
- if err != nil {
- return nil, nil, 0, err
- }
-
- if err := dbBranches.LoadDeletedBy(ctx); err != nil {
- return nil, nil, 0, err
- }
- if err := dbBranches.LoadPusher(ctx); err != nil {
- 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
- }
-
- 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
-
- divergence := &git.DivergeObject{
- Ahead: -1,
- Behind: -1,
- }
-
- // it's not default branch
- if repo.DefaultBranch != dbBranch.Name && !dbBranch.IsDeleted {
- var err error
- divergence, err = files_service.CountDivergingCommits(ctx, repo, git.BranchPrefix+branchName)
- if err != nil {
- log.Error("CountDivergingCommits: %v", err)
- }
- }
-
- pr, err := issues_model.GetLatestPullRequestByHeadInfo(repo.ID, branchName)
- 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 {
- baseGitRepo, err = git.OpenRepository(ctx, pr.BaseRepo.RepoPath())
- 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
- }
-
- func GetBranchCommitID(ctx context.Context, repo *repo_model.Repository, branch string) (string, error) {
- return git.GetBranchCommitID(ctx, repo.RepoPath(), branch)
- }
-
- // checkBranchName validates branch name with existing repository branches
- func checkBranchName(ctx context.Context, repo *repo_model.Repository, name string) error {
- _, err := git.WalkReferences(ctx, repo.RepoPath(), func(_, refName string) error {
- branchRefName := strings.TrimPrefix(refName, git.BranchPrefix)
- switch {
- case branchRefName == name:
- return git_model.ErrBranchAlreadyExists{
- BranchName: name,
- }
- // If branchRefName like a/b but we want to create a branch named a then we have a conflict
- case strings.HasPrefix(branchRefName, name+"/"):
- return git_model.ErrBranchNameConflict{
- 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+"/"):
- return git_model.ErrBranchNameConflict{
- BranchName: branchRefName,
- }
- case refName == git.TagPrefix+name:
- return models.ErrTagAlreadyExists{
- TagName: name,
- }
- }
- return nil
- })
-
- return err
- }
-
- // syncBranchToDB sync the branch information in the database. It 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.
- func syncBranchToDB(ctx context.Context, repoID, pusherID int64, branchName string, commit *git.Commit) error {
- cnt, err := git_model.UpdateBranch(ctx, repoID, pusherID, branchName, commit)
- if err != nil {
- return fmt.Errorf("git_model.UpdateBranch %d:%s failed: %v", repoID, branchName, err)
- }
- if cnt > 0 { // This means branch does exist, so it's a normal update. It also means the branch has been synced.
- return nil
- }
-
- // 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: util.OptionalBoolFalse,
- }.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:%s failed: %v", repoID, branchName, err)
- }
- return nil
- }
-
- // if database have branches but not this branch, it means this is a new branch
- return db.Insert(ctx, &git_model.Branch{
- RepoID: repoID,
- Name: branchName,
- CommitID: commit.ID.String(),
- CommitMessage: commit.Summary(),
- PusherID: pusherID,
- CommitTime: timeutil.TimeStamp(commit.Committer.When.Unix()),
- })
- }
-
- // CreateNewBranchFromCommit creates a new repository branch
- func CreateNewBranchFromCommit(ctx context.Context, doer *user_model.User, repo *repo_model.Repository, gitRepo *git.Repository, commitID, branchName string) (err error) {
- err = repo.MustNotBeArchived()
- if err != nil {
- return err
- }
-
- // Check if branch name can be used
- if err := checkBranchName(ctx, repo, branchName); err != nil {
- return err
- }
-
- return db.WithTx(ctx, func(ctx context.Context) error {
- commit, err := gitRepo.GetCommit(commitID)
- if err != nil {
- return err
- }
- // database operation should be done before git operation so that we can rollback if git operation failed
- if err := syncBranchToDB(ctx, repo.ID, doer.ID, branchName, commit); err != nil {
- return err
- }
-
- 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) {
- return err
- }
- return fmt.Errorf("push: %w", err)
- }
- return nil
- })
- }
-
- // RenameBranch rename a branch
- func RenameBranch(ctx context.Context, repo *repo_model.Repository, doer *user_model.User, gitRepo *git.Repository, from, to string) (string, error) {
- if from == to {
- return "target_exist", nil
- }
-
- if gitRepo.IsBranchExist(to) {
- return "target_exist", nil
- }
-
- if !gitRepo.IsBranchExist(from) {
- return "from_not_exist", nil
- }
-
- if err := git_model.RenameBranch(ctx, repo, from, to, func(isDefault bool) error {
- err2 := gitRepo.RenameBranch(from, to)
- if err2 != nil {
- return err2
- }
-
- if isDefault {
- err2 = gitRepo.SetDefaultBranch(to)
- if err2 != nil {
- return err2
- }
- }
-
- return nil
- }); err != nil {
- return "", err
- }
- refNameTo := git.RefNameFromBranch(to)
- refID, err := gitRepo.GetRefCommitID(refNameTo.String())
- if err != nil {
- return "", err
- }
-
- notify_service.DeleteRef(ctx, doer, repo, git.RefNameFromBranch(from))
- notify_service.CreateRef(ctx, doer, repo, refNameTo, refID)
-
- return "", nil
- }
-
- // enmuerates all branch related errors
- var (
- ErrBranchIsDefault = errors.New("branch is default")
- )
-
- // DeleteBranch delete branch
- func DeleteBranch(ctx context.Context, doer *user_model.User, repo *repo_model.Repository, gitRepo *git.Repository, branchName string) error {
- if branchName == repo.DefaultBranch {
- return ErrBranchIsDefault
- }
-
- isProtected, err := git_model.IsBranchProtected(ctx, repo.ID, branchName)
- if err != nil {
- return err
- }
- if isProtected {
- return git_model.ErrBranchIsProtected
- }
-
- rawBranch, err := git_model.GetBranch(ctx, repo.ID, branchName)
- if err != nil {
- return fmt.Errorf("GetBranch: %vc", err)
- }
-
- if rawBranch.IsDeleted {
- return nil
- }
-
- commit, err := gitRepo.GetBranchCommit(branchName)
- if err != nil {
- return err
- }
-
- if err := db.WithTx(ctx, func(ctx context.Context) error {
- if err := git_model.AddDeletedBranch(ctx, repo.ID, branchName, doer.ID); err != nil {
- return err
- }
-
- return gitRepo.DeleteBranch(branchName, git.DeleteBranchOptions{
- Force: true,
- })
- }); err != nil {
- return err
- }
-
- // Don't return error below this
- if err := PushUpdate(
- &repo_module.PushUpdateOptions{
- RefFullName: git.RefNameFromBranch(branchName),
- OldCommitID: commit.ID.String(),
- NewCommitID: git.EmptySHA,
- PusherID: doer.ID,
- PusherName: doer.Name,
- RepoUserName: repo.OwnerName,
- RepoName: repo.Name,
- }); err != nil {
- log.Error("Update: %v", err)
- }
-
- return nil
- }
-
- 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
- }
|