Rolling update trên Swarm: lên 1.5.0 không cắt lệnh, bản lỗi tự rollback

#:package YamlDotNet@18.1.0
// KiemStack.cs: luật mà docker stack config không kiểm. Mã thoát = số vi phạm, dùng được trong CI.
// docker stack config -c banhang-api.stack.yml > render.yml
// dotnet run KiemStack.cs -- render.yml [Dockerfile]
using System.Text.RegularExpressions;
using YamlDotNet.RepresentationModel;

const double ShutdownTimeout = 15, KiemTraTimeout = 2, Gossip = 2, TreoToiDa = 20;   // theo BanHang.Api.cs và bài 2
string[] khoaCanCo = ["ConnectionStrings__BanHang", "BHPay__ApiKey"];                // khóa app đọc qua KeyPerFile
var biMat = new Regex(@"(?i)(password|pwd)\s*=|bhpay_\w+_sk_|api_?key|secret");
var loi = new List<string>();
var yaml = new YamlStream(); yaml.Load(new StreamReader(args[0]));
var goc = (YamlMappingNode)yaml.Documents[0].RootNode;

foreach (var (tenNode, svNode) in (YamlMappingNode)goc["services"])
{
    var sv = (YamlMappingNode)svNode; string ten = tenNode.ToString();
    string? Lay(params string[] duong)
    {
        YamlNode n = sv;
        foreach (var d in duong) { if (n is not YamlMappingNode m || !m.Children.TryGetValue(d, out var con)) return null; n = con; }
        return n.ToString();
    }
    void Phai(bool dung, string thongBao) { if (!dung) loi.Add($"{ten}: {thongBao}"); }

    // 1. Giá trị liệt kê: docker stack config để lọt "rollbak"
    Phai(Lay("deploy", "update_config", "order") is null or "start-first" or "stop-first", "update_config.order sai");
    Phai(Lay("deploy", "update_config", "failure_action") is null or "pause" or "continue" or "rollback", "update_config.failure_action sai");
    Phai(Lay("deploy", "rollback_config", "failure_action") is null or "pause" or "continue", "rollback_config.failure_action sai");
    Phai(Lay("deploy", "restart_policy", "condition") is null or "none" or "on-failure" or "any", "restart_policy.condition sai");

    // 2. Docker phải chờ lâu hơn .NET: grace > ShutdownTimeout + RutChoGiay + 1 s
    double grace = Giay(Lay("stop_grace_period") ?? "10s");
    double rut = double.Parse(Lay("environment", "RutChoGiay") ?? "0");
    Phai(grace > ShutdownTimeout + rut + 1, $"stop_grace_period {grace} s phải lớn hơn {ShutdownTimeout + rut + 1} s");

    // 3. Healthcheck: có, không dựa vào curl/wget (image ASP.NET Core không có), timeout dài hơn KiemTra
    var test = (sv.Children.TryGetValue("healthcheck", out var hc) && ((YamlMappingNode)hc).Children.TryGetValue("test", out var tt))
        ? ((YamlSequenceNode)tt).Select(x => x.ToString()).ToArray() : [];
    Phai(test.Length > 1 && test[0] != "NONE", "thiếu healthcheck: task vào mesh trước khi Kestrel mở cổng");
    Phai(!test.Any(x => x.Contains("curl") || x.Contains("wget")), "healthcheck dùng curl/wget");
    double interval = Giay(Lay("healthcheck", "interval") ?? "30s"), timeout = Giay(Lay("healthcheck", "timeout") ?? "30s");
    int retries = int.Parse(Lay("healthcheck", "retries") ?? "3");
    Phai(timeout > KiemTraTimeout, $"healthcheck.timeout {timeout} s phải lớn hơn {KiemTraTimeout} s của KiemTra");

    // 4. Task treo sau TreoToiDa giây phải bị phát hiện trong monitor, trước khi slot sau được cập nhật
    double phatHien = TreoToiDa + retries * (interval + KiemTraTimeout) + Gossip + grace;
    Phai(Lay("deploy", "update_config", "failure_action") == "rollback", "update_config.failure_action phải là rollback");
    Phai(Giay(Lay("deploy", "update_config", "monitor") ?? "5s") >= phatHien, $"update_config.monitor phải từ {phatHien} s");
    Phai(Giay(Lay("deploy", "update_config", "delay") ?? "0s") >= phatHien, $"update_config.delay phải từ {phatHien} s");

    // 5. Bí mật không nằm trong biến môi trường; secret có đủ khóa app cần
    if (sv.Children.TryGetValue("environment", out var env))
        foreach (var (k, v) in (YamlMappingNode)env)
            Phai(!biMat.IsMatch(k.ToString()) && !biMat.IsMatch(v.ToString()), $"biến môi trường {k} chứa bí mật");
    var dich = sv.Children.TryGetValue("secrets", out var sc)
        ? ((YamlSequenceNode)sc).Select(x => x is YamlMappingNode m && m.Children.TryGetValue("target", out var tg) ? tg.ToString() : x.ToString()).ToHashSet() : [];
    foreach (var k in khoaCanCo) Phai(dich.Contains(k), $"thiếu secret có target {k}");
}
if (args.Length > 1)   // Dockerfile: ENV/ARG mang bí mật thì nằm trong mọi bản image
    foreach (var (dong, so) in File.ReadLines(args[1]).Select((d, i) => (d.Trim(), i + 1)))
        if (Regex.IsMatch(dong, @"^(ENV|ARG)\s", RegexOptions.IgnoreCase) && biMat.IsMatch(dong))
            loi.Add($"Dockerfile dòng {so}: {dong.Split(' ', '=')[0]} {dong.Split(' ', 3)[1].Split('=')[0]} mang bí mật vào image");

foreach (var l in loi) Console.WriteLine("VI PHẠM " + l);
Console.WriteLine($"{loi.Count} vi phạm");
return loi.Count;

static double Giay(string s) => Regex.Matches(s, @"([\d.]+)(h|ms|m|s)").Sum(m =>
    double.Parse(m.Groups[1].Value, System.Globalization.CultureInfo.InvariantCulture) *
    m.Groups[2].Value switch { "h" => 3600, "m" => 60, "ms" => 0.001, _ => 1 });

// MoHinhCapNhat.cs: mô hình cập nhật 4 replica 1.4.0 lên 1.5.0 trên Swarm. Không phải cụm thật.
// dotnet run MoHinhCapNhat.cs -- [giây khởi động tới mở cổng] [giây dừng .NET khi rảnh]
// Luật lấy từ mã nguồn, nhánh master ngày 2026-10-04:
//  - swarmkit update/updater.go: từng slot theo parallelism; start-first gỡ task cũ khi task mới RUNNING;
//    stop-first chờ task cũ dừng mới chạy task mới; task của lần cập nhật kết thúc khi chưa RUNNING hoặc
//    trong monitor kể từ lúc RUNNING là một lỗi; lỗi/số slot > max_failure_ratio thì pause hoặc rollback;
//    hết slot thì canh thêm monitor, monitor = delay + 1 s nếu delay >= monitor.
//  - moby executor/container/controller.go: có healthcheck thì task RUNNING và vào mesh khi healthy, không có
//    thì ngay khi container chạy; dừng task: gỡ khỏi mesh, chờ 2 s, SIGTERM, quá stop_grace_period thì SIGKILL;
//    unhealthy thì dừng task như trên, task kết thúc lúc tiến trình thoát.
//  - moby daemon/health.go: lần kiểm đầu sau start_interval, trong start_period chỉ dùng start_interval khi còn
//    "starting"; lỗi trong start_period khi chưa từng khỏe không tính; retries lỗi liên tiếp là unhealthy.
//  - swarmkit restart/restart.go: task hỏng được thay sau restart delay 5 s, theo spec hiện tại của service.
// Giả định của mô hình: container chạy 1 s sau khi task được tạo (image có sẵn), 300 request/s chia vòng tròn cho
// task trong mesh, 1 trên 50 request là lệnh gọi đối tác (BHPay, ký hóa đơn) dài 1–14 s, còn lại 50 ms; bản lỗi treo 20 s sau khi mở cổng.
double khoiDong = args.Length > 0 ? double.Parse(args[0]) : 1.817;   // trung vị tới live 200, DoKhoiDong.cs ở bài 1
double dungNet = args.Length > 1 ? double.Parse(args[1]) : 0.06;   // dừng lúc rảnh, DungMem.cs
var cauHinh = new CauHinh[]
{
    new("Mặc định Swarm",           Hc: false, StartFirst: false, Delay: 0,  Monitor: 5,  Rollback: false, Grace: 10),
    new("+ healthcheck",            Hc: true,  StartFirst: false, Delay: 0,  Monitor: 5,  Rollback: false, Grace: 10),
    new("+ start-first, grace 20 s",Hc: true,  StartFirst: true,  Delay: 0,  Monitor: 5,  Rollback: false, Grace: 20),
    new("+ rollback, monitor 90 s", Hc: true,  StartFirst: true,  Delay: 0,  Monitor: 90, Rollback: true,  Grace: 20),
    new("+ delay 90 s (chọn)",      Hc: true,  StartFirst: true,  Delay: 90, Monitor: 90, Rollback: true,  Grace: 20),
};
Console.WriteLine($"Khởi động tới mở cổng {khoiDong:F2} s, .NET dừng khi rảnh {dungNet:F2} s, 15 phút đầu");
Console.WriteLine($"{"cấu hình",-27}{"bản",-5}{"từ chối",8}{"bị cắt",7}{"treo",7}{"không task",11}{"ít nhất",8}{"0 task tốt",11}{"slot lỗi",9}{"kết thúc",20}");
var chuoi = new Dictionary<string, List<(double t, int tot)>>();
foreach (var ch in cauHinh)
    foreach (bool loi in new[] { false, true })
    {
        var mp = new MoPhong(ch, loi, khoiDong, dungNet); var kq = mp.Chay();
        if (loi) chuoi[ch.Ten] = mp.ChuoiTot;
        Console.WriteLine($"{ch.Ten,-27}{(loi ? "lỗi" : "tốt"),-5}{kq.TuChoi,8}{kq.BiCat,7}{kq.Treo,7}{kq.KhongTask,11}{kq.ItNhat + "/4",8}{kq.GiayKhongTot,10:F0}s{kq.SlotLoi,9}{kq.KetThuc,20}");
    }

Console.WriteLine();
Console.WriteLine("Số task tốt trong mesh, bản lỗi, mỗi 10 s từ 0 đến 120 s:");
foreach (var (ten, c) in chuoi) Console.WriteLine($"{ten,-27}{string.Join(",", c.Select(x => x.tot))}");

record CauHinh(string Ten, bool Hc, bool StartFirst, double Delay, double Monitor, bool Rollback, double Grace);
record KetQua(int TuChoi, int BiCat, int Treo, int KhongTask, int ItNhat, double GiayKhongTot, int SlotLoi, string KetThuc);

sealed class Task1(int slot, bool banMoi, bool loi, double tao, double chay)
{
    public int Slot = slot; public bool BanMoi = banMoi, Loi = loi;
    public double Tao = tao, Chay = chay;                 // Chay: lúc container chạy (NaN: đang chờ task cũ dừng)
    public double MoCong = double.NaN, Treo = double.PositiveInfinity, Running = double.NaN;
    public bool TrongMesh, MuonDung, KetThuc;
    public double GoMesh = double.NaN, Sigterm = double.NaN, Kill = double.NaN, Thoat = double.NaN;
    // healthcheck
    public double KiemTiep = double.NaN; public int ChuoiLoi; public bool TungKhoe, KhongKhoe;
    public List<(double ketThuc, int id)> DangXuLy = [];
}

sealed class MoPhong(CauHinh ch, bool banLoi, double khoiDong, double dungNet)
{
    const double Dt = 0.01, HetGio = 900, TaiReq = 300, ChayContainer = 1, TreoSau = 20, ShutdownTimeout = 15;
    const double Interval = 5, Timeout = 2, StartPeriod = 60, StartInterval = 1, ChayKiem = 0.1, RestartDelay = 5, Gossip = 2;
    const int Retries = 3;
    readonly List<Task1> tasks = [];
    double t;
    int tuChoi, biCat, treo, khongTask, vong, reqId;
    int itNhat = 4; double giayKhongTot; int slotLoi;
    // updater: danh sách slot cần cập nhật, cấu hình đang dùng, spec hiện tại của service
    bool specMoi = true, dangRollback, dungCapNhat; string ketThuc = ""; double phatHien = double.NaN;
    Queue<int> slotCho = new(); Task1? moi, cu; double choDelayToi = double.NaN, monitorHet = double.NaN;
    readonly Dictionary<Task1, double> taskCapNhat = [];   // task do updater tạo -> lúc RUNNING (NaN nếu chưa)
    readonly List<(double luc, int slot)> restartCho = [];
    public readonly List<(double t, int tot)> ChuoiTot = [];   // số task tốt trong mesh, mỗi 10 s

    public KetQua Chay()
    {
        for (int s = 0; s < 4; s++) { var k = new Task1(s, false, false, -30, -30); BatDau(k); k.Chay = -29; k.MoCong = -28; k.Running = -27; k.TrongMesh = true; k.TungKhoe = true; k.KiemTiep = 0; tasks.Add(k); }
        for (int s = 0; s < 4; s++) slotCho.Enqueue(s);
        double denReq = 0;
        for (int buoc = 0; buoc * Dt < HetGio; buoc++)
        {
            t = buoc * Dt;
            BuocUpdater();
            ChayKhiCuDung();
            foreach (var k in tasks.ToArray()) BuocTask(k);
            BuocRestart();
            for (; denReq <= t; denReq += 1 / TaiReq) GuiRequest();
            int tot = tasks.Count(k => k.TrongMesh && !k.KetThuc && t >= k.MoCong && t < k.Treo);
            itNhat = Math.Min(itNhat, tot);
            if (tot == 0) giayKhongTot += Dt;
            if (buoc % 1000 == 0 && t <= 120) ChuoiTot.Add((t, tot));
        }
        slotLoi = tasks.Where(k => k.Loi && !double.IsNaN(k.Running)).Select(k => k.Slot).Distinct().Count();
        if (ketThuc == "") ketThuc = dungCapNhat ? "dừng giữa chừng" : "chưa xong";
        return new(tuChoi, biCat, treo, khongTask, itNhat, giayKhongTot, slotLoi, ketThuc);
    }

    void BatDau(Task1 k) { k.Chay = t + ChayContainer; k.MoCong = k.Chay + khoiDong; if (k.Loi) k.Treo = k.MoCong + TreoSau; k.KiemTiep = k.Chay + StartInterval; }

    Task1 TaoTask(int slot, bool choCuDung)
    {
        bool moiSpec = specMoi;
        var k = new Task1(slot, moiSpec, moiSpec && banLoi, t, double.NaN);
        if (!choCuDung) BatDau(k);
        tasks.Add(k);
        return k;
    }

    void YeuCauDung(Task1 k)
    {
        if (k.MuonDung || k.KetThuc) return;
        k.MuonDung = true;
        if (double.IsNaN(k.Chay)) { k.KetThuc = true; k.Thoat = t; return; }   // chưa chạy thì bỏ luôn
        k.TrongMesh = false; k.GoMesh = t; k.Sigterm = t + Gossip; k.Kill = k.Sigterm + ch.Grace;
    }

    void BuocTask(Task1 k)
    {
        if (k.KetThuc) return;
        if (double.IsNaN(k.Chay)) return;   // stop-first: chờ task cũ dừng
        if (t < k.Chay) return;
        // healthcheck theo daemon/health.go
        if (ch.Hc && !k.MuonDung && t >= k.KiemTiep)
        {
            bool ok = t >= k.MoCong && t < k.Treo;
            double tg = t >= k.Treo ? Timeout : ChayKiem;     // treo: KiemTra chờ hết 2 s
            if (ok) { k.ChuoiLoi = 0; k.TungKhoe = true; }
            else if (k.TungKhoe || t - k.Chay >= StartPeriod) { if (++k.ChuoiLoi >= Retries) k.KhongKhoe = true; }
            double ke = (t - k.Chay < StartPeriod && !k.TungKhoe) ? StartInterval : Interval;
            k.KiemTiep = t + tg + ke;
            if (ok && double.IsNaN(k.Running)) { k.Running = t + tg; k.TrongMesh = true; DanhDauRunning(k); }
            if (k.KhongKhoe) YeuCauDung(k);    // controller.Wait: unhealthy thì Shutdown
        }
        if (!ch.Hc && double.IsNaN(k.Running)) { k.Running = k.Chay; k.TrongMesh = true; DanhDauRunning(k); }
        // dừng: SIGTERM rồi .NET xả request; quá ShutdownTimeout thì cắt; quá grace thì SIGKILL
        if (!double.IsNaN(k.Sigterm) && t >= k.Sigterm)
        {
            bool treo = t >= k.Treo;
            double xong = k.DangXuLy.Count == 0 ? k.Sigterm + dungNet : Math.Max(k.DangXuLy.Max(r => r.ketThuc), k.Sigterm + dungNet);
            double hanNet = k.Sigterm + ShutdownTimeout + dungNet;
            double thoat = treo ? k.Kill : Math.Min(Math.Min(xong, hanNet), k.Kill);
            if (t >= thoat)
            {
                foreach (var r in k.DangXuLy) if (r.ketThuc > t) biCat++;
                k.DangXuLy.Clear();
                k.KetThuc = true; k.Thoat = t;
                TaskKetThuc(k);
                return;
            }
        }
        // request xong hoặc kẹt khi tiến trình treo
        if (t >= k.Treo) { treo += k.DangXuLy.Count; k.DangXuLy.Clear(); }
        else k.DangXuLy.RemoveAll(r => r.ketThuc <= t);
    }

    void GuiRequest()
    {
        int id = reqId++;
        double dai = id % 50 == 0 ? 1 + (id / 50) % 14 : 0.05;   // lệnh gọi đối tác 1–14 s
        var mesh = tasks.Where(k => k.TrongMesh && !k.KetThuc).ToArray();
        if (mesh.Length == 0) { khongTask++; return; }
        var k = mesh[vong++ % mesh.Length];
        if (t < k.MoCong) { tuChoi++; return; }         // trong mesh nhưng Kestrel chưa nghe: kết nối bị từ chối
        if (t >= k.Treo) { treo++; return; }
        k.DangXuLy.Add((t + dai, id));
    }

    void DanhDauRunning(Task1 k) { if (taskCapNhat.ContainsKey(k) && double.IsNaN(taskCapNhat[k])) taskCapNhat[k] = t; }

    void TaskKetThuc(Task1 k)
    {
        if (k.MuonDung && !k.KhongKhoe) return;    // task bị gỡ có chủ đích
        // task hỏng: updater xét lỗi, restart policy tạo task thay thế theo spec hiện tại
        if (taskCapNhat.TryGetValue(k, out var running) && !dungCapNhat &&
            (double.IsNaN(running) || t - running <= MonitorHieuLuc()))
        {
            if (ch.Rollback && !dangRollback) { phatHien = t; BatDauRollback(); }
            else if (!ch.Rollback) { dungCapNhat = true; ketThuc = $"pause lúc {t:F0} s"; }
        }
        restartCho.Add((t + RestartDelay, k.Slot));
    }

    double MonitorHieuLuc() => slotCho.Count == 0 && moi == null && ch.Delay >= ch.Monitor ? ch.Delay + 1 : ch.Monitor;

    void BuocRestart()
    {
        foreach (var r in restartCho.Where(r => t >= r.luc).ToArray())
        {
            restartCho.Remove(r);
            if (tasks.Any(k => k.Slot == r.slot && !k.KetThuc && !k.MuonDung)) continue;
            var k = TaoTask(r.slot, false);
            if (dangRollback) taskCapNhat[k] = double.NaN;
        }
    }

    void BatDauRollback()
    {
        dangRollback = true; specMoi = false;
        slotCho = new(tasks.Where(k => !k.KetThuc && !k.MuonDung && k.BanMoi).Select(k => k.Slot).Distinct()
            .Concat(restartCho.Select(r => r.slot)).Distinct().Order());
        restartCho.Clear(); moi = null; cu = null; choDelayToi = double.NaN; monitorHet = double.NaN;
        taskCapNhat.Clear();
    }

    void BuocUpdater()
    {
        if (dungCapNhat || ketThuc != "") return;
        bool startFirst = dangRollback || ch.StartFirst;     // rollback_config: start-first, delay 0, monitor 30 s
        double delay = dangRollback ? 0 : ch.Delay;
        if (!double.IsNaN(choDelayToi)) { if (t < choDelayToi) return; choDelayToi = double.NaN; }
        if (moi != null)
        {
            if (double.IsNaN(moi.Running) && !moi.KetThuc) return;     // chờ task mới RUNNING
            if (startFirst && cu != null) YeuCauDung(cu);
            moi = null; cu = null;
            if (delay > 0) { choDelayToi = t + delay; return; }
        }
        if (moi == null && slotCho.Count > 0)
        {
            int s = slotCho.Dequeue();
            cu = tasks.FirstOrDefault(k => k.Slot == s && !k.KetThuc && !k.MuonDung);
            if (startFirst) moi = TaoTask(s, false);
            else
            {
                moi = TaoTask(s, cu != null);
                if (cu != null) { YeuCauDung(cu); var c = cu; var m = moi; choCuDung.Add((c, m)); }
                cu = null;
            }
            taskCapNhat[moi] = double.NaN;
            return;
        }
        if (moi == null && slotCho.Count == 0)
        {
            if (double.IsNaN(monitorHet)) monitorHet = t + (dangRollback ? 30 : MonitorHieuLuc());
            if (t >= monitorHet) ketThuc = dangRollback ? $"rollback {phatHien:F0} s, xong {t:F0} s" : $"cập nhật xong {t:F0} s";
        }
    }
    readonly List<(Task1 cu, Task1 moi)> choCuDung = [];
    // stop-first: task mới chỉ chạy khi task cũ đã thoát (DelayStart với waitStop)
    void ChayKhiCuDung() { foreach (var p in choCuDung.ToArray()) if (p.cu.KetThuc) { BatDau(p.moi); choCuDung.Remove(p); } }
}

// DungMem.cs: chạy thứ tự dừng task của Swarm trên tiến trình BanHang.Api thật.
// dotnet run DungMem.cs -- [số lần]   (cần ../out/api từ DoKhoiDong.cs của bài 1)
// Thứ tự theo moby controller.go: gỡ task khỏi mesh (ở đây: ngừng gửi request mới), chờ 2 s, SIGTERM
// (máy thử Windows: dòng "term" qua stdin, cùng lời gọi StopApplication), quá stop_grace_period thì SIGKILL.
using System.Diagnostics;

int soLan = args.Length > 0 ? int.Parse(args[0]) : 5;
string exe = Path.GetFullPath(Path.Combine("../out/api", OperatingSystem.IsWindows() ? "BanHang.Api.exe" : "BanHang.Api"));
string biMat = Path.GetFullPath("../bai1/bimat");
const string Url = "http://127.0.0.1:5182";
var http = new HttpClient { Timeout = TimeSpan.FromSeconds(60) };
int[] lenhDaiGiay = [4, 8, 12, 14];   // lệnh gọi đối tác đang chạy lúc task bị gỡ

Console.WriteLine($".NET {Environment.Version}, ShutdownTimeout 15 s, {soLan} lần mỗi grace");
foreach (int grace in new[] { 10, 20 })
{
    var catTheoLenh = lenhDaiGiay.ToDictionary(g => g, _ => 0);
    var thoat = new List<double>(); var maThoat = new List<string>();
    for (int lan = 0; lan < soLan; lan++)
    {
        var (p, _) = await ChayApi();
        var sw = Stopwatch.StartNew();
        var lenh = lenhDaiGiay.Select(async g =>
        {
            try { using var r = await http.PostAsync($"{Url}/api/thanh-toan/L{g}?choMs={g * 1000}", null); return (g, ok: r.IsSuccessStatusCode); }
            catch { return (g, ok: false); }
        }).ToArray();
        await Task.Delay(300);                       // lệnh đã vào handler
        await Task.Delay(2000);                      // Swarm: gỡ khỏi mesh rồi chờ defaultGossipConvergeDelay
        double tTerm = sw.Elapsed.TotalSeconds;
        p.StandardInput.WriteLine("term");           // SIGTERM
        bool tuThoat = p.WaitForExit(grace * 1000);
        if (!tuThoat) p.Kill();                      // SIGKILL khi hết stop_grace_period
        await p.WaitForExitAsync();
        thoat.Add(sw.Elapsed.TotalSeconds - tTerm);
        maThoat.Add(tuThoat ? $"tự thoát mã {p.ExitCode}" : "bị kill");
        foreach (var (g, ok) in await Task.WhenAll(lenh)) if (!ok) catTheoLenh[g]++;
    }
    Console.WriteLine($"stop_grace_period {grace} s: thoát sau SIGTERM {thoat.Min():F2}–{thoat.Max():F2} s, {string.Join(", ", maThoat.Distinct())}");
    foreach (var (g, cat) in catTheoLenh) Console.WriteLine($"  lệnh {g,2} s (còn {g - 2.3:F1} s lúc SIGTERM): bị cắt {cat}/{soLan}");
}

// Dừng lúc rảnh: thời gian từ SIGTERM tới khi tiến trình thoát
var rang = new List<double>();
for (int lan = 0; lan < soLan; lan++)
{
    var (p, _) = await ChayApi();
    var sw = Stopwatch.StartNew();
    p.StandardInput.WriteLine("term");
    await p.WaitForExitAsync();
    rang.Add(sw.Elapsed.TotalSeconds);
}
Console.WriteLine($"dừng lúc rảnh: thoát sau {rang.Order().ElementAt(rang.Count / 2):F2} s (trung vị, {rang.Min():F2}–{rang.Max():F2})");

async Task<(Process, double)> ChayApi()
{
    var p = Process.Start(new ProcessStartInfo(exe, ["--urls", Url, "--ThuMucBiMat", biMat, "--RutChoGiay", "0"])
        { RedirectStandardInput = true, RedirectStandardOutput = true, RedirectStandardError = true })!;
    p.OutputDataReceived += (_, _) => { }; p.ErrorDataReceived += (_, _) => { };
    p.BeginOutputReadLine(); p.BeginErrorReadLine();
    var sw = Stopwatch.StartNew();
    while (true)
    {
        if (p.HasExited) throw new Exception($"API thoát mã {p.ExitCode}");
        try { using var r = await http.GetAsync($"{Url}/healthz/ready"); if (r.IsSuccessStatusCode) break; } catch { }
        await Task.Delay(50);
    }
    return (p, sw.Elapsed.TotalSeconds);
}