RC-2 0.5.2

cmd/edgeguard/main.go

@@ -0,0 +1,121 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"github.com/example/sessionguard/internal/edgeguard"
+)
+
+var version = "dev"
+
+func main() {
+	configPath := flag.String("config", "/etc/sessionguard-edgeguard/edgeguard.json", "path to EdgeGuard JSON configuration")
+	checkConfig := flag.Bool("check-config", false, "validate configuration and exit")
+	showVersion := flag.Bool("version", false, "print version and exit")
+	flag.Parse()
+
+	if *showVersion {
+		fmt.Printf("sessionguard-edgeguard %s\n", version)
+		return
+	}
+
+	logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo}))
+	cfg, err := edgeguard.LoadRuntimeConfig(*configPath)
+	if err != nil {
+		logger.Error("load configuration", "error", err)
+		os.Exit(2)
+	}
+	if *checkConfig {
+		fmt.Printf("configuration OK (%s)\n", cfg.Fingerprint()[:12])
+		return
+	}
+
+	guard := edgeguard.NewGuard(cfg, logger)
+	handler := edgeguard.NewHTTPServer(guard, logger).Handler()
+	server := &http.Server{
+		Addr:              cfg.Listen,
+		Handler:           handler,
+		ReadHeaderTimeout: 5 * time.Second,
+		IdleTimeout:       30 * time.Second,
+		MaxHeaderBytes:    16 << 10,
+	}
+
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+	defer stop()
+
+	go reloadLoop(ctx, *configPath, guard, logger)
+	go cleanupLoop(ctx, guard)
+	go persistenceLoop(ctx, guard)
+
+	go func() {
+		<-ctx.Done()
+		guard.FlushState()
+		shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+		_ = server.Shutdown(shutdownCtx)
+	}()
+
+	logger.Info("SessionGuard EdgeGuard started", "version", version, "listen", cfg.Listen)
+	if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+		logger.Error("edgeguard server stopped", "error", err)
+		os.Exit(1)
+	}
+}
+
+func reloadLoop(ctx context.Context, path string, guard *edgeguard.Guard, logger *slog.Logger) {
+	interval := guard.Config().ReloadInterval()
+	t := time.NewTicker(interval)
+	defer t.Stop()
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-t.C:
+			cfg, err := edgeguard.LoadRuntimeConfig(path)
+			if err != nil {
+				logger.Error("reload edgeguard configuration", "error", err)
+				continue
+			}
+			guard.ReplaceConfig(cfg)
+			newInterval := cfg.ReloadInterval()
+			if newInterval != interval {
+				interval = newInterval
+				t.Reset(interval)
+			}
+		}
+	}
+}
+
+func cleanupLoop(ctx context.Context, guard *edgeguard.Guard) {
+	t := time.NewTicker(time.Minute)
+	defer t.Stop()
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case now := <-t.C:
+			guard.Cleanup(now)
+		}
+	}
+}
+
+func persistenceLoop(ctx context.Context, guard *edgeguard.Guard) {
+	t := time.NewTicker(5 * time.Second)
+	defer t.Stop()
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-t.C:
+			guard.FlushState()
+		}
+	}
+}