DoGaMa-serv/cmd/dogama/main.go

// Command dogama runs the DoGaMa main application.
package main

import (
	"bytes"
	"context"
	"errors"
	"log/slog"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"

	catalogdata "git.zaynet.fr/DoGaMa/DoGaMa-serv/catalog"
	"git.zaynet.fr/DoGaMa/DoGaMa-serv/internal/agentclient"
	"git.zaynet.fr/DoGaMa/DoGaMa-serv/internal/auth"
	"git.zaynet.fr/DoGaMa/DoGaMa-serv/internal/backup"
	"git.zaynet.fr/DoGaMa/DoGaMa-serv/internal/catalog"
	"git.zaynet.fr/DoGaMa/DoGaMa-serv/internal/importexport"
	"git.zaynet.fr/DoGaMa/DoGaMa-serv/internal/instance"
	"git.zaynet.fr/DoGaMa/DoGaMa-serv/internal/persistence/sqlite"
	"git.zaynet.fr/DoGaMa/DoGaMa-serv/internal/web"
)

func main() {
	logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
	if err := run(logger); err != nil {
		logger.Error("application stopped", "event", "application.failed", "error", err)
		os.Exit(1)
	}
}

func run(logger *slog.Logger) error {
	listenAddress := environment("DOGAMA_LISTEN_ADDRESS", ":8080")
	databasePath := environment("DOGAMA_DATABASE_PATH", "dogama.db")

	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
	defer stop()
	db, err := sqlite.Open(ctx, databasePath)
	if err != nil {
		return err
	}
	defer db.Close()
	snapshots, err := catalog.LoadFS(catalogdata.Files, ".")
	if err != nil {
		return err
	}
	repository := sqlite.NewRepository(db)
	if err := repository.Sync(ctx, snapshots); err != nil {
		return err
	}
	logger.Info("local catalog synchronized", "event", "catalog.synchronized", "template_count", len(snapshots))
	var handler http.Handler
	var lifecycle *instance.LifecycleService
	var backupService *backup.Service
	importService, err := importexport.New(repository, environment("DOGAMA_IMPORTS_ROOT", "/var/lib/dogama/imports/staging"))
	if err != nil {
		return err
	}
	agentURL, tokenFile := os.Getenv("DOGAMA_AGENT_URL"), os.Getenv("DOGAMA_AGENT_TOKEN_FILE")
	if agentURL == "" && tokenFile == "" {
		logger.Warn("instance lifecycle disabled", "event", "lifecycle.disabled")
		handler, err = web.NewHandlerWithRepositoryAndImports(auth.New(db), repository, importService, logger)
	} else {
		if agentURL == "" || tokenFile == "" {
			return errors.New("DOGAMA_AGENT_URL and DOGAMA_AGENT_TOKEN_FILE must be configured together")
		}
		secret, readErr := os.ReadFile(tokenFile)
		if readErr != nil {
			return errors.New("read agent token file")
		}
		secret = bytes.TrimSuffix(bytes.TrimSuffix(secret, []byte("\n")), []byte("\r"))
		agent, clientErr := agentclient.New(agentURL, secret, &http.Client{Timeout: 15 * time.Minute})
		if clientErr != nil {
			return clientErr
		}
		lifecycle = instance.NewLifecycleService(repository, agent)
		backupService, err = backup.New(repository, agent, environment("DOGAMA_SERVERS_ROOT", "/srv/game-servers"), environment("DOGAMA_BACKUPS_ROOT", "/srv/game-backups"))
		if err != nil {
			return err
		}
		reconcileCtx, cancel := context.WithTimeout(ctx, 15*time.Second)
		if recoverErr := lifecycle.RecoverInterruptedOperations(reconcileCtx); recoverErr != nil {
			cancel()
			return recoverErr
		}
		if reconcileErr := lifecycle.ReconcileAll(reconcileCtx); reconcileErr != nil {
			logger.Warn("instance reconciliation incomplete", "event", "lifecycle.reconcile.failed")
		}
		cancel()
		handler, err = web.NewHandlerWithLifecycleAndBackup(auth.New(db), repository, agent, backupService, importService, logger)
	}
	if err != nil {
		return err
	}
	if lifecycle != nil {
		go reconcileInstances(ctx, lifecycle, logger)
	}
	if backupService != nil {
		go runBackupScheduler(ctx, backupService, logger)
	}
	go runImportCleanup(ctx, importService, logger)
	server := &http.Server{
		Addr:              listenAddress,
		Handler:           handler,
		ReadHeaderTimeout: 5 * time.Second,
		ReadTimeout:       15 * time.Second,
		WriteTimeout:      15 * time.Minute,
		IdleTimeout:       60 * time.Second,
	}
	errCh := make(chan error, 1)
	go func() {
		logger.Info("application listening", "event", "application.started", "address", listenAddress)
		errCh <- server.ListenAndServe()
	}()
	select {
	case err := <-errCh:
		if errors.Is(err, http.ErrServerClosed) {
			return nil
		}
		return err
	case <-ctx.Done():
		shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
		defer cancel()
		return server.Shutdown(shutdownCtx)
	}
}

func runImportCleanup(ctx context.Context, service *importexport.Service, logger *slog.Logger) {
	ticker := time.NewTicker(time.Hour)
	defer ticker.Stop()
	for {
		select {
		case <-ctx.Done():
			return
		case <-ticker.C:
			if err := service.CleanupExpired(ctx); err != nil {
				logger.Warn("expired import cleanup incomplete", "event", "import.cleanup.failed")
			}
		}
	}
}

func runBackupScheduler(ctx context.Context, service *backup.Service, logger *slog.Logger) {
	ticker := time.NewTicker(time.Minute)
	defer ticker.Stop()
	for {
		select {
		case <-ctx.Done():
			return
		case <-ticker.C:
			runCtx, cancel := context.WithTimeout(ctx, 30*time.Minute)
			if err := service.RunDue(runCtx); err != nil {
				logger.Warn("scheduled backup run incomplete", "event", "backup.scheduler.failed")
			}
			cancel()
		}
	}
}

func reconcileInstances(ctx context.Context, lifecycle *instance.LifecycleService, logger *slog.Logger) {
	ticker := time.NewTicker(time.Minute)
	defer ticker.Stop()
	for {
		select {
		case <-ctx.Done():
			return
		case <-ticker.C:
			reconcileCtx, cancel := context.WithTimeout(ctx, 15*time.Second)
			if err := lifecycle.ReconcileAll(reconcileCtx); err != nil {
				logger.Warn("periodic instance reconciliation incomplete", "event", "lifecycle.reconcile.failed")
			}
			cancel()
		}
	}
}

func environment(name, fallback string) string {
	if value := os.Getenv(name); value != "" {
		return value
	}
	return fallback
}