Merge pull request #9 from github/vdye/web-server-daemon

Improve argument parsing & implement the `web-server` command

Author: vdye

cmd/git-bundle-server/delete.go

@@ -1,31 +1,35 @@
 package main
 
 import (
-	"errors"
 	"os"
 
+	"github.com/github/git-bundle-server/internal/argparse"
 	"github.com/github/git-bundle-server/internal/core"
 )
 
 type Delete struct{}
 
-func (Delete) subcommand() string {
+func (Delete) Name() string {
 	return "delete"
 }
 
-func (Delete) run(args []string) error {
-	if len(args) < 1 {
-		return errors.New("usage: git-bundle-server delete <route>")
-	}
+func (Delete) Description() string {
+	return `
+Remove the configuration for the given '<route>' and delete its repository
+data.`
+}
 
-	route := args[0]
+func (Delete) Run(args []string) error {
+	parser := argparse.NewArgParser("git-bundle-server delete <route>")
+	route := parser.PositionalString("route", "the route to delete")
+	parser.Parse(args)
 
-	repo, err := core.CreateRepository(route)
+	repo, err := core.CreateRepository(*route)
 	if err != nil {
 		return err
 	}
 
-	err = core.RemoveRoute(route)
+	err = core.RemoveRoute(*route)
 	if err != nil {
 		return err
 	}

cmd/git-bundle-server/init.go

@@ -1,36 +1,40 @@
 package main
 
 import (
-	"errors"
 	"fmt"
 
+	"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/git"
 )
 
 type Init struct{}
 
-func (Init) subcommand() string {
+func (Init) Name() string {
 	return "init"
 }
 
-func (Init) run(args []string) error {
-	if len(args) < 2 {
-		// TODO: allow parsing <route> out of <url>
-		return errors.New("usage: git-bundle-server init <url> <route>")
-	}
+func (Init) Description() string {
+	return `
+Initialize a repository by cloning a bare repo from '<url>', whose bundles
+should be hosted at '<route>'.`
+}
 
-	url := args[0]
-	route := args[1]
+func (Init) Run(args []string) error {
+	parser := argparse.NewArgParser("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")
+	parser.Parse(args)
 
-	repo, err := core.CreateRepository(route)
+	repo, err := core.CreateRepository(*route)
 	if err != nil {
 		return err
 	}
 
-	fmt.Printf("Cloning repository from %s\n", url)
-	gitErr := git.GitCommand("clone", "--bare", url, repo.RepoDir)
+	fmt.Printf("Cloning repository from %s\n", *url)
+	gitErr := git.GitCommand("clone", "--bare", *url, repo.RepoDir)
 
 	if gitErr != nil {
 		return fmt.Errorf("failed to clone repository: %w", gitErr)

cmd/git-bundle-server/main.go

@@ -3,22 +3,34 @@ package main
 import (
 	"log"
 	"os"
+
+	"github.com/github/git-bundle-server/internal/argparse"
 )
 
+func all() []argparse.Subcommand {
+	return []argparse.Subcommand{
+		Delete{},
+		Init{},
+		Start{},
+		Stop{},
+		Update{},
+		UpdateAll{},
+		NewWebServerCommand(),
+	}
+}
+
 func main() {
 	cmds := all()
 
-	if len(os.Args) < 2 {
-		log.Fatal("usage: git-bundle-server <command> [<options>]\n")
-		return
+	parser := argparse.NewArgParser("git-bundle-server <command> [<options>]")
+	parser.SetIsTopLevel(true)
+	for _, cmd := range cmds {
+		parser.Subcommand(cmd)
 	}
+	parser.Parse(os.Args[1:])
 
-	for i := 0; i < len(cmds); i++ {
-		if cmds[i].subcommand() == os.Args[1] {
-			err := cmds[i].run(os.Args[2:])
-			if err != nil {
-				log.Fatal("Failed with error: ", err)
-			}
-		}
+	err := parser.InvokeSubcommand()
+	if err != nil {
+		log.Fatal("Failed with error: ", err)
 	}
 }

cmd/git-bundle-server/start.go

@@ -1,35 +1,39 @@
 package main
 
 import (
-	"errors"
 	"fmt"
 	"os"
 
+	"github.com/github/git-bundle-server/internal/argparse"
 	"github.com/github/git-bundle-server/internal/core"
 )
 
 type Start struct{}
 
-func (Start) subcommand() string {
+func (Start) Name() string {
 	return "start"
 }
 
-func (Start) run(args []string) error {
-	if len(args) < 1 {
-		return errors.New("usage: git-bundle-server start <route>")
-	}
+func (Start) Description() string {
+	return `
+Start computing bundles and serving content for the repository at the
+specified '<route>'.`
+}
 
-	route := args[0]
+func (Start) Run(args []string) error {
+	parser := argparse.NewArgParser("git-bundle-server start <route>")
+	route := parser.PositionalString("route", "the route for which bundles should be generated")
+	parser.Parse(args)
 
 	// CreateRepository registers the route.
-	repo, err := core.CreateRepository(route)
+	repo, err := core.CreateRepository(*route)
 	if err != nil {
 		return err
 	}
 
 	_, err = os.ReadDir(repo.RepoDir)
 	if err != nil {
-		return fmt.Errorf("route '%s' appears to have been deleted; use 'init' instead", route)
+		return fmt.Errorf("route '%s' appears to have been deleted; use 'init' instead", *route)
 	}
 
 	// Make sure we have the global schedule running.

cmd/git-bundle-server/stop.go

@@ -1,23 +1,26 @@
 package main
 
 import (
-	"errors"
-
+	"github.com/github/git-bundle-server/internal/argparse"
 	"github.com/github/git-bundle-server/internal/core"
 )
 
 type Stop struct{}
 
-func (Stop) subcommand() string {
+func (Stop) Name() string {
 	return "stop"
 }
 
-func (Stop) run(args []string) error {
-	if len(args) < 1 {
-		return errors.New("usage: git-bundle-server stop <route>")
-	}
+func (Stop) Description() string {
+	return `
+Stop computing bundles or serving content for the repository at the
+specified '<route>'.`
+}
 
-	route := args[0]
+func (Stop) Run(args []string) error {
+	parser := argparse.NewArgParser("git-bundle-server stop <route>")
+	route := parser.PositionalString("route", "the route for which bundles should stop being generated")
+	parser.Parse(args)
 
-	return core.RemoveRoute(route)
+	return core.RemoveRoute(*route)
 }

cmd/git-bundle-server/subcommand.go

@@ -5,16 +5,25 @@ import (
 	"os"
 	"os/exec"
 
+	"github.com/github/git-bundle-server/internal/argparse"
 	"github.com/github/git-bundle-server/internal/core"
 )
 
 type UpdateAll struct{}
 
-func (UpdateAll) subcommand() string {
+func (UpdateAll) Name() string {
 	return "update-all"
 }
 
-func (UpdateAll) run(args []string) error {
+func (UpdateAll) Description() string {
+	return `
+For every configured route, run 'git-bundle-server update <options> <route>'.`
+}
+
+func (UpdateAll) Run(args []string) error {
+	parser := argparse.NewArgParser("git-bundle-server update-all")
+	parser.Parse(args)
+
 	exe, err := os.Executable()
 	if err != nil {
 		return fmt.Errorf("failed to get path to execuable: %w", err)

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

@@ -1,27 +1,32 @@
 package main
 
 import (
-	"errors"
 	"fmt"
 
+	"github.com/github/git-bundle-server/internal/argparse"
 	"github.com/github/git-bundle-server/internal/bundles"
 	"github.com/github/git-bundle-server/internal/core"
 )
 
 type Update struct{}
 
-func (Update) subcommand() string {
+func (Update) Name() string {
 	return "update"
 }
 
-func (Update) run(args []string) error {
-	if len(args) != 1 {
-		// TODO: allow parsing <route> out of <url>
-		return errors.New("usage: git-bundle-server update <route>")
-	}
+func (Update) Description() string {
+	return `
+For the repository in the current directory (or the one specified by
+'<route>'), fetch the latest content from the remote, create a new set of
+bundles, and update the bundle list.`
+}
+
+func (Update) Run(args []string) error {
+	parser := argparse.NewArgParser("git-bundle-server update <route>")
+	route := parser.PositionalString("route", "the route to update")
+	parser.Parse(args)
 
-	route := args[0]
-	repo, err := core.CreateRepository(route)
+	repo, err := core.CreateRepository(*route)
 	if err != nil {
 		return err
 	}