feat: game lobby service
This commit is contained in:
Ilia Denisov
@@ -0,0 +1,579 @@
|
||||
// Package gmevents implements the worker that consumes Game Master
|
||||
// runtime events from the `gm:lobby_events` Redis Stream and drives the
|
||||
// surface area: keeping the denormalized runtime snapshot
|
||||
// current, feeding the per-game stats aggregate, and
|
||||
// dispatching capability evaluation at game finish.
|
||||
//
|
||||
// The consumer recognizes two event kinds documented in
|
||||
// lobby/README.md §Runtime Snapshot:
|
||||
//
|
||||
// - `runtime_snapshot_update` — applied to the game record snapshot
|
||||
// (current_turn, runtime_status, engine_health_summary) and to the
|
||||
// per-user stats aggregate (initial fields frozen on the first
|
||||
// observation, max fields raised by per-component maximum on every
|
||||
// event);
|
||||
// - `game_finished` — the same snapshot update plus a status
|
||||
// transition to `finished` and a capability-evaluation hand-off.
|
||||
//
|
||||
// Replay protection rests on three ingredients:
|
||||
//
|
||||
// 1. Status transitions (running/paused → finished) use the existing
|
||||
// ports.GameStore CAS guard, so a replayed game_finished finds the
|
||||
// game already in `finished` and the second pass is a no-op for the
|
||||
// status field.
|
||||
// 2. Snapshot updates use a fresh `At` timestamp on each call but
|
||||
// overwrite a deterministic snapshot blob, so re-applying an older
|
||||
// event does not corrupt the record.
|
||||
// 3. Capability evaluation uses ports.EvaluationGuardStore to recognise
|
||||
// replay and skip mutations.
|
||||
//
|
||||
// Stream-offset bookkeeping advances after each successfully handled
|
||||
// event. A `game_finished` event that fails capability evaluation
|
||||
// (transient store error) leaves the offset behind so the next loop
|
||||
// iteration retries the same entry.
|
||||
package gmevents
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"galaxy/lobby/internal/domain/common"
|
||||
"galaxy/lobby/internal/domain/game"
|
||||
"galaxy/lobby/internal/logging"
|
||||
"galaxy/lobby/internal/ports"
|
||||
"galaxy/lobby/internal/telemetry"
|
||||
|
||||
"github.com/redis/go-redis/v9"
|
||||
)
|
||||
|
||||
// streamOffsetLabel identifies the gmevents consumer in the stream offset
|
||||
// store. It stays stable when the underlying stream key is renamed via
|
||||
// configuration.
|
||||
const streamOffsetLabel = "gm_lobby_events"
|
||||
|
||||
// Event kinds carried in the GM stream `kind` field.
|
||||
const (
|
||||
kindRuntimeSnapshotUpdate = "runtime_snapshot_update"
|
||||
kindGameFinished = "game_finished"
|
||||
)
|
||||
|
||||
// CapabilityEvaluator is the minimal interface the gmevents consumer
|
||||
// requires from the capability evaluation service. The interface
|
||||
// lives here rather than in the service package to avoid an import cycle.
|
||||
type CapabilityEvaluator interface {
|
||||
Evaluate(ctx context.Context, gameID common.GameID, finishedAt time.Time) error
|
||||
}
|
||||
|
||||
// Config groups the dependencies used by Consumer.
|
||||
type Config struct {
|
||||
// Client provides XREAD access to the GM events stream.
|
||||
Client *redis.Client
|
||||
|
||||
// Stream stores the Redis Streams key consumed by the worker.
|
||||
Stream string
|
||||
|
||||
// BlockTimeout bounds the blocking XREAD window.
|
||||
BlockTimeout time.Duration
|
||||
|
||||
// Games persists the runtime snapshot updates and the game-finished
|
||||
// status transitions.
|
||||
Games ports.GameStore
|
||||
|
||||
// Stats persists the per-user stats aggregate fed by every snapshot
|
||||
// event.
|
||||
Stats ports.GameTurnStatsStore
|
||||
|
||||
// Capability runs capability evaluation after a successful
|
||||
// `game_finished` transition.
|
||||
Capability CapabilityEvaluator
|
||||
|
||||
// OffsetStore persists the last successfully processed entry id.
|
||||
OffsetStore ports.StreamOffsetStore
|
||||
|
||||
// Clock supplies the wall-clock used for snapshot UpdatedAt and for
|
||||
// status transition timestamps when the GM event does not carry one.
|
||||
// Defaults to time.Now when nil.
|
||||
Clock func() time.Time
|
||||
|
||||
// Logger receives structured worker-level events. Defaults to
|
||||
// slog.Default when nil.
|
||||
Logger *slog.Logger
|
||||
|
||||
// Telemetry records the `lobby.game.transitions` counter on each
|
||||
// successful game-finished transition. Optional; nil disables
|
||||
// metric emission.
|
||||
Telemetry *telemetry.Runtime
|
||||
}
|
||||
|
||||
// Consumer drives the gmevents processing loop.
|
||||
type Consumer struct {
|
||||
client *redis.Client
|
||||
stream string
|
||||
blockTimeout time.Duration
|
||||
games ports.GameStore
|
||||
stats ports.GameTurnStatsStore
|
||||
capability CapabilityEvaluator
|
||||
offsetStore ports.StreamOffsetStore
|
||||
clock func() time.Time
|
||||
logger *slog.Logger
|
||||
telemetry *telemetry.Runtime
|
||||
}
|
||||
|
||||
// NewConsumer constructs one Consumer from cfg.
|
||||
func NewConsumer(cfg Config) (*Consumer, error) {
|
||||
switch {
|
||||
case cfg.Client == nil:
|
||||
return nil, errors.New("new gm events consumer: nil redis client")
|
||||
case strings.TrimSpace(cfg.Stream) == "":
|
||||
return nil, errors.New("new gm events consumer: stream must not be empty")
|
||||
case cfg.BlockTimeout <= 0:
|
||||
return nil, errors.New("new gm events consumer: block timeout must be positive")
|
||||
case cfg.Games == nil:
|
||||
return nil, errors.New("new gm events consumer: nil game store")
|
||||
case cfg.Stats == nil:
|
||||
return nil, errors.New("new gm events consumer: nil game turn stats store")
|
||||
case cfg.Capability == nil:
|
||||
return nil, errors.New("new gm events consumer: nil capability evaluator")
|
||||
case cfg.OffsetStore == nil:
|
||||
return nil, errors.New("new gm events consumer: nil offset store")
|
||||
}
|
||||
clock := cfg.Clock
|
||||
if clock == nil {
|
||||
clock = time.Now
|
||||
}
|
||||
logger := cfg.Logger
|
||||
if logger == nil {
|
||||
logger = slog.Default()
|
||||
}
|
||||
return &Consumer{
|
||||
client: cfg.Client,
|
||||
stream: cfg.Stream,
|
||||
blockTimeout: cfg.BlockTimeout,
|
||||
games: cfg.Games,
|
||||
stats: cfg.Stats,
|
||||
capability: cfg.Capability,
|
||||
offsetStore: cfg.OffsetStore,
|
||||
clock: clock,
|
||||
logger: logger.With("worker", "lobby.gmevents", "stream", cfg.Stream),
|
||||
telemetry: cfg.Telemetry,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// Run drives the XREAD loop until ctx is cancelled. Per-message outcomes
|
||||
// are absorbed by HandleMessage; the loop only exits on context
|
||||
// cancellation or a fatal Redis error. The offset advances only after a
|
||||
// successful HandleMessage call so capability evaluation failure replays
|
||||
// the same entry on the next iteration.
|
||||
func (consumer *Consumer) Run(ctx context.Context) error {
|
||||
if consumer == nil || consumer.client == nil {
|
||||
return errors.New("run gm events consumer: nil consumer")
|
||||
}
|
||||
if ctx == nil {
|
||||
return errors.New("run gm events consumer: nil context")
|
||||
}
|
||||
if err := ctx.Err(); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
lastID, found, err := consumer.offsetStore.Load(ctx, streamOffsetLabel)
|
||||
if err != nil {
|
||||
return fmt.Errorf("run gm events consumer: load offset: %w", err)
|
||||
}
|
||||
if !found {
|
||||
lastID = "0-0"
|
||||
}
|
||||
|
||||
consumer.logger.Info("gm events consumer started",
|
||||
"block_timeout", consumer.blockTimeout.String(),
|
||||
"start_entry_id", lastID,
|
||||
)
|
||||
defer consumer.logger.Info("gm events consumer stopped")
|
||||
|
||||
for {
|
||||
streams, err := consumer.client.XRead(ctx, &redis.XReadArgs{
|
||||
Streams: []string{consumer.stream, lastID},
|
||||
Count: 1,
|
||||
Block: consumer.blockTimeout,
|
||||
}).Result()
|
||||
switch {
|
||||
case err == nil:
|
||||
for _, stream := range streams {
|
||||
for _, message := range stream.Messages {
|
||||
if !consumer.HandleMessage(ctx, message) {
|
||||
continue
|
||||
}
|
||||
if err := consumer.offsetStore.Save(ctx, streamOffsetLabel, message.ID); err != nil {
|
||||
return fmt.Errorf("run gm events consumer: save offset: %w", err)
|
||||
}
|
||||
lastID = message.ID
|
||||
}
|
||||
}
|
||||
case errors.Is(err, redis.Nil):
|
||||
continue
|
||||
case ctx.Err() != nil && (errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) || errors.Is(err, redis.ErrClosed)):
|
||||
return ctx.Err()
|
||||
case errors.Is(err, context.Canceled), errors.Is(err, context.DeadlineExceeded), errors.Is(err, redis.ErrClosed):
|
||||
return fmt.Errorf("run gm events consumer: %w", err)
|
||||
default:
|
||||
return fmt.Errorf("run gm events consumer: %w", err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Shutdown is a no-op; the consumer relies on context cancellation.
|
||||
func (consumer *Consumer) Shutdown(ctx context.Context) error {
|
||||
if ctx == nil {
|
||||
return errors.New("shutdown gm events consumer: nil context")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// HandleMessage processes one Redis Stream message and reports whether
|
||||
// the offset is allowed to advance. Decoding errors and logical replays
|
||||
// return true (the message is consumed and the offset advances). A
|
||||
// `game_finished` whose capability evaluation fails returns false so the
|
||||
// caller leaves the offset behind and the next iteration retries.
|
||||
//
|
||||
// Exported so tests can drive the consumer deterministically without
|
||||
// spinning up a real XREAD loop.
|
||||
func (consumer *Consumer) HandleMessage(ctx context.Context, message redis.XMessage) bool {
|
||||
if consumer == nil {
|
||||
return false
|
||||
}
|
||||
|
||||
event, err := decodeGMEvent(message)
|
||||
if err != nil {
|
||||
consumer.logger.WarnContext(ctx, "decode gm event",
|
||||
"stream_entry_id", message.ID,
|
||||
"err", err.Error(),
|
||||
)
|
||||
return true
|
||||
}
|
||||
|
||||
switch event.Kind {
|
||||
case kindRuntimeSnapshotUpdate:
|
||||
consumer.handleSnapshotUpdate(ctx, message.ID, event)
|
||||
return true
|
||||
case kindGameFinished:
|
||||
return consumer.handleGameFinished(ctx, message.ID, event)
|
||||
default:
|
||||
consumer.logger.WarnContext(ctx, "unknown gm event kind",
|
||||
"stream_entry_id", message.ID,
|
||||
"game_id", event.GameID.String(),
|
||||
"kind", event.Kind,
|
||||
)
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
// handleSnapshotUpdate applies the snapshot to the game record and the
|
||||
// stats aggregate. Errors are logged and absorbed: the message advances
|
||||
// in either case so a transient Redis hiccup does not stall the stream.
|
||||
// CAS-protected mutations naturally absorb replays without further
|
||||
// bookkeeping.
|
||||
func (consumer *Consumer) handleSnapshotUpdate(ctx context.Context, entryID string, event gmEvent) {
|
||||
at := consumer.clock().UTC()
|
||||
|
||||
if err := consumer.games.UpdateRuntimeSnapshot(ctx, ports.UpdateRuntimeSnapshotInput{
|
||||
GameID: event.GameID,
|
||||
Snapshot: event.Snapshot,
|
||||
At: at,
|
||||
}); err != nil && !errors.Is(err, game.ErrNotFound) {
|
||||
consumer.logger.WarnContext(ctx, "apply runtime snapshot",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", event.GameID.String(),
|
||||
"err", err.Error(),
|
||||
)
|
||||
}
|
||||
|
||||
if len(event.PlayerStats) == 0 {
|
||||
return
|
||||
}
|
||||
if err := consumer.stats.SaveInitial(ctx, event.GameID, event.PlayerStats); err != nil {
|
||||
consumer.logger.WarnContext(ctx, "save initial player stats",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", event.GameID.String(),
|
||||
"err", err.Error(),
|
||||
)
|
||||
}
|
||||
if err := consumer.stats.UpdateMax(ctx, event.GameID, event.PlayerStats); err != nil {
|
||||
consumer.logger.WarnContext(ctx, "update max player stats",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", event.GameID.String(),
|
||||
"err", err.Error(),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
// handleGameFinished applies the final snapshot, transitions the game to
|
||||
// `finished` (or absorbs a replay where the game is already finished),
|
||||
// then drives capability evaluation. The function returns false to hold
|
||||
// the stream offset when a recoverable failure prevents capability
|
||||
// evaluation; the next loop iteration retries the same entry.
|
||||
func (consumer *Consumer) handleGameFinished(ctx context.Context, entryID string, event gmEvent) bool {
|
||||
at := consumer.clock().UTC()
|
||||
finishedAt := event.FinishedAt
|
||||
if finishedAt.IsZero() {
|
||||
finishedAt = at
|
||||
}
|
||||
|
||||
if err := consumer.games.UpdateRuntimeSnapshot(ctx, ports.UpdateRuntimeSnapshotInput{
|
||||
GameID: event.GameID,
|
||||
Snapshot: event.Snapshot,
|
||||
At: at,
|
||||
}); err != nil && !errors.Is(err, game.ErrNotFound) {
|
||||
consumer.logger.WarnContext(ctx, "apply final runtime snapshot",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", event.GameID.String(),
|
||||
"err", err.Error(),
|
||||
)
|
||||
}
|
||||
|
||||
if len(event.PlayerStats) > 0 {
|
||||
if err := consumer.stats.SaveInitial(ctx, event.GameID, event.PlayerStats); err != nil {
|
||||
consumer.logger.WarnContext(ctx, "save initial player stats on finish",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", event.GameID.String(),
|
||||
"err", err.Error(),
|
||||
)
|
||||
}
|
||||
if err := consumer.stats.UpdateMax(ctx, event.GameID, event.PlayerStats); err != nil {
|
||||
consumer.logger.WarnContext(ctx, "update max player stats on finish",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", event.GameID.String(),
|
||||
"err", err.Error(),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
record, err := consumer.games.Get(ctx, event.GameID)
|
||||
switch {
|
||||
case err == nil:
|
||||
case errors.Is(err, game.ErrNotFound):
|
||||
consumer.logger.WarnContext(ctx, "game finished for unknown game id",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", event.GameID.String(),
|
||||
)
|
||||
return true
|
||||
default:
|
||||
consumer.logger.WarnContext(ctx, "load game for finish",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", event.GameID.String(),
|
||||
"err", err.Error(),
|
||||
)
|
||||
return false
|
||||
}
|
||||
|
||||
switch record.Status {
|
||||
case game.StatusRunning, game.StatusPaused:
|
||||
if err := consumer.games.UpdateStatus(ctx, ports.UpdateStatusInput{
|
||||
GameID: record.GameID,
|
||||
ExpectedFrom: record.Status,
|
||||
To: game.StatusFinished,
|
||||
Trigger: game.TriggerRuntimeEvent,
|
||||
At: finishedAt,
|
||||
}); err != nil {
|
||||
switch {
|
||||
case errors.Is(err, game.ErrConflict), errors.Is(err, game.ErrInvalidTransition):
|
||||
consumer.logger.InfoContext(ctx, "game finished transition absorbed by status conflict",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", record.GameID.String(),
|
||||
)
|
||||
default:
|
||||
consumer.logger.WarnContext(ctx, "transition game to finished",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", record.GameID.String(),
|
||||
"err", err.Error(),
|
||||
)
|
||||
return false
|
||||
}
|
||||
} else {
|
||||
consumer.telemetry.RecordGameTransition(ctx,
|
||||
string(record.Status),
|
||||
string(game.StatusFinished),
|
||||
string(game.TriggerRuntimeEvent),
|
||||
)
|
||||
logArgs := []any{
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", record.GameID.String(),
|
||||
"from_status", string(record.Status),
|
||||
"to_status", string(game.StatusFinished),
|
||||
"trigger", string(game.TriggerRuntimeEvent),
|
||||
}
|
||||
logArgs = append(logArgs, logging.ContextAttrs(ctx)...)
|
||||
consumer.logger.InfoContext(ctx, "game finished", logArgs...)
|
||||
}
|
||||
case game.StatusFinished:
|
||||
consumer.logger.InfoContext(ctx, "game finished event observed for already finished game",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", record.GameID.String(),
|
||||
)
|
||||
default:
|
||||
consumer.logger.InfoContext(ctx, "game finished event ignored for unexpected status",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", record.GameID.String(),
|
||||
"current_status", string(record.Status),
|
||||
)
|
||||
return true
|
||||
}
|
||||
|
||||
refreshed, err := consumer.games.Get(ctx, event.GameID)
|
||||
if err != nil {
|
||||
consumer.logger.WarnContext(ctx, "reload finished game record",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", event.GameID.String(),
|
||||
"err", err.Error(),
|
||||
)
|
||||
return false
|
||||
}
|
||||
if refreshed.Status != game.StatusFinished {
|
||||
consumer.logger.WarnContext(ctx, "game record not finished after transition attempt",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", refreshed.GameID.String(),
|
||||
"current_status", string(refreshed.Status),
|
||||
)
|
||||
return true
|
||||
}
|
||||
if refreshed.FinishedAt == nil {
|
||||
consumer.logger.WarnContext(ctx, "finished game missing finished_at",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", refreshed.GameID.String(),
|
||||
)
|
||||
return true
|
||||
}
|
||||
|
||||
if err := consumer.capability.Evaluate(ctx, refreshed.GameID, *refreshed.FinishedAt); err != nil {
|
||||
consumer.logger.WarnContext(ctx, "capability evaluation failed",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", refreshed.GameID.String(),
|
||||
"err", err.Error(),
|
||||
)
|
||||
return false
|
||||
}
|
||||
|
||||
consumer.logger.InfoContext(ctx, "game finished processed",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", refreshed.GameID.String(),
|
||||
)
|
||||
return true
|
||||
}
|
||||
|
||||
// gmEvent stores the decoded shape of one `gm:lobby_events` entry shared
|
||||
// by the snapshot and finish handlers.
|
||||
type gmEvent struct {
|
||||
Kind string
|
||||
GameID common.GameID
|
||||
Snapshot game.RuntimeSnapshot
|
||||
PlayerStats []ports.PlayerObservedStats
|
||||
FinishedAt time.Time
|
||||
}
|
||||
|
||||
func decodeGMEvent(message redis.XMessage) (gmEvent, error) {
|
||||
kind := optionalString(message.Values, "kind")
|
||||
if kind != kindRuntimeSnapshotUpdate && kind != kindGameFinished {
|
||||
return gmEvent{}, fmt.Errorf("unsupported event kind %q", kind)
|
||||
}
|
||||
|
||||
gameIDRaw := optionalString(message.Values, "game_id")
|
||||
if strings.TrimSpace(gameIDRaw) == "" {
|
||||
return gmEvent{}, errors.New("missing game_id")
|
||||
}
|
||||
gameID := common.GameID(gameIDRaw)
|
||||
if err := gameID.Validate(); err != nil {
|
||||
return gmEvent{}, fmt.Errorf("invalid game_id: %w", err)
|
||||
}
|
||||
|
||||
snapshot := game.RuntimeSnapshot{
|
||||
RuntimeStatus: optionalString(message.Values, "runtime_status"),
|
||||
EngineHealthSummary: optionalString(message.Values, "engine_health_summary"),
|
||||
}
|
||||
if turnRaw := optionalString(message.Values, "current_turn"); turnRaw != "" {
|
||||
parsed, err := strconv.Atoi(turnRaw)
|
||||
if err != nil {
|
||||
return gmEvent{}, fmt.Errorf("invalid current_turn: %w", err)
|
||||
}
|
||||
if parsed < 0 {
|
||||
return gmEvent{}, fmt.Errorf("invalid current_turn: must not be negative")
|
||||
}
|
||||
snapshot.CurrentTurn = parsed
|
||||
}
|
||||
|
||||
playerStats, err := decodePlayerStats(optionalString(message.Values, "player_turn_stats"))
|
||||
if err != nil {
|
||||
return gmEvent{}, fmt.Errorf("invalid player_turn_stats: %w", err)
|
||||
}
|
||||
|
||||
var finishedAt time.Time
|
||||
if raw := optionalString(message.Values, "finished_at_ms"); raw != "" {
|
||||
ms, err := strconv.ParseInt(raw, 10, 64)
|
||||
if err != nil {
|
||||
return gmEvent{}, fmt.Errorf("invalid finished_at_ms: %w", err)
|
||||
}
|
||||
if ms <= 0 {
|
||||
return gmEvent{}, fmt.Errorf("invalid finished_at_ms: must be positive")
|
||||
}
|
||||
finishedAt = time.UnixMilli(ms).UTC()
|
||||
}
|
||||
|
||||
return gmEvent{
|
||||
Kind: kind,
|
||||
GameID: gameID,
|
||||
Snapshot: snapshot,
|
||||
PlayerStats: playerStats,
|
||||
FinishedAt: finishedAt,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// playerStatsLine mirrors the JSON shape of one `player_turn_stats`
|
||||
// element on the GM stream.
|
||||
type playerStatsLine struct {
|
||||
UserID string `json:"user_id"`
|
||||
Planets int64 `json:"planets"`
|
||||
Population int64 `json:"population"`
|
||||
ShipsBuilt int64 `json:"ships_built"`
|
||||
}
|
||||
|
||||
func decodePlayerStats(payload string) ([]ports.PlayerObservedStats, error) {
|
||||
if strings.TrimSpace(payload) == "" {
|
||||
return nil, nil
|
||||
}
|
||||
var lines []playerStatsLine
|
||||
if err := json.Unmarshal([]byte(payload), &lines); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
stats := make([]ports.PlayerObservedStats, 0, len(lines))
|
||||
for _, line := range lines {
|
||||
entry := ports.PlayerObservedStats{
|
||||
UserID: strings.TrimSpace(line.UserID),
|
||||
Planets: line.Planets,
|
||||
Population: line.Population,
|
||||
ShipsBuilt: line.ShipsBuilt,
|
||||
}
|
||||
if err := entry.Validate(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
stats = append(stats, entry)
|
||||
}
|
||||
return stats, nil
|
||||
}
|
||||
|
||||
func optionalString(values map[string]any, key string) string {
|
||||
raw, ok := values[key]
|
||||
if !ok {
|
||||
return ""
|
||||
}
|
||||
switch typed := raw.(type) {
|
||||
case string:
|
||||
return typed
|
||||
case []byte:
|
||||
return string(typed)
|
||||
default:
|
||||
return ""
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user