log: propagate to deeper structures

To increase the amount of the code covered by logging, pass the 'main()'
functions' 'logger' instances to structures it creates to execute the
user-specified operation (i.e., the arg parser, 'git-bundle-server'
commands, 'bundleWebServer', and daemon providers). For now, do nothing with
the 'logger' instance in those structs.

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

Author: vdye

cmd/git-bundle-server/delete.go

@@ -6,12 +6,17 @@ import (
 
 	"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{}
+type deleteCmd struct {
+	logger log.TraceLogger
+}
 
-func NewDeleteCommand() argparse.Subcommand {
-	return &deleteCmd{}
+func NewDeleteCommand(logger log.TraceLogger) argparse.Subcommand {
+	return &deleteCmd{
+		logger: logger,
+	}
 }
 
 func (deleteCmd) Name() string {
@@ -24,8 +29,8 @@ Remove the configuration for the given '<route>' and delete its repository
 data.`
 }
 
-func (deleteCmd) Run(ctx context.Context, args []string) error {
-	parser := argparse.NewArgParser("git-bundle-server delete <route>")
+func (d *deleteCmd) Run(ctx context.Context, args []string) error {
+	parser := argparse.NewArgParser(d.logger, "git-bundle-server delete <route>")
 	route := parser.PositionalString("route", "the route to delete")
 	parser.Parse(ctx, args)
 

cmd/git-bundle-server/init.go

@@ -8,12 +8,17 @@ import (
 	"github.com/github/git-bundle-server/internal/bundles"
 	"github.com/github/git-bundle-server/internal/core"
 	"github.com/github/git-bundle-server/internal/git"
+	"github.com/github/git-bundle-server/internal/log"
 )
 
-type initCmd struct{}
+type initCmd struct {
+	logger log.TraceLogger
+}
 
-func NewInitCommand() argparse.Subcommand {
-	return &initCmd{}
+func NewInitCommand(logger log.TraceLogger) argparse.Subcommand {
+	return &initCmd{
+		logger: logger,
+	}
 }
 
 func (initCmd) Name() string {
@@ -26,8 +31,8 @@ Initialize a repository by cloning a bare repo from '<url>', whose bundles
 should be hosted at '<route>'.`
 }
 
-func (initCmd) Run(ctx context.Context, args []string) error {
-	parser := argparse.NewArgParser("git-bundle-server init <url> <route>")
+func (i *initCmd) Run(ctx context.Context, args []string) error {
+	parser := argparse.NewArgParser(i.logger, "git-bundle-server init <url> <route>")
 	url := parser.PositionalString("url", "the URL of a repository to clone")
 	// TODO: allow parsing <route> out of <url>
 	route := parser.PositionalString("route", "the route to host the specified repo")

cmd/git-bundle-server/main.go

@@ -9,23 +9,23 @@ import (
 	tracelog "github.com/github/git-bundle-server/internal/log"
 )
 
-func all() []argparse.Subcommand {
+func all(logger tracelog.TraceLogger) []argparse.Subcommand {
 	return []argparse.Subcommand{
-		NewDeleteCommand(),
-		NewInitCommand(),
-		NewStartCommand(),
-		NewStopCommand(),
-		NewUpdateCommand(),
-		NewUpdateAllCommand(),
-		NewWebServerCommand(),
+		NewDeleteCommand(logger),
+		NewInitCommand(logger),
+		NewStartCommand(logger),
+		NewStopCommand(logger),
+		NewUpdateCommand(logger),
+		NewUpdateAllCommand(logger),
+		NewWebServerCommand(logger),
 	}
 }
 
 func main() {
 	tracelog.WithTraceLogger(context.Background(), func(ctx context.Context, logger tracelog.TraceLogger) {
-		cmds := all()
+		cmds := all(logger)
 
-		parser := argparse.NewArgParser("git-bundle-server <command> [<options>]")
+		parser := argparse.NewArgParser(logger, "git-bundle-server <command> [<options>]")
 		parser.SetIsTopLevel(true)
 		for _, cmd := range cmds {
 			parser.Subcommand(cmd)

cmd/git-bundle-server/start.go

@@ -7,12 +7,17 @@ import (
 
 	"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{}
+type startCmd struct {
+	logger log.TraceLogger
+}
 
-func NewStartCommand() argparse.Subcommand {
-	return &startCmd{}
+func NewStartCommand(logger log.TraceLogger) argparse.Subcommand {
+	return &startCmd{
+		logger: logger,
+	}
 }
 
 func (startCmd) Name() string {
@@ -25,8 +30,8 @@ Start computing bundles and serving content for the repository at the
 specified '<route>'.`
 }
 
-func (startCmd) Run(ctx context.Context, args []string) error {
-	parser := argparse.NewArgParser("git-bundle-server start <route>")
+func (s *startCmd) Run(ctx context.Context, args []string) error {
+	parser := argparse.NewArgParser(s.logger, "git-bundle-server start <route>")
 	route := parser.PositionalString("route", "the route for which bundles should be generated")
 	parser.Parse(ctx, args)
 

cmd/git-bundle-server/stop.go

@@ -5,12 +5,17 @@ import (
 
 	"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{}
+type stopCmd struct {
+	logger log.TraceLogger
+}
 
-func NewStopCommand() argparse.Subcommand {
-	return &stopCmd{}
+func NewStopCommand(logger log.TraceLogger) argparse.Subcommand {
+	return &stopCmd{
+		logger: logger,
+	}
 }
 
 func (stopCmd) Name() string {
@@ -23,8 +28,8 @@ Stop computing bundles or serving content for the repository at the
 specified '<route>'.`
 }
 
-func (stopCmd) Run(ctx context.Context, args []string) error {
-	parser := argparse.NewArgParser("git-bundle-server stop <route>")
+func (s *stopCmd) Run(ctx context.Context, args []string) error {
+	parser := argparse.NewArgParser(s.logger, "git-bundle-server stop <route>")
 	route := parser.PositionalString("route", "the route for which bundles should stop being generated")
 	parser.Parse(ctx, args)
 

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

@@ -9,12 +9,17 @@ import (
 	"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{}
+type updateAllCmd struct {
+	logger log.TraceLogger
+}
 
-func NewUpdateAllCommand() argparse.Subcommand {
-	return &updateAllCmd{}
+func NewUpdateAllCommand(logger log.TraceLogger) argparse.Subcommand {
+	return &updateAllCmd{
+		logger: logger,
+	}
 }
 
 func (updateAllCmd) Name() string {
@@ -26,14 +31,14 @@ func (updateAllCmd) Description() string {
 For every configured route, run 'git-bundle-server update <options> <route>'.`
 }
 
-func (updateAllCmd) Run(ctx context.Context, args []string) error {
+func (u *updateAllCmd) Run(ctx context.Context, args []string) error {
 	user, err := common.NewUserProvider().CurrentUser()
 	if err != nil {
 		return err
 	}
 	fs := common.NewFileSystem()
 
-	parser := argparse.NewArgParser("git-bundle-server update-all")
+	parser := argparse.NewArgParser(u.logger, "git-bundle-server update-all")
 	parser.Parse(ctx, args)
 
 	exe, err := os.Executable()

cmd/git-bundle-server/update.go

@@ -7,12 +7,17 @@ import (
 	"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{}
+type updateCmd struct {
+	logger log.TraceLogger
+}
 
-func NewUpdateCommand() argparse.Subcommand {
-	return &updateAllCmd{}
+func NewUpdateCommand(logger log.TraceLogger) argparse.Subcommand {
+	return &updateCmd{
+		logger: logger,
+	}
 }
 
 func (updateCmd) Name() string {
@@ -26,8 +31,8 @@ For the repository in the current directory (or the one specified by
 bundles, and update the bundle list.`
 }
 
-func (updateCmd) Run(ctx context.Context, args []string) error {
-	parser := argparse.NewArgParser("git-bundle-server update <route>")
+func (u *updateCmd) Run(ctx context.Context, args []string) error {
+	parser := argparse.NewArgParser(u.logger, "git-bundle-server update <route>")
 	route := parser.PositionalString("route", "the route to update")
 	parser.Parse(ctx, args)
 

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

@@ -13,17 +13,20 @@ import (
 	"github.com/github/git-bundle-server/internal/argparse"
 	"github.com/github/git-bundle-server/internal/common"
 	"github.com/github/git-bundle-server/internal/daemon"
+	"github.com/github/git-bundle-server/internal/log"
 )
 
 type webServerCmd struct {
+	logger     log.TraceLogger
 	user       common.UserProvider
 	cmdExec    common.CommandExecutor
 	fileSystem common.FileSystem
 }
 
-func NewWebServerCommand() argparse.Subcommand {
+func NewWebServerCommand(logger log.TraceLogger) argparse.Subcommand {
 	// Create subcommand-specific dependencies
 	return &webServerCmd{
+		logger:     logger,
 		user:       common.NewUserProvider(),
 		cmdExec:    common.NewCommandExecutor(),
 		fileSystem: common.NewFileSystem(),
@@ -79,7 +82,7 @@ func (w *webServerCmd) getDaemonConfig() (*daemon.DaemonConfig, error) {
 
 func (w *webServerCmd) startServer(ctx context.Context, args []string) error {
 	// Parse subcommand arguments
-	parser := argparse.NewArgParser("git-bundle-server web-server start [-f|--force]")
+	parser := argparse.NewArgParser(w.logger, "git-bundle-server web-server start [-f|--force]")
 
 	// Args for 'git-bundle-server web-server start'
 	force := parser.Bool("force", false, "Force reconfiguration of the web server daemon")
@@ -94,7 +97,7 @@ func (w *webServerCmd) startServer(ctx context.Context, args []string) error {
 	parser.Parse(ctx, args)
 	validate(ctx)
 
-	d, err := daemon.NewDaemonProvider(w.user, w.cmdExec, w.fileSystem)
+	d, err := daemon.NewDaemonProvider(w.logger, w.user, w.cmdExec, w.fileSystem)
 	if err != nil {
 		return err
 	}
@@ -146,11 +149,11 @@ func (w *webServerCmd) startServer(ctx context.Context, args []string) error {
 
 func (w *webServerCmd) stopServer(ctx context.Context, args []string) error {
 	// Parse subcommand arguments
-	parser := argparse.NewArgParser("git-bundle-server web-server stop [--remove]")
+	parser := argparse.NewArgParser(w.logger, "git-bundle-server web-server stop [--remove]")
 	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.user, w.cmdExec, w.fileSystem)
+	d, err := daemon.NewDaemonProvider(w.logger, w.user, w.cmdExec, w.fileSystem)
 	if err != nil {
 		return err
 	}
@@ -177,7 +180,7 @@ func (w *webServerCmd) stopServer(ctx context.Context, args []string) error {
 
 func (w *webServerCmd) Run(ctx context.Context, args []string) error {
 	// Parse command arguments
-	parser := argparse.NewArgParser("git-bundle-server web-server (start|stop) <options>")
+	parser := argparse.NewArgParser(w.logger, "git-bundle-server web-server (start|stop) <options>")
 	parser.Subcommand(argparse.NewSubcommand("start", "Start the web server", w.startServer))
 	parser.Subcommand(argparse.NewSubcommand("stop", "Stop the web server", w.stopServer))
 	parser.Parse(ctx, args)

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

@@ -13,16 +13,21 @@ import (
 
 	"github.com/github/git-bundle-server/internal/common"
 	"github.com/github/git-bundle-server/internal/core"
+	tracelog "github.com/github/git-bundle-server/internal/log"
 )
 
 type bundleWebServer struct {
+	logger             tracelog.TraceLogger
 	server             *http.Server
 	serverWaitGroup    *sync.WaitGroup
 	listenAndServeFunc func() error
 }
 
-func NewBundleWebServer(port string, certFile string, keyFile string) *bundleWebServer {
+func NewBundleWebServer(logger tracelog.TraceLogger,
+	port string, certFile string, keyFile string,
+) *bundleWebServer {
 	bundleServer := &bundleWebServer{
+		logger:          logger,
 		serverWaitGroup: &sync.WaitGroup{},
 	}
 

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

@@ -13,7 +13,7 @@ import (
 
 func main() {
 	log.WithTraceLogger(context.Background(), func(ctx context.Context, logger log.TraceLogger) {
-		parser := argparse.NewArgParser("git-bundle-web-server [--port <port>] [--cert <filename> --key <filename>]")
+		parser := argparse.NewArgParser(logger, "git-bundle-web-server [--port <port>] [--cert <filename> --key <filename>]")
 		flags, validate := utils.WebServerFlags(parser)
 		flags.VisitAll(func(f *flag.Flag) {
 			parser.Var(f.Value, f.Name, f.Usage)
@@ -28,7 +28,7 @@ func main() {
 		key := utils.GetFlagValue[string](parser, "key")
 
 		// Configure the server
-		bundleServer := NewBundleWebServer(port, cert, key)
+		bundleServer := NewBundleWebServer(logger, port, cert, key)
 
 		// Start the server asynchronously
 		bundleServer.StartServerAsync(ctx)

internal/argparse/argparse.go

@@ -6,6 +6,8 @@ import (
 	"fmt"
 	"os"
 	"strings"
+
+	"github.com/github/git-bundle-server/internal/log"
 )
 
 // For consistency with 'flag', use 2 as the usage-related error code
@@ -30,17 +32,19 @@ type argParser struct {
 	// Post-parsing
 	selectedSubcommand Subcommand
 
+	logger log.TraceLogger
 	flag.FlagSet
 }
 
-func NewArgParser(usageString string) *argParser {
+func NewArgParser(logger log.TraceLogger, usageString string) *argParser {
 	flagSet := flag.NewFlagSet("", flag.ContinueOnError)
 
 	a := &argParser{
 		isTopLevel:  false,
 		parsed:      false,
 		argOffset:   0,
 		subcommands: make(map[string]Subcommand),
+		logger:      logger,
 		FlagSet:     *flagSet,
 	}
 

internal/daemon/daemon.go

@@ -6,6 +6,7 @@ import (
 	"runtime"
 
 	"github.com/github/git-bundle-server/internal/common"
+	"github.com/github/git-bundle-server/internal/log"
 )
 
 type DaemonConfig struct {
@@ -26,17 +27,18 @@ type DaemonProvider interface {
 }
 
 func NewDaemonProvider(
+	l log.TraceLogger,
 	u common.UserProvider,
 	c common.CommandExecutor,
 	fs common.FileSystem,
 ) (DaemonProvider, error) {
 	switch thisOs := runtime.GOOS; thisOs {
 	case "linux":
 		// Use systemd/systemctl
-		return NewSystemdProvider(u, c, fs), nil
+		return NewSystemdProvider(l, u, c, fs), nil
 	case "darwin":
 		// Use launchd/launchctl
-		return NewLaunchdProvider(u, c, fs), nil
+		return NewLaunchdProvider(l, u, c, fs), nil
 	default:
 		return nil, fmt.Errorf("cannot configure daemon handler for OS '%s'", thisOs)
 	}