Class ChannelAsyncOutputStream

All Implemented Interfaces:
Closeable, AutoCloseable, Channel, ChannelHolder, Closeable, IoOutputStream

public class ChannelAsyncOutputStream extends AbstractCloseable implements IoOutputStream, ChannelHolder
  • Field Details

    • 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
    • packetWriter

      private final ChannelStreamWriter packetWriter
    • cmd

      private final byte cmd
    • packetWriteId

      private final Object packetWriteId
  • Constructor Details

  • Method Details

    • getChannel

      public Channel getChannel()
      Specified by:
      getChannel in interface ChannelHolder
      Returns:
      The associated Channel instance
    • getCommandType

      public byte getCommandType()
      Returns:
      Either SSH_MSG_CHANNEL_DATA or SSH_MSG_CHANNEL_EXTENDED_DATA indicating the output stream type
    • writeBuffer

      public IoWriteFuture writeBuffer(Buffer buffer) throws 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
      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()
    • terminateFuture

      protected void terminateFuture(IoWriteFutureImpl future)
    • doCloseGracefully

      protected CloseFuture doCloseGracefully()
      Overrides:
      doCloseGracefully in class AbstractCloseable
    • onWindowExpanded

      public void onWindowExpanded() throws IOException
      Throws:
      IOException
    • doWriteIfPossible

      protected void doWriteIfPossible(boolean resume)
    • abortWrite

      private boolean abortWrite(AbstractCloseable.State openState)
    • 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.
    • onWritten

      protected void onWritten(IoWriteFutureImpl future, int total, int length, IoWriteFuture f)
    • createSendBuffer

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

      public String toString()
      Overrides:
      toString in class Object