void ITraceEnlightenment.AsyncConditionVariable_NotifyAll(AsyncConditionVariable conditionVariable, AsyncLock asyncLock)
{
if (IsEnabled(EventLevel.Verbose, Keywords.AsyncSynchronization))
{
AsyncConditionVariableNotifyAll(conditionVariable.Id, Task.CurrentId ?? 0, asyncLock.Id);
}
}
void ITraceEnlightenment.AsyncMonitor_Created(AsyncLock asyncLock, AsyncConditionVariable conditionVariable)
{
if (IsEnabled(EventLevel.Verbose, Keywords.AsyncSynchronization))
{
AsyncMonitorCreated(asyncLock.Id, conditionVariable.Id, Task.CurrentId ?? 0);
}
}
public void Id_IsNotZero()
{
var mutex = new AsyncLock();
var cv = new AsyncConditionVariable(mutex);
Assert.AreNotEqual(0, cv.Id);
}
public void MultipleWaits_NotifyAll_AllAreCompleted()
{
AsyncContext.Run(async() =>
{
var mutex = new AsyncLock();
var cv = new AsyncConditionVariable(mutex);
var key1 = await mutex.LockAsync();
var task1 = cv.WaitAsync();
var __ = task1.ContinueWith(_ => key1.Dispose());
var key2 = await mutex.LockAsync();
var task2 = cv.WaitAsync();
var ___ = task2.ContinueWith(_ => key2.Dispose());
await Task.Run(async() =>
{
using (await mutex.LockAsync())
{
cv.NotifyAll();
}
});
await task1;
await task2;
});
}
internal RpcServer()
{
Active = false;
m_terminating = false;
m_lockObject = new AsyncLock();
m_callCond = new AsyncConditionVariable(m_lockObject);
m_pollCond = new AsyncConditionVariable(m_lockObject);
}
/// <summary>
/// Constructs a new in-memory stream.
/// </summary>
/// <param name="maxBytes">The maximum number of bytes to hold available for reading. Note that due to buffers, the memory usage of this type may be higher than this parameter.</param>
public ProducerConsumerStream(int maxBytes = int.MaxValue)
{
_maxBytes = maxBytes;
_data = new LinkedList <byte[]>();
_mutex = new AsyncLock();
_notFullOrCompleted = new AsyncConditionVariable(_mutex);
_notEmptyOrCompleted = new AsyncConditionVariable(_mutex);
Reader = new ReaderStream(this);
Writer = new WriterStream(this);
}
public async Task WaitAsync_WithoutNotify_IsNotCompleted()
{
var mutex = new AsyncLock();
var cv = new AsyncConditionVariable(mutex);
await mutex.LockAsync();
var task = cv.WaitAsync();
await AsyncAssert.NeverCompletesAsync(task);
}
public async Task WaitAsync_WithoutNotify_IsNotCompleted()
{
AsyncLock mutex = new AsyncLock();
AsyncConditionVariable cv = new AsyncConditionVariable(mutex);
await mutex.LockAsync();
Task task = cv.WaitAsync();
await AsyncAssert.NeverCompletesAsync(task).ConfigureAwait(false);
}
public void WaitAsync_WithoutNotify_IsNotCompleted()
{
AsyncContext.Run(async() =>
{
var mutex = new AsyncLock();
var cv = new AsyncConditionVariable(mutex);
await mutex.LockAsync();
var task = cv.WaitAsync();
await AssertEx.NeverCompletesAsync(task);
});
}
public AsyncCollection(IProducerConsumerCollection <T> collection = null, int maxCount = int.MaxValue)
{
if (maxCount <= 0)
{
throw new ArgumentOutOfRangeException("maxCount", "The maximum count must be greater than zero.");
}
this.collection = collection ?? new ConcurrentQueue <T>();
this.maxCount = maxCount;
mutex = new AsyncLock();
notFull = new AsyncConditionVariable(mutex);
notEmpty = new AsyncConditionVariable(mutex);
}
void ITraceEnlightenment.AsyncConditionVariable_TrackWait(AsyncConditionVariable conditionVariable, AsyncLock asyncLock, Task notifyTask, Task waitTask)
{
if (!IsEnabled(EventLevel.Verbose, Keywords.AsyncSynchronization))
{
return;
}
var conditionVariableId = conditionVariable.Id;
var asyncLockId = asyncLock.Id;
var notifyTaskId = notifyTask.Id;
var waitTaskId = waitTask.Id;
AsyncConditionVariableWaitBegin(conditionVariableId, Task.CurrentId ?? 0, asyncLockId, notifyTaskId, waitTaskId);
waitTask.ContinueWith(t => AsyncConditionVariableWaitEnd(conditionVariableId, Task.CurrentId ?? 0, asyncLockId, notifyTaskId, waitTaskId, t.IsCanceled), TaskContinuationOptions.ExecuteSynchronously);
}
/// <summary>
/// Create a new <see cref="K8sMultiplexedReadStream"/>.
/// </summary>
/// <param name="streamIndex">
/// The Kubernetes stream index of the target input stream.
/// </param>
/// <param name="maxPendingBytes">
/// The maximum number of pending bytes that the stream can hold.
/// </param>
/// <param name="loggerFactory">
/// The <see cref="ILoggerFactory"/> used to create loggers for client components.
/// </param>
public K8sMultiplexedReadStream(byte streamIndex, int maxPendingBytes, ILoggerFactory loggerFactory)
{
if (maxPendingBytes < 1)
{
throw new ArgumentOutOfRangeException(nameof(maxPendingBytes), maxPendingBytes, "Maximum number of pending bytes cannot be less than 1.");
}
_mutex = new AsyncLock();
_completedOrDataAvailable = new AsyncConditionVariable(_mutex);
StreamIndex = streamIndex;
MaxPendingBytes = maxPendingBytes;
Log = loggerFactory.CreateLogger <K8sMultiplexedReadStream>();
}
public async Task WaitAsync_AfterNotify_IsNotCompleted()
{
var mutex = new AsyncLock();
var cv = new AsyncConditionVariable(mutex);
await Task.Run(async() =>
{
using (await mutex.LockAsync())
{
cv.Notify();
}
});
await mutex.LockAsync();
var task = cv.WaitAsync();
await AsyncAssert.NeverCompletesAsync(task);
}
public async Task WaitAsync_AfterNotify_IsNotCompleted()
{
AsyncLock mutex = new AsyncLock();
AsyncConditionVariable cv = new AsyncConditionVariable(mutex);
await Task.Run(async() =>
{
using (await mutex.LockAsync())
{
cv.Notify();
}
}).ConfigureAwait(false);
await mutex.LockAsync();
Task task = cv.WaitAsync();
await AsyncAssert.NeverCompletesAsync(task).ConfigureAwait(false);
}
public async Task WaitAsync_Notified_IsCompleted()
{
AsyncLock mutex = new AsyncLock();
AsyncConditionVariable cv = new AsyncConditionVariable(mutex);
await mutex.LockAsync();
Task task = cv.WaitAsync();
await Task.Run(async() =>
{
using (await mutex.LockAsync())
{
cv.Notify();
}
}).ConfigureAwait(false);
await task;
}
public async Task WaitAsync_Notified_IsCompleted()
{
var mutex = new AsyncLock();
var cv = new AsyncConditionVariable(mutex);
await mutex.LockAsync();
var task = cv.WaitAsync();
await Task.Run(async() =>
{
using (await mutex.LockAsync())
{
cv.Notify();
}
});
await task;
}
public async Task MultipleWaits_Notify_OneIsCompleted()
{
AsyncLock mutex = new AsyncLock();
AsyncConditionVariable cv = new AsyncConditionVariable(mutex);
IDisposable key = await mutex.LockAsync();
Task task1 = cv.WaitAsync();
Task __ = task1.ContinueWith(_ => key.Dispose());
await mutex.LockAsync();
Task task2 = cv.WaitAsync();
await Task.Run(async() =>
{
using (await mutex.LockAsync())
{
cv.Notify();
}
}).ConfigureAwait(false);
await task1;
await AsyncAssert.NeverCompletesAsync(task2).ConfigureAwait(false);
}
public async Task MultipleWaits_Notify_OneIsCompleted()
{
var mutex = new AsyncLock();
var cv = new AsyncConditionVariable(mutex);
var key = await mutex.LockAsync();
var task1 = cv.WaitAsync();
var __ = task1.ContinueWith(_ => key.Dispose());
await mutex.LockAsync();
var task2 = cv.WaitAsync();
await Task.Run(async() =>
{
using (await mutex.LockAsync())
{
cv.Notify();
}
});
await task1;
await AsyncAssert.NeverCompletesAsync(task2);
}
public async Task MultipleWaits_NotifyAll_AllAreCompleted()
{
AsyncLock mutex = new AsyncLock();
AsyncConditionVariable cv = new AsyncConditionVariable(mutex);
IDisposable key1 = await mutex.LockAsync();
Task task1 = cv.WaitAsync();
Task __ = task1.ContinueWith(_ => key1.Dispose());
IDisposable key2 = await mutex.LockAsync();
Task task2 = cv.WaitAsync();
Task ___ = task2.ContinueWith(_ => key2.Dispose());
await Task.Run(async() =>
{
using (await mutex.LockAsync())
{
cv.NotifyAll();
}
}).ConfigureAwait(false);
await task1;
await task2;
}
