Files

203 lines
6.0 KiB
Go

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
}