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" 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() 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) } userRepo := postgres.NewUserRepository(queries) chatRepo := postgres.NewChatRepository(queries, pool) messageRepo := postgres.NewMessageRepository(queries, pool) sessionRepo := redis.NewSessionRepository(redisClient) authService := service.NewAuthService(userRepo, sessionRepo, cfg.Session.TTL) userService := service.NewUserService(userRepo) chatService := service.NewChatService(chatRepo, userRepo, userService) messageService := service.NewMessageService(messageRepo, chatService, userService) healthHandler := handler.NewHealthHandler(pool, redisClient) authHandler := handler.NewAuthHandler(authService) userHandler := handler.NewUserHandler(userService) chatHandler := handler.NewChatHandler(chatService) messageHandler := handler.NewMessageHandler(messageService) mid := middleware.NewMiddleware(authService, instanceID) router := httpdeliver.NewRouter(mid, authHandler, healthHandler, chatHandler, userHandler, messageHandler) 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) } }