git-bundle-server: add 'repair' command

Create a new command 'repair' to fix common issues with the bundle server's
internal storage. Start by implementing the 'routes' subcommand, which (by
default) removes routes from the 'routes' file if they do not appear (or are
not Git repositories) on disk.

Include two additional options:
- '--dry-run', which gathers repository information and constructs the list
  of repairs needed, but does not update anything
- '--start-all', which adds any unregistered, valid repositories on disk to
  the 'routes' file (effectively running 'git-bundle-server start' on all)

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

Author: vdye

README.md

@@ -136,6 +136,10 @@ being managed by the bundle server.
 * `git-bundle-server list [<options>]`: List each route and associated
   information (e.g. Git remote URL) in the bundle server.
 
+* `git-bundle-server repair routes [<options>]`: Correct the contents of the
+  internal route registry by comparing to bundle server's internal repository
+  storage.
+
 ### Web server management
 
 Independent of the management of the individual repositories hosted by the

cmd/git-bundle-server/main.go

@@ -15,6 +15,7 @@ func all(logger log.TraceLogger) []argparse.Subcommand {
 	return []argparse.Subcommand{
 		NewDeleteCommand(logger, container),
 		NewInitCommand(logger, container),
+		NewRepairCommand(logger, container),
 		NewStartCommand(logger, container),
 		NewStopCommand(logger, container),
 		NewUpdateCommand(logger, container),

cmd/git-bundle-server/repair.go

@@ -0,0 +1,113 @@
+package main
+
+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/core"
+	"github.com/github/git-bundle-server/internal/log"
+	typeutils "github.com/github/git-bundle-server/internal/utils"
+)
+
+type repairCmd struct {
+	logger    log.TraceLogger
+	container *utils.DependencyContainer
+}
+
+func NewRepairCommand(logger log.TraceLogger, container *utils.DependencyContainer) argparse.Subcommand {
+	return &repairCmd{
+		logger:    logger,
+		container: container,
+	}
+}
+
+func (repairCmd) Name() string {
+	return "repair"
+}
+
+func (repairCmd) Description() string {
+	return `
+Scan and correct inconsistencies in the bundle server's internal registries and
+storage.`
+}
+
+func (r *repairCmd) repairRoutes(ctx context.Context, args []string) error {
+	parser := argparse.NewArgParser(r.logger, "git-bundle-server repair routes [--start-all] [--dry-run]")
+	enable := parser.Bool("start-all", false, "turn on bundle computation for all repositories found")
+	dryRun := parser.Bool("dry-run", false, "report the repairs needed, but do not perform them")
+	// TODO: add a '--cleanup' option to delete non-repo contents inside repo root
+	parser.Parse(ctx, args)
+
+	repoProvider := utils.GetDependency[core.RepositoryProvider](ctx, r.container)
+
+	// Read the routes file
+	repos, err := repoProvider.GetRepositories(ctx)
+	if err != nil {
+		// If routes file cannot be read, start over
+		fmt.Println("warning: cannot load routes file; rebuilding from scratch...")
+		repos = make(map[string]core.Repository)
+	}
+
+	// Read the repositories as represented by internal storage
+	storedRepos, err := repoProvider.ReadRepositoryStorage(ctx)
+	if err != nil {
+		return r.logger.Errorf(ctx, "could not read internal repository storage: %w", err)
+	}
+
+	_, missingOnDisk, notRegistered := typeutils.SegmentKeys(repos, storedRepos)
+
+	// Print the updates to be made
+	fmt.Print("\n")
+
+	if *enable && len(notRegistered) > 0 {
+		fmt.Println("Unregistered routes to add")
+		fmt.Println("--------------------------")
+		for _, route := range notRegistered {
+			fmt.Printf("* %s\n", route)
+			repos[route] = storedRepos[route]
+		}
+		fmt.Print("\n")
+	}
+
+	if len(missingOnDisk) > 0 {
+		fmt.Println("Missing or invalid routes to remove")
+		fmt.Println("-----------------------------------")
+		for _, route := range missingOnDisk {
+			fmt.Printf("* %s\n", route)
+			delete(repos, route)
+		}
+		fmt.Print("\n")
+	}
+
+	if (!*enable || len(notRegistered) == 0) && len(missingOnDisk) == 0 {
+		fmt.Println("No repairs needed.")
+		return nil
+	}
+
+	if *dryRun {
+		fmt.Println("Skipping updates (dry run)")
+	} else {
+		fmt.Println("Applying route repairs...")
+		err := repoProvider.WriteAllRoutes(ctx, repos)
+		if err != nil {
+			return err
+		}
+
+		// Start the global cron schedule (if it's not already running)
+		cron := utils.GetDependency[utils.CronHelper](ctx, r.container)
+		cron.SetCronSchedule(ctx)
+		fmt.Println("Done")
+	}
+
+	return nil
+}
+
+func (r *repairCmd) Run(ctx context.Context, args []string) error {
+	parser := argparse.NewArgParser(r.logger, "git-bundle-server repair <subcommand> [<options>]")
+	parser.Subcommand(argparse.NewSubcommand("routes", "Correct the contents of the internal route registry", r.repairRoutes))
+	parser.Parse(ctx, args)
+
+	return parser.InvokeSubcommand(ctx)
+}

docs/man/git-bundle-server.adoc

@@ -92,6 +92,19 @@ fetching during scheduled bundle updates.
   *--name-only*:::
     Print only the route name on each line.
 
+*repair* *routes* [*--start-all*] [*--dry-run*]::
+  Correct the contents of the internal route registry by comparing to bundle
+  server's internal repository storage.
+
+  *--start-all*:::
+    If any valid repositories are found that are not registered to the bundle
+    server (for example, those deactivated with *git-bundle-server stop*),
+    enable them.
+
+  *--dry-run*:::
+    Collect and report the repairs that the command will perform, but do not
+    perform them.
+
 *web-server* *start* [*-f*|*--force*] [_server-options_]::
   Start a background process web server hosting bundle metadata and content. The
   web server daemon runs under the calling user's domain, and will continue

internal/utils/maps.go

@@ -0,0 +1,27 @@
+package utils
+
+// SegmentKeys takes two maps with keys of the same type and returns three
+// slices (with *no guaranteed order*):
+// - the keys common across both maps
+// - the keys present in the first set but not the second
+// - the keys present in the second set but not the first
+func SegmentKeys[T comparable, S any, R any](mapA map[T]S, mapB map[T]R) (intersect, diffAB, diffBA []T) {
+	intersect = []T{}
+	diffAB = []T{}
+	diffBA = []T{}
+	for a := range mapA {
+		if _, contains := mapB[a]; contains {
+			intersect = append(intersect, a)
+		} else {
+			diffAB = append(diffAB, a)
+		}
+	}
+
+	for b := range mapB {
+		if _, contains := mapA[b]; !contains {
+			diffBA = append(diffBA, b)
+		}
+	}
+
+	return
+}

internal/utils/maps_test.go

@@ -0,0 +1,120 @@
+package utils_test
+
+import (
+	"testing"
+
+	"github.com/github/git-bundle-server/internal/utils"
+	"github.com/stretchr/testify/assert"
+)
+
+var segmentKeysTests = []struct {
+	title string
+	mapA  map[string]interface{}
+	mapB  map[string]interface{}
+
+	expectedIntersect []string
+	expectedDiffAB    []string
+	expectedDiffBA    []string
+}{
+	{
+		"all empty",
+		map[string]interface{}{},
+		map[string]interface{}{},
+
+		[]string{},
+		[]string{},
+		[]string{},
+	},
+	{
+		"no overlap",
+		map[string]interface{}{
+			"A": nil,
+			"B": nil,
+		},
+		map[string]interface{}{
+			"C": nil,
+			"D": nil,
+		},
+
+		[]string{},
+		[]string{"A", "B"},
+		[]string{"C", "D"},
+	},
+	{
+		"all overlap",
+		map[string]interface{}{
+			"A": nil,
+			"B": nil,
+		},
+		map[string]interface{}{
+			"B": nil,
+			"A": nil,
+		},
+
+		[]string{"A", "B"},
+		[]string{},
+		[]string{},
+	},
+	{
+		"A superset of B",
+		map[string]interface{}{
+			"A": nil,
+			"B": nil,
+			"C": nil,
+			"D": nil,
+		},
+		map[string]interface{}{
+			"B": nil,
+			"D": nil,
+		},
+
+		[]string{"B", "D"},
+		[]string{"A", "C"},
+		[]string{},
+	},
+	{
+		"B superset of A",
+		map[string]interface{}{
+			"A": nil,
+			"C": nil,
+		},
+		map[string]interface{}{
+			"A": nil,
+			"B": nil,
+			"C": nil,
+			"D": nil,
+		},
+
+		[]string{"A", "C"},
+		[]string{},
+		[]string{"B", "D"},
+	},
+	{
+		"no empty result sets",
+		map[string]interface{}{
+			"A": nil,
+			"C": nil,
+			"E": nil,
+		},
+		map[string]interface{}{
+			"B": nil,
+			"C": nil,
+			"D": nil,
+		},
+
+		[]string{"C"},
+		[]string{"A", "E"},
+		[]string{"B", "D"},
+	},
+}
+
+func TestSegmentKeys(t *testing.T) {
+	for _, tt := range segmentKeysTests {
+		t.Run(tt.title, func(t *testing.T) {
+			intersect, diffAB, diffBA := utils.SegmentKeys(tt.mapA, tt.mapB)
+			assert.ElementsMatch(t, tt.expectedIntersect, intersect)
+			assert.ElementsMatch(t, tt.expectedDiffAB, diffAB)
+			assert.ElementsMatch(t, tt.expectedDiffBA, diffBA)
+		})
+	}
+}