Fix PR #80 review follow-ups

Author: KSemenenko

DotPilot.Runtime.Host/Features/RuntimeFoundation/EmbeddedRuntimeHostBuilderExtensions.cs

@@ -43,6 +43,16 @@ internal static void ConfigureSilo(ISiloBuilder siloBuilder, EmbeddedRuntimeHost
             cluster.ClusterId = options.ClusterId;
             cluster.ServiceId = options.ServiceId;
         });
+        siloBuilder.AddStartupTask(
+            static (serviceProvider, _) =>
+            {
+                serviceProvider
+                    .GetRequiredService<EmbeddedRuntimeHostCatalog>()
+                    .SetState(EmbeddedRuntimeHostState.Running);
+
+                return Task.CompletedTask;
+            },
+            ServiceLifecycleStage.Active);
         siloBuilder.AddMemoryGrainStorage(EmbeddedRuntimeHostNames.GrainStorageProviderName);
         siloBuilder.UseInMemoryReminderService();
     }

DotPilot.Runtime.Host/Features/RuntimeFoundation/EmbeddedRuntimeHostLifecycleService.cs

@@ -4,11 +4,7 @@ namespace DotPilot.Runtime.Host.Features.RuntimeFoundation;
 
 internal sealed class EmbeddedRuntimeHostLifecycleService(EmbeddedRuntimeHostCatalog catalog) : IHostedService
 {
-    public Task StartAsync(CancellationToken cancellationToken)
-    {
-        catalog.SetState(DotPilot.Core.Features.RuntimeFoundation.EmbeddedRuntimeHostState.Running);
-        return Task.CompletedTask;
-    }
+    public Task StartAsync(CancellationToken cancellationToken) => Task.CompletedTask;
 
     public Task StopAsync(CancellationToken cancellationToken)
     {

DotPilot.Runtime/Features/ToolchainCenter/ToolchainCommandProbe.cs

@@ -5,6 +5,7 @@ namespace DotPilot.Runtime.Features.ToolchainCenter;
 internal static class ToolchainCommandProbe
 {
     private static readonly TimeSpan CommandTimeout = TimeSpan.FromSeconds(2);
+    private static readonly TimeSpan RedirectDrainTimeout = TimeSpan.FromSeconds(1);
     private const string VersionSeparator = "version";
     private const string EmptyOutput = "";
 
@@ -87,14 +88,19 @@ private static ToolchainCommandExecution Execute(string executablePath, IReadOnl
 
         using (process)
         {
-            var standardOutputTask = process.StandardOutput.ReadToEndAsync();
-            var standardErrorTask = process.StandardError.ReadToEndAsync();
+            var standardOutputTask = ObserveRedirectedStream(process.StandardOutput.ReadToEndAsync());
+            var standardErrorTask = ObserveRedirectedStream(process.StandardError.ReadToEndAsync());
 
             if (!process.WaitForExit((int)CommandTimeout.TotalMilliseconds))
             {
                 TryTerminate(process);
-                ObserveRedirectedStreamFaults(standardOutputTask, standardErrorTask);
-                return new(true, false, EmptyOutput, EmptyOutput);
+                WaitForTermination(process);
+
+                return new(
+                    true,
+                    false,
+                    AwaitStreamRead(standardOutputTask),
+                    AwaitStreamRead(standardErrorTask));
             }
 
             return new(
@@ -105,10 +111,26 @@ private static ToolchainCommandExecution Execute(string executablePath, IReadOnl
         }
     }
 
+    private static Task<string> ObserveRedirectedStream(Task<string> readTask)
+    {
+        _ = readTask.ContinueWith(
+            static task => _ = task.Exception,
+            CancellationToken.None,
+            TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously,
+            TaskScheduler.Default);
+
+        return readTask;
+    }
+
     private static string AwaitStreamRead(Task<string> readTask)
     {
         try
         {
+            if (!readTask.Wait(RedirectDrainTimeout))
+            {
+                return EmptyOutput;
+            }
+
             return readTask.GetAwaiter().GetResult();
         }
         catch
@@ -117,19 +139,28 @@ private static string AwaitStreamRead(Task<string> readTask)
         }
     }
 
-    private static void ObserveRedirectedStreamFaults(Task<string> standardOutputTask, Task<string> standardErrorTask)
+    private static void TryTerminate(Process process)
     {
-        _ = standardOutputTask.Exception;
-        _ = standardErrorTask.Exception;
+        try
+        {
+            if (!process.HasExited)
+            {
+                process.Kill(entireProcessTree: true);
+            }
+        }
+        catch
+        {
+            // Best-effort cleanup only.
+        }
     }
 
-    private static void TryTerminate(Process process)
+    private static void WaitForTermination(Process process)
     {
         try
         {
             if (!process.HasExited)
             {
-                process.Kill(entireProcessTree: true);
+                process.WaitForExit((int)RedirectDrainTimeout.TotalMilliseconds);
             }
         }
         catch

DotPilot.Tests/Features/RuntimeFoundation/EmbeddedRuntimeHostTests.cs

@@ -60,6 +60,25 @@ public async Task CatalogTransitionsToRunningStateAfterHostStartAsync()
         snapshot.State.Should().Be(EmbeddedRuntimeHostState.Running);
     }
 
+    [Test]
+    public async Task LifecycleServiceDoesNotMarkTheCatalogRunningBeforeTheSiloStartupTaskRuns()
+    {
+        var options = CreateOptions();
+        using var host = CreateHost(options);
+        var lifecycleService = host.Services
+            .GetServices<IHostedService>()
+            .Single(service => service.GetType().Name == "EmbeddedRuntimeHostLifecycleService");
+
+        await lifecycleService.StartAsync(CancellationToken.None);
+
+        host.Services
+            .GetRequiredService<IEmbeddedRuntimeHostCatalog>()
+            .GetSnapshot()
+            .State
+            .Should()
+            .Be(EmbeddedRuntimeHostState.Stopped);
+    }
+
     [Test]
     public async Task InitialGrainsReturnNullBeforeTheirFirstWrite()
     {