forked from mtusi2026/mtusi2026lab3
155 lines
4.0 KiB
Go
155 lines
4.0 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"encoding/base64"
|
|
"errors"
|
|
"fmt"
|
|
"github.com/redis/go-redis/v9"
|
|
"log/slog"
|
|
"mtusi/messenger/internal/database"
|
|
"mtusi/messenger/internal/messenger"
|
|
"net"
|
|
"net/http"
|
|
"os"
|
|
"os/signal"
|
|
"strconv"
|
|
"strings"
|
|
"syscall"
|
|
"time"
|
|
)
|
|
|
|
func env(key, fallback string) string {
|
|
if v := os.Getenv(key); v != "" {
|
|
return v
|
|
}
|
|
return fallback
|
|
}
|
|
func main() {
|
|
if err := run(); err != nil {
|
|
slog.Error("server failed", "error", err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
func run() error {
|
|
host := env("APP_HOST", "0.0.0.0")
|
|
port := env("APP_PORT", "8080")
|
|
p, err := strconv.Atoi(port)
|
|
if err != nil || p < 1 || p > 65535 {
|
|
return fmt.Errorf("invalid APP_PORT")
|
|
}
|
|
if len(os.Args) == 2 && os.Args[1] == "healthcheck" {
|
|
c := http.Client{Timeout: time.Second}
|
|
r, e := c.Get("http://127.0.0.1:" + port + "/health/ready")
|
|
if e != nil {
|
|
return e
|
|
}
|
|
defer r.Body.Close()
|
|
if r.StatusCode != 200 {
|
|
return fmt.Errorf("not ready: %d", r.StatusCode)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
log := slog.New(slog.NewJSONHandler(os.Stdout, nil))
|
|
ttl, err := strconv.Atoi(env("SESSION_TTL_SECONDS", "3600"))
|
|
if err != nil || ttl < 1 || ttl > 86400 {
|
|
return fmt.Errorf("SESSION_TTL_SECONDS must be 1..86400")
|
|
}
|
|
databaseURL, err := secret("DATABASE_URL_FILE")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
startup, cancel := context.WithTimeout(context.Background(), 15*time.Second)
|
|
defer cancel()
|
|
pool, err := database.Open(startup, databaseURL)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer pool.Close()
|
|
if len(os.Args) == 2 && os.Args[1] == "migrate" {
|
|
return database.Migrate(startup, pool)
|
|
}
|
|
cacheURL, err := secret("CACHE_URL_FILE")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
cursorKey, err := secret("CURSOR_KEY_FILE")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
key, err := base64.RawURLEncoding.DecodeString(cursorKey)
|
|
if err != nil || len(key) != 32 {
|
|
return fmt.Errorf("invalid cursor key")
|
|
}
|
|
opts, err := redis.ParseURL(cacheURL)
|
|
if err != nil {
|
|
return fmt.Errorf("invalid cache configuration")
|
|
}
|
|
opts.DialTimeout = 60 * time.Millisecond
|
|
opts.ReadTimeout = 60 * time.Millisecond
|
|
opts.WriteTimeout = 60 * time.Millisecond
|
|
opts.PoolTimeout = 60 * time.Millisecond
|
|
opts.ContextTimeoutEnabled = true
|
|
opts.MaxRetries = -1
|
|
opts.PoolSize = 10
|
|
cache := redis.NewClient(opts)
|
|
defer cache.Close()
|
|
api := messenger.New(pool, cache, key, ttl, log)
|
|
srv := &http.Server{Addr: net.JoinHostPort(host, port), Handler: api, ReadHeaderTimeout: 3 * time.Second, ReadTimeout: 5 * time.Second, WriteTimeout: 10 * time.Second, IdleTimeout: 30 * time.Second, MaxHeaderBytes: 16 << 10}
|
|
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
|
|
defer stop()
|
|
if os.Getenv("POOL_DIAGNOSTICS") == "1" {
|
|
go func() {
|
|
ticker := time.NewTicker(time.Second)
|
|
defer ticker.Stop()
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return
|
|
case <-ticker.C:
|
|
stat := pool.Stat()
|
|
log.Info("pool", "instance", os.Getenv("HOSTNAME"), "acquires", stat.AcquireCount(), "empty_acquires", stat.EmptyAcquireCount(), "wait_ns", stat.EmptyAcquireWaitTime().Nanoseconds(), "in_use", stat.AcquiredConns(), "max", stat.MaxConns())
|
|
}
|
|
}
|
|
}()
|
|
}
|
|
done := make(chan error, 1)
|
|
go func() {
|
|
log.Info("listening", "address", srv.Addr, "session_store", "postgres", "profile_cache", "valkey", "environment", env("APP_ENV", "lab"))
|
|
done <- srv.ListenAndServe()
|
|
}()
|
|
select {
|
|
case err := <-done:
|
|
return err
|
|
case <-ctx.Done():
|
|
}
|
|
start := time.Now()
|
|
api.Stop()
|
|
log.Info("shutdown started")
|
|
shutdown, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
|
defer cancel()
|
|
if err := srv.Shutdown(shutdown); err != nil {
|
|
_ = srv.Close()
|
|
return err
|
|
}
|
|
err = <-done
|
|
if !errors.Is(err, http.ErrServerClosed) {
|
|
return err
|
|
}
|
|
log.Info("shutdown completed", "duration_ms", time.Since(start).Milliseconds())
|
|
return nil
|
|
}
|
|
|
|
func secret(name string) (string, error) {
|
|
path := os.Getenv(name)
|
|
if path == "" {
|
|
return "", fmt.Errorf("missing %s", name)
|
|
}
|
|
raw, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return "", fmt.Errorf("cannot read %s", name)
|
|
}
|
|
return strings.TrimSpace(string(raw)), nil
|
|
}
|