187 lines
4.4 KiB
Go
187 lines
4.4 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"log/slog"
|
|
"net/http"
|
|
"os"
|
|
"os/signal"
|
|
"strconv"
|
|
"strings"
|
|
"sync/atomic"
|
|
"syscall"
|
|
"time"
|
|
|
|
"mtusi-messenger/internal/api"
|
|
"mtusi-messenger/internal/auth"
|
|
"mtusi-messenger/internal/cache"
|
|
"mtusi-messenger/internal/db"
|
|
"mtusi-messenger/internal/store"
|
|
)
|
|
|
|
func getenv(key, def string) string {
|
|
if v := os.Getenv(key); v != "" {
|
|
return v
|
|
}
|
|
return def
|
|
}
|
|
|
|
func getint(key string, def int) int {
|
|
v := os.Getenv(key)
|
|
if v == "" {
|
|
return def
|
|
}
|
|
n, err := strconv.Atoi(v)
|
|
if err != nil || n <= 0 {
|
|
fmt.Fprintf(os.Stderr, "invalid %s\n", key)
|
|
os.Exit(2)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func secret(key string) (string, error) {
|
|
if path := os.Getenv(key + "_FILE"); path != "" {
|
|
b, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return "", fmt.Errorf("read %s_FILE: %w", key, err)
|
|
}
|
|
return strings.TrimSpace(string(b)), nil
|
|
}
|
|
if v := os.Getenv(key); v != "" {
|
|
return v, nil
|
|
}
|
|
return "", fmt.Errorf("%s or %s_FILE is required", key, key)
|
|
}
|
|
|
|
func main() {
|
|
log := slog.New(slog.NewJSONHandler(os.Stdout, nil))
|
|
if err := run(log); err != nil {
|
|
log.Error("fatal", "error", err.Error())
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
func openDB(ctx context.Context) (*store.Store, func(), error) {
|
|
dsn, err := secret("DATABASE_URL")
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
pool, err := db.Open(ctx, dsn, db.PoolOptions{MaxConns: int32(getint("DB_MAX_CONNS", 10))})
|
|
if err != nil {
|
|
return nil, nil, errors.New("database config is invalid")
|
|
}
|
|
return store.New(pool), pool.Close, nil
|
|
}
|
|
|
|
func run(log *slog.Logger) error {
|
|
ctx := context.Background()
|
|
|
|
if len(os.Args) > 1 && os.Args[1] == "migrate" {
|
|
dsn, err := secret("DATABASE_URL")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
pool, err := db.Open(ctx, dsn, db.PoolOptions{MaxConns: 2})
|
|
if err != nil {
|
|
return errors.New("database config is invalid")
|
|
}
|
|
defer pool.Close()
|
|
mctx, cancel := context.WithTimeout(ctx, 60*time.Second)
|
|
defer cancel()
|
|
return db.Migrate(mctx, pool, log)
|
|
}
|
|
|
|
st, closeDB, err := openDB(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer closeDB()
|
|
|
|
ttl := time.Duration(getint("SESSION_TTL_SECONDS", 3600)) * time.Second
|
|
cacheMaxTTL := time.Duration(getint("SESSION_CACHE_MAX_TTL_SECONDS", 60)) * time.Second
|
|
|
|
var sessCache auth.SessionCache
|
|
switch mode := getenv("SESSION_STORE", "postgres"); mode {
|
|
case "postgres":
|
|
case "valkey", "redis":
|
|
url, err := secret("CACHE_URL")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
vk, err := cache.NewValkey(url)
|
|
if err != nil {
|
|
return errors.New("cache config is invalid")
|
|
}
|
|
defer vk.Close()
|
|
sessCache = vk
|
|
default:
|
|
return fmt.Errorf("unknown SESSION_STORE %q (postgres|valkey|redis)", mode)
|
|
}
|
|
|
|
hasher := auth.NewHasher(getint("PASSWORD_HASH_CONCURRENCY", 4))
|
|
sessions := auth.NewSessions(st, sessCache, ttl, cacheMaxTTL, log)
|
|
|
|
ready := &atomic.Bool{}
|
|
ready.Store(true)
|
|
|
|
host := getenv("APP_HOST", "0.0.0.0")
|
|
port := getenv("APP_PORT", "8080")
|
|
addr := host + ":" + port
|
|
srv := api.NewServer(st, sessions, hasher, log, ready)
|
|
httpSrv := &http.Server{
|
|
Addr: addr,
|
|
Handler: srv.Handler(),
|
|
ReadHeaderTimeout: 5 * time.Second,
|
|
ReadTimeout: 15 * time.Second,
|
|
WriteTimeout: 30 * time.Second,
|
|
IdleTimeout: 60 * time.Second,
|
|
}
|
|
|
|
bgCtx, stopBg := context.WithCancel(ctx)
|
|
defer stopBg()
|
|
go func() {
|
|
t := time.NewTicker(10 * time.Minute)
|
|
defer t.Stop()
|
|
for {
|
|
select {
|
|
case <-bgCtx.Done():
|
|
return
|
|
case <-t.C:
|
|
c, cancel := context.WithTimeout(bgCtx, 10*time.Second)
|
|
if n, err := st.PurgeSessions(c, 24*time.Hour); err == nil && n > 0 {
|
|
log.Info("expired sessions purged", "count", n)
|
|
}
|
|
cancel()
|
|
}
|
|
}
|
|
}()
|
|
|
|
errCh := make(chan error, 1)
|
|
go func() { errCh <- httpSrv.ListenAndServe() }()
|
|
log.Info("server started", "addr", addr, "pid", os.Getpid(),
|
|
"session_store", getenv("SESSION_STORE", "postgres"), "session_ttl_s", int(ttl.Seconds()))
|
|
|
|
stop := make(chan os.Signal, 1)
|
|
signal.Notify(stop, syscall.SIGTERM, syscall.SIGINT)
|
|
|
|
select {
|
|
case err := <-errCh:
|
|
if err != nil && !errors.Is(err, http.ErrServerClosed) {
|
|
return err
|
|
}
|
|
case sig := <-stop:
|
|
log.Info("shutdown signal received", "signal", sig.String())
|
|
ready.Store(false)
|
|
sctx, cancel := context.WithTimeout(ctx, 8*time.Second)
|
|
defer cancel()
|
|
if err := httpSrv.Shutdown(sctx); err != nil {
|
|
log.Warn("graceful shutdown exceeded budget, closing", "error", err.Error())
|
|
_ = httpSrv.Close()
|
|
}
|
|
log.Info("server stopped cleanly")
|
|
}
|
|
return nil
|
|
}
|