ZipMe.java

/**
 * C-JDBC: Clustered JDBC.
 * Copyright (C) 2002-2004 French National Institute For Research In Computer
 * Science And Control (INRIA).
 * Contact: c-jdbc@objectweb.org
 * 
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by the
 * Free Software Foundation; either version 2.1 of the License, or any later
 * version.
 * 
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
 * for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
 *
 * Initial developer(s): Nicolas Modrzyk
 * Contributor(s): 
 */

package org.objectweb.cjdbc.common.util;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

import org.objectweb.cjdbc.common.i18n.Translate;
import org.objectweb.cjdbc.common.log.Trace;

/**
 * Zip utility class inspired by the java tutorials of sun.
 * 
 * @author <a href="mailto:Nicolas.Modrzyk@inrialpes.fr">Nicolas Modrzyk </a>
 */
public class ZipMe
{
  // Buffers and streams
  private FileOutputStream     fos                        = null;
  private ZipOutputStream      zos                        = null;
  private ZipInputStream       zis                        = null;
  private FileInputStream      fis                        = null;
  private BufferedOutputStream dest;
  private String               rootDir;
  private String               zipPath;
  private boolean              useCompression             = true;

  static final int             BUFFER                     = 2048;
  

  // Store policy
  static final int             STORE_FULL_PATH_IN_ZIP     = 0;
  static final int             STORE_NAME_ONLY_IN_ZIP     = 1;
  static final int             STORE_RELATIVE_PATH_IN_ZIP = 2;
  static final int             STORE_PATH_FROM_ZIP_ROOT   = 3;
  static final int             STORE_POLICY               = STORE_PATH_FROM_ZIP_ROOT;

  static Trace                 logger                     = Trace
                                                              .getLogger(ZipMe.class
                                                                  .getName());

  /**
   * New ZipMe object
   */
  public ZipMe()
  {
  }

  /**
   * Create a zip file from directory
   * 
   * @param zipname of the file to create
   * @param rootdir of the directory to archive
   * @throws Exception if fails
   */
  public void create(String zipname, String rootdir) throws Exception
  {
    if (zipname == null || rootdir == null)
      throw new Exception("Invalid arguments to create zip file");
    this.rootDir = rootdir;
    try
    {
      zipPath = zipname + Constants.ZIP_EXT;
      fos = new FileOutputStream(zipPath);
      zos = new ZipOutputStream(fos);

      dirFunc(rootdir);

      zos.flush();
      zos.finish();
      zos.close();
      fos.close();
    }
    catch (IOException e)
    {
      logger.error(e.getMessage());
      throw e;
    }
  }

  /**
   * Same as above but the place where to put the zip file is explicit
   * 
   * @param zipname of the file to create
   * @param rootdir of the directory to archive
   * @param putMeThere please
   * @throws Exception if fails
   */
  public void create(String zipname, String rootdir, String putMeThere)
      throws Exception
  {
    create(putMeThere + File.separator + zipname, rootdir);
  }

  /**
   * Same as below but the place where to get the zip file is explicit
   * 
   * @param zipname of the file to expand
   * @param targetdir where to place unzipped files
   * @param getMeThere please
   * @throws Exception if fails
   */
  public void expand(String zipname, String targetdir, String getMeThere)
      throws Exception
  {
    expand(getMeThere + File.separator + zipname, targetdir);
  }

  /**
   * Get the size of the zip file
   * 
   * @return size in bytes
   */
  public long getZipSize()
  {
    File f = new File(zipPath);
    if (f.exists())
      return f.length();
    else
      return -1;
  }

  /**
   * Expand the content of the zip file
   * 
   * @param zipname of the file to expand
   * @param targetdir where to place unzipped files
   * @throws Exception if fails
   */
  public void expand(String zipname, String targetdir) throws Exception
  {
    File ftargetDir = new File(targetdir);
    if (!ftargetDir.exists())
      ftargetDir.mkdirs();
    if (!ftargetDir.exists())
      throw new Exception(Translate.get("zip.invalid.target.directory"));

    zipPath = zipname + Constants.ZIP_EXT;
    File fzipname = new File(zipPath);
    if (!fzipname.exists())
      throw new Exception(Translate.get("zip.invalid.source.file", zipname));

    try
    {
      fis = new FileInputStream(fzipname);
      zis = new ZipInputStream(fis);
      
      ZipEntry entry;

      byte data[] = new byte[BUFFER];
      while ((entry = zis.getNextEntry()) != null)
      {
        int count;
        String target = targetdir + File.separator + entry.getName();
        File fget = new File(target);
        fget.mkdirs(); // create needed new directories
        fget.delete(); // delete directory but not parents
        if (logger.isDebugEnabled())
          logger.debug(Translate.get("zip.extracting", new String[]{
              String.valueOf(entry), fget.getAbsolutePath()}));
        fos = new FileOutputStream(target);

        dest = new BufferedOutputStream(fos, BUFFER);
        while ((count = zis.read(data, 0, BUFFER)) != -1)
        {
          dest.write(data, 0, count);
        }
        dest.flush();
        dest.close();
      }
      zis.close();
    }
    catch (Exception e)
    {
      e.printStackTrace();
      logger.error(e.getMessage());
      throw e;
    }
  }

  private void dirFunc(String dirName) throws IOException
  {
    File dirObj = new File(dirName);
    if (dirObj.exists() == true)
    {
      if (dirObj.isDirectory() == true)
      {

        File[] fileList = dirObj.listFiles();

        for (int i = 0; i < fileList.length; i++)
        {
          if (fileList[i].isDirectory())
          {
            dirFunc(fileList[i].getPath());
          }
          else if (fileList[i].isFile())
          {

            zipFunc(fileList[i].getPath());
          }
        }
      }
      else
      {
        if (logger.isDebugEnabled())
          logger.debug(Translate.get("zip.not.directory", dirName));
      }
    }
    else
    {
      if (logger.isDebugEnabled())
        logger.debug(Translate.get("zip.directory.not.found", dirName));
    }
  }

  private void zipFunc(String filePath) throws IOException
  {
    File ffilePath = new File(filePath);
    String path = "";
    switch (STORE_POLICY)
    {
      case STORE_FULL_PATH_IN_ZIP :
        path = ffilePath.getAbsolutePath();
        break;
      case STORE_NAME_ONLY_IN_ZIP :
        ffilePath.getName();
        break;
      case STORE_RELATIVE_PATH_IN_ZIP :
        File f = new File("");
        String pathToHere = f.getAbsolutePath();
        path = ffilePath.getAbsolutePath();
        path = path.substring(path.indexOf(pathToHere + File.separator)
            + pathToHere.length());
        break;
      case STORE_PATH_FROM_ZIP_ROOT :
        path = ffilePath.getAbsolutePath();
        String tmpDir = File.separator + rootDir + File.separator;
        path = rootDir + File.separator
            + path.substring(path.indexOf(tmpDir) + tmpDir.length());
        logger.debug(path);
        break;
      default :
        break;
    }

    FileInputStream fis = new FileInputStream(filePath);
    BufferedInputStream bis = new BufferedInputStream(fis);

    ZipEntry fileEntry = new ZipEntry(path);
    zos.putNextEntry(fileEntry);

    byte[] data = new byte[1024];
    int byteCount;
    while ((byteCount = bis.read(data, 0, 1024)) > -1)
      zos.write(data, 0, byteCount);

    if (logger.isDebugEnabled())
      logger.debug(filePath);
  }

  /**
   * @return Returns the useCompression.
   */
  public boolean getUseCompression()
  {
    return useCompression;
  }

  /**
   * @param useCompression The useCompression to set.
   */
  public void setUseCompression(boolean useCompression)
  {
    this.useCompression = useCompression;
  }
}

---