public async Task DequeueAsync_GivenTokenIsCanceled_ShouldCancelTask()
{
//Arrange
CancellationTokenSource source1 = new(), source2 = new();
const int excepted = 1;
var queue = new AsyncQueue <int>();
var task1 = queue.Dequeue(source1.Token).AsTask();
var task2 = queue.Dequeue(source2.Token).AsTask();
//Act
source1.Cancel();
queue.Enqueue(excepted);
var exception = await Record.ExceptionAsync(() => task1).ConfigureAwait(false);
await task2.ConfigureAwait(false);
//Assert
exception.Should().BeOfType <TaskCanceledException>();
task2.Result.Should().Be(excepted);
//Annihilate
source1.Dispose();
source2.Dispose();
queue.Dispose();
}
public async Task DequeueAsync_GivenTokenIsCanceled_ShouldCancelTask()
{
//Arrange
CancellationTokenSource source1 = new CancellationTokenSource(), source2 = new CancellationTokenSource();
const int excepted = 1;
var queue = new AsyncQueue <int>();
var task1 = queue.Dequeue(source1.Token);
var task2 = queue.Dequeue(source2.Token);
//Act
source1.Cancel();
queue.Enqueue(excepted);
var exception = await Record.ExceptionAsync(() => task1.AsTask()).ConfigureAwait(false); // xUnit can't record ValueTask yet
await task2.ConfigureAwait(false);
//Assert
Assert.IsType <TaskCanceledException>(exception);
Assert.Equal(excepted, task2.Result);
//Annihilate
source1.Dispose();
source2.Dispose();
queue.Dispose();
}
private async Task ProcessHandler(AsyncQueue <OwnTcpSendMessage> queue)
{
while (true)
{
(_, OwnTcpSendMessage item) = await queue.Dequeue();
if (queue.IsEnd)
{
break;
}
try
{
LockTopic(item.Message.Topic, item.Message.Payload);
bool success = HandlerMessage(item.Message);
item.SetResult(success);
}
catch (Exception e)
{
item.SetException(e);
}
finally
{
UnlockTopic(item.Message.Topic);
}
}
}
private async ValueTask SendAllRequestsInQueue(IEasyClient <Response, Request> client, int index)
{
if (!_uncheckedRequests.TryGetValue((EasyClient <Response>)client, out var uncheckedRequest))
{
return;
}
var success = false;
while (!success)
{
success = await Connect(index);
if (!success)
{
Thread.Sleep(1000);
}
}
while (_running)
{
if (_uncheckedRequests.Count > MaxSizeOfUncheckedRequestList)
{
Thread.Sleep(100);
continue;
}
var request = await _toBeSendRequests.Dequeue();
// 若请求已超时，则放弃
if (request.IsTimeout)
{
continue;
}
try
{
await client.SendAsync(request.Request);
uncheckedRequest.Add(new Tuple <DateTime, RequestWithTimeout>(DateTime.Now, request));
}
catch
{
if (!_running)
{
return;
}
await _toBeSendRequests.Enqueue(request,
new RequestPriority(0, request.Request.Id));
success = await Connect(index);
if (!success)
{
Thread.Sleep(200);
}
}
}
}
/// <summary> Loop forever (or at least, until it's done). </summary>
/// <remarks> Any exceptions thrown are passed to the exception callback. </remarks>
private async Task Loop()
{
// Wait for initialization to finish and check success.
try
{
await Ready.ConfigureAwait(false);
}
catch (OperationCanceledException) { throw; }
catch (Exception e)
{
_log?.Error("While waiting to catch up with event stream.", e);
return;
}
// The auto-refresh process
// ========================
// This is a background task that checks periodically whether
// a synchronization with the remote stream has occurred. If
// it has not, it performs one.
#pragma warning disable CS4014
Task.Run(async() =>
{
while (!_cancel.IsCancellationRequested)
{
var syncStep = Wrapper.SyncStep;
// RefreshPeriod/2 because it's possible to have a
// syncStep increment happen right before this 'await',
// in which case the delay will execute twice before
// it detects that no sync is happening.
await Task.Delay(TimeSpan.FromSeconds(RefreshPeriod / 2), _cancel);
if (syncStep == Wrapper.SyncStep)
{
await CatchUpAsync(default(CancellationToken));
}
}
}, _cancel);
#pragma warning restore CS4014
// The actual loop
// ===============
while (!_cancel.IsCancellationRequested)
{
// This sleeps until an action becomes available in the queue
var nextAction = await _pending.Dequeue(_cancel).ConfigureAwait(false);
// The action does not throw (is it wrapped properly)
await nextAction().ConfigureAwait(false);
}
}
public async Task DequeueAsync_GivenSequenceOfInput_ShouldReturnSameSequenceOfOutput()
{
//Arrange
const int expected1 = 1, expected2 = 2;
var queue = new AsyncQueue <int>();
queue.Enqueue(expected1);
queue.Enqueue(expected2);
//Act
var actual1 = await queue.Dequeue().ConfigureAwait(false);
var actual2 = await queue.Dequeue().ConfigureAwait(false);
//Assert
actual1.Should().Be(expected1);
actual2.Should().Be(expected2);
//Annihilate
queue.Dispose();
}
public async Task DequeueAsync_GivenSequenceOfInput_ShouldReturnSameSequenceOfOutput()
{
//Arrange
const int value1 = 1, value2 = 2;
var queue = new AsyncQueue <int>();
queue.Enqueue(value1);
queue.Enqueue(value2);
//Act
var actual1 = await queue.Dequeue().ConfigureAwait(false);
var actual2 = await queue.Dequeue().ConfigureAwait(false);
//Assert
Assert.Equal(value1, actual1);
Assert.Equal(value2, actual2);
//Annihilate
queue.Dispose();
}
async void Writer(NeoSocket neoSocket, AsyncQueue <byte[]> queue)
{
try
{
while (await queue.HasItemsAsync())
{
var buffer = queue.Dequeue();
await neoSocket.WriteAsync(buffer, 0, buffer.Length);
}
}
catch { queue.SetFinished(); }
finally { neoSocket.Close(); }
}
public async Task DequeueAsync_GivenMultipleDequeues_ShouldCompleteInOrderedSequence()
{
//Arrange
const int value1 = 1, value2 = 2;
var queue = new AsyncQueue <int>();
var dequeue1 = queue.Dequeue();
var dequeue2 = queue.Dequeue();
queue.Enqueue(value1);
queue.Enqueue(value2);
//Act
var actual1 = await dequeue1;
var actual2 = await dequeue2;
//Assert
Assert.Equal(value1, actual1);
Assert.Equal(value2, actual2);
//Annihilate
queue.Dispose();
}
public async Task DequeueAsync_GivenMultipleDequeues_ShouldCompleteInOrderedSequence()
{
//Arrange
const int expected1 = 1, expected2 = 2;
var queue = new AsyncQueue <int>();
var dequeue1 = queue.Dequeue();
var dequeue2 = queue.Dequeue();
queue.Enqueue(expected1);
queue.Enqueue(expected2);
//Act
var actual1 = await dequeue1.ConfigureAwait(false);
var actual2 = await dequeue2.ConfigureAwait(false);
//Assert
actual1.Should().Be(expected1);
actual2.Should().Be(expected2);
//Annihilate
queue.Dispose();
}
private async Task ExtMethodQueueTestAsync()
{
AsyncQueue <string> q = new AsyncQueue <string>(5);
Func <Task> producer = async delegate()
{
#region
for (int i = 0; i < 20; ++i)
{
System.Diagnostics.Debug.WriteLine($"Writing {i}...");
await q.Enqueue($"Value: {i}", CancellationToken.None);
}
System.Diagnostics.Debug.WriteLine("Writing EOF...");
q.WriteEof();
#endregion
};
Func <Task> consumer = async delegate()
{
#region
bool more = true;
while (more)
{
System.Diagnostics.Debug.WriteLine("Reading...");
Option <string> ostr = await q.Dequeue(CancellationToken.None);
if (ostr.HasValue)
{
System.Diagnostics.Debug.WriteLine($"Read {ostr.Value}");
}
else
{
System.Diagnostics.Debug.WriteLine("Read EOF...");
more = false;
}
}
#endregion
};
Task tProducer = Task.Run(producer);
Task tConsumer = Task.Run(consumer);
await Task.WhenAll(tProducer, tConsumer);
}
private async Task Work()
{
while (true)
{
var task = await _waitingScheduleTask.Dequeue();
if (task.Status != TaskStatus.Waiting)
{
continue;
}
await Execute(task);
await Task.Yield();
}
}
private void ThreadStart()
{
var state = _consumer.Enter();
try
{
while (!Thread.IsStopRequested)
{
_queue.Dequeue(this);
}
}
finally
{
_consumer.Exit(state);
}
}
public async Task DequeueAsync_GivenQueueWasNotEmpty_ShouldCompleteDequeueTask()
{
//Arrange
const int value = 1;
var queue = new AsyncQueue <int>();
queue.Enqueue(value);
//Act
var actual = await queue.Dequeue().ConfigureAwait(false);
//Assert
Assert.Equal(value, actual);
//Annihilate
queue.Dispose();
}
public async static void Run(AsyncQueue <string> urls, Action <string> action, CancellationToken token)
{
var outputFiles = new AsyncQueue <string>();
AsyncHelper.RunTasks(urls, url => FetchSlideAsync(url, action, token), outputFiles, token);
var fileNames = new List <string>();
while (await outputFiles.HasItemsAsync(token))
{
fileNames.Add(outputFiles.Dequeue());
}
try { await Task.Delay(-1, token); }
catch (TaskCanceledException) { }
fileNames.Where(file => file != null).ToList().ForEach(File.Delete);
}
public async Task DequeueAsync_GivenQueueWasNotEmpty_ShouldCompleteDequeueTask()
{
//Arrange
const int expected = 1;
var queue = new AsyncQueue <int>();
queue.Enqueue(expected);
//Act
var actual = await queue.Dequeue().ConfigureAwait(false);
//Assert
actual.Should().Be(expected);
//Annihilate
queue.Dispose();
}
public async Task Enqueue_GivenDequeueTaskWasWaiting_ShouldCompleteDequeueTask()
{
//Arrange
const int expected = 1;
var queue = new AsyncQueue <int>();
var dequeueTask = queue.Dequeue();
queue.Enqueue(expected);
//Act
var actual = await dequeueTask.ConfigureAwait(false);
//Assert
actual.Should().Be(expected);
//Annihilate
queue.Dispose();
}
public async Task Enqueue_GivenDequeueTaskWasWaiting_ShouldCompleteDequeueTask()
{
//Arrange
const int value = 1;
var queue = new AsyncQueue <int>();
var dequeueTask = queue.Dequeue();
queue.Enqueue(value);
//Act
var actual = await dequeueTask.ConfigureAwait(false);
//Assert
Assert.Equal(value, actual);
//Annihilate
queue.Dispose();
}
public Day15()
{
AsyncQueue <long> programInputs = new AsyncQueue <long>();
AsyncQueue <long> programOutputs = new AsyncQueue <long>();
IntCodeAsync intCode = new IntCodeAsync(_program, programInputs.Dequeue, programOutputs.Enqueue);
Task vm = Task.Run(intCode.RunAsync);
Task <long> sendCommand(Direction d)
{
programInputs.Enqueue((long)d + 1);
return(programOutputs.Dequeue());
}
async Task backtrackHelper(IntVec2 position)
{
foreach (Direction d in s_directions)
{
IntVec2 candidatePosition = position + s_deltas[(int)d];
if (!_map.ContainsKey(candidatePosition))
{
Status status = (Status) await sendCommand(d);
if (status != Status.Wall)
{
_map.Add(candidatePosition, status);
if (status == Status.Oxygen)
{
_oxygen = candidatePosition;
}
await backtrackHelper(candidatePosition);
await sendCommand(s_opposites[(int)d]);
}
}
}
}
Task.Run(() => backtrackHelper(IntVec2.Zero)).Wait();
}
public async static void Run(string slidesQuery, string size, Action <string> action, CancellationToken token)
{
if (string.IsNullOrWhiteSpace(slidesQuery))
{
return;
}
var inputQueries = new AsyncQueue <string>();
slidesQuery.Split('\n').ToList().ForEach(query => inputQueries.Enqueue(query));
inputQueries.SetFinished();
var outputURLs = new AsyncQueue <List <string> >();
AsyncHelper.RunTasks(inputQueries, query => GetSlideURLs(query, size, token), outputURLs, token);
var urls = new List <string>();
while (await outputURLs.HasItemsAsync(token))
{
foreach (var item in outputURLs.Dequeue())
{
urls.Add(item);
}
}
var random = new Random();
urls = urls.OrderBy(x => random.Next()).ToList();
var inputURLs = new AsyncQueue <string>();
urls.ForEach(url => inputURLs.Enqueue(url));
inputURLs.SetFinished();
SlideDownloader.Run(inputURLs, action, token);
}
private async Task ExtMethodQueueTestAsync()
{
AsyncQueue<string> q = new AsyncQueue<string>(5);
Func<Task> producer = async delegate ()
{
#region
for (int i = 0; i < 20; ++i)
{
System.Diagnostics.Debug.WriteLine($"Writing {i}...");
await q.Enqueue($"Value: {i}", CancellationToken.None);
}
System.Diagnostics.Debug.WriteLine("Writing EOF...");
q.WriteEof();
#endregion
};
Func<Task> consumer = async delegate ()
{
#region
bool more = true;
while (more)
{
System.Diagnostics.Debug.WriteLine("Reading...");
Option<string> ostr = await q.Dequeue(CancellationToken.None);
if (ostr.HasValue)
{
System.Diagnostics.Debug.WriteLine($"Read {ostr.Value}");
}
else
{
System.Diagnostics.Debug.WriteLine("Read EOF...");
more = false;
}
}
#endregion
};
Task tProducer = Task.Run(producer);
Task tConsumer = Task.Run(consumer);
await Task.WhenAll(tProducer, tConsumer);
}
public async Task <IEnumerable <FtpEntry> > ListFilesRecursiveAsync(string startPath = null, Predicate <FtpEntry> skipFolder = null, CancellationToken ctk = default)
{
startPath = startPath ?? "./";
if (skipFolder == null)
{
skipFolder = x => false;
}
List <Task <IEnumerable <FtpEntry> > > pending = new List <Task <IEnumerable <FtpEntry> > >();
IEnumerable <FtpEntry> files = new List <FtpEntry>();
using (var d = new DisposableContainer())
{
var clientsQueue = new AsyncQueue <FluentFTP.IFtpClient>(5);
for (int i = 0; i < 5; i++)
{
var c = _getClient();
d.Add(c);
await clientsQueue.Enqueue(c, ctk);
}
Func <string, CancellationToken, Task <IEnumerable <FtpEntry> > > listFolderAsync = async(string path, CancellationToken ct) =>
{
var c = await clientsQueue.Dequeue(ct);
try
{
var retrier = Policy
.Handle <Exception>()
.WaitAndRetryAsync(new[]
{
TimeSpan.FromSeconds(1),
TimeSpan.FromSeconds(5),
TimeSpan.FromSeconds(15)
}, (ex, ts) =>
{
_logger.Warn(ex, "Failed to list folder {0}. Try again soon ...", path);
});
var res = await retrier.ExecuteAsync(ct1 =>
{
return(c.Value.GetListingAsync(path));
}, ct).ConfigureAwait(false);
return(res.Select(x => new FtpEntry()
{
FullPath = x.FullName,
IsDirectory = x.Type == FtpFileSystemObjectType.Directory,
Modified = x.Modified,
Name = x.Name,
Size = x.Size
}).ToList());
} finally
{
await clientsQueue.Enqueue(c.Value, ct);
}
};
pending.Add(listFolderAsync(startPath, ctk));
while (pending.Count > 0 && !ctk.IsCancellationRequested)
{
var completedTask = await Task.WhenAny(pending).ConfigureAwait(false);
pending.Remove(completedTask);
// task could have completed with errors ... strange, let them progate.
var list = await completedTask.ConfigureAwait(false);
//we want to exclude folders . and .. that we dont want to search
foreach (var dir in list.Where(x => x.IsDirectory && !x.Name.Equals(".") && !x.Name.Equals("..")))
{
if (skipFolder.Invoke(dir))
{
_logger.Debug("Skipping folder: {0}", dir.FullPath);
}
else
{
pending.Add(listFolderAsync(dir.FullPath, ctk));
}
}
files = files.Concat(list.Where(x => !x.IsDirectory));
}
ctk.ThrowIfCancellationRequested();
return(files.ToList());
}
}