Rename variables in gitaly-wrapperjc-use-gitaly-wrapper-for-praefect

4 files changed, 32 insertions, 27 deletions

diff --git a/.gitignore b/.gitignore
index febee9017..b0e481a1f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,8 +3,9 @@
 /gitaly-hooks
 cmd/gitaly-ssh/gitaly-ssh
 /gitaly-ssh
-cmd/gitaly-wrapper/gitaly-wrapper
+cmd/wrapper/wrapper
 /gitaly-wrapper
+/wrapper
 cmd/gitaly-remote/gitaly-remote
 /gitaly-remote
 **/testdata/gitaly-libexec/
diff --git a/Makefile b/Makefile
index 89b8a5c8a..db1b544ff 100644
--- a/Makefile
+++ b/Makefile
@@ -23,6 +23,9 @@ all: build
 .PHONY: build
 build: prepare-build
 	cd $(BUILD_DIR) && $(MAKE) install INSTALL_DEST_DIR=$(CURDIR)
+	# Remove this in 12.7 once wrapper is used in place of gitaly-wrapper
+	# https://gitlab.com/gitlab-org/gitaly/issues/2232
+	cp "$(BUILD_DIR)/bin/wrapper" "$(BUILD_DIR)/bin/gitaly-wrapper"
 
 .PHONY: build-gitaly-remote
 build-gitaly-remote: prepare-build
@@ -43,6 +46,7 @@ assemble: prepare-build
 .PHONY: binaries
 binaries: prepare-build
 	cd $(BUILD_DIR) && $(MAKE) $@
+	cd $(BULLD_DIR) && cp wrapper gitaly-wrapper
 
 .PHONY: prepare-tests
 prepare-tests: prepare-build
diff --git a/cmd/gitaly-wrapper/main.go b/cmd/wrapper/main.go
index 0d06ff978..2120e7a58 100644
--- a/cmd/gitaly-wrapper/main.go
+++ b/cmd/wrapper/main.go
@@ -29,67 +29,67 @@ func main() {
 		logrus.Fatalf("usage: %s forking_binary [args]", os.Args[0])
 	}
 
-	gitalyBin, gitalyArgs := os.Args[1], os.Args[2:]
+	bin, args := os.Args[1], os.Args[2:]
 
-	log := logrus.WithField("wrapper", os.Getpid())
+	log := logrus.WithField("wrapper", os.Getpid()).WithField("binary", bin)
 	log.Info("Wrapper started")
 
 	if bootstrap.PidFile() == "" {
 		log.Fatalf("missing pid file ENV variable %q", bootstrap.PidFileEnvVar)
 	}
 
-	log.WithField("pid_file", bootstrap.PidFile()).Info("finding gitaly")
-	gitaly, err := findGitaly()
+	log.WithField("pid_file", bootstrap.PidFile()).Info("finding process")
+	proc, err := findProcess()
 	if err != nil {
-		log.WithError(err).Fatal("find gitaly")
+		log.WithError(err).Fatal("find process")
 	}
 
-	if gitaly != nil && isGitaly(gitaly, gitalyBin) {
+	if proc != nil && matches(proc, bin) {
 		log.Info("adopting a process")
 	} else {
 		log.Info("spawning a process")
 
-		proc, err := spawnGitaly(gitalyBin, gitalyArgs)
+		newProc, err := spawn(bin, args)
 		if err != nil {
-			log.WithError(err).Fatal("spawn gitaly")
+			log.WithError(err).Fatal("spawn process")
 		}
 
-		gitaly = proc
+		proc = newProc
 	}
 
-	log = log.WithField("gitaly", gitaly.Pid)
-	log.Info("monitoring gitaly")
+	log = log.WithField("process", proc.Pid)
+	log.Info("monitoring process")
 
-	forwardSignals(gitaly, log)
+	forwardSignals(proc, log)
 
 	// wait
-	for isAlive(gitaly) {
+	for isAlive(proc) {
 		time.Sleep(1 * time.Second)
 	}
 
-	log.Error("wrapper for gitaly shutting down")
+	log.Error("wrapper for process shutting down")
 }
 
-func findGitaly() (*os.Process, error) {
+func findProcess() (*os.Process, error) {
 	pid, err := getPid()
 	if err != nil && !os.IsNotExist(err) {
 		return nil, err
 	}
 
 	// os.FindProcess on unix do not return an error if the process does not exist
-	gitaly, err := os.FindProcess(pid)
+	process, err := os.FindProcess(pid)
 	if err != nil {
 		return nil, err
 	}
 
-	if isAlive(gitaly) {
-		return gitaly, nil
+	if isAlive(process) {
+		return process, nil
 	}
 
 	return nil, nil
 }
 
-func spawnGitaly(bin string, args []string) (*os.Process, error) {
+func spawn(bin string, args []string) (*os.Process, error) {
 	cmd := exec.Command(bin, args...)
 	cmd.Env = append(os.Environ(), fmt.Sprintf("%s=true", bootstrap.UpgradesEnabledEnvVar))
 
@@ -107,13 +107,13 @@ func spawnGitaly(bin string, args []string) (*os.Process, error) {
 	return cmd.Process, nil
 }
 
-func forwardSignals(gitaly *os.Process, log *logrus.Entry) {
+func forwardSignals(proc *os.Process, log *logrus.Entry) {
 	sigs := make(chan os.Signal, 1)
 	go func() {
 		for sig := range sigs {
 			log.WithField("signal", sig).Warning("forwarding signal")
 
-			if err := gitaly.Signal(sig); err != nil {
+			if err := proc.Signal(sig); err != nil {
 				log.WithField("signal", sig).WithError(err).Error("can't forward the signal")
 			}
 		}
@@ -139,13 +139,13 @@ func isAlive(p *os.Process) bool {
 	return p.Signal(syscall.Signal(0)) == nil
 }
 
-func isGitaly(p *os.Process, gitalyBin string) bool {
+func matches(p *os.Process, bin string) bool {
 	command, err := ps.Comm(p.Pid)
 	if err != nil {
 		return false
 	}
 
-	if path.Base(command) == path.Base(gitalyBin) {
+	if path.Base(command) == path.Base(bin) {
 		return true
 	}
 
diff --git a/cmd/gitaly-wrapper/main_test.go b/cmd/wrapper/main_test.go
index 09423f2b0..e1cc76aef 100644
--- a/cmd/gitaly-wrapper/main_test.go
+++ b/cmd/wrapper/main_test.go
@@ -31,16 +31,16 @@ func TestStolenPid(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, pidFile.Close())
 
-	tail, err := findGitaly()
+	tail, err := findProcess()
 	require.NoError(t, err)
 	require.NotNil(t, tail)
 	require.Equal(t, cmd.Process.Pid, tail.Pid)
 
 	t.Run("stolen", func(t *testing.T) {
-		require.False(t, isGitaly(tail, "/path/to/gitaly"))
+		require.False(t, matches(tail, "/path/to/gitaly"))
 	})
 
 	t.Run("not stolen", func(t *testing.T) {
-		require.True(t, isGitaly(tail, "/path/to/tail"))
+		require.True(t, matches(tail, "/path/to/tail"))
 	})
 }