feat: game lobby service
This commit is contained in:
Ilia Denisov
@@ -0,0 +1,564 @@
|
||||
// Package runtimejobresult implements the worker that consumes runtime
|
||||
// job results published by Runtime Manager and drives the second half of
|
||||
// the game start flow: persisting the runtime binding, calling
|
||||
// Game Master to register the running game, and transitioning the game
|
||||
// status to `running`, `paused`, or `start_failed` accordingly.
|
||||
//
|
||||
// Replay protection relies on the CAS-based UpdateStatus semantics: a
|
||||
// duplicate result event finds the game in a non-`starting` status and
|
||||
// the second pass becomes a no-op without any extra side effects. The
|
||||
// stream offset advances after each message so the consumer survives
|
||||
// restarts without re-emitting state changes.
|
||||
package runtimejobresult
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"galaxy/lobby/internal/domain/common"
|
||||
"galaxy/lobby/internal/domain/game"
|
||||
"galaxy/lobby/internal/logging"
|
||||
"galaxy/lobby/internal/ports"
|
||||
"galaxy/lobby/internal/telemetry"
|
||||
"galaxy/notificationintent"
|
||||
|
||||
"github.com/redis/go-redis/v9"
|
||||
)
|
||||
|
||||
// streamOffsetLabel identifies the runtime-job-results consumer in the
|
||||
// stream offset store. The label stays stable when the underlying
|
||||
// stream key is renamed via configuration.
|
||||
const streamOffsetLabel = "runtime_results"
|
||||
|
||||
// IntentPublisher publishes notification intents.
|
||||
type IntentPublisher interface {
|
||||
Publish(ctx context.Context, intent notificationintent.Intent) (string, error)
|
||||
}
|
||||
|
||||
// Config groups the dependencies used by Consumer.
|
||||
type Config struct {
|
||||
// Client provides XREAD access to the runtime job results 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 post-start game record updates.
|
||||
Games ports.GameStore
|
||||
|
||||
// RuntimeManager publishes stop jobs in the orphan-container path.
|
||||
RuntimeManager ports.RuntimeManager
|
||||
|
||||
// GMClient registers the running game with Game Master after a
|
||||
// successful binding persistence.
|
||||
GMClient ports.GMClient
|
||||
|
||||
// Intents publishes the lobby.runtime_paused_after_start
|
||||
// notification when GM is unavailable.
|
||||
Intents IntentPublisher
|
||||
|
||||
// OffsetStore persists the last successfully processed entry id.
|
||||
OffsetStore ports.StreamOffsetStore
|
||||
|
||||
// Clock supplies the wall-clock used for status transition
|
||||
// timestamps. 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.start_flow.outcomes` and
|
||||
// `lobby.game.transitions` counters per processed result. Optional;
|
||||
// nil disables metric emission.
|
||||
Telemetry *telemetry.Runtime
|
||||
}
|
||||
|
||||
// Consumer drives the runtime-job-results processing loop.
|
||||
type Consumer struct {
|
||||
client *redis.Client
|
||||
stream string
|
||||
blockTimeout time.Duration
|
||||
games ports.GameStore
|
||||
runtimeManager ports.RuntimeManager
|
||||
gmClient ports.GMClient
|
||||
intents IntentPublisher
|
||||
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 runtime job result consumer: nil redis client")
|
||||
case strings.TrimSpace(cfg.Stream) == "":
|
||||
return nil, errors.New("new runtime job result consumer: stream must not be empty")
|
||||
case cfg.BlockTimeout <= 0:
|
||||
return nil, errors.New("new runtime job result consumer: block timeout must be positive")
|
||||
case cfg.Games == nil:
|
||||
return nil, errors.New("new runtime job result consumer: nil game store")
|
||||
case cfg.RuntimeManager == nil:
|
||||
return nil, errors.New("new runtime job result consumer: nil runtime manager")
|
||||
case cfg.GMClient == nil:
|
||||
return nil, errors.New("new runtime job result consumer: nil gm client")
|
||||
case cfg.Intents == nil:
|
||||
return nil, errors.New("new runtime job result consumer: nil intent publisher")
|
||||
case cfg.OffsetStore == nil:
|
||||
return nil, errors.New("new runtime job result 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,
|
||||
runtimeManager: cfg.RuntimeManager,
|
||||
gmClient: cfg.GMClient,
|
||||
intents: cfg.Intents,
|
||||
offsetStore: cfg.OffsetStore,
|
||||
clock: clock,
|
||||
logger: logger.With("worker", "lobby.runtimejobresult", "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.
|
||||
func (consumer *Consumer) Run(ctx context.Context) error {
|
||||
if consumer == nil || consumer.client == nil {
|
||||
return errors.New("run runtime job result consumer: nil consumer")
|
||||
}
|
||||
if ctx == nil {
|
||||
return errors.New("run runtime job result 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 runtime job result consumer: load offset: %w", err)
|
||||
}
|
||||
if !found {
|
||||
lastID = "0-0"
|
||||
}
|
||||
|
||||
consumer.logger.Info("runtime job result consumer started", "block_timeout", consumer.blockTimeout.String(), "start_entry_id", lastID)
|
||||
defer consumer.logger.Info("runtime job result 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 {
|
||||
consumer.HandleMessage(ctx, message)
|
||||
if err := consumer.offsetStore.Save(ctx, streamOffsetLabel, message.ID); err != nil {
|
||||
return fmt.Errorf("run runtime job result 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 runtime job result consumer: %w", err)
|
||||
default:
|
||||
return fmt.Errorf("run runtime job result 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 runtime job result consumer: nil context")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// HandleMessage processes one Redis Stream message. Exported so tests
|
||||
// can drive the consumer deterministically without spinning up a real
|
||||
// XREAD loop.
|
||||
//
|
||||
// Per-message errors are logged and absorbed: the worker keeps running
|
||||
// and the offset is allowed to advance. CAS-status conflicts (typical
|
||||
// for replayed events) are also absorbed.
|
||||
func (consumer *Consumer) HandleMessage(ctx context.Context, message redis.XMessage) {
|
||||
if consumer == nil {
|
||||
return
|
||||
}
|
||||
|
||||
event, err := decodeJobResult(message)
|
||||
if err != nil {
|
||||
consumer.logger.WarnContext(ctx, "decode runtime job result",
|
||||
"stream_entry_id", message.ID,
|
||||
"err", err.Error(),
|
||||
)
|
||||
return
|
||||
}
|
||||
|
||||
switch event.Outcome {
|
||||
case outcomeFailure:
|
||||
consumer.handleFailure(ctx, message.ID, event)
|
||||
case outcomeSuccess:
|
||||
consumer.handleSuccess(ctx, message.ID, event)
|
||||
default:
|
||||
consumer.logger.WarnContext(ctx, "unknown runtime job outcome",
|
||||
"stream_entry_id", message.ID,
|
||||
"outcome", event.Outcome,
|
||||
"game_id", event.GameID.String(),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
// handleFailure transitions the game from `starting` to `start_failed`.
|
||||
// The CAS-status update absorbs replays naturally: if the game is no
|
||||
// longer in `starting`, the second call returns ErrConflict /
|
||||
// ErrInvalidTransition and the worker treats it as an already-handled
|
||||
// duplicate.
|
||||
func (consumer *Consumer) handleFailure(ctx context.Context, entryID string, event jobResultEvent) {
|
||||
at := consumer.clock().UTC()
|
||||
err := consumer.games.UpdateStatus(ctx, ports.UpdateStatusInput{
|
||||
GameID: event.GameID,
|
||||
ExpectedFrom: game.StatusStarting,
|
||||
To: game.StatusStartFailed,
|
||||
Trigger: game.TriggerRuntimeEvent,
|
||||
At: at,
|
||||
})
|
||||
switch {
|
||||
case err == nil:
|
||||
consumer.telemetry.RecordGameTransition(ctx,
|
||||
string(game.StatusStarting),
|
||||
string(game.StatusStartFailed),
|
||||
string(game.TriggerRuntimeEvent),
|
||||
)
|
||||
consumer.telemetry.RecordStartFlowOutcome(ctx, "start_failed")
|
||||
logArgs := []any{
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", event.GameID.String(),
|
||||
"from_status", string(game.StatusStarting),
|
||||
"to_status", string(game.StatusStartFailed),
|
||||
"trigger", string(game.TriggerRuntimeEvent),
|
||||
"error_code", event.ErrorCode,
|
||||
}
|
||||
logArgs = append(logArgs, logging.ContextAttrs(ctx)...)
|
||||
consumer.logger.InfoContext(ctx, "game start failed", logArgs...)
|
||||
case errors.Is(err, game.ErrConflict), errors.Is(err, game.ErrInvalidTransition):
|
||||
consumer.logger.InfoContext(ctx, "ignored runtime failure for game not in starting",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", event.GameID.String(),
|
||||
)
|
||||
default:
|
||||
consumer.logger.WarnContext(ctx, "transition game to start_failed",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", event.GameID.String(),
|
||||
"err", err.Error(),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
// handleSuccess applies the success-path branches: persist binding,
|
||||
// call GM, transition status. Any failure branches into the
|
||||
// orphan-container or paused-after-start paths defined by the README.
|
||||
//
|
||||
// Replay protection: the worker re-reads the game record up front. If
|
||||
// the record is no longer in `starting`, the event is treated as an
|
||||
// already-handled replay and processing exits without further side
|
||||
// effects (no binding overwrite, no GM call, no status transition).
|
||||
func (consumer *Consumer) handleSuccess(ctx context.Context, entryID string, event jobResultEvent) {
|
||||
at := consumer.clock().UTC()
|
||||
|
||||
if err := event.validateSuccess(); err != nil {
|
||||
consumer.logger.WarnContext(ctx, "invalid runtime job success event",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", event.GameID.String(),
|
||||
"err", err.Error(),
|
||||
)
|
||||
return
|
||||
}
|
||||
|
||||
record, err := consumer.games.Get(ctx, event.GameID)
|
||||
if err != nil {
|
||||
consumer.logger.WarnContext(ctx, "load game for runtime success",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", event.GameID.String(),
|
||||
"err", err.Error(),
|
||||
)
|
||||
return
|
||||
}
|
||||
if record.Status != game.StatusStarting {
|
||||
consumer.logger.InfoContext(ctx, "ignored runtime success for game not in starting",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", record.GameID.String(),
|
||||
"current_status", string(record.Status),
|
||||
)
|
||||
return
|
||||
}
|
||||
|
||||
binding := game.RuntimeBinding{
|
||||
ContainerID: event.ContainerID,
|
||||
EngineEndpoint: event.EngineEndpoint,
|
||||
RuntimeJobID: entryID,
|
||||
BoundAt: at,
|
||||
}
|
||||
if err := consumer.games.UpdateRuntimeBinding(ctx, ports.UpdateRuntimeBindingInput{
|
||||
GameID: event.GameID,
|
||||
Binding: binding,
|
||||
At: at,
|
||||
}); err != nil {
|
||||
consumer.handleOrphan(ctx, entryID, event, at, err)
|
||||
return
|
||||
}
|
||||
|
||||
gmErr := consumer.gmClient.RegisterGame(ctx, ports.RegisterGameRequest{
|
||||
GameID: record.GameID,
|
||||
ContainerID: binding.ContainerID,
|
||||
EngineEndpoint: binding.EngineEndpoint,
|
||||
TargetEngineVersion: record.TargetEngineVersion,
|
||||
TurnSchedule: record.TurnSchedule,
|
||||
})
|
||||
if gmErr != nil {
|
||||
consumer.handleGMUnavailable(ctx, entryID, record, at, gmErr)
|
||||
return
|
||||
}
|
||||
|
||||
if err := consumer.games.UpdateStatus(ctx, ports.UpdateStatusInput{
|
||||
GameID: record.GameID,
|
||||
ExpectedFrom: game.StatusStarting,
|
||||
To: game.StatusRunning,
|
||||
Trigger: game.TriggerRuntimeEvent,
|
||||
At: at,
|
||||
}); err != nil {
|
||||
switch {
|
||||
case errors.Is(err, game.ErrConflict), errors.Is(err, game.ErrInvalidTransition):
|
||||
consumer.logger.InfoContext(ctx, "ignored running transition for game not in starting",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", record.GameID.String(),
|
||||
)
|
||||
default:
|
||||
consumer.logger.WarnContext(ctx, "transition game to running",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", record.GameID.String(),
|
||||
"err", err.Error(),
|
||||
)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
consumer.telemetry.RecordGameTransition(ctx,
|
||||
string(game.StatusStarting),
|
||||
string(game.StatusRunning),
|
||||
string(game.TriggerRuntimeEvent),
|
||||
)
|
||||
consumer.telemetry.RecordStartFlowOutcome(ctx, "running")
|
||||
|
||||
logArgs := []any{
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", record.GameID.String(),
|
||||
"from_status", string(game.StatusStarting),
|
||||
"to_status", string(game.StatusRunning),
|
||||
"trigger", string(game.TriggerRuntimeEvent),
|
||||
}
|
||||
logArgs = append(logArgs, logging.ContextAttrs(ctx)...)
|
||||
consumer.logger.InfoContext(ctx, "game running after runtime registration", logArgs...)
|
||||
}
|
||||
|
||||
// handleOrphan implements the orphan-container path: the container
|
||||
// started but Lobby could not persist the binding metadata. We publish
|
||||
// a stop job to Runtime Manager and transition the game to
|
||||
// `start_failed`. Stop-job dispatch is attempted before the status
|
||||
// transition so a process crash between the two leaves the stop-job
|
||||
// safely re-published on replay (Runtime Manager idempotency is
|
||||
// required).
|
||||
func (consumer *Consumer) handleOrphan(ctx context.Context, entryID string, event jobResultEvent, at time.Time, cause error) {
|
||||
consumer.logger.WarnContext(ctx, "persist runtime binding failed; orphan container path",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", event.GameID.String(),
|
||||
"err", cause.Error(),
|
||||
)
|
||||
if err := consumer.runtimeManager.PublishStopJob(ctx, event.GameID.String()); err != nil {
|
||||
consumer.logger.WarnContext(ctx, "publish stop job for orphan container",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", event.GameID.String(),
|
||||
"err", err.Error(),
|
||||
)
|
||||
}
|
||||
if err := consumer.games.UpdateStatus(ctx, ports.UpdateStatusInput{
|
||||
GameID: event.GameID,
|
||||
ExpectedFrom: game.StatusStarting,
|
||||
To: game.StatusStartFailed,
|
||||
Trigger: game.TriggerRuntimeEvent,
|
||||
At: at,
|
||||
}); err != nil && !errors.Is(err, game.ErrConflict) && !errors.Is(err, game.ErrInvalidTransition) {
|
||||
consumer.logger.WarnContext(ctx, "transition orphan game to start_failed",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", event.GameID.String(),
|
||||
"err", err.Error(),
|
||||
)
|
||||
return
|
||||
}
|
||||
consumer.telemetry.RecordGameTransition(ctx,
|
||||
string(game.StatusStarting),
|
||||
string(game.StatusStartFailed),
|
||||
string(game.TriggerRuntimeEvent),
|
||||
)
|
||||
consumer.telemetry.RecordStartFlowOutcome(ctx, "start_failed")
|
||||
}
|
||||
|
||||
// handleGMUnavailable implements the paused-after-start path: the
|
||||
// container is alive but Game Master could not be registered. The game
|
||||
// is moved to `paused` and an admin notification is published.
|
||||
func (consumer *Consumer) handleGMUnavailable(ctx context.Context, entryID string, record game.Game, at time.Time, cause error) {
|
||||
consumer.logger.WarnContext(ctx, "gm registration failed; pause-after-start path",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", record.GameID.String(),
|
||||
"err", cause.Error(),
|
||||
)
|
||||
if err := consumer.games.UpdateStatus(ctx, ports.UpdateStatusInput{
|
||||
GameID: record.GameID,
|
||||
ExpectedFrom: game.StatusStarting,
|
||||
To: game.StatusPaused,
|
||||
Trigger: game.TriggerRuntimeEvent,
|
||||
At: at,
|
||||
}); err != nil {
|
||||
switch {
|
||||
case errors.Is(err, game.ErrConflict), errors.Is(err, game.ErrInvalidTransition):
|
||||
consumer.logger.InfoContext(ctx, "ignored paused transition for game not in starting",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", record.GameID.String(),
|
||||
)
|
||||
default:
|
||||
consumer.logger.WarnContext(ctx, "transition game to paused",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", record.GameID.String(),
|
||||
"err", err.Error(),
|
||||
)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
consumer.telemetry.RecordGameTransition(ctx,
|
||||
string(game.StatusStarting),
|
||||
string(game.StatusPaused),
|
||||
string(game.TriggerRuntimeEvent),
|
||||
)
|
||||
consumer.telemetry.RecordStartFlowOutcome(ctx, "paused")
|
||||
|
||||
intent, err := notificationintent.NewLobbyRuntimePausedAfterStartIntent(
|
||||
notificationintent.Metadata{
|
||||
IdempotencyKey: "lobby.runtime_paused_after_start:" + entryID,
|
||||
OccurredAt: at,
|
||||
},
|
||||
notificationintent.LobbyRuntimePausedAfterStartPayload{
|
||||
GameID: record.GameID.String(),
|
||||
GameName: record.GameName,
|
||||
},
|
||||
)
|
||||
if err != nil {
|
||||
consumer.logger.ErrorContext(ctx, "build runtime paused intent",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", record.GameID.String(),
|
||||
"err", err.Error(),
|
||||
)
|
||||
return
|
||||
}
|
||||
if _, err := consumer.intents.Publish(ctx, intent); err != nil {
|
||||
consumer.logger.WarnContext(ctx, "publish runtime paused intent",
|
||||
"stream_entry_id", entryID,
|
||||
"game_id", record.GameID.String(),
|
||||
"err", err.Error(),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
// outcomeSuccess and outcomeFailure are the two accepted values of the
|
||||
// runtime job result `outcome` field.
|
||||
const (
|
||||
outcomeSuccess = "success"
|
||||
outcomeFailure = "failure"
|
||||
)
|
||||
|
||||
// jobResultEvent stores the decoded shape of one runtime:job_results
|
||||
// stream entry.
|
||||
type jobResultEvent struct {
|
||||
GameID common.GameID
|
||||
Outcome string
|
||||
ContainerID string
|
||||
EngineEndpoint string
|
||||
ErrorCode string
|
||||
ErrorMessage string
|
||||
}
|
||||
|
||||
func (event jobResultEvent) validateSuccess() error {
|
||||
if strings.TrimSpace(event.ContainerID) == "" {
|
||||
return errors.New("success event missing container_id")
|
||||
}
|
||||
if strings.TrimSpace(event.EngineEndpoint) == "" {
|
||||
return errors.New("success event missing engine_endpoint")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func decodeJobResult(message redis.XMessage) (jobResultEvent, error) {
|
||||
gameIDRaw := optionalString(message.Values, "game_id")
|
||||
if strings.TrimSpace(gameIDRaw) == "" {
|
||||
return jobResultEvent{}, errors.New("missing game_id")
|
||||
}
|
||||
gameID := common.GameID(gameIDRaw)
|
||||
if err := gameID.Validate(); err != nil {
|
||||
return jobResultEvent{}, fmt.Errorf("invalid game_id: %w", err)
|
||||
}
|
||||
outcome := optionalString(message.Values, "outcome")
|
||||
if outcome != outcomeSuccess && outcome != outcomeFailure {
|
||||
return jobResultEvent{}, fmt.Errorf("unsupported outcome %q", outcome)
|
||||
}
|
||||
|
||||
return jobResultEvent{
|
||||
GameID: gameID,
|
||||
Outcome: outcome,
|
||||
ContainerID: optionalString(message.Values, "container_id"),
|
||||
EngineEndpoint: optionalString(message.Values, "engine_endpoint"),
|
||||
ErrorCode: optionalString(message.Values, "error_code"),
|
||||
ErrorMessage: optionalString(message.Values, "error_message"),
|
||||
}, 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