Feature/prevent blocking start async

src/Client/NetDaemon.HassClient/Common/IHomeAssistantRunner.cs

@@ -3,23 +3,22 @@ namespace NetDaemon.Client;
 public interface IHomeAssistantRunner : IAsyncDisposable
 {
     /// <summary>
-    ///     Event when new connection is established
+    /// Observable that emits when a (new) connection is established.
     /// </summary>
     IObservable<IHomeAssistantConnection> OnConnect { get; }
 
     /// <summary>
-    ///     Event when connection is lost
+    /// Observable that emits when the current connection is lost.
     /// </summary>
     IObservable<DisconnectReason> OnDisconnect { get; }
 
     /// <summary>
-    ///     The current connection to Home Assistant
+    /// The current connection to Home Assistant. Null if disconnected.
     /// </summary>
-    /// <value></value>
     IHomeAssistantConnection? CurrentConnection { get; }
 
     /// <summary>
-    ///     Maintains a connection to the Home Assistant server
+    /// Maintains a connection to the Home Assistant server
     /// </summary>
     /// <param name="host">Host of Home Assistant instance</param>
     /// <param name="port">Port of Home Assistant instance</param>
@@ -30,7 +29,7 @@ public interface IHomeAssistantRunner : IAsyncDisposable
     Task RunAsync(string host, int port, bool ssl, string token, TimeSpan timeout, CancellationToken cancelToken);
 
     /// <summary>
-    ///     Maintains a connection to the Home Assistant server
+    /// Maintains a connection to the Home Assistant server
     /// </summary>
     /// <param name="host">Host of Home Assistant instance</param>
     /// <param name="port">Port of Home Assistant instance</param>
@@ -40,4 +39,4 @@ public interface IHomeAssistantRunner : IAsyncDisposable
     /// <param name="timeout">Wait time between connects</param>
     /// <param name="cancelToken">Cancel token</param>
     Task RunAsync(string host, int port, bool ssl, string token, string websocketPath, TimeSpan timeout, CancellationToken cancelToken);
-}
+}

src/Client/NetDaemon.HassClient/Internal/HomeAssistantRunner.cs

@@ -12,7 +12,7 @@ internal class HomeAssistantRunner(IHomeAssistantClient client,
 
     private readonly Subject<DisconnectReason> _onDisconnectSubject = new();
 
-    private readonly TimeSpan MaxTimeoutInSeconds = TimeSpan.FromSeconds(80);
+    private readonly TimeSpan _maxTimeoutInSeconds = TimeSpan.FromSeconds(80);
 
     private Task? _runTask;
 
@@ -62,7 +62,7 @@ await Task.WhenAny(
     private async Task InternalRunAsync(string host, int port, bool ssl, string token, string websocketPath, TimeSpan timeout,
         CancellationToken cancelToken)
     {
-        var progressiveTimeout = new ProgressiveTimeout(timeout, MaxTimeoutInSeconds, 2.0);
+        var progressiveTimeout = new ProgressiveTimeout(timeout, _maxTimeoutInSeconds, 2.0);
         var combinedToken = CancellationTokenSource.CreateLinkedTokenSource(_internalTokenSource.Token, cancelToken);
         while (!combinedToken.IsCancellationRequested)
         {

src/HassModel/NetDaemon.HassModel/ICacheManager.cs

@@ -11,4 +11,4 @@ public interface ICacheManager
     /// <param name="cancellationToken"></param>
     /// <returns></returns>
     Task InitializeAsync(CancellationToken cancellationToken);
-}
+}

src/Runtime/NetDaemon.Runtime.Tests/Internal/NetDaemonRuntimeTests.cs

@@ -20,26 +20,22 @@ public sealed class NetDaemonRuntimeTests : IDisposable
 
 
     [Fact]
-    public async Task TestStartAsyncAsync()
+    public async Task TestStartSubscribesToHomeAssistantRunnerEvents()
     {
         await using var runtime = SetupNetDaemonRuntime();
-        var startingTask = runtime.StartAsync(CancellationToken.None);
+        runtime.Start(CancellationToken.None);
 
         _connectSubject.HasObservers.Should().BeTrue();
         _disconnectSubject.HasObservers.Should().BeTrue();
-
-        startingTask.IsCompleted.Should().BeFalse();
     }
 
     [Fact]
     public async Task TestOnConnect()
     {
         await using var runtime = SetupNetDaemonRuntime();
-        var startingTask = runtime.StartAsync(CancellationToken.None);
+        runtime.Start(CancellationToken.None);
 
-        startingTask.IsCompleted.Should().BeFalse();
         _connectSubject.OnNext(_homeAssistantConnectionMock.Object);
-        await startingTask.ConfigureAwait(false);
 
         _appModelMock.Verify(n => n.LoadNewApplicationContext(It.IsAny<CancellationToken>()));
 
@@ -50,12 +46,11 @@ public async Task TestOnConnect()
     public async Task TestOnDisconnect()
     {
         await using var runtime = SetupNetDaemonRuntime();
-        var startingTask = runtime.StartAsync(CancellationToken.None);
+        runtime.Start(CancellationToken.None);
 
         // First make sure we add an connection
         _connectSubject.OnNext(_homeAssistantConnectionMock.Object);
 
-        await startingTask.ConfigureAwait(false);
         runtime.IsConnected.Should().BeTrue();
 
         // Then fake a disconnect
@@ -70,12 +65,11 @@ public async Task TestOnDisconnect()
     public async Task TestReconnect()
     {
         await using var runtime = SetupNetDaemonRuntime();
-        var startingTask = runtime.StartAsync(CancellationToken.None);
+        runtime.Start(CancellationToken.None);
 
         // First make sure we add an connection
         _connectSubject.OnNext(_homeAssistantConnectionMock.Object);
 
-        await startingTask.ConfigureAwait(false);
         runtime.IsConnected.Should().BeTrue();
 
         // Then fake a disconnect
@@ -101,10 +95,15 @@ public async Task TestOnConnectError()
 
         await using var runtime = SetupNetDaemonRuntime();
 
-        var startAsync = runtime.StartAsync(CancellationToken.None);
+        runtime.Start(CancellationToken.None);
         _connectSubject.OnNext(_homeAssistantConnectionMock.Object);
-        Func<Task> startingTask = ()=> startAsync;
-        await startingTask.Should().ThrowAsync<InvalidOperationException>();
+
+        _loggerMock.Verify(
+            x => x.Log(LogLevel.Critical,
+                It.IsAny<EventId>(),
+                It.IsAny<It.IsAnyType>(),
+                It.IsAny<Exception>(),
+                It.Is<Func<It.IsAnyType, Exception, string>>((v, t) => true)!), times: Times.Once);
     }
 
 
@@ -113,15 +112,14 @@ public async Task TestOnReConnectError()
     {
         await using var runtime = SetupNetDaemonRuntime();
 
-        _ = runtime.StartAsync(CancellationToken.None);
+        runtime.Start(CancellationToken.None);
         _connectSubject.OnNext(_homeAssistantConnectionMock.Object);
         _disconnectSubject.OnNext(DisconnectReason.Client);
 
         // now it should err on the second connection
         _cacheManagerMock.Setup(m => m.InitializeAsync(It.IsAny<CancellationToken>())).ThrowsAsync(new InvalidOperationException("Something wrong while initializing"));
         _connectSubject.OnNext(_homeAssistantConnectionMock.Object);
 
-
         _loggerMock.Verify(
             x => x.Log(LogLevel.Critical,
                 It.IsAny<EventId>(),

src/Runtime/NetDaemon.Runtime/Common/Extensions/HostBuilderExtensions.cs

@@ -72,7 +72,9 @@ public static IHostBuilder UseNetDaemonRuntime(this IHostBuilder hostBuilder)
                 services.AddHostedService<RuntimeService>();
                 services.AddHomeAssistantClient();
                 services.Configure<HomeAssistantSettings>(context.Configuration.GetSection("HomeAssistant"));
-                services.AddSingleton<IRuntime, NetDaemonRuntime>();
+                services.AddSingleton<NetDaemonRuntime>();
+                services.AddSingleton<IRuntime>(provider => provider.GetRequiredService<NetDaemonRuntime>());
+                services.AddSingleton<INetDaemonRuntime>(provider => provider.GetRequiredService<NetDaemonRuntime>());
             });
     }
-}
+}

src/Runtime/NetDaemon.Runtime/Common/INetDaemonRuntime.cs

@@ -0,0 +1,12 @@
+namespace NetDaemon.Runtime;
+
+/// <summary>
+/// The NetDaemon runtime interface.
+/// </summary>
+public interface INetDaemonRuntime : IAsyncDisposable
+{
+    /// <summary>
+    /// Method that can be awaited to ensure that the runtime is fully started and initialized (initial connection is created and cache is initialized).
+    /// </summary>
+    Task WaitForInitializationAsync();
+}

src/Runtime/NetDaemon.Runtime/Common/IRuntime.cs

@@ -2,5 +2,8 @@ namespace NetDaemon.Runtime;
 
 internal interface IRuntime : IAsyncDisposable
 {
-    Task StartAsync(CancellationToken stoppingToken);
-}
+    /// <summary>
+    /// Starts the runtime and passes <paramref name="stoppingToken"/> to the runtime task/thread.
+    /// </summary>
+    void Start(CancellationToken stoppingToken);
+}

src/Runtime/NetDaemon.Runtime/Internal/NetDaemonRuntime.cs

@@ -9,11 +9,13 @@
         IServiceProvider serviceProvider,
         ILogger<NetDaemonRuntime> logger,
         ICacheManager cacheManager)
-    : IRuntime
+    : IRuntime, INetDaemonRuntime
 {
     private const string Version = "local build";
     private const int TimeoutInSeconds = 5;
 
+    private readonly TaskCompletionSource _initializationTcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
     private readonly HomeAssistantSettings _haSettings = settings.Value;
 
     private IAppModelContext? _applicationModelContext;
@@ -26,11 +28,9 @@
     internal IReadOnlyCollection<IApplication> ApplicationInstances =>
         _applicationModelContext?.Applications ?? [];
 
-    private readonly TaskCompletionSource _startedAndConnected = new();
-
     private Task _runnerTask = Task.CompletedTask;
 
-    public async Task StartAsync(CancellationToken stoppingToken)
+    public void Start(CancellationToken stoppingToken)
     {
         logger.LogInformation("Starting NetDaemon runtime version {Version}.", Version);
 
@@ -46,6 +46,7 @@
         {
             _runnerCancellationSource = CancellationTokenSource.CreateLinkedTokenSource(stoppingToken);
 
+            // Assign the runner so we can dispose it later. Note that this task contains the connection loop and will not end. We don't want to await it.
             _runnerTask = homeAssistantRunner.RunAsync(
                 _haSettings.Host,
                 _haSettings.Port,
@@ -56,19 +57,16 @@
                 _runnerCancellationSource.Token);
 
             // make sure we cancel the task if the stoppingToken is cancelled
-            stoppingToken.Register(() =>
-            {
-                _startedAndConnected.TrySetCanceled();
-            });
-            // Make sure we only return after the connection is made and initialization is ready
-            await _startedAndConnected.Task;
+            stoppingToken.Register(() => _initializationTcs.TrySetCanceled());
         }
         catch (OperationCanceledException)
         {
             // Ignore and just stop
         }
     }
 
+    public Task WaitForInitializationAsync() => _initializationTcs.Task;
+
     private async Task OnHomeAssistantClientConnected(
         IHomeAssistantConnection haConnection,
         CancellationToken cancelToken)
@@ -80,7 +78,7 @@
             if (_applicationModelContext is not null)
             {
                 // Something wrong with unloading and disposing apps on restart of HA, we need to prevent apps loading multiple times
-                logger.LogWarning("Applications were not successfully disposed during restart, skippin loading apps again");
+                logger.LogWarning("Applications were not successfully disposed during restart, skipping loading apps again");
                 return;
             }
 
@@ -90,21 +88,18 @@
 
             await LoadNewAppContextAsync(haConnection, cancelToken);
 
-            _startedAndConnected.TrySetResult();
+            // Signal anyone waiting that the runtime is now initialized
+            _initializationTcs.TrySetResult();
         }
         catch (Exception ex)
         {
-            if (!_startedAndConnected.Task.IsCompleted)
+            if (!_initializationTcs.Task.IsCompleted)
             {
                 // This means this was the first time we connected and StartAsync is still awaiting _startedAndConnected
                 // By setting the exception on the task it will propagate up.
-                _startedAndConnected.SetException(ex);
-            }
-            else
-            {
-                // There is none waiting for this event handler to finish so we need to Log the exception here
-                logger.LogCritical(ex, "Error re-initializing after reconnect to Home Assistant");
+                _initializationTcs.SetException(ex);
             }
+            logger.LogCritical(ex, "Error (re-)initializing after connect to Home Assistant");
         }
     }
 
@@ -150,13 +145,14 @@
         {
             logger.LogError(e, "Error disposing applications");
         }
-        IsConnected = false;
 
         if (reason == DisconnectReason.Unauthorized)
         {
-            // We will exit the runtime if the token is unauthorized to avoid hammering the server
-            _startedAndConnected.SetResult();
+            logger.LogInformation("Home Assistant runtime will dispose itself to stop automatic retrying to prevent user from being locked out.");
+            await DisposeAsync();
         }
+
+        IsConnected = false;
     }
 
     private async Task DisposeApplicationsAsync()

src/Runtime/NetDaemon.Runtime/Internal/RuntimeService.cs

@@ -6,7 +6,7 @@ public override async Task StartAsync(CancellationToken cancellationToken)
     {
         try
         {
-            await runtime.StartAsync(cancellationToken);
+            runtime.Start(cancellationToken);
             await base.StartAsync(cancellationToken);
         }
         catch (OperationCanceledException) { }

tests/Integration/NetDaemon.Tests.Integration/Helpers/NetDaemonIntegrationBase.cs

@@ -45,9 +45,18 @@ private IHost StartNetDaemon()
             ).Build();
 
         netDaemon.Start();
+
+        WaitForRuntimeToBeInitialized(netDaemon).GetAwaiter().GetResult();
+
         return netDaemon;
     }
 
+    private static async Task WaitForRuntimeToBeInitialized(IHost host)
+    {
+        var netDaemonRuntime = host.Services.GetRequiredService<INetDaemonRuntime>();
+        await netDaemonRuntime.WaitForInitializationAsync();
+    }
+
     /// <summary>
     /// Runs the specified function without a synchronization context and restores the synchronization context afterwards.
     /// </summary>