Traefik_Control/backend/cmd/traefik-gui/main.go

package main

import (
	"context"
	"flag"
	"log"
	"net/http"
	"os"
	"os/signal"
	"strings"
	"syscall"
	"time"

	"github.com/traefik/traefik-gui/backend/internal/api"
	"github.com/traefik/traefik-gui/backend/internal/auth"
	"github.com/traefik/traefik-gui/backend/internal/config"
	"github.com/traefik/traefik-gui/backend/internal/database"
	"github.com/traefik/traefik-gui/backend/internal/traefik"
	"github.com/traefik/traefik-gui/backend/pkg/version"
)

func main() {
	var (
		addr           = flag.String("addr", ":8080", "HTTP server address")
		dbPath         = flag.String("db", "./data/traefik-gui.db", "SQLite database path")
		sessionSecret  = flag.String("session-secret", "", "Session signing secret (required)")
		corsOrigin     = flag.String("cors-origin", "http://localhost:5173", "CORS allowed origin")
		traefikAPIURL  = flag.String("traefik-api", "http://localhost:8080/api", "Traefik API base URL")
		configDir      = flag.String("config-dir", "./configs/dynamic", "File provider config directory")
		devMode        = flag.Bool("dev", false, "Development mode (serves frontend from Vite)")
		adminPassword  = flag.String("admin-password", os.Getenv("GUI_ADMIN_PASSWORD"), "Admin password (env GUI_ADMIN_PASSWORD)")
		trustedProxies = flag.String("trusted-proxies", os.Getenv("GUI_TRUSTED_PROXIES"), "Trusted proxy IPs for X-Forwarded-For (comma-separated)")
		showVersion    = flag.Bool("version", false, "Show version and exit")
	)

	flag.Parse()

	// Also allow env fallback for session secret
	if *sessionSecret == "" {
		*sessionSecret = os.Getenv("GUI_SESSION_SECRET")
	}
	if *sessionSecret == "" {
		*sessionSecret = os.Getenv("GUI_SESSION_SECRET")
	}

	if *showVersion {
		version.Print()
		os.Exit(0)
	}

	if *sessionSecret == "" {
		log.Fatal("SESSION_SECRET environment variable or -session-secret flag is required")
	}
	if len(*sessionSecret) < 32 {
		log.Fatal("session-secret must be at least 32 characters")
	}

	if *trustedProxies == "" {
		*trustedProxies = os.Getenv("GUI_TRUSTED_PROXIES")
	}
	if *trustedProxies == "" {
		*trustedProxies = "*"
	}
	trustedList := strings.Split(*trustedProxies, ",")

	cfg := &config.Config{
		Addr:           *addr,
		DBPath:         *dbPath,
		SessionSecret:  *sessionSecret,
		CORSOrigin:     *corsOrigin,
		TraefikAPIURL:  *traefikAPIURL,
		ConfigDir:      *configDir,
		DevMode:        *devMode,
		TrustedProxies: trustedList,
	}

	db, err := database.New(cfg.DBPath)
	if err != nil {
		log.Fatalf("Failed to connect to database: %v", err)
	}
	defer db.Close()

	if err := db.Migrate(); err != nil {
		log.Fatalf("Failed to migrate database: %v", err)
	}

	if err := db.EnsureAdminPasswordViaEnv(*adminPassword, *devMode); err != nil {
		log.Fatalf("Failed to configure admin password: %v", err)
	}

	var traefikAPI traefik.TraefikAPI
	// Try to create real Traefik client if URL is provided and not in dev mock mode
	// For now, dev mode uses mock; production can set TRAEFIK_API_URL to real Traefik
	if cfg.TraefikAPIURL != "" && !cfg.DevMode {
		if client, err := traefik.NewClient(cfg.TraefikAPIURL); err == nil {
			traefikAPI = client
			log.Println("Using real Traefik API client at", cfg.TraefikAPIURL)
		} else {
			log.Printf("Failed to create Traefik client for %q: %v, falling back to mock", cfg.TraefikAPIURL, err)
			traefikAPI = traefik.NewMockAPIClient()
		}
	} else {
		traefikAPI = traefik.NewMockAPIClient()
	}

	server := api.NewServer(cfg, db, traefikAPI)

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	// Start session cleanup background job (uses auth.SessionCleanupInterval)
	db.StartSessionCleanup(ctx, auth.SessionCleanupInterval)

	go func() {
		sigCh := make(chan os.Signal, 1)
		signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
		<-sigCh
		log.Println("Shutdown signal received")
		cancel()
	}()

	go func() {
		if err := server.Start(ctx); err != nil && err != http.ErrServerClosed {
			log.Printf("Server error: %v", err)
			cancel()
		}
	}()

	<-ctx.Done()

	shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer shutdownCancel()

	if err := server.Shutdown(shutdownCtx); err != nil {
		log.Printf("Graceful shutdown failed: %v", err)
	}

	log.Println("Server stopped")
}