Files
mtusi2026lab5/src/cmd/server/main.go
T
2026-11-10 13:55:56 +03:00

347 lines
10 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"
"encoding/json"
"errors"
"flag"
"log/slog"
"mtusi-messenger/internal/model"
"net/http"
"os"
"os/signal"
"strconv"
"sync/atomic"
"syscall"
"time"
"mtusi-messenger/internal/api"
"mtusi-messenger/internal/store"
"mtusi-messenger/internal/worker"
"github.com/google/uuid"
"github.com/jackc/pgx/v5/pgxpool"
"github.com/redis/go-redis/v9"
)
func getenv(key, def string) string {
if v := os.Getenv(key); v != "" {
return v
}
return def
}
func getenvDurationSeconds(key string, def time.Duration) time.Duration {
if v := os.Getenv(key); v != "" {
if n, err := strconv.Atoi(v); err == nil && n >= 0 {
return time.Duration(n) * time.Second
}
}
return def
}
func ensureBucketWithRetry(ctx context.Context, c *store.S3Client, log *slog.Logger) error {
const attempts = 30
const delay = 2 * time.Second
var lastErr error
for i := 1; i <= attempts; i++ {
if ctx.Err() != nil {
return ctx.Err()
}
lastErr = c.EnsureBucket(ctx)
if lastErr == nil {
return nil
}
log.Warn("s3 bootstrap retry", "attempt", i, "max_attempts", attempts, "error", lastErr.Error())
timer := time.NewTimer(delay)
select {
case <-ctx.Done():
timer.Stop()
return ctx.Err()
case <-timer.C:
}
}
return lastErr
}
// runOutboxRelay — публикация намерений из outbox в брокер (лаба 5).
// Закрывает разрыв COMMIT -> publish: всё, что закоммичено, но не опубликовано
// (в т.ч. после краха процесса), будет опубликовано здесь. Повторная публикация
// безопасна: воркер идемпотентен через claim-гард.
func runOutboxRelay(ctx context.Context, st *store.Store, q *store.Queue, log *slog.Logger) {
t := time.NewTicker(500 * time.Millisecond)
defer t.Stop()
for {
select {
case <-ctx.Done():
return
case <-t.C:
}
for {
msgs, err := st.FetchUnpublishedOutbox(ctx, 50)
if err != nil {
log.Warn("outbox fetch", "error", err.Error())
break
}
if len(msgs) == 0 {
break
}
published := 0
for _, m := range msgs {
var jm model.JobMessage
if err := json.Unmarshal(m.Payload, &jm); err != nil {
log.Error("outbox payload malformed", "error", err.Error())
_ = st.MarkOutboxPublished(ctx, m.ID)
continue
}
if _, err := q.Publish(ctx, jm); err != nil {
log.Warn("outbox publish", "error", err.Error())
break
}
_ = st.MarkOutboxPublished(ctx, m.ID)
published++
}
if published > 0 {
log.Info("outbox relay published", "count", published)
}
if published < len(msgs) {
break // брокер недоступен: повторим на следующем тике
}
}
}
}
func main() {
migrateOnly := flag.Bool("migrate-only", false, "Run migrations and exit")
reconcileMode := flag.Bool("reconcile", false, "Reconcile orphaned S3 objects and exit")
workerMode := flag.Bool("worker", false, "Run attachment processing worker")
flag.Parse()
log := slog.New(slog.NewJSONHandler(os.Stdout, nil))
host := getenv("APP_HOST", "0.0.0.0")
port := getenv("APP_PORT", "8080")
addr := host + ":" + port
databaseURL := getenv("DATABASE_URL", "postgres://messenger:messenger_password@localhost:5432/messenger?sslmode=disable")
redisURL := getenv("REDIS_URL", "redis://localhost:6379/0")
sessionStore := getenv("SESSION_STORE", "postgres")
sessionTTL := getenv("SESSION_TTL_SECONDS", "3600")
cacheMode := getenv("CACHE_MODE", "versioned")
s3Endpoint := getenv("S3_ENDPOINT", "localhost:9000")
s3AccessKey := getenv("S3_ACCESS_KEY", "")
s3SecretKey := getenv("S3_SECRET_KEY", "")
s3Bucket := getenv("S3_BUCKET", "messenger")
s3UseSSL := getenv("S3_USE_SSL", "false") == "true"
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
// PostgreSQL
poolConfig, err := pgxpool.ParseConfig(databaseURL)
if err != nil {
log.Error("parse database URL", "error", err.Error())
os.Exit(1)
}
poolConfig.MaxConns = 10
poolConfig.MinConns = 2
poolConfig.ConnConfig.ConnectTimeout = 5 * time.Second
poolConfig.MaxConnLifetime = 30 * time.Minute
poolConfig.MaxConnIdleTime = 5 * time.Minute
poolConfig.HealthCheckPeriod = 10 * time.Second
poolConfig.ConnConfig.RuntimeParams["statement_timeout"] = "15000"
pool, err := pgxpool.NewWithConfig(ctx, poolConfig)
if err != nil {
log.Error("connect to postgres", "error", err.Error())
os.Exit(1)
}
defer pool.Close()
if err := pool.Ping(ctx); err != nil {
log.Error("ping postgres", "error", err.Error())
os.Exit(1)
}
log.Info("postgres connected")
// Миграции — только однократный контейнер.
if *migrateOnly {
log.Info("migrate-only mode: applying migrations")
if err := store.RunMigrations(ctx, pool, log); err != nil {
log.Error("migrations failed", "error", err.Error())
os.Exit(1)
}
log.Info("migrations applied successfully, exiting")
os.Exit(0)
}
// Redis: нужен и кэшу, и брокеру. Создаём всегда; деградация кэша не
// отключает очередь (go-redis ленив, реконнект внутри клиента).
rdb := redis.NewClient(mustParseRedisURL(redisURL, log))
if err := rdb.Ping(ctx).Err(); err != nil {
log.Warn("redis ping failed at startup", "error", err.Error())
} else {
log.Info("redis connected")
}
defer rdb.Close()
var cacheRdb *redis.Client
if sessionStore == "redis" {
cacheRdb = rdb
}
// S3
var s3client *store.S3Client
if s3Endpoint != "" && s3AccessKey != "" && s3SecretKey != "" {
s3client, err = store.NewS3Client(s3Endpoint, s3AccessKey, s3SecretKey, s3Bucket, s3UseSSL, log)
if err != nil {
log.Error("init s3 client", "error", err.Error())
os.Exit(1)
}
} else {
log.Warn("S3 credentials not set; attachments unavailable")
}
// Reconcile — однократный режим.
if *reconcileMode {
if s3client == nil {
log.Error("reconcile requires S3 credentials")
os.Exit(1)
}
grace := getenvDurationSeconds("RECONCILE_GRACE_PERIOD_SECONDS", 3600*time.Second)
log.Info("reconcile mode: sweeping orphaned objects", "grace_seconds", int(grace.Seconds()))
recCtx, recCancel := context.WithTimeout(ctx, 120*time.Second)
defer recCancel()
if err := store.RunReconcile(recCtx, pool, s3client, grace, log); err != nil {
log.Error("reconcile failed", "error", err.Error())
os.Exit(1)
}
log.Info("reconcile completed successfully, exiting")
os.Exit(0)
}
st := store.New(pool, cacheRdb, s3client, sessionTTL, cacheMode, log)
queue := store.NewQueue(rdb, log)
// ─────────── WORKER MODE ───────────
if *workerMode {
if s3client == nil {
log.Error("worker requires S3 credentials")
os.Exit(1)
}
// LAB 5: воркер не должен умирать из-за временной недоступности S3 на старте.
// Одна быстрая попытка bootstrap; при неудаче продолжаем — каждое задание
// само получит transient-ошибку и уйдёт в retry с backoff.
pingCtx, pingCancel := context.WithTimeout(ctx, 5*time.Second)
err := s3client.EnsureBucket(pingCtx)
pingCancel()
if err != nil {
log.Warn("s3 not ready at worker start; continuing, jobs will retry", "error", err.Error())
} else {
log.Info("s3 ready", "endpoint", s3Endpoint, "bucket", s3Bucket)
}
w := worker.New(st, queue, log)
stop := make(chan os.Signal, 1)
signal.Notify(stop, syscall.SIGTERM, syscall.SIGINT)
errCh := make(chan error, 1)
go func() { errCh <- w.Run(ctx) }()
select {
case err := <-errCh:
if err != nil {
log.Error("worker failed", "error", err.Error())
os.Exit(1)
}
case sig := <-stop:
log.Info("worker shutdown signal", "signal", sig.String())
cancel()
<-errCh
}
log.Info("worker stopped cleanly")
return
}
// ─────────── API MODE ───────────
log.Info("migrations already applied by migrate service, starting server")
if s3client != nil {
bootCtx, bootCancel := context.WithTimeout(ctx, 90*time.Second)
err = ensureBucketWithRetry(bootCtx, s3client, log)
bootCancel()
if err != nil {
log.Error("ensure s3 bucket", "error", err.Error())
os.Exit(1)
}
log.Info("s3 ready", "endpoint", s3Endpoint, "bucket", s3Bucket)
}
// Outbox relay: публикация намерений в брокер.
go runOutboxRelay(ctx, st, queue, log)
ready := &atomic.Bool{}
ready.Store(true)
var instanceID string
if v := getenv("INSTANCE_ID", ""); v != "" {
instanceID = v
} else {
hostname, _ := os.Hostname()
prefix := hostname
if len(prefix) > 12 {
prefix = prefix[:12]
}
if prefix == "" {
prefix = "local"
}
instanceID = prefix + "-" + uuid.NewString()[:8]
}
log.Info("instance identity", "instance_id", instanceID)
srv := api.NewServer(st, log, ready, instanceID)
httpSrv := &http.Server{
Addr: addr,
Handler: srv.Handler(),
ReadHeaderTimeout: 5 * time.Second,
ReadTimeout: 30 * time.Second,
WriteTimeout: 60 * time.Second,
IdleTimeout: 60 * time.Second,
}
errCh := make(chan error, 1)
go func() { errCh <- httpSrv.ListenAndServe() }()
log.Info("server started", "addr", addr, "pid", os.Getpid())
stop := make(chan os.Signal, 1)
signal.Notify(stop, syscall.SIGTERM, syscall.SIGINT)
select {
case err := <-errCh:
if err != nil && !errors.Is(err, http.ErrServerClosed) {
log.Error("server failed", "error", err.Error())
os.Exit(1)
}
case sig := <-stop:
log.Info("shutdown signal received", "signal", sig.String())
ready.Store(false)
sctx, scancel := context.WithTimeout(context.Background(), 8*time.Second)
defer scancel()
if err := httpSrv.Shutdown(sctx); err != nil {
log.Warn("graceful shutdown exceeded budget, closing", "error", err.Error())
_ = httpSrv.Close()
}
cancel()
log.Info("server stopped cleanly")
}
}
func mustParseRedisURL(redisURL string, log *slog.Logger) *redis.Options {
opts, err := redis.ParseURL(redisURL)
if err != nil {
log.Error("parse redis URL", "error", err.Error())
os.Exit(1)
}
return opts
}