package main import ( "context" "errors" "log/slog" "net/http" "os" "os/signal" "sync/atomic" "syscall" "time" "github.com/charawein/mtusi2026lab6/internal/config" "github.com/charawein/mtusi2026lab6/internal/repository/postgres" redisrepo "github.com/charawein/mtusi2026lab6/internal/repository/redis" "github.com/charawein/mtusi2026lab6/internal/service" "github.com/charawein/mtusi2026lab6/internal/storage" "github.com/charawein/mtusi2026lab6/internal/telemetry" transporthttp "github.com/charawein/mtusi2026lab6/internal/transport/http" ) func main() { cfg := config.Load() slog.SetDefault(slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: cfg.LogLevel}))) // OTLP → Collector: трассы, метрики, логи (service.name=messenger-api, // service.instance.id = X-Instance-Id реплики). Логи дублируются JSON в stdout. shutdownTelemetry, err := telemetry.Setup(context.Background(), "messenger-api", cfg.InstanceID, cfg.LogLevel) if err != nil { slog.Error("telemetry setup", "err", err) os.Exit(1) } defer func() { ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() _ = shutdownTelemetry(ctx) }() if cfg.DatabaseURL == "" { slog.Error("DATABASE_URL_FILE is not set or empty") os.Exit(1) } if cfg.CacheURL == "" { slog.Error("CACHE_URL_FILE is not set or empty") os.Exit(1) } ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) pool, err := postgres.NewPool(ctx, cfg.DatabaseURL, cfg.DBPoolMax) cancel() if err != nil { slog.Error("connect to postgres", "err", err) os.Exit(1) } defer pool.Close() rctx, rcancel := context.WithTimeout(context.Background(), 10*time.Second) redisClient, err := redisrepo.NewClient(rctx, cfg.CacheURL) rcancel() if err != nil { slog.Error("connect to redis", "err", err) os.Exit(1) } defer redisClient.Close() if cfg.S3AccessKey == "" || cfg.S3SecretKey == "" { slog.Error("S3_ACCESS_KEY_ID_FILE / S3_SECRET_ACCESS_KEY_FILE are not set or empty") os.Exit(1) } store, err := storage.NewS3(cfg.S3Endpoint, cfg.S3Region, cfg.S3Bucket, cfg.S3AccessKey, cfg.S3SecretKey) if err != nil { slog.Error("s3 client", "err", err) os.Exit(1) } userRepo := postgres.NewUserRepository(pool) chatRepo := postgres.NewChatRepository(pool) msgRepo := postgres.NewMessageRepository(pool) sessRepo := redisrepo.NewSessionRepository(redisClient) userSvc := service.NewUserService(userRepo) chatSvc := service.NewChatService(chatRepo, userRepo) var msgCache *redisrepo.MessageCache if cfg.CacheEnabled { msgCache = redisrepo.NewMessageCache(redisClient, cfg.CacheInvalidation) } msgSvc := service.NewMessageService(msgRepo, chatRepo, msgCache, cfg.IdempotencyTTL) attSvc := service.NewAttachmentService(postgres.NewAttachmentRepository(pool), chatRepo, store, cfg.MaxUploadBytes, cfg.MaxImagePixels, cfg.PipelineVersion, cfg.JobMaxAttempts) authSvc := service.NewAuthService(userRepo, sessRepo, cfg.SessionTTL()) // draining выставляется по SIGTERM: /health/ready начинает отвечать 503, // LB исключает реплику, и только затем закрывается listener. var draining atomic.Bool router := transporthttp.NewRouter(userSvc, chatSvc, msgSvc, attSvc, authSvc, pool, redisClient, cfg.InstanceID, &draining) // Очистка просроченных ключей идемпотентности. Запрос идемпотентен, // поэтому параллельный запуск на всех репликах безопасен. cleanupCtx, cleanupStop := context.WithCancel(context.Background()) defer cleanupStop() go func() { t := time.NewTicker(time.Hour) defer t.Stop() for { select { case <-cleanupCtx.Done(): return case <-t.C: ctx, cancel := context.WithTimeout(cleanupCtx, 30*time.Second) if n, err := msgRepo.DeleteExpiredKeys(ctx, cfg.IdempotencyTTL); err != nil { slog.Warn("idempotency cleanup failed", "err", err) } else if n > 0 { slog.Info("idempotency keys expired", "deleted", n) } cancel() } } }() srv := &http.Server{ Addr: cfg.Addr(), Handler: router, ReadHeaderTimeout: 5 * time.Second, // Загрузка до 10 MiB должна уложиться в ReadTimeout; медленный клиент // дольше не держит соединение и память. ReadTimeout: 30 * time.Second, WriteTimeout: 35 * time.Second, IdleTimeout: 60 * time.Second, } // Внутренний endpoint метрик для экспериментов (трек 1). Порт не публикуется // и не проксируется LB: читается только через docker exec внутри контейнера. internalSrv := &http.Server{ Addr: cfg.InternalAddr, Handler: transporthttp.NewInternalStatsHandler(pool, cfg), ReadHeaderTimeout: 2 * time.Second, } go func() { if err := internalSrv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) { slog.Warn("internal stats server failed", "err", err) } }() defer internalSrv.Close() errCh := make(chan error, 1) go func() { slog.Info("server starting", "addr", cfg.Addr(), "instance_id", cfg.InstanceID) if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) { errCh <- err } }() sigCtx, stop := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT) defer stop() select { case err := <-errCh: slog.Error("server failed", "err", err) os.Exit(1) case <-sigCtx.Done(): slog.Info("shutdown signal received, draining", "delay", cfg.DrainDelay) } // Перестаём быть ready и даём LB время заметить это (inter*fall у HAProxy), // продолжая обслуживать уже направленные к нам запросы. draining.Store(true) time.Sleep(cfg.DrainDelay) shutdownCtx, cancel := context.WithTimeout(context.Background(), cfg.ShutdownTimeout) defer cancel() if err := srv.Shutdown(shutdownCtx); err != nil { slog.Error("graceful shutdown failed", "err", err) os.Exit(1) } slog.Info("server stopped") }