0
0
package delivery
import (
"context"
"path/filepath"
"strings"
"sync"
"time"
"github.com/johnandersen777/socialweb-computer-kcp/internal/contract/events"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/fsx"
)
type Snapshot struct {
Started bool
Cursor int64
LastEventAt time.Time
Lag int64
Err error
}
type TrackerConfig struct {
CountGaps bool
Seed int64
}
type Tracker struct {
gaps bool
mu sync.Mutex
s Snapshot
}
func NewTracker(cfg TrackerConfig) *Tracker {
t := &Tracker{gaps: cfg.CountGaps}
if cfg.Seed > 0 {
t.s.Cursor = cfg.Seed
}
return t
}
func (t *Tracker) Observe(e events.Event, gapless bool) bool {
at := e.Time
if at.IsZero() {
at = time.Now().UTC()
}
t.mu.Lock()
defer t.mu.Unlock()
transition := !t.s.Started || t.s.Err != nil
t.s.Lag = 0
if t.gaps && !gapless && t.s.Started && e.Seq > t.s.Cursor+1 {
t.s.Lag = e.Seq - t.s.Cursor - 1
}
t.s.Started, t.s.Cursor, t.s.LastEventAt, t.s.Err = true, e.Seq, at, nil
return transition
}
func (t *Tracker) Fail(err error) {
t.mu.Lock()
defer t.mu.Unlock()
t.s.Err = err
}
func (t *Tracker) Recover() {
t.mu.Lock()
defer t.mu.Unlock()
t.s.Err = nil
}
func (t *Tracker) Snapshot() Snapshot {
t.mu.Lock()
defer t.mu.Unlock()
return t.s
}
type Tracked struct {
stream events.Stream
tracker *Tracker
changed func()
progress func()
gapless bool
}
var _ events.Stream = (*Tracked)(nil)
func NewTracked(stream events.Stream, tracker *Tracker, changed, progress func()) *Tracked {
if progress == nil {
progress = changed
}
return &Tracked{stream: stream, tracker: tracker, changed: changed, progress: progress}
}
func (t *Tracked) Next(ctx context.Context) (events.Event, error) {
event, err := t.stream.Next(ctx)
if err != nil {
if ctx.Err() == nil {
t.tracker.Fail(err)
t.changed()
}
return event, err
}
if event.ServerFilter != nil {
t.gapless = event.ServerFilter.Gapless()
return event, nil
}
if t.tracker.Observe(event, t.gapless) {
t.changed()
} else {
t.progress()
}
return event, nil
}
func (t *Tracked) Close() error {
return t.stream.Close()
}
var _ events.CursorStore = CursorStore{}
type CursorStore struct {
dir string
}
type cursorFile struct {
UID string `json:"uid"`
Cursor int64 `json:"cursor"`
SavedAt time.Time `json:"savedAt,omitzero"`
}
func NewCursorStore(dir string) CursorStore {
return CursorStore{dir: strings.TrimSpace(dir)}
}
func (s CursorStore) path(workspace, name string) string {
clean := func(v string) string {
return strings.Map(func(r rune) rune {
switch {
case r >= 'a' && r <= 'z', r >= 'A' && r <= 'Z', r >= '0' && r <= '9', r == '-', r == '.', r == '_':
return r
default:
return '_'
}
}, strings.TrimSpace(v))
}
return filepath.Join(s.dir, clean(workspace), clean(name)+".json")
}
func (s CursorStore) Load(workspace, name, uid string) (events.SavedCursor, bool) {
if s.dir == "" {
return events.SavedCursor{}, false
}
var f cursorFile
if err := fsx.ReadJSON(s.path(workspace, name), &f); err != nil || f.UID != uid {
return events.SavedCursor{}, false
}
return events.SavedCursor{Cursor: f.Cursor, SavedAt: f.SavedAt}, true
}
func (s CursorStore) Save(workspace, name, uid string, cursor int64) error {
if s.dir == "" {
return nil
}
return fsx.WriteJSON(s.path(workspace, name), cursorFile{UID: uid, Cursor: cursor, SavedAt: time.Now().UTC()}, 0o600)
}