From 4afc210cc1f7455185206899918a612267caf715 Mon Sep 17 00:00:00 2001 From: zjxxzjwang Date: Tue, 27 Oct 2026 17:41:51 +0800 Subject: [PATCH 1/2] [fix][tableview] Cancel reader context in Close() to prevent potential deadlock --- pulsar/table_view_impl.go | 1 + pulsar/table_view_test.go | 40 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 41 insertions(+) diff --git a/pulsar/table_view_impl.go b/pulsar/table_view_impl.go index 43aa007783..204fca4b20 100644 --- a/pulsar/table_view_impl.go +++ b/pulsar/table_view_impl.go @@ -237,6 +237,7 @@ func (tv *TableViewImpl) Close() { if !tv.closed { tv.closed = true for _, cancelReader := range tv.cancelReaders { + cancelReader.cancelFunc() cancelReader.reader.Close() } close(tv.closedCh) diff --git a/pulsar/table_view_test.go b/pulsar/table_view_test.go index b3e04864ad..b9524fd226 100644 --- a/pulsar/table_view_test.go +++ b/pulsar/table_view_test.go @@ -25,6 +25,7 @@ import ( "time" pb "github.com/apache/pulsar-client-go/integration-tests/pb" + "github.com/apache/pulsar-client-go/pulsar/log" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) @@ -593,3 +594,42 @@ func TestTableViewEntriesIntegration(t *testing.T) { } } } + +// mockReader is a minimal Reader stub whose Next blocks until ctx is cancelled. +type mockReader struct { + topic string +} + +func (m *mockReader) Topic() string { return m.topic } +func (m *mockReader) Next(ctx context.Context) (Message, error) { <-ctx.Done(); return nil, ctx.Err() } +func (m *mockReader) HasNext() bool { return false } +func (m *mockReader) Close() {} +func (m *mockReader) Seek(MessageID) error { return nil } +func (m *mockReader) SeekByTime(time.Time) error { return nil } +func (m *mockReader) GetLastMessageID() (MessageID, error) { return nil, nil } + +// TestCloseCallsCancelFuncToAvoidDeadlock verifies that Close() cancels +// each reader's context so that watchReaderForNewMessages can exit and +// Close() does not deadlock. +func TestCloseCallsCancelFuncToAvoidDeadlock(t *testing.T) { + tv := &TableViewImpl{ + data: make(map[string]interface{}), + cancelReaders: make(map[string]cancelReader), + logger: log.DefaultNopLogger(), + closedCh: make(chan struct{}), + } + + ctx, cancel := context.WithCancel(context.Background()) + reader := &mockReader{topic: "test-topic"} + tv.cancelReaders["test-topic"] = cancelReader{reader: reader, cancelFunc: cancel} + go tv.watchReaderForNewMessages(ctx, reader) + + done := make(chan struct{}) + go func() { tv.Close(); close(done) }() + + select { + case <-done: + case <-time.After(3 * time.Second): + t.Fatal("Close() deadlocked: cancelFunc() was probably not called") + } +} From 2fbaabd0e610a7fda489a19299f2b40d95bbc327 Mon Sep 17 00:00:00 2001 From: zjxxzjwang Date: Mon, 9 Nov 2026 00:57:06 +0800 Subject: [PATCH 2/2] [fix][tableview] Cancel reader context in Close() to prevent potential deadlock --- pulsar/table_view_test.go | 42 +++++++++++++++++++++++++++++---------- 1 file changed, 31 insertions(+), 11 deletions(-) diff --git a/pulsar/table_view_test.go b/pulsar/table_view_test.go index 695e045a85..b1b264a826 100644 --- a/pulsar/table_view_test.go +++ b/pulsar/table_view_test.go @@ -802,22 +802,25 @@ func (m *mockMessage) GetEncryptionContext() *EncryptionContext { return nil } func (m *mockMessage) Index() *uint64 { return nil } func (m *mockMessage) BrokerPublishTime() *time.Time { return nil } -// mockReader is a minimal Reader stub whose Next blocks until ctx is cancelled. -type mockReader struct { - topic string +// blockingCloseReader wraps a Reader and makes Close() block until the +// given channel is closed. This models the real reader.Close() → +// consumer.closeWithCause() → wg.Wait() behaviour. +type blockingCloseReader struct { + Reader + nextExited chan struct{} } -func (m *mockReader) Topic() string { return m.topic } -func (m *mockReader) Next(ctx context.Context) (Message, error) { <-ctx.Done(); return nil, ctx.Err() } -func (m *mockReader) HasNext() bool { return false } -func (m *mockReader) Close() {} -func (m *mockReader) Seek(MessageID) error { return nil } -func (m *mockReader) SeekByTime(time.Time) error { return nil } -func (m *mockReader) GetLastMessageID() (MessageID, error) { return nil, nil } +func (b *blockingCloseReader) Close() { + <-b.nextExited +} // TestCloseCallsCancelFuncToAvoidDeadlock verifies that Close() cancels // each reader's context so that watchReaderForNewMessages can exit and // Close() does not deadlock. +// +// The mock models the real shutdown coupling: Close() blocks until Next() +// returns. Without the cancelFunc() call, Next() never unblocks, Close() +// never returns, and the test times out. func TestCloseCallsCancelFuncToAvoidDeadlock(t *testing.T) { tv := &TableViewImpl{ data: make(map[string]interface{}), @@ -826,11 +829,28 @@ func TestCloseCallsCancelFuncToAvoidDeadlock(t *testing.T) { closedCh: make(chan struct{}), } + entered := make(chan struct{}) // closed when Next() enters its blocking wait + nextExited := make(chan struct{}) // closed when Next() returns + ctx, cancel := context.WithCancel(context.Background()) - reader := &mockReader{topic: "test-topic"} + reader := &blockingCloseReader{ + Reader: &mockReader{ + topic: "test-topic", + nextFn: func(ctx context.Context, _ int32) (Message, error) { + close(entered) + <-ctx.Done() + close(nextExited) + return nil, ctx.Err() + }, + }, + nextExited: nextExited, + } tv.cancelReaders["test-topic"] = cancelReader{reader: reader, cancelFunc: cancel} go tv.watchReaderForNewMessages(ctx, reader) + // Wait until Next() is entered so the deadlock scenario is fully set up. + <-entered + done := make(chan struct{}) go func() { tv.Close(); close(done) }()