Stability fixes

src/AppModel/NetDaemon.AppModel.Tests/AppModelTests.cs

@@ -233,6 +233,21 @@ public async Task TestGetApplicationsLocalWithDisposable()
         app!.DisposeIsCalled.Should().BeTrue();
     }
 
+    [Fact]
+    public async Task TestApplicationCanDisposeMultipleTimesWithoutExceptions()
+    {
+        // ARRANGE
+        // ACT
+        var loadApps = await TestHelpers.GetLocalApplicationsFromYamlConfigPath("Fixtures/Local");
+
+        // CHECK
+
+        // check the application instance is init ok
+        var application = loadApps.First(n => n.Id == "LocalApps.MyAppLocalAppWithDispose");
+        await application.DisposeAsync().ConfigureAwait(false);
+        await application.DisposeAsync().ConfigureAwait(false);
+    }
+
     [Fact]
     public async Task TestGetApplicationsLocalWithAsyncDisposable()
     {

src/AppModel/NetDaemon.AppModel.Tests/Context/ApplicationContextTests.cs

@@ -0,0 +1,18 @@
+using NetDaemon.AppModel.Internal;
+using NetDaemon.AppModel.Internal.AppFactories;
+
+namespace NetDaemon.AppModel.Tests.Context;
+
+public class ApplicationContextTests
+{
+    [Fact]
+    public async Task TestApplicationContectIsDisposedMultipleTimesNotThrowsException()
+    {
+        var serviceProvider = new ServiceCollection().BuildServiceProvider();
+        var appFactory = Mock.Of<IAppFactory>();
+        var applicationContext = new ApplicationContext(serviceProvider, appFactory);
+
+        await applicationContext.DisposeAsync();
+        await applicationContext.DisposeAsync();
+    }
+}

src/AppModel/NetDaemon.AppModel/Internal/Context/ApplicationContext.cs

@@ -6,7 +6,7 @@ internal sealed class ApplicationContext : IAsyncDisposable
 {
     private readonly CancellationTokenSource _cancelTokenSource = new();
     private readonly IServiceScope? _serviceScope;
-    private bool _isDisposed;
+    private int _isDisposed; // 0 = false, 1 = true
 
     public ApplicationContext(IServiceProvider serviceProvider, IAppFactory appFactory)
     {
@@ -34,10 +34,8 @@ public async Task InitializeAsync()
 
     public async ValueTask DisposeAsync()
     {
-        // prevent multiple Disposes because the Service Scope will also dispose this
-        if (_isDisposed) return;
-
-        _isDisposed = true;
+        if (Interlocked.CompareExchange(ref _isDisposed, 1, 0) == 1)
+            return;
 
         if (!_cancelTokenSource.IsCancellationRequested)
             await _cancelTokenSource.CancelAsync();

src/Extensions/NetDaemon.Extensions.Scheduling.Tests/Scheduling/DisposableSchedulerTest.cs

@@ -35,6 +35,47 @@ public void _SchedulePeriodicStopsAfterDisposeOfDisposableScheduler()
     }
 
 
+    [Fact]
+    public void PeriodicSchedulerShouldNotCallActionIfItIsDisposedDuringSchedule()
+    {
+        var (inner, disposableScheduler) = CreateScheduler();
+
+        int called = 0;
+        using var _ = disposableScheduler.SchedulePeriodic(TimeSpan.FromMinutes(1), () => called++);
+
+        // Dispose before the time moves forward and trigger a schedule
+        disposableScheduler.Dispose();
+
+        inner.AdvanceBy(TimeSpan.FromMinutes(1).Ticks);
+        called.Should().Be(0);
+    }
+
+    [Fact]
+    public void PeriodicSchedulerShouldNotCallActionIfItIsDisposedBeforeScheduled()
+    {
+        var (inner, disposableScheduler) = CreateScheduler();
+
+        int called = 0;
+        // Dispose before the we call schedule
+        disposableScheduler.Dispose();
+        using var _ = disposableScheduler.SchedulePeriodic(TimeSpan.FromMinutes(1), () => called++);
+        inner.AdvanceBy(TimeSpan.FromMinutes(1).Ticks);
+        called.Should().Be(0);
+    }
+
+    [Fact]
+    public void SchedulerShouldNotCallActionIfItIsDisposedBeforeScheduled()
+    {
+        var (inner, disposableScheduler) = CreateScheduler();
+
+        int called = 0;
+        // Dispose before the we call schedule
+        disposableScheduler.Dispose();
+        using var _ = disposableScheduler.Schedule(() => called++);
+        inner.AdvanceBy(TimeSpan.FromMinutes(1).Ticks);
+        called.Should().Be(0);
+    }
+
     [Fact]
     public void SchedulePeriodicStopsAfterDisposeOfDisposableScheduler()
     {

src/Extensions/NetDaemon.Extensions.Scheduling.Tests/Scheduling/SchedulingTests.cs

@@ -30,6 +30,23 @@ public void TestRunInCallsFunction()
         Assert.True(isCalled);
     }
 
+    [Fact]
+    public void TestRunInDoesNotCallFunctionIfDisposed()
+    {
+        // ARRANGE
+        var testScheduler = new TestScheduler();
+        bool isCalled = false;
+        var netDaemonScheduler = new NetDaemonScheduler(reactiveScheduler: testScheduler);
+        netDaemonScheduler.Dispose();
+        netDaemonScheduler.RunIn(TimeSpan.FromMinutes(1), () => isCalled = true);
+
+        // ACT
+        testScheduler.AdvanceBy(TimeSpan.FromMinutes(1).Ticks);
+
+        // ASSERT
+        Assert.False(isCalled);
+    }
+
     [Fact]
     public void TestRunInShouldNotCallFunctionIfNotDue()
     {
@@ -91,6 +108,29 @@ public void TestRunAtCallsFunction()
         Assert.True(isCalled);
     }
 
+    [Fact]
+    public void TestRunAtNotCallFunctionIfDisposed()
+    {
+        // ARRANGE
+        var testScheduler = new TestScheduler();
+
+        // sets the date to a specific time so we do not get errors in UTC
+        var dueTime = new DateTime(2021, 1, 1, 0, 0, 0);
+        testScheduler.AdvanceTo(dueTime.Ticks);
+
+        bool isCalled = false;
+        var netDaemonScheduler = new NetDaemonScheduler(reactiveScheduler: testScheduler);
+
+        netDaemonScheduler.Dispose();
+        netDaemonScheduler.RunAt(testScheduler.Now.AddHours(1), () => isCalled = true);
+
+        // ACT and ASSERT
+        testScheduler.AdvanceBy(TimeSpan.FromMinutes(30).Ticks);
+        Assert.False(isCalled);
+        testScheduler.AdvanceBy(TimeSpan.FromMinutes(30).Ticks);
+        Assert.False(isCalled);
+    }
+
     [Fact]
     public void TestRunAtLogsException()
     {
@@ -136,6 +176,63 @@ public void TestRunEveryCallsCorrectNrOfTimes()
         Assert.Equal(5, nrOfTimesCalled);
     }
 
+    [Fact]
+    public void TestRunEveryNotCallsIfDisposedBeforeSchedule()
+    {
+        // ARRANGE
+        var testScheduler = new TestScheduler();
+        // sets the date to a specific time so we do not get errors in UTC
+        var dueTime = new DateTime(2021, 1, 1, 0, 0, 0);
+        testScheduler.AdvanceTo(dueTime.Ticks);
+
+        int nrOfTimesCalled = 0;
+        var netDaemonScheduler = new NetDaemonScheduler(reactiveScheduler: testScheduler);
+
+        netDaemonScheduler.Dispose();
+        netDaemonScheduler.RunEvery(TimeSpan.FromSeconds(1), () => nrOfTimesCalled++);
+
+        // ACT and ASSERT
+        testScheduler.AdvanceBy(TimeSpan.FromSeconds(5).Ticks);
+        Assert.Equal(0, nrOfTimesCalled);
+    }
+
+    [Fact]
+    public void TestRunEveryCallsCorrectNrOfTimesIfDisposed()
+    {
+        // ARRANGE
+        var testScheduler = new TestScheduler();
+        // sets the date to a specific time so we do not get errors in UTC
+        var dueTime = new DateTime(2021, 1, 1, 0, 0, 0);
+        testScheduler.AdvanceTo(dueTime.Ticks);
+
+        int nrOfTimesCalled = 0;
+        var netDaemonScheduler = new NetDaemonScheduler(reactiveScheduler: testScheduler);
+
+        netDaemonScheduler.RunEvery(TimeSpan.FromSeconds(1), () => nrOfTimesCalled++);
+
+        // ACT and ASSERT
+        testScheduler.AdvanceBy(TimeSpan.FromSeconds(3).Ticks);
+        Assert.Equal(3, nrOfTimesCalled);
+        netDaemonScheduler.Dispose();
+        testScheduler.AdvanceBy(TimeSpan.FromSeconds(3).Ticks);
+        // No other calls thould been made on a disposed scheduler
+        Assert.Equal(3, nrOfTimesCalled);
+    }
+
+    [Fact]
+    public void SchedulerShouldNotThrowOnMultipleDisposeCalls()
+    {
+        // ARRANGE
+        var testScheduler = new TestScheduler();
+
+        var netDaemonScheduler = new NetDaemonScheduler(reactiveScheduler: testScheduler);
+
+        // ACT and ASSERT
+        // No exception should be thrown calling dispose multiple times
+        netDaemonScheduler.Dispose();
+        netDaemonScheduler.Dispose();
+    }
+
     [Fact]
     public void TestRunEveryLogsException()
     {
@@ -181,6 +278,26 @@ public void TestRunEveryCallsCorrectNrOfTimesUsingForwardTime()
         Assert.Equal(4, nrOfTimesCalled);
     }
 
+    [Fact]
+    public void TestRunEveryNotCallsUsingForwardTimeWhenDisposed()
+    {
+        // ARRANGE
+        var testScheduler = new TestScheduler();
+        // sets the date to a specific time so we do not get errors in UTC
+        var dueTime = new DateTime(2021, 1, 1, 0, 0, 0);
+        testScheduler.AdvanceTo(dueTime.Ticks);
+
+        int nrOfTimesCalled = 0;
+        var netDaemonScheduler = new NetDaemonScheduler(reactiveScheduler: testScheduler);
+        netDaemonScheduler.Dispose();
+
+        netDaemonScheduler.RunEvery(TimeSpan.FromSeconds(1), testScheduler.Now.AddSeconds(2), () => nrOfTimesCalled++);
+
+        // ACT and ASSERT
+        testScheduler.AdvanceBy(TimeSpan.FromSeconds(5).Ticks);
+        Assert.Equal(0, nrOfTimesCalled);
+    }
+
     [Fact]
     public void TestRunEveryLogsExceptionUsingForwardTime()
     {

src/Extensions/NetDaemon.Extensions.Scheduling/DisposableScheduler.cs

@@ -6,26 +6,34 @@ namespace NetDaemon.Extensions.Scheduler;
 /// <summary>
 /// IScheduler decorator that will cancel pending scheduled tasks when Disposed
 /// </summary>
-public sealed class DisposableScheduler : IScheduler, IDisposable
+/// <remarks>
+/// Wraps a scheduler to make it cancel all pending subscriptions on dispose.
+/// </remarks>
+public sealed class DisposableScheduler(IScheduler scheduler) : IScheduler, IDisposable
 {
-    private readonly IScheduler _innerScheduler;
+    private readonly IScheduler _innerScheduler = scheduler;
     private readonly CancellationTokenSource _cancellationTokenSource = new();
     private bool _isDisposed;
 
-    /// <summary>
-    /// Wraps a scheduler to make it cancel all pending subscriptions on dispose.
-    /// </summary>
-    public DisposableScheduler(IScheduler scheduler)
-    {
-        _innerScheduler = scheduler;
-    }
-
     /// <inheritdoc />
     public IDisposable Schedule<TState>(TState state, Func<IScheduler, TState, IDisposable> action)
     {
         if (_isDisposed) return Disposable.Empty;
 
-        return _innerScheduler.Schedule(state, action);
+        CancellationTokenRegistration? cancellationTokenRegistration = null;
+
+        var subscription = _innerScheduler.Schedule(state, (_, d) =>
+        {
+            if (_isDisposed) return Disposable.Empty;
+            // pass this to the action to make sure it will also use this scheduler to schedule subsequent tasks
+            var disposable = action(this, d);
+            cancellationTokenRegistration?.Unregister();
+            return disposable;
+        });
+
+        cancellationTokenRegistration = _cancellationTokenSource.Token.Register(() => subscription.Dispose());
+
+        return subscription;
     }
 
     /// <inheritdoc />
@@ -37,6 +45,7 @@ public IDisposable Schedule<TState>(TState state, TimeSpan dueTime, Func<ISchedu
 
         var subscription = _innerScheduler.Schedule(state, dueTime, (_, d) =>
         {
+            if (_isDisposed) return Disposable.Empty;
             // pass this to the action to make sure it will also use this scheduler to schedule subsequent tasks
             var disposable = action(this, d);
             cancellationTokenRegistration?.Unregister();
@@ -57,6 +66,7 @@ public IDisposable Schedule<TState>(TState state, DateTimeOffset dueTime, Func<I
 
         var subscription = _innerScheduler.Schedule(state, dueTime, (_, d) =>
         {
+            if (_isDisposed) return Disposable.Empty;
             // pass this to the action to make sure it will also use this scheduler to schedule subsequent tasks
             var disposable = action(this, d);
             cancellationTokenRegistration?.Unregister();
@@ -81,4 +91,4 @@ public void Dispose()
             _isDisposed = true;
         }
     }
-}
+}

src/Extensions/NetDaemon.Extensions.Scheduling/DisposableTimer.cs

@@ -1,3 +1,5 @@
+using System.Reactive.Disposables;
+
 namespace NetDaemon.Extensions.Scheduler;
 
 /// <summary>
@@ -8,7 +10,7 @@ public sealed class DisposableTimer : IDisposable
     private readonly CancellationTokenSource _combinedToken;
     private readonly CancellationTokenSource _internalToken;
     private bool _disposed;
-    
+
     /// <summary>
     ///     Constructor
     /// </summary>
@@ -19,6 +21,11 @@ public DisposableTimer(CancellationToken token)
         _combinedToken = CancellationTokenSource.CreateLinkedTokenSource(_internalToken.Token, token);
     }
 
+    /// <summary>
+    ///    Empty disposable timer
+    /// </summary>
+    public static IDisposable Empty => Disposable.Empty;
+
     /// <summary>
     ///     Token to use as cancellation
     /// </summary>
@@ -35,4 +42,4 @@ public void Dispose()
             _disposed = true;
         }
     }
-}
+}