StreamUtils.java

  1. /*
  2.  * StreamUtils
  3.  *
  4.  * $Id$
  5.  * $HeadURL$
  6.  */
  7. package gov.usgs.util;

  9. import java.io.BufferedInputStream;
  10. import java.io.BufferedOutputStream;
  11. import java.io.ByteArrayInputStream;
  12. import java.io.ByteArrayOutputStream;
  13. import java.io.File;
  14. import java.io.FileInputStream;
  15. import java.io.FileOutputStream;
  16. import java.io.FilterInputStream;
  17. import java.io.FilterOutputStream;
  18. import java.io.IOException;
  19. import java.io.InputStream;
  20. import java.io.OutputStream;
  21. import java.net.URL;
  22. import java.net.URLConnection;
  23. import java.util.zip.GZIPInputStream;

  25. /**
  26.  * Stream input, output, and transfer utilities.
  27.  */
  28. public class StreamUtils {

  30.     /** Default buffer size used for stream reads and writes. */
  31.     public static final int DEFAULT_BUFFER_SIZE = 4096;

  33.     /** Default connect timeout for url connections. */
  34.     public static final int DEFAULT_URL_CONNECT_TIMEOUT = 5000;

  36.     /** Default read timeout for url connections. */
  37.     public static final int DEFAULT_URL_READ_TIMEOUT = 15000;

  39.     /**
  40.      * Get an input stream for an Object if possible.
  41.      *
  42.      * @param obj
  43.      *            an InputStream, File, byte[], or String.
  44.      * @return an InputStream or null. If obj is a File, the stream is Buffered.
  45.      * @throws IOException
  46.      *             if an error occurs.
  47.      * @throws IllegalArgumentException
  48.      *             if obj is not an InputStream, URL, File, byte[], or String.
  49.      */
  50.     public static InputStream getInputStream(final Object obj)
  51.             throws IOException, IllegalArgumentException {
  52.         InputStream stream = null;
  53.         byte[] bytes = null;

  55.         if (obj instanceof InputStream) {
  56.             stream = (InputStream) obj;
  57.         } else if (obj instanceof URL) {
  58.             stream = getURLInputStream((URL) obj);
  59.         } else if (obj instanceof File) {
  60.             stream = new BufferedInputStream(new FileInputStream((File) obj));
  61.         } else if (obj instanceof byte[]) {
  62.             bytes = (byte[]) obj;
  63.         } else if (obj instanceof String) {
  64.             bytes = ((String) obj).getBytes();
  65.         } else {
  66.             throw new IllegalArgumentException(
  67.                     "Expected an InputStream, URL, File, byte[], or String");
  68.         }

  70.         if (bytes != null) {
  71.             stream = new ByteArrayInputStream(bytes);
  72.         }

  74.         return stream;
  75.     }

  77.     /**
  78.      * Get an InputStream from a URL. If URL is a HTTP url, attempts gzip
  79.      * compression.
  80.      *
  81.      * @param url
  82.      *            the url being accessed.
  83.      * @return an InputStream to content at URL.
  84.      * @throws IOException
  85.      *             if an error occurs.
  86.      */
  87.     public static InputStream getURLInputStream(final URL url)
  88.             throws IOException {
  89.         return getURLInputStream(url, DEFAULT_URL_CONNECT_TIMEOUT,
  90.                 DEFAULT_URL_READ_TIMEOUT);
  91.     }

  93.     /**
  94.      * Get an InputStream from a URL. If URL is a HTTP url, attempts gzip
  95.      * compression.
  96.      *
  97.      * @param url
  98.      *            the url being accessed.
  99.      * @param connectTimeout allowed time in milliseconds before connection.
  100.      * @param readTimeout allowed time in milliseconds before read.
  101.      * @return an InputStream to content at URL.
  102.      * @throws IOException
  103.      *             if an error occurs.
  104.      */
  105.     public static InputStream getURLInputStream(final URL url,
  106.             final int connectTimeout, final int readTimeout)
  107.             throws IOException {
  108.         InputStream in = null;

  110.         // initialize connection
  111.         URLConnection conn = url.openConnection();
  112.         conn.setRequestProperty("Accept-Encoding", "gzip");
  113.         conn.setConnectTimeout(connectTimeout);
  114.         conn.setReadTimeout(readTimeout);

  116.         // connect
  117.         conn.connect();

  119.         // get response
  120.         in = conn.getInputStream();
  121.         String contentEncoding = conn.getContentEncoding();
  122.         if (contentEncoding != null && contentEncoding.equals("gzip")) {
  123.             in = new GZIPInputStream(in);
  124.         }

  126.         return in;
  127.     }

  129.     /**
  130.      * Turn an object into an OutputStream if possible.
  131.      *
  132.      * @param obj
  133.      *            an OutputStream or File.
  134.      * @param append
  135.      *            if obj is a file and this parameter is true, the output stream
  136.      *            will be opened in append mode.
  137.      * @return an OutputStream. If obj is a File, the stream is Buffered.
  138.      * @throws IOException
  139.      *             if an error occurs
  140.      */
  141.     public static OutputStream getOutputStream(final Object obj,
  142.             final boolean append) throws IOException {
  143.         OutputStream stream = null;

  145.         if (obj instanceof OutputStream) {
  146.             stream = (OutputStream) obj;
  147.         } else if (obj instanceof File) {
  148.             File file = (File) obj;
  149.             // create parent directory first, if needed
  150.             File parent = file.getAbsoluteFile().getParentFile();
  151.             if (!parent.exists() && !parent.mkdirs()) {
  152.                 throw new IOException("Unable to create directory "
  153.                         + parent.getAbsolutePath());
  154.             }
  155.             if (!parent.canWrite()) {
  156.                 throw new IOException(
  157.                         "Do not have write permission for directory "
  158.                                 + parent.getAbsolutePath());
  159.             }

  161.             stream = new BufferedOutputStream(
  162.                     new FileOutputStream(file, append));
  163.         } else {
  164.             throw new IllegalArgumentException(
  165.                     "Expected an OutputStream or File");
  166.         }

  168.         return stream;
  169.     }

  171.     /**
  172.      * Same as calling getOutputStream(obj, false). If obj is a file, it will
  173.      * open a new output stream and will not append.
  174.      *
  175.      * @param obj
  176.      *            an OutputStream or File.
  177.      * @return an OutputStream. If obj is a File, the stream is Buffered.
  178.      * @throws IOException
  179.      *             if an error occurs.
  180.      */
  181.     public static OutputStream getOutputStream(final Object obj)
  182.             throws IOException {
  183.         return getOutputStream(obj, false);
  184.     }

  186.     /**
  187.      * Read stream contents into a byte array.
  188.      *
  189.      * @param from
  190.      *            stream to read.
  191.      * @return byte array of file content.
  192.      * @throws IOException
  193.      *             if an error occurs while reading.
  194.      */
  195.     public static byte[] readStream(final Object from) throws IOException {
  196.         ByteArrayOutputStream buffer = new ByteArrayOutputStream();
  197.         transferStream(from, buffer);
  198.         return buffer.toByteArray();
  199.     }

  201.     /**
  202.      * Transfer contents of Object from to Object to.
  203.      *
  204.      * Calls transferStream(from, to, DEFAULT_BUFFER_SIZE).
  205.      *
  206.      * @param from
  207.      *            streamable source.
  208.      * @param to
  209.      *            streamable target.
  210.      * @throws IOException
  211.      *            if IO error occurs
  212.      */
  213.     public static void transferStream(final Object from, final Object to)
  214.             throws IOException {
  215.         transferStream(from, to, DEFAULT_BUFFER_SIZE);
  216.     }

  218.     /**
  219.      * Transfer contents of Object from to Object to. Uses getInputStream and
  220.      * getOutputStream to generate streams. Streams are closed after reading.
  221.      *
  222.      * @param from
  223.      *            streamable source.
  224.      * @param to
  225.      *            streamable target.
  226.      * @param bufferSize
  227.      *            size of buffer
  228.      * @throws IOException
  229.      *             if thrown by calls to read/write on streams.
  230.      */
  231.     public static void transferStream(final Object from, final Object to,
  232.             final int bufferSize) throws IOException {
  233.         InputStream in = null;
  234.         OutputStream out = null;

  236.         try {
  237.             in = getInputStream(from);
  238.             out = getOutputStream(to);
  239.             byte[] buffer = new byte[bufferSize];
  240.             int read;
  241.             while ((read = in.read(buffer, 0, bufferSize)) != -1) {
  242.                 out.write(buffer, 0, read);
  243.             }
  244.             closeStream(in);
  245.             closeStream(out);
  246.         } catch (Exception e) {
  247.             closeStream(in);
  248.             closeStream(out);
  249.             if (e instanceof IOException) {
  250.                 throw (IOException) e;
  251.             }
  252.         }
  253.     }

  255.     /**
  256.      * Close an InputStream or OutputStream.
  257.      *
  258.      * @param stream
  259.      *            stream to close.
  260.      */
  261.     public static void closeStream(final Object stream) {
  262.         try {
  263.             if (stream instanceof OutputStream) {
  264.                 OutputStream out = (OutputStream) stream;
  265.                 try {
  266.                     out.flush();
  267.                 } finally {
  268.                     out.close();
  269.                 }
  270.             } else if (stream instanceof InputStream) {
  271.                 ((InputStream) stream).close();
  272.             }
  273.         } catch (Exception e) {
  274.             // ignore
  275.         }
  276.     }

  278.     /**
  279.      * An InputStream that ignores calls to close.
  280.      *
  281.      * Used for methods that automatically close a stream at EOF, even though it
  282.      * is undesirable for the stream to be closed, such as when using a
  283.      * ZipInputStream.
  284.      *
  285.      * @author jmfee
  286.      *
  287.      */
  288.     public static class UnclosableInputStream extends FilterInputStream {

  290.         /**
  291.          * Create a new UnclosableInputStream object.
  292.          *
  293.          * @param in
  294.          *            the InputStream to wrap.
  295.          */
  296.         public UnclosableInputStream(final InputStream in) {
  297.             super(in);
  298.         }

  300.         /**
  301.          * Does not close stream.
  302.          */
  303.         public void close() {
  304.             // ignore
  305.         }
  306.     }

  308.     /**
  309.      * An OutputStream that ignores calls to close.
  310.      *
  311.      * Used for methods that automatically close a stream, even though it is
  312.      * undesirable for the stream to be closed, such as when using a
  313.      * ZipOutputStream.
  314.      *
  315.      * @author jmfee
  316.      *
  317.      */
  318.     public static class UnclosableOutputStream extends FilterOutputStream {

  320.         /**
  321.          * Create a new UnclosableOutputStream object.
  322.          *
  323.          * @param out
  324.          *            the OutputStream to wrap.
  325.          */
  326.         public UnclosableOutputStream(final OutputStream out) {
  327.             super(out);
  328.         }

  330.         /**
  331.          * Flush written content, but does not close stream.
  332.          */
  333.         public void close() throws IOException {
  334.             out.flush();
  335.             // otherwise ignore
  336.         }
  337.     }

  339. }
Created with JaCoCo 0.8.8.202204050719