rewrite cli component with urfave/cli

cmd/q3rcon-proxy/main.go

@@ -1,75 +1,105 @@
 package main
 
 import (
+	"context"
 	"fmt"
 	"os"
 	"strings"
 	"time"
 
-	log "github.com/sirupsen/logrus"
-
 	"github.com/onyx-and-iris/q3rcon-proxy/pkg/udpproxy"
+	log "github.com/sirupsen/logrus"
+	"github.com/urfave/cli/v3"
 )
 
-func main() {
-	loglevel := os.Getenv("Q3RCON_LOGLEVEL")
-	if loglevel == "" {
-		loglevel = "info"
-	}
-	level, err := log.ParseLevel(loglevel)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Invalid log level: %s\n", loglevel)
-		os.Exit(1)
-	}
-	log.SetLevel(level)
-
-	proxyHost := os.Getenv("Q3RCON_PROXY_HOST")
-	if proxyHost == "" {
-		proxyHost = "0.0.0.0"
-	}
-
-	targetHost := os.Getenv("Q3RCON_TARGET_HOST")
-	if targetHost == "" {
-		targetHost = "127.0.0.1"
-	}
-
-	proxies := os.Getenv("Q3RCON_TARGET_PORTS")
-	if proxies == "" {
-		log.Fatal("env Q3RCON_TARGET_PORTS required")
-	}
-
-	sessionTimeout, err := getEnvInt("Q3RCON_SESSION_TIMEOUT")
-	if err != nil {
-		log.Fatalf("unable to parse Q3RCON_SESSION_TIMEOUT: %s", err.Error())
-	}
-	if sessionTimeout == 0 {
-		sessionTimeout = 20
-	}
-
-	for _, proxy := range strings.Split(proxies, ";") {
-		go start(proxyHost, targetHost, proxy, sessionTimeout)
-	}
-
-	<-make(chan struct{})
+type proxyConfig struct {
+	proxyHost      string
+	targetHost     string
+	portsMapping   []string
+	sessionTimeout int
 }
 
-func start(proxyHost, targetHost, ports string, sessionTimeout int) {
-	proxyPort, targetPort := func() (string, string) {
-		x := strings.Split(ports, ":")
-		return x[0], x[1]
-	}()
+func main() {
+	cmd := &cli.Command{
+		Name:  "q3rcon-proxy",
+		Usage: "A Quake 3 RCON proxy server",
+		Flags: []cli.Flag{
+			&cli.StringFlag{
+				Name:    "proxy-host",
+				Value:   "0.0.0.0",
+				Usage:   "Proxy host address",
+				Sources: cli.EnvVars("Q3RCON_PROXY_HOST"),
+			},
+			&cli.StringFlag{
+				Name:    "target-host",
+				Value:   "127.0.0.1",
+				Usage:   "Target host address",
+				Sources: cli.EnvVars("Q3RCON_TARGET_HOST"),
+			},
+			&cli.StringFlag{
+				Name:     "ports-mapping",
+				Usage:    "Proxy and target ports (proxy:target)",
+				Sources:  cli.EnvVars("Q3RCON_PORTS_MAPPING"),
+				Required: true,
+			},
+			&cli.IntFlag{
+				Name:    "session-timeout",
+				Value:   20,
+				Usage:   "Session timeout in minutes",
+				Sources: cli.EnvVars("Q3RCON_SESSION_TIMEOUT"),
+			},
+			&cli.StringFlag{
+				Name:    "loglevel",
+				Value:   "info",
+				Usage:   "Log level (trace, debug, info, warn, error, fatal, panic)",
+				Sources: cli.EnvVars("Q3RCON_LOGLEVEL"),
+			},
+		},
+		Action: func(_ context.Context, cmd *cli.Command) error {
+			errChan := make(chan error)
 
-	hostAddr := fmt.Sprintf("%s:%s", proxyHost, proxyPort)
-	proxyAddr := fmt.Sprintf("%s:%s", targetHost, targetPort)
+			for mapping := range strings.SplitSeq(cmd.String("ports-mapping"), ";") {
+				cfg := proxyConfig{
+					proxyHost:      cmd.String("proxy-host"),
+					targetHost:     cmd.String("target-host"),
+					portsMapping:   strings.Split(mapping, ":"),
+					sessionTimeout: cmd.Int("session-timeout"),
+				}
+
+				go initProxy(cfg, errChan)
+			}
+
+			// We don't expect to receive any errors from the channels, but if we do, we log and return early.
+			for err := range errChan {
+				if err != nil {
+					log.Errorf("Error: %v", err)
+					return err
+				}
+			}
+			return nil
+		},
+	}
+
+	if err := cmd.Run(context.Background(), os.Args); err != nil {
+		log.Fatal(err)
+	}
+}
+
+func initProxy(cfg proxyConfig, errChan chan error) {
+	proxyPort, targetPort := cfg.portsMapping[0], cfg.portsMapping[1]
+
+	hostAddr := fmt.Sprintf("%s:%s", cfg.proxyHost, proxyPort)
+	proxyAddr := fmt.Sprintf("%s:%s", cfg.targetHost, targetPort)
 
 	c, err := udpproxy.New(
 		hostAddr, proxyAddr,
-		udpproxy.WithSessionTimeout(time.Duration(sessionTimeout)*time.Minute))
+		udpproxy.WithSessionTimeout(time.Duration(cfg.sessionTimeout)*time.Minute))
 	if err != nil {
-		log.Fatal(err)
+		errChan <- fmt.Errorf("failed to create proxy: %w", err)
+		return
 	}
 
 	log.Printf("q3rcon-proxy initialized: [proxy] (%s) [target] (%s)", hostAddr, proxyAddr)
 
-	log.Fatal(c.ListenAndServe())
+	errChan <- c.ListenAndServe()
 }