repo: add 'ReadRepositoryStorage()'

Add a function to the 'core.RepositoryProvider' that reads the on-disk
repository storage for the bundle server and returns the valid repos in a
route -> 'core.Repository' map.

'ReadRepositoryStorage()' identifies repositories by finding the directories
at a depth of 2 from the repo storage root, then checking that the
repository has a remote 'origin'. The result includes the "active" routes in
the bundle server (stored in the 'routes' file) as well as those that have
been removed from the routes file with 'git-bundle-server stop'. In later
commits, this information will be used to provide more complete information
about the state of the bundle server and configure "repairs" to a corrupted
server.

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

Author: vdye

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

@@ -13,8 +13,10 @@ import (
 	"time"
 
 	"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/git"
 	"github.com/github/git-bundle-server/internal/log"
 )
 
@@ -84,7 +86,9 @@ func (b *bundleWebServer) serve(w http.ResponseWriter, r *http.Request) {
 
 	userProvider := common.NewUserProvider()
 	fileSystem := common.NewFileSystem()
-	repoProvider := core.NewRepositoryProvider(b.logger, userProvider, fileSystem)
+	commandExecutor := cmd.NewCommandExecutor(b.logger)
+	gitHelper := git.NewGitHelper(b.logger, commandExecutor)
+	repoProvider := core.NewRepositoryProvider(b.logger, userProvider, fileSystem, gitHelper)
 
 	repos, err := repoProvider.GetRepositories(ctx)
 	if err != nil {

cmd/utils/container-helpers.go

@@ -28,6 +28,7 @@ func BuildGitBundleServerContainer(logger log.TraceLogger) *DependencyContainer
 			logger,
 			GetDependency[common.UserProvider](ctx, container),
 			GetDependency[common.FileSystem](ctx, container),
+			GetDependency[git.GitHelper](ctx, container),
 		)
 	})
 	registerDependency(container, func(ctx context.Context) bundles.BundleProvider {

internal/core/repo.go

@@ -5,8 +5,10 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"strings"
 
 	"github.com/github/git-bundle-server/internal/common"
+	"github.com/github/git-bundle-server/internal/git"
 	"github.com/github/git-bundle-server/internal/log"
 )
 
@@ -19,23 +21,27 @@ type Repository struct {
 type RepositoryProvider interface {
 	CreateRepository(ctx context.Context, route string) (*Repository, error)
 	GetRepositories(ctx context.Context) (map[string]Repository, error)
+	ReadRepositoryStorage(ctx context.Context) (map[string]Repository, error)
 	RemoveRoute(ctx context.Context, route string) error
 }
 
 type repoProvider struct {
 	logger     log.TraceLogger
 	user       common.UserProvider
 	fileSystem common.FileSystem
+	gitHelper  git.GitHelper
 }
 
 func NewRepositoryProvider(logger log.TraceLogger,
 	u common.UserProvider,
 	fs common.FileSystem,
+	g git.GitHelper,
 ) RepositoryProvider {
 	return &repoProvider{
 		logger:     logger,
 		user:       u,
 		fileSystem: fs,
+		gitHelper:  g,
 	}
 }
 
@@ -149,3 +155,43 @@ func (r *repoProvider) GetRepositories(ctx context.Context) (map[string]Reposito
 
 	return repos, nil
 }
+
+func (r *repoProvider) ReadRepositoryStorage(ctx context.Context) (map[string]Repository, error) {
+	ctx, exitRegion := r.logger.Region(ctx, "repo", "get_on_disk_repos")
+	defer exitRegion()
+
+	user, err := r.user.CurrentUser()
+	if err != nil {
+		return nil, err
+	}
+
+	entries, err := r.fileSystem.ReadDirRecursive(reporoot(user), 2, true)
+	if err != nil {
+		return nil, err
+	}
+
+	repos := make(map[string]Repository)
+	for _, entry := range entries {
+		if !entry.IsDir() {
+			continue
+		}
+
+		_, err = r.gitHelper.GetRemoteUrl(ctx, entry.Path())
+		if err != nil {
+			continue
+		}
+
+		pathElems := strings.Split(entry.Path(), string(os.PathSeparator))
+		if len(pathElems) < 2 {
+			return nil, r.logger.Errorf(ctx, "invalid repo path '%s'", entry.Path())
+		}
+		route := strings.Join(pathElems[len(pathElems)-2:], "/")
+		repos[route] = Repository{
+			Route:   route,
+			RepoDir: filepath.Join(reporoot(user), route),
+			WebDir:  filepath.Join(webroot(user), route),
+		}
+	}
+
+	return repos, nil
+}

internal/core/repo_test.go

@@ -7,8 +7,10 @@ import (
 	"path/filepath"
 	"testing"
 
+	"github.com/github/git-bundle-server/internal/common"
 	"github.com/github/git-bundle-server/internal/core"
 	. "github.com/github/git-bundle-server/internal/testhelpers"
+	"github.com/github/git-bundle-server/internal/utils"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 )
@@ -94,7 +96,7 @@ func TestRepos_GetRepositories(t *testing.T) {
 	}
 	testUserProvider := &MockUserProvider{}
 	testUserProvider.On("CurrentUser").Return(testUser, nil)
-	repoProvider := core.NewRepositoryProvider(testLogger, testUserProvider, testFileSystem)
+	repoProvider := core.NewRepositoryProvider(testLogger, testUserProvider, testFileSystem, nil)
 
 	for _, tt := range getRepositoriesTests {
 		t.Run(tt.title, func(t *testing.T) {
@@ -123,3 +125,134 @@ func TestRepos_GetRepositories(t *testing.T) {
 		})
 	}
 }
+
+var readRepositoryStorageTests = []struct {
+	title string
+
+	foundPaths            Pair[[]Pair[string, bool], error] // list of (path, isDir), error
+	foundRouteIsValidRepo map[string]bool                   // map of route -> whether GetRemoteUrl succeeds
+
+	expectedRoutes []string
+	expectedErr    bool
+}{
+	{
+		"no dirs found",
+		NewPair([]Pair[string, bool]{}, error(nil)),
+		map[string]bool{},
+		[]string{},
+		false,
+	},
+	{
+		"multiple valid repos found",
+		NewPair(
+			[]Pair[string, bool]{
+				NewPair("my/repo", true),
+				NewPair("another/route", true),
+			},
+			error(nil),
+		),
+		map[string]bool{
+			"my/repo":       true,
+			"another/route": true,
+		},
+		[]string{"my/repo", "another/route"},
+		false,
+	},
+	{
+		"ignores non-directories",
+		NewPair(
+			[]Pair[string, bool]{
+				NewPair("this-is-a/file", false),
+				NewPair("my/repo", true),
+			},
+			error(nil),
+		),
+		map[string]bool{
+			"my/repo": true,
+		},
+		[]string{"my/repo"},
+		false,
+	},
+	{
+		"ignores invalid Git repos",
+		NewPair(
+			[]Pair[string, bool]{
+				NewPair("is/a-repo", true),
+				NewPair("not/a-repo", true),
+			},
+			error(nil),
+		),
+		map[string]bool{
+			"is/a-repo":  true,
+			"not/a-repo": false,
+		},
+		[]string{"is/a-repo"},
+		false,
+	},
+}
+
+func TestRepos_ReadRepositoryStorage(t *testing.T) {
+	testLogger := &MockTraceLogger{}
+	testFileSystem := &MockFileSystem{}
+	testGitHelper := &MockGitHelper{}
+	testUser := &user.User{
+		Uid:      "123",
+		Username: "testuser",
+		HomeDir:  "/my/test/dir",
+	}
+	testUserProvider := &MockUserProvider{}
+	testUserProvider.On("CurrentUser").Return(testUser, nil)
+	repoProvider := core.NewRepositoryProvider(testLogger, testUserProvider, testFileSystem, testGitHelper)
+
+	for _, tt := range readRepositoryStorageTests {
+		t.Run(tt.title, func(t *testing.T) {
+			testFileSystem.On("ReadDirRecursive",
+				filepath.Clean("/my/test/dir/git-bundle-server/git"),
+				2,
+				true,
+			).Return(utils.Map(tt.foundPaths.First, func(path Pair[string, bool]) common.ReadDirEntry {
+				return TestReadDirEntry{
+					PathVal:  filepath.Join("/my/test/dir/git-bundle-server/git", path.First),
+					IsDirVal: path.Second,
+				}
+			}), tt.foundPaths.Second).Once()
+
+			for route, isValid := range tt.foundRouteIsValidRepo {
+				call := testGitHelper.On("GetRemoteUrl",
+					mock.Anything,
+					filepath.Join("/my/test/dir/git-bundle-server/git", route),
+				).Once()
+
+				if isValid {
+					call.Return("https://localhost/example-remote", nil)
+				} else {
+					call.Return("", errors.New("could not get remote URL"))
+				}
+			}
+
+			actual, err := repoProvider.ReadRepositoryStorage(context.Background())
+			mock.AssertExpectationsForObjects(t, testUserProvider, testFileSystem, testGitHelper)
+
+			if tt.expectedErr {
+				assert.NotNil(t, err, "Expected error")
+				assert.Nil(t, actual, "Expected nil map")
+			} else {
+				assert.Nil(t, err, "Expected success")
+				assert.NotNil(t, actual, "Expected non-nil map")
+				assert.NotNil(t, actual, "Expected non-nil list")
+				assert.Equal(t, len(tt.expectedRoutes), len(actual), "Length mismatch")
+				for _, route := range tt.expectedRoutes {
+					a := actual[route]
+
+					assert.Equal(t, route, a.Route)
+					assert.Equal(t, filepath.Join("/my/test/dir/git-bundle-server/git", route), a.RepoDir)
+					assert.Equal(t, filepath.Join("/my/test/dir/git-bundle-server/www", route), a.WebDir)
+				}
+			}
+
+			// Reset mocks
+			testFileSystem.Mock = mock.Mock{}
+			testGitHelper.Mock = mock.Mock{}
+		})
+	}
+}

internal/testhelpers/mocks.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"io/fs"
 	"os/exec"
 	"os/user"
 	"runtime"
@@ -13,6 +14,34 @@ import (
 	"github.com/stretchr/testify/mock"
 )
 
+type TestReadDirEntry struct {
+	PathVal  string
+	NameVal  string
+	IsDirVal bool
+	TypeVal  fs.FileMode
+	InfoVal  fs.FileInfo
+}
+
+func (e TestReadDirEntry) Path() string {
+	return e.PathVal
+}
+
+func (e TestReadDirEntry) Name() string {
+	return e.NameVal
+}
+
+func (e TestReadDirEntry) IsDir() bool {
+	return e.IsDirVal
+}
+
+func (e TestReadDirEntry) Type() fs.FileMode {
+	return e.TypeVal
+}
+
+func (e TestReadDirEntry) Info() (fs.FileInfo, error) {
+	return e.InfoVal, nil
+}
+
 func methodIsMocked(m *mock.Mock) bool {
 	// Get the calling method name
 	pc := make([]uintptr, 1)