BackupManager.java

/**
 * C-JDBC: Clustered JDBC.
 * Copyright (C) 2002-2005 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): Emmanuel Cecchet.
 */

package org.objectweb.cjdbc.controller.backup;

import java.io.File;
import java.io.FilenameFilter;
import java.util.ArrayList;
import java.util.Hashtable;

import org.objectweb.cjdbc.common.exceptions.BackupException;
import org.objectweb.cjdbc.common.exceptions.OctopusException;
import org.objectweb.cjdbc.common.i18n.Translate;
import org.objectweb.cjdbc.common.log.Trace;
import org.objectweb.cjdbc.common.shared.BackupListener;
import org.objectweb.cjdbc.common.util.Constants;
import org.objectweb.cjdbc.common.xml.DatabasesXmlTags;
import org.objectweb.cjdbc.common.xml.XmlComponent;
import org.objectweb.cjdbc.controller.backend.DatabaseBackend;
import org.objectweb.cjdbc.controller.core.ControllerConstants;

/**
 * This class defines a BackupManager
 * 
 * @author <a href="mailto:Nicolas.Modrzyk@inrialpes.fr">Nicolas Modrzyk </a>
 * @author <a href="mailto:Emmanuel.Cecchet@inria.fr">Emmanuel Cecchet </a>
 * @version 1.0
 */
public class BackupManager implements XmlComponent
{
  static Trace      logger           = Trace.getLogger(BackupManager.class
                                         .getName());
  private String    backupDir        = ControllerConstants.DEFAULT_BACKUP_DIR;
  private boolean   cleanBackupFiles = true;
  private boolean   zipBackupFiles   = true;
  private int       numberOfBackups  = -1;

  private Hashtable threads;

  /**
   * Creates a new <code>BackupManager</code> object
   * 
   * @param backupDir the directory used for backup
   * @param cleanBackupFiles should we clean temp backup files
   * @param zipBackupFiles should we zip backup files
   * @param numberOfBackups number of backups before deleting others, not used
   */
  public BackupManager(String backupDir, boolean cleanBackupFiles,
      boolean zipBackupFiles, int numberOfBackups)
  {
    this();
    this.backupDir = backupDir;
    this.cleanBackupFiles = cleanBackupFiles;
    this.zipBackupFiles = zipBackupFiles;
    this.numberOfBackups = numberOfBackups;

  }

  /**
   * Creates a new <code>BackupManager</code> object
   */
  public BackupManager()
  {
    threads = new Hashtable();
  }

  /**
   * Create a backup from the content of a backend
   * 
   * @param backend the target backend to backup from
   * @param checkpoint the checkpoint name of the backup to create
   * @param tables the list of tables to consider for backup
   * @param listener handback object to notify
   * @throws BackupException if backup fails for unknown reasons
   */
  public void backup(DatabaseBackend backend, String checkpoint,
      ArrayList tables, BackupListener listener) throws BackupException
  {
    logger.info(Translate.get("backup.manager.backuping.backend", new String[]{
        backend.getName(), checkpoint}));
    Octopus octopus = new Octopus(backend, checkpoint, tables);
    octopus.setZipOctopus(zipBackupFiles);
    octopus.setCleanOctopus(cleanBackupFiles);
    octopus.setOctopusDirectory(backupDir);
    octopus.setOctopusMode(Octopus.MODE_BACKUP);
    if (listener != null)
      octopus.setListener(listener);
    threads.put(backend, octopus);
    octopus.start();
  }

  /**
   * Get the result of the backup/recovery process for the given backend
   * 
   * @param backend the backend we started a backup recovery process on
   * @param waitTime the time to wait to join the octopus thread
   * @throws BackupException if backup fails for unknown reasons
   * @throws OctopusException if backup fails because of Octopus
   */
  public synchronized void getResult(DatabaseBackend backend, long waitTime)
      throws BackupException, OctopusException
  {
    logger.info(Translate.get("backup.manager.waiting.backend.result",
        new String[]{backend.getName(), String.valueOf((waitTime / 1000))}));
    Octopus backup = (Octopus) threads.get(backend);
    try
    {
      backup.join(waitTime);
    }
    catch (InterruptedException e)
    {
      logger.error("Interrupted while joining on backend:" + backend.getName(),
          e);
    }
    Exception e = backup.getRunException();
    if (e != null)
    {
      if (e instanceof BackupException)
        throw (BackupException) e;
      else if (e instanceof OctopusException)
        throw (OctopusException) e;
    }

  }

  /**
   * Restore the content of a backup onto a specific backend
   * 
   * @param backend the target backend to restore to
   * @param checkpoint the checkpoint name of the backup to restore
   * @param tables the list of tables to consider for restore
   * @param listener handback object to notify
   * @throws BackupException if backup fails for unknown reasons
   */
  public void restore(DatabaseBackend backend, String checkpoint,
      ArrayList tables, BackupListener listener) throws BackupException
  {
    logger.info(Translate.get("backup.manager.restoring.backend", new String[]{
        backend.getName(), checkpoint}));
    Octopus octopus = new Octopus(backend, checkpoint, tables);
    octopus.setZipOctopus(zipBackupFiles);
    octopus.setCleanOctopus(cleanBackupFiles);
    octopus.setOctopusDirectory(backupDir);
    if (listener != null)
      octopus.setListener(listener);
    octopus.setOctopusMode(Octopus.MODE_RECOVERY);
    threads.put(backend, octopus);
    octopus.start();
  }

  /**
   * List all the files this backup manager has access to.
   * 
   * @return a <code>File[]</code> object that can be empty, but cannot be
   *         null
   */
  public File[] listAvailableDumpFiles()
  {
    File f = new File(backupDir);
    if (f.exists())
    {
      return f.listFiles(new FilenameFilter()
      {
        /**
         * @see java.io.FilenameFilter#accept(java.io.File, java.lang.String)
         */
        public boolean accept(File dir, String name)
        {
          if (name.endsWith(Constants.ZIP_EXT))
            return true;
          else
            return false;
        }
      });
    }
    else
      return new File[0];
  }

  /**
   * Returns the backupDir value.
   * 
   * @return Returns the backupDir.
   */
  public String getBackupDir()
  {
    return backupDir;
  }

  /**
   * Sets the backupDir value.
   * 
   * @param backupDir The backupDir to set.
   */
  public void setBackupDir(String backupDir)
  {
    this.backupDir = backupDir;
  }

  /**
   * Returns the cleanBackupFiles value.
   * 
   * @return Returns the cleanBackupFiles.
   */
  public boolean isCleanBackupFiles()
  {
    return cleanBackupFiles;
  }

  /**
   * Sets the cleanBackupFiles value.
   * 
   * @param cleanBackupFiles The cleanBackupFiles to set.
   */
  public void setCleanBackupFiles(boolean cleanBackupFiles)
  {
    this.cleanBackupFiles = cleanBackupFiles;
  }

  /**
   * Returns the numberOfBackups value.
   * 
   * @return Returns the numberOfBackups.
   */
  public int getNumberOfBackups()
  {
    return numberOfBackups;
  }

  /**
   * Sets the numberOfBackups value.
   * 
   * @param numberOfBackups The numberOfBackups to set.
   */
  public void setNumberOfBackups(int numberOfBackups)
  {
    this.numberOfBackups = numberOfBackups;
  }

  /**
   * Returns the zipBackupFiles value.
   * 
   * @return Returns the zipBackupFiles.
   */
  public boolean isZipBackupFiles()
  {
    return zipBackupFiles;
  }

  /**
   * Sets the zipBackupFiles value.
   * 
   * @param zipBackupFiles The zipBackupFiles to set.
   */
  public void setZipBackupFiles(boolean zipBackupFiles)
  {
    this.zipBackupFiles = zipBackupFiles;
  }

  /**
   * @see org.objectweb.cjdbc.common.xml.XmlComponent#getXml()
   */
  public String getXml()
  {
    return "<" + DatabasesXmlTags.ELT_Backup + " " + DatabasesXmlTags.ATT_dir
        + "=\"" + backupDir + "\" " + DatabasesXmlTags.ATT_clean + "=\""
        + cleanBackupFiles + "\" " + DatabasesXmlTags.ATT_zip + "=\""
        + zipBackupFiles + "\" " + "/>";
  }
}

---