public ReusableTask <int> ReadAsync(ITorrentFileInfo file, long offset, Memory <byte> buffer)
{
if (DoNotReadFrom.Contains(file))
{
return(ReusableTask.FromResult(0));
}
if (!Paths.Contains(file.FullPath))
{
Paths.Add(file.FullPath);
}
if ((offset + buffer.Length) > file.Length)
{
throw new ArgumentOutOfRangeException("Tried to read past the end of the file");
}
if (!DontWrite)
{
for (int i = 0; i < buffer.Length; i++)
{
buffer.Span[i] = (byte)i;
}
}
return(ReusableTask.FromResult(buffer.Length));
}
public ReusableTask <int> ReadAsync(ITorrentFileInfo file, long offset, byte[] buffer, int bufferOffset, int count)
{
if (DoNotReadFrom.Contains(file))
{
return(ReusableTask.FromResult(0));
}
if (!Paths.Contains(file.FullPath))
{
Paths.Add(file.FullPath);
}
if ((offset + count) > file.Length)
{
throw new ArgumentOutOfRangeException("Tried to read past the end of the file");
}
if (!DontWrite)
{
for (int i = 0; i < count; i++)
{
buffer[bufferOffset + i] = (byte)(bufferOffset + i);
}
}
return(ReusableTask.FromResult(count));
}
public ReusableTask <bool> ReadFromCacheAsync(ITorrentData torrent, BlockInfo block, Memory <byte> buffer)
{
if (torrent == null)
{
throw new ArgumentNullException(nameof(torrent));
}
if (CachedBlocks.TryGetValue(torrent, out List <CachedBlock> blocks))
{
for (int i = 0; i < blocks.Count; i++)
{
var cached = blocks[i];
if (cached.Block != block)
{
continue;
}
cached.Buffer.CopyTo(buffer);
if (!cached.Flushing)
{
blocks[i] = cached.SetFlushing();
FlushBlockAsync(torrent, blocks, cached);
}
Interlocked.Add(ref cacheHits, block.RequestLength);
ReadFromCache?.Invoke(this, block);
return(ReusableTask.FromResult(true));
}
}
return(ReusableTask.FromResult(false));
}
public async Task FromResult_TwiceConcurrent()
{
var task1 = ReusableTask.FromResult(4);
var task2 = ReusableTask.FromResult(14);
Assert.AreEqual(14, await task2);
Assert.AreEqual(4, await task1);
}
public ReusableTask <bool> ExistsAsync(ITorrentFileInfo file)
{
if (exist)
{
throw new Exception("exists");
}
return(ReusableTask.FromResult(true));
}
public ReusableTask <int> ReadAsync(ITorrentFileInfo file, long offset, byte[] buffer, int bufferOffset, int count)
{
if (read)
{
throw new Exception("read");
}
return(ReusableTask.FromResult(count));
}
public ReusableTask <int> ReadAsync(ITorrentFileInfo file, long offset, Memory <byte> buffer)
{
if (read)
{
throw new Exception("read");
}
return(ReusableTask.FromResult(buffer.Length));
}
/// <summary>
///
/// </summary>
/// <param name="e"></param>
public void SetException(Exception e)
{
if (task.ResultHolder == null)
{
lock (Cache)
task = new ReusableTask <T> (Cache.Count > 0 ? Cache.Pop() : new ResultHolder <T> (true));
}
task.ResultHolder.SetException(e);
}
public async Task FromResult_TwiceSequential()
{
var task = ReusableTask.FromResult(5);
Assert.AreEqual(0, ReusableTaskMethodBuilder <int> .CacheCount);
Assert.IsTrue(task.IsCompleted);
Assert.AreEqual(5, await task);
Assert.AreEqual(15, await ReusableTask.FromResult(15));
}
public static async ReusableTask <T> WithTimeout <T> (this ReusableTask <T> task, string message)
{
var t = task.AsTask();
if (await Task.WhenAny(Task.Delay(Timeout), t) != t)
{
Assert.Fail("The task timed out. {0}", message);
}
return(await t);
}
protected override ReusableTask <ScrapeResponse> DoScrapeAsync(ScrapeParameters parameters, CancellationToken token)
{
ScrapedAt.Add(DateTime.Now);
if (FailScrape)
{
throw new TrackerException("Deliberately failing scrape request", null);
}
return(ReusableTask.FromResult(new ScrapeResponse(0, 0, 0)));
}
public ReusableTask <AnnounceResponse> AnnounceAsync(AnnounceRequest parameters, CancellationToken token)
{
AnnouncedAt.Add(DateTime.Now);
if (FailAnnounce)
{
throw new TrackerException("Deliberately failing announce request", null);
}
AnnounceParameters.Add(parameters);
return(ReusableTask.FromResult(new AnnounceResponse(TrackerState.Ok, peers: peers.Select(t => new PeerInfo(t.ConnectionUri, t.PeerId?.AsMemory() ?? Memory <byte> .Empty)).ToArray())));
}
protected override ReusableTask <AnnounceResponse> DoAnnounceAsync(AnnounceParameters parameters, CancellationToken token)
{
AnnouncedAt.Add(DateTime.Now);
if (FailAnnounce)
{
throw new TrackerException("Deliberately failing announce request", null);
}
AnnounceParameters.Add(parameters);
return(ReusableTask.FromResult(new AnnounceResponse(peers, null, null)));
}
/// <summary>
///
/// </summary>
public void SetResult()
{
if (task.ResultHolder == null)
{
task = ReusableTask.CompletedTask;
}
else
{
task.ResultHolder.SetResult(new EmptyStruct());
}
}
/// <summary>
///
/// </summary>
/// <param name="result"></param>
public void SetResult(T result)
{
if (task.ResultHolder == null)
{
task = new ReusableTask <T> (result);
}
else
{
task.ResultHolder.SetResult(result);
}
}
public ReusableTask <bool> ExistsAsync(ITorrentFileInfo file)
{
foreach (var item in CachedBlocks)
{
if (item.File == file)
{
return(ReusableTask.FromResult(true));
}
}
return(Writer.ExistsAsync(file));
}
/// <summary>
///
/// </summary>
/// <typeparam name="TAwaiter"></typeparam>
/// <typeparam name="TStateMachine"></typeparam>
/// <param name="awaiter"></param>
/// <param name="stateMachine"></param>
public void AwaitUnsafeOnCompleted <TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
where TAwaiter : ICriticalNotifyCompletion
where TStateMachine : IAsyncStateMachine
{
if (task.ResultHolder == null)
{
lock (Cache)
task = new ReusableTask <T> (Cache.Count > 0 ? Cache.Pop() : new ResultHolder <T> (true));
task.ResultHolder.SyncContext = SynchronizationContext.Current;
}
StateMachineCache <TStateMachine> .GetOrCreate()
.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine);
}
/// <summary>
/// Begins the message stream encryption handshaking process
/// </summary>
/// <param name="socket">The socket to perform handshaking with</param>
public virtual async ReusableTask HandshakeAsync(IConnection2 socket)
{
this.socket = socket ?? throw new ArgumentNullException(nameof(socket));
// Either "1 A->B: Diffie Hellman Ya, PadA" or "2 B->A: Diffie Hellman Yb, PadB"
// These two steps will be done simultaneously to save time due to latency
ReusableTask first = SendY();
ReusableTask second = ReceiveY();
try {
await first;
await second;
} catch (Exception ex) {
socket.Dispose();
throw new EncryptionException("Encrypted handshake failed", ex);
}
}
public ReusableTask <int> ReadAsync(ITorrentFileInfo file, long offset, byte[] buffer, int bufferOffset, int count)
{
ReadData.Add(Tuple.Create(file, offset, count));
if (Data == null)
{
var fileData = WrittenData
.Where(t => t.Item1 == file)
.OrderBy(t => t.Item2)
.SelectMany(t => t.Item3)
.ToArray();
Buffer.BlockCopy(fileData, (int)offset, buffer, bufferOffset, count);
}
else
{
var data = Data[file];
Buffer.BlockCopy(data, (int)offset, buffer, bufferOffset, count);
}
return(ReusableTask.FromResult(count));
}
public ReusableTask <int> ReadAsync(ITorrentFileInfo file, long offset, Memory <byte> buffer)
{
ReadData.Add(Tuple.Create(file, offset, buffer.Length));
if (Data == null)
{
var fileData = WrittenData
.Where(t => t.Item1 == file)
.OrderBy(t => t.Item2)
.SelectMany(t => t.Item3)
.ToArray();
fileData.AsSpan((int)offset, buffer.Length).CopyTo(buffer.Span);
}
else
{
var data = Data[file];
data.AsSpan((int)offset, buffer.Length).CopyTo(buffer.Span);
}
return(ReusableTask.FromResult(buffer.Length));
}
public ReusableTask <bool> ExistsAsync(ITorrentFileInfo file)
{
return(ReusableTask.FromResult(File.Exists(file.FullPath)));
}
public ReusableTask <int> ReadAsync(ITorrentFileInfo file, long offset, Memory <byte> buffer)
{
return(ReusableTask.FromResult(0));
}
public ReusableTask <bool> ExistsAsync(ITorrentFileInfo file)
{
return(ReusableTask.FromResult(false));
}
public ReusableTask <int> ReadAsync(ITorrentFileInfo file, long offset, byte[] buffer, int bufferOffset, int count)
{
return(ReusableTask.FromResult(0));
}
public static Task <T> WithTimeout <T> (this ReusableTask <T> task, string message = null) => task.AsTask().WithTimeout(message);
public static Task <T> WithTimeout <T> (this ReusableTask <T> task, int timeout, string message = null) => task.AsTask().WithTimeout(TimeSpan.FromMilliseconds(timeout), message);
public ReusableTask <bool> ExistsAsync(ITorrentFileInfo file)
{
return(ReusableTask.FromResult(FilesThatExist.Contains(file)));
}
public static Task WithTimeout(this ReusableTask task, TimeSpan timeout, string message = null) => task.AsTask().WithTimeout(timeout, message);
public ReusableTask <bool> ExistsAsync(ITorrentManagerFile file)
{
return(ReusableTask.FromResult(true));
}
public ReusableTask <int> SendAsync(Memory <byte> buffer)
{
return(ReusableTask.FromResult(0));
}
