git-bundle-web-server: move flags definition to common location

Move the definition of flags used by 'git-bundle-web-server' & custom flag
validation, to a more openly-accessible location. Specifically, add the
function 'WebServerFlags()' to a new file 'common-args.go' (in a new command
'utils' library). This function returns two values: a 'flag.FlagSet'
containing the args that are used by 'git-bundle-web-server', and a function
that takes no arguments and runs validation checks on the flag values after
arg parsing.

The goal of this change is to avoid duplicating these arg definitions and
validations when 'git-bundle-server web-server start' eventually uses those
options to configure the server daemon. It also sets up a pattern we can use
for future commands that need to share options.

Additionally, because the access pattern for flag values in a parsed
'flag.FlagSet' is a bit weird, add another helper function to
'common-args.go' to contain the logic for getting those values.

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

Author: vdye

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

@@ -2,16 +2,17 @@ package main
 
 import (
 	"context"
+	"flag"
 	"fmt"
 	"log"
 	"net/http"
 	"os"
 	"os/signal"
-	"strconv"
 	"strings"
 	"sync"
 	"syscall"
 
+	"github.com/github/git-bundle-server/cmd/utils"
 	"github.com/github/git-bundle-server/internal/argparse"
 	"github.com/github/git-bundle-server/internal/core"
 )
@@ -102,31 +103,29 @@ func startServer(server *http.Server,
 
 func main() {
 	parser := argparse.NewArgParser("git-bundle-web-server [--port <port>] [--cert <filename> --key <filename>]")
-	port := parser.String("port", "8080", "The port on which the server should be hosted")
-	cert := parser.String("cert", "", "The path to the X.509 SSL certificate file to use in securely hosting the server")
-	key := parser.String("key", "", "The path to the certificate's private key")
+	flags, validate := utils.WebServerFlags(parser)
+	flags.VisitAll(func(f *flag.Flag) {
+		parser.Var(f.Value, f.Name, f.Usage)
+	})
 	parser.Parse(os.Args[1:])
+	validate()
 
-	// Additional option validation
-	p, err := strconv.Atoi(*port)
-	if err != nil || p < 0 || p > 65535 {
-		parser.Usage("Invalid port '%s'.", *port)
-	}
-	if (*cert == "") != (*key == "") {
-		parser.Usage("Both '--cert' and '--key' are needed to specify SSL configuration.")
-	}
+	// Get the flag values
+	port := utils.GetFlagValue[string](parser, "port")
+	cert := utils.GetFlagValue[string](parser, "cert")
+	key := utils.GetFlagValue[string](parser, "key")
 
 	// Configure the server
 	mux := http.NewServeMux()
 	mux.HandleFunc("/", serve)
 	server := &http.Server{
 		Handler: mux,
-		Addr:    ":" + *port,
+		Addr:    ":" + port,
 	}
 	serverWaitGroup := &sync.WaitGroup{}
 
 	// Start the server asynchronously
-	startServer(server, *cert, *key, serverWaitGroup)
+	startServer(server, cert, key, serverWaitGroup)
 
 	// Intercept interrupt signals
 	c := make(chan os.Signal, 1)

cmd/utils/common-args.go

@@ -0,0 +1,59 @@
+package utils
+
+import (
+	"flag"
+	"fmt"
+	"strconv"
+)
+
+// Helpers
+
+// Forward declaration (kinda) of argParser.
+// 'argparse.argParser' is private, but we want to be able to pass instances
+// of it to functions, so we need to define an interface that includes the
+// functions we want to call from the parser.
+type argParser interface {
+	Lookup(name string) *flag.Flag
+	Usage(errFmt string, args ...any)
+}
+
+func GetFlagValue[T any](parser argParser, name string) T {
+	flagVal := parser.Lookup(name)
+	if flagVal == nil {
+		panic(fmt.Sprintf("flag '--%s' is undefined", name))
+	}
+
+	flagGetter, ok := flagVal.Value.(flag.Getter)
+	if !ok {
+		panic(fmt.Sprintf("flag '--%s' is invalid (does not implement flag.Getter)", name))
+	}
+
+	value, ok := flagGetter.Get().(T)
+	if !ok {
+		panic(fmt.Sprintf("flag '--%s' is invalid (cannot cast to appropriate type)", name))
+	}
+
+	return value
+}
+
+// Sets of flags shared between multiple commands/programs
+
+func WebServerFlags(parser argParser) (*flag.FlagSet, func()) {
+	f := flag.NewFlagSet("", flag.ContinueOnError)
+	port := f.String("port", "8080", "The port on which the server should be hosted")
+	cert := f.String("cert", "", "The path to the X.509 SSL certificate file to use in securely hosting the server")
+	key := f.String("key", "", "The path to the certificate's private key")
+
+	// Function to call for additional arg validation (may exit with 'Usage()')
+	validationFunc := func() {
+		p, err := strconv.Atoi(*port)
+		if err != nil || p < 0 || p > 65535 {
+			parser.Usage("Invalid port '%s'.", *port)
+		}
+		if (*cert == "") != (*key == "") {
+			parser.Usage("Both '--cert' and '--key' are needed to specify SSL configuration.")
+		}
+	}
+
+	return f, validationFunc
+}