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 }