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)); }