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;
}
}
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.channel.Active)
{
try
{
if (this.channel.Open)
{
outboundBuffer.FailFlushed(NotYetConnectedException, true);
}
else
{
// Do not trigger channelWritabilityChanged because the channel is closed already.
outboundBuffer.FailFlushed(ClosedChannelException, false);
}
}
finally
{
this.inFlush0 = false;
}
return;
}
try
{
this.channel.DoWrite(outboundBuffer);
}
catch (Exception t)
{
outboundBuffer.FailFlushed(t, true);
}
finally
{
this.inFlush0 = false;
}
}
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);
}
protected virtual void Flush0()
{
if (_inFlush0)
{
// Avoid re-entrance
return;
}
ChannelOutboundBuffer outboundBuffer = Volatile.Read(ref _outboundBuffer);
if (outboundBuffer is null || outboundBuffer.IsEmpty)
{
return;
}
_inFlush0 = true;
var ch = _channel;
// Mark all pending write requests as failure if the channel is inactive.
if (!CanWrite)
{
try
{
if (ch.Open)
{
outboundBuffer.FailFlushed(Flush0NotYetConnectedException, true);
}
else
{
// Do not trigger channelWritabilityChanged because the channel is closed already.
outboundBuffer.FailFlushed(Flush0ClosedChannelException, false);
}
}
finally
{
_inFlush0 = false;
}
return;
}
try
{
ch.DoWrite(outboundBuffer);
}
catch (Exception ex)
{
//if (ch.Configuration.AutoClose)
//{
/*
* Just call {@link #close(ChannelPromise, Throwable, boolean)} here which will take care of
* failing all flushed messages and also ensure the actual close of the underlying transport
* will happen before the promises are notified.
*
* This is needed as otherwise {@link #isActive()} , {@link #isOpen()} and {@link #isWritable()}
* may still return <c>true</c> even if the channel should be closed as result of the exception.
*/
Close(VoidPromise(), ex, Flush0ClosedChannelException, false);
//}
//else
//{
// try
// {
// shutdownOutput(voidPromise(), t);
// }
// catch(Exception ex2)
// {
// close(voidPromise(), t2, FLUSH0_CLOSED_CHANNEL_EXCEPTION, false);
// }
//}
}
finally
{
_inFlush0 = false;
}
}
private void CloseOutboundBufferForShutdown(IChannelPipeline pipeline, ChannelOutboundBuffer buffer, Exception cause)
{
buffer.FailFlushed(cause, false);
buffer.Close(cause, true);
_ = pipeline.FireUserEventTriggered(ChannelOutputShutdownEvent.Instance);
}
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(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(ClosedChannelException);
}
if (this.inFlush0)
{
this.InvokeLater(() => this.FireChannelInactiveAndDeregister(wasActive));
}
else
{
this.FireChannelInactiveAndDeregister(wasActive);
}
}
return promise.Task;
}