public async Task When_Test(
bool useCancellation,
bool useWhenAllCompleteAction)
{
var cancellation = useCancellation ? new CancellationTokenSource() : null;
var disposed = new ManualResetEventSlim(false);
Action <int[]> whenAllCompleteAction = null;
if (useWhenAllCompleteAction)
{
whenAllCompleteAction = DisposeCancellation;
}
using (await _gate.AcquireAsync())
{
// arrange
var sw = Stopwatch.StartNew();
Task <int>[] tasks =
{
Delayed(TimeSpan.FromMilliseconds(1)),
Delayed(TimeSpan.FromMilliseconds(50)),
Delayed(TimeSpan.FromMilliseconds(100)),
Delayed(TimeSpan.FromMilliseconds(200))
};
// act
(int result, bool succeed) = await tasks.When(
x => x != 1,
cancellation,
whenAllCompleteAction);
// assert
sw.Stop();
TimeSpan duration = sw.Elapsed;
if (cancellation != null)
{
Assert.IsTrue(cancellation.IsCancellationRequested, "Cancellation");
}
Assert.IsTrue(duration >= TimeSpan.FromMilliseconds(50) &&
duration < TimeSpan.FromMilliseconds(100), "Duration");
Assert.IsTrue(succeed, "Succeed");
Assert.AreEqual(1, result);
if (whenAllCompleteAction != null)
{
Assert.IsTrue(disposed.Wait(500), "DisposeCancellation");
}
}
void DisposeCancellation(int[] _)
{
cancellation?.Dispose();
disposed.Set();
}
async Task <int> Delayed(TimeSpan time)
{
await Task.Delay(time).ConfigureAwait(false);
return((int)time.TotalMilliseconds);
}
}
public async Task Should_throw_oce_if_cancelled()
{
using var mutex = new AsyncLock();
using var cts = new CancellationTokenSource();
using var releaser = await mutex.AcquireAsync(cts.Token).ConfigureAwait(false);
cts.CancelAfter(50);
await Assert.ThrowsAnyAsync <OperationCanceledException>(
() => mutex.AcquireAsync(cts.Token)
).ConfigureAwait(false);
}
public static async Task AsyncLock_AcquireAsync_Timeout_Timespan()
{
using (var l = new AsyncLock())
{
var sw = Stopwatch.StartNew();
using (AsyncLockCookie t1 = await l.AcquireAsync())
using (AsyncLockCookie t2 = await l.AcquireAsync(TimeSpan.FromMilliseconds(100)))
{
Assert.True(t1.IsAcquired);
Assert.False(t2.IsAcquired);
Assert.True(sw.Elapsed.TotalMilliseconds >= 80);
}
}
}
public static async Task AsyncLock_AcquireAsync_Twice()
{
using (var l = new AsyncLock())
{
using (AsyncLockCookie t = await l.AcquireAsync())
{
Assert.True(t.IsAcquired);
Assert.Equal(t.IsAcquired, t);
}
using (AsyncLockCookie t = await l.AcquireAsync())
{
Assert.True(t.IsAcquired);
}
}
}
public void TestSynchronizeTwoParallelTasks()
{
this.TestWithError(async() =>
{
SharedEntry entry = new SharedEntry();
AsyncLock mutex = AsyncLock.Create();
async Task WriteAsync(int value)
{
using (await mutex.AcquireAsync())
{
entry.Value = value;
}
}
Task task1 = Task.Run(async() =>
{
await WriteAsync(3);
});
Task task2 = Task.Run(async() =>
{
await WriteAsync(5);
});
await Task.WhenAll(task1, task2);
AssertSharedEntryValue(entry, 5);
},
configuration: this.GetConfiguration().WithTestingIterations(200),
expectedError: "Value is 3 instead of 5.",
replay: true);
}
public static TokenFactory GetAccessTokenFactory(
[NotNull] this RsdnApiAuthenticator authenticator,
[NotNull] string login,
[NotNull] string password)
{
Code.NotNull(authenticator, nameof(authenticator));
AuthTokenResponse token = null;
var tokenLock = new AsyncLock();
return(async ct =>
{
if (token != null && token.ExpiresOn >= DateTimeOffset.UtcNow)
{
return token.AccessToken;
}
using (await tokenLock.AcquireAsync(ct))
if (token == null || token.ExpiresOn < DateTimeOffset.UtcNow)
{
token = token == null
? await authenticator.GetTokenByPasswordAsync(login, password, ct)
: await authenticator.RefreshTokenAsync(token.RefreshToken, ct)
?? await authenticator.GetTokenByPasswordAsync(login, password, ct);
}
return token.AccessToken;
});
}
public static TokenFactory GetAccessTokenFactory(
[NotNull] this RsdnApiAuthenticator authenticator,
[NotNull] Func <AuthTokenResponse> getToken,
[NotNull] Action <AuthTokenResponse> setToken)
{
Code.NotNull(authenticator, nameof(authenticator));
var tokenLock = new AsyncLock();
return(async ct =>
{
var token = getToken();
if (token == null)
{
return null;
}
if (token.ExpiresOn >= DateTimeOffset.UtcNow)
{
return token.AccessToken;
}
using (await tokenLock.AcquireAsync(ct))
if (token.ExpiresOn < DateTimeOffset.UtcNow)
{
token = await authenticator.RefreshTokenAsync(token.RefreshToken, ct);
setToken(token);
}
return token?.AccessToken;
});
}
private static async Task <bool> TryTakeAndHold(
AsyncLock asyncLock,
TimeSpan holdTime,
CancellationToken cancellation = default,
Action callback = null)
{
try
{
using (await asyncLock.AcquireAsync(holdTime, cancellation))
{
callback?.Invoke();
await TaskEx.Delay(holdTime);
}
return(true);
}
catch (OperationCanceledException)
{
return(false);
}
catch (TimeoutException)
{
return(false);
}
}
public void TestAcquireTwice()
{
this.TestWithError(async() =>
{
AsyncLock mutex = AsyncLock.Create();
await mutex.AcquireAsync();
await Task.Run(async() =>
{
await mutex.AcquireAsync();
});
},
expectedError: "Deadlock detected. Task() and Task() are waiting for a task to complete, but no other " +
"controlled tasks are enabled. Task() is waiting to acquire a resource that is already " +
"acquired, but no other controlled tasks are enabled.",
replay: true);
}
public async Task When_Test_All(
bool useCancellation)
{
var cancellation = useCancellation ? new CancellationTokenSource() : default;
using (await _gate.AcquireAsync())
{
// arrange
var sw = Stopwatch.StartNew();
Task <int>[] tasks =
{
Delayed(TimeSpan.FromMilliseconds(1)),
Delayed(TimeSpan.FromMilliseconds(50)),
Delayed(TimeSpan.FromMilliseconds(100)),
Delayed(TimeSpan.FromMilliseconds(200))
};
// act
(int result, bool succeed, Task <int[]> all) = await tasks.When(
x => x != 1,
cancellation);
// assert
sw.Stop();
TimeSpan duration = sw.Elapsed;
if (cancellation != null)
{
Assert.True(cancellation.IsCancellationRequested, "Cancellation");
}
Assert.True(duration >= TimeSpan.FromMilliseconds(45) &&
duration < TimeSpan.FromMilliseconds(100), "Duration");
Assert.True(succeed, "Succeed");
Assert.Equal(50, result);
await all.WithTimeout(TimeSpan.FromSeconds(10)).ConfigureAwait(false);
cancellation?.Dispose();
}
async Task <int> Delayed(TimeSpan time)
{
await Task.Delay(time).ConfigureAwait(false);
return((int)time.TotalMilliseconds);
}
}
public async Task Enqueue(T item, string taskName)
{
_logger.Mark(taskName, StateEnum.SemaphoreWait);
await _producerSemaphore.WaitAsync();
_logger.Mark(taskName, StateEnum.SemaphoreEnter);
_logger.Mark(taskName, StateEnum.MutexAttemptAcquire);
using (await _mutex.AcquireAsync())
{
_logger.Mark(taskName, StateEnum.MutexAcquired);
_buffer.Enqueue(item);
}
// wakeup consumers
_consumerSemaphore.Release();
_logger.Mark(taskName, StateEnum.SemaphoreReleased);
}
public async Task ExecAsync(int i)
{
using (await _gate.AcquireAsync().ConfigureAwait(false))
{
Console.Write($"#{i}");
await Task.Delay(1500).ConfigureAwait(false);
Console.Write($"{i}# ");
}
}
public async Task AsyncLock_WithGcCollect_Test()
{
var locker = new AsyncLock(TimeSpan.FromMilliseconds(200));
Task fireForget;
using (await locker.AcquireAsync())
{
CollectGC();
fireForget = Task.Run(async() =>
{
await Task.Delay(30);
using (await locker.AcquireAsync())
{
}
});
}
CollectGC();
await fireForget;
}
public async Task Should_throw_oce_if_already_cancelled()
{
using var mutex = new AsyncLock();
using var cts = new CancellationTokenSource();
cts.Cancel();
await Assert.ThrowsAnyAsync <OperationCanceledException>(
() => mutex.AcquireAsync(cts.Token)
);
}
public async SystemTasks.Task TestAcquireRelease()
{
AsyncLock mutex = AsyncLock.Create();
Assert.True(!mutex.IsAcquired);
var releaser = await mutex.AcquireAsync();
Assert.True(mutex.IsAcquired);
releaser.Dispose();
Assert.True(!mutex.IsAcquired);
}
public static async Task AsyncLock_AcquireAsync_Fail()
{
using (var l = new AsyncLock())
{
using (AsyncLockCookie t1 = await l.AcquireAsync())
{
Assert.True(t1.IsAcquired);
using (AsyncLockCookie t2 = await l.AcquireAsync(0))
{
Assert.False(t2.IsAcquired);
Assert.Equal(t2.IsAcquired, t2);
}
using (AsyncLockCookie t2 = await l.AcquireAsync(TimeSpan.Zero))
{
Assert.False(t2.IsAcquired);
Assert.Equal(t2.IsAcquired, t2);
}
}
}
}
public static async Task AsyncLock_AcquireAsync_Wait()
{
using (var l = new AsyncLock())
{
AsyncLockCookie t1 = await l.AcquireAsync();
Assert.True(t1.IsAcquired);
var sw = Stopwatch.StartNew();
ThreadPool.QueueUserWorkItem(_ =>
{
Thread.Sleep(500);
t1.Dispose();
});
using (AsyncLockCookie t2 = await l.AcquireAsync())
{
Assert.True(t2);
}
Assert.True(sw.Elapsed.TotalMilliseconds >= 400);
}
}
public async Task AsyncLock_Timeout_Test()
{
using (var locker = new AsyncLock(TimeSpan.FromMilliseconds(1)))
using (await locker.AcquireAsync())
{
await Task.Run(async() =>
{
try
{
using (await locker.AcquireAsync(TimeSpan.FromMilliseconds(1)))
{
}
throw new NotSupportedException("Not expected");
}
catch (TimeoutException)
{
// expected
}
});
}
}
public void TestAcquireRelease()
{
this.Test(async() =>
{
AsyncLock mutex = AsyncLock.Create();
Specification.Assert(!mutex.IsAcquired, "Mutex is acquired.");
var releaser = await mutex.AcquireAsync();
Specification.Assert(mutex.IsAcquired, "Mutex is not acquired.");
releaser.Dispose();
Specification.Assert(!mutex.IsAcquired, "Mutex is acquired.");
});
}
public async Task AsyncLock_Test()
{
var locker = new AsyncLock(TimeSpan.FromMilliseconds(200));
Task fireForget;
using (await locker.AcquireAsync())
{
fireForget = Task.Run(async() =>
{
using (await locker.AcquireAsync())
{
}
});
await Task.Delay(5).ConfigureAwait(false);
Assert.IsFalse(fireForget.IsCompleted, "fireForget.IsCompleted");
}
await Task.Delay(5).ConfigureAwait(false);
Assert.IsTrue(fireForget.IsCompleted);
await fireForget;
}
public void TestAcquireTwice()
{
if (!this.SystematicTest)
{
// .NET cannot detect these deadlocks.
return;
}
this.TestWithError(async() =>
{
AsyncLock mutex = AsyncLock.Create();
await mutex.AcquireAsync();
await Task.Run(async() =>
{
await mutex.AcquireAsync();
});
},
expectedError: "Deadlock detected. Task() is waiting for a task to complete, but no other " +
"controlled tasks are enabled. Task() is waiting to acquire a resource that is already " +
"acquired, but no other controlled tasks are enabled.",
replay: true);
}
public override async ValueTask WriteAsync(T item, CancellationToken token)
{
using (await writeLock.AcquireAsync(token).ConfigureAwait(false))
{
var partition = Partition;
await writer.SerializeAsync(item, partition, token).ConfigureAwait(false);
await partition.FlushAsync(token).ConfigureAwait(false);
cursor.Advance(partition.Position);
}
writer.MessageReady();
}
private static async Task CheckAsyncLockReentranceAsync(AsyncLock asyncLock, int maxReentrances = 2)
{
using (await asyncLock.AcquireAsync())
{
Console.WriteLine($"Lock taken as reentrance: {maxReentrances}.. TaskId: {asyncLock.TaskId}");
if (maxReentrances > 0)
{
await CheckAsyncLockReentranceAsync(asyncLock, maxReentrances - 1);
}
Console.WriteLine($"Press any key to release reentrance: {maxReentrances} lock... TaskId: {asyncLock.TaskId}");
Console.ReadKey();
}
}
public static TokenFactory GetAccessTokenFactory(
[NotNull] this RsdnApiAuthenticator authenticator,
[NotNull] CodeFlowData flowData,
[NotNull] IDictionary <string, string> redirectParams)
{
Code.NotNull(authenticator, nameof(authenticator));
Code.NotNull(flowData, nameof(flowData));
Code.NotNull(redirectParams, nameof(redirectParams));
AuthTokenResponse token = null;
var tokenLock = new AsyncLock();
return(async ct =>
{
if (token == null)
{
using (await tokenLock.AcquireAsync(ct))
if (token == null)
{
token = await authenticator.GetTokenByCodeAsync(flowData, redirectParams, ct);
return token.AccessToken;
}
}
if (token.ExpiresOn >= DateTimeOffset.UtcNow)
{
return token.AccessToken;
}
using (await tokenLock.AcquireAsync())
if (token.ExpiresOn < DateTimeOffset.UtcNow)
{
token = await authenticator.RefreshTokenAsync(token.RefreshToken, ct);
}
return token?.AccessToken;
});
}
private static async Task RegAsyncTestAsync()
{
const int RANGE = 1000;
var builder = new ContainerBuilder();
var tasks = Enumerable.Range(0, RANGE)
.Select(i => Task.Run(async() =>
{
//lock (_sync)
using (await _lock.AcquireAsync())
{
builder.RegisterType <ConsoleLogger>()
.Keyed <ILogger>(i)
.SingleInstance();
builder.Register <IEnumerable <int> >(c =>
{
var v = c.Resolve <ILogger>();
return(Enumerable.Range(4, 5));
});
}
}));
builder.RegisterType <ConsoleLogger>()
.As <ILogger>()
.SingleInstance();
await Task.WhenAll(tasks);
var container = builder.Build();
for (int i = 0; i < RANGE; i++)
{
if (container.IsRegisteredWithKey <ILogger>(i))
{
Console.ForegroundColor = ConsoleColor.Green;
Console.Write("V,");
Console.ResetColor();
}
else
{
Console.ForegroundColor = ConsoleColor.Magenta;
Console.Write("X,");
Console.ResetColor();
}
}
Console.WriteLine();
}
public async Task <IExchange> DeclareExchangeAsync(string exchangeName, string exchangeType)
{
if (exchanges.TryGetValue(exchangeName, out var exchange))
{
return(exchange);
}
using (await asyncLock.AcquireAsync().ConfigureAwait(false))
{
if (exchanges.TryGetValue(exchangeName, out exchange))
{
return(exchange);
}
exchange = await advancedBus.ExchangeDeclareAsync(exchangeName, exchangeType).ConfigureAwait(false);
exchanges[exchangeName] = exchange;
return(exchange);
}
}
private async Task InitAsync()
{
if (_initialized)
{
return;
}
using (await _initializeLock.AcquireAsync())
{
if (_initialized)
{
return;
}
await _easyNetQBus.DeclareMessageBusAsync(_messageBus.Value);
_initialized = true;
}
}
public async SystemTasks.Task TestSynchronizeTwoAsynchronousTasks()
{
SharedEntry entry = new SharedEntry();
AsyncLock mutex = AsyncLock.Create();
async Task WriteAsync(int value)
{
using (await mutex.AcquireAsync())
{
entry.Value = value;
}
}
Task task1 = WriteAsync(3);
Task task2 = WriteAsync(5);
await Task.WhenAll(task1, task2);
Assert.True(task1.IsCompleted && task2.IsCompleted && !mutex.IsAcquired);
Assert.True(entry.Value == 5, $"Value is '{entry.Value}' instead of 5.");
}
public void TestSynchronizeTwoAsynchronousTasks()
{
this.Test(async() =>
{
SharedEntry entry = new SharedEntry();
AsyncLock mutex = AsyncLock.Create();
async Task WriteAsync(int value)
{
using (await mutex.AcquireAsync())
{
entry.Value = value;
}
}
Task task1 = WriteAsync(3);
Task task2 = WriteAsync(5);
await Task.WhenAll(task1, task2);
AssertSharedEntryValue(entry, 5);
},
configuration: this.GetConfiguration().WithTestingIterations(200));
}
/// <inheritdoc />
public async Task <T> InvokeChannelActionAsync <T>(
Func <IModel, T> channelAction, CancellationToken cancellationToken
)
{
Preconditions.CheckNotNull(channelAction, "channelAction");
using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, disposeCts.Token);
using var releaser = await mutex.AcquireAsync(cts.Token).ConfigureAwait(false);
var retryTimeoutMs = MinRetryTimeoutMs;
while (true)
{
cts.Token.ThrowIfCancellationRequested();
try
{
var channel = initializedChannel ??= CreateChannel();
return(channelAction(channel));
}
catch (Exception exception)
{
var exceptionVerdict = GetExceptionVerdict(exception);
if (exceptionVerdict.CloseChannel)
{
CloseChannel();
}
if (exceptionVerdict.Rethrow)
{
throw;
}
}
await Task.Delay(retryTimeoutMs, cts.Token).ConfigureAwait(false);
retryTimeoutMs = Math.Min(retryTimeoutMs * 2, MaxRetryTimeoutMs);
}
}
