Merge branch '5395-feature-flag-git-merge-tree-for-resolveconflicts' into 'master'

conflicts: Remove git2go implementation of `ResolveConflicts`

Closes #5436 and #5395

See merge request https://gitlab.com/gitlab-org/gitaly/-/merge_requests/6122

Merged-by: Justin Tobler <jtobler@gitlab.com>
Approved-by: John Cai <jcai@gitlab.com>
Approved-by: Justin Tobler <jtobler@gitlab.com>
Reviewed-by: Justin Tobler <jtobler@gitlab.com>
Reviewed-by: karthik nayak <knayak@gitlab.com>
Co-authored-by: Karthik Nayak <knayak@gitlab.com>

10 files changed, 53 insertions, 448 deletions

diff --git a/cmd/gitaly-git2go/main.go b/cmd/gitaly-git2go/main.go
index 137dceb46..f3af1d68c 100644
--- a/cmd/gitaly-git2go/main.go
+++ b/cmd/gitaly-git2go/main.go
@@ -29,7 +29,6 @@ var subcommands = map[string]subcmd{
 	"merge":       &mergeSubcommand{},
 	"rebase":      &rebaseSubcommand{},
 	"revert":      &revertSubcommand{},
-	"resolve":     &resolveSubcommand{},
 }
 
 func fatalf(logger logrus.FieldLogger, encoder *gob.Encoder, format string, args ...interface{}) {
diff --git a/cmd/gitaly-git2go/resolve_conflicts.go b/cmd/gitaly-git2go/resolve_conflicts.go
deleted file mode 100644
index 5f322e856..000000000
--- a/cmd/gitaly-git2go/resolve_conflicts.go
+++ /dev/null
@@ -1,272 +0,0 @@
-//go:build static && system_libgit2
-
-package main
-
-import (
-	"bytes"
-	"context"
-	"encoding/gob"
-	"errors"
-	"flag"
-	"fmt"
-	"strings"
-	"time"
-
-	git "github.com/libgit2/git2go/v34"
-	"gitlab.com/gitlab-org/gitaly/v16/cmd/gitaly-git2go/git2goutil"
-	"gitlab.com/gitlab-org/gitaly/v16/internal/git/conflict"
-	"gitlab.com/gitlab-org/gitaly/v16/internal/git2go"
-)
-
-type resolveSubcommand struct{}
-
-func (cmd *resolveSubcommand) Flags() *flag.FlagSet {
-	return flag.NewFlagSet("resolve", flag.ExitOnError)
-}
-
-func (cmd resolveSubcommand) Run(_ context.Context, decoder *gob.Decoder, encoder *gob.Encoder) error {
-	var request git2go.ResolveCommand
-	if err := decoder.Decode(&request); err != nil {
-		return err
-	}
-
-	if request.AuthorDate.IsZero() {
-		request.AuthorDate = time.Now()
-	}
-
-	repo, err := git2goutil.OpenRepository(request.Repository)
-	if err != nil {
-		return fmt.Errorf("could not open repository: %w", err)
-	}
-
-	ours, err := lookupCommit(repo, request.Ours)
-	if err != nil {
-		return fmt.Errorf("ours commit lookup: %w", err)
-	}
-
-	theirs, err := lookupCommit(repo, request.Theirs)
-	if err != nil {
-		return fmt.Errorf("theirs commit lookup: %w", err)
-	}
-
-	index, err := repo.MergeCommits(ours, theirs, nil)
-	if err != nil {
-		return fmt.Errorf("could not merge commits: %w", err)
-	}
-
-	ci, err := index.ConflictIterator()
-	if err != nil {
-		return err
-	}
-
-	type paths struct {
-		theirs, ours string
-	}
-	conflicts := map[paths]git.IndexConflict{}
-
-	for {
-		c, err := ci.Next()
-		if git.IsErrorCode(err, git.ErrorCodeIterOver) {
-			break
-		}
-		if err != nil {
-			return err
-		}
-
-		if c.Our.Path == "" || c.Their.Path == "" {
-			return errors.New("conflict side missing")
-		}
-
-		k := paths{
-			theirs: c.Their.Path,
-			ours:   c.Our.Path,
-		}
-		conflicts[k] = c
-	}
-
-	odb, err := repo.Odb()
-	if err != nil {
-		return err
-	}
-
-	for _, r := range request.Resolutions {
-		c, ok := conflicts[paths{
-			theirs: r.OldPath,
-			ours:   r.NewPath,
-		}]
-		if !ok {
-			// Note: this emulates the Ruby error that occurs when
-			// there are no conflicts for a resolution
-			return errors.New("NoMethodError: undefined method `resolve_lines' for nil:NilClass")
-		}
-
-		switch {
-		case c.Our == nil:
-			return fmt.Errorf("missing our-part of merge file input for new path %q", r.NewPath)
-		case c.Their == nil:
-			return fmt.Errorf("missing their-part of merge file input for new path %q", r.NewPath)
-		}
-
-		ancestor, our, their, err := readConflictEntries(odb, c)
-		if err != nil {
-			return fmt.Errorf("read conflict entries: %w", err)
-		}
-
-		mfr, err := mergeFileResult(ancestor, our, their)
-		if err != nil {
-			return fmt.Errorf("merge file result for %q: %w", r.NewPath, err)
-		}
-
-		if r.Content != "" && bytes.Equal([]byte(r.Content), mfr.Contents) {
-			return fmt.Errorf("Resolved content has no changes for file %s", r.NewPath) //nolint
-		}
-
-		conflictFile, err := conflict.Parse(
-			bytes.NewReader(mfr.Contents),
-			ancestor,
-			our,
-			their,
-		)
-		if err != nil {
-			return fmt.Errorf("parse conflict for %q: %w", c.Our.Path, err)
-		}
-
-		resolvedBlob, err := conflictFile.Resolve(r)
-		if err != nil {
-			return err // do not decorate this error to satisfy old test
-		}
-
-		resolvedBlobOID, err := odb.Write(resolvedBlob, git.ObjectBlob)
-		if err != nil {
-			return fmt.Errorf("write object for %q: %w", c.Ancestor.Path, err)
-		}
-
-		ourResolvedEntry := *c.Our // copy by value
-		ourResolvedEntry.Id = resolvedBlobOID
-		if err := index.Add(&ourResolvedEntry); err != nil {
-			return fmt.Errorf("add index for %q: %w", c.Ancestor.Path, err)
-		}
-
-		if err := index.RemoveConflict(ourResolvedEntry.Path); err != nil {
-			return fmt.Errorf("remove conflict from index for %q: %w", c.Ancestor.Path, err)
-		}
-	}
-
-	if index.HasConflicts() {
-		ci, err := index.ConflictIterator()
-		if err != nil {
-			return fmt.Errorf("iterating unresolved conflicts: %w", err)
-		}
-
-		var conflictPaths []string
-		for {
-			c, err := ci.Next()
-			if git.IsErrorCode(err, git.ErrorCodeIterOver) {
-				break
-			}
-			if err != nil {
-				return fmt.Errorf("next unresolved conflict: %w", err)
-			}
-			var conflictingPath string
-			if c.Ancestor != nil {
-				conflictingPath = c.Ancestor.Path
-			} else {
-				conflictingPath = c.Our.Path
-			}
-
-			conflictPaths = append(conflictPaths, conflictingPath)
-		}
-
-		return fmt.Errorf("Missing resolutions for the following files: %s", strings.Join(conflictPaths, ", ")) //nolint
-	}
-
-	treeOID, err := index.WriteTreeTo(repo)
-	if err != nil {
-		return fmt.Errorf("write tree to repo: %w", err)
-	}
-	tree, err := repo.LookupTree(treeOID)
-	if err != nil {
-		return fmt.Errorf("lookup tree: %w", err)
-	}
-
-	sign := git2go.NewSignature(request.AuthorName, request.AuthorMail, request.AuthorDate)
-	committer := &git.Signature{
-		Name:  sign.Name,
-		Email: sign.Email,
-		When:  request.AuthorDate,
-	}
-
-	commitID, err := git2goutil.NewCommitSubmitter(repo, request.SigningKey).
-		Commit(committer, committer, git.MessageEncodingUTF8, request.Message, tree, ours, theirs)
-	if err != nil {
-		return fmt.Errorf("create commit: %w", err)
-	}
-
-	response := git2go.ResolveResult{
-		MergeResult: git2go.MergeResult{
-			CommitID: commitID.String(),
-		},
-	}
-
-	return encoder.Encode(response)
-}
-
-func readConflictEntries(odb *git.Odb, c git.IndexConflict) (*conflict.Entry, *conflict.Entry, *conflict.Entry, error) {
-	var ancestor, our, their *conflict.Entry
-
-	for _, part := range []struct {
-		entry  *git.IndexEntry
-		result **conflict.Entry
-	}{
-		{entry: c.Ancestor, result: &ancestor},
-		{entry: c.Our, result: &our},
-		{entry: c.Their, result: &their},
-	} {
-		if part.entry == nil {
-			continue
-		}
-
-		blob, err := odb.Read(part.entry.Id)
-		if err != nil {
-			return nil, nil, nil, err
-		}
-
-		data := blob.Data()
-		contents := make([]byte, len(data))
-		copy(contents, data)
-
-		*part.result = &conflict.Entry{
-			Path:     part.entry.Path,
-			Mode:     uint(part.entry.Mode),
-			Contents: contents,
-		}
-	}
-
-	return ancestor, our, their, nil
-}
-
-func mergeFileResult(ancestor, our, their *conflict.Entry) (*git.MergeFileResult, error) {
-	mfr, err := git.MergeFile(
-		conflictEntryToMergeFileInput(ancestor),
-		conflictEntryToMergeFileInput(our),
-		conflictEntryToMergeFileInput(their),
-		nil,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	return mfr, nil
-}
-
-func conflictEntryToMergeFileInput(e *conflict.Entry) git.MergeFileInput {
-	if e == nil {
-		return git.MergeFileInput{}
-	}
-
-	return git.MergeFileInput{
-		Path:     e.Path,
-		Mode:     e.Mode,
-		Contents: e.Contents,
-	}
-}
diff --git a/internal/featureflag/ff_resolve_conflicts_via_git.go b/internal/featureflag/ff_resolve_conflicts_via_git.go
deleted file mode 100644
index b26525e48..000000000
--- a/internal/featureflag/ff_resolve_conflicts_via_git.go
+++ /dev/null
@@ -1,10 +0,0 @@
-package featureflag
-
-// ResolveConflictsViaGit enables the usage of git-merge-tree(1) for
-// the ResolveConflicts RPC.
-var ResolveConflictsViaGit = NewFeatureFlag(
-	"resolve_conflicts_via_git",
-	"v16.2.0",
-	"https://gitlab.com/gitlab-org/gitaly/-/issues/5395",
-	false,
-)
diff --git a/internal/git2go/resolve_conflicts.go b/internal/git2go/resolve_conflicts.go
deleted file mode 100644
index 57089ed79..000000000
--- a/internal/git2go/resolve_conflicts.go
+++ /dev/null
@@ -1,57 +0,0 @@
-package git2go
-
-import (
-	"bytes"
-	"context"
-	"encoding/gob"
-	"fmt"
-
-	"gitlab.com/gitlab-org/gitaly/v16/internal/git/conflict"
-	"gitlab.com/gitlab-org/gitaly/v16/internal/gitaly/storage"
-)
-
-// ResolveCommand contains arguments to perform a merge commit and resolve any
-// conflicts produced from that merge commit
-type ResolveCommand struct {
-	MergeCommand
-	Resolutions []conflict.Resolution
-}
-
-// ResolveResult returns information about the successful merge and resolution
-type ResolveResult struct {
-	MergeResult
-
-	// Err is set if an error occurred. Err must exist on all gob serialized
-	// results so that any error can be returned.
-	Err error
-}
-
-// Resolve will attempt merging and resolving conflicts for the provided request
-func (b *Executor) Resolve(ctx context.Context, repo storage.Repository, r ResolveCommand) (ResolveResult, error) {
-	r.SigningKey = b.signingKey
-
-	if err := r.verify(); err != nil {
-		return ResolveResult{}, fmt.Errorf("resolve: %w: %s", ErrInvalidArgument, err.Error())
-	}
-
-	input := &bytes.Buffer{}
-	if err := gob.NewEncoder(input).Encode(r); err != nil {
-		return ResolveResult{}, fmt.Errorf("resolve: %w", err)
-	}
-
-	stdout, err := b.run(ctx, repo, input, "resolve")
-	if err != nil {
-		return ResolveResult{}, err
-	}
-
-	var response ResolveResult
-	if err := gob.NewDecoder(stdout).Decode(&response); err != nil {
-		return ResolveResult{}, fmt.Errorf("resolve: %w", err)
-	}
-
-	if response.Err != nil {
-		return ResolveResult{}, response.Err
-	}
-
-	return response, nil
-}
diff --git a/internal/gitaly/service/conflicts/list_conflict_files_test.go b/internal/gitaly/service/conflicts/list_conflict_files_test.go
index 04b5725c5..367845c96 100644
--- a/internal/gitaly/service/conflicts/list_conflict_files_test.go
+++ b/internal/gitaly/service/conflicts/list_conflict_files_test.go
@@ -1,5 +1,3 @@
-//go:build !gitaly_test_sha256
-
 package conflicts
 
 import (
diff --git a/internal/gitaly/service/conflicts/resolve_conflicts.go b/internal/gitaly/service/conflicts/resolve_conflicts.go
index d2b0ba85b..9a442276e 100644
--- a/internal/gitaly/service/conflicts/resolve_conflicts.go
+++ b/internal/gitaly/service/conflicts/resolve_conflicts.go
@@ -13,12 +13,10 @@ import (
 	"time"
 
 	"github.com/grpc-ecosystem/go-grpc-middleware/logging/logrus/ctxlogrus"
-	"gitlab.com/gitlab-org/gitaly/v16/internal/featureflag"
 	"gitlab.com/gitlab-org/gitaly/v16/internal/git"
 	"gitlab.com/gitlab-org/gitaly/v16/internal/git/conflict"
 	"gitlab.com/gitlab-org/gitaly/v16/internal/git/localrepo"
 	"gitlab.com/gitlab-org/gitaly/v16/internal/git/remoterepo"
-	"gitlab.com/gitlab-org/gitaly/v16/internal/git2go"
 	"gitlab.com/gitlab-org/gitaly/v16/internal/gitaly/storage"
 	"gitlab.com/gitlab-org/gitaly/v16/internal/structerr"
 	"gitlab.com/gitlab-org/gitaly/v16/proto/go/gitalypb"
@@ -156,58 +154,31 @@ func (s *server) resolveConflicts(header *gitalypb.ResolveConflictsRequestHeader
 		return err
 	}
 
-	repoPath, err := s.locator.GetRepoPath(quarantineRepo)
-	if err != nil {
-		return err
-	}
-
 	authorDate := time.Now()
 	if header.Timestamp != nil {
 		authorDate = header.Timestamp.AsTime()
 	}
 
-	if git.ObjectHashSHA1.ValidateHex(header.GetOurCommitOid()) != nil ||
-		git.ObjectHashSHA1.ValidateHex(header.GetTheirCommitOid()) != nil {
-		return errors.New("Rugged::InvalidError: unable to parse OID - contains invalid characters")
+	objectHash, err := quarantineRepo.ObjectHash(ctx)
+	if err != nil {
+		return fmt.Errorf("detecting object hash: %w", err)
 	}
 
-	var result git2go.ResolveResult
-	if !featureflag.ResolveConflictsViaGit.IsEnabled(ctx) {
-		result, err = s.git2goExecutor.Resolve(ctx, quarantineRepo, git2go.ResolveCommand{
-			MergeCommand: git2go.MergeCommand{
-				Repository: repoPath,
-				AuthorName: string(header.User.Name),
-				AuthorMail: string(header.User.Email),
-				AuthorDate: authorDate,
-				Message:    string(header.CommitMessage),
-				Ours:       header.GetOurCommitOid(),
-				Theirs:     header.GetTheirCommitOid(),
-			},
-			Resolutions: resolutions,
-		})
-		if err != nil {
-			if errors.Is(err, git2go.ErrInvalidArgument) {
-				return structerr.NewInvalidArgument("%w", err)
-			}
-			return err
-		}
-	} else {
-		result, err = s.resolveConflictsWithGit(
-			ctx,
-			header.GetOurCommitOid(),
-			header.GetTheirCommitOid(),
-			quarantineRepo,
-			resolutions,
-			authorDate,
-			header.User,
-			header.GetCommitMessage(),
-		)
-		if err != nil {
-			return err
-		}
+	if objectHash.ValidateHex(header.GetOurCommitOid()) != nil ||
+		objectHash.ValidateHex(header.GetTheirCommitOid()) != nil {
+		return errors.New("Rugged::InvalidError: unable to parse OID - contains invalid characters")
 	}
 
-	commitOID, err := git.ObjectHashSHA1.FromHex(result.CommitID)
+	commitOID, err := s.resolveConflictsWithGit(
+		ctx,
+		header.GetOurCommitOid(),
+		header.GetTheirCommitOid(),
+		quarantineRepo,
+		resolutions,
+		authorDate,
+		header.User,
+		header.GetCommitMessage(),
+	)
 	if err != nil {
 		return err
 	}
@@ -235,9 +206,7 @@ func (s *server) resolveConflictsWithGit(
 	authorDate time.Time,
 	user *gitalypb.User,
 	commitMessage []byte,
-) (git2go.ResolveResult, error) {
-	var result git2go.ResolveResult
-
+) (git.ObjectID, error) {
 	treeOID, err := repo.MergeTree(ctx, ours, theirs, localrepo.WithAllowUnrelatedHistories())
 
 	var mergeConflictErr *localrepo.MergeTreeConflictError
@@ -250,12 +219,12 @@ func (s *server) resolveConflictsWithGit(
 
 		tree, err := repo.ReadTree(ctx, treeOID.Revision(), localrepo.WithRecursive())
 		if err != nil {
-			return result, structerr.NewInternal("getting tree: %w", err)
+			return "", structerr.NewInternal("getting tree: %w", err)
 		}
 
 		objectReader, cancel, err := s.catfileCache.ObjectReader(ctx, repo)
 		if err != nil {
-			return result, structerr.NewInternal("getting objectreader: %w", err)
+			return "", structerr.NewInternal("getting objectreader: %w", err)
 		}
 		defer cancel()
 
@@ -265,7 +234,7 @@ func (s *server) resolveConflictsWithGit(
 			if _, ok := checkedConflictedFiles[path]; !ok {
 				// Note: this emulates the Ruby error that occurs when
 				// there are no conflicts for a resolution
-				return result, errors.New("NoMethodError: undefined method `resolve_lines' for nil:NilClass")
+				return "", errors.New("NoMethodError: undefined method `resolve_lines' for nil:NilClass")
 			}
 
 			// We mark the file as checked, any remaining files, which don't have a resolution
@@ -274,11 +243,11 @@ func (s *server) resolveConflictsWithGit(
 
 			conflictedBlob, err := tree.Get(path)
 			if err != nil {
-				return result, structerr.NewInternal("path not found in merged-tree: %w", err)
+				return "", structerr.NewInternal("path not found in merged-tree: %w", err)
 			}
 
 			if conflictedBlob.Type != localrepo.Blob {
-				return result, structerr.NewInternal("entry should be of type blob").
+				return "", structerr.NewInternal("entry should be of type blob").
 					WithMetadataItems(
 						structerr.MetadataItem{Key: "path", Value: path},
 						structerr.MetadataItem{Key: "type", Value: conflictedBlob.Type},
@@ -290,12 +259,12 @@ func (s *server) resolveConflictsWithGit(
 			if resolution.Content != "" {
 				object, err := objectReader.Object(ctx, conflictedBlob.OID.Revision())
 				if err != nil {
-					return result, structerr.NewInternal("retrieving object: %w", err)
+					return "", structerr.NewInternal("retrieving object: %w", err)
 				}
 
 				content, err := io.ReadAll(object)
 				if err != nil {
-					return result, structerr.NewInternal("reading object: %w", err)
+					return "", structerr.NewInternal("reading object: %w", err)
 				}
 
 				// Git2Go conflict markers have filenames and git-merge-tree(1) has commit OIDs.
@@ -308,13 +277,13 @@ func (s *server) resolveConflictsWithGit(
 
 				if bytes.Equal([]byte(resolution.Content), content) {
 					// This is to keep the error consistent with git2go implementation
-					return result, structerr.NewInvalidArgument("Resolved content has no changes for file %s", path)
+					return "", structerr.NewInvalidArgument("Resolved content has no changes for file %s", path)
 				}
 			}
 
 			object, err := objectReader.Object(ctx, git.Revision(fmt.Sprintf("%s:%s", ours, resolution.OldPath)))
 			if err != nil {
-				return result, structerr.NewInternal("retrieving object: %w", err)
+				return "", structerr.NewInternal("retrieving object: %w", err)
 			}
 
 			// Rails expects files ending with newlines to retain them post conflict, but
@@ -323,7 +292,7 @@ func (s *server) resolveConflictsWithGit(
 
 			oursContent, err := io.ReadAll(object)
 			if err != nil {
-				return result, structerr.NewInternal("reading object: %w", err)
+				return "", structerr.NewInternal("reading object: %w", err)
 			}
 			if len(oursContent) > 0 {
 				needsNewLine = oursContent[len(oursContent)-1] == '\n'
@@ -331,17 +300,17 @@ func (s *server) resolveConflictsWithGit(
 
 			object, err = objectReader.Object(ctx, conflictedBlob.OID.Revision())
 			if err != nil {
-				return result, structerr.NewInternal("retrieving object: %w", err)
+				return "", structerr.NewInternal("retrieving object: %w", err)
 			}
 
 			resolvedContent, err := conflict.Resolve(object, git.ObjectID(ours), git.ObjectID(theirs), path, resolution, needsNewLine)
 			if err != nil {
-				return result, structerr.NewInternal("%w", err)
+				return "", structerr.NewInternal("%w", err)
 			}
 
 			blobOID, err := repo.WriteBlob(ctx, filepath.Base(path), resolvedContent)
 			if err != nil {
-				return result, structerr.NewInternal("writing blob: %w", err)
+				return "", structerr.NewInternal("writing blob: %w", err)
 			}
 
 			err = tree.Add(path, localrepo.TreeEntry{
@@ -351,24 +320,24 @@ func (s *server) resolveConflictsWithGit(
 				Type: localrepo.Blob,
 			}, localrepo.WithOverwriteFile())
 			if err != nil {
-				return result, structerr.NewInternal("add to tree: %w", err)
+				return "", structerr.NewInternal("add to tree: %w", err)
 			}
 		}
 
 		for conflictedFile, checked := range checkedConflictedFiles {
 			if !checked {
-				return result, fmt.Errorf("Missing resolutions for the following files: %s", conflictedFile) //nolint // this is to stay consistent with rugged-rails error
+				return "", fmt.Errorf("Missing resolutions for the following files: %s", conflictedFile) //nolint // this is to stay consistent with rugged-rails error
 			}
 		}
 
 		err = tree.Write(ctx, repo)
 		if err != nil {
-			return result, structerr.NewInternal("write tree: %w", err)
+			return "", structerr.NewInternal("write tree: %w", err)
 		}
 
 		treeOID = tree.OID
 	} else if err != nil {
-		return result, structerr.NewInternal("merge-tree: %w", err)
+		return "", structerr.NewInternal("merge-tree: %w", err)
 	}
 
 	commitOID, err := repo.WriteCommit(ctx, localrepo.WriteCommitConfig{
@@ -383,12 +352,10 @@ func (s *server) resolveConflictsWithGit(
 		TreeID:         treeOID,
 	})
 	if err != nil {
-		return result, structerr.NewInternal("writing commit: %w", err)
+		return "", structerr.NewInternal("writing commit: %w", err)
 	}
 
-	result.CommitID = commitOID.String()
-
-	return result, nil
+	return commitOID, nil
 }
 
 func sameRepo(left, right storage.Repository) bool {
diff --git a/internal/gitaly/service/conflicts/resolve_conflicts_test.go b/internal/gitaly/service/conflicts/resolve_conflicts_test.go
index 8e5ab6ceb..be4f7c41b 100644
--- a/internal/gitaly/service/conflicts/resolve_conflicts_test.go
+++ b/internal/gitaly/service/conflicts/resolve_conflicts_test.go
@@ -1,5 +1,3 @@
-//go:build !gitaly_test_sha256
-
 package conflicts
 
 import (
@@ -39,7 +37,6 @@ func TestResolveConflicts(t *testing.T) {
 	t.Parallel()
 
 	testhelper.NewFeatureSets(
-		featureflag.ResolveConflictsViaGit,
 		featureflag.GPGSigning,
 	).Run(t, testResolveConflicts)
 }
@@ -737,17 +734,6 @@ func testResolveConflicts(t *testing.T, ctx context.Context) {
 				filesJSON, err := json.Marshal(files)
 				require.NoError(t, err)
 
-				expectedContent := map[string]map[string][]byte{
-					"refs/heads/ours": {
-						"a": []byte("A\r\nB\r\nX\r\nD\r\nE\r\n"),
-					},
-				}
-
-				// git replaces crlf with newlines when storing to the database
-				if featureflag.ResolveConflictsViaGit.IsEnabled(ctx) {
-					expectedContent["refs/heads/ours"]["a"] = []byte("A\nB\nX\nD\nE\n")
-				}
-
 				return setupData{
 					cfg:      cfg,
 					client:   client,
@@ -770,7 +756,11 @@ func testResolveConflicts(t *testing.T, ctx context.Context) {
 						{FilesJson: filesJSON},
 					},
 					expectedResponse: &gitalypb.ResolveConflictsResponse{},
-					expectedContent:  expectedContent,
+					expectedContent: map[string]map[string][]byte{
+						"refs/heads/ours": {
+							"a": []byte("A\nB\nX\nD\nE\n"),
+						},
+					},
 				}
 			},
 		},
diff --git a/internal/gitaly/service/conflicts/server.go b/internal/gitaly/service/conflicts/server.go
index 17f218e46..cf9a86979 100644
--- a/internal/gitaly/service/conflicts/server.go
+++ b/internal/gitaly/service/conflicts/server.go
@@ -8,7 +8,6 @@ import (
 	"gitlab.com/gitlab-org/gitaly/v16/internal/git/catfile"
 	"gitlab.com/gitlab-org/gitaly/v16/internal/git/localrepo"
 	"gitlab.com/gitlab-org/gitaly/v16/internal/git/quarantine"
-	"gitlab.com/gitlab-org/gitaly/v16/internal/git2go"
 	"gitlab.com/gitlab-org/gitaly/v16/internal/gitaly/hook"
 	"gitlab.com/gitlab-org/gitaly/v16/internal/gitaly/hook/updateref"
 	"gitlab.com/gitlab-org/gitaly/v16/internal/gitaly/storage"
@@ -18,13 +17,12 @@ import (
 
 type server struct {
 	gitalypb.UnimplementedConflictsServiceServer
-	locator        storage.Locator
-	gitCmdFactory  git.CommandFactory
-	catfileCache   catfile.Cache
-	pool           *client.Pool
-	hookManager    hook.Manager
-	updater        *updateref.UpdaterWithHooks
-	git2goExecutor *git2go.Executor
+	locator       storage.Locator
+	gitCmdFactory git.CommandFactory
+	catfileCache  catfile.Cache
+	pool          *client.Pool
+	hookManager   hook.Manager
+	updater       *updateref.UpdaterWithHooks
 }
 
 // NewServer creates a new instance of a grpc ConflictsServer
@@ -34,17 +32,15 @@ func NewServer(
 	gitCmdFactory git.CommandFactory,
 	catfileCache catfile.Cache,
 	connsPool *client.Pool,
-	git2goExecutor *git2go.Executor,
 	updater *updateref.UpdaterWithHooks,
 ) gitalypb.ConflictsServiceServer {
 	return &server{
-		hookManager:    hookManager,
-		locator:        locator,
-		gitCmdFactory:  gitCmdFactory,
-		catfileCache:   catfileCache,
-		pool:           connsPool,
-		updater:        updater,
-		git2goExecutor: git2goExecutor,
+		hookManager:   hookManager,
+		locator:       locator,
+		gitCmdFactory: gitCmdFactory,
+		catfileCache:  catfileCache,
+		pool:          connsPool,
+		updater:       updater,
 	}
 }
 
diff --git a/internal/gitaly/service/conflicts/testhelper_test.go b/internal/gitaly/service/conflicts/testhelper_test.go
index bec508e0c..99fa6038f 100644
--- a/internal/gitaly/service/conflicts/testhelper_test.go
+++ b/internal/gitaly/service/conflicts/testhelper_test.go
@@ -1,5 +1,3 @@
-//go:build !gitaly_test_sha256
-
 package conflicts
 
 import (
@@ -27,8 +25,6 @@ func TestMain(m *testing.M) {
 func setupConflictsService(tb testing.TB, hookManager hook.Manager) (config.Cfg, gitalypb.ConflictsServiceClient) {
 	cfg := testcfg.Build(tb)
 
-	testcfg.BuildGitalyGit2Go(tb, cfg)
-
 	serverSocketPath := runConflictsServer(tb, cfg, hookManager)
 	cfg.SocketPath = serverSocketPath
 
@@ -46,7 +42,6 @@ func runConflictsServer(tb testing.TB, cfg config.Cfg, hookManager hook.Manager)
 			deps.GetGitCmdFactory(),
 			deps.GetCatfileCache(),
 			deps.GetConnsPool(),
-			deps.GetGit2goExecutor(),
 			deps.GetUpdaterWithHooks(),
 		))
 		gitalypb.RegisterRepositoryServiceServer(srv, repository.NewServer(
diff --git a/internal/gitaly/service/setup/register.go b/internal/gitaly/service/setup/register.go
index 1708124e7..b9320a2be 100644
--- a/internal/gitaly/service/setup/register.go
+++ b/internal/gitaly/service/setup/register.go
@@ -122,7 +122,6 @@ func RegisterAll(srv *grpc.Server, deps *service.Dependencies) {
 		deps.GetGitCmdFactory(),
 		deps.GetCatfileCache(),
 		deps.GetConnsPool(),
-		deps.GetGit2goExecutor(),
 		deps.GetUpdaterWithHooks(),
 	))
 	gitalypb.RegisterRemoteServiceServer(srv, remote.NewServer(