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 ReusableTask <int> ReadAsync(ITorrentFileInfo file, long offset, Memory <byte> buffer)
{
if (read)
{
throw new Exception("read");
}
return(ReusableTask.FromResult(buffer.Length));
}
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 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));
}
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)));
}
public ReusableTask <bool> ExistsAsync(ITorrentFileInfo file)
{
foreach (var item in CachedBlocks)
{
if (item.File == file)
{
return(ReusableTask.FromResult(true));
}
}
return(Writer.ExistsAsync(file));
}
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(FilesThatExist.Contains(file)));
}
public ReusableTask <bool> ExistsAsync(ITorrentFileInfo file)
{
return(ReusableTask.FromResult(File.Exists(file.FullPath)));
}
public ReusableTask <bool> ExistsAsync(ITorrentManagerFile file)
{
return(ReusableTask.FromResult(true));
}
protected override ReusableTask <ScrapeResponse> DoScrapeAsync(ScrapeParameters parameters, CancellationToken token)
{
return(ReusableTask.FromResult(new ScrapeResponse(0, 0, 0)));
}
public ReusableTask <int> ReadAsync(ITorrentFileInfo file, long offset, Memory <byte> buffer)
{
return(ReusableTask.FromResult(0));
}
public ReusableTask <ScrapeResponse> ScrapeAsync(ScrapeRequest parameters, CancellationToken token)
{
return(ReusableTask.FromResult(new ScrapeResponse(TrackerState.Ok)));
}
public ReusableTask <int> SendAsync(Memory <byte> buffer)
{
return(ReusableTask.FromResult(0));
}
public ReusableTask <int> ReadAsync(ITorrentFileInfo file, long offset, byte[] buffer, int bufferOffset, int count)
{
return(ReusableTask.FromResult(0));
}
public ReusableTask <AnnounceResponse> AnnounceAsync(AnnounceRequest parameters, CancellationToken token)
{
return(ReusableTask.FromResult(new AnnounceResponse(TrackerState.Ok)));
}
public ReusableTask <bool> ExistsAsync(ITorrentFileInfo file)
{
return(ReusableTask.FromResult(false));
}
public ReusableTask <int> SendAsync(ByteBuffer buffer, int offset, int count)
{
return(ReusableTask.FromResult(0));
}
public ReusableTask <int> SendAsync(SocketMemory buffer)
{
return(ReusableTask.FromResult(0));
}
protected override ReusableTask <AnnounceResponse> DoAnnounceAsync(AnnounceParameters parameters, CancellationToken token)
{
return(ReusableTask.FromResult(new AnnounceResponse(new List <Peer> (), null, null)));
}