diff --git a/.dockerignore b/.dockerignore index bc16e556..4a37b658 100644 --- a/.dockerignore +++ b/.dockerignore @@ -18,3 +18,7 @@ __pycache__ node_modules evidence .DS_Store +**/bin/ +**/obj/ +**/*.user +.vs/ diff --git a/.env.example b/.env.example index d32b9be0..761ec297 100644 --- a/.env.example +++ b/.env.example @@ -11,3 +11,5 @@ SESSION_STORE=postgres CACHE_URL_FILE=/run/secrets/cache_url API_REPLICAS=2 IDEMPOTENCY_TTL_SECONDS=86400 +# Local compose only. Put the real value in .env, never in git. +POSTGRES_PASSWORD=replace-with-a-local-password diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..81a8dae0 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,25 @@ +# syntax=docker/dockerfile:1 + +FROM mcr.microsoft.com/dotnet/sdk:10.0.401 AS build +WORKDIR /src +COPY src/Messenger/Messenger.csproj ./Messenger/ +RUN dotnet restore ./Messenger/Messenger.csproj +COPY src/Messenger/ ./Messenger/ +RUN dotnet publish ./Messenger/Messenger.csproj -c Release -o /out --no-restore /p:UseAppHost=false + +FROM mcr.microsoft.com/dotnet/aspnet:10.0.12 +RUN apt-get update \ + && apt-get install -y --no-install-recommends curl \ + && rm -rf /var/lib/apt/lists/* +WORKDIR /app +COPY --from=build /out . +USER $APP_UID +ENV APP_HOST=0.0.0.0 \ + APP_PORT=8080 \ + APP_ENV=lab \ + ASPNETCORE_ENVIRONMENT=Production \ + DOTNET_EnableDiagnostics=0 +EXPOSE 8080 +HEALTHCHECK --interval=5s --timeout=3s --start-period=15s --retries=10 \ + CMD curl --fail --silent http://127.0.0.1:8080/health/ready || exit 1 +ENTRYPOINT ["dotnet", "Messenger.dll"] diff --git a/REPORT.md b/REPORT.md index c2679005..9da90a96 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,61 @@ # Отчёт — лабораторная 3 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO +- Автор, группа: Лобашов Валентин, БПИ2303 +- Целевая оценка; выбранный трек 5, если нужен: 3 - Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Использованные источники, библиотеки и помощь ИИ: ASP.NET Core, Npgsql 9.0.4, Konscious.Security.Cryptography.Argon2 1.3.1, PostgreSQL 16.11, HAProxy 2.8.14, контракт репозитория. Реализацию и черновик отчёта подготовил ассистент Cursor. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Нужны Docker Desktop и интернет для первой сборки. Образы: `mcr.microsoft.com/dotnet/sdk:10.0.401`, `mcr.microsoft.com/dotnet/aspnet:10.0.12`, `postgres:16.11`, `haproxy:2.8.14`. + +```sh +copy .env.example .env +``` + +В `.env` замените `POSTGRES_PASSWORD` на локальный пароль. Файл не коммитится. Затем: + +```sh +docker compose --env-file .env up -d --build +``` + +Поднимаются PostgreSQL, две реплики API и HAProxy. Снаружи открыт только `127.0.0.1:8080` на балансировщике. Порты реплик наружу не публикуются. Миграция применяется при старте каждой реплики под advisory lock, повторный запуск данные не дублирует. Готовность: `GET http://127.0.0.1:8080/health/ready`. + +```sh +python tests/smoke.py --base-url http://127.0.0.1:8080 +``` + +Перезапуск без удаления volume: `sh scripts/restart.sh`. Остановка одной реплики: `TARGET_INSTANCE_ID=<значение X-Instance-Id> sh scripts/stop-one.sh`. Вернуть её: `docker compose --env-file .env start api`. Удаление учебных данных: `docker compose --env-file .env down -v`. + +На Windows `.sh` напрямую не запускается. Те же действия: `docker compose --env-file .env restart postgres api lb` и остановка контейнера, чей `X-Instance-Id` совпал. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Из lab2 перенесены PostgreSQL, Argon2id, Basic только для входа и Bearer для остальных запросов. Сессии общие в PostgreSQL, локальной памяти для них нет. + +Клиент ходит только на HAProxy. Две реплики `api` отвечают по очереди. У каждой свой `X-Instance-Id` на всё время процесса; заголовок есть у каждого ответа API. HAProxy проверяет `/health/ready` раз в секунду и убирает реплику после одной неудачи. Таймаут к реплике 2 секунды, затем запрос уходит на другую. + +`Idempotency-Key` обязателен только для `POST` сообщения. Ключ уникален в пределах пользователя, метода и пути чата. Тот же текст в течение `IDEMPOTENCY_TTL_SECONDS` (по умолчанию 86400) возвращает то же сообщение. Другой текст с тем же ключом даёт 409. Запись сообщения и ключа — одна транзакция, поэтому неуспешный запрос ключ не занимает. + +`SESSION_STORE=postgres`. `DATABASE_URL` задаёт строку Npgsql внутри compose. `DATABASE_URL_FILE` читается, если переменной нет. `API_REPLICAS` по умолчанию 2. ## Доказательства критериев | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| Публичный smoke через LB | `python tests/smoke.py --base-url http://127.0.0.1:8080` | PASS | evidence/smoke.txt | +| Две реплики, одна сессия | 40 запросов `/users/me` | 2 разных `X-Instance-Id` | evidence/failover.txt | +| Остановка одной реплики | `scripts/stop-one.sh` по `TARGET_INSTANCE_ID` | скрипт вернул 0, следующие чтения идут на другую реплику, сообщение на месте | evidence/failover.txt | +| Свои тесты lab2 | `dotnet test src/Messenger.slnx` | 3 пройдено | evidence/dotnet-test.txt | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +Проверялось 2026-11-13, Docker Desktop, compose-проект `3`. ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. - | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| `docker stop` одной реплики API | вторая продолжает читать и писать, подтверждённое сообщение остаётся | 5 успешных чтений другой реплики, сообщение на месте | в пределах 10 с; сообщение не потеряно | ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Оценка 3 не включает лимиты CPU/RAM, rolling update и замер RPS по каждой реплике. База одна: падение PostgreSQL останавливает обе реплики. HAProxy тоже один. Это не отказ узла, а отказ процесса одной реплики. diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..7d3d41ca --- /dev/null +++ b/compose.yaml @@ -0,0 +1,50 @@ +services: + postgres: + image: postgres:16.11 + environment: + POSTGRES_USER: messenger + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} + POSTGRES_DB: messenger + volumes: + - pgdata:/var/lib/postgresql/data + ports: + - "127.0.0.1:5432:5432" + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 2s + timeout: 3s + retries: 20 + + api: + build: . + environment: + APP_HOST: 0.0.0.0 + APP_PORT: "8080" + APP_ENV: ${APP_ENV:-lab} + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400} + DATABASE_URL: Host=postgres;Port=5432;Username=messenger;Password=${POSTGRES_PASSWORD};Database=messenger;Timeout=5;Command Timeout=5 + deploy: + replicas: ${API_REPLICAS:-2} + depends_on: + postgres: + condition: service_healthy + healthcheck: + test: ["CMD", "curl", "--fail", "--silent", "http://127.0.0.1:8080/health/ready"] + interval: 2s + timeout: 3s + retries: 10 + start_period: 20s + + lb: + image: haproxy:2.8.14 + volumes: + - ./infra/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro + ports: + - "127.0.0.1:8080:80" + depends_on: + api: + condition: service_healthy + +volumes: + pgdata: diff --git a/evidence/dotnet-test.txt b/evidence/dotnet-test.txt new file mode 100644 index 00000000..e85d9b9d --- /dev/null +++ b/evidence/dotnet-test.txt @@ -0,0 +1 @@ +Пройден: не пройдено 0, пройдено 3, пропущено 0, всего 3. diff --git a/evidence/failover.txt b/evidence/failover.txt new file mode 100644 index 00000000..25d4f668 --- /dev/null +++ b/evidence/failover.txt @@ -0,0 +1,4 @@ +instances=2 +stop_code=0 +reads_after_stop=5 +PASS balance_and_failover diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 00000000..fc20f9dd --- /dev/null +++ b/evidence/smoke.txt @@ -0,0 +1 @@ +PASS: lab3 public API scenario; infrastructure and grading evidence remain separate. diff --git a/global.json b/global.json new file mode 100644 index 00000000..163a6e14 --- /dev/null +++ b/global.json @@ -0,0 +1,6 @@ +{ + "sdk": { + "version": "10.0.401", + "rollForward": "latestFeature" + } +} diff --git a/infra/haproxy.cfg b/infra/haproxy.cfg new file mode 100644 index 00000000..85cb7c6c --- /dev/null +++ b/infra/haproxy.cfg @@ -0,0 +1,30 @@ +global + maxconn 200 + +defaults + mode http + timeout connect 1s + timeout client 10s + timeout server 2s + option httplog + option redispatch + retries 2 + +resolvers docker + nameserver dns 127.0.0.11:53 + resolve_retries 3 + timeout resolve 1s + timeout retry 1s + hold valid 1s + +frontend http + bind *:80 + default_backend api + +backend api + balance roundrobin + option httpchk + http-check send meth GET uri /health/ready ver HTTP/1.1 hdr host localhost + http-check expect status 200 + default-server inter 1s fall 1 rise 1 + server-template api 4 api:8080 check resolvers docker init-addr none resolve-prefer ipv4 diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..c7e09c8d --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,4 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +docker compose --env-file .env restart postgres api lb diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100755 index 00000000..25d0fbc1 --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,15 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +: "${TARGET_INSTANCE_ID:?}" +found=0 +for id in $(docker compose --env-file .env ps -q api); do + docker exec "$id" curl -fsS -o /dev/null -D /tmp/live-headers.txt http://127.0.0.1:8080/health/live || true + got=$(docker exec "$id" grep -i "^x-instance-id:" /tmp/live-headers.txt | awk "{print \$2}" | tr -d "\r") + if [ "$got" = "$TARGET_INSTANCE_ID" ]; then + docker stop -t 5 "$id" + found=1 + break + fi +done +test "$found" -eq 1 diff --git a/src/Messenger.Tests/ApiTests.cs b/src/Messenger.Tests/ApiTests.cs new file mode 100644 index 00000000..fd126c3b --- /dev/null +++ b/src/Messenger.Tests/ApiTests.cs @@ -0,0 +1,167 @@ +using System.Net; +using Messenger; +using System.Net.Http.Headers; +using System.Runtime.CompilerServices; +using System.Text; +using System.Text.Json; +using Microsoft.AspNetCore.Mvc.Testing; +using Xunit; + +namespace Messenger.Tests; + +internal static class TestSetup +{ + [ModuleInitializer] + internal static void Init() + { + Environment.SetEnvironmentVariable("MESSENGER_TESTING", "1"); + if (string.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable("DATABASE_URL"))) + throw new InvalidOperationException("Для тестов задайте DATABASE_URL."); + } +} + +public sealed class MessengerFactory : WebApplicationFactory +{ +} + +public sealed class ApiTests : IClassFixture +{ + private readonly HttpClient _client; + + public ApiTests(MessengerFactory factory) => _client = factory.CreateClient(); + + [Fact] + public async Task Wrong_password_basic_on_api_and_user_id_are_401() + { + var (id, username, password, token) = await Register(); + var bad = Convert.ToBase64String(Encoding.UTF8.GetBytes(username + ":wrong-password-xx")); + var login = await Send(HttpMethod.Post, "/api/v1/auth/sessions", headers: new Dictionary + { + ["Authorization"] = "Basic " + bad + }); + await Error(login, HttpStatusCode.Unauthorized, "unauthorized"); + Assert.StartsWith("Basic", login.Headers.WwwAuthenticate.ToString(), StringComparison.OrdinalIgnoreCase); + + var basicOnApi = await Send(HttpMethod.Get, "/api/v1/users/me", headers: new Dictionary + { + ["Authorization"] = "Basic " + Convert.ToBase64String(Encoding.UTF8.GetBytes(username + ":" + password)) + }); + await Error(basicOnApi, HttpStatusCode.Unauthorized, "unauthorized"); + Assert.StartsWith("Bearer", basicOnApi.Headers.WwwAuthenticate.ToString(), StringComparison.OrdinalIgnoreCase); + + var onlyUser = await Send(HttpMethod.Get, "/api/v1/users/me", headers: new Dictionary + { + ["X-User-Id"] = id + }); + await Error(onlyUser, HttpStatusCode.Unauthorized, "unauthorized"); + + var me = await Json(await Send(HttpMethod.Get, "/api/v1/users/me", token: token, headers: new Dictionary + { + ["X-User-Id"] = Guid.NewGuid().ToString("D") + })); + Assert.Equal(id, me.GetProperty("id").GetString()); + } + + [Fact] + public async Task Logout_revokes_the_current_token() + { + var (_, _, _, token) = await Register(); + var gone = await Send(HttpMethod.Delete, "/api/v1/auth/sessions/current", token: token); + Assert.Equal(HttpStatusCode.NoContent, gone.StatusCode); + Assert.Equal("", await gone.Content.ReadAsStringAsync()); + var again = await Send(HttpMethod.Get, "/api/v1/users/me", token: token); + await Error(again, HttpStatusCode.Unauthorized, "unauthorized"); + } + + [Fact] + public async Task Duplicate_username_is_409_and_empty_message_is_400() + { + var (id, username, password, _) = await Register(); + var again = await Post("/api/v1/users", JsonSerializer.Serialize(new + { + username, + display_name = "Ещё", + password + })); + await Error(again, HttpStatusCode.Conflict, "conflict"); + + var (_, token) = await Login(username, password); + var chat = await Json(await Post("/api/v1/chats", JsonSerializer.Serialize(new + { + title = "Пусто", + member_ids = new[] { id } + }), token), HttpStatusCode.Created); + var empty = await Send( + HttpMethod.Post, + $"/api/v1/chats/{chat.GetProperty("id").GetString()}/messages", + """{"text":" "}""", + token, + new Dictionary { ["Idempotency-Key"] = Guid.NewGuid().ToString("N") }); + await Error(empty, HttpStatusCode.BadRequest, "invalid_request"); + } + + private async Task<(string Id, string Username, string Password, string Token)> Register() + { + var username = "u_" + Guid.NewGuid().ToString("N")[..12]; + var password = "T3st-" + Guid.NewGuid().ToString("N"); + var created = await Json(await Post("/api/v1/users", JsonSerializer.Serialize(new + { + username, + display_name = "Студент", + password + })), HttpStatusCode.Created); + var (id, token) = (created.GetProperty("id").GetString()!, (await Login(username, password)).Token); + return (id, username, password, token); + } + + private async Task<(string Id, string Token)> Login(string username, string password) + { + var basic = Convert.ToBase64String(Encoding.UTF8.GetBytes(username + ":" + password)); + var session = await Json(await Send(HttpMethod.Post, "/api/v1/auth/sessions", headers: new Dictionary + { + ["Authorization"] = "Basic " + basic + }), HttpStatusCode.Created); + return (session.GetProperty("user").GetProperty("id").GetString()!, session.GetProperty("token").GetString()!); + } + + private Task Post(string path, string json, string? token = null) => + Send(HttpMethod.Post, path, json, token); + + private async Task Send( + HttpMethod method, + string path, + string? json = null, + string? token = null, + Dictionary? headers = null) + { + var request = new HttpRequestMessage(method, path); + if (json is not null) + request.Content = new StringContent(json, Encoding.UTF8, "application/json"); + if (token is not null) + request.Headers.TryAddWithoutValidation("Authorization", "Bearer " + token); + if (headers is not null) + { + foreach (var pair in headers) + request.Headers.TryAddWithoutValidation(pair.Key, pair.Value); + } + + return await _client.SendAsync(request); + } + + private static async Task Json(HttpResponseMessage response, HttpStatusCode expected = HttpStatusCode.OK) + { + var body = await response.Content.ReadAsStringAsync(); + Assert.Equal(expected, response.StatusCode); + Assert.True(response.Headers.TryGetValues("X-Request-Id", out var ids) && ids.Single().Length > 0); + Assert.Equal("application/json", MediaTypeHeaderValue.Parse(response.Content.Headers.ContentType!.ToString()).MediaType); + using var document = JsonDocument.Parse(body); + return document.RootElement.Clone(); + } + + private static async Task Error(HttpResponseMessage response, HttpStatusCode status, string code) + { + var document = await Json(response, status); + Assert.Equal(code, document.GetProperty("error").GetProperty("code").GetString()); + Assert.Equal(response.Headers.GetValues("X-Request-Id").Single(), document.GetProperty("error").GetProperty("request_id").GetString()); + } +} diff --git a/src/Messenger.Tests/Messenger.Tests.csproj b/src/Messenger.Tests/Messenger.Tests.csproj new file mode 100644 index 00000000..9d00fd65 --- /dev/null +++ b/src/Messenger.Tests/Messenger.Tests.csproj @@ -0,0 +1,19 @@ + + + net10.0 + enable + enable + false + true + + + + + + + + + + + + diff --git a/src/Messenger.slnx b/src/Messenger.slnx new file mode 100644 index 00000000..ab20da6a --- /dev/null +++ b/src/Messenger.slnx @@ -0,0 +1,4 @@ + + + + diff --git a/src/Messenger/Db.cs b/src/Messenger/Db.cs new file mode 100644 index 00000000..0e375fa6 --- /dev/null +++ b/src/Messenger/Db.cs @@ -0,0 +1,581 @@ +using System.Security.Cryptography; +using System.Text; +using Npgsql; +using NpgsqlTypes; + +namespace Messenger; + +public sealed class Db : IAsyncDisposable +{ + private readonly NpgsqlDataSource _dataSource; + private readonly TimeSpan _sessionTtl; + private readonly TimeSpan _idempotencyTtl; + + public Db(string connectionString, TimeSpan sessionTtl, TimeSpan idempotencyTtl) + { + var builder = new NpgsqlDataSourceBuilder(connectionString); + builder.ConnectionStringBuilder.MaxPoolSize = 20; + builder.ConnectionStringBuilder.Timeout = 5; + builder.ConnectionStringBuilder.CommandTimeout = 5; + _dataSource = builder.Build(); + _sessionTtl = sessionTtl; + _idempotencyTtl = idempotencyTtl; + } + + public async Task Ping(CancellationToken cancellationToken = default) + { + try + { + await using var connection = await _dataSource.OpenConnectionAsync(cancellationToken); + await using var command = new NpgsqlCommand("SELECT 1", connection); + await command.ExecuteScalarAsync(cancellationToken); + return true; + } + catch (NpgsqlException) + { + return false; + } + } + + public async Task Migrate(CancellationToken cancellationToken = default) + { + var path = Path.Combine(AppContext.BaseDirectory, "Migrations", "001_init.sql"); + var sql = await File.ReadAllTextAsync(path, cancellationToken); + await using var connection = await _dataSource.OpenConnectionAsync(cancellationToken); + await using var lockCommand = new NpgsqlCommand("SELECT pg_advisory_lock(7202602)", connection); + await lockCommand.ExecuteNonQueryAsync(cancellationToken); + try + { + await using (var ensure = new NpgsqlCommand( + """ + CREATE TABLE IF NOT EXISTS schema_migrations ( + version text PRIMARY KEY, + applied_at timestamptz NOT NULL + ) + """, + connection)) + { + await ensure.ExecuteNonQueryAsync(cancellationToken); + } + + await using var check = new NpgsqlCommand("SELECT 1 FROM schema_migrations WHERE version = '001'", connection); + var applied = await check.ExecuteScalarAsync(cancellationToken); + if (applied is not null) + return; + + await using var tx = await connection.BeginTransactionAsync(cancellationToken); + foreach (var statement in Split(sql)) + { + if (statement.Contains("CREATE TABLE schema_migrations", StringComparison.Ordinal)) + continue; + await using var command = new NpgsqlCommand(statement, connection, tx); + await command.ExecuteNonQueryAsync(cancellationToken); + } + + await using (var mark = new NpgsqlCommand( + "INSERT INTO schema_migrations (version, applied_at) VALUES ('001', now())", + connection, + tx)) + { + await mark.ExecuteNonQueryAsync(cancellationToken); + } + + await tx.CommitAsync(cancellationToken); + } + finally + { + await using var unlock = new NpgsqlCommand("SELECT pg_advisory_unlock(7202602)", connection); + await unlock.ExecuteNonQueryAsync(CancellationToken.None); + } + } + + public async Task AddUser(string username, string displayName, string password, CancellationToken cancellationToken = default) + { + var user = new UserRecord(Guid.NewGuid(), username, displayName, Clock.Truncate(DateTime.UtcNow), Passwords.Hash(password)); + const string sql = """ + INSERT INTO users (id, username, display_name, password_hash, created_at) + VALUES ($1, $2, $3, $4, $5) + """; + try + { + await using var connection = await _dataSource.OpenConnectionAsync(cancellationToken); + await using var command = new NpgsqlCommand(sql, connection); + BindUser(command, user); + await command.ExecuteNonQueryAsync(cancellationToken); + return user with { PasswordHash = null }; + } + catch (PostgresException ex) when (ex.SqlState == PostgresErrorCodes.UniqueViolation) + { + return null; + } + } + + public async Task FindUser(Guid id, CancellationToken cancellationToken = default) + { + const string sql = """ + SELECT id, username, display_name, created_at + FROM users + WHERE id = $1 + """; + await using var connection = await _dataSource.OpenConnectionAsync(cancellationToken); + await using var command = new NpgsqlCommand(sql, connection); + command.Parameters.AddWithValue(id); + await using var reader = await command.ExecuteReaderAsync(cancellationToken); + if (!await reader.ReadAsync(cancellationToken)) + return null; + return ReadUser(reader); + } + + public async Task FindLogin(string username, CancellationToken cancellationToken = default) + { + const string sql = """ + SELECT id, username, display_name, created_at, password_hash + FROM users + WHERE username = $1 + """; + await using var connection = await _dataSource.OpenConnectionAsync(cancellationToken); + await using var command = new NpgsqlCommand(sql, connection); + command.Parameters.AddWithValue(username); + await using var reader = await command.ExecuteReaderAsync(cancellationToken); + if (!await reader.ReadAsync(cancellationToken)) + return null; + return ReadUser(reader) with { PasswordHash = reader.GetString(4) }; + } + + public async Task<(string Token, DateTime ExpiresAt)> CreateSession(Guid userId, CancellationToken cancellationToken = default) + { + var token = Convert.ToBase64String(RandomNumberGenerator.GetBytes(32)) + .TrimEnd('=') + .Replace('+', '-') + .Replace('/', '_'); + var expires = Clock.Truncate(DateTime.UtcNow.Add(_sessionTtl)); + const string sql = """ + INSERT INTO sessions (token_hash, user_id, expires_at) + VALUES ($1, $2, $3) + """; + await using var connection = await _dataSource.OpenConnectionAsync(cancellationToken); + await using var command = new NpgsqlCommand(sql, connection); + command.Parameters.AddWithValue(TokenHash(token)); + command.Parameters.AddWithValue(userId); + command.Parameters.AddWithValue(expires); + await command.ExecuteNonQueryAsync(cancellationToken); + return (token, expires); + } + + public async Task FindSessionUser(string token, CancellationToken cancellationToken = default) + { + const string sql = """ + SELECT u.id, u.username, u.display_name, u.created_at + FROM sessions s + JOIN users u ON u.id = s.user_id + WHERE s.token_hash = $1 + AND s.revoked_at IS NULL + AND s.expires_at > now() + """; + await using var connection = await _dataSource.OpenConnectionAsync(cancellationToken); + await using var command = new NpgsqlCommand(sql, connection); + command.Parameters.AddWithValue(TokenHash(token)); + await using var reader = await command.ExecuteReaderAsync(cancellationToken); + if (!await reader.ReadAsync(cancellationToken)) + return null; + return ReadUser(reader); + } + + public async Task RevokeSession(string token, CancellationToken cancellationToken = default) + { + const string sql = """ + UPDATE sessions + SET revoked_at = now() + WHERE token_hash = $1 + AND revoked_at IS NULL + AND expires_at > now() + """; + await using var connection = await _dataSource.OpenConnectionAsync(cancellationToken); + await using var command = new NpgsqlCommand(sql, connection); + command.Parameters.AddWithValue(TokenHash(token)); + return await command.ExecuteNonQueryAsync(cancellationToken) == 1; + } + + public async Task<(ChatRecord? Chat, string? Error)> AddChat(Guid callerId, string title, IReadOnlyList memberIds, CancellationToken cancellationToken = default) + { + await using var connection = await _dataSource.OpenConnectionAsync(cancellationToken); + await using var tx = await connection.BeginTransactionAsync(cancellationToken); + var seen = new HashSet(); + foreach (var memberId in memberIds) + { + if (!seen.Add(memberId)) + { + await tx.RollbackAsync(cancellationToken); + return (null, "В списке участников есть дубликаты"); + } + + await using var exists = new NpgsqlCommand("SELECT 1 FROM users WHERE id = $1", connection, tx); + exists.Parameters.AddWithValue(memberId); + if (await exists.ExecuteScalarAsync(cancellationToken) is null) + { + await tx.RollbackAsync(cancellationToken); + return (null, "В списке есть неизвестный участник"); + } + } + + if (!seen.Contains(callerId)) + { + await tx.RollbackAsync(cancellationToken); + return (null, "Создатель чата должен входить в member_ids"); + } + + var chat = new ChatRecord(Guid.NewGuid(), title, memberIds.ToArray(), Clock.Truncate(DateTime.UtcNow)); + await using (var insert = new NpgsqlCommand( + "INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)", + connection, + tx)) + { + insert.Parameters.AddWithValue(chat.Id); + insert.Parameters.AddWithValue(chat.Title); + insert.Parameters.AddWithValue(chat.CreatedAt); + await insert.ExecuteNonQueryAsync(cancellationToken); + } + + for (var i = 0; i < chat.MemberIds.Length; i++) + { + await using var member = new NpgsqlCommand( + "INSERT INTO chat_members (chat_id, user_id, position) VALUES ($1, $2, $3)", + connection, + tx); + member.Parameters.AddWithValue(chat.Id); + member.Parameters.AddWithValue(chat.MemberIds[i]); + member.Parameters.AddWithValue(i); + await member.ExecuteNonQueryAsync(cancellationToken); + } + + await tx.CommitAsync(cancellationToken); + return (chat, null); + } + + public async Task FindChat(Guid chatId, Guid userId, CancellationToken cancellationToken = default) + { + const string sql = """ + SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members m ON m.chat_id = c.id + WHERE c.id = $1 AND m.user_id = $2 + """; + await using var connection = await _dataSource.OpenConnectionAsync(cancellationToken); + await using var command = new NpgsqlCommand(sql, connection); + command.Parameters.AddWithValue(chatId); + command.Parameters.AddWithValue(userId); + await using var reader = await command.ExecuteReaderAsync(cancellationToken); + if (!await reader.ReadAsync(cancellationToken)) + return null; + var id = reader.GetGuid(0); + var title = reader.GetString(1); + var created = Utc(reader, 2); + await reader.DisposeAsync(); + var members = await Members(connection, id, cancellationToken); + return new ChatRecord(id, title, members, created); + } + + public async Task<(IReadOnlyList Items, string? NextCursor)> ListChats( + Guid userId, + int limit, + DateTime? afterTime, + Guid? afterId, + CancellationToken cancellationToken = default) + { + const string sql = """ + SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members mine ON mine.chat_id = c.id AND mine.user_id = $1 + WHERE $2::timestamptz IS NULL + OR (c.created_at, c.id::text) > ($2::timestamptz, $3) + ORDER BY c.created_at, c.id::text + LIMIT $4 + """; + await using var connection = await _dataSource.OpenConnectionAsync(cancellationToken); + await using var command = new NpgsqlCommand(sql, connection); + command.Parameters.AddWithValue(userId); + command.Parameters.Add(new NpgsqlParameter { NpgsqlDbType = NpgsqlDbType.TimestampTz, Value = afterTime.HasValue ? afterTime.Value : DBNull.Value }); + command.Parameters.AddWithValue(afterId?.ToString("D") ?? ""); + command.Parameters.AddWithValue(limit + 1); + var rows = new List(); + await using (var reader = await command.ExecuteReaderAsync(cancellationToken)) + { + while (await reader.ReadAsync(cancellationToken)) + rows.Add(new ChatRecord(reader.GetGuid(0), reader.GetString(1), [], Utc(reader, 2))); + } + + string? next = null; + if (rows.Count > limit) + { + rows.RemoveAt(rows.Count - 1); + var last = rows[^1]; + next = CursorCodec.Encode("c", userId, last.CreatedAt, last.Id); + } + + var result = new List(rows.Count); + foreach (var row in rows) + result.Add(row with { MemberIds = await Members(connection, row.Id, cancellationToken) }); + return (result, next); + } + + public async Task<(MessageRecord? Message, bool Conflict)> SendMessage( + Guid chatId, + Guid senderId, + string text, + string idempotencyKey, + string path, + CancellationToken cancellationToken = default) + { + var hash = SHA256.HashData(Encoding.UTF8.GetBytes(text)); + try + { + return await InsertMessage(chatId, senderId, text, idempotencyKey, path, hash, cancellationToken); + } + catch (PostgresException ex) when (ex.SqlState == PostgresErrorCodes.UniqueViolation) + { + return await ReadExisting(senderId, path, idempotencyKey, hash, cancellationToken); + } + } + + private async Task<(MessageRecord? Message, bool Conflict)> InsertMessage( + Guid chatId, + Guid senderId, + string text, + string idempotencyKey, + string path, + byte[] hash, + CancellationToken cancellationToken) + { + await using var connection = await _dataSource.OpenConnectionAsync(cancellationToken); + await using var tx = await connection.BeginTransactionAsync(cancellationToken); + var existing = await FindIdempotency(connection, tx, senderId, path, idempotencyKey, hash, cancellationToken); + if (existing is not null) + { + await tx.CommitAsync(cancellationToken); + return existing.Value; + } + + var message = new MessageRecord(Guid.NewGuid(), chatId, senderId, text, Clock.Truncate(DateTime.UtcNow)); + await using (var insert = new NpgsqlCommand( + """ + INSERT INTO messages (id, chat_id, sender_id, body, created_at) + SELECT $1, $2, $3, $4, $5 + WHERE EXISTS ( + SELECT 1 FROM chat_members WHERE chat_id = $2 AND user_id = $3 + ) + RETURNING id + """, + connection, + tx)) + { + insert.Parameters.AddWithValue(message.Id); + insert.Parameters.AddWithValue(message.ChatId); + insert.Parameters.AddWithValue(message.SenderId); + insert.Parameters.AddWithValue(message.Text); + insert.Parameters.AddWithValue(message.CreatedAt); + if (await insert.ExecuteScalarAsync(cancellationToken) is null) + { + await tx.RollbackAsync(cancellationToken); + return (null, false); + } + } + + await using (var key = new NpgsqlCommand( + """ + INSERT INTO idempotency_keys (user_id, http_method, path, idem_key, request_hash, message_id, created_at) + VALUES ($1, 'POST', $2, $3, $4, $5, now()) + """, + connection, + tx)) + { + key.Parameters.AddWithValue(senderId); + key.Parameters.AddWithValue(path); + key.Parameters.AddWithValue(idempotencyKey); + key.Parameters.AddWithValue(hash); + key.Parameters.AddWithValue(message.Id); + await key.ExecuteNonQueryAsync(cancellationToken); + } + + await tx.CommitAsync(cancellationToken); + return (message, false); + } + + private async Task<(MessageRecord? Message, bool Conflict)> ReadExisting( + Guid senderId, + string path, + string idempotencyKey, + byte[] hash, + CancellationToken cancellationToken) + { + await using var connection = await _dataSource.OpenConnectionAsync(cancellationToken); + var existing = await FindIdempotency(connection, null, senderId, path, idempotencyKey, hash, cancellationToken); + return existing ?? (null, false); + } + + private async Task<(MessageRecord? Message, bool Conflict)?> FindIdempotency( + NpgsqlConnection connection, + NpgsqlTransaction? tx, + Guid senderId, + string path, + string idempotencyKey, + byte[] hash, + CancellationToken cancellationToken) + { + await using var command = new NpgsqlCommand( + """ + SELECT request_hash, message_id, created_at <= now() - ($4::int * interval '1 second') + FROM idempotency_keys + WHERE user_id = $1 AND http_method = 'POST' AND path = $2 AND idem_key = $3 + FOR UPDATE + """, + connection, + tx); + command.Parameters.AddWithValue(senderId); + command.Parameters.AddWithValue(path); + command.Parameters.AddWithValue(idempotencyKey); + command.Parameters.AddWithValue((int)_idempotencyTtl.TotalSeconds); + await using var reader = await command.ExecuteReaderAsync(cancellationToken); + if (!await reader.ReadAsync(cancellationToken)) + return null; + var storedHash = (byte[])reader.GetValue(0); + var messageId = reader.GetGuid(1); + var expired = reader.GetBoolean(2); + await reader.DisposeAsync(); + if (expired) + { + await using var delete = new NpgsqlCommand( + "DELETE FROM idempotency_keys WHERE user_id = $1 AND http_method = 'POST' AND path = $2 AND idem_key = $3", + connection, + tx); + delete.Parameters.AddWithValue(senderId); + delete.Parameters.AddWithValue(path); + delete.Parameters.AddWithValue(idempotencyKey); + await delete.ExecuteNonQueryAsync(cancellationToken); + return null; + } + + if (!storedHash.AsSpan().SequenceEqual(hash)) + return (null, true); + return (await LoadMessage(connection, tx, messageId, cancellationToken), false); + } + + private static async Task LoadMessage( + NpgsqlConnection connection, + NpgsqlTransaction? tx, + Guid messageId, + CancellationToken cancellationToken) + { + await using var command = new NpgsqlCommand( + "SELECT id, chat_id, sender_id, body, created_at FROM messages WHERE id = $1", + connection, + tx); + command.Parameters.AddWithValue(messageId); + await using var reader = await command.ExecuteReaderAsync(cancellationToken); + if (!await reader.ReadAsync(cancellationToken)) + return null; + return new MessageRecord(reader.GetGuid(0), reader.GetGuid(1), reader.GetGuid(2), reader.GetString(3), Utc(reader, 4)); + } + + public async Task<(IReadOnlyList Items, string? NextCursor)> ListMessages( + Guid chatId, + int limit, + DateTime? afterTime, + Guid? afterId, + CancellationToken cancellationToken = default) + { + const string sql = """ + SELECT id, chat_id, sender_id, body, created_at + FROM messages + WHERE chat_id = $1 + AND ( + $2::timestamptz IS NULL + OR (created_at, id::text) > ($2::timestamptz, $3) + ) + ORDER BY created_at, id::text + LIMIT $4 + """; + await using var connection = await _dataSource.OpenConnectionAsync(cancellationToken); + await using var command = new NpgsqlCommand(sql, connection); + command.Parameters.AddWithValue(chatId); + command.Parameters.Add(new NpgsqlParameter { NpgsqlDbType = NpgsqlDbType.TimestampTz, Value = afterTime.HasValue ? afterTime.Value : DBNull.Value }); + command.Parameters.AddWithValue(afterId?.ToString("D") ?? ""); + command.Parameters.AddWithValue(limit + 1); + var rows = new List(); + await using var reader = await command.ExecuteReaderAsync(cancellationToken); + while (await reader.ReadAsync(cancellationToken)) + { + rows.Add(new MessageRecord( + reader.GetGuid(0), + reader.GetGuid(1), + reader.GetGuid(2), + reader.GetString(3), + Utc(reader, 4))); + } + + string? next = null; + if (rows.Count > limit) + { + rows.RemoveAt(rows.Count - 1); + var last = rows[^1]; + next = CursorCodec.Encode("m", chatId, last.CreatedAt, last.Id); + } + + return (rows, next); + } + + public async ValueTask DisposeAsync() => await _dataSource.DisposeAsync(); + + private static async Task Members(NpgsqlConnection connection, Guid chatId, CancellationToken cancellationToken) + { + await using var command = new NpgsqlCommand( + "SELECT user_id FROM chat_members WHERE chat_id = $1 ORDER BY position", + connection); + command.Parameters.AddWithValue(chatId); + var members = new List(); + await using var reader = await command.ExecuteReaderAsync(cancellationToken); + while (await reader.ReadAsync(cancellationToken)) + members.Add(reader.GetGuid(0)); + return members.ToArray(); + } + + private static void BindUser(NpgsqlCommand command, UserRecord user) + { + command.Parameters.AddWithValue(user.Id); + command.Parameters.AddWithValue(user.Username); + command.Parameters.AddWithValue(user.DisplayName); + command.Parameters.AddWithValue(user.PasswordHash ?? ""); + command.Parameters.AddWithValue(user.CreatedAt); + } + + private static UserRecord ReadUser(NpgsqlDataReader reader) => + new(reader.GetGuid(0), reader.GetString(1), reader.GetString(2), Utc(reader, 3)); + + private static DateTime Utc(NpgsqlDataReader reader, int ordinal) + { + var value = reader.GetFieldValue(ordinal).UtcDateTime; + return Clock.Truncate(value); + } + + private static byte[] TokenHash(string token) => SHA256.HashData(Encoding.UTF8.GetBytes(token)); + + private static IEnumerable Split(string sql) + { + var current = new StringBuilder(); + foreach (var line in sql.Split('\n')) + { + var trimmed = line.Trim(); + if (trimmed.Length == 0 || trimmed.StartsWith("--", StringComparison.Ordinal)) + continue; + current.AppendLine(line); + if (trimmed.EndsWith(';')) + { + var statement = current.ToString().Trim(); + current.Clear(); + if (statement.EndsWith(';')) + statement = statement[..^1]; + if (statement.Length > 0) + yield return statement; + } + } + } +} diff --git a/src/Messenger/Messenger.csproj b/src/Messenger/Messenger.csproj new file mode 100644 index 00000000..c5198356 --- /dev/null +++ b/src/Messenger/Messenger.csproj @@ -0,0 +1,17 @@ + + + net10.0 + enable + enable + true + true + Messenger + + + + + + + + + diff --git a/src/Messenger/Migrations/001_init.sql b/src/Messenger/Migrations/001_init.sql new file mode 100644 index 00000000..427279be --- /dev/null +++ b/src/Messenger/Migrations/001_init.sql @@ -0,0 +1,56 @@ +CREATE TABLE schema_migrations ( + version text PRIMARY KEY, + applied_at timestamptz NOT NULL +); + +CREATE TABLE users ( + id uuid PRIMARY KEY, + username text NOT NULL, + display_name text NOT NULL, + password_hash text NOT NULL, + created_at timestamptz NOT NULL, + CONSTRAINT users_username_unique UNIQUE (username) +); + +CREATE TABLE chats ( + id uuid PRIMARY KEY, + title text NOT NULL, + created_at timestamptz NOT NULL +); + +CREATE TABLE chat_members ( + chat_id uuid NOT NULL REFERENCES chats (id), + user_id uuid NOT NULL REFERENCES users (id), + position integer NOT NULL, + PRIMARY KEY (chat_id, user_id) +); + +CREATE TABLE messages ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL REFERENCES chats (id), + sender_id uuid NOT NULL REFERENCES users (id), + body text NOT NULL, + created_at timestamptz NOT NULL +); + +CREATE INDEX messages_chat_history ON messages (chat_id, created_at, id); + +CREATE TABLE sessions ( + token_hash bytea PRIMARY KEY, + user_id uuid NOT NULL REFERENCES users (id), + expires_at timestamptz NOT NULL, + revoked_at timestamptz +); + +CREATE INDEX sessions_user ON sessions (user_id); + +CREATE TABLE idempotency_keys ( + user_id uuid NOT NULL REFERENCES users (id), + http_method text NOT NULL, + path text NOT NULL, + idem_key text NOT NULL, + request_hash bytea NOT NULL, + message_id uuid NOT NULL REFERENCES messages (id), + created_at timestamptz NOT NULL, + PRIMARY KEY (user_id, http_method, path, idem_key) +); diff --git a/src/Messenger/Models.cs b/src/Messenger/Models.cs new file mode 100644 index 00000000..bc93a05b --- /dev/null +++ b/src/Messenger/Models.cs @@ -0,0 +1,281 @@ +using System.Buffers; +using System.Globalization; +using System.Text; +using System.Text.Json; +using System.Text.Json.Serialization; +using System.Text.RegularExpressions; + +namespace Messenger; + +public static class Clock +{ + public const string Format = "yyyy-MM-dd'T'HH:mm:ss.ffffff'Z'"; + + public static DateTime Truncate(DateTime utc) + { + var ticks = utc.ToUniversalTime().Ticks; + ticks -= ticks % 10; + return new DateTime(ticks, DateTimeKind.Utc); + } + + public static string FormatUtc(DateTime value) => + Truncate(value).ToString(Format, CultureInfo.InvariantCulture); + + public static bool TryParse(string text, out DateTime utc) + { + if (DateTime.TryParseExact(text, Format, CultureInfo.InvariantCulture, DateTimeStyles.None, out var parsed)) + { + utc = DateTime.SpecifyKind(parsed, DateTimeKind.Utc); + return true; + } + + utc = default; + return false; + } +} + +public static class Rules +{ + private static readonly Regex UsernamePattern = new( + "^[a-z0-9_]{3,32}$", + RegexOptions.CultureInvariant | RegexOptions.Compiled); + + public static bool IsUsername(string? value) => + value is not null && UsernamePattern.IsMatch(value); + + public static bool IsPresentText(string? value, int maxCodePoints) + { + if (value is null || !IsWellFormed(value) || string.IsNullOrWhiteSpace(value)) + return false; + var count = value.EnumerateRunes().Count(); + return count >= 1 && count <= maxCodePoints; + } + + public static bool IsPassword(string? value) + { + if (value is null || !IsWellFormed(value) || string.IsNullOrWhiteSpace(value)) + return false; + var count = value.EnumerateRunes().Count(); + return count is >= 12 and <= 128; + } + + public static bool IsWellFormed(string value) + { + var index = 0; + while (index < value.Length) + { + if (Rune.DecodeFromUtf16(value.AsSpan(index), out _, out var consumed) != OperationStatus.Done) + return false; + index += consumed; + } + + return true; + } +} + +public static class CursorCodec +{ + public static string Encode(string kind, Guid scopeId, DateTime createdAt, Guid itemId) + { + var raw = $"{kind}|{scopeId:D}|{Clock.FormatUtc(createdAt)}|{itemId:D}"; + return Convert.ToBase64String(Encoding.UTF8.GetBytes(raw)) + .TrimEnd('=') + .Replace('+', '-') + .Replace('/', '_'); + } + + public static bool TryDecode(string cursor, out string kind, out Guid scopeId, out DateTime createdAt, out Guid itemId) + { + kind = ""; + scopeId = default; + createdAt = default; + itemId = default; + if (string.IsNullOrEmpty(cursor) || cursor.Length > 512) + return false; + + try + { + var text = cursor.Replace('-', '+').Replace('_', '/'); + switch (text.Length % 4) + { + case 0: + break; + case 2: + text += "=="; + break; + case 3: + text += "="; + break; + default: + return false; + } + + var parts = Encoding.UTF8.GetString(Convert.FromBase64String(text)).Split('|'); + if (parts.Length != 4 || parts[0] is not ("m" or "c")) + return false; + if (!Guid.TryParseExact(parts[1], "D", out scopeId) || !Guid.TryParseExact(parts[3], "D", out itemId)) + return false; + if (!Clock.TryParse(parts[2], out createdAt)) + return false; + kind = parts[0]; + return true; + } + catch (FormatException) + { + return false; + } + } +} + +public static class JsonIO +{ + public const int MaxBodyBytes = 65_536; + + public static readonly JsonSerializerOptions Options = new(JsonSerializerDefaults.Web) + { + PropertyNameCaseInsensitive = false, + UnmappedMemberHandling = JsonUnmappedMemberHandling.Disallow, + DefaultIgnoreCondition = JsonIgnoreCondition.Never, + ReadCommentHandling = JsonCommentHandling.Disallow, + AllowTrailingCommas = false, + MaxDepth = 16 + }; + + public static bool HasDuplicateKeys(ReadOnlySpan utf8) + { + var reader = new Utf8JsonReader(utf8, new JsonReaderOptions + { + CommentHandling = JsonCommentHandling.Disallow, + AllowTrailingCommas = false, + MaxDepth = 16 + }); + var seen = new Stack>(); + var rootChecked = false; + while (reader.Read()) + { + if (!rootChecked) + { + rootChecked = true; + if (reader.TokenType != JsonTokenType.StartObject) + return true; + } + + switch (reader.TokenType) + { + case JsonTokenType.StartObject: + seen.Push(new HashSet(StringComparer.Ordinal)); + break; + case JsonTokenType.EndObject: + if (seen.Count == 0) + return true; + seen.Pop(); + break; + case JsonTokenType.PropertyName: + if (seen.Count == 0 || !seen.Peek().Add(reader.GetString() ?? "")) + return true; + break; + } + } + + return !rootChecked || seen.Count != 0; + } +} + +public sealed record UserRecord(Guid Id, string Username, string DisplayName, DateTime CreatedAt, string? PasswordHash = null); + +public sealed record ChatRecord(Guid Id, string Title, Guid[] MemberIds, DateTime CreatedAt); + +public sealed record MessageRecord(Guid Id, Guid ChatId, Guid SenderId, string Text, DateTime CreatedAt); + +public sealed class CreateUserBody +{ + [JsonRequired] + [JsonPropertyName("username")] + public string? Username { get; set; } + + [JsonRequired] + [JsonPropertyName("display_name")] + public string? DisplayName { get; set; } + + [JsonRequired] + [JsonPropertyName("password")] + public string? Password { get; set; } +} + +public sealed class CreateChatBody +{ + [JsonRequired] + [JsonPropertyName("title")] + public string? Title { get; set; } + + [JsonRequired] + [JsonPropertyName("member_ids")] + public List? MemberIds { get; set; } +} + +public sealed class CreateMessageBody +{ + [JsonRequired] + [JsonPropertyName("text")] + public string? Text { get; set; } +} + +public sealed record UserDto( + [property: JsonPropertyName("id")] string Id, + [property: JsonPropertyName("username")] string Username, + [property: JsonPropertyName("display_name")] string DisplayName, + [property: JsonPropertyName("created_at")] string CreatedAt); + +public sealed record ChatDto( + [property: JsonPropertyName("id")] string Id, + [property: JsonPropertyName("title")] string Title, + [property: JsonPropertyName("member_ids")] IReadOnlyList MemberIds, + [property: JsonPropertyName("created_at")] string CreatedAt); + +public sealed record MessageDto( + [property: JsonPropertyName("id")] string Id, + [property: JsonPropertyName("chat_id")] string ChatId, + [property: JsonPropertyName("sender_id")] string SenderId, + [property: JsonPropertyName("text")] string Text, + [property: JsonPropertyName("created_at")] string CreatedAt); + +public sealed record ChatPageDto( + [property: JsonPropertyName("items")] IReadOnlyList Items, + [property: JsonPropertyName("next_cursor")] string? NextCursor); + +public sealed record MessagePageDto( + [property: JsonPropertyName("items")] IReadOnlyList Items, + [property: JsonPropertyName("next_cursor")] string? NextCursor); + +public sealed record SessionDto( + [property: JsonPropertyName("token")] string Token, + [property: JsonPropertyName("token_type")] string TokenType, + [property: JsonPropertyName("expires_at")] string ExpiresAt, + [property: JsonPropertyName("user")] UserDto User); + +public sealed record ErrorEnvelope( + [property: JsonPropertyName("error")] ErrorDetail Error); + +public sealed record ErrorDetail( + [property: JsonPropertyName("code")] string Code, + [property: JsonPropertyName("message")] string Message, + [property: JsonPropertyName("request_id")] string RequestId); + +public sealed record HealthDto([property: JsonPropertyName("status")] string Status); + +public enum BodyStatus +{ + Ok, + UnsupportedMedia, + TooLarge, + Invalid +} + +public sealed class ReadinessState +{ + private int _open = 1; + + public bool IsReady => Volatile.Read(ref _open) == 1; + + public void Close() => Interlocked.Exchange(ref _open, 0); +} diff --git a/src/Messenger/Passwords.cs b/src/Messenger/Passwords.cs new file mode 100644 index 00000000..abbfaa56 --- /dev/null +++ b/src/Messenger/Passwords.cs @@ -0,0 +1,56 @@ +using System.Security.Cryptography; +using System.Text; +using Konscious.Security.Cryptography; + +namespace Messenger; + +public static class Passwords +{ + private const int MemoryKb = 19456; + private const int Iterations = 2; + private const int Parallelism = 1; + private const int HashLength = 32; + private const int SaltLength = 16; + + public static readonly string DummyHash = Hash("dummy-password-not-a-login"); + + public static string Hash(string password) + { + var salt = RandomNumberGenerator.GetBytes(SaltLength); + var hash = Derive(password, salt); + return $"argon2id$m={MemoryKb},t={Iterations},p={Parallelism}${Convert.ToBase64String(salt)}${Convert.ToBase64String(hash)}"; + } + + public static bool Verify(string password, string stored) + { + var parts = stored.Split('$'); + if (parts.Length != 4 || parts[0] != "argon2id") + return false; + byte[] salt; + byte[] expected; + try + { + salt = Convert.FromBase64String(parts[2]); + expected = Convert.FromBase64String(parts[3]); + } + catch (FormatException) + { + return false; + } + + var actual = Derive(password, salt); + return CryptographicOperations.FixedTimeEquals(actual, expected); + } + + private static byte[] Derive(string password, byte[] salt) + { + using var argon = new Argon2id(Encoding.UTF8.GetBytes(password)) + { + Salt = salt, + MemorySize = MemoryKb, + Iterations = Iterations, + DegreeOfParallelism = Parallelism + }; + return argon.GetBytes(HashLength); + } +} diff --git a/src/Messenger/Program.cs b/src/Messenger/Program.cs new file mode 100644 index 00000000..22e1126b --- /dev/null +++ b/src/Messenger/Program.cs @@ -0,0 +1,636 @@ +using System.Globalization; +using System.Text.RegularExpressions; +using System.Net; +using System.Net.Http.Headers; +using System.Text; +using System.Text.Json; + +namespace Messenger; + +public sealed record InstanceId(string Value); + +public sealed class Program +{ + private Program() + { + } + + public static void Main(string[] args) => CreateApp(args).Run(); + + public static WebApplication CreateApp(string[] args) + { + var builder = WebApplication.CreateBuilder(args); + builder.Logging.AddFilter("Microsoft.AspNetCore", LogLevel.Warning); + builder.Logging.AddFilter("Messenger", LogLevel.Information); + builder.Services.Configure(options => options.ShutdownTimeout = TimeSpan.FromSeconds(5)); + builder.WebHost.ConfigureKestrel(options => + { + options.AddServerHeader = false; + options.Limits.MaxRequestBodySize = JsonIO.MaxBodyBytes; + }); + + var ttlSeconds = ReadTtl("SESSION_TTL_SECONDS", 3600); + var idempotencySeconds = ReadTtl("IDEMPOTENCY_TTL_SECONDS", 86400); + var instanceId = Guid.NewGuid().ToString("D"); + builder.Services.AddSingleton(new InstanceId(instanceId)); + builder.Services.AddSingleton(new Db(ReadDatabaseUrl(), TimeSpan.FromSeconds(ttlSeconds), TimeSpan.FromSeconds(idempotencySeconds))); + builder.Services.AddSingleton(); + builder.Services.AddHostedService(); + + var listen = "test-host"; + if (Environment.GetEnvironmentVariable("MESSENGER_TESTING") != "1") + { + listen = BindUrl(); + builder.WebHost.UseUrls(listen); + } + + var app = builder.Build(); + var readiness = app.Services.GetRequiredService(); + var log = app.Logger; + app.Lifetime.ApplicationStopping.Register(() => + { + readiness.Close(); + log.LogInformation("shutdown: новые запросы больше не обслуживаются"); + }); + + app.Use(async (ctx, next) => + { + var requestId = Guid.NewGuid().ToString("D"); + var instance = ctx.RequestServices.GetRequiredService().Value; + ctx.Response.Headers["X-Request-Id"] = requestId; + ctx.Response.Headers["X-Instance-Id"] = instance; + ctx.Items["request_id"] = requestId; + var watch = System.Diagnostics.Stopwatch.StartNew(); + try + { + var path = ctx.Request.Path.Value ?? ""; + if (!readiness.IsReady && !path.Equals("/health/live", StringComparison.Ordinal)) + { + await ApiResults.WriteError(ctx, StatusCodes.Status503ServiceUnavailable, "unavailable", "Сервер останавливается"); + return; + } + + await next(); + } + catch (BadHttpRequestException ex) + { + var tooLarge = ex.StatusCode == StatusCodes.Status413PayloadTooLarge; + log.LogWarning("bad request {ExceptionType} request_id={RequestId}", ex.GetType().Name, requestId); + await ApiResults.WriteError( + ctx, + tooLarge ? StatusCodes.Status413PayloadTooLarge : StatusCodes.Status400BadRequest, + tooLarge ? "payload_too_large" : "invalid_request", + tooLarge ? "Тело запроса слишком большое" : "Некорректный запрос"); + } + catch (Npgsql.NpgsqlException) + { + log.LogWarning("database unavailable request_id={RequestId}", requestId); + await ApiResults.WriteError(ctx, StatusCodes.Status503ServiceUnavailable, "unavailable", "База данных недоступна"); + } + catch (OperationCanceledException) + { + if (!readiness.IsReady) + await ApiResults.WriteError(ctx, StatusCodes.Status503ServiceUnavailable, "unavailable", "Сервер останавливается"); + } + catch (Exception ex) + { + log.LogError("unhandled {ExceptionType} request_id={RequestId}", ex.GetType().Name, requestId); + await ApiResults.WriteError(ctx, StatusCodes.Status500InternalServerError, "internal_error", "Внутренняя ошибка"); + } + finally + { + log.LogInformation( + "{Method} {Path} -> {Status} request_id={RequestId} elapsed_ms={Elapsed}", + ctx.Request.Method, + ctx.Request.Path.Value, + ctx.Response.StatusCode, + requestId, + watch.Elapsed.TotalMilliseconds.ToString("0.###", CultureInfo.InvariantCulture)); + } + }); + + Endpoints.Map(app); + var envName = Environment.GetEnvironmentVariable("APP_ENV") ?? "lab"; + log.LogInformation( + "Messenger API listen={Listen} APP_ENV={Env} session_ttl_seconds={Ttl}. Источник истины — PostgreSQL.", + listen, + envName, + ttlSeconds); + return app; + } + + private static int ReadTtl(string name, int fallback) + { + var text = Environment.GetEnvironmentVariable(name); + if (string.IsNullOrWhiteSpace(text)) + return fallback; + if (!int.TryParse(text, NumberStyles.None, CultureInfo.InvariantCulture, out var seconds) || seconds < 1) + throw new InvalidOperationException(name + " must be a positive integer"); + return seconds; + } + + private static string ReadDatabaseUrl() + { + var direct = Environment.GetEnvironmentVariable("DATABASE_URL"); + if (!string.IsNullOrWhiteSpace(direct)) + return direct.Trim(); + var file = Environment.GetEnvironmentVariable("DATABASE_URL_FILE"); + if (!string.IsNullOrWhiteSpace(file)) + return File.ReadAllText(file).Trim(); + throw new InvalidOperationException("Set DATABASE_URL or DATABASE_URL_FILE"); + } + + private static string BindUrl() + { + var host = Environment.GetEnvironmentVariable("APP_HOST"); + if (string.IsNullOrWhiteSpace(host)) + host = "0.0.0.0"; + var portText = Environment.GetEnvironmentVariable("APP_PORT"); + if (string.IsNullOrWhiteSpace(portText)) + portText = "8080"; + if (!ushort.TryParse(portText, NumberStyles.None, CultureInfo.InvariantCulture, out var port) || port == 0) + throw new InvalidOperationException("APP_PORT must be an integer from 1 to 65535"); + if (host is not ("0.0.0.0" or "localhost") && !IPAddress.TryParse(host, out _)) + throw new InvalidOperationException("APP_HOST must be an IP address or localhost"); + var bind = host.Contains(':') ? $"[{host}]" : host; + return $"http://{bind}:{port}"; + } +} + +public sealed class DatabaseStartup(Db db, ILogger log) : IHostedService +{ + public async Task StartAsync(CancellationToken cancellationToken) + { + for (var attempt = 1; attempt <= 30; attempt++) + { + try + { + await db.Migrate(cancellationToken); + log.LogInformation("database migrations applied"); + return; + } + catch (Exception ex) when (ex is Npgsql.NpgsqlException or IOException or TimeoutException) + { + log.LogWarning("database not ready attempt={Attempt} error={ExceptionType}", attempt, ex.GetType().Name); + await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken); + } + } + + throw new InvalidOperationException("database migrations did not apply"); + } + + public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask; +} + +public static class ApiResults +{ + public const string BasicChallenge = "Basic realm=\"messenger\", charset=\"UTF-8\""; + public const string BearerChallenge = "Bearer realm=\"messenger\""; + + public static IResult Ok(object body) => Results.Json(body, JsonIO.Options); + + public static IResult Created(object body) => + Results.Json(body, JsonIO.Options, statusCode: StatusCodes.Status201Created); + + public static IResult NoContent() => Results.StatusCode(StatusCodes.Status204NoContent); + + public static IResult Fail(HttpContext ctx, int status, string code, string message) => + Results.Json(Envelope(ctx, code, message), JsonIO.Options, statusCode: status); + + public static IResult Unauthorized(HttpContext ctx, string challenge, string message) + { + ctx.Response.Headers.WWWAuthenticate = challenge; + return Fail(ctx, StatusCodes.Status401Unauthorized, "unauthorized", message); + } + + public static async Task WriteError(HttpContext ctx, int status, string code, string message) + { + if (ctx.Response.HasStarted) + return; + ctx.Response.StatusCode = status; + ctx.Response.ContentType = "application/json; charset=utf-8"; + await JsonSerializer.SerializeAsync(ctx.Response.Body, Envelope(ctx, code, message), JsonIO.Options, ctx.RequestAborted); + } + + private static ErrorEnvelope Envelope(HttpContext ctx, string code, string message) + { + var requestId = ctx.Items["request_id"] as string; + if (string.IsNullOrEmpty(requestId)) + requestId = "missing-request-id"; + return new ErrorEnvelope(new ErrorDetail(code, message, requestId)); + } +} + +public static class Endpoints +{ + public static void Map(WebApplication app) + { + app.MapGet("/health/live", () => ApiResults.Ok(new HealthDto("ok"))); + app.MapGet("/health/ready", Ready); + app.MapPost("/api/v1/users", CreateUser); + app.MapPost("/api/v1/auth/sessions", CreateSession); + app.MapDelete("/api/v1/auth/sessions/current", RevokeSession); + app.MapGet("/api/v1/users/me", Me); + app.MapPost("/api/v1/chats", CreateChat); + app.MapGet("/api/v1/chats", ListChats); + app.MapGet("/api/v1/chats/{chatId}", GetChat); + app.MapPost("/api/v1/chats/{chatId}/messages", CreateMessage); + app.MapGet("/api/v1/chats/{chatId}/messages", ListMessages); + app.MapFallback((HttpContext ctx) => ApiResults.Fail(ctx, StatusCodes.Status404NotFound, "not_found", "Ресурс не найден")); + } + + private static async Task Ready(ReadinessState readiness, Db db, HttpContext ctx) + { + if (!readiness.IsReady || !await db.Ping(ctx.RequestAborted)) + return ApiResults.Fail(ctx, StatusCodes.Status503ServiceUnavailable, "unavailable", "База данных недоступна"); + return ApiResults.Ok(new HealthDto("ok")); + } + + private static async Task CreateUser(HttpContext ctx, Db db, ILogger log) + { + var (status, body) = await Read(ctx); + if (status != BodyStatus.Ok || body is null) + return BodyError(ctx, status); + if (!Rules.IsUsername(body.Username)) + return ApiResults.Fail(ctx, StatusCodes.Status400BadRequest, "invalid_request", "username должен соответствовать [a-z0-9_]{3,32}"); + if (!Rules.IsPresentText(body.DisplayName, 100)) + return ApiResults.Fail(ctx, StatusCodes.Status400BadRequest, "invalid_request", "display_name должен содержать от 1 до 100 символов и не состоять из пробелов"); + if (!Rules.IsPassword(body.Password)) + return ApiResults.Fail(ctx, StatusCodes.Status400BadRequest, "invalid_request", "password должен содержать от 12 до 128 символов и не состоять из пробелов"); + var user = await db.AddUser(body.Username!, body.DisplayName!, body.Password!, ctx.RequestAborted); + if (user is null) + return ApiResults.Fail(ctx, StatusCodes.Status409Conflict, "conflict", "Имя пользователя занято"); + log.LogInformation("user created id={UserId}", user.Id); + return ApiResults.Created(ToUser(user)); + } + + private static async Task CreateSession(HttpContext ctx, Db db, ILogger log) + { + if (!TryBasic(ctx, out var username, out var password)) + return ApiResults.Unauthorized(ctx, ApiResults.BasicChallenge, "Неверные учётные данные"); + var login = await db.FindLogin(username, ctx.RequestAborted); + var hash = login?.PasswordHash ?? Passwords.DummyHash; + if (login is null || !Passwords.Verify(password, hash)) + return ApiResults.Unauthorized(ctx, ApiResults.BasicChallenge, "Неверные учётные данные"); + var (token, expires) = await db.CreateSession(login.Id, ctx.RequestAborted); + log.LogInformation("session created user={UserId} expires_at={ExpiresAt}", login.Id, Clock.FormatUtc(expires)); + return ApiResults.Created(new SessionDto(token, "Bearer", Clock.FormatUtc(expires), ToUser(login))); + } + + private static async Task RevokeSession(HttpContext ctx, Db db, ILogger log) + { + if (!TryBearerToken(ctx, out var token)) + return ApiResults.Unauthorized(ctx, ApiResults.BearerChallenge, "Требуется Bearer-сессия"); + if (!await db.RevokeSession(token, ctx.RequestAborted)) + return ApiResults.Unauthorized(ctx, ApiResults.BearerChallenge, "Сессия недействительна"); + log.LogInformation("session revoked"); + return ApiResults.NoContent(); + } + + private static async Task Me(HttpContext ctx, Db db) + { + var actor = await TryActor(ctx, db); + if (actor.User is null) + return actor.Error!; + var user = actor.User; + return ApiResults.Ok(ToUser(user)); + } + + private static async Task CreateChat(HttpContext ctx, Db db, ILogger log) + { + var actor = await TryActor(ctx, db); + if (actor.User is null) + return actor.Error!; + var user = actor.User; + var (status, body) = await Read(ctx); + if (status != BodyStatus.Ok || body is null) + return BodyError(ctx, status); + if (!Rules.IsPresentText(body.Title, 100)) + return ApiResults.Fail(ctx, StatusCodes.Status400BadRequest, "invalid_request", "title должен содержать от 1 до 100 символов и не состоять из пробелов"); + if (body.MemberIds is null || body.MemberIds.Count is < 1 or > 100) + return ApiResults.Fail(ctx, StatusCodes.Status400BadRequest, "invalid_request", "member_ids должен содержать от 1 до 100 участников"); + var (chat, reason) = await db.AddChat(user.Id, body.Title!, body.MemberIds, ctx.RequestAborted); + if (chat is null) + return ApiResults.Fail(ctx, StatusCodes.Status400BadRequest, "invalid_request", reason ?? "Некорректный список участников"); + log.LogInformation("chat created id={ChatId} members={Members}", chat.Id, chat.MemberIds.Length); + return ApiResults.Created(ToChat(chat)); + } + + private static async Task ListChats(HttpContext ctx, Db db) + { + var actor = await TryActor(ctx, db); + if (actor.User is null) + return actor.Error!; + var user = actor.User; + if (!TryPage(ctx, out var limit, out var cursor, out var error)) + return error!; + if (!TryPosition(ctx, cursor, "c", user.Id, out var afterTime, out var afterId, out error)) + return error!; + var (items, next) = await db.ListChats(user.Id, limit, afterTime, afterId, ctx.RequestAborted); + return ApiResults.Ok(new ChatPageDto(items.Select(ToChat).ToArray(), next)); + } + + private static async Task GetChat(string chatId, HttpContext ctx, Db db) + { + var actor = await TryActor(ctx, db); + if (actor.User is null) + return actor.Error!; + var user = actor.User; + if (!TryChatId(ctx, chatId, out var id, out var error)) + return error!; + var chat = await db.FindChat(id, user.Id, ctx.RequestAborted); + if (chat is null) + return ApiResults.Fail(ctx, StatusCodes.Status404NotFound, "not_found", "Чат не найден"); + return ApiResults.Ok(ToChat(chat)); + } + + private static async Task CreateMessage(string chatId, HttpContext ctx, Db db, ILogger log) + { + var actor = await TryActor(ctx, db); + if (actor.User is null) + return actor.Error!; + var user = actor.User; + if (!TryChatId(ctx, chatId, out var id, out var error)) + return error!; + if (await db.FindChat(id, user.Id, ctx.RequestAborted) is null) + return ApiResults.Fail(ctx, StatusCodes.Status404NotFound, "not_found", "Чат не найден"); + if (!TryIdempotencyKey(ctx, out var idempotencyKey, out error)) + return error!; + var (status, body) = await Read(ctx); + if (status != BodyStatus.Ok || body is null) + return BodyError(ctx, status); + if (!Rules.IsPresentText(body.Text, 4000)) + return ApiResults.Fail(ctx, StatusCodes.Status400BadRequest, "invalid_request", "Текст сообщения должен содержать от 1 до 4000 символов и не состоять из пробелов"); + var (message, conflict) = await db.SendMessage(id, user.Id, body.Text!, idempotencyKey, "/api/v1/chats/" + id.ToString("D") + "/messages", ctx.RequestAborted); + if (conflict) + return ApiResults.Fail(ctx, StatusCodes.Status409Conflict, "conflict", "Ключ уже использован для другого сообщения"); + if (message is null) + return ApiResults.Fail(ctx, StatusCodes.Status404NotFound, "not_found", "Чат не найден"); + log.LogInformation( + "message created id={MessageId} chat={ChatId} sender={SenderId} codepoints={CodePoints}", + message.Id, + message.ChatId, + message.SenderId, + body.Text!.EnumerateRunes().Count()); + return ApiResults.Created(ToMessage(message)); + } + + private static async Task ListMessages(string chatId, HttpContext ctx, Db db) + { + var actor = await TryActor(ctx, db); + if (actor.User is null) + return actor.Error!; + var user = actor.User; + if (!TryChatId(ctx, chatId, out var id, out var error)) + return error!; + if (await db.FindChat(id, user.Id, ctx.RequestAborted) is null) + return ApiResults.Fail(ctx, StatusCodes.Status404NotFound, "not_found", "Чат не найден"); + if (!TryPage(ctx, out var limit, out var cursor, out error)) + return error!; + if (!TryPosition(ctx, cursor, "m", id, out var afterTime, out var afterId, out error)) + return error!; + var (items, next) = await db.ListMessages(id, limit, afterTime, afterId, ctx.RequestAborted); + return ApiResults.Ok(new MessagePageDto(items.Select(ToMessage).ToArray(), next)); + } + + private static readonly Regex IdempotencyPattern = new( + "^[A-Za-z0-9._:-]{1,128}$", + RegexOptions.CultureInvariant | RegexOptions.Compiled); + + private static bool TryIdempotencyKey(HttpContext ctx, out string key, out IResult? error) + { + key = ""; + if (!ctx.Request.Headers.TryGetValue("Idempotency-Key", out var values) || values.Count != 1 || string.IsNullOrEmpty(values[0])) + { + error = ApiResults.Fail(ctx, StatusCodes.Status400BadRequest, "invalid_request", "Требуется заголовок Idempotency-Key"); + return false; + } + + key = values[0]!; + if (!IdempotencyPattern.IsMatch(key)) + { + error = ApiResults.Fail(ctx, StatusCodes.Status400BadRequest, "invalid_request", "Некорректный Idempotency-Key"); + return false; + } + + error = null; + return true; + } + + private static bool TryBasic(HttpContext ctx, out string username, out string password) + { + username = ""; + password = ""; + if (!ctx.Request.Headers.TryGetValue("Authorization", out var values) || values.Count != 1) + return false; + var header = values[0]; + if (string.IsNullOrEmpty(header) || !header.StartsWith("Basic ", StringComparison.OrdinalIgnoreCase)) + return false; + byte[] raw; + try + { + raw = Convert.FromBase64String(header["Basic ".Length..].Trim()); + } + catch (FormatException) + { + return false; + } + + string text; + try + { + text = new UTF8Encoding(false, true).GetString(raw); + } + catch (DecoderFallbackException) + { + return false; + } + + var split = text.IndexOf(':'); + if (split <= 0) + return false; + username = text[..split]; + password = text[(split + 1)..]; + return username.Length > 0; + } + + private static bool TryBearerToken(HttpContext ctx, out string token) + { + token = ""; + if (!ctx.Request.Headers.TryGetValue("Authorization", out var values) || values.Count != 1) + return false; + var header = values[0]; + if (string.IsNullOrEmpty(header) || !header.StartsWith("Bearer ", StringComparison.Ordinal)) + return false; + token = header["Bearer ".Length..].Trim(); + return token.Length >= 32; + } + + private readonly record struct Actor(UserRecord? User, IResult? Error); + + private static async Task TryActor(HttpContext ctx, Db db) + { + if (!TryBearerToken(ctx, out var token)) + return new Actor(null, ApiResults.Unauthorized(ctx, ApiResults.BearerChallenge, "Требуется Bearer-сессия")); + + var user = await db.FindSessionUser(token, ctx.RequestAborted); + if (user is null) + return new Actor(null, ApiResults.Unauthorized(ctx, ApiResults.BearerChallenge, "Сессия недействительна")); + return new Actor(user, null); + } + + private static async Task<(BodyStatus Status, T? Value)> Read(HttpContext ctx) where T : class + { + var request = ctx.Request; + if (string.IsNullOrWhiteSpace(request.ContentType)) + return (BodyStatus.Invalid, null); + if (!MediaTypeHeaderValue.TryParse(request.ContentType, out var media) || + !string.Equals(media.MediaType, "application/json", StringComparison.OrdinalIgnoreCase)) + return (BodyStatus.UnsupportedMedia, null); + if (media.CharSet is { Length: > 0 } charSet && + !charSet.Equals("utf-8", StringComparison.OrdinalIgnoreCase) && + !charSet.Equals("utf8", StringComparison.OrdinalIgnoreCase)) + return (BodyStatus.Invalid, null); + if (request.ContentLength > JsonIO.MaxBodyBytes) + return (BodyStatus.TooLarge, null); + + using var buffer = new MemoryStream(); + var chunk = new byte[8192]; + while (true) + { + int read; + try + { + read = await request.Body.ReadAsync(chunk, ctx.RequestAborted); + } + catch (BadHttpRequestException ex) when (ex.StatusCode == StatusCodes.Status413PayloadTooLarge) + { + return (BodyStatus.TooLarge, null); + } + + if (read == 0) + break; + if (buffer.Length + read > JsonIO.MaxBodyBytes) + return (BodyStatus.TooLarge, null); + buffer.Write(chunk, 0, read); + } + + var bytes = buffer.ToArray(); + if (bytes.Length >= 3 && bytes[0] == 0xEF && bytes[1] == 0xBB && bytes[2] == 0xBF) + bytes = bytes[3..]; + if (bytes.Length == 0) + return (BodyStatus.Invalid, null); + + try + { + _ = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true).GetString(bytes); + if (JsonIO.HasDuplicateKeys(bytes)) + return (BodyStatus.Invalid, null); + var value = JsonSerializer.Deserialize(bytes, JsonIO.Options); + return value is null ? (BodyStatus.Invalid, null) : (BodyStatus.Ok, value); + } + catch (JsonException) + { + return (BodyStatus.Invalid, null); + } + catch (DecoderFallbackException) + { + return (BodyStatus.Invalid, null); + } + } + + private static IResult BodyError(HttpContext ctx, BodyStatus status) => status switch + { + BodyStatus.UnsupportedMedia => ApiResults.Fail(ctx, StatusCodes.Status415UnsupportedMediaType, "unsupported_media_type", "Поддерживается только application/json"), + BodyStatus.TooLarge => ApiResults.Fail(ctx, StatusCodes.Status413PayloadTooLarge, "payload_too_large", "Тело запроса слишком большое"), + _ => ApiResults.Fail(ctx, StatusCodes.Status400BadRequest, "invalid_request", "Некорректный JSON") + }; + + private static bool TryChatId(HttpContext ctx, string chatId, out Guid id, out IResult? error) + { + if (!Guid.TryParseExact(chatId, "D", out id)) + { + error = ApiResults.Fail(ctx, StatusCodes.Status400BadRequest, "invalid_request", "Некорректный идентификатор чата"); + return false; + } + + error = null; + return true; + } + + private static bool TryPage(HttpContext ctx, out int limit, out string? cursor, out IResult? error) + { + limit = 50; + cursor = null; + var query = ctx.Request.Query; + if (query.TryGetValue("limit", out var limits)) + { + if (limits.Count != 1 || + !int.TryParse(limits[0], NumberStyles.None, CultureInfo.InvariantCulture, out limit) || + limit is < 1 or > 100) + { + error = ApiResults.Fail(ctx, StatusCodes.Status400BadRequest, "invalid_request", "Параметр limit должен быть целым числом от 1 до 100"); + return false; + } + } + + if (query.TryGetValue("cursor", out var cursors)) + { + if (cursors.Count != 1 || string.IsNullOrEmpty(cursors[0])) + { + error = ApiResults.Fail(ctx, StatusCodes.Status400BadRequest, "invalid_request", "Некорректный cursor"); + return false; + } + + cursor = cursors[0]; + } + + error = null; + return true; + } + + private static bool TryPosition( + HttpContext ctx, + string? cursor, + string expectedKind, + Guid expectedScope, + out DateTime? afterTime, + out Guid? afterId, + out IResult? error) + { + afterTime = null; + afterId = null; + if (cursor is null) + { + error = null; + return true; + } + + if (!CursorCodec.TryDecode(cursor, out var kind, out var scope, out var time, out var itemId) || + kind != expectedKind || + scope != expectedScope) + { + error = ApiResults.Fail(ctx, StatusCodes.Status400BadRequest, "invalid_request", "Некорректный cursor"); + return false; + } + + afterTime = time; + afterId = itemId; + error = null; + return true; + } + + private static UserDto ToUser(UserRecord user) => + new(user.Id.ToString("D"), user.Username, user.DisplayName, Clock.FormatUtc(user.CreatedAt)); + + private static ChatDto ToChat(ChatRecord chat) => + new(chat.Id.ToString("D"), chat.Title, chat.MemberIds.Select(id => id.ToString("D")).ToArray(), Clock.FormatUtc(chat.CreatedAt)); + + private static MessageDto ToMessage(MessageRecord message) => + new( + message.Id.ToString("D"), + message.ChatId.ToString("D"), + message.SenderId.ToString("D"), + message.Text, + Clock.FormatUtc(message.CreatedAt)); +}