forked from mtusi2026/mtusi2026lab3
135 lines
2.9 KiB
Go
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
|
|
}
|
|
}
|