public void TryEnqueueAfterComplete()
{
var queue = new AsyncQueue<int>();
Assert.True(queue.TryEnqueue(42));
queue.Complete();
Assert.False(queue.TryEnqueue(42));
}
public void TryEnqueueAfterComplete()
{
var queue = new AsyncQueue <int>();
Assert.True(queue.TryEnqueue(42));
queue.Complete();
Assert.False(queue.TryEnqueue(42));
}
public void TryEnqueueAfterPromisingNotTo()
{
var queue = new AsyncQueue<int>();
Assert.True(queue.TryEnqueue(42));
queue.PromiseNotToEnqueue();
Assert.Throws(typeof(InvalidOperationException), () => {
queue.TryEnqueue(42);
});
}
public void TryEnqueueAfterPromisingNotTo()
{
var queue = new AsyncQueue <int>();
Assert.True(queue.TryEnqueue(42));
queue.PromiseNotToEnqueue();
Assert.Throws(typeof(InvalidOperationException), () => {
queue.TryEnqueue(42);
});
}
public Task <TResponseType> ExecuteAsync <TRequestType, TResponseType>(
bool mutatesSolutionState,
IRequestHandler <TRequestType, TResponseType> handler,
TRequestType request,
ClientCapabilities clientCapabilities,
string?clientName,
CancellationToken requestCancellationToken) where TRequestType : class
{
// Create a task completion source that will represent the processing of this request to the caller
var completion = new TaskCompletionSource <TResponseType>();
// Note: If the queue is not accepting any more items then TryEnqueue below will fail.
var textDocument = handler.GetTextDocumentIdentifier(request);
var item = new QueueItem(mutatesSolutionState, clientCapabilities, clientName, textDocument,
callbackAsync: async(context, cancellationToken) =>
{
// Check if cancellation was requested while this was waiting in the queue
if (cancellationToken.IsCancellationRequested)
{
completion.SetCanceled();
// Tell the queue to ignore any mutations from this request, not that we've given it a chance
// to make any
return(false);
}
try
{
var result = await handler.HandleRequestAsync(request, context, cancellationToken).ConfigureAwait(false);
completion.SetResult(result);
// Tell the queue that this was successful so that mutations (if any) can be applied
return(true);
}
catch (OperationCanceledException ex)
{
completion.TrySetCanceled(ex.CancellationToken);
}
catch (Exception exception)
{
// Pass the exception to the task completion source, so the caller of the ExecuteAsync method can observe but
// don't let it escape from this callback, so it doesn't affect the queue processing.
completion.SetException(exception);
}
// Tell the queue to ignore any mutations from this request
return(false);
}, requestCancellationToken);
var didEnqueue = _queue.TryEnqueue(item);
// If the queue has been shut down the enqueue will fail, so we just fault the task immediately.
// The queue itself is threadsafe (_queue.TryEnqueue and _queue.Complete use the same lock).
if (!didEnqueue)
{
completion.SetException(new InvalidOperationException("Server was requested to shut down."));
}
return(completion.Task);
}
public async Task AsyncSendAndCloseAndReceiveAll(int count)
{
var cancellation = new CancellationTokenSource(TimeSpan.FromSeconds(5));
var asyncQueue = new AsyncQueue <int>();
var sendValue = 0;
var sendTask = new Func <Task>(async() =>
{
await Task.Yield();
while (cancellation.IsCancellationRequested == false)
{
if (asyncQueue.TryEnqueue(sendValue++) == false)
{
return;
}
await Task.Delay(10).ConfigureAwait(false);
}
})().IgnoreFaultOrCancellation().ConfigureAwait(false);
await Task.Delay(count);
var actualSum = asyncQueue.TakeAllAndClose().Sum();
await sendTask;
var expectedSum = Enumerable.Range(0, sendValue).Sum();
Assert.NotEqual(expectedSum, actualSum);
Assert.Equal(0, asyncQueue.Count);
cancellation.Cancel();
}
public async Task ParallelSendAndDequeueAsync(int count)
{
var cancellation = new CancellationTokenSource(TimeSpan.FromSeconds(5));
var options = new ParallelOptions {
MaxDegreeOfParallelism = Environment.ProcessorCount, TaskScheduler = TaskScheduler.Default
};
var asyncQueue = new AsyncQueue <int>();
var items = Enumerable.Range(0, count).ToArray();
var expectedSum = items.Sum();
var actualSum = 0;
var ct = 0;
var receiveTask = new Func <Task>(async() =>
{
await Task.Yield();
while (cancellation.IsCancellationRequested == false)
{
var value = await asyncQueue.DequeueAsync(cancellation.Token).ConfigureAwait(false);
Interlocked.Add(ref actualSum, value);
if (Interlocked.Increment(ref ct) == count)
{
return;
}
}
})();
Parallel.For(0, count, options, i => Assert.True(asyncQueue.TryEnqueue(i), "fail to send"));
await receiveTask.ConfigureAwait(false);
Assert.Equal(expectedSum, actualSum);
Assert.Equal(0, asyncQueue.Count);
}
internal void CompleteCompilationEventQueue_NoLock()
{
Debug.Assert(EventQueue != null);
// Signal the end of compilation.
EventQueue.TryEnqueue(new CompilationCompletedEvent(this));
EventQueue.PromiseNotToEnqueue();
EventQueue.TryComplete();
}
public void QueueRepositoryDiscovery(string filePath)
{
lock (_filesRepositoryToDiscover)
{
Requires.NotNullOrEmpty(filePath, nameof(filePath));
_filesRepositoryToDiscover.TryEnqueue(filePath);
}
TreatRepositoryDiscoveryQueueAsync().Forget();
}
public void TryEnqueueAndTryDequeue(int count)
{
var asyncQueue = new AsyncQueue <int>();
for (var i = 0; i < count; i++)
{
Assert.True(asyncQueue.TryEnqueue(i), "fail to send");
}
for (var i = 0; i < count; i++)
{
var value = default(int);
Assert.True(asyncQueue.TryDequeue(out value), "fail to receive");
Assert.Equal(i, value);
}
Assert.Equal(0, asyncQueue.Count);
}
public async Task TryEnqueueAndDequeueAsync(int count)
{
var cancellation = new CancellationTokenSource(TimeSpan.FromSeconds(1000));
var asyncQueue = new AsyncQueue <int>();
var items = Enumerable.Range(0, count).ToArray();
var expectedSum = items.Sum();
var actualSum = 0;
var ct = 0;
var receiveTask = new Func <Task>(async() =>
{
await Task.Yield();
while (cancellation.IsCancellationRequested == false)
{
var receiveValueTask = asyncQueue.DequeueAsync(cancellation.Token).ConfigureAwait(false);
var value1 = await receiveValueTask;
var value2 = await receiveValueTask;
Assert.Equal(value1, value2); // check if awaited values are same
this.logger.Debug(value1.ToString());
Interlocked.Add(ref actualSum, value1);
if (Interlocked.Increment(ref ct) == count)
{
return;
}
}
})();
await Task.Delay(10, cancellation.Token).ConfigureAwait(false);
for (var i = 0; i < count; i++)
{
Assert.True(asyncQueue.TryEnqueue(i), "fail to send");
}
await receiveTask.ConfigureAwait(false);
Assert.Equal(expectedSum, actualSum);
Assert.Equal(0, asyncQueue.Count);
}
/// <summary>
/// Бесконечно запрашивает у пользователя сообщения для отправки
/// </summary>
static void AskingUserForMessages()
{
while (true)
{
Console.WriteLine("Введите сообщение для отправки на сервер: ");
var messageText = Console.ReadLine();
if (messageText == string.Empty)
{
closeProgram = true;
break;
}
var newMessage = new Message()
{
Text = messageText
};
SaveMessage(newMessage);
messagesToSend.TryEnqueue(newMessage);
}
}
public async Task SlowSendAndFastDequeueAsync(int seconds)
{
var cancellation = new CancellationTokenSource(TimeSpan.FromSeconds(5));
var asyncQueue = new AsyncQueue <int>(10);
var expectedValue = (int)(DateTime.Now.Ticks % int.MaxValue);
var ct = 0;
var receiveTask = new Func <Task>(async() =>
{
await Task.Yield();
while (cancellation.IsCancellationRequested == false)
{
await Task.Delay(1).ConfigureAwait(false);
var actual = await asyncQueue.DequeueAsync(cancellation.Token).ConfigureAwait(false);
ct++;
Assert.Equal(expectedValue, actual);
}
})().IgnoreFaultOrCancellation().ConfigureAwait(false);
var sendTask = new Func <Task>(async() =>
{
await Task.Yield();
while (cancellation.IsCancellationRequested == false)
{
asyncQueue.TryEnqueue(expectedValue);
await Task.Delay(2).ConfigureAwait(false);
}
})().IgnoreFaultOrCancellation().ConfigureAwait(false);
while (cancellation.IsCancellationRequested == false)
{
await Task.Delay(10).ConfigureAwait(false);
}
await receiveTask;
await sendTask;
Assert.NotEqual(0, ct);
}
public void ParallelSendAndTryDequeue(int count)
{
var asyncQueue = new AsyncQueue <int>();
var options = new ParallelOptions {
MaxDegreeOfParallelism = Environment.ProcessorCount, TaskScheduler = TaskScheduler.Default
};
var items = Enumerable.Range(0, count).ToArray();
var expectedSum = items.Sum();
Parallel.For(0, count, options, i => Assert.True(asyncQueue.TryEnqueue(i), "fail to send"));
var actualSum = 0;
var value = default(int);
while (asyncQueue.TryDequeue(out value))
{
actualSum += value;
}
Assert.Equal(expectedSum, actualSum);
Assert.Equal(0, asyncQueue.Count);
}
public async Task ParallelSendAndCloseReceiveAll(int count)
{
var cancellationSource = new CancellationTokenSource();
var asyncQueue = new AsyncQueue <int>();
var options = new ParallelOptions {
CancellationToken = cancellationSource.Token, MaxDegreeOfParallelism = Environment.ProcessorCount / 2, TaskScheduler = TaskScheduler.Default
};
var items = new ConcurrentQueue <int>(Enumerable.Range(0, count));
var sendTask = Task.Factory.StartNew(() => Parallel.For(0, count, options, i =>
{
var item = default(int);
if (items.TryDequeue(out item))
{
if (asyncQueue.TryEnqueue(item) == false)
{
items.Enqueue(item);
}
}
}));
await Task.Delay(1).ConfigureAwait(false);
var itemsInAsyncQueue = asyncQueue.TakeAllAndClose(); // deny TryEnqueue
cancellationSource.Cancel(); // stop parallel for
await sendTask.IgnoreFaultOrCancellation().ConfigureAwait(false);
var actualCount = items.Count + itemsInAsyncQueue.Count;
this.logger.Debug($"[TEST] en-queued: {itemsInAsyncQueue.Count}, total: {count}");
Assert.Equal(count, actualCount);
Assert.Equal(0, asyncQueue.Count);
}
private async Task NegotiateWebSocket(NetworkConnection networkConnection)
{
if (networkConnection == null)
{
throw new ArgumentNullException(nameof(networkConnection));
}
await Task.Yield();
WebSocketNegotiationResult result;
try
{
var timeoutTask = Task.Delay(_options.NegotiationTimeout);
foreach (var conExt in _extensions)
{
var extTask = conExt.ExtendConnectionAsync(networkConnection);
await Task.WhenAny(timeoutTask, extTask).ConfigureAwait(false);
if (timeoutTask.IsCompleted)
{
#pragma warning disable 4014
extTask.IgnoreFaultOrCancellation(); // make connection exception observed
#pragma warning restore 4014
throw new WebSocketException($"Negotiation timeout (Extension: {conExt.GetType().Name})");
}
networkConnection = await extTask.ConfigureAwait(false);
}
var handshakeTask = _handShaker.HandshakeAsync(networkConnection);
await Task.WhenAny(timeoutTask, handshakeTask).ConfigureAwait(false);
if (timeoutTask.IsCompleted)
{
#pragma warning disable 4014
handshakeTask.IgnoreFaultOrCancellation(); // make connection exception observed
#pragma warning restore 4014
throw new WebSocketException("Negotiation timeout");
}
var handshake = await handshakeTask.ConfigureAwait(false);
if (handshake.IsValidWebSocketRequest)
{
result = new WebSocketNegotiationResult(handshake.Factory.CreateWebSocket(networkConnection, _options, handshake.Request, handshake.Response, handshake.NegotiatedMessageExtensions));
}
else if (handshake.IsValidHttpRequest && _options.HttpFallback != null)
{
_options.HttpFallback.Post(handshake.Request, networkConnection);
return;
}
else
{
SafeEnd.Dispose(networkConnection, this.log);
result = new WebSocketNegotiationResult(handshake.Error);
}
var webSocket = result.Result;
if (_negotiations.TryEnqueue(result) == false)
{
SafeEnd.Dispose(webSocket);
return; // too many negotiations
}
if (webSocket != null)
{
this.pingQueue?.GetSubscriptionList().Add(webSocket);
}
}
catch (Exception negotiationError)
{
if (this.log.IsDebugEnabled)
{
this.log.Debug("An error occurred while negotiating WebSocket request.", negotiationError);
}
SafeEnd.Dispose(networkConnection, this.log);
result = new WebSocketNegotiationResult(ExceptionDispatchInfo.Capture(negotiationError));
}
finally
{
_semaphore.Release();
}
}