Files
mtusi2026lab2/cmd/server/main.go
T
Mlvn 096c53ecdb
Skeleton contracts / contracts (pull_request) Canceled after 0s
Перенести мессенджер на PostgreSQL и сессии Redis.
Сообщения должны переживать рестарт, а доступ идти через Bearer, а не X-User-Id. Трек 2 сравнивает план keyset-запроса и сверяет pg_restore.
2026-10-14 22:47:08 +03:00

159 lines
4.0 KiB
Go

// Точка входа HTTP API.
//
// Процесс поднимает пул PostgreSQL, применяет миграции, проверяет Redis и только потом слушает порт.
// SIGTERM переводит /health/ready в 503 и даёт текущим запросам до 10 секунд на завершение.
package main
import (
"context"
"flag"
"fmt"
"io"
"log"
"net/http"
"os"
"os/signal"
"syscall"
"time"
"mtusi2026lab2/internal/api"
"mtusi2026lab2/internal/auth"
"mtusi2026lab2/internal/config"
"mtusi2026lab2/internal/session"
"mtusi2026lab2/internal/store"
)
func main() {
healthcheck := flag.Bool("healthcheck", false, "probe local /health/ready 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()
// docker compose restart поднимает API одновременно с Postgres.
// Процесс не выходит сразу: иначе контейнер останется мёртвым, а тест сохранности
// не дождётся /health/ready. Ждём хранилища ограниченное время.
st, err := waitPostgres(rootCtx, cfg.DatabaseURL, hasher)
if err != nil {
log.Fatalf("postgres: %v", err)
}
defer st.Close()
if err := st.Migrate(rootCtx); err != nil {
log.Fatalf("migrate: %v", err)
}
sessions, err := waitRedis(rootCtx, cfg.RedisURL, cfg.SessionTTL)
if err != nil {
log.Fatalf("redis: %v", err)
}
defer sessions.Close()
srvAPI := api.New(st, sessions)
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 session_ttl=%s", cfg.Addr(), cfg.Env, cfg.SessionTTL)
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")
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) (*store.Store, error) {
deadline := time.Now().Add(45 * time.Second)
var last error
for {
st, err := store.Open(ctx, dsn, hasher)
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
}