unsafe protected void CreateMemory(Libuv uv, int threadId, int size) { _uv = uv; ThreadId = threadId; handle = Marshal.AllocCoTaskMem(size); *(IntPtr *)handle = GCHandle.ToIntPtr(GCHandle.Alloc(this, GCHandleType.Weak)); }
public void Init(Libuv uv) { CreateMemory( uv, Thread.CurrentThread.ManagedThreadId, uv.loop_size()); _uv.loop_init(this); }
unsafe protected void CreateHandle( Libuv uv, int threadId, int size, Action <Action <IntPtr>, IntPtr> queueCloseHandle) { _queueCloseHandle = queueCloseHandle; CreateMemory(uv, threadId, size); }
public unsafe void Write( UvStreamHandle handle, MemoryPoolIterator2 start, MemoryPoolIterator2 end, int nBuffers, Action <UvWriteReq, int, Exception, object> callback, object state) { try { // add GCHandle to keeps this SafeHandle alive while request processing _pins.Add(GCHandle.Alloc(this, GCHandleType.Normal)); var pBuffers = (Libuv.uv_buf_t *)_bufs; if (nBuffers > BUFFER_COUNT) { // create and pin buffer array when it's larger than the pre-allocated one var bufArray = new Libuv.uv_buf_t[nBuffers]; var gcHandle = GCHandle.Alloc(bufArray, GCHandleType.Pinned); _pins.Add(gcHandle); pBuffers = (Libuv.uv_buf_t *)gcHandle.AddrOfPinnedObject(); } var block = start.Block; for (var index = 0; index < nBuffers; index++) { var blockStart = block == start.Block ? start.Index : block.Data.Offset; var blockEnd = block == end.Block ? end.Index : block.Data.Offset + block.Data.Count; // create and pin each segment being written pBuffers[index] = Libuv.buf_init( block.Pin() + blockStart, blockEnd - blockStart); block = block.Next; } _callback = callback; _state = state; _uv.write(this, handle, pBuffers, nBuffers, _uv_write_cb); } catch { _callback = null; _state = null; Unpin(this); var block = start.Block; for (var index = 0; index < nBuffers; index++) { block.Unpin(); block = block.Next; } throw; } }
protected unsafe void CreateHandle( Libuv uv, int threadId, int size, Action<Action<IntPtr>, IntPtr> queueCloseHandle) { _queueCloseHandle = queueCloseHandle; CreateMemory(uv, threadId, size); }
public static void Apply(Libuv libuv) { if (libuv.IsWindows) { WindowsApis.Apply(libuv); } else { LinuxApis.Apply(libuv); } }
public void Connect( UvPipeHandle pipe, string name, Action <UvConnectRequest, int, Exception, object> callback, object state) { _callback = callback; _state = state; Pin(); Libuv.pipe_connect(this, pipe, name, _uv_connect_cb); }
public unsafe void Write2( UvStreamHandle handle, ArraySegment <ArraySegment <byte> > bufs, UvStreamHandle sendHandle, Action <UvWriteReq, int, Exception, object> callback, object state) { try { // add GCHandle to keeps this SafeHandle alive while request processing _pins.Add(GCHandle.Alloc(this, GCHandleType.Normal)); var pBuffers = (Libuv.uv_buf_t *)_bufs; var nBuffers = bufs.Count; if (nBuffers > BUFFER_COUNT) { // create and pin buffer array when it's larger than the pre-allocated one var bufArray = new Libuv.uv_buf_t[nBuffers]; var gcHandle = GCHandle.Alloc(bufArray, GCHandleType.Pinned); _pins.Add(gcHandle); pBuffers = (Libuv.uv_buf_t *)gcHandle.AddrOfPinnedObject(); } for (var index = 0; index != nBuffers; ++index) { // create and pin each segment being written var buf = bufs.Array[bufs.Offset + index]; var gcHandle = GCHandle.Alloc(buf.Array, GCHandleType.Pinned); _pins.Add(gcHandle); pBuffers[index] = Libuv.buf_init( gcHandle.AddrOfPinnedObject() + buf.Offset, buf.Count); } _callback = callback; _state = state; _uv.write2(this, handle, pBuffers, nBuffers, sendHandle, _uv_write_cb); } catch { _callback = null; _state = null; Unpin(this); throw; } }
public KestrelEngine(ILibraryManager libraryManager, IApplicationShutdown appShutdownService) { AppShutdown = appShutdownService; Threads = new List<KestrelThread>(); Listeners = new List<Listener>(); Memory = new MemoryPool(); Libuv = new Libuv(); var libraryPath = default(string); if (libraryManager != null) { var library = libraryManager.GetLibraryInformation("Microsoft.AspNet.Server.Kestrel"); libraryPath = library.Path; if (library.Type == "Project") { libraryPath = Path.GetDirectoryName(libraryPath); } if (Libuv.IsWindows) { var architecture = IntPtr.Size == 4 ? "x86" : "amd64"; libraryPath = Path.Combine( libraryPath, "native", "windows", architecture, "libuv.dll"); } else if (Libuv.IsDarwin) { libraryPath = Path.Combine( libraryPath, "native", "darwin", "universal", "libuv.dylib"); } else { libraryPath = "libuv.so.1"; } } Libuv.Load(libraryPath); }
private static void UvReadCb(IntPtr handle, int nread, ref Libuv.uv_buf_t buf) { var stream = FromIntPtr<UvStreamHandle>(handle); try { if (nread < 0) { Exception error; stream._uv.Check(nread, out error); stream._readCallback(stream, 0, error, stream._readState); } else { stream._readCallback(stream, nread, null, stream._readState); } } catch (Exception ex) { Trace.WriteLine("UbReadCb " + ex.ToString()); } }
public MultipleLoopTests() { var engine = new KestrelEngine(LibraryManager, new ShutdownNotImplemented()); _uv = engine.Libuv; }
public static void Apply(Libuv libuv) { libuv.LoadLibrary = LoadLibrary; libuv.FreeLibrary = FreeLibrary; libuv.GetProcAddress = GetProcAddress; }
private static void UvAllocCb(IntPtr handle, int suggested_size, out Libuv.uv_buf_t buf) { var stream = FromIntPtr<UvStreamHandle>(handle); try { buf = stream._allocCallback(stream, suggested_size, stream._readState); } catch (Exception ex) { stream._log.LogError("UvAllocCb", ex); buf = stream.Libuv.buf_init(IntPtr.Zero, 0); throw; } }
private static void UvReadCb(IntPtr handle, int nread, ref Libuv.uv_buf_t buf) { var stream = FromIntPtr<UvStreamHandle>(handle); try { if (nread < 0) { Exception error; stream._uv.Check(nread, out error); stream._readCallback(stream, 0, nread, error, stream._readState); } else { stream._readCallback(stream, nread, 0, null, stream._readState); } } catch (Exception ex) { stream._log.LogError("UbReadCb", ex); throw; } }
private static void UvReadCb(IntPtr handle, int status, ref Libuv.uv_buf_t buf) { var stream = FromIntPtr<UvStreamHandle>(handle); try { stream._readCallback(stream, status, stream._readState); } catch (Exception ex) { stream._log.LogError("UbReadCb", ex); throw; } }
public int TryWrite(Libuv.uv_buf_t buf) { return _uv.try_write(this, new[] { buf }, 1); }
// For testing internal KestrelEngine(Libuv uv, IApplicationShutdown appShutdownService) : this(appShutdownService) { Libuv = uv; }
public unsafe void write(UvWriteReq req, UvStreamHandle handle, Libuv.uv_buf_t* bufs, int nbufs, uv_write_cb cb) { req.Validate(); handle.Validate(); Check(_uv_write(req, handle, bufs, nbufs, cb)); }
unsafe public void write2(UvRequest req, UvStreamHandle handle, Libuv.uv_buf_t* bufs, int nbufs, UvStreamHandle sendHandle, uv_write_cb cb) { req.Validate(); handle.Validate(); Check(_uv_write2(req, handle, bufs, nbufs, sendHandle, cb)); }
// For testing internal KestrelEngine(Libuv uv, ServiceContext context) : base(context) { Libuv = uv; Threads = new List<KestrelThread>(); }
public NetworkingTests() { var engine = new KestrelEngine(new TestServiceContext()); _uv = engine.Libuv; _logger = engine.Log; }
public NetworkingTests() { var engine = new KestrelEngine(LibraryManager); _uv = engine.Libuv; }
public MultipleLoopTests() { var engine = new KestrelEngine(new TestServiceContext()); _uv = engine.Libuv; _logger = engine.Log; }
public NetworkingTests() { var engine = new KestrelEngine(LibraryManager, new ShutdownNotImplemented()); _uv = engine.Libuv; }
public int try_write(UvStreamHandle handle, Libuv.uv_buf_t[] bufs, int nbufs) { handle.Validate(); return Check(_uv_try_write(handle, bufs, nbufs)); }
private static void UvAllocCb(IntPtr handle, int suggested_size, out Libuv.uv_buf_t buf) { var stream = FromIntPtr<UvStreamHandle>(handle); try { buf = stream._allocCallback(stream, suggested_size, stream._readState); } catch (Exception ex) { Trace.WriteLine("UvAllocCb " + ex.ToString()); buf = stream.Libuv.buf_init(IntPtr.Zero, 0); throw; } }