// Command server starts the messenger API over PostgreSQL and Valkey. package main import ( "context" "expvar" "fmt" "log/slog" "net" "os" "os/signal" "runtime" "sync" "syscall" "time" "github.com/jackc/pgx/v5/pgxpool" "messenger/internal/app" "messenger/internal/attachment" "messenger/internal/chat" "messenger/internal/platform/config" "messenger/internal/platform/ident" "messenger/internal/platform/postgres" "messenger/internal/platform/s3store" "messenger/internal/platform/valkey" "messenger/internal/server" ) const keyCleanupEvery = 10 * time.Minute func main() { cfg, err := config.Load(os.LookupEnv) if err != nil { fmt.Fprintln(os.Stderr, "configuration error:", err) os.Exit(2) } alias := ident.NewAlias() log := cfg.NewLogger().With("instance", alias) ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT) defer stop() if err := run(ctx, log, cfg, alias); err != nil { log.Error("server stopped with error", "error", err.Error()) os.Exit(1) } } // run connects the dependencies before it listens, so the port accepts // connections only once they answer. func run(ctx context.Context, log *slog.Logger, cfg config.Config, alias string) error { pool, err := postgres.NewPool(ctx, cfg.DatabaseURL, cfg.DBMaxConns) if err != nil { return err } defer pool.Close() sessions, err := valkey.NewClient(ctx, cfg.SessionStoreURL) if err != nil { return err } defer sessions.Close() var blobs attachment.Blobs var reconciler *attachment.Reconciler if cfg.S3.Endpoint != "" { blobs, err = s3store.New(cfg.S3.Endpoint, cfg.S3.Region, cfg.S3.Bucket, cfg.S3.AccessKey, cfg.S3.SecretKey) if err != nil { return err } reconCfg, e := config.LoadS3(config.ReconcileS3(os.LookupEnv)) if e != nil { return e } reconBlobs, e := s3store.New(reconCfg.Endpoint, reconCfg.Region, reconCfg.Bucket, reconCfg.AccessKey, reconCfg.SecretKey) if e != nil { return e } reconciler, err = attachment.NewReconciler(pool, reconBlobs, time.Hour) if err != nil { return err } } ln, err := net.Listen("tcp", cfg.Addr()) if err != nil { return fmt.Errorf("listen on %s: %w", cfg.Addr(), err) } defer ln.Close() log.Info("starting", "env", cfg.Env, "addr", cfg.Addr(), "gomaxprocs", runtime.GOMAXPROCS(0), "db_max_conns", cfg.DBMaxConns, "drain_delay", cfg.DrainDelay.String(), "shutdown_timeout", cfg.ShutdownTimeout.String(), "session_ttl", cfg.SessionTTL.String(), "idempotency_ttl", cfg.IdempotencyTTL.String()) a := app.New(app.Deps{ Log: log, DB: pool, Sessions: sessions, SessionTTL: cfg.SessionTTL, MaxBodyBytes: cfg.MaxBodyBytes, InstanceID: alias, IdempotencyTTL: cfg.IdempotencyTTL, Blobs: blobs, MaxUploadBytes: cfg.S3.MaxBytes, MaxImagePixels: cfg.S3.MaxPixels, }) var debugLn net.Listener if cfg.DebugAddr != "" { if debugLn, err = net.Listen("tcp", cfg.DebugAddr); err != nil { return fmt.Errorf("listen on %s: %w", cfg.DebugAddr, err) } publishDebugVars(alias, pool) } ctx, cancel := context.WithCancel(ctx) var background sync.WaitGroup background.Go(func() { chat.RunKeyCleanup(ctx, log, a.Chats, keyCleanupEvery) }) if reconciler != nil { background.Go(func() { ticker := time.NewTicker(10 * time.Minute) defer ticker.Stop() for { select { case <-ctx.Done(): return case <-ticker.C: scan, cancel := context.WithTimeout(ctx, 2*time.Minute) stats, err := reconciler.Run(scan, true, false, nil) cancel() if err != nil { log.Warn("attachment cleanup incomplete", "error", err) } else { log.Info("attachment cleanup", "scanned_files", stats.ScannedFiles, "repaired", stats.Repaired) } } } }) } if debugLn != nil { background.Go(func() { if err := server.RunDebug(ctx, log, debugLn, expvar.Handler()); err != nil { log.Error("debug listener stopped", "error", err.Error()) } }) } err = server.Run(ctx, log, ln, a.Engine, a.Health, cfg.DrainDelay, cfg.ShutdownTimeout) cancel() background.Wait() return err } // publishDebugVars adds to expvar what the load tests read from a replica. func publishDebugVars(alias string, pool *pgxpool.Pool) { expvar.NewString("instance").Set(alias) expvar.Publish("gomaxprocs", expvar.Func(func() any { return runtime.GOMAXPROCS(0) })) expvar.Publish("pgxpool", expvar.Func(func() any { s := pool.Stat() return map[string]any{ "acquire_count": s.AcquireCount(), "acquire_duration_ms": s.AcquireDuration().Milliseconds(), "acquired_conns": s.AcquiredConns(), "idle_conns": s.IdleConns(), "total_conns": s.TotalConns(), "max_conns": s.MaxConns(), "empty_acquire_count": s.EmptyAcquireCount(), "empty_acquire_wait_ms": s.EmptyAcquireWaitTime().Milliseconds(), "canceled_acquire_count": s.CanceledAcquireCount(), "new_conns_count": s.NewConnsCount(), } })) }