PostgreSQL как источник истины, непрозрачные сессии в Redis с TTL и AOF, миграции под advisory lock, пул и таймауты, проверки гонки/отката/отказов и отчёт с evidence.
492 lines
17 KiB
Python
492 lines
17 KiB
Python
"""HTTP API for laboratory 2 (PostgreSQL + opaque sessions in Redis)."""
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import logging
|
|
import time
|
|
import uuid
|
|
from datetime import datetime, timezone
|
|
|
|
import psycopg
|
|
import psycopg_pool
|
|
import redis
|
|
from argon2 import PasswordHasher
|
|
from argon2.exceptions import InvalidHashError, VerifyMismatchError
|
|
from flask import Flask, Response, g, request
|
|
|
|
from . import db, sessions
|
|
from .config import settings
|
|
from .errors import ApiError, bad_request, conflict, not_found, unauthorized, unavailable
|
|
from .validation import (
|
|
cursor_time,
|
|
decode_cursor,
|
|
display_name,
|
|
encode_cursor,
|
|
exact_keys,
|
|
json_object,
|
|
limit_arg,
|
|
message_text,
|
|
non_blank,
|
|
password,
|
|
username,
|
|
uuid_list,
|
|
uuid_value,
|
|
)
|
|
|
|
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s")
|
|
log = logging.getLogger("messenger.api")
|
|
|
|
app = Flask(__name__)
|
|
app.config["MAX_CONTENT_LENGTH"] = settings.max_body_bytes
|
|
hasher = PasswordHasher()
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Response helpers and middleware
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _json(payload: object, status: int = 200, headers: dict[str, str] | None = None) -> Response:
|
|
body = json.dumps(payload, ensure_ascii=False, separators=(",", ":"))
|
|
response = Response(body, status=status, mimetype="application/json")
|
|
for key, value in (headers or {}).items():
|
|
response.headers[key] = value
|
|
return response
|
|
|
|
|
|
def _error_response(error: ApiError, request_id: str) -> Response:
|
|
return _json(
|
|
{
|
|
"error": {
|
|
"code": error.code,
|
|
"message": error.message,
|
|
"request_id": request_id,
|
|
}
|
|
},
|
|
error.status,
|
|
error.headers,
|
|
)
|
|
|
|
|
|
@app.before_request
|
|
def _request_context() -> None:
|
|
g.request_id = uuid.uuid4().hex
|
|
g.started_at = time.monotonic()
|
|
db.start_background_initialisation()
|
|
|
|
|
|
@app.after_request
|
|
def _response_headers(response: Response) -> Response:
|
|
response.headers["X-Request-Id"] = g.get("request_id", uuid.uuid4().hex)
|
|
response.headers["Cache-Control"] = "no-store"
|
|
return response
|
|
|
|
|
|
@app.errorhandler(ApiError)
|
|
def _handle_api_error(error: ApiError) -> Response:
|
|
return _error_response(error, g.get("request_id", uuid.uuid4().hex))
|
|
|
|
|
|
@app.errorhandler(413)
|
|
def _handle_too_large(_error: object) -> Response:
|
|
return _error_response(
|
|
ApiError(413, "payload_too_large", "Тело запроса слишком велико"),
|
|
g.get("request_id", uuid.uuid4().hex),
|
|
)
|
|
|
|
|
|
@app.errorhandler(404)
|
|
def _handle_not_found(_error: object) -> Response:
|
|
return _error_response(not_found(), g.get("request_id", uuid.uuid4().hex))
|
|
|
|
|
|
@app.errorhandler(405)
|
|
def _handle_method(_error: object) -> Response:
|
|
return _error_response(bad_request("Метод не поддерживается"), g.get("request_id", uuid.uuid4().hex))
|
|
|
|
|
|
@app.errorhandler(Exception)
|
|
def _handle_unexpected(error: Exception) -> Response:
|
|
request_id = g.get("request_id", uuid.uuid4().hex)
|
|
if isinstance(error, (psycopg.OperationalError, psycopg_pool.PoolTimeout, psycopg_pool.PoolClosed)):
|
|
log.warning("database unavailable on %s %s: %s", request.method, request.path, type(error).__name__)
|
|
return _error_response(unavailable("База данных недоступна"), request_id)
|
|
if isinstance(error, redis.RedisError):
|
|
log.warning("session store unavailable on %s %s: %s", request.method, request.path, type(error).__name__)
|
|
return _error_response(unavailable("Хранилище сессий недоступно"), request_id)
|
|
log.exception("unhandled error on %s %s", request.method, request.path)
|
|
return _error_response(
|
|
ApiError(500, "internal_error", "Внутренняя ошибка сервера"), request_id
|
|
)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Serialisation
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def format_time(value: datetime) -> str:
|
|
return value.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
|
|
|
|
|
|
def user_json(row: dict) -> dict:
|
|
return {
|
|
"id": str(row["id"]),
|
|
"username": row["username"],
|
|
"display_name": row["display_name"],
|
|
"created_at": format_time(row["created_at"]),
|
|
}
|
|
|
|
|
|
def chat_json(row: dict) -> dict:
|
|
member_ids = sorted(str(item) for item in (row.get("member_ids") or []))
|
|
return {
|
|
"id": str(row["id"]),
|
|
"title": row["title"],
|
|
"member_ids": member_ids,
|
|
"created_at": format_time(row["created_at"]),
|
|
}
|
|
|
|
|
|
def message_json(row: dict) -> dict:
|
|
return {
|
|
"id": str(row["id"]),
|
|
"chat_id": str(row["chat_id"]),
|
|
"sender_id": str(row["sender_id"]),
|
|
"text": row["text"],
|
|
"created_at": format_time(row["created_at"]),
|
|
}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Authentication
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _bearer_token() -> str:
|
|
header = request.headers.get("Authorization", "")
|
|
parts = header.split(None, 1)
|
|
if len(parts) != 2 or parts[0].lower() != "bearer" or not parts[1].strip():
|
|
raise unauthorized()
|
|
return parts[1].strip()
|
|
|
|
|
|
def current_user() -> dict:
|
|
cached = g.get("current_user")
|
|
if cached is not None:
|
|
return cached
|
|
token = _bearer_token()
|
|
user_id, token_digest = sessions.resolve(token)
|
|
if not user_id:
|
|
raise unauthorized()
|
|
try:
|
|
parsed = uuid.UUID(user_id)
|
|
except ValueError as exc:
|
|
raise unauthorized() from exc
|
|
with db.pool().connection() as conn:
|
|
row = conn.execute(
|
|
"SELECT id, username, display_name, created_at FROM users WHERE id = %s",
|
|
(parsed,),
|
|
).fetchone()
|
|
if row is None:
|
|
sessions.revoke(token_digest)
|
|
raise unauthorized()
|
|
g.current_user = row
|
|
g.session_token_digest = token_digest
|
|
return row
|
|
|
|
|
|
def _basic_credentials() -> tuple[str, str]:
|
|
header = request.headers.get("Authorization", "")
|
|
parts = header.split(None, 1)
|
|
if len(parts) != 2 or parts[0].lower() != "basic":
|
|
raise unauthorized(basic=True)
|
|
import base64
|
|
|
|
try:
|
|
decoded = base64.b64decode(parts[1].strip(), validate=True).decode("utf-8")
|
|
except (ValueError, UnicodeError) as exc:
|
|
raise unauthorized(basic=True) from exc
|
|
name, separator, secret = decoded.partition(":")
|
|
if not separator or not name or not secret:
|
|
raise unauthorized(basic=True)
|
|
if len(name) > 32 or any(ord(char) > 127 for char in name):
|
|
raise unauthorized(basic=True)
|
|
return name, secret
|
|
|
|
|
|
def _authenticate_basic() -> dict:
|
|
name, secret = _basic_credentials()
|
|
with db.pool().connection() as conn:
|
|
row = conn.execute(
|
|
"SELECT id, username, display_name, password_hash, created_at FROM users WHERE username = %s",
|
|
(name,),
|
|
).fetchone()
|
|
if row is None:
|
|
raise unauthorized(basic=True)
|
|
try:
|
|
hasher.verify(row["password_hash"], secret)
|
|
except (VerifyMismatchError, InvalidHashError):
|
|
raise unauthorized(basic=True)
|
|
return row
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Health
|
|
# ---------------------------------------------------------------------------
|
|
|
|
@app.get("/health/live")
|
|
def health_live() -> Response:
|
|
return _json({"status": "ok"})
|
|
|
|
|
|
@app.get("/health/ready")
|
|
def health_ready() -> Response:
|
|
if not db.is_migrated():
|
|
raise unavailable("База данных ещё не готова")
|
|
try:
|
|
with db.pool().connection(timeout=1.0) as conn:
|
|
conn.execute("SELECT 1")
|
|
except Exception as exc:
|
|
raise unavailable("База данных недоступна") from exc
|
|
sessions.ping()
|
|
return _json({"status": "ok"})
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Users and sessions
|
|
# ---------------------------------------------------------------------------
|
|
|
|
@app.post("/api/v1/users")
|
|
def register_user() -> Response:
|
|
body = json_object(request, settings.max_body_bytes)
|
|
exact_keys(body, ("username", "display_name", "password"))
|
|
name = username(body["username"])
|
|
shown_name = display_name(body["display_name"])
|
|
secret = password(body["password"])
|
|
user_id = uuid.uuid4()
|
|
try:
|
|
with db.pool().connection() as conn:
|
|
row = conn.execute(
|
|
"""
|
|
INSERT INTO users (id, username, display_name, password_hash)
|
|
VALUES (%s, %s, %s, %s)
|
|
RETURNING id, username, display_name, created_at
|
|
""",
|
|
(user_id, name, shown_name, hasher.hash(secret)),
|
|
).fetchone()
|
|
except psycopg.errors.UniqueViolation as exc:
|
|
raise conflict("Username уже занят") from exc
|
|
return _json(user_json(row), 201)
|
|
|
|
|
|
@app.post("/api/v1/auth/sessions")
|
|
def create_session() -> Response:
|
|
row = _authenticate_basic()
|
|
token, expires_at = sessions.create(str(row["id"]))
|
|
return _json(
|
|
{
|
|
"token": token,
|
|
"token_type": "Bearer",
|
|
"expires_at": format_time(expires_at),
|
|
"user": user_json(row),
|
|
},
|
|
201,
|
|
)
|
|
|
|
|
|
@app.delete("/api/v1/auth/sessions/current")
|
|
def revoke_session() -> Response:
|
|
current_user() # authentication must happen before revocation
|
|
sessions.revoke(g.session_token_digest)
|
|
return Response(status=204)
|
|
|
|
|
|
@app.get("/api/v1/users/me")
|
|
def current_user_endpoint() -> Response:
|
|
return _json(user_json(current_user()))
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Chats
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _require_chat_member(chat_id: uuid.UUID, user_id: uuid.UUID) -> None:
|
|
with db.pool().connection() as conn:
|
|
row = conn.execute(
|
|
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
|
|
(chat_id, user_id),
|
|
).fetchone()
|
|
if row is None:
|
|
raise not_found()
|
|
|
|
|
|
@app.post("/api/v1/chats")
|
|
def create_chat() -> Response:
|
|
actor = current_user()
|
|
body = json_object(request, settings.max_body_bytes)
|
|
exact_keys(body, ("title", "member_ids"))
|
|
title = non_blank(body["title"], "title", 1, 100)
|
|
member_ids = uuid_list(body["member_ids"], "member_ids")
|
|
actor_id = str(actor["id"])
|
|
if actor_id not in member_ids:
|
|
raise bad_request("Создатель должен входить в member_ids")
|
|
|
|
member_uuids = [uuid.UUID(item) for item in member_ids]
|
|
chat_id = uuid.uuid4()
|
|
with db.pool().connection() as conn:
|
|
existing = conn.execute(
|
|
"SELECT id FROM users WHERE id = ANY(%s)", (member_uuids,)
|
|
).fetchall()
|
|
if len(existing) != len(member_uuids):
|
|
raise bad_request("Указан неизвестный участник")
|
|
row = conn.execute(
|
|
"INSERT INTO chats (id, title) VALUES (%s, %s) RETURNING id, title, created_at",
|
|
(chat_id, title),
|
|
).fetchone()
|
|
with conn.cursor() as cursor:
|
|
cursor.executemany(
|
|
"INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)",
|
|
[(chat_id, member) for member in member_uuids],
|
|
)
|
|
payload = dict(row)
|
|
payload["member_ids"] = member_uuids
|
|
return _json(chat_json(payload), 201)
|
|
|
|
|
|
@app.get("/api/v1/chats")
|
|
def list_chats() -> Response:
|
|
actor = current_user()
|
|
limit = limit_arg(request.args.get("limit"))
|
|
cursor = decode_cursor(request.args.get("cursor"))
|
|
parameters: list[object] = [actor["id"]]
|
|
predicate = ""
|
|
if cursor is not None:
|
|
if cursor.get("kind") != "chats" or cursor.get("user_id") != str(actor["id"]):
|
|
raise bad_request("Некорректный cursor")
|
|
try:
|
|
cursor_created = cursor_time(cursor.get("created_at"))
|
|
cursor_id = uuid_value(cursor.get("id"), "cursor")
|
|
except ApiError:
|
|
raise bad_request("Некорректный cursor")
|
|
predicate = "AND (c.created_at, c.id) > (%s, %s)"
|
|
parameters.extend([cursor_created, cursor_id])
|
|
parameters.append(limit + 1)
|
|
query = f"""
|
|
SELECT c.id, c.title, c.created_at,
|
|
ARRAY(
|
|
SELECT cm.user_id FROM chat_members cm
|
|
WHERE cm.chat_id = c.id ORDER BY cm.user_id
|
|
) AS member_ids
|
|
FROM chats c
|
|
JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s
|
|
WHERE TRUE {predicate}
|
|
ORDER BY c.created_at, c.id
|
|
LIMIT %s
|
|
"""
|
|
with db.pool().connection() as conn:
|
|
rows = conn.execute(query, tuple(parameters)).fetchall()
|
|
page = rows[:limit]
|
|
next_cursor = None
|
|
if len(rows) > limit and page:
|
|
last = page[-1]
|
|
next_cursor = encode_cursor(
|
|
{
|
|
"v": 1,
|
|
"kind": "chats",
|
|
"user_id": str(actor["id"]),
|
|
"created_at": format_time(last["created_at"]),
|
|
"id": str(last["id"]),
|
|
}
|
|
)
|
|
return _json({"items": [chat_json(row) for row in page], "next_cursor": next_cursor})
|
|
|
|
|
|
@app.get("/api/v1/chats/<chat_id>")
|
|
def get_chat(chat_id: str) -> Response:
|
|
actor = current_user()
|
|
parsed_chat_id = uuid_value(chat_id, "chat_id")
|
|
with db.pool().connection() as conn:
|
|
row = conn.execute(
|
|
"""
|
|
SELECT c.id, c.title, c.created_at,
|
|
ARRAY(
|
|
SELECT cm.user_id FROM chat_members cm
|
|
WHERE cm.chat_id = c.id ORDER BY cm.user_id
|
|
) AS member_ids
|
|
FROM chats c
|
|
JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s
|
|
WHERE c.id = %s
|
|
""",
|
|
(actor["id"], parsed_chat_id),
|
|
).fetchone()
|
|
if row is None:
|
|
raise not_found()
|
|
return _json(chat_json(row))
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Messages
|
|
# ---------------------------------------------------------------------------
|
|
|
|
@app.post("/api/v1/chats/<chat_id>/messages")
|
|
def create_message(chat_id: str) -> Response:
|
|
actor = current_user()
|
|
parsed_chat_id = uuid_value(chat_id, "chat_id")
|
|
_require_chat_member(parsed_chat_id, actor["id"])
|
|
body = json_object(request, settings.max_body_bytes)
|
|
exact_keys(body, ("text",))
|
|
text = message_text(body["text"])
|
|
with db.pool().connection() as conn:
|
|
row = conn.execute(
|
|
"""
|
|
INSERT INTO messages (id, chat_id, sender_id, text)
|
|
VALUES (%s, %s, %s, %s)
|
|
RETURNING id, chat_id, sender_id, text, created_at
|
|
""",
|
|
(uuid.uuid4(), parsed_chat_id, actor["id"], text),
|
|
).fetchone()
|
|
return _json(message_json(row), 201)
|
|
|
|
|
|
@app.get("/api/v1/chats/<chat_id>/messages")
|
|
def list_messages(chat_id: str) -> Response:
|
|
actor = current_user()
|
|
parsed_chat_id = uuid_value(chat_id, "chat_id")
|
|
_require_chat_member(parsed_chat_id, actor["id"])
|
|
limit = limit_arg(request.args.get("limit"))
|
|
cursor = decode_cursor(request.args.get("cursor"))
|
|
parameters: list[object] = [parsed_chat_id]
|
|
predicate = ""
|
|
if cursor is not None:
|
|
if cursor.get("kind") != "messages" or cursor.get("chat_id") != str(parsed_chat_id):
|
|
raise bad_request("Некорректный cursor")
|
|
try:
|
|
cursor_created = cursor_time(cursor.get("created_at"))
|
|
cursor_id = uuid_value(cursor.get("id"), "cursor")
|
|
except ApiError:
|
|
raise bad_request("Некорректный cursor")
|
|
predicate = "AND (created_at, id) > (%s, %s)"
|
|
parameters.extend([cursor_created, cursor_id])
|
|
parameters.append(limit + 1)
|
|
query = f"""
|
|
SELECT id, chat_id, sender_id, text, created_at
|
|
FROM messages
|
|
WHERE chat_id = %s {predicate}
|
|
ORDER BY created_at, id
|
|
LIMIT %s
|
|
"""
|
|
with db.pool().connection() as conn:
|
|
rows = conn.execute(query, tuple(parameters)).fetchall()
|
|
page = rows[:limit]
|
|
next_cursor = None
|
|
if len(rows) > limit and page:
|
|
last = page[-1]
|
|
next_cursor = encode_cursor(
|
|
{
|
|
"v": 1,
|
|
"kind": "messages",
|
|
"chat_id": str(parsed_chat_id),
|
|
"created_at": format_time(last["created_at"]),
|
|
"id": str(last["id"]),
|
|
}
|
|
)
|
|
return _json({"items": [message_json(row) for row in page], "next_cursor": next_cursor})
|