Skip to content

RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.

fix(harness): return empty iterator when seek clock exceeds event log (#20726)

NanPan6ef1351190fc
diff --git a/internal/harness/events/localfile.go b/internal/harness/events/localfile.go
index 524dfde289..a729fedada 100644
--- a/internal/harness/events/localfile.go
+++ b/internal/harness/events/localfile.go
@@ -223,13 +223,12 @@ func (s *LocalFileEventStore) Seek(ctx context.Context, clock uint64) (EventIter
s.mu.RLock()
defer s.mu.RUnlock()
- pos := 0
+ pos := len(s.cached)
for i, ev := range s.cached {
if ev.Clock >= clock {
pos = i
break
}
- _ = i
}
return &sliceIterator{events: s.cached[pos:], pos: 0}, nil
}
diff --git a/internal/harness/events/memory.go b/internal/harness/events/memory.go
index 68e02dcd11..741b11fa89 100644
--- a/internal/harness/events/memory.go
+++ b/internal/harness/events/memory.go
@@ -106,13 +106,12 @@ func (s *MemoryEventStore) Seek(ctx context.Context, clock uint64) (EventIterato
s.mu.RLock()
defer s.mu.RUnlock()
- pos := 0
+ pos := len(s.events)
for i, ev := range s.events {
if ev.Clock >= clock {
pos = i
break
}
- _ = i
}
return &sliceIterator{events: s.events[pos:], pos: 0}, nil
}
diff --git a/internal/harness/events/seek_boundary_test.go b/internal/harness/events/seek_boundary_test.go
new file mode 100644
index 0000000000..6ed4f78f07
--- /dev/null
+++ b/internal/harness/events/seek_boundary_test.go
@@ -0,0 +1,81 @@
+package events
+
+import (
+ "slices"
+ "testing"
+ "time"
+)
+
+// TestEventStoreSeekBoundaries checks both local EventLog implementations.
+// Seeking past the final logical clock must yield no events, not a replay
+// of the entire log.
+func TestEventStoreSeekBoundaries(t *testing.T) {
+ stores := []struct {
+ name string
+ new func(*testing.T) EventLog
+ }{
+ {"memory", func(t *testing.T) EventLog { return NewMemoryEventStore() }},
+ {"local-file", func(t *testing.T) EventLog {
+ s, err := NewLocalFileEventStore(t.TempDir())
+ if err != nil {
+ t.Fatalf("new local store: %v", err)
+ }
+ return s
+ }},
+ }
+
+ for _, tc := range stores {
+ t.Run(tc.name, func(t *testing.T) {
+ store := tc.new(t)
+ ctx := t.Context()
+
+ // Empty logs always return an exhausted iterator.
+ empty, err := store.Seek(ctx, 1)
+ if err != nil {
+ t.Fatalf("seek empty log: %v", err)
+ }
+ if event, ok := empty.Next(ctx); ok {
+ t.Fatalf("empty log returned event %+v", event)
+ }
+ _ = empty.Close()
+
+ if err := store.Append(ctx,
+ &Event{ID: "seek-1", Type: EventStepStart, Clock: 1, TraceID: "seek", Timestamp: time.Now()},
+ &Event{ID: "seek-3", Type: EventStepEnd, Clock: 3, TraceID: "seek", Timestamp: time.Now()},
+ ); err != nil {
+ t.Fatalf("append events: %v", err)
+ }
+
+ cases := []struct {
+ clock uint64
+ want []uint64
+ }{
+ {0, []uint64{1, 3}},
+ {1, []uint64{1, 3}},
+ {2, []uint64{3}},
+ {3, []uint64{3}},
+ {4, nil},
+ }
+ for _, c := range cases {
+ iter, err := store.Seek(ctx, c.clock)
+ if err != nil {
+ t.Fatalf("seek clock %d: %v", c.clock, err)
+ }
+ var got []uint64
+ for {
+ event, ok := iter.Next(ctx)
+ if !ok {
+ break
+ }
+ got = append(got, event.Clock)
+ }
+ if err := iter.Close(); err != nil {
+ t.Fatalf("close iterator at %d: %v", c.clock, err)
+ }
+ if !slices.Equal(got, c.want) {
+ t.Fatalf("seek clock %d: got %v, want %v", c.clock, got, c.want)
+ }
+ }
+ })
+ }
+}