Ilia Denisov
95 lines
2.9 KiB
Go
95 lines
2.9 KiB
Go
// Package streamoffsets implements the Redis-backed adapter for
|
|
// `ports.StreamOffsetStore`.
|
|
//
|
|
// In v1 the only consumer that calls Load/Save is the
|
|
// runtime:health_events worker (PLAN stage 18). Keys are produced by
|
|
// `redisstate.Keyspace.StreamOffset`, mirroring the lobby and rtmanager
|
|
// patterns.
|
|
package streamoffsets
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
|
|
"galaxy/gamemaster/internal/adapters/redisstate"
|
|
"galaxy/gamemaster/internal/ports"
|
|
|
|
"github.com/redis/go-redis/v9"
|
|
)
|
|
|
|
// Config configures one Redis-backed stream-offset store. The store
|
|
// does not own the redis client lifecycle; the caller (typically the
|
|
// service runtime) opens and closes it.
|
|
type Config struct {
|
|
Client *redis.Client
|
|
}
|
|
|
|
// Store persists Game Master stream consumer offsets in Redis.
|
|
type Store struct {
|
|
client *redis.Client
|
|
keys redisstate.Keyspace
|
|
}
|
|
|
|
// New constructs one Redis-backed stream-offset store from cfg.
|
|
func New(cfg Config) (*Store, error) {
|
|
if cfg.Client == nil {
|
|
return nil, errors.New("new gamemaster stream offset store: nil redis client")
|
|
}
|
|
return &Store{
|
|
client: cfg.Client,
|
|
keys: redisstate.Keyspace{},
|
|
}, nil
|
|
}
|
|
|
|
// Load returns the last processed entry id for streamLabel when one
|
|
// is stored. A missing key returns ("", false, nil).
|
|
func (store *Store) Load(ctx context.Context, streamLabel string) (string, bool, error) {
|
|
if store == nil || store.client == nil {
|
|
return "", false, errors.New("load gamemaster stream offset: nil store")
|
|
}
|
|
if ctx == nil {
|
|
return "", false, errors.New("load gamemaster stream offset: nil context")
|
|
}
|
|
if strings.TrimSpace(streamLabel) == "" {
|
|
return "", false, errors.New("load gamemaster stream offset: stream label must not be empty")
|
|
}
|
|
|
|
value, err := store.client.Get(ctx, store.keys.StreamOffset(streamLabel)).Result()
|
|
switch {
|
|
case errors.Is(err, redis.Nil):
|
|
return "", false, nil
|
|
case err != nil:
|
|
return "", false, fmt.Errorf("load gamemaster stream offset: %w", err)
|
|
}
|
|
return value, true, nil
|
|
}
|
|
|
|
// Save stores entryID as the new offset for streamLabel. The key has
|
|
// no TTL — offsets are durable and only overwritten by subsequent
|
|
// Saves.
|
|
func (store *Store) Save(ctx context.Context, streamLabel, entryID string) error {
|
|
if store == nil || store.client == nil {
|
|
return errors.New("save gamemaster stream offset: nil store")
|
|
}
|
|
if ctx == nil {
|
|
return errors.New("save gamemaster stream offset: nil context")
|
|
}
|
|
if strings.TrimSpace(streamLabel) == "" {
|
|
return errors.New("save gamemaster stream offset: stream label must not be empty")
|
|
}
|
|
if strings.TrimSpace(entryID) == "" {
|
|
return errors.New("save gamemaster stream offset: entry id must not be empty")
|
|
}
|
|
|
|
if err := store.client.Set(ctx, store.keys.StreamOffset(streamLabel), entryID, 0).Err(); err != nil {
|
|
return fmt.Errorf("save gamemaster stream offset: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Ensure Store satisfies the ports.StreamOffsetStore interface at
|
|
// compile time.
|
|
var _ ports.StreamOffsetStore = (*Store)(nil)
|