Files
mtusi2026lab4/cmd/api/main.go
T
2026-11-05 13:52:11 +03:00

134 lines
3.5 KiB
Go

package main
import (
"context"
"log"
"net/http"
"os"
"os/signal"
"sync/atomic"
"syscall"
"time"
"mtusi2026/internal/blobstore"
"mtusi2026/internal/cache"
"mtusi2026/internal/config"
"mtusi2026/internal/db"
"mtusi2026/internal/httpapi"
"mtusi2026/internal/sessionstore"
"mtusi2026/internal/store"
"github.com/redis/go-redis/v9"
)
func main() {
ctx := context.Background()
dbCfg := db.Config{
DSN: config.GetEnv("DATABASE_URL", ""),
MaxConns: int32(config.ParseIntEnv("DB_MAX_CONNS", 10)),
MinConns: int32(config.ParseIntEnv("DB_MIN_CONNS", 2)),
ConnMaxLifetime: config.ParseDurationSecondsEnv("DB_CONN_MAX_LIFETIME_SECONDS", 3600),
ConnTimeout: config.ParseDurationSecondsEnv("DB_CONN_TIMEOUT_SECONDS", 5),
}
if dbCfg.DSN == "" {
log.Fatal("DATABASE_URL is required")
}
pool, err := db.Connect(ctx, dbCfg)
if err != nil {
log.Fatalf("db connect: %v", err)
}
defer pool.Close()
maxMessages := int64(config.ParseIntEnv("MAX_MESSAGES", 10000))
maxConcurrent := config.ParseIntEnv("MAX_CONCURRENT_REQUESTS", 50)
limiter := store.NewLimiter(maxMessages, maxConcurrent)
cacheURL := config.GetEnv("CACHE_URL", "")
if cacheURL == "" {
log.Fatal("CACHE_URL is required")
}
redisOpts, err := redis.ParseURL(cacheURL)
if err != nil {
log.Fatalf("redis config: %v", err)
}
redisClient := redis.NewClient(redisOpts)
defer redisClient.Close()
if err := redisClient.Ping(ctx).Err(); err != nil {
log.Fatalf("redis connect: %v", err)
}
sessionStore := sessionstore.NewRedis(redisClient)
chatCacheTTL := config.ParseDurationSecondsEnv("CHAT_CACHE_TTL_SECONDS", 30)
chatCache := cache.New(redisClient, chatCacheTTL)
s := store.New(pool, limiter)
instanceID := config.GetEnv("INSTANCE_ID", "")
if instanceID == "" {
instanceID, _ = os.Hostname()
}
var draining atomic.Bool
var blobs blobstore.Store
if ep := config.GetEnv("S3_ENDPOINT", ""); ep != "" {
b, err := blobstore.NewS3(ctx, blobstore.S3Config{
Endpoint: ep,
Region: config.GetEnv("S3_REGION", "us-east-1"),
Bucket: config.GetEnv("S3_BUCKET", ""),
AccessKey: config.GetEnv("S3_ACCESS_KEY", ""),
SecretKey: config.GetEnv("S3_SECRET_KEY", ""),
})
if err != nil {
log.Fatalf("s3 config: %v", err)
}
blobs = b
}
mux := httpapi.NewRouterWithCache(s, pool, sessionStore, chatCache, httpapi.Options{
InstanceID: instanceID,
Redis: redisClient,
Draining: &draining,
Blobs: blobs,
MaxUploads: config.ParseIntEnv("MAX_UPLOADS", 4),
})
port := config.GetEnv("PORT", "8080")
srv := &http.Server{
Addr: ":" + port,
Handler: mux,
ReadHeaderTimeout: 5 * time.Second,
ReadTimeout: 60 * time.Second,
WriteTimeout: 60 * time.Second,
IdleTimeout: 60 * time.Second,
}
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT)
defer stop()
go func() {
log.Printf("запуск на :%s instance=%s", port, instanceID)
if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
log.Fatalf("сервер упал: %v", err)
}
}()
<-ctx.Done()
log.Println("Получен сигнал остановки: readiness -> 503, жду LB...")
draining.Store(true)
time.Sleep(time.Duration(config.ParseIntEnv("DRAIN_SECONDS", 4)) * time.Second)
shutdownCtx, cancel := context.WithTimeout(context.Background(), 12*time.Second)
defer cancel()
if err := srv.Shutdown(shutdownCtx); err != nil {
log.Printf("принудительное завершение: %v", err)
}
log.Println("Остановлен")
}