public void FinishWrite(FABSocketChannelAsyncOperation operation)
{
bool resetWritePending = this.Channel.TryResetState(StateFlags.WriteScheduled);
Contract.Assert(resetWritePending);
FABChannelOutboundBuffer input = this.OutboundBuffer;
try
{
operation.Validate();
int sent = operation.BytesTransferred;
this.Channel.ResetWriteOperation();
if (sent > 0)
{
input.RemoveBytes(sent);
}
}
catch (Exception ex)
{
Util.CompleteChannelCloseTaskSafely(this.channel, this.CloseAsync(new ClosedChannelException("Failed to write", ex), false));
}
// Double check if there's no pending flush
// See https://github.com/Azure/DotNetty/issues/218
this.Flush0(); // todo: does it make sense now that we've actually written out everything that was flushed previously? concurrent flush handling?
}
protected static void Init(AbstractWriteTask task, FABHandlerContext ctx, object msg, TaskCompletionSource promise)
{
task.ctx = ctx;
task.msg = msg;
task.promise = promise;
if (EstimateTaskSizeOnSubmit)
{
FABChannelOutboundBuffer 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;
}
}
protected virtual void Flush0()
{
if (this.inFlush0)
{
// Avoid re-entrance
return;
}
FABChannelOutboundBuffer 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();
FABChannelOutboundBuffer outboundBuffer = this.outboundBuffer;
if (outboundBuffer == null)
{
return;
}
outboundBuffer.AddFlush();
this.Flush0();
}
public Task WriteAsync(object msg)
{
this.AssertEventLoop();
FABChannelOutboundBuffer 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
{
FABChannelOutboundBuffer buffer = this.ctx.Channel.Unsafe.OutboundBuffer;
// Check for null as it may be set to null if the channel is closed already
if (EstimateTaskSizeOnSubmit)
{
if (buffer != null)
{
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);
}
}
protected Task CloseAsync(Exception cause, bool notify)
{
var promise = new TaskCompletionSource();
if (!promise.SetUncancellable())
{
return(promise.Task);
}
FABChannelOutboundBuffer 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);
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 FABUnsafe(FABChannel channel)
{
this.channel = channel;
this.outboundBuffer = new FABChannelOutboundBuffer(channel);
}
protected abstract void DoWrite(FABChannelOutboundBuffer input);
public CloseChannelTask(FABChannelOutboundBuffer buf, Exception cause, bool allowChannelOpen)
{
this.buf = buf;
this.cause = cause;
this.allowChannelOpen = allowChannelOpen;
}
