ЛР 2 — БПИ2303 — Лобашов — на 3 #175

Closed
PoRATL wants to merge 1 commits from PoRATL/mtusi2026lab2:solution/БПИ2303-lobashov into master
20 changed files with 1755 additions and 15 deletions
+4
View File
@@ -18,3 +18,7 @@ __pycache__
node_modules
evidence
.DS_Store
**/bin/
**/obj/
**/*.user
.vs/
+2
View File
@@ -9,3 +9,5 @@ DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
# Local compose only. Put the real value in .env, never in git.
POSTGRES_PASSWORD=replace-with-a-local-password
+25
View File
@@ -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"]
+46 -15
View File
@@ -1,37 +1,68 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Лобашов Валентин, БПИ2303
- Целевая оценка; выбранный трек 5, если нужен: 3
- Commit/PR: ветка solution/БПИ2303-lobashov, https://gitea.privcloud.tech/PoRATL/mtusi2026lab2
- Использованные источники, библиотеки и помощь ИИ: ASP.NET Core, Npgsql 9.0.4, Konscious.Security.Cryptography.Argon2 1.3.1, PostgreSQL 16.11, контракт репозитория. Реализацию и черновик отчёта подготовил ассистент 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`.
```sh
copy .env.example .env
```
В `.env` замените `POSTGRES_PASSWORD` на локальный пароль. Файл не коммитится. Затем:
```sh
docker compose --env-file .env up -d --build
```
Миграция `src/Messenger/Migrations/001_init.sql` применяется при старте API и повторно ничего не создаёт. Готовность: `GET http://127.0.0.1:8080/health/ready` возвращает `{"status":"ok"}`.
```sh
python tests/smoke.py --base-url http://127.0.0.1:8080
dotnet test src/Messenger.slnx
```
Перезапуск API и PostgreSQL без удаления volume:
```sh
sh scripts/restart.sh
```
На Windows этот `.sh` напрямую не запускается. Та же команда: `docker compose --env-file .env restart postgres api`.
Остановка без удаления данных: `docker compose --env-file .env stop`. Удаление учебных данных: `docker compose --env-file .env down -v`.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
Из lab1 перенесены пользователи, чаты, членство, сообщения, cursor и формат ошибок. Хранилище в памяти заменено на PostgreSQL. Redis не используется: для оценки 3 сессии лежат в PostgreSQL.
`SESSION_STORE=postgres`. `DATABASE_URL` задаёт Npgsql-строку внутри compose. `DATABASE_URL_FILE` из `.env.example` тоже читается, если переменной нет. `SESSION_TTL_SECONDS` по умолчанию 3600. `APP_HOST`, `APP_PORT`, `APP_ENV` те же, что в lab1.
Пароль хешируется Argon2id (память 19 МиБ, 2 итерации, parallelism 1). В ответе пользователя пароля нет. Токен сессии — 32 случайных байта. В базе хранится только SHA-256 токена, срок `expires_at` и `revoked_at`. Перезапуск срок не продлевает.
`POST /auth/sessions` принимает только Basic. Остальные защищённые маршруты принимают только Bearer. `X-User-Id` не даёт доступ и не подменяет сессию. Создание чата — одна транзакция: проверка участников, вставка чата и членства. Повторный username ловится уникальным ограничением и возвращает 409.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Публичный smoke | `python tests/smoke.py --base-url http://127.0.0.1:8080` | PASS | evidence/smoke.txt |
| Свои проверки входа, logout и пустого сообщения | `dotnet test src/Messenger.slnx` | 3 пройдено, 0 провалено | evidence/dotnet-test.txt |
| Рестарт API и PostgreSQL сохраняет сессию и сообщение | `docker compose --env-file .env restart postgres api`, затем тот же Bearer | PASS, 1.558 с, сообщение на месте | evidence/persistence.txt |
| Миграция при старте, логи без текста сообщений и пароля | `docker logs` контейнера API | migrations=True, утечек нет | evidence/logs.txt |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
Проверялось 2026-11-13, Docker Desktop, compose-проект `2`.
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| `docker compose restart postgres api` | тот же токен читает те же данные, volume не стирается | `/health/ready` = 200, `/users/me` тот же пользователь, сообщение на месте | около 1.6 с; подтверждённые данные сохранены |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
Оценка 3 не включает Redis/Valkey, EXPLAIN и отдельную проверку недоступности кэша. Если PostgreSQL не отвечает, `/health/ready` и запросы к данным возвращают 503. Два процесса API в этой работе не запускаются: одна база уже общая, но горизонтальное масштабирование — лабораторная 3. `scripts/restart.sh` рассчитан на `sh`; на Windows его выполняет `docker compose restart`.
+33
View File
@@ -0,0 +1,33 @@
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}
DATABASE_URL: Host=postgres;Port=5432;Username=messenger;Password=${POSTGRES_PASSWORD};Database=messenger;Timeout=5;Command Timeout=5
ports:
- "127.0.0.1:8080:8080"
depends_on:
postgres:
condition: service_healthy
volumes:
pgdata:
+1
View File
@@ -0,0 +1 @@
Пройден: не пройдено 0, пройдено 3, пропущено 0, всего 3. Messenger.Tests.dll
+3
View File
@@ -0,0 +1,3 @@
leak_message=False
leak_password=False
migrations=True
+3
View File
@@ -0,0 +1,3 @@
PASS persistence restart_seconds=1.558 same_token=true message_kept=true
docker compose restart postgres api
volumes preserved
+1
View File
@@ -0,0 +1 @@
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
+6
View File
@@ -0,0 +1,6 @@
{
"sdk": {
"version": "10.0.401",
"rollForward": "latestFeature"
}
}
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
docker compose --env-file .env restart postgres api
+162
View File
@@ -0,0 +1,162 @@
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<Program>
{
}
public sealed class ApiTests : IClassFixture<MessengerFactory>
{
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<string, string>
{
["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<string, string>
{
["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<string, string>
{
["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<string, string>
{
["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 Post($"/api/v1/chats/{chat.GetProperty("id").GetString()}/messages", """{"text":" "}""", token);
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<string, string>
{
["Authorization"] = "Basic " + basic
}), HttpStatusCode.Created);
return (session.GetProperty("user").GetProperty("id").GetString()!, session.GetProperty("token").GetString()!);
}
private Task<HttpResponseMessage> Post(string path, string json, string? token = null) =>
Send(HttpMethod.Post, path, json, token);
private async Task<HttpResponseMessage> Send(
HttpMethod method,
string path,
string? json = null,
string? token = null,
Dictionary<string, string>? 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<JsonElement> 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());
}
}
@@ -0,0 +1,19 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net10.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>enable</ImplicitUsings>
<IsPackable>false</IsPackable>
<IsTestProject>true</IsTestProject>
</PropertyGroup>
<ItemGroup>
<FrameworkReference Include="Microsoft.AspNetCore.App" />
<PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="10.0.12" />
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
<PackageReference Include="xunit" Version="2.9.3" />
<PackageReference Include="xunit.runner.visualstudio" Version="2.8.2" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Messenger\Messenger.csproj" />
</ItemGroup>
</Project>
+4
View File
@@ -0,0 +1,4 @@
<Solution>
<Project Path="Messenger.Tests/Messenger.Tests.csproj" />
<Project Path="Messenger/Messenger.csproj" />
</Solution>
+443
View File
@@ -0,0 +1,443 @@
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;
public Db(string connectionString, TimeSpan sessionTtl)
{
var builder = new NpgsqlDataSourceBuilder(connectionString);
builder.ConnectionStringBuilder.MaxPoolSize = 20;
builder.ConnectionStringBuilder.Timeout = 5;
builder.ConnectionStringBuilder.CommandTimeout = 5;
_dataSource = builder.Build();
_sessionTtl = sessionTtl;
}
public async Task<bool> 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<UserRecord?> 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<UserRecord?> 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<UserRecord?> 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<UserRecord?> 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<bool> 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<Guid> memberIds, CancellationToken cancellationToken = default)
{
await using var connection = await _dataSource.OpenConnectionAsync(cancellationToken);
await using var tx = await connection.BeginTransactionAsync(cancellationToken);
var seen = new HashSet<Guid>();
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<ChatRecord?> 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<ChatRecord> 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<ChatRecord>();
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<ChatRecord>(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?> AddMessage(Guid chatId, Guid senderId, string text, CancellationToken cancellationToken = default)
{
var message = new MessageRecord(Guid.NewGuid(), chatId, senderId, text, Clock.Truncate(DateTime.UtcNow));
const string sql = """
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
""";
await using var connection = await _dataSource.OpenConnectionAsync(cancellationToken);
await using var command = new NpgsqlCommand(sql, connection);
command.Parameters.AddWithValue(message.Id);
command.Parameters.AddWithValue(message.ChatId);
command.Parameters.AddWithValue(message.SenderId);
command.Parameters.AddWithValue(message.Text);
command.Parameters.AddWithValue(message.CreatedAt);
var id = await command.ExecuteScalarAsync(cancellationToken);
return id is null ? null : message;
}
public async Task<(IReadOnlyList<MessageRecord> 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<MessageRecord>();
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<Guid[]> 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<Guid>();
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<DateTimeOffset>(ordinal).UtcDateTime;
return Clock.Truncate(value);
}
private static byte[] TokenHash(string token) => SHA256.HashData(Encoding.UTF8.GetBytes(token));
private static IEnumerable<string> 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;
}
}
}
}
+17
View File
@@ -0,0 +1,17 @@
<Project Sdk="Microsoft.NET.Sdk.Web">
<PropertyGroup>
<TargetFramework>net10.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>enable</ImplicitUsings>
<InvariantGlobalization>true</InvariantGlobalization>
<TreatWarningsAsErrors>true</TreatWarningsAsErrors>
<RootNamespace>Messenger</RootNamespace>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Konscious.Security.Cryptography.Argon2" Version="1.3.1" />
<PackageReference Include="Npgsql" Version="9.0.4" />
</ItemGroup>
<ItemGroup>
<Content Include="Migrations\*.sql" CopyToOutputDirectory="PreserveNewest" />
</ItemGroup>
</Project>
+45
View File
@@ -0,0 +1,45 @@
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);
+281
View File
@@ -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<byte> utf8)
{
var reader = new Utf8JsonReader(utf8, new JsonReaderOptions
{
CommentHandling = JsonCommentHandling.Disallow,
AllowTrailingCommas = false,
MaxDepth = 16
});
var seen = new Stack<HashSet<string>>();
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<string>(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<Guid>? 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<string> 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<ChatDto> Items,
[property: JsonPropertyName("next_cursor")] string? NextCursor);
public sealed record MessagePageDto(
[property: JsonPropertyName("items")] IReadOnlyList<MessageDto> 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);
}
+56
View File
@@ -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);
}
}
+600
View File
@@ -0,0 +1,600 @@
using System.Globalization;
using System.Net;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
namespace Messenger;
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<HostOptions>(options => options.ShutdownTimeout = TimeSpan.FromSeconds(5));
builder.WebHost.ConfigureKestrel(options =>
{
options.AddServerHeader = false;
options.Limits.MaxRequestBodySize = JsonIO.MaxBodyBytes;
});
var ttlSeconds = ReadTtl();
builder.Services.AddSingleton(new Db(ReadDatabaseUrl(), TimeSpan.FromSeconds(ttlSeconds)));
builder.Services.AddSingleton<ReadinessState>();
builder.Services.AddHostedService<DatabaseStartup>();
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<ReadinessState>();
var log = app.Logger;
app.Lifetime.ApplicationStopping.Register(() =>
{
readiness.Close();
log.LogInformation("shutdown: новые запросы больше не обслуживаются");
});
app.Use(async (ctx, next) =>
{
var requestId = Guid.NewGuid().ToString("D");
ctx.Response.Headers["X-Request-Id"] = requestId;
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()
{
var text = Environment.GetEnvironmentVariable("SESSION_TTL_SECONDS");
if (string.IsNullOrWhiteSpace(text))
return 3600;
if (!int.TryParse(text, NumberStyles.None, CultureInfo.InvariantCulture, out var seconds) || seconds < 1)
throw new InvalidOperationException("SESSION_TTL_SECONDS 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<DatabaseStartup> 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<IResult> 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<IResult> CreateUser(HttpContext ctx, Db db, ILogger<Program> log)
{
var (status, body) = await Read<CreateUserBody>(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<IResult> CreateSession(HttpContext ctx, Db db, ILogger<Program> 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<IResult> RevokeSession(HttpContext ctx, Db db, ILogger<Program> 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<IResult> 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<IResult> CreateChat(HttpContext ctx, Db db, ILogger<Program> log)
{
var actor = await TryActor(ctx, db);
if (actor.User is null)
return actor.Error!;
var user = actor.User;
var (status, body) = await Read<CreateChatBody>(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<IResult> 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<IResult> 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<IResult> CreateMessage(string chatId, HttpContext ctx, Db db, ILogger<Program> 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", "Чат не найден");
var (status, body) = await Read<CreateMessageBody>(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 = await db.AddMessage(id, user.Id, body.Text!, ctx.RequestAborted);
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<IResult> 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 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<Actor> 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<T>(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<T>(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));
}