internal static void Start(uv_handle_type handleType, IntPtr handle)
{
Debug.Assert(handle != IntPtr.Zero);
int result;
switch (handleType)
{
case uv_handle_type.UV_PREPARE:
result = uv_prepare_start(handle, WorkHandle.WorkCallback);
break;
case uv_handle_type.UV_CHECK:
result = uv_check_start(handle, WorkHandle.WorkCallback);
break;
case uv_handle_type.UV_IDLE:
result = uv_idle_start(handle, WorkHandle.WorkCallback);
break;
default:
throw new NotSupportedException($"Handle type to start {handleType} not supported");
}
ThrowIfError(result);
}
internal ServerStream(
LoopContext loop,
uv_handle_type handleType,
params object[] args)
: base(loop, handleType, args)
{
}
internal StreamHandle(
LoopContext loop,
uv_handle_type handleType)
: base(loop, handleType)
{
this.Pipeline = new Pipeline(this);
}
// constructor /////////////////////////////////////////////////////////
public TcpStream(Loop loop)
{
// make sure loop can be used
loop.Validate();
// converting OnFramingCallback to Action allocates.
// lets do it only once, instead of every ReadCallback.
FramingCallback = OnFramingCallback;
HandleContext initialHandle = NativeMethods.Initialize(loop.Handle, uv_handle_type.UV_TCP, this);
if (initialHandle != null)
{
handle = initialHandle;
HandleType = uv_handle_type.UV_TCP;
// note: setting send/recv buffer sizes gives EBADF when trying it
// here. instead we call ConfigureSendReceiveBufferSize after
// successful connects.
}
else
{
throw new ArgumentException($"{nameof(TcpStream)} Initialize failed for handle: {loop.Handle}");
}
}
internal static void Stop(uv_handle_type handleType, IntPtr handle)
{
switch (handleType)
{
case uv_handle_type.UV_TIMER:
Invoke(uv_timer_stop, handle);
break;
case uv_handle_type.UV_PREPARE:
InvokeAction(uv_prepare_stop, handle);
break;
case uv_handle_type.UV_CHECK:
InvokeFunction(uv_check_stop, handle);
break;
case uv_handle_type.UV_IDLE:
InvokeFunction(uv_idle_stop, handle);
break;
default:
throw new NotSupportedException($"Handle type to stop {handleType} not supported");
}
Log.Debug($"{handleType} {handle} stopped.");
}
public unsafe StreamHandle CreatePendingType()
{
this.Validate();
StreamHandle handle = null;
int count = this.PendingCount();
if (count > 0)
{
IntPtr loopHandle = ((uv_stream_t *)this.InternalHandle)->loop;
var loop = HandleContext.GetTarget <LoopContext>(loopHandle);
uv_handle_type handleType = NativeMethods.PipePendingType(this.InternalHandle);
if (handleType == uv_handle_type.UV_TCP)
{
handle = new Tcp(loop);
}
else if (handleType == uv_handle_type.UV_NAMED_PIPE)
{
handle = new Pipe(loop);
}
else
{
throw new InvalidOperationException($"{handleType} not supported or IPC over Pipe is disabled.");
}
NativeMethods.StreamAccept(this.InternalHandle, handle.InternalHandle);
}
return(handle);
}
internal IntPtr AllocHandle(uv_handle_type handleType)
{
var ret = Alloc(Uvi.uv_handle_size(handleType));
_allocatedHandles++;
return(ret);
}
protected internal override unsafe StreamHandle NewStream()
{
IntPtr loopHandle = ((uv_stream_t *)this.InternalHandle)->loop;
var loop = HandleContext.GetTarget <LoopContext>(loopHandle);
uv_handle_type type = ((uv_stream_t *)this.InternalHandle)->type;
StreamHandle client;
if (type == uv_handle_type.UV_NAMED_PIPE)
{
client = new Pipe(loop, this.ipc);
}
else if (type == uv_handle_type.UV_TCP)
{
client = new Tcp(loop);
}
else
{
throw new InvalidOperationException($"Pipe IPC handle {type} not supported");
}
NativeMethods.StreamAccept(this.InternalHandle, client.InternalHandle);
if (!this.ipc)
{
client.ReadStart();
}
if (Log.IsDebugEnabled)
{
Log.DebugFormat("{0} {1} client {2} accepted. (IPC : {3})", this.HandleType, this.InternalHandle, client.InternalHandle, this.ipc);
}
return(client);
}
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);
}
internal WorkHandle(
LoopContext loop,
uv_handle_type handleType,
params object[] args)
: base(loop, handleType, args)
{
}
internal static void Start(uv_handle_type handleType, IntPtr handle)
{
Contract.Requires(handle != IntPtr.Zero);
int result;
switch (handleType)
{
case uv_handle_type.UV_PREPARE:
result = uv_prepare_start(handle, WorkHandle.WorkCallback);
break;
case uv_handle_type.UV_CHECK:
result = uv_check_start(handle, WorkHandle.WorkCallback);
break;
case uv_handle_type.UV_IDLE:
result = uv_idle_start(handle, WorkHandle.WorkCallback);
break;
default:
throw new NotSupportedException($"Handle type to start {handleType} not supported");
}
if (result < 0)
{
throw CreateError((uv_err_code)result);
}
}
internal HandleContext(
uv_handle_type handleType,
Func <IntPtr, IntPtr, int> initializer,
IntPtr loopHandle,
TcpStream target)
{
if (loopHandle != IntPtr.Zero && initializer != null && target != null)
{
int size = NativeMethods.GetSize(handleType);
IntPtr handle = Marshal.AllocCoTaskMem(size);
try
{
int result = initializer(loopHandle, handle);
NativeMethods.ThrowIfError(result);
}
catch (Exception)
{
Marshal.FreeCoTaskMem(handle);
throw;
}
GCHandle gcHandle = GCHandle.Alloc(target, GCHandleType.Normal);
((uv_handle_t *)handle)->data = GCHandle.ToIntPtr(gcHandle);
Handle = handle;
this.handleType = handleType;
//Logger.Log($"{handleType} {handle} allocated");
}
else
{
throw new ArgumentException($"loopHandle {loopHandle}, initializer {initializer}, target {target} can't be null!");
}
}
internal StreamHandle(
LoopContext loop,
uv_handle_type handleType,
params object[] args)
: base(loop, handleType, args)
{
this.pipeline = new Pipeline(this);
}
internal static int GetSize(uv_handle_type handleType)
{
IntPtr value = uv_handle_size(handleType);
int size = value.ToInt32();
if (size <= 0)
{
throw new InvalidOperationException($"Handle {handleType} size must be greater than zero.");
}
return(size);
}
internal ScheduleHandle(
LoopContext loop,
uv_handle_type handleType,
object[] args = null)
{
Contract.Requires(loop != null);
HandleContext initialHandle = NativeMethods.Initialize(loop.Handle, handleType, this, args);
Debug.Assert(initialHandle != null);
this.handle = initialHandle;
this.HandleType = handleType;
}
internal ScheduleHandle(LoopContext loop, uv_handle_type handleType)
{
Contract.Requires(loop != null);
HandleContext initialHandle = NativeMethods.Initialize(loop.Handle, handleType, this);
if (initialHandle == null)
{
throw new InvalidOperationException($"Initialize {handleType} for loop {loop.Handle} failed.");
}
this.handle = initialHandle;
this.HandleType = handleType;
}
internal static HandleContext Initialize(IntPtr loopHandle, uv_handle_type handleType, ScheduleHandle target, object[] args)
{
Debug.Assert(loopHandle != IntPtr.Zero);
Debug.Assert(target != null);
switch (handleType)
{
case uv_handle_type.UV_TIMER:
return(new HandleContext(handleType, InitializeTimer, loopHandle, target, args));
case uv_handle_type.UV_PREPARE:
return(new HandleContext(handleType, InitializePrepare, loopHandle, target, args));
case uv_handle_type.UV_CHECK:
return(new HandleContext(handleType, InitializeCheck, loopHandle, target, args));
case uv_handle_type.UV_IDLE:
return(new HandleContext(handleType, InitializeIdle, loopHandle, target, args));
case uv_handle_type.UV_ASYNC:
return(new HandleContext(handleType, InitializeAsync, loopHandle, target, args));
case uv_handle_type.UV_POLL:
return(new HandleContext(handleType, InitializePoll, loopHandle, target, args));
case uv_handle_type.UV_SIGNAL:
return(new HandleContext(handleType, InitializeSignal, loopHandle, target, args));
case uv_handle_type.UV_TCP:
return(new HandleContext(handleType, InitializeTcp, loopHandle, target, args));
case uv_handle_type.UV_NAMED_PIPE:
return(new HandleContext(handleType, InitializePipe, loopHandle, target, args));
case uv_handle_type.UV_TTY:
return(new HandleContext(handleType, InitializeTty, loopHandle, target, args));
case uv_handle_type.UV_UDP:
return(new HandleContext(handleType, InitializeUdp, loopHandle, target, args));
case uv_handle_type.UV_FS_EVENT:
return(new HandleContext(handleType, InitializeFSEvent, loopHandle, target, args));
case uv_handle_type.UV_FS_POLL:
return(new HandleContext(handleType, InitializeFSPoll, loopHandle, target, args));
default:
throw new NotSupportedException($"Handle type to initialize {handleType} not supported");
}
}
internal ScheduleHandle(
LoopContext loop,
uv_handle_type handleType,
object[] args = null)
{
if (loop is null)
{
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.loop);
}
HandleContext initialHandle = NativeMethods.Initialize(loop.Handle, handleType, this, args);
Debug.Assert(initialHandle is object);
_handle = initialHandle;
HandleType = handleType;
}
internal static void Stop(uv_handle_type handleType, IntPtr handle)
{
Contract.Requires(handle != IntPtr.Zero);
switch (handleType)
{
case uv_handle_type.UV_TIMER:
int result = uv_timer_stop(handle);
if (result < 0)
{
throw CreateError((uv_err_code)result);
}
break;
case uv_handle_type.UV_PREPARE:
uv_prepare_stop(handle);
break;
case uv_handle_type.UV_CHECK:
uv_check_stop(handle);
break;
case uv_handle_type.UV_IDLE:
uv_idle_stop(handle);
break;
case uv_handle_type.UV_POLL:
uv_poll_stop(handle);
break;
case uv_handle_type.UV_SIGNAL:
uv_signal_stop(handle);
break;
case uv_handle_type.UV_FS_EVENT:
uv_fs_event_stop(handle);
break;
case uv_handle_type.UV_FS_POLL:
uv_fs_poll_stop(handle);
break;
default:
throw new NotSupportedException($"Handle type to stop {handleType} not supported");
}
}
internal static HandleContext Initialize(IntPtr loopHandle, uv_handle_type handleType, TcpStream target)
{
if (loopHandle != IntPtr.Zero && target != null)
{
switch (handleType)
{
case uv_handle_type.UV_TCP:
return(new HandleContext(handleType, InitializeTcp, loopHandle, target));
default:
throw new NotSupportedException($"Handle type to initialize {handleType} not supported");
}
}
else
{
throw new ArgumentException($"loopHandle {loopHandle} and target {target} can't be null!");
}
}
internal HandleContext(
uv_handle_type handleType,
Func <IntPtr, IntPtr, object[], int> initializer,
IntPtr loopHandle,
ScheduleHandle target,
params object[] args)
{
Contract.Requires(loopHandle != IntPtr.Zero);
Contract.Requires(initializer != null);
Contract.Requires(target != null);
int size = NativeMethods.GetSize(handleType);
IntPtr handle = Marshal.AllocHGlobal(size);
int result;
try
{
result = initializer(loopHandle, handle, args);
}
catch (Exception)
{
Marshal.FreeHGlobal(handle);
throw;
}
if (result < 0)
{
Marshal.FreeHGlobal(handle);
throw NativeMethods.CreateError((uv_err_code)result);
}
GCHandle gcHandle = GCHandle.Alloc(target, GCHandleType.Normal);
((uv_handle_t *)handle)->data = GCHandle.ToIntPtr(gcHandle);
this.Handle = handle;
this.handleType = handleType;
if (Log.IsInfoEnabled)
{
Log.InfoFormat("{0} {1} allocated.", handleType, handle);
}
}
internal static void Stop(uv_handle_type handleType, IntPtr handle)
{
Debug.Assert(handle != IntPtr.Zero);
switch (handleType)
{
case uv_handle_type.UV_TIMER:
int result = uv_timer_stop(handle);
ThrowIfError(result);
break;
case uv_handle_type.UV_PREPARE:
uv_prepare_stop(handle);
break;
case uv_handle_type.UV_CHECK:
uv_check_stop(handle);
break;
case uv_handle_type.UV_IDLE:
uv_idle_stop(handle);
break;
case uv_handle_type.UV_POLL:
uv_poll_stop(handle);
break;
case uv_handle_type.UV_SIGNAL:
uv_signal_stop(handle);
break;
case uv_handle_type.UV_FS_EVENT:
uv_fs_event_stop(handle);
break;
case uv_handle_type.UV_FS_POLL:
uv_fs_poll_stop(handle);
break;
default:
throw new NotSupportedException($"Handle type to stop {handleType} not supported");
}
}
internal HandleContext(
uv_handle_type handleType,
Action <IntPtr> initializer,
ScheduleHandle target)
{
Contract.Requires(initializer != null);
Contract.Requires(target != null);
int size = NativeMethods.GetSize(handleType);
IntPtr handle = Marshal.AllocHGlobal(size);
initializer(handle);
GCHandle gcHandle = GCHandle.Alloc(target, GCHandleType.Normal);
((uv_handle_t *)handle)->data = GCHandle.ToIntPtr(gcHandle);
this.Handle = handle;
this.handleType = handleType;
Log.Info($"{handleType} {handle} allocated.");
}
internal static void Start(uv_handle_type handleType, IntPtr handle, uv_work_cb callback)
{
switch (handleType)
{
case uv_handle_type.UV_PREPARE:
Invoke(uv_prepare_start, handle, callback);
break;
case uv_handle_type.UV_CHECK:
Invoke(uv_check_start, handle, callback);
break;
case uv_handle_type.UV_IDLE:
Invoke(uv_idle_start, handle, callback);
break;
default:
throw new NotSupportedException($"Handle type to start {handleType} not supported");
}
Log.Debug($"{handleType} {handle} started.");
}
protected internal override unsafe StreamHandle NewStream()
{
IntPtr loopHandle = ((uv_stream_t *)InternalHandle)->loop;
var loop = HandleContext.GetTarget <LoopContext>(loopHandle);
uv_handle_type type = ((uv_stream_t *)InternalHandle)->type;
StreamHandle client;
switch (type)
{
case uv_handle_type.UV_NAMED_PIPE:
client = new Pipe(loop, _ipc);
break;
case uv_handle_type.UV_TCP:
client = new Tcp(loop);
break;
default:
throw ThrowHelper.GetInvalidOperationException_Pipe_IPC_handle_not_supported(type);
}
NativeMethods.StreamAccept(InternalHandle, client.InternalHandle);
if (!_ipc)
{
client.ReadStart();
}
#if DEBUG
if (Log.DebugEnabled)
{
Log.Debug("{} {1} client {} accepted. (IPC : {})", HandleType, InternalHandle, client.InternalHandle, _ipc);
}
#endif
return(client);
}
internal static HandleContext Initialize(IntPtr loopHandle, uv_handle_type handleType, ScheduleHandle target)
{
Action <IntPtr> action;
switch (handleType)
{
case uv_handle_type.UV_TIMER:
action = handle => Invoke(uv_timer_init, loopHandle, handle);
break;
case uv_handle_type.UV_PREPARE:
action = handle => Invoke(uv_prepare_init, loopHandle, handle);
break;
case uv_handle_type.UV_CHECK:
action = handle => Invoke(uv_check_init, loopHandle, handle);
break;
case uv_handle_type.UV_IDLE:
action = handle => Invoke(uv_idle_init, loopHandle, handle);
break;
case uv_handle_type.UV_ASYNC:
action = handle => Invoke(uv_async_init, loopHandle, handle,
WorkHandle.WorkCallback);
break;
case uv_handle_type.UV_TCP:
action = handle => Invoke(uv_tcp_init, loopHandle, handle);
break;
default:
throw new NotSupportedException($"Handle type to initialize {handleType} not supported");
}
return(new HandleContext(handleType, action, target));
}
internal HandleContext(
uv_handle_type handleType,
Func <IntPtr, IntPtr, object[], int> initializer,
IntPtr loopHandle,
ScheduleHandle target,
params object[] args)
{
Debug.Assert(loopHandle != IntPtr.Zero);
Debug.Assert(initializer is object);
Debug.Assert(target is object);
int size = NativeMethods.GetSize(handleType);
IntPtr handle = NativeMethods.Allocate(size);
try
{
int result = initializer(loopHandle, handle, args);
NativeMethods.ThrowIfError(result);
}
catch (Exception)
{
NativeMethods.FreeMemory(handle);
throw;
}
GCHandle gcHandle = GCHandle.Alloc(target, GCHandleType.Normal);
((uv_handle_t *)handle)->data = GCHandle.ToIntPtr(gcHandle);
Handle = handle;
_handleType = handleType;
if (Log.InfoEnabled)
{
Log.HandleAllocated(handleType, handle);
}
}
internal UvHandle(Loop loop, uv_handle_type handleType)
: this(loop)
{
_handle = loop.Allocs.AllocHandle(handleType);
}
internal UvStream(Loop loop, uv_handle_type handleType)
: base(loop, handleType)
{
}
internal UvHandle(Loop loop, uv_handle_type handleType)
: this(loop)
{
_handle = loop.Allocs.AllocHandle(handleType);
}
public static void CallbackRrror(this IInternalLogger logger, uv_handle_type handleType, IntPtr handle, Exception exception)
{
logger.Error($"{handleType} {handle} callback error.", exception);
}
internal static extern int uv_handle_size(uv_handle_type handleType);
public static IntPtr Allocate(uv_handle_type handleType)
{
int size = GetSize(handleType);
return(Allocate(size));
}
internal IntPtr Alloc(uv_handle_type handleType)
{
return Alloc(Uvi.uv_handle_size(handleType));
}
internal UvHandle(Loop loop, uv_handle_type handleType)
{
this.Loop = loop;
this.Handle = this.Alloc(handleType);
this.Status = HandleStatus.Open;
}
internal IntPtr AllocHandle(uv_handle_type handleType)
{
var ret = Alloc(Uvi.uv_handle_size(handleType));
_allocatedHandles++;
return ret;
}
