package main import ( "context" "encoding/json" "errors" "fmt" "log/slog" "net" "net/http" "net/url" "os" "os/signal" "path/filepath" "strconv" "strings" "syscall" "time" "aeternalis/server/content" "aeternalis/server/internal/game" "aeternalis/server/internal/gitops" "aeternalis/server/internal/store" "aeternalis/server/internal/transport" ) func env(k, def string) string { if v := os.Getenv(k); v != "" { return v } return def } func run() error { dev := env("APP_ENV", "production") == "development" listen := env("LISTEN_ADDR", "127.0.0.1:18080") base := env("PUBLIC_URL", "http://127.0.0.1:18080") if dev { host, _, err := net.SplitHostPort(listen) if err != nil || net.ParseIP(host) == nil || !net.ParseIP(host).IsLoopback() { return errors.New("development auth requires an explicit loopback listen address") } u, err := url.Parse(base) if err != nil || net.ParseIP(u.Hostname()) == nil || !net.ParseIP(u.Hostname()).IsLoopback() { return errors.New("development PUBLIC_URL must be loopback") } } if !dev && os.Getenv("DATABASE_URL") == "" { return errors.New("production requires DATABASE_URL") } dsn := env("DATABASE_URL", "file:../.local/aeternalis.db") if !dev && !(strings.HasPrefix(dsn, "postgres://") || strings.HasPrefix(dsn, "postgresql://")) { return errors.New("production requires PostgreSQL") } if !dev { u, err := url.Parse(dsn) if err != nil || u.Query().Get("sslmode") != "verify-full" { return errors.New("production DATABASE_URL requires sslmode=verify-full") } } if dev && strings.HasPrefix(dsn, "file:") { path := strings.Split(strings.TrimPrefix(dsn, "file:"), "?")[0] if err := os.MkdirAll(filepath.Dir(path), 0700); err != nil { return err } } b, err := content.Load() if err != nil { return err } if dev { for key, dest := range map[string]*float64{"DEV_SEASON_SECONDS": &b.SeasonSeconds, "DEV_COLLAPSE_SECONDS": &b.CollapseSeconds, "DEV_DAILY_SECONDS": &b.DailyPlaySeconds} { if raw := os.Getenv(key); raw != "" { value, err := strconv.ParseFloat(raw, 64) if err != nil { return err } *dest = value } } } if err = b.Validate(); err != nil { return err } seed, err := strconv.ParseInt(env("WORLD_SEED", "734291"), 10, 64) if err != nil { return err } id := env("WORLD_ID", "world-001") if len(id) > 64 || strings.ContainsAny(id, "/\\ \t\n") { return errors.New("invalid WORLD_ID") } ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) defer cancel() db, err := store.Open(ctx, dsn) if err != nil { return err } defer db.Close() kind := env("WORLD_KIND", "survival") if kind != "survival" && kind != "hub" { return errors.New("WORLD_KIND must be survival or hub") } w := game.New(id, seed, time.Now().UTC(), b) w.Kind = kind if kind == "hub" { w.Phase = "hub" } lease, raw, err := db.Acquire(ctx, w) if err != nil { return fmt.Errorf("acquire world: %w", err) } released := false defer func() { if !released { ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() _ = lease.Release(ctx) } }() w, err = restoreInstance(raw, kind, time.Now().UTC()) if err != nil { return err } auth, err := transport.NewAuth(ctx, db, dev, base, os.Getenv("OIDC_ISSUER"), os.Getenv("OIDC_CLIENT_ID"), os.Getenv("OIDC_CLIENT_SECRET")) if err != nil { return err } auth.AdminRole = env("OIDC_ADMIN_ROLE", "aeternalis-admin") auth.DevAdmin = dev && env("DEV_ADMIN", "false") == "true" worlds := []transport.Destination{} if raw := os.Getenv("WORLD_DIRECTORY"); raw != "" { if err = json.Unmarshal([]byte(raw), &worlds); err != nil { return err } for _, dest := range worlds { u, err := url.Parse(dest.URL) if err != nil || u.Host == "" || (!dev && u.Scheme != "https") || u.User != nil { return errors.New("invalid WORLD_DIRECTORY URL") } } } svc := transport.NewService(w, lease) handler := transport.NewHTTP(svc, auth, env("CLIENT_DIR", "../client/dist"), worlds) if env("CONTROL_PRIMARY", "true") == "true" { handler.Provisioner, err = gitops.New(gitops.Config{Repository: os.Getenv("CONTROL_GITOPS_REPOSITORY"), Branch: os.Getenv("CONTROL_GITOPS_BRANCH"), File: os.Getenv("CONTROL_GITOPS_VALUES_FILE"), Token: os.Getenv("CONTROL_GITOPS_TOKEN"), PublicURL: base}) if err != nil { return err } } server := &http.Server{Addr: listen, Handler: handler.Handler(), ReadHeaderTimeout: 5 * time.Second, ReadTimeout: 15 * time.Second, WriteTimeout: 15 * time.Second, IdleTimeout: 60 * time.Second, MaxHeaderBytes: 16384} runtimeCtx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM) defer stop() go svc.Run(runtimeCtx) go handler.RunProvisioning(runtimeCtx) errorsCh := make(chan error, 1) go func() { slog.Info("world listening", "url", base, "world", id, "development", dev) errorsCh <- server.ListenAndServe() }() select { case <-runtimeCtx.Done(): case err = <-errorsCh: if !errors.Is(err, http.ErrServerClosed) { return err } } stop() shutdown, cancelShutdown := context.WithTimeout(context.Background(), 10*time.Second) defer cancelShutdown() err = svc.Stop(shutdown) released = true httpErr := server.Shutdown(shutdown) if err != nil { return err } return httpErr } func main() { if err := run(); err != nil { slog.Error("world stopped", "error", err) os.Exit(1) } } func restoreInstance(raw []byte, kind string, now time.Time) (*game.World, error) { var w game.World if err := json.Unmarshal(raw, &w); err != nil { return nil, err } // An older image can initialize a new hub ID during image promotion. Only an // untyped, unused legacy instance may adopt its configured hub kind. if w.Kind == "" && kind == "hub" && w.Phase == "gathering" && w.EndedAt == nil && len(w.Characters) == 0 && len(w.Corpses) == 0 { w.Kind = "hub" } if err := w.Restore(now); err != nil { return nil, err } if w.Kind != kind { return nil, errors.New("WORLD_KIND does not match saved world; use a new world ID") } return &w, nil }