Skip to content

tetragon: handle test events sequentially #4291

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 1 commit into
base: main
Choose a base branch
from
+43 −34
Open

tetragon: handle test events sequentially #4291

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
77 changes: 43 additions & 34 deletions pkg/testutils/perfring/perfring.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -100,83 +100,77 @@ func ProcessEvents(t *testing.T, ctx context.Context, eventFn EventFn, wgStarted

wgStarted.Done()

errChan := make(chan error)
errChan := make(chan error, 2)
defer close(errChan)

complChan := make(chan bool)
complChan := make(chan bool, 2)
defer close(complChan)

// Create an events queue that both the ring buffers can send to.
// This means we can handle the events sequentially by reading from the
// queue, avoiding issues of handling events concurrently.
type testEvent struct {
RawSample *[]byte
ComplChecker *testsensor.CompletionChecker
Ctx context.Context
CancelFunc context.CancelFunc
}

eventsQueue := make(chan *testEvent, 65536) // arbitrary size for tests

var wg sync.WaitGroup
wg.Add(1)
ctxPerfRing, cancelPerfRing := context.WithCancel(ctx)
defer wg.Wait()

go func() {
defer wg.Done()

complChecker := testsensor.NewCompletionChecker()

for ctx.Err() == nil {
for ctxPerfRing.Err() == nil {

record, err := perfReader.Read()
if err != nil {
if ctx.Err() == nil && !errors.Is(err, os.ErrClosed) {
if ctxPerfRing.Err() == nil && !errors.Is(err, os.ErrClosed) {
errChan <- fmt.Errorf("error reading perfring data: %w", err)
}
break
}

if len(record.RawSample) > 0 {
_, events, handlerErr := observer.HandlePerfData(record.RawSample)
if handlerErr != nil {
errChan <- fmt.Errorf("error handling perfring data: %w", handlerErr)
break
}
err = loopEvents(events, eventFn, complChecker)
if err != nil {
errChan <- fmt.Errorf("error loop event function returned: %w", err)
break
}
if complChecker.Done() || ctxPerfRing.Err() != nil {
Copy link
Contributor

@kkourt kkourt Nov 12, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

What happens if there is a ctxPerfRing error? Do we propagate it to the test somehow?
The benefit of having t *testing.T is that we can just fail the test, but we do not seem to be doing that.

Copy link
Contributor Author

@kevsecurity kevsecurity Nov 12, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

We use ctxPerfRing only to indicate that we are done. I don't think we need to propagate any errors. What errors did you have in mind?

break
}

if complChecker.Done() {
complChan <- true
break
if len(record.RawSample) > 0 {
eventsQueue <- &testEvent{&record.RawSample, complChecker, ctxPerfRing, cancelPerfRing}
}
}
}()

if useBPFRingBuffer {
// Service the BPF ring buffer.
ctxBPFRing, cancelBPFRing := context.WithCancel(ctx)
wg.Go(func() {

complChecker := testsensor.NewCompletionChecker()

for ctx.Err() == nil {
for ctxBPFRing.Err() == nil {

record, err := ringBufReader.Read()
if err != nil {
if ctx.Err() == nil && !errors.Is(err, os.ErrClosed) {
if ctxBPFRing.Err() == nil && !errors.Is(err, os.ErrClosed) {
errChan <- fmt.Errorf("error reading ringbuf data: %w", err)
}
break
}

if len(record.RawSample) > 0 {
_, events, handlerErr := observer.HandlePerfData(record.RawSample)
if handlerErr != nil {
errChan <- fmt.Errorf("error handling ringbuf data: %w", handlerErr)
break
}
err = loopEvents(events, eventFn, complChecker)
if err != nil {
errChan <- fmt.Errorf("error loop event function returned: %w", err)
break
}
if complChecker.Done() || ctxBPFRing.Err() != nil {
Copy link
Contributor

@kkourt kkourt Nov 12, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Similarly for this error here.

break
}

if complChecker.Done() {
complChan <- true
break
if len(record.RawSample) > 0 {
eventsQueue <- &testEvent{&record.RawSample, complChecker, ctxBPFRing, cancelBPFRing}
}
}
})
Expand All @@ -189,6 +183,21 @@ func ProcessEvents(t *testing.T, ctx context.Context, eventFn EventFn, wgStarted
}
for {
select {
case event := <-eventsQueue:
_, events, handlerErr := observer.HandlePerfData(*event.RawSample)
if handlerErr != nil {
errChan <- fmt.Errorf("error handling ringbuf data: %w", handlerErr)
break
}
err = loopEvents(events, eventFn, event.ComplChecker)
if err != nil {
errChan <- fmt.Errorf("error loop event function returned: %w", err)
break
}
if event.ComplChecker.Done() && event.Ctx.Err() == nil {
event.CancelFunc()
complChan <- true
}
case err := <-errChan:
t.Fatal(err)
case <-complChan:
Expand Down
Loading