package main import ( "context" "errors" "fmt" "log/slog" "net" "net/http" "os" "os/signal" "syscall" "time" "xhchat/server/internal/account" "xhchat/server/internal/config" "xhchat/server/internal/contacts" "xhchat/server/internal/database" "xhchat/server/internal/delivery" "xhchat/server/internal/httpapi" "github.com/jackc/pgx/v5/pgxpool" "github.com/redis/go-redis/v9" ) func main() { if err := run(); err != nil { slog.Error("XHChat API stopped", "error", err) os.Exit(1) } } func run() error { cfg, err := config.Load() if err != nil { return err } ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM) defer stop() startup, cancel := context.WithTimeout(ctx, 30*time.Second) defer cancel() db, err := pgxpool.New(startup, cfg.DatabaseURL) if err != nil { return errors.New("invalid database configuration") } defer db.Close() options, err := redis.ParseURL(cfg.RedisURL) if err != nil { return errors.New("invalid Redis configuration") } cache := redis.NewClient(options) defer cache.Close() ready := func(ctx context.Context) error { if err := db.Ping(ctx); err != nil { return err } return cache.Ping(ctx).Err() } if err := ready(startup); err != nil { return fmt.Errorf("dependencies not ready (%T)", err) } if err := database.Migrate(startup, db); err != nil { return fmt.Errorf("database migration failed (%T)", err) } cancel() accounts := account.New(db, cfg.SessionTTL) envelopes := delivery.New(db) go func() { ticker := time.NewTicker(15 * time.Minute) defer ticker.Stop() for { select { case <-ctx.Done(): return case <-ticker.C: cleanup, cancel := context.WithTimeout(ctx, 10*time.Second) if err := accounts.Cleanup(cleanup); err != nil { slog.Warn("session cleanup failed") } if err := envelopes.Cleanup(cleanup, cfg.EnvelopeRetention); err != nil { slog.Warn("delivery cleanup failed") } cancel() } } }() server := &http.Server{ Addr: cfg.Addr, Handler: httpapi.New(accounts, contacts.New(db), envelopes, cache, cfg.Origins, ready), ReadHeaderTimeout: 5 * time.Second, ReadTimeout: 10 * time.Second, WriteTimeout: 15 * time.Second, IdleTimeout: 60 * time.Second, MaxHeaderBytes: 16 << 10, BaseContext: func(net.Listener) context.Context { return ctx }, } server.RegisterOnShutdown(stop) done := make(chan error, 1) go func() { done <- server.ListenAndServe() }() select { case err := <-done: return err case <-ctx.Done(): shutdown, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() return server.Shutdown(shutdown) } }