src/org/objectweb/cjdbc/controller/backup/Octopus.java

説明を見る。

package org.objectweb.cjdbc.controller.backup;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Vector;

import org.apache.log4j.Category;
import org.apache.log4j.Priority;
import org.apache.regexp.RE;
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.jmx.notifications.CjdbcNotificationList;
import org.objectweb.cjdbc.common.log.Trace;
import org.objectweb.cjdbc.common.shared.BackendState;
import org.objectweb.cjdbc.common.shared.BackupListener;
import org.objectweb.cjdbc.common.sql.schema.DatabaseTable;
import org.objectweb.cjdbc.common.util.LoggingOutputStream;
import org.objectweb.cjdbc.common.util.ZipMe;
import org.objectweb.cjdbc.controller.backend.DatabaseBackend;
import org.objectweb.cjdbc.controller.connection.AbstractConnectionManager;
import org.webdocwf.util.loader.Loader;
import org.webdocwf.util.loader.generator.LoaderGenerator;

public class Octopus extends Thread
{
  static Trace               logger;

  static final String        TYPE_CSV              = "csv";
  static final String        COPY_MODE             = "copy";
  static final String        OVERRIDE_MODE         = "sync";
  static final String        GENERATE_DOC          = "sql";
  static final String        OCTOPUS_LOG_FILE      = "octopusLog.txt";
  boolean             cleanOctopus          = false;
  boolean             zipOctopus            = true;

  static final int           ZIP_MODE_CREATE       = 0;
  static final int           ZIP_MODE_EXPAND       = 1;

  static final int           OCTOPUS_MODE_FROM_CSV = 0;
  static final int           OCTOPUS_MODE_TO_CSV   = 1;

  public static final int    MODE_BACKUP           = 0;
  public static final int    MODE_RECOVERY         = 1;

  private DatabaseBackend    database;

  private String             user;
  private String             password;
  private String             checkpoint;
  private String             octopusDir;
  private String             csvDir;
  private String             loaderJobXmlFile;
  private ArrayList          tables;
  private static PrintStream stream;

  static String              mainDirectory         = ".." + File.separator
                                                       + "backup";

  private boolean            backupMode;

  private Exception          runException;

  private BackupListener     listener;

  public Exception getRunException()
  {
    return runException;
  }

  public final void setOctopusDirectory(String path)
  {
    mainDirectory = path;
  }

  public final String getOctopusDirectory()
  {
    return mainDirectory;
  }

  public Octopus(DatabaseBackend database, String checkpoint)
      throws BackupException
  {
    logger = Trace.getLogger(this.getClass().getName());
    // Prepare references
    this.database = database;
    this.checkpoint = checkpoint;
    this.tables = null;

    // Retrieve information
    getUserLogin();
    setPaths();
  }

  public Octopus(DatabaseBackend database, String checkpoint, boolean backupMode)
      throws BackupException
  {
    this(database, checkpoint);
    this.backupMode = backupMode;
  }

  public Octopus(DatabaseBackend database, String checkpoint, ArrayList tables,
      boolean backupMode) throws BackupException
  {
    this(database, checkpoint, backupMode);
    this.tables = tables;
  }

  public Octopus(DatabaseBackend database, String checkpoint, ArrayList tables)
      throws BackupException
  {
    this(database, checkpoint);
    this.tables = tables;
  }

  public void backup() throws BackupException, OctopusException
  {
    sanityCheck();
    prepareOctopus(OCTOPUS_MODE_TO_CSV);
    launchOctopus();
    if (zipOctopus)
      zipOctopus(ZIP_MODE_CREATE);
    if (cleanOctopus)
      cleanUp();
  }

  public void restore() throws BackupException, OctopusException
  {
    if (zipOctopus)
      zipOctopus(ZIP_MODE_EXPAND);
    prepareOctopus(OCTOPUS_MODE_FROM_CSV);
    setOctopusLoaderJob();
    launchOctopus();
    if (cleanOctopus)
      cleanUp();
  }

  public void setOctopusMode(boolean backup)
  {
    this.backupMode = backup;
  }

  public void run()
  {
    if (backupMode)
      try
      {
        database.setState(BackendState.BACKUPING);
        backup();
        database
            .notifyJmx(CjdbcNotificationList.CONTROLLER_VIRTUALDATABASE_NEW_DUMP_LIST);
        database.setLastKnownCheckpoint(checkpoint);
        database.setState(BackendState.DISABLED);
        if (listener != null)
          listener.success(database.getName());
      }
      catch (Exception e)
      {
        database.setState(BackendState.UNKNOWN);
        runException = e;
        if (listener != null)
          listener.failure(database.getName(), e);
      }
    else
    {
      try
      {
        database.setState(BackendState.RECOVERING);
        restore();
        database.setLastKnownCheckpoint(checkpoint);
        database.setState(BackendState.DISABLED);
        if (listener != null)
          listener.success(database.getName());
      }
      catch (Exception e1)
      {
        database.setState(BackendState.UNKNOWN);
        runException = e1;
        if (listener != null)
          listener.failure(database.getName(), e1);
      }
    }

    // Wake up everybody waiting on the listener
    if (listener != null)
    {
      synchronized (listener)
      {
        listener.notifyAll();
      }
    }
  }

  private void getUserLogin()
  {
    //Retrieve user login and password to connect to database
    HashMap connectionManagers = database.getConnectionManagers();
    Iterator iter = connectionManagers.values().iterator();
    AbstractConnectionManager connectionManager = (AbstractConnectionManager) iter
        .next();
    user = connectionManager.getLogin();
    password = connectionManager.getPassword();
    if (logger.isDebugEnabled())
      logger.debug("User:" + user + ":Password:" + password);
  }

  private void setPaths() throws BackupException
  {
    // Change output stream
    if (stream == null)
      stream = new PrintStream(new LoggingOutputStream(Category
          .getInstance(this.getClass().getName()), Priority.DEBUG), true);
    //stream.close();
    System.setOut(stream);

    // Create main octopus directory
    octopusDir = mainDirectory + File.separator + checkpoint;

    File octopusd = new File(octopusDir);
    octopusd.mkdirs();

    // Create Csv directory
    // Octopus needs a relative path from the loader file,
    // so just give the name of the directory
    csvDir = "csv";
    File csvd = new File(octopusDir + File.separator + csvDir);
    csvd.mkdirs();

    // Create LoaderFile name
    loaderJobXmlFile = octopusDir + File.separator + "LoaderJob.olj";

    if (logger.isDebugEnabled())
    {
      logger.debug("OCTOPUS_DIR=" + octopusDir);
      logger.debug("CSV_DIR=" + csvDir);
      logger.debug("LOADER_JOB_XML_FILE=" + loaderJobXmlFile);
      logger.debug("cleanOctopus=" + cleanOctopus);
      logger.debug("zipOctopus=" + cleanOctopus);
    }

    if (!octopusd.exists() || !csvd.exists())
    {
      throw new BackupException("backup.directory.cannot.be.created");
    }
  }

  public void sanityCheck() throws BackupException
  {
    boolean notEnabled = false, noPendingRequests = false;
    if (database.isReadEnabled() == false)
      notEnabled = true;

    Vector pending = database.getPendingRequests();
    int size = pending.size();
    noPendingRequests = (size == 0) ? true : false;
    if (logger.isDebugEnabled())
    {
      if (!noPendingRequests)
      {
        for (int i = 0; i < size; i++)
        {
          logger.debug("Pending:" + pending.get(i).toString());
        }
      }
      logger.debug("Pending Requests:" + database.getPendingRequests().size());
      logger.debug("Read enabled:" + database.isReadEnabled());
      logger.debug("Write enabled:" + database.isWriteEnabled());
    }
    if (!(notEnabled && noPendingRequests))
      throw new BackupException(Translate.get("backend.not.ready.for.backup"));
  }

  private void setOctopusLoaderJob() throws OctopusException, BackupException
  {
    Hashtable options = getOctopusStrings(database);
    String sourceType = (String) options.get("octopusType");
    String onErrorContinueEqualFalse = "onErrorContinue=\"false\"";
    String onErrorContinueEqualTrue = "onErrorContinue=\"true\"";
    BufferedReader br = null;
    BufferedWriter bw = null;

    try
    {
      br = new BufferedReader(new FileReader(loaderJobXmlFile));
      String line = "";
      StringBuffer buffer = new StringBuffer();
      while ((line = br.readLine()) != null)
      {

        /* Give the metadata location */

        RE href = new RE("(<include.*href\\s*=\\s*\")(.*/)(.*?\\.sql\".*)");

        /* XX in this string is a hack to workaround a bug in apache regexp 1.3 */

        line = href.subst(line, "XX$1.." + File.separator + octopusDir
            + File.separator + "SQLForAllVendors" + File.separator + sourceType
            + File.separator + "sql" + File.separator + "$3",
            RE.REPLACE_BACKREFERENCES);

        /* Force on error continue */
        int index7 = line.indexOf(onErrorContinueEqualFalse);
        if (index7 != -1)
        {
          line = line.substring(0, index7) + onErrorContinueEqualTrue
              + line.substring(index7 + onErrorContinueEqualFalse.length());
        }
        buffer.append(line + System.getProperty("line.separator"));
      }
      br.close();

      if (logger.isDebugEnabled())
      {
        logger.debug("Octopus file updated with success");
      }

      bw = new BufferedWriter(new FileWriter(loaderJobXmlFile));
      bw.write(buffer.toString());
      bw.close();
    }
    catch (FileNotFoundException fie)
    {
      // loader job was not generated properly
      logger.warn(Translate.get("controller.octopus.loader.job.not.found"));
      throw new OctopusException(fie.getMessage());
    }
    catch (IOException e)
    {
      // Error while reading file
      logger.warn(Translate.get("controller.octopus.loader.io.problem"));
    }
    finally
    {
      // close the open streams
      if (bw != null)
        try
        {
          bw.close();
        }
        catch (IOException e1)
        {

        }
      if (br != null)
        try
        {
          br.close();
        }
        catch (IOException e2)
        {
        }
    }
  }

  private void launchOctopus() throws OctopusException
  {
    try
    {
      Loader myOctopus;
      if (tables == null)
      {
        // Copy everything
        myOctopus = new Loader(loaderJobXmlFile, Loader.LOGMODE_NORMAL,
            "cjdbc", octopusDir, OCTOPUS_LOG_FILE, true, null, null, true,
            null, 0, 100);
      }
      else
      {
        // Copy only the tables we want
        myOctopus = new Loader(loaderJobXmlFile, Loader.LOGMODE_NORMAL,
            "cjdbc", octopusDir, OCTOPUS_LOG_FILE, true, null, null, true,
            null, 0, 100, this.convertTablesToArray(tables));

      }
      try
      {
        myOctopus.load();
      }
      catch (Exception e)
      {
        logger.error("Failed to load octopus",e);
        throw new OctopusException(Translate.get(
            "controller.octopus.load.failed", e));
      }
    }
    // I am doing this because Octopus throws NullPointerException
    // all the time so it is impossible to know which failed
    catch (OctopusException oe)
    {
      // This is thrown only by the above.
      throw oe;
    }
    catch (Exception e)
    {
      throw new OctopusException(Translate
          .get("controller.octopus.instance.failed"));
    }
  }

  private void cleanUp()
  {
    if (logger.isDebugEnabled())
      logger.debug("Cleaning up temporary backup files...");
    File toRemove = new File(octopusDir);
    deleteDir(toRemove);
  }

  public boolean deleteDir(File dir)
  {
    if (dir.isDirectory())
    {
      String[] children = dir.list();
      for (int i = 0; i < children.length; i++)
      {
        boolean success = deleteDir(new File(dir, children[i]));
        if (!success)
        {
          return false;
        }
      }
    }
    // The directory is now empty so delete it
    return dir.delete();
  }

  private void zipOctopus(int zipMode) throws BackupException
  {
    try
    {
      if (logger.isDebugEnabled())
      {
        logger.debug("Checkpoint:" + checkpoint);
        logger.debug("CsvDir:" + csvDir);
        logger.debug("MainDir:" + mainDirectory);
      }
      switch (zipMode)
      {
        case ZIP_MODE_CREATE :
          new ZipMe().create(checkpoint, octopusDir, mainDirectory);
          break;
        case ZIP_MODE_EXPAND :
          new ZipMe().expand(checkpoint, ".", mainDirectory);
          break;
        default :
          throw new BackupException("invalid.zip.mode");
      }
    }
    catch (Exception e)
    {
      logger.error(e.getMessage(), e);
      throw new BackupException(e.getMessage());
    }
  }

  private String getDbType(String url) throws BackupException
  {
    if (url == null)
      throw new BackupException("Invalid null source url");
    int index = url.indexOf(':');
    int index2 = url.indexOf(':', index + 1);
    if (index == -1 || index2 == -1 || index > index2)
      throw new BackupException("Invalid source url format");
    String type = url.substring(index + 1, index2);
    return type;
  }

  private void prepareOctopus(int octopusMode) throws BackupException,
      OctopusException
  {
    // Declare variables
    String sourceType = "";
    String sourceUrl = "";
    String sourceDriver = "";
    String sourceUser = "";
    String sourcePassword = "";

    String targetType = "";
    String targetDriver = "";
    String targetUrl = "";
    String targetUser = "";
    String targetPassword = "";

    boolean backupMode = true;

    Hashtable options = getOctopusStrings(database);

    // Prepare Variables
    switch (octopusMode)
    {
      case OCTOPUS_MODE_FROM_CSV :
        targetType = (String) options.get("octopusType");
        targetUrl = (String) options.get("octopusUrl");
        targetDriver = (String) options.get("octopusDriver");
        targetUser = user;
        targetPassword = password;
        sourceType = OctopusConstants.getOctopusType(TYPE_CSV);
        sourceDriver = OctopusConstants.getOctopusDriver(TYPE_CSV);
        sourceUrl = csvDir;
        sourceUser = "";
        sourcePassword = "";
        backupMode = false;
        break;
      case OCTOPUS_MODE_TO_CSV :
        sourceType = (String) options.get("octopusType");
        sourceUrl = (String) options.get("octopusUrl");
        sourceDriver = (String) options.get("octopusDriver");
        sourceUser = user;
        sourcePassword = password;
        targetType = OctopusConstants.getOctopusType(TYPE_CSV);
        targetDriver = OctopusConstants.getOctopusDriver(TYPE_CSV);
        targetUrl = csvDir;
        targetUser = "";
        targetPassword = "";
        backupMode = true;
        // Generate metadata
        generateMetadata(sourceType, sourceUrl, sourceDriver, sourceUser,
            sourcePassword, targetType, targetDriver, targetUrl, targetUser,
            targetPassword, backupMode);
        break;
      default :
        throw new BackupException("invalid.octopus.prepare.type");
    }

    // Generate loader job
    prepareOctopus(sourceType, sourceUrl, sourceDriver, sourceUser,
        sourcePassword, targetType, targetDriver, targetUrl, targetUser,
        targetPassword, backupMode);

  }

  final Hashtable getOctopusStrings(DatabaseBackend database)
      throws BackupException
  {
    Hashtable strings = new Hashtable(3);
    String type = getDbType(database.getURL());
    String octopusPrefixUrl = OctopusConstants.getUrlPrefix(type);
    String databaseUrl = database.getURL();

    strings.put("octopusType", OctopusConstants.getOctopusType(type));
    strings.put("octopusDriver", OctopusConstants.getOctopusDriver(type));
    strings.put("octopusUrl", databaseUrl.substring(octopusPrefixUrl.length()));

    return strings;
  }

  final void generateMetadata(String sourceType, String sourceUrl,
      String sourceDriver, String sourceUser, String sourcePassword,
      String targetType, String targetDriver, String targetUrl,
      String targetUser, String targetPassword, boolean backup)
      throws OctopusException
  {
    logger.debug("### Generating metadata ###");
    callOctopusLoader(sourceType, sourceUrl, sourceDriver, sourceUser,
        sourcePassword, targetType, targetDriver, targetUrl, targetUser,
        targetPassword, backup, true);
  }

  final void prepareOctopus(String sourceType, String sourceUrl,
      String sourceDriver, String sourceUser, String sourcePassword,
      String targetType, String targetDriver, String targetUrl,
      String targetUser, String targetPassword, boolean backup)
      throws OctopusException
  {
    callOctopusLoader(sourceType, sourceUrl, sourceDriver, sourceUser,
        sourcePassword, targetType, targetDriver, targetUrl, targetUser,
        targetPassword, backup, false);
  }

  final void callOctopusLoader(String sourceType, String sourceUrl,
      String sourceDriver, String sourceUser, String sourcePassword,
      String targetType, String targetDriver, String targetUrl,
      String targetUser, String targetPassword, boolean backup,
      boolean generateAllVendors) throws OctopusException
  {
    try
    {
      if (logger.isDebugEnabled())
      {
        logger.debug("Source Type:" + sourceType);
        logger.debug("Source Driver:" + sourceDriver);
        logger.debug("Source URL :" + sourceUrl);
        logger.debug("Source User :" + sourceUser);
        logger.debug("Target Type:" + targetType);
        logger.debug("Target Driver:" + targetDriver);
        logger.debug("Target URL:" + targetUrl);
        logger.debug("Target User :" + targetUser);
        if (backup)
          logger.debug("Backup Mode");
        else
          logger.debug("Restore Mode");
        logger.debug("Generate SQL for all vendors :" + generateAllVendors);
      }
      LoaderGenerator loader = new LoaderGenerator(sourceType, // sourceType
          sourceUrl, // sourceDatabase Url?
          COPY_MODE, // valueMode
          octopusDir, // generatorOutput
          sourceDriver, // sourceDriverName
          targetDriver, // TargetDriverName
          targetUrl, // targetDataBase
          targetType, // TargetType
          sourceUser, // sourceUser
          sourcePassword, // sourcePassword
          targetUser, // targetUser
          targetPassword, //targetPassword
          "", // domlPath
          "org.webdoc.util.loader", // package name
          "true", // generate drop table stmt
          "true", // generate drop integrity statement
          "true", // generate create table stmt
          "true", // generate create pk statement
          "true", // generate create fk statement
          "true", // generate create index stmt
          String.valueOf(generateAllVendors), // generate
          // sql
          // for
          // all
          // vendors
          String.valueOf(!generateAllVendors), // generate
          // xml
          "false", // generate doml
          String.valueOf(!generateAllVendors), // full
          // mode
          // ??
          String.valueOf(!backup), // restore mode
          null, //convertTablesToSemicolonSeparatedList(database.getTables()),
          // // tables list
          null // Jar file structure
      );
      loader.generate();
    }
    catch (Exception e)
    {
      throw new OctopusException(e);
    }
  }

  private String[] convertTablesToArray(ArrayList tablesList)
  {
    int length = tablesList.size();
    String[] result = new String[length];
    for (int i = 0; i < length; i++)
      result[i] = ((DatabaseTable) tablesList.get(i)).getName();
    return result;
  }

  public boolean isCleanOctopus()
  {
    return cleanOctopus;
  }

  public void setCleanOctopus(boolean cleanOctopus)
  {
    this.cleanOctopus = cleanOctopus;
  }

  public boolean isZipOctopus()
  {
    return zipOctopus;
  }

  public void setZipOctopus(boolean zipOctopus)
  {
    this.zipOctopus = zipOctopus;
  }

  public void setListener(BackupListener listener)
  {
    this.listener = listener;
  }
}

---