/*
 *  $Source: /cvsroot2/open/projects/jAckup/ca/bc/webarts/tools/MultiZip.java,v $
 *  $Revision: 1.1 $  $Date: 2005-04-10 11:32:43 -0700 (Sun, 10 Apr 2005) $  $Locker:  $
 *  Copyright 2001-2002 (C) WebARTS Design.   All rights reserved.
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version 2
 *  of the License, or any later version.
 *
 *  This program 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
package ca.bc.webarts.tools;

import ca.bc.webarts.widgets.Util;

import com.aftexsw.util.bzip.BZip;

import com.ice.tar.TarArchive;
import com.ice.tar.TarEntry;

import jargs.gnu.CmdLineParser;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

import java.util.Date;
import java.util.Vector;

import java.util.zip.DataFormatException;
import java.util.zip.DeflaterOutputStream;
import java.util.zip.GZIPOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipException;
import java.util.zip.ZipOutputStream;

import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;


/**
 *  This class creates an archive of the specified directories and/or files. <p>
 *
 *  Some of the features of this classes implementation of archiving:
 *  <ul>
 *    <li> The max size for the archive can be specified</li>
 *    <li> Cross Platform </li>
 *    <li> Selectable Archive format:
 *    <ul>
 *      <li> directory of files</li>
 *      <li> tar </li>
 *      <li> zip</li>
 *      <li> tgz</li>
 *    </ul>
 *
 *    <li> Selectable compression format:
 *    <ul>
 *      <li> none</li>
 *      <li> zip</li>
 *      <li> gzip</li>
 *      <li> bzip2</li>
 *    </ul>
 *
 *  </ul>
 *  </p> Compression format is independant of the archive format.<p>
 *
 *  <p>
 *
 *  As you see this is a slightly different way of thinking of archiving - it
 *  provides maximum latitude in choosing the style a archive. For example: it
 *  allows the unconventional file.gz.tar format of an archive (all files are
 *  individually compressed with gzip format and then they are collected
 *  together into a tar archive format. Why??? its up to you. But this class
 *  should provide the way of getting the archive you want.</p> <p>
 *
 *  I personally bzip2 all my files into an empty directory which then is a
 *  staging area for making an iso-9660 image for backing onto a CDRW. </p> <p>
 *
 *  <b>Usage details:</b> (for full usage details...run MultiZip with no
 *  options) <pre>
 * java ca.bc.webarts.tools.MultiZip [options] &lt;source directory(s)/file(s)>
 *    options:
 *         -a dir,tar,zip         DEFAULT=zip
 *         -c none,zip,gzip,bzip2 DEFAULT=zip
 *         -l 0-9                 DEFAULT=9
 *         -v                     DEFAULT=not verbose
 *         -o filename            DEFAULT=same as input location
 *
 * EXAMPLE:
 *   java MultiZip -a dir -c bzip2 -l 9 -o /home/joeBlo/staging /home/joBlo/src
 *  </pre> <p>
 *
 *  <b>This tool is released with a GNU General Public License.<br>
 *  Author: Tom Gutwin <a href="mailto:tgutwin@webarts.bc.ca">
 *  tgutwin@webarts.bc.ca</a> <br>
 *  Copyright &copy; 2002 <a href="http://www.webarts.bc.ca">WebARTS Design.</a>
 *  </b></p>
 *
 * @author    Tom Gutwin <a href="mailto:tgutwin@webarts.bc.ca">
 *      tgutwin@webarts.bc.ca</a>
 */
public class MultiZip
{
  /**  Constant VAR */
  public final static short DIR_ARCHIVE = 1;
  /**  Constant VAR */
  public final static short TAR_ARCHIVE = 2;
  /**  Constant VAR */
  public final static short ZIP_ARCHIVE = 3;
  /**  Constant VAR */
  public final static short TGZ_ARCHIVE = 4;
  /**  Constant VAR */
  public final static short ZIP_COMPRESSION = 1;
  /**  Constant VAR */
  public final static short GZIP_COMPRESSION = 2;
  /**  Constant VAR */
  public final static short BZIP2_COMPRESSION = 3;
  /**  Constant VAR */
  public final static short NO_COMPRESSION = 4;
  /**  Constant VAR */
  public final static String LINE_SEPARATOR =
      System.getProperty("line.separator");

  /**  The log4j logger object. */
  protected static Logger logger_ = Logger.getLogger(MultiZip.class.getName());

  /**  A Class holder for its name (used in Logging). */
  protected static String className_ = "MultiZip";

  /**  The log4j logger config location. */
  protected static String log4jConfigLocation_ =
      System.getProperty("user.home") + "/dev/logs/" + className_ +
      "Log4jConfig.txt";

  /*
   *  User settable vars from the cmdline
   */
  /**  Flags if the output will be verbose. **/
  protected boolean verbose_ = false;

  /**  Flags if the output will be reduced. **/
  protected boolean quiet_ = false;

  /**  Flags for no output. **/
  protected boolean reallyQuiet_ = false;

  /**  Output stream for destination zip file. **/
  protected DeflaterOutputStream zos_ = null;

  /**  The current working destination zip file. **/
  protected File zipfile_ = null;

  /**
   * The instatited archive type.
   * User settable. **/
  short archiveType_ = DIR_ARCHIVE;
  /**  Description of the Field. */
  short compressionType_ = ZIP_COMPRESSION;
  /**  Description of the Field. **/
  int compressionLevel_ = 9;
  /**  The specified output filename/dirname. **/
  String output_ = null;
  /**  The temp dir where the zipped files go before archiving. **/
  String zippedOutputLocation_ = null;
  /**  The collection of files/dirnames to include in the archive. **/
  Vector input_ = null;
  /**  The collection of filenames that actually got comp'd. **/
  Vector compressedFilenames_ = new Vector();
  /**  The collection of filenames that had errors during compression. **/
  Vector errorFiles_ = null;
  /**  Description of the Field **/
  int archivefilenameCounter_ = 0;
  /**
   *  The maximum size in megabytes the archive will be allowed to grow to
   *  before creating a second archive with a incremental name.
   **/
  int maxArchiveSize_ = 600 * 1000 * 1000;

  /**  The current archive file size in bytes. **/
  long currArchiveSize_ = 0L;

  /**  Description of the Field */
  String[] defaultExcludes_ = {"~", "SWAPPER.DAT", "#", "OldHPFS", "OldFatDisk",
      "tmp", "Trash", "deleteme"};
  /**  The temp dir where the zipped files go before archiving. **/
  private String tmpDirName_ = "tmp_MultiZip";


  /**
   *  Default Constructor for the MultiZip object that does NO processing.
   **/
  MultiZip()
  {
    final String methodName = className_ + ": MultiZip Constructor()";
    logger_.debug("Entering " + methodName);

    logger_.debug("Exiting " + methodName);
  }


  /**
   *  Constructor for the MultiZip object
   *
   * @param  src  An array of files to include in the zip.
   * @param  des  Description of the Parameter
   */
  MultiZip(File[] src, File des)
  {
    final String methodName = className_ + ": MultiZip Constructor()";
    logger_.debug("Entering " + methodName);

    zipFiles(src, des);
    logger_.debug("Exiting " + methodName);
  }


  /**
   *  Constructor for the MultiZip object
   *
   * @param  src  a single File object to be included in the archice
   * @param  des  The destination File for the archive.
   */
  MultiZip(File src, File des)
  {
    final String methodName = className_ + ": MultiZip Constructor()";
    logger_.debug("Entering " + methodName);

    File[] srcArray = {src};
    zipFiles(srcArray, des);

    logger_.debug("Exiting " + methodName);
  }


  /**
   *  Main Entry point to run this class as an application usage: <code>
   * MultiZip <destination file> <source directorys / files>
   *</code>
   *
   * @param  args  1st arg is the destination file, 2nd arg is the source files
   */
  public static void main(String args[])
  {
    // log4j logger config
    PropertyConfigurator.configure(log4jConfigLocation_);
    logger_.setLevel(Level.WARN);
    final String methodName = className_ + ": MultiZip Main(String [])";
    logger_.debug("Entering " + methodName);

    MultiZip multiZipper = new MultiZip();
    parseCmdArgs(args, multiZipper);

    multiZipper.doArchiving();

    logger_.debug("Exiting " + methodName);
  }


  /**  Parses the cmd line args into usefule class vars. */
  private static void printUsage()
  {
    final String methodName = className_ + ": printUsage()";
    logger_.debug("Entering " + methodName);

    StringBuffer usage = new StringBuffer();
    usage.append(LINE_SEPARATOR);
    usage.append("Java MultiZIp - Copyright 2002 - Tom B. Gutwin, WebARTS Design");
    usage.append(LINE_SEPARATOR);
    usage.append(LINE_SEPARATOR);
    usage.append("Usage details:");
    usage.append(LINE_SEPARATOR);
    usage.append("  java ca.bc.webarts.tools.MultiZip [options] ");
    usage.append("file/dir(s)");
    usage.append(LINE_SEPARATOR);
    usage.append("    options:");
    usage.append(LINE_SEPARATOR);
    usage.append("      -h {--help}");
    usage.append(LINE_SEPARATOR);
    usage.append("      -a {--archive} dir,tar,zip,tgz          DEFAULT=zip");
    usage.append(LINE_SEPARATOR);
    usage.append("      -c {--compression} none,zip,gzip,bzip2  DEFAULT=zip");
    usage.append(LINE_SEPARATOR);
    usage.append("      -l {--compressionLevel} 0-9             DEFAULT=9");
    usage.append(LINE_SEPARATOR);
    usage.append("      -m {--maxarchive} an_integer            DEFAULT=650");
    usage.append(LINE_SEPARATOR);
    usage.append("      -v {--verbose}                          ");
    usage.append("DEFAULT=not verbose");
    usage.append(LINE_SEPARATOR);
    usage.append("      -q {--quiet}                            ");
    usage.append("DEFAULT=not quiet");
    usage.append(LINE_SEPARATOR);
    usage.append("      -Q {--reallyQuiet}                      ");
    usage.append("DEFAULT=not reallyQuiet");
    usage.append(LINE_SEPARATOR);
    usage.append("      -o {--output} filename");
    usage.append(LINE_SEPARATOR);
    usage.append(LINE_SEPARATOR);
    usage.append("   EXAMPLE:");
    usage.append(LINE_SEPARATOR);
    usage.append("    java ca.bc.webarts.tools.MultiZip -a dir -c bzip2 -l 9 ");
    usage.append("-o /home/joeBlo/staging /home/joBlo/src");
    usage.append(LINE_SEPARATOR);
    usage.append(LINE_SEPARATOR);
    usage.append("If the destination file/directory is not specified - the ");
    usage.append("files are compressed in the ");
    usage.append(LINE_SEPARATOR);
    usage.append("same dir as the specified source dir. The compressed files ");
    usage.append("will take the associated ");
    usage.append(LINE_SEPARATOR);
    usage.append("file extension (gz, zip, bz2, tar).");
    System.out.println(usage.toString());

    logger_.debug("Exiting " + methodName);
  }


  /**
   *  Parses the cmd line args into usefule class vars.
   *
   * @param  args         Description of the Parameter
   * @param  multiZipper  Description of the Parameter
   */
  private static void parseCmdArgs(String args[], MultiZip multiZipper)
  {
    final String methodName =
        className_ + ": parseCmdArgs(String [], MultiZip)";
    logger_.debug("Entering " + methodName);

    CmdLineParser parser = new CmdLineParser();
    CmdLineParser.Option help = parser.addBooleanOption('h', "help");
    CmdLineParser.Option verbose = parser.addBooleanOption('v', "verbose");
    CmdLineParser.Option verboseDebug =
        parser.addBooleanOption('V', "verboseDebug");
    CmdLineParser.Option quiet = parser.addBooleanOption('q', "quiet");
    CmdLineParser.Option reallyQuiet =
        parser.addBooleanOption('Q', "reallyQuiet");
    CmdLineParser.Option output = parser.addStringOption('o', "output");
    CmdLineParser.Option archive = parser.addStringOption('a', "archive");
    CmdLineParser.Option compression =
        parser.addStringOption('c', "compression");
    CmdLineParser.Option compressionLevel =
        parser.addIntegerOption('l', "compressionLevel");
    CmdLineParser.Option maxarchive =
        parser.addIntegerOption('m', "maxarchive");

    try
    {
      parser.parse(args);
    }
    catch (CmdLineParser.OptionException e)
    {
      logger_.error(e.getMessage());
      printUsage();
      System.exit(2);
    }

    // Extract the values entered for the various options -- if the
    // options were not specified, the corresponding values will be
    // null.
    if (parser.getOptionValue(help) != null)
    {
      printUsage();
    }
    if (parser.getOptionValue(reallyQuiet) != null)
    {
      multiZipper.setReallyQuiet(
          ((Boolean) parser.getOptionValue(reallyQuiet)).booleanValue());
    }
    if (parser.getOptionValue(quiet) != null)
    {
      multiZipper.setQuiet(
          ((Boolean) parser.getOptionValue(quiet)).booleanValue());
    }
    if (parser.getOptionValue(verbose) != null)
    {
      multiZipper.setVerbose(
          ((Boolean) parser.getOptionValue(verbose)).booleanValue());
    }
    if (parser.getOptionValue(verboseDebug) != null)
    {
      logger_.setLevel(Level.DEBUG);
    }
    if (parser.getOptionValue(compression) != null)
    {
      multiZipper.setArchiveType((String) parser.getOptionValue(compression));
    }
    if (parser.getOptionValue(output) != null)
    {
      multiZipper.setOutput((String) parser.getOptionValue(output));
    }
    if (parser.getOptionValue(archive) != null)
    {
      multiZipper.setArchiveType((String) parser.getOptionValue(archive));
    }
    if (parser.getOptionValue(compression) != null)
    {
      multiZipper.setCompressionType(
          (String) parser.getOptionValue(compression));
    }
    if (parser.getOptionValue(compressionLevel) != null)
    {
      multiZipper.setCompressionLevel(
          ((Integer) parser.getOptionValue(compressionLevel)).shortValue());
    }
    if (parser.getOptionValue(maxarchive) != null)
    {
      multiZipper.setMaxArchiveSize(
          ((Integer) parser.getOptionValue(maxarchive)).shortValue());
    }

    // For testing purposes, we just print out the option values
    logger_.debug("verbose_: " + multiZipper.getVerbose());
    logger_.debug("quiet_: " + multiZipper.getQuiet());
    logger_.debug("reallyQuiet_: " + multiZipper.getReallyQuiet());
    logger_.debug("archive: " + multiZipper.getArchiveType());
    logger_.debug("compression: " + multiZipper.getCompressionType());
    logger_.debug("compressionLevel: " + multiZipper.getCompressionLevel());
    logger_.debug("output: " + multiZipper.getOutput());
    logger_.debug("maxarchive: " + multiZipper.getMaxArchiveSize());

    // Extract the trailing command-line arguments in the
    String[] otherArgs = parser.getRemainingArgs();
    logger_.debug("remaining args: ");
    for (int i = 0; i < otherArgs.length; ++i)
    {
      logger_.debug(otherArgs[i]);
    }

    if (otherArgs.length == 0)
    {
      // ERROR
      logger_.error("ERROR:");
      logger_.error("   No input files specified.");
      printUsage();
      System.exit(2);
    }
    else
    {
      //Input files
      Vector tmpVector = new Vector();
      String fileSep = System.getProperty("file.separator");
      String userDir = System.getProperty("user.dir");
      StringBuffer newInput = null;
      for (short i = 0; i < otherArgs.length; ++i)
      {
        // first confirm we ar dealing with an absolute path
        if (!(otherArgs[i].startsWith(fileSep) ||
            otherArgs[i].substring(1).startsWith(":")))
        {
          //  it is a relative path so... construct the absolute path
          logger_.info("Specified Input File path appears to be a relative path.");
          newInput = new StringBuffer(userDir);
          if (!userDir.endsWith(fileSep))
          {
            newInput.append(fileSep);
          }
          newInput.append(otherArgs[i]);
          otherArgs[i] = Util.removeParentRelativeReference(newInput.toString());
        }

        tmpVector.add(otherArgs[i]);
      }
      multiZipper.setInput(tmpVector);
    }

    // now check and correct the output_ setting depending on the comp and
    // archive types
    if (!multiZipper.validateOutputLocation())
    {
      // ERROR
      logger_.error("ERROR:");
      logger_.error("   Output file specified in a NON-writable dir or " +
          "incorrectly specified.");
      printUsage();
      System.exit(2);
    }

    logger_.debug("Exiting " + methodName);
  }



  /**
   *  The public set method to set the zippedOutputLocation_ class field.
   *
   * @param  zippedOutputLocation  is the value to use to set the class field
   *      to.
   */
  public void setZippedOutputLocation(String zippedOutputLocation)
  {
    this.zippedOutputLocation_ = zippedOutputLocation_;
  }


  /**
   *  The public get method to return the zippedOutputLocation_ class field.
   *
   * @return    the class field: zippedOutputLocation_
   */
  public String getZippedOutputLocation()
  {
    return zippedOutputLocation_;
  }


  /**
   *  The public set method to set the input_ class field.
   *
   * @param  input  is the value to use to set the class field to.
   */
  public void setInput(String[] input)
  {
    final String methodName = className_ + ": setInput(String [])";
    logger_.debug("Entering " + methodName);

    input_ = null;
    input_ = new Vector();
    if (input != null)
    {
      for (short i = 0; i < input.length; ++i)
      {
        input_.add(input[i]);
      }
    }

    logger_.debug("Exiting " + methodName);
  }


  /**
   *  The public set method to set the input_ class field.
   *
   * @param  input  is the Vector of valuese to use to set the class field to.
   */
  public void setInput(Vector input)
  {
    final String methodName = className_ + ": setInput(Vector)";
    logger_.debug("Entering " + methodName);

    this.input_ = input;

    logger_.debug("Exiting " + methodName);
  }


  /**
   *  The public get method to return the input_ class field.
   *
   * @return    the class field: input_
   */
  public Vector getInput()
  {
    final String methodName = className_ + ": getInput()";
    logger_.debug("Entering " + methodName);

    logger_.debug("Exiting " + methodName);
    return input_;
  }


  /**
   *  The public set method to set the output_ class field.
   *
   * @param  output  The new output value
   */
  public void setOutput(String output)
  {
    final String methodName = className_ + ": setOutput(String)";
    logger_.debug("Entering " + methodName);

    this.output_ = output;

    logger_.debug("Exiting " + methodName);
  }


  /**
   *  The public get method to return the output_ class field.
   *
   * @return    the class field: output_
   */
  public String getOutput()
  {
    final String methodName = className_ + ": getOutput()";
    logger_.debug("Entering " + methodName);

    logger_.debug("Exiting " + methodName);
    return output_;
  }


  /**
   *  The public set method to set the compressionType_ class field.
   *
   * @param  compressionType  is the value to use to set the class field to.
   */
  public void setCompressionType(String compressionType)
  {
    final String methodName = className_ + ": setCompressionType(String)";
    logger_.debug("Entering " + methodName);

    this.compressionType_ = 0;
    if (compressionType.trim().toLowerCase().equals("zip"))
    {
      this.compressionType_ = ZIP_COMPRESSION;
    }
    else if (compressionType.trim().toLowerCase().equals("gzip"))
    {
      this.compressionType_ = GZIP_COMPRESSION;
    }
    else if (compressionType.trim().toLowerCase().equals("bzip2"))
    {
      this.compressionType_ = BZIP2_COMPRESSION;
    }
    else if (compressionType.trim().toLowerCase().equals("none"))
    {
      this.compressionType_ = NO_COMPRESSION;
    }
    else if (compressionType.trim().toLowerCase().equals("no"))
    {
      this.compressionType_ = NO_COMPRESSION;
    }

    logger_.debug("Exiting " + methodName);
  }


  /**
   *  The public set method to set the compressionType_ class field.
   *
   * @param  compressionType  is the value to use to set the class field to.
   */
  public void setCompressionType(short compressionType)
  {
    final String methodName = className_ + ": setCompressionType(short)";
    logger_.debug("Entering " + methodName);

    this.compressionType_ = compressionType;

    logger_.debug("Exiting " + methodName);
  }


  /**
   *  The public get method to return the compressionType_ class field.
   *
   * @return    the class field: compressionType_
   */
  public short getCompressionType()
  {
    final String methodName = className_ + ": getCompressionType()";
    logger_.debug("Entering " + methodName);

    logger_.debug("Exiting " + methodName);
    return compressionType_;
  }


  /**
   *  The public set method to set the compressionType_ class field.
   *
   * @param  archiveType  The new archiveType value
   */
  public void setArchiveType(String archiveType)
  {
    final String methodName = className_ + ": setArchiveType(String)";
    logger_.debug("Entering " + methodName);

    this.archiveType_ = 0;
    if (archiveType.trim().toLowerCase().equals("zip"))
    {
      this.archiveType_ = ZIP_ARCHIVE;
    }
    else if (archiveType.trim().toLowerCase().equals("tar"))
    {
      this.archiveType_ = TAR_ARCHIVE;
    }
    else if (archiveType.trim().toLowerCase().equals("dir"))
    {
      this.archiveType_ = DIR_ARCHIVE;
    }
    else if (archiveType.trim().toLowerCase().equals("tgz"))
    {
      this.archiveType_ = TGZ_ARCHIVE;
    }

    logger_.debug("Exiting " + methodName);
  }


  /**
   *  The public set method to set the archiveType_ class field.
   *
   * @param  archiveType  is the value to use to set the class field to.
   */
  public void setArchiveType(short archiveType)
  {
    final String methodName = className_ + ": setArchiveType(short)";
    logger_.debug("Entering " + methodName);

    this.archiveType_ = archiveType_;

    logger_.debug("Exiting " + methodName);
  }


  /**
   *  The public get method to return the archiveType_ class field.
   *
   * @return    the class field: archiveType_
   */
  public short getArchiveType()
  {
    final String methodName = className_ + ": getArchiveType()";
    logger_.debug("Entering " + methodName);

    logger_.debug("Exiting " + methodName);
    return archiveType_;
  }


  /**
   *  The public set method to set the reallyQuiet_ class field.
   *
   * @param  reallyQuiet  is the value to use to set the class field to.
   */
  public void setReallyQuiet(boolean reallyQuiet)
  {
    final String methodName = className_ + ": setReallyQuiet(boolean)";
    logger_.debug("Entering " + methodName);

    this.reallyQuiet_ = reallyQuiet;
    logger_.setLevel(Level.FATAL);

    logger_.debug("Exiting " + methodName);
  }


  /**
   *  The public get method to return the reallyQuiet_ class field.
   *
   * @return    the class field: reallyQuiet_
   */
  public boolean getReallyQuiet()
  {
    final String methodName = className_ + ": getReallyQuiet()";
    logger_.debug("Entering " + methodName);

    logger_.debug("Exiting " + methodName);
    return reallyQuiet_;
  }


  /**
   *  The public set method to set the verbose_ class field.
   *
   * @param  verbose  is the value to use to set the class field to.
   */
  public void setVerbose(boolean verbose)
  {
    final String methodName = className_ + ": setVerbose(boolean)";
    logger_.debug("Entering " + methodName);

    this.verbose_ = verbose_;
    logger_.setLevel(Level.INFO);
    logger_.debug("Exiting " + methodName);
  }


  /**
   *  The public get method to return the verbose_ class field.
   *
   * @return    the class field: verbose_
   */
  public boolean getVerbose()
  {
    final String methodName = className_ + ": getVerbose()";
    logger_.debug("Entering " + methodName);

    logger_.debug("Exiting " + methodName);
    return verbose_;
  }


  /**
   *  Gets the quiet_ field. Which specifies how much user feedback is provided
   *
   * @return    The quiet_ value
   */
  public boolean getQuiet()
  {
    final String methodName = className_ + ": getQuiet()";
    logger_.debug("Entering " + methodName);

    logger_.debug("Exiting " + methodName);
    return quiet_;
  }


  /**
   *  Sets the quiet_ field. Which specifies how much user feedback is provided
   *
   * @param  quiet  The new quiet_ value
   */
  public void setQuiet(boolean quiet)
  {
    final String methodName = className_ + ": setQuiet(boolean)";
    logger_.debug("Entering " + methodName);

    this.quiet_ = quiet;
    logger_.setLevel(Level.ERROR);

    logger_.debug("Exiting " + methodName);
  }


  /**
   *  Sets the maxArchiveSize_ attribute of the MultiZip object
   *
   * @param  maxArchiveSize  The new maxArchiveSize value
   */
  public void setMaxArchiveSize(int maxArchiveSize)
  {
    final String methodName = className_ + ": setMaxArchiveSize(int)";
    logger_.debug("Entering " + methodName);

    this.maxArchiveSize_ = maxArchiveSize;

    logger_.debug("Exiting " + methodName);
  }


  /**
   *  Gets the maxArchiveSize_ attribute of the MultiZip object
   *
   * @return    The maxArchiveSize_ value
   */
  public int getMaxArchiveSize()
  {
    final String methodName = className_ + ": getMaxArchiveSize()";
    logger_.debug("Entering " + methodName);

    logger_.debug("Exiting " + methodName);
    return maxArchiveSize_;
  }


  /**
   *  Sets the compressionLevel_ attribute of the MultiZip object
   *
   * @param  compressionLevel  The new compressionLevel_ value
   */
  public void setCompressionLevel(int compressionLevel)
  {
    final String methodName = className_ + ": setCompressionLevel(int)";
    logger_.debug("Entering " + methodName);

    this.compressionLevel_ = compressionLevel;

    logger_.debug("Exiting " + methodName);
  }


  /**
   *  Gets the compressionLevel_ attribute of the MultiZip object
   *
   * @return    The compressionLevel_ value
   */
  public int getCompressionLevel()
  {
    final String methodName = className_ + ": getCompressionLevel()";
    logger_.debug("Entering " + methodName);
    logger_.debug("Exiting " + methodName);
    return compressionLevel_;
  }


  /**
   *  Initiates and begins the archival process. It is the method to call to
   *  start things rolling.
   *
   * @return    The compressionLevel_ value
   */
  public short doArchiving()
  {
    final String methodName = className_ + ": doArchiving()";
    logger_.debug("Entering " + methodName);

    short retVal = 0;

    long startTime = (new Date()).getTime();
    // Pre-recurse the dirs into a flat list of files.
    setInput(recurseInputIntoFiles(input_));

    // Check if we can do this on one step instead of two
    if (!oneStepArchive())
    {
      compressFiles();
    }

    //if (!oneStepCompress())
    //{
      archiveFiles();
    //}

    long duration = ((new Date()).getTime() - startTime) / 1000L;
    long minutes = duration / 60L;
    long seconds = duration - (60L * minutes);
    logger_.info("Time to complete: " + minutes + " min. " + seconds + " sec.");
    logger_.debug("Exiting " + methodName);
    return retVal;
  }


  /**
   *  It simply move a compressed file to the output dir for DIR type archives.
   *
   * @param  source  The filename to include in the archive.
   */
  public void moveFileToArchive(File source)
  {
    final String methodName = className_ + ": moveFileToArchive(File)";
    logger_.debug("Entering " + methodName);

    if (source != null)
    {
      if (source.isDirectory())
      {
        String srcFileNames[] = source.list();
        for (int i = 0; i < srcFileNames.length; i++)
        {
          logger_.info("Recursing On Dir " + source.getName());
          moveFileToArchive(new File(source.getAbsolutePath() + File.separator +
              srcFileNames[i]));
        }
      }
      else
      {
        File tmpNewFile = null;
        if (currArchiveSize_+source.length() < maxArchiveSize_ *1000000)
        {
          logger_.info("Moving " + source.getName() + " to \n  -->" +
              output_ + source.getAbsolutePath() + "\n");
          Util.ensureFolderExists(new File(output_ + source.getAbsolutePath()).
              getParentFile());
          tmpNewFile = new File(output_ + source.getAbsolutePath());
          if (source.renameTo(tmpNewFile))
            currArchiveSize_ += tmpNewFile.length();
        }
        else
        {
          // up the archive dir name
          String oldCntr = ""+archivefilenameCounter_;
          archivefilenameCounter_++;
          if(archivefilenameCounter_ == 1)
            output_ = output_ + archivefilenameCounter_;
          else
          {
            // scratch off the old counter number and replace it with the new
            output_ = output_.substring(0,output_.length()-oldCntr.length()) +
                      archivefilenameCounter_;
            currArchiveSize_ = 0L;
          }
          // now move it
          logger_.info("Moving " + source.getName() + " to \n  -->" +
              output_ + source.getAbsolutePath() + "\n");
          Util.ensureFolderExists(new File(output_ + source.getAbsolutePath()).
              getParentFile());
          tmpNewFile = new File(output_ + source.getAbsolutePath());
          if (source.renameTo(tmpNewFile))
            currArchiveSize_ += tmpNewFile.length();
        }
      }
    }

    logger_.debug("Exiting " + methodName);
  }


  /**
   *  It simply copies a compressed file to the output dir for DIR type archives
   *
   * @param  source  The filename to include in the archive.
   */
  public void copyFileToArchive(File source)
  {
    final String methodName = className_ + ": copyFileToArchive(File)";
    logger_.debug("Entering " + methodName);

    if (source != null)
    {
      if (source.isDirectory())
      {
        String srcFileNames[] = source.list();
        for (int i = 0; i < srcFileNames.length; i++)
        {
          logger_.info("Recursing On Dir " + source.getName());
          copyFileToArchive(new File(source.getAbsolutePath() + File.separator +
              srcFileNames[i]));
        }
      }
      else
      {
        logger_.info("Copying " + source.getName() + " to \n  -->" +
            output_ + source.getAbsolutePath() + "\n");
        Util.ensureFolderExists(new File(output_ + source.getAbsolutePath()).
            getParentFile());
        File newFile = new File(output_ + source.getAbsolutePath());
        try
        {
          FileInputStream fis = new FileInputStream(source);
          FileOutputStream fos = new FileOutputStream(newFile);
          long bytesToRead = source.length();
          int bufferSize = 512;
          byte[] buffer = new byte[bufferSize];
          int amountRead = 0;
          for (int i = 0; i < bytesToRead; i += amountRead)
          {
            try
            {
              amountRead = fis.read(buffer);
              if (amountRead == -1)
              {
                break;
              }
              fos.write(buffer);
            }
            catch (java.lang.IndexOutOfBoundsException boundsEx)
            {
              logger_.error("Cannot copy file to archive:");
              logger_.error("  " + source.getAbsolutePath() + " --> " +
                  newFile.getAbsolutePath());
              logger_.error("   i=" + i);
              logger_.error("   amountRead=" + amountRead);
              logger_.error("   bytesToRead=" + bytesToRead);
              break;
            }
          }
          fis.close();
          fos.close();
        }
        catch (IOException ioEx)
        {
          logger_.error("Cannot copy file to archive:");
          logger_.error("  " + source.getAbsolutePath() + " --> " +
              newFile.getAbsolutePath());
        }
      }
    }

    logger_.debug("Exiting " + methodName);
  }


  /**
   *  It simply moves all the compressed files to the output dir for DIR type
   *  archives.
   */
  public void moveFilesToArchive()
  {
    final String methodName = className_ + ": moveFilesToArchive()";
    logger_.debug("Entering " + methodName);

    if (input_ != null)
    {
      String compExtension = "";
      switch (getCompressionType())
      {
          case ZIP_COMPRESSION:
            compExtension = ".zip";
            break;
          case GZIP_COMPRESSION:
            compExtension = ".gz";
            break;
          case BZIP2_COMPRESSION:
            compExtension = ".bz2";
            break;
          case NO_COMPRESSION:
            break;
          default:
      }

      logger_.info("Begining to Move " + compressedFilenames_.size() +
          " Files To Archive:");
      File tmpFile = null;
      for (int i = 0; i < compressedFilenames_.size(); i++)
      {
        tmpFile = new File(((String) compressedFilenames_.elementAt(i)).trim());
        moveFileToArchive(tmpFile);
      }
    }

    logger_.debug("Exiting " + methodName);
  }


  /**
   *  It simply copies the compressed files to the output dir for DIR type
   *  archives.
   */
  public void copyFilesToArchive()
  {
    final String methodName = className_ + ": copyFilesToArchive()";
    logger_.debug("Entering " + methodName);

    if (input_ != null)
    {
      String compExtension = "";
      switch (getCompressionType())
      {
          case ZIP_COMPRESSION:
            compExtension = ".zip";
            break;
          case GZIP_COMPRESSION:
            compExtension = ".gz";
            break;
          case BZIP2_COMPRESSION:
            compExtension = ".bz2";
            break;
          case NO_COMPRESSION:
            break;
          default:
      }

      logger_.info("Begining to copy " + compressedFilenames_.size() +
          " Files To Archive:");
      File tmpFile = null;
      for (int i = 0; i < compressedFilenames_.size(); i++)
      {
        tmpFile = new File(((String) compressedFilenames_.elementAt(i)).trim());
        copyFileToArchive(tmpFile);
      }
    }

    logger_.debug("Exiting " + methodName);
  }


  /**  It cleans up the compressed files by deleting them */
  public void removeCompressedFiles()
  {
    final String methodName = className_ + ": removeCompressedFiles()";
    logger_.debug("Entering " + methodName);

    if (input_ != null)
    {
      String compExtension = "";
      switch (getCompressionType())
      {
          case ZIP_COMPRESSION:
            compExtension = ".zip";
            break;
          case GZIP_COMPRESSION:
            compExtension = ".gz";
            break;
          case BZIP2_COMPRESSION:
            compExtension = ".bz2";
            break;
          case NO_COMPRESSION:
            break;
          default:
      }

      logger_.info("Begining to DELETE " + compressedFilenames_.size() +
          " Files.");
      File tmpFile = null;
      for (int i = 0; i < compressedFilenames_.size(); i++)
      {
        tmpFile = new File(((String) compressedFilenames_.elementAt(i)).trim());
        tmpFile.delete();
      }
    }

    logger_.debug("Exiting " + methodName);
  }


  /**
   *  Encapsulates the zipping of file(s) individually into the class
   *  zippedOutputLocation_. THIS DOES NOT collect them together into an
   *  archive. It simply compresses the files into a *.zip file in the
   *  zippedOutputLocation_ dir.
   *
   * @param  source  A Vector of Strings holding the filenames to include in the
   *      zipped file.
   */
  public void zipFiles(Vector source)
  {
    final String methodName = className_ + ": zipFiles(Vector)";
    logger_.debug("Entering " + methodName);

    if (source != null)
    {
      File tmpFile = null;
      File outZip = null;
      StringBuffer outLocation = new StringBuffer();
      String fileSep = File.separator;
      String foPath = null;
      for (int i = 0; i < source.size(); i++)
      {
        tmpFile = new File((String) source.elementAt(i));
        if (!tmpFile.isDirectory())
        {
          foPath = tmpFile.getAbsolutePath().trim();
          if (zippedOutputLocation_ == null)
          {
            zippedOutputLocation_ = "";
          }
          // use the spec'd location
          outLocation = new StringBuffer(zippedOutputLocation_);
          if (!zippedOutputLocation_.endsWith(fileSep) &&
              !foPath.startsWith(fileSep))
          {
            outLocation.append(fileSep);
          }
          outLocation.append(foPath);
          outLocation.append(".zip");
          logger_.info("Zipping " + foPath);
          outZip = new File(outLocation.toString());
          //ensureFolderExists(outZip.getParentFile());
          zipFile(tmpFile, outZip);
          tmpFile = null;
          outLocation = null;
        }
        else
        {
          zipFiles(tmpFile.listFiles());
        }
      }
    }

    logger_.debug("Exiting " + methodName);
  }


  /**
   *  Encapsulates the gzipping of 1 file/dir in place.
   *
   * @param  source  The file to GZIP.
   * @return         the new length in bytes of the zipped file
   */
  public long gzipFile(File source)
  {
    final String methodName = className_ + ": gzipFile(File)";
    logger_.debug("Entering " + methodName);
    long retVal = 0L;

    logger_.info(" GZIPPING " + source.getName());
    retVal += recursiveGZip(source);

    logger_.debug("Exiting " + methodName);
    return retVal;
  }


  /**
   *  Encapsulates the gzipping of file(s) individually in place. THIS DOES NOT
   *  collect them together into an archive. It simply compresses the files into
   *  a *.bz2 file in the same dir as the source.
   *
   * @param  source  The files to include in the zipped file.
   * @return         the new length in bytes of the zipped file
   */
  public long gzipFiles(File[] source)
  {
    final String methodName = className_ + ": gzipFiles(File[])";
    logger_.debug("Entering " + methodName);
    long retVal = 0L;

    for (int i = 0; i < source.length; i++)
    {
      retVal += gzipFile(new File(source[i].getAbsolutePath().trim()));

      //watch for the Archive size limit when One Step Compress.

    }

    logger_.debug("Exiting " + methodName);
    return retVal;
  }


  /**
   *  Encapsulates the gzipping of file(s) individually in place. THIS DOES NOT
   *  collect them together into an archive. It simply compresses the files into
   *  a *.zip file in the same dir as the source.
   *
   * @param  source  The filenames to include in the zipped file.
   * @return         the new length in bytes of the zipped file
   */
  public long gzipFiles(Vector source)
  {
    final String methodName = className_ + ": gzipFiles(Vector)";
    logger_.debug("Entering " + methodName);
    long retVal = 0L;

    if (source != null)
    {
      File[] tmpArray = new File[source.size()];
      for (int i = 0; i < source.size(); i++)
      {
        tmpArray[i] = new File((String) source.elementAt(i));
      }
      retVal += gzipFiles(tmpArray);
    }

    logger_.debug("Exiting " + methodName);
    return retVal;
  }


  /**
   *  Encapsulates the bzip2ping of file(s) individually in place. THIS DOES NOT
   *  collect them together into an archive. It simply compresses the files into
   *  a *.bz2 file in the same dir as the source.
   *
   * @param  source  The filenames to include in the zipped file.
   * @return         the new length in bytes of the zipped file
   */
  public long bzip2Files(Vector source)
  {
    final String methodName = className_ + ": bzip2Files(Vector)";
    logger_.debug("Entering " + methodName);
    long retVal = 0L;

    if (source != null)
    {
      File[] tmpArray = new File[source.size()];
      for (int i = 0; i < source.size(); i++)
      {
        tmpArray[i] = new File((String) source.elementAt(i));
      }
      retVal += bzip2Files(tmpArray);
    }

    logger_.debug("Exiting " + methodName);
    return retVal;
  }


  /**
   *  Encapsulates the bzip2ping of 1 file/dir in place.
   *
   * @param  source  The file to GZIP.
   * @return         the new length in bytes of the zipped file
   */
  public long bzip2File(File source)
  {
    final String methodName = className_ + ": bzip2File(File)";
    logger_.debug("Entering " + methodName);
    long retVal = 0L;

    logger_.info(" BZIP2ING " + source.getAbsolutePath());
    retVal += recursiveBzip2(source);

    logger_.debug("Exiting " + methodName);
    return retVal;
  }


  /**
   *  Encapsulates the bzip2ping of file(s) individually in place. THIS DOES NOT
   *  collect them together into an archive. It simply compresses the files into
   *  a *.bz2 file in the same dir as the source.
   *
   * @param  source  The files to include in the zipped file.
   * @return         the new length in bytes of the zipped file
   */
  public long bzip2Files(File[] source)
  {
    final String methodName = className_ + ": bzip2Files(File[])";
    logger_.debug("Entering " + methodName);
    long retVal = 0L;

    for (int i = 0; i < source.length; i++)
    {
      retVal += bzip2File(new File(source[i].getAbsolutePath().trim()));
    }

    logger_.debug("Exiting " + methodName);
    return retVal;
  }


  /**
   *  Encapsulates the zipping of an individual file into the specified
   *  destination file.
   *
   * @param  source       The files to include in the zipped file.
   * @param  destination  The destination zip file location.
   */
  public void zipFile(File source, File destination)
  {
    final String methodName = className_ + ": zipFile(File, File)";
    logger_.debug("Entering " + methodName);

    File[] tmpArray = new File[1];
    tmpArray[0] = source;
    if (zos_ != null)
    {
      try
      {
        zos_.close();
      }
      catch (java.io.IOException ioe)
      {
      }
      zipfile_ = null;
    }
    archivefilenameCounter_ = 0;
    zipFiles(tmpArray, destination);

    logger_.debug("Exiting " + methodName);
  }


  /**
   *  Encapsulates the zipping of file(s) individually into the class
   *  zippedOutputLocation_. THIS DOES NOT collect them together into an
   *  archive. It simply compresses the files into a *.zip file in the
   *  zippedOutputLocation_ dir.
   *
   * @param  source  The files to include in the zipped file.
   */
  public void zipFiles(File[] source)
  {
    final String methodName = className_ + ": zipFiles(File[])";
    logger_.debug("Entering " + methodName);

    if (source != null)
    {
      File tmpFile = null;
      File outZip = null;
      StringBuffer outLocation = new StringBuffer();
      String fileSep = File.separator;
      String foPath = null;
      for (int i = 0; i < source.length; i++)
      {
        tmpFile = source[i];
        if (!tmpFile.isDirectory())
        {
          foPath = tmpFile.getAbsolutePath().trim();
          if (zippedOutputLocation_ == null)
          {
            zippedOutputLocation_ = "";
          }
          // use the spec'd location
          outLocation = new StringBuffer(zippedOutputLocation_);
          if (!zippedOutputLocation_.endsWith(fileSep) &&
              !foPath.startsWith(fileSep))
          {
            outLocation.append(fileSep);
          }
          outLocation.append(foPath);
          outLocation.append(".zip");
          logger_.info("Zipping " + foPath);
          outZip = new File(outLocation.toString());
          //ensureFolderExists(outZip.getParentFile());
          zipFile(tmpFile, outZip);
          tmpFile = null;
          outLocation = null;
        }
        else
        {
          zipFiles(tmpFile.listFiles());
        }
      }
    }

    logger_.debug("Exiting " + methodName);
  }


  /**
   *  Encapsulates the zipping of 1 file individually in place. THIS DOES NOT
   *  collect them together into an archive. It simply compresses the files into
   *  a *.zip file in the same dir as the source.
   *
   * @param  source  The files to include in the zipped file.
   */
  public void zipFile(File source)
  {
    final String methodName = className_ + ": zipFiles(File)";
    logger_.debug("Entering " + methodName);

    File[] tmpArray = new File[1];
    tmpArray[0] = source;
    if (zos_ != null)
    {
      try
      {
        zos_.close();
      }
      catch (java.io.IOException ioe)
      {
      }
      zipfile_ = null;
    }
    archivefilenameCounter_ = 0;
    zipFiles(tmpArray, new File(source.getAbsolutePath().trim() + ".zip"));

    logger_.debug("Exiting " + methodName);
  }


  /**
   *  Encapsulates the zipping of file(s) into a zip archive.
   *
   * @param  source       A Vector of filenames to include in the zipped file.
   * @param  destination  The resultant zipped archive.
   */
  public void zipFiles(Vector source, File destination)
  {
    final String methodName = className_ + ": zipFiles(Vector, File)";
    logger_.debug("Entering " + methodName);

    if (source != null)
    {
      File[] tmpArray = new File[source.size()];
      for (int i = 0; i < source.size(); i++)
      {
        tmpArray[i] = new File((String) source.elementAt(i));
      }
      zipFiles(tmpArray, destination);
    }

    logger_.debug("Exiting " + methodName);
  }


  /**
   *  Encapsulates the zipping of file(s) into a zip archive.
   *
   * @param  source       The files to include in the zipped file.
   * @param  destination  The resultant zipped archive.
   */
  public void zipFiles(File[] source, File destination)
  {
    final String methodName = className_ + ": zipFiles(File[], File)";
    logger_.debug("Entering " + methodName);

    boolean initOkay = false;
    try
    {
      long startTime = (new Date()).getTime();
      String destFilename = destination.getAbsolutePath();
      if (!destFilename.toLowerCase()
          .substring(destFilename.length() - 4,
          destFilename.length())
          .equalsIgnoreCase(".zip"))
      {
        destFilename += ".zip";
      }
      destination = new File(destFilename);
      zipfile_ = null;
      initOkay = initZipOutputStream(destination);
      //logger_.warn("Starting The ZIP Archive: " + destFilename);
      // String srcFileNames[] = {source.getName()};
      //File arrFile[] = {source};
      if (initOkay && source.length > 0)
      {
        for (int i = 0; i < source.length; i++)
        {
          recursiveZip(source[i]);
        }
        //Calling recursive function
        zos_.close();

        long duration = ((new Date()).getTime() - startTime) / 1000L;
        long minutes = duration / 60L;
        long seconds = duration - (60L * minutes);
        logger_.info(destination.getName() +
            " file created successfully with "+source.length + " files.");
        logger_.info("Time to complete: " + minutes + ":" + seconds);
      }
      else
      {
        logger_.error("There is no file in the specified source.");
      }
    }
    catch (java.util.zip.ZipException ze)
    {
      logger_.error("Exception occured in zipping file. Details :\n" +
          ze.getMessage());
    }
    catch (java.io.FileNotFoundException fnfe)
    {
      logger_.error("File is missing. Details :" + fnfe.getMessage());
    }
    catch (java.io.IOException ioe)
    {
      logger_.error("Input / Output problem. Details :\n" + ioe.getMessage());
    }

    logger_.debug("Exiting " + methodName);
  }


  /**
   *  Encapsulates the taring of file(s) into a TAR archive.
   *
   * @param  source     A Vector of the filenames to include in the tar file.
   * @param  outputTar  The tar filename.
   * @return            Description of the Return Value
   */
  public boolean tarFiles(Vector source, String outputTar)
  {
    final String methodName = className_ + ": tarFiles(Vector, String)";
    logger_.debug("Entering " + methodName);

    boolean retVal = false;
    if (source != null)
    {
      String[] tmpArray = new String[source.size()];
      for (int i = 0; i < source.size(); i++)
      {
        tmpArray[i] = (String) (source.elementAt(i));
      }
      tarFiles(tmpArray, outputTar);
    }
    logger_.debug("Exiting " + methodName);
    return retVal;
  }


  /**
   *  Encapsulates the taring of the compressed Files dir into a TAR archive.
   *
   * @param  outputTar  The tar filename.
   * @return            Description of the Return Value
   */
  public boolean tarCompressedFilesDir(String outputTar)
  {
    final String methodName = className_ + ": tarCompressedFilesDir(String)";
    logger_.debug("Entering " + methodName);
    boolean retVal = false;

    //int startSpot = zippedOutputLocation_.length();
    Vector tmpVector = new Vector();
    for (int j = 0; j < compressedFilenames_.size(); j++)
    {
      tmpVector.add(((String) compressedFilenames_.elementAt(j)));//.substring(startSpot));
    }
    tarFiles(tmpVector, outputTar);

    logger_.debug("Exiting " + methodName);
    return retVal;
  }


  /**
   *  Encapsulates the taring of file(s) into a TAR archive.
   *
   * @param  source     The files to include in the tar file.
   * @param  outputTar  The tar filename.
   * @return            Description of the Return Value
   */
  public boolean tarFiles(String[] source, String outputTar)
  {
    final String methodName = className_ + ": tarFiles(String[], String)";
    logger_.debug("Entering " + methodName);

    boolean retVal = false;
    if (source != null)
    {
      File tmpFile = null;
      try
      {
        logger_.debug("Tar Archive will be: " + outputTar);
        TarArchive tarArchive = new TarArchive(new FileOutputStream(outputTar));

        String parentDir = "";
        TarEntry tarEntry = null;
        String relPath = "";
        String absPath = "";
        int tmpDirOffset = 0;
        for (int i = 0; i < source.length; i++)
        {
          absPath = source[i];
          logger_.debug("  - preparing to tar: " + absPath);
          relPath = Util.removeParentRelativeReference(
              Util.absoluteToPwdRelativePath(source[i]));
          absPath = Util.removeParentRelativeReference(
              source[i]);
          tmpFile = new File(absPath);
          logger_.debug("  - preparing to tar: " + absPath);
          parentDir = tmpFile.getParent();
          if (parentDir != null)
          {
            tmpFile = new File(parentDir);
            logger_.debug("  - ...Adding Directory " + parentDir);
            tarEntry = new TarEntry(tmpFile);
            tmpDirOffset = parentDir.indexOf(tmpDirName_);
            if (tmpDirOffset != -1)
            {
              parentDir = parentDir.substring(
                  tmpDirOffset + tmpDirName_.length() + 1);
            }
            logger_.debug("   ......As " + parentDir);
            tarEntry.setName(parentDir);
            tarArchive.writeEntry(tarEntry, false);
          }
          logger_.info("  ...Adding " + absPath);
          tmpFile = new File(absPath);
          tarEntry = new TarEntry(tmpFile);
          tmpDirOffset = absPath.indexOf(tmpDirName_);
          if (tmpDirOffset != -1)
          {
            relPath = absPath.substring(
                tmpDirOffset + tmpDirName_.length() + 1);
          }
          tarEntry.setName(relPath);
          logger_.debug("  - ...As " + relPath);
          tarArchive.writeEntry(tarEntry, false);
          tmpFile = null;
        }
        tarArchive.closeArchive();
        retVal = true;
      }
      catch (java.lang.NullPointerException npe)
      {
        logger_.error("Internal MultiZip Error. Details :", npe);

      }
      catch (java.io.FileNotFoundException fnfe)
      {
        logger_.error("Cannot init File:" + outputTar +
            ". \nDetails :\n" + fnfe.getMessage());
      }
      catch (java.io.IOException ioEx)
      {
        logger_.error("Cannot complete the tar File:" + outputTar +
            ". \nDetails :", ioEx);

      }
    }

    logger_.debug("Exiting " + methodName);
    return retVal;
  }


  /**
   *  Compresses and saves the passed file parameter to a gzip file.
   *
   * @param  src              The File to gzip up - it can be a dir.
   * @return                  the new length in bytes of the zipped file
   * @exception  IOException  Description of the Exception
   */
  public long writeToGZip(File src)
    throws IOException
  {
    final String methodName = className_ + ": writeToGZip(File)";
    logger_.debug("Entering " + methodName);
    long retVal = 0L;

    retVal = writeToGZip(src, src.getAbsolutePath().trim() + ".gz");

    logger_.debug("Exiting " + methodName);
    return retVal;
  }


  /**
   *  Compresses and saves the passed file parameter to a gzip file.
   *
   * @param  src              The File to gzip up - it can be a dir.
   * @param  dest             The location of the gzip'd file.
   * @return                  the new length in bytes of the zipped file
   * @exception  IOException  Description of the Exception
   */
  public long writeToGZip(File src, String dest)
    throws IOException
  {
    final String methodName = className_ + ": writeToGZip(File, String)";
    logger_.debug("Entering " + methodName);
    long retVal = 0L;

    // This function writes the data in to GZipoutput Stream.
    byte b[] = new byte[512];
    if (!src.isDirectory())
    {
      logger_.debug("Attempting to Init the GZip Out Stream: " + dest);
      File destFile = new File(dest);
      if (destFile != null && initGZIPOutputStream(destFile))
      {
        int len = 0;
        FileInputStream is = new FileInputStream(src);
        while ((len = is.read(b)) != -1)
        {
          ((GZIPOutputStream) zos_).write(b, 0, len);
        }
        is.close();
        logger_.debug("Completed GZIP : " + dest);
        retVal = destFile.length();
        compressedFilenames_.add(dest);
        is = null;
        ((GZIPOutputStream) zos_).close();
        zos_ = null;
      }
    }

    logger_.debug("Exiting " + methodName);
    return retVal;
  }


  /**
   *  Compresses and saves the passed file parameter to a zip file.
   *
   * @param  src                        The File to zip up - it can be a dir.
   * @exception  DataFormatException    Description of the Exception
   * @exception  ZipException           Description of the Exception
   * @exception  FileNotFoundException  Description of the Exception
   * @exception  IOException            Description of the Exception
   */
  public void writeToZip(File src)
    throws DataFormatException, ZipException, FileNotFoundException, IOException
  {
    final String methodName = className_ + ": writeToZip(File)";
    logger_.debug("Entering " + methodName);

    // This function write s the data in to Zipoutput Stream.
    byte b[] = new byte[512];
    // clean off the drive letter and '/'
    String entry = src.toString().trim();
    if (entry.startsWith(":" + File.separator, 1))
    {
      entry = src.toString().substring(3);
    }
    else if (entry.startsWith(File.separator))
    {
      entry = src.toString().substring(1);
    }

    // Make sure dirs hava a trailing separator char so it is represented
    // in the Zip correctly
    if (src.isDirectory() && !entry.endsWith(File.separator))
    {
      entry += File.separator;
    }

    entry = Util.tokenReplace(entry, "\\", "/");
    ZipEntry ze = new ZipEntry(entry);
    ((ZipOutputStream) zos_).putNextEntry(ze);
    if (!src.isDirectory())
    {
      int len = 0;
      FileInputStream is = new FileInputStream(src);
      while ((len = is.read(b)) != -1)
      {
        ((ZipOutputStream) zos_).write(b, 0, len);
      }
      compressedFilenames_.add(zipfile_.getAbsolutePath());
      is = null;
    }

    // Provide some user feedback
    if (!src.isDirectory())
    {
      logger_.info(" Adding " + entry);
    }
    else
    {
      logger_.info(" Added directory " + entry);
    }
    ((ZipOutputStream) zos_).closeEntry();

    logger_.debug("Exiting " + methodName);
  }


  /**
   *  Wrapper method to accept a dir or individual file in the passed in File
   *  object AND then calls the method that writes the passed file/dir to this
   *  MultiZip instances zip output stream. This is a recursive function. If the
   *  passed File object is a file then it calls the function to write to zip
   *  output stream. If it is a directory it gets the list of file objects in
   *  the child directory and recurses on them.
   *
   * @param  fo  The File object to zip up (can be an actual file or dir).
   * @return     the new length in bytes of the zipped file
   */
  public long recursiveGZip(File fo)
  {
    final String methodName = className_ + ": recursiveGZip(File)";
    logger_.debug("Entering " + methodName);
    long retVal = 0L;

    if (!fo.isDirectory())
    {
      //logger_.debug("  looking at file:" + fo.getPath());
      try
      {
        if (!excludedFile(fo))
        {
          StringBuffer outLocation = new StringBuffer();
          if (zippedOutputLocation_ != null)
          {
            // use the spec'd location
            String fileSep = System.getProperty("file.separator");
            String foPath = fo.getAbsolutePath().trim().substring(42);
            outLocation.append(zippedOutputLocation_);
            if (!zippedOutputLocation_.endsWith(fileSep) &&
                !foPath.startsWith(fileSep))
            {
              outLocation.append(fileSep);
            }
            outLocation.append(foPath);
            outLocation.append(".gz");
            logger_.info("Gziping " + foPath + " --> " + outLocation.toString());
            retVal = writeToGZip(fo, outLocation.toString());
          }
          else
          {
            // zip it in place
            logger_.info("Gziping " + fo.getAbsolutePath().trim());
            retVal = writeToGZip(fo);
          }
        }
        else
        {
          logger_.info("Excluding File:" + fo.getAbsolutePath());
        }
      }
      catch (IOException ioEx)
      {
        logger_.warn("File is missing (Zipping will continue):\n" +
            ioEx.getMessage());
      }
    }
    else
    {
      logger_.debug("  looking at DIRECTORY:" + fo.getPath());
      // recurse the Directory
      if (excludedFile(fo))
      {
        logger_.info("Excluding Directory:" + fo.getAbsolutePath());
      }
      else
      {
        logger_.info("Recursing " + fo.getPath());
        String srcFileNames[] = fo.list();
        for (int i = 0; i < srcFileNames.length; i++)
        {
          retVal += recursiveGZip(new File(fo.getAbsolutePath() + File.separator +
              srcFileNames[i]));
        }
      }
    }

    logger_.debug("Exiting " + methodName);
    return retVal;
  }


  /**
   *  Wrapper method to accept a dir or individual file in the passed in File
   *  object AND then calls the method that writes the passed file/dir to this
   *  MultiZip instances zip output stream. This is a recursive function. If the
   *  passed File object is a file then it calls the function to write to zip
   *  output stream. If it is a directory it gets the list of file objects in
   *  the child directory and recurses on them.
   *
   * @param  fo  The File object to zip up (can be an actual file or dir).
   * @return     the new length in bytes of the zipped file
   */
  public long recursiveBzip2(File fo)
  {
    final String methodName = className_ + ": recursiveBzip2(File)";
    logger_.debug("Entering " + methodName);
    long retVal = 0L;

    String fullFilename = fo.getAbsolutePath().trim();
    if (!fo.isDirectory())
    {
      //logger_.info("Bzip2ing "+fullFilename);
      if (!excludedFile(fo))
      {
        StringBuffer outLocation = new StringBuffer();
        if (zippedOutputLocation_ != null)
        {
          // use the spec'd location
          String fileSep = System.getProperty("file.separator");
          outLocation.append(zippedOutputLocation_);
          if (!zippedOutputLocation_.endsWith(fileSep) &&
              !fullFilename.startsWith(fileSep))
          {
            outLocation.append(fileSep);
          }
          outLocation.append(fullFilename);
          outLocation.append(".bz2");
          logger_.info("Bzip2ing " + fullFilename);
          logger_.info("  to  " + outLocation.toString());
          File outFile = new File(outLocation.toString());
          Util.ensureFolderExists(outFile.getParentFile());
          try
          {
            BZip.compress(fo, outFile, 9);
            compressedFilenames_.add(outLocation.toString());
            retVal += outFile.length();
          }
          catch (java.lang.ArithmeticException mathEx)
          {
            logger_.error("BZip2 ERROR: " + fullFilename);
            logger_.error(mathEx.getMessage());
            errorFiles_.add(fullFilename);
          }
        }
        else
        {
          // zip it in place
          //logger_.info("Bzip2ing "+fullFilename);
          File outFile = new File(fullFilename + ".bz2");
          Util.ensureFolderExists(outFile.getParentFile());
          try
          {
            BZip.compress(fo, outFile, 9);
            compressedFilenames_.add(fullFilename + ".bz2");
            retVal += outFile.length();
          }
          catch (java.lang.ArithmeticException mathEx)
          {
            logger_.error("BZip2 ERROR: " + fullFilename);
            logger_.error(mathEx.getMessage());
          }
        }
      }
      else
      {
        logger_.info("Excluding File:" + fullFilename);
      }
    }
    else
    {
      if (excludedFile(fo))
      {
        logger_.info("Excluding Directory:" + fullFilename);
      }
      else
      {
        logger_.info("Recursing " + fo.getPath());
        String srcFileNames[] = fo.list();
        for (int i = 0; i < srcFileNames.length; i++)
        {
          retVal += recursiveBzip2(new File(fullFilename + File.separator +
              srcFileNames[i]));
        }
      }
    }

    logger_.debug("Exiting " + methodName);
    return retVal;
  }


  /**
   *  Wrapper method to accept a dir or individual file in the passed in File
   *  object AND then calls the method that writes the passed file/dir to this
   *  MultiZip instances zip output stream. This is a recursive function. If the
   *  passed File object is a file then it calls the function to write to zip
   *  output stream. If it is a directory it gets the list of file objects in
   *  the child directory and recurses on them.
   *
   * @param  fo  The File object to zip up (can be an actual file or dir).
   */
  public void recursiveZip(File fo)
  {
    final String methodName = className_ + ": recursiveZip(File)";
    logger_.debug("Entering " + methodName);

    try
    {
      // First check the Zip file size to see if it has reached the user
      // specified max size.
      if (zipfile_.length() + fo.length() > maxArchiveSize_)
      {
        logger_.info("Max Zip File Size Reached! " +
            "Incrementing ZipFile Name.");
        // reinit the stream to increment the name counter
        initZipOutputStream(zipfile_);
      }

      try
      {
        if (!excludedFile(fo))
        {
          StringBuffer outLocation = new StringBuffer();
          if (zippedOutputLocation_ != null)
          {
            // use the spec'd location
            String fileSep = System.getProperty("file.separator");
            String foPath = fo.getAbsolutePath().trim();
            outLocation.append(zippedOutputLocation_);
            if (!zippedOutputLocation_.endsWith(fileSep) &&
                !foPath.startsWith(fileSep))
            {
              outLocation.append(fileSep);
            }
            outLocation.append(foPath);
            outLocation.append(".zip");
            //logger_.info("Zipping "+foPath);
            writeToZip(fo);
          }
          else
          {
            // zip it in place
            String foPath = fo.getAbsolutePath().trim();
            outLocation.append(foPath);
            outLocation.append(".zip");
            //logger_.info("Zipping "+ foPath);
            initZipOutputStream(new File(outLocation.toString()));
            writeToZip(fo);
          }
        }
        else
        {
          logger_.info("Excluding File:" + fo.getAbsolutePath());
        }
      }
      catch (java.io.FileNotFoundException fnfe)
      {
        logger_.error("File is missing (Zipping will continue):\n" +
            fnfe.getMessage());
      }

      // Directory entries must also be included (unless we want a FLAT archive)
      if (fo.isDirectory())
      {
        logger_.info("Recursing " + fo.getPath());
        String srcFileNames[] = fo.list();
        for (int i = 0; i < srcFileNames.length; i++)
        {
          recursiveZip(new File(fo.getPath() + File.separator +
              srcFileNames[i]));
        }
      }
    }
    catch (java.util.zip.DataFormatException dfe)
    {
      logger_.error("Input data is not in proper format. Details :\n" +
          dfe.getMessage());
    }
    catch (java.util.zip.ZipException ze)
    {
      logger_.error("Exception occured in zipping file. Details :\n" +
          ze.getMessage());
    }
    catch (java.io.IOException ioe)
    {
      logger_.error("Input / Output problem. Details :\n" +
          ioe.getMessage());
    }

    logger_.debug("Exiting " + methodName);
  }


  /**
   *  Description of the Method
   *
   * @param  fileToCheck  Description of the Parameter
   * @return              Description of the Return Value
   */
  protected boolean excludedFile(File fileToCheck)
  {
    final String methodName = className_ + ": excludedFile(File)";
    logger_.debug("Entering " + methodName);

    boolean retVal = false;

    retVal = excludedFile(fileToCheck.getName());

    logger_.debug("Exiting " + methodName);
    return retVal;
  }


  /**
   *  Description of the Method
   *
   * @param  filename  Description of the Parameter
   * @return           Description of the Return Value
   */
  protected boolean excludedFile(String filename)
  {
    final String methodName = className_ + ": excludedFile(String)";
    logger_.debug("Entering " + methodName);

    boolean retVal = false;

    if (filename != null)
    {
      for (int i = 0; i < defaultExcludes_.length; i++)
      {
        if (filename.toLowerCase().endsWith(defaultExcludes_[i].toLowerCase()))
        {
          retVal = true;
          break;
        }
      }
    }

    logger_.debug("Exiting " + methodName);
    return retVal;
  }


  /**
   *  Wraps the insantaition of a GZIPOutputStream.
   *
   * @param  fos              Description of the Parameter
   * @return                  Description of the Return Value
   * @exception  IOException  Description of the Exception
   */
  protected GZIPOutputStream createGZIPOutputStream(FileOutputStream fos)
    throws IOException
  {
    final String methodName = className_ +
        ": createGZIPOutputStream(FileOutputStream)";
    logger_.debug("Entering " + methodName);

    GZIPOutputStream retVal = null;
    retVal = new GZIPOutputStream(fos);

    logger_.debug("Exiting " + methodName);
    return retVal;
  }


  /**
   *  Wraps the insantaition of a ZipOutputStream.
   *
   * @param  fos  Description of the Parameter
   * @return      Description of the Return Value
   */
  protected ZipOutputStream createZipOutputStream(FileOutputStream fos)
  {
    final String methodName = className_ +
        ": createZipOutputStream(FileOutputStream)";
    logger_.debug("Entering " + methodName);

    logger_.debug("Exiting " + methodName);
    return new ZipOutputStream(fos);
  }


  /**
   *  Creates a GZip type archive output stream and assigns it to the class
   *  zipfile_ var. This method automatically
   *
   * @param  destZipFile  the base Zip filename (in File format) to create
   * @return              Success or failure
   */
  protected boolean initGZIPOutputStream(File destZipFile)
  {
    final String methodName = className_ + ": initGZIPOutputStream(File)";
    logger_.debug("Entering " + methodName);

    boolean retVal = (destZipFile != null);
    // avoid nullPEx

    if (retVal)
    {
      // Attempt to open the stream
      try
      {
        zipfile_ = new File(destZipFile.getAbsolutePath());
        logger_.debug("Creating Folder: " +
            zipfile_.getParent());
        Util.ensureFolderExists(zipfile_.getParentFile());
        logger_.debug("Creating FileOutputStream Object for " +
            zipfile_.getAbsolutePath());

        FileOutputStream fos = new FileOutputStream(zipfile_);
        zos_ = createGZIPOutputStream(fos);
        if (zos_ == null)
        {
          retVal = false;
        }
        zipfile_ = null;
      }
      catch (java.lang.NullPointerException npe)
      {
        logger_.error("Internal MultiZip Error. Details :\n" +
            npe.getMessage());
        retVal = false;
      }
      catch (java.io.FileNotFoundException fnfe)
      {
        logger_.error("Cannot init File:" + destZipFile.getAbsolutePath() +
            ". \nDetails :\n" + fnfe.getMessage());
        //fnfe.printStackTrace();
        //System.exit(2);
        retVal = false;
      }
      catch (java.io.IOException ioEx)
      {
        logger_.error("Cannot init File:" + destZipFile.getAbsolutePath() +
            ". \nDetails :\n" + ioEx.getMessage());
        retVal = false;
      }
    }

    logger_.debug("Exiting " + methodName);
    return retVal;
  }


  /**
   *  Creates a Zip type archive output stream and assigns it to the class
   *  zipfile_ var. This method automatically increments the filename if the zip
   *  archive is larger than the max archive size set in this class. It also
   *  will ensure ther output location exists.
   *
   * @param  destZipFile  the base Zip filename (in File format) to create
   * @return              Success or failure
   */
  protected boolean initZipOutputStream(File destZipFile)
  {
    final String methodName = className_ + ": initZipOutputStream(File)";
    logger_.debug("Entering " + methodName);

    boolean retVal = (destZipFile != null);
    // avoid nullPEx

    if (retVal)
    {
      String newName = destZipFile.getAbsolutePath().trim();
      int endOffset = 5;

      if (archivefilenameCounter_ > 0)
      {
        if (archivefilenameCounter_ == 1)
        {
          endOffset = 4;
        }
        newName = newName.substring(0, newName.length() - endOffset) +
            archivefilenameCounter_ + ".zip";
        try
        {
          if (zos_ != null)
          {
            zos_.close();
          }
        }
        catch (java.io.IOException ioe)
        {
          logger_.error("Input/Output problem attempting to close the " +
              "zipfile " + destZipFile.getAbsolutePath().trim() +
              ". \nDetails :\n" + ioe.getMessage());
          retVal = false;
        }
      }

      // Attempt to open the stream
      try
      {
        archivefilenameCounter_++;
        zipfile_ = new File(newName);

        logger_.debug("Creating Folder: " +
            zipfile_.getParent());
        Util.ensureFolderExists(zipfile_.getParentFile());
        logger_.debug("Creating FileOutputStream Object for " +
            zipfile_);

        FileOutputStream fos = new FileOutputStream(zipfile_);
        zos_ = createZipOutputStream(fos);
        if (zos_ == null)
        {
          retVal = false;
        }
        else
        {
          ((ZipOutputStream) zos_).setLevel(getCompressionLevel());
        }
        //zipfile_ = null;
      }
      catch (java.lang.NullPointerException npe)
      {
        logger_.error("Internal MultiZip Error. Details :\n" + npe.getMessage());
        retVal = false;
      }
      catch (java.io.FileNotFoundException fnfe)
      {
        logger_.error("Cannot init File:" + newName + ". \nDetails :\n" +
            fnfe.getMessage());
        retVal = false;
      }
    }

    logger_.debug("Exiting " + methodName);
    return retVal;
  }


  /**
   *  Using the class output_, compressionType_ and archiveType_, this method
   *  validates that a valid and writable output location/file was specified.
   *
   * @return    boolean valid or not
   */
  private boolean validateOutputLocation()
  {
    final String methodName =
        className_ + ": validateOutputLocation()";
    logger_.debug("Entering " + methodName);
    boolean retVal = true;

    if (archiveType_ == (DIR_ARCHIVE))
    {
      logger_.debug("Validating the DIR Archive:: " + output_);
      if (output_ != null && !output_.equals(""))
      {
        // first confirm we ar dealing with an absolute path
        String fileSep = System.getProperty("file.separator");
        if (!(output_.startsWith(fileSep) ||
            output_.substring(1).startsWith(":")))
        {
          //  it is a relative path so... construct the absolute path
          logger_.info("Specified output path appears to be a relative path.");
          String userDir = System.getProperty("user.dir");
          StringBuffer newOutput = new StringBuffer(userDir);
          if (!userDir.endsWith(fileSep))
          {
            newOutput.append(fileSep);
          }
          newOutput.append(output_);
          output_ = newOutput.toString();
          logger_.info("   ... using the following Absolute path: " + output_);
        }
        // check that output_ is a dir and is writable
        File outFile = new File(output_);
        if (!outFile.isDirectory())
        {
          retVal = false;
        }
        else
        {
          // it is a dir so do a test write into it.
          try
          {
            logger_.debug("Testing the output dir: " + output_);
            File tmpFile = File.createTempFile("MZP", "", outFile);
            tmpFile.delete();
            tmpFile = null;

            File tmpOutputFile = new File(outFile.getParent() + fileSep + tmpDirName_);
            //tmpOutputFile.deleteOnExit();
            Util.ensureFolderExists(tmpOutputFile);
            logger_.debug("DIR Archive will get its comp files from the dir:");
            zippedOutputLocation_ = tmpOutputFile.getAbsolutePath();
            logger_.debug(zippedOutputLocation_);
            currArchiveSize_ = Util.dirSize(outFile.getAbsolutePath(), true);
          }
          catch (Exception ex)
          {
            logger_.fatal("Cannot write into specified output directory.");
            logger_.fatal(ex.getMessage());
            retVal = false;
          }
        }
      }
      else
      {
        // write to the inputfile location
        zippedOutputLocation_ = null;
      }
    }
    else if (archiveType_ == (TAR_ARCHIVE))
    {
      if (output_ != null && !output_.equals(""))
      {
        // first confirm we are dealing with an absolute path
        String fileSep = System.getProperty("file.separator");
        if (!(output_.startsWith(fileSep) ||
            output_.substring(1).startsWith(":")))
        {
          //  it is a relative path so... construct the absolute path
          logger_.info("Specified output path appears to be a relative path.");
          String userDir = System.getProperty("user.dir");
          StringBuffer newOutput = new StringBuffer(userDir);
          if (!userDir.endsWith(fileSep))
          {
            newOutput.append(fileSep);
          }
          newOutput.append(output_);
          output_ = newOutput.toString();
          logger_.info("   ... using the following Absolute path: " + output_);
        }

        // check that output_ is a NOT A DIR and it is in a writable dir
        File outFile = new File(output_);
        if (outFile.isDirectory())
        {
          retVal = false;
        }
        else
        {
          if (!output_.endsWith(".tar"))
          {
            output_ += ".tar";
          }
          try
          {
            File tmpOutputFile = new File(outFile.getParent() + fileSep + tmpDirName_);
            //tmpOutputFile.deleteOnExit();
            Util.ensureFolderExists(tmpOutputFile);
            logger_.debug("Tar Archive will get its comp files from the dir:");
            zippedOutputLocation_ = tmpOutputFile.getAbsolutePath();
            logger_.debug(zippedOutputLocation_);
          }
          catch (Exception ex)
          {
            logger_.error("Cannot create a tmp dir in specified output dir.");
            logger_.error(ex.getMessage());
            zippedOutputLocation_ = null;
          }
        }
      }
      else
      {
        //ERROR Need a tar file location
        retVal = false;
      }
    }
    else if (archiveType_ == (ZIP_ARCHIVE))
    {
      if (output_ != null && !output_.equals(""))
      {
        // check that output_ is a NOT A DIR and it is in a writable dir
        File outFile = new File(output_);
        logger_.debug("Testing the output filename: " + output_);
        if (outFile.isDirectory())// || !outFile.canWrite())
        {
          logger_.debug(output_ +" is unusable.");
          retVal = false;
        }
        else
        {
          if (!output_.endsWith(".zip"))
          {
            output_ += ".zip";
          }
          logger_.debug(output_ +" is usable!");
          retVal = true;
          zippedOutputLocation_ = null;
        }
      }
      else
      {
        //ERROR Need a zip file location
        logger_.debug("An output archive location must be specified.");
        retVal = false;
      }
    }
    else if (archiveType_ == (TGZ_ARCHIVE))
    {
      if (output_ != null && !output_.equals(""))
      {
        // check that output_ is a NOT A DIR and it is in a writable dir
        File outFile = new File(output_);
        if (outFile.isDirectory() || !outFile.canWrite())
        {
          retVal = false;
        }
        else
        {
          if (!output_.endsWith(".tar"))
          {
            output_ += ".tar";
            zippedOutputLocation_ = null;
          }
        }
      }
      else
      {
        //ERROR Need a file location
        retVal = false;
      }
    }

    logger_.debug("Exiting " + methodName);
    return retVal;
  }


  /**
   *  Runs through the input Vector and recurses any dirs into the contained
   *  names.
   *
   * @param  input  Description of the Parameter
   * @return        The resultant/parsed Vector of Filnames.
   */
  private Vector recurseInputIntoFiles(Vector input)
  {
    final String methodName = className_ + ": recurseInputIntoFiles()";
    logger_.debug("Entering " + methodName);

    Vector retVal = new Vector();
    Vector tmpVector = null;
    String[] tmpArray = null;
    String currElement;
    File currFile = null;
    if (input != null)
    {
      String fileSep = File.separator;
      String userDir = System.getProperty("user.dir");
      StringBuffer newOutput;
      if (!userDir.endsWith(fileSep))
      {
        userDir += fileSep;
      }
      for (int i = 0; i < input.size(); i++)
      {
        currElement = ((String) input.elementAt(i)).trim();

        // first confirm we are dealing with an absolute path
        if (!(currElement.startsWith(fileSep) ||
            currElement.substring(1).startsWith(":")))
        {
          //  it is a relative path so... construct the absolute path
          logger_.debug("Specified inputFile path appears to be a relative path.");
          newOutput = new StringBuffer(userDir);
          newOutput.append(currElement);
          currElement = newOutput.toString();
        }

        currFile = new File(currElement);
        if (currFile != null)
        {
          logger_.debug("    Working on: " + currElement);
          if (!currFile.isDirectory())
          {
            retVal.add(currElement);
          }
          else
          {
            logger_.debug("    ...Found a DIR");
            tmpVector = new Vector();
            tmpArray = currFile.list();
            for (int j = 0; j < tmpArray.length; j++)
            {
              logger_.debug("    ...... " + currElement + fileSep + tmpArray[j]);
              if (!excludedFile(tmpArray[j]))
              {
                tmpVector.add(currElement + fileSep + tmpArray[j]);
              }
            }
            retVal.addAll(recurseInputIntoFiles(tmpVector));
          }
        }
      }
    }

    logger_.debug("Exiting " + methodName);
    return retVal;
  }


  /**
   *  Examines the users Compression and Archive choices and looks for special
   *  combos that require an adjustment in some settings.
   *
   * @return    Description of the Return Value
   */
  private boolean oneStepArchive()
  {
    final String methodName = className_ + ": oneStepArchive()";
    logger_.debug("Entering " + methodName);

    boolean retVal = false;
    // TGZ - can be done in one step
    if (getArchiveType() == TGZ_ARCHIVE)
    {
      setCompressionType(NO_COMPRESSION);
      retVal = true;
    }
    // Zip / Zip - can be done in one step
    else if (getCompressionType() == ZIP_COMPRESSION &&
        getArchiveType() == ZIP_ARCHIVE)
    {
      retVal = true;
    }
    // NONE / Zip - can be done in one step
    else if (getCompressionType() == NO_COMPRESSION &&
        getArchiveType() == ZIP_ARCHIVE)
    {
      setCompressionLevel(0);
      retVal = true;
    }
    // NONE / DIR - can be done in one step
    else if (getCompressionType() == NO_COMPRESSION &&
        getArchiveType() == DIR_ARCHIVE)
    {
      retVal = true;
    }
    // NONE / Dir,TAR,NONE - can be done in one step
    else if (getCompressionType() == NO_COMPRESSION)
    {
      retVal = true;
    }

    logger_.debug("Exiting " + methodName);
    return retVal;
  }


  /**
   *  Examines the users Compression and Archive choices and looks for special
   *  combos that require an adjustment in some settings.
   *
   * @return    Description of the Return Value
   */
  private boolean oneStepCompress()
  {
    final String methodName = className_ + ": oneStepCompress()";
    logger_.debug("Entering " + methodName);

    boolean retVal = false;

    // Zip,Gzip,Bzip2 / DIR - can be done in one step
    if (getArchiveType() == DIR_ARCHIVE &&
        getCompressionType() != NO_COMPRESSION)
    {
      retVal = true;
    }

    logger_.debug("Exiting " + methodName);
    return retVal;
  }


  /**
   *  Executes the compression of the input files..
   *
   * @return    return code
   */
  private short compressFiles()
  {
    final String methodName = className_ + ": compressFiles()";
    logger_.debug("Entering " + methodName);

    short retVal = 0;
    switch (getCompressionType())
    {
        case ZIP_COMPRESSION:
          logger_.warn("Beginning to compress files with 'ZIP'.");
          //zipFiles(recurseInputIntoFiles(input_));
          zipFiles(input_);
          break;
        case GZIP_COMPRESSION:
          logger_.warn("Beginning to compress files with 'GZIP'.");
          long gzippedSize = gzipFiles(input_);
          logger_.warn("Compressing now Complete. " + (gzippedSize / 1000L) +
              "kbytes of 'GZIP' files in ");
          logger_.warn(output_);
          break;
        case BZIP2_COMPRESSION:
          logger_.warn("Beginning to compress files with 'BZIP2'.");
          long bzippedSize = bzip2Files(input_);
          logger_.warn("Compressing now Complete. " + (bzippedSize / 1000L) +
              "kbytes of 'BZIP2' files in ");
          logger_.warn(output_);
          break;
        case NO_COMPRESSION:
          logger_.warn("NOT compressing files.");
          copyFilesToArchive();
          break;
        default:
    }

    logger_.debug("Exiting " + methodName);
    return retVal;
  }


  /**
   *  Executes the archiving of the input files.
   *
   * @return    return code
   */
  private short archiveFiles()
  {
    final String methodName = className_ + ": archiveFiles()";
    logger_.debug("Entering " + methodName);

    short retVal = 0;
    switch (getArchiveType())
    {
        case ZIP_ARCHIVE:
          logger_.warn("Beginning to Archive " + compressedFilenames_.size() +
              " files into the following 'ZIP' style archive.");
          logger_.warn(output_);
          zipFiles(compressedFilenames_, new File(output_));
          break;
        case TAR_ARCHIVE:
          logger_.warn("Beginning to Archive " + compressedFilenames_.size() +
              " files into the following 'TAR' style archive.");
          logger_.warn(output_);
          tarFiles(compressedFilenames_, output_);//tarCompressedFilesDir(output_);
          if (getCompressionType() != NO_COMPRESSION)
          {
            logger_.debug("Now removing the tmp zip dir: " + zippedOutputLocation_);
            Util.removeDir(zippedOutputLocation_);//removeCompressedFiles();
          }
          break;
        case DIR_ARCHIVE:
          logger_.warn("Beginning to Archive " + compressedFilenames_.size() +
              " files into the following directory.");
          logger_.warn(output_);
          if (getCompressionType() != NO_COMPRESSION)
          {
            moveFilesToArchive();
          }
          else
          {
            copyFilesToArchive();
          }
          break;
        case TGZ_ARCHIVE:
          logger_.warn("Beginning to Archive " + compressedFilenames_.size() +
              " files into the following 'TGZ' style archive.");
          logger_.warn(output_);
          tarFiles(compressedFilenames_, output_);
          gzipFile(new File(output_));
          String targzFilename = output_ + ".gz";
          String tgzFilename = output_.substring(0, output_.lastIndexOf(".tar")) + ".tgz";
          (new File(targzFilename)).renameTo(new File(tgzFilename));
          break;
        default:
    }

    logger_.debug("Exiting " + methodName);
    return retVal;
  }
}