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("Остановлен") }