141 lines
3.6 KiB
Go
141 lines
3.6 KiB
Go
package app
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"log"
|
|
"net"
|
|
"net/http"
|
|
"os"
|
|
"os/signal"
|
|
"runtime"
|
|
"syscall"
|
|
"time"
|
|
|
|
"messenger/src/backend/handlers"
|
|
"messenger/src/backend/repositories"
|
|
"messenger/src/backend/services"
|
|
)
|
|
|
|
func serverAddress() string {
|
|
host := os.Getenv("APP_HOST")
|
|
if host == "" {
|
|
host = "0.0.0.0"
|
|
}
|
|
|
|
port := os.Getenv("APP_PORT")
|
|
if port == "" {
|
|
port = "8080"
|
|
}
|
|
|
|
return net.JoinHostPort(host, port)
|
|
}
|
|
|
|
func RunHTTP() error {
|
|
if _, err := repositories.UploadCleanupGrace(); err != nil {
|
|
return err
|
|
}
|
|
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
|
|
db, err := repositories.OpenDatabase(ctx)
|
|
cancel()
|
|
if err != nil {
|
|
return fmt.Errorf("database initialization failed: %w", err)
|
|
}
|
|
defer db.Close()
|
|
// Opt-in experiment telemetry goes to container logs, never a public port.
|
|
if os.Getenv("BENCH_POOL_STATS") == "1" {
|
|
go func() {
|
|
for range time.Tick(time.Second) {
|
|
s := db.Stat()
|
|
data, _ := json.Marshal(map[string]any{
|
|
"time": time.Now().UTC(), "acquired": s.AcquiredConns(),
|
|
"total": s.TotalConns(), "max": s.MaxConns(),
|
|
"gomaxprocs": runtime.GOMAXPROCS(0), "goroutines": runtime.NumGoroutine(),
|
|
"acquire_count": s.AcquireCount(), "acquire_duration_ns": s.AcquireDuration().Nanoseconds(),
|
|
"empty_acquire_count": s.EmptyAcquireCount(), "canceled_acquire_count": s.CanceledAcquireCount(),
|
|
})
|
|
log.Printf("benchmark_pool %s", data)
|
|
}
|
|
}()
|
|
}
|
|
redisClient, err := repositories.RedisClientFromEnvironment()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer redisClient.Close()
|
|
sessionStore := repositories.NewSessionStore(redisClient, "messenger:session:")
|
|
userStore := repositories.NewUserStore(db)
|
|
chatStore := repositories.NewChatStore(db)
|
|
idempotencyTTL, err := repositories.IdempotencyTTL()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
messageStore := repositories.NewMessageStoreWithTTL(db, idempotencyTTL)
|
|
ttl, err := services.SessionTTL()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
userService := services.NewUserService(userStore)
|
|
sessionService := services.NewSessionService(userService, sessionStore, ttl)
|
|
chatService := services.NewChatService(chatStore)
|
|
messageService := services.NewMessageService(messageStore)
|
|
objects, err := repositories.NewObjectStoreFromEnvironment()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
attachmentService := services.NewAttachmentService(repositories.NewAttachmentStore(db), objects)
|
|
mux := handlers.NewRouter(services.NewHealthService(repositories.NewHealthStore(db), sessionStore, objects), userService, sessionService, chatService, messageService, attachmentService)
|
|
|
|
server := &http.Server{
|
|
Addr: serverAddress(),
|
|
Handler: mux,
|
|
ReadHeaderTimeout: 5 * time.Second,
|
|
ReadTimeout: 30 * time.Second,
|
|
WriteTimeout: 30 * time.Second,
|
|
IdleTimeout: 60 * time.Second,
|
|
}
|
|
|
|
shutdownContext, stop := signal.NotifyContext(
|
|
context.Background(),
|
|
os.Interrupt,
|
|
syscall.SIGTERM,
|
|
)
|
|
defer stop()
|
|
|
|
serverErrors := make(chan error, 1)
|
|
|
|
go func() {
|
|
log.Printf("server is listening on %s", server.Addr)
|
|
|
|
if err := server.ListenAndServe(); err != nil &&
|
|
!errors.Is(err, http.ErrServerClosed) {
|
|
serverErrors <- err
|
|
}
|
|
}()
|
|
|
|
select {
|
|
case err := <-serverErrors:
|
|
log.Printf("server error: %v", err)
|
|
|
|
case <-shutdownContext.Done():
|
|
log.Printf("shutdown signal received")
|
|
handlers.BeginShutdown()
|
|
|
|
shutdownDeadline, cancel := context.WithTimeout(
|
|
context.Background(),
|
|
10*time.Second,
|
|
)
|
|
defer cancel()
|
|
|
|
if err := server.Shutdown(shutdownDeadline); err != nil {
|
|
log.Printf("graceful shutdown failed: %v", err)
|
|
return nil
|
|
}
|
|
|
|
log.Printf("server stopped gracefully")
|
|
}
|
|
return nil
|
|
}
|