Files
mtusi2026lab3/internal/app/app.go
T

135 lines
2.9 KiB
Go

package app
import (
"context"
"net/http"
"os"
"os/signal"
"sync"
"syscall"
"time"
"github.com/joho/godotenv"
goredis "github.com/redis/go-redis/v9"
"mtusi2026-messenger/internal/config"
"mtusi2026-messenger/internal/db"
"mtusi2026-messenger/internal/logger"
"mtusi2026-messenger/internal/postgres"
"mtusi2026-messenger/internal/redis"
"mtusi2026-messenger/internal/service"
)
func Run() error {
if err := godotenv.Load(); err != nil && !os.IsNotExist(err) {
return err
}
cfg := config.Load()
log := logger.New(cfg.Logging.Level).With("instance_id", cfg.Server.InstanceID)
dbURL, err := cfg.Database.URL()
if err != nil {
log.Error("read database url", "error", err)
return err
}
pool, err := postgres.New(context.Background(), dbURL)
if err != nil {
log.Error("connect to database", "error", err)
return err
}
defer pool.Close()
queries := db.New(pool)
var rdb *goredis.Client
if cfg.UseCache() {
cacheURL, err := cfg.Redis.URL()
if err != nil {
log.Error("read redis url", "error", err)
return err
}
rdb, err = redis.New(context.Background(), log, cacheURL)
if err != nil {
log.Error("create redis client", "error", err)
return err
}
defer rdb.Close()
}
log.Info("session store configured", "store", cfg.SessionStore)
cleanupCtx, stopCleanup := context.WithCancel(context.Background())
var cleanupWG sync.WaitGroup
cleanupWG.Go(func() {
runSessionCleanup(cleanupCtx, log, queries, sessionCleanupInterval)
})
cleanupWG.Go(func() {
runIdempotencyCleanup(cleanupCtx, log, queries, cfg.Server.IdempotencyTTL, idempotencyCleanupInterval)
})
defer func() {
stopCleanup()
cleanupWG.Wait()
}()
authService := service.NewAuthService(queries, rdb, cfg.Server.SessionTTL, log)
userService := service.NewUserService(queries)
chatService := service.NewChatService(pool, queries)
messageService := service.NewMessageService(pool, queries)
router := NewRouter(
log,
cfg.Server.InstanceID,
cfg.Server.MaxInflightRequests,
pool,
authService,
userService,
chatService,
messageService,
)
server := &http.Server{
Addr: cfg.Server.Host + ":" + cfg.Server.Port,
Handler: router,
}
serverErrors := make(chan error, 1)
go func() {
log.Info("server starting", "addr", server.Addr)
serverErrors <- server.ListenAndServe()
}()
signalCh := make(chan os.Signal, 1)
signal.Notify(signalCh, syscall.SIGINT, syscall.SIGTERM)
defer signal.Stop(signalCh)
select {
case err := <-serverErrors:
if err == http.ErrServerClosed {
return nil
}
log.Error("server failed", "error", err)
return err
case sig := <-signalCh:
log.Info("shutdown signal received", "signal", sig.String())
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err := server.Shutdown(ctx); err != nil {
log.Error("server shutdown failed", "error", err)
return err
}
log.Info("server stopped")
return nil
}
}