agent: unify listening and dialing with directed mutual measurements

Replace Probe with Agent across node runtime, Fleet contracts, backend state, API and storage. Report incoming sessions and outgoing link health through each Agent uplink, and retain directed link controls and retry.

Update protocol fixtures and end-to-end coverage for the unified model; accept requested cancellation during the Fleet timeout test cleanup.

backend/agent/src/MoShiro.Agent/AgentApp.cs

@@ -10,13 +10,17 @@ using MoShiro.Protocol;
 
 namespace MoShiro.Agent;
 
-/// <summary>Agent 的组装点：数据面、点对点监听、与 Backend 的链路都在这里接起来。没有全局状态，测试可以在同一进程里启动多个。</summary>
+/// <summary>
+/// 节点的组装点：与 Backend 的链路、监听侧（数据面和点对点监听，<c>listen.enabled</c> 为 false 时不启动）、拨号侧（Backend 下发的拨号目标）都在这里接起来。
+/// 没有全局状态，测试可以在同一进程里启动多个。
+/// </summary>
 public sealed class AgentApp : IDisposable, IAsyncDisposable
 {
     public const string Version = MoShiro.Protocol.BuildInfo.Version;
 
     private readonly AgentConfig _config;
-    private readonly bool _ipv6Supported;
+    private readonly bool _listening;
+    private readonly bool? _ipv6Supported;
     private readonly KnockGate _knock;
     private readonly TrustAnchor _trust;
     private readonly RestartController _restart;
@@ -33,6 +37,8 @@ public sealed class AgentApp : IDisposable, IAsyncDisposable
     private readonly AgentAdmission _admission;
     private readonly Outbox _outbox = new(64 << 20);
     private readonly RestartUpdater? _update;
+    private readonly OpenWrtUpdater? _nativeUpdate;
+    private readonly DialerHost _dialer;
     private readonly BackendUplink _uplink;
     private readonly QuicDatagramTransport _datagrams;
     private readonly TcpAcceptor _tcp;
@@ -50,7 +56,9 @@ public sealed class AgentApp : IDisposable, IAsyncDisposable
         _ownedRestart = restart is null ? new RestartController() : null;
         _restart = restart ?? _ownedRestart!;
         _update = RestartUpdater.FromEnvironment("agent", _restart.RequestNow, time, log);
+        _nativeUpdate = OpenWrtUpdater.FromEnvironment(time, log);
         _config = config;
+        _listening = config.Listen.Enabled;
         _identity = identity;
         _time = time;
         _log = log;
@@ -64,20 +72,21 @@ public sealed class AgentApp : IDisposable, IAsyncDisposable
             bind = IPAddress.Any;
         }
 
-        _ipv6Supported = bind.AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6;
+        _ipv6Supported = _listening ? bind.AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6 : null;
         _admission = new AgentAdmission(_streams);
-        _datagrams = new QuicDatagramTransport(_sessions, _admission, _clock, _counters.Data, log, bind, config.Listen.EffectiveQuicPorts, identity.Certificate);
+        _datagrams = new QuicDatagramTransport(_sessions, _admission, _clock, _counters.Data, log, bind, config.Listen.QuicPorts, identity.Certificate);
         // 预握手敲门：控制端口和数据端口共用一个关卡（限速和去重一起算）；名册就是期望状态里的 peers
         _trust = TrustAnchor.Load(config.Fleet.IdentityDir, log);
+        _dialer = new DialerHost(new DialEnv(identity.PeerIdentity, identity.NodeId.Value, config.Limits, new DialDirectory(new ConfigStore(dataDirectory), dataDirectory, log, _trust), _clock, time, log), time, log);
         _knock = new KnockGate(identity.PeerIdentity, RosterKeys, time);
         _tcp = new TcpAcceptor(bind, config.Listen.TcpPorts, identity.Certificate, _sessions, _counters.Data, _knock);
 
-        // 监听方积木的环境：和 Probe 的拨号方共用同一套积木，区别只在这里装配的部分（准入策略、TCP 监听）
+        // 监听方积木的环境：和拨号方的拨号方共用同一套积木，区别只在这里装配的部分（准入策略、TCP 监听）
         var env = new BlockEnv
         {
             Clock = _clock,
             Log = log,
-            Session = () => null, // 每个 Probe 会话各用自己绑定的环境（BlockEnv.WithSession）
+            Session = () => null, // 每个拨号方会话各用自己绑定的环境（BlockEnv.WithSession）
             Datagrams = _datagrams,
             TcpListen = _tcp,
             Admission = _admission,
@@ -87,14 +96,14 @@ public sealed class AgentApp : IDisposable, IAsyncDisposable
         };
         _chunks = new ChunkAssembler(_streams, _clock, _counters, _outbox, identity.NodeId, time, log);
         var targets = new TargetRunners(_chunks, identity.NodeId, _clock, time, log);
-        _tasks = new TaskManager(CreateGuard, _streams, env, targets, () => _datagrams.BoundPorts, () => _tcp.BoundPorts, _trust);
+        _tasks = new TaskManager(CreateGuard, _streams, env, targets, () => _datagrams.BoundPorts, () => _tcp.BoundPorts, _trust, acceptLineTasks: _listening);
         _hub = new PeerHub(_sessions, _clock, _chunks, _tasks, _uplink, time, log);
         _tests = new TestRunner(_tasks, _sessions, _streams, env, _uplink, config.Limits.MaxConcurrentTests, transport => transport == "quic_datagram" ? _datagrams.BoundPorts : _tcp.BoundPorts, time, log);
 
-        _tasks.OnLineTasksChanged = (probe, set) => _ = _hub.PushToAsync(probe, set).AsTask();
+        _tasks.OnLineTasksChanged = (dialer, set) => _ = _hub.PushToAsync(dialer, set).AsTask();
         _tasks.OnPeersChanged = _hub.CloseNotIn;
-        _hub.OnProbeLost = probe => _tests.ProbeLost(probe);
-        _admission.OnEndpointChanged = probe => _ = _uplink.EmitEventAsync(AgentEventKinds.EndpointChanged, probe.DatagramRemoteEndPoint?.ToString()).AsTask();
+        _hub.OnDialerLost = dialer => _tests.DialerLost(dialer);
+        _admission.OnEndpointChanged = dialer => _ = _uplink.EmitEventAsync(AgentEventKinds.EndpointChanged, dialer.DatagramRemoteEndPoint?.ToString()).AsTask();
 
         _peers = new PeerListener(
             new PeerListenerOptions
@@ -122,6 +131,7 @@ public sealed class AgentApp : IDisposable, IAsyncDisposable
             return;
         }
 
+        _dialer.Dispose();
         _datagrams.Dispose();
         _ownedRestart?.Dispose();
     }
@@ -133,6 +143,7 @@ public sealed class AgentApp : IDisposable, IAsyncDisposable
             return;
         }
 
+        _dialer.Dispose();
         await _datagrams.DisposeAsync().ConfigureAwait(false);
         _ownedRestart?.Dispose();
     }
@@ -152,12 +163,15 @@ public sealed class AgentApp : IDisposable, IAsyncDisposable
 
     public FleetLink Link => _link;
 
-    /// <summary>对等面（Probe 连进来的会话）的路由器，测试用。</summary>
+    /// <summary>拨号侧（测试和状态查看用）。</summary>
+    public DialerHost Dialer => _dialer;
+
+    /// <summary>对等面（拨号方连进来的会话）的路由器，测试用。</summary>
     public RpcRouter<PeerContext> PeerRouter => _hub.Router;
 
-    /// <summary>期望状态里是否已经有这个 Probe 的公钥（测试用：握手会按它校验）。</summary>
-    public bool IsPeerKnown(string probeId, string publicKeyBase64) =>
-        _tasks.LookupPeerKey(probeId) is { } key && Convert.ToBase64String(key) == publicKeyBase64;
+    /// <summary>期望状态里是否已经有这个拨号方的公钥（测试用：握手会按它校验）。</summary>
+    public bool IsPeerKnown(string dialerId, string publicKeyBase64) =>
+        _tasks.LookupPeerKey(dialerId) is { } key && Convert.ToBase64String(key) == publicKeyBase64;
 
     public TestRunner Tests => _tests;
 
@@ -165,24 +179,35 @@ public sealed class AgentApp : IDisposable, IAsyncDisposable
     {
         _log.Info("moshiro agent starting", MoShiro.Protocol.BuildInfo.Fields);
         using CancellationTokenSource linked = CancellationTokenSource.CreateLinkedTokenSource(ct);
-        // 数据面和控制端口先开始监听，再连接 Backend：hello 里上报的是实际端口
-        _datagrams.Bind();
-        _tcp.Bind();
-        Task quic = _datagrams.RunAsync(linked.Token);
-        Task tcp = _tcp.RunAsync(linked.Token);
-        Task peers = _peers.RunAsync(linked.Token);
-        await Task.WhenAny(_peers.Started.Task, peers);
-        if (peers.IsFaulted)
+        Task quic = Task.CompletedTask;
+        Task tcp = Task.CompletedTask;
+        Task peers = Task.CompletedTask;
+        if (_listening)
         {
-            await linked.CancelAsync();
-            await Task.WhenAll(quic, tcp, peers); // 抛出监听失败的原因（端口被占用等）
+            // 数据面和控制端口先开始监听，再连接 Backend：hello 里上报的是实际端口
+            _datagrams.Bind();
+            _tcp.Bind();
+            quic = _datagrams.RunAsync(linked.Token);
+            tcp = _tcp.RunAsync(linked.Token);
+            peers = _peers.RunAsync(linked.Token);
+            await Task.WhenAny(_peers.Started.Task, peers);
+            if (peers.IsFaulted)
+            {
+                await linked.CancelAsync();
+                await Task.WhenAll(quic, tcp, peers); // 抛出监听失败的原因（端口被占用等）
+            }
+
+            _log.Info("agent listening", ("control", ControlPort), ("quic", string.Join(',', QuicPorts)), ("tcp", string.Join(',', TcpPorts)));
+        }
+        else
+        {
+            _log.Info("agent is dial-only: listening is disabled");
         }
 
         _ready.TrySetResult();
-        _log.Info("agent listening", ("control", ControlPort), ("quic", string.Join(',', QuicPorts)), ("tcp", string.Join(',', TcpPorts)));
         try
         {
-            await Task.WhenAll(quic, tcp, peers, _link.RunAsync(linked.Token), ReportHostAsync(linked.Token), _chunks.RunTrafficReportingAsync(linked.Token));
+            await Task.WhenAll(quic, tcp, peers, _link.RunAsync(linked.Token), _dialer.RunAsync(linked.Token), ReportHostAsync(linked.Token), _chunks.RunTrafficReportingAsync(linked.Token));
         }
         finally
         {
@@ -227,11 +252,11 @@ public sealed class AgentApp : IDisposable, IAsyncDisposable
                 AllowedQuicPorts = _datagrams.BoundPorts,
                 AllowedTcpPorts = _tcp.BoundPorts,
             },
-            BlockCatalog.AgentKinds);
+            _listening ? BlockCatalog.AgentKinds : BlockCatalog.TargetKinds);
 
     private FleetLink BuildLink()
     {
-        var router = new RpcRouter<LinkContext>(RpcSide.Node, MoShiroMethodTable.Table, NodeRoles.Agent);
+        var router = new RpcRouter<LinkContext>(RpcSide.Node, MoShiroMethodTable.Table);
         HashSet<string>? allowed = _config.Policy.AllowMethods is { } list ? [.. list] : null;
         bool Allow(string method) => allowed is null || allowed.Contains(method);
 
@@ -258,6 +283,7 @@ public sealed class AgentApp : IDisposable, IAsyncDisposable
             router.OnNotify(MoShiroMethods.UpdateOffer, MoShiroJsonContext.Default.UpdateOfferParams, (_, offer, _) =>
             {
                 _update?.Offer(offer);
+                _nativeUpdate?.Offer();
                 return ValueTask.CompletedTask;
             });
         }
@@ -280,17 +306,27 @@ public sealed class AgentApp : IDisposable, IAsyncDisposable
             router.OnNotify(MoShiroMethods.UpdateApply, MoShiroJsonContext.Default.UpdateOfferParams, (_, _, _) =>
             {
                 _update?.RequestApply();
+                _nativeUpdate?.RequestApply();
                 return ValueTask.CompletedTask;
             });
         }
 
-        if (Allow(MoShiroMethods.ProbeDisconnect))
+        if (Allow(MoShiroMethods.DialerDisconnect))
         {
             router.On(
-                MoShiroMethods.ProbeDisconnect,
-                MoShiroJsonContext.Default.ProbeDisconnectParams,
+                MoShiroMethods.DialerDisconnect,
+                MoShiroJsonContext.Default.DialerDisconnectParams,
                 MoShiroJsonContext.Default.TestRunResult,
-                async (_, request, _) => Result<TestRunResult>.Ok(new TestRunResult { Accepted = await _hub.DisconnectAsync(request.ProbeId.Value) }));
+                async (_, request, _) => Result<TestRunResult>.Ok(new TestRunResult { Accepted = await _hub.DisconnectAsync(request.DialerId.Value) }));
+        }
+
+        if (Allow(MoShiroMethods.LinkRetry))
+        {
+            router.OnNotify(MoShiroMethods.LinkRetry, MoShiroJsonContext.Default.LinkRetryParams, (_, request, _) =>
+            {
+                _dialer.RetryListener(request.ListenerId.Value);
+                return ValueTask.CompletedTask;
+            });
         }
 
         var options = new FleetLinkOptions
@@ -300,19 +336,32 @@ public sealed class AgentApp : IDisposable, IAsyncDisposable
             ServerVerifier = _trust,
             NodeId = _identity.NodeId,
             NodeVersion = Version,
-            Capabilities = [MoShiroCapabilities.Base, MoShiroCapabilities.KindsPrefix + string.Join(',', BlockCatalog.AgentKinds)],
+            Capabilities = [MoShiroCapabilities.Base, MoShiroCapabilities.KindsPrefix + string.Join(',', _listening ? BlockCatalog.AgentKinds : BlockCatalog.TargetKinds)],
             HelloMeta = HelloMeta,
             HeartbeatExtra = HeartbeatExtra,
             ShutdownReason = () => _restart.NowReason == "update" ? "updating" : "stopping",
         };
-        var link = new FleetLink(options, router, [new StateHandler<TaskSet>(TaskSet.StateType, MoShiroJsonContext.Default.TaskSet, _tasks.ApplyAsync)], _outbox, _time, _log);
+        var link = new FleetLink(
+            options,
+            router,
+            [
+                new StateHandler<TaskSet>(TaskSet.StateType, MoShiroJsonContext.Default.TaskSet, _tasks.ApplyAsync),
+                new StateHandler<DialTargets>(DialTargets.StateType, MoShiroJsonContext.Default.DialTargets, (version, targets, _) =>
+                {
+                    _dialer.Directory.Apply(targets);
+                    return ValueTask.FromResult(new StateSyncResult { AppliedVersion = version });
+                }),
+            ],
+            _outbox,
+            _time,
+            _log);
 
-        // 链路重新连上之后补报：在线的 Probe 都告诉 Backend（Backend 重启或链路抖动期间错过了 probe_connected）
+        // 链路重新连上之后补报：在线的拨号方都告诉 Backend（Backend 重启或链路抖动期间错过了 dialer_connected）
         link.OnConnected = async (_, _) =>
         {
-            foreach (ConnectedProbe probe in _hub.ConnectedProbes())
+            foreach (ConnectedDialer dialer in _hub.ConnectedDialers())
             {
-                await _uplink.EmitEventAsync(AgentEventKinds.ProbeConnected, probe.Id.Value, probe);
+                await _uplink.EmitEventAsync(AgentEventKinds.DialerConnected, dialer.Id.Value, dialer);
             }
         };
         return link;
@@ -323,17 +372,11 @@ public sealed class AgentApp : IDisposable, IAsyncDisposable
 
     private JsonElement? HelloMeta()
     {
-        var meta = new AgentHelloMeta
+        var meta = new NodeHelloMeta
         {
             Owners = [.. _trust.Controllers],
             Ipv6 = Ipv6Diagnostics.Sample(_ipv6Supported, Environment.GetEnvironmentVariable("MOSHIRO_NETWORK_SCOPE"), Environment.GetEnvironmentVariable("HOST_PROC")),
-            Ipv6Supported = _ipv6Supported,
-            Addresses = [.. LocalAddresses.Sample()],
             Platform = MoShiro.Measurement.PlatformDetector.Detect(),
-            TlsPublicKey = Convert.ToBase64String(_identity.Certificate.PublicKey.ExportSubjectPublicKeyInfo()),
-            ProbeTcpPort = ControlPort,
-            ProbeQuicPorts = [.. QuicPorts],
-            LegacyProbeUdpPorts = [.. QuicPorts],
             LocalLimits = new LocalLimits
             {
                 MaxTotalMbps = _config.Limits.MaxTotalMbps,
@@ -341,8 +384,17 @@ public sealed class AgentApp : IDisposable, IAsyncDisposable
                 AllowedTargetCidrs = _config.Limits.AllowedTargetCidrs,
                 MaxConcurrentTests = _config.Limits.MaxConcurrentTests,
             },
+            Listen = !_listening
+                ? null
+                : new ListenInfo
+                {
+                    TcpPort = ControlPort,
+                    QuicPorts = [.. QuicPorts],
+                    Ipv6Supported = _ipv6Supported == true,
+                    Addresses = [.. LocalAddresses.Sample()],
+                },
         };
-        return JsonSerializer.SerializeToElement(meta, MoShiroJsonContext.Default.AgentHelloMeta);
+        return JsonSerializer.SerializeToElement(meta, MoShiroJsonContext.Default.NodeHelloMeta);
     }
 
     private long _lastIn;
@@ -356,24 +408,25 @@ public sealed class AgentApp : IDisposable, IAsyncDisposable
         long packetsIn = _counters.PacketsIn;
         long packetsOut = _counters.PacketsOut;
         NodeLogBatch logBatch = _logBatchSource?.TakeBatch(16) ?? new NodeLogBatch([], 0);
-        var extra = new AgentHeartbeatExtra
+        UpdateStatus? updateStatus = _nativeUpdate?.Status() ?? _update?.Status();
+        var extra = new NodeHeartbeatExtra
         {
-            RuntimeStatus = _update?.Status().State == "applying" ? NodeRuntimeStatus.Updating : NodeRuntimeStatus.Running,
+            RuntimeStatus = updateStatus?.State == "applying" ? NodeRuntimeStatus.Updating : !_listening && _dialer.Directory.Targets.Count == 0 ? NodeRuntimeStatus.Idle : NodeRuntimeStatus.Running,
             Ipv6 = Ipv6Diagnostics.Sample(_ipv6Supported, Environment.GetEnvironmentVariable("MOSHIRO_NETWORK_SCOPE"), Environment.GetEnvironmentVariable("HOST_PROC")),
-            Probes = [.. _hub.ConnectedProbes()],
-            Sessions = _sessions.All.Count,
+            Links = _dialer.SnapshotLinks(),
+            Dialers = [.. _hub.ConnectedDialers()],
             PpsIn = _lastAtMs == 0 ? 0 : (packetsIn - _lastIn) / seconds,
             PpsOut = _lastAtMs == 0 ? 0 : (packetsOut - _lastOut) / seconds,
             DroppedInvalid = _counters.DroppedInvalid,
             DroppedRateLimited = _counters.DroppedRateLimited,
             QueueBytes = _outbox.PendingBytes,
-            Update = _update?.Status(),
+            Update = updateStatus,
             RuntimeLogs = logBatch.Records.Count == 0 ? null : [.. logBatch.Records],
             DroppedRuntimeLogs = logBatch.Dropped == 0 ? null : logBatch.Dropped,
         };
         _lastIn = packetsIn;
         _lastOut = packetsOut;
         _lastAtMs = nowMs;
-        return JsonSerializer.SerializeToElement(extra, MoShiroJsonContext.Default.AgentHeartbeatExtra);
+        return JsonSerializer.SerializeToElement(extra, MoShiroJsonContext.Default.NodeHeartbeatExtra);
     }
 }