Refactor git command stdio pipe (#36422)

Most potential deadlock problems should have been fixed, and new code is
unlikely to cause new problems with the new design.

Also raise the minimum Git version required to 2.6.0 (released in 2015)

modules/gitrepo/archive.go

@@ -36,7 +36,7 @@ func CreateArchive(ctx context.Context, repo Repository, format string, target i
 		paths[i] = path.Clean(paths[i])
 	}
 	cmd.AddDynamicArguments(paths...)
-	return RunCmdWithStderr(ctx, repo, cmd.WithStdout(target))
+	return RunCmdWithStderr(ctx, repo, cmd.WithStdoutCopy(target))
 }
 
 // CreateBundle create bundle content to the target path

modules/gitrepo/blame.go

@@ -8,7 +8,6 @@ import (
 	"bytes"
 	"context"
 	"io"
-	"os"
 
 	"code.gitea.io/gitea/modules/git"
 	"code.gitea.io/gitea/modules/git/gitcmd"
@@ -34,8 +33,6 @@ type BlamePart struct {
 
 // BlameReader returns part of file blame one by one
 type BlameReader struct {
-	output         io.WriteCloser
-	reader         io.ReadCloser
 	bufferedReader *bufio.Reader
 	done           chan error
 	lastSha        *string
@@ -131,34 +128,42 @@ func (r *BlameReader) Close() error {
 
 	err := <-r.done
 	r.bufferedReader = nil
-	_ = r.reader.Close()
-	_ = r.output.Close()
-	for _, cleanup := range r.cleanupFuncs {
-		if cleanup != nil {
-			cleanup()
-		}
-	}
+	r.cleanup()
 	return err
 }
 
+func (r *BlameReader) cleanup() {
+	for _, cleanup := range r.cleanupFuncs {
+		cleanup()
+	}
+}
+
 // CreateBlameReader creates reader for given repository, commit and file
-func CreateBlameReader(ctx context.Context, objectFormat git.ObjectFormat, repo Repository, commit *git.Commit, file string, bypassBlameIgnore bool) (rd *BlameReader, err error) {
-	var ignoreRevsFileName string
-	var ignoreRevsFileCleanup func()
+func CreateBlameReader(ctx context.Context, objectFormat git.ObjectFormat, repo Repository, commit *git.Commit, file string, bypassBlameIgnore bool) (rd *BlameReader, retErr error) {
 	defer func() {
-		if err != nil && ignoreRevsFileCleanup != nil {
-			ignoreRevsFileCleanup()
+		if retErr != nil {
+			rd.cleanup()
 		}
 	}()
 
+	rd = &BlameReader{
+		done:         make(chan error, 1),
+		objectFormat: objectFormat,
+	}
+
 	cmd := gitcmd.NewCommand("blame", "--porcelain")
 
+	stdoutReader, stdoutReaderClose := cmd.MakeStdoutPipe()
+	rd.bufferedReader = bufio.NewReader(stdoutReader)
+	rd.cleanupFuncs = append(rd.cleanupFuncs, stdoutReaderClose)
+
 	if git.DefaultFeatures().CheckVersionAtLeast("2.23") && !bypassBlameIgnore {
-		ignoreRevsFileName, ignoreRevsFileCleanup, err = tryCreateBlameIgnoreRevsFile(commit)
+		ignoreRevsFileName, ignoreRevsFileCleanup, err := tryCreateBlameIgnoreRevsFile(commit)
 		if err != nil && !git.IsErrNotExist(err) {
 			return nil, err
-		}
-		if ignoreRevsFileName != "" {
+		} else if err == nil {
+			rd.ignoreRevsFile = ignoreRevsFileName
+			rd.cleanupFuncs = append(rd.cleanupFuncs, ignoreRevsFileCleanup)
 			// Possible improvement: use --ignore-revs-file /dev/stdin on unix
 			// There is no equivalent on Windows. May be implemented if Gitea uses an external git backend.
 			cmd.AddOptionValues("--ignore-revs-file", ignoreRevsFileName)
@@ -167,28 +172,12 @@ func CreateBlameReader(ctx context.Context, objectFormat git.ObjectFormat, repo
 
 	cmd.AddDynamicArguments(commit.ID.String()).AddDashesAndList(file)
 
-	done := make(chan error, 1)
-	reader, stdout, err := os.Pipe()
-	if err != nil {
-		return nil, err
-	}
 	go func() {
 		// TODO: it doesn't work for directories (the directories shouldn't be "blamed"), and the "err" should be returned by "Read" but not by "Close"
-		err := RunCmdWithStderr(ctx, repo, cmd.WithStdout(stdout))
-		done <- err
-		_ = stdout.Close()
+		rd.done <- RunCmdWithStderr(ctx, repo, cmd)
 	}()
 
-	bufferedReader := bufio.NewReader(reader)
-	return &BlameReader{
-		output:         stdout,
-		reader:         reader,
-		bufferedReader: bufferedReader,
-		done:           done,
-		ignoreRevsFile: ignoreRevsFileName,
-		objectFormat:   objectFormat,
-		cleanupFuncs:   []func(){ignoreRevsFileCleanup},
-	}, nil
+	return rd, nil
 }
 
 func tryCreateBlameIgnoreRevsFile(commit *git.Commit) (string, func(), error) {

modules/gitrepo/commit_file.go

@@ -67,20 +67,18 @@ func parseCommitFileStatus(fileStatus *CommitFileStatus, stdout io.Reader) {
 
 // GetCommitFileStatus returns file status of commit in given repository.
 func GetCommitFileStatus(ctx context.Context, repo Repository, commitID string) (*CommitFileStatus, error) {
-	stdout, w := io.Pipe()
+	cmd := gitcmd.NewCommand("log", "--name-status", "-m", "--pretty=format:", "--first-parent", "--no-renames", "-z", "-1")
+	stdout, stdoutClose := cmd.MakeStdoutPipe()
+	defer stdoutClose()
 	done := make(chan struct{})
 	fileStatus := NewCommitFileStatus()
 	go func() {
 		parseCommitFileStatus(fileStatus, stdout)
 		close(done)
 	}()
-
-	err := gitcmd.NewCommand("log", "--name-status", "-m", "--pretty=format:", "--first-parent", "--no-renames", "-z", "-1").
-		AddDynamicArguments(commitID).
+	err := cmd.AddDynamicArguments(commitID).
 		WithDir(repoPath(repo)).
-		WithStdout(w).
 		RunWithStderr(ctx)
-	_ = w.Close() // Close writer to exit parsing goroutine
 	if err != nil {
 		return nil, err
 	}

modules/gitrepo/diff.go

@@ -66,6 +66,6 @@ func parseDiffStat(stdout string) (numFiles, totalAdditions, totalDeletions int,
 func GetReverseRawDiff(ctx context.Context, repo Repository, commitID string, writer io.Writer) error {
 	return RunCmdWithStderr(ctx, repo, gitcmd.NewCommand("show", "--pretty=format:revert %H%n", "-R").
 		AddDynamicArguments(commitID).
-		WithStdout(writer),
+		WithStdoutCopy(writer),
 	)
 }