broker-core/src/main/java/org/apache/qpid/server/util/FileUtils.java - qpid-broker-j - Git at Google

 /*
  *
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  *
  */
 package org.apache.qpid.server.util;

 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 import java.io.BufferedInputStream;
 import java.io.BufferedReader;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.FileReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.util.LinkedList;
 import java.util.List;

 /**
  * FileUtils provides some simple helper methods for working with files. It follows the convention of wrapping all
  * checked exceptions as runtimes, so code using these methods is free of try-catch blocks but does not expect to
  * recover from errors.
  */
 public class FileUtils
 {
     private static final Logger LOG = LoggerFactory.getLogger(FileUtils.class);

     private FileUtils()
     {
     }

     /**
      * Reads a text file as a string.
      *
      * @param filename The name of the file.
      *
      * @return The contents of the file.
      */
     public static byte[] readFileAsBytes(String filename)
     {

         try(BufferedInputStream is = new BufferedInputStream(new FileInputStream(filename)))
         {
             return readStreamAsString(is);
         }
         catch (IOException e)
         {
             throw new RuntimeException(e);
         }
     }


     /**
      * Reads a text file as a string.
      *
      * @param filename The name of the file.
      *
      * @return The contents of the file.
      */
     public static String readFileAsString(String filename)
     {
         return new String(readFileAsBytes(filename));
     }

     /**
      * Reads a text file as a string.
      *
      * @param file The file.
      *
      * @return The contents of the file.
      */
     public static String readFileAsString(File file)
     {
         try(BufferedInputStream is = new BufferedInputStream(new FileInputStream(file)))
         {

             return new String(readStreamAsString(is));
         }
         catch (IOException e)
         {
             throw new RuntimeException(e);
         }
     }

     /**
      * Reads the contents of a reader, one line at a time until the end of stream is encountered, and returns all
      * together as a string.
      *
      * @param is The reader.
      *
      * @return The contents of the reader.
      */
     private static byte[] readStreamAsString(BufferedInputStream is)
     {
         try(ByteArrayOutputStream inBuffer = new ByteArrayOutputStream())
         {
             byte[] data = new byte[4096];

             int read;

             while ((read = is.read(data)) != -1)
             {
                 inBuffer.write(data, 0, read);
             }

             return inBuffer.toByteArray();
         }
         catch (IOException e)
         {
             throw new RuntimeException(e);
         }
     }

     /**
      * Either opens the specified filename as an input stream or either the filesystem or classpath,
      * or uses the default resource loaded using the specified class loader, if opening the file fails
      * or no file name is specified.
      *
      * @param filename        The name of the file to open.
      * @param defaultResource The name of the default resource on the classpath if the file cannot be opened.
      * @param cl              The classloader to load the default resource with.
      *
      * @return An input stream for the file or resource, or null if one could not be opened.
      */
     @SuppressWarnings("resource")
     public static InputStream openFileOrDefaultResource(String filename, String defaultResource, ClassLoader cl)
     {
         InputStream is = null;

         // Try to open the file if one was specified.
         if (filename != null)
         {
             // try on filesystem
             try
             {
                 is = new BufferedInputStream(new FileInputStream(new File(filename)));
             }
             catch (FileNotFoundException e)
             {
                 is = null;
             }
             if (is == null)
             {
                 // failed on filesystem, so try on classpath
                 is = cl.getResourceAsStream(filename);
             }
         }

         // Load the default resource if a file was not specified, or if opening the file failed.
         if (is == null)
         {
             is = cl.getResourceAsStream(defaultResource);
         }

         return is;
     }

     /**
      * Copies the specified source file to the specified destintaion file. If the destinationst file does not exist,
      * it is created.
      *
      * @param src The source file name.
      * @param dst The destination file name.
      */
     public static void copy(File src, File dst)
     {
         try
         {
             copyCheckedEx(src, dst);
         }
         catch (IOException e)
         {
             throw new RuntimeException(e);
         }
     }

     /**
      * Copies the specified source file to the specified destination file. If the destination file does not exist,
      * it is created.
      *
      * @param src The source file name.
      * @param dst The destination file name.
      * @throws IOException if there is an issue copying the file
      */
     public static void copyCheckedEx(File src, File dst) throws IOException
     {
         InputStream in = new FileInputStream(src);
         copy(in, dst);
     }

     /**
      * Copies the specified InputStream to the specified destination file. If the destination file does not exist,
      * it is created.
      *
      * @param in The InputStream
      * @param dst The destination file name.
      * @throws IOException if there is an issue copying the stream
      */
     public static void copy(InputStream in, File dst) throws IOException
     {
         try
         {
             if (!dst.exists())
             {
                 dst.createNewFile();
             }

             OutputStream out = new FileOutputStream(dst);

             try
             {
                 // Transfer bytes from in to out
                 byte[] buf = new byte[1024];
                 int len;
                 while ((len = in.read(buf)) > 0)
                 {
                     out.write(buf, 0, len);
                 }
             }
             finally
             {
                 out.close();
             }
         }
         finally
         {
             in.close();
         }
     }

     /*
      * Deletes a given file
      */
     public static boolean deleteFile(String filePath)
     {
         return delete(new File(filePath), false);
     }

     /*
      * Deletes a given empty directory
      */
     public static boolean deleteDirectory(String directoryPath)
     {
         File directory = new File(directoryPath);

         if (directory.isDirectory())
         {
             if (directory.listFiles().length == 0)
             {
                 return delete(directory, true);
             }
         }

         return false;
     }

     /**
      * Delete a given file/directory,
      * A directory will always require the recursive flag to be set.
      * if a directory is specified and recursive set then delete the whole tree
      *
      * @param file      the File object to start at
      * @param recursive boolean to recurse if a directory is specified.
      *
      * @return <code>true</code> if and only if the file or directory is
      *         successfully deleted; <code>false</code> otherwise
      */
     public static boolean delete(File file, boolean recursive)
     {
         boolean success = true;

         if (file.isDirectory())
         {
             if (recursive)
             {
                 File[] files = file.listFiles();

                 // This can occur if the file is deleted outside the JVM
                 if (files == null)
                 {
                     LOG.debug("Recursive delete failed as file was deleted outside JVM");
                     return false;
                 }

                 for (int i = 0; i < files.length; i++)
                 {
                     success = delete(files[i], true) && success;
                 }

                 final boolean directoryDeleteSuccess = file.delete();
                 if(!directoryDeleteSuccess)
                 {
                     LOG.debug("Failed to delete " + file.getPath());
                 }
                 return success && directoryDeleteSuccess;
             }

             return false;
         }

         success = file.delete();
         if(!success)
         {
             LOG.debug("Failed to delete " + file.getPath());
         }
         return success;
     }

     public static class UnableToCopyException extends Exception
     {
         private static final long serialVersionUID = 956249157141857044L;

         UnableToCopyException(String msg)
         {
             super(msg);
         }
     }

     public static void copyRecursive(File source, File dst) throws FileNotFoundException, UnableToCopyException
     {

         if (!source.exists())
         {
             throw new FileNotFoundException("Unable to copy '" + source.toString() + "' as it does not exist.");
         }

         if (dst.exists() && !dst.isDirectory())
         {
             throw new IllegalArgumentException("Unable to copy '" + source.toString() + "' to '" + dst + "' a file with same name exists.");
         }

         if (source.isFile())
         {
             copy(source, dst);
         }

         //else we have a source directory
         if (!dst.isDirectory() && !dst.mkdirs())
         {
             throw new UnableToCopyException("Unable to create destination directory");
         }

         for (File file : source.listFiles())
         {
             if (file.isFile())
             {
                 copy(file, new File(dst.toString() + File.separator + file.getName()));
             }
             else
             {
                 copyRecursive(file, new File(dst + File.separator + file.getName()));
             }
         }

     }

     /**
      * Checks the specified file for instances of the search string.
      *
      * @param file the file to search
      * @param search the search String
      *
      * @throws java.io.IOException if there is an issue searching the file
      * @return the list of matching entries
      */
     public static List<String> searchFile(File file, String search)
             throws IOException
     {

         List<String> results = new LinkedList<String>();

         BufferedReader reader = new BufferedReader(new FileReader(file));
         try
         {
             while (reader.ready())
             {
                 String line = reader.readLine();
                 if (line.contains(search))
                 {
                     results.add(line);
                 }
             }
         }
         finally
         {
             reader.close();
         }

         return results;
     }
 }
	/*
	*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*
	*/
	package org.apache.qpid.server.util;

	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	import java.io.BufferedInputStream;
	import java.io.BufferedReader;
	import java.io.ByteArrayOutputStream;
	import java.io.File;
	import java.io.FileInputStream;
	import java.io.FileNotFoundException;
	import java.io.FileOutputStream;
	import java.io.FileReader;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.util.LinkedList;
	import java.util.List;

	/**
	* FileUtils provides some simple helper methods for working with files. It follows the convention of wrapping all
	* checked exceptions as runtimes, so code using these methods is free of try-catch blocks but does not expect to
	* recover from errors.
	*/
	public class FileUtils
	{
	private static final Logger LOG = LoggerFactory.getLogger(FileUtils.class);

	private FileUtils()
	{
	}

	/**
	* Reads a text file as a string.
	*
	* @param filename The name of the file.
	*
	* @return The contents of the file.
	*/
	public static byte[] readFileAsBytes(String filename)
	{

	try(BufferedInputStream is = new BufferedInputStream(new FileInputStream(filename)))
	{
	return readStreamAsString(is);
	}
	catch (IOException e)
	{
	throw new RuntimeException(e);
	}
	}


	/**
	* Reads a text file as a string.
	*
	* @param filename The name of the file.
	*
	* @return The contents of the file.
	*/
	public static String readFileAsString(String filename)
	{
	return new String(readFileAsBytes(filename));
	}

	/**
	* Reads a text file as a string.
	*
	* @param file The file.
	*
	* @return The contents of the file.
	*/
	public static String readFileAsString(File file)
	{
	try(BufferedInputStream is = new BufferedInputStream(new FileInputStream(file)))
	{

	return new String(readStreamAsString(is));
	}
	catch (IOException e)
	{
	throw new RuntimeException(e);
	}
	}

	/**
	* Reads the contents of a reader, one line at a time until the end of stream is encountered, and returns all
	* together as a string.
	*
	* @param is The reader.
	*
	* @return The contents of the reader.
	*/
	private static byte[] readStreamAsString(BufferedInputStream is)
	{
	try(ByteArrayOutputStream inBuffer = new ByteArrayOutputStream())
	{
	byte[] data = new byte[4096];

	int read;

	while ((read = is.read(data)) != -1)
	{
	inBuffer.write(data, 0, read);
	}

	return inBuffer.toByteArray();
	}
	catch (IOException e)
	{
	throw new RuntimeException(e);
	}
	}

	/**
	* Either opens the specified filename as an input stream or either the filesystem or classpath,
	* or uses the default resource loaded using the specified class loader, if opening the file fails
	* or no file name is specified.
	*
	* @param filename The name of the file to open.
	* @param defaultResource The name of the default resource on the classpath if the file cannot be opened.
	* @param cl The classloader to load the default resource with.
	*
	* @return An input stream for the file or resource, or null if one could not be opened.
	*/
	@SuppressWarnings("resource")
	public static InputStream openFileOrDefaultResource(String filename, String defaultResource, ClassLoader cl)
	{
	InputStream is = null;

	// Try to open the file if one was specified.
	if (filename != null)
	{
	// try on filesystem
	try
	{
	is = new BufferedInputStream(new FileInputStream(new File(filename)));
	}
	catch (FileNotFoundException e)
	{
	is = null;
	}
	if (is == null)
	{
	// failed on filesystem, so try on classpath
	is = cl.getResourceAsStream(filename);
	}
	}

	// Load the default resource if a file was not specified, or if opening the file failed.
	if (is == null)
	{
	is = cl.getResourceAsStream(defaultResource);
	}

	return is;
	}

	/**
	* Copies the specified source file to the specified destintaion file. If the destinationst file does not exist,
	* it is created.
	*
	* @param src The source file name.
	* @param dst The destination file name.
	*/
	public static void copy(File src, File dst)
	{
	try
	{
	copyCheckedEx(src, dst);
	}
	catch (IOException e)
	{
	throw new RuntimeException(e);
	}
	}

	/**
	* Copies the specified source file to the specified destination file. If the destination file does not exist,
	* it is created.
	*
	* @param src The source file name.
	* @param dst The destination file name.
	* @throws IOException if there is an issue copying the file
	*/
	public static void copyCheckedEx(File src, File dst) throws IOException
	{
	InputStream in = new FileInputStream(src);
	copy(in, dst);
	}

	/**
	* Copies the specified InputStream to the specified destination file. If the destination file does not exist,
	* it is created.
	*
	* @param in The InputStream
	* @param dst The destination file name.
	* @throws IOException if there is an issue copying the stream
	*/
	public static void copy(InputStream in, File dst) throws IOException
	{
	try
	{
	if (!dst.exists())
	{
	dst.createNewFile();
	}

	OutputStream out = new FileOutputStream(dst);

	try
	{
	// Transfer bytes from in to out
	byte[] buf = new byte[1024];
	int len;
	while ((len = in.read(buf)) > 0)
	{
	out.write(buf, 0, len);
	}
	}
	finally
	{
	out.close();
	}
	}
	finally
	{
	in.close();
	}
	}

	/*
	* Deletes a given file
	*/
	public static boolean deleteFile(String filePath)
	{
	return delete(new File(filePath), false);
	}

	/*
	* Deletes a given empty directory
	*/
	public static boolean deleteDirectory(String directoryPath)
	{
	File directory = new File(directoryPath);

	if (directory.isDirectory())
	{
	if (directory.listFiles().length == 0)
	{
	return delete(directory, true);
	}
	}

	return false;
	}

	/**
	* Delete a given file/directory,
	* A directory will always require the recursive flag to be set.
	* if a directory is specified and recursive set then delete the whole tree
	*
	* @param file the File object to start at
	* @param recursive boolean to recurse if a directory is specified.
	*
	* @return <code>true</code> if and only if the file or directory is
	* successfully deleted; <code>false</code> otherwise
	*/
	public static boolean delete(File file, boolean recursive)
	{
	boolean success = true;

	if (file.isDirectory())
	{
	if (recursive)
	{
	File[] files = file.listFiles();

	// This can occur if the file is deleted outside the JVM
	if (files == null)
	{
	LOG.debug("Recursive delete failed as file was deleted outside JVM");
	return false;
	}

	for (int i = 0; i < files.length; i++)
	{
	success = delete(files[i], true) && success;
	}

	final boolean directoryDeleteSuccess = file.delete();
	if(!directoryDeleteSuccess)
	{
	LOG.debug("Failed to delete " + file.getPath());
	}
	return success && directoryDeleteSuccess;
	}

	return false;
	}

	success = file.delete();
	if(!success)
	{
	LOG.debug("Failed to delete " + file.getPath());
	}
	return success;
	}

	public static class UnableToCopyException extends Exception
	{
	private static final long serialVersionUID = 956249157141857044L;

	UnableToCopyException(String msg)
	{
	super(msg);
	}
	}

	public static void copyRecursive(File source, File dst) throws FileNotFoundException, UnableToCopyException
	{

	if (!source.exists())
	{
	throw new FileNotFoundException("Unable to copy '" + source.toString() + "' as it does not exist.");
	}

	if (dst.exists() && !dst.isDirectory())
	{
	throw new IllegalArgumentException("Unable to copy '" + source.toString() + "' to '" + dst + "' a file with same name exists.");
	}

	if (source.isFile())
	{
	copy(source, dst);
	}

	//else we have a source directory
	if (!dst.isDirectory() && !dst.mkdirs())
	{
	throw new UnableToCopyException("Unable to create destination directory");
	}

	for (File file : source.listFiles())
	{
	if (file.isFile())
	{
	copy(file, new File(dst.toString() + File.separator + file.getName()));
	}
	else
	{
	copyRecursive(file, new File(dst + File.separator + file.getName()));
	}
	}

	}

	/**
	* Checks the specified file for instances of the search string.
	*
	* @param file the file to search
	* @param search the search String
	*
	* @throws java.io.IOException if there is an issue searching the file
	* @return the list of matching entries
	*/
	public static List<String> searchFile(File file, String search)
	throws IOException
	{

	List<String> results = new LinkedList<String>();

	BufferedReader reader = new BufferedReader(new FileReader(file));
	try
	{
	while (reader.ready())
	{
	String line = reader.readLine();
	if (line.contains(search))
	{
	results.add(line);
	}
	}
	}
	finally
	{
	reader.close();
	}

	return results;
	}
	}