oubliette/cmd/oubliette/main.go

package main

import (
	"context"
	"errors"
	"flag"
	"fmt"
	"log/slog"
	"net/http"
	"os"
	"os/signal"
	"sync"
	"syscall"
	"time"

	"git.t-juice.club/torjus/oubliette/internal/config"
	"git.t-juice.club/torjus/oubliette/internal/metrics"
	"git.t-juice.club/torjus/oubliette/internal/server"
	"git.t-juice.club/torjus/oubliette/internal/storage"
	"git.t-juice.club/torjus/oubliette/internal/web"
)

const Version = "0.18.0"

func main() {
	if err := run(); err != nil {
		slog.Error("fatal error", "err", err)
		os.Exit(1)
	}
}

func run() error {
	configPath := flag.String("config", "oubliette.toml", "path to config file")
	flag.Parse()

	cfg, err := config.Load(*configPath)
	if err != nil {
		return fmt.Errorf("load config: %w", err)
	}

	level := new(slog.LevelVar)
	switch cfg.LogLevel {
	case "debug":
		level.Set(slog.LevelDebug)
	case "warn":
		level.Set(slog.LevelWarn)
	case "error":
		level.Set(slog.LevelError)
	default:
		level.Set(slog.LevelInfo)
	}

	var handler slog.Handler
	opts := &slog.HandlerOptions{Level: level}
	if cfg.LogFormat == "json" {
		handler = slog.NewJSONHandler(os.Stderr, opts)
	} else {
		handler = slog.NewTextHandler(os.Stderr, opts)
	}
	logger := slog.New(handler)
	slog.SetDefault(logger)

	store, err := storage.NewSQLiteStore(cfg.Storage.DBPath)
	if err != nil {
		return fmt.Errorf("open database: %w", err)
	}
	defer store.Close()

	// Clean up sessions left active by a previous unclean shutdown.
	if n, err := store.CloseActiveSessions(context.Background(), time.Now()); err != nil {
		return fmt.Errorf("close stale sessions: %w", err)
	} else if n > 0 {
		logger.Info("closed stale sessions from previous run", "count", n)
	}

	ctx, cancel := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
	defer cancel()

	m := metrics.New(Version)
	instrumentedStore := storage.NewInstrumentedStore(store, m.StorageQueryDuration, m.StorageQueryErrors)
	m.RegisterStoreCollector(instrumentedStore)

	go storage.RunRetention(ctx, instrumentedStore, cfg.Storage.RetentionDays, cfg.Storage.RetentionIntervalDuration, logger)

	srv, err := server.New(*cfg, instrumentedStore, logger, m)
	if err != nil {
		return fmt.Errorf("create server: %w", err)
	}

	var wg sync.WaitGroup

	// Start web server if enabled.
	if cfg.Web.Enabled {
		var metricsHandler http.Handler
		if *cfg.Web.MetricsEnabled {
			metricsHandler = m.Handler()
		}

		webHandler, err := web.NewServer(instrumentedStore, logger.With("component", "web"), metricsHandler, cfg.Web.MetricsToken)
		if err != nil {
			return fmt.Errorf("create web server: %w", err)
		}

		httpServer := &http.Server{
			Addr:              cfg.Web.ListenAddr,
			Handler:           webHandler,
			ReadHeaderTimeout: 10 * time.Second,
		}

		wg.Go(func() {
			logger.Info("web server listening", "addr", cfg.Web.ListenAddr)
			if err := httpServer.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
				logger.Error("web server error", "err", err)
			}
		})

		// Graceful shutdown on context cancellation.
		go func() {
			<-ctx.Done()
			if err := httpServer.Shutdown(context.Background()); err != nil {
				logger.Error("web server shutdown error", "err", err)
			}
		}()
	}

	if err := srv.ListenAndServe(ctx); err != nil {
		return fmt.Errorf("server: %w", err)
	}

	wg.Wait()
	logger.Info("server stopped")
	return nil
}