jetty-proxy/src/main/java/org/eclipse/jetty/proxy/AfterContentTransformer.java - gerrit/jetty/org.eclipse.jetty.project - Git at Google

 //
 //  ========================================================================
 //  Copyright (c) 1995-2016 Mort Bay Consulting Pty. Ltd.
 //  ------------------------------------------------------------------------
 //  All rights reserved. This program and the accompanying materials
 //  are made available under the terms of the Eclipse Public License v1.0
 //  and Apache License v2.0 which accompanies this distribution.
 //
 //      The Eclipse Public License is available at
 //      http://www.eclipse.org/legal/epl-v10.html
 //
 //      The Apache License v2.0 is available at
 //      http://www.opensource.org/licenses/apache2.0.php
 //
 //  You may elect to redistribute this code under either of these licenses.
 //  ========================================================================
 //

 package org.eclipse.jetty.proxy;

 import java.io.Closeable;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.nio.ByteBuffer;
 import java.nio.channels.Channels;
 import java.nio.channels.FileChannel;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.nio.file.StandardOpenOption;
 import java.nio.file.attribute.FileAttribute;
 import java.util.ArrayList;
 import java.util.List;

 import org.eclipse.jetty.util.IO;
 import org.eclipse.jetty.util.component.Destroyable;
 import org.eclipse.jetty.util.log.Log;
 import org.eclipse.jetty.util.log.Logger;

 /**
  * <p>A specialized transformer for {@link AsyncMiddleManServlet} that performs
  * the transformation when the whole content has been received.</p>
  * <p>The content is buffered in memory up to a configurable {@link #getMaxInputBufferSize() maximum size},
  * after which it is overflown to a file on disk. The overflow file is saved
  * in the {@link #getOverflowDirectory() overflow directory} as a
  * {@link Files#createTempFile(Path, String, String, FileAttribute[]) temporary file}
  * with a name starting with the {@link #getInputFilePrefix() input prefix}
  * and default suffix.</p>
  * <p>Application must implement the {@link #transform(Source, Sink) transformation method}
  * to transform the content.</p>
  * <p>The transformed content is buffered in memory up to a configurable {@link #getMaxOutputBufferSize() maximum size}
  * after which it is overflown to a file on disk. The overflow file is saved
  * in the {@link #getOverflowDirectory() overflow directory} as a
  * {@link Files#createTempFile(Path, String, String, FileAttribute[]) temporary file}
  * with a name starting with the {@link #getOutputFilePrefix()} output prefix}
  * and default suffix.</p>
  */
 public abstract class AfterContentTransformer implements AsyncMiddleManServlet.ContentTransformer, Destroyable
 {
     private static final Logger LOG = Log.getLogger(AfterContentTransformer.class);

     private final List<ByteBuffer> sourceBuffers = new ArrayList<>();
     private Path overflowDirectory = Paths.get(System.getProperty("java.io.tmpdir"));
     private String inputFilePrefix = "amms_adct_in_";
     private String outputFilePrefix = "amms_adct_out_";
     private long maxInputBufferSize = 1024 * 1024;
     private long inputBufferSize;
     private FileChannel inputFile;
     private long maxOutputBufferSize = maxInputBufferSize;
     private long outputBufferSize;
     private FileChannel outputFile;

     /**
      * <p>Returns the directory where input and output are overflown to
      * temporary files if they exceed, respectively, the
      * {@link #getMaxInputBufferSize() max input size} or the
      * {@link #getMaxOutputBufferSize() max output size}.</p>
      * <p>Defaults to the directory pointed by the {@code java.io.tmpdir}
      * system property.</p>
      *
      * @return the overflow directory path
      * @see #setOverflowDirectory(Path)
      */
     public Path getOverflowDirectory()
     {
         return overflowDirectory;
     }

     /**
      * @param overflowDirectory the overflow directory path
      * @see #getOverflowDirectory()
      */
     public void setOverflowDirectory(Path overflowDirectory)
     {
         this.overflowDirectory = overflowDirectory;
     }

     /**
      * @return the prefix of the input overflow temporary files
      * @see #setInputFilePrefix(String)
      */
     public String getInputFilePrefix()
     {
         return inputFilePrefix;
     }

     /**
      * @param inputFilePrefix the prefix of the input overflow temporary files
      * @see #getInputFilePrefix()
      */
     public void setInputFilePrefix(String inputFilePrefix)
     {
         this.inputFilePrefix = inputFilePrefix;
     }

     /**
      * <p>Returns the maximum input buffer size, after which the input is overflown to disk.</p>
      * <p>Defaults to 1 MiB, i.e. 1048576 bytes.</p>
      *
      * @return the max input buffer size
      * @see #setMaxInputBufferSize(long)
      */
     public long getMaxInputBufferSize()
     {
         return maxInputBufferSize;
     }

     /**
      * @param maxInputBufferSize the max input buffer size
      * @see #getMaxInputBufferSize()
      */
     public void setMaxInputBufferSize(long maxInputBufferSize)
     {
         this.maxInputBufferSize = maxInputBufferSize;
     }

     /**
      * @return the prefix of the output overflow temporary files
      * @see #setOutputFilePrefix(String)
      */
     public String getOutputFilePrefix()
     {
         return outputFilePrefix;
     }

     /**
      * @param outputFilePrefix the prefix of the output overflow temporary files
      * @see #getOutputFilePrefix()
      */
     public void setOutputFilePrefix(String outputFilePrefix)
     {
         this.outputFilePrefix = outputFilePrefix;
     }

     /**
      * <p>Returns the maximum output buffer size, after which the output is overflown to disk.</p>
      * <p>Defaults to 1 MiB, i.e. 1048576 bytes.</p>
      *
      * @return the max output buffer size
      * @see #setMaxOutputBufferSize(long)
      */
     public long getMaxOutputBufferSize()
     {
         return maxOutputBufferSize;
     }

     /**
      * @param maxOutputBufferSize the max output buffer size
      */
     public void setMaxOutputBufferSize(long maxOutputBufferSize)
     {
         this.maxOutputBufferSize = maxOutputBufferSize;
     }

     @Override
     public final void transform(ByteBuffer input, boolean finished, List<ByteBuffer> output) throws IOException
     {
         int remaining = input.remaining();
         if (remaining > 0)
         {
             inputBufferSize += remaining;
             long max = getMaxInputBufferSize();
             if (max >= 0 && inputBufferSize > max)
             {
                 overflow(input);
             }
             else
             {
                 ByteBuffer copy = ByteBuffer.allocate(input.remaining());
                 copy.put(input).flip();
                 sourceBuffers.add(copy);
             }
         }

         if (finished)
         {
             Source source = new Source();
             Sink sink = new Sink();
             if (transform(source, sink))
                 sink.drainTo(output);
             else
                 source.drainTo(output);
         }
     }

     /**
      * <p>Transforms the original content read from the {@code source} into
      * transformed content written to the {@code sink}.</p>
      * <p>The transformation must happen synchronously in the context of a call
      * to this method (it is not supported to perform the transformation in another
      * thread spawned during the call to this method).</p>
      * <p>Differently from {@link #transform(ByteBuffer, boolean, List)}, this
      * method is invoked only when the whole content is available, and offers
      * a blocking API via the InputStream and OutputStream that can be obtained
      * from {@link Source} and {@link Sink} respectively.</p>
      * <p>Implementations may read the source, inspect the input bytes and decide
      * that no transformation is necessary, and therefore the source must be copied
      * unchanged to the sink. In such case, the implementation must return false to
      * indicate that it wishes to just pipe the bytes from the source to the sink.</p>
      * <p>Typical implementations:</p>
      * <pre>
      * // Identity transformation (no transformation, the input is copied to the output)
      * public boolean transform(Source source, Sink sink)
      * {
      *     org.eclipse.jetty.util.IO.copy(source.getInputStream(), sink.getOutputStream());
      *     return true;
      * }
      * </pre>
      *
      * @param source where the original content is read
      * @param sink where the transformed content is written
      * @return true if the transformation happened and the transformed bytes have
      * been written to the sink, false if no transformation happened and the source
      * must be copied to the sink.
      * @throws IOException if the transformation fails
      */
     public abstract boolean transform(Source source, Sink sink) throws IOException;

     private void overflow(ByteBuffer input) throws IOException
     {
         if (inputFile == null)
         {
             Path path = Files.createTempFile(getOverflowDirectory(), getInputFilePrefix(), null);
             inputFile = FileChannel.open(path,
                     StandardOpenOption.CREATE,
                     StandardOpenOption.READ,
                     StandardOpenOption.WRITE,
                     StandardOpenOption.DELETE_ON_CLOSE);
             int size = sourceBuffers.size();
             if (size > 0)
             {
                 ByteBuffer[] buffers = sourceBuffers.toArray(new ByteBuffer[size]);
                 sourceBuffers.clear();
                 IO.write(inputFile,buffers,0,buffers.length);
             }
         }
         inputFile.write(input);
     }

     @Override
     public void destroy()
     {
         close(inputFile);
         close(outputFile);
     }

     private void drain(FileChannel file, List<ByteBuffer> output) throws IOException
     {
         long position = 0;
         long length = file.size();
         file.position(position);
         while (length > 0)
         {
             // At most 1 GiB file maps.
             long size = Math.min(1024 * 1024 * 1024, length);
             ByteBuffer buffer = file.map(FileChannel.MapMode.READ_ONLY, position, size);
             output.add(buffer);
             position += size;
             length -= size;
         }
     }

     private void close(Closeable closeable)
     {
         try
         {
             if (closeable != null)
                 closeable.close();
         }
         catch (IOException x)
         {
             LOG.ignore(x);
         }
     }

     /**
      * <p>The source from where the original content is read to be transformed.</p>
      * <p>The {@link #getInputStream() input stream} provided by this
      * class supports the {@link InputStream#reset()} method so that
      * the stream can be rewound to the beginning.</p>
      */
     public class Source
     {
         private final InputStream stream;

         private Source() throws IOException
         {
             if (inputFile != null)
             {
                 inputFile.force(true);
                 stream = new ChannelInputStream();
             }
             else
             {
                 stream = new MemoryInputStream();
             }
             stream.reset();
         }

         /**
          * @return an input stream to read the original content from
          */
         public InputStream getInputStream()
         {
             return stream;
         }

         private void drainTo(List<ByteBuffer> output) throws IOException
         {
             if (inputFile == null)
             {
                 output.addAll(sourceBuffers);
                 sourceBuffers.clear();
             }
             else
             {
                 drain(inputFile, output);
             }
         }
     }

     private class ChannelInputStream extends InputStream
     {
         private final InputStream stream = Channels.newInputStream(inputFile);

         @Override
         public int read(byte[] b, int off, int len) throws IOException
         {
             return stream.read(b, off, len);
         }

         @Override
         public int read() throws IOException
         {
             return stream.read();
         }

         @Override
         public void reset() throws IOException
         {
             inputFile.position(0);
         }
     }

     private class MemoryInputStream extends InputStream
     {
         private final byte[] oneByte = new byte[1];
         private int index;
         private ByteBuffer slice;

         @Override
         public int read(byte[] b, int off, int len) throws IOException
         {
             if (len == 0)
                 return 0;
             if (index == sourceBuffers.size())
                 return -1;

             if (slice == null)
                 slice = sourceBuffers.get(index).slice();

             int size = Math.min(len, slice.remaining());
             slice.get(b, off, size);

             if (!slice.hasRemaining())
             {
                 ++index;
                 slice = null;
             }

             return size;
         }

         @Override
         public int read() throws IOException
         {
             int read = read(oneByte, 0, 1);
             return read < 0 ? read : oneByte[0] & 0xFF;
         }

         @Override
         public void reset() throws IOException
         {
             index = 0;
             slice = null;
         }
     }

     /**
      * <p>The target to where the transformed content is written after the transformation.</p>
      */
     public class Sink
     {
         private final List<ByteBuffer> sinkBuffers = new ArrayList<>();
         private final OutputStream stream = new SinkOutputStream();

         /**
          * @return an output stream to write the transformed content to
          */
         public OutputStream getOutputStream()
         {
             return stream;
         }


         private void overflow(ByteBuffer output) throws IOException
         {
             if (outputFile == null)
             {
                 Path path = Files.createTempFile(getOverflowDirectory(), getOutputFilePrefix(), null);
                 outputFile = FileChannel.open(path,
                         StandardOpenOption.CREATE,
                         StandardOpenOption.READ,
                         StandardOpenOption.WRITE,
                         StandardOpenOption.DELETE_ON_CLOSE);
                 int size = sinkBuffers.size();
                 if (size > 0)
                 {
                     ByteBuffer[] buffers = sinkBuffers.toArray(new ByteBuffer[size]);
                     sinkBuffers.clear();

                     IO.write(outputFile,buffers,0,buffers.length);
                 }
             }
             outputFile.write(output);
         }

         private void drainTo(List<ByteBuffer> output) throws IOException
         {
             if (outputFile == null)
             {
                 output.addAll(sinkBuffers);
                 sinkBuffers.clear();
             }
             else
             {
                 outputFile.force(true);
                 drain(outputFile, output);
             }
         }

         private class SinkOutputStream extends OutputStream
         {
             @Override
             public void write(byte[] b, int off, int len) throws IOException
             {
                 if (len <= 0)
                     return;

                 outputBufferSize += len;
                 long max = getMaxOutputBufferSize();
                 if (max >= 0 && outputBufferSize > max)
                 {
                     overflow(ByteBuffer.wrap(b, off, len));
                 }
                 else
                 {
                     // The array may be reused by the
                     // application so we need to copy it.
                     byte[] copy = new byte[len];
                     System.arraycopy(b, off, copy, 0, len);
                     sinkBuffers.add(ByteBuffer.wrap(copy));
                 }
             }

             @Override
             public void write(int b) throws IOException
             {
                 write(new byte[]{(byte)b}, 0, 1);
             }
         }
     }
 }
	//
	// ========================================================================
	// Copyright (c) 1995-2016 Mort Bay Consulting Pty. Ltd.
	// ------------------------------------------------------------------------
	// All rights reserved. This program and the accompanying materials
	// are made available under the terms of the Eclipse Public License v1.0
	// and Apache License v2.0 which accompanies this distribution.
	//
	// The Eclipse Public License is available at
	// http://www.eclipse.org/legal/epl-v10.html
	//
	// The Apache License v2.0 is available at
	// http://www.opensource.org/licenses/apache2.0.php
	//
	// You may elect to redistribute this code under either of these licenses.
	// ========================================================================
	//

	package org.eclipse.jetty.proxy;

	import java.io.Closeable;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.nio.ByteBuffer;
	import java.nio.channels.Channels;
	import java.nio.channels.FileChannel;
	import java.nio.file.Files;
	import java.nio.file.Path;
	import java.nio.file.Paths;
	import java.nio.file.StandardOpenOption;
	import java.nio.file.attribute.FileAttribute;
	import java.util.ArrayList;
	import java.util.List;

	import org.eclipse.jetty.util.IO;
	import org.eclipse.jetty.util.component.Destroyable;
	import org.eclipse.jetty.util.log.Log;
	import org.eclipse.jetty.util.log.Logger;

	/**
	* <p>A specialized transformer for {@link AsyncMiddleManServlet} that performs
	* the transformation when the whole content has been received.</p>
	* <p>The content is buffered in memory up to a configurable {@link #getMaxInputBufferSize() maximum size},
	* after which it is overflown to a file on disk. The overflow file is saved
	* in the {@link #getOverflowDirectory() overflow directory} as a
	* {@link Files#createTempFile(Path, String, String, FileAttribute[]) temporary file}
	* with a name starting with the {@link #getInputFilePrefix() input prefix}
	* and default suffix.</p>
	* <p>Application must implement the {@link #transform(Source, Sink) transformation method}
	* to transform the content.</p>
	* <p>The transformed content is buffered in memory up to a configurable {@link #getMaxOutputBufferSize() maximum size}
	* after which it is overflown to a file on disk. The overflow file is saved
	* in the {@link #getOverflowDirectory() overflow directory} as a
	* {@link Files#createTempFile(Path, String, String, FileAttribute[]) temporary file}
	* with a name starting with the {@link #getOutputFilePrefix()} output prefix}
	* and default suffix.</p>
	*/
	public abstract class AfterContentTransformer implements AsyncMiddleManServlet.ContentTransformer, Destroyable
	{
	private static final Logger LOG = Log.getLogger(AfterContentTransformer.class);

	private final List<ByteBuffer> sourceBuffers = new ArrayList<>();
	private Path overflowDirectory = Paths.get(System.getProperty("java.io.tmpdir"));
	private String inputFilePrefix = "amms_adct_in_";
	private String outputFilePrefix = "amms_adct_out_";
	private long maxInputBufferSize = 1024 * 1024;
	private long inputBufferSize;
	private FileChannel inputFile;
	private long maxOutputBufferSize = maxInputBufferSize;
	private long outputBufferSize;
	private FileChannel outputFile;

	/**
	* <p>Returns the directory where input and output are overflown to
	* temporary files if they exceed, respectively, the
	* {@link #getMaxInputBufferSize() max input size} or the
	* {@link #getMaxOutputBufferSize() max output size}.</p>
	* <p>Defaults to the directory pointed by the {@code java.io.tmpdir}
	* system property.</p>
	*
	* @return the overflow directory path
	* @see #setOverflowDirectory(Path)
	*/
	public Path getOverflowDirectory()
	{
	return overflowDirectory;
	}

	/**
	* @param overflowDirectory the overflow directory path
	* @see #getOverflowDirectory()
	*/
	public void setOverflowDirectory(Path overflowDirectory)
	{
	this.overflowDirectory = overflowDirectory;
	}

	/**
	* @return the prefix of the input overflow temporary files
	* @see #setInputFilePrefix(String)
	*/
	public String getInputFilePrefix()
	{
	return inputFilePrefix;
	}

	/**
	* @param inputFilePrefix the prefix of the input overflow temporary files
	* @see #getInputFilePrefix()
	*/
	public void setInputFilePrefix(String inputFilePrefix)
	{
	this.inputFilePrefix = inputFilePrefix;
	}

	/**
	* <p>Returns the maximum input buffer size, after which the input is overflown to disk.</p>
	* <p>Defaults to 1 MiB, i.e. 1048576 bytes.</p>
	*
	* @return the max input buffer size
	* @see #setMaxInputBufferSize(long)
	*/
	public long getMaxInputBufferSize()
	{
	return maxInputBufferSize;
	}

	/**
	* @param maxInputBufferSize the max input buffer size
	* @see #getMaxInputBufferSize()
	*/
	public void setMaxInputBufferSize(long maxInputBufferSize)
	{
	this.maxInputBufferSize = maxInputBufferSize;
	}

	/**
	* @return the prefix of the output overflow temporary files
	* @see #setOutputFilePrefix(String)
	*/
	public String getOutputFilePrefix()
	{
	return outputFilePrefix;
	}

	/**
	* @param outputFilePrefix the prefix of the output overflow temporary files
	* @see #getOutputFilePrefix()
	*/
	public void setOutputFilePrefix(String outputFilePrefix)
	{
	this.outputFilePrefix = outputFilePrefix;
	}

	/**
	* <p>Returns the maximum output buffer size, after which the output is overflown to disk.</p>
	* <p>Defaults to 1 MiB, i.e. 1048576 bytes.</p>
	*
	* @return the max output buffer size
	* @see #setMaxOutputBufferSize(long)
	*/
	public long getMaxOutputBufferSize()
	{
	return maxOutputBufferSize;
	}

	/**
	* @param maxOutputBufferSize the max output buffer size
	*/
	public void setMaxOutputBufferSize(long maxOutputBufferSize)
	{
	this.maxOutputBufferSize = maxOutputBufferSize;
	}

	@Override
	public final void transform(ByteBuffer input, boolean finished, List<ByteBuffer> output) throws IOException
	{
	int remaining = input.remaining();
	if (remaining > 0)
	{
	inputBufferSize += remaining;
	long max = getMaxInputBufferSize();
	if (max >= 0 && inputBufferSize > max)
	{
	overflow(input);
	}
	else
	{
	ByteBuffer copy = ByteBuffer.allocate(input.remaining());
	copy.put(input).flip();
	sourceBuffers.add(copy);
	}
	}

	if (finished)
	{
	Source source = new Source();
	Sink sink = new Sink();
	if (transform(source, sink))
	sink.drainTo(output);
	else
	source.drainTo(output);
	}
	}

	/**
	* <p>Transforms the original content read from the {@code source} into
	* transformed content written to the {@code sink}.</p>
	* <p>The transformation must happen synchronously in the context of a call
	* to this method (it is not supported to perform the transformation in another
	* thread spawned during the call to this method).</p>
	* <p>Differently from {@link #transform(ByteBuffer, boolean, List)}, this
	* method is invoked only when the whole content is available, and offers
	* a blocking API via the InputStream and OutputStream that can be obtained
	* from {@link Source} and {@link Sink} respectively.</p>
	* <p>Implementations may read the source, inspect the input bytes and decide
	* that no transformation is necessary, and therefore the source must be copied
	* unchanged to the sink. In such case, the implementation must return false to
	* indicate that it wishes to just pipe the bytes from the source to the sink.</p>
	* <p>Typical implementations:</p>
	* <pre>
	* // Identity transformation (no transformation, the input is copied to the output)
	* public boolean transform(Source source, Sink sink)
	* {
	* org.eclipse.jetty.util.IO.copy(source.getInputStream(), sink.getOutputStream());
	* return true;
	* }
	* </pre>
	*
	* @param source where the original content is read
	* @param sink where the transformed content is written
	* @return true if the transformation happened and the transformed bytes have
	* been written to the sink, false if no transformation happened and the source
	* must be copied to the sink.
	* @throws IOException if the transformation fails
	*/
	public abstract boolean transform(Source source, Sink sink) throws IOException;

	private void overflow(ByteBuffer input) throws IOException
	{
	if (inputFile == null)
	{
	Path path = Files.createTempFile(getOverflowDirectory(), getInputFilePrefix(), null);
	inputFile = FileChannel.open(path,
	StandardOpenOption.CREATE,
	StandardOpenOption.READ,
	StandardOpenOption.WRITE,
	StandardOpenOption.DELETE_ON_CLOSE);
	int size = sourceBuffers.size();
	if (size > 0)
	{
	ByteBuffer[] buffers = sourceBuffers.toArray(new ByteBuffer[size]);
	sourceBuffers.clear();
	IO.write(inputFile,buffers,0,buffers.length);
	}
	}
	inputFile.write(input);
	}

	@Override
	public void destroy()
	{
	close(inputFile);
	close(outputFile);
	}

	private void drain(FileChannel file, List<ByteBuffer> output) throws IOException
	{
	long position = 0;
	long length = file.size();
	file.position(position);
	while (length > 0)
	{
	// At most 1 GiB file maps.
	long size = Math.min(1024 * 1024 * 1024, length);
	ByteBuffer buffer = file.map(FileChannel.MapMode.READ_ONLY, position, size);
	output.add(buffer);
	position += size;
	length -= size;
	}
	}

	private void close(Closeable closeable)
	{
	try
	{
	if (closeable != null)
	closeable.close();
	}
	catch (IOException x)
	{
	LOG.ignore(x);
	}
	}

	/**
	* <p>The source from where the original content is read to be transformed.</p>
	* <p>The {@link #getInputStream() input stream} provided by this
	* class supports the {@link InputStream#reset()} method so that
	* the stream can be rewound to the beginning.</p>
	*/
	public class Source
	{
	private final InputStream stream;

	private Source() throws IOException
	{
	if (inputFile != null)
	{
	inputFile.force(true);
	stream = new ChannelInputStream();
	}
	else
	{
	stream = new MemoryInputStream();
	}
	stream.reset();
	}

	/**
	* @return an input stream to read the original content from
	*/
	public InputStream getInputStream()
	{
	return stream;
	}

	private void drainTo(List<ByteBuffer> output) throws IOException
	{
	if (inputFile == null)
	{
	output.addAll(sourceBuffers);
	sourceBuffers.clear();
	}
	else
	{
	drain(inputFile, output);
	}
	}
	}

	private class ChannelInputStream extends InputStream
	{
	private final InputStream stream = Channels.newInputStream(inputFile);

	@Override
	public int read(byte[] b, int off, int len) throws IOException
	{
	return stream.read(b, off, len);
	}

	@Override
	public int read() throws IOException
	{
	return stream.read();
	}

	@Override
	public void reset() throws IOException
	{
	inputFile.position(0);
	}
	}

	private class MemoryInputStream extends InputStream
	{
	private final byte[] oneByte = new byte[1];
	private int index;
	private ByteBuffer slice;

	@Override
	public int read(byte[] b, int off, int len) throws IOException
	{
	if (len == 0)
	return 0;
	if (index == sourceBuffers.size())
	return -1;

	if (slice == null)
	slice = sourceBuffers.get(index).slice();

	int size = Math.min(len, slice.remaining());
	slice.get(b, off, size);

	if (!slice.hasRemaining())
	{
	++index;
	slice = null;
	}

	return size;
	}

	@Override
	public int read() throws IOException
	{
	int read = read(oneByte, 0, 1);
	return read < 0 ? read : oneByte[0] & 0xFF;
	}

	@Override
	public void reset() throws IOException
	{
	index = 0;
	slice = null;
	}
	}

	/**
	* <p>The target to where the transformed content is written after the transformation.</p>
	*/
	public class Sink
	{
	private final List<ByteBuffer> sinkBuffers = new ArrayList<>();
	private final OutputStream stream = new SinkOutputStream();

	/**
	* @return an output stream to write the transformed content to
	*/
	public OutputStream getOutputStream()
	{
	return stream;
	}


	private void overflow(ByteBuffer output) throws IOException
	{
	if (outputFile == null)
	{
	Path path = Files.createTempFile(getOverflowDirectory(), getOutputFilePrefix(), null);
	outputFile = FileChannel.open(path,
	StandardOpenOption.CREATE,
	StandardOpenOption.READ,
	StandardOpenOption.WRITE,
	StandardOpenOption.DELETE_ON_CLOSE);
	int size = sinkBuffers.size();
	if (size > 0)
	{
	ByteBuffer[] buffers = sinkBuffers.toArray(new ByteBuffer[size]);
	sinkBuffers.clear();

	IO.write(outputFile,buffers,0,buffers.length);
	}
	}
	outputFile.write(output);
	}

	private void drainTo(List<ByteBuffer> output) throws IOException
	{
	if (outputFile == null)
	{
	output.addAll(sinkBuffers);
	sinkBuffers.clear();
	}
	else
	{
	outputFile.force(true);
	drain(outputFile, output);
	}
	}

	private class SinkOutputStream extends OutputStream
	{
	@Override
	public void write(byte[] b, int off, int len) throws IOException
	{
	if (len <= 0)
	return;

	outputBufferSize += len;
	long max = getMaxOutputBufferSize();
	if (max >= 0 && outputBufferSize > max)
	{
	overflow(ByteBuffer.wrap(b, off, len));
	}
	else
	{
	// The array may be reused by the
	// application so we need to copy it.
	byte[] copy = new byte[len];
	System.arraycopy(b, off, copy, 0, len);
	sinkBuffers.add(ByteBuffer.wrap(copy));
	}
	}

	@Override
	public void write(int b) throws IOException
	{
	write(new byte[]{(byte)b}, 0, 1);
	}
	}
	}
	}