203 lines
6.0 KiB
Go
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
|
|
}
|