// Точка входа HTTP API и одноразового мигратора. // // Режимы: // // (по умолчанию) — API-реплика: ждёт Postgres/Redis, слушает порт, миграции НЕ применяет // (их гоняет отдельный сервис migrate, чтобы реплики не гонялись); // -migrate — применить встроенные SQL и выйти с кодом 0/1; // -healthcheck — локальный probe /health/ready для Docker HEALTHCHECK. // // SIGTERM: /health/ready → 503 (LB снимает реплику) и Shutdown до 10 секунд. package main import ( "context" "flag" "fmt" "io" "log" "net/http" "os" "os/signal" "syscall" "time" "mtusi2026lab3/internal/api" "mtusi2026lab3/internal/auth" "mtusi2026lab3/internal/config" "mtusi2026lab3/internal/session" "mtusi2026lab3/internal/store" ) func main() { healthcheck := flag.Bool("healthcheck", false, "probe local /health/ready and exit") migrateOnly := flag.Bool("migrate", false, "apply SQL migrations and exit") flag.Parse() if *healthcheck { os.Exit(runHealthcheck()) } cfg, err := config.Load() if err != nil { log.Fatalf("config: %v", err) } hasher, err := auth.NewHasher() if err != nil { log.Fatalf("password hasher: %v", err) } rootCtx, stop := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT) defer stop() st, err := waitPostgres(rootCtx, cfg.DatabaseURL, hasher, cfg.MaxConns) if err != nil { log.Fatalf("postgres: %v", err) } defer st.Close() if *migrateOnly || cfg.RunMigrations { if err := st.Migrate(rootCtx); err != nil { log.Fatalf("migrate: %v", err) } log.Printf("migrations applied") if *migrateOnly { return } } sessions, err := waitRedis(rootCtx, cfg.RedisURL, cfg.SessionTTL) if err != nil { log.Fatalf("redis: %v", err) } defer sessions.Close() srvAPI := api.New(st, sessions, cfg.InstanceID) httpServer := &http.Server{ Addr: cfg.Addr(), Handler: srvAPI.Handler(), ReadHeaderTimeout: 5 * time.Second, ReadTimeout: 15 * time.Second, WriteTimeout: 15 * time.Second, IdleTimeout: 60 * time.Second, } errCh := make(chan error, 1) go func() { log.Printf("listening on %s env=%s instance=%s session_ttl=%s db_max_conns=%d", cfg.Addr(), cfg.Env, cfg.InstanceID, cfg.SessionTTL, cfg.MaxConns) if err := httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed { errCh <- err } }() select { case err := <-errCh: log.Fatalf("listen: %v", err) case <-rootCtx.Done(): } log.Printf("shutting down instance=%s", cfg.InstanceID) srvAPI.BeginDrain() ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() if err := httpServer.Shutdown(ctx); err != nil { log.Printf("shutdown error: %v", err) os.Exit(1) } log.Printf("shutdown complete") } func waitPostgres(ctx context.Context, dsn string, hasher *auth.Hasher, maxConns int32) (*store.Store, error) { deadline := time.Now().Add(45 * time.Second) var last error for { st, err := store.Open(ctx, dsn, hasher, maxConns) if err == nil { return st, nil } last = err if ctx.Err() != nil || time.Now().After(deadline) { return nil, last } log.Printf("postgres not ready, retrying") select { case <-ctx.Done(): return nil, ctx.Err() case <-time.After(time.Second): } } } func waitRedis(ctx context.Context, redisURL string, ttl time.Duration) (*session.Store, error) { deadline := time.Now().Add(45 * time.Second) var last error for { st, err := session.Open(redisURL, ttl) if err == nil { return st, nil } last = err if ctx.Err() != nil || time.Now().After(deadline) { return nil, last } log.Printf("redis not ready, retrying") select { case <-ctx.Done(): return nil, ctx.Err() case <-time.After(time.Second): } } } func runHealthcheck() int { cfg, err := config.Load() if err != nil { return 1 } host := cfg.Host if host == "0.0.0.0" || host == "::" { host = "127.0.0.1" } client := &http.Client{Timeout: 2 * time.Second} resp, err := client.Get(fmt.Sprintf("http://%s:%d/health/ready", host, cfg.Port)) if err != nil { return 1 } defer resp.Body.Close() _, _ = io.Copy(io.Discard, resp.Body) if resp.StatusCode != http.StatusOK { return 1 } return 0 }