Package hudson.util

Class ChunkedOutputStream

java.lang.Object
java.io.OutputStream
hudson.util.ChunkedOutputStream
All Implemented Interfaces:
Closeable, Flushable, AutoCloseable

public class ChunkedOutputStream extends OutputStream
Implements HTTP chunking support. Writes are buffered to an internal buffer (2048 default size). Chunks are guaranteed to be at least as large as the buffer size (except for the last chunk).
Author:
Mohammad Rezaei, Goldman, Sachs & Co.
  • Constructor Summary

    Constructors
    Constructor
    Description
    Wraps a stream and chunks the output.
    ChunkedOutputStream(OutputStream stream, int bufferSize)
    Wraps a stream and chunks the output.
  • Method Summary

    Modifier and Type
    Method
    Description
    void
    Finishes writing to the underlying stream, but does NOT close the underlying stream.
    void
    Must be called to ensure the internal cache is flushed and the closing chunk is written.
    void
    Flushes the underlying stream, but leaves the internal buffer alone.
    protected void
    Writes the cache out onto the underlying stream
    protected void
    flushCacheWithAppend(byte[] bufferToAppend, int off, int len)
    Writes the cache and bufferToAppend to the underlying stream as one large chunk
    void
    write(byte[] b)
    Writes the array.
    void
    write(byte[] src, int off, int len)
     
    void
    write(int b)
    Write the specified byte to our output stream.
    protected void
     

    Methods inherited from class java.io.OutputStream

    nullOutputStream

    Methods inherited from class java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
  • Constructor Details

    • ChunkedOutputStream

      public ChunkedOutputStream(OutputStream stream, int bufferSize) throws IOException
      Wraps a stream and chunks the output.
      Parameters:
      stream - to wrap
      bufferSize - minimum chunk size (excluding last chunk)
      Throws:
      IOException
      Since:
      3.0
    • ChunkedOutputStream

      public ChunkedOutputStream(OutputStream stream) throws IOException
      Wraps a stream and chunks the output. The default buffer size of 2048 was chosen because the chunk overhead is less than 0.5%
      Throws:
      IOException
  • Method Details

    • flushCache

      protected void flushCache() throws IOException
      Writes the cache out onto the underlying stream
      Throws:
      IOException
      Since:
      3.0
    • flushCacheWithAppend

      protected void flushCacheWithAppend(byte[] bufferToAppend, int off, int len) throws IOException
      Writes the cache and bufferToAppend to the underlying stream as one large chunk
      Throws:
      IOException
      Since:
      3.0
    • writeClosingChunk

      protected void writeClosingChunk() throws IOException
      Throws:
      IOException
    • finish

      public void finish() throws IOException
      Must be called to ensure the internal cache is flushed and the closing chunk is written.
      Throws:
      IOException
      Since:
      3.0
    • write

      public void write(int b) throws IOException
      Write the specified byte to our output stream. Note: Avoid this method as it will cause an inefficient single byte chunk. Use write (byte[], int, int) instead.
      Specified by:
      write in class OutputStream
      Parameters:
      b - The byte to be written
      Throws:
      IOException - if an input/output error occurs
    • write

      public void write(byte[] b) throws IOException
      Writes the array. If the array does not fit within the buffer, it is not split, but rather written out as one large chunk.
      Overrides:
      write in class OutputStream
      Throws:
      IOException
      Since:
      3.0
    • write

      public void write(byte[] src, int off, int len) throws IOException
      Overrides:
      write in class OutputStream
      Throws:
      IOException
    • flush

      public void flush() throws IOException
      Flushes the underlying stream, but leaves the internal buffer alone.
      Specified by:
      flush in interface Flushable
      Overrides:
      flush in class OutputStream
      Throws:
      IOException
    • close

      public void close() throws IOException
      Finishes writing to the underlying stream, but does NOT close the underlying stream.
      Specified by:
      close in interface AutoCloseable
      Specified by:
      close in interface Closeable
      Overrides:
      close in class OutputStream
      Throws:
      IOException