From fd3eb67798a83cfa0f0b76ea2da4e3c9368cc0b4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=A1=D0=B8=D1=80=D0=B5=D0=BD=D0=BA=D0=BE=20=D0=98=D0=BB?= =?UTF-8?q?=D1=8C=D1=8F?= Date: Mon, 16 Nov 2026 21:47:32 +0000 Subject: [PATCH 1/8] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=B8=D1=82?= =?UTF-8?q?=D1=8C=20=D1=81=D1=85=D0=B5=D0=BC=D1=83=20=D0=91=D0=94,=20?= =?UTF-8?q?=D0=BC=D0=B8=D0=B3=D1=80=D0=B0=D1=86=D0=B8=D0=B8=20=D0=B8=20?= =?UTF-8?q?=D0=BF=D1=80=D0=BE=D0=B5=D0=BA=D1=82=20=D1=82=D1=80=D0=B0=D0=BD?= =?UTF-8?q?=D0=B7=D0=B0=D0=BA=D1=86=D0=B8=D0=BE=D0=BD=D0=BD=D1=8B=D1=85=20?= =?UTF-8?q?=D0=B3=D1=80=D0=B0=D0=BD=D0=B8=D1=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- infra/DATABASE.md | 19 +++++++++++++++++++ messenger/migrate.py | 24 ++++++++++++++++++++++++ migrations/001_initial.sql | 37 +++++++++++++++++++++++++++++++++++++ 3 files changed, 80 insertions(+) create mode 100644 infra/DATABASE.md create mode 100644 messenger/migrate.py create mode 100644 migrations/001_initial.sql diff --git a/infra/DATABASE.md b/infra/DATABASE.md new file mode 100644 index 00000000..154e1488 --- /dev/null +++ b/infra/DATABASE.md @@ -0,0 +1,19 @@ +# Схема и транзакционные границы + +Проект схемы составлен перед реализацией SQL-адаптера. PostgreSQL — единый источник истины, включая сессии. + +| Таблица | Ключи и ограничения | Индексы и назначение | +| --- | --- | --- | +| users | UUID PK, username UNIQUE, NOT NULL для имени/хеша/времени | UNIQUE username для регистрации и входа | +| chats | UUID PK, title NOT NULL | (created_at, id) для списка | +| chat_members | (chat_id, user_id) PK, два FK, position для порядка участников | (user_id, chat_id) для доступных чатов | +| messages | UUID PK, chat_id FK, sender_id FK, составной FK на членство | (chat_id, created_at, id) для истории | +| sessions | token_hash PK, user_id FK, expires_at NOT NULL | expiry для возможной очистки | +| app_settings | name PK, value NOT NULL | постоянный случайный ключ подписи курсоров | +| schema_migrations | version PK | только учёт применённых миграций | + +Каждый метод записи репозитория — одна транзакция с COMMIT до HTTP-ответа. Создание чата: проверить существование всех пользователей, вставить чат и всех участников, COMMIT; ошибка откатывает всё. Регистрация защищена UNIQUE, конфликт возвращает 409. Сообщение вставляется после проверки членства; FK также не позволяет записать отправителя вне чата. Создание/отзыв сессии — отдельные транзакции. Сессия проверяется на каждом защищённом запросе по времени БД; рестарт не меняет expiry. + +Миграции нумеруются в migrations/*.sql. Runner выполняет новые файлы и запись версии в одной транзакции под advisory lock. Повторный запуск не выполняет уже учтённую версию. Пароли — Argon2id; в sessions лежит SHA-256 случайного 256-битного токена, а не пароль. SHA-256 здесь служит индексом высокоэнтропийного токена и не заменяет password KDF. + +Пагинация SQL keyset, LIMIT + 1; offset не используется. Курсор сохраняет область ресурса и подписан постоянным ключом из БД, поэтому продолжение работает после рестарта. Часы PostgreSQL задают created_at. Между страницами нет snapshot; поздно закоммиченная конкурентная запись с ключом до курсора может не попасть в уже начатый обход. Для неизменной истории гарантируется отсутствие повторов и пропусков. diff --git a/messenger/migrate.py b/messenger/migrate.py new file mode 100644 index 00000000..a8774b21 --- /dev/null +++ b/messenger/migrate.py @@ -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).') diff --git a/migrations/001_initial.sql b/migrations/001_initial.sql new file mode 100644 index 00000000..ef3ace75 --- /dev/null +++ b/migrations/001_initial.sql @@ -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); -- 2.54.0 From 7eba9cc14dc215333d96a4b8067bba4019918703 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=A1=D0=B8=D1=80=D0=B5=D0=BD=D0=BA=D0=BE=20=D0=98=D0=BB?= =?UTF-8?q?=D1=8C=D1=8F?= Date: Mon, 16 Nov 2026 21:47:32 +0000 Subject: [PATCH 2/8] =?UTF-8?q?=D0=A0=D0=B5=D0=B0=D0=BB=D0=B8=D0=B7=D0=BE?= =?UTF-8?q?=D0=B2=D0=B0=D1=82=D1=8C=20PostgreSQL-=D1=81=D0=BB=D0=BE=D0=B9:?= =?UTF-8?q?=20=D1=81=D0=BE=D0=B5=D0=B4=D0=B8=D0=BD=D0=B5=D0=BD=D0=B8=D1=8F?= =?UTF-8?q?,=20=D1=80=D0=B5=D0=BF=D0=BE=D0=B7=D0=B8=D1=82=D0=BE=D1=80?= =?UTF-8?q?=D0=B8=D0=B9,=20keyset-=D0=BF=D0=B0=D0=B3=D0=B8=D0=BD=D0=B0?= =?UTF-8?q?=D1=86=D0=B8=D1=8E?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- messenger/config.py | 28 +++++++++ messenger/database.py | 20 ++++++ messenger/domain.py | 33 ++++++++++ messenger/pagination.py | 43 +++++++++++++ messenger/postgres.py | 133 ++++++++++++++++++++++++++++++++++++++++ messenger/repository.py | 17 +++++ 6 files changed, 274 insertions(+) create mode 100644 messenger/config.py create mode 100644 messenger/database.py create mode 100644 messenger/domain.py create mode 100644 messenger/pagination.py create mode 100644 messenger/postgres.py create mode 100644 messenger/repository.py diff --git a/messenger/config.py b/messenger/config.py new file mode 100644 index 00000000..177aacb4 --- /dev/null +++ b/messenger/config.py @@ -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) diff --git a/messenger/database.py b/messenger/database.py new file mode 100644 index 00000000..740dbeff --- /dev/null +++ b/messenger/database.py @@ -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 diff --git a/messenger/domain.py b/messenger/domain.py new file mode 100644 index 00000000..a67f0bea --- /dev/null +++ b/messenger/domain.py @@ -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 diff --git a/messenger/pagination.py b/messenger/pagination.py new file mode 100644 index 00000000..1744d190 --- /dev/null +++ b/messenger/pagination.py @@ -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} diff --git a/messenger/postgres.py b/messenger/postgres.py new file mode 100644 index 00000000..8175c042 --- /dev/null +++ b/messenger/postgres.py @@ -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] diff --git a/messenger/repository.py b/messenger/repository.py new file mode 100644 index 00000000..971de0e6 --- /dev/null +++ b/messenger/repository.py @@ -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): ... -- 2.54.0 From c0613925c8cc59c0e162ece5d6cb83d322d5750c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=A1=D0=B8=D1=80=D0=B5=D0=BD=D0=BA=D0=BE=20=D0=98=D0=BB?= =?UTF-8?q?=D1=8C=D1=8F?= Date: Mon, 16 Nov 2026 21:47:32 +0000 Subject: [PATCH 3/8] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=B8=D1=82?= =?UTF-8?q?=D1=8C=20=D0=B0=D1=83=D1=82=D0=B5=D0=BD=D1=82=D0=B8=D1=84=D0=B8?= =?UTF-8?q?=D0=BA=D0=B0=D1=86=D0=B8=D1=8E:=20Argon2id,=20Basic-=D0=B2?= =?UTF-8?q?=D1=85=D0=BE=D0=B4,=20Bearer-=D1=81=D0=B5=D1=81=D1=81=D0=B8?= =?UTF-8?q?=D0=B8=20=D1=81=20TTL=20=D0=B8=20=D0=BE=D1=82=D0=B7=D1=8B=D0=B2?= =?UTF-8?q?=D0=BE=D0=BC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- messenger/security.py | 60 +++++++++++++++++++++++++++++++++++++++++++ messenger/service.py | 53 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 113 insertions(+) create mode 100644 messenger/security.py create mode 100644 messenger/service.py diff --git a/messenger/security.py b/messenger/security.py new file mode 100644 index 00000000..39144eb2 --- /dev/null +++ b/messenger/security.py @@ -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} diff --git a/messenger/service.py b/messenger/service.py new file mode 100644 index 00000000..f04742aa --- /dev/null +++ b/messenger/service.py @@ -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) -- 2.54.0 From d876930498c19a87aa98b8cbab4c0f24a2112fa3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=A1=D0=B8=D1=80=D0=B5=D0=BD=D0=BA=D0=BE=20=D0=98=D0=BB?= =?UTF-8?q?=D1=8C=D1=8F?= Date: Mon, 16 Nov 2026 21:47:35 +0000 Subject: [PATCH 4/8] =?UTF-8?q?=D0=A1=D0=BE=D0=B1=D1=80=D0=B0=D1=82=D1=8C?= =?UTF-8?q?=20HTTP=20API=20=D0=BD=D0=B0=20Flask=20=D0=B8=20=D1=82=D0=BE?= =?UTF-8?q?=D1=87=D0=BA=D1=83=20=D0=B7=D0=B0=D0=BF=D1=83=D1=81=D0=BA=D0=B0?= =?UTF-8?q?=20Waitress?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Makefile | 8 +++ messenger/__init__.py | 1 + messenger/__main__.py | 15 ++++++ messenger/api.py | 115 ++++++++++++++++++++++++++++++++++++++++++ requirements.txt | 13 +++++ 5 files changed, 152 insertions(+) create mode 100644 messenger/__init__.py create mode 100644 messenger/__main__.py create mode 100644 messenger/api.py create mode 100644 requirements.txt diff --git a/Makefile b/Makefile index 9ecb223e..d1829460 100644 --- a/Makefile +++ b/Makefile @@ -24,3 +24,11 @@ load: test-persistence: @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2) $(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) + +.PHONY: run migrate student-test +run: + $(PYTHON) -m messenger +migrate: + $(PYTHON) -m messenger.migrate +student-test: + $(PYTHON) -m unittest discover -s student-tests -v diff --git a/messenger/__init__.py b/messenger/__init__.py new file mode 100644 index 00000000..bd3057eb --- /dev/null +++ b/messenger/__init__.py @@ -0,0 +1 @@ +"""Messenger lab series.""" diff --git a/messenger/__main__.py b/messenger/__main__.py new file mode 100644 index 00000000..1402c9d3 --- /dev/null +++ b/messenger/__main__.py @@ -0,0 +1,15 @@ +import logging +from waitress import serve +from .api import create_app +from .config import Settings + + +def main(): + logging.basicConfig(level=logging.INFO) + settings = Settings.from_env() + logging.info('Starting messenger environment=%s', settings.environment) + serve(create_app(settings=settings), host=settings.host, port=settings.port, threads=4) + + +if __name__ == '__main__': + main() diff --git a/messenger/api.py b/messenger/api.py new file mode 100644 index 00000000..dec18818 --- /dev/null +++ b/messenger/api.py @@ -0,0 +1,115 @@ +"""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) + + @app.before_request + def identify(): + g.request_id = str(uuid4()) + 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 + 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/') + def chat(chat_id): + return jsonify(service.chat(g.user['id'], chat_id)) + + @app.route('/api/v1/chats//messages', methods=['GET', 'POST']) + def messages(chat_id): + if request.method == 'POST': + service.chat(g.user['id'], chat_id) + return jsonify(service.send(g.user['id'], chat_id, body())), 201 + return jsonify(service.history(g.user['id'], chat_id, *paging())) + + return app diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..7faec4b2 --- /dev/null +++ b/requirements.txt @@ -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 -- 2.54.0 From d7a30a6c4a292ad41aea00caa795260786dbe5fc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=A1=D0=B8=D1=80=D0=B5=D0=BD=D0=BA=D0=BE=20=D0=98=D0=BB?= =?UTF-8?q?=D1=8C=D1=8F?= Date: Mon, 16 Nov 2026 21:47:35 +0000 Subject: [PATCH 5/8] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=B8=D1=82?= =?UTF-8?q?=D1=8C=20Dockerfile=20=D0=B8=20Compose-=D1=81=D1=82=D0=B5=D0=BD?= =?UTF-8?q?=D0=B4=20=D1=81=20secrets=20=D0=B8=20=D0=B8=D0=BC=D0=B5=D0=BD?= =?UTF-8?q?=D0=BE=D0=B2=D0=B0=D0=BD=D0=BD=D1=8B=D0=BC=20volume?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Dockerfile | 10 ++++++++++ compose.yaml | 44 +++++++++++++++++++++++++++++++++++++++++++ scripts/init_local.py | 24 +++++++++++++++++++++++ 3 files changed, 78 insertions(+) create mode 100644 Dockerfile create mode 100644 compose.yaml create mode 100644 scripts/init_local.py diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..ef503e19 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,10 @@ +FROM python:3.11.11-slim-bookworm +WORKDIR /app +ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 APP_HOST=0.0.0.0 APP_PORT=8080 APP_ENV=lab +COPY requirements.txt ./ +RUN pip install --no-cache-dir -r requirements.txt +COPY messenger ./messenger +EXPOSE 8080 +COPY migrations ./migrations +COPY scripts/start.sh ./scripts/start.sh +CMD ["sh", "scripts/start.sh"] diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..ecbc4c49 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,44 @@ +services: + db: + image: postgres:16.6-bookworm + environment: + POSTGRES_DB: messenger + POSTGRES_USER: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + secrets: + - postgres_password + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 2s + timeout: 3s + retries: 30 + api: + build: . + environment: + APP_HOST: ${APP_HOST:-0.0.0.0} + APP_PORT: ${APP_PORT:-8080} + APP_ENV: ${APP_ENV:-lab} + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + SESSION_STORE: postgres + DATABASE_URL_FILE: /run/secrets/database_url + ports: + - "127.0.0.1:8080:${APP_PORT:-8080}" + secrets: + - database_url + depends_on: + db: + condition: service_healthy + healthcheck: + test: ["CMD", "python", "-c", "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:'+os.getenv('APP_PORT','8080')+'/health/ready',timeout=3)"] + interval: 3s + timeout: 5s + retries: 20 +volumes: + postgres_data: +secrets: + postgres_password: + file: ./secrets/postgres_password + database_url: + file: ./secrets/database_url diff --git a/scripts/init_local.py b/scripts/init_local.py new file mode 100644 index 00000000..e03dfc7e --- /dev/null +++ b/scripts/init_local.py @@ -0,0 +1,24 @@ +"""Create local secrets once. Never overwrite existing credentials.""" +from pathlib import Path +import secrets +import shutil + +root = Path(__file__).resolve().parents[1] +directory = root / 'secrets' +directory.mkdir(mode=0o700, exist_ok=True) +password_file = directory / 'postgres_password' +url_file = directory / 'database_url' +if password_file.exists() != url_file.exists(): + raise SystemExit('Incomplete secrets: restore the missing file; do not regenerate credentials for an existing volume.') +if not password_file.exists(): + password = secrets.token_hex(32) + for path, value in [(password_file, password), + (url_file, 'postgresql://messenger:' + password + '@db:5432/messenger')]: + with path.open('x', encoding='utf-8') as f: + f.write(value + '\n') + # Compose mounts secret files individually; PostgreSQL runs as a distinct UID. + # The enclosing host directory is 0700, while this mounted file must be readable. + path.chmod(0o644 if path == password_file else 0o600) +if not (root / '.env').exists(): + shutil.copyfile(root / '.env.example', root / '.env') +print('Local configuration ready; existing credentials preserved.') -- 2.54.0 From 39197c218f24842317fb3d22963ebcf4fe359a01 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=A1=D0=B8=D1=80=D0=B5=D0=BD=D0=BA=D0=BE=20=D0=98=D0=BB?= =?UTF-8?q?=D1=8C=D1=8F?= Date: Mon, 16 Nov 2026 21:47:35 +0000 Subject: [PATCH 6/8] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=B8=D1=82?= =?UTF-8?q?=D1=8C=20=D1=81=D0=BE=D0=B1=D1=81=D1=82=D0=B2=D0=B5=D0=BD=D0=BD?= =?UTF-8?q?=D1=8B=D0=B5=20=D0=B8=D0=BD=D1=82=D0=B5=D0=B3=D1=80=D0=B0=D1=86?= =?UTF-8?q?=D0=B8=D0=BE=D0=BD=D0=BD=D1=8B=D0=B5=20=D1=82=D0=B5=D1=81=D1=82?= =?UTF-8?q?=D1=8B=20=D0=B8=20CI-=D0=BF=D1=80=D0=BE=D0=B2=D0=B5=D1=80=D0=BA?= =?UTF-8?q?=D1=83?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .github/workflows/application.yml | 28 +++++++ scripts/start.sh | 4 + student-tests/test_api.py | 123 ++++++++++++++++++++++++++++++ 3 files changed, 155 insertions(+) create mode 100644 .github/workflows/application.yml create mode 100644 scripts/start.sh create mode 100644 student-tests/test_api.py diff --git a/.github/workflows/application.yml b/.github/workflows/application.yml new file mode 100644 index 00000000..40962420 --- /dev/null +++ b/.github/workflows/application.yml @@ -0,0 +1,28 @@ +name: Application +on: [push, pull_request] +permissions: + contents: read +jobs: + postgres-compose: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.11' + - run: python scripts/init_local.py + - run: docker compose config --quiet + - run: docker compose up -d --build --wait --wait-timeout 120 + - run: make check test + - run: docker compose exec -T api python -m messenger.migrate + - run: | + docker compose cp student-tests api:/app/student-tests + docker compose exec -T api python -m unittest discover -s student-tests -v + - run: chmod +x scripts/restart.sh && make test-persistence ACTION_SCRIPT=scripts/restart.sh + - uses: actions/upload-artifact@v4 + if: always() + with: + name: restart-evidence + path: evidence/restart-*.txt + - if: always() + run: docker compose down diff --git a/scripts/start.sh b/scripts/start.sh new file mode 100644 index 00000000..6d9e6f43 --- /dev/null +++ b/scripts/start.sh @@ -0,0 +1,4 @@ +#!/bin/sh +set -eu +python -m messenger.migrate +exec python -m messenger diff --git a/student-tests/test_api.py b/student-tests/test_api.py new file mode 100644 index 00000000..8bcae7d1 --- /dev/null +++ b/student-tests/test_api.py @@ -0,0 +1,123 @@ +"""Integration tests. DATABASE_URL[_FILE] must point to a disposable PostgreSQL DB.""" +import base64 +import time +import unittest +from dataclasses import replace +from uuid import uuid4 +from messenger.api import create_app +from messenger.config import Settings +from messenger.database import Database +from messenger.migrate import migrate + + +class ApiTests(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.settings = Settings.from_env() + cls.db = Database(cls.settings.database_url) + migrate(cls.db) + cls.app = create_app(settings=cls.settings) + + def setUp(self): + self.c = self.app.test_client() + self.password = 'Учебный:пароль-12345' + self.name = 'u_' + uuid4().hex[:16] + self.registration = {'username': self.name, 'display_name': 'Имя 👋', 'password': self.password} + r = self.c.post('/api/v1/users', json=self.registration) + self.assertEqual(r.status_code, 201) + self.user = r.json + self.basic = {'Authorization': 'Basic ' + base64.b64encode((self.name + ':' + self.password).encode()).decode()} + r = self.c.post('/api/v1/auth/sessions', headers=self.basic) + self.assertEqual(r.status_code, 201) + self.session = r.json + self.headers = {'Authorization': 'Bearer ' + self.session['token']} + self.chat = self.c.post('/api/v1/chats', headers=self.headers, json={ + 'title': 'Учебный чат', 'member_ids': [self.user['id']]}).json + self.path = '/api/v1/chats/' + self.chat['id'] + '/messages' + + def error(self, response, status): + self.assertEqual(response.status_code, status) + self.assertEqual(response.json['error']['request_id'], response.headers['X-Request-Id']) + + def test_authentication_and_logout(self): + for headers in [{}, self.basic, {'X-User-Id': self.user['id']}, {'Authorization': 'Bearer bad'}]: + r = self.c.get('/api/v1/users/me', headers=headers) + self.error(r, 401) + self.assertEqual(r.headers['WWW-Authenticate'], 'Bearer realm="messenger"') + for auth in ['Basic bad', 'Bearer bad', 'Basic ' + base64.b64encode((self.name + ':wrong-password').encode()).decode()]: + r = self.c.post('/api/v1/auth/sessions', headers={'Authorization': auth}) + self.error(r, 401) + self.assertEqual(r.headers['WWW-Authenticate'], 'Basic realm="messenger", charset="UTF-8"') + r = self.c.get('/api/v1/users/me', headers=dict(self.headers, **{'X-User-Id': str(uuid4())})) + self.assertEqual(r.json, self.user) + self.error(self.c.post('/api/v1/auth/sessions', headers=self.basic, json={}), 400) + r = self.c.delete('/api/v1/auth/sessions/current', headers=self.headers) + self.assertEqual((r.status_code, r.data), (204, b'')) + self.error(self.c.get('/api/v1/users/me', headers=self.headers), 401) + self.error(self.c.delete('/api/v1/auth/sessions/current', headers=self.headers), 401) + + def test_expiry_and_restart_app(self): + short = create_app(settings=replace(self.settings, session_ttl=2)).test_client() + r = short.post('/api/v1/auth/sessions', headers=self.basic) + self.assertEqual(r.status_code, 201) + headers = {'Authorization': 'Bearer ' + r.json['token']} + self.assertEqual(short.get('/api/v1/users/me', headers=headers).status_code, 200) + # New app instance must respect the stored original expiry, not renew it. + restarted = create_app(settings=replace(self.settings, session_ttl=3600)).test_client() + self.assertEqual(restarted.get('/api/v1/users/me', headers=headers).status_code, 200) + time.sleep(2.1) + self.error(restarted.get('/api/v1/users/me', headers=headers), 401) + + def test_strict_validation_and_private_chat(self): + self.error(self.c.post('/api/v1/users', data='{', content_type='application/json'), 400) + self.error(self.c.post('/api/v1/users', json=self.registration), 409) + for patch in [{'password': 'short'}, {'password': 42}, {'display_name': ' '}, {'extra': 1}]: + self.error(self.c.post('/api/v1/users', json=dict(self.registration, **patch)), 400) + self.error(self.c.post(self.path, headers=self.headers, json={'text': ' \n'}), 400) + self.error(self.c.post(self.path, headers=self.headers, json={'text': 'x', 'sender_id': self.user['id']}), 400) + self.error(self.c.get('/api/v1/chats/' + str(uuid4()), headers=self.headers), 404) + outsider = 'u_' + uuid4().hex[:16] + self.c.post('/api/v1/users', json=dict(self.registration, username=outsider)) + basic = {'Authorization': 'Basic ' + base64.b64encode((outsider + ':' + self.password).encode()).decode()} + token = self.c.post('/api/v1/auth/sessions', headers=basic).json['token'] + self.error(self.c.get(self.path, headers={'Authorization': 'Bearer ' + token}), 404) + + def test_pagination_survives_new_app(self): + expected = [self.c.post(self.path, headers=self.headers, json={'text': str(i)}).json for i in range(5)] + first = self.c.get(self.path + '?limit=2', headers=self.headers).json + cursor = first['next_cursor'] + new_client = create_app(settings=self.settings).test_client() + second = new_client.get(self.path, query_string={'limit': 1, 'cursor': cursor}, headers=self.headers).json + third = new_client.get(self.path, query_string={'limit': 100, 'cursor': second['next_cursor']}, headers=self.headers).json + self.assertEqual(first['items'] + second['items'] + third['items'], expected) + self.assertIsNone(third['next_cursor']) + self.error(self.c.get('/api/v1/chats', query_string={'cursor': cursor}, headers=self.headers), 400) + other = self.c.post('/api/v1/chats', headers=self.headers, json={'title': 'Other', 'member_ids': [self.user['id']]}).json + self.error(self.c.get('/api/v1/chats/' + other['id'] + '/messages', query_string={'cursor': cursor}, headers=self.headers), 400) + for limit in ['0', '101', '1.5', 'true']: + self.error(self.c.get(self.path, query_string={'limit': limit}, headers=self.headers), 400) + self.error(self.c.get(self.path, query_string={'cursor': 'invalid'}, headers=self.headers), 400) + page = self.c.get('/api/v1/chats?limit=1', headers=self.headers).json + last = self.c.get('/api/v1/chats', query_string={'cursor': page['next_cursor']}, headers=self.headers).json + self.assertEqual(len(page['items'] + last['items']), 2) + + def test_atomic_chat_and_migration_repeat(self): + with self.db.transaction() as conn: + before = conn.execute('SELECT count(*) AS n FROM chats').fetchone()['n'] + for members in [[self.user['id'], str(uuid4())], [self.user['id'], self.user['id']], []]: + self.error(self.c.post('/api/v1/chats', headers=self.headers, + json={'title': 'Invalid', 'member_ids': members}), 400) + migrate(self.db) + migrate(self.db) + with self.db.transaction() as conn: + self.assertEqual(conn.execute('SELECT count(*) AS n FROM chats').fetchone()['n'], before) + self.assertEqual(conn.execute('SELECT count(*) AS n FROM schema_migrations').fetchone()['n'], 1) + row = conn.execute('SELECT password_hash FROM users WHERE id=%s', (self.user['id'],)).fetchone() + self.assertTrue(row['password_hash'].startswith('$argon2id$')) + hashes = [r['token_hash'] for r in conn.execute('SELECT token_hash FROM sessions WHERE user_id=%s', (self.user['id'],))] + self.assertNotIn(self.session['token'], hashes) + self.assertEqual(self.c.get('/api/v1/users/me', headers=self.headers).json, self.user) + + +if __name__ == '__main__': + unittest.main() -- 2.54.0 From 87d279bfb5a6368ee5038116f3114f3168a2571a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=A1=D0=B8=D1=80=D0=B5=D0=BD=D0=BA=D0=BE=20=D0=98=D0=BB?= =?UTF-8?q?=D1=8C=D1=8F?= Date: Mon, 16 Nov 2026 21:47:40 +0000 Subject: [PATCH 7/8] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=B8=D1=82?= =?UTF-8?q?=D1=8C=20restart-hook=20=D0=B8=20=D0=B4=D0=BE=D0=BA=D0=B0=D0=B7?= =?UTF-8?q?=D0=B0=D1=82=D0=B5=D0=BB=D1=8C=D1=81=D1=82=D0=B2=D0=B0=20=D0=BB?= =?UTF-8?q?=D0=BE=D0=BA=D0=B0=D0=BB=D1=8C=D0=BD=D1=8B=D1=85=20=D0=BF=D1=80?= =?UTF-8?q?=D0=BE=D0=B2=D0=B5=D1=80=D0=BE=D0=BA?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- evidence/local-checks.txt | 34 +++++++++ evidence/local-restart.txt | 4 ++ evidence/restart-after.txt | 2 + evidence/restart-before.txt | 2 + scripts/check_local.py | 138 ++++++++++++++++++++++++++++++++++++ scripts/restart.sh | 24 +++++++ 6 files changed, 204 insertions(+) create mode 100644 evidence/local-checks.txt create mode 100644 evidence/local-restart.txt create mode 100644 evidence/restart-after.txt create mode 100644 evidence/restart-before.txt create mode 100644 scripts/check_local.py create mode 100755 scripts/restart.sh diff --git a/evidence/local-checks.txt b/evidence/local-checks.txt new file mode 100644 index 00000000..9d0ef1fd --- /dev/null +++ b/evidence/local-checks.txt @@ -0,0 +1,34 @@ +$ /workspace/scratch/a9cc7b7e4e4a/.venv/bin/python -m messenger.migrate +Migrations applied successfully (already applied versions skipped). +$ /workspace/scratch/a9cc7b7e4e4a/.venv/bin/python -m messenger.migrate +Migrations applied successfully (already applied versions skipped). +$ make check validate student-test PYTHON=/workspace/scratch/a9cc7b7e4e4a/.venv/bin/python +/workspace/scratch/a9cc7b7e4e4a/.venv/bin/python scripts/check_contract.py +PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. +/workspace/scratch/a9cc7b7e4e4a/.venv/bin/python scripts/validate_openapi.py +PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested. +/workspace/scratch/a9cc7b7e4e4a/.venv/bin/python -m unittest discover -s student-tests -v +test_atomic_chat_and_migration_repeat (test_api.ApiTests.test_atomic_chat_and_migration_repeat) ... ok +test_authentication_and_logout (test_api.ApiTests.test_authentication_and_logout) ... ok +test_expiry_and_restart_app (test_api.ApiTests.test_expiry_and_restart_app) ... ok +test_pagination_survives_new_app (test_api.ApiTests.test_pagination_survives_new_app) ... ok +test_strict_validation_and_private_chat (test_api.ApiTests.test_strict_validation_and_private_chat) ... ok + +---------------------------------------------------------------------- +Ran 5 tests in 4.193s + +OK +$ make test BASE_URL=http://127.0.0.1:18080 PYTHON=/workspace/scratch/a9cc7b7e4e4a/.venv/bin/python +/workspace/scratch/a9cc7b7e4e4a/.venv/bin/python tests/smoke.py --base-url "http://127.0.0.1:18080" +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. +$ make test-persistence ACTION_SCRIPT=/tmp/messenger-lab2-3_7rknxw/restart.sh BASE_URL=http://127.0.0.1:18080 PYTHON=/workspace/scratch/a9cc7b7e4e4a/.venv/bin/python +/workspace/scratch/a9cc7b7e4e4a/.venv/bin/python tests/resilience.py --mode persistence --action-script "/tmp/messenger-lab2-3_7rknxw/restart.sh" --base-url "http://127.0.0.1:18080" +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. +Real local PostgreSQL restart (not Docker) +API PID: 34 -> 1056 +PostgreSQL start: 2026-11-15T21:29:56.296193+00:00 -> 2026-11-15T21:30:04.106927+00:00 +Same data directory; no initdb/migrations/reseed in restart hook. + +Verified database: PostgreSQL 16.2 on x86_64-pc-linux-gnu, compiled by gcc (GCC) 10.2.1 20210130 (Red Hat 10.2.1-11), 64-bit +PASS: DB outage gives ready=503, live=200 diff --git a/evidence/local-restart.txt b/evidence/local-restart.txt new file mode 100644 index 00000000..e64aa3ac --- /dev/null +++ b/evidence/local-restart.txt @@ -0,0 +1,4 @@ +Real local PostgreSQL restart (not Docker) +API PID: 34 -> 1056 +PostgreSQL start: 2026-11-15T21:29:56.296193+00:00 -> 2026-11-15T21:30:04.106927+00:00 +Same data directory; no initdb/migrations/reseed in restart hook. diff --git a/evidence/restart-after.txt b/evidence/restart-after.txt new file mode 100644 index 00000000..8c504230 --- /dev/null +++ b/evidence/restart-after.txt @@ -0,0 +1,2 @@ +/mtusi2026lab2-db-1 2026-11-15T21:36:49.02822853Z running +/mtusi2026lab2-api-1 2026-11-15T21:36:51.309065877Z running diff --git a/evidence/restart-before.txt b/evidence/restart-before.txt new file mode 100644 index 00000000..23113d80 --- /dev/null +++ b/evidence/restart-before.txt @@ -0,0 +1,2 @@ +/mtusi2026lab2-db-1 2026-11-15T21:35:53.794161714Z running +/mtusi2026lab2-api-1 2026-11-15T21:35:56.415432352Z running diff --git a/scripts/check_local.py b/scripts/check_local.py new file mode 100644 index 00000000..8cee4af0 --- /dev/null +++ b/scripts/check_local.py @@ -0,0 +1,138 @@ +"""Optional Linux/macOS verification with real local PostgreSQL binaries. + +Usage: python scripts/check_local.py --pg-bin /path/to/postgresql/bin +Creates a private temporary cluster; never touches an existing database. +The normal delivery/deployment path remains Docker Compose. +""" +import argparse +import json +import os +from pathlib import Path +import shlex +import signal +import subprocess +import sys +import tempfile +import time +from urllib.request import urlopen + +ROOT = Path(__file__).resolve().parents[1] + + +def pg(state, *args): + return subprocess.run([str(Path(state['bin']) / 'pg_ctl'), '-D', state['data'], *args], + check=True, stdout=subprocess.DEVNULL) + + +def start_api(state, env): + with open(Path(state['data']).parent / 'api.log', 'a') as log: + process = subprocess.Popen([sys.executable, '-m', 'messenger'], cwd=ROOT, + env=env, stdout=log, stderr=log, start_new_session=True) + state['api_pid'] = process.pid + return process + + +def ready(): + for _ in range(100): + try: + with urlopen('http://127.0.0.1:18080/health/ready', timeout=1) as r: + if r.status == 200: + return + except OSError: + time.sleep(0.1) + raise RuntimeError('Local API did not become ready') + + +def restart(state_path): + import psycopg + state = json.loads(state_path.read_text()) + with psycopg.connect(os.environ['DATABASE_URL']) as conn: + before = conn.execute('SELECT pg_postmaster_start_time()').fetchone()[0] + old_pid = state['api_pid'] + os.kill(old_pid, signal.SIGTERM) + pg(state, '-m', 'fast', '-w', 'stop') + pg(state, '-l', str(state_path.parent / 'postgres.log'), '-w', 'start') + start_api(state, dict(os.environ)) + state_path.write_text(json.dumps(state)) + ready() + with psycopg.connect(os.environ['DATABASE_URL']) as conn: + after = conn.execute('SELECT pg_postmaster_start_time()').fetchone()[0] + assert before != after and old_pid != state['api_pid'] + (ROOT / 'evidence/local-restart.txt').write_text( + 'Real local PostgreSQL restart (not Docker)\n' + 'API PID: %s -> %s\nPostgreSQL start: %s -> %s\n' + 'Same data directory; no initdb/migrations/reseed in restart hook.\n' % + (old_pid, state['api_pid'], before.isoformat(), after.isoformat())) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--pg-bin') + parser.add_argument('--restart', type=Path) + args = parser.parse_args() + if args.restart: + restart(args.restart) + return + if not args.pg_bin: + parser.error('--pg-bin is required') + binary = Path(args.pg_bin).resolve() + with tempfile.TemporaryDirectory(prefix='messenger-lab2-') as tmp: + temp = Path(tmp) + state_path = temp / 'state.json' + state = {'bin': str(binary), 'data': str(temp / 'data')} + env = dict(os.environ, DATABASE_URL='postgresql://127.0.0.1:15432/postgres', + APP_PORT='18080', APP_HOST='127.0.0.1', SESSION_TTL_SECONDS='3600') + env.pop('DATABASE_URL_FILE', None) + env['SESSION_STORE'] = 'postgres' + subprocess.run([str(binary / 'initdb'), '-D', state['data'], '-A', 'trust', + '--no-locale', '-E', 'UTF8'], check=True, stdout=subprocess.DEVNULL) + with (Path(state['data']) / 'postgresql.conf').open('a') as f: + f.write("\nport=15432\nlisten_addresses='127.0.0.1'\nunix_socket_directories=''\ntimezone='UTC'\n") + initial_process = None + try: + pg(state, '-l', str(temp / 'postgres.log'), '-w', 'start') + def run(command): + print('$ ' + ' '.join(command), flush=True) + subprocess.run(command, env=env, cwd=ROOT, check=True) + run([sys.executable, '-m', 'messenger.migrate']) + run([sys.executable, '-m', 'messenger.migrate']) + initial_process = start_api(state, env) + state_path.write_text(json.dumps(state)) + ready() + run(['make', 'check', 'validate', 'student-test', 'PYTHON=' + sys.executable]) + run(['make', 'test', 'BASE_URL=http://127.0.0.1:18080', 'PYTHON=' + sys.executable]) + hook = temp / 'restart.sh' + hook.write_text('#!/bin/sh\nexec ' + shlex.join([sys.executable, str(Path(__file__).resolve()), + '--restart', str(state_path)]) + '\n') + hook.chmod(0o700) + run(['make', 'test-persistence', 'ACTION_SCRIPT=' + str(hook), + 'BASE_URL=http://127.0.0.1:18080', 'PYTHON=' + sys.executable]) + print((ROOT / 'evidence/local-restart.txt').read_text(), flush=True) + import psycopg + with psycopg.connect(env['DATABASE_URL']) as conn: + print('Verified database: ' + conn.execute('SELECT version()').fetchone()[0], flush=True) + # A real dependency outage must not leave the application ready. + pg(state, '-m', 'fast', '-w', 'stop') + from urllib.error import HTTPError + try: + urlopen('http://127.0.0.1:18080/health/ready', timeout=8) + raise AssertionError('Readiness must fail without PostgreSQL') + except HTTPError as error: + assert error.code == 503 + assert urlopen('http://127.0.0.1:18080/health/live').status == 200 + print('PASS: DB outage gives ready=503, live=200', flush=True) + finally: + if state_path.exists(): + current = json.loads(state_path.read_text()) + try: + os.kill(current['api_pid'], signal.SIGTERM) + except ProcessLookupError: + pass + if initial_process is not None: + initial_process.wait(timeout=10) + subprocess.run([str(binary / 'pg_ctl'), '-D', state['data'], '-m', 'fast', '-w', 'stop'], + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + + +if __name__ == '__main__': + main() diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..3fcc47f5 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,24 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +# Stop API first; restart the only store, keeping its named volume. +mkdir -p evidence +snapshot() { + for service in db api; do + id=$(docker compose ps -q "$service") + docker inspect --format '{{.Name}} {{.State.StartedAt}} {{.State.Status}}' "$id" + done +} +snapshot > evidence/restart-before.txt +docker compose stop -t 10 api +docker compose restart -t 10 db +# Wait for DB before the API applies idempotent migrations. +i=0 +until docker compose exec -T db pg_isready -U messenger -d messenger >/dev/null 2>&1; do + i=$((i + 1)) + [ "$i" -lt 30 ] || exit 1 + sleep 1 +done +docker compose start api +snapshot > evidence/restart-after.txt +# Public resilience.py waits for readiness and tests the OLD token. -- 2.54.0 From 9e81517ea02605a594450893b3e3e2d893990c23 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=A1=D0=B8=D1=80=D0=B5=D0=BD=D0=BA=D0=BE=20=D0=98=D0=BB?= =?UTF-8?q?=D1=8C=D1=8F?= Date: Mon, 16 Nov 2026 21:47:40 +0000 Subject: [PATCH 8/8] =?UTF-8?q?=D0=97=D0=B0=D0=BF=D0=BE=D0=BB=D0=BD=D0=B8?= =?UTF-8?q?=D1=82=D1=8C=20=D0=BE=D1=82=D1=87=D1=91=D1=82=20=D0=BB=D0=B0?= =?UTF-8?q?=D0=B1=D0=BE=D1=80=D0=B0=D1=82=D0=BE=D1=80=D0=BD=D0=BE=D0=B9=20?= =?UTF-8?q?=D1=80=D0=B0=D0=B1=D0=BE=D1=82=D1=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- REPORT.md | 170 ++++++++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 147 insertions(+), 23 deletions(-) diff --git a/REPORT.md b/REPORT.md index e42f2b05..05bd5c88 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,161 @@ -# Отчёт — лабораторная 2 +# Отчёт — лабораторная работа №2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор: **Сиренко Илья**. +- Группа: **БПИ2304**. +- Целевая оценка: **3**. Redis/Valkey и треки уровней 4–5 не заявлены. +- Commit / PR: заполнить после публикации в своём fork. +- Стек сохранён из lab1: Python 3.9+, Flask 3.1.0, Waitress 3.0.2. Добавлены PostgreSQL, psycopg 3.2.6 и argon2-cffi 23.1.0. -## Запуск из чистого clone +## Запуск из чистого clone / ZIP -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Нужны Docker Engine / Docker Desktop с Compose v2 (поддержкой `up --wait`), Python 3.9+ и доступ к Docker Hub/PyPI для первой сборки. Все команды выполняются в корне `mtusi2026lab2`. Для Linux/macOS или Windows WSL: -## Архитектура и решения +```sh +python3 scripts/init_local.py +docker compose config --quiet +docker compose up -d --build --wait --wait-timeout 120 +curl --fail http://localhost:8080/health/ready +make check +make test +chmod +x scripts/restart.sh +make test-persistence ACTION_SCRIPT=scripts/restart.sh +``` -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +`init_local.py` создаёт `.env` из шаблона и случайные credentials в `secrets/`. Повторный запуск сохраняет имеющиеся файлы. Не удалять secrets при сохранённом volume: PostgreSQL не меняет пароль существующего пользователя от замены POSTGRES_PASSWORD_FILE. При неполном комплекте secrets скрипт останавливается, не перезаписывая оставшийся файл. -## Доказательства критериев +Если нет make, публичные тесты запускаются непосредственно Python: -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | +```sh +python3 scripts/check_contract.py +python3 tests/smoke.py --base-url http://localhost:8080 +python3 tests/resilience.py --mode persistence \ + --action-script scripts/restart.sh --base-url http://localhost:8080 +``` + +Hook написан для POSIX shell. В Windows выполняйте persistence-сценарий через WSL с доступным Docker; `python3` можно заменить на `python`, если так называется установленный интерпретатор. + +Первый старт API применяет миграции и затем делает `exec python -m messenger`; HTTP-сервер — основной процесс контейнера. БД должна быть healthy до старта API. Файлы `001_initial.sql` и учёт применённых версий находятся в проекте/БД соответственно. Без повторного выполнения DDL можно перезапускать контейнер сколько угодно. + +```sh +# Явно повторить миграции (данные не дублируются): +docker compose exec -T api python -m messenger.migrate +# Остановить стенд; данные сохраняются: +docker compose down +# Снова поднять на том же volume: +docker compose up -d --wait --wait-timeout 120 +# Пересобрать после изменений: +docker compose up -d --build --wait --wait-timeout 120 +# Только для НАМЕРЕННОГО удаления всех учебных данных: +docker compose down -v +``` + +В последнем случае следующий запуск создаст пустую БД, прежние пользователи и токены исчезнут. `.env`, secrets и файлы БД исключены из Git и ZIP. При проблеме запуска проверить `docker compose ps` и логи сервисов; не публиковать вывод конфигурации с вручную добавленными секретами. + +### Собственные тесты в контейнере + +Тесты создают синтетические данные, используйте учебный стенд. + +```sh +docker compose cp student-tests api:/app/student-tests +docker compose exec -T api python -m unittest discover -s student-tests -v +``` + +Полная валидация OpenAPI на host: + +```sh +python3 -m venv .venv +.venv/bin/python -m pip install -r requirements-dev.txt +make validate PYTHON=.venv/bin/python +``` + +### Конфигурация и инфраструктура + +| Роль | Сервис / версия | Readiness | Постоянные данные | Сеть и credentials | +| --- | --- | --- | --- | --- | +| API | api; python:3.11.11-slim-bookworm; Flask/Waitress | /health/ready проверяет доступность таблиц БД | Нет локальных данных | Host 127.0.0.1:8080; DATABASE_URL_FILE — Compose secret | +| БД и сессии | db; postgres:16.6-bookworm | pg_isready | Именованный postgres_data, /var/lib/postgresql/data | Только внутренняя сеть Compose, порт БД на host не опубликован; POSTGRES_PASSWORD_FILE | + +| Переменная | Реальное назначение | +| --- | --- | +| APP_HOST | Адрес bind API; по умолчанию 0.0.0.0 внутри контейнера | +| APP_PORT | Внутренний порт API, по умолчанию 8080; host-порт Compose остаётся 8080 | +| APP_ENV | Метка окружения стартового лога; debug не включает | +| SESSION_TTL_SECONDS | Срок новой сессии, по умолчанию 3600; для smoke/persistence оставить не менее 300 | +| DATABASE_URL_FILE | Файл строки подключения; Compose фиксирует /run/secrets/database_url | +| DATABASE_URL | Альтернатива для локального запуска без Docker; файл имеет приоритет | +| SESSION_STORE | Только postgres; иное значение отклоняется при старте | +| CACHE_URL_FILE | Сохранён из шаблона задания, на уровне 3 не используется | + +Папка secrets создаётся с правами 0700. Файл пароля PostgreSQL имеет 0644, чтобы отдельный UID postgres мог прочитать индивидуально смонтированный Compose secret; на host доступ к нему закрывает родительская папка. Файл URL имеет 0600 и читается API. Для этой учебной Compose-конфигурации API работает от пользователя базового образа, не заявляется hardening уровня 4/7. + +## Архитектура и перенос из первой работы + +Путь запроса: клиент → Waitress → Flask HTTP-адаптер → Messenger / Authentication → Repository → PostgreSQL. Flask, Waitress, фабрика приложения, разделение HTTP / сценариев / хранилища сохранены. Контракт и публичные tests взяты именно из второй работы, без замены файлами lab1. Первая работа не изменялась. + +| Компонент | Что изменилось относительно lab1 | +| --- | --- | +| domain.py | Сохранены общие проверки полей, строк, UUID и ошибки; NUL отклоняется как 400, поскольку PostgreSQL text его не хранит | +| api.py | Те же маршруты пользователей, чатов и истории; добавлены login/logout и WWW-Authenticate; X-User-Id больше не выбирает пользователя | +| service.py | Сохранены сценарии и валидация; регистрация теперь включает пароль, пагинация получает ограниченную выборку SQL | +| repository.py | Сохранена роль интерфейса Repository; порт расширен для credentials и сессий | +| postgres.py / database.py | MemoryRepository заменён SQL-адаптером с транзакциями и параметризованными запросами | +| security.py | Argon2id, разбор Basic, проверка Bearer, генерация токена | +| pagination.py | Сохранён формат подписанного keyset-курсора; ключ постоянен в БД, страницы выбираются через SQL LIMIT+1 | +| config.py / migrate.py | Загрузка конфигурации и versioned migration runner | + +Схема, ключи, индексы и транзакционные границы описаны **до SQL-реализации** в [infra/DATABASE.md](infra/DATABASE.md). Данные пользователей, чатов, участников, сообщений и сессий живут в PostgreSQL. Память процесса не является источником истины. SQLite, Redis и внешние готовые серверы решения не используются. + +Каждая запись завершается COMMIT до успешного HTTP-ответа. Создание чата и всех его участников атомарно. Ошибки приводят к rollback. Уникальность username обеспечивает UNIQUE, повтор даёт 409. Поля id — UUID; FK связывают пользователей, чаты, членство, отправителей сообщений. Индекс истории `(chat_id, created_at, id)` соответствует SQL keyset-пагинации. Соединение открывается на операцию и закрывается по её завершении; пул не добавлен для уровня 3. Таймаут подключения — 3 секунды, statement_timeout — 5 секунд, lock_timeout — 3 секунды. + +Курсор связан с конкретным чатом или списком чатов пользователя. Ключ подписи генерируется один раз миграцией и сохраняется в app_settings. Он не меняется при рестарте API/БД. Обычный обход неизменной истории не пропускает и не повторяет записи. Время назначает PostgreSQL (clock_timestamp), сортировка — `(created_at, id)`. Между HTTP-страницами snapshot отсутствует: конкурентная запись, закоммиченная позже, с ключом до уже выданного курсора может не войти в текущий обход. Подтверждённая запись видна следующему новому чтению; кэша нет. + +### Аутентификация + +- POST `/api/v1/users` публичен и принимает username, display_name, password (12–128 Unicode code points). +- POST `/api/v1/auth/sessions` принимает Basic без тела. Пароль может содержать двоеточие и Unicode: деление выполняется только по первому `:`. +- Пароль хранится как Argon2id: память 65536 KiB, time_cost=3, parallelism=2, случайная соль. Поле password_hash никогда не входит в User. +- Успешный вход создаёт случайный opaque-токен из 32 случайных байт (256 бит). В БД сохраняется SHA-256 токена и expires_at. Быстрый SHA-256 используется для высокоэнтропийного токена, а не как хеш пароля. +- Остальные бизнес-endpoint требуют Bearer. X-User-Id игнорируется; Basic на бизнес-endpoint — 401. +- Expiry назначается временем БД один раз; проверяется при каждом запросе и не продлевается перезапуском или чтением. Истёкшая сессия остаётся строкой БД, но никогда не даёт доступ. +- Logout удаляет сессию; повторный запрос с прежним токеном получает 401. 401 содержит нужный WWW-Authenticate. Посторонний участник получает 404 для чужого чата. + +Сессию проверяем в начале запроса. Уже начатая операция может завершиться одновременно с logout; отмена выполняющихся запросов не заявлена. HTTP/Basic допустимы только на локальном изолированном учебном стенде. Для удалённого доступа нужен TLS. + +## Доказательства и фактические проверки + +Дата: 16.11.2026, Москва. Среда проверки: Linux x86_64, Python 3.12.14, настоящий PostgreSQL 16.2 (локальные бинарники из pgserver 0.1.4, **не SQLite и не mock**). Версии приложения — requirements.txt. Это функциональные проверки без исследования производительности, искусственные CPU/RAM-лимиты и прогрев не задавались. + +Docker CLI/daemon в среде подготовки отсутствует. Поэтому **сборка образов, Compose-стенд PostgreSQL 16.6 и scripts/restart.sh здесь не запускались**. Вместо этого публичный persistence-тест прошёл с отдельным локальным hook, который действительно перезапустил API и PostgreSQL 16.2 с тем же каталогом данных. Это проверка поведения приложения и БД, но не свидетельство испытания Docker. Для окончательного подтверждения контейнерного запуска выполнить команды первого раздела. + +| Критерий / проверка | Команда / методика | Наблюдаемый результат | Доказательство | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| Структура и контракт | make check / make validate | PASS | evidence/local-checks.txt | +| Минимум API lab2 | make test BASE_URL=http://127.0.0.1:18080 | Публичный smoke PASS | evidence/local-checks.txt | +| Пользователи, чаты, сообщения, действующие сессии после рестарта | make test-persistence с локальным реальным hook | Прежний токен, пользователь и сообщение сохранились | evidence/local-checks.txt | +| Рестарт обоих процессов, тот же каталог БД | scripts/check_local.py | Изменились PID API и pg_postmaster_start_time; данные не пересоздавались | evidence/local-restart.txt | +| Миграции с нуля и повторный запуск | migrate выполнен дважды при старте и повторно в own tests | Одна запись версии, без дублей/потери данных | evidence/local-checks.txt | +| Basic/Bearer, logout, X-User-Id | test_authentication_and_logout | OK | student-tests/test_api.py; evidence/local-checks.txt | +| TTL=2, неизменность expiry после нового экземпляра API | test_expiry_and_restart_app | Сначала 200, через expiry — 401 | evidence/local-checks.txt | +| Ошибки, неизвестные поля и чужой чат | test_strict_validation_and_private_chat | OK | evidence/local-checks.txt | +| Курсоры, размер страницы и продолжение после нового экземпляра API | test_pagination_survives_new_app | Порядок сохранён, чужой курсор — 400 | evidence/local-checks.txt | +| Атомарность отказа создания чата, хранение KDF и token digest | test_atomic_chat_and_migration_repeat | Число чатов не изменилось; Argon2id и digest в БД | evidence/local-checks.txt | +| Потеря БД | Настоящая остановка PostgreSQL | ready=503, live=200 | evidence/local-checks.txt | +| Compose и контейнерный hook | scripts/restart.sh / application.yml | Подготовлены; в этой среде не выполнены | compose.yaml; .github/workflows/application.yml | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +Логи содержат путь временного окружения проверки и номер порта 18080; эти значения не нужно копировать для стандартного Compose-запуска на 8080. В логах нет токенов и credentials. -## Эксперименты и отказы +### Повтор проверки без Docker -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +При наличии локальных `initdb`, `pg_ctl`, `postgres`: -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +```sh +python3 -m venv .venv +.venv/bin/python -m pip install -r requirements.txt -r requirements-dev.txt +.venv/bin/python scripts/check_local.py --pg-bin /путь/к/postgresql/bin +``` -## Ограничения и следующие шаги +Скрипт работает без root на Linux/macOS, создаёт временный изолированный кластер на 127.0.0.1:15432 и API на 127.0.0.1:18080, применяет миграции, запускает проверки и убирает свой временный кластер. Порты должны быть свободны. Временно применяется trust-аутентификация только этого localhost-кластера; существующие БД не затрагиваются. В проекте pgserver не является runtime-зависимостью; для сдачи используется обычный PostgreSQL Compose. -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +### Контейнерный restart hook + +`scripts/restart.sh` сохраняет только имена/время старта/статус контейнеров в `evidence/restart-before.txt` и `evidence/restart-after.txt`. Затем останавливает API, перезапускает db, ждёт готовности PostgreSQL и запускает API. Не удаляет volume, не вызывает initdb, не создаёт тестовые данные. API повторяет versioned migrations без повторного применения версии. Публичный тест ожидает готовности и проверяет прежний токен. После распаковки ZIP выполнить `chmod +x scripts/restart.sh`, если архиватор не сохранил права. \ No newline at end of file -- 2.54.0