From f3a6f7a62ff62af4199035a88e7b11ab6e3fa495 Mon Sep 17 00:00:00 2001 From: Maksimova Snezhana Date: Thu, 1 Oct 2026 02:43:08 +0300 Subject: [PATCH] =?UTF-8?q?Alembic=20migrations=20=D0=B8=20Docker=20Compos?= =?UTF-8?q?e=20=D1=81=20postgres=20=D0=B8=20redis?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 4 +- Dockerfile | 27 +++++ alembic.ini | 114 ++++++++++++++++++ compose.yaml | 54 +++++++++ migrations/README | 1 + migrations/env.py | 99 +++++++++++++++ migrations/script.py.mako | 26 ++++ .../versions/44ea9d3b68ac_initial_schema.py | 85 +++++++++++++ student-tests/concurrent_test.py | 54 +++++---- student-tests/test_rollback.py | 61 ++++++++++ 10 files changed, 500 insertions(+), 25 deletions(-) create mode 100644 Dockerfile create mode 100644 alembic.ini create mode 100644 compose.yaml create mode 100644 migrations/README create mode 100644 migrations/env.py create mode 100644 migrations/script.py.mako create mode 100644 migrations/versions/44ea9d3b68ac_initial_schema.py create mode 100644 student-tests/test_rollback.py diff --git a/.gitignore b/.gitignore index b5a71896..9bbbd61c 100644 --- a/.gitignore +++ b/.gitignore @@ -28,5 +28,5 @@ coverage/ .DS_Store .idea/ .vscode/ -# Keep small, sanitized evidence summaries in evidence/ under version control. -# Inspect git diff --cached: ignore rules are not a secret scanner. +evidence/track1.json +evidence/track1_run.log \ No newline at end of file diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..207638eb --- /dev/null +++ b/Dockerfile @@ -0,0 +1,27 @@ +# syntax=docker/dockerfile:1.7 +FROM python:3.11.9-slim AS builder +WORKDIR /build +COPY requirements.txt . +RUN pip install --no-cache-dir --user -r requirements.txt + +FROM python:3.11.9-slim +RUN useradd -m -u 10001 appuser + +WORKDIR /app +COPY --from=builder /root/.local /home/appuser/.local +COPY app ./app +COPY migrations ./migrations +COPY alembic.ini . + +ENV PATH=/home/appuser/.local/bin:$PATH \ + PYTHONUNBUFFERED=1 \ + PYTHONDONTWRITEBYTECODE=1 + +RUN chown -R appuser:appuser /app +USER appuser +EXPOSE 8080 + +HEALTHCHECK --interval=30s --timeout=3s --start-period=20s --retries=5 \ + CMD python -c "import urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).status==200 else 1)" + +CMD ["sh", "-c", "alembic upgrade head && python -m app.main"] \ No newline at end of file diff --git a/alembic.ini b/alembic.ini new file mode 100644 index 00000000..71e7425c --- /dev/null +++ b/alembic.ini @@ -0,0 +1,114 @@ +# A generic, single database configuration. + +[alembic] +# path to migration scripts +script_location = migrations + +# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s +# Uncomment the line below if you want the files to be prepended with date and time +# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s + +# sys.path path, will be prepended to sys.path if present. +# defaults to the current working directory. +prepend_sys_path = . + +# timezone to use when rendering the date within the migration file +# as well as the filename. +# If specified, requires the python>=3.9 or backports.zoneinfo library. +# Any required deps can installed by adding `alembic[tz]` to the pip requirements +# string value is passed to ZoneInfo() +# leave blank for localtime +# timezone = + +# max length of characters to apply to the +# "slug" field +# truncate_slug_length = 40 + +# set to 'true' to run the environment during +# the 'revision' command, regardless of autogenerate +# revision_environment = false + +# set to 'true' to allow .pyc and .pyo files without +# a source .py file to be detected as revisions in the +# versions/ directory +# sourceless = false + +# version location specification; This defaults +# to migrations/versions. When using multiple version +# directories, initial revisions must be specified with --version-path. +# The path separator used here should be the separator specified by "version_path_separator" below. +# version_locations = %(here)s/bar:%(here)s/bat:migrations/versions + +# version path separator; As mentioned above, this is the character used to split +# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep. +# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas. +# Valid values for version_path_separator are: +# +# version_path_separator = : +# version_path_separator = ; +# version_path_separator = space +version_path_separator = os # Use os.pathsep. Default configuration used for new projects. + +# set to 'true' to search source files recursively +# in each "version_locations" directory +# new in Alembic version 1.10 +# recursive_version_locations = false + +# the output encoding used when revision files +# are written from script.py.mako +# output_encoding = utf-8 + +sqlalchemy.url = driver://user:pass@localhost/dbname + + +[post_write_hooks] +# post_write_hooks defines scripts or Python functions that are run +# on newly generated revision scripts. See the documentation for further +# detail and examples + +# format using "black" - use the console_scripts runner, against the "black" entrypoint +# hooks = black +# black.type = console_scripts +# black.entrypoint = black +# black.options = -l 79 REVISION_SCRIPT_FILENAME + +# lint with attempts to fix using "ruff" - use the exec runner, execute a binary +# hooks = ruff +# ruff.type = exec +# ruff.executable = %(here)s/.venv/bin/ruff +# ruff.options = --fix REVISION_SCRIPT_FILENAME + +# Logging configuration +[loggers] +keys = root,sqlalchemy,alembic + +[handlers] +keys = console + +[formatters] +keys = generic + +[logger_root] +level = WARN +handlers = console +qualname = + +[logger_sqlalchemy] +level = WARN +handlers = +qualname = sqlalchemy.engine + +[logger_alembic] +level = INFO +handlers = +qualname = alembic + +[handler_console] +class = StreamHandler +args = (sys.stderr,) +level = NOTSET +formatter = generic + +[formatter_generic] +format = %(levelname)-5.5s [%(name)s] %(message)s +datefmt = %H:%M:%S diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..514566a4 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,54 @@ +services: + postgres: + image: postgres:16.2-alpine + environment: + POSTGRES_USER: ${POSTGRES_USER} + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} + POSTGRES_DB: ${POSTGRES_DB} + volumes: + - pgdata:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"] + interval: 5s + timeout: 5s + retries: 10 + ports: + - "127.0.0.1:5432:5432" + + redis: + image: redis:7.2-alpine + command: ["redis-server", "--appendonly", "yes"] + volumes: + - redisdata:/data + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 5s + timeout: 5s + retries: 10 + ports: + - "127.0.0.1:6379:6379" + + api: + build: . + ports: + - "127.0.0.1:8080:8080" + env_file: .env + depends_on: + postgres: + condition: service_healthy + redis: + condition: service_healthy + healthcheck: + test: + - "CMD" + - "python" + - "-c" + - "import urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).status==200 else 1)" + interval: 10s + timeout: 5s + retries: 10 + start_period: 20s + +volumes: + pgdata: + redisdata: \ No newline at end of file diff --git a/migrations/README b/migrations/README new file mode 100644 index 00000000..e0d0858f --- /dev/null +++ b/migrations/README @@ -0,0 +1 @@ +Generic single-database configuration with an async dbapi. \ No newline at end of file diff --git a/migrations/env.py b/migrations/env.py new file mode 100644 index 00000000..ee06e32b --- /dev/null +++ b/migrations/env.py @@ -0,0 +1,99 @@ +import asyncio +from logging.config import fileConfig + +from sqlalchemy import pool +from sqlalchemy.engine import Connection +from sqlalchemy.ext.asyncio import async_engine_from_config + +from alembic import context +import os + +from app.db import models # noqa: F401 — регистрирует таблицы +from app.db.base import Base +# this is the Alembic Config object, which provides +# access to the values within the .ini file in use. +config = context.config + +# Interpret the config file for Python logging. +# This line sets up loggers basically. +if config.config_file_name is not None: + fileConfig(config.config_file_name) + +# add your model's MetaData object here +# for 'autogenerate' support +# from myapp import mymodel +# target_metadata = mymodel.Base.metadata +target_metadata = Base.metadata + +# other values from the config, defined by the needs of env.py, +# can be acquired: +# my_important_option = config.get_main_option("my_important_option") +# ... etc. + + +def run_migrations_offline() -> None: + """Run migrations in 'offline' mode. + + This configures the context with just a URL + and not an Engine, though an Engine is acceptable + here as well. By skipping the Engine creation + we don't even need a DBAPI to be available. + + Calls to context.execute() here emit the given string to the + script output. + + """ + url = config.get_main_option("sqlalchemy.url") + context.configure( + url=url, + target_metadata=target_metadata, + literal_binds=True, + dialect_opts={"paramstyle": "named"}, + ) + + with context.begin_transaction(): + context.run_migrations() + + +def do_run_migrations(connection: Connection) -> None: + context.configure(connection=connection, target_metadata=target_metadata) + + with context.begin_transaction(): + context.run_migrations() + + +async def run_async_migrations() -> None: + """In this scenario we need to create an Engine + and associate a connection with the context. + + """ + + config.set_main_option( + "sqlalchemy.url", + os.getenv( + "DATABASE_URL", + "postgresql+asyncpg://messenger:strongpassword@localhost:5432/messenger", + ), +) + connectable = async_engine_from_config( + config.get_section(config.config_ini_section, {}), + prefix="sqlalchemy.", + poolclass=pool.NullPool, + ) + + async with connectable.connect() as connection: + await connection.run_sync(do_run_migrations) + + await connectable.dispose() + + +def run_migrations_online() -> None: + """Run migrations in 'online' mode.""" + + asyncio.run(run_async_migrations()) + + +if context.is_offline_mode(): + run_migrations_offline() +else: + run_migrations_online() diff --git a/migrations/script.py.mako b/migrations/script.py.mako new file mode 100644 index 00000000..fbc4b07d --- /dev/null +++ b/migrations/script.py.mako @@ -0,0 +1,26 @@ +"""${message} + +Revision ID: ${up_revision} +Revises: ${down_revision | comma,n} +Create Date: ${create_date} + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa +${imports if imports else ""} + +# revision identifiers, used by Alembic. +revision: str = ${repr(up_revision)} +down_revision: Union[str, None] = ${repr(down_revision)} +branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)} +depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)} + + +def upgrade() -> None: + ${upgrades if upgrades else "pass"} + + +def downgrade() -> None: + ${downgrades if downgrades else "pass"} diff --git a/migrations/versions/44ea9d3b68ac_initial_schema.py b/migrations/versions/44ea9d3b68ac_initial_schema.py new file mode 100644 index 00000000..62b49d14 --- /dev/null +++ b/migrations/versions/44ea9d3b68ac_initial_schema.py @@ -0,0 +1,85 @@ +"""initial schema + +Revision ID: 44ea9d3b68ac +Revises: +Create Date: 2026-10-01 02:42:35.498512 + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa + + +# revision identifiers, used by Alembic. +revision: str = '44ea9d3b68ac' +down_revision: Union[str, None] = None +branch_labels: Union[str, Sequence[str], None] = None +depends_on: Union[str, Sequence[str], None] = None + + +def upgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.create_table('chats', + sa.Column('id', sa.UUID(), nullable=False), + sa.Column('title', sa.String(length=100), nullable=False), + sa.Column('created_at', sa.DateTime(timezone=True), nullable=False), + sa.PrimaryKeyConstraint('id') + ) + op.create_index('idx_chats_created_id', 'chats', ['created_at', 'id'], unique=False) + op.create_table('users', + sa.Column('id', sa.UUID(), nullable=False), + sa.Column('username', sa.String(length=32), nullable=False), + sa.Column('display_name', sa.String(length=100), nullable=False), + sa.Column('password_hash', sa.Text(), nullable=False), + sa.Column('created_at', sa.DateTime(timezone=True), nullable=False), + sa.PrimaryKeyConstraint('id') + ) + op.create_index(op.f('ix_users_username'), 'users', ['username'], unique=True) + op.create_table('chat_members', + sa.Column('chat_id', sa.UUID(), nullable=False), + sa.Column('user_id', sa.UUID(), nullable=False), + sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'), + sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'), + sa.PrimaryKeyConstraint('chat_id', 'user_id') + ) + op.create_index('idx_chat_members_user', 'chat_members', ['user_id', 'chat_id'], unique=False) + op.create_table('messages', + sa.Column('id', sa.UUID(), nullable=False), + sa.Column('chat_id', sa.UUID(), nullable=False), + sa.Column('sender_id', sa.UUID(), nullable=False), + sa.Column('text', sa.Text(), nullable=False), + sa.Column('created_at', sa.DateTime(timezone=True), nullable=False), + sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'), + sa.ForeignKeyConstraint(['sender_id'], ['users.id'], ), + sa.PrimaryKeyConstraint('id') + ) + op.create_index('idx_messages_chat_created_id', 'messages', ['chat_id', 'created_at', 'id'], unique=False) + op.create_table('sessions', + sa.Column('id', sa.UUID(), nullable=False), + sa.Column('user_id', sa.UUID(), nullable=False), + sa.Column('token_hash', sa.String(length=64), nullable=False), + sa.Column('expires_at', sa.DateTime(timezone=True), nullable=False), + sa.Column('created_at', sa.DateTime(timezone=True), nullable=False), + sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'), + sa.PrimaryKeyConstraint('id') + ) + op.create_index(op.f('ix_sessions_expires_at'), 'sessions', ['expires_at'], unique=False) + op.create_index(op.f('ix_sessions_token_hash'), 'sessions', ['token_hash'], unique=True) + # ### end Alembic commands ### + + +def downgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.drop_index(op.f('ix_sessions_token_hash'), table_name='sessions') + op.drop_index(op.f('ix_sessions_expires_at'), table_name='sessions') + op.drop_table('sessions') + op.drop_index('idx_messages_chat_created_id', table_name='messages') + op.drop_table('messages') + op.drop_index('idx_chat_members_user', table_name='chat_members') + op.drop_table('chat_members') + op.drop_index(op.f('ix_users_username'), table_name='users') + op.drop_table('users') + op.drop_index('idx_chats_created_id', table_name='chats') + op.drop_table('chats') + # ### end Alembic commands ### diff --git a/student-tests/concurrent_test.py b/student-tests/concurrent_test.py index db3bd3c2..f8e46d26 100644 --- a/student-tests/concurrent_test.py +++ b/student-tests/concurrent_test.py @@ -1,18 +1,21 @@ #!/usr/bin/env python3 -"""10 клиентов × 10 сообщений = 100 уникальных. Запуск: python tests/concurrent_test.py""" +"""10 клиентов × 10 сообщений = 100 уникальных.""" +import asyncio +import base64 import json -import urllib.error import urllib.request +import urllib.error import uuid from concurrent.futures import ThreadPoolExecutor -BASE = "http://localhost:8080" +BASE = "http://127.0.0.1:8080" +PASSWORD = "Example-only-not-a-real-secret-123" -def call(method, path, body=None, actor=None): +def call(method, path, body=None, token=None): h = {"Accept": "application/json"} - if actor: - h["X-User-Id"] = actor + if token: + h["Authorization"] = f"Bearer {token}" data = None if body is not None: data = json.dumps(body).encode("utf-8") @@ -27,29 +30,35 @@ def call(method, path, body=None, actor=None): return e.code, (json.loads(payload) if payload else None) -def create_user(name): - s, u = call("POST", "/api/v1/users", {"username": name, "display_name": name}) +def create_user_and_login(name): + s, u = call("POST", "/api/v1/users", + {"username": name, "display_name": name, "password": PASSWORD}) assert s == 201, f"create_user {name}: {s} {u}" - return u + cred = base64.b64encode(f"{name}:{PASSWORD}".encode()).decode() + req = urllib.request.Request( + BASE + "/api/v1/auth/sessions", + headers={"Authorization": f"Basic {cred}"}, + method="POST", + ) + with urllib.request.urlopen(req, timeout=30) as r: + session = json.loads(r.read()) + return u, session["token"] def main(): - users = [create_user(f"conc_{i}_{uuid.uuid4().hex[:6]}") for i in range(10)] - s, chat = call( - "POST", "/api/v1/chats", - {"title": "concurrent", "member_ids": [u["id"] for u in users]}, - actor=users[0]["id"], - ) - assert s == 201, f"chat: {s} {chat}" + users = [create_user_and_login(f"conc_{i}_{uuid.uuid4().hex[:6]}") for i in range(10)] + owner, owner_token = users[0] + chat = call("POST", "/api/v1/chats", + {"title": "concurrent", "member_ids": [u["id"] for u, _ in users]}, + token=owner_token)[1] cid = chat["id"] - def post_10(user): + def post_10(user_and_token): + _, token = user_and_token results = [] for k in range(10): - s, m = call( - "POST", f"/api/v1/chats/{cid}/messages", - {"text": f"{user['username']}-{k}"}, actor=user["id"], - ) + s, m = call("POST", f"/api/v1/chats/{cid}/messages", + {"text": f"m{k}"}, token=token) results.append((s, m)) return results @@ -66,8 +75,7 @@ def main(): path = f"/api/v1/chats/{cid}/messages?limit=100" if cursor: path += f"&cursor={cursor}" - s, page = call("GET", path, actor=users[0]["id"]) - assert s == 200 + s, page = call("GET", path, token=owner_token) for m in page["items"]: seen.add(m["id"]) cursor = page["next_cursor"] diff --git a/student-tests/test_rollback.py b/student-tests/test_rollback.py new file mode 100644 index 00000000..45d35470 --- /dev/null +++ b/student-tests/test_rollback.py @@ -0,0 +1,61 @@ +import asyncio +import base64 +import uuid + +import httpx +import pytest + +BASE = "http://127.0.0.1:8080" +PASSWORD = "Example-only-not-a-real-secret-123" + + +async def _create_user(c, name): + return await c.post( + "/api/v1/users", + json={"username": name, "display_name": name, "password": PASSWORD}, + ) + + +async def _login(c, name): + cred = base64.b64encode(f"{name}:{PASSWORD}".encode()).decode() + r = await c.post( + "/api/v1/auth/sessions", headers={"Authorization": f"Basic {cred}"} + ) + return r.json()["token"] + + +@pytest.mark.asyncio +async def test_duplicate_username_race(): + async with httpx.AsyncClient(base_url=BASE, timeout=10) as c: + name = f"dup_{uuid.uuid4().hex[:8]}" + r1, r2 = await asyncio.gather(_create_user(c, name), _create_user(c, name)) + codes = sorted([r1.status_code, r2.status_code]) + assert codes == [201, 409], codes + + +@pytest.mark.asyncio +async def test_chat_with_unknown_member_rolls_back(): + async with httpx.AsyncClient(base_url=BASE, timeout=10) as c: + name = f"cb_{uuid.uuid4().hex[:8]}" + me = (await _create_user(c, name)).json() + tok = await _login(c, name) + r = await c.post( + "/api/v1/chats", + json={"title": "x", "member_ids": [me["id"], str(uuid.uuid4())]}, + headers={"Authorization": f"Bearer {tok}"}, + ) + assert r.status_code == 404 + + +@pytest.mark.asyncio +async def test_message_to_missing_chat(): + async with httpx.AsyncClient(base_url=BASE, timeout=10) as c: + name = f"mc_{uuid.uuid4().hex[:8]}" + await _create_user(c, name) + tok = await _login(c, name) + r = await c.post( + f"/api/v1/chats/{uuid.uuid4()}/messages", + json={"text": "hi"}, + headers={"Authorization": f"Bearer {tok}"}, + ) + assert r.status_code == 404 \ No newline at end of file