Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
80 changes: 73 additions & 7 deletions src/VectorNNTPD.BackFillerService/Nntp/NntpSessionPool.cs
Original file line number Diff line number Diff line change
Expand Up @@ -52,6 +52,8 @@ internal sealed class NntpSessionPool : IAsyncDisposable
/// <summary>
/// Wakeup signal for <see cref="AcquirePermitAsync"/> waiters. The count is not the pool capacity.
/// <see cref="ReleasePermit"/> releases one count only when <see cref="_permitWaiters"/> is positive.
/// A cancelled waiter that drains that count posts it again while another waiter is still counted,
/// so an available permit cannot be left with no wakeup.
/// </summary>
// codeql[cs/missed-using-statement] Owned for the pool lifetime. A using at this declaration would release it when the constructor returns. Shutdown disposes it once, after retirement, and a second dispose returns before that finally.
private readonly SemaphoreSlim _leases = new(0);
Expand Down Expand Up @@ -169,6 +171,18 @@ internal sealed class NntpSessionPool : IAsyncDisposable
/// </summary>
private Func<Task>? _beforePermitWaiterDrain;

/// <summary>
/// Test gate invoked after a permit waiter is counted and before it waits on <see cref="_leases"/>.
/// Null in production. The delegate runs outside <see cref="_permitGate"/>.
/// </summary>
private Func<Task>? _beforePermitWait;

/// <summary>
/// Test gate invoked after a permit wait has failed and before that waiter drains a raced release.
/// Null in production. The waiter is still counted. The delegate runs outside <see cref="_permitGate"/>.
/// </summary>
private Func<Task>? _beforeCancelledPermitDrain;

/// <summary>Permit waiters still inside <see cref="AcquirePermitAsync"/> when semaphores are about to be disposed. Zero when the drain finished.</summary>
private int _permitWaitersAtSemaphoreDispose;

Expand Down Expand Up @@ -586,6 +600,27 @@ internal Func<Task>? BeforePermitWaiterDrain
set => _beforePermitWaiterDrain = value;
}

/// <summary>
/// Pauses a permit waiter after it is counted and before <see cref="SemaphoreSlim.WaitAsync(CancellationToken)"/>.
/// Null unless a test is holding that window. The delegate runs outside <see cref="_permitGate"/>.
/// </summary>
internal Func<Task>? BeforePermitWait
{
get => _beforePermitWait;
set => _beforePermitWait = value;
}

/// <summary>
/// Pauses a failed permit wait after that waiter has left the semaphore and before it drains a raced count.
/// The waiter is still included in <see cref="PermitWaiterCount"/>. Null unless a test is holding that window.
/// The delegate runs outside <see cref="_permitGate"/>.
/// </summary>
internal Func<Task>? BeforeCancelledPermitDrain
{
get => _beforeCancelledPermitDrain;
set => _beforeCancelledPermitDrain = value;
}

/// <summary>
/// Permit waiters remaining when dispose is about to drop <see cref="_leases"/>.
/// Zero after the drain has seen every waiter leave <see cref="AcquirePermitAsync"/>.
Expand Down Expand Up @@ -1327,7 +1362,10 @@ private bool TryTakeAvailablePermit()
/// <exception cref="OperationCanceledException"><paramref name="cancellationToken"/> is cancelled while waiting.</exception>
/// <remarks>
/// The fast path takes <see cref="_permitGate"/> only long enough to decrement <see cref="_availablePermits"/> and increment <see cref="_permitReservations"/>.
/// The wait itself does not hold that lock. A signal that arrives after cancellation is consumed so it cannot grant a later waiter twice.
/// The wait itself does not hold that lock.
/// A release is paired with a counted waiter. If that waiter fails and <see cref="SemaphoreSlim.Wait(int)"/> drains the release,
/// the same count is posted again while <see cref="_permitWaiters"/> is still positive. It is not posted when no waiter remains,
/// because the permit stays in <see cref="_availablePermits"/> for the next fast path.
/// </remarks>
private async Task AcquirePermitAsync(CancellationToken cancellationToken)
{
Expand All @@ -1348,20 +1386,48 @@ private async Task AcquirePermitAsync(CancellationToken cancellationToken)

try
{
if (_beforePermitWait is { } beforeWait)
{
await beforeWait().ConfigureAwait(false);
}

await _leases.WaitAsync(cancellationToken).ConfigureAwait(false);
}
catch (Exception)
{
lock (_permitGate)
try
{
_permitWaiters--;
try
if (_beforeCancelledPermitDrain is { } beforeDrain)
{
_ = _leases.Wait(0);
await beforeDrain().ConfigureAwait(false);
}
catch (ObjectDisposedException)
}
finally
{
lock (_permitGate)
{
ShutdownObservations.AlreadyDisposed(_logger, "lease permit wait");
_permitWaiters--;
var consumedRelease = false;
try
{
consumedRelease = _leases.Wait(0);
}
catch (ObjectDisposedException)
{
ShutdownObservations.AlreadyDisposed(_logger, "lease permit wait");
}

if (consumedRelease && _permitWaiters > 0)
{
try
{
_leases.Release();
}
catch (ObjectDisposedException)
{
ShutdownObservations.AlreadyDisposed(_logger, "lease permit release");
}
}
}
}

Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -318,6 +318,123 @@ public async Task Cancelled_permit_wait_and_dispose_do_not_strand_or_leak_permit
}
}

/// <summary>
/// A cancelled permit wait that drains the only wakeup restores it for a waiter already counted.
/// The survivor acquires without a second release, and repeated cycles do not drift the permit counts.
/// </summary>
[Fact]
public async Task Cancelled_permit_wait_does_not_consume_the_only_wakeup()
{
var factory = new ScriptedNntpTransportFactory();
EnqueueReadyServers(factory, count: 1);
var pool = CreatePool(factory, max: 1);
NntpSessionLease? held = null;
Task<NntpSessionLease>? cancelled = null;
Task<NntpSessionLease>? survivor = null;
Task<NntpSessionLease>? follower = null;
var releaseCancelledDrain = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
var releaseSurvivorWait = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
try
{
await pool.EnsureDesiredSessionsAsync(CancellationToken.None);

for (var cycle = 0; cycle < 8; cycle++)
{
held = await pool.AcquireAsync(CancellationToken.None);
Assert.Equal(0, pool.AvailablePermitCount);
Assert.Equal(1, pool.ActiveLeaseCount);

var waitsEntered = 0;
var survivorWaiting = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
var drainEntered = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
releaseCancelledDrain = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
releaseSurvivorWait = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
using var cancel = new CancellationTokenSource();
try
{
pool.BeforePermitWait = () =>
{
if (Interlocked.Increment(ref waitsEntered) == 2)
{
survivorWaiting.TrySetResult();
return releaseSurvivorWait.Task;
}

return Task.CompletedTask;
};
pool.BeforeCancelledPermitDrain = () =>
{
drainEntered.TrySetResult();
return releaseCancelledDrain.Task;
};

cancelled = pool.AcquireAsync(cancel.Token);
await WaitUntilAsync(() => pool.PermitWaiterCount == 1);
survivor = pool.AcquireAsync(CancellationToken.None);
await survivorWaiting.Task.WaitAsync(TimeSpan.FromSeconds(2));
Assert.Equal(2, pool.PermitWaiterCount);

cancel.Cancel();
await drainEntered.Task.WaitAsync(TimeSpan.FromSeconds(2));
await held.DisposeAsync();
held = null;
Assert.Equal(1, pool.AvailablePermitCount);
Assert.Equal(0, pool.ActiveLeaseCount);

releaseCancelledDrain.TrySetResult();
await Assert.ThrowsAnyAsync<OperationCanceledException>(() => cancelled);
Assert.Equal(1, pool.AvailablePermitCount);
Assert.Equal(0, pool.PermitReservationCount);
Assert.Equal(0, pool.ActiveLeaseCount);
pool.BeforeCancelledPermitDrain = null;
pool.BeforePermitWait = null;

releaseSurvivorWait.TrySetResult();
var gained = await survivor.WaitAsync(TimeSpan.FromSeconds(2));
Assert.Equal(1, pool.ActiveLeaseCount);
Assert.Equal(0, pool.AvailablePermitCount);
Assert.Equal(1, pool.PermitReservationCount);

follower = pool.AcquireAsync(CancellationToken.None);
await WaitUntilAsync(() => pool.PermitWaiterCount == 1);
Assert.False(follower.IsCompleted);

await gained.DisposeAsync();
var followed = await follower.WaitAsync(TimeSpan.FromSeconds(2));
await followed.DisposeAsync();
follower = null;
survivor = null;
cancelled = null;
Assert.Equal(1, pool.AvailablePermitCount);
Assert.Equal(0, pool.PermitReservationCount);
Assert.Equal(0, pool.ActiveLeaseCount);
Assert.Equal(0, pool.PermitWaiterCount);
}
finally
{
releaseCancelledDrain.TrySetResult();
releaseSurvivorWait.TrySetResult();
}
}
}
finally
{
releaseCancelledDrain.TrySetResult();
releaseSurvivorWait.TrySetResult();
pool.BeforePermitWait = null;
pool.BeforeCancelledPermitDrain = null;
if (held is not null)
{
await held.DisposeAsync();
}

await SettleAcquireAsync(cancelled);
await SettleAcquireAsync(survivor);
await SettleAcquireAsync(follower);
await pool.DisposeAsync();
}
}

/// <summary>
/// Released healthy lease reuses the same connection when max is one.
/// </summary>
Expand Down
Loading