package main import ( "context" "errors" "fmt" "log/slog" "net/http" "os" "os/signal" "strconv" "strings" "sync/atomic" "syscall" "time" "mtusi-messenger/internal/api" "mtusi-messenger/internal/auth" "mtusi-messenger/internal/cache" "mtusi-messenger/internal/db" "mtusi-messenger/internal/store" ) func getenv(key, def string) string { if v := os.Getenv(key); v != "" { return v } return def } func getint(key string, def int) int { v := os.Getenv(key) if v == "" { return def } n, err := strconv.Atoi(v) if err != nil || n <= 0 { fmt.Fprintf(os.Stderr, "invalid %s\n", key) os.Exit(2) } return n } func secret(key string) (string, error) { if path := os.Getenv(key + "_FILE"); path != "" { b, err := os.ReadFile(path) if err != nil { return "", fmt.Errorf("read %s_FILE: %w", key, err) } return strings.TrimSpace(string(b)), nil } if v := os.Getenv(key); v != "" { return v, nil } return "", fmt.Errorf("%s or %s_FILE is required", key, key) } func main() { log := slog.New(slog.NewJSONHandler(os.Stdout, nil)) if err := run(log); err != nil { log.Error("fatal", "error", err.Error()) os.Exit(1) } } func openDB(ctx context.Context) (*store.Store, func(), error) { dsn, err := secret("DATABASE_URL") if err != nil { return nil, nil, err } pool, err := db.Open(ctx, dsn, db.PoolOptions{MaxConns: int32(getint("DB_MAX_CONNS", 10))}) if err != nil { return nil, nil, errors.New("database config is invalid") } return store.New(pool), pool.Close, nil } func run(log *slog.Logger) error { ctx := context.Background() if len(os.Args) > 1 && os.Args[1] == "migrate" { dsn, err := secret("DATABASE_URL") if err != nil { return err } pool, err := db.Open(ctx, dsn, db.PoolOptions{MaxConns: 2}) if err != nil { return errors.New("database config is invalid") } defer pool.Close() mctx, cancel := context.WithTimeout(ctx, 60*time.Second) defer cancel() return db.Migrate(mctx, pool, log) } st, closeDB, err := openDB(ctx) if err != nil { return err } defer closeDB() ttl := time.Duration(getint("SESSION_TTL_SECONDS", 3600)) * time.Second cacheMaxTTL := time.Duration(getint("SESSION_CACHE_MAX_TTL_SECONDS", 60)) * time.Second var sessCache auth.SessionCache switch mode := getenv("SESSION_STORE", "postgres"); mode { case "postgres": case "valkey", "redis": url, err := secret("CACHE_URL") if err != nil { return err } vk, err := cache.NewValkey(url) if err != nil { return errors.New("cache config is invalid") } defer vk.Close() sessCache = vk default: return fmt.Errorf("unknown SESSION_STORE %q (postgres|valkey|redis)", mode) } hasher := auth.NewHasher(getint("PASSWORD_HASH_CONCURRENCY", 4)) sessions := auth.NewSessions(st, sessCache, ttl, cacheMaxTTL, log) ready := &atomic.Bool{} ready.Store(true) host := getenv("APP_HOST", "0.0.0.0") port := getenv("APP_PORT", "8080") addr := host + ":" + port srv := api.NewServer(st, sessions, hasher, log, ready) httpSrv := &http.Server{ Addr: addr, Handler: srv.Handler(), ReadHeaderTimeout: 5 * time.Second, ReadTimeout: 15 * time.Second, WriteTimeout: 30 * time.Second, IdleTimeout: 60 * time.Second, } bgCtx, stopBg := context.WithCancel(ctx) defer stopBg() go func() { t := time.NewTicker(10 * time.Minute) defer t.Stop() for { select { case <-bgCtx.Done(): return case <-t.C: c, cancel := context.WithTimeout(bgCtx, 10*time.Second) if n, err := st.PurgeSessions(c, 24*time.Hour); err == nil && n > 0 { log.Info("expired sessions purged", "count", n) } cancel() } } }() errCh := make(chan error, 1) go func() { errCh <- httpSrv.ListenAndServe() }() log.Info("server started", "addr", addr, "pid", os.Getpid(), "session_store", getenv("SESSION_STORE", "postgres"), "session_ttl_s", int(ttl.Seconds())) stop := make(chan os.Signal, 1) signal.Notify(stop, syscall.SIGTERM, syscall.SIGINT) select { case err := <-errCh: if err != nil && !errors.Is(err, http.ErrServerClosed) { return err } case sig := <-stop: log.Info("shutdown signal received", "signal", sig.String()) ready.Store(false) sctx, cancel := context.WithTimeout(ctx, 8*time.Second) defer cancel() if err := httpSrv.Shutdown(sctx); err != nil { log.Warn("graceful shutdown exceeded budget, closing", "error", err.Error()) _ = httpSrv.Close() } log.Info("server stopped cleanly") } return nil }