forked from mtusi2026/mtusi2026lab3
170 lines
4.4 KiB
Go
170 lines
4.4 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"os/signal"
|
|
"strconv"
|
|
"strings"
|
|
"syscall"
|
|
"time"
|
|
|
|
"github.com/jackc/pgx/v5/pgxpool"
|
|
"github.com/redis/go-redis/v9"
|
|
"mtusi-messenger/internal/database"
|
|
"mtusi-messenger/internal/messenger"
|
|
)
|
|
|
|
func env(name, fallback string) string {
|
|
if value := os.Getenv(name); value != "" {
|
|
return value
|
|
}
|
|
return fallback
|
|
}
|
|
func secret(envName, fileEnv string) (string, error) {
|
|
if value := os.Getenv(envName); value != "" {
|
|
return value, nil
|
|
}
|
|
path := os.Getenv(fileEnv)
|
|
if path == "" {
|
|
return "", fmt.Errorf("set %s or %s", envName, fileEnv)
|
|
}
|
|
b, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
value := strings.TrimSpace(string(b))
|
|
if value == "" {
|
|
return "", fmt.Errorf("%s is empty", path)
|
|
}
|
|
return value, nil
|
|
}
|
|
func positiveInt(name string, fallback int) (int, error) {
|
|
raw := env(name, strconv.Itoa(fallback))
|
|
n, err := strconv.Atoi(raw)
|
|
if err != nil || n < 1 {
|
|
return 0, fmt.Errorf("invalid %s", name)
|
|
}
|
|
return n, nil
|
|
}
|
|
|
|
func main() {
|
|
port := env("APP_PORT", "8080")
|
|
if len(os.Args) > 1 && os.Args[1] == "healthcheck" {
|
|
client := &http.Client{Timeout: 2 * time.Second}
|
|
resp, err := client.Get("http://127.0.0.1:" + port + "/health/ready")
|
|
if err != nil || resp.StatusCode != http.StatusOK {
|
|
os.Exit(1)
|
|
}
|
|
_ = resp.Body.Close()
|
|
return
|
|
}
|
|
host := env("APP_HOST", "0.0.0.0")
|
|
if _, err := strconv.Atoi(port); err != nil {
|
|
log.Fatal("invalid APP_PORT")
|
|
}
|
|
ttlSeconds, err := positiveInt("SESSION_TTL_SECONDS", 3600)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
idempotencyTTLSeconds, err := positiveInt("IDEMPOTENCY_TTL_SECONDS", 86400)
|
|
if err != nil || idempotencyTTLSeconds < 86400 {
|
|
log.Fatal("IDEMPOTENCY_TTL_SECONDS must be at least 86400")
|
|
}
|
|
dbTimeoutMS, err := positiveInt("DB_TIMEOUT_MS", 3000)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
maxConns, err := positiveInt("DB_MAX_CONNS", 10)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
databaseURL, err := secret("DATABASE_URL", "DATABASE_URL_FILE")
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
logger := log.New(os.Stdout, "", log.LstdFlags|log.LUTC)
|
|
ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
|
|
defer cancel()
|
|
config, err := pgxpool.ParseConfig(databaseURL)
|
|
if err != nil {
|
|
log.Fatal("invalid database configuration")
|
|
}
|
|
config.MaxConns = int32(maxConns)
|
|
config.MinConns = 1
|
|
config.MaxConnLifetime = 30 * time.Minute
|
|
var pool *pgxpool.Pool
|
|
for {
|
|
pool, err = pgxpool.NewWithConfig(ctx, config)
|
|
if err == nil {
|
|
err = pool.Ping(ctx)
|
|
}
|
|
if err == nil {
|
|
break
|
|
}
|
|
if pool != nil {
|
|
pool.Close()
|
|
}
|
|
if ctx.Err() != nil {
|
|
log.Fatal("database unavailable during startup")
|
|
}
|
|
time.Sleep(time.Second)
|
|
}
|
|
defer pool.Close()
|
|
if len(os.Args) > 1 && os.Args[1] == "migrate" {
|
|
if err = database.Migrate(ctx, pool); err != nil {
|
|
log.Fatalf("migration failed: %v", err)
|
|
}
|
|
logger.Print("migrations complete")
|
|
return
|
|
}
|
|
instanceID := env("INSTANCE_ID", "")
|
|
if instanceID == "" {
|
|
log.Fatal("INSTANCE_ID is required")
|
|
}
|
|
cacheURL, err := secret("CACHE_URL", "CACHE_URL_FILE")
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
redisOptions, err := redis.ParseURL(cacheURL)
|
|
if err != nil {
|
|
log.Fatal("invalid cache configuration")
|
|
}
|
|
sessions := redis.NewClient(redisOptions)
|
|
defer sessions.Close()
|
|
for {
|
|
if err = sessions.Ping(ctx).Err(); err == nil {
|
|
break
|
|
}
|
|
if ctx.Err() != nil {
|
|
log.Fatal("session store unavailable during startup")
|
|
}
|
|
time.Sleep(time.Second)
|
|
}
|
|
dbTimeout := time.Duration(dbTimeoutMS) * time.Millisecond
|
|
srv := &http.Server{Addr: host + ":" + port, Handler: messenger.NewHandler(pool, sessions, time.Duration(ttlSeconds)*time.Second, time.Duration(idempotencyTTLSeconds)*time.Second, dbTimeout, instanceID, logger), ReadHeaderTimeout: 5 * time.Second, ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, IdleTimeout: 30 * time.Second}
|
|
stop := make(chan os.Signal, 1)
|
|
signal.Notify(stop, syscall.SIGTERM, os.Interrupt)
|
|
done := make(chan struct{})
|
|
go func() {
|
|
defer close(done)
|
|
<-stop
|
|
logger.Print("shutdown started")
|
|
shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 8*time.Second)
|
|
defer shutdownCancel()
|
|
if shutdownErr := srv.Shutdown(shutdownCtx); shutdownErr != nil {
|
|
logger.Printf("shutdown error: %v", shutdownErr)
|
|
}
|
|
logger.Print("shutdown complete")
|
|
}()
|
|
logger.Printf("listening on %s", srv.Addr)
|
|
if err = srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
|
|
logger.Fatal(err)
|
|
}
|
|
<-done
|
|
}
|