From 55f5d5e072ed23d5cb7c23fd2bb67ec727f9e20a Mon Sep 17 00:00:00 2001
From: Optic00 <benjamin.busche@gmail.com>
Date: Sat, 25 Jul 2026 17:18:04 +0200
Subject: [PATCH 1/2] fix(monitoring): harden ONT/CM/Cellular Disable/Enable
 toggle (review follow-ups)

Pattern-wide robustness fixes from the adversarial review of the toggle,
applied across all three device types.

#1 Atomic anti-resurrection guard: UpdateXxxPollResultAsync now performs a
single conditional ExecuteUpdate WHERE Id == id && Enabled instead of a
read-then-SaveChanges, closing the TOCTOU where a Disable committing between
the read and the write could still overwrite a paused row's frozen state.
Repo tests moved from the EF InMemory provider to SQLite in-memory (InMemory
cannot execute ExecuteUpdate) + a relational mid-poll-disable regression per type.

#2 Disabled devices are no longer contacted or falsely reported on the service
paths: PollCmAsync / PollModemAsync / the ONT manual poll short-circuit when the
config is disabled (Cellular returns a clear 'disabled' message instead of a
false 'polled successfully'), and the Cellular card skips auto-polling a disabled
config on initial load and when paging between modems. The dashboard-card side of
this (Refresh button state, server-side refresh guard, timer config reload) is
already covered by 618c2e90 and is not duplicated here. The non-persisting
Test/Probe buttons are unchanged.

#3 Removed the redundant 'Enable polling' checkbox from the ONT/CM/Cellular edit
forms (the row Disable/Enable toggle is the single control) and stopped
SaveXxxConfigurationAsync from copying Enabled on update, so a stale open edit
form can no longer resurrect a row the toggle just disabled. Starlink untouched.

#4 A persistence exception is no longer swallowed into the same 'false' the guard
uses for a disabled row: the poll success helpers rethrow, so a real DB write
failure on an enabled device surfaces via the error path instead of silently
dropping valid stats. Both call sites already run inside a catch that records the
failure on the config, so the poll loops stay alive.
---
 .../Repositories/CmRepository.cs              | 26 +++----
 .../Repositories/ModemRepository.cs           | 26 +++----
 .../Repositories/OntRepository.cs             | 26 +++----
 .../Components/Pages/Settings.razor           | 20 ------
 .../Shared/CellularStatsPanel.razor           |  4 +-
 .../Services/CableModemMonitorService.cs      |  7 +-
 .../Services/CellularModemService.cs          | 10 ++-
 .../Services/OntMonitorService.cs             |  5 ++
 .../CmRepositoryTests.cs                      | 68 ++++++++++++++++++-
 .../ModemRepositoryTests.cs                   | 63 ++++++++++++++++-
 .../OntRepositoryTests.cs                     | 68 ++++++++++++++++++-
 11 files changed, 255 insertions(+), 68 deletions(-)

diff --git a/src/NetworkOptimizer.Storage/Repositories/CmRepository.cs b/src/NetworkOptimizer.Storage/Repositories/CmRepository.cs
index 2fb4100cd1..e3188d1d28 100644
--- a/src/NetworkOptimizer.Storage/Repositories/CmRepository.cs
+++ b/src/NetworkOptimizer.Storage/Repositories/CmRepository.cs
@@ -84,7 +84,6 @@ public async Task SaveCmConfigurationAsync(CmConfiguration config, CancellationT
                     existing.Username = config.Username;
                     existing.Password = config.Password;
                     existing.StatusPagePath = config.StatusPagePath;
-                    existing.Enabled = config.Enabled;
                     existing.PollingIntervalSeconds = config.PollingIntervalSeconds;
                     existing.LastPolled = config.LastPolled;
                     existing.LastError = config.LastError;
@@ -154,19 +153,20 @@ public async Task<bool> UpdateCmPollResultAsync(int id, DateTime? lastPolled, st
     {
         try
         {
-            var config = await _context.CmConfigurations.FirstOrDefaultAsync(c => c.Id == id, cancellationToken);
-            // Never resurrect or overwrite a config that was disabled while the poll was
-            // in flight - its frozen state (and cleared LastError) must stand.
-            if (config == null || !config.Enabled)
-                return false;
-
+            var now = DateTime.UtcNow;
+            int rows;
             if (lastPolled.HasValue)
-                config.LastPolled = lastPolled.Value;
-            config.LastError = lastError;
-            config.UpdatedAt = DateTime.UtcNow;
-
-            await _context.SaveChangesAsync(cancellationToken);
-            return true;
+                rows = await _context.CmConfigurations.Where(c => c.Id == id && c.Enabled)
+                    .ExecuteUpdateAsync(s => s
+                        .SetProperty(c => c.LastPolled, lastPolled.Value)
+                        .SetProperty(c => c.LastError, lastError)
+                        .SetProperty(c => c.UpdatedAt, now), cancellationToken);
+            else
+                rows = await _context.CmConfigurations.Where(c => c.Id == id && c.Enabled)
+                    .ExecuteUpdateAsync(s => s
+                        .SetProperty(c => c.LastError, lastError)
+                        .SetProperty(c => c.UpdatedAt, now), cancellationToken);
+            return rows > 0;
         }
         catch (Exception ex)
         {
diff --git a/src/NetworkOptimizer.Storage/Repositories/ModemRepository.cs b/src/NetworkOptimizer.Storage/Repositories/ModemRepository.cs
index b5a60fd2bf..65379a8e4f 100644
--- a/src/NetworkOptimizer.Storage/Repositories/ModemRepository.cs
+++ b/src/NetworkOptimizer.Storage/Repositories/ModemRepository.cs
@@ -107,7 +107,6 @@ public async Task SaveModemConfigurationAsync(ModemConfiguration config, Cancell
                     existing.ModemType = config.ModemType;
                     existing.QmiDevice = config.QmiDevice;
                     existing.Provider = config.Provider;
-                    existing.Enabled = config.Enabled;
                     existing.PollingIntervalSeconds = config.PollingIntervalSeconds;
                     existing.LastPolled = config.LastPolled;
                     existing.LastError = config.LastError;
@@ -182,19 +181,20 @@ public async Task<bool> UpdateModemPollResultAsync(int id, DateTime? lastPolled,
     {
         try
         {
-            var config = await _context.ModemConfigurations.FirstOrDefaultAsync(m => m.Id == id, cancellationToken);
-            // Never resurrect or overwrite a config that was disabled while the poll was
-            // in flight - its frozen state (and cleared LastError) must stand.
-            if (config == null || !config.Enabled)
-                return false;
-
+            var now = DateTime.UtcNow;
+            int rows;
             if (lastPolled.HasValue)
-                config.LastPolled = lastPolled.Value;
-            config.LastError = lastError;
-            config.UpdatedAt = DateTime.UtcNow;
-
-            await _context.SaveChangesAsync(cancellationToken);
-            return true;
+                rows = await _context.ModemConfigurations.Where(m => m.Id == id && m.Enabled)
+                    .ExecuteUpdateAsync(s => s
+                        .SetProperty(m => m.LastPolled, lastPolled.Value)
+                        .SetProperty(m => m.LastError, lastError)
+                        .SetProperty(m => m.UpdatedAt, now), cancellationToken);
+            else
+                rows = await _context.ModemConfigurations.Where(m => m.Id == id && m.Enabled)
+                    .ExecuteUpdateAsync(s => s
+                        .SetProperty(m => m.LastError, lastError)
+                        .SetProperty(m => m.UpdatedAt, now), cancellationToken);
+            return rows > 0;
         }
         catch (Exception ex)
         {
diff --git a/src/NetworkOptimizer.Storage/Repositories/OntRepository.cs b/src/NetworkOptimizer.Storage/Repositories/OntRepository.cs
index 3531f21453..24ccccd7b6 100644
--- a/src/NetworkOptimizer.Storage/Repositories/OntRepository.cs
+++ b/src/NetworkOptimizer.Storage/Repositories/OntRepository.cs
@@ -85,7 +85,6 @@ public async Task SaveOntConfigurationAsync(OntConfiguration config, Cancellatio
                     existing.Password = config.Password;
                     existing.PrivateKeyPath = config.PrivateKeyPath;
                     existing.AttachedSfpId = config.AttachedSfpId;
-                    existing.Enabled = config.Enabled;
                     existing.PollingIntervalSeconds = config.PollingIntervalSeconds;
                     existing.LastPolled = config.LastPolled;
                     existing.LastError = config.LastError;
@@ -155,19 +154,20 @@ public async Task<bool> UpdateOntPollResultAsync(int id, DateTime? lastPolled, s
     {
         try
         {
-            var config = await _context.OntConfigurations.FirstOrDefaultAsync(o => o.Id == id, cancellationToken);
-            // Never resurrect or overwrite a config that was disabled while the poll was
-            // in flight - its frozen state (and cleared LastError) must stand.
-            if (config == null || !config.Enabled)
-                return false;
-
+            var now = DateTime.UtcNow;
+            int rows;
             if (lastPolled.HasValue)
-                config.LastPolled = lastPolled.Value;
-            config.LastError = lastError;
-            config.UpdatedAt = DateTime.UtcNow;
-
-            await _context.SaveChangesAsync(cancellationToken);
-            return true;
+                rows = await _context.OntConfigurations.Where(o => o.Id == id && o.Enabled)
+                    .ExecuteUpdateAsync(s => s
+                        .SetProperty(o => o.LastPolled, lastPolled.Value)
+                        .SetProperty(o => o.LastError, lastError)
+                        .SetProperty(o => o.UpdatedAt, now), cancellationToken);
+            else
+                rows = await _context.OntConfigurations.Where(o => o.Id == id && o.Enabled)
+                    .ExecuteUpdateAsync(s => s
+                        .SetProperty(o => o.LastError, lastError)
+                        .SetProperty(o => o.UpdatedAt, now), cancellationToken);
+            return rows > 0;
         }
         catch (Exception ex)
         {
diff --git a/src/NetworkOptimizer.Web/Components/Pages/Settings.razor b/src/NetworkOptimizer.Web/Components/Pages/Settings.razor
index 19777ac6a5..baa77227e4 100644
--- a/src/NetworkOptimizer.Web/Components/Pages/Settings.razor
+++ b/src/NetworkOptimizer.Web/Components/Pages/Settings.razor
@@ -1236,12 +1236,6 @@
                             }
                         }
 
-                        <div class="form-group">
-                            <label class="checkbox-label">
-                                <input type="checkbox" @bind="editingModem.Enabled" />
-                                <span>Enable polling</span>
-                            </label>
-                        </div>
                     }
 
                     <div class="action-buttons">
@@ -1438,13 +1432,6 @@
                         </div>
                     </div>
 
-                    <div class="form-group">
-                        <label class="checkbox-label">
-                            <input type="checkbox" @bind="_editingCm.Enabled" />
-                            <span>Enable polling</span>
-                        </label>
-                    </div>
-
                     <div class="action-buttons">
                         <button class="btn btn-primary" @onclick="SaveCm" disabled="@_savingCm">
                             @if (_savingCm)
@@ -1663,13 +1650,6 @@
                         </div>
                     </div>
 
-                    <div class="form-group">
-                        <label class="checkbox-label">
-                            <input type="checkbox" @bind="_editingOnt.Enabled" />
-                            <span>Enable polling</span>
-                        </label>
-                    </div>
-
                     <div class="action-buttons">
                         <button class="btn btn-primary" @onclick="SaveOnt" disabled="@_savingOnt">
                             @if (_savingOnt)
diff --git a/src/NetworkOptimizer.Web/Components/Shared/CellularStatsPanel.razor b/src/NetworkOptimizer.Web/Components/Shared/CellularStatsPanel.razor
index 022157340f..03e888a908 100644
--- a/src/NetworkOptimizer.Web/Components/Shared/CellularStatsPanel.razor
+++ b/src/NetworkOptimizer.Web/Components/Shared/CellularStatsPanel.razor
@@ -505,7 +505,7 @@
                 {
                     modemStats = cachedStats;
                 }
-                else
+                else if (modem.Enabled)
                 {
                     // No cached stats - do initial poll
                     var (success, _) = await ModemService.PollModemAsync(modem);
@@ -580,7 +580,7 @@
             modemStats = cached;
             StateHasChanged();
 
-            if (cached == null)
+            if (cached == null && modem.Enabled)
             {
                 // No cached stats - try polling, but don't block paging
                 var (success, _) = await ModemService.PollModemAsync(modem);
diff --git a/src/NetworkOptimizer.Web/Services/CableModemMonitorService.cs b/src/NetworkOptimizer.Web/Services/CableModemMonitorService.cs
index bd4d454fa7..6db04bc3e9 100644
--- a/src/NetworkOptimizer.Web/Services/CableModemMonitorService.cs
+++ b/src/NetworkOptimizer.Web/Services/CableModemMonitorService.cs
@@ -110,6 +110,11 @@ public async Task PollCmAsync(int cmId)
             _logger.LogWarning("PollCmAsync called for unknown CM config {Id}", cmId);
             return;
         }
+        if (!config.Enabled)
+        {
+            _logger.LogDebug("PollCmAsync skipped for disabled CM config {Id}", cmId);
+            return;
+        }
 
         await PollSingleAsync(config);
     }
@@ -331,7 +336,7 @@ private async Task<bool> UpdateConfigSuccessAsync(int id)
         catch (Exception ex)
         {
             _logger.LogWarning(ex, "Failed to update CM config {Id} after successful poll", id);
-            return false;
+            throw;
         }
     }
 
diff --git a/src/NetworkOptimizer.Web/Services/CellularModemService.cs b/src/NetworkOptimizer.Web/Services/CellularModemService.cs
index 83e9b8fe1b..598fd194e9 100644
--- a/src/NetworkOptimizer.Web/Services/CellularModemService.cs
+++ b/src/NetworkOptimizer.Web/Services/CellularModemService.cs
@@ -257,6 +257,14 @@ private async Task<ModemPollContext> ToPollContextAsync(ModemConfiguration modem
     {
         try
         {
+            using (var scope = CreateSiteScope())
+            {
+                var repository = scope.ServiceProvider.GetRequiredService<IModemRepository>();
+                var current = await repository.GetModemConfigurationAsync(modem.Id);
+                if (current == null || !current.Enabled)
+                    return (false, "Modem is disabled - enable it to resume polling.");
+            }
+
             var stats = await ExecutePollAsync(modem);
 
             if (stats != null)
@@ -420,7 +428,7 @@ private async Task<bool> UpdateModemConfigAsync(int modemId, string? error, bool
         catch (Exception ex)
         {
             _logger.LogWarning(ex, "Failed to update modem config after poll");
-            return false;
+            throw;
         }
     }
 
diff --git a/src/NetworkOptimizer.Web/Services/OntMonitorService.cs b/src/NetworkOptimizer.Web/Services/OntMonitorService.cs
index 290d79fbd8..d44b8dd618 100644
--- a/src/NetworkOptimizer.Web/Services/OntMonitorService.cs
+++ b/src/NetworkOptimizer.Web/Services/OntMonitorService.cs
@@ -131,6 +131,11 @@ public async Task<List<OntConfiguration>> GetStandaloneConfigsAsync()
             _logger.LogWarning("Cannot poll ONT {Id}: configuration not found", ontId);
             return null;
         }
+        if (!config.Enabled)
+        {
+            _logger.LogDebug("Cannot poll ONT {Id}: configuration is disabled", ontId);
+            return null;
+        }
 
         return await PollSingleAsync(config, repository, await ResolveThresholdsAsync(scope));
     }
diff --git a/tests/NetworkOptimizer.Storage.Tests/CmRepositoryTests.cs b/tests/NetworkOptimizer.Storage.Tests/CmRepositoryTests.cs
index 3210c22acf..e710b8e275 100644
--- a/tests/NetworkOptimizer.Storage.Tests/CmRepositoryTests.cs
+++ b/tests/NetworkOptimizer.Storage.Tests/CmRepositoryTests.cs
@@ -1,4 +1,5 @@
 using FluentAssertions;
+using Microsoft.Data.Sqlite;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Moq;
@@ -10,21 +11,31 @@ namespace NetworkOptimizer.Storage.Tests;
 
 public class CmRepositoryTests : IDisposable
 {
+    private readonly SqliteConnection _connection;
     private readonly NetworkOptimizerDbContext _context;
     private readonly CmRepository _repository;
 
     public CmRepositoryTests()
     {
+        // SQLite in-memory (not the EF InMemory provider): UpdateCmPollResultAsync uses
+        // ExecuteUpdate for an atomic guarded write, which only a relational provider supports.
+        _connection = new SqliteConnection("DataSource=:memory:");
+        _connection.Open();
         var options = new DbContextOptionsBuilder<NetworkOptimizerDbContext>()
-            .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
+            .UseSqlite(_connection)
             .Options;
 
         _context = new NetworkOptimizerDbContext(options);
+        _context.Database.EnsureCreated();
         var logger = new Mock<ILogger<CmRepository>>();
         _repository = new CmRepository(_context, logger.Object);
     }
 
-    public void Dispose() => _context.Dispose();
+    public void Dispose()
+    {
+        _context.Dispose();
+        _connection.Dispose();
+    }
 
     [Fact]
     public async Task GetEnabledCmConfigurationsAsync_ReturnsOnlyEnabled()
@@ -39,6 +50,27 @@ public async Task GetEnabledCmConfigurationsAsync_ReturnsOnlyEnabled()
         results.Should().ContainSingle().Which.Name.Should().Be("Live CM");
     }
 
+    [Fact]
+    public async Task SaveCmConfigurationAsync_ExistingConfig_PreservesDatabaseEnabledValue()
+    {
+        var cm = new CmConfiguration
+        {
+            Name = "Paused CM", Host = "192.168.100.1", Enabled = false,
+        };
+        _context.CmConfigurations.Add(cm);
+        await _context.SaveChangesAsync();
+
+        await _repository.SaveCmConfigurationAsync(new CmConfiguration
+        {
+            Id = cm.Id, Name = "Edited CM", Host = cm.Host, Enabled = true,
+        });
+
+        _context.ChangeTracker.Clear();
+        var reloaded = await _repository.GetCmConfigurationAsync(cm.Id);
+        reloaded!.Name.Should().Be("Edited CM");
+        reloaded.Enabled.Should().BeFalse("only SetCmEnabledAsync may change Enabled on an existing CM");
+    }
+
     [Fact]
     public async Task SetCmEnabledAsync_Disable_SetsFlagFalseAndClearsLastError()
     {
@@ -157,6 +189,38 @@ public async Task UpdateCmPollResultAsync_ConfigDisabledMidPoll_DoesNotResurrect
         reloaded.LastPolled.Should().Be(new DateTime(2026, 7, 22, 8, 0, 0, DateTimeKind.Utc));
     }
 
+    [Fact]
+    public async Task UpdateCmPollResultAsync_SqliteDisabledBeforeLateResult_AtomicallySkipsUpdate()
+    {
+        await using var connection = new SqliteConnection("DataSource=:memory:");
+        await connection.OpenAsync();
+        var options = new DbContextOptionsBuilder<NetworkOptimizerDbContext>()
+            .UseSqlite(connection)
+            .Options;
+        await using var context = new NetworkOptimizerDbContext(options);
+        await context.Database.EnsureCreatedAsync();
+        var repository = new CmRepository(context, new Mock<ILogger<CmRepository>>().Object);
+        var lastPolled = new DateTime(2026, 7, 22, 8, 0, 0, DateTimeKind.Utc);
+        var cm = new CmConfiguration
+        {
+            Name = "CM", Host = "192.168.100.1", Enabled = true, LastPolled = lastPolled,
+        };
+        context.CmConfigurations.Add(cm);
+        await context.SaveChangesAsync();
+
+        await repository.SetCmEnabledAsync(cm.Id, false);
+        context.ChangeTracker.Clear();
+        var persisted = await repository.UpdateCmPollResultAsync(
+            cm.Id, new DateTime(2026, 7, 22, 8, 5, 0, DateTimeKind.Utc), "late");
+
+        persisted.Should().BeFalse();
+        context.ChangeTracker.Clear();
+        var reloaded = await repository.GetCmConfigurationAsync(cm.Id);
+        reloaded!.Enabled.Should().BeFalse();
+        reloaded.LastError.Should().BeNull();
+        reloaded.LastPolled.Should().Be(lastPolled);
+    }
+
     [Fact]
     public async Task UpdateCmPollResultAsync_UnknownId_ReturnsFalse()
     {
diff --git a/tests/NetworkOptimizer.Storage.Tests/ModemRepositoryTests.cs b/tests/NetworkOptimizer.Storage.Tests/ModemRepositoryTests.cs
index e6f29a8361..4e08c22be2 100644
--- a/tests/NetworkOptimizer.Storage.Tests/ModemRepositoryTests.cs
+++ b/tests/NetworkOptimizer.Storage.Tests/ModemRepositoryTests.cs
@@ -1,4 +1,5 @@
 using FluentAssertions;
+using Microsoft.Data.Sqlite;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Moq;
@@ -10,16 +11,22 @@ namespace NetworkOptimizer.Storage.Tests;
 
 public class ModemRepositoryTests : IDisposable
 {
+    private readonly SqliteConnection _connection;
     private readonly NetworkOptimizerDbContext _context;
     private readonly ModemRepository _repository;
 
     public ModemRepositoryTests()
     {
+        // SQLite in-memory (not the EF InMemory provider): UpdateModemPollResultAsync uses
+        // ExecuteUpdate for an atomic guarded write, which only a relational provider supports.
+        _connection = new SqliteConnection("DataSource=:memory:");
+        _connection.Open();
         var options = new DbContextOptionsBuilder<NetworkOptimizerDbContext>()
-            .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
+            .UseSqlite(_connection)
             .Options;
 
         _context = new NetworkOptimizerDbContext(options);
+        _context.Database.EnsureCreated();
         var logger = new Mock<ILogger<ModemRepository>>();
         _repository = new ModemRepository(_context, logger.Object);
     }
@@ -27,6 +34,7 @@ public ModemRepositoryTests()
     public void Dispose()
     {
         _context.Dispose();
+        _connection.Dispose();
     }
 
     [Fact]
@@ -83,6 +91,27 @@ public async Task SaveModemConfigurationAsync_CreatesNew()
         saved.Should().NotBeNull();
     }
 
+    [Fact]
+    public async Task SaveModemConfigurationAsync_ExistingConfig_PreservesDatabaseEnabledValue()
+    {
+        var modem = new ModemConfiguration
+        {
+            Name = "Paused Modem", Host = "192.168.1.1", Enabled = false,
+        };
+        _context.ModemConfigurations.Add(modem);
+        await _context.SaveChangesAsync();
+
+        await _repository.SaveModemConfigurationAsync(new ModemConfiguration
+        {
+            Id = modem.Id, Name = "Edited Modem", Host = modem.Host, Enabled = true,
+        });
+
+        _context.ChangeTracker.Clear();
+        var reloaded = await _repository.GetModemConfigurationAsync(modem.Id);
+        reloaded!.Name.Should().Be("Edited Modem");
+        reloaded.Enabled.Should().BeFalse("only SetModemEnabledAsync may change Enabled on an existing modem");
+    }
+
     [Fact]
     public async Task DeleteModemConfigurationAsync_RemovesModem()
     {
@@ -215,6 +244,38 @@ public async Task UpdateModemPollResultAsync_ConfigDisabledMidPoll_DoesNotResurr
         reloaded.LastPolled.Should().Be(new DateTime(2026, 7, 22, 8, 0, 0, DateTimeKind.Utc));
     }
 
+    [Fact]
+    public async Task UpdateModemPollResultAsync_SqliteDisabledBeforeLateResult_AtomicallySkipsUpdate()
+    {
+        await using var connection = new SqliteConnection("DataSource=:memory:");
+        await connection.OpenAsync();
+        var options = new DbContextOptionsBuilder<NetworkOptimizerDbContext>()
+            .UseSqlite(connection)
+            .Options;
+        await using var context = new NetworkOptimizerDbContext(options);
+        await context.Database.EnsureCreatedAsync();
+        var repository = new ModemRepository(context, new Mock<ILogger<ModemRepository>>().Object);
+        var lastPolled = new DateTime(2026, 7, 22, 8, 0, 0, DateTimeKind.Utc);
+        var modem = new ModemConfiguration
+        {
+            Name = "Modem", Host = "192.168.1.1", Enabled = true, LastPolled = lastPolled,
+        };
+        context.ModemConfigurations.Add(modem);
+        await context.SaveChangesAsync();
+
+        await repository.SetModemEnabledAsync(modem.Id, false);
+        context.ChangeTracker.Clear();
+        var persisted = await repository.UpdateModemPollResultAsync(
+            modem.Id, new DateTime(2026, 7, 22, 8, 5, 0, DateTimeKind.Utc), "late");
+
+        persisted.Should().BeFalse();
+        context.ChangeTracker.Clear();
+        var reloaded = await repository.GetModemConfigurationAsync(modem.Id);
+        reloaded!.Enabled.Should().BeFalse();
+        reloaded.LastError.Should().BeNull();
+        reloaded.LastPolled.Should().Be(lastPolled);
+    }
+
     [Fact]
     public async Task UpdateModemPollResultAsync_UnknownId_ReturnsFalse()
     {
diff --git a/tests/NetworkOptimizer.Storage.Tests/OntRepositoryTests.cs b/tests/NetworkOptimizer.Storage.Tests/OntRepositoryTests.cs
index f14473a22f..278e52ffd4 100644
--- a/tests/NetworkOptimizer.Storage.Tests/OntRepositoryTests.cs
+++ b/tests/NetworkOptimizer.Storage.Tests/OntRepositoryTests.cs
@@ -1,4 +1,5 @@
 using FluentAssertions;
+using Microsoft.Data.Sqlite;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Moq;
@@ -10,21 +11,31 @@ namespace NetworkOptimizer.Storage.Tests;
 
 public class OntRepositoryTests : IDisposable
 {
+    private readonly SqliteConnection _connection;
     private readonly NetworkOptimizerDbContext _context;
     private readonly OntRepository _repository;
 
     public OntRepositoryTests()
     {
+        // SQLite in-memory (not the EF InMemory provider): UpdateOntPollResultAsync uses
+        // ExecuteUpdate for an atomic guarded write, which only a relational provider supports.
+        _connection = new SqliteConnection("DataSource=:memory:");
+        _connection.Open();
         var options = new DbContextOptionsBuilder<NetworkOptimizerDbContext>()
-            .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
+            .UseSqlite(_connection)
             .Options;
 
         _context = new NetworkOptimizerDbContext(options);
+        _context.Database.EnsureCreated();
         var logger = new Mock<ILogger<OntRepository>>();
         _repository = new OntRepository(_context, logger.Object);
     }
 
-    public void Dispose() => _context.Dispose();
+    public void Dispose()
+    {
+        _context.Dispose();
+        _connection.Dispose();
+    }
 
     [Fact]
     public async Task GetEnabledOntConfigurationsAsync_ReturnsOnlyEnabled()
@@ -39,6 +50,27 @@ public async Task GetEnabledOntConfigurationsAsync_ReturnsOnlyEnabled()
         results.Should().ContainSingle().Which.Name.Should().Be("Live ONT");
     }
 
+    [Fact]
+    public async Task SaveOntConfigurationAsync_ExistingConfig_PreservesDatabaseEnabledValue()
+    {
+        var ont = new OntConfiguration
+        {
+            Name = "Paused ONT", Host = "192.168.1.1", Enabled = false,
+        };
+        _context.OntConfigurations.Add(ont);
+        await _context.SaveChangesAsync();
+
+        await _repository.SaveOntConfigurationAsync(new OntConfiguration
+        {
+            Id = ont.Id, Name = "Edited ONT", Host = ont.Host, Enabled = true,
+        });
+
+        _context.ChangeTracker.Clear();
+        var reloaded = await _repository.GetOntConfigurationAsync(ont.Id);
+        reloaded!.Name.Should().Be("Edited ONT");
+        reloaded.Enabled.Should().BeFalse("only SetOntEnabledAsync may change Enabled on an existing ONT");
+    }
+
     [Fact]
     public async Task SetOntEnabledAsync_Disable_SetsFlagFalseAndClearsLastError()
     {
@@ -157,6 +189,38 @@ public async Task UpdateOntPollResultAsync_ConfigDisabledMidPoll_DoesNotResurrec
         reloaded.LastPolled.Should().Be(new DateTime(2026, 7, 22, 8, 0, 0, DateTimeKind.Utc));
     }
 
+    [Fact]
+    public async Task UpdateOntPollResultAsync_SqliteDisabledBeforeLateResult_AtomicallySkipsUpdate()
+    {
+        await using var connection = new SqliteConnection("DataSource=:memory:");
+        await connection.OpenAsync();
+        var options = new DbContextOptionsBuilder<NetworkOptimizerDbContext>()
+            .UseSqlite(connection)
+            .Options;
+        await using var context = new NetworkOptimizerDbContext(options);
+        await context.Database.EnsureCreatedAsync();
+        var repository = new OntRepository(context, new Mock<ILogger<OntRepository>>().Object);
+        var lastPolled = new DateTime(2026, 7, 22, 8, 0, 0, DateTimeKind.Utc);
+        var ont = new OntConfiguration
+        {
+            Name = "ONT", Host = "192.168.1.1", Enabled = true, LastPolled = lastPolled,
+        };
+        context.OntConfigurations.Add(ont);
+        await context.SaveChangesAsync();
+
+        await repository.SetOntEnabledAsync(ont.Id, false);
+        context.ChangeTracker.Clear();
+        var persisted = await repository.UpdateOntPollResultAsync(
+            ont.Id, new DateTime(2026, 7, 22, 8, 5, 0, DateTimeKind.Utc), "late");
+
+        persisted.Should().BeFalse();
+        context.ChangeTracker.Clear();
+        var reloaded = await repository.GetOntConfigurationAsync(ont.Id);
+        reloaded!.Enabled.Should().BeFalse();
+        reloaded.LastError.Should().BeNull();
+        reloaded.LastPolled.Should().Be(lastPolled);
+    }
+
     [Fact]
     public async Task UpdateOntPollResultAsync_UnknownId_ReturnsFalse()
     {

From 2dda7b0272a57f68bcde0264c083f8530503d4de Mon Sep 17 00:00:00 2001
From: Optic00 <benjamin.busche@gmail.com>
Date: Mon, 27 Jul 2026 19:26:26 +0200
Subject: [PATCH 2/2] fix(monitoring): extend the toggle hardening to Starlink

Starlink got its own Disable/Enable row toggle after the ONT/CM/Cellular
hardening was written, and it shipped with the same four gaps this branch
already closed for the other three device types.

#1 UpdateStarlinkPollResultAsync is now a single conditional ExecuteUpdate
WHERE Id == id && Enabled instead of a read-then-SaveChanges, so a Disable
committing between the read and the write can no longer let an in-flight poll
overwrite the paused terminal's frozen state. StarlinkRepositoryTests moved to
SQLite in-memory (the EF InMemory provider cannot execute ExecuteUpdate) plus a
relational mid-poll-disable regression.

#2 PollStarlinkAsync short-circuits on a disabled config, so the manual Refresh
path no longer reaches the dish of a paused terminal. The stats panel already
guards this client-side; this is the server-side half.

#3 Removed the 'Enable polling' checkbox from the Starlink edit form (the row
toggle is the single control) and stopped SaveStarlinkConfigurationAsync from
copying Enabled on update, so a stale open edit form can no longer resurrect a
terminal the toggle just disabled. SetStarlinkEnabledAsync is the sole writer.

#4 UpdateConfigSuccessAsync rethrows a persistence failure instead of returning
the same false the guard uses for a disabled row, so a real DB write failure
surfaces via the poll error path. The call site already runs inside a catch that
records the failure, so the poll loop stays alive.
---
 .../Repositories/StarlinkRepository.cs        | 28 ++++----
 .../Components/Pages/Settings.razor           |  7 --
 .../Services/StarlinkMonitorService.cs        |  9 ++-
 .../StarlinkRepositoryTests.cs                | 68 ++++++++++++++++++-
 4 files changed, 90 insertions(+), 22 deletions(-)

diff --git a/src/NetworkOptimizer.Storage/Repositories/StarlinkRepository.cs b/src/NetworkOptimizer.Storage/Repositories/StarlinkRepository.cs
index a5ba3af414..385630c0f2 100644
--- a/src/NetworkOptimizer.Storage/Repositories/StarlinkRepository.cs
+++ b/src/NetworkOptimizer.Storage/Repositories/StarlinkRepository.cs
@@ -81,7 +81,6 @@ public async Task SaveStarlinkConfigurationAsync(StarlinkConfiguration config, C
                     existing.Provider = config.Provider;
                     existing.Host = config.Host;
                     existing.Port = config.Port;
-                    existing.Enabled = config.Enabled;
                     existing.PollingIntervalSeconds = config.PollingIntervalSeconds;
                     existing.LastPolled = config.LastPolled;
                     existing.LastError = config.LastError;
@@ -132,19 +131,24 @@ public async Task<bool> UpdateStarlinkPollResultAsync(int id, DateTime? lastPoll
     {
         try
         {
-            var config = await _context.StarlinkConfigurations.FirstOrDefaultAsync(c => c.Id == id, cancellationToken);
             // Never resurrect or overwrite a config that was disabled while the poll was
-            // in flight - its frozen state (and cleared LastError) must stand.
-            if (config == null || !config.Enabled)
-                return false;
-
+            // in flight - its frozen state (and cleared LastError) must stand. Check and
+            // write in one conditional statement so a Disable committing in between
+            // cannot slip through.
+            var now = DateTime.UtcNow;
+            int rows;
             if (lastPolled.HasValue)
-                config.LastPolled = lastPolled.Value;
-            config.LastError = lastError;
-            config.UpdatedAt = DateTime.UtcNow;
-
-            await _context.SaveChangesAsync(cancellationToken);
-            return true;
+                rows = await _context.StarlinkConfigurations.Where(c => c.Id == id && c.Enabled)
+                    .ExecuteUpdateAsync(s => s
+                        .SetProperty(c => c.LastPolled, lastPolled.Value)
+                        .SetProperty(c => c.LastError, lastError)
+                        .SetProperty(c => c.UpdatedAt, now), cancellationToken);
+            else
+                rows = await _context.StarlinkConfigurations.Where(c => c.Id == id && c.Enabled)
+                    .ExecuteUpdateAsync(s => s
+                        .SetProperty(c => c.LastError, lastError)
+                        .SetProperty(c => c.UpdatedAt, now), cancellationToken);
+            return rows > 0;
         }
         catch (Exception ex)
         {
diff --git a/src/NetworkOptimizer.Web/Components/Pages/Settings.razor b/src/NetworkOptimizer.Web/Components/Pages/Settings.razor
index baa77227e4..6d218533f2 100644
--- a/src/NetworkOptimizer.Web/Components/Pages/Settings.razor
+++ b/src/NetworkOptimizer.Web/Components/Pages/Settings.razor
@@ -1825,13 +1825,6 @@
                         </div>
                     </div>
 
-                    <div class="form-group">
-                        <label class="checkbox-label">
-                            <input type="checkbox" @bind="_editingStarlink.Enabled" />
-                            <span>Enable polling</span>
-                        </label>
-                    </div>
-
                     <div class="action-buttons">
                         <button class="btn btn-primary" @onclick="SaveStarlink" disabled="@_savingStarlink">
                             @if (_savingStarlink)
diff --git a/src/NetworkOptimizer.Web/Services/StarlinkMonitorService.cs b/src/NetworkOptimizer.Web/Services/StarlinkMonitorService.cs
index 205c1df199..dae352d244 100644
--- a/src/NetworkOptimizer.Web/Services/StarlinkMonitorService.cs
+++ b/src/NetworkOptimizer.Web/Services/StarlinkMonitorService.cs
@@ -112,6 +112,11 @@ public async Task PollStarlinkAsync(int id)
             _logger.LogWarning("PollStarlinkAsync called for unknown Starlink config {Id}", id);
             return;
         }
+        if (!config.Enabled)
+        {
+            _logger.LogDebug("PollStarlinkAsync skipped for disabled Starlink config {Id}", id);
+            return;
+        }
 
         await PollSingleAsync(config);
     }
@@ -318,6 +323,8 @@ private async Task<StarlinkPollContext> ToContextAsync(StarlinkConfiguration con
     /// <summary>
     /// Guarded success write - returns false (and persists nothing) when the config was
     /// disabled while the poll was in flight, so callers can skip caching/Influx too.
+    /// A write failure is rethrown rather than reported as that same false, so it
+    /// surfaces on the poll error path instead of silently dropping valid stats.
     /// </summary>
     private async Task<bool> UpdateConfigSuccessAsync(int id)
     {
@@ -330,7 +337,7 @@ private async Task<bool> UpdateConfigSuccessAsync(int id)
         catch (Exception ex)
         {
             _logger.LogWarning(ex, "Failed to update Starlink config {Id} after successful poll", id);
-            return false;
+            throw;
         }
     }
 
diff --git a/tests/NetworkOptimizer.Storage.Tests/StarlinkRepositoryTests.cs b/tests/NetworkOptimizer.Storage.Tests/StarlinkRepositoryTests.cs
index 5a58f38dda..2a40c4723f 100644
--- a/tests/NetworkOptimizer.Storage.Tests/StarlinkRepositoryTests.cs
+++ b/tests/NetworkOptimizer.Storage.Tests/StarlinkRepositoryTests.cs
@@ -1,4 +1,5 @@
 using FluentAssertions;
+using Microsoft.Data.Sqlite;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Moq;
@@ -10,21 +11,31 @@ namespace NetworkOptimizer.Storage.Tests;
 
 public class StarlinkRepositoryTests : IDisposable
 {
+    private readonly SqliteConnection _connection;
     private readonly NetworkOptimizerDbContext _context;
     private readonly StarlinkRepository _repository;
 
     public StarlinkRepositoryTests()
     {
+        // SQLite in-memory (not the EF InMemory provider): UpdateStarlinkPollResultAsync uses
+        // ExecuteUpdate for an atomic guarded write, which only a relational provider supports.
+        _connection = new SqliteConnection("DataSource=:memory:");
+        _connection.Open();
         var options = new DbContextOptionsBuilder<NetworkOptimizerDbContext>()
-            .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
+            .UseSqlite(_connection)
             .Options;
 
         _context = new NetworkOptimizerDbContext(options);
+        _context.Database.EnsureCreated();
         var logger = new Mock<ILogger<StarlinkRepository>>();
         _repository = new StarlinkRepository(_context, logger.Object);
     }
 
-    public void Dispose() => _context.Dispose();
+    public void Dispose()
+    {
+        _context.Dispose();
+        _connection.Dispose();
+    }
 
     [Fact]
     public async Task GetEnabledStarlinkConfigurationsAsync_ReturnsOnlyEnabled()
@@ -39,6 +50,27 @@ public async Task GetEnabledStarlinkConfigurationsAsync_ReturnsOnlyEnabled()
         results.Should().ContainSingle().Which.Name.Should().Be("Live Dish");
     }
 
+    [Fact]
+    public async Task SaveStarlinkConfigurationAsync_ExistingConfig_PreservesDatabaseEnabledValue()
+    {
+        var terminal = new StarlinkConfiguration
+        {
+            Name = "Paused Dish", Host = "192.168.100.1", Enabled = false,
+        };
+        _context.StarlinkConfigurations.Add(terminal);
+        await _context.SaveChangesAsync();
+
+        await _repository.SaveStarlinkConfigurationAsync(new StarlinkConfiguration
+        {
+            Id = terminal.Id, Name = "Edited Dish", Host = terminal.Host, Enabled = true,
+        });
+
+        _context.ChangeTracker.Clear();
+        var reloaded = await _repository.GetStarlinkConfigurationAsync(terminal.Id);
+        reloaded!.Name.Should().Be("Edited Dish");
+        reloaded.Enabled.Should().BeFalse("only SetStarlinkEnabledAsync may change Enabled on an existing terminal");
+    }
+
     [Fact]
     public async Task SetStarlinkEnabledAsync_Disable_SetsFlagFalseAndClearsLastError()
     {
@@ -157,6 +189,38 @@ public async Task UpdateStarlinkPollResultAsync_ConfigDisabledMidPoll_DoesNotRes
         reloaded.LastPolled.Should().Be(new DateTime(2026, 7, 22, 8, 0, 0, DateTimeKind.Utc));
     }
 
+    [Fact]
+    public async Task UpdateStarlinkPollResultAsync_SqliteDisabledBeforeLateResult_AtomicallySkipsUpdate()
+    {
+        await using var connection = new SqliteConnection("DataSource=:memory:");
+        await connection.OpenAsync();
+        var options = new DbContextOptionsBuilder<NetworkOptimizerDbContext>()
+            .UseSqlite(connection)
+            .Options;
+        await using var context = new NetworkOptimizerDbContext(options);
+        await context.Database.EnsureCreatedAsync();
+        var repository = new StarlinkRepository(context, new Mock<ILogger<StarlinkRepository>>().Object);
+        var lastPolled = new DateTime(2026, 7, 22, 8, 0, 0, DateTimeKind.Utc);
+        var terminal = new StarlinkConfiguration
+        {
+            Name = "Roof", Host = "192.168.100.1", Enabled = true, LastPolled = lastPolled,
+        };
+        context.StarlinkConfigurations.Add(terminal);
+        await context.SaveChangesAsync();
+
+        await repository.SetStarlinkEnabledAsync(terminal.Id, false);
+        context.ChangeTracker.Clear();
+        var persisted = await repository.UpdateStarlinkPollResultAsync(
+            terminal.Id, new DateTime(2026, 7, 22, 8, 5, 0, DateTimeKind.Utc), "late");
+
+        persisted.Should().BeFalse();
+        context.ChangeTracker.Clear();
+        var reloaded = await repository.GetStarlinkConfigurationAsync(terminal.Id);
+        reloaded!.Enabled.Should().BeFalse();
+        reloaded.LastError.Should().BeNull();
+        reloaded.LastPolled.Should().Be(lastPolled);
+    }
+
     [Fact]
     public async Task UpdateStarlinkPollResultAsync_UnknownId_ReturnsFalse()
     {