measurement: name the kinds by protocol and action, add the http_request kind and QUIC settings

backend/shared/MoShiro.Measurement/Blocks/BlockBase.cs

@@ -76,7 +76,7 @@ public abstract class BlockBase : IBlock
         }
     }
 
-    /// <summary>读这个任务的自适应频率参数（<c>udp_echo</c> 和 <c>tcp_echo</c> 共用）。</summary>
+    /// <summary>读这个任务的自适应频率参数（<c>quic_ping</c> 和 <c>tcp_ping</c> 共用）。</summary>
     protected AdaptiveRate? CreateAdaptiveRate()
     {
         if (!Spec.Bool("adaptive"))

backend/shared/MoShiro.Measurement/Blocks/BlockCatalog.cs

@@ -26,13 +26,14 @@ public static class BlockCatalog
 {
     public static readonly IReadOnlyList<BlockPair> All =
     [
-        new("udp_echo", (e, s) => new DatagramEchoDialer(e, s), (e, s) => new DatagramEchoListener(e, s)),
-        new("tcp_echo", (e, s) => new TcpEchoDialer(e, s), (e, s) => new TcpEchoListener(e, s)),
-        new("udp_train", (e, s) => new TrainDialer(e, s), (e, s) => new TrainListener(e, s), OnDemandOnly: true, Directions: ["rev"]),
-        new("tcp_bulk", (e, s) => new TcpBulkDialer(e, s), (e, s) => new TcpBulkListener(e, s), OnDemandOnly: true, Directions: ["fwd", "rev"]),
-        new("connect", (e, s) => new ConnectDialer(e, s), (e, s) => new IdleListener(e, s), RunsAsTarget: true),
-        new("hold", (e, s) => new HoldDialer(e, s), (e, s) => new TcpEchoListener(e, s, record: false)),
-        new("icmp_echo", (e, s) => new IcmpEchoSolo(e, s), null, RunsAsTarget: true),
+        new("quic_ping", (e, s) => new DatagramEchoDialer(e, s), (e, s) => new DatagramEchoListener(e, s)),
+        new("tcp_ping", (e, s) => new TcpEchoDialer(e, s), (e, s) => new TcpEchoListener(e, s)),
+        new("quic_stream", (e, s) => new TrainDialer(e, s), (e, s) => new TrainListener(e, s), OnDemandOnly: true, Directions: ["rev"]),
+        new("tcp_transfer", (e, s) => new TcpBulkDialer(e, s), (e, s) => new TcpBulkListener(e, s), OnDemandOnly: true, Directions: ["fwd", "rev"]),
+        new("tcp_connect", (e, s) => new ConnectDialer(e, s), (e, s) => new IdleListener(e, s), RunsAsTarget: true),
+        new("tls_hold", (e, s) => new HoldDialer(e, s), (e, s) => new TcpEchoListener(e, s, record: false)),
+        new("http_request", (e, s) => new HttpDialer(e, s), null, RunsAsTarget: true),
+        new("icmp_ping", (e, s) => new IcmpEchoSolo(e, s), null, RunsAsTarget: true),
     ];
 
     public static BlockPair? Find(string kind) => All.FirstOrDefault(p => p.Kind == kind);

backend/shared/MoShiro.Measurement/Blocks/Http.cs

@@ -0,0 +1,382 @@
+using System.Net;
+using System.Net.Http;
+using System.Net.Quic;
+using System.Net.Security;
+using System.Net.Sockets;
+using System.Security.Authentication;
+using Fleet.Core;
+using MoShiro.Protocol;
+
+namespace MoShiro.Measurement;
+
+/// <summary>http 请求的结果，编码与 Backend 的 <c>HttpOutcome</c> 一致。</summary>
+internal static class HttpOutcomes
+{
+    public const int Ok = 0;
+    public const int Timeout = 1;
+    public const int Reset = 2;
+    public const int Tls = 3;
+    public const int Other = 4;
+    public const int Dns = 5;
+    public const int BadStatus = 6;
+    public const int Unsupported = 7;
+    public const int NotAllowed = 8;
+}
+
+/// <summary>解析出的地址都不在本地允许的网段内。</summary>
+internal sealed class TargetNotAllowedException : Exception
+{
+    public TargetNotAllowedException(string host)
+        : base("no address of " + host + " is allowed by allowed_target_cidrs")
+    {
+    }
+}
+
+/// <summary>
+/// 单个 Agent 去请求一个 URL（HTTP/1.1、HTTP/2 或 HTTP/3，不回退），记录 DNS、TCP 建连、首字节、总耗时和状态码。
+/// 每次请求新建连接，所以每次都包含完整的建连过程；频率按失败率自适应：目标一直应答就降到证明得了成功率的最低频率，
+/// 出现失败升到最高频率，全部失败时指数退避。
+/// </summary>
+public sealed class HttpDialer : BlockBase
+{
+    private readonly DriverLog _log;
+    private readonly int _attempt;
+    private readonly int _ts;
+    private readonly int _w;
+    private readonly int _dns;
+    private readonly int _tcp;
+    private readonly int _ttfb;
+    private readonly int _total;
+    private readonly int _status;
+    private readonly int _proto;
+    private readonly int _outcome;
+    private readonly HashSet<int> _loggedOutcomes = [];
+    private long _next;
+
+    public HttpDialer(BlockEnv env, BlockSpec spec)
+        : base(env, spec)
+    {
+        _log = new DriverLog(spec.Kind.FindStream("req")!, Side.Dialer, 1024);
+        _attempt = _log.Store.ColumnIndex("attempt");
+        _ts = _log.Store.ColumnIndex("ts");
+        _w = _log.Store.ColumnIndex("w");
+        _dns = _log.Store.ColumnIndex("dns_us");
+        _tcp = _log.Store.ColumnIndex("tcp_us");
+        _ttfb = _log.Store.ColumnIndex("ttfb_us");
+        _total = _log.Store.ColumnIndex("total_us");
+        _status = _log.Store.ColumnIndex("status");
+        _proto = _log.Store.ColumnIndex("proto");
+        _outcome = _log.Store.ColumnIndex("outcome");
+    }
+
+    public override long Produced => _log.Count;
+
+    public override async Task RunAsync(CancellationToken ct)
+    {
+        if (!TargetHost.TryParse(Env.Target, out _, out _, out Uri? url) || url is null)
+        {
+            Env.Log.Warn("http target is not a URL", ("task", Spec.Scope.Task?.Value));
+            await WaitUntilCancelledAsync(ct);
+            return;
+        }
+
+        AdaptiveRate? rate = CreateRequestRate();
+        try
+        {
+            if (rate is not null)
+            {
+                await PaceAsync(rate, async () =>
+                {
+                    int weight = rate.Weight;
+                    long sent = Env.Clock.NowUs();
+                    rate.OnSend(sent);
+                    bool ok = await RequestAsync(url, weight, ct);
+                    if (ok)
+                    {
+                        long now = Env.Clock.NowUs();
+                        rate.OnReply(sent, now, (now - sent) / 1000.0);
+                    }
+                }, ct);
+            }
+            else
+            {
+                TimeSpan interval = TimeSpan.FromSeconds(60.0 / Spec.Int("per_minute"));
+                while (!ct.IsCancellationRequested)
+                {
+                    long start = Env.Clock.NowUs();
+                    await RequestAsync(url, 1, ct);
+                    TimeSpan wait = interval - TimeSpan.FromMicroseconds(Env.Clock.NowUs() - start);
+                    if (wait > TimeSpan.Zero)
+                    {
+                        await Task.Delay(wait, Env.Time, ct);
+                    }
+                }
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            // 积木被停止
+        }
+    }
+
+    public override int Flush(FlushMode mode, long peerProduced = 0)
+    {
+        RawStream? stream = _log.Take(null, all: true);
+        if (stream is null)
+        {
+            return 0;
+        }
+
+        Ship(stream, "ts");
+        return 1;
+    }
+
+    /// <summary>
+    /// 频率以「次/分钟」声明，换算成 Hz 交给 <see cref="AdaptiveRate"/>。请求间隔以秒到分钟计，所以窗口按分钟级放宽，
+    /// 并且不用 RTT 分位数的精度保护（样本太少，估计不出来）：平稳时只由成功率的上界决定频率。
+    /// </summary>
+    private AdaptiveRate? CreateRequestRate()
+    {
+        if (!Spec.Bool("adaptive"))
+        {
+            return null;
+        }
+
+        double max = Math.Max(Spec.Int("rate_max_per_min"), Spec.Int("rate_min_per_min")) / 60.0;
+        return new AdaptiveRate(new AdaptiveRateOptions
+        {
+            MinHz = Spec.Int("rate_min_per_min") / 60.0,
+            MaxHz = max,
+            TauPct = Spec.Number("tau_pct"),
+            RttGuard = false,
+            CertifySeconds = 900,
+            QuietCertifySeconds = 1200,
+            GraceSeconds = Math.Ceiling(Spec.Int("timeout_ms") / 1000.0) + 1,
+            DeadWindowSeconds = 120,
+            DeadMinSent = 3,
+            DeadMaxIntervalSeconds = 300,
+            ActiveLossCount = 2,
+            Prior = Env.LossPrior,
+        });
+    }
+
+    /// <summary>发一次请求并记一行；返回这次算不算成功（有应答且状态码合格）。</summary>
+    private async Task<bool> RequestAsync(Uri url, int weight, CancellationToken ct)
+    {
+        string version = Spec.Text("version");
+        bool verify = Spec.Bool("tls_verify");
+        TimeSpan timeout = TimeSpan.FromMilliseconds(Spec.Int("timeout_ms"));
+        var phases = new Phases();
+        long start = Env.Clock.NowUs();
+        int outcome = HttpOutcomes.Other;
+        int status = 0;
+        int proto = 0;
+        long? ttfb = null;
+        long? total = null;
+        using var timeoutCts = new CancellationTokenSource(timeout, Env.Time);
+        using CancellationTokenSource linked = CancellationTokenSource.CreateLinkedTokenSource(ct, timeoutCts.Token);
+        try
+        {
+            if (version == "h3" && !QuicConnection.IsSupported)
+            {
+                outcome = HttpOutcomes.Unsupported;
+                LogFirstFailure(outcome, url, version, null);
+            }
+            else
+            {
+                if (version == "h3")
+                {
+                    await ResolveForQuicAsync(url.IdnHost, phases, linked.Token);
+                }
+
+                using HttpMessageInvoker invoker = CreateInvoker(version, verify, phases);
+                using var request = new HttpRequestMessage(new HttpMethod(Spec.Text("method")), url)
+                {
+                    Version = version switch { "h1" => HttpVersion.Version11, "h2" => HttpVersion.Version20, _ => HttpVersion.Version30 },
+                    VersionPolicy = HttpVersionPolicy.RequestVersionExact,
+                };
+                using HttpResponseMessage response = await invoker.SendAsync(request, linked.Token);
+                ttfb = Env.Clock.NowUs() - start;
+                status = (int)response.StatusCode;
+                proto = response.Version.Major switch { 3 => 3, 2 => 2, _ => 1 };
+                await ReadBodyAsync(response, (int)Spec.Int("read_kb") * 1024, linked.Token);
+                total = Env.Clock.NowUs() - start;
+                long expected = Spec.Int("ok_status");
+                outcome = (expected == 0 ? status < 400 : status == expected) ? HttpOutcomes.Ok : HttpOutcomes.BadStatus;
+            }
+        }
+        catch (OperationCanceledException) when (!ct.IsCancellationRequested)
+        {
+            outcome = HttpOutcomes.Timeout;
+        }
+        catch (OperationCanceledException)
+        {
+            return false;
+        }
+        catch (Exception ex) when (ex is HttpRequestException or IOException or SocketException or AuthenticationException or TargetNotAllowedException or QuicException)
+        {
+            outcome = Classify(ex);
+            LogFirstFailure(outcome, url, version, ex);
+        }
+
+        Record(start, weight, phases, ttfb, total, status, proto, outcome);
+        return outcome == HttpOutcomes.Ok;
+    }
+
+    private HttpMessageInvoker CreateInvoker(string version, bool verify, Phases phases)
+    {
+        var handler = new SocketsHttpHandler
+        {
+            UseProxy = false,
+            AllowAutoRedirect = false,
+            UseCookies = false,
+            AutomaticDecompression = DecompressionMethods.None,
+        };
+
+        // 设置了 ConnectCallback 的处理器不能用 HTTP/3（运行时用自己的 QUIC 连接，不经过回调）：h3 只能靠请求前的解析和网段检查
+        if (version != "h3")
+        {
+            handler.ConnectCallback = (context, token) => ConnectAsync(context.DnsEndPoint, phases, token);
+        }
+
+        if (!verify)
+        {
+#pragma warning disable CA5359 // 操作员明确关闭证书校验（tls_verify=false）：只测可达性和耗时
+            handler.SslOptions = new SslClientAuthenticationOptions { RemoteCertificateValidationCallback = (_, _, _, _) => true };
+#pragma warning restore CA5359
+        }
+
+        return new HttpMessageInvoker(handler, disposeHandler: true);
+    }
+
+    /// <summary>自己解析和连接：每个地址都要在允许的网段里，DNS 和 TCP 建连的耗时分别记下来。</summary>
+    private async ValueTask<Stream> ConnectAsync(DnsEndPoint endpoint, Phases phases, CancellationToken ct)
+    {
+        IPAddress[] addresses = await ResolveAsync(endpoint.Host, phases, ct);
+        long start = Env.Clock.NowUs();
+        Exception? last = null;
+        foreach (IPAddress address in addresses)
+        {
+            var socket = new Socket(address.AddressFamily, SocketType.Stream, ProtocolType.Tcp) { NoDelay = true };
+            try
+            {
+                await socket.ConnectAsync(new IPEndPoint(address, endpoint.Port), ct);
+                phases.TcpUs = Env.Clock.NowUs() - start;
+                return new NetworkStream(socket, ownsSocket: true);
+            }
+            catch (SocketException ex)
+            {
+                socket.Dispose();
+                last = ex;
+            }
+        }
+
+        throw last ?? new SocketException((int)SocketError.HostNotFound);
+    }
+
+    /// <summary>HTTP/3 由运行时自己建 UDP 连接，没法接管；先解析并检查一遍，再让它去连。</summary>
+    private async Task ResolveForQuicAsync(string host, Phases phases, CancellationToken ct) => _ = await ResolveAsync(host, phases, ct);
+
+    private async Task<IPAddress[]> ResolveAsync(string host, Phases phases, CancellationToken ct)
+    {
+        long start = Env.Clock.NowUs();
+        IPAddress[] all = IPAddress.TryParse(host, out IPAddress? literal) ? [literal] : await Dns.GetHostAddressesAsync(host, ct);
+        phases.DnsUs = Env.Clock.NowUs() - start;
+        IPAddress[] allowed = [.. all.Where(a => Env.AllowAddress?.Invoke(a) ?? true)];
+        return allowed.Length > 0 ? allowed : throw new TargetNotAllowedException(host);
+    }
+
+    private static async Task ReadBodyAsync(HttpResponseMessage response, int limit, CancellationToken ct)
+    {
+        if (limit <= 0)
+        {
+            return;
+        }
+
+        await using Stream body = await response.Content.ReadAsStreamAsync(ct);
+        byte[] buffer = new byte[Math.Min(limit, 16 * 1024)];
+        int read = 0;
+        while (read < limit)
+        {
+            int n = await body.ReadAsync(buffer.AsMemory(0, Math.Min(buffer.Length, limit - read)), ct);
+            if (n == 0)
+            {
+                break;
+            }
+
+            read += n;
+        }
+    }
+
+    /// <summary>每种失败结果只记第一次（带原因），保留给事后审计，不会随请求频率刷屏。</summary>
+    private void LogFirstFailure(int outcome, Uri url, string version, Exception? ex)
+    {
+        if (!_loggedOutcomes.Add(outcome))
+        {
+            return;
+        }
+
+        Env.Log.Warn("http request failed", ("task", Spec.Scope.Task?.Value), ("outcome", outcome), ("version", version), ("host", url.Host),
+            ("quic_supported", version == "h3" ? QuicConnection.IsSupported : null), ("err", ex is null ? "System.Net.Quic is not available" : ex.GetType().Name + ": " + (ex.InnerException?.Message ?? ex.Message)));
+    }
+
+    private static int Classify(Exception ex)
+    {
+        for (Exception? e = ex; e is not null; e = e.InnerException)
+        {
+            switch (e)
+            {
+                case TargetNotAllowedException:
+                    return HttpOutcomes.NotAllowed;
+                case AuthenticationException:
+                    return HttpOutcomes.Tls;
+                case SocketException { SocketErrorCode: SocketError.HostNotFound or SocketError.TryAgain or SocketError.NoData }:
+                    return HttpOutcomes.Dns;
+                case SocketException { SocketErrorCode: SocketError.ConnectionRefused or SocketError.ConnectionReset }:
+                    return HttpOutcomes.Reset;
+                case HttpRequestException { HttpRequestError: HttpRequestError.NameResolutionError }:
+                    return HttpOutcomes.Dns;
+                case HttpRequestException { HttpRequestError: HttpRequestError.SecureConnectionError }:
+                    return HttpOutcomes.Tls;
+                case HttpRequestException { HttpRequestError: HttpRequestError.VersionNegotiationError }:
+                    return HttpOutcomes.Unsupported;
+            }
+        }
+
+        return HttpOutcomes.Other;
+    }
+
+    private void Record(long startUs, int weight, Phases phases, long? ttfb, long? total, int status, int proto, int outcome)
+    {
+        long key = _log.Store.Append();
+        _log.Store.Set(key, _attempt, _next++);
+        _log.Store.Set(key, _ts, startUs);
+        _log.Store.Set(key, _w, Math.Clamp(weight, 1, 65535));
+        _log.Store.Set(key, _outcome, outcome);
+        SetIf(key, _dns, phases.DnsUs);
+        SetIf(key, _tcp, phases.TcpUs);
+        SetIf(key, _ttfb, ttfb);
+        SetIf(key, _total, total);
+        if (status != 0)
+        {
+            _log.Store.Set(key, _status, status);
+            _log.Store.Set(key, _proto, proto);
+        }
+    }
+
+    private void SetIf(long key, int column, long? value)
+    {
+        if (value is { } v)
+        {
+            _log.Store.Set(key, column, Math.Clamp(v, 0, uint.MaxValue));
+        }
+    }
+
+    /// <summary>一次请求里 DNS 和 TCP 建连用了多久（连接回调里填）。</summary>
+    private sealed class Phases
+    {
+        public long? DnsUs { get; set; }
+
+        public long? TcpUs { get; set; }
+    }
+}

backend/shared/MoShiro.Measurement/Blocks/Train.cs

@@ -219,7 +219,7 @@ public sealed class TrainDialer : BlockBase
                 [FragmentKeys.SeqTo] = Number(to),
             };
             Env.Fragments!.Ship(
-                "udp_train",
+                "quic_stream",
                 Spec.Scope,
                 fragments == 0 ? [pkt, _step.Cut(0, 1, includeKey: false)] : [pkt],
                 parameters,

backend/shared/MoShiro.Measurement/Core/AdaptiveRate.cs

@@ -65,6 +65,9 @@ public sealed record AdaptiveRateOptions
 
     public double RttFloorMs { get; init; } = 5;
 
+    /// <summary>用 RTT p99 的置信区间限制降频。样本稀少的任务（每分钟几次）估不出区间，关掉后平稳频率只由丢包上界决定。</summary>
+    public bool RttGuard { get; init; } = true;
+
     /// <summary>先验：时间 → 这个时刻丢包的历史概率（0 到 1）；null 表示没有历史。</summary>
     public Func<long, double?>? Prior { get; init; }
 
@@ -285,7 +288,7 @@ public sealed class AdaptiveRate
             UpdateGuard(nowUs);
             double hz = next switch
             {
-                ProbeState.Quiet => Quantize(Math.Max(QuietHz(QuietWindowSeconds(nowUs)), double.IsNaN(_guardHz) ? _options.MaxHz : _guardHz)),
+                ProbeState.Quiet => Quantize(Math.Max(QuietHz(QuietWindowSeconds(nowUs)), !_options.RttGuard ? _options.MinHz : double.IsNaN(_guardHz) ? _options.MaxHz : _guardHz)),
                 ProbeState.Watch or ProbeState.Active => _options.MaxHz,
                 _ => Math.Max(_options.MinHz / 4, 1.0 / _options.DeadMaxIntervalSeconds),
             };

backend/shared/MoShiro.Measurement/Core/Contracts.cs

@@ -190,6 +190,8 @@ public sealed class BlockSpec
 
     public bool Bool(string name) => Params.GetBool(name);
 
+    public string Text(string name) => Params.GetString(name);
+
     /// <summary>参数或端口变化时调和器重启这个积木（不含流编号：Agent 的流编号每次重建都会重新分配）。</summary>
     public string ConfigSignature => KindId + "|" + Port + "|" +
         string.Join(',', Params.Values.OrderBy(p => p.Key, StringComparer.Ordinal).Select(p => p.Key + "=" + p.Value.GetRawText()));
@@ -237,6 +239,12 @@ public sealed class BlockEnv
     /// <summary>拨号方：对端（Agent，或目标任务的目标地址）。</summary>
     public IPAddress? PeerAddress { get; init; }
 
+    /// <summary>单个 Agent 任务的目标原文（http 是 URL，其余是主机[:端口]）；线路任务为 null。</summary>
+    public string? Target { get; init; }
+
+    /// <summary>单个 Agent 任务：解析出来的地址能不能连（本地 <c>allowed_target_cidrs</c>）；null 表示不限制。</summary>
+    public Func<IPAddress, bool>? AllowAddress { get; init; }
+
     /// <summary>拨号方：对端 TLS 证书的 SPKI 指纹；null 表示不校验证书（目标任务，目标是任意地址）。</summary>
     public byte[]? PeerSpkiSha256 { get; init; }
 
@@ -246,7 +254,7 @@ public sealed class BlockEnv
     /// <summary>拨号方：列块出口。</summary>
     public IFragmentSink? Fragments { get; init; }
 
-    /// <summary>本地硬上限：批量传输（tcp_bulk）发送端的码率（Mbit/s）。批量传输会尽可能占满链路，这是防止把小机器打满的保险。</summary>
+    /// <summary>本地硬上限：批量传输（tcp_transfer）发送端的码率（Mbit/s）。批量传输会尽可能占满链路，这是防止把小机器打满的保险。</summary>
     public double MaxBulkMbps { get; init; } = 100;
 
     /// <summary>本地硬上限：单向数据流接收缓冲的包速率上界。</summary>
@@ -267,6 +275,8 @@ public sealed class BlockEnv
             Counters = Counters,
             TcpListen = TcpListen,
             PeerAddress = PeerAddress,
+            Target = Target,
+            AllowAddress = AllowAddress,
             PeerSpkiSha256 = PeerSpkiSha256,
             KnockKey = KnockKey,
             Fragments = Fragments,

backend/shared/MoShiro.Measurement/Execution/BudgetGuard.cs

@@ -106,22 +106,25 @@ public sealed class BudgetGuard
         return Check(new TaskSpec { Id = new TaskId("tsk_phase"), Scope = "line", Kind = kindId, Params = new Dictionary<string, JsonElement>(parameters) }, ref mbps, ref pps);
     }
 
+    /// <summary>
+    /// 目标在静态上可不可以接受：IP 字面量按 <c>allowed_target_cidrs</c> 检查；域名（包括 URL 里的）要解析之后才知道，
+    /// 这里只要求配置过白名单，运行时每次解析出的地址再用 <see cref="AddressAllowed"/> 检查。
+    /// </summary>
     public bool TargetAllowed(string? target)
     {
-        if (target is null)
+        if (!TargetHost.TryParse(target, out string? host, out _, out _))
         {
             return false;
         }
 
-        string host = target;
-        if (IPEndPoint.TryParse(target, out IPEndPoint? endpoint))
-        {
-            host = endpoint.Address.ToString();
-        }
+        return IPAddress.TryParse(host, out IPAddress? address) ? AddressAllowed(address) : _cidrs.Count > 0;
+    }
 
-        if (!IPAddress.TryParse(host, out IPAddress? address))
+    public bool AddressAllowed(IPAddress address)
+    {
+        if (address.IsIPv4MappedToIPv6)
         {
-            return false;
+            address = address.MapToIPv4();
         }
 
         foreach ((IPAddress network, int prefix) in _cidrs)
@@ -148,10 +151,11 @@ public sealed class BudgetGuard
 
     private static long EstimatePps(string kindId, ParamValues values) => kindId switch
     {
-        "udp_echo" or "tcp_echo" => Kinds.PeakRateHz(kindId, values) * 2,
-        "icmp_echo" => values.GetInt("rate_hz") * 2,
-        "udp_train" => (long)(values.GetNumber("mbps") * 1_000_000 / 8 / Math.Max(1, values.GetInt("size"))),
-        "connect" => values.GetInt("per_minute") * 6 / 60,
+        "quic_ping" or "tcp_ping" => Kinds.PeakRateHz(kindId, values) * 2,
+        "icmp_ping" => values.GetInt("rate_hz") * 2,
+        "quic_stream" => (long)(values.GetNumber("mbps") * 1_000_000 / 8 / Math.Max(1, values.GetInt("size"))),
+        "tcp_connect" => values.GetInt("per_minute") * 6 / 60,
+        "http_request" => Math.Max(1, values.GetInt("rate_max_per_min") * 20 / 60),
         _ => 1,
     };
 

backend/shared/MoShiro.Measurement/Net/MsQuicApi.cs

@@ -109,14 +109,16 @@ internal static unsafe class MsQuicApi
 
     public static void RegistrationClose(nint handle) => s_registrationClose(handle);
 
-    public static nint ConfigurationOpen(nint registration, byte[] alpn)
+    public static nint ConfigurationOpen(nint registration, byte[] alpn, QuicSettings? settings = null)
     {
+        byte[] native = settings is { IsDefault: false } ? settings.ToNative() : [];
         unsafe
         {
             fixed (byte* alpnBytes = alpn)
+            fixed (byte* settingsBytes = native)
             {
                 var buffer = new QuicBuffer { Length = (uint)alpn.Length, Buffer = (nint)alpnBytes };
-                uint status = s_configurationOpen(registration, ref buffer, 1, 0, 0, 0, out nint configuration);
+                uint status = s_configurationOpen(registration, ref buffer, 1, native.Length == 0 ? 0 : (nint)settingsBytes, (uint)native.Length, 0, out nint configuration);
                 Check(status, "ConfigurationOpen");
                 return configuration;
             }

backend/shared/MoShiro.Measurement/Net/MsQuicConnection.cs

@@ -156,7 +156,8 @@ internal sealed class MsQuicConnection : IAsyncDisposable, IDatagramConnection
         byte[] expectedPeerSpki,
         MsQuicDatagramCallback datagramHandler,
         INodeLog log,
-        CancellationToken ct)
+        CancellationToken ct,
+        QuicSettings? settings = null)
     {
         nint registration = 0;
         nint configuration = 0;
@@ -165,7 +166,7 @@ internal sealed class MsQuicConnection : IAsyncDisposable, IDatagramConnection
         try
         {
             registration = MsQuicApi.RegistrationOpen("moshiro-dialer");
-            configuration = MsQuicApi.ConfigurationOpen(registration, QuicAlpn.Value);
+            configuration = MsQuicApi.ConfigurationOpen(registration, QuicAlpn.Value, settings);
             LoadClientCredentials(configuration);
             var endpoint = new IPEndPoint(address.AddressFamily == AddressFamily.InterNetworkV6 ? IPAddress.IPv6Any : IPAddress.Any, localPort);
             SocketAddress serialized = endpoint.Serialize();

backend/shared/MoShiro.Measurement/Net/MsQuicListener.cs

@@ -21,6 +21,7 @@ internal sealed class MsQuicListener : IAsyncDisposable
     private readonly INodeLog _log;
     private readonly Action<IPEndPoint>? _peerAddressChanged;
     private readonly X509Certificate2 _certificate;
+    private readonly QuicSettings? _settings;
     private readonly GCHandle _self;
     private readonly ConcurrentDictionary<nint, MsQuicConnection> _connections = new();
     private readonly List<nint> _listeners = [];
@@ -34,8 +35,10 @@ internal sealed class MsQuicListener : IAsyncDisposable
         X509Certificate2 certificate,
         MsQuicDatagramCallback datagramHandler,
         INodeLog log,
-        Action<IPEndPoint>? peerAddressChanged)
+        Action<IPEndPoint>? peerAddressChanged,
+        QuicSettings? settings = null)
     {
+        _settings = settings;
         // MsQuic opens dual-mode wildcard sockets, but filters incoming connections using
         // the address family supplied to ListenerStart. An IPv6Any listener alone rejects
         // IPv4-mapped connections with TLS alert 120 (no_application_protocol).
@@ -62,7 +65,7 @@ internal sealed class MsQuicListener : IAsyncDisposable
         _registration = MsQuicApi.RegistrationOpen("moshiro-agent");
         try
         {
-            _configuration = MsQuicApi.ConfigurationOpen(_registration, QuicAlpn.Value);
+            _configuration = MsQuicApi.ConfigurationOpen(_registration, QuicAlpn.Value, _settings);
             MsQuicConnection.LoadServerCredentials(_configuration, _certificate);
             var bound = new List<int>(_ports.Count * _bindAddresses.Count);
             foreach (int port in _ports)

backend/shared/MoShiro.Measurement/Net/QuicDatagramTransport.cs

@@ -21,6 +21,7 @@ public sealed class QuicDatagramTransport : IDisposable, IAsyncDisposable
     private readonly DataSession? _clientSession;
     private readonly IPEndPoint? _remote;
     private readonly byte[]? _peerSpki;
+    private readonly QuicSettings? _settings;
     private int _previousSourcePort;
     private readonly TaskCompletionSource _clientReady = new(TaskCreationOptions.RunContinuationsAsynchronously);
     private MsQuicListener? _listener;
@@ -28,8 +29,9 @@ public sealed class QuicDatagramTransport : IDisposable, IAsyncDisposable
     private int _disposed;
 
     /// <summary>Constructs an Agent-side QUIC listener.</summary>
-    public QuicDatagramTransport(IDataSessions sessions, IAdmission? admission, MonoClock clock, DataPlaneCounters counters, INodeLog log, IPAddress bind, IReadOnlyList<int> ports, X509Certificate2 serverCertificate)
+    public QuicDatagramTransport(IDataSessions sessions, IAdmission? admission, MonoClock clock, DataPlaneCounters counters, INodeLog log, IPAddress bind, IReadOnlyList<int> ports, X509Certificate2 serverCertificate, QuicSettings? settings = null)
     {
+        _settings = settings;
         _router = new MeasurementDatagramRouter(sessions, admission, clock, counters, log);
         _log = log;
         _onDatagram = _router.Dispatch;
@@ -39,8 +41,9 @@ public sealed class QuicDatagramTransport : IDisposable, IAsyncDisposable
     }
 
     /// <summary>Constructs a 拨号方-side QUIC dialer for one Agent session.</summary>
-    public QuicDatagramTransport(DataSession session, MonoClock clock, DataPlaneCounters counters, INodeLog log, IPEndPoint remote, byte[] peerSpki)
+    public QuicDatagramTransport(DataSession session, MonoClock clock, DataPlaneCounters counters, INodeLog log, IPEndPoint remote, byte[] peerSpki, QuicSettings? settings = null)
     {
+        _settings = settings;
         _router = new MeasurementDatagramRouter(new SingleSession(session), null, clock, counters, log);
         _log = log;
         _onDatagram = _router.Dispatch;
@@ -73,7 +76,7 @@ public sealed class QuicDatagramTransport : IDisposable, IAsyncDisposable
             throw new InvalidOperationException("QUIC listener is already bound.");
         }
 
-        _listener = new MsQuicListener(_bind, _ports, _serverCertificate!, _onDatagram, _log, null);
+        _listener = new MsQuicListener(_bind, _ports, _serverCertificate!, _onDatagram, _log, null, _settings);
         _listener.Start();
         BoundPorts = _listener.BoundPorts;
     }
@@ -92,7 +95,7 @@ public sealed class QuicDatagramTransport : IDisposable, IAsyncDisposable
         ObjectDisposedException.ThrowIf(Volatile.Read(ref _disposed) != 0, this);
         await CloseClientAsync().ConfigureAwait(false);
         int sourcePort = SelectSourcePort(_remote.AddressFamily, _previousSourcePort);
-        MsQuicConnection client = await MsQuicConnection.ConnectAsync(_remote.Address, _remote.Port, sourcePort, _peerSpki, _onDatagram, _log, ct).ConfigureAwait(false);
+        MsQuicConnection client = await MsQuicConnection.ConnectAsync(_remote.Address, _remote.Port, sourcePort, _peerSpki, _onDatagram, _log, ct, _settings).ConfigureAwait(false);
         _client = client;
         _clientSession.BindDatagramConnection(client);
         BoundPorts = client.LocalEndPoint is { } local ? [local.Port] : [sourcePort];

backend/shared/MoShiro.Measurement/Net/QuicSettings.cs

@@ -0,0 +1,110 @@
+using System.Buffers.Binary;
+
+namespace MoShiro.Measurement;
+
+/// <summary>
+/// 数据通道 QUIC 连接的传输参数（<c>agent.json</c> 的 <c>quic</c> 段）；null 的项用 MsQuic 默认值。
+/// 一条 QUIC 连接由这个 Agent 与对端之间的所有任务共用，所以这些参数属于节点，不属于某个任务。
+/// 监听方用它接受连接，拨号方用它发起连接，两边各自生效。
+/// </summary>
+public sealed record QuicSettings
+{
+    /// <summary>MsQuic 默认的最小、最大 MTU 是 1248 和 1500（IP 包大小，含 IP 和 UDP 头）。</summary>
+    public const int MinAllowedMtu = 1200;
+
+    public const int MaxAllowedMtu = 65535;
+
+    /// <summary>路径 MTU 探测的起点；链路的真实 MTU 更小时探测会往下收缩，更大时往上探测到 <see cref="MaxMtu"/>。</summary>
+    public int? MinMtu { get; init; }
+
+    /// <summary>路径 MTU 探测的上限。设成链路的真实 MTU 可以省掉探测，设小可以避开会丢大包的路径。</summary>
+    public int? MaxMtu { get; init; }
+
+    public bool? Pacing { get; init; }
+
+    public int? IdleTimeoutMs { get; init; }
+
+    public int? KeepAliveMs { get; init; }
+
+    public bool IsDefault => MinMtu is null && MaxMtu is null && Pacing is null && IdleTimeoutMs is null && KeepAliveMs is null;
+
+    /// <summary>参数是否合法；不合法返回原因。</summary>
+    public string? Validate()
+    {
+        if (MinMtu is { } min && min is < MinAllowedMtu or > MaxAllowedMtu)
+        {
+            return $"min_mtu must be {MinAllowedMtu}..{MaxAllowedMtu}";
+        }
+
+        if (MaxMtu is { } max && max is < MinAllowedMtu or > MaxAllowedMtu)
+        {
+            return $"max_mtu must be {MinAllowedMtu}..{MaxAllowedMtu}";
+        }
+
+        if (MinMtu is { } lo && MaxMtu is { } hi && lo > hi)
+        {
+            return "min_mtu must not exceed max_mtu";
+        }
+
+        if (IdleTimeoutMs is < 0)
+        {
+            return "idle_timeout_ms must not be negative";
+        }
+
+        return KeepAliveMs is < 0 ? "keep_alive_ms must not be negative" : null;
+    }
+
+    // QUIC_SETTINGS（msquic.h）的布局：IsSetFlags(u64) 后面依次是 u64、u32、u16 各一组字段，再是位域字节。
+    // 这里只写用到的几项，其余字段保持 0 且不置位。长度只算到 MtuDiscoveryMissingProbeCount，更靠后的字段 MsQuic 不会读。
+    private const int Size = 112;
+    private const int IdleTimeoutOffset = 24;
+    private const int KeepAliveOffset = 88;
+    private const int MinMtuOffset = 102;
+    private const int MaxMtuOffset = 104;
+    private const int BitFieldOffset = 106;
+    private const int PacingBit = 1 << 1;
+
+    private const int IdleTimeoutFlag = 2;
+    private const int KeepAliveFlag = 16;
+    private const int MinMtuFlag = 22;
+    private const int MaxMtuFlag = 23;
+    private const int PacingFlag = 25;
+
+    internal byte[] ToNative()
+    {
+        byte[] native = new byte[Size];
+        ulong isSet = 0;
+        if (IdleTimeoutMs is { } idle)
+        {
+            BinaryPrimitives.WriteUInt64LittleEndian(native.AsSpan(IdleTimeoutOffset), (ulong)idle);
+            isSet |= 1UL << IdleTimeoutFlag;
+        }
+
+        if (KeepAliveMs is { } keepAlive)
+        {
+            BinaryPrimitives.WriteUInt32LittleEndian(native.AsSpan(KeepAliveOffset), (uint)keepAlive);
+            isSet |= 1UL << KeepAliveFlag;
+        }
+
+        if (MinMtu is { } min)
+        {
+            BinaryPrimitives.WriteUInt16LittleEndian(native.AsSpan(MinMtuOffset), (ushort)min);
+            isSet |= 1UL << MinMtuFlag;
+        }
+
+        if (MaxMtu is { } max)
+        {
+            BinaryPrimitives.WriteUInt16LittleEndian(native.AsSpan(MaxMtuOffset), (ushort)max);
+            isSet |= 1UL << MaxMtuFlag;
+        }
+
+        if (Pacing is { } pacing)
+        {
+            native[BitFieldOffset] = (byte)(pacing ? PacingBit : 0);
+            isSet |= 1UL << PacingFlag;
+        }
+
+        BinaryPrimitives.WriteUInt64LittleEndian(native, isSet);
+        return native;
+    }
+}