Files
mtusi2026lab7/src/backend/app/server.go
T

156 lines
4.0 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"
"messenger/src/backend/telemetry"
)
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 {
tlsConfig, err := ingressTLS()
if err != nil {
return err
}
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)
signals, stopTelemetry, err := telemetry.Start("messenger-api")
if err != nil {
return fmt.Errorf("telemetry initialization failed: %w", err)
}
defer stopTelemetry()
if err := signals.ObservePool(db); err != nil {
return err
}
server := &http.Server{
Addr: serverAddress(),
TLSConfig: tlsConfig,
Handler: signals.HTTP(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.ListenAndServeTLS(os.Getenv("TLS_CERT_FILE"), os.Getenv("TLS_KEY_FILE")); err != nil &&
!errors.Is(err, http.ErrServerClosed) {
serverErrors <- err
}
}()
select {
case err := <-serverErrors:
return 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
}