Ilia Denisov
95 lines
3.0 KiB
Go
95 lines
3.0 KiB
Go
// Package streamoffsets implements the Redis-backed adapter for
|
|
// `ports.StreamOffsetStore`.
|
|
//
|
|
// The start-jobs and stop-jobs consumers call Load on startup to
|
|
// resume from the persisted offset and Save after every successful
|
|
// message handling. Keys are produced by
|
|
// `redisstate.Keyspace.StreamOffset`, mirroring the lobby pattern.
|
|
package streamoffsets
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
|
|
"galaxy/rtmanager/internal/adapters/redisstate"
|
|
"galaxy/rtmanager/internal/ports"
|
|
|
|
"github.com/redis/go-redis/v9"
|
|
)
|
|
|
|
// Config configures one Redis-backed stream-offset store instance. The
|
|
// store does not own the redis client lifecycle; the caller (typically
|
|
// the service runtime) opens and closes it.
|
|
type Config struct {
|
|
// Client stores the Redis client the store uses for every command.
|
|
Client *redis.Client
|
|
}
|
|
|
|
// Store persists Runtime Manager 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 rtmanager 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 rtmanager stream offset: nil store")
|
|
}
|
|
if ctx == nil {
|
|
return "", false, errors.New("load rtmanager stream offset: nil context")
|
|
}
|
|
if strings.TrimSpace(streamLabel) == "" {
|
|
return "", false, errors.New("load rtmanager 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 rtmanager 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 rtmanager stream offset: nil store")
|
|
}
|
|
if ctx == nil {
|
|
return errors.New("save rtmanager stream offset: nil context")
|
|
}
|
|
if strings.TrimSpace(streamLabel) == "" {
|
|
return errors.New("save rtmanager stream offset: stream label must not be empty")
|
|
}
|
|
if strings.TrimSpace(entryID) == "" {
|
|
return errors.New("save rtmanager 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 rtmanager stream offset: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Ensure Store satisfies the ports.StreamOffsetStore interface at
|
|
// compile time.
|
|
var _ ports.StreamOffsetStore = (*Store)(nil)
|