public override Task SendAsync(byte[] buffer, Func <SocketAsyncState, Task> callback, ISpan span, ErrorMap errorMap) { SocketAsyncState state = null; try { var opaque = Converter.ToUInt32(buffer, HeaderIndexFor.Opaque); state = new SocketAsyncState { Data = MemoryStreamFactory.GetMemoryStream(), Opaque = opaque, Buffer = buffer, Completed = callback, SendOffset = _eventArgs.Offset, DispatchSpan = span, ConnectionId = ContextId, LocalEndpoint = LocalEndPoint.ToString(), ErrorMap = errorMap, Timeout = Configuration.SendTimeout }; _eventArgs.UserToken = state; Log.Debug("Sending {0} with {1} on server {2}", state.Opaque, Identity, EndPoint); //set the buffer var bufferLength = buffer.Length < Configuration.BufferSize ? buffer.Length : Configuration.BufferSize; _eventArgs.SetBuffer(state.SendOffset, bufferLength); Buffer.BlockCopy(buffer, 0, _eventArgs.Buffer, state.SendOffset, bufferLength); //Send the request if (!Socket.SendAsync(_eventArgs)) { OnCompleted(Socket, _eventArgs); } } catch (Exception e) { if (state == null) { callback(new SocketAsyncState { Exception = e, Status = (e is SocketException) ? ResponseStatus.TransportFailure : ResponseStatus.ClientFailure }); } else { state.Exception = e; state.Completed(state); Log.Debug(e); } } return(Task.FromResult(0)); }
public override void SendAsync(byte[] buffer, Func <SocketAsyncState, Task> callback) { SocketAsyncState state = null; try { state = new SocketAsyncState { Data = new MemoryStream(), Opaque = Converter.ToUInt32(buffer, HeaderIndexFor.Opaque), Buffer = buffer, Completed = callback, SendOffset = _eventArgs.Offset }; _eventArgs.UserToken = state; Log.Debug(m => m("Sending {0} with {1} on server {2}", state.Opaque, Identity, EndPoint)); //set the buffer var bufferLength = buffer.Length < Configuration.BufferSize ? buffer.Length : Configuration.BufferSize; _eventArgs.SetBuffer(state.SendOffset, bufferLength); Buffer.BlockCopy(buffer, 0, _eventArgs.Buffer, state.SendOffset, bufferLength); //Send the request if (!Socket.SendAsync(_eventArgs)) { OnCompleted(Socket, _eventArgs); } } catch (Exception e) { if (state == null) { callback(new SocketAsyncState { Exception = e, Status = (e is SocketException) ? ResponseStatus.TransportFailure : ResponseStatus.ClientFailure }); } else { state.Exception = e; state.Completed(state); Log.Debug(e); } } }
public override void SendAsync(byte[] buffer, Func<SocketAsyncState, Task> callback) { SocketAsyncState state = null; try { state = new SocketAsyncState { Data = new MemoryStream(), Opaque = Converter.ToUInt32(buffer, HeaderIndexFor.Opaque), Buffer = buffer, Completed = callback, SendOffset = _eventArgs.Offset }; _eventArgs.UserToken = state; Log.Debug(m => m("Sending {0} with {1} on server {2}", state.Opaque, Identity, EndPoint)); //set the buffer var bufferLength = buffer.Length < Configuration.BufferSize ? buffer.Length : Configuration.BufferSize; _eventArgs.SetBuffer(state.SendOffset, bufferLength); Buffer.BlockCopy(buffer, 0, _eventArgs.Buffer, state.SendOffset, bufferLength); //Send the request if (!Socket.SendAsync(_eventArgs)) { OnCompleted(Socket, _eventArgs); } } catch (Exception e) { if (state == null) { callback(new SocketAsyncState { Exception = e, Status = (e is SocketException) ? ResponseStatus.TransportFailure : ResponseStatus.ClientFailure }); } else { state.Exception = e; state.Completed(state); Log.Debug(e); } } }
public override void SendAsync(byte[] buffer, Func <SocketAsyncState, Task> callback) { SocketAsyncState state = null; try { state = new SocketAsyncState { Data = new MemoryStream(), Opaque = Converter.ToUInt32(buffer, HeaderIndexFor.Opaque), Buffer = buffer, Completed = callback }; _eventArgs.UserToken = state; Log.Debug(m => m("Sending {0}", state.Opaque)); //set the buffer var bufferLength = buffer.Length < Configuration.BufferSize ? buffer.Length : Configuration.BufferSize; _eventArgs.SetBuffer(0, bufferLength); Buffer.BlockCopy(buffer, 0, _eventArgs.Buffer, 0, bufferLength); //Send the request if (!Socket.SendAsync(_eventArgs)) { IsDead = true; } } catch (Exception e) { if (state == null) { callback(new SocketAsyncState { Exception = e }); } else { state.Exception = e; state.Completed(state); Log.Debug(e); } } }
public override async void SendAsync(byte[] request, Func <SocketAsyncState, Task> callback) { ExceptionDispatchInfo capturedException = null; SocketAsyncState state = null; try { state = new SocketAsyncState { Data = new MemoryStream(), Opaque = Converter.ToUInt32(request, HeaderIndexFor.Opaque), Buffer = request, Completed = callback }; await _sslStream.WriteAsync(request, 0, request.Length).ConfigureAwait(false); state.SetIOBuffer(BufferAllocator.GetBuffer()); state.BytesReceived = await _sslStream.ReadAsync(state.Buffer, state.BufferOffset, state.BufferLength).ConfigureAwait(false); //write the received buffer to the state obj await state.Data.WriteAsync(state.Buffer, state.BufferOffset, state.BytesReceived).ConfigureAwait(false); state.BodyLength = Converter.ToInt32(state.Buffer, state.BufferOffset + HeaderIndexFor.BodyLength); while (state.BytesReceived < state.BodyLength + 24) { var bufferLength = state.BufferLength - state.BytesSent < state.BufferLength ? state.BufferLength - state.BytesSent : state.BufferLength; state.BytesReceived += await _sslStream.ReadAsync(state.Buffer, state.BufferOffset, bufferLength).ConfigureAwait(false); await state.Data.WriteAsync(state.Buffer, state.BufferOffset, state.BytesReceived - (int)state.Data.Length).ConfigureAwait(false); } await callback(state).ConfigureAwait(false); } catch (Exception e) { IsDead = true; capturedException = ExceptionDispatchInfo.Capture(e); } finally { ConnectionPool.Release(this); if (state.IOBuffer != null) { BufferAllocator.ReleaseBuffer(state.IOBuffer); } } if (capturedException != null) { var sourceException = capturedException.SourceException; if (state == null) { await callback(new SocketAsyncState { Exception = capturedException.SourceException, Status = (sourceException is SocketException) ? ResponseStatus.TransportFailure : ResponseStatus.ClientFailure }).ConfigureAwait(false); } else { state.Exception = sourceException; await state.Completed(state).ConfigureAwait(false); Log.Debug(sourceException); } } }
public override async void SendAsync(byte[] request, Func <SocketAsyncState, Task> callback) { SocketAsyncState state = null; byte[] buffer = null; try { state = new SocketAsyncState { Data = new MemoryStream(), Opaque = Converter.ToUInt32(request, HeaderIndexFor.Opaque), Buffer = request, Completed = callback }; await _sslStream.WriteAsync(request, 0, request.Length); state.Buffer = BufferManager.TakeBuffer(Configuration.BufferSize); state.BytesReceived = await _sslStream.ReadAsync(state.Buffer, 0, Configuration.BufferSize); //write the received buffer to the state obj await state.Data.WriteAsync(state.Buffer, 0, state.BytesReceived); state.BodyLength = Converter.ToInt32(state.Buffer, HeaderIndexFor.BodyLength); while (state.BytesReceived < state.BodyLength + 24) { var bufferLength = state.Buffer.Length - state.BytesSent < Configuration.BufferSize ? state.Buffer.Length - state.BytesSent : Configuration.BufferSize; state.BytesReceived += await _sslStream.ReadAsync(state.Buffer, 0, bufferLength); await state.Data.WriteAsync(state.Buffer, 0, state.BytesReceived - (int)state.Data.Length); } await callback(state); } catch (Exception e) { IsDead = true; if (state == null) { callback(new SocketAsyncState { Exception = e, Status = (e is SocketException) ? ResponseStatus.TransportFailure : ResponseStatus.ClientFailure }); } else { state.Exception = e; state.Completed(state); Log.Debug(e); } } finally { ConnectionPool.Release(this); if (buffer != null) { BufferManager.ReturnBuffer(buffer); } } }
public override async Task SendAsync(byte[] request, Func <SocketAsyncState, Task> callback, ISpan span, ErrorMap errorMap) { ExceptionDispatchInfo capturedException = null; SocketAsyncState state = null; try { var opaque = Converter.ToUInt32(request, HeaderIndexFor.Opaque); state = new SocketAsyncState { Data = MemoryStreamFactory.GetMemoryStream(), Opaque = opaque, Buffer = request, Completed = callback, DispatchSpan = span, ConnectionId = ContextId, LocalEndpoint = LocalEndPoint.ToString(), ErrorMap = errorMap, Timeout = Configuration.SendTimeout }; await _sslStream.WriteAsync(request, 0, request.Length).ContinueOnAnyContext(); state.SetIOBuffer(_buffer); state.BytesReceived = await _sslStream.ReadAsync(state.Buffer, state.BufferOffset, state.BufferLength).ContinueOnAnyContext(); //write the received buffer to the state obj await state.Data.WriteAsync(state.Buffer, state.BufferOffset, state.BytesReceived).ContinueOnAnyContext(); state.BodyLength = Converter.ToInt32(state.Buffer, state.BufferOffset + HeaderIndexFor.BodyLength); while (state.BytesReceived < state.BodyLength + OperationHeader.Length) { var bufferLength = state.BufferLength - state.BytesSent < state.BufferLength ? state.BufferLength - state.BytesSent : state.BufferLength; state.BytesReceived += await _sslStream.ReadAsync(state.Buffer, state.BufferOffset, bufferLength).ContinueOnAnyContext(); await state.Data.WriteAsync(state.Buffer, state.BufferOffset, state.BytesReceived - (int)state.Data.Length).ContinueOnAnyContext(); } await callback(state).ContinueOnAnyContext(); } catch (Exception e) { IsDead = true; capturedException = ExceptionDispatchInfo.Capture(e); } finally { ConnectionPool.Release(this); } if (capturedException != null) { var sourceException = capturedException.SourceException; if (state == null) { await callback(new SocketAsyncState { Exception = capturedException.SourceException, Status = (sourceException is SocketException) ? ResponseStatus.TransportFailure : ResponseStatus.ClientFailure }).ContinueOnAnyContext(); } else { state.Exception = sourceException; await state.Completed(state).ContinueOnAnyContext(); Log.Debug(sourceException); } } }