Package org.apache.sshd.common.channel

Class ChannelAsyncOutputStream

java.lang.Object
org.apache.sshd.common.util.logging.AbstractLoggingBean
org.apache.sshd.common.util.closeable.IoBaseCloseable
org.apache.sshd.common.util.closeable.AbstractCloseable
org.apache.sshd.common.channel.ChannelAsyncOutputStream
All Implemented Interfaces:
Closeable, AutoCloseable, Channel, ChannelHolder, Closeable, IoOutputStream
public class ChannelAsyncOutputStream extends AbstractCloseable implements IoOutputStream, ChannelHolder

  • Field Details

    • lastWrite

      protected final 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.

  • 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
      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
      Throws:
      WritePendingException - if a concurrent write is attempted
      IOException

    • preClose

      protected void preClose()
      Overrides:
      preClose in class AbstractCloseable

    • doCloseImmediately

      protected void doCloseImmediately()
      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)

    • 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