Files
mtusi2026lab7/cmd/api/main.go
T

213 lines
7.7 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package main
import (
"context"
"errors"
"log/slog"
"net/http"
"os"
"os/signal"
"strings"
"sync/atomic"
"syscall"
"time"
"github.com/charawein/mtusi2026lab7/internal/config"
"github.com/charawein/mtusi2026lab7/internal/platform"
"github.com/charawein/mtusi2026lab7/internal/repository/postgres"
redisrepo "github.com/charawein/mtusi2026lab7/internal/repository/redis"
"github.com/charawein/mtusi2026lab7/internal/service"
"github.com/charawein/mtusi2026lab7/internal/telemetry"
"github.com/charawein/mtusi2026lab7/internal/tlsutil"
transporthttp "github.com/charawein/mtusi2026lab7/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)
}()
// Lab7: identity сервиса (сертификат) → OpenBao (cert auth) → роль БД, ACL Redis,
// ключ S3 этого сервиса. Без BAO_ADDR — режим файлов lab6 (локальная разработка).
bootCtx, bootCancel := context.WithTimeout(context.Background(), 90*time.Second)
plat, err := platform.New(bootCtx, cfg)
bootCancel()
if err != nil {
slog.Error("platform (tls/openbao)", "err", err)
os.Exit(1)
}
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
pool, err := plat.PG(ctx, 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 := plat.Redis(rctx)
rcancel()
if err != nil {
slog.Error("connect to redis", "err", err)
os.Exit(1)
}
defer redisClient.Close()
store, err := plat.S3()
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,
// Ошибки TLS-рукопожатия (чужой CA, запрещённая identity) — в лог без шума stdlib.
ErrorLog: slog.NewLogLogger(slog.Default().Handler(), slog.LevelWarn),
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()
// Lab7: бизнес-API только по mTLS — клиент обязан предъявить сертификат CA стенда
// с identity из API_ALLOWED_CLIENTS (по умолчанию lb). Plaintext-порта нет.
if cfg.TLSCertFile != "" {
kp, err := tlsutil.NewKeyPair(cfg.TLSCertFile, cfg.TLSKeyFile)
if err != nil {
slog.Error("api certificate", "err", err)
os.Exit(1)
}
tc, err := tlsutil.ServerMTLSRevocable(cfg.TLSCAFile, kp, tlsutil.NewRevoked(os.Getenv("REVOKED_SERIALS_FILE")),
strings.Split(cfg.AllowedClients, ",")...)
if err != nil {
slog.Error("api mtls config", "err", err)
os.Exit(1)
}
srv.TLSConfig = tc
}
// Health для docker healthcheck: только 127.0.0.1 внутри контейнера, только
// /health/live и /health/ready — обхода бизнес-API через него нет.
healthSrv := &http.Server{Addr: cfg.HealthAddr, Handler: transporthttp.NewHealthMux(pool, redisClient, &draining),
ReadHeaderTimeout: 2 * time.Second}
go func() {
if err := healthSrv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
slog.Warn("health listener failed", "err", err)
}
}()
defer healthSrv.Close()
errCh := make(chan error, 1)
go func() {
slog.Info("server starting", "addr", cfg.Addr(), "instance_id", cfg.InstanceID, "mtls", srv.TLSConfig != nil)
var err error
if srv.TLSConfig != nil {
err = srv.ListenAndServeTLS("", "")
} else {
err = srv.ListenAndServe()
}
if 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")
}