Move some functions to gitrepo package

cmd/admin.go

@@ -11,7 +11,6 @@ import (
 	"code.gitea.io/gitea/models/db"
 	repo_model "code.gitea.io/gitea/models/repo"
 	"code.gitea.io/gitea/modules/git"
-	"code.gitea.io/gitea/modules/gitrepo"
 	"code.gitea.io/gitea/modules/log"
 	repo_module "code.gitea.io/gitea/modules/repository"
 
@@ -122,34 +121,26 @@ func runRepoSyncReleases(ctx context.Context, _ *cli.Command) error {
 		log.Trace("Processing next %d repos of %d", len(repos), count)
 		for _, repo := range repos {
 			log.Trace("Synchronizing repo %s with path %s", repo.FullName(), repo.RelativePath())
-			gitRepo, err := gitrepo.OpenRepository(ctx, repo)
-			if err != nil {
-				log.Warn("OpenRepository: %v", err)
-				continue
-			}
 
 			oldnum, err := getReleaseCount(ctx, repo.ID)
 			if err != nil {
 				log.Warn(" GetReleaseCountByRepoID: %v", err)
 			}
 			log.Trace(" currentNumReleases is %d, running SyncReleasesWithTags", oldnum)
 
-			if err = repo_module.SyncReleasesWithTags(ctx, repo, gitRepo); err != nil {
+			if err = repo_module.SyncReleasesWithTags(ctx, repo); err != nil {
 				log.Warn(" SyncReleasesWithTags: %v", err)
-				gitRepo.Close()
 				continue
 			}
 
 			count, err = getReleaseCount(ctx, repo.ID)
 			if err != nil {
 				log.Warn(" GetReleaseCountByRepoID: %v", err)
-				gitRepo.Close()
 				continue
 			}
 
 			log.Trace("repo %s releases synchronized to tags: from %d to %d",
 				repo.FullName(), oldnum, count)
-			gitRepo.Close()
 		}
 	}
 

modules/git/repo_branch_gogit.go

@@ -7,11 +7,7 @@
 package git
 
 import (
-	"sort"
-	"strings"
-
 	"github.com/go-git/go-git/v5/plumbing"
-	"github.com/go-git/go-git/v5/plumbing/storer"
 )
 
 // IsObjectExist returns true if the given object exists in the repository.
@@ -54,99 +50,3 @@ func (repo *Repository) IsBranchExist(name string) bool {
 	}
 	return reference.Type() != plumbing.InvalidReference
 }
-
-// GetBranches returns branches from the repository, skipping "skip" initial branches and
-// returning at most "limit" branches, or all branches if "limit" is 0.
-// Branches are returned with sort of `-committerdate` as the nogogit
-// implementation. This requires full fetch, sort and then the
-// skip/limit applies later as gogit returns in undefined order.
-func (repo *Repository) GetBranchNames(skip, limit int) ([]string, int, error) {
-	type BranchData struct {
-		name          string
-		committerDate int64
-	}
-	var branchData []BranchData
-
-	branchIter, err := repo.gogitRepo.Branches()
-	if err != nil {
-		return nil, 0, err
-	}
-
-	_ = branchIter.ForEach(func(branch *plumbing.Reference) error {
-		obj, err := repo.gogitRepo.CommitObject(branch.Hash())
-		if err != nil {
-			// skip branch if can't find commit
-			return nil
-		}
-
-		branchData = append(branchData, BranchData{strings.TrimPrefix(branch.Name().String(), BranchPrefix), obj.Committer.When.Unix()})
-		return nil
-	})
-
-	sort.Slice(branchData, func(i, j int) bool {
-		return !(branchData[i].committerDate < branchData[j].committerDate)
-	})
-
-	var branchNames []string
-	maxPos := len(branchData)
-	if limit > 0 {
-		maxPos = min(skip+limit, maxPos)
-	}
-	for i := skip; i < maxPos; i++ {
-		branchNames = append(branchNames, branchData[i].name)
-	}
-
-	return branchNames, len(branchData), nil
-}
-
-// WalkReferences walks all the references from the repository
-func (repo *Repository) WalkReferences(arg ObjectType, skip, limit int, walkfn func(sha1, refname string) error) (int, error) {
-	i := 0
-	var iter storer.ReferenceIter
-	var err error
-	switch arg {
-	case ObjectTag:
-		iter, err = repo.gogitRepo.Tags()
-	case ObjectBranch:
-		iter, err = repo.gogitRepo.Branches()
-	default:
-		iter, err = repo.gogitRepo.References()
-	}
-	if err != nil {
-		return i, err
-	}
-	defer iter.Close()
-
-	err = iter.ForEach(func(ref *plumbing.Reference) error {
-		if i < skip {
-			i++
-			return nil
-		}
-		err := walkfn(ref.Hash().String(), string(ref.Name()))
-		i++
-		if err != nil {
-			return err
-		}
-		if limit != 0 && i >= skip+limit {
-			return storer.ErrStop
-		}
-		return nil
-	})
-	return i, err
-}
-
-// GetRefsBySha returns all references filtered with prefix that belong to a sha commit hash
-func (repo *Repository) GetRefsBySha(sha, prefix string) ([]string, error) {
-	var revList []string
-	iter, err := repo.gogitRepo.References()
-	if err != nil {
-		return nil, err
-	}
-	err = iter.ForEach(func(ref *plumbing.Reference) error {
-		if ref.Hash().String() == sha && strings.HasPrefix(string(ref.Name()), prefix) {
-			revList = append(revList, string(ref.Name()))
-		}
-		return nil
-	})
-	return revList, err
-}

modules/git/repo_branch_nogogit.go

@@ -7,12 +7,8 @@
 package git
 
 import (
-	"bufio"
-	"context"
-	"io"
 	"strings"
 
-	"code.gitea.io/gitea/modules/git/gitcmd"
 	"code.gitea.io/gitea/modules/log"
 )
 
@@ -61,137 +57,3 @@ func (repo *Repository) IsBranchExist(name string) bool {
 
 	return repo.IsReferenceExist(BranchPrefix + name)
 }
-
-// GetBranchNames returns branches from the repository, skipping "skip" initial branches and
-// returning at most "limit" branches, or all branches if "limit" is 0.
-func (repo *Repository) GetBranchNames(skip, limit int) ([]string, int, error) {
-	return callShowRef(repo.Ctx, repo.Path, BranchPrefix, gitcmd.TrustedCmdArgs{BranchPrefix, "--sort=-committerdate"}, skip, limit)
-}
-
-// WalkReferences walks all the references from the repository
-// refType should be empty, ObjectTag or ObjectBranch. All other values are equivalent to empty.
-func (repo *Repository) WalkReferences(refType ObjectType, skip, limit int, walkfn func(sha1, refname string) error) (int, error) {
-	var args gitcmd.TrustedCmdArgs
-	switch refType {
-	case ObjectTag:
-		args = gitcmd.TrustedCmdArgs{TagPrefix, "--sort=-taggerdate"}
-	case ObjectBranch:
-		args = gitcmd.TrustedCmdArgs{BranchPrefix, "--sort=-committerdate"}
-	}
-
-	return WalkShowRef(repo.Ctx, repo.Path, args, skip, limit, walkfn)
-}
-
-// callShowRef return refs, if limit = 0 it will not limit
-func callShowRef(ctx context.Context, repoPath, trimPrefix string, extraArgs gitcmd.TrustedCmdArgs, skip, limit int) (branchNames []string, countAll int, err error) {
-	countAll, err = WalkShowRef(ctx, repoPath, extraArgs, skip, limit, func(_, branchName string) error {
-		branchName = strings.TrimPrefix(branchName, trimPrefix)
-		branchNames = append(branchNames, branchName)
-
-		return nil
-	})
-	return branchNames, countAll, err
-}
-
-func WalkShowRef(ctx context.Context, repoPath string, extraArgs gitcmd.TrustedCmdArgs, skip, limit int, walkfn func(sha1, refname string) error) (countAll int, err error) {
-	stdoutReader, stdoutWriter := io.Pipe()
-	defer func() {
-		_ = stdoutReader.Close()
-		_ = stdoutWriter.Close()
-	}()
-
-	go func() {
-		stderrBuilder := &strings.Builder{}
-		args := gitcmd.TrustedCmdArgs{"for-each-ref", "--format=%(objectname) %(refname)"}
-		args = append(args, extraArgs...)
-		err := gitcmd.NewCommand(args...).
-			WithDir(repoPath).
-			WithStdout(stdoutWriter).
-			WithStderr(stderrBuilder).
-			Run(ctx)
-		if err != nil {
-			if stderrBuilder.Len() == 0 {
-				_ = stdoutWriter.Close()
-				return
-			}
-			_ = stdoutWriter.CloseWithError(gitcmd.ConcatenateError(err, stderrBuilder.String()))
-		} else {
-			_ = stdoutWriter.Close()
-		}
-	}()
-
-	i := 0
-	bufReader := bufio.NewReader(stdoutReader)
-	for i < skip {
-		_, isPrefix, err := bufReader.ReadLine()
-		if err == io.EOF {
-			return i, nil
-		}
-		if err != nil {
-			return 0, err
-		}
-		if !isPrefix {
-			i++
-		}
-	}
-	for limit == 0 || i < skip+limit {
-		// The output of show-ref is simply a list:
-		// <sha> SP <ref> LF
-		sha, err := bufReader.ReadString(' ')
-		if err == io.EOF {
-			return i, nil
-		}
-		if err != nil {
-			return 0, err
-		}
-
-		branchName, err := bufReader.ReadString('\n')
-		if err == io.EOF {
-			// This shouldn't happen... but we'll tolerate it for the sake of peace
-			return i, nil
-		}
-		if err != nil {
-			return i, err
-		}
-
-		if len(branchName) > 0 {
-			branchName = branchName[:len(branchName)-1]
-		}
-
-		if len(sha) > 0 {
-			sha = sha[:len(sha)-1]
-		}
-
-		err = walkfn(sha, branchName)
-		if err != nil {
-			return i, err
-		}
-		i++
-	}
-	// count all refs
-	for limit != 0 {
-		_, isPrefix, err := bufReader.ReadLine()
-		if err == io.EOF {
-			return i, nil
-		}
-		if err != nil {
-			return 0, err
-		}
-		if !isPrefix {
-			i++
-		}
-	}
-	return i, nil
-}
-
-// GetRefsBySha returns all references filtered with prefix that belong to a sha commit hash
-func (repo *Repository) GetRefsBySha(sha, prefix string) ([]string, error) {
-	var revList []string
-	_, err := WalkShowRef(repo.Ctx, repo.Path, nil, 0, 0, func(walkSha, refname string) error {
-		if walkSha == sha && strings.HasPrefix(refname, prefix) {
-			revList = append(revList, refname)
-		}
-		return nil
-	})
-	return revList, err
-}

modules/git/repo_branch_test.go

@@ -11,91 +11,6 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestRepository_GetBranches(t *testing.T) {
-	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare")
-	bareRepo1, err := OpenRepository(t.Context(), bareRepo1Path)
-	assert.NoError(t, err)
-	defer bareRepo1.Close()
-
-	branches, countAll, err := bareRepo1.GetBranchNames(0, 2)
-
-	assert.NoError(t, err)
-	assert.Len(t, branches, 2)
-	assert.Equal(t, 3, countAll)
-	assert.ElementsMatch(t, []string{"master", "branch2"}, branches)
-
-	branches, countAll, err = bareRepo1.GetBranchNames(0, 0)
-
-	assert.NoError(t, err)
-	assert.Len(t, branches, 3)
-	assert.Equal(t, 3, countAll)
-	assert.ElementsMatch(t, []string{"master", "branch2", "branch1"}, branches)
-
-	branches, countAll, err = bareRepo1.GetBranchNames(5, 1)
-
-	assert.NoError(t, err)
-	assert.Empty(t, branches)
-	assert.Equal(t, 3, countAll)
-	assert.ElementsMatch(t, []string{}, branches)
-}
-
-func BenchmarkRepository_GetBranches(b *testing.B) {
-	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare")
-	bareRepo1, err := OpenRepository(b.Context(), bareRepo1Path)
-	if err != nil {
-		b.Fatal(err)
-	}
-	defer bareRepo1.Close()
-
-	for b.Loop() {
-		_, _, err := bareRepo1.GetBranchNames(0, 0)
-		if err != nil {
-			b.Fatal(err)
-		}
-	}
-}
-
-func TestGetRefsBySha(t *testing.T) {
-	bareRepo5Path := filepath.Join(testReposDir, "repo5_pulls")
-	bareRepo5, err := OpenRepository(t.Context(), bareRepo5Path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer bareRepo5.Close()
-
-	// do not exist
-	branches, err := bareRepo5.GetRefsBySha("8006ff9adbf0cb94da7dad9e537e53817f9fa5c0", "")
-	assert.NoError(t, err)
-	assert.Empty(t, branches)
-
-	// refs/pull/1/head
-	branches, err = bareRepo5.GetRefsBySha("c83380d7056593c51a699d12b9c00627bd5743e9", PullPrefix)
-	assert.NoError(t, err)
-	assert.Equal(t, []string{"refs/pull/1/head"}, branches)
-
-	branches, err = bareRepo5.GetRefsBySha("d8e0bbb45f200e67d9a784ce55bd90821af45ebd", BranchPrefix)
-	assert.NoError(t, err)
-	assert.Equal(t, []string{"refs/heads/master", "refs/heads/master-clone"}, branches)
-
-	branches, err = bareRepo5.GetRefsBySha("58a4bcc53ac13e7ff76127e0fb518b5262bf09af", BranchPrefix)
-	assert.NoError(t, err)
-	assert.Equal(t, []string{"refs/heads/test-patch-1"}, branches)
-}
-
-func BenchmarkGetRefsBySha(b *testing.B) {
-	bareRepo5Path := filepath.Join(testReposDir, "repo5_pulls")
-	bareRepo5, err := OpenRepository(b.Context(), bareRepo5Path)
-	if err != nil {
-		b.Fatal(err)
-	}
-	defer bareRepo5.Close()
-
-	_, _ = bareRepo5.GetRefsBySha("8006ff9adbf0cb94da7dad9e537e53817f9fa5c0", "")
-	_, _ = bareRepo5.GetRefsBySha("d8e0bbb45f200e67d9a784ce55bd90821af45ebd", "")
-	_, _ = bareRepo5.GetRefsBySha("c83380d7056593c51a699d12b9c00627bd5743e9", "")
-	_, _ = bareRepo5.GetRefsBySha("58a4bcc53ac13e7ff76127e0fb518b5262bf09af", "")
-}
-
 func TestRepository_IsObjectExist(t *testing.T) {
 	repo, err := OpenRepository(t.Context(), filepath.Join(testReposDir, "repo1_bare"))
 	require.NoError(t, err)