Merge branch 'replace-deprecated-with-dialer' into 'master'

Fix most deprecation warnings

See merge request gitlab-org/gitaly!1630

19 files changed, 103 insertions, 82 deletions

diff --git a/client/dial.go b/client/dial.go
index 8ab04e788..befd73942 100644
--- a/client/dial.go
+++ b/client/dial.go
@@ -1,6 +1,7 @@
 package client
 
 import (
+	"context"
 	"fmt"
 	"net"
 	"time"
@@ -63,13 +64,14 @@ func Dial(rawAddress string, connOpts []grpc.DialOption) (*grpc.ClientConn, erro
 			// Use a custom dialer to ensure that we don't experience
 			// issues in environments that have proxy configurations
 			// https://gitlab.com/gitlab-org/gitaly/merge_requests/1072#note_140408512
-			grpc.WithDialer(func(addr string, timeout time.Duration) (net.Conn, error) {
+			grpc.WithContextDialer(func(ctx context.Context, addr string) (conn net.Conn, err error) {
 				path, err := extractPathFromSocketURL(addr)
 				if err != nil {
 					return nil, err
 				}
 
-				return net.DialTimeout("unix", path, timeout)
+				d := net.Dialer{}
+				return d.DialContext(ctx, "unix", path)
 			}),
 		)
 	}
diff --git a/internal/praefect/coordinator.go b/internal/praefect/coordinator.go
index 3985a13ea..fa322da2b 100644
--- a/internal/praefect/coordinator.go
+++ b/internal/praefect/coordinator.go
@@ -23,6 +23,7 @@ import (
 	"gitlab.com/gitlab-org/gitaly/internal/praefect/grpc-proxy/proxy"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 )
 
 func isDestructive(methodName string) bool {
@@ -128,7 +129,7 @@ func (c *Coordinator) getStorageForRepositoryMessage(mi protoregistry.MethodInfo
 	}
 
 	if targetRepo.StorageName != c.conf.VirtualStorageName {
-		return "", nil, grpc.Errorf(codes.InvalidArgument, "only messages for %s are allowed", c.conf.VirtualStorageName)
+		return "", nil, status.Errorf(codes.InvalidArgument, "only messages for %s are allowed", c.conf.VirtualStorageName)
 	}
 
 	primary, err := c.selectPrimary(mi, targetRepo)
diff --git a/internal/rubyserver/health.go b/internal/rubyserver/health.go
index ffab0c779..07c2369aa 100644
--- a/internal/rubyserver/health.go
+++ b/internal/rubyserver/health.go
@@ -16,8 +16,9 @@ func ping(address string) error {
 		// Use a custom dialer to ensure that we don't experience
 		// issues in environments that have proxy configurations
 		// https://gitlab.com/gitlab-org/gitaly/merge_requests/1072#note_140408512
-		grpc.WithDialer(func(addr string, timeout time.Duration) (net.Conn, error) {
-			return net.DialTimeout("unix", addr, timeout)
+		grpc.WithContextDialer(func(ctx context.Context, addr string) (conn net.Conn, err error) {
+			d := net.Dialer{}
+			return d.DialContext(ctx, "unix", addr)
 		}),
 	)
 	if err != nil {
diff --git a/internal/rubyserver/rubyserver.go b/internal/rubyserver/rubyserver.go
index 2f8e57bc9..5f55e3ff4 100644
--- a/internal/rubyserver/rubyserver.go
+++ b/internal/rubyserver/rubyserver.go
@@ -277,8 +277,9 @@ func dialOptions() []grpc.DialOption {
 		// Use a custom dialer to ensure that we don't experience
 		// issues in environments that have proxy configurations
 		// https://gitlab.com/gitlab-org/gitaly/merge_requests/1072#note_140408512
-		grpc.WithDialer(func(addr string, timeout time.Duration) (net.Conn, error) {
-			return net.DialTimeout("unix", addr, timeout)
+		grpc.WithContextDialer(func(ctx context.Context, addr string) (conn net.Conn, err error) {
+			d := net.Dialer{}
+			return d.DialContext(ctx, "unix", addr)
 		}),
 		grpc.WithUnaryInterceptor(
 			grpc_middleware.ChainUnaryClient(
diff --git a/internal/service/cleanup/internalrefs/cleaner.go b/internal/service/cleanup/internalrefs/cleaner.go
index dc803db34..db6e45ac3 100644
--- a/internal/service/cleanup/internalrefs/cleaner.go
+++ b/internal/service/cleanup/internalrefs/cleaner.go
@@ -120,8 +120,11 @@ func (c *Cleaner) processEntry(oldSHA, newSHA string) error {
 // consulted once per line in the object map. Git is optimized for ref -> SHA
 // lookups, but we want the opposite!
 func buildLookupTable(ctx context.Context, repo *gitalypb.Repository) (map[string][]string, error) {
-	args := append([]string{"for-each-ref", "--format", "%(objectname) %(refname)"}, internalRefs...)
-	cmd, err := git.Command(ctx, repo, args...)
+	cmd, err := git.SafeCmd(ctx, repo, nil, git.SubCmd{
+		Name:  "for-each-ref",
+		Flags: []git.Option{git.ValueFlag{Name: "--format", Value: "%(objectname) %(refname)"}},
+		Args:  internalRefs,
+	})
 	if err != nil {
 		return nil, err
 	}
diff --git a/internal/service/commit/count_commits.go b/internal/service/commit/count_commits.go
index 2f3de307f..51916195f 100644
--- a/internal/service/commit/count_commits.go
+++ b/internal/service/commit/count_commits.go
@@ -20,31 +20,31 @@ func (s *server) CountCommits(ctx context.Context, in *gitalypb.CountCommitsRequ
 		return nil, status.Errorf(codes.InvalidArgument, "CountCommits: %v", err)
 	}
 
-	cmdArgs := []string{"rev-list", "--count"}
+	subCmd := git.SubCmd{Name: "rev-list", Flags: []git.Option{git.Flag{Name: "--count"}}}
 
 	if in.GetAll() {
-		cmdArgs = append(cmdArgs, "--all")
+		subCmd.Flags = append(subCmd.Flags, git.Flag{Name: "--all"})
 	} else {
-		cmdArgs = append(cmdArgs, string(in.GetRevision()))
+		subCmd.Args = []string{string(in.GetRevision())}
 	}
 
 	if before := in.GetBefore(); before != nil {
-		cmdArgs = append(cmdArgs, "--before="+timestampToRFC3339(before.Seconds))
+		subCmd.Flags = append(subCmd.Flags, git.Flag{Name: "--before=" + timestampToRFC3339(before.Seconds)})
 	}
 	if after := in.GetAfter(); after != nil {
-		cmdArgs = append(cmdArgs, "--after="+timestampToRFC3339(after.Seconds))
+		subCmd.Flags = append(subCmd.Flags, git.Flag{Name: "--after=" + timestampToRFC3339(after.Seconds)})
 	}
 	if maxCount := in.GetMaxCount(); maxCount != 0 {
-		cmdArgs = append(cmdArgs, fmt.Sprintf("--max-count=%d", maxCount))
+		subCmd.Flags = append(subCmd.Flags, git.Flag{Name: fmt.Sprintf("--max-count=%d", maxCount)})
 	}
 	if in.GetFirstParent() {
-		cmdArgs = append(cmdArgs, "--first-parent")
+		subCmd.Flags = append(subCmd.Flags, git.Flag{Name: "--first-parent"})
 	}
 	if path := in.GetPath(); path != nil {
-		cmdArgs = append(cmdArgs, "--", string(path))
+		subCmd.PostSepArgs = []string{string(path)}
 	}
 
-	cmd, err := git.Command(ctx, in.Repository, cmdArgs...)
+	cmd, err := git.SafeCmd(ctx, in.Repository, nil, subCmd)
 	if err != nil {
 		if _, ok := status.FromError(err); ok {
 			return nil, err
diff --git a/internal/service/commit/count_diverging_commits.go b/internal/service/commit/count_diverging_commits.go
index 9ec4aed8d..9381c9a5c 100644
--- a/internal/service/commit/count_diverging_commits.go
+++ b/internal/service/commit/count_diverging_commits.go
@@ -47,19 +47,20 @@ func validateCountDivergingCommitsRequest(req *gitalypb.CountDivergingCommitsReq
 	return nil
 }
 
-func buildRevListCountArgs(from, to string, maxCount int) []string {
-	cmdArgs := []string{"rev-list", "--count", "--left-right"}
+func buildRevListCountCmd(from, to string, maxCount int) git.SubCmd {
+	subCmd := git.SubCmd{
+		Name:  "rev-list",
+		Flags: []git.Option{git.Flag{Name: "--count"}, git.Flag{Name: "--left-right"}},
+		Args:  []string{fmt.Sprintf("%s...%s", from, to)},
+	}
 	if maxCount != 0 {
-		cmdArgs = append(cmdArgs, fmt.Sprintf("--max-count=%d", maxCount))
+		subCmd.Flags = append(subCmd.Flags, git.Flag{Name: fmt.Sprintf("--max-count=%d", maxCount)})
 	}
-
-	return append(cmdArgs, fmt.Sprintf("%s...%s", from, to))
+	return subCmd
 }
 
 func findLeftRightCount(ctx context.Context, repo *gitalypb.Repository, from, to string, maxCount int) (int32, int32, error) {
-	cmdArgs := buildRevListCountArgs(from, to, maxCount)
-
-	cmd, err := git.Command(ctx, repo, cmdArgs...)
+	cmd, err := git.SafeCmd(ctx, repo, nil, buildRevListCountCmd(from, to, maxCount))
 	if err != nil {
 		return 0, 0, fmt.Errorf("git rev-list cmd: %v", err)
 	}
diff --git a/internal/service/commit/find_commit_test.go b/internal/service/commit/find_commit_test.go
index dcfa5d019..97bdfdbff 100644
--- a/internal/service/commit/find_commit_test.go
+++ b/internal/service/commit/find_commit_test.go
@@ -330,7 +330,8 @@ func benchmarkFindCommit(withCache bool, b *testing.B) {
 
 	// get a list of revisions
 
-	logCmd, err := git.Command(ctx, testRepo, "log", "--format=format:%H")
+	logCmd, err := git.SafeCmd(ctx, testRepo, nil,
+		git.SubCmd{Name: "log", Flags: []git.Option{git.Flag{Name: "--format=format:%H"}}})
 	require.NoError(b, err)
 
 	logScanner := bufio.NewScanner(logCmd)
@@ -376,7 +377,8 @@ func TestFindCommitWithCache(t *testing.T) {
 
 	// get a list of revisions
 
-	logCmd, err := git.Command(ctx, testRepo, "log", "--format=format:%H")
+	logCmd, err := git.SafeCmd(ctx, testRepo, nil,
+		git.SubCmd{Name: "log", Flags: []git.Option{git.Flag{Name: "--format=format:%H"}}})
 	require.NoError(t, err)
 
 	logScanner := bufio.NewScanner(logCmd)
diff --git a/internal/service/commit/find_commits.go b/internal/service/commit/find_commits.go
index c7f5bd092..84a4ab0b3 100644
--- a/internal/service/commit/find_commits.go
+++ b/internal/service/commit/find_commits.go
@@ -49,8 +49,7 @@ func (s *server) FindCommits(req *gitalypb.FindCommitsRequest, stream gitalypb.C
 }
 
 func findCommits(ctx context.Context, req *gitalypb.FindCommitsRequest, stream gitalypb.CommitService_FindCommitsServer) error {
-	args := getLogCommandFlags(req)
-	logCmd, err := git.Command(ctx, req.GetRepository(), args...)
+	logCmd, err := git.SafeCmd(ctx, req.GetRepository(), nil, getLogCommandSubCmd(req))
 	if err != nil {
 		return fmt.Errorf("error when creating git log command: %v", err)
 	}
@@ -154,46 +153,45 @@ func streamPaginatedCommits(getCommits *GetCommits, commitsPerPage int, stream g
 	return chunker.Flush()
 }
 
-func getLogCommandFlags(req *gitalypb.FindCommitsRequest) []string {
-	args := []string{"log", "--format=format:%H"}
+func getLogCommandSubCmd(req *gitalypb.FindCommitsRequest) git.SubCmd {
+	subCmd := git.SubCmd{Name: "log", Flags: []git.Option{git.Flag{Name: "--format=format:%H"}}}
 
 	//  We will perform the offset in Go because --follow doesn't play well with --skip.
 	//  See: https://gitlab.com/gitlab-org/gitlab-ce/issues/3574#note_3040520
 	if req.GetOffset() > 0 && !calculateOffsetManually(req) {
-		args = append(args, fmt.Sprintf("--skip=%d", req.GetOffset()))
+		subCmd.Flags = append(subCmd.Flags, git.Flag{Name: fmt.Sprintf("--skip=%d", req.GetOffset())})
 	}
 	limit := req.GetLimit()
 	if calculateOffsetManually(req) {
 		limit += req.GetOffset()
 	}
-	args = append(args, fmt.Sprintf("--max-count=%d", limit))
+	subCmd.Flags = append(subCmd.Flags, git.Flag{Name: fmt.Sprintf("--max-count=%d", limit)})
 
 	if req.GetFollow() && len(req.GetPaths()) > 0 {
-		args = append(args, "--follow")
+		subCmd.Flags = append(subCmd.Flags, git.Flag{Name: "--follow"})
 	}
 	if req.GetSkipMerges() {
-		args = append(args, "--no-merges")
+		subCmd.Flags = append(subCmd.Flags, git.Flag{Name: "--no-merges"})
 	}
 	if req.GetBefore() != nil {
-		args = append(args, fmt.Sprintf("--before=%s", req.GetBefore().String()))
+		subCmd.Flags = append(subCmd.Flags, git.Flag{Name: fmt.Sprintf("--before=%s", req.GetBefore().String())})
 	}
 	if req.GetAfter() != nil {
-		args = append(args, fmt.Sprintf("--after=%s", req.GetAfter().String()))
+		subCmd.Flags = append(subCmd.Flags, git.Flag{Name: fmt.Sprintf("--after=%s", req.GetAfter().String())})
 	}
 	if req.GetAll() {
-		args = append(args, "--all", "--reverse")
+		subCmd.Flags = append(subCmd.Flags, git.Flag{Name: "--all"}, git.Flag{Name: "--reverse"})
 	}
 	if req.GetRevision() != nil {
-		args = append(args, string(req.GetRevision()))
+		subCmd.Args = []string{string(req.GetRevision())}
 	}
 	if req.GetFirstParent() {
-		args = append(args, "--first-parent")
+		subCmd.Flags = append(subCmd.Flags, git.Flag{Name: "--first-parent"})
 	}
 	if len(req.GetPaths()) > 0 {
-		args = append(args, "--")
 		for _, path := range req.GetPaths() {
-			args = append(args, string(path))
+			subCmd.PostSepArgs = append(subCmd.PostSepArgs, string(path))
 		}
 	}
-	return args
+	return subCmd
 }
diff --git a/internal/service/commit/isancestor.go b/internal/service/commit/isancestor.go
index e1eaed4e0..2b56a6acf 100644
--- a/internal/service/commit/isancestor.go
+++ b/internal/service/commit/isancestor.go
@@ -30,7 +30,8 @@ func commitIsAncestorName(ctx context.Context, repo *gitalypb.Repository, ancest
 		"childSha":    childID,
 	}).Debug("commitIsAncestor")
 
-	cmd, err := git.Command(ctx, repo, "merge-base", "--is-ancestor", ancestorID, childID)
+	cmd, err := git.SafeCmd(ctx, repo, nil, git.SubCmd{Name: "merge-base",
+		Flags: []git.Option{git.Flag{Name: "--is-ancestor"}}, Args: []string{ancestorID, childID}})
 	if err != nil {
 		if _, ok := status.FromError(err); ok {
 			return false, err
diff --git a/internal/service/commit/languages.go b/internal/service/commit/languages.go
index 17a00407e..8d73542e6 100644
--- a/internal/service/commit/languages.go
+++ b/internal/service/commit/languages.go
@@ -92,7 +92,7 @@ func (ls languageSorter) Swap(i, j int)      { ls[i], ls[j] = ls[j], ls[i] }
 func (ls languageSorter) Less(i, j int) bool { return ls[i].Share > ls[j].Share }
 
 func lookupRevision(ctx context.Context, repo *gitalypb.Repository, revision string) (string, error) {
-	revParse, err := git.Command(ctx, repo, "rev-parse", revision)
+	revParse, err := git.SafeCmd(ctx, repo, nil, git.SubCmd{Name: "rev-parse", Args: []string{revision}})
 	if err != nil {
 		return "", err
 	}
diff --git a/internal/service/commit/list_files.go b/internal/service/commit/list_files.go
index 547633dc2..95b455897 100644
--- a/internal/service/commit/list_files.go
+++ b/internal/service/commit/list_files.go
@@ -57,8 +57,10 @@ func validateListFilesRequest(in *gitalypb.ListFilesRequest) error {
 }
 
 func listFiles(repo *gitalypb.Repository, revision string, stream gitalypb.CommitService_ListFilesServer) error {
-	args := []string{"ls-tree", "-z", "-r", "--full-tree", "--full-name", "--", revision}
-	cmd, err := git.Command(stream.Context(), repo, args...)
+	cmd, err := git.SafeCmd(stream.Context(), repo, nil, git.SubCmd{Name: "ls-tree",
+		Flags:       []git.Option{git.Flag{Name: "-z"}, git.Flag{Name: "-r"}, git.Flag{Name: "--full-tree"}, git.Flag{Name: "--full-name"}},
+		PostSepArgs: []string{revision},
+	})
 	if err != nil {
 		return err
 	}
diff --git a/internal/service/commit/list_last_commits_for_tree.go b/internal/service/commit/list_last_commits_for_tree.go
index cb379e420..75964b229 100644
--- a/internal/service/commit/list_last_commits_for_tree.go
+++ b/internal/service/commit/list_last_commits_for_tree.go
@@ -121,8 +121,11 @@ func newLSTreeParser(in *gitalypb.ListLastCommitsForTreeRequest, stream gitalypb
 		path = "."
 	}
 
-	cmdArgs := []string{"ls-tree", "-z", "--full-name", string(in.GetRevision()), path}
-	cmd, err := git.Command(stream.Context(), in.GetRepository(), cmdArgs...)
+	cmd, err := git.SafeCmd(stream.Context(), in.GetRepository(), nil, git.SubCmd{
+		Name:  "ls-tree",
+		Flags: []git.Option{git.Flag{Name: "-z"}, git.Flag{Name: "--full-name"}},
+		Args:  []string{in.GetRevision(), path},
+	})
 	if err != nil {
 		return nil, nil, err
 	}
diff --git a/internal/service/diff/commit.go b/internal/service/diff/commit.go
index 3502a8dee..7f46bdc9c 100644
--- a/internal/service/diff/commit.go
+++ b/internal/service/diff/commit.go
@@ -35,22 +35,24 @@ func (s *server) CommitDiff(in *gitalypb.CommitDiffRequest, stream gitalypb.Diff
 	ignoreWhitespaceChange := in.GetIgnoreWhitespaceChange()
 	paths := in.GetPaths()
 
-	cmdArgs := []string{
-		"diff",
-		"--patch",
-		"--raw",
-		"--abbrev=40",
-		"--full-index",
-		"--find-renames=30%",
+	cmd := git.SubCmd{
+		Name: "diff",
+		Flags: []git.Option{
+			git.Flag{Name: "--patch"},
+			git.Flag{Name: "--raw"},
+			git.Flag{Name: "--abbrev=40"},
+			git.Flag{Name: "--full-index"},
+			git.Flag{Name: "--find-renames=30%"},
+		},
+		Args: []string{leftSha, rightSha},
 	}
+
 	if ignoreWhitespaceChange {
-		cmdArgs = append(cmdArgs, "--ignore-space-change")
+		cmd.Flags = append(cmd.Flags, git.Flag{Name: "--ignore-space-change"})
 	}
-	cmdArgs = append(cmdArgs, leftSha, rightSha)
 	if len(paths) > 0 {
-		cmdArgs = append(cmdArgs, "--")
 		for _, path := range paths {
-			cmdArgs = append(cmdArgs, string(path))
+			cmd.PostSepArgs = append(cmd.PostSepArgs, string(path))
 		}
 	}
 
@@ -67,7 +69,7 @@ func (s *server) CommitDiff(in *gitalypb.CommitDiffRequest, stream gitalypb.Diff
 	limits.SafeMaxLines = int(in.SafeMaxLines)
 	limits.SafeMaxBytes = int(in.SafeMaxBytes)
 
-	return eachDiff(stream.Context(), "CommitDiff", in.Repository, cmdArgs, limits, func(diff *diff.Diff) error {
+	return eachDiff(stream.Context(), "CommitDiff", in.Repository, cmd, limits, func(diff *diff.Diff) error {
 		response := &gitalypb.CommitDiffResponse{
 			FromPath:       diff.FromPath,
 			ToPath:         diff.ToPath,
@@ -129,19 +131,19 @@ func (s *server) CommitDelta(in *gitalypb.CommitDeltaRequest, stream gitalypb.Di
 	rightSha := in.RightCommitId
 	paths := in.GetPaths()
 
-	cmdArgs := []string{
-		"diff",
-		"--raw",
-		"--abbrev=40",
-		"--full-index",
-		"--find-renames",
-		leftSha,
-		rightSha,
+	cmd := git.SubCmd{
+		Name: "diff",
+		Flags: []git.Option{
+			git.Flag{Name: "--raw"},
+			git.Flag{Name: "--abbrev=40"},
+			git.Flag{Name: "--full-index"},
+			git.Flag{Name: "--find-renames"},
+		},
+		Args: []string{leftSha, rightSha},
 	}
 	if len(paths) > 0 {
-		cmdArgs = append(cmdArgs, "--")
 		for _, path := range paths {
-			cmdArgs = append(cmdArgs, string(path))
+			cmd.PostSepArgs = append(cmd.PostSepArgs, string(path))
 		}
 	}
 
@@ -160,7 +162,7 @@ func (s *server) CommitDelta(in *gitalypb.CommitDeltaRequest, stream gitalypb.Di
 		return nil
 	}
 
-	err := eachDiff(stream.Context(), "CommitDelta", in.Repository, cmdArgs, diff.Limits{}, func(diff *diff.Diff) error {
+	err := eachDiff(stream.Context(), "CommitDelta", in.Repository, cmd, diff.Limits{}, func(diff *diff.Diff) error {
 		delta := &gitalypb.CommitDelta{
 			FromPath: diff.FromPath,
 			ToPath:   diff.ToPath,
@@ -203,8 +205,8 @@ func validateRequest(in requestWithLeftRightCommitIds) error {
 	return nil
 }
 
-func eachDiff(ctx context.Context, rpc string, repo *gitalypb.Repository, cmdArgs []string, limits diff.Limits, callback func(*diff.Diff) error) error {
-	cmd, err := git.Command(ctx, repo, cmdArgs...)
+func eachDiff(ctx context.Context, rpc string, repo *gitalypb.Repository, subCmd git.Cmd, limits diff.Limits, callback func(*diff.Diff) error) error {
+	cmd, err := git.SafeCmd(ctx, repo, nil, subCmd)
 	if err != nil {
 		if _, ok := status.FromError(err); ok {
 			return err
diff --git a/internal/service/objectpool/alternates_test.go b/internal/service/objectpool/alternates_test.go
index 69ed29d69..cba9ea7d5 100644
--- a/internal/service/objectpool/alternates_test.go
+++ b/internal/service/objectpool/alternates_test.go
@@ -41,7 +41,8 @@ func TestDisconnectGitAlternates(t *testing.T) {
 	require.NoError(t, err, "find info/alternates")
 	require.NoError(t, os.RemoveAll(altPath))
 
-	cmd, err := git.Command(ctx, testRepo, "cat-file", "-e", existingObjectID)
+	cmd, err := git.SafeCmd(ctx, testRepo, nil,
+		git.SubCmd{Name: "cat-file", Flags: []git.Option{git.Flag{Name: "-e"}}, Args: []string{existingObjectID}})
 	require.NoError(t, err)
 	require.Error(t, cmd.Wait(), "expect cat-file to fail because object cannot be found")
 
diff --git a/internal/service/objectpool/reduplicate_test.go b/internal/service/objectpool/reduplicate_test.go
index d7f6cad1c..d1d9f560c 100644
--- a/internal/service/objectpool/reduplicate_test.go
+++ b/internal/service/objectpool/reduplicate_test.go
@@ -38,7 +38,8 @@ func TestReduplicate(t *testing.T) {
 	require.NoError(t, err, "find info/alternates")
 	require.NoError(t, os.RemoveAll(altPath))
 
-	cmd, err := git.Command(ctx, testRepo, "cat-file", "-e", existingObjectID)
+	cmd, err := git.SafeCmd(ctx, testRepo, nil,
+		git.SubCmd{Name: "cat-file", Flags: []git.Option{git.Flag{Name: "-e"}}, Args: []string{existingObjectID}})
 	require.NoError(t, err)
 	require.Error(t, cmd.Wait())
 
diff --git a/internal/service/objectpool/testhelper_test.go b/internal/service/objectpool/testhelper_test.go
index 23776a262..448e3d60d 100644
--- a/internal/service/objectpool/testhelper_test.go
+++ b/internal/service/objectpool/testhelper_test.go
@@ -1,10 +1,10 @@
 package objectpool
 
 import (
+	"context"
 	"net"
 	"os"
 	"testing"
-	"time"
 
 	"gitlab.com/gitlab-org/gitaly/internal/testhelper"
 	"gitlab.com/gitlab-org/gitaly/proto/go/gitalypb"
@@ -42,8 +42,9 @@ func runObjectPoolServer(t *testing.T) (*grpc.Server, string) {
 func newObjectPoolClient(t *testing.T, serverSocketPath string) (gitalypb.ObjectPoolServiceClient, *grpc.ClientConn) {
 	connOpts := []grpc.DialOption{
 		grpc.WithInsecure(),
-		grpc.WithDialer(func(addr string, timeout time.Duration) (net.Conn, error) {
-			return net.DialTimeout("unix", addr, timeout)
+		grpc.WithContextDialer(func(ctx context.Context, addr string) (conn net.Conn, err error) {
+			d := net.Dialer{}
+			return d.DialContext(ctx, "unix", addr)
 		}),
 	}
 
diff --git a/internal/service/remote/find_remote_root_ref.go b/internal/service/remote/find_remote_root_ref.go
index d0dc20c24..23dd0c03c 100644
--- a/internal/service/remote/find_remote_root_ref.go
+++ b/internal/service/remote/find_remote_root_ref.go
@@ -14,7 +14,8 @@ import (
 const headPrefix = "HEAD branch: "
 
 func findRemoteRootRef(ctx context.Context, repo *gitalypb.Repository, remote string) (string, error) {
-	cmd, err := git.Command(ctx, repo, "remote", "show", remote)
+	cmd, err := git.SafeCmd(ctx, repo, nil,
+		git.SubCmd{Name: "remote", Flags: []git.Option{git.SubSubCmd{Name: "show"}}, Args: []string{remote}})
 	if err != nil {
 		return "", err
 	}
diff --git a/internal/service/remote/remotes.go b/internal/service/remote/remotes.go
index 0cba15dfb..fe9432ffd 100644
--- a/internal/service/remote/remotes.go
+++ b/internal/service/remote/remotes.go
@@ -109,7 +109,7 @@ func (s *server) ListRemotes(req *gitalypb.ListRemotesRequest, stream gitalypb.R
 	repo := req.GetRepository()
 
 	ctx := stream.Context()
-	cmd, err := git.Command(ctx, repo, "remote", "-v")
+	cmd, err := git.SafeCmd(ctx, repo, nil, git.SubCmd{Name: "remote", Flags: []git.Option{git.Flag{Name: "-v"}}})
 	if err != nil {
 		return err
 	}