~95% on SimpleQA (e.g. Qwen3.6-27B on a 3090). Supports all local and cloud LLMs (llama.cpp, Ollama, Google, ...). 10+ search engines - arXiv, PubMed, your private documents. Everything Local & Encrypted.
Python academiaanthropicarxivbravedeep-researchencryptionhome-automationhomeserverlocallocal-deep-researchlocal-llmmistralollamaopenaipubmedresearchresearch-toolretrieval-augmented-generationsearxngself-hosted
"""``create_user_database`` must be serialized per user by the init lock.
Only ``open_user_database`` took ``_get_init_lock``. Two concurrent creates
for the same username could both pass the ``db_path.exists()`` guard; the
loser's orphaned-salt recovery then unlinked the winner's in-flight
``.db``/``.salt`` and both registrations failed (#6355). The exists-check,
salt and file creation, the migrations and the cache publish now all run
under the lock, exactly like the cold-open path.
"""
import threading
import pytest
from local_deep_research.database import encrypted_db
from local_deep_research.database.encrypted_db import DatabaseManager
PASSWORD = "CorrectHorse1!"
@pytest.fixture
def manager(tmp_path, monkeypatch):
monkeypatch.setenv("LDR_DATA_DIR", str(tmp_path))
mgr = DatabaseManager()
mgr.data_dir = tmp_path
if not mgr.has_encryption:
pytest.skip("SQLCipher not available; the salt path is encrypted-only")
yield mgr
mgr.close_all_databases()
def test_file_creation_runs_under_the_init_lock(manager, monkeypatch):
username = "locked_create_user"
lock = manager._get_init_lock(username)
real_create_salt = encrypted_db.create_database_salt
seen = []
def observed_create_salt(db_path):
seen.append(lock.locked())
return real_create_salt(db_path)
monkeypatch.setattr(
encrypted_db, "create_database_salt", observed_create_salt
)
manager.create_user_database(username, PASSWORD)
assert seen == [True]
assert not lock.locked()
def test_migrations_run_under_the_init_lock(manager, monkeypatch):
from local_deep_research.database import initialize
username = "migrated_user"
lock = manager._get_init_lock(username)
real_initialize = initialize.initialize_database
seen = []
def observed_initialize(engine, session):
seen.append(lock.locked())
return real_initialize(engine, session)
monkeypatch.setattr(initialize, "initialize_database", observed_initialize)
manager.create_user_database(username, PASSWORD)
assert seen == [True]
assert not lock.locked()
def test_concurrent_creates_for_one_user_leave_a_usable_database(manager):
username = "raced_user"
barrier = threading.Barrier(2)
outcomes: list = []
def create():
barrier.wait()
try:
outcomes.append(
("ok", manager.create_user_database(username, PASSWORD))
)
except ValueError as exc:
outcomes.append(("error", str(exc)))
threads = [threading.Thread(target=create) for _ in range(2)]
for t in threads:
t.start()
for t in threads:
t.join(timeout=60)
kinds = sorted(kind for kind, _ in outcomes)
assert kinds == ["error", "ok"], outcomes
error_message = next(msg for kind, msg in outcomes if kind == "error")
assert "already exists" in error_message
db_path = manager._get_user_db_path(username)
assert db_path.exists()
manager.close_all_databases()
assert manager.open_user_database(username, PASSWORD) is not None
@pytest.mark.parametrize("leftover_pending", [False, True])
def test_creation_mints_a_fresh_epoch_over_leftover_sidecars(
manager, leftover_pending
):
# Given epoch sidecars left beside a database path that no longer has
# a database (an account removed without them, a partial restore)
from local_deep_research.database.rekey_lock import read_rekey_epoch_state
username = "recreated_user"
db_path = manager._get_user_db_path(username)
db_path.parent.mkdir(parents=True, exist_ok=True)
stale_epoch = "00000000-0000-0000-0000-000000000001"
db_path.with_name(f"{db_path.name}.rekey.epoch").write_text(
stale_epoch, encoding="ascii"
)
if leftover_pending:
db_path.with_name(f"{db_path.name}.rekey.pending").write_text(
"00000000-0000-0000-0000-000000000002", encoding="ascii"
)
# When the account is registered again
assert manager.create_user_database(username, PASSWORD) is not None
# Then it gets a fresh stable epoch, not the earlier database's
state = read_rekey_epoch_state(db_path)
assert state.pending_epoch is None
assert state.committed_epoch is not None
assert state.committed_epoch != stale_epoch
assert manager._connection_epochs[username] == state.committed_epoch