public IAsyncResult BeginReceive(byte[] buffer, int offset, int count, AsyncCallback callback, object state) { if (receiveResult != null) { throw new InvalidOperationException("Cannot call BeginReceive twice"); } receiveResult = new HttpResult(callback, state, buffer, offset, count); try { // BeginReceive has been called *before* we have sent a piece request. // Wait for a piece request to be sent before allowing this to complete. if (dataStream == null) { return(receiveResult); } DoReceive(); return(receiveResult); } catch (Exception ex) { if (sendResult != null) { sendResult.Complete(ex); } if (receiveResult != null) { receiveResult.Complete(ex); } } return(receiveResult); }
public IAsyncResult BeginReceive(byte[] buffer, int offset, int count, AsyncCallback callback, object state) { if (receiveResult != null) throw new InvalidOperationException("Cannot call BeginReceive twice"); receiveResult = new HttpResult(callback, state, buffer, offset, count); try { // BeginReceive has been called *before* we have sent a piece request. // Wait for a piece request to be sent before allowing this to complete. if (dataStream == null) return receiveResult; DoReceive(); return receiveResult; } catch (Exception ex) { if (sendResult != null) sendResult.Complete(ex); if (receiveResult != null) receiveResult.Complete(ex); } return receiveResult; }
public IAsyncResult BeginSend(byte[] buffer, int offset, int count, AsyncCallback callback, object state) { if (sendResult != null) { throw new InvalidOperationException("Cannot call BeginSend twice"); } sendResult = new HttpResult(callback, state, buffer, offset, count); try { List <PeerMessage> bundle = DecodeMessages(buffer, offset, count); if (bundle == null) { sendResult.Complete(count); } else if (bundle.TrueForAll(delegate(PeerMessage m) { return(m is RequestMessage); })) { #if NETSTANDARD1_5 var mesList = bundle.ConvertAll <PeerMessage, RequestMessage>(delegate(PeerMessage m) { return((RequestMessage)m); }); #else var mesList = bundle.ConvertAll <RequestMessage> (delegate(PeerMessage m) { return((RequestMessage)m); }); #endif requestMessages.AddRange(mesList); // The RequestMessages are always sequential RequestMessage start = (RequestMessage)bundle[0]; RequestMessage end = (RequestMessage)bundle[bundle.Count - 1]; CreateWebRequests(start, end); KeyValuePair <WebRequest, int> r = webRequests.Dequeue(); totalExpected = r.Value; BeginGetResponse(r.Key, getResponseCallback, r.Key); } else { sendResult.Complete(count); } } catch (Exception ex) { sendResult.Complete(ex); } return(sendResult); }
private void ReceivedChunk(IAsyncResult result) { if (disposed) { return; } try { int received = dataStream.EndRead(result); if (received == 0) { throw new WebException("No futher data is available"); } receiveResult.BytesTransferred += received; currentRequest.TotalReceived += received; // We've received everything for this piece, so null it out if (currentRequest.Complete) { currentRequest = null; } totalExpected -= received; receiveResult.Complete(); } catch (Exception ex) { receiveResult.Complete(ex); } finally { // If there are no more requests pending, complete the Send call if (currentRequest == null && requestMessages.Count == 0) { RequestCompleted(); } } }
public IAsyncResult BeginSend(byte[] buffer, int offset, int count, AsyncCallback callback, object state) { if (_sendResult != null) { throw new InvalidOperationException("Cannot call BeginSend twice"); } _sendResult = new HttpResult(callback, state, buffer, offset, count); try { var bundle = DecodeMessages(buffer, offset, count); if (bundle == null) { _sendResult.Complete(count); } else if (bundle.TrueForAll(m => m is RequestMessage)) { _requestMessages.AddRange(bundle.Cast <RequestMessage>()); // The RequestMessages are always sequential var start = (RequestMessage)bundle[0]; var end = (RequestMessage)bundle[bundle.Count - 1]; CreateWebRequests(start, end); var r = _webRequests.Dequeue(); _totalExpected = r.Value; BeginGetResponse(r.Key, _getResponseCallback, r.Key); } else { _sendResult.Complete(count); } } catch (Exception ex) { _sendResult.Complete(ex); } return(_sendResult); }
public IAsyncResult BeginSend(byte[] buffer, int offset, int count, AsyncCallback callback, object state) { if (sendResult != null) throw new InvalidOperationException("Cannot call BeginSend twice"); sendResult = new HttpResult(callback, state, buffer, offset, count); try { List<PeerMessage> bundle = DecodeMessages(buffer, offset, count); if (bundle == null) { sendResult.Complete(count); } else if (bundle.TrueForAll(delegate(PeerMessage m) { return m is RequestMessage; })) { requestMessages.AddRange(bundle.ConvertAll<RequestMessage>(delegate(PeerMessage m) { return (RequestMessage)m; })); // The RequestMessages are always sequential RequestMessage start = (RequestMessage)bundle[0]; RequestMessage end = (RequestMessage)bundle[bundle.Count - 1]; CreateWebRequests(start, end); KeyValuePair<WebRequest, int> r = webRequests.Dequeue(); totalExpected = r.Value; BeginGetResponse(r.Key, getResponseCallback, r.Key); } else { sendResult.Complete(count); } } catch (Exception ex) { sendResult.Complete(ex); } return sendResult; }
public IAsyncResult BeginSend(byte[] buffer, int offset, int count, AsyncCallback callback, object state) { if (_sendResult != null) throw new InvalidOperationException("Cannot call BeginSend twice"); _sendResult = new HttpResult(callback, state, buffer, offset, count); try { var bundle = DecodeMessages(buffer, offset, count); if (bundle == null) { _sendResult.Complete(count); } else if (bundle.TrueForAll(m => m is RequestMessage)) { _requestMessages.AddRange(bundle.Cast<RequestMessage>()); // The RequestMessages are always sequential var start = (RequestMessage) bundle[0]; var end = (RequestMessage) bundle[bundle.Count - 1]; CreateWebRequests(start, end); var r = _webRequests.Dequeue(); _totalExpected = r.Value; BeginGetResponse(r.Key, _getResponseCallback, r.Key); } else { _sendResult.Complete(count); } } catch (Exception ex) { _sendResult.Complete(ex); } return _sendResult; }
private void DoReceive() { byte[] buffer = receiveResult.Buffer; int offset = receiveResult.Offset; int count = receiveResult.Count; if (currentRequest == null && requestMessages.Count > 0) { currentRequest = new HttpRequestData(requestMessages[0]); requestMessages.RemoveAt(0); } if (totalExpected == 0) { if (webRequests.Count == 0) { sendResult.Complete(sendResult.Count); } else { KeyValuePair <WebRequest, int> r = webRequests.Dequeue(); totalExpected = r.Value; BeginGetResponse(r.Key, getResponseCallback, r.Key); } return; } if (!currentRequest.SentLength) { // The message length counts as the first four bytes currentRequest.SentLength = true; currentRequest.TotalReceived += 4; Message.Write(receiveResult.Buffer, receiveResult.Offset, currentRequest.TotalToReceive - currentRequest.TotalReceived); receiveResult.Complete(4); return; } else if (!currentRequest.SentHeader) { currentRequest.SentHeader = true; // We have *only* written the messageLength to the stream // Now we need to write the rest of the PieceMessage header int written = 0; written += Message.Write(buffer, offset + written, PieceMessage.MessageId); written += Message.Write(buffer, offset + written, CurrentRequest.Request.PieceIndex); written += Message.Write(buffer, offset + written, CurrentRequest.Request.StartOffset); count -= written; offset += written; receiveResult.BytesTransferred += written; currentRequest.TotalReceived += written; } int received = dataStream.Read(buffer, offset, count); if (disposed) { return; } try { if (received == 0) { throw new WebException("No futher data is available"); } receiveResult.BytesTransferred += received; currentRequest.TotalReceived += received; // We've received everything for this piece, so null it out if (currentRequest.Complete) { currentRequest = null; } totalExpected -= received; receiveResult.Complete(); } catch (Exception ex) { receiveResult.Complete(ex); } finally { // If there are no more requests pending, complete the Send call if (currentRequest == null && requestMessages.Count == 0) { RequestCompleted(); } } }