fix(site-runtime): resolve SiteRuntime-004..011 — deploy-after-persist, remove reflection, deterministic IDs, non-blocking startup, dedicated script scheduler, config-change detection, semantic trust-model check

src/ScadaLink.SiteRuntime/Scripts/ScriptExecutionScheduler.cs

@@ -0,0 +1,107 @@
+using System.Collections.Concurrent;
+
+namespace ScadaLink.SiteRuntime.Scripts;
+
+/// <summary>
+/// SiteRuntime-009: a dedicated, bounded <see cref="TaskScheduler"/> for running script
+/// and alarm on-trigger bodies.
+///
+/// Script bodies may perform synchronous blocking I/O (a database connection, a
+/// synchronous external-system call). Running them on the shared .NET
+/// <see cref="ThreadPool"/> lets a burst of blocking scripts starve the pool and stall
+/// unrelated Akka dispatchers and HTTP request handling. This scheduler owns a fixed set
+/// of dedicated threads, so script blocking is contained to those threads and cannot
+/// exhaust the global pool.
+///
+/// The scheduler is process-wide (one set of threads for all instances) and is sized
+/// from <see cref="SiteRuntimeOptions"/> the first time it is configured.
+/// </summary>
+public sealed class ScriptExecutionScheduler : TaskScheduler, IDisposable
+{
+    private readonly BlockingCollection<Task> _queue = new();
+    private readonly List<Thread> _threads;
+    private int _disposed;
+
+    private static volatile ScriptExecutionScheduler? _shared;
+    private static readonly object SharedLock = new();
+
+    /// <summary>
+    /// The process-wide script-execution scheduler. Lazily created on first use with the
+    /// thread count from <see cref="SiteRuntimeOptions.ScriptExecutionThreadCount"/>; the
+    /// first caller wins, subsequent calls reuse the existing instance.
+    /// </summary>
+    public static ScriptExecutionScheduler Shared(SiteRuntimeOptions options)
+    {
+        if (_shared != null)
+            return _shared;
+
+        lock (SharedLock)
+        {
+            return _shared ??= new ScriptExecutionScheduler(options.ScriptExecutionThreadCount);
+        }
+    }
+
+    /// <summary>
+    /// Creates a scheduler backed by <paramref name="threadCount"/> dedicated threads.
+    /// </summary>
+    public ScriptExecutionScheduler(int threadCount)
+    {
+        if (threadCount < 1)
+            threadCount = 1;
+
+        _threads = new List<Thread>(threadCount);
+        for (var i = 0; i < threadCount; i++)
+        {
+            var thread = new Thread(WorkerLoop)
+            {
+                IsBackground = true,
+                Name = $"script-execution-{i}"
+            };
+            _threads.Add(thread);
+            thread.Start();
+        }
+    }
+
+    /// <summary>The number of dedicated worker threads.</summary>
+    public override int MaximumConcurrencyLevel => _threads.Count;
+
+    private void WorkerLoop()
+    {
+        try
+        {
+            foreach (var task in _queue.GetConsumingEnumerable())
+            {
+                TryExecuteTask(task);
+            }
+        }
+        catch (ObjectDisposedException)
+        {
+            // Scheduler disposed — worker exits.
+        }
+    }
+
+    protected override void QueueTask(Task task) => _queue.Add(task);
+
+    protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
+    {
+        // Only inline if we are already on one of this scheduler's worker threads,
+        // so script work never escapes onto a thread-pool thread.
+        if (Thread.CurrentThread.Name?.StartsWith("script-execution-", StringComparison.Ordinal) != true)
+            return false;
+
+        return TryExecuteTask(task);
+    }
+
+    protected override IEnumerable<Task> GetScheduledTasks() => _queue.ToArray();
+
+    public void Dispose()
+    {
+        if (Interlocked.Exchange(ref _disposed, 1) != 0)
+            return;
+
+        _queue.CompleteAdding();
+        foreach (var thread in _threads)
+            thread.Join(TimeSpan.FromSeconds(5));
+        _queue.Dispose();
+    }
+}