feat: choose which probes link to which agents from the admin

The panel decides the probe/agent pairs and probes always dial out. A new
fleet.auto_link setting connects every probe to every agent (default); with it
off only the pairs chosen by hand connect, and any pair can be forced on or
off. The Probes page has a link matrix with the switch and per-pair toggles.

backend/src/Monitor.Backend.Application/Admin/SettingsService.cs

@@ -13,6 +13,7 @@ public sealed class SettingsService
 {
     public const string SitePublic = "site.public";
     public const string SiteShowBuild = "site.show_build";
+    public const string AutoLink = "fleet.auto_link";
     public const string RawDays = "retention.raw_days";
     public const string TestRawDays = "retention.test_raw_days";
     public const string Metric10sHours = "retention.metric_10s_hours";
@@ -42,6 +43,7 @@ public sealed class SettingsService
     [
         new(SitePublic, "bool", "false", 0, 1, "Whether anonymous visitors can read the public API."),
         new(SiteShowBuild, "bool", "false", 0, 1, "Whether the public pages show the versions, tags and build times of the backend, agents and probes."),
+        new(AutoLink, "bool", "true", 0, 1, "Whether every probe connects to every agent automatically; when off, only the links chosen by hand are connected."),
         new(RawDays, "int", o.RawRetentionDays.ToString(CultureInfo.InvariantCulture), 1, 365, "Days to keep raw chunks of continuous tasks."),
         new(TestRawDays, "int", o.TestRawRetentionDays.ToString(CultureInfo.InvariantCulture), 1, 365, "Days to keep raw chunks of on-demand tests."),
         new(Metric10sHours, "int", o.Metric10sRetentionHours.ToString(CultureInfo.InvariantCulture), 1, 720, "Hours to keep the 10 s metric layer."),

backend/src/Monitor.Backend.Application/Agents/AgentService.cs

@@ -21,9 +21,11 @@ public sealed partial class AgentService
     private readonly ISettingsStore _settings;
 
     private readonly NodeInfoService _nodes;
+    private readonly LinkService _links;
 
-    public AgentService(IAgentStore agents, AgentRuntime runtime, IAgentGateway gateway, TaskPlanner planner, ISettingsStore settings, NodeInfoService nodes)
+    public AgentService(IAgentStore agents, AgentRuntime runtime, IAgentGateway gateway, TaskPlanner planner, ISettingsStore settings, NodeInfoService nodes, LinkService links)
     {
+        _links = links;
         _nodes = nodes;
         _agents = agents;
         _runtime = runtime;
@@ -118,17 +120,19 @@ public sealed partial class AgentService
         await _gateway.DisconnectAsync(id, "deleted", ct);
         await _agents.DeleteAsync(id, ct);
         await _nodes.ForgetAsync(id.Value, ct);
+        await _links.ForgetNodeAsync(id.Value, ct);
         _runtime.Remove(id);
         await AfterAgentSetChangedAsync(ct);
     }
 
-    /// <summary>Probe 需要连接的 Agent 列表（所有已激活的 Agent）。版本号在列表变化时递增。</summary>
-    public async ValueTask<ProbeAgentList> ProbeAgentsAsync(CancellationToken ct)
+    /// <summary>这个 Probe 要连接的 Agent 列表（已激活、有公开地址，并且线路是开着的）。版本号在列表变化时递增。</summary>
+    public async ValueTask<ProbeAgentList> ProbeAgentsAsync(string probeId, CancellationToken ct)
     {
+        LinkSnapshot links = await _links.SnapshotAsync(ct);
         IReadOnlyList<AgentRecord> agents = await _agents.ListAsync(ct);
         long version = long.TryParse(await _settings.GetAsync(TaskPlanner.ProbeAgentsVersionKey, ct), out long v) ? v : 0;
         var result = new ProbeAgentList { Version = version };
-        foreach (AgentRecord agent in agents.Where(a => a.Status == NodeStatus.Active && a.PublicHost.Length > 0))
+        foreach (AgentRecord agent in agents.Where(a => a.Status == NodeStatus.Active && a.PublicHost.Length > 0 && links.IsLinked(probeId, a.Id.Value)))
         {
             result.Agents.Add(new AgentEndpoint
             {

backend/src/Monitor.Backend.Application/Agents/LinkService.cs

@@ -0,0 +1,68 @@
+namespace Monitor.Backend.Application;
+
+/// <summary>某一时刻的「线路」开关：自动连接的总开关，加上每一对（Probe，Agent）的手动设置。</summary>
+public sealed class LinkSnapshot
+{
+    private readonly Dictionary<(string Probe, string Agent), bool> _overrides;
+
+    public LinkSnapshot(bool auto, Dictionary<(string Probe, string Agent), bool> overrides)
+    {
+        Auto = auto;
+        _overrides = overrides;
+    }
+
+    /// <summary>自动连接：开着时，没有手动设置的 Probe 和 Agent 都会连；关着时，只有手动开启的才连。</summary>
+    public bool Auto { get; }
+
+    /// <summary>手动设置：<c>true</c> 强制连、<c>false</c> 强制不连、<c>null</c> 没设置（跟随自动连接）。</summary>
+    public bool? OverrideOf(string probeId, string agentId) => _overrides.TryGetValue((probeId, agentId), out bool value) ? value : null;
+
+    /// <summary>这一对最终连不连：手动设置优先，没有就看自动连接。</summary>
+    public bool IsLinked(string probeId, string agentId) => OverrideOf(probeId, agentId) ?? Auto;
+}
+
+/// <summary>
+/// 哪些（Probe，Agent）要连成线路。由面板决定、Probe 主动拨出：自动连接开着时所有 Probe 和 Agent 两两连（默认），
+/// 关着时只连手动选中的；每一对还可以手动强制开或关。手动设置存在设置表里（<c>link.&lt;probe&gt;.&lt;agent&gt;</c>，值 1 或 0，空表示没设置）。
+/// 判断结果分别用在 Probe 的 Agent 列表、Agent 允许的 Probe（<c>peers</c>）和线路目录里；改动之后要调用 <see cref="AgentService.AfterAgentSetChangedAsync"/> 重新下发。
+/// </summary>
+public sealed class LinkService
+{
+    private const string Prefix = "link.";
+
+    private readonly ISettingsStore _settings;
+
+    public LinkService(ISettingsStore settings)
+    {
+        _settings = settings;
+    }
+
+    public async ValueTask<LinkSnapshot> SnapshotAsync(CancellationToken ct)
+    {
+        IReadOnlyDictionary<string, string> all = await _settings.GetAllAsync(ct);
+        var overrides = new Dictionary<(string, string), bool>();
+        foreach ((string key, string value) in all)
+        {
+            string[] parts = key.Split('.');
+            if (parts.Length == 3 && parts[0] + "." == Prefix && value is "1" or "0")
+            {
+                overrides[(parts[1], parts[2])] = value == "1";
+            }
+        }
+
+        return new LinkSnapshot(all.GetValueOrDefault(SettingsService.AutoLink) != "false", overrides);
+    }
+
+    /// <summary>手动设置一对线路：<c>true</c> 强制连、<c>false</c> 强制不连、<c>null</c> 取消手动设置。</summary>
+    public ValueTask SetAsync(string probeId, string agentId, bool? enabled, CancellationToken ct) =>
+        _settings.SetAsync($"{Prefix}{probeId}.{agentId}", enabled is null ? "" : enabled.Value ? "1" : "0", ct);
+
+    /// <summary>Probe 或 Agent 被删除：清掉所有涉及它的手动设置。</summary>
+    public async ValueTask ForgetNodeAsync(string nodeId, CancellationToken ct)
+    {
+        foreach (string key in (await _settings.GetAllAsync(ct)).Keys.Where(k => k.StartsWith(Prefix, StringComparison.Ordinal) && k.Split('.').Skip(1).Contains(nodeId)))
+        {
+            await _settings.SetAsync(key, "", ct);
+        }
+    }
+}

backend/src/Monitor.Backend.Application/Agents/ProbeService.cs

@@ -33,9 +33,11 @@ public sealed partial class ProbeService
     private readonly IAgentGateway _gateway;
     private readonly TimeProvider _time;
     private readonly NodeInfoService _nodes;
+    private readonly LinkService _links;
 
-    public ProbeService(IProbeStore probes, IAgentStore agents, AgentRuntime runtime, IAgentGateway gateway, TimeProvider time, NodeInfoService nodes)
+    public ProbeService(IProbeStore probes, IAgentStore agents, AgentRuntime runtime, IAgentGateway gateway, TimeProvider time, NodeInfoService nodes, LinkService links)
     {
+        _links = links;
         _nodes = nodes;
         _probes = probes;
         _agents = agents;
@@ -137,6 +139,7 @@ public sealed partial class ProbeService
         if (deleted)
         {
             await _nodes.ForgetAsync(id, ct);
+            await _links.ForgetNodeAsync(id, ct);
             _gateway.NotifyAllTaskSetsChanged();
         }
 

backend/src/Monitor.Backend.Application/ApplicationServiceCollectionExtensions.cs

@@ -29,6 +29,7 @@ public static class ApplicationServiceCollectionExtensions
         services.AddSingleton<HostStatusService>();
         services.AddSingleton<NodeInfoService>();
         services.AddSingleton<ProbeService>();
+        services.AddSingleton<LinkService>();
         services.AddSingleton<LineService>();
         services.AddSingleton<TestService>();
         services.AddSingleton<IngestService>();

backend/src/Monitor.Backend.Application/Query/Lines.cs

@@ -39,19 +39,22 @@ public sealed class LineService
 {
     private readonly AgentService _agents;
     private readonly IProbeStore _probes;
+    private readonly LinkService _links;
 
-    public LineService(AgentService agents, IProbeStore probes)
+    public LineService(AgentService agents, IProbeStore probes, LinkService links)
     {
+        _links = links;
         _agents = agents;
         _probes = probes;
     }
 
-    /// <summary>所有线路：每个 Agent 和每个<b>未吊销</b>的 Probe 配成一对。</summary>
+    /// <summary>所有线路：每个 Agent 和每个<b>未吊销</b>的 Probe 配成一对，只留下线路开着的（见 <see cref="LinkService"/>）；关掉的线路历史数据还在，按 id 仍然查得到。</summary>
     public async ValueTask<IReadOnlyList<LineView>> ListAsync(Func<AgentView, bool> include, CancellationToken ct)
     {
         IReadOnlyList<AgentView> agents = await _agents.ListAsync(ct);
         IReadOnlyList<ProbeRecord> probes = [.. (await _probes.ListAsync(ct)).Where(p => p.RevokedAtMs is null)];
-        return [.. agents.Where(include).SelectMany(a => probes.Select(p => new LineView(a, p)))];
+        LinkSnapshot links = await _links.SnapshotAsync(ct);
+        return [.. agents.Where(include).SelectMany(a => probes.Where(p => links.IsLinked(p.Id, a.Agent.Id.Value)).Select(p => new LineView(a, p)))];
     }
 
     /// <summary>

backend/src/Monitor.Backend.Application/Tasks/TaskPlanner.cs

@@ -20,10 +20,12 @@ public sealed class TaskPlanner : IDisposable
     private readonly IAgentStore _agents;
     private readonly IProbeStore _probes;
     private readonly ISettingsStore _settings;
+    private readonly LinkService _links;
     private readonly SemaphoreSlim _gate = new(1, 1);
 
-    public TaskPlanner(ITaskStore tasks, IAgentStore agents, IProbeStore probes, ISettingsStore settings)
+    public TaskPlanner(ITaskStore tasks, IAgentStore agents, IProbeStore probes, ISettingsStore settings, LinkService links)
     {
+        _links = links;
         _tasks = tasks;
         _agents = agents;
         _probes = probes;
@@ -41,6 +43,7 @@ public sealed class TaskPlanner : IDisposable
 
         IReadOnlyList<TaskRecord> all = await _tasks.ListAsync(ct);
         IReadOnlyList<ProbeRecord> probes = await _probes.ListAsync(ct);
+        LinkSnapshot links = await _links.SnapshotAsync(ct);
 
         var document = new TaskSet();
         foreach (EffectiveTask task in EffectiveTasks.Compute(all, agent, filterByAgentKinds: true))
@@ -57,7 +60,7 @@ public sealed class TaskPlanner : IDisposable
             });
         }
 
-        foreach (ProbeRecord probe in probes.Where(p => p.RevokedAtMs is null))
+        foreach (ProbeRecord probe in probes.Where(p => p.RevokedAtMs is null && links.IsLinked(p.Id, agentId.Value)))
         {
             document.Peers.Add(new PeerSpec { ProbeId = new ProbeId(probe.Id), PublicKey = Convert.ToBase64String(probe.PublicKey) });
         }