Перенести приложение мессенджера с сессиями в PostgreSQL

Реализован Flask-мессенджер (авторизация с Argon2-сессиями в PostgreSQL,
чаты, сообщения, курсорная пагинация), миграции 001, зависимости и цели
make run/migrate. Отправка сообщения пока без идемпотентности.
This commit is contained in:
2026-11-16 22:17:40 +00:00
parent 0ab3a341aa
commit 9698fae3be
15 changed files with 626 additions and 0 deletions
+5
View File
@@ -28,3 +28,8 @@ test-persistence:
test-failover:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2)
$(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
.PHONY: run migrate
run:
$(PYTHON) -m messenger
migrate:
$(PYTHON) -m messenger.migrate
+1
View File
@@ -0,0 +1 @@
"""Messenger lab series."""
+41
View File
@@ -0,0 +1,41 @@
"""One process per replica; bounded drain on SIGTERM."""
import logging
import signal
import time
from waitress import create_server
from .api import create_app
from .config import Settings
def main():
logging.basicConfig(level=logging.INFO)
settings = Settings.from_env()
app = create_app(settings=settings)
server = create_server(app, host=settings.host, port=settings.port, threads=4)
stopping = False
def stop(signum, frame):
nonlocal stopping
stopping = True
signal.signal(signal.SIGTERM, stop)
signal.signal(signal.SIGINT, stop)
logging.info('Starting messenger environment=%s', settings.environment)
try:
while not stopping:
server.asyncore.loop(timeout=0.1, count=1, map=server._map)
# Stop accepting new TCP connections. Keep the event loop alive briefly
# so responses from existing worker tasks can still be flushed.
app.config['DRAINING'] = True
server.close()
deadline = time.monotonic() + 5
while server._map and time.monotonic() < deadline:
server.asyncore.loop(timeout=0.1, count=1, map=server._map)
finally:
server.task_dispatcher.shutdown(timeout=1)
server.asyncore.close_all(map=server._map)
logging.info('Messenger stopped')
if __name__ == '__main__':
main()
+118
View File
@@ -0,0 +1,118 @@
"""HTTP adapter and composition root."""
import json
from uuid import uuid4
from flask import Flask, g, request, jsonify
from werkzeug.exceptions import HTTPException
from .domain import ApiError, invalid
from .postgres import PostgresRepository
from .database import Database
from .config import Settings
from .service import Messenger
def create_app(repository=None, settings=None):
app = Flask(__name__)
app.json.ensure_ascii = False
settings = settings or Settings.from_env()
repository = repository if repository is not None else PostgresRepository(Database(settings.database_url))
service = Messenger(repository, settings.session_ttl)
instance_id = str(uuid4())
@app.before_request
def identify():
g.request_id = str(uuid4())
if app.config.get('DRAINING'):
raise ApiError(503, 'unavailable', 'Instance is shutting down')
if request.path.startswith('/api/v1/') and not (
request.path in ('/api/v1/users', '/api/v1/auth/sessions') and request.method == 'POST'
):
g.user, g.token_hash = service.auth.bearer(request.headers.get('Authorization'))
@app.after_request
def request_id(response):
response.headers['X-Request-Id'] = g.request_id
response.headers['X-Instance-Id'] = instance_id
return response
@app.errorhandler(Exception)
def error(exc):
if isinstance(exc, ApiError):
status, code, message = exc.status, exc.code, exc.message
elif isinstance(exc, HTTPException):
status = exc.code
code = {404: 'not_found', 413: 'payload_too_large', 415: 'unsupported_media_type'}.get(status, 'invalid_request')
message = exc.name
else:
app.logger.error('Unhandled error; request_id=%s', g.request_id)
status, code, message = 500, 'internal_error', 'Internal server error'
response = jsonify(error={'code': code, 'message': message, 'request_id': g.request_id})
response.status_code = status
if status == 401:
response.headers['WWW-Authenticate'] = (
'Basic realm="messenger", charset="UTF-8"'
if request.path == '/api/v1/auth/sessions' and request.method == 'POST'
else 'Bearer realm="messenger"')
return response
def body():
if request.mimetype != 'application/json':
raise ApiError(415, 'unsupported_media_type', 'Use application/json')
try:
def reject_constant(value):
raise ValueError(value)
return json.loads(request.get_data().decode('utf-8'), parse_constant=reject_constant)
except (ValueError, UnicodeError):
invalid('Malformed UTF-8 JSON')
def paging():
for key in ('limit', 'cursor'):
if len(request.args.getlist(key)) > 1:
invalid('Duplicate query parameter')
return request.args.get('limit', '50'), request.args.get('cursor')
@app.get('/health/live')
def health():
return jsonify(status='ok')
@app.get('/health/ready')
def ready():
repository.ready()
return jsonify(status='ok')
@app.post('/api/v1/auth/sessions')
def login():
# Session creation accepts no request body.
if request.get_data():
invalid('Session creation does not accept a body')
return jsonify(service.auth.login(request.headers.get('Authorization'))), 201
@app.delete('/api/v1/auth/sessions/current')
def logout():
repository.revoke_session(g.token_hash)
return '', 204
@app.post('/api/v1/users')
def register():
return jsonify(service.register(body())), 201
@app.get('/api/v1/users/me')
def me():
return jsonify(g.user)
@app.route('/api/v1/chats', methods=['GET', 'POST'])
def chats():
if request.method == 'POST':
return jsonify(service.create_chat(g.user['id'], body())), 201
return jsonify(service.chats(g.user['id'], *paging()))
@app.get('/api/v1/chats/<chat_id>')
def chat(chat_id):
return jsonify(service.chat(g.user['id'], chat_id))
@app.route('/api/v1/chats/<chat_id>/messages', methods=['GET', 'POST'])
def messages(chat_id):
if request.method == 'POST':
return jsonify(service.send(g.user['id'], chat_id, body())), 201
return jsonify(service.history(g.user['id'], chat_id, *paging()))
return app
+28
View File
@@ -0,0 +1,28 @@
"""Configuration is loaded only at process startup; secrets are never logged."""
import os
from dataclasses import dataclass
from pathlib import Path
@dataclass(frozen=True)
class Settings:
database_url: str
host: str = '0.0.0.0'
port: int = 8080
environment: str = 'lab'
session_ttl: int = 3600
@classmethod
def from_env(cls):
source = os.getenv('DATABASE_URL_FILE')
url = Path(source).read_text().strip() if source else os.getenv('DATABASE_URL', '')
if not url:
raise ValueError('Set DATABASE_URL_FILE or DATABASE_URL')
if os.getenv('SESSION_STORE', 'postgres') != 'postgres':
raise ValueError('This lab uses SESSION_STORE=postgres')
port = int(os.getenv('APP_PORT', '8080'))
ttl = int(os.getenv('SESSION_TTL_SECONDS', '3600'))
if not 1 <= port <= 65535 or ttl <= 0:
raise ValueError('Invalid APP_PORT or SESSION_TTL_SECONDS')
return cls(url, os.getenv('APP_HOST', '0.0.0.0'), port,
os.getenv('APP_ENV', 'lab'), ttl)
+20
View File
@@ -0,0 +1,20 @@
"""Short-lived database connections, one transaction per operation."""
from contextlib import contextmanager
import psycopg
from psycopg.rows import dict_row
from .domain import ApiError
class Database:
def __init__(self, url):
self.url = url
@contextmanager
def transaction(self):
try:
with psycopg.connect(self.url, row_factory=dict_row, connect_timeout=3,
options='-c statement_timeout=5000 -c lock_timeout=3000 -c timezone=UTC') as conn:
yield conn
except (psycopg.OperationalError, psycopg.InterfaceError,
psycopg.errors.QueryCanceled, psycopg.errors.LockNotAvailable):
raise ApiError(503, 'unavailable', 'Database temporarily unavailable') from None
+33
View File
@@ -0,0 +1,33 @@
"""Framework-independent validation and application errors."""
import re
from uuid import UUID
class ApiError(Exception):
def __init__(self, status, code, message):
self.status, self.code, self.message = status, code, message
def invalid(message='Invalid request'):
raise ApiError(400, 'invalid_request', message)
def uuid_value(value):
if not isinstance(value, str) or not re.fullmatch(
r'[0-9a-fA-F]{8}(?:-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}', value
):
invalid('Invalid UUID')
return str(UUID(value))
def fields(body, names):
if not isinstance(body, dict) or set(body) != set(names):
invalid('Required fields are missing or unknown fields supplied')
def string(value, maximum):
if (not isinstance(value, str) or not value.strip()
or len(value) > maximum or "\x00" in value
or any(0xD800 <= ord(c) <= 0xDFFF for c in value)):
invalid('Invalid string')
return value
+24
View File
@@ -0,0 +1,24 @@
"""Versioned, transactional migrations; safe to run again."""
from pathlib import Path
import secrets
from .config import Settings
from .database import Database
def migrate(database):
directory = Path(__file__).resolve().parents[1] / 'migrations'
with database.transaction() as conn:
conn.execute('SELECT pg_advisory_xact_lock(20260201)')
conn.execute('CREATE TABLE IF NOT EXISTS schema_migrations (version text PRIMARY KEY)')
versions = {r['version'] for r in conn.execute('SELECT version FROM schema_migrations')}
for path in sorted(directory.glob('*.sql')):
if path.name not in versions:
conn.execute(path.read_text(encoding='utf-8'))
conn.execute('INSERT INTO schema_migrations(version) VALUES (%s)', (path.name,))
conn.execute("INSERT INTO app_settings(name,value) VALUES ('cursor_key',%s) ON CONFLICT DO NOTHING",
(secrets.token_hex(32),))
if __name__ == '__main__':
migrate(Database(Settings.from_env().database_url))
print('Migrations applied successfully (already applied versions skipped).')
+43
View File
@@ -0,0 +1,43 @@
"""Resource-scoped signed cursors; SQL fetches only limit+1 rows."""
import base64
import hashlib
import hmac
import json
import re
from datetime import datetime
from .domain import invalid, uuid_value
class Pagination:
def __init__(self, key):
self._key = key
def decode(self, scope, limit, cursor):
if not re.fullmatch(r'[0-9]{1,3}', limit) or not 1 <= int(limit) <= 100:
invalid('Limit must be between 1 and 100')
after = None
if cursor is not None:
try:
if len(cursor) > 2048:
raise ValueError()
raw = base64.b64decode(cursor, altchars=b'-_', validate=True)
payload, signature = raw[:-32], raw[-32:]
if not hmac.compare_digest(signature, hmac.digest(self._key, payload, hashlib.sha256)):
raise ValueError()
saved_scope, timestamp, identifier = json.loads(payload)
if saved_scope != scope or not isinstance(timestamp, str):
raise ValueError()
datetime.fromisoformat(timestamp.replace('Z', '+00:00'))
after = (timestamp, uuid_value(identifier))
except (ValueError, TypeError, UnicodeError):
invalid('Invalid cursor for this resource')
return int(limit), after
def page(self, rows, scope, limit):
items = rows[:limit]
next_cursor = None
if len(rows) > limit:
last = items[-1]
payload = json.dumps([scope, last['created_at'], last['id']], separators=(',', ':')).encode()
next_cursor = base64.urlsafe_b64encode(payload + hmac.digest(self._key, payload, hashlib.sha256)).decode()
return {'items': items, 'next_cursor': next_cursor}
+133
View File
@@ -0,0 +1,133 @@
"""PostgreSQL repository: all SQL values are bound parameters."""
from datetime import datetime, timezone
from uuid import UUID, uuid4
import psycopg
from .domain import ApiError, invalid
def serialize(row):
if row is None:
return None
result = {}
for key, value in row.items():
if isinstance(value, UUID):
value = str(value)
elif isinstance(value, datetime):
value = value.astimezone(timezone.utc).isoformat(timespec='microseconds').replace('+00:00', 'Z')
elif isinstance(value, list):
value = [str(item) if isinstance(item, UUID) else item for item in value]
result[key] = value
return result
USER_COLUMNS = 'id, username, display_name, created_at'
# Members retain the request order, with no password/session fields in public objects.
CHAT_COLUMNS = '''c.id, c.title, c.created_at,
ARRAY(SELECT m.user_id FROM chat_members m WHERE m.chat_id=c.id ORDER BY m.position) AS member_ids'''
class PostgresRepository:
def __init__(self, database):
self.db = database
def ready(self):
with self.db.transaction() as conn:
conn.execute('SELECT id FROM users LIMIT 0')
conn.execute('SELECT token_hash FROM sessions LIMIT 0')
def cursor_key(self):
with self.db.transaction() as conn:
row = conn.execute("SELECT value FROM app_settings WHERE name='cursor_key'").fetchone()
if row is None:
raise ApiError(503, 'unavailable', 'Database is not initialized')
return bytes.fromhex(row['value'])
def create_user(self, username, display_name, password_hash):
try:
with self.db.transaction() as conn:
row = conn.execute('INSERT INTO users(id,username,display_name,password_hash) VALUES (%s,%s,%s,%s) RETURNING ' + USER_COLUMNS,
(uuid4(), username, display_name, password_hash)).fetchone()
return serialize(row)
except psycopg.errors.UniqueViolation:
raise ApiError(409, 'conflict', 'Username already exists') from None
def credentials(self, username):
with self.db.transaction() as conn:
return serialize(conn.execute('SELECT ' + USER_COLUMNS + ', password_hash FROM users WHERE username=%s',
(username,)).fetchone())
def create_session(self, user_id, token_hash, ttl):
with self.db.transaction() as conn:
row = conn.execute('INSERT INTO sessions(token_hash,user_id,expires_at) VALUES (%s,%s,clock_timestamp() + %s * interval \'1 second\') RETURNING expires_at',
(token_hash, user_id, ttl)).fetchone()
return serialize(row)['expires_at']
def session_user(self, token_hash):
with self.db.transaction() as conn:
row = conn.execute('''SELECT u.id,u.username,u.display_name,u.created_at FROM users u
JOIN sessions s ON s.user_id=u.id
WHERE s.token_hash=%s AND s.expires_at>clock_timestamp()''', (token_hash,)).fetchone()
if row is None:
raise ApiError(401, 'unauthorized', 'Valid Bearer session required')
return serialize(row)
def revoke_session(self, token_hash):
with self.db.transaction() as conn:
conn.execute('DELETE FROM sessions WHERE token_hash=%s', (token_hash,))
@staticmethod
def _access(conn, actor, chat_id):
if conn.execute('SELECT 1 FROM chat_members WHERE chat_id=%s AND user_id=%s', (chat_id, actor)).fetchone() is None:
raise ApiError(404, 'not_found', 'Chat not found')
def create_chat(self, actor, title, members):
with self.db.transaction() as conn:
count = conn.execute('SELECT count(*) AS n FROM users WHERE id=ANY(%s::uuid[])', (members,)).fetchone()['n']
if actor not in members or count != len(members):
invalid('Members must exist and include the current user')
identifier = uuid4()
conn.execute('INSERT INTO chats(id,title) VALUES (%s,%s)', (identifier, title))
with conn.cursor() as cur:
cur.executemany('INSERT INTO chat_members(chat_id,user_id,position) VALUES (%s,%s,%s)',
[(identifier, member, i) for i, member in enumerate(members)])
row = conn.execute('SELECT ' + CHAT_COLUMNS + ' FROM chats c WHERE c.id=%s', (identifier,)).fetchone()
return serialize(row)
def chat(self, actor, chat_id):
with self.db.transaction() as conn:
self._access(conn, actor, chat_id)
row = conn.execute('SELECT ' + CHAT_COLUMNS + ' FROM chats c WHERE c.id=%s', (chat_id,)).fetchone()
return serialize(row)
def chats(self, actor, limit, after):
params = [actor]
boundary = ''
if after is not None:
boundary = ' AND (c.created_at,c.id)>(%s::timestamptz,%s::uuid)'
params.extend(after)
params.append(limit)
with self.db.transaction() as conn:
rows = conn.execute('SELECT ' + CHAT_COLUMNS + ''' FROM chats c JOIN chat_members own
ON own.chat_id=c.id WHERE own.user_id=%s''' + boundary +
' ORDER BY c.created_at,c.id LIMIT %s', params).fetchall()
return [serialize(r) for r in rows]
def create_message(self, actor, chat_id, text):
with self.db.transaction() as conn:
self._access(conn, actor, chat_id)
row = conn.execute('INSERT INTO messages(id,chat_id,sender_id,text) VALUES (%s,%s,%s,%s) RETURNING *',
(uuid4(), chat_id, actor, text)).fetchone()
return serialize(row)
def messages(self, actor, chat_id, limit, after):
params = [chat_id]
boundary = ''
if after is not None:
boundary = ' AND (created_at,id)>(%s::timestamptz,%s::uuid)'
params.extend(after)
params.append(limit)
with self.db.transaction() as conn:
self._access(conn, actor, chat_id)
rows = conn.execute('SELECT * FROM messages WHERE chat_id=%s' + boundary +
' ORDER BY created_at,id LIMIT %s', params).fetchall()
return [serialize(r) for r in rows]
+17
View File
@@ -0,0 +1,17 @@
"""Storage port. Concrete PostgreSQL adapter is wired in api.create_app."""
from typing import Protocol
class Repository(Protocol):
def ready(self): ...
def cursor_key(self): ...
def create_user(self, username, display_name, password_hash): ...
def credentials(self, username): ...
def create_session(self, user_id, token_hash, ttl): ...
def session_user(self, token_hash): ...
def revoke_session(self, token_hash): ...
def create_chat(self, actor, title, members): ...
def chat(self, actor, chat_id): ...
def chats(self, actor, limit, after): ...
def create_message(self, actor, chat_id, text): ...
def messages(self, actor, chat_id, limit, after): ...
+60
View File
@@ -0,0 +1,60 @@
"""Password KDF and HTTP credential parsing, without framework dependencies."""
import base64
import binascii
import hashlib
import re
import secrets
from argon2 import PasswordHasher, Type
from argon2.exceptions import VerificationError, InvalidHashError
from .domain import ApiError, invalid, string
class Authentication:
def __init__(self, repository, ttl):
self.repository = repository
self.ttl = ttl
self.hasher = PasswordHasher(time_cost=3, memory_cost=65536, parallelism=2,
hash_len=32, salt_len=16, type=Type.ID)
self._dummy = self.hasher.hash(secrets.token_urlsafe(32))
@staticmethod
def password(value):
string(value, 128)
if len(value) < 12:
invalid('Password must contain 12 to 128 Unicode characters')
return value
@staticmethod
def digest(token):
return hashlib.sha256(token.encode('ascii')).hexdigest()
def bearer(self, header):
parts = (header or '').split()
if len(parts) != 2 or parts[0].lower() != 'bearer' or not re.fullmatch(r'[A-Za-z0-9_-]{43}', parts[1]):
raise ApiError(401, 'unauthorized', 'Valid Bearer session required')
token_hash = self.digest(parts[1])
return self.repository.session_user(token_hash), token_hash
def login(self, header):
def denied():
raise ApiError(401, 'unauthorized', 'Invalid credentials')
try:
parts = (header or '').split()
if len(parts) != 2 or parts[0].lower() != 'basic':
denied()
username, password = base64.b64decode(parts[1], validate=True).decode('utf-8').split(':', 1)
if not re.fullmatch(r'[a-z0-9_]{3,32}', username) or not 12 <= len(password) <= 128:
denied()
except (ValueError, UnicodeError, binascii.Error):
denied()
row = self.repository.credentials(username)
try:
self.hasher.verify(row['password_hash'] if row else self._dummy, password)
except (VerificationError, InvalidHashError):
denied()
if row is None:
denied()
user = {key: value for key, value in row.items() if key != 'password_hash'}
token = secrets.token_urlsafe(32)
expires_at = self.repository.create_session(user['id'], self.digest(token), self.ttl)
return {'token': token, 'token_type': 'Bearer', 'expires_at': expires_at, 'user': user}
+53
View File
@@ -0,0 +1,53 @@
"""Use cases; independent of Flask and the concrete storage adapter."""
import re
from .domain import fields, string, uuid_value, invalid, ApiError
from .repository import Repository
from .pagination import Pagination
from .security import Authentication
class Messenger:
def __init__(self, repository: Repository, session_ttl=3600):
self.repository = repository
self.pagination = Pagination(repository.cursor_key())
self.auth = Authentication(repository, session_ttl)
def register(self, body):
fields(body, ('username', 'display_name', 'password'))
username = string(body['username'], 32)
if not re.fullmatch(r'[a-z0-9_]{3,32}', username):
invalid('Invalid username')
display_name = string(body['display_name'], 100)
password = self.auth.password(body['password'])
return self.repository.create_user(username, display_name, self.auth.hasher.hash(password))
def create_chat(self, actor, body):
fields(body, ('title', 'member_ids'))
title = string(body['title'], 100)
members = body['member_ids']
if not isinstance(members, list) or not 1 <= len(members) <= 100:
invalid('Invalid member list')
members = [uuid_value(m) for m in members]
if len(set(members)) != len(members):
invalid('Duplicate members')
return self.repository.create_chat(actor, title, members)
def chat(self, actor, chat_id):
return self.repository.chat(actor, uuid_value(chat_id))
def send(self, actor, chat_id, body):
self.chat(actor, chat_id)
fields(body, ('text',))
return self.repository.create_message(actor, uuid_value(chat_id), string(body['text'], 4000))
def chats(self, actor, limit, cursor):
scope = 'chats:' + actor
limit, after = self.pagination.decode(scope, limit, cursor)
return self.pagination.page(self.repository.chats(actor, limit + 1, after), scope, limit)
def history(self, actor, chat_id, limit, cursor):
chat_id = uuid_value(chat_id)
self.repository.chat(actor, chat_id)
scope = 'messages:' + chat_id
limit, after = self.pagination.decode(scope, limit, cursor)
return self.pagination.page(self.repository.messages(actor, chat_id, limit + 1, after), scope, limit)
+37
View File
@@ -0,0 +1,37 @@
CREATE TABLE users (
id uuid PRIMARY KEY,
username text NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'),
display_name text NOT NULL CHECK (char_length(display_name) BETWEEN 1 AND 100),
password_hash text NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
);
CREATE TABLE chats (
id uuid PRIMARY KEY,
title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100),
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
);
CREATE INDEX chats_order_idx ON chats(created_at, id);
CREATE TABLE chat_members (
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id uuid NOT NULL REFERENCES users(id),
position integer NOT NULL CHECK (position >= 0),
PRIMARY KEY(chat_id, user_id),
UNIQUE(chat_id, position)
);
CREATE INDEX chat_members_user_idx ON chat_members(user_id, chat_id);
CREATE TABLE messages (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL REFERENCES chats(id),
sender_id uuid NOT NULL REFERENCES users(id),
text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000),
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
FOREIGN KEY(chat_id, sender_id) REFERENCES chat_members(chat_id, user_id)
);
CREATE INDEX messages_history_idx ON messages(chat_id, created_at, id);
CREATE TABLE sessions (
token_hash text PRIMARY KEY CHECK (char_length(token_hash) = 64),
user_id uuid NOT NULL REFERENCES users(id),
expires_at timestamptz NOT NULL
);
CREATE INDEX sessions_expiry_idx ON sessions(expires_at);
CREATE TABLE app_settings (name text PRIMARY KEY, value text NOT NULL);
+13
View File
@@ -0,0 +1,13 @@
Flask==3.1.0
waitress==3.0.2
Werkzeug==3.1.3
Jinja2==3.1.6
MarkupSafe==3.0.3
itsdangerous==2.2.0
click==8.1.8
blinker==1.9.0
psycopg[binary]==3.2.6
argon2-cffi==23.1.0
argon2-cffi-bindings==21.2.0
cffi==1.17.1
pycparser==2.22