Files
mtusi2026lab6/cmd/server/main.go
T

225 lines
6.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"
"mtusi/messenger/internal/telemetry"
"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 {
if errors.Is(err, messenger.ErrInvalidImage) {
os.Exit(65)
}
slog.Error("server failed", "error", err)
os.Exit(1)
}
}
func run() error {
if (len(os.Args) == 4 || len(os.Args) == 5) && os.Args[1] == "transform" {
version := 1
if len(os.Args) == 5 {
v, e := strconv.Atoi(os.Args[4])
if e != nil {
return e
}
version = v
}
return messenger.Transform(os.Args[2], os.Args[3], version)
}
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))
service := "messenger-api"
if len(os.Args) > 1 {
service = "messenger-" + os.Args[1]
}
if len(os.Args) == 1 || os.Args[1] != "migrate" {
var shutdown func()
var e error
log, shutdown, e = telemetry.Init(context.Background(), service)
if e != nil {
return e
}
defer shutdown()
}
slog.SetDefault(log)
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)
}
storeAccess, err := secret("S3_ACCESS_KEY_ID_FILE")
if err != nil {
return err
}
storeSecret, err := secret("S3_SECRET_ACCESS_KEY_FILE")
if err != nil {
return err
}
objects, err := messenger.NewObjectStore(env("S3_ENDPOINT", "http://s3:9000"), env("S3_BUCKET", "messenger-attachments"), storeAccess, storeSecret)
if err != nil {
return err
}
if len(os.Args) > 1 {
command := os.Args[1]
if command == "worker" || command == "dispatcher" || command == "replay" || command == "reprocess" || command == "cleanup" || command == "housekeeping" {
brokerURL, e := secret("BROKER_URL_FILE")
if e != nil {
return e
}
opts, e := redis.ParseURL(brokerURL)
if e != nil {
return fmt.Errorf("invalid broker configuration")
}
opts.MaxRetries = -1
opts.DialTimeout = time.Second
opts.ReadTimeout = 2 * time.Second
opts.WriteTimeout = 2 * time.Second
broker := redis.NewClient(opts)
defer broker.Close()
telemetry.Observe(pool, command == "dispatcher")
pipeline := messenger.NewPipeline(pool, broker, objects, log)
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
defer stop()
switch command {
case "worker":
n, e := strconv.Atoi(env("WORKER_CONCURRENCY", "1"))
if e != nil {
return e
}
return pipeline.RunWorker(ctx, n)
case "dispatcher":
return pipeline.RunDispatcher(ctx)
case "housekeeping":
return pipeline.RunHousekeeping(ctx)
case "cleanup":
return pipeline.Cleanup(ctx, len(os.Args) == 3 && os.Args[2] == "--apply")
case "replay", "reprocess":
if len(os.Args) != 3 {
return fmt.Errorf("expected attachment UUID")
}
return pipeline.Replay(ctx, os.Args[2], command == "reprocess")
}
}
}
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()
telemetry.Observe(pool, false)
api := messenger.New(pool, cache, key, ttl, log)
api.SetObjectStore(objects)
srv := &http.Server{Addr: net.JoinHostPort(host, port), Handler: api, ReadHeaderTimeout: 3 * time.Second, ReadTimeout: 35 * time.Second, WriteTimeout: 35 * time.Second, IdleTimeout: 30 * time.Second, MaxHeaderBytes: 16 << 10}
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
defer stop()
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
}