refactor!: rename the project from Monitor to MoShiro [CI]

Namespaces, assemblies, solution, binaries, images, systemd units, config paths, environment variables, protocol methods and the Linux user are all renamed. Breaking: existing databases, node identities and installed units must be recreated.

backend/agent/src/MoShiro.Agent/Tasks/TargetRunners.cs

@@ -0,0 +1,163 @@
+using System.Net;
+using System.Text.Json;
+using Fleet.Core;
+using MoShiro.Measurement;
+using MoShiro.Protocol;
+
+namespace MoShiro.Agent;
+
+/// <summary>
+/// 目标任务（Agent 自己探测一个地址，没有对端）：用和线路任务同一套积木（<see cref="BlockCatalog"/> 里的拨号方，例如 icmp_echo、connect），
+/// 只是列块不交给 Agent 合并，而是自己盖章、10 秒一块直接上传。目标地址必须在本地 <c>allowed_target_cidrs</c> 内
+/// （由 <see cref="BudgetGuard"/> 在接受任务之前检查）。
+/// </summary>
+public sealed class TargetRunners
+{
+    private static readonly TimeSpan s_chunkSpan = TimeSpan.FromSeconds(ProtocolLimits.ChunkSeconds);
+
+    private readonly Dictionary<string, Running> _running = [];
+    private readonly object _gate = new();
+    private readonly ChunkAssembler _chunks;
+    private readonly NodeId _agent;
+    private readonly MonoClock _clock;
+    private readonly TimeProvider _time;
+    private readonly INodeLog _log;
+
+    public TargetRunners(ChunkAssembler chunks, NodeId agent, MonoClock clock, TimeProvider time, INodeLog log)
+    {
+        _chunks = chunks;
+        _agent = agent;
+        _clock = clock;
+        _time = time;
+        _log = log;
+    }
+
+    /// <summary>让运行中的任务与期望集合一致：参数没有变化的保持，其余启动或停止。</summary>
+    public void Reconcile(IReadOnlyList<(TaskSpec Spec, TaskDecision Decision)> desired)
+    {
+        lock (_gate)
+        {
+            var wanted = desired.ToDictionary(d => d.Spec.Id.Value, d => d);
+            foreach ((string id, Running running) in _running.ToList())
+            {
+                if (!wanted.TryGetValue(id, out (TaskSpec Spec, TaskDecision Decision) entry) || Signature(entry.Spec) != running.Signature)
+                {
+                    running.Cancel.Cancel();
+                    _running.Remove(id);
+                }
+            }
+
+            foreach ((string id, (TaskSpec spec, TaskDecision decision)) in wanted)
+            {
+                if (_running.ContainsKey(id))
+                {
+                    continue;
+                }
+
+                var cts = new CancellationTokenSource();
+                _running[id] = new Running(Signature(spec), cts);
+                _ = Task.Run(() => RunAsync(spec, decision, cts.Token), CancellationToken.None);
+            }
+        }
+    }
+
+    private static string Signature(TaskSpec spec) =>
+        spec.Kind + "|" + spec.Target + "|" + string.Join(',', spec.Params.OrderBy(p => p.Key, StringComparer.Ordinal).Select(p => p.Key + "=" + p.Value.GetRawText()));
+
+    private async Task RunAsync(TaskSpec spec, TaskDecision decision, CancellationToken ct)
+    {
+        try
+        {
+            if (!TryResolve(spec.Target!, decision.Resolved!, spec.Kind, out IPAddress? address, out int port))
+            {
+                _log.Warn("target is not an address", ("task", spec.Id.Value));
+                return;
+            }
+
+            var env = new BlockEnv
+            {
+                Clock = _clock,
+                Log = _log,
+                Session = () => null,
+                PeerAddress = address,
+                Fragments = new LocalSink(this, spec),
+            };
+            IBlock block = BlockCatalog.Find(spec.Kind)!.Dialer(env, new BlockSpec(decision.Kind!, decision.Resolved!, 0, port, new FragmentScope(spec.Id, null, null)));
+            using var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
+            Task run = block.RunAsync(cts.Token);
+            try
+            {
+                using var timer = new PeriodicTimer(s_chunkSpan, _time);
+                while (await timer.WaitForNextTickAsync(ct))
+                {
+                    block.Flush(FlushMode.Settled);
+                }
+            }
+            finally
+            {
+                await cts.CancelAsync();
+                await run;
+                block.Flush(FlushMode.All);
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            // 任务被撤销
+        }
+        catch (Exception ex) when (ex is System.Net.Sockets.SocketException or InvalidOperationException or BlockFaultException)
+        {
+            _log.Warn("target task stopped", ("task", spec.Id.Value), ("err", ex.Message));
+        }
+    }
+
+    private static bool TryResolve(string target, ParamValues values, string kind, out IPAddress address, out int port)
+    {
+        port = kind == "connect" ? (int)values.GetInt("port") : 0;
+        if (IPEndPoint.TryParse(target, out IPEndPoint? endpoint))
+        {
+            address = endpoint.Address;
+            if (endpoint.Port != 0)
+            {
+                port = endpoint.Port;
+            }
+
+            return true;
+        }
+
+        return IPAddress.TryParse(target, out address!);
+    }
+
+    /// <summary>目标任务的行没有 Probe 一侧可以合并：积木交出的就是完整的行，Agent 自己盖章（目标、时钟锚点）并放进发件箱。</summary>
+    private sealed class LocalSink : IFragmentSink
+    {
+        private readonly TargetRunners _owner;
+        private readonly TaskSpec _spec;
+
+        public LocalSink(TargetRunners owner, TaskSpec spec)
+        {
+            _owner = owner;
+            _spec = spec;
+        }
+
+        public void Ship(string kind, FragmentScope scope, IReadOnlyList<RawStream> streams, IReadOnlyDictionary<string, JsonElement>? parameters, long startUtcMs, int durationMs, int port)
+        {
+            ClockAnchor anchor = _owner._clock.Anchor();
+            var header = new RawChunkHeader
+            {
+                ChunkId = ChunkId.New(_owner._time),
+                Kind = kind,
+                TaskId = scope.Task,
+                AgentId = _owner._agent,
+                Target = _spec.Target,
+                Params = parameters is null ? [] : new Dictionary<string, JsonElement>(parameters),
+                Port = port,
+                StartUtcMs = startUtcMs,
+                DurationMs = Math.Clamp(durationMs, 1, ChunkFinalizer.MaxDurationMs),
+                Clock = new ChunkClock { AgentMonoUs = anchor.AgentMonoUs, UtcMs = anchor.UtcMs, ProbeOffsetUs = 0 },
+            };
+            _owner._chunks.Emit(new RawChunk(header, streams));
+        }
+    }
+
+    private sealed record Running(string Signature, CancellationTokenSource Cancel);
+}