public void FinishWrite(SocketChannelAsyncOperation operation) { bool resetWritePending = this.Channel.TryResetState(StateFlags.WriteScheduled); Contract.Assert(resetWritePending); ChannelOutboundBuffer 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 override void DoFinishConnect(SocketChannelAsyncOperation operation) { try { operation.Validate(); } finally { operation.Dispose(); } this.OnConnected(); }
public override void FinishRead(SocketChannelAsyncOperation operation) { Contract.Assert(this.channel.EventLoop.InEventLoop); TcpServerSocketChannel ch = this.Channel; if ((ch.ResetState(StateFlags.ReadScheduled) & StateFlags.Active) == 0) { return; // read was signaled as a result of channel closure } IChannelConfiguration config = ch.Configuration; IChannelPipeline pipeline = ch.Pipeline; IRecvByteBufAllocatorHandle allocHandle = this.Channel.Unsafe.RecvBufAllocHandle; allocHandle.Reset(config); bool closed = false; Exception exception = null; try { Socket connectedSocket = null; try { connectedSocket = operation.AcceptSocket; operation.AcceptSocket = null; operation.Validate(); var message = this.PrepareChannel(connectedSocket); connectedSocket = null; ch.ReadPending = false; pipeline.FireChannelRead(message); allocHandle.IncMessagesRead(1); if (!config.AutoRead && !ch.ReadPending) { // ChannelConfig.setAutoRead(false) was called in the meantime. // Completed Accept has to be processed though. return; } while (allocHandle.ContinueReading()) { connectedSocket = ch.Socket.Accept(); message = this.PrepareChannel(connectedSocket); connectedSocket = null; ch.ReadPending = false; pipeline.FireChannelRead(message); allocHandle.IncMessagesRead(1); } } catch (SocketException ex) when(ex.SocketErrorCode == SocketError.OperationAborted || ex.SocketErrorCode == SocketError.InvalidArgument) { closed = true; } catch (SocketException ex) when(ex.SocketErrorCode == SocketError.WouldBlock) { } catch (SocketException ex) { // socket exceptions here are internal to channel's operation and should not go through the pipeline // especially as they have no effect on overall channel's operation Logger.Info("Exception on accept.", ex); } catch (ObjectDisposedException) { closed = true; } catch (Exception ex) { exception = ex; } allocHandle.ReadComplete(); pipeline.FireChannelReadComplete(); if (exception != null) { // ServerChannel should not be closed even on SocketException because it can often continue // accepting incoming connections. (e.g. too many open files) pipeline.FireExceptionCaught(exception); } if (closed && ch.Open) { this.CloseSafe(); } } finally { // Check if there is a readPending which was not processed yet. if (!closed && (ch.ReadPending || config.AutoRead)) { ch.DoBeginRead(); } } }
public override void FinishRead(SocketChannelAsyncOperation operation) { AbstractSocketByteChannel ch = this.Channel; if ((ch.ResetState(StateFlags.ReadScheduled) & StateFlags.Active) == 0) { return; // read was signaled as a result of channel closure } IChannelConfiguration config = ch.Configuration; IChannelPipeline pipeline = ch.Pipeline; IByteBufferAllocator allocator = config.Allocator; IRecvByteBufAllocatorHandle allocHandle = this.RecvBufAllocHandle; allocHandle.Reset(config); IByteBuffer byteBuf = null; bool close = false; try { operation.Validate(); do { byteBuf = allocHandle.Allocate(allocator); //int writable = byteBuf.WritableBytes; allocHandle.LastBytesRead = ch.DoReadBytes(byteBuf); if (allocHandle.LastBytesRead <= 0) { // nothing was read -> release the buffer. byteBuf.Release(); byteBuf = null; close = allocHandle.LastBytesRead < 0; break; } allocHandle.IncMessagesRead(1); this.Channel.ReadPending = false; pipeline.FireChannelRead(byteBuf); byteBuf = null; }while (allocHandle.ContinueReading()); allocHandle.ReadComplete(); pipeline.FireChannelReadComplete(); if (close) { this.CloseOnRead(); } } catch (Exception t) { this.HandleReadException(pipeline, byteBuf, t, close, allocHandle); } finally { // Check if there is a readPending which was not processed yet. // This could be for two reasons: // /// The user called Channel.read() or ChannelHandlerContext.read() input channelRead(...) method // /// The user called Channel.read() or ChannelHandlerContext.read() input channelReadComplete(...) method // // See https://github.com/netty/netty/issues/2254 if (!close && (ch.ReadPending || config.AutoRead)) { ch.DoBeginRead(); } } }