feat(server): use smart http git backend

This implements the smart http git protocol which also supports
git-receive-pack service.

cmd/soft/root.go

@@ -54,6 +54,9 @@ func init() {
 func main() {
 	logger := NewDefaultLogger()
 
+	// Set global logger
+	log.SetDefault(logger)
+
 	// Set the max number of processes to the number of CPUs
 	// This is useful when running soft serve in a container
 	if _, err := maxprocs.Set(maxprocs.Logger(logger.Debugf)); err != nil {

git/repo.go

@@ -205,13 +205,6 @@ func (r *Repository) CommitsByPage(ref *Reference, page, size int) (Commits, err
 	return commits, nil
 }
 
-// UpdateServerInfo updates the repository server info.
-func (r *Repository) UpdateServerInfo() error {
-	cmd := git.NewCommand("update-server-info")
-	_, err := cmd.RunInDir(r.Path)
-	return err
-}
-
 // Config returns the config value for the given key.
 func (r *Repository) Config(key string, opts ...ConfigOptions) (string, error) {
 	dir, err := gitDir(r.Repository)

git/server.go

@@ -0,0 +1,18 @@
+package git
+
+import (
+	"context"
+
+	"github.com/gogs/git-module"
+)
+
+// UpdateServerInfo updates the server info file for the given repo path.
+func UpdateServerInfo(ctx context.Context, path string) error {
+	if !isGitDir(path) {
+		return ErrNotAGitRepository
+	}
+
+	cmd := git.NewCommand("update-server-info").WithContext(ctx).WithTimeout(-1)
+	_, err := cmd.RunInDir(path)
+	return err
+}

git/utils.go

@@ -1,6 +1,7 @@
 package git
 
 import (
+	"os"
 	"path/filepath"
 
 	"github.com/gobwas/glob"
@@ -49,3 +50,25 @@ func LatestFile(repo *Repository, pattern string) (string, string, error) {
 	}
 	return "", "", ErrFileNotFound
 }
+
+// Returns true if path is a directory containing an `objects` directory and a
+// `HEAD` file.
+func isGitDir(path string) bool {
+	stat, err := os.Stat(filepath.Join(path, "objects"))
+	if err != nil {
+		return false
+	}
+	if !stat.IsDir() {
+		return false
+	}
+
+	stat, err = os.Stat(filepath.Join(path, "HEAD"))
+	if err != nil {
+		return false
+	}
+	if stat.IsDir() {
+		return false
+	}
+
+	return true
+}

internal/log/log.go

@@ -32,6 +32,10 @@ func NewDefaultLogger() *log.Logger {
 
 	if debug, _ := strconv.ParseBool(os.Getenv("SOFT_SERVE_DEBUG")); debug {
 		logger.SetLevel(log.DebugLevel)
+
+		if verbose, _ := strconv.ParseBool(os.Getenv("SOFT_SERVE_VERBOSE")); verbose {
+			logger.SetReportCaller(true)
+		}
 	}
 
 	logger.SetTimeFormat(cfg.Log.TimeFormat)

server/backend/sqlite/hooks.go

@@ -36,16 +36,6 @@ func (d *SqliteBackend) PostUpdate(stdout io.Writer, stderr io.Writer, repo stri
 
 	var wg sync.WaitGroup
 
-	// Update server info
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		if err := updateServerInfo(d, repo); err != nil {
-			d.logger.Error("error updating server-info", "repo", repo, "err", err)
-			return
-		}
-	}()
-
 	// Populate last-modified file.
 	wg.Add(1)
 	go func() {
@@ -59,20 +49,6 @@ func (d *SqliteBackend) PostUpdate(stdout io.Writer, stderr io.Writer, repo stri
 	wg.Wait()
 }
 
-func updateServerInfo(d *SqliteBackend, repo string) error {
-	rr, err := d.Repository(repo)
-	if err != nil {
-		return err
-	}
-
-	r, err := rr.Open()
-	if err != nil {
-		return err
-	}
-
-	return r.UpdateServerInfo()
-}
-
 func populateLastModified(d *SqliteBackend, repo string) error {
 	var rr *Repo
 	_rr, err := d.Repository(repo)

server/backend/sqlite/sqlite.go

@@ -151,17 +151,12 @@ func (d *SqliteBackend) CreateRepository(name string, opts backend.RepositoryOpt
 			return err
 		}
 
-		rr, err := git.Init(rp, true)
+		_, err := git.Init(rp, true)
 		if err != nil {
 			d.logger.Debug("failed to create repository", "err", err)
 			return err
 		}
 
-		if err := rr.UpdateServerInfo(); err != nil {
-			d.logger.Debug("failed to update server info", "err", err)
-			return err
-		}
-
 		return nil
 	}); err != nil {
 		d.logger.Debug("failed to create repository in database", "err", err)

server/git/git.go

@@ -69,6 +69,8 @@ func EnsureWithin(reposDir string, repo string) error {
 	return nil
 }
 
+// EnsureDefaultBranch ensures the repo has a default branch.
+// It will prefer choosing "main" or "master" if available.
 func EnsureDefaultBranch(ctx context.Context, scmd ServiceCommand) error {
 	r, err := git.Open(scmd.Dir)
 	if err != nil {

server/git/service.go

@@ -9,6 +9,7 @@ import (
 	"os/exec"
 	"strings"
 
+	"github.com/charmbracelet/log"
 	"golang.org/x/sync/errgroup"
 )
 
@@ -66,58 +67,107 @@ func gitServiceHandler(ctx context.Context, svc Service, scmd ServiceCommand) er
 		scmd.CmdFunc(cmd)
 	}
 
-	stdin, err := cmd.StdinPipe()
-	if err != nil {
-		return err
+	var (
+		err    error
+		stdin  io.WriteCloser
+		stdout io.ReadCloser
+		stderr io.ReadCloser
+	)
+
+	if scmd.Stdin != nil {
+		stdin, err = cmd.StdinPipe()
+		if err != nil {
+			return err
+		}
 	}
 
-	stdout, err := cmd.StdoutPipe()
-	if err != nil {
-		return err
+	if scmd.Stdout != nil {
+		stdout, err = cmd.StdoutPipe()
+		if err != nil {
+			return err
+		}
 	}
 
-	stderr, err := cmd.StderrPipe()
-	if err != nil {
-		return err
+	if scmd.Stderr != nil {
+		stderr, err = cmd.StderrPipe()
+		if err != nil {
+			return err
+		}
 	}
 
+	log.Debugf("git service command in %q: %s", cmd.Dir, cmd.String())
 	if err := cmd.Start(); err != nil {
 		return err
 	}
 
 	errg, ctx := errgroup.WithContext(ctx)
 
 	// stdin
-	errg.Go(func() error {
-		defer stdin.Close() // nolint: errcheck
-		_, err := io.Copy(stdin, scmd.Stdin)
-		return err
-	})
+	if scmd.Stdin != nil {
+		errg.Go(func() error {
+			if scmd.StdinHandler != nil {
+				return scmd.StdinHandler(scmd.Stdin, stdin)
+			} else {
+				return defaultStdinHandler(scmd.Stdin, stdin)
+			}
+		})
+	}
 
 	// stdout
-	errg.Go(func() error {
-		_, err := io.Copy(scmd.Stdout, stdout)
-		return err
-	})
+	if scmd.Stdout != nil {
+		errg.Go(func() error {
+			if scmd.StdoutHandler != nil {
+				return scmd.StdoutHandler(scmd.Stdout, stdout)
+			} else {
+				return defaultStdoutHandler(scmd.Stdout, stdout)
+			}
+		})
+	}
 
 	// stderr
-	errg.Go(func() error {
-		_, err := io.Copy(scmd.Stderr, stderr)
-		return err
-	})
+	if scmd.Stderr != nil {
+		errg.Go(func() error {
+			if scmd.StderrHandler != nil {
+				return scmd.StderrHandler(scmd.Stderr, stderr)
+			} else {
+				return defaultStderrHandler(scmd.Stderr, stderr)
+			}
+		})
+	}
 
 	return errors.Join(errg.Wait(), cmd.Wait())
 }
 
 // ServiceCommand is used to run a git service command.
 type ServiceCommand struct {
-	Stdin   io.Reader
-	Stdout  io.Writer
-	Stderr  io.Writer
-	Dir     string
-	Env     []string
-	Args    []string
-	CmdFunc func(*exec.Cmd)
+	Stdin  io.Reader
+	Stdout io.Writer
+	Stderr io.Writer
+	Dir    string
+	Env    []string
+	Args   []string
+
+	// Modifier functions
+	CmdFunc       func(*exec.Cmd)
+	StdinHandler  func(io.Reader, io.WriteCloser) error
+	StdoutHandler func(io.Writer, io.ReadCloser) error
+	StderrHandler func(io.Writer, io.ReadCloser) error
+}
+
+func defaultStdinHandler(in io.Reader, stdin io.WriteCloser) error {
+	defer stdin.Close() // nolint: errcheck
+	_, err := io.Copy(stdin, in)
+	return err
+}
+
+func defaultStdoutHandler(out io.Writer, stdout io.ReadCloser) error {
+	_, err := io.Copy(out, stdout)
+	return err
+}
+
+func defaultStderrHandler(err io.Writer, stderr io.ReadCloser) error {
+	_, erro := io.Copy(err, stderr)
+	return erro
 }
 
 // UploadPack runs the git upload-pack protocol against the provided repo.