forked from mtusi2026/mtusi2026lab4
156 lines
4.0 KiB
Go
156 lines
4.0 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"highload/internal/config"
|
|
"highload/internal/database"
|
|
"highload/internal/database/sqlc"
|
|
"highload/internal/repository/postgres"
|
|
"highload/internal/repository/redis"
|
|
"highload/internal/service"
|
|
"highload/internal/storage/s3"
|
|
httpdeliver "highload/internal/transport/http"
|
|
"highload/internal/transport/http/handler"
|
|
"highload/internal/transport/http/middleware"
|
|
"log/slog"
|
|
"net"
|
|
"net/http"
|
|
"os"
|
|
"os/signal"
|
|
"syscall"
|
|
"time"
|
|
)
|
|
|
|
func main() {
|
|
|
|
cfg, err := config.Load()
|
|
|
|
if err != nil {
|
|
slog.Error("invalid configuration", "error", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
sessionStore := cfg.Session.Store
|
|
|
|
if sessionStore != "redis" {
|
|
slog.Error("session store is "+sessionStore+"must redis", "error", nil)
|
|
os.Exit(1)
|
|
}
|
|
|
|
databaseURL := cfg.Database.PostgresURL
|
|
pool, err := database.NewPostgres(context.Background(), databaseURL)
|
|
|
|
if err != nil {
|
|
slog.Error("postgres error", "error", err)
|
|
os.Exit(1)
|
|
}
|
|
defer pool.Close()
|
|
if os.Getenv("PG_POOL_DIAGNOSTICS") == "1" {
|
|
diagnosticsCtx, stopDiagnostics := context.WithCancel(context.Background())
|
|
defer stopDiagnostics()
|
|
go logPoolStats(diagnosticsCtx, pool)
|
|
}
|
|
|
|
queries := sqlc.New(pool)
|
|
|
|
redisAddr := cfg.Database.RedisAddr
|
|
|
|
redisClient, err := database.NewRedis(context.Background(), redisAddr)
|
|
|
|
if err != nil {
|
|
slog.Error("redis error", "error", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
defer redisClient.Close()
|
|
|
|
instanceID, err := os.Hostname()
|
|
if err != nil || instanceID == "" {
|
|
slog.Error("cannot get instance ID", "error", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
s3Storage, err := s3.NewStorage(context.Background(), &cfg.S3)
|
|
|
|
if err != nil {
|
|
slog.Error("cannot create new storage", "error", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
userRepo := postgres.NewUserRepository(queries)
|
|
chatRepo := postgres.NewChatRepository(queries, pool)
|
|
messageRepo := postgres.NewMessageRepository(queries, pool)
|
|
sessionRepo := redis.NewSessionRepository(redisClient)
|
|
attachmentRepo := postgres.NewAttachmentRepository(queries, pool)
|
|
|
|
authService := service.NewAuthService(userRepo, sessionRepo, cfg.Session.TTL)
|
|
userService := service.NewUserService(userRepo)
|
|
chatService := service.NewChatService(chatRepo, userRepo, userService)
|
|
messageService := service.NewMessageService(messageRepo, chatService, userService)
|
|
attachmentService := service.NewAttachmentService(attachmentRepo, chatService, s3Storage)
|
|
|
|
healthHandler := handler.NewHealthHandler(pool, redisClient, s3Storage)
|
|
authHandler := handler.NewAuthHandler(authService)
|
|
userHandler := handler.NewUserHandler(userService)
|
|
chatHandler := handler.NewChatHandler(chatService)
|
|
messageHandler := handler.NewMessageHandler(messageService)
|
|
attachmentHandler := handler.NewAttachmentHandler(attachmentService)
|
|
|
|
mid := middleware.NewMiddleware(authService, instanceID)
|
|
router := httpdeliver.NewRouter(mid, authHandler, healthHandler, chatHandler, userHandler, messageHandler, attachmentHandler)
|
|
|
|
server := &http.Server{
|
|
Addr: net.JoinHostPort(cfg.HTTP.Host, cfg.HTTP.Port),
|
|
Handler: router.Handler(),
|
|
ReadHeaderTimeout: 5 * time.Second,
|
|
ReadTimeout: 10 * time.Second,
|
|
WriteTimeout: 10 * time.Second,
|
|
IdleTimeout: 30 * time.Second,
|
|
}
|
|
|
|
listener, err := net.Listen("tcp", server.Addr)
|
|
if err != nil {
|
|
slog.Error("server failed to start", "error", err)
|
|
return
|
|
}
|
|
|
|
slog.Info("server started", "addr", server.Addr)
|
|
|
|
serverErr := make(chan error, 1)
|
|
go func() {
|
|
err := server.Serve(listener)
|
|
if err != nil && !errors.Is(err, http.ErrServerClosed) {
|
|
serverErr <- err
|
|
slog.Error("server failed", "error", err)
|
|
}
|
|
}()
|
|
|
|
ctx, stop := signal.NotifyContext(
|
|
context.Background(),
|
|
os.Interrupt,
|
|
syscall.SIGTERM,
|
|
)
|
|
defer stop()
|
|
|
|
select {
|
|
case <-ctx.Done():
|
|
slog.Info("shutdown signal received")
|
|
|
|
case err := <-serverErr:
|
|
slog.Error("server failed", "error", err)
|
|
return
|
|
}
|
|
|
|
shutdownCtx, cancel := context.WithTimeout(
|
|
context.Background(),
|
|
15*time.Second,
|
|
)
|
|
defer cancel()
|
|
|
|
if err := server.Shutdown(shutdownCtx); err != nil {
|
|
slog.Error("shutdown failed", "error", err)
|
|
}
|
|
|
|
}
|