Files
mtusi2026lab3/tools/ScaleLoad/Program.cs
T

210 lines
10 KiB
C#

using System.Diagnostics;
using System.Net.Http.Headers;
using System.Net.Http.Json;
using System.Text;
using System.Text.Json;
// Генератор нагрузки для трека 1 (цена масштабирования). Замкнутый цикл: каждый из --clients потоков шлёт запрос,
// ждёт ответ и сразу шлёт следующий. Профиль: --write-ratio доля POST сообщения (уникальный Idempotency-Key),
// остальное — GET страницы истории (limit=50). У каждого пользователя свой чат с --history сообщений,
// поэтому записи разных клиентов не сериализуются на одной строке чата.
//
// Запуск (стенд поднят):
// dotnet run -c Release --project tools/ScaleLoad -- --url http://localhost:8081 --clients 64 --duration 20 \
// --label A-2x1.0 --output evidence/track1/results.jsonl
// Загрузка CPU контейнеров снимается `docker stats` во время измерения (если доступен docker CLI).
var o = ParseArguments(args);
string Get(string k, string d) => o.TryGetValue(k, out var v) ? v : d;
var url = Get("url", "http://localhost:8080");
var clients = int.Parse(Get("clients", "32"));
var users = int.Parse(Get("users", "32"));
var history = int.Parse(Get("history", "200"));
var duration = TimeSpan.FromSeconds(double.Parse(Get("duration", "20")));
var warmup = TimeSpan.FromSeconds(double.Parse(Get("warmup", "5")));
var writeRatio = double.Parse(Get("write-ratio", "0.2"), System.Globalization.CultureInfo.InvariantCulture);
var label = Get("label", "run");
var output = o.GetValueOrDefault("output");
var project = Get("compose-project", "messenger-lab3");
var handler = new SocketsHttpHandler { MaxConnectionsPerServer = clients * 2, PooledConnectionLifetime = TimeSpan.FromMinutes(5) };
using var http = new HttpClient(handler) { BaseAddress = new Uri(url), Timeout = TimeSpan.FromSeconds(30) };
Console.Error.WriteLine($"[1/4] prepare: {users} users, {history} messages per chat");
var actors = await Prepare(http, users, history);
Console.Error.WriteLine($"[2/4] warm-up {warmup.TotalSeconds}s, {clients} clients");
await Measure(http, actors, clients, warmup, writeRatio);
Console.Error.WriteLine($"[3/4] measure {duration.TotalSeconds}s");
using var statsCts = new CancellationTokenSource();
var statsTask = Task.Run(() => SampleDockerStats(project, statsCts.Token));
var r = await Measure(http, actors, clients, duration, writeRatio);
statsCts.Cancel();
var stats = await statsTask;
Console.Error.WriteLine("[4/4] results");
var lat = r.Latencies.OrderBy(x => x).ToArray();
double P(double p) => lat.Length == 0 ? double.NaN : Math.Round(lat[Math.Max(0, (int)Math.Ceiling(p * lat.Length) - 1)], 2);
var report = new Dictionary<string, object?>
{
["label"] = label,
["timestamp"] = DateTimeOffset.UtcNow.ToString("O"),
["clients"] = clients, ["users"] = users, ["history"] = history, ["write_ratio"] = writeRatio,
["duration_s"] = Math.Round(r.Elapsed, 2),
["ok"] = lat.Length, ["errors"] = r.Errors, ["ok_get"] = r.OkGet, ["ok_post"] = r.OkPost,
["rps"] = Math.Round(lat.Length / r.Elapsed, 1),
["p50_ms"] = P(0.50), ["p95_ms"] = P(0.95), ["p99_ms"] = P(0.99),
["cpu_pct"] = stats,
};
var line = JsonSerializer.Serialize(report);
Console.WriteLine(line);
if (output is not null)
{
Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(output))!);
File.AppendAllText(output, line + Environment.NewLine);
}
return r.Errors == 0 ? 0 : 1;
static async Task<Actor[]> Prepare(HttpClient http, int users, int history)
{
var result = new Actor[users];
await Parallel.ForEachAsync(Enumerable.Range(0, users), new ParallelOptions { MaxDegreeOfParallelism = 4 }, async (i, ct) =>
{
var username = "sl" + Guid.NewGuid().ToString("N")[..14];
var password = "Load-" + Guid.NewGuid().ToString("N");
using var reg = await http.PostAsJsonAsync("/api/v1/users", new { username, display_name = "Load", password }, ct);
reg.EnsureSuccessStatusCode();
var me = (await reg.Content.ReadFromJsonAsync<JsonElement>(ct)).GetProperty("id").GetGuid();
using var login = new HttpRequestMessage(HttpMethod.Post, "/api/v1/auth/sessions");
login.Headers.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.UTF8.GetBytes($"{username}:{password}")));
using var loginResponse = await http.SendAsync(login, ct);
loginResponse.EnsureSuccessStatusCode();
var token = (await loginResponse.Content.ReadFromJsonAsync<JsonElement>(ct)).GetProperty("token").GetString()!;
using var chatRequest = Authorized(HttpMethod.Post, "/api/v1/chats", token);
chatRequest.Content = JsonContent.Create(new { title = "Load", member_ids = new[] { me } });
using var chatResponse = await http.SendAsync(chatRequest, ct);
chatResponse.EnsureSuccessStatusCode();
var chatId = (await chatResponse.Content.ReadFromJsonAsync<JsonElement>(ct)).GetProperty("id").GetGuid();
for (var m = 0; m < history; m++)
{
using var post = PostMessage(chatId, token, $"history {m}");
using var response = await http.SendAsync(post, ct);
response.EnsureSuccessStatusCode();
}
result[i] = new Actor(token, chatId);
});
return result;
}
static HttpRequestMessage Authorized(HttpMethod method, string path, string token)
{
var request = new HttpRequestMessage(method, path);
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token);
return request;
}
static HttpRequestMessage PostMessage(Guid chatId, string token, string text)
{
var request = Authorized(HttpMethod.Post, $"/api/v1/chats/{chatId}/messages", token);
request.Headers.Add("Idempotency-Key", Guid.NewGuid().ToString("N"));
request.Content = JsonContent.Create(new { text });
return request;
}
static async Task<Result> Measure(HttpClient http, Actor[] actors, int clients, TimeSpan duration, double writeRatio)
{
var started = Stopwatch.GetTimestamp();
var deadline = started + (long)(duration.TotalSeconds * Stopwatch.Frequency);
var workers = Enumerable.Range(0, clients).Select(i => Task.Run(async () =>
{
var actor = actors[i % actors.Length];
var rnd = new Random(i * 7919 + Environment.TickCount);
var latencies = new List<double>();
int errors = 0, okGet = 0, okPost = 0;
while (Stopwatch.GetTimestamp() < deadline)
{
var write = rnd.NextDouble() < writeRatio;
var t = Stopwatch.GetTimestamp();
try
{
using var request = write
? PostMessage(actor.ChatId, actor.Token, "load " + Guid.NewGuid().ToString("N"))
: Authorized(HttpMethod.Get, $"/api/v1/chats/{actor.ChatId}/messages?limit=50", actor.Token);
using var response = await http.SendAsync(request);
await response.Content.ReadAsByteArrayAsync();
if (response.IsSuccessStatusCode)
{
latencies.Add(Stopwatch.GetElapsedTime(t).TotalMilliseconds);
if (write) okPost++; else okGet++;
}
else
{
errors++;
}
}
catch (Exception ex) when (ex is HttpRequestException or TaskCanceledException)
{
errors++;
}
}
return (latencies, errors, okGet, okPost);
})).ToArray();
var results = await Task.WhenAll(workers);
return new Result(
results.SelectMany(x => x.latencies).ToList(), results.Sum(x => x.errors),
results.Sum(x => x.okGet), results.Sum(x => x.okPost), Stopwatch.GetElapsedTime(started).TotalSeconds);
}
// Средняя загрузка CPU (в % одного ядра, как в docker stats) по роли контейнера за время измерения.
static async Task<Dictionary<string, double>> SampleDockerStats(string project, CancellationToken ct)
{
var sums = new Dictionary<string, (double Sum, int N)>();
try
{
while (!ct.IsCancellationRequested)
{
var info = new ProcessStartInfo("docker", ["stats", "--no-stream", "--format", "{{.Name}} {{.CPUPerc}}"])
{ RedirectStandardOutput = true, RedirectStandardError = true };
using var p = Process.Start(info)!;
var text = await p.StandardOutput.ReadToEndAsync(ct);
await p.WaitForExitAsync(ct);
// Внутри одного снимка суммируем реплики одной роли, затем усредняем снимки.
var snapshot = new Dictionary<string, double>();
foreach (var line in text.Split('\n', StringSplitOptions.RemoveEmptyEntries))
{
var parts = line.Trim().Split(' ');
if (parts.Length < 2 || !parts[0].StartsWith(project + "-")) continue;
var role = parts[0][(project.Length + 1)..];
role = role[..role.LastIndexOf('-')];
if (!double.TryParse(parts[1].TrimEnd('%'), System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var cpu)) continue;
snapshot[role] = snapshot.GetValueOrDefault(role) + cpu;
}
foreach (var (role, cpu) in snapshot)
{
var (sum, n) = sums.GetValueOrDefault(role);
sums[role] = (sum + cpu, n + 1);
}
}
}
catch (OperationCanceledException) { }
catch (Exception) { }
return sums.ToDictionary(kv => kv.Key, kv => Math.Round(kv.Value.Sum / Math.Max(1, kv.Value.N), 1));
}
static Dictionary<string, string> ParseArguments(string[] args)
{
var result = new Dictionary<string, string>();
for (var i = 0; i < args.Length; i++)
{
if (!args[i].StartsWith("--") || i + 1 >= args.Length) throw new ArgumentException($"Bad argument: {args[i]}");
result[args[i][2..]] = args[++i];
}
return result;
}
internal sealed record Actor(string Token, Guid ChatId);
internal sealed record Result(List<double> Latencies, int Errors, int OkGet, int OkPost, double Elapsed);