forked from mtusi2026/mtusi2026lab5
347 lines
10 KiB
Go
347 lines
10 KiB
Go
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
|
||
}
|