Author SHA1 Message Date
skripcsb add9fbb9f4 Implement messenger functionality 2026-10-30 16:12:37 +03:00
15 changed files with 986 additions and 32 deletions
+1 -7
View File
@@ -1,11 +1,5 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
POSTGRES_PASSWORD=replace-with-a-long-local-password
+12
View File
@@ -0,0 +1,12 @@
FROM python:3.13.2-slim@sha256:6b3223eb4d93718828223966ad316909c39813dee3ee9395204940500792b740
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app ./app
COPY migrations ./migrations
COPY scripts ./scripts
RUN useradd --uid 10001 --no-create-home appuser
USER 10001
EXPOSE 8080
CMD ["sh", "-c", "python scripts/migrate.py && uvicorn app.main:app --host 0.0.0.0 --port 8080"]
+22 -25
View File
@@ -1,37 +1,34 @@
# Отчёт — лабораторная 2
# Лабораторная работа 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
**Автор:** Скрипченко Анастасия · **Группа:** БПИ2304 · **Целевая оценка:** 4
## Запуск из чистого clone
## Запуск
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Создать `.env` из `.env.example`, задать `POSTGRES_PASSWORD`, затем выполнить:
## Архитектура и решения
```sh
docker compose --env-file .env up -d --build
python tests/smoke.py --base-url http://localhost:8080
```
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
Остановка с сохранением данных: `docker compose down`. Удаление учебных данных: `docker compose down -v`.
## Доказательства критериев
## Реализация
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
FastAPI использует PostgreSQL для пользователей, чатов, участников, сообщений и сессий. Redis кэширует сессии с TTL; PostgreSQL остаётся источником истины. Пароли хешируются Argon2id, сессии используют случайные Bearer-токены. Миграция задаёт внешние ключи, уникальность username и индекс истории `(chat_id, created_at, id)`. Создание чата и участников атомарно.
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
## Проверки
## Эксперименты и отказы
- Smoke API: PASS.
- Сохранение данных и активной сессии после перезапуска API, PostgreSQL и Redis: PASS.
- Конкурентная регистрация и откат создания чата: PASS.
- Истечение сессии с коротким TTL: PASS.
- Недоступность Redis и PostgreSQL: корректный ответ 503.
- Запрос по индексу на 100 000 синтетических строк: Index Scan, 50 строк за 0.108 мс.
- `scripts/check_contract.py`, синтаксис Python и Compose config: PASS.
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Полная OpenAPI-валидация не запускалась: пакет `openapi-spec-validator` отсутствовал.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
## Использованные средства
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
FastAPI, psycopg, PostgreSQL, Redis, argon2-cffi; исходники API лабораторной 1.
+717
View File
@@ -0,0 +1,717 @@
from __future__ import annotations
import base64
import hashlib
import secrets
import uuid
import os
from datetime import datetime, timezone, timedelta
from typing import Any
import psycopg
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool
import redis
from argon2 import PasswordHasher
from argon2.exceptions import VerifyMismatchError, InvalidHashError
from fastapi import FastAPI, Request, Query
from fastapi.responses import JSONResponse
from fastapi.exceptions import RequestValidationError
from starlette.exceptions import HTTPException as StarletteHTTPException
from pydantic import BaseModel, ConfigDict, Field, field_validator
DB_URL = os.getenv(
"DATABASE_URL",
"postgresql://messenger:messenger@localhost:5432/messenger"
)
REDIS_URL = os.getenv("REDIS_URL", "redis://localhost:6379/0")
TTL = int(os.getenv("SESSION_TTL_SECONDS", "3600"))
pool = ConnectionPool(
DB_URL,
min_size=1,
max_size=10,
timeout=5,
kwargs={
"connect_timeout": 5,
"options": "-c statement_timeout=5000",
"row_factory": dict_row
},
open=False
)
cache = redis.Redis.from_url(
REDIS_URL,
socket_connect_timeout=2,
socket_timeout=2,
decode_responses=True
)
ph = PasswordHasher()
app = FastAPI(
title="MTUSI Messenger",
version="2.0.0",
docs_url=None,
redoc_url=None
)
class ApiError(Exception):
def __init__(self, status: int, code: str, message: str):
self.status, self.code, self.message = status, code, message
class UserOut(BaseModel):
model_config = ConfigDict(extra="forbid")
id: uuid.UUID
username: str
display_name: str
created_at: str
class UserIn(BaseModel):
model_config = ConfigDict(extra="forbid")
username: str = Field(pattern=r"^[a-z0-9_]{3,32}$")
display_name: str = Field(min_length=1, max_length=100)
password: str = Field(min_length=12, max_length=128)
@field_validator("display_name")
@classmethod
def not_blank(cls, v):
if not v.strip():
raise ValueError("blank")
return v
class ChatIn(BaseModel):
model_config = ConfigDict(extra="forbid")
title: str = Field(min_length=1, max_length=100)
member_ids: list[uuid.UUID] = Field(min_length=1, max_length=100)
@field_validator("title")
@classmethod
def nonblank(cls, v):
if not v.strip():
raise ValueError("blank")
return v
@field_validator("member_ids")
@classmethod
def unique(cls, v):
if len(v) != len(set(v)):
raise ValueError("duplicate")
return v
class MessageIn(BaseModel):
model_config = ConfigDict(extra="forbid")
text: str = Field(min_length=1, max_length=4000)
@field_validator("text")
@classmethod
def nonblank(cls, v):
if not v.strip():
raise ValueError("blank")
return v
def stamp(v):
return (
v.astimezone(timezone.utc)
.isoformat(timespec="microseconds")
.replace("+00:00", "Z")
if isinstance(v, datetime)
else str(v)
)
def out(row):
d = dict(row)
d["created_at"] = stamp(d["created_at"])
return d
def err(request, status, code, message):
rid = getattr(request.state, "rid", str(uuid.uuid4()))
headers = {"X-Request-Id": rid}
if status == 401:
headers["WWW-Authenticate"] = (
'Basic realm="messenger", charset="UTF-8"'
if request.url.path == "/api/v1/auth/sessions"
else 'Bearer realm="messenger"'
)
return JSONResponse(
status_code=status,
content={
"error": {
"code": code,
"message": message,
"request_id": rid
}
},
headers=headers
)
@app.middleware("http")
async def request_mw(req, call_next):
req.state.rid = req.headers.get("X-Request-Id") or str(uuid.uuid4())
response = await call_next(req)
response.headers["X-Request-Id"] = req.state.rid
return response
@app.exception_handler(ApiError)
async def apierr(req, e):
return err(req, e.status, e.code, e.message)
@app.exception_handler(RequestValidationError)
async def valerr(req, e):
return err(req, 400, "invalid_request", "Некорректный запрос")
@app.exception_handler(StarletteHTTPException)
async def httperr(req, e):
return err(
req,
e.status_code,
"not_found" if e.status_code == 404 else "invalid_request",
"Недоступный HTTP маршрут или метод"
)
@app.exception_handler(psycopg.Error)
async def dberr(req, e):
return err(req, 503, "unavailable", "База данных временно недоступна")
@app.exception_handler(Exception)
async def unexpected(req, e):
return err(req, 500, "internal_error", "Внутренняя ошибка")
@app.on_event("startup")
def startup():
pool.open(wait=True)
@app.on_event("shutdown")
def shutdown():
pool.close()
def current(req):
h = req.headers.get("Authorization", "")
parts = h.split(" ", 1)
if len(parts) != 2 or parts[0].lower() != "bearer" or not parts[1]:
raise ApiError(401, "unauthorized", "Требуется действительная сессия")
token = parts[1]
digest = hashlib.sha256(token.encode()).hexdigest()
try:
uid = cache.get("session:" + digest)
if uid is None:
with pool.connection() as c:
row = c.execute(
"SELECT user_id,expires_at FROM sessions WHERE token_hash=%s",
(digest,)
).fetchone()
if not row or row["expires_at"] <= datetime.now(timezone.utc):
raise ApiError(
401,
"unauthorized",
"Требуется действительная сессия"
)
uid = str(row["user_id"])
remain = max(
1,
int(
(
row["expires_at"] - datetime.now(timezone.utc)
).total_seconds()
)
)
cache.setex("session:" + digest, remain, uid)
except redis.RedisError as e:
raise ApiError(
503,
"unavailable",
"Сервис сессий временно недоступен"
) from e
try:
uid = uuid.UUID(uid)
except (ValueError, TypeError, AttributeError) as e:
raise ApiError(
401,
"unauthorized",
"Требуется действительная сессия"
) from e
with pool.connection() as c:
user = c.execute(
"SELECT id,username,display_name,created_at FROM users WHERE id=%s",
(uid,)
).fetchone()
if not user:
raise ApiError(401, "unauthorized", "Требуется действительная сессия")
return user, digest
def membership(cid, uid):
with pool.connection() as c:
row = c.execute(
"SELECT 1 FROM memberships WHERE chat_id=%s AND user_id=%s",
(cid, uid)
).fetchone()
if not row:
raise ApiError(404, "not_found", "Объект не найден")
@app.get("/health/live")
def live():
return {"status": "ok"}
@app.get("/health/ready")
def ready():
try:
with pool.connection() as c:
c.execute("SELECT 1")
cache.ping()
return {"status": "ok"}
except Exception:
raise ApiError(503, "unavailable", "Зависимость временно недоступна")
@app.post("/api/v1/users", status_code=201)
def register(p: UserIn):
uid = uuid.uuid4()
try:
with pool.connection() as c:
with c.transaction():
r = c.execute(
"""
INSERT INTO users(id,username,display_name,password_hash)
VALUES(%s,%s,%s,%s)
RETURNING id,username,display_name,created_at
""",
(uid, p.username, p.display_name, ph.hash(p.password))
).fetchone()
return out(r)
except psycopg.errors.UniqueViolation as e:
raise ApiError(409, "conflict", "Username уже занят") from e
def basic_credentials(req):
h = req.headers.get("Authorization", "")
scheme, _, value = h.partition(" ")
try:
if scheme.lower() != "basic" or not value:
raise ValueError
decoded = base64.b64decode(value, validate=True).decode("utf-8")
username, password = decoded.split(":", 1)
if not username or not password:
raise ValueError
return username, password
except (ValueError, UnicodeError):
raise ApiError(401, "unauthorized", "Неверные учётные данные")
@app.post("/api/v1/auth/sessions", status_code=201)
def create_session(req: Request):
username, password = basic_credentials(req)
with pool.connection() as c:
user = c.execute(
"""
SELECT id,username,display_name,created_at,password_hash
FROM users WHERE username=%s
""",
(username,)
).fetchone()
good = False
if user:
try:
good = ph.verify(user["password_hash"], password)
except (VerifyMismatchError, InvalidHashError):
pass
if not good:
raise ApiError(401, "unauthorized", "Неверные учётные данные")
token = secrets.token_urlsafe(32)
digest = hashlib.sha256(token.encode()).hexdigest()
exp = datetime.now(timezone.utc) + timedelta(seconds=TTL)
try:
with pool.connection() as c:
c.execute(
"""
INSERT INTO sessions(token_hash,user_id,expires_at)
VALUES(%s,%s,%s)
""",
(digest, user["id"], exp)
)
cache.setex("session:" + digest, TTL, str(user["id"]))
except redis.RedisError as e:
with pool.connection() as c:
c.execute(
"DELETE FROM sessions WHERE token_hash=%s",
(digest,)
)
raise ApiError(
503,
"unavailable",
"Сервис сессий временно недоступен"
) from e
public_user = {
k: user[k]
for k in ("id", "username", "display_name", "created_at")
}
return {
"token": token,
"token_type": "Bearer",
"expires_at": stamp(exp),
"user": out(public_user)
}
@app.delete("/api/v1/auth/sessions/current", status_code=204)
def logout(req: Request):
user, digest = current(req)
try:
cache.delete("session:" + digest)
except redis.RedisError as e:
raise ApiError(
503,
"unavailable",
"Сервис сессий временно недоступен"
) from e
with pool.connection() as c:
c.execute(
"DELETE FROM sessions WHERE token_hash=%s",
(digest,)
)
return None
@app.get("/api/v1/users/me")
def me(req: Request):
return out(current(req)[0])
@app.post("/api/v1/chats", status_code=201)
def create_chat(req: Request, p: ChatIn):
user, _ = current(req)
cid = uuid.uuid4()
if user["id"] not in p.member_ids:
raise ApiError(400, "invalid_request", "Список участников некорректен")
try:
with pool.connection() as c:
with c.transaction():
c.execute(
"INSERT INTO chats(id,title) VALUES(%s,%s)",
(cid, p.title)
)
existing = c.execute(
"SELECT id FROM users WHERE id=ANY(%s)",
(p.member_ids,)
).fetchall()
if len(existing) != len(p.member_ids):
raise ApiError(
400,
"invalid_request",
"Список участников некорректен"
)
with c.cursor() as cur:
cur.executemany(
"INSERT INTO memberships(chat_id,user_id) VALUES(%s,%s)",
[(cid, x) for x in p.member_ids]
)
return {
"id": cid,
"title": p.title,
"member_ids": p.member_ids,
"created_at": stamp(
c.execute(
"SELECT created_at FROM chats WHERE id=%s",
(cid,)
).fetchone()["created_at"]
)
}
except psycopg.Error as e:
raise ApiError(
503,
"unavailable",
"База данных временно недоступна"
) from e
@app.get("/api/v1/chats")
def list_chats(
req: Request,
limit: int = Query(50, ge=1, le=100),
cursor: str | None = None
):
user, _ = current(req)
with pool.connection() as c:
query = (
"SELECT c.id,c.title,c.created_at,"
"array_agg(m.user_id ORDER BY m.user_id) member_ids "
"FROM chats c "
"JOIN memberships mine ON mine.chat_id=c.id "
"JOIN memberships m ON m.chat_id=c.id "
"WHERE mine.user_id=%s"
)
params = [user["id"]]
if cursor:
try:
import json
obj = json.loads(
base64.urlsafe_b64decode(
cursor + "=" * (-len(cursor) % 4)
).decode()
)
if obj["chat_id"] != str(uuid.UUID(int=0)):
raise ValueError
chat_marker = uuid.UUID(obj["id"])
datetime.fromisoformat(
obj["created_at"].replace("Z", "+00:00")
)
query += " AND (c.created_at,c.id)>(%s,%s)"
params.extend([obj["created_at"], chat_marker])
except Exception:
raise ApiError(400, "invalid_request", "Некорректный cursor")
query += " GROUP BY c.id ORDER BY c.created_at,c.id LIMIT %s"
params.append(limit + 1)
rows = c.execute(query, params).fetchall()
more = len(rows) > limit
items = [
{**out(r), "member_ids": r["member_ids"]}
for r in rows[:limit]
]
next_cursor = None
if more and items:
import json
z = items[-1]
next_cursor = base64.urlsafe_b64encode(
json.dumps(
{
"chat_id": str(uuid.UUID(int=0)),
"created_at": z["created_at"],
"id": str(z["id"])
},
separators=(",", ":")
).encode()
).decode().rstrip("=")
return {"items": items, "next_cursor": next_cursor}
@app.get("/api/v1/chats/{chat_id}")
def get_chat(req: Request, chat_id: uuid.UUID):
user, _ = current(req)
membership(chat_id, user["id"])
with pool.connection() as c:
r = c.execute(
"""
SELECT c.id,c.title,c.created_at,
array_agg(m.user_id ORDER BY m.user_id) member_ids
FROM chats c
JOIN memberships m ON m.chat_id=c.id
WHERE c.id=%s GROUP BY c.id
""",
(chat_id,)
).fetchone()
return {**out(r), "member_ids": r["member_ids"]}
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
def create_message(req: Request, chat_id: uuid.UUID, p: MessageIn):
user, _ = current(req)
mid = uuid.uuid4()
try:
with pool.connection() as c:
with c.transaction():
if not c.execute(
"SELECT 1 FROM memberships WHERE chat_id=%s AND user_id=%s",
(chat_id, user["id"])
).fetchone():
raise ApiError(404, "not_found", "Объект не найден")
r = c.execute(
"""
INSERT INTO messages(id,chat_id,sender_id,text)
VALUES(%s,%s,%s,%s)
RETURNING id,chat_id,sender_id,text,created_at
""",
(mid, chat_id, user["id"], p.text)
).fetchone()
return out(r)
except psycopg.Error as e:
raise ApiError(
503,
"unavailable",
"База данных временно недоступна"
) from e
@app.get("/api/v1/chats/{chat_id}/messages")
def list_messages(
req: Request,
chat_id: uuid.UUID,
limit: int = Query(50, ge=1, le=100),
cursor: str | None = None
):
user, _ = current(req)
membership(chat_id, user["id"])
try:
with pool.connection() as c:
if cursor:
try:
raw = base64.urlsafe_b64decode(
cursor + "=" * (-len(cursor) % 4)
).decode()
obj = __import__("json").loads(raw)
if obj["chat_id"] != str(chat_id):
raise ValueError
marker = (
obj["created_at"],
uuid.UUID(obj["id"])
)
except Exception:
raise ApiError(
400,
"invalid_request",
"Некорректный cursor"
)
rows = c.execute(
"""
SELECT id,chat_id,sender_id,text,created_at
FROM messages
WHERE chat_id=%s AND (created_at,id)>(%s,%s)
ORDER BY created_at,id
LIMIT %s
""",
(chat_id, marker[0], marker[1], limit + 1)
).fetchall()
else:
rows = c.execute(
"""
SELECT id,chat_id,sender_id,text,created_at
FROM messages
WHERE chat_id=%s
ORDER BY created_at,id
LIMIT %s
""",
(chat_id, limit + 1)
).fetchall()
more = len(rows) > limit
items = [out(x) for x in rows[:limit]]
next_cursor = None
if more and items:
import json
z = items[-1]
next_cursor = base64.urlsafe_b64encode(
json.dumps(
{
"chat_id": str(chat_id),
"created_at": z["created_at"],
"id": str(z["id"])
},
separators=(",", ":")
).encode()
).decode().rstrip("=")
return {"items": items, "next_cursor": next_cursor}
except psycopg.Error as e:
raise ApiError(
503,
"unavailable",
"База данных временно недоступна"
) from e
+37
View File
@@ -0,0 +1,37 @@
services:
db:
image: postgres:17.2-alpine
environment:
POSTGRES_DB: messenger
POSTGRES_USER: messenger
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?set POSTGRES_PASSWORD in .env}
volumes: [pgdata:/var/lib/postgresql/data]
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 5s
timeout: 3s
retries: 20
redis:
image: redis:7.4.2-alpine
command: ["redis-server", "--appendonly", "yes", "--appendfsync", "always"]
volumes: [redisdata:/data]
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
timeout: 3s
retries: 20
api:
build: .
environment:
DATABASE_URL: postgresql://messenger:${POSTGRES_PASSWORD}@db:5432/messenger
REDIS_URL: redis://redis:6379/0
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
APP_HOST: 0.0.0.0
APP_PORT: 8080
ports: ["127.0.0.1:8080:8080"]
depends_on:
db: {condition: service_healthy}
redis: {condition: service_healthy}
volumes:
pgdata:
redisdata:
+24
View File
@@ -0,0 +1,24 @@
CREATE TABLE IF NOT EXISTS users (
id UUID PRIMARY KEY, username VARCHAR(32) NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'),
display_name VARCHAR(100) NOT NULL, password_hash TEXT NOT NULL, created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE TABLE IF NOT EXISTS chats (
id UUID PRIMARY KEY, title VARCHAR(100) NOT NULL, created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE TABLE IF NOT EXISTS memberships (
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
PRIMARY KEY(chat_id,user_id)
);
CREATE INDEX IF NOT EXISTS memberships_user_chat_idx ON memberships(user_id,chat_id);
CREATE TABLE IF NOT EXISTS messages (
id UUID PRIMARY KEY, chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id UUID NOT NULL REFERENCES users(id), text VARCHAR(4000) NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE INDEX IF NOT EXISTS messages_history_idx ON messages(chat_id,created_at,id);
CREATE TABLE IF NOT EXISTS sessions (
token_hash CHAR(64) PRIMARY KEY, user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
expires_at TIMESTAMPTZ NOT NULL
);
CREATE INDEX IF NOT EXISTS sessions_expiry_idx ON sessions(expires_at);
+5
View File
@@ -0,0 +1,5 @@
fastapi==0.127.0
uvicorn[standard]==0.42.0
psycopg[binary,pool]==3.2.6
argon2-cffi==23.1.0
redis==5.2.1
+20
View File
@@ -0,0 +1,20 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
restore() { docker compose --env-file .env start db redis >/dev/null; }
trap restore EXIT
docker compose --env-file .env stop redis
python3 tests/dependency_failure.py redis
docker compose --env-file .env start redis
for attempt in $(seq 1 30); do
if curl -fsS http://localhost:8080/health/ready >/dev/null; then break; fi
sleep 2
done
docker compose --env-file .env stop db
python3 tests/dependency_failure.py db
docker compose --env-file .env start db
for attempt in $(seq 1 30); do
if curl -fsS http://localhost:8080/health/ready >/dev/null; then break; fi
sleep 2
done
curl -fsS http://localhost:8080/health/ready >/dev/null
+30
View File
@@ -0,0 +1,30 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
backup=$(mktemp)
cp .env "$backup"
restore() {
cp "$backup" .env
rm -f "$backup"
docker compose --env-file .env up -d --force-recreate api
for attempt in $(seq 1 30); do
if curl -fsS http://localhost:8080/health/ready >/dev/null; then return; fi
sleep 2
done
return 1
}
trap restore EXIT
trap 'exit 130' INT
trap 'exit 143' TERM
if grep -q '^SESSION_TTL_SECONDS=' .env; then
sed -i 's/^SESSION_TTL_SECONDS=.*/SESSION_TTL_SECONDS=3/' .env
else
printf '\nSESSION_TTL_SECONDS=3\n' >> .env
fi
docker compose --env-file .env up -d --force-recreate api
for attempt in $(seq 1 30); do
if curl -fsS http://localhost:8080/health/ready >/dev/null; then break; fi
sleep 2
done
curl -fsS http://localhost:8080/health/ready >/dev/null
SESSION_TTL_SECONDS=3 python3 tests/expiry.py
+23
View File
@@ -0,0 +1,23 @@
BEGIN;
CREATE TEMP TABLE lab_messages (
id UUID NOT NULL,
chat_id INTEGER NOT NULL,
created_at TIMESTAMPTZ NOT NULL,
text VARCHAR(4000) NOT NULL
);
CREATE INDEX lab_messages_history_idx ON lab_messages(chat_id, created_at, id);
INSERT INTO lab_messages(id, chat_id, created_at, text)
SELECT md5(g::text)::uuid,
CASE WHEN g <= 10000 THEN 1 ELSE 2 + (g % 100) END,
TIMESTAMPTZ '2026-01-01 00:00:00+00' + g * INTERVAL '1 millisecond',
repeat('x', 40)
FROM generate_series(1, 100000) AS g;
ANALYZE lab_messages;
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, created_at, text
FROM lab_messages
WHERE chat_id = 1
AND (created_at, id) > (TIMESTAMPTZ '2026-01-01 00:00:05+00', md5('5000')::uuid)
ORDER BY created_at, id
LIMIT 50;
ROLLBACK;
+15
View File
@@ -0,0 +1,15 @@
import os
from pathlib import Path
import psycopg
url = os.environ["DATABASE_URL"]
with psycopg.connect(url, connect_timeout=5) as conn:
conn.execute("CREATE TABLE IF NOT EXISTS schema_migrations (version TEXT PRIMARY KEY, applied_at TIMESTAMPTZ NOT NULL DEFAULT now())")
for path in sorted((Path(__file__).resolve().parents[1] / "migrations").glob("*.sql")):
version = path.name
if conn.execute("SELECT 1 FROM schema_migrations WHERE version=%s", (version,)).fetchone():
continue
with conn.transaction():
conn.execute(path.read_text(encoding="utf-8"))
conn.execute("INSERT INTO schema_migrations(version) VALUES (%s)", (version,))
print("Migrations applied")
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
docker compose restart db redis api
+20
View File
@@ -0,0 +1,20 @@
import sys
import urllib.error
import urllib.request
kind=sys.argv[1]
if kind=="redis":
url="http://localhost:8080/api/v1/users/me"
headers={"Authorization":"Bearer synthetic-invalid-token"}
elif kind=="db":
url="http://localhost:8080/health/ready"
headers={}
else:
raise SystemExit("expected redis or db")
request=urllib.request.Request(url,headers=headers)
try:
with urllib.request.urlopen(request,timeout=10) as response: status=response.status
except urllib.error.HTTPError as error:
status=error.code
assert status==503, f"{kind} outage returned {status}, expected bounded 503"
print(f"PASS: {kind} outage returns 503")
+13
View File
@@ -0,0 +1,13 @@
import os
import time
from client import Client
base=os.environ.get("BASE_URL","http://localhost:8080")
ttl=int(os.environ.get("SESSION_TTL_SECONDS","3"))
if ttl>10: raise SystemExit("Run with a short SESSION_TTL_SECONDS (10 seconds or less)")
c=Client(base)
actor=c.user("expiry")
time.sleep(ttl+1.2)
response=c.call("GET","/api/v1/users/me",401,actor=actor)
assert response["status"]==401
print("PASS: expired Bearer session rejected after short TTL")
+43
View File
@@ -0,0 +1,43 @@
from concurrent.futures import ThreadPoolExecutor
import json
import urllib.error
import urllib.request
from urllib.parse import quote
import uuid
from client import Client
BASE="http://localhost:8080"
def register(body):
req=urllib.request.Request(BASE+"/api/v1/users",data=json.dumps(body).encode(),headers={"Content-Type":"application/json"},method="POST")
try:
with urllib.request.urlopen(req,timeout=10) as r: return r.status
except urllib.error.HTTPError as e: return e.code
def main():
uname="race_"+uuid.uuid4().hex[:20]
body={"username":uname,"display_name":"Race","password":"RacePassword-123456"}
with ThreadPoolExecutor(max_workers=12) as executor:
statuses=list(executor.map(register,[body]*12))
assert statuses.count(201)==1 and statuses.count(409)==11, statuses
c=Client(BASE)
actor=c.user("rollback")
for title in ("cursor first", "cursor second"):
c.call("POST", "/api/v1/chats", 201, actor=actor,
body={"title": title, "member_ids": [actor["id"]]}, schema="Chat")
page1=c.call("GET", "/api/v1/chats?limit=1", actor=actor, schema="ChatPage")["json"]
assert len(page1["items"]) == 1 and page1["next_cursor"]
page2=c.call("GET", "/api/v1/chats?limit=1&cursor=" + quote(page1["next_cursor"], safe=""), actor=actor, schema="ChatPage")["json"]
assert len(page2["items"]) == 1 and page2["next_cursor"] is None
assert page1["items"][0]["id"] != page2["items"][0]["id"]
before=c.call("GET","/api/v1/chats?limit=100",actor=actor,schema="ChatPage")["json"]["items"]
invalid=str(uuid.uuid4())
result=c.call("POST","/api/v1/chats",400,actor=actor,body={"title":"must rollback","member_ids":[actor["id"],invalid]})
assert result["status"]==400
after=c.call("GET","/api/v1/chats?limit=100",actor=actor,schema="ChatPage")["json"]["items"]
assert [x["id"] for x in after]==[x["id"] for x in before], "failed chat left partial state"
print("PASS: concurrent username uniqueness and atomic chat rollback")
if __name__=="__main__": main()