From 30aea9ac9a712ebff47518a297ffdeb5237ba69d Mon Sep 17 00:00:00 2001 From: eblackbu <40918195+eblackbu@users.noreply.github.com> Date: Fri, 30 Oct 2026 14:34:44 +0300 Subject: [PATCH 1/5] Fix async session pool slot leak on keep-alive failure --- CHANGELOG.md | 2 ++ tests/aio/test_session_pool.py | 56 ++++++++++++++++++++++++++++++++++ ydb/aio/table.py | 2 +- 3 files changed, 59 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 51700d4f5..ed4cf67bc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,5 @@ +* Fix async table session pool capacity leaking when keeping an idle session alive fails or is cancelled + ## 3.34.0 ## * Remove `AAA Certificate Services` and `emSign ECC Root CA - G3` from the bundled TLS trust store to reject certificate chains affected by the eMudhra CA compromise * Fix topic writer batching to include message metadata and protobuf overhead in request size calculations diff --git a/tests/aio/test_session_pool.py b/tests/aio/test_session_pool.py index af1ef3515..852f460fc 100644 --- a/tests/aio/test_session_pool.py +++ b/tests/aio/test_session_pool.py @@ -1,7 +1,9 @@ import asyncio +from unittest.mock import AsyncMock, Mock import pytest import ydb +from ydb.aio.table import Session @pytest.mark.asyncio @@ -144,3 +146,57 @@ async def test_no_session_leak(driver, docker_project): docker_project.start() await pool.stop() + + +@pytest.fixture +async def mock_session_pool(): + driver = Mock() + driver.wait = AsyncMock() + + def create_session(): + session = Mock(spec=Session) + session.create.return_value = session + session.initialized.return_value = True + session.closing.return_value = False + session.pending_query.return_value = False + return session + + driver.table_client.session.side_effect = create_session + pool = ydb.aio.SessionPool(driver, 1) + try: + yield pool + finally: + await pool.stop() + + +@pytest.mark.asyncio +@pytest.mark.parametrize("error", [ydb.BadSession, ydb.ConnectionLost, asyncio.CancelledError]) +async def test_keep_alive_failure_frees_pool_slot(mock_session_pool, error): + pool = mock_session_pool + session = await pool.acquire(timeout=1) + session.keep_alive.side_effect = error("KeepAlive failed") + + await asyncio.gather(pool._send_keep_alive(session), return_exceptions=True) + + session.delete.assert_awaited_once_with(pool._req_settings) + assert pool._active_count == 0 + assert pool._active_queue.empty() + + replacement = await pool.acquire(timeout=1) + assert replacement is not session + await pool.release(replacement) + + +@pytest.mark.asyncio +async def test_keep_alive_success_reuses_session(mock_session_pool): + pool = mock_session_pool + session = await pool.acquire(timeout=1) + + await pool._send_keep_alive(session) + + session.keep_alive.assert_awaited_once_with(pool._req_settings) + session.delete.assert_not_called() + assert pool._active_count == 1 + reused = await pool.acquire(timeout=1) + assert reused is session + await pool.release(reused) diff --git a/ydb/aio/table.py b/ydb/aio/table.py index 136c02004..888121586 100644 --- a/ydb/aio/table.py +++ b/ydb/aio/table.py @@ -730,8 +730,8 @@ async def _send_keep_alive(self, session: typing.Optional[ydb.ISession]) -> bool if self._should_stop.is_set(): self._destroy(session) return False - await session.keep_alive(self._req_settings) try: + await session.keep_alive(self._req_settings) await self.release(typing.cast(Session, session)) except BaseException: # pylint: disable=W0703 self._destroy(session) From 64f8893b049901f7c972cd4fbcf3b54ab76d9fd8 Mon Sep 17 00:00:00 2001 From: Denis Romashin Date: Mon, 2 Nov 2026 10:55:41 +0300 Subject: [PATCH 2/5] Fix async task cleanup and markers in SDK tests --- ydb/_topic_common/common_test.py | 59 ++++++++++++++++++++++++++++++- ydb/_topic_common/test_helpers.py | 9 +++-- 2 files changed, 65 insertions(+), 3 deletions(-) diff --git a/ydb/_topic_common/common_test.py b/ydb/_topic_common/common_test.py index 45cab316b..1a8e5ac62 100644 --- a/ydb/_topic_common/common_test.py +++ b/ydb/_topic_common/common_test.py @@ -7,6 +7,7 @@ import pytest from .common import CallFromSyncToAsync +from .test_helpers import WaitConditionError, wait_for_fast from .._grpc.grpcwrapper.common_utils import ( GrpcWrapperAsyncIO, ServerStatus, @@ -133,7 +134,6 @@ def test_failed(self): issues._process_response(status) -@pytest.mark.asyncio class TestCallFromSyncToAsync: @pytest.fixture() def caller(self, separate_loop): @@ -288,3 +288,60 @@ def callback(): with pytest.raises(TestError): caller.call_sync(callback) assert callback_eventloop is separate_loop + + +@pytest.mark.asyncio +class TestWaitForFast: + async def test_timeout_cancels_and_waits_for_pending_task(self): + queue = asyncio.Queue() + task = asyncio.create_task(queue.get()) + try: + with pytest.raises(WaitConditionError): + await wait_for_fast(task, timeout=0) + + assert task.cancelled() + queue.put_nowait("message") + assert queue.get_nowait() == "message" + finally: + task.cancel() + await asyncio.gather(task, return_exceptions=True) + + async def test_cancellation_waits_for_pending_task_cleanup(self): + started = asyncio.Event() + cleaned_up = asyncio.Event() + + async def wait_for_message(): + started.set() + try: + await asyncio.Queue().get() + finally: + await asyncio.sleep(0) + cleaned_up.set() + + task = asyncio.create_task(wait_for_message()) + waiter = asyncio.create_task(wait_for_fast(task, timeout=5)) + try: + await asyncio.wait_for(started.wait(), timeout=1) + waiter.cancel() + with pytest.raises(asyncio.CancelledError): + await waiter + + assert task.cancelled() + assert cleaned_up.is_set() + finally: + waiter.cancel() + task.cancel() + await asyncio.gather(waiter, task, return_exceptions=True) + + async def test_returns_completed_result(self): + future = asyncio.get_running_loop().create_future() + future.set_result("message") + + assert await wait_for_fast(future) == "message" + + async def test_preserves_task_error(self): + async def fail(): + raise ValueError("test error") + + with pytest.raises(ValueError, match="test error"): + await wait_for_fast(fail()) diff --git a/ydb/_topic_common/test_helpers.py b/ydb/_topic_common/test_helpers.py index 5df3c80b1..9a49a4e24 100644 --- a/ydb/_topic_common/test_helpers.py +++ b/ydb/_topic_common/test_helpers.py @@ -74,5 +74,10 @@ async def wait_for_fast( timeout: typing.Optional[typing.Union[float, int]] = None, ): fut = asyncio.ensure_future(awaitable) - await wait_condition(lambda: fut.done(), timeout) - return fut.result() + try: + await wait_condition(lambda: fut.done(), timeout) + return fut.result() + finally: + if not fut.done(): + fut.cancel() + await asyncio.gather(fut, return_exceptions=True) From b5aba219f5dc5cf2cf5c11e73b88e61430f7a116 Mon Sep 17 00:00:00 2001 From: Denis Romashin Date: Mon, 2 Nov 2026 11:02:29 +0300 Subject: [PATCH 3/5] Use pytest fixtures and monkeypatch for keep-alive regressions --- tests/aio/test_session_pool.py | 62 ++++++++++++++++++++++------------ 1 file changed, 41 insertions(+), 21 deletions(-) diff --git a/tests/aio/test_session_pool.py b/tests/aio/test_session_pool.py index 852f460fc..c12b079a6 100644 --- a/tests/aio/test_session_pool.py +++ b/tests/aio/test_session_pool.py @@ -1,9 +1,9 @@ import asyncio -from unittest.mock import AsyncMock, Mock +from types import SimpleNamespace import pytest import ydb -from ydb.aio.table import Session +from ydb.aio.table import Session, TableClient @pytest.mark.asyncio @@ -149,19 +149,27 @@ async def test_no_session_leak(driver, docker_project): @pytest.fixture -async def mock_session_pool(): - driver = Mock() - driver.wait = AsyncMock() - - def create_session(): - session = Mock(spec=Session) - session.create.return_value = session - session.initialized.return_value = True - session.closing.return_value = False - session.pending_query.return_value = False +def session_deletions(): + return [] + + +@pytest.fixture +async def session_pool(monkeypatch, session_deletions): + async def wait(timeout): + pass + + async def create_session(session, settings=None): + session._state.set_id(f"test-session-{id(session)}") return session - driver.table_client.session.side_effect = create_session + async def delete_session(session, settings=None): + session_deletions.append((session, settings)) + session.reset() + + monkeypatch.setattr(Session, "create", create_session) + monkeypatch.setattr(Session, "delete", delete_session) + driver = SimpleNamespace(wait=wait) + driver.table_client = TableClient(driver) pool = ydb.aio.SessionPool(driver, 1) try: yield pool @@ -171,14 +179,19 @@ def create_session(): @pytest.mark.asyncio @pytest.mark.parametrize("error", [ydb.BadSession, ydb.ConnectionLost, asyncio.CancelledError]) -async def test_keep_alive_failure_frees_pool_slot(mock_session_pool, error): - pool = mock_session_pool +async def test_keep_alive_failure_frees_pool_slot(session_pool, session_deletions, monkeypatch, error): + pool = session_pool session = await pool.acquire(timeout=1) - session.keep_alive.side_effect = error("KeepAlive failed") + + async def fail_keep_alive(settings): + raise error("KeepAlive failed") + + monkeypatch.setattr(session, "keep_alive", fail_keep_alive) await asyncio.gather(pool._send_keep_alive(session), return_exceptions=True) - session.delete.assert_awaited_once_with(pool._req_settings) + assert session_deletions == [(session, pool._req_settings)] + assert not session.initialized() assert pool._active_count == 0 assert pool._active_queue.empty() @@ -188,14 +201,21 @@ async def test_keep_alive_failure_frees_pool_slot(mock_session_pool, error): @pytest.mark.asyncio -async def test_keep_alive_success_reuses_session(mock_session_pool): - pool = mock_session_pool +async def test_keep_alive_success_reuses_session(session_pool, session_deletions, monkeypatch): + pool = session_pool session = await pool.acquire(timeout=1) + keep_alive_calls = [] + + async def keep_alive(settings): + keep_alive_calls.append(settings) + return session + + monkeypatch.setattr(session, "keep_alive", keep_alive) await pool._send_keep_alive(session) - session.keep_alive.assert_awaited_once_with(pool._req_settings) - session.delete.assert_not_called() + assert keep_alive_calls == [pool._req_settings] + assert session_deletions == [] assert pool._active_count == 1 reused = await pool.acquire(timeout=1) assert reused is session From 645f80f003ff5b6ff7812c392b51d78860bc2737 Mon Sep 17 00:00:00 2001 From: Denis Romashin Date: Mon, 2 Nov 2026 11:12:16 +0300 Subject: [PATCH 4/5] Limit keep-alive regressions to failure cases --- tests/aio/test_session_pool.py | 40 +++++---------------- ydb/_topic_common/common_test.py | 59 +------------------------------ ydb/_topic_common/test_helpers.py | 9 ++--- 3 files changed, 12 insertions(+), 96 deletions(-) diff --git a/tests/aio/test_session_pool.py b/tests/aio/test_session_pool.py index c12b079a6..fe2cdf153 100644 --- a/tests/aio/test_session_pool.py +++ b/tests/aio/test_session_pool.py @@ -149,12 +149,7 @@ async def test_no_session_leak(driver, docker_project): @pytest.fixture -def session_deletions(): - return [] - - -@pytest.fixture -async def session_pool(monkeypatch, session_deletions): +async def session_pool(monkeypatch): async def wait(timeout): pass @@ -163,7 +158,6 @@ async def create_session(session, settings=None): return session async def delete_session(session, settings=None): - session_deletions.append((session, settings)) session.reset() monkeypatch.setattr(Session, "create", create_session) @@ -179,18 +173,24 @@ async def delete_session(session, settings=None): @pytest.mark.asyncio @pytest.mark.parametrize("error", [ydb.BadSession, ydb.ConnectionLost, asyncio.CancelledError]) -async def test_keep_alive_failure_frees_pool_slot(session_pool, session_deletions, monkeypatch, error): +async def test_keep_alive_failure_frees_pool_slot(session_pool, monkeypatch, error): pool = session_pool session = await pool.acquire(timeout=1) + session_deletions = [] async def fail_keep_alive(settings): raise error("KeepAlive failed") + async def delete_session(settings): + session_deletions.append(settings) + session.reset() + monkeypatch.setattr(session, "keep_alive", fail_keep_alive) + monkeypatch.setattr(session, "delete", delete_session) await asyncio.gather(pool._send_keep_alive(session), return_exceptions=True) - assert session_deletions == [(session, pool._req_settings)] + assert session_deletions == [pool._req_settings] assert not session.initialized() assert pool._active_count == 0 assert pool._active_queue.empty() @@ -198,25 +198,3 @@ async def fail_keep_alive(settings): replacement = await pool.acquire(timeout=1) assert replacement is not session await pool.release(replacement) - - -@pytest.mark.asyncio -async def test_keep_alive_success_reuses_session(session_pool, session_deletions, monkeypatch): - pool = session_pool - session = await pool.acquire(timeout=1) - keep_alive_calls = [] - - async def keep_alive(settings): - keep_alive_calls.append(settings) - return session - - monkeypatch.setattr(session, "keep_alive", keep_alive) - - await pool._send_keep_alive(session) - - assert keep_alive_calls == [pool._req_settings] - assert session_deletions == [] - assert pool._active_count == 1 - reused = await pool.acquire(timeout=1) - assert reused is session - await pool.release(reused) diff --git a/ydb/_topic_common/common_test.py b/ydb/_topic_common/common_test.py index 1a8e5ac62..45cab316b 100644 --- a/ydb/_topic_common/common_test.py +++ b/ydb/_topic_common/common_test.py @@ -7,7 +7,6 @@ import pytest from .common import CallFromSyncToAsync -from .test_helpers import WaitConditionError, wait_for_fast from .._grpc.grpcwrapper.common_utils import ( GrpcWrapperAsyncIO, ServerStatus, @@ -134,6 +133,7 @@ def test_failed(self): issues._process_response(status) +@pytest.mark.asyncio class TestCallFromSyncToAsync: @pytest.fixture() def caller(self, separate_loop): @@ -288,60 +288,3 @@ def callback(): with pytest.raises(TestError): caller.call_sync(callback) assert callback_eventloop is separate_loop - - -@pytest.mark.asyncio -class TestWaitForFast: - async def test_timeout_cancels_and_waits_for_pending_task(self): - queue = asyncio.Queue() - task = asyncio.create_task(queue.get()) - try: - with pytest.raises(WaitConditionError): - await wait_for_fast(task, timeout=0) - - assert task.cancelled() - queue.put_nowait("message") - assert queue.get_nowait() == "message" - finally: - task.cancel() - await asyncio.gather(task, return_exceptions=True) - - async def test_cancellation_waits_for_pending_task_cleanup(self): - started = asyncio.Event() - cleaned_up = asyncio.Event() - - async def wait_for_message(): - started.set() - try: - await asyncio.Queue().get() - finally: - await asyncio.sleep(0) - cleaned_up.set() - - task = asyncio.create_task(wait_for_message()) - waiter = asyncio.create_task(wait_for_fast(task, timeout=5)) - try: - await asyncio.wait_for(started.wait(), timeout=1) - waiter.cancel() - with pytest.raises(asyncio.CancelledError): - await waiter - - assert task.cancelled() - assert cleaned_up.is_set() - finally: - waiter.cancel() - task.cancel() - await asyncio.gather(waiter, task, return_exceptions=True) - - async def test_returns_completed_result(self): - future = asyncio.get_running_loop().create_future() - future.set_result("message") - - assert await wait_for_fast(future) == "message" - - async def test_preserves_task_error(self): - async def fail(): - raise ValueError("test error") - - with pytest.raises(ValueError, match="test error"): - await wait_for_fast(fail()) diff --git a/ydb/_topic_common/test_helpers.py b/ydb/_topic_common/test_helpers.py index 9a49a4e24..5df3c80b1 100644 --- a/ydb/_topic_common/test_helpers.py +++ b/ydb/_topic_common/test_helpers.py @@ -74,10 +74,5 @@ async def wait_for_fast( timeout: typing.Optional[typing.Union[float, int]] = None, ): fut = asyncio.ensure_future(awaitable) - try: - await wait_condition(lambda: fut.done(), timeout) - return fut.result() - finally: - if not fut.done(): - fut.cancel() - await asyncio.gather(fut, return_exceptions=True) + await wait_condition(lambda: fut.done(), timeout) + return fut.result() From d9665d55c3b48b2cc51ad613dd48999b82e32814 Mon Sep 17 00:00:00 2001 From: Denis Romashin Date: Mon, 2 Nov 2026 11:20:36 +0300 Subject: [PATCH 5/5] Use fully qualified SDK classes in keep-alive tests --- tests/aio/test_session_pool.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/tests/aio/test_session_pool.py b/tests/aio/test_session_pool.py index fe2cdf153..63631ea9b 100644 --- a/tests/aio/test_session_pool.py +++ b/tests/aio/test_session_pool.py @@ -3,7 +3,6 @@ import pytest import ydb -from ydb.aio.table import Session, TableClient @pytest.mark.asyncio @@ -160,10 +159,10 @@ async def create_session(session, settings=None): async def delete_session(session, settings=None): session.reset() - monkeypatch.setattr(Session, "create", create_session) - monkeypatch.setattr(Session, "delete", delete_session) + monkeypatch.setattr(ydb.aio.table.Session, "create", create_session) + monkeypatch.setattr(ydb.aio.table.Session, "delete", delete_session) driver = SimpleNamespace(wait=wait) - driver.table_client = TableClient(driver) + driver.table_client = ydb.aio.table.TableClient(driver) pool = ydb.aio.SessionPool(driver, 1) try: yield pool