forked from mtusi2026/mtusi2026lab4
145 lines
6.6 KiB
Python
145 lines
6.6 KiB
Python
"""Идемпотентность на уровне хранилища (нужен прямой доступ к PostgreSQL).
|
|
|
|
* сбой ПОСЛЕ вставки ключа и сообщения внутри транзакции -> не остаётся ни ключа,
|
|
ни сообщения, и повтор с тем же ключом создаёт сообщение (5xx не фиксируется);
|
|
* 16 потоков с одним ключом -> ровно одна вставка, остальные — повтор;
|
|
* истёкший ключ можно занять заново; очистка удаляет только истёкшие строки и
|
|
выполняется одной репликой за раз (advisory lock).
|
|
|
|
Запуск внутри compose-сети (БД наружу не публикуется):
|
|
python scripts/ops.py in-network storage
|
|
Без DATABASE_URL/DATABASE_URL_FILE тест пропускается.
|
|
"""
|
|
import hashlib
|
|
import os
|
|
import sys
|
|
import threading
|
|
import time
|
|
import unittest
|
|
import uuid
|
|
from concurrent.futures import ThreadPoolExecutor
|
|
from pathlib import Path
|
|
|
|
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
|
|
|
|
HAS_DB = bool(os.environ.get("DATABASE_URL") or os.environ.get("DATABASE_URL_FILE"))
|
|
DAY = 86400
|
|
|
|
|
|
class InjectedFailure(RuntimeError):
|
|
pass
|
|
|
|
|
|
def fp(text):
|
|
return hashlib.sha256(text.encode()).digest()
|
|
|
|
|
|
@unittest.skipUnless(HAS_DB, "DATABASE_URL is not configured")
|
|
class StorageIdempotencyTests(unittest.TestCase):
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
from src.config import load_settings
|
|
from src.db import create_pool, wait_and_migrate
|
|
from src.security import hash_password
|
|
from src.storage import Storage
|
|
|
|
settings = load_settings()
|
|
wait_and_migrate(settings)
|
|
cls.pool = create_pool(settings)
|
|
cls.pool.wait(timeout=10)
|
|
cls.storage = Storage(cls.pool)
|
|
h = hash_password("Idempotency-test-password")
|
|
cls.user = cls.storage.create_user("idm_" + uuid.uuid4().hex[:12], "Idem", h)
|
|
cls.chat = cls.storage.create_chat("idem-" + uuid.uuid4().hex[:8], [cls.user.id])
|
|
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
cls.pool.close()
|
|
|
|
def count(self, sql, params):
|
|
with self.pool.connection() as conn:
|
|
return conn.execute(sql, params).fetchone()[0]
|
|
|
|
def keys(self, key):
|
|
return self.count("SELECT count(*) FROM idempotency_keys WHERE user_id = %s AND idem_key = %s",
|
|
(self.user.id, key))
|
|
|
|
def test_failure_inside_transaction_stores_nothing(self):
|
|
key = "fail-" + uuid.uuid4().hex
|
|
text = "сбой " + key
|
|
original = self.storage._insert_message
|
|
seen = {}
|
|
|
|
def insert_then_fail(conn, message_id, chat_id, sender_id, body):
|
|
original(conn, message_id, chat_id, sender_id, body)
|
|
seen["keys"] = conn.execute("SELECT count(*) FROM idempotency_keys WHERE idem_key = %s", (key,)).fetchone()[0]
|
|
seen["messages"] = conn.execute("SELECT count(*) FROM messages WHERE id = %s", (message_id,)).fetchone()[0]
|
|
raise InjectedFailure("crash after both inserts, before COMMIT")
|
|
|
|
self.storage._insert_message = insert_then_fail
|
|
try:
|
|
with self.assertRaises(InjectedFailure):
|
|
self.storage.create_message(self.chat.id, self.user.id, text, key, fp(text), DAY)
|
|
finally:
|
|
self.storage._insert_message = original
|
|
self.assertEqual((seen["keys"], seen["messages"]), (1, 1), "inserts were visible inside the transaction")
|
|
self.assertEqual(self.keys(key), 0)
|
|
self.assertEqual(self.count("SELECT count(*) FROM messages WHERE text = %s", (text,)), 0)
|
|
# Клиент повторяет неподтверждённый запрос с тем же ключом — теперь успешно.
|
|
msg, replayed = self.storage.create_message(self.chat.id, self.user.id, text, key, fp(text), DAY)
|
|
self.assertFalse(replayed)
|
|
self.assertEqual(self.count("SELECT count(*) FROM messages WHERE text = %s", (text,)), 1)
|
|
|
|
def test_threads_same_key_single_insert(self):
|
|
key = "thr-" + uuid.uuid4().hex
|
|
text = "потоки " + key
|
|
barrier = threading.Barrier(16)
|
|
|
|
def call(_):
|
|
barrier.wait()
|
|
return self.storage.create_message(self.chat.id, self.user.id, text, key, fp(text), DAY)
|
|
|
|
with ThreadPoolExecutor(max_workers=16) as pool:
|
|
results = list(pool.map(call, range(16)))
|
|
self.assertEqual(sum(1 for _, replayed in results if not replayed), 1)
|
|
self.assertEqual(len({m.id for m, _ in results}), 1)
|
|
self.assertEqual(self.count("SELECT count(*) FROM messages WHERE text = %s", (text,)), 1)
|
|
|
|
def test_conflict_on_different_body(self):
|
|
from src.storage import IdempotencyConflict
|
|
key = "cnf-" + uuid.uuid4().hex
|
|
self.storage.create_message(self.chat.id, self.user.id, "a", key, fp("a"), DAY)
|
|
with self.assertRaises(IdempotencyConflict):
|
|
self.storage.create_message(self.chat.id, self.user.id, "b", key, fp("b"), DAY)
|
|
|
|
def test_expired_key_can_be_reused_and_is_cleaned(self):
|
|
key = "exp-" + uuid.uuid4().hex
|
|
first, _ = self.storage.create_message(self.chat.id, self.user.id, "старый", key, fp("старый"), 1)
|
|
time.sleep(1.2)
|
|
# Истёк: другое тело уже не конфликт, создаётся новое сообщение.
|
|
second, replayed = self.storage.create_message(self.chat.id, self.user.id, "новый", key, fp("новый"), DAY)
|
|
self.assertFalse(replayed)
|
|
self.assertNotEqual(first.id, second.id)
|
|
self.assertEqual(self.keys(key), 1)
|
|
# Очистка удаляет только истёкшие ключи.
|
|
k2 = "exp2-" + uuid.uuid4().hex
|
|
self.storage.create_message(self.chat.id, self.user.id, "x", k2, fp("x"), 1)
|
|
time.sleep(1.2)
|
|
while self.storage.delete_expired_idempotency_keys():
|
|
pass
|
|
self.assertEqual(self.keys(k2), 0)
|
|
self.assertEqual(self.keys(key), 1)
|
|
|
|
def test_cleanup_runs_on_one_replica_at_a_time(self):
|
|
from src.storage import IDEMPOTENCY_CLEANUP_LOCK_ID
|
|
with self.pool.connection() as conn:
|
|
with conn.transaction():
|
|
conn.execute("SELECT pg_advisory_xact_lock(%s)", (IDEMPOTENCY_CLEANUP_LOCK_ID,))
|
|
self.assertIsNone(self.storage.delete_expired_idempotency_keys())
|
|
self.assertIsNotNone(self.storage.delete_expired_idempotency_keys())
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|