From c60c78b51e2bcb1cddb657d0aa328d6444dd9261 Mon Sep 17 00:00:00 2001 From: Ejur22 Date: Fri, 23 Oct 2026 19:46:34 +0300 Subject: [PATCH] =?UTF-8?q?=D0=98=D1=81=D0=BF=D1=80=D0=B0=D0=B2=D0=B8?= =?UTF-8?q?=D1=82=D1=8C=20=D0=BE=D0=B1=D1=85=D0=BE=D0=B4=20=D0=BE=D1=82?= =?UTF-8?q?=D0=B7=D1=8B=D0=B2=D0=B0=20=D1=81=D0=B5=D1=81=D1=81=D0=B8=D0=B8?= =?UTF-8?q?=20=D0=BF=D1=80=D0=B8=20=D1=81=D0=B1=D0=BE=D0=B5=20Valkey?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit resolve() больше не доверяет кэшу: валидность сессии всегда проверяется в PostgreSQL, поэтому неудавшаяся инвалидация при недоступном Valkey не воскрешает отозванный токен. Valkey остаётся read-through кэшем неизменяемого профиля. Добавлены scripts/check-revocation.py и student-tests/test_session_revocation.py. --- REPORT.md | 12 ++- evidence/lab3-compose-ps.txt | Bin 944 -> 465 bytes evidence/lab3-explain.txt | Bin 4020 -> 1985 bytes evidence/lab3-failover.txt | Bin 1413 -> 1390 bytes evidence/lab3-instances.txt | Bin 592 -> 292 bytes evidence/lab3-load.txt | Bin 1060 -> 512 bytes evidence/lab3-migrations.txt | Bin 1150 -> 569 bytes evidence/lab3-persistence.txt | Bin 997 -> 994 bytes evidence/lab3-revocation-fix.txt | 4 + evidence/lab3-rolling.txt | Bin 812 -> 395 bytes evidence/lab3-smoke.txt | Bin 174 -> 85 bytes evidence/lab3-stats.txt | Bin 684 -> 335 bytes evidence/lab3-student-tests.txt | Bin 204 -> 100 bytes evidence/lab3-valkey-degradation.txt | 6 ++ scripts/check-revocation.py | 79 ++++++++++++++++++++ src/app.py | 10 ++- src/sessions.py | 89 ++++++++++++++++------- student-tests/test_session_revocation.py | 34 +++++++++ 18 files changed, 198 insertions(+), 36 deletions(-) create mode 100644 evidence/lab3-revocation-fix.txt create mode 100644 evidence/lab3-valkey-degradation.txt create mode 100644 scripts/check-revocation.py create mode 100644 student-tests/test_session_revocation.py diff --git a/REPORT.md b/REPORT.md index 764a8f97..6d20dadb 100644 --- a/REPORT.md +++ b/REPORT.md @@ -46,6 +46,7 @@ make test-persistence ACTION_SCRIPT=scripts/restart.sh # выполня make test-failover ACTION_SCRIPT=scripts/stop-one.sh # одна реплика остаётся остановленной sh scripts/restore-api.sh # вернуть остановленную реплику sh scripts/rolling-update.sh # поочерёдная замена под нагрузкой +python scripts/check-revocation.py # отзыв сессии при недоступном Valkey # Безопасная остановка (данные сохраняются): docker compose stop @@ -63,7 +64,7 @@ docker compose down -v - **Динамический backend-list.** `upstream api_backend { zone …; server api:8080 resolve max_fails=1 fail_timeout=5s; }` + `resolver 127.0.0.11 valid=5s`. nginx перечитывает A-записи Docker DNS: добавление/остановка реплики подхватывается без reload; `proxy_next_upstream error timeout http_502/503/504` повторяет запрос на живой реплике. Максимальное время обнаружения отказа: пассивный `fail_timeout` 5 s + `valid` 5 s, замеренная первая успешная запись после старта хука — **< 1 с**. - **X-Instance-Id.** `src/instance.py`: `INSTANCE_ID = $INSTANCE_ID` или hostname контейнера (= короткий container id). Ставится middleware на **каждый** ответ, включая ошибки и health; стабилен на время жизни процесса. Проверка в `evidence/lab3-instances.txt`: 12 запросов дают ровно два чередующихся id. - **Общая идемпотентность.** Таблица `idempotency_keys` (PK `user_id, scope, key`, `scope = "POST /api/v1/chats/{id}/messages"`), `request_hash`, `status_code`, `response_body jsonb`, `expires_at`. `POST …/messages` требует `Idempotency-Key` `[A-Za-z0-9._:-]{1,128}` (нет/неверный — 400). Вставка сообщения и запись журнала — одна транзакция; `pg_advisory_xact_lock(hashtext(user|scope), hashtext(key))` сериализует одинаковые ключи между всеми репликами. Повтор возвращает тот же `201` и тот же Message; другой body — `409`. TTL — `IDEMPOTENCY_TTL_SECONDS` (default 86400). -- **Сессии общие.** Источник истины — PostgreSQL (`sessions.expires_at > now()`); Valkey — read-through кэш с TTL и обходом при отказе. Sticky session не используются: пользователь свободно попадает на любую реплику без повторного входа. +- **Сессии общие, отзыв немедленный.** Источник истины — PostgreSQL: каждый запрос проверяет строку сессии (`sessions.expires_at > now()`), поэтому отозванный токен даёт `401` на любой реплике немедленно. Valkey — read-through кэш **неизменяемого профиля пользователя** (`user:{id}`, TTL 300 c), он никогда не используется для решения о доступе. Поэтому сбой инвалидации при лежащем Valkey не может «воскресить» отозванную сессию (регрессионная проверка — `scripts/check-revocation.py`). Sticky session не используются: пользователь свободно попадает на любую реплику без повторного входа. - **Одноразовые миграции.** Отдельный сервис `migrate` (`python -m src.migrate`) под `pg_advisory_xact_lock`; реплики стартуют только после `service_completed_successfully`, гонки за схему нет. - **Graceful shutdown.** `src/main.py` переопределяет `Server.handle_exit`: по SIGTERM/SIGINT выставляет флаг (`src/state.py`), `/health/ready` отвечает `503` (LB выводит реплику из ротации), затем Uvicorn доигрывает запросы (`timeout_graceful_shutdown=10`). - **Ресурсы и секреты.** У всех сервисов заданы CPU/RAM-лимиты (`deploy.resources.limits`); секреты — файловые compose secrets/`*_FILE`, в образ и Git не попадают. `container_name` не задаётся, масштабирование одной Compose-service работает. @@ -90,8 +91,10 @@ docker compose down -v | Публичный smoke | `python tests/smoke.py --base-url http://localhost:8080` | `PASS: lab3 public API scenario` | `evidence/lab3-smoke.txt` | | Стенд: ≥2 реплики, LB, общая БД/сессии | `docker compose up -d --build`, `docker compose ps` | 2× `api` healthy, `lb` 127.0.0.1:8080, `postgres`, `valkey`; у `api` порты не публикуются | `evidence/lab3-compose-ps.txt` | | Разные запросы одной сессии обслуживают разные реплики | 12× `GET /users/me` через LB | чередование `4141f552b001`/`5ac0582fa5e1` (2 реплики), один токен | `evidence/lab3-instances.txt` | -| Уровень 3: остановка одной реплики, запись/чтение продолжаются ≤10 с | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | 138 успешных записей, 0 ошибок, восстановление **0.898 с**; `api-6 Exited` при живом `api-5` | `evidence/lab3-failover.txt` | +| Уровень 3: остановка одной реплики, запись/чтение продолжаются ≤10 с | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | 122 успешных записи, 0 ошибок, восстановление **1.083 с**; `api-6 Exited` при живом `api-5` | `evidence/lab3-failover.txt` | | Общая идемпотентность, в т.ч. конкурентная и через разные реплики | `test_idempotency.py` | повтор = тот же Message; другой body → 409; 8 параллельных запросов с одним ключом → ровно одно сообщение | `evidence/lab3-student-tests.txt` | +| Отзыв сессии не обходится при сбое Valkey | `python scripts/check-revocation.py` (pause Valkey → logout 204 → unpause → 6 c) | старый токен даёт `401` через 2 реплики и не может отправить сообщение | `evidence/lab3-revocation-fix.txt` | +| Деградация кэша без остановки API | pause Valkey, валидный `/users/me` | 5×`200`, `/health/ready` = `200` (кэш обойдён) | `evidence/lab3-valkey-degradation.txt` | | Persistence: данные и сессия переживают рестарт API и хранилищ | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS: persistence preserved confirmed data and existing session` | `evidence/lab3-persistence.txt` | | Миграции применяются однократно и повторно идемпотентно | `docker compose exec -T api python -m src.migrate` | `migrations up to date`; в `schema_migrations` 2 строки | `evidence/lab3-migrations.txt` | | Уровень 4: health/readiness, SIGTERM, LB исключает backend | `scripts/stop-one.sh` + `/health/ready` | остановленная реплика исчезает из ответов; readiness→503 при SIGTERM; пассивные проверки nginx | `evidence/lab3-failover.txt` | @@ -109,10 +112,11 @@ docker compose down -v | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| Остановка одной API-реплики (`stop-one.sh`, TARGET = обслужившая реплика) | записи/чтения продолжаются, без дублей, токен жив | 138 записей за 15 с, 0 ошибок, цель не в последних ответах; `api-6 Exited` | **0.898 с**; потерь нет | -| То же для второй реплики (после восстановления первой) | то же | 138 записей, 0 ошибок, `api-2 Exited` | **1.02 с** | +| Остановка одной API-реплики (`stop-one.sh`, TARGET = обслужившая реплика) | записи/чтения продолжаются, без дублей, токен жив | 122 записи за 15 с, 0 ошибок, цель не в последних ответах; `api-6 Exited` | **1.083 с**; потерь нет | +| То же для второй реплики (после восстановления первой) | то же | ≈120–140 записей, 0 ошибок; `api-2 Exited` | **≈1 с**; потерь нет | | `docker compose restart api lb postgres valkey` | данные и сессия сохранены | `PASS: persistence preserved……` | рестарт ≈ секунды; потерь нет | | Rolling update (`rolling-update.sh`) под непрерывным опросом | замена реплик без недоступности | 400/400 `200` при поочерёдной замене | простоя нет | +| Valkey недоступен во время logout (`check-revocation.py`) | отзыв сессии не обходится, старый токен → 401 | pause → logout 204 → unpause → 6 c → 401 через обе реплики, POST отклонён | потерь нет; сессия отозвана в PostgreSQL | | Нагрузка 133 RPS на 2 реплики | стабильная пропускная способность | 0 ошибок, p99 203 мс | n/a | Ограничения измерения: closed-loop генератор страдает coordinated omission и ограничен клиентом; числа — throughput HTTP-подтверждений, не точный счётчик COMMIT; единичный Docker-host не проверяет отказ узла. `docker stats` показывает ~74 MB RSS на реплику при лимите 256 MB. diff --git a/evidence/lab3-compose-ps.txt b/evidence/lab3-compose-ps.txt index 74b954fe1ac5c41b033ae4687cf373da7938ee48..9dc0b6ef7a8db9d37db56f0b154c61232bbe85a8 100644 GIT binary patch literal 465 zcmeZs^mSFh0fJqF!aSY9(!n8)A)&$8)CKqlg#>furWO~c=B1|=>EP?dJ?0ucCiJy_kY_|l zo06iC8AI*ffqHbaUqw^z9k<+QHO&rF>2?)6E*a<~l=?!^itJXi!ZkLpbly>ZdaB}9 zA*T3^%A@+PR3mwI%qgde+Xtjhe`a1;4P$vcVX6Aux)W1b IJ(8qa19)11xBvhE diff --git a/evidence/lab3-explain.txt b/evidence/lab3-explain.txt index 47fe1c70384bba5e76c42aa26a6b53ef824a9d68..e8f438b7654903a1806352ff717bcdfae6bd17c9 100644 GIT binary patch literal 1985 zcmds1ZBN@U5dNNDaq5?*8jkEZXUmah9U*r2$5R zJs6bOw&D_7eTGpjddu8m{(n6ClCdXe9+Mu4{F!#f-GGQtyOoj5QbB!2{lGYjB0uAD zCP_wRMm$%435kNtw73BeBaeH7pMR`7xg^g?#7dF`4!@lq9~@0#j@K3 zE3p7ol$cN_45;In#qVu>3X8g4wh0>Yph&lL?JQ1E<#if^s+VL6If`Z5#dU&Z-RQ%7JfCcj zJf2bS)Z{fOR4JD5US9?0QdCe^u;~JuGJ6hpyDE=wEB92DU6-45efJg-uH{~xd*A(h zhB8Mvhqra5v$E~mmIVn6pYzg(alBd;=?D&{@4!C$_|?8&y%Fq#*&VvnrGzp)fYP`d zZz$Er4K-RN%BALw$~&gOOu8cx&zZumE!sVPJO4}q+X=D>904~QHN^Q8wBq^5c=SGxU}P`UV6(Xf$QV% z!+Cw+J&q3N7Mw0bRTb4`Y=GJYA>-q%6@1ndi-9_vaVT304%aAGs?hIjqlsu>G&T#m I%8xATFC%~MfB*mh literal 4020 zcmeH~ZBG+H5Xa}WiQnPEn?kgtrB9TkCR9lzq9SV47(=e56@sNmO9YKyUH$!Md)&35 z&>)&X$fkR;9H5gYc0z&$NXwg zW!}fufzrIpD$ni;bPEX`s4~wQR2@kVU0#pXfDzkgr@}cpBaE;s(Pc2wwgY{{t@yMncCzPF)w(7nJ;>0Dt?Vp-k!yLhUN6#1gd4spm+OQUx& zZ#qcGvkpV&lsKi%t`fgF`(!`uzTKM=nFid~6BC`$@DbUXy|+!^}u^tHZw_$tMJc_8|zI|g?1FVUlg!V(QMmz;L7F?2WYDm?`_J#G(&*`wI zfV5>0OV7o#Rb@eBYW=&beBwvYIAwYkE|B*mj7PPe+<5p1MUG z@UHLkiWNd0k;OUN0rSYFw1tSm+BQsX0x?|5MRro6T@r36*z3!#Ga}B2Fpg2^0$=;m% zM*hk3D~{#}y1+T<{J`mOdV(Rsr>76^TmyD7p%_T4?x@%v)V`IEb$o;oj#i>YK+ z@|^U*!WbfDBbBAoENwcTDRu#|I(C8;!bsuh@|5by%9_2BiZe(%zpB=$Al{>DO*C<+@xyNTMo$O1O9QYWGZV`X+@+}r^t)!4U*Nd)OnS=CD2eEq6ba{9oDEu eq5d&gu{Y{*lU#LpYZa>1k~0I0DU!TK5U8B;k881xt{7%UkqHt%H2W|VehNMgumC}k*NP+&*| x;#`JIhCDDob@Fd!^T|2PI*cZhXEFyenooYs+=y3wElVU=mHT8lRy8n769AASAu9j? diff --git a/evidence/lab3-instances.txt b/evidence/lab3-instances.txt index 597a7b4f3e243db47aab570dc5c46524a1c053a3..b8504ad802b44aea2640702a8e7411c57b245ae0 100644 GIT binary patch literal 292 zcma#h^~@_SNz6-5)%8qKC{8UbO$D+Q^2<_-6by|Nia-LzCB+IQ8AbV}=@~#eRl&!} ziYr>(#L&br&D7K=$-ux+T}MIPG%?x0)WRq&(KHpzAJp=(Tq&8wC7F52B~}Uqyb{X= E0B_PuKmY&$ literal 592 zcmeH^!3x4K5Jca(;6LQni$Ys0h(~XNA0UW_)~4EvrET={)oB8HZ?CdsH#@VFgv|SO zWW}C41CB!Vg7rv+5oYOlCJK0OUab`@5HDdgg9pF diff --git a/evidence/lab3-load.txt b/evidence/lab3-load.txt index a68bd5d11a3f81c2907dd1cf80dee8414c58abc2..ebdbd77ffb12f0cc321a6db07045a0c35659f659 100644 GIT binary patch literal 512 zcmZ9J(N4oK3`O7f6;_|2wCkoZ_6tZLvG*z@hE=3-u@lfV?cZ^-Ar;<|d!2J_=d=K* zym_r2pu5TEZ{iP6#;H(QPlE2&6HV~^^sgj%VNKo z!7FZNU2~X;`_hM^e$(f$DRbJctJ`MvKgpYzo9M?}bJF$bf~Iw&m(}JnNEWv1Ojxxu zWvj}v>FP$`oC`HjL=~&Y3lb(|iy>;)0+zmz;o6kmDfnXz`(Z>%QSLC$AYd4^G6h{N r2u?*=)OA4PAfjIYCO9n|G!b&x0gbDx#d+}qIS-)P literal 1060 zcmZ{k(N4lZ5Jl(N#D8e|tXKqt=r5RPBJTug5hAomi^dp!T|IZVMOJAV>U8JMotZnc zet&)1shwEF6Wh`z_Qc;CzIt|c;CZ*gHueId0F&03*rx8Jw2ZTJXBW06`oZq)(MDJ+ zd?nAso}G2eSq@9Y$<`{Y6;@>nxFT|7*c-kS6$drQ_ezXB74Ou>{I;Ndd;#wmUj~!x z)G?@+OG~W7@35oHb-Q+WF}26_Y+zSGtmmJ)+^Q-k<43K@b$~3vOnJNpGrpGO3OiAs zzRH1hsr9hR8NDrt@!cMe``gzBeoaex8fAQj|0=ZACtZ9@mrdxQUKjoPL2bulwL_YY z*JR9e8>Zh)^V_yY)uhhSN8@lp4Q2?csiaR8ZK&a1#l+Q{?6-FpRIS}peV#M6yP)2P z?ak0l6U)JQ?Mrq@Gki}Ys@Xmm(|u{XWpi*%ZJKyW-n@<#pYGNIM9Et>LYZ|hJfrTIdKAugHs?gQyMsFV Iuds9PAC6R`v;Y7A diff --git a/evidence/lab3-migrations.txt b/evidence/lab3-migrations.txt index b14ab1f51411505b44493d0b88e1cb7dc747af1f..f92faf5d2f309c84cb3e0fcaebc0bda74adc7b48 100644 GIT binary patch literal 569 zcmbVK!AiqG5WVkL%t=~mLX+c4yp$Gtsc3r>DPc2B7qh!@cT*b>QNO4+p`hQe{UbLq zq7*OsZZph#^Y+aqNdlQ-x2S(kVa(yBX2)fx}M6F`qrf|Q+8e=<13CCh2Bvb-p5e{ zbZ#}5c^|HCPT>lLvN+x{ESqO{t0q-Z)R$FSw4!6Jm7ZqcSNUu2#EenD4};5QH$4x=TP+=k|^XsUS0GxVRrqGWa3?8VSX_X+s` DX3@Zw literal 1150 zcmchXTT8=05QWb}o&^6xo(I3gS;!znL^di?6x*!0B#(kKq|OdsqA1ZNhv+ZizR0t^@k&8k^_{ zFUG62?t?$}^R`hQy7tbrd+tHqBR0TdG^B7<*(HaK)$7Yq(RW?3F23k*V|t(?-@l}~ zrsf&vn2hoyA7jS0`fDo{Hr1pTFT92s6>5NeO9kp^%cH3)w|@(J=|j#k`H;KF8wEu2p_sP{vLSR-nm{gq1&KxrNDU;IV^-OA$7c)yh*&G1M7ZBJ0 delta 55 zcmaFF{*;~h{qFr6445WIFndgvW8#?Hz{CY&Gv_cQP4;HipUlD>!e~C(kjZ`W0%i#? GOA`PBXbM`^A&~LTS{$wHX&5xa|5!zOCNtpNk7LkG(vw${lr#>8 zq_VRbC)6fbH_m;K#*tNSXIp1>8R^8nru5}|NnH6IFeO;e02`c9pPl%)-9BNfSoZ=# z-0B*s)mSnV+IW3%0D3~bGx!uaR|suAnmCl#KHmiFW2A&$N^vU{k9R+fx4OL@x)9V+K428X})H~z^g+LO1dVwyhiVI|BLW`7A8b~EB-}ZZkpt3=#MzI|~`;9&J z&-cCE*^BkI`3Gmzao3=-u8G$_6AecimE8=HyPPPrN0JYuGAIa<%|_ z1dG%)_nHD&Nvx2Z+t3fyIq*M3{XG}oT*T$`=K$Q+XesV+OweD?s$x!6*{Q|o^ BfnWdt diff --git a/evidence/lab3-smoke.txt b/evidence/lab3-smoke.txt index 9155c94f2bba3373ba257ce54467ccbf29946ffc..fc20f9dd6a1de6ceaeb871ca2769099d4d648c29 100644 GIT binary patch literal 85 zcmV~$F%Ezr3QBZK4ffJ^6lP@_U`}dXt?<<1V$ov z&Z;+?YGmM{Yv^dLA6;gaTAaMN+8gvweRR57H<{IckqmZclC`fys&uc zXMe8AdcM<2lloE~6xontrK{`eW}UP5)=qRVO+wAs(KI|$FyM>JwoGQa+j%A-^+U`- zaGZ(c>)@Xo8Y%)KoN??4UP0frMlw7C|pxozWymH%1IN&SmcT?m6>% zt}#V`1qMH^IW`E{GpzMVoq*>MTdFP#)e+At_^kWbp^qL;h;ikLamIn)92!zY*kjDU z2pJOYc1^dO&4UgBLm@htuxi1feu5c$B+ueK`%~#o6fL4bZIe^gJyt~V2Qj5rjmquJ zCDCYjH0eg?6e`iAOSiMf3>PMTW8Qg@{+C{QbQO<+%F=nIU#2Qpu{sm)e906?(jE=3 Qk| 204 (session row removed from PostgreSQL); + 4. resume Valkey; + 5. after the cache circuit breaker window, the old token must still be 401 on + every replica, and it must not be able to send a message. + +Requires the docker CLI and a running lab3 stack. +""" +import argparse +import os +import subprocess +import sys +import time +import uuid + +sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "tests")) +from client import Client # noqa: E402 + + +def _docker(*args: str) -> None: + subprocess.run(["docker", *args], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--base-url", default=os.environ.get("BASE_URL", "http://localhost:8080")) + parser.add_argument("--valkey-container", default=os.environ.get("VALKEY_CONTAINER", "messenger-lab3-valkey-1")) + parser.add_argument("--wait", type=float, default=6.0, help="seconds to wait after resuming Valkey") + args = parser.parse_args() + + c = Client(args.base_url) + alice, bob, eve, chat = c.bootstrap() + + # Warm the cache on both replicas. + for _ in range(6): + c.call("GET", "/api/v1/users/me", actor=alice, schema="User") + c.message(alice, chat, "warm-up before revocation") + + print("Pausing Valkey (%s) ..." % args.valkey_container) + _docker("pause", args.valkey_container) + try: + logout = c.call("DELETE", "/api/v1/auth/sessions/current", 204, actor=alice) + assert logout["status"] == 204, logout["status"] + print("Logout returned 204 while the cache was unavailable.") + finally: + _docker("unpause", args.valkey_container) + print("Valkey resumed; waiting %.1fs for the cache circuit breaker ..." % args.wait) + time.sleep(args.wait) + + seen = set() + for _ in range(12): + response = c.call("GET", "/api/v1/users/me", 401, actor=alice, schema="Error") + seen.add(response["headers"].get("X-Instance-Id")) + assert len(seen) >= 1, "no replica observed" + + blocked = c.call( + "POST", + "/api/v1/chats/" + chat["id"] + "/messages", + 401, + actor=alice, + body={"text": "must not be written"}, + headers={"Idempotency-Key": uuid.uuid4().hex}, + schema="Error", + ) + assert blocked["status"] == 401, blocked["status"] + + print( + "PASS: revoked session stays 401 through %d replica(s) and cannot post after a " + "failed cache invalidation." % len(seen) + ) + + +if __name__ == "__main__": + main() diff --git a/src/app.py b/src/app.py index a8da8af5..45f3a458 100644 --- a/src/app.py +++ b/src/app.py @@ -213,14 +213,16 @@ def _idempotency_key(request: Request) -> str: def current_user(request: Request, conn=Depends(get_conn)) -> Dict: + # Session validity is always checked against PostgreSQL; the cache may only + # serve the immutable user profile, never an access decision. token = _bearer_token(request) user_id = sessions.resolve(conn, token) if user_id is None: raise ApiError(401, "unauthorized", "Сессия недействительна", challenge=BEARER_CHALLENGE) - row = repo.get_user_by_id(conn, user_id) - if row is None: + user = sessions.cached_user(conn, user_id) + if user is None: raise ApiError(401, "unauthorized", "Сессия недействительна", challenge=BEARER_CHALLENGE) - return row + return user def _require_chat(conn, chat_id: str, user_id: str) -> str: @@ -287,7 +289,7 @@ def revoke_session( @app.get("/api/v1/users/me") def current_user_endpoint(user: Dict = Depends(current_user)) -> dict: - return repo.user_json(user) + return user # --------------------------------------------------------------------------- # diff --git a/src/sessions.py b/src/sessions.py index f1eee158..a810d62d 100644 --- a/src/sessions.py +++ b/src/sessions.py @@ -1,11 +1,17 @@ -"""Sessions: PostgreSQL is the source of truth, Valkey is a read-through cache. +"""Sessions and profile cache. -Design: - * ``sessions`` rows in PostgreSQL decide validity (``expires_at > now()``). - * Valkey caches ``session:{token_hash} -> user_id`` with a TTL equal to the - remaining session lifetime. - * If Valkey is unreachable the cache is bypassed transparently and the API - keeps authenticating from PostgreSQL (Valkey is never trusted as authority). +PostgreSQL is the source of truth for **session validity**. Every authenticated +request resolves its bearer token against the ``sessions`` table, so an +expired, revoked or unknown token is rejected immediately - even if Valkey was +unreachable at logout time and the invalidation could not be performed. The +cache is therefore never consulted to decide whether a session is valid, and a +stale or not-invalidated entry cannot resurrect a revoked session. + +Valkey is a best-effort read-through cache for **immutable user profiles** +(``user:{id}``). Profiles do not carry authorization state, so a failed cache +operation only costs one extra SQL query; it can never change an access +decision. This keeps Redis/Valkey genuinely useful without weakening the +contract. Every cache operation is bounded by a hard timeout and guarded by a tiny circuit breaker. A stopped Valkey container can make Docker DNS itself block @@ -16,9 +22,10 @@ from __future__ import annotations import concurrent.futures import datetime as dt +import json import logging import time -from typing import Optional, Tuple +from typing import Dict, Optional, Tuple import redis from redis.backoff import NoBackoff @@ -38,6 +45,10 @@ _OP_TIMEOUT = 0.5 _BREAKER_SECONDS = 5.0 _breaker_until = 0.0 +# User profiles are immutable in the mandatory API, so a short TTL is enough +# and bounds staleness to a value that cannot affect authorization. +_USER_CACHE_TTL = 300 + def _cache() -> Optional[redis.Redis]: global _client, _client_disabled @@ -73,32 +84,36 @@ def _guard(fn, *args): return None -def _key(token_hash: str) -> str: - return f"session:{token_hash}" - - -def _cache_get(token_hash: str) -> Optional[str]: +def _cache_get(key: str) -> Optional[str]: client = _cache() if client is None: return None - value = _guard(lambda: client.get(_key(token_hash))) + value = _guard(lambda: client.get(key)) if value is None: return None return value.decode("utf-8") if isinstance(value, bytes) else str(value) -def _cache_set(token_hash: str, user_id: str, ttl_seconds: float) -> None: +def _cache_set(key: str, value: str, ttl_seconds: float) -> None: client = _cache() if client is None: return - _guard(lambda: client.set(_key(token_hash), user_id, ex=max(1, int(ttl_seconds)))) + _guard(lambda: client.set(key, value, ex=max(1, int(ttl_seconds)))) -def _cache_delete(token_hash: str) -> None: +def _cache_delete(key: str) -> None: client = _cache() if client is None: return - _guard(lambda: client.delete(_key(token_hash))) + _guard(lambda: client.delete(key)) + + +def _session_key(token_hash: str) -> str: + return f"session:{token_hash}" + + +def _user_key(user_id: str) -> str: + return f"user:{user_id}" def create(conn, user_id: str) -> Tuple[str, dt.datetime]: @@ -106,26 +121,44 @@ def create(conn, user_id: str) -> Tuple[str, dt.datetime]: hashed = security.token_hash(token) expires_at = repo.utcnow() + dt.timedelta(seconds=settings.session_ttl_seconds) repo.insert_session(conn, hashed, user_id, expires_at) - _cache_set(hashed, user_id, settings.session_ttl_seconds) return token, expires_at def resolve(conn, token: str) -> Optional[str]: + """Return the session's user id, or None if the token is not valid. + + Validity is always decided by PostgreSQL. The cache is *not* consulted here, + so revoking a session (DELETE row) takes effect immediately on every + replica regardless of the state of Valkey. + """ hashed = security.token_hash(token) - cached = _cache_get(hashed) - if cached is not None: - return cached row = repo.get_valid_session(conn, hashed) if row is None: + # Best-effort cleanup of any legacy session entry from older versions; + # never used for a decision. + _cache_delete(_session_key(hashed)) return None - user_id = str(row["user_id"]) - remaining = (row["expires_at"] - repo.utcnow()).total_seconds() - if remaining > 0: - _cache_set(hashed, user_id, remaining) - return user_id + return str(row["user_id"]) def revoke(conn, token: str) -> None: hashed = security.token_hash(token) repo.delete_session(conn, hashed) - _cache_delete(hashed) + _cache_delete(_session_key(hashed)) + + +def cached_user(conn, user_id: str) -> Optional[Dict]: + """Read-through cache of an immutable user profile (never authorization).""" + key = _user_key(user_id) + raw = _cache_get(key) + if raw is not None: + try: + return json.loads(raw) + except ValueError: + pass + row = repo.get_user_by_id(conn, user_id) + if row is None: + return None + data = repo.user_json(row) + _cache_set(key, json.dumps(data, ensure_ascii=False), _USER_CACHE_TTL) + return data diff --git a/student-tests/test_session_revocation.py b/student-tests/test_session_revocation.py new file mode 100644 index 00000000..e5c56547 --- /dev/null +++ b/student-tests/test_session_revocation.py @@ -0,0 +1,34 @@ +"""Lab3 revocation: logout takes effect immediately on every replica. + +Session validity is decided only by PostgreSQL, so a revoked token must be +rejected regardless of which replica answers and regardless of the cache state. +The heavier Valkey-outage reproduction lives in scripts/check-revocation.py. +""" +from __future__ import annotations + +import os + + +def _actor(client, label="revoke"): + suffix = os.urandom(4).hex() + username = f"s_{label}_{suffix}" + password = "T3st-" + os.urandom(8).hex() + assert client.register(username, password).status == 201 + token = client.login(username, password).json["token"] + return {"id": client.me(token).json["id"], "token": token} + + +def test_logout_invalidates_across_replicas(client): + actor = _actor(client) + seen = set() + for _ in range(20): + response = client.me(actor["token"]) + assert response.status == 200, response.body + seen.add(response.instance_id) + assert len(seen) >= 2, f"expected the LB to spread requests, saw {sorted(seen)}" + + logout = client.logout(actor["token"]) + assert logout.status == 204, logout.body + + for _ in range(20): + assert client.me(actor["token"]).status == 401