Logging Part 3: child process tracing

cmd/git-bundle-server/init.go

@@ -43,33 +43,20 @@ func (i *initCmd) Run(ctx context.Context, args []string) error {
 
 	repoProvider := utils.GetDependency[core.RepositoryProvider](ctx, i.container)
 	bundleProvider := utils.GetDependency[bundles.BundleProvider](ctx, i.container)
+	gitHelper := utils.GetDependency[git.GitHelper](ctx, i.container)
 
 	repo, err := repoProvider.CreateRepository(ctx, *route)
 	if err != nil {
 		return i.logger.Error(ctx, err)
 	}
 
 	fmt.Printf("Cloning repository from %s\n", *url)
-	gitErr := git.GitCommand("clone", "--bare", *url, repo.RepoDir)
-
-	if gitErr != nil {
-		return i.logger.Errorf(ctx, "failed to clone repository: %w", gitErr)
-	}
-
-	gitErr = git.GitCommand("-C", repo.RepoDir, "config", "remote.origin.fetch", "+refs/heads/*:refs/heads/*")
-	if gitErr != nil {
-		return i.logger.Errorf(ctx, "failed to configure refspec: %w", gitErr)
-	}
-
-	gitErr = git.GitCommand("-C", repo.RepoDir, "fetch", "origin")
-	if gitErr != nil {
-		return i.logger.Errorf(ctx, "failed to fetch latest refs: %w", gitErr)
-	}
+	gitHelper.CloneBareRepo(ctx, *url, repo.RepoDir)
 
 	bundle := bundleProvider.CreateInitialBundle(ctx, repo)
 	fmt.Printf("Constructing base bundle file at %s\n", bundle.Filename)
 
-	written, gitErr := git.CreateBundle(repo.RepoDir, bundle.Filename)
+	written, gitErr := gitHelper.CreateBundle(ctx, repo.RepoDir, bundle.Filename)
 	if gitErr != nil {
 		return i.logger.Errorf(ctx, "failed to create bundle: %w", gitErr)
 	}
@@ -83,7 +70,8 @@ func (i *initCmd) Run(ctx context.Context, args []string) error {
 		return i.logger.Errorf(ctx, "failed to write bundle list: %w", listErr)
 	}
 
-	SetCronSchedule()
+	cron := utils.GetDependency[utils.CronHelper](ctx, i.container)
+	cron.SetCronSchedule(ctx)
 
 	return nil
 }

cmd/git-bundle-server/start.go

@@ -51,7 +51,8 @@ func (s *startCmd) Run(ctx context.Context, args []string) error {
 	}
 
 	// Make sure we have the global schedule running.
-	SetCronSchedule()
+	cron := utils.GetDependency[utils.CronHelper](ctx, s.container)
+	cron.SetCronSchedule(ctx)
 
 	return nil
 }

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{

cmd/utils/container-helpers.go

@@ -4,9 +4,11 @@ import (
 	"context"
 
 	"github.com/github/git-bundle-server/internal/bundles"
+	"github.com/github/git-bundle-server/internal/cmd"
 	"github.com/github/git-bundle-server/internal/common"
 	"github.com/github/git-bundle-server/internal/core"
 	"github.com/github/git-bundle-server/internal/daemon"
+	"github.com/github/git-bundle-server/internal/git"
 	"github.com/github/git-bundle-server/internal/log"
 )
 
@@ -15,8 +17,8 @@ func BuildGitBundleServerContainer(logger log.TraceLogger) *DependencyContainer
 	registerDependency(container, func(ctx context.Context) common.UserProvider {
 		return common.NewUserProvider()
 	})
-	registerDependency(container, func(ctx context.Context) common.CommandExecutor {
-		return common.NewCommandExecutor()
+	registerDependency(container, func(ctx context.Context) cmd.CommandExecutor {
+		return cmd.NewCommandExecutor(logger)
 	})
 	registerDependency(container, func(ctx context.Context) common.FileSystem {
 		return common.NewFileSystem()
@@ -29,13 +31,37 @@ func BuildGitBundleServerContainer(logger log.TraceLogger) *DependencyContainer
 		)
 	})
 	registerDependency(container, func(ctx context.Context) bundles.BundleProvider {
-		return bundles.NewBundleProvider(logger)
+		return bundles.NewBundleProvider(
+			logger,
+			GetDependency[git.GitHelper](ctx, container),
+		)
+	})
+	registerDependency(container, func(ctx context.Context) core.CronScheduler {
+		return core.NewCronScheduler(
+			logger,
+			GetDependency[common.UserProvider](ctx, container),
+			GetDependency[cmd.CommandExecutor](ctx, container),
+			GetDependency[common.FileSystem](ctx, container),
+		)
+	})
+	registerDependency(container, func(ctx context.Context) CronHelper {
+		return NewCronHelper(
+			logger,
+			GetDependency[common.FileSystem](ctx, container),
+			GetDependency[core.CronScheduler](ctx, container),
+		)
+	})
+	registerDependency(container, func(ctx context.Context) git.GitHelper {
+		return git.NewGitHelper(
+			logger,
+			GetDependency[cmd.CommandExecutor](ctx, container),
+		)
 	})
 	registerDependency(container, func(ctx context.Context) daemon.DaemonProvider {
 		t, err := daemon.NewDaemonProvider(
 			logger,
 			GetDependency[common.UserProvider](ctx, container),
-			GetDependency[common.CommandExecutor](ctx, container),
+			GetDependency[cmd.CommandExecutor](ctx, container),
 			GetDependency[common.FileSystem](ctx, container),
 		)
 		if err != nil {

cmd/utils/cron.go

@@ -0,0 +1,45 @@
+package utils
+
+import (
+	"context"
+
+	"github.com/github/git-bundle-server/internal/common"
+	"github.com/github/git-bundle-server/internal/core"
+	"github.com/github/git-bundle-server/internal/log"
+)
+
+type CronHelper interface {
+	SetCronSchedule(ctx context.Context) error
+}
+
+type cronHelper struct {
+	logger     log.TraceLogger
+	fileSystem common.FileSystem
+	scheduler  core.CronScheduler
+}
+
+func NewCronHelper(
+	l log.TraceLogger,
+	fs common.FileSystem,
+	s core.CronScheduler,
+) CronHelper {
+	return &cronHelper{
+		logger:     l,
+		fileSystem: fs,
+		scheduler:  s,
+	}
+}
+
+func (c *cronHelper) SetCronSchedule(ctx context.Context) error {
+	pathToExec, err := c.fileSystem.GetLocalExecutable("git-bundle-server")
+	if err != nil {
+		return c.logger.Errorf(ctx, "failed to get executable: %w", err)
+	}
+
+	err = c.scheduler.AddJob(ctx, core.CronDaily, pathToExec, []string{"update-all"})
+	if err != nil {
+		return c.logger.Errorf(ctx, "failed to set cron schedule: %w", err)
+	}
+
+	return nil
+}

internal/bundles/bundles.go

@@ -65,12 +65,17 @@ type BundleProvider interface {
 }
 
 type bundleProvider struct {
-	logger log.TraceLogger
+	logger    log.TraceLogger
+	gitHelper git.GitHelper
 }
 
-func NewBundleProvider(logger log.TraceLogger) BundleProvider {
+func NewBundleProvider(
+	l log.TraceLogger,
+	g git.GitHelper,
+) BundleProvider {
 	return &bundleProvider{
-		logger: logger,
+		logger:    l,
+		gitHelper: g,
 	}
 }
 
@@ -301,7 +306,7 @@ func (b *bundleProvider) CreateIncrementalBundle(ctx context.Context, repo *core
 		return nil, err
 	}
 
-	written, err := git.CreateIncrementalBundle(repo.RepoDir, bundle.Filename, lines)
+	written, err := b.gitHelper.CreateIncrementalBundle(ctx, repo.RepoDir, bundle.Filename, lines)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create incremental bundle: %w", err)
 	}
@@ -366,7 +371,7 @@ func (b *bundleProvider) CollapseList(ctx context.Context, repo *core.Repository
 		URI:           fmt.Sprintf("./base-%d.bundle", maxTimestamp),
 	}
 
-	err := git.CreateBundleFromRefs(repo.RepoDir, bundle.Filename, refs)
+	err := b.gitHelper.CreateBundleFromRefs(ctx, repo.RepoDir, bundle.Filename, refs)
 	if err != nil {
 		return err
 	}