@@ -94,14 +99,21 @@
// auth-state change is applying concurrently.
private volatile IReadOnlySet
? _scopedSiteIds;
+ // Result of the provider FALLBACK below, kept so it is resolved at most once per
+ // auth state instead of on every parameter set.
+ private ClaimsPrincipal? _fallbackPrincipal;
+
private PendingUpdatesSnapshot? _snapshot;
private string? _error;
private string? _lastLoggedError;
///
/// The ambient authentication state supplied by the app's
- /// CascadingAuthenticationState. Preferred over asking the provider so the
- /// principal already resolved for the page is reused rather than re-fetched.
+ /// CascadingAuthenticationState (registered by
+ /// AddCascadingAuthenticationState, so it is always present in the running
+ /// app). Preferred over asking the provider because this task is ALREADY resolved
+ /// for the page: reusing it means this component never triggers a session
+ /// revalidation of its own, whereas every provider entry point does refresh.
///
[CascadingParameter]
private Task? AuthenticationStateTask { get; set; }
@@ -132,14 +144,32 @@
protected override async Task OnParametersSetAsync()
{
- // Non-forced on purpose: this is display gating, not a mutation, so the
- // cached principal is the right input (same pattern as Templates.razor /
- // FlowDebugger). Anything that ACTS on a site re-checks authoritatively.
- var state = AuthenticationStateTask is not null
- ? await AuthenticationStateTask
- : await AuthStateProvider.GetAuthenticationStateAsync();
+ ClaimsPrincipal user;
+ if (AuthenticationStateTask is not null)
+ {
+ user = (await AuthenticationStateTask).User;
+ }
+ else
+ {
+ // Fallback for a host with no cascade. AddCascadingAuthenticationState() is
+ // registered, so this is expected to be dead in production — and it is a
+ // REAL session refresh (non-forced differs only in failClosed), which is why
+ // it is taken at most once and then reused until the state changes.
+ _fallbackPrincipal ??= (await AuthStateProvider.GetAuthenticationStateAsync()).User;
+ user = _fallbackPrincipal;
+ }
- ApplyPrincipal(state.User);
+ ApplyPrincipal(user);
+
+ // MUST be here, not only in OnAfterRenderAsync: the await above can suspend, in
+ // which case the FIRST render runs with _visible still false and skips the
+ // OnAfterRender(firstRender: true) start. The render that follows the resolve is
+ // firstRender: false, so nothing else would ever start the poll and the block
+ // would sit on "Checking for updates…" for the life of the circuit. Idempotent.
+ if (_visible)
+ {
+ EnsurePollingStarted();
+ }
}
// Roles and site scope are both pure functions of the principal's claims, so
@@ -178,6 +208,7 @@
return;
}
+ _fallbackPrincipal = state.User;
ApplyPrincipal(state.User);
// A role GRANTED mid-session has to start the poll that first render
diff --git a/tests/ZB.MOM.WW.ScadaBridge.CentralUI.Tests/Layout/PendingUpdatesIndicatorTests.cs b/tests/ZB.MOM.WW.ScadaBridge.CentralUI.Tests/Layout/PendingUpdatesIndicatorTests.cs
index b0e382b0..a2c52217 100644
--- a/tests/ZB.MOM.WW.ScadaBridge.CentralUI.Tests/Layout/PendingUpdatesIndicatorTests.cs
+++ b/tests/ZB.MOM.WW.ScadaBridge.CentralUI.Tests/Layout/PendingUpdatesIndicatorTests.cs
@@ -369,4 +369,47 @@ public class PendingUpdatesIndicatorTests : BunitContext
NotifyAuthenticationStateChanged(GetAuthenticationStateAsync());
}
}
+
+ [Fact]
+ public void Polling_StartsAfterAnAsynchronousAuthResolveCompletes()
+ {
+ // Regression: OnParametersSetAsync awaits the principal. On a real cookie
+ // session that await suspends, so the FIRST render happens with _visible
+ // still false and OnAfterRenderAsync(firstRender: true) skips starting the
+ // poll; the render that follows the resolve is firstRender: false. Without a
+ // start from OnParametersSetAsync the block sits on "Checking for updates…"
+ // for the life of the circuit.
+ var gate = new TaskCompletionSource(
+ TaskCreationOptions.RunContinuationsAsynchronously);
+ var cache = CacheReturning(Snapshot(SiteRow(1, staleInstances: 4)));
+
+ Services.AddSingleton(new DeferredAuthStateProvider(gate.Task));
+ Services.AddScoped();
+ Services.AddSingleton(cache);
+ Services.AddSingleton>(NullLogger.Instance);
+
+ var cut = Render();
+
+ // Nothing resolved yet: no principal, so nothing rendered and nothing polled.
+ Assert.True(string.IsNullOrWhiteSpace(cut.Markup));
+
+ gate.SetResult(new AuthenticationState(
+ new ClaimsPrincipal(new ClaimsIdentity([Role(Roles.Deployer)], "TestAuth"))));
+
+ cut.WaitForAssertion(() =>
+ {
+ _ = cache.Received().GetAsync(Arg.Any(), Arg.Any());
+ Assert.Contains("4 instances", cut.Markup);
+ });
+ }
+
+ /// An auth provider whose state resolves only when the supplied task completes.
+ private sealed class DeferredAuthStateProvider : AuthenticationStateProvider
+ {
+ private readonly Task _state;
+
+ public DeferredAuthStateProvider(Task state) => _state = state;
+
+ public override Task GetAuthenticationStateAsync() => _state;
+ }
}