Logging Part 2: region tracing

cmd/git-bundle-server/delete.go

@@ -4,18 +4,21 @@ import (
 	"context"
 	"os"
 
+	"github.com/github/git-bundle-server/cmd/utils"
 	"github.com/github/git-bundle-server/internal/argparse"
 	"github.com/github/git-bundle-server/internal/core"
 	"github.com/github/git-bundle-server/internal/log"
 )
 
 type deleteCmd struct {
-	logger log.TraceLogger
+	logger    log.TraceLogger
+	container *utils.DependencyContainer
 }
 
-func NewDeleteCommand(logger log.TraceLogger) argparse.Subcommand {
+func NewDeleteCommand(logger log.TraceLogger, container *utils.DependencyContainer) argparse.Subcommand {
 	return &deleteCmd{
-		logger: logger,
+		logger:    logger,
+		container: container,
 	}
 }
 
@@ -34,12 +37,14 @@ func (d *deleteCmd) Run(ctx context.Context, args []string) error {
 	route := parser.PositionalString("route", "the route to delete")
 	parser.Parse(ctx, args)
 
-	repo, err := core.CreateRepository(*route)
+	repoProvider := utils.GetDependency[core.RepositoryProvider](ctx, d.container)
+
+	repo, err := repoProvider.CreateRepository(ctx, *route)
 	if err != nil {
 		return d.logger.Error(ctx, err)
 	}
 
-	err = core.RemoveRoute(*route)
+	err = repoProvider.RemoveRoute(ctx, *route)
 	if err != nil {
 		return d.logger.Error(ctx, err)
 	}

cmd/git-bundle-server/init.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/github/git-bundle-server/cmd/utils"
 	"github.com/github/git-bundle-server/internal/argparse"
 	"github.com/github/git-bundle-server/internal/bundles"
 	"github.com/github/git-bundle-server/internal/core"
@@ -12,12 +13,14 @@ import (
 )
 
 type initCmd struct {
-	logger log.TraceLogger
+	logger    log.TraceLogger
+	container *utils.DependencyContainer
 }
 
-func NewInitCommand(logger log.TraceLogger) argparse.Subcommand {
+func NewInitCommand(logger log.TraceLogger, container *utils.DependencyContainer) argparse.Subcommand {
 	return &initCmd{
-		logger: logger,
+		logger:    logger,
+		container: container,
 	}
 }
 
@@ -38,7 +41,10 @@ func (i *initCmd) Run(ctx context.Context, args []string) error {
 	route := parser.PositionalString("route", "the route to host the specified repo")
 	parser.Parse(ctx, args)
 
-	repo, err := core.CreateRepository(*route)
+	repoProvider := utils.GetDependency[core.RepositoryProvider](ctx, i.container)
+	bundleProvider := utils.GetDependency[bundles.BundleProvider](ctx, i.container)
+
+	repo, err := repoProvider.CreateRepository(ctx, *route)
 	if err != nil {
 		return i.logger.Error(ctx, err)
 	}
@@ -60,7 +66,7 @@ func (i *initCmd) Run(ctx context.Context, args []string) error {
 		return i.logger.Errorf(ctx, "failed to fetch latest refs: %w", gitErr)
 	}
 
-	bundle := bundles.CreateInitialBundle(repo)
+	bundle := bundleProvider.CreateInitialBundle(ctx, repo)
 	fmt.Printf("Constructing base bundle file at %s\n", bundle.Filename)
 
 	written, gitErr := git.CreateBundle(repo.RepoDir, bundle.Filename)
@@ -71,8 +77,8 @@ func (i *initCmd) Run(ctx context.Context, args []string) error {
 		return i.logger.Errorf(ctx, "refused to write empty bundle. Is the repo empty?")
 	}
 
-	list := bundles.CreateSingletonList(bundle)
-	listErr := bundles.WriteBundleList(list, repo)
+	list := bundleProvider.CreateSingletonList(ctx, bundle)
+	listErr := bundleProvider.WriteBundleList(ctx, list, repo)
 	if listErr != nil {
 		return i.logger.Errorf(ctx, "failed to write bundle list: %w", listErr)
 	}

cmd/git-bundle-server/main.go

@@ -4,19 +4,22 @@ import (
 	"context"
 	"os"
 
+	"github.com/github/git-bundle-server/cmd/utils"
 	"github.com/github/git-bundle-server/internal/argparse"
 	"github.com/github/git-bundle-server/internal/log"
 )
 
 func all(logger log.TraceLogger) []argparse.Subcommand {
+	container := utils.BuildGitBundleServerContainer(logger)
+
 	return []argparse.Subcommand{
-		NewDeleteCommand(logger),
-		NewInitCommand(logger),
-		NewStartCommand(logger),
-		NewStopCommand(logger),
-		NewUpdateCommand(logger),
-		NewUpdateAllCommand(logger),
-		NewWebServerCommand(logger),
+		NewDeleteCommand(logger, container),
+		NewInitCommand(logger, container),
+		NewStartCommand(logger, container),
+		NewStopCommand(logger, container),
+		NewUpdateCommand(logger, container),
+		NewUpdateAllCommand(logger, container),
+		NewWebServerCommand(logger, container),
 	}
 }
 

cmd/git-bundle-server/start.go

@@ -4,18 +4,21 @@ import (
 	"context"
 	"os"
 
+	"github.com/github/git-bundle-server/cmd/utils"
 	"github.com/github/git-bundle-server/internal/argparse"
 	"github.com/github/git-bundle-server/internal/core"
 	"github.com/github/git-bundle-server/internal/log"
 )
 
 type startCmd struct {
-	logger log.TraceLogger
+	logger    log.TraceLogger
+	container *utils.DependencyContainer
 }
 
-func NewStartCommand(logger log.TraceLogger) argparse.Subcommand {
+func NewStartCommand(logger log.TraceLogger, container *utils.DependencyContainer) argparse.Subcommand {
 	return &startCmd{
-		logger: logger,
+		logger:    logger,
+		container: container,
 	}
 }
 
@@ -34,8 +37,10 @@ func (s *startCmd) Run(ctx context.Context, args []string) error {
 	route := parser.PositionalString("route", "the route for which bundles should be generated")
 	parser.Parse(ctx, args)
 
+	repoProvider := utils.GetDependency[core.RepositoryProvider](ctx, s.container)
+
 	// CreateRepository registers the route.
-	repo, err := core.CreateRepository(*route)
+	repo, err := repoProvider.CreateRepository(ctx, *route)
 	if err != nil {
 		return s.logger.Error(ctx, err)
 	}

cmd/git-bundle-server/stop.go

@@ -3,18 +3,21 @@ package main
 import (
 	"context"
 
+	"github.com/github/git-bundle-server/cmd/utils"
 	"github.com/github/git-bundle-server/internal/argparse"
 	"github.com/github/git-bundle-server/internal/core"
 	"github.com/github/git-bundle-server/internal/log"
 )
 
 type stopCmd struct {
-	logger log.TraceLogger
+	logger    log.TraceLogger
+	container *utils.DependencyContainer
 }
 
-func NewStopCommand(logger log.TraceLogger) argparse.Subcommand {
+func NewStopCommand(logger log.TraceLogger, container *utils.DependencyContainer) argparse.Subcommand {
 	return &stopCmd{
-		logger: logger,
+		logger:    logger,
+		container: container,
 	}
 }
 
@@ -33,7 +36,9 @@ func (s *stopCmd) Run(ctx context.Context, args []string) error {
 	route := parser.PositionalString("route", "the route for which bundles should stop being generated")
 	parser.Parse(ctx, args)
 
-	err := core.RemoveRoute(*route)
+	repoProvider := utils.GetDependency[core.RepositoryProvider](ctx, s.container)
+
+	err := repoProvider.RemoveRoute(ctx, *route)
 	if err != nil {
 		s.logger.Error(ctx, err)
 	}

cmd/git-bundle-server/update-all.go

@@ -5,19 +5,21 @@ import (
 	"os"
 	"os/exec"
 
+	"github.com/github/git-bundle-server/cmd/utils"
 	"github.com/github/git-bundle-server/internal/argparse"
-	"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 updateAllCmd struct {
-	logger log.TraceLogger
+	logger    log.TraceLogger
+	container *utils.DependencyContainer
 }
 
-func NewUpdateAllCommand(logger log.TraceLogger) argparse.Subcommand {
+func NewUpdateAllCommand(logger log.TraceLogger, container *utils.DependencyContainer) argparse.Subcommand {
 	return &updateAllCmd{
-		logger: logger,
+		logger:    logger,
+		container: container,
 	}
 }
 
@@ -31,23 +33,19 @@ For every configured route, run 'git-bundle-server update <options> <route>'.`
 }
 
 func (u *updateAllCmd) Run(ctx context.Context, args []string) error {
-	user, err := common.NewUserProvider().CurrentUser()
-	if err != nil {
-		return u.logger.Error(ctx, err)
-	}
-	fs := common.NewFileSystem()
-
 	parser := argparse.NewArgParser(u.logger, "git-bundle-server update-all")
 	parser.Parse(ctx, args)
 
-	exe, err := os.Executable()
+	repoProvider := utils.GetDependency[core.RepositoryProvider](ctx, u.container)
+
+	repos, err := repoProvider.GetRepositories(ctx)
 	if err != nil {
-		return u.logger.Errorf(ctx, "failed to get path to execuable: %w", err)
+		return u.logger.Error(ctx, err)
 	}
 
-	repos, err := core.GetRepositories(user, fs)
+	exe, err := os.Executable()
 	if err != nil {
-		return u.logger.Error(ctx, err)
+		return u.logger.Errorf(ctx, "failed to get path to execuable: %w", err)
 	}
 
 	subargs := []string{"update", ""}

cmd/git-bundle-server/update.go

@@ -4,19 +4,22 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/github/git-bundle-server/cmd/utils"
 	"github.com/github/git-bundle-server/internal/argparse"
 	"github.com/github/git-bundle-server/internal/bundles"
 	"github.com/github/git-bundle-server/internal/core"
 	"github.com/github/git-bundle-server/internal/log"
 )
 
 type updateCmd struct {
-	logger log.TraceLogger
+	logger    log.TraceLogger
+	container *utils.DependencyContainer
 }
 
-func NewUpdateCommand(logger log.TraceLogger) argparse.Subcommand {
+func NewUpdateCommand(logger log.TraceLogger, container *utils.DependencyContainer) argparse.Subcommand {
 	return &updateCmd{
-		logger: logger,
+		logger:    logger,
+		container: container,
 	}
 }
 
@@ -36,18 +39,21 @@ func (u *updateCmd) Run(ctx context.Context, args []string) error {
 	route := parser.PositionalString("route", "the route to update")
 	parser.Parse(ctx, args)
 
-	repo, err := core.CreateRepository(*route)
+	repoProvider := utils.GetDependency[core.RepositoryProvider](ctx, u.container)
+	bundleProvider := utils.GetDependency[bundles.BundleProvider](ctx, u.container)
+
+	repo, err := repoProvider.CreateRepository(ctx, *route)
 	if err != nil {
 		return u.logger.Error(ctx, err)
 	}
 
-	list, err := bundles.GetBundleList(repo)
+	list, err := bundleProvider.GetBundleList(ctx, repo)
 	if err != nil {
 		return u.logger.Errorf(ctx, "failed to load bundle list: %w", err)
 	}
 
 	fmt.Printf("Creating new incremental bundle\n")
-	bundle, err := bundles.CreateIncrementalBundle(repo, list)
+	bundle, err := bundleProvider.CreateIncrementalBundle(ctx, repo, list)
 	if err != nil {
 		return u.logger.Error(ctx, err)
 	}
@@ -60,13 +66,13 @@ func (u *updateCmd) Run(ctx context.Context, args []string) error {
 	list.Bundles[bundle.CreationToken] = *bundle
 
 	fmt.Printf("Collapsing bundle list\n")
-	err = bundles.CollapseList(repo, list)
+	err = bundleProvider.CollapseList(ctx, repo, list)
 	if err != nil {
 		return u.logger.Error(ctx, err)
 	}
 
 	fmt.Printf("Writing updated bundle list\n")
-	listErr := bundles.WriteBundleList(list, repo)
+	listErr := bundleProvider.WriteBundleList(ctx, list, repo)
 	if listErr != nil {
 		return u.logger.Errorf(ctx, "failed to write bundle list: %w", listErr)
 	}

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

@@ -17,19 +17,14 @@ import (
 )
 
 type webServerCmd struct {
-	logger     log.TraceLogger
-	user       common.UserProvider
-	cmdExec    common.CommandExecutor
-	fileSystem common.FileSystem
+	logger    log.TraceLogger
+	container *utils.DependencyContainer
 }
 
-func NewWebServerCommand(logger log.TraceLogger) argparse.Subcommand {
-	// Create subcommand-specific dependencies
+func NewWebServerCommand(logger log.TraceLogger, container *utils.DependencyContainer) argparse.Subcommand {
 	return &webServerCmd{
-		logger:     logger,
-		user:       common.NewUserProvider(),
-		cmdExec:    common.NewCommandExecutor(),
-		fileSystem: common.NewFileSystem(),
+		logger:    logger,
+		container: container,
 	}
 }
 
@@ -64,7 +59,8 @@ func (w *webServerCmd) getDaemonConfig(ctx context.Context) (*daemon.DaemonConfi
 			}
 
 			programPath = filepath.Join(exeDir, "git-bundle-web-server")
-			programExists, err := w.fileSystem.FileExists(programPath)
+			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 {
@@ -97,10 +93,7 @@ func (w *webServerCmd) startServer(ctx context.Context, args []string) error {
 	parser.Parse(ctx, args)
 	validate(ctx)
 
-	d, err := daemon.NewDaemonProvider(w.logger, w.user, w.cmdExec, w.fileSystem)
-	if err != nil {
-		return w.logger.Error(ctx, err)
-	}
+	d := utils.GetDependency[daemon.DaemonProvider](ctx, w.container)
 
 	config, err := w.getDaemonConfig(ctx)
 	if err != nil {
@@ -153,10 +146,7 @@ func (w *webServerCmd) stopServer(ctx context.Context, args []string) error {
 	remove := parser.Bool("remove", false, "Remove the web server daemon configuration from the system after stopping")
 	parser.Parse(ctx, args)
 
-	d, err := daemon.NewDaemonProvider(w.logger, w.user, w.cmdExec, w.fileSystem)
-	if err != nil {
-		return w.logger.Error(ctx, err)
-	}
+	d := utils.GetDependency[daemon.DaemonProvider](ctx, w.container)
 
 	config, err := w.getDaemonConfig(ctx)
 	if err != nil {