public unsafe StreamHandle CreatePendingType()
{
Validate();
StreamHandle handle = null;
int count = PendingCount();
if (count > 0)
{
IntPtr loopHandle = ((uv_stream_t *)InternalHandle)->loop;
var loop = HandleContext.GetTarget <LoopContext>(loopHandle);
uv_handle_type handleType = NativeMethods.PipePendingType(InternalHandle);
switch (handleType)
{
case uv_handle_type.UV_TCP:
handle = new Tcp(loop);
break;
case uv_handle_type.UV_NAMED_PIPE:
handle = new Pipe(loop);
break;
default:
throw ThrowHelper.GetInvalidOperationException_uv_handle_type_not_supported_or_IPC_over_Pipe_is_disabled(handleType);
}
NativeMethods.StreamAccept(InternalHandle, handle.InternalHandle);
handle.ReadStart();
}
return(handle);
}
private static void OnConnectionCallback(IntPtr handle, int status)
{
var server = HandleContext.GetTarget <ServerStream>(handle);
if (server is null)
{
return;
}
StreamHandle client = null;
Exception error = null;
try
{
if ((uint)status > SharedConstants.TooBigOrNegative) // < 0
{
error = NativeMethods.CreateError((uv_err_code)status);
}
else
{
client = server.NewStream();
}
server._connectionHandler(client, error);
}
catch
{
client?.Dispose();
throw;
}
}
internal Pipeline(StreamHandle streamHandle, PooledByteBufferAllocator allocator)
{
Debug.Assert(streamHandle is object);
Debug.Assert(allocator is object);
_streamHandle = streamHandle;
_allocator = allocator;
_receiveBufferSizeEstimate = new ReceiveBufferSizeEstimate();
_pendingRead = new PendingRead();
}
public void QueueWriteStream(byte[] array, StreamHandle sendHandle,
Action <StreamHandle, Exception> completion)
{
if (array is null)
{
return;
}
QueueWriteStream(array, 0, array.Length, sendHandle, completion);
}
internal void QueueWrite(IByteBuffer bufferRef, StreamHandle sendHandle, Action <StreamHandle, Exception> completion)
{
Debug.Assert(bufferRef is object && sendHandle is object);
WriteRequest request = Loop.WriteRequestPool.Take();
try
{
request.Prepare(bufferRef,
(writeRequest, exception) => completion?.Invoke(_streamHandle, exception));
_streamHandle.WriteStream(request, sendHandle);
}
catch (Exception exception)
{
Log.Pipeline_Handle_faulted(_streamHandle.HandleType, exception);
request.Release();
throw;
}
}
internal unsafe void WriteStream(WriteRequest request, StreamHandle sendHandle)
{
Debug.Assert(request is object);
Debug.Assert(sendHandle is object);
Validate();
try
{
NativeMethods.WriteStream(
request.InternalHandle,
InternalHandle,
request.Bufs,
ref request.Size,
sendHandle.InternalHandle);
}
catch (Exception exception)
{
Log.Failed_to_write_data(HandleType, request, exception);
throw;
}
}
public void QueueWriteStream(byte[] array, int offset, int count,
StreamHandle sendHandle,
Action <StreamHandle, Exception> completion)
{
if (array is null || 0u >= (uint)array.Length)
{
return;
}
if ((uint)count > SharedConstants.TooBigOrNegative)
{
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count);
}
if ((uint)(offset + count) > (uint)array.Length)
{
ThrowHelper.ThrowArgumentException_InvalidOffLen();
}
IByteBuffer buffer = Unpooled.WrappedBuffer(array, offset, count);
_pipeline.QueueWrite(buffer, sendHandle, completion);
}
public void QueueWriteStream(WritableBuffer writableBuffer, StreamHandle sendHandle,
Action <StreamHandle, Exception> completion)
{
if (completion is null)
{
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.completion);
}
if (sendHandle is null)
{
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.sendHandle);
}
IByteBuffer buffer = writableBuffer.GetBuffer();
if (buffer is null || !buffer.IsReadable())
{
return;
}
_pipeline.QueueWrite(buffer, sendHandle, completion);
}
internal Pipeline(StreamHandle streamHandle)
: this(streamHandle, PooledByteBufferAllocator.Default)
{
}