forked from mtusi2026/mtusi2026lab6
134 lines
3.5 KiB
Go
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("Остановлен")
|
|
}
|