protected static void Init(AbstractWriteTask task, AbstractChannelHandlerContext ctx, object msg, TaskCompletionSource promise) { task.ctx = ctx; task.msg = msg; task.promise = promise; if (EstimateTaskSizeOnSubmit) { ChannelOutboundBuffer buffer = ctx.Channel.Unsafe.OutboundBuffer; // Check for null as it may be set to null if the channel is closed already if (buffer != null) { task.size = ctx.pipeline.EstimatorHandle.Size(msg) + WriteTaskOverhead; buffer.IncrementPendingOutboundBytes(task.size); } else { task.size = 0; } } else { task.size = 0; } }
public PendingWriteQueue(IChannelHandlerContext ctx) { Contract.Requires(ctx != null); this.ctx = ctx; this.buffer = ctx.Channel.Unsafe.OutboundBuffer; this.estimatorHandle = ctx.Channel.Configuration.MessageSizeEstimator.NewHandle(); }
protected virtual void Flush0() { if (this.inFlush0) { // Avoid re-entrance return; } ChannelOutboundBuffer outboundBuffer = this.outboundBuffer; if (outboundBuffer == null || outboundBuffer.IsEmpty) { return; } this.inFlush0 = true; // Mark all pending write requests as failure if the channel is inactive. if (!this.CanWrite) { try { if (this.channel.Open) { outboundBuffer.FailFlushed(NotYetConnectedException, true); } else { // Do not trigger channelWritabilityChanged because the channel is closed already. outboundBuffer.FailFlushed(new ClosedChannelException(), false); } } finally { this.inFlush0 = false; } return; } try { this.channel.DoWrite(outboundBuffer); } catch (Exception ex) { Util.CompleteChannelCloseTaskSafely(this.channel, this.CloseAsync(new ClosedChannelException("Failed to write", ex), false)); } finally { this.inFlush0 = false; } }
public void Flush() { this.AssertEventLoop(); ChannelOutboundBuffer outboundBuffer = this.outboundBuffer; if (outboundBuffer == null) { return; } outboundBuffer.AddFlush(); this.Flush0(); }
public Task WriteAsync(object msg) { this.AssertEventLoop(); ChannelOutboundBuffer outboundBuffer = this.outboundBuffer; if (outboundBuffer == null) { // If the outboundBuffer is null we know the channel was closed and so // need to fail the future right away. If it is not null the handling of the rest // will be done input flush0() // See https://github.com/netty/netty/issues/2362 // release message now to prevent resource-leak ReferenceCountUtil.Release(msg); return(TaskEx.FromException(new ClosedChannelException())); } int size; try { msg = this.channel.FilterOutboundMessage(msg); size = this.channel.pipeline.EstimatorHandle.Size(msg); if (size < 0) { size = 0; } } catch (Exception t) { ReferenceCountUtil.Release(msg); return(TaskEx.FromException(t)); } var promise = new TaskCompletionSource(); outboundBuffer.AddMessage(msg, size, promise); return(promise.Task); }
public void Run() { try { ChannelOutboundBuffer buffer = this.ctx.Channel.Unsafe.OutboundBuffer; // Check for null as it may be set to null if the channel is closed already if (EstimateTaskSizeOnSubmit) { buffer?.DecrementPendingOutboundBytes(this.size); } this.WriteAsync(this.ctx, this.msg).LinkOutcome(this.promise); } finally { // Set to null so the GC can collect them directly this.ctx = null; this.msg = null; this.promise = null; this.handle.Release(this); } }
/// <summary> /// Flush the content of the given buffer to the remote peer. /// </summary> protected abstract void DoWrite(ChannelOutboundBuffer input);
protected Task CloseAsync(Exception cause, bool notify) { var promise = new TaskCompletionSource(); if (!promise.SetUncancellable()) { return(promise.Task); } ChannelOutboundBuffer outboundBuffer = this.outboundBuffer; if (outboundBuffer == null) { // Only needed if no VoidChannelPromise. if (promise != TaskCompletionSource.Void) { // This means close() was called before so we just register a listener and return return(this.channel.closeFuture.Task); } return(promise.Task); } if (this.channel.closeFuture.Task.IsCompleted) { // Closed already. Util.SafeSetSuccess(promise, Logger); return(promise.Task); } bool wasActive = this.channel.Active; this.outboundBuffer = null; // Disallow adding any messages and flushes to outboundBuffer. IEventExecutor closeExecutor = null; // todo closeExecutor(); if (closeExecutor != null) { closeExecutor.Execute(() => { try { // Execute the close. this.DoClose0(promise); } finally { // Call invokeLater so closeAndDeregister is executed input the EventLoop again! this.InvokeLater(() => { // Fail all the queued messages outboundBuffer.FailFlushed(cause, notify); outboundBuffer.Close(new ClosedChannelException()); this.FireChannelInactiveAndDeregister(wasActive); }); } }); } else { try { // Close the channel and fail the queued messages input all cases. this.DoClose0(promise); } finally { // Fail all the queued messages. outboundBuffer.FailFlushed(cause, notify); outboundBuffer.Close(new ClosedChannelException()); } if (this.inFlush0) { this.InvokeLater(() => this.FireChannelInactiveAndDeregister(wasActive)); } else { this.FireChannelInactiveAndDeregister(wasActive); } } return(promise.Task); }
//public ChannelHandlerInvoker invoker() { // // return the unwrapped invoker. // return ((PausableChannelEventExecutor) eventLoop().asInvoker()).unwrapInvoker(); //} protected AbstractUnsafe(AbstractChannel channel) { this.channel = channel; this.outboundBuffer = new ChannelOutboundBuffer(channel); }
protected override void DoWrite(ChannelOutboundBuffer buf) => throw new NotSupportedException();
public CloseChannelTask(ChannelOutboundBuffer buf, Exception cause, bool allowChannelOpen) { this.buf = buf; this.cause = cause; this.allowChannelOpen = allowChannelOpen; }