src/be/nikiroo/utils/IOUtils.java

   1 package be.nikiroo.utils;
   2
   3 import java.io.ByteArrayOutputStream;
   4 import java.io.File;
   5 import java.io.FileInputStream;
   6 import java.io.FileOutputStream;
   7 import java.io.IOException;
   8 import java.io.InputStream;
   9 import java.io.OutputStream;
  10 import java.util.ArrayList;
  11 import java.util.List;
  12 import java.util.zip.ZipEntry;
  13 import java.util.zip.ZipInputStream;
  14 import java.util.zip.ZipOutputStream;
  15
  16 import be.nikiroo.utils.streams.MarkableFileInputStream;
  17
  18 /**
  19  * This class offer some utilities based around Streams and Files.
  20  *
  21  * @author niki
  22  */
  23 public class IOUtils {
  24         /**
  25          * Write the data to the given {@link File}.
  26          *
  27          * @param in
  28          *            the data source
  29          * @param target
  30          *            the target {@link File}
  31          *
  32          * @throws IOException
  33          *             in case of I/O error
  34          */
  35         public static void write(InputStream in, File target) throws IOException {
  36                 OutputStream out = new FileOutputStream(target);
  37                 try {
  38                         write(in, out);
  39                 } finally {
  40                         out.close();
  41                 }
  42         }
  43
  44         /**
  45          * Write the data to the given {@link OutputStream}.
  46          *
  47          * @param in
  48          *            the data source
  49          * @param out
  50          *            the target {@link OutputStream}
  51          *
  52          * @throws IOException
  53          *             in case of I/O error
  54          */
  55         public static void write(InputStream in, OutputStream out)
  56                         throws IOException {
  57                 byte buffer[] = new byte[4096];
  58                 int len = in.read(buffer);
  59                 while (len > -1) {
  60                         out.write(buffer, 0, len);
  61                         len = in.read(buffer);
  62                 }
  63         }
  64
  65         /**
  66          * Recursively Add a {@link File} (which can thus be a directory, too) to a
  67          * {@link ZipOutputStream}.
  68          *
  69          * @param zip
  70          *            the stream
  71          * @param base
  72          *            the path to prepend to the ZIP info before the actual
  73          *            {@link File} path
  74          * @param target
  75          *            the source {@link File} (which can be a directory)
  76          * @param targetIsRoot
  77          *            FALSE if we need to add a {@link ZipEntry} for base/target,
  78          *            TRUE to add it at the root of the ZIP
  79          *
  80          * @throws IOException
  81          *             in case of I/O error
  82          */
  83         public static void zip(ZipOutputStream zip, String base, File target,
  84                         boolean targetIsRoot) throws IOException {
  85                 if (target.isDirectory()) {
  86                         if (!targetIsRoot) {
  87                                 if (base == null || base.isEmpty()) {
  88                                         base = target.getName();
  89                                 } else {
  90                                         base += "/" + target.getName();
  91                                 }
  92                                 zip.putNextEntry(new ZipEntry(base + "/"));
  93                         }
  94
  95                         File[] files = target.listFiles();
  96                         if (files != null) {
  97                                 for (File file : files) {
  98                                         zip(zip, base, file, false);
  99                                 }
 100                         }
 101                 } else {
 102                         if (base == null || base.isEmpty()) {
 103                                 base = target.getName();
 104                         } else {
 105                                 base += "/" + target.getName();
 106                         }
 107                         zip.putNextEntry(new ZipEntry(base));
 108                         FileInputStream in = new FileInputStream(target);
 109                         try {
 110                                 IOUtils.write(in, zip);
 111                         } finally {
 112                                 in.close();
 113                         }
 114                 }
 115         }
 116
 117         /**
 118          * Zip the given source into dest.
 119          *
 120          * @param src
 121          *            the source {@link File} (which can be a directory)
 122          * @param dest
 123          *            the destination <tt>.zip</tt> file
 124          * @param srcIsRoot
 125          *            FALSE if we need to add a {@link ZipEntry} for src, TRUE to
 126          *            add it at the root of the ZIP
 127          *
 128          * @throws IOException
 129          *             in case of I/O error
 130          */
 131         public static void zip(File src, File dest, boolean srcIsRoot)
 132                         throws IOException {
 133                 OutputStream out = new FileOutputStream(dest);
 134                 try {
 135                         ZipOutputStream zip = new ZipOutputStream(out);
 136                         try {
 137                                 IOUtils.zip(zip, "", src, srcIsRoot);
 138                         } finally {
 139                                 zip.close();
 140                         }
 141                 } finally {
 142                         out.close();
 143                 }
 144         }
 145
 146         /**
 147          * Unzip the given ZIP file into the target directory.
 148          *
 149          * @param zipFile
 150          *            the ZIP file
 151          * @param targetDirectory
 152          *            the target directory
 153          *
 154          * @return the number of extracted files (not directories)
 155          *
 156          * @throws IOException
 157          *             in case of I/O errors
 158          */
 159         public static long unzip(File zipFile, File targetDirectory)
 160                         throws IOException {
 161                 long count = 0;
 162
 163                 if (targetDirectory.exists() && targetDirectory.isFile()) {
 164                         throw new IOException("Cannot unzip " + zipFile + " into "
 165                                         + targetDirectory + ": it is not a directory");
 166                 }
 167
 168                 targetDirectory.mkdir();
 169                 if (!targetDirectory.exists()) {
 170                         throw new IOException("Cannot create target directory "
 171                                         + targetDirectory);
 172                 }
 173
 174                 FileInputStream in = new FileInputStream(zipFile);
 175                 try {
 176                         ZipInputStream zipStream = new ZipInputStream(in);
 177                         try {
 178                                 for (ZipEntry entry = zipStream.getNextEntry(); entry != null; entry = zipStream
 179                                                 .getNextEntry()) {
 180                                         File file = new File(targetDirectory, entry.getName());
 181                                         if (entry.isDirectory()) {
 182                                                 file.mkdirs();
 183                                         } else {
 184                                                 IOUtils.write(zipStream, file);
 185                                                 count++;
 186                                         }
 187                                 }
 188                         } finally {
 189                                 zipStream.close();
 190                         }
 191                 } finally {
 192                         in.close();
 193                 }
 194
 195                 return count;
 196         }
 197
 198         /**
 199          * Write the {@link String} content to {@link File}.
 200          *
 201          * @param dir
 202          *            the directory where to write the {@link File}
 203          * @param filename
 204          *            the {@link File} name
 205          * @param content
 206          *            the content
 207          *
 208          * @throws IOException
 209          *             in case of I/O error
 210          */
 211         public static void writeSmallFile(File dir, String filename, String content)
 212                         throws IOException {
 213                 if (!dir.exists()) {
 214                         dir.mkdirs();
 215                 }
 216
 217                 writeSmallFile(new File(dir, filename), content);
 218         }
 219
 220         /**
 221          * Write the {@link String} content to {@link File}.
 222          *
 223          * @param file
 224          *            the {@link File} to write
 225          * @param content
 226          *            the content
 227          *
 228          * @throws IOException
 229          *             in case of I/O error
 230          */
 231         public static void writeSmallFile(File file, String content)
 232                         throws IOException {
 233                 FileOutputStream out = new FileOutputStream(file);
 234                 try {
 235                         out.write(StringUtils.getBytes(content));
 236                 } finally {
 237                         out.close();
 238                 }
 239         }
 240
 241         /**
 242          * Read the whole {@link File} content into a {@link String}.
 243          *
 244          * @param file
 245          *            the {@link File}
 246          *
 247          * @return the content
 248          *
 249          * @throws IOException
 250          *             in case of I/O error
 251          */
 252         public static String readSmallFile(File file) throws IOException {
 253                 InputStream stream = new FileInputStream(file);
 254                 try {
 255                         return readSmallStream(stream);
 256                 } finally {
 257                         stream.close();
 258                 }
 259         }
 260
 261         /**
 262          * Read the whole {@link InputStream} content into a {@link String}.
 263          *
 264          * @param stream
 265          *            the {@link InputStream}
 266          *
 267          * @return the content
 268          *
 269          * @throws IOException
 270          *             in case of I/O error
 271          */
 272         public static String readSmallStream(InputStream stream) throws IOException {
 273                 ByteArrayOutputStream out = new ByteArrayOutputStream();
 274                 try {
 275                         write(stream, out);
 276                         return out.toString("UTF-8");
 277                 } finally {
 278                         out.close();
 279                 }
 280         }
 281
 282         /**
 283          * Recursively delete the given {@link File}, which may of course also be a
 284          * directory.
 285          * <p>
 286          * Will either silently continue or throw an exception in case of error,
 287          * depending upon the parameters.
 288          *
 289          * @param target
 290          *            the target to delete
 291          * @param exception
 292          *            TRUE to throw an {@link IOException} in case of error, FALSE
 293          *            to silently continue
 294          *
 295          * @return TRUE if all files were deleted, FALSE if an error occurred
 296          *
 297          * @throws IOException
 298          *             if an error occurred and the parameters allow an exception to
 299          *             be thrown
 300          */
 301         public static boolean deltree(File target, boolean exception)
 302                         throws IOException {
 303                 List<File> list = deltree(target, null);
 304                 if (exception && !list.isEmpty()) {
 305                         StringBuilder slist = new StringBuilder();
 306                         for (File file : list) {
 307                                 slist.append("\n").append(file.getPath());
 308                         }
 309
 310                         throw new IOException("Cannot delete all the files from: <" //
 311                                         + target + ">:" + slist.toString());
 312                 }
 313
 314                 return list.isEmpty();
 315         }
 316
 317         /**
 318          * Recursively delete the given {@link File}, which may of course also be a
 319          * directory.
 320          * <p>
 321          * Will silently continue in case of error.
 322          *
 323          * @param target
 324          *            the target to delete
 325          *
 326          * @return TRUE if all files were deleted, FALSE if an error occurred
 327          */
 328         public static boolean deltree(File target) {
 329                 return deltree(target, null).isEmpty();
 330         }
 331
 332         /**
 333          * Recursively delete the given {@link File}, which may of course also be a
 334          * directory.
 335          * <p>
 336          * Will collect all {@link File} that cannot be deleted in the given
 337          * accumulator.
 338          *
 339          * @param target
 340          *            the target to delete
 341          * @param errorAcc
 342          *            the accumulator to use for errors, or NULL to create a new one
 343          *
 344          * @return the errors accumulator
 345          */
 346         public static List<File> deltree(File target, List<File> errorAcc) {
 347                 if (errorAcc == null) {
 348                         errorAcc = new ArrayList<File>();
 349                 }
 350
 351                 File[] files = target.listFiles();
 352                 if (files != null) {
 353                         for (File file : files) {
 354                                 errorAcc = deltree(file, errorAcc);
 355                         }
 356                 }
 357
 358                 if (!target.delete()) {
 359                         errorAcc.add(target);
 360                 }
 361
 362                 return errorAcc;
 363         }
 364
 365         /**
 366          * Open the given /-separated resource (from the binary root).
 367          *
 368          * @param name
 369          *            the resource name
 370          *
 371          * @return the opened resource if found, NLL if not
 372          */
 373         public static InputStream openResource(String name) {
 374                 ClassLoader loader = IOUtils.class.getClassLoader();
 375                 if (loader == null) {
 376                         loader = ClassLoader.getSystemClassLoader();
 377                 }
 378
 379                 return loader.getResourceAsStream(name);
 380         }
 381
 382         /**
 383          * Return a resetable {@link InputStream} from this stream, and reset it.
 384          *
 385          * @param in
 386          *            the input stream
 387          * @return the resetable stream, which <b>may</b> be the same
 388          *
 389          * @throws IOException
 390          *             in case of I/O error
 391          */
 392         public static InputStream forceResetableStream(InputStream in)
 393                         throws IOException {
 394                 boolean resetable = in.markSupported();
 395                 if (resetable) {
 396                         try {
 397                                 in.reset();
 398                         } catch (IOException e) {
 399                                 resetable = false;
 400                         }
 401                 }
 402
 403                 if (resetable) {
 404                         return in;
 405                 }
 406
 407                 final File tmp = File.createTempFile(".tmp-stream.", ".tmp");
 408                 try {
 409                         write(in, tmp);
 410                         in.close();
 411
 412                         return new MarkableFileInputStream(tmp) {
 413                                 @Override
 414                                 public void close() throws IOException {
 415                                         try {
 416                                                 super.close();
 417                                         } finally {
 418                                                 tmp.delete();
 419                                         }
 420                                 }
 421                         };
 422                 } catch (IOException e) {
 423                         tmp.delete();
 424                         throw e;
 425                 }
 426         }
 427
 428         /**
 429          * Convert the {@link InputStream} into a byte array.
 430          *
 431          * @param in
 432          *            the input stream
 433          *
 434          * @return the array
 435          *
 436          * @throws IOException
 437          *             in case of I/O error
 438          */
 439         public static byte[] toByteArray(InputStream in) throws IOException {
 440                 ByteArrayOutputStream out = new ByteArrayOutputStream();
 441                 try {
 442                         write(in, out);
 443                         return out.toByteArray();
 444                 } finally {
 445                         out.close();
 446                 }
 447         }
 448
 449         /**
 450          * Convert the {@link File} into a byte array.
 451          *
 452          * @param file
 453          *            the input {@link File}
 454          *
 455          * @return the array
 456          *
 457          * @throws IOException
 458          *             in case of I/O error
 459          */
 460         public static byte[] toByteArray(File file) throws IOException {
 461                 FileInputStream fis = new FileInputStream(file);
 462                 try {
 463                         return toByteArray(fis);
 464                 } finally {
 465                         fis.close();
 466                 }
 467         }
 468 }