From 1253c6a454cc6e36fdcc80798e318183d0a86ac0 Mon Sep 17 00:00:00 2001 From: NICE-DEV226 Date: Tue, 13 Oct 2026 21:33:08 +0000 Subject: [PATCH] =?UTF-8?q?fix(tenancy):=20pose=20le=20search=5Fpath=20via?= =?UTF-8?q?=20after=5Fbegin=20sans=20autobegin=20=C3=A0=20l'entr=C3=A9e=20?= =?UTF-8?q?de=20session?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Exécuter set_config à l'entrée de TenantAwareDB.session() ouvrait la transaction et faisait échouer 'async with session.begin():' des plugins (InvalidRequestError). Le search_path est désormais posé et vérifié (fail-closed) par un listener after_begin au début de chaque transaction. --- tests/integration/test_tenancy_integration.py | 43 ++++++--- tests/unit/kernel/test_tenancy.py | 16 +++- .../kernel/test_tenancy_isolation_real.py | 91 +++++++++++++++++++ xcore/kernel/tenancy/services.py | 53 +++++++---- 4 files changed, 170 insertions(+), 33 deletions(-) diff --git a/tests/integration/test_tenancy_integration.py b/tests/integration/test_tenancy_integration.py index 54c86c1..d1aa45e 100644 --- a/tests/integration/test_tenancy_integration.py +++ b/tests/integration/test_tenancy_integration.py @@ -148,7 +148,7 @@ class TestDBTenantIsolation: """ @staticmethod - def _postgres_db(calls): + def _postgres_db(calls, listeners): import contextlib class _Dialect: @@ -164,21 +164,37 @@ def __init__(self, value): def scalar(self): return self._value - class FakeSess: + class _Conn: def __init__(self): self._search_path = None - def get_bind(self): - return _Bind() - - async def execute(self, query, params=None, *a, **kw): + def execute(self, query, params=None): sql = str(query) calls.append((sql, params)) if "set_config" in sql: self._search_path = params["sp"] return _Result(None) - if "current_setting" in sql: - return _Result(self._search_path) + return _Result(self._search_path) + + class _Sync: + def in_transaction(self): + return False + + class FakeSess: + sync_session = _Sync() + + def __init__(self): + self._conn = _Conn() + + def get_bind(self): + return _Bind() + + async def execute(self, query, params=None, *a, **kw): + # Simule l'autobegin : `after_begin` pose le search_path avant + # la première requête du plugin. + if not self._conn._search_path: + for fn in listeners: + fn(self, None, self._conn) return _Result("ok") @contextlib.asynccontextmanager @@ -195,9 +211,10 @@ async def test_each_session_sets_search_path(self, monkeypatch): from xcore.kernel.tenancy.services import TenantAwareDB - monkeypatch.setattr(event, "listen", lambda *a, **k: None) + listeners = [] + monkeypatch.setattr(event, "listen", lambda t, n, fn: listeners.append(fn)) calls = [] - tdb = TenantAwareDB(self._postgres_db(calls), "acme") + tdb = TenantAwareDB(self._postgres_db(calls, listeners), "acme") await tdb.execute("SELECT 1") set_calls = [(sql, p) for sql, p in calls if "set_config" in sql] @@ -212,11 +229,13 @@ async def test_two_tenants_set_different_search_paths(self, monkeypatch): from xcore.kernel.tenancy.services import TenantAwareDB - monkeypatch.setattr(event, "listen", lambda *a, **k: None) + listeners = [] + monkeypatch.setattr(event, "listen", lambda t, n, fn: listeners.append(fn)) calls = [] - db = self._postgres_db(calls) + db = self._postgres_db(calls, listeners) await TenantAwareDB(db, "acme").execute("SELECT 1") + listeners.clear() # un listener par session SQLAlchemy await TenantAwareDB(db, "beta").execute("SELECT 1") values = [p["sp"] for sql, p in calls if "set_config" in sql] diff --git a/tests/unit/kernel/test_tenancy.py b/tests/unit/kernel/test_tenancy.py index 12d8f19..baac722 100644 --- a/tests/unit/kernel/test_tenancy.py +++ b/tests/unit/kernel/test_tenancy.py @@ -153,14 +153,24 @@ async def test_non_sql_adapter_is_skipped(self): await TenantAwareDB(MagicMock(), "acme")._set_tenant_schema(sess) @pytest.mark.asyncio - async def test_postgres_error_is_not_swallowed(self): + async def test_postgres_error_is_not_swallowed(self, monkeypatch): + """Le SQL part dans le listener `after_begin` (pas à l'entrée de session).""" + from sqlalchemy import event + from xcore.kernel.tenancy.services import TenantAwareDB + listeners = [] + monkeypatch.setattr(event, "listen", lambda t, n, fn: listeners.append(fn)) sess = MagicMock() sess.get_bind.return_value.dialect.name = "postgresql" - sess.execute = AsyncMock(side_effect=RuntimeError("boom")) + sess.sync_session.in_transaction.return_value = False + sess.execute = AsyncMock() + await TenantAwareDB(MagicMock(), "acme")._set_tenant_schema(sess) + sess.execute.assert_not_called() # aucun autobegin à l'entrée + conn = MagicMock() + conn.execute.side_effect = RuntimeError("boom") with pytest.raises(RuntimeError): - await TenantAwareDB(MagicMock(), "acme")._set_tenant_schema(sess) + listeners[0](None, None, conn) # ───────────────────────────────────────────────────────────── diff --git a/tests/unit/kernel/test_tenancy_isolation_real.py b/tests/unit/kernel/test_tenancy_isolation_real.py index b8d15ad..6bbb7dd 100644 --- a/tests/unit/kernel/test_tenancy_isolation_real.py +++ b/tests/unit/kernel/test_tenancy_isolation_real.py @@ -345,3 +345,94 @@ def add_job(self, func, job_id=None, **kw): assert inspect.isawaitable(result) await result assert seen == ["acme"] + + +# ── idiomes plugin : transaction ouverte par le plugin lui-même ───────────── + + +@needs_pg +async def test_pg_session_begin_du_plugin_ne_leve_pas(pg_adapter): + """Régression : `async with sess.begin():` après l'entrée de session().""" + from sqlalchemy import text + + async with TenantAwareDB(pg_adapter, "acme").session() as sess: + async with sess.begin(): + rows = (await sess.execute(text("SELECT owner FROM invoices"))).fetchall() + assert [r[0] for r in rows] == ["acme-row"] + await sess.execute(text("INSERT INTO invoices VALUES ('acme-2')")) + assert await _owners(TenantAwareDB(pg_adapter, "acme")) == ["acme-2", "acme-row"] + assert await _owners(TenantAwareDB(pg_adapter, "beta")) == ["beta-row"] + + +@needs_pg +async def test_pg_add_commit_et_begin_apres_select(pg_adapter): + from sqlalchemy import text + + async with TenantAwareDB(pg_adapter, "beta").session() as sess: + await sess.execute(text("SELECT 1")) # autobegin + await sess.execute(text("INSERT INTO invoices VALUES ('b2')")) + await sess.commit() + async with sess.begin(): # nouvelle transaction explicite après commit + rows = (await sess.execute(text("SELECT owner FROM invoices"))).fetchall() + assert sorted(r[0] for r in rows) == ["b2", "beta-row"] + await sess.execute(text("INSERT INTO invoices VALUES ('b3')")) + await sess.rollback() + rows = (await sess.execute(text("SELECT owner FROM invoices"))).fetchall() + assert sorted(r[0] for r in rows) == ["b2", "beta-row"] + + +@needs_pg +async def test_pg_50_sessions_concurrentes_pool_de_5_sans_fuite(pg_adapter): + import asyncio + + from sqlalchemy import text + + adapter = AsyncSQLAdapter( + "pg-pool", DatabaseConfig(url=PG_URL, pool_size=5, max_overflow=0) + ) + await adapter.connect() + + async def work(i: int) -> tuple[str, list[str]]: + tenant = ("acme", "beta")[i % 2] + tdb = TenantAwareDB(adapter, tenant) + if i % 3 == 0: + async with tdb.session() as sess: + async with sess.begin(): + res = await sess.execute(text("SELECT owner FROM invoices")) + rows = [r[0] for r in res.fetchall()] + await asyncio.sleep(0) + elif i % 3 == 1: + async with tdb.session() as sess: + await sess.commit() + res = await sess.execute(text("SELECT owner FROM invoices")) + rows = [r[0] for r in res.fetchall()] + await sess.rollback() + else: + rows = await _owners(tdb) + return tenant, rows + + try: + results = await asyncio.gather(*(work(i) for i in range(50))) + assert all(rows == [f"{t}-row"] for t, rows in results) + async with adapter.session() as raw: + res = await raw.execute(text("SELECT owner FROM invoices")) + assert [r[0] for r in res.fetchall()] == ["public-row"] + finally: + await adapter.disconnect() + + +@needs_pg +async def test_pg_autocommit_refuse_aussi_avec_begin_plugin(pg_adapter): + from sqlalchemy import text + + adapter = AsyncSQLAdapter( + "pg-ac2", DatabaseConfig(url=PG_URL, isolation_level="AUTOCOMMIT") + ) + await adapter.connect() + try: + async with TenantAwareDB(adapter, "acme").session() as sess: + with pytest.raises(RuntimeError, match="isolation"): + async with sess.begin(): + await sess.execute(text("SELECT owner FROM invoices")) + finally: + await adapter.disconnect() diff --git a/xcore/kernel/tenancy/services.py b/xcore/kernel/tenancy/services.py index fe2413c..d93155f 100644 --- a/xcore/kernel/tenancy/services.py +++ b/xcore/kernel/tenancy/services.py @@ -194,8 +194,9 @@ async def _set_tenant_schema(self, sess: Any) -> None: paramètre lié à `set_config(..., true)` : aucune interpolation SQL. - Portée transaction (équivalent `SET LOCAL`) : rien ne fuit vers la requête suivante du pool, même si le reset du pool est désactivé. - Un listener `after_begin` le ré-applique si le plugin fait un - `commit()` intermédiaire sur la même session. + Un listener `after_begin` le pose au début de CHAQUE transaction + de la session (autobegin, `begin()` du plugin, après `commit()`), sans + exécuter de SQL à l'entrée (sinon `session.begin()` échouerait). - PostgreSQL uniquement. Les autres dialectes (SQLite, MySQL) et les adapters non SQL (MongoDB) sont ignorés. Une erreur sur PostgreSQL est propagée : une isolation qui échoue ne doit jamais être silencieuse. @@ -209,24 +210,40 @@ async def _set_tenant_schema(self, sess: Any) -> None: from sqlalchemy import event, text params = {"sp": f'"{tenant}", public'} - await _maybe_await(sess.execute(text(_SET_SEARCH_PATH_SQL), params)) - # Preuve que la valeur tient : en AUTOCOMMIT (ou derrière un pooler - # transactionnel) chaque instruction est sa propre transaction et le - # set_config local est perdu sans erreur. On refuse plutôt que de lire - # silencieusement le schéma public. - check = await _maybe_await(sess.execute(text(_CURRENT_SEARCH_PATH_SQL))) - if check.scalar() != params["sp"]: - raise RuntimeError( - "isolation tenant impossible : le search_path n'a pas persisté " - "dans la transaction (isolation_level AUTOCOMMIT ou pooler en " - "mode statement ?). Désactivez AUTOCOMMIT pour les bases " - "utilisées avec tenancy.isolate_db, ou isolate_db." - ) - def _reapply(_session: Any, _transaction: Any, connection: Any) -> None: + # Aucune requête ici : exécuter du SQL à l'entrée déclencherait + # l'autobegin et casserait `async with session.begin():` côté plugin + # ("A transaction is already begun"). Le search_path est posé par un + # listener `after_begin`, au tout début de CHAQUE transaction de la + # session (autobegin, `begin()`, après commit/rollback), donc dans la + # même transaction que les requêtes du plugin. + def _apply_conn(connection: Any) -> None: connection.execute(text(_SET_SEARCH_PATH_SQL), params) - - event.listen(getattr(sess, "sync_session", sess), "after_begin", _reapply) + # Preuve que la valeur tient : en AUTOCOMMIT (ou derrière un pooler + # transactionnel) chaque instruction est sa propre transaction et le + # set_config local est perdu sans erreur. On refuse plutôt que de + # lire silencieusement le schéma public. + current = connection.execute(text(_CURRENT_SEARCH_PATH_SQL)).scalar() + if current != params["sp"]: + raise RuntimeError( + "isolation tenant impossible : le search_path n'a pas " + "persisté dans la transaction (isolation_level AUTOCOMMIT " + "ou pooler en mode statement ?). Désactivez AUTOCOMMIT pour " + "les bases utilisées avec tenancy.isolate_db, ou isolate_db." + ) + + def _on_begin(_session: Any, _transaction: Any, connection: Any) -> None: + _apply_conn(connection) + + sync_sess = getattr(sess, "sync_session", sess) + event.listen(sync_sess, "after_begin", _on_begin) + # Transaction déjà ouverte par l'adapter (ex. `execution_options` + # appliquées via `sess.connection()`) : `after_begin` est passé, on pose + # le search_path tout de suite (le plugin ne pourrait de toute façon + # plus appeler `begin()` sur cette session). + if sync_sess.in_transaction(): + conn = await _maybe_await(sess.connection()) + await _maybe_await(conn.run_sync(_apply_conn)) @contextlib.asynccontextmanager async def session(self):