Introduce git service interface and refactor gitrepo module

Author: lunny

modules/gitrepo/branch.go

@@ -5,45 +5,55 @@ package gitrepo
 
 import (
 	"context"
+	"errors"
+	"strings"
 
 	"code.gitea.io/gitea/modules/git"
 )
 
-// GetBranchesByPath returns a branch by its path
+// GetBranches returns branch names by repository
 // if limit = 0 it will not limit
-func GetBranchesByPath(ctx context.Context, repo Repository, skip, limit int) ([]*git.Branch, int, error) {
-	gitRepo, err := OpenRepository(ctx, repo)
-	if err != nil {
-		return nil, 0, err
-	}
-	defer gitRepo.Close()
-
-	return gitRepo.GetBranches(skip, limit)
+func GetBranches(ctx context.Context, repo Repository, skip, limit int) ([]string, int, error) {
+	branchNames := []string{}
+	countAll, err := curService.WalkShowRef(ctx, repo, git.TrustedCmdArgs{git.BranchPrefix, "--sort=-committerdate"}, skip, limit, func(_, branchName string) error {
+		branchName = strings.TrimPrefix(branchName, git.BranchPrefix)
+		branchNames = append(branchNames, branchName)
+
+		return nil
+	})
+	return branchNames, countAll, err
 }
 
 func GetBranchCommitID(ctx context.Context, repo Repository, branch string) (string, error) {
-	gitRepo, err := OpenRepository(ctx, repo)
+	gitRepo, err := curService.OpenRepository(ctx, repo)
 	if err != nil {
 		return "", err
 	}
 	defer gitRepo.Close()
-
-	return gitRepo.GetBranchCommitID(branch)
+	return gitRepo.GetRefCommitID(branch)
 }
 
 // SetDefaultBranch sets default branch of repository.
 func SetDefaultBranch(ctx context.Context, repo Repository, name string) error {
-	_, _, err := git.NewCommand(ctx, "symbolic-ref", "HEAD").
-		AddDynamicArguments(git.BranchPrefix + name).
-		RunStdString(&git.RunOpts{Dir: repoPath(repo)})
-	return err
+	cmd := git.NewCommand(ctx, "symbolic-ref", "HEAD").
+		AddDynamicArguments(git.BranchPrefix + name)
+	return RunGitCmd(ctx, repo, cmd, &git.RunOpts{})
 }
 
 // GetDefaultBranch gets default branch of repository.
 func GetDefaultBranch(ctx context.Context, repo Repository) (string, error) {
-	return git.GetDefaultBranch(ctx, repoPath(repo))
+	cmd := git.NewCommand(ctx, "symbolic-ref", "HEAD")
+	stdout, _, err := RunGitCmdStdString(ctx, repo, cmd, &git.RunOpts{})
+	if err != nil {
+		return "", err
+	}
+	stdout = strings.TrimSpace(stdout)
+	if !strings.HasPrefix(stdout, git.BranchPrefix) {
+		return "", errors.New("the HEAD is not a branch: " + stdout)
+	}
+	return strings.TrimPrefix(stdout, git.BranchPrefix), nil
 }
 
 func GetWikiDefaultBranch(ctx context.Context, repo Repository) (string, error) {
-	return git.GetDefaultBranch(ctx, wikiPath(repo))
+	return GetDefaultBranch(ctx, wikiRepo(repo))
 }

modules/gitrepo/command.go

@@ -0,0 +1,88 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package gitrepo
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+
+	"code.gitea.io/gitea/modules/git"
+	"code.gitea.io/gitea/modules/util"
+)
+
+// RunGitCmd runs the command with the RunOpts
+func RunGitCmd(ctx context.Context, repo Repository, c *git.Command, opts *git.RunOpts) error {
+	if opts.Dir != "" {
+		return fmt.Errorf("dir field must be empty")
+	}
+	opts.Dir = repoRelativePath(repo)
+	return curService.Run(ctx, c, opts)
+}
+
+type runStdError struct {
+	err    error
+	stderr string
+	errMsg string
+}
+
+func (r *runStdError) Error() string {
+	// the stderr must be in the returned error text, some code only checks `strings.Contains(err.Error(), "git error")`
+	if r.errMsg == "" {
+		r.errMsg = git.ConcatenateError(r.err, r.stderr).Error()
+	}
+	return r.errMsg
+}
+
+func (r *runStdError) Unwrap() error {
+	return r.err
+}
+
+func (r *runStdError) Stderr() string {
+	return r.stderr
+}
+
+// RunStdBytes runs the command with options and returns stdout/stderr as bytes. and store stderr to returned error (err combined with stderr).
+func RunGitCmdStdBytes(ctx context.Context, repo Repository, c *git.Command, opts *git.RunOpts) (stdout, stderr []byte, runErr git.RunStdError) {
+	if opts == nil {
+		opts = &git.RunOpts{}
+	}
+	if opts.Stdout != nil || opts.Stderr != nil {
+		// we must panic here, otherwise there would be bugs if developers set Stdin/Stderr by mistake, and it would be very difficult to debug
+		panic("stdout and stderr field must be nil when using RunStdBytes")
+	}
+	stdoutBuf := &bytes.Buffer{}
+	stderrBuf := &bytes.Buffer{}
+
+	// We must not change the provided options as it could break future calls - therefore make a copy.
+	newOpts := &git.RunOpts{
+		Env:               opts.Env,
+		Timeout:           opts.Timeout,
+		UseContextTimeout: opts.UseContextTimeout,
+		Stdout:            stdoutBuf,
+		Stderr:            stderrBuf,
+		Stdin:             opts.Stdin,
+		PipelineFunc:      opts.PipelineFunc,
+	}
+
+	err := RunGitCmd(ctx, repo, c, newOpts)
+	stderr = stderrBuf.Bytes()
+	if err != nil {
+		return nil, stderr, &runStdError{err: err, stderr: util.UnsafeBytesToString(stderr)}
+	}
+	// even if there is no err, there could still be some stderr output
+	return stdoutBuf.Bytes(), stderr, nil
+}
+
+// RunStdString runs the command with options and returns stdout/stderr as string. and store stderr to returned error (err combined with stderr).
+func RunGitCmdStdString(ctx context.Context, repo Repository, c *git.Command, opts *git.RunOpts) (stdout, stderr string, runErr git.RunStdError) {
+	stdoutBytes, stderrBytes, err := RunGitCmdStdBytes(ctx, repo, c, opts)
+	stdout = util.UnsafeBytesToString(stdoutBytes)
+	stderr = util.UnsafeBytesToString(stderrBytes)
+	if err != nil {
+		return stdout, stderr, &runStdError{err: err, stderr: stderr}
+	}
+	// even if there is no err, there could still be some stderr output, so we just return stdout/stderr as they are
+	return stdout, stderr, nil
+}

modules/gitrepo/gitrepo.go

@@ -6,33 +6,30 @@ package gitrepo
 import (
 	"context"
 	"io"
-	"path/filepath"
 	"strings"
 
 	"code.gitea.io/gitea/modules/git"
-	"code.gitea.io/gitea/modules/setting"
 )
 
 type Repository interface {
 	GetName() string
 	GetOwnerName() string
 }
 
-func repoPath(repo Repository) string {
-	return filepath.Join(setting.RepoRootPath, strings.ToLower(repo.GetOwnerName()), strings.ToLower(repo.GetName())+".git")
+type wikiRepository struct {
+	Repository
 }
 
-func wikiPath(repo Repository) string {
-	return filepath.Join(setting.RepoRootPath, strings.ToLower(repo.GetOwnerName()), strings.ToLower(repo.GetName())+".wiki.git")
+func (w wikiRepository) GetName() string {
+	return w.Repository.GetName() + ".wiki"
 }
 
-// OpenRepository opens the repository at the given relative path with the provided context.
-func OpenRepository(ctx context.Context, repo Repository) (*git.Repository, error) {
-	return git.OpenRepository(ctx, repoPath(repo))
+func wikiRepo(repo Repository) Repository {
+	return wikiRepository{repo}
 }
 
-func OpenWikiRepository(ctx context.Context, repo Repository) (*git.Repository, error) {
-	return git.OpenRepository(ctx, wikiPath(repo))
+func repoRelativePath(repo Repository) string {
+	return strings.ToLower(repo.GetOwnerName()) + "/" + strings.ToLower(repo.GetName()) + ".git"
 }
 
 // contextKey is a value for use with context.WithValue.
@@ -51,7 +48,7 @@ func repositoryFromContext(ctx context.Context, repo Repository) *git.Repository
 	}
 
 	if gitRepo, ok := value.(*git.Repository); ok && gitRepo != nil {
-		if gitRepo.Path == repoPath(repo) {
+		if strings.HasSuffix(gitRepo.Path, repoRelativePath(repo)) {
 			return gitRepo
 		}
 	}

modules/gitrepo/init.go

@@ -0,0 +1,19 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package gitrepo
+
+import (
+	"context"
+
+	"code.gitea.io/gitea/modules/setting"
+)
+
+var curService Service
+
+func Init(ctx context.Context) error {
+	curService = &localServiceImpl{
+		repoRootDir: setting.RepoRootPath,
+	}
+	return nil
+}

modules/gitrepo/repository.go

@@ -0,0 +1,19 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package gitrepo
+
+import (
+	"context"
+
+	"code.gitea.io/gitea/modules/git"
+)
+
+// OpenRepository opens the repository at the given relative path with the provided context.
+func OpenRepository(ctx context.Context, repo Repository) (*git.Repository, error) {
+	return curService.OpenRepository(ctx, repo)
+}
+
+func OpenWikiRepository(ctx context.Context, repo Repository) (*git.Repository, error) {
+	return curService.OpenRepository(ctx, wikiRepo(repo))
+}

modules/gitrepo/service.go

@@ -0,0 +1,52 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package gitrepo
+
+import (
+	"context"
+	"path/filepath"
+
+	"code.gitea.io/gitea/modules/git"
+)
+
+type Service interface {
+	OpenRepository(ctx context.Context, repo Repository) (*git.Repository, error)
+	Run(ctx context.Context, c *git.Command, opts *git.RunOpts) error
+	RepoGitURL(repo Repository) string
+	WalkShowRef(ctx context.Context, repo Repository, extraArgs git.TrustedCmdArgs, skip, limit int, walkfn func(sha1, refname string) error) (countAll int, err error)
+}
+
+var _ Service = &localServiceImpl{}
+
+type localServiceImpl struct {
+	repoRootDir string
+}
+
+func (s *localServiceImpl) Run(ctx context.Context, c *git.Command, opts *git.RunOpts) error {
+	opts.Dir = s.absPath(opts.Dir)
+	return c.Run(opts)
+}
+
+func (s *localServiceImpl) absPath(relativePaths ...string) string {
+	for _, p := range relativePaths {
+		if filepath.IsAbs(p) {
+			// we must panic here, otherwise there would be bugs if developers set Dir by mistake, and it would be very difficult to debug
+			panic("dir field must be relative path")
+		}
+	}
+	path := append([]string{s.repoRootDir}, relativePaths...)
+	return filepath.Join(path...)
+}
+
+func (s *localServiceImpl) OpenRepository(ctx context.Context, repo Repository) (*git.Repository, error) {
+	return git.OpenRepository(ctx, s.absPath(repoRelativePath(repo)))
+}
+
+func (s *localServiceImpl) RepoGitURL(repo Repository) string {
+	return s.absPath(repoRelativePath(repo))
+}
+
+func (s *localServiceImpl) WalkShowRef(ctx context.Context, repo Repository, extraArgs git.TrustedCmdArgs, skip, limit int, walkfn func(sha1, refname string) error) (int, error) {
+	return git.WalkShowRef(ctx, s.absPath(repoRelativePath(repo)), extraArgs, skip, limit, walkfn)
+}

modules/gitrepo/url.go

@@ -4,5 +4,5 @@
 package gitrepo
 
 func RepoGitURL(repo Repository) string {
-	return repoPath(repo)
+	return curService.RepoGitURL(repo)
 }

modules/gitrepo/walk_nogogit.go renamed to modules/gitrepo/walk.go

@@ -1,17 +1,13 @@
 // Copyright 2024 The Gitea Authors. All rights reserved.
 // SPDX-License-Identifier: MIT
 
-//go:build !gogit
-
 package gitrepo
 
 import (
 	"context"
-
-	"code.gitea.io/gitea/modules/git"
 )
 
 // WalkReferences walks all the references from the repository
 func WalkReferences(ctx context.Context, repo Repository, walkfn func(sha1, refname string) error) (int, error) {
-	return git.WalkShowRef(ctx, repoPath(repo), nil, 0, 0, walkfn)
+	return curService.WalkShowRef(ctx, repo, nil, 0, 0, walkfn)
 }

modules/gitrepo/walk_gogit.go

@@ -405,14 +405,14 @@ func runSync(ctx context.Context, m *repo_model.Mirror) ([]*mirrorSyncResult, bo
 	}
 
 	log.Trace("SyncMirrors [repo: %-v]: invalidating mirror branch caches...", m.Repo)
-	branches, _, err := gitrepo.GetBranchesByPath(ctx, m.Repo, 0, 0)
+	branches, _, err := gitrepo.GetBranches(ctx, m.Repo, 0, 0)
 	if err != nil {
 		log.Error("SyncMirrors [repo: %-v]: failed to GetBranches: %v", m.Repo, err)
 		return nil, false
 	}
 
 	for _, branch := range branches {
-		cache.Remove(m.Repo.GetCommitsCountCacheKey(branch.Name, true))
+		cache.Remove(m.Repo.GetCommitsCountCacheKey(branch, true))
 	}
 
 	m.UpdatedUnix = timeutil.TimeStampNow()