filesystem: add 'GetLocalExecutable()'

Add a function 'GetLocalExecutable()' to 'FileSystem'. This function, given
the identifier of one of the executables installed with this package
('git-bundle-server' or 'git-bundle-web-server'), will look for the file in
the same directory as the current executing program, and return its absolute
path.

This function is then used to replace the custom logic in
'getDaemonConfig()', which locates the 'git-bundle-web-server' executable to
run in a daemon process. This is a functional change; previously,
'getDaemonConfig()' would first lookup the executable with 'exec.LookPath()'
before falling back on the local directory. Removing the 'exec.LookPath()'
seems like the right thing to do here - if we're running a local version of
'git-bundle-server', we'd want to find the executable corresponding to that
local build.

Signed-off-by: Victoria Dye <[email protected]>

Author: vdye

cmd/git-bundle-server/web-server.go

@@ -2,11 +2,8 @@ package main
 
 import (
 	"context"
-	"errors"
 	"flag"
 	"fmt"
-	"os"
-	"os/exec"
 	"path/filepath"
 
 	"github.com/github/git-bundle-server/cmd/utils"
@@ -38,35 +35,10 @@ func (webServerCmd) Description() string {
 
 func (w *webServerCmd) getDaemonConfig(ctx context.Context) (*daemon.DaemonConfig, error) {
 	// Find git-bundle-web-server
-	// First, search for it on the path
-	programPath, err := exec.LookPath("git-bundle-web-server")
+	fileSystem := utils.GetDependency[common.FileSystem](ctx, w.container)
+	programPath, err := fileSystem.GetLocalExecutable("git-bundle-web-server")
 	if err != nil {
-		if errors.Is(err, exec.ErrDot) {
-			// Result is a relative path
-			programPath, err = filepath.Abs(programPath)
-			if err != nil {
-				return nil, w.logger.Errorf(ctx, "could not get absolute path to program: %w", err)
-			}
-		} else {
-			// Fall back on looking for it in the same directory as the currently-running executable
-			exePath, err := os.Executable()
-			if err != nil {
-				return nil, w.logger.Errorf(ctx, "failed to get path to current executable: %w", err)
-			}
-			exeDir := filepath.Dir(exePath)
-			if err != nil {
-				return nil, w.logger.Errorf(ctx, "failed to get parent dir of current executable: %w", err)
-			}
-
-			programPath = filepath.Join(exeDir, "git-bundle-web-server")
-			fileSystem := utils.GetDependency[common.FileSystem](ctx, w.container)
-			programExists, err := fileSystem.FileExists(programPath)
-			if err != nil {
-				return nil, w.logger.Errorf(ctx, "could not determine whether path to 'git-bundle-web-server' exists: %w", err)
-			} else if !programExists {
-				return nil, w.logger.Errorf(ctx, "could not find path to 'git-bundle-web-server'")
-			}
-		}
+		return nil, w.logger.Error(ctx, err)
 	}
 
 	return &daemon.DaemonConfig{

internal/common/filesystem.go

@@ -7,6 +7,7 @@ import (
 	"io/fs"
 	"os"
 	"path"
+	"path/filepath"
 	"syscall"
 )
 
@@ -16,6 +17,8 @@ const (
 )
 
 type FileSystem interface {
+	GetLocalExecutable(name string) (string, error)
+
 	FileExists(filename string) (bool, error)
 	WriteFile(filename string, content []byte) error
 	DeleteFile(filename string) (bool, error)
@@ -28,6 +31,27 @@ func NewFileSystem() FileSystem {
 	return &fileSystem{}
 }
 
+func (f *fileSystem) GetLocalExecutable(name string) (string, error) {
+	thisExePath, err := os.Executable()
+	if err != nil {
+		return "", fmt.Errorf("failed to get path to current executable: %w", err)
+	}
+	exeDir := filepath.Dir(thisExePath)
+	if err != nil {
+		return "", fmt.Errorf("failed to get parent dir of current executable: %w", err)
+	}
+
+	programPath := filepath.Join(exeDir, name)
+	programExists, err := f.FileExists(programPath)
+	if err != nil {
+		return "", fmt.Errorf("could not determine whether path to '%s' exists: %w", name, err)
+	} else if !programExists {
+		return "", fmt.Errorf("could not find path to '%s'", name)
+	}
+
+	return programPath, nil
+}
+
 func (f *fileSystem) FileExists(filename string) (bool, error) {
 	_, err := os.Stat(filename)
 	if err == nil {

internal/testhelpers/mocks.go

@@ -150,6 +150,11 @@ type MockFileSystem struct {
 	mock.Mock
 }
 
+func (m *MockFileSystem) GetLocalExecutable(name string) (string, error) {
+	fnArgs := m.Called(name)
+	return fnArgs.String(0), fnArgs.Error(1)
+}
+
 func (m *MockFileSystem) FileExists(filename string) (bool, error) {
 	fnArgs := m.Called(filename)
 	return fnArgs.Bool(0), fnArgs.Error(1)