Class ChannelAsyncOutputStream

    • Field Detail

      • lastWrite

        protected final java.util.concurrent.atomic.AtomicReference<IoWriteFuture> lastWrite
        The future describing the last executed *buffer* write writeBuffer(Buffer). Used for graceful closing.
      • writeState

        protected final ChannelAsyncOutputStream.WriteState writeState
        Encapsulates the state of the current write operation. Access is always under lock (on writeState's monitor), the lock is held only shortly and never while writing.
      • channelInstance

        private final Channel channelInstance
      • cmd

        private final byte cmd
      • packetWriteId

        private final java.lang.Object packetWriteId
    • Method Detail

      • writeBuffer

        public IoWriteFuture writeBuffer​(Buffer buffer)
                                  throws java.io.IOException
        Write the given buffer. This write operation is asynchronous: if there is not enough window space, it may keep the write pending or write only part of the buffer and keep the rest pending. Concurrent writes are not allowed and will throw a WritePendingException. Any subsequent write must occur only once the returned future is fulfilled; for instance triggered via a listener on the returned future. Try to avoid doing a subsequent write directly in a future listener, though; doing so may lead to deep chains of nested listener calls with deep stack traces, and may ultimately lead to a stack overflow.
        Specified by:
        writeBuffer in interface IoOutputStream
        Parameters:
        buffer - the data to write. NOTE: the buffer must not be touched until the returned write future is completed.
        Returns:
        An IoWriteFuture that can be used to check when the data has actually been written.
        Throws:
        WritePendingException - if a concurrent write is attempted
        java.io.IOException - if an error occurred when writing the data
      • preClose

        protected void preClose()
        Description copied from class: AbstractCloseable
        preClose is guaranteed to be called before doCloseGracefully or doCloseImmediately. When preClose() is called, isClosing() == true
        Overrides:
        preClose in class AbstractCloseable
      • doCloseImmediately

        protected void doCloseImmediately()
        Description copied from class: AbstractCloseable

        doCloseImmediately is called once and only once with state == Immediate

        Overriding methods should always call the base implementation. It may be called concurrently while preClose() or doCloseGracefully is executing

        Overrides:
        doCloseImmediately in class AbstractCloseable
      • shutdown

        protected void shutdown()
      • onWindowExpanded

        public void onWindowExpanded()
                              throws java.io.IOException
        Throws:
        java.io.IOException
      • doWriteIfPossible

        protected void doWriteIfPossible​(boolean resume)
      • writePacket

        protected IoWriteFutureImpl writePacket​(IoWriteFutureImpl future,
                                                boolean resume)
        Try to write as much of the current buffer as possible. If the buffer is larger than the packet size split it in packets, writing one after the other by chaining futures. If there is not enough window space, stop writing. Writing will be resumed once the window has been enlarged again.
        Parameters:
        future - IoWriteFutureImpl for the current write
        resume - whether being called in response to a remote window adjustment
        Returns:
        null if all written, or if the rest will be written via a future listener. Otherwise a future for the remaining writes.
      • createSendBuffer

        protected Buffer createSendBuffer​(Buffer buffer,
                                          Channel channel,
                                          int length)
      • toString

        public java.lang.String toString()
        Overrides:
        toString in class java.lang.Object