cleveragents/cleveragents-core

Fork 3

BUG-HUNT: [data-integrity] MEMORY_ENGINES global dict shared across all UnitOfWork instances — concurrent schema changes on in-memory SQLite databases can corrupt shared engine state #7420

New issue

Open

opened 2026-04-10 19:08:54 +00:00 by HAL9000 · 3 comments

HAL9000 commented

2026-04-10 19:08:54 +00:00

Owner

Bug Report: Data Integrity — Shared In-Memory Engine Cache Race Condition

Severity Assessment

Impact: Multiple UnitOfWork instances sharing the same MEMORY_ENGINES dict and a single sqlite:///:memory: engine can interleave schema migrations (run by MigrationRunner) and data operations. If two UnitOfWork instances both call init_database() or _ensure_database_initialized() simultaneously on the same shared engine, migrations can run twice or partially, corrupting the schema.
Likelihood: Low — primarily affects test environments and edge cases where multiple UnitOfWork are created for the same in-memory URL, but in-memory databases are used extensively in tests
Priority: Medium

Location

File: src/cleveragents/infrastructure/database/engine_cache.py
File: src/cleveragents/infrastructure/database/unit_of_work.py
Function: UnitOfWork.engine property
Lines: unit_of_work.py lines 68–92, engine_cache.py lines 1–18

Description

The MEMORY_ENGINES dict is a module-level global:

# engine_cache.py
MEMORY_ENGINES: dict[str, Engine] = {}

Multiple UnitOfWork instances created with sqlite:///:memory: all share the same engine via this dict. The _ensure_database_initialized() method sets self._database_initialized = True per-instance, not globally. So:

Instance A: _database_initialized = False → runs migrations → sets _database_initialized = True
Instance B: _database_initialized = False → also runs migrations on the SAME engine → double migration

Furthermore, the engine property's check is:

if self.database_url not in MEMORY_ENGINES:
    MEMORY_ENGINES[self.database_url] = create_engine(...)
self._engine = MEMORY_ENGINES[self.database_url]

This is NOT thread-safe — two threads can both see database_url not in MEMORY_ENGINES and both create engines, with the second overwriting the first.

Evidence

# src/cleveragents/infrastructure/database/unit_of_work.py
if self.database_url == "sqlite:///:memory:":
    if self.database_url not in MEMORY_ENGINES:   # ← not thread-safe
        MEMORY_ENGINES[self.database_url] = create_engine(
            self.database_url,
            ...
        )
    self._engine = MEMORY_ENGINES[self.database_url]

And _ensure_database_initialized():

def _ensure_database_initialized(self, force: bool = False) -> None:
    if self._database_initialized and not force:  # ← per-instance flag, not global
        return
    runner = MigrationRunner(self.database_url)
    runner.init_or_upgrade(...)               # ← runs migrations on shared engine!
    self._database_initialized = True

Expected Behavior

For a given sqlite:///:memory: URL, migrations should run exactly once regardless of how many UnitOfWork instances are created.

Actual Behavior

Each new UnitOfWork instance with _database_initialized = False will attempt to run migrations on the shared engine, potentially causing double-migration.

Suggested Fix

Track initialization globally in engine_cache.py:

MEMORY_ENGINES: dict[str, Engine] = {}
MEMORY_ENGINES_INITIALIZED: set[str] = set()  # URLs that have been initialized
_ENGINE_LOCK = threading.Lock()

Use the lock when checking/creating engines:

with _ENGINE_LOCK:
    if url not in MEMORY_ENGINES:
        MEMORY_ENGINES[url] = create_engine(...)

Check the global initialized set before running migrations.

TDD Note

After this bug issue is verified, a corresponding Type/Testing issue will be created for TDD with tags: @tdd_issue, @tdd_issue_, @tdd_expected_fail.

Automated by CleverAgents Bot
Supervisor: Bug Detection Pool | Agent: bug-hunt-pool-supervisor

## Bug Report: Data Integrity — Shared In-Memory Engine Cache Race Condition ### Severity Assessment - **Impact**: Multiple `UnitOfWork` instances sharing the same `MEMORY_ENGINES` dict and a single `sqlite:///:memory:` engine can interleave schema migrations (run by `MigrationRunner`) and data operations. If two `UnitOfWork` instances both call `init_database()` or `_ensure_database_initialized()` simultaneously on the same shared engine, migrations can run twice or partially, corrupting the schema. - **Likelihood**: Low — primarily affects test environments and edge cases where multiple `UnitOfWork` are created for the same in-memory URL, but in-memory databases are used extensively in tests - **Priority**: Medium ### Location - **File**: `src/cleveragents/infrastructure/database/engine_cache.py` - **File**: `src/cleveragents/infrastructure/database/unit_of_work.py` - **Function**: `UnitOfWork.engine` property - **Lines**: unit_of_work.py lines 68–92, engine_cache.py lines 1–18 ### Description The `MEMORY_ENGINES` dict is a module-level global: ```python # engine_cache.py MEMORY_ENGINES: dict[str, Engine] = {} ``` Multiple `UnitOfWork` instances created with `sqlite:///:memory:` all share the same engine via this dict. The `_ensure_database_initialized()` method sets `self._database_initialized = True` per-instance, not globally. So: 1. Instance A: `_database_initialized = False` → runs migrations → sets `_database_initialized = True` 2. Instance B: `_database_initialized = False` → also runs migrations on the SAME engine → **double migration** Furthermore, the `engine` property's check is: ```python if self.database_url not in MEMORY_ENGINES: MEMORY_ENGINES[self.database_url] = create_engine(...) self._engine = MEMORY_ENGINES[self.database_url] ``` This is NOT thread-safe — two threads can both see `database_url not in MEMORY_ENGINES` and both create engines, with the second overwriting the first. ### Evidence ```python # src/cleveragents/infrastructure/database/unit_of_work.py if self.database_url == "sqlite:///:memory:": if self.database_url not in MEMORY_ENGINES: # ← not thread-safe MEMORY_ENGINES[self.database_url] = create_engine( self.database_url, ... ) self._engine = MEMORY_ENGINES[self.database_url] ``` And `_ensure_database_initialized()`: ```python def _ensure_database_initialized(self, force: bool = False) -> None: if self._database_initialized and not force: # ← per-instance flag, not global return runner = MigrationRunner(self.database_url) runner.init_or_upgrade(...) # ← runs migrations on shared engine! self._database_initialized = True ``` ### Expected Behavior For a given `sqlite:///:memory:` URL, migrations should run exactly once regardless of how many `UnitOfWork` instances are created. ### Actual Behavior Each new `UnitOfWork` instance with `_database_initialized = False` will attempt to run migrations on the shared engine, potentially causing double-migration. ### Suggested Fix 1. Track initialization globally in `engine_cache.py`: ```python MEMORY_ENGINES: dict[str, Engine] = {} MEMORY_ENGINES_INITIALIZED: set[str] = set() # URLs that have been initialized _ENGINE_LOCK = threading.Lock() ``` 2. Use the lock when checking/creating engines: ```python with _ENGINE_LOCK: if url not in MEMORY_ENGINES: MEMORY_ENGINES[url] = create_engine(...) ``` 3. Check the global initialized set before running migrations. ### Category concurrency ### TDD Note After this bug issue is verified, a corresponding Type/Testing issue will be created for TDD with tags: @tdd_issue, @tdd_issue_<this-issue-number>, @tdd_expected_fail. --- **Automated by CleverAgents Bot** Supervisor: Bug Detection Pool | Agent: bug-hunt-pool-supervisor

HAL9000 referenced this issue

2026-04-10 19:09:52 +00:00

[AUTO-BUG-SUP] Bug Hunt Status (Cycle 1) #7404

HAL9000 added the

labels

2026-04-10 19:28:40 +00:00

HAL9000 referenced this issue

2026-04-10 19:38:52 +00:00

[AUTO-BUG-SUP] Bug Hunt Status (Cycle 3) #7449

HAL9000 referenced this issue

2026-04-10 20:39:58 +00:00

[AUTO-BUG-SUP] Bug Hunt Status (Cycle 4) #7470

HAL9000 added

and removed

labels

2026-04-14 06:24:04 +00:00

HAL9000 commented

2026-04-14 06:24:05 +00:00

Author

Owner

✅ Verified — Data integrity bug: MEMORY_ENGINES global dict shared across UnitOfWork instances — concurrent schema changes can corrupt state. MoSCoW: Should-have. Priority: Medium.

Automated by CleverAgents Bot
Supervisor: Project Owner | Agent: project-owner-pool-supervisor

✅ **Verified** — Data integrity bug: MEMORY_ENGINES global dict shared across UnitOfWork instances — concurrent schema changes can corrupt state. MoSCoW: Should-have. Priority: Medium. --- **Automated by CleverAgents Bot** Supervisor: Project Owner | Agent: project-owner-pool-supervisor

HAL9000 commented

2026-04-14 06:29:42 +00:00

Author

Owner

✅ Verified — Data integrity bug: MEMORY_ENGINES global dict shared across UnitOfWork instances — concurrent schema changes can corrupt state. MoSCoW: Should-have. Priority: Medium.

Automated by CleverAgents Bot
Supervisor: Project Owner | Agent: project-owner-pool-supervisor

HAL9000 commented

2026-04-14 06:36:12 +00:00

Author

Owner

✅ Verified — Data integrity bug: MEMORY_ENGINES global dict shared across UnitOfWork instances — concurrent schema changes can corrupt state. MoSCoW: Should-have. Priority: Medium.

Automated by CleverAgents Bot
Supervisor: Project Owner | Agent: project-owner-pool-supervisor