Octopus.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.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.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;

/**
 * Octopus Hook Class. It has the necessary methods and fields to use octopus
 * simply.
 * 
 * @see org.objectweb.cjdbc.controller.backup.OctopusConstants
 * @author <a href="mailto:Nicolas.Modrzyk@inrialpes.fr">Nicolas Modrzyk </a>
 * @author <a href="mailto:Emmanuel.Cecchet@inria.fr">Emmanuel Cecchet </a>
 */
public class Octopus extends Thread
{
  private static final String OCTOPUS_INCLUDE_HREF  = "<include href=\"sql/";
  static Trace                logger;

  static
  {
    String cjdbcHome = System.getProperty("cjdbc.home");
    if (cjdbcHome != null)
      System.setProperty("OCTOPUS_HOME", cjdbcHome + File.separator + "lib"
          + File.separator + "octopus" + File.separator + "xml");
  }
  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;

  /** Mode for backup using octopus */
  public static final int     MODE_BACKUP           = 0;
  /** Mode for recovery using octopus */
  public static final int     MODE_RECOVERY         = 1;

  private DatabaseBackend     database;

  private String              user;
  private String              password;
  private String              dumpName;
  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;

  /**
   * Instanciate hook to octopus
   * 
   * @param database backend to manipulate with octopus
   * @param dumpName to name files
   * @throws BackupException if fails
   */
  public Octopus(DatabaseBackend database, String dumpName)
      throws BackupException
  {
    logger = Trace.getLogger(this.getClass().getName());
    // Prepare references
    this.database = database;
    this.dumpName = dumpName;
    this.tables = null;

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

  /**
   * Creates a new <code>Octopus</code> object and sets the mode to use it as
   * a thread
   * 
   * @param database the <code>DatabaseBackend</code> object to process
   * @param dumpName the dumpName to use for name of backup
   * @param backupMode true if we should backup, false if we should restore
   * @throws BackupException if fails (not due to Octopus)
   */
  public Octopus(DatabaseBackend database, String dumpName, boolean backupMode)
      throws BackupException
  {
    this(database, dumpName);
    this.backupMode = backupMode;
  }

  /**
   * Use Octopus only for a set of tables
   * 
   * @param database backend to manipulate with octopus
   * @param dumpName to name files
   * @param tables on which we should use Octopus
   * @param backupMode true if we should backup, false if we should restore
   * @throws BackupException if fails
   */
  public Octopus(DatabaseBackend database, String dumpName, ArrayList tables,
      boolean backupMode) throws BackupException
  {
    this(database, dumpName, backupMode);
    this.tables = tables;
  }

  /**
   * Use Octopus only for a set of tables
   * 
   * @param database backend to manipulate with octopus
   * @param dumpName to name files
   * @param tables on which we should use Octopus
   * @throws BackupException if fails
   */
  public Octopus(DatabaseBackend database, String dumpName, ArrayList tables)
      throws BackupException
  {
    this(database, dumpName);
    this.tables = tables;
  }

  /**
   * Convert database to csv and zip the files
   * 
   * @throws BackupException if failure is not due to octopus
   * @throws OctopusException if failure is due to octopus
   */
  public void backup() throws BackupException, OctopusException
  {
    sanityCheck();
    prepareOctopus(OCTOPUS_MODE_TO_CSV);
    launchOctopus();
    if (zipOctopus)
      zipOctopus(ZIP_MODE_CREATE);
    if (cleanOctopus)
      cleanUp();
  }

  /**
   * Recover database from zipped csv the files
   * 
   * @throws BackupException if failure is not due to octopus
   * @throws OctopusException if failure is due to octopus
   */
  public void restore() throws BackupException, OctopusException
  {
    if (zipOctopus)
      zipOctopus(ZIP_MODE_EXPAND);
    prepareOctopus(OCTOPUS_MODE_FROM_CSV);
    setOctopusLoaderJob();
    launchOctopus();
    if (cleanOctopus)
      cleanUp();
  }

  /**
   * @see java.lang.Runnable#run()
   */
  public void run()
  {
    if (backupMode)
      try
      {
        database.setState(BackendState.BACKUPING);
        backup();
        database.notifyJmx(CjdbcNotificationList.VIRTUALDATABASE_NEW_DUMP_LIST);
        // Backend keeps its dumpName (it should have disabled with dumpName
        // prior this backup operation).
        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();
        // Set the dumpName corresponding to this database dump
        database.setLastKnownCheckpoint(dumpName);
        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();
      }
    }
  }

  /**
   * Check if backup can be executed.
   * 
   * @throws BackupException if backend cannot be used for backup
   */
  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"));
  }

  /**
   * Delete a directory by deleting all sub files
   * 
   * @param dir to delete
   * @return true if success, false otherwise
   */
  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();
  }

  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
  {
    if (logger.isDebugEnabled())
      logger.debug("### Generating metadata ###");
    callOctopusLoader(sourceType, sourceUrl, sourceDriver, sourceUser,
        sourcePassword, targetType, targetDriver, targetUrl, targetUser,
        targetPassword, backup, true);
  }

  /**
   * Prepare the loader job file for octopus
   */
  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
  {
    if (logger.isDebugEnabled())
      logger.debug("### Generating loader job ###");
    callOctopusLoader(sourceType, sourceUrl, sourceDriver, sourceUser,
        sourcePassword, targetType, targetDriver, targetUrl, targetUser,
        targetPassword, backup, false);
  }

  /**
   * Generate all the metadata
   */
  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;
  }

  /**
   * Returns the cleanOctopus value.
   * 
   * @return Returns the cleanOctopus.
   */
  public boolean isCleanOctopus()
  {
    return cleanOctopus;
  }

  /**
   * Returns the zipOctopus value.
   * 
   * @return Returns the zipOctopus.
   */
  public boolean isZipOctopus()
  {
    return zipOctopus;
  }

  /**
   * Retrieve the path for the octopus directory
   * 
   * @return string
   */
  public final String getOctopusDirectory()
  {
    return mainDirectory;
  }

  /**
   * Returns the runException value.
   * 
   * @return Returns the runException.
   */
  public Exception getRunException()
  {
    return runException;
  }

  /**
   * Set the default path of octopus directory to a new one
   * 
   * @param path of the directory
   */
  public final void setOctopusDirectory(String path)
  {
    mainDirectory = path;
  }

  /**
   * When used as a thread Octopus needs to know if this will be a backup or
   * restore operation.
   * 
   * @param mode Octopus.MODE_BACKUP for a backup or Octopus.MODE_RECOVERY for a
   *          recovery
   */
  public void setOctopusMode(int mode)
  {
    switch (mode)
    {
      case MODE_BACKUP :
        this.backupMode = true;
        break;
      case MODE_RECOVERY :
        this.backupMode = false;
        break;
      default :
        throw new RuntimeException("Invalid mode " + mode
            + " in setOctopusMode");
    }
  }

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

  /**
   * Set the callback listener of this octopus process
   * 
   * @param listener this thread will call the callback method on this object
   */
  public void setListener(BackupListener listener)
  {
    this.listener = listener;
  }

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

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

  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 + dumpName;

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

    // Create Csv directory
    csvDir = "csv";
    File csvd = new File(octopusDir + File.separator + csvDir);
    csvDir = csvd.getAbsolutePath();
    csvd.mkdirs();
    csvd.mkdir();

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

    if (logger.isDebugEnabled())
    {
      logger.debug("=======================================");
      logger.debug("Using the following Octopus settings:");
      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);
      logger.debug("OCTOPUS_HOME:" + System.getProperty("OCTOPUS_HOME"));
      logger.debug("=======================================");
    }

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

  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 */
        int idx = line.indexOf(OCTOPUS_INCLUDE_HREF);
        if (idx != -1)
        {
          idx += OCTOPUS_INCLUDE_HREF.length();
          // -4 = Skip "sql/"
          line = line.substring(0, idx - 4) + ".." + File.separator
              + octopusDir + File.separator + "SQLForAllVendors"
              + File.separator + sourceType + File.separator + "sql"
              + File.separator + line.substring(idx);
        }

        /* 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)
        {
        }
    }
  }

  /**
   * This start octopus with previously generated LoaderJob file
   * 
   * @throws OctopusException if octopus fails
   */
  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 zipOctopus(int zipMode) throws BackupException
  {
    try
    {
      if (logger.isDebugEnabled())
      {
        logger.debug("Checkpoint:" + dumpName);
        logger.debug("CsvDir:" + csvDir);
        logger.debug("MainDir:" + mainDirectory);
      }
      switch (zipMode)
      {
        case ZIP_MODE_CREATE :
          new ZipMe().create(dumpName, octopusDir, mainDirectory);
          break;
        case ZIP_MODE_EXPAND :
          new ZipMe().expand(dumpName, ".", 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);

  }

}

---