src/org/objectweb/cjdbc/controller/virtualdatabase/VirtualDatabase.java

説明を見る。

package org.objectweb.cjdbc.controller.virtualdatabase;

import java.io.Serializable;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Map;

import javax.management.NotCompliantMBeanException;
import javax.management.ObjectName;

import org.objectweb.cjdbc.common.exceptions.BackupException;
import org.objectweb.cjdbc.common.exceptions.ExceptionTypes;
import org.objectweb.cjdbc.common.exceptions.OctopusException;
import org.objectweb.cjdbc.common.exceptions.VirtualDatabaseException;
import org.objectweb.cjdbc.common.i18n.Translate;
import org.objectweb.cjdbc.common.jmx.JmxConstants;
import org.objectweb.cjdbc.common.jmx.JmxException;
import org.objectweb.cjdbc.common.jmx.mbeans.VirtualDatabaseMBean;
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.AbstractWriteRequest;
import org.objectweb.cjdbc.common.sql.SelectRequest;
import org.objectweb.cjdbc.common.sql.StoredProcedure;
import org.objectweb.cjdbc.common.sql.filters.AbstractBlobFilter;
import org.objectweb.cjdbc.common.sql.schema.DatabaseSchema;
import org.objectweb.cjdbc.common.sql.schema.DatabaseTable;
import org.objectweb.cjdbc.common.users.AdminUser;
import org.objectweb.cjdbc.common.users.VirtualDatabaseUser;
import org.objectweb.cjdbc.common.util.Constants;
import org.objectweb.cjdbc.common.util.ReadPrioritaryFIFOWriteLock;
import org.objectweb.cjdbc.common.xml.DatabasesXmlTags;
import org.objectweb.cjdbc.common.xml.XmlComponent;
import org.objectweb.cjdbc.controller.authentication.AuthenticationManager;
import org.objectweb.cjdbc.controller.backend.DatabaseBackend;
import org.objectweb.cjdbc.controller.core.Controller;
import org.objectweb.cjdbc.controller.core.shutdown.VirtualDatabaseShutdownThread;
import org.objectweb.cjdbc.controller.jmx.AbstractStandardMBean;
import org.objectweb.cjdbc.controller.jmx.MBeanServerManager;
import org.objectweb.cjdbc.controller.jmx.RmiConnector;
import org.objectweb.cjdbc.controller.monitoring.SQLMonitoring;
import org.objectweb.cjdbc.controller.recoverylog.AbstractRecoveryLog;
import org.objectweb.cjdbc.controller.recoverylog.BackendRecoveryInfo;
import org.objectweb.cjdbc.controller.recoverylog.JDBCRecoveryLog;
import org.objectweb.cjdbc.controller.requestmanager.RequestManager;

public class VirtualDatabase extends AbstractStandardMBean
    implements
      Serializable,
      VirtualDatabaseMBean,
      XmlComponent
{
  //
  // How the code is organized ?
  //
  // 1. Member variables
  // 2. Constructor(s)
  // 3. Request handling
  // 4. Transaction handling
  // 5. Database backend management
  // 6. Distribution management (multicast)
  // 7. Getter/Setter (possibly in alphabetical order)
  // 8. Shutdown
  //

  protected String                      name;

  protected AuthenticationManager       authenticationManager;

  protected ArrayList                   backends;

  protected ReadPrioritaryFIFOWriteLock rwLock;

  protected RequestManager              requestManager;

  public Trace                          logger                = null;
  protected Trace                       requestLogger         = null;

  // List of current active Worker Threads
  private ArrayList                     activeThreads         = new ArrayList();
  // List of current idle Worker Threads
  private int                           idleThreads           = 0;
  // List of current pending connections (Socket objects)
  private ArrayList                     pendingConnections    = new ArrayList();

  protected int                         maxNbOfConnections;

  protected boolean                     poolConnectionThreads;

  protected long                        maxThreadIdleTime;

  protected int                         minNbOfThreads;

  protected int                         maxNbOfThreads;

  protected int                         currentNbOfThreads;

  protected VirtualDatabaseMetaData     metadata;

  private SQLMonitoring                 sqlMonitor            = null;

  public static final int               CHECK_BACKEND_ENABLE  = 1;
  public static final int               CHECK_BACKEND_DISABLE = 0;
  public static final int               NO_CHECK_BACKEND      = -1;

  private int                           sqlShortFormLength;

  private AbstractBlobFilter            blobFilter;

  Controller                            controller;

  private String                        databaseProductNames  = "C-JDBC";

  private boolean                       shuttingDown          = false;

  /* Constructors */

  public VirtualDatabase(Controller controller, String name,
      int maxConnections, boolean pool, int minThreads, int maxThreads,
      long maxThreadIdleTime, int sqlShortFormLength,
      AbstractBlobFilter blobFilter) throws NotCompliantMBeanException,
      JmxException
  {
    super(VirtualDatabaseMBean.class);
    this.controller = controller;
    this.name = name;
    this.maxNbOfConnections = maxConnections;
    this.poolConnectionThreads = pool;
    this.minNbOfThreads = minThreads;
    this.maxNbOfThreads = maxThreads;
    this.maxThreadIdleTime = maxThreadIdleTime;
    this.sqlShortFormLength = sqlShortFormLength;
    this.blobFilter = blobFilter;
    backends = new ArrayList();

    ObjectName objectName = JmxConstants.getVirtualDbObjectName(name);
    MBeanServerManager.registerMBean(this, objectName);

    rwLock = new ReadPrioritaryFIFOWriteLock();
    logger = Trace.getLogger("org.objectweb.cjdbc.controller.virtualdatabase."
        + name);
    requestLogger = Trace
        .getLogger("org.objectweb.cjdbc.controller.virtualdatabase.request."
            + name);
  }

  public String getAssociatedString()
  {
    return "virtualdatabase";
  }

  public boolean isDistributed()
  {
    return false;
  }

  /* Request Handling */

  public boolean checkUserAuthentication(String virtualLogin,
      String virtualPassword)
  {
    if (authenticationManager == null)
    {
      logger.error("No authentification manager defined to check login '"
          + virtualLogin + "'");
      return false;
    }
    else
      return authenticationManager.isValidVirtualUser(new VirtualDatabaseUser(
          virtualLogin, virtualPassword));
  }

  public boolean checkAdminAuthentication(String adminLogin,
      String adminPassword)
  {
    if (authenticationManager == null)
    {
      logger.error("No authentification manager defined to check admin login '"
          + adminLogin + "'");
      return false;
    }
    else
      return authenticationManager.isValidAdminUser(new AdminUser(adminLogin,
          adminPassword));
  }

  public ControllerResultSet execReadRequest(SelectRequest request)
      throws SQLException
  {
    if (request == null)
    {
      String msg = "Request failed (null read request received)";
      logger.warn(msg);
      throw new SQLException(msg);
    }

    try
    {
      if (requestLogger.isInfoEnabled())
        requestLogger.info("S " + request.getTransactionId() + " "
            + request.getSQL());

      long start = 0;
      if (sqlMonitor != null)
        start = System.currentTimeMillis();

      ControllerResultSet rs = requestManager.execReadRequest(request);

      if (sqlMonitor != null)
        sqlMonitor.logRequestTime(request, System.currentTimeMillis() - start);

      return rs;
    }
    catch (SQLException e)
    {
      String msg = "Request '" + request.getId() + "' failed ("
          + e.getMessage() + ")";
      logger.warn(msg);
      if (sqlMonitor != null)
        sqlMonitor.logError(request);
      throw e;
    }
  }

  public int execWriteRequest(AbstractWriteRequest request) throws SQLException
  {
    if (request == null)
    {
      String msg = "Request failed (null write request received)";
      logger.warn(msg);
      throw new SQLException(msg);
    }

    try
    {
      if (requestLogger.isInfoEnabled())
        requestLogger.info("W " + request.getTransactionId() + " "
            + request.getSQL());

      long start = 0;
      if (sqlMonitor != null)
        start = System.currentTimeMillis();

      int result = requestManager.execWriteRequest(request);

      if (sqlMonitor != null)
        sqlMonitor.logRequestTime(request, System.currentTimeMillis() - start);

      return result;
    }
    catch (SQLException e)
    {
      String msg = "Request '" + request.getId() + "' failed ("
          + e.getMessage() + ")";
      logger.warn(msg);
      if (sqlMonitor != null)
        sqlMonitor.logError(request);
      throw e;
    }
  }

  public ControllerResultSet execWriteRequestWithKeys(
      AbstractWriteRequest request) throws SQLException
  {
    if (request == null)
    {
      String msg = "Request failed (null write request received)";
      logger.warn(msg);
      throw new SQLException(msg);
    }

    try
    {
      if (requestLogger.isInfoEnabled())
        requestLogger.info("W " + request.getTransactionId() + " "
            + request.getSQL());

      long start = 0;
      if (sqlMonitor != null)
        start = System.currentTimeMillis();

      ControllerResultSet result = requestManager
          .execWriteRequestWithKeys(request);

      if (sqlMonitor != null)
        sqlMonitor.logRequestTime(request, System.currentTimeMillis() - start);

      return result;
    }
    catch (SQLException e)
    {
      String msg = "Request '" + request.getId() + "' failed ("
          + e.getMessage() + ")";
      logger.warn(msg);
      if (sqlMonitor != null)
        sqlMonitor.logError(request);
      throw e;
    }
  }

  public ControllerResultSet execReadStoredProcedure(StoredProcedure proc)
      throws SQLException
  {
    if (proc == null)
    {
      String msg = "Request failed (null stored procedure received)";
      logger.warn(msg);
      throw new SQLException(msg);
    }

    try
    {
      if (requestLogger.isInfoEnabled())
        requestLogger
            .info("S " + proc.getTransactionId() + " " + proc.getSQL());

      long start = 0;
      if (sqlMonitor != null)
        start = System.currentTimeMillis();

      ControllerResultSet rs = requestManager.execReadStoredProcedure(proc);

      if (sqlMonitor != null)
        sqlMonitor.logRequestTime(proc, System.currentTimeMillis() - start);

      return rs;
    }
    catch (SQLException e)
    {
      String msg = Translate.get("loadbalancer.storedprocedure.failed",
          new String[]{String.valueOf(proc.getId()), e.getMessage()});
      logger.warn(msg);
      if (sqlMonitor != null)
        sqlMonitor.logError(proc);
      throw e;
    }
  }

  protected int execWriteStoredProcedure(StoredProcedure proc)
      throws SQLException
  {
    if (proc == null)
    {
      String msg = "Request failed (null stored procedure received)";
      logger.warn(msg);
      throw new SQLException(msg);
    }

    try
    {
      if (requestLogger.isInfoEnabled())
        requestLogger
            .info("W " + proc.getTransactionId() + " " + proc.getSQL());

      long start = 0;
      if (sqlMonitor != null)
        start = System.currentTimeMillis();

      int result = requestManager.execWriteStoredProcedure(proc);

      if (sqlMonitor != null)
        sqlMonitor.logRequestTime(proc, System.currentTimeMillis() - start);

      return result;
    }
    catch (SQLException e)
    {
      String msg = Translate.get("loadbalancer.storedprocedure.failed",
          new String[]{String.valueOf(proc.getId()), e.getMessage()});
      logger.warn(msg);
      if (sqlMonitor != null)
        sqlMonitor.logError(proc);
      throw e;
    }
  }

  /* Transaction management */

  public long begin(String login) throws SQLException
  {
    try
    {
      long tid = requestManager.begin(login);
      if (requestLogger.isInfoEnabled())
        requestLogger.info("B " + tid);
      return tid;
    }
    catch (SQLException e)
    {
      String msg = "Begin failed (" + e.getMessage() + ")";
      logger.warn(msg);
      throw e;
    }
  }

  public void commit(long transactionId) throws SQLException
  {
    try
    {
      if (requestLogger.isInfoEnabled())
        requestLogger.info("C " + transactionId);
      requestManager.commit(transactionId);
    }
    catch (SQLException e)
    {
      String msg = "Commit of transaction '" + transactionId + "' failed ("
          + e.getMessage() + ")";
      logger.warn(msg);
      throw e;
    }
  }

  public void rollback(long transactionId) throws SQLException
  {
    try
    {
      if (requestLogger.isInfoEnabled())
        requestLogger.info("R " + transactionId);
      requestManager.rollback(transactionId);
    }
    catch (SQLException e)
    {
      String msg = "Rollback of transaction '" + transactionId + "' failed ("
          + e.getMessage() + ")";
      logger.warn(msg);
      throw e;
    }
  }

  /* Backup management */

  public void backupBackendWithCheckpoint(String backendName,
      String checkpointName, ArrayList tables) throws VirtualDatabaseException
  {
    try
    {
      DatabaseBackend db = getAndCheckBackend(backendName, NO_CHECK_BACKEND);
      requestManager.backupBackendWithCheckpoint(db, checkpointName, tables, db
          .isReadEnabled(), true, null);
    }
    catch (SQLException sql)
    {
      throw new VirtualDatabaseException(sql.getMessage());
    }
  }

  public synchronized void callBackupManager(boolean backup,
      String backendName, String checkpoint, ArrayList tables,
      boolean enableAfter, BackupListener listener)
      throws VirtualDatabaseException
  {
    try
    {
      DatabaseBackend db = getAndCheckBackend(backendName, NO_CHECK_BACKEND);
      requestManager.callBackupManager(backup, db, checkpoint, tables, db
          .isReadEnabled(), listener);
    }
    catch (Exception sql)
    {
      throw new VirtualDatabaseException(sql.getMessage());
    }
  }

  /* Database backends management */

  public void addBackend(DatabaseBackend db) throws VirtualDatabaseException
  {
    this.addBackend(db, true);
  }

  public void addBackend(DatabaseBackend db, boolean checkForCompliance)
      throws VirtualDatabaseException
  {
    if (db == null)
    {
      String msg = "Illegal null database backend in addBackend(DatabaseBackend) method";
      logger.error(msg);
      throw new VirtualDatabaseException(msg);
    }

    if (db.isReadEnabled())
    {
      String msg = "It is not allowed to add an enabled database.";
      logger.error(msg);
      throw new VirtualDatabaseException(msg);
    }

    try
    {
      rwLock.acquireWrite();
    }
    catch (InterruptedException e)
    {
      String msg = Translate.get(
          "loadbalancer.backendlist.acquire.writelock.failed", e);
      logger.error(msg);
      throw new VirtualDatabaseException(msg);
    }

    if (backends.indexOf(db) == -1)
    {
      // Check the authentication manager has all virtual logins defined
      ArrayList logins = authenticationManager.getVirtualLogins();
      VirtualDatabaseUser vdu;
      String login;
      for (int i = 0; i < logins.size(); i++)
      {
        vdu = (VirtualDatabaseUser) logins.get(i);
        login = vdu.getLogin();
        if (db.getConnectionManager(login) == null)
          throw new VirtualDatabaseException(Translate.get(
              "backend.missing.connection.manager", login));
      }

      // Initialize the driver and check the compliance
      try
      {
        if (logger.isDebugEnabled())
          logger.debug("Checking driver compliance");
        if (checkForCompliance)
          db.checkDriverCompliance(); // Also loads
        // the
        // driver
      }
      catch (Exception e)
      {
        rwLock.releaseWrite();
        String msg = "Error while adding database backend " + db.getName()
            + " (" + e + ")";
        logger.warn(msg);
        throw new VirtualDatabaseException(msg);
      }
      db.setSqlShortFormLength(getSQLShortFormLength());
      backends.add(db);

      // Add the backend to the list
      if (logger.isDebugEnabled())
        logger.debug("Backend " + db.getName() + " added successfully");

      rwLock.releaseWrite(); // Relase the lock

      // Jmx
      if (MBeanServerManager.isJmxEnabled())
      {
        // Send notification
        Hashtable data = new Hashtable();
        data.put(CjdbcNotificationList.DATA_DATABASE, this.name);
        data.put(CjdbcNotificationList.DATA_DRIVER, db.getDriverClassName());
        String checkpoint = db.getLastKnownCheckpoint();
        checkpoint = (checkpoint == null) ? "" : checkpoint;
        data.put(CjdbcNotificationList.DATA_CHECKPOINT, checkpoint);
        data.put(CjdbcNotificationList.DATA_NAME, db.getName());
        data.put(CjdbcNotificationList.DATA_URL, db.getURL());
        RmiConnector.broadcastNotification(this,
            CjdbcNotificationList.VIRTUALDATABASE_BACKEND_ADDED,
            CjdbcNotificationList.NOTIFICATION_LEVEL_INFO, Translate.get(
                "notification.backend.added", db.getName()), data);

        // Add backend mbean to jmx server
        ObjectName objectName = JmxConstants.getDatabaseBackendObjectName(name,
            db.getName());
        try
        {
          MBeanServerManager.registerMBean(db, objectName);
        }
        catch (JmxException e1)
        {
          logger.error(Translate.get(
              "virtualdatabase.fail.register.backend.mbean", db.getName()), e1);
        }
      }

    }
    else
    {
      rwLock.releaseWrite();
      String msg = "Duplicate backend " + db.getURL();
      logger.warn(msg);
      throw new VirtualDatabaseException(msg);
    }

  }

  public void removeCheckpoint(String checkpointName)
      throws VirtualDatabaseException
  {
    try
    {
      requestManager.removeCheckpoint(checkpointName);
    }
    catch (Exception e)
    {
      throw new VirtualDatabaseException(e.getMessage());
    }
  }

  public void removeBackend(String backend) throws VirtualDatabaseException
  {
    removeBackend(getAndCheckBackend(backend, NO_CHECK_BACKEND));
  }

  public void removeBackend(DatabaseBackend db) throws VirtualDatabaseException
  {
    if (db == null)
    {
      String msg = "Illegal null database backend in removeBackend(DatabaseBackend) method";
      logger.error(msg);
      throw new VirtualDatabaseException(msg);
    }

    try
    {
      rwLock.acquireWrite();
    }
    catch (InterruptedException e)
    {
      String msg = Translate.get(
          "loadbalancer.backendlist.acquire.writelock.failed", e);
      logger.error(msg);
      throw new VirtualDatabaseException(msg);
    }

    // Sanity checks
    int idx = backends.indexOf(db);
    if (idx == -1)
    {
      rwLock.releaseWrite(); // Release the lock
      String msg = "Trying to remove a non-existing backend " + db.getName();
      logger.warn(msg);
      throw new VirtualDatabaseException(msg);
    }

    if (((DatabaseBackend) backends.get(idx)).isReadEnabled())
    {
      rwLock.releaseWrite(); // Release the lock
      String msg = "Trying to remove an enabled backend " + db.getName();
      logger.error(msg);
      throw new VirtualDatabaseException(msg);
    }

    // Remove it
    backends.remove(idx);
    rwLock.releaseWrite(); // Relase the lock

    // Send notification
    if (MBeanServerManager.isJmxEnabled())
    {
      // Send notification
      Hashtable data = new Hashtable();
      data.put(CjdbcNotificationList.DATA_DATABASE, this.name);
      data.put(CjdbcNotificationList.DATA_DRIVER, db.getDriverClassName());
      String checkpoint = db.getLastKnownCheckpoint();
      checkpoint = (checkpoint == null) ? "" : checkpoint;
      data.put(CjdbcNotificationList.DATA_CHECKPOINT, checkpoint);
      data.put(CjdbcNotificationList.DATA_NAME, db.getName());
      data.put(CjdbcNotificationList.DATA_URL, db.getURL());
      RmiConnector.broadcastNotification(this,
          CjdbcNotificationList.VIRTUALDATABASE_BACKEND_REMOVED,
          CjdbcNotificationList.NOTIFICATION_LEVEL_INFO, Translate.get(
              "notification.backend.removed", db.getName()), data);

      // Remove backend mbean to jmx server
      ObjectName objectName = JmxConstants.getDatabaseBackendObjectName(name,
          db.getName());
      try
      {
        MBeanServerManager.unregister(objectName);
      }
      catch (JmxException e1)
      {
        logger.error(Translate.get(
            "virtualdatabase.fail.unregister.backend.mbean", db.getName()), e1);
      }
    }

    if (logger.isDebugEnabled())
      logger.debug("Backend " + db.getName() + " removed successfully");
  }

  public ArrayList viewCheckpointNames()
  {
    try
    {
      AbstractRecoveryLog recoveryLog = requestManager.getRecoveryLog();
      if (recoveryLog == null)
        return new ArrayList();
      else
        return recoveryLog.getCheckpointNames();
    }
    catch (SQLException e)
    {
      return new ArrayList();
    }
  }

  public void enableBackend(String backendName) throws VirtualDatabaseException
  {
    // Call the Request Manager
    try
    {
      DatabaseBackend backend = getAndCheckBackend(backendName,
          CHECK_BACKEND_ENABLE);

      requestManager.enableBackend(backend);

      // Update the list of database product names
      if (databaseProductNames.indexOf(backend.getDatabaseProductName()) == -1)
        databaseProductNames += "," + backend.getDatabaseProductName();

      // Send notification
      if (MBeanServerManager.isJmxEnabled())
      {
        Hashtable data = new Hashtable();
        data.put("driver", backend.getDriverClassName());
        String checkpoint = backend.getLastKnownCheckpoint();
        checkpoint = (checkpoint == null) ? "" : checkpoint;
        data.put("checkpoint", checkpoint);
        data.put("name", backend.getName());
        data.put("url", backend.getURL());
        RmiConnector.broadcastNotification(this,
            CjdbcNotificationList.VIRTUALDATABASE_BACKEND_ENABLED,
            CjdbcNotificationList.NOTIFICATION_LEVEL_INFO, Translate.get(
                "notification.backend.enabled", backend.getName()), data);
      }
    }
    catch (Exception e)
    {
      e.printStackTrace();
      throw new VirtualDatabaseException(e.getMessage());
    }
  }

  public void enableBackendFromCheckpoint(String backendName,
      String checkpointName) throws VirtualDatabaseException
  {
    // Call the Request Manager
    try
    {
      DatabaseBackend backend = getAndCheckBackend(backendName,
          CHECK_BACKEND_ENABLE);
      requestManager.enableBackendFromCheckpoint(backend, checkpointName);

      // Update the list of database product names
      if (databaseProductNames.indexOf(backend.getDatabaseProductName()) == -1)
        databaseProductNames += "," + backend.getDatabaseProductName();
    }
    catch (Exception e)
    {
      throw new VirtualDatabaseException(
          "Failed to enable backend from checkpoint: " + e);
    }
  }

  public void enableBackendFromLastCheckpoint(String backendName)
      throws VirtualDatabaseException
  {
    DatabaseBackend backend = getAndCheckBackend(backendName, NO_CHECK_BACKEND);
    String checkpoint = backend.getLastKnownCheckpoint();
    if (checkpoint == null)
      throw new VirtualDatabaseException("No last checkpoint for backend:"
          + backendName);
    else
    {
      if (logger.isDebugEnabled())
        logger.debug("Enabling backend:" + backendName
            + " with its last checkpoint:" + backend.getLastKnownCheckpoint());
    }
    enableBackendFromCheckpoint(backendName, backend.getLastKnownCheckpoint());
  }

  public DatabaseBackend getAndCheckBackend(String backendName, int testEnable)
      throws VirtualDatabaseException
  {
    try
    {
      acquireReadLockBackendLists();
    }
    catch (InterruptedException e)
    {
      String msg = "Unable to acquire read lock on backend list in getAndCheckBackend ("
          + e + ")";
      logger.error(msg);
      throw new VirtualDatabaseException(msg);
    }

    // Find the backend
    int size = backends.size();
    DatabaseBackend b = null;
    for (int i = 0; i < size; i++)
    {
      b = (DatabaseBackend) backends.get(i);
      if (b.getName().equals(backendName))
        break;
      else
        b = null;
    }
    // Check not null
    if (b == null)
    {
      releaseReadLockBackendLists();
      String msg = "Trying to access a non-existing backend " + backendName;
      logger.warn(msg);
      throw new VirtualDatabaseException(msg);
    }

    // Check enable/disable
    switch (testEnable)
    {
      case NO_CHECK_BACKEND :
        break;
      case CHECK_BACKEND_DISABLE :
        if (!b.isReadEnabled())
        {
          releaseReadLockBackendLists();
          String msg = "Backend " + backendName + " is already disabled";
          logger.warn(msg);
          throw new VirtualDatabaseException(msg);
        }
        break;
      case CHECK_BACKEND_ENABLE :
        if (b.isReadEnabled())
        {
          releaseReadLockBackendLists();
          String msg = "Backend " + backendName + " is already enabled";
          logger.warn(msg);
          throw new VirtualDatabaseException(msg);
        }
        break;
      default :
        releaseReadLockBackendLists();
        String msg = "Unexpected parameter in getAndCheckBackend(...)";
        logger.error(msg);
        throw new VirtualDatabaseException(msg);
    }

    releaseReadLockBackendLists();

    if (testEnable == CHECK_BACKEND_ENABLE)
    {
      // Initialize backend for enable
      try
      {
        if (logger.isDebugEnabled())
          logger.debug("Initializing connections for backend " + b.getName());
        b.initializeConnections();

        b.checkDriverCompliance();

        if (logger.isDebugEnabled())
          logger.debug("Checking schema for backend " + b.getName());
        b.checkDatabaseSchema();

        DatabaseSchema backendSchema = b.getDatabaseSchema();

        if (backendSchema != null)
          requestManager.mergeDatabaseSchema(backendSchema);
        else
          logger.warn("Backend " + b.getName() + " has no defined schema.");
      }
      catch (SQLException e)
      {
        String msg = "Error while initalizing database backend " + b.getName()
            + " (" + e + ")";
        logger.warn(msg,e);
        throw new VirtualDatabaseException(msg);
      }
    }

    return b;
  }

  public void disableBackend(String backendName)
      throws VirtualDatabaseException
  {
    try
    {
      DatabaseBackend db = getAndCheckBackend(backendName,
          CHECK_BACKEND_DISABLE);
      requestManager.disableBackend(db);
      requestManager.setDatabaseSchema(
          getDatabaseSchemaFromActiveBackendsAndRefreshDatabaseProductNames(),
          false);

      // Send notification
      if (MBeanServerManager.isJmxEnabled())
      {
        Hashtable data = new Hashtable();
        data.put("driver", db.getDriverClassName());
        String checkpoint = db.getLastKnownCheckpoint();
        checkpoint = (checkpoint == null) ? "" : checkpoint;
        data.put("checkpoint", checkpoint);
        data.put("name", db.getName());
        data.put("url", db.getURL());
        RmiConnector.broadcastNotification(this,
            CjdbcNotificationList.VIRTUALDATABASE_BACKEND_DISABLED,
            CjdbcNotificationList.NOTIFICATION_LEVEL_INFO, Translate.get(
                "notification.backend.disabled", db.getName()), data);
      }
    }
    catch (Exception e)
    {
      logger.error("An error occured while disabling backend " + backendName
          + " (" + e + ")");
      throw new VirtualDatabaseException(e.getMessage());
    }
  }

  public void disableAllBackend() throws VirtualDatabaseException
  {
    try
    {
      int size = this.backends.size();
      DatabaseBackend dbe;
      for (int i = 0; i < size; i++)
      {
        dbe = (DatabaseBackend) backends.get(i);
        if (dbe.isReadEnabled())
          requestManager.disableBackend(getAndCheckBackend(dbe.getName(),
              CHECK_BACKEND_DISABLE));
      }
    }
    catch (Exception e)
    {
      throw new VirtualDatabaseException(e.getMessage());
    }
  }

  public void enableAllBackend() throws VirtualDatabaseException
  {
    try
    {
      int size = this.backends.size();
      DatabaseBackend dbe;
      for (int i = 0; i < size; i++)
      {
        dbe = (DatabaseBackend) backends.get(i);
        if (!dbe.isReadEnabled())
          enableBackend(((DatabaseBackend) backends.get(i)).getName());
      }
    }
    catch (Exception e)
    {
      logger.error(e);
      throw new VirtualDatabaseException(e.getMessage());
    }
  }

  public void enableAllBackend(String checkpoint)
      throws VirtualDatabaseException
  {
    if (checkpoint == null || checkpoint.equals(""))
      enableAllBackend();
    else
    {
      try
      {
        int size = this.backends.size();
        DatabaseBackend dbe;
        for (int i = 0; i < size; i++)
        {
          dbe = (DatabaseBackend) backends.get(i);
          if (!dbe.isReadEnabled())
          {
            if (checkpoint == null || checkpoint.equals(""))
              enableBackend(((DatabaseBackend) backends.get(i)).getName());
            else
              enableBackendFromCheckpoint(((DatabaseBackend) backends.get(i))
                  .getName(), checkpoint);
          }
        }
      }
      catch (Exception e)
      {
        throw new VirtualDatabaseException(e.getMessage());
      }
    }
  }

  public void enableAllBackendsFromRecovery(String checkpoint)
      throws VirtualDatabaseException
  {
    AbstractRecoveryLog log = requestManager.getRecoveryLog();
    // If no recovery log is defined ignore call to this method
    if (log == null)
    {
      enableAllBackend();
    }
    else
    {
      try
      {
        int size = this.backends.size();
        DatabaseBackend dbe;
        String backendName;
        BackendRecoveryInfo info;
        for (int i = 0; i < size; i++)
        {
          dbe = (DatabaseBackend) backends.get(i);
          backendName = dbe.getName();
          info = log.getBackendInfo(name, backendName);
          if (info.getBackendState() == BackendState.DISABLED)
            continue;
          if (!dbe.isReadEnabled())
          {
            if (checkpoint == null || checkpoint.equals(""))
              enableBackend(dbe.getName());
            else
              enableBackendFromCheckpoint(dbe.getName(), checkpoint);
          }
        }
      }
      catch (Exception e)
      {
        throw new VirtualDatabaseException(e.getMessage());
      }
    }

  }

  public void disableBackendForCheckpoint(String backendName,
      String checkpointName) throws VirtualDatabaseException
  {
    try
    {
      requestManager.disableBackendForCheckpoint(getAndCheckBackend(
          backendName, CHECK_BACKEND_DISABLE), checkpointName);
      requestManager.setDatabaseSchema(
          getDatabaseSchemaFromActiveBackendsAndRefreshDatabaseProductNames(),
          false);
    }
    catch (Exception e)
    {
      logger.error("An error occured while disabling backend " + backendName
          + " (" + e + ")");
      throw new VirtualDatabaseException(e.getMessage());
    }
  }

  public final void acquireReadLockBackendLists() throws InterruptedException
  {
    rwLock.acquireRead();
  }

  public final void releaseReadLockBackendLists()
  {
    rwLock.releaseRead();
  }

  /* Getter/Setter and tools (equals, ...) */

  public AuthenticationManager getAuthenticationManager()
  {
    return authenticationManager;
  }

  public void setAuthenticationManager(
      AuthenticationManager authenticationManager)
  {
    this.authenticationManager = authenticationManager;
  }

  public ArrayList getBackends()
  {
    return backends;
  }

  public ArrayList getAllBackendNames() throws VirtualDatabaseException
  {
    try
    {
      acquireReadLockBackendLists();
    }
    catch (InterruptedException e)
    {
      String msg = "Unable to acquire read lock on backend list in getAllBackendNames ("
          + e + ")";
      logger.error(msg);
      throw new VirtualDatabaseException(msg);
    }

    int size = backends.size();
    ArrayList result = new ArrayList();
    for (int i = 0; i < size; i++)
    {
      result.add(((DatabaseBackend) backends.get(i)).getName());
    }

    releaseReadLockBackendLists();
    return result;
  }

  public String getDatabaseName()
  {
    return name;
  }

  public String getDatabaseProductName()
  {
    return databaseProductNames;
  }

  public int getSQLShortFormLength()
  {
    return sqlShortFormLength;
  }

  public VirtualDatabaseMetaData getMetaData()
  {
    if (metadata == null)
    {
      metadata = new VirtualDatabaseMetaData(this);
    }
    return metadata;
  }

  public DatabaseSchema getDatabaseSchemaFromActiveBackendsAndRefreshDatabaseProductNames()
      throws SQLException
  {
    try
    {
      acquireReadLockBackendLists();
    }
    catch (InterruptedException e)
    {
      String msg = "Unable to acquire read lock on backend list in getDatabaseSchemaFromActiveBackends ("
          + e + ")";
      logger.error(msg);
      throw new SQLException(msg);
    }
    // Build the new schema from all active backend's schemas
    int size = backends.size();
    DatabaseSchema schema = null;
    DatabaseBackend b = null;
    String dbProductNames = "C-JDBC";
    for (int i = 0; i < size; i++)
    {
      b = (DatabaseBackend) backends.get(i);
      if (b.isReadEnabled())
      {
        if (schema == null)
          schema = b.getDatabaseSchema();
        else
          schema.mergeSchema(b.getDatabaseSchema());
      }

      // Update the list of database product names
      if (dbProductNames.indexOf(b.getDatabaseProductName()) == -1)
        dbProductNames += "," + b.getDatabaseProductName();
    }

    releaseReadLockBackendLists();
    databaseProductNames = dbProductNames;
    logger.debug("getDatabaseSchemaFromActiveBackends - end");
    if (requestManager.getRecoveryLog() != null)
    {
      try
      {
        JDBCRecoveryLog log = (JDBCRecoveryLog) requestManager.getRecoveryLog();
        // Remove recovery log tables from schema
        if (schema.hasTable(log.getBackendTableName()))
          schema.removeTable(new DatabaseTable(log.getBackendTableName()));
        if (schema.hasTable(log.getCheckpointTableName()))
          schema.removeTable(new DatabaseTable(log.getCheckpointTableName()));
        if (schema.hasTable(log.getLogTableName()))
          schema.removeTable(new DatabaseTable(log.getLogTableName()));
      }
      catch (RuntimeException ignore)
      {
        // Should be a ClassCastException
      }
    }
    return schema;
  }

  public void setDatabaseSchema(DatabaseSchema schema, boolean isStatic)
  {
    if (requestManager != null)
      requestManager.setDatabaseSchema(schema, isStatic);
    else
      logger
          .warn("Unable to set database schema, no request manager has been defined.");
  }

  public RequestManager getRequestManager()
  {
    return requestManager;
  }

  public void setRequestManager(RequestManager requestManager)
  {
    this.requestManager = requestManager;
  }

  public String getVirtualDatabaseName()
  {
    return name;
  }

  public SQLMonitoring getSQLMonitor()
  {
    return sqlMonitor;
  }

  public void setSQLMonitor(SQLMonitoring sqlMonitor)
  {
    this.sqlMonitor = sqlMonitor;
  }

  public boolean equals(Object other)
  {
    if ((other == null) || (!(other instanceof VirtualDatabase)))
      return false;
    else
    {
      VirtualDatabase db = (VirtualDatabase) other;
      return name.equals(db.getDatabaseName());
    }
  }

  public String getXml()
  {
    StringBuffer info = new StringBuffer();
    info.append("<C-JDBC>");
    info.append("<" + DatabasesXmlTags.ELT_VirtualDatabase + " "
        + DatabasesXmlTags.ATT_name + "=\"" + this.getName() + "\" "
        + DatabasesXmlTags.ATT_maxNbOfConnections + "=\""
        + this.getMaxNbOfConnections() + "\" "
        + DatabasesXmlTags.ATT_poolThreads + "=\""
        + this.isPoolConnectionThreads() + "\" "
        + DatabasesXmlTags.ATT_minNbOfThreads + "=\""
        + this.getMinNbOfThreads() + "\" "
        + DatabasesXmlTags.ATT_maxNbOfThreads + "=\""
        + this.getMaxNbOfThreads() + "\" "
        + DatabasesXmlTags.ATT_maxThreadIdleTime + "=\""
        + this.getMaxThreadIdleTime() / 1000 + "\" "
        + DatabasesXmlTags.ATT_sqlDumpLength + "=\"" + this.sqlShortFormLength
        + "\" " + DatabasesXmlTags.ATT_blobEncodingMethod + "=\""
        + this.blobFilter.getXml() + "\">");

    info.append(getDistributionXml());

    if (this.getSQLMonitor() != null)
      info.append(sqlMonitor.getXml());

    info.append(requestManager.getBackupManager().getXml());

    if (this.getAuthenticationManager() != null)
      info.append(authenticationManager.getXml());

    try
    {
      acquireReadLockBackendLists();
      int size = backends.size();
      for (int i = 0; i < size; i++)
        info.append(((DatabaseBackend) backends.get(i)).getXml());
      releaseReadLockBackendLists();
    }
    catch (InterruptedException e)
    {
      logger.error(Translate.get("virtualdatabase.fail.read.lock", e));
    }
    if (requestManager != null)
      info.append(requestManager.getXml());
    info.append("</" + DatabasesXmlTags.ELT_VirtualDatabase + ">");
    info.append("</C-JDBC>");
    return info.toString();
  }

  protected String getDistributionXml()
  {
    return "";
  }

  public String getBackendInformation(String backendName)
      throws VirtualDatabaseException
  {
    try
    {
      acquireReadLockBackendLists();
    }
    catch (InterruptedException e)
    {
      String msg = "Unable to acquire read lock on backend list in getBackendInformation ("
          + e + ")";
      logger.error(msg);
      throw new VirtualDatabaseException(msg);
    }

    // Find the backend
    int size = backends.size();
    DatabaseBackend b = null;
    for (int i = 0; i < size; i++)
    {
      b = (DatabaseBackend) backends.get(i);
      if (b.getName().equals(backendName))
        break;
      else
        b = null;
    }

    if (b == null)
    {
      releaseReadLockBackendLists();
      String msg = "Backend " + backendName + " does not exists.";
      logger.warn(msg);
      throw new VirtualDatabaseException(msg);
    }

    releaseReadLockBackendLists();
    return b.getXml();
  }

  // JMX

  public String getName()
  {
    return name;
  }

  public int getCurrentNbOfThreads()
  {
    return currentNbOfThreads;
  }

  public void addCurrentNbOfThread()
  {
    currentNbOfThreads++;
  }

  public void removeCurrentNbOfThread()
  {
    currentNbOfThreads--;
  }

  public int getMinNbOfThreads()
  {
    return minNbOfThreads;
  }

  public boolean isPoolConnectionThreads()
  {
    return poolConnectionThreads;
  }

  public void setMinNbOfThreads(int minNbOfThreads)
  {
    this.minNbOfThreads = minNbOfThreads;
  }

  public void setPoolConnectionThreads(boolean poolConnectionThreads)
  {
    this.poolConnectionThreads = poolConnectionThreads;
  }

  public long getMaxThreadIdleTime()
  {
    return maxThreadIdleTime;
  }

  public void setMaxThreadIdleTime(long maxThreadIdleTime)
  {
    this.maxThreadIdleTime = maxThreadIdleTime;
  }

  public int getMaxNbOfConnections()
  {
    return maxNbOfConnections;
  }

  public int getMaxNbOfThreads()
  {
    return maxNbOfThreads;
  }

  public ArrayList getPendingConnections()
  {
    return pendingConnections;
  }

  public void setMaxNbOfConnections(int maxNbOfConnections)
  {
    this.maxNbOfConnections = maxNbOfConnections;
  }

  public void setMaxNbOfThreads(int maxNbOfThreads)
  {
    this.maxNbOfThreads = maxNbOfThreads;
  }

  public ArrayList getActiveThreads()
  {
    return activeThreads;
  }

  public String[] viewBackendInformation(String backendName)
      throws VirtualDatabaseException
  {
    DatabaseBackend backend = getAndCheckBackend(backendName, NO_CHECK_BACKEND);
    return backend.getBackendData();
  }

  public void addIdleThread()
  {
    idleThreads++;
  }

  public void removeIdleThread()
  {
    idleThreads--;
  }

  public int getIdleThreads()
  {
    return idleThreads;
  }

  public ArrayList viewAllBackendNames() throws VirtualDatabaseException
  {
    return this.getAllBackendNames();
  }

  public ArrayList viewAllClientNames()
  {
    ArrayList list = this.getActiveThreads();
    int size = list.size();
    ArrayList clients = new ArrayList(size);
    for (int i = 0; i < list.size(); i++)
      clients.add(((VirtualDatabaseWorkerThread) list.get(i)).getUser());
    return clients;
  }

  public void disableAllBackendForCheckpoint(String checkpoint)
      throws VirtualDatabaseException
  {
    if (checkpoint == null)
    {
      disableAllBackend();
      return;
    }

    try
    {
      this.acquireReadLockBackendLists();
      requestManager.disableBackendsForCheckpoint(backends, checkpoint);
      this.releaseReadLockBackendLists();
    }
    catch (Exception e)
    {
      throw new VirtualDatabaseException(e.getMessage());
    }
  }

  /* Shutdown */

  public void shutdown(int level)
  {
    if (shuttingDown)
      return;
    shuttingDown = true;
    VirtualDatabaseShutdownThread vdst = new VirtualDatabaseShutdownThread(
        this, level);
    new Thread(vdst.getShutdownGroup(), vdst, "VirtualDatabase Shutdown Thread")
        .start();
  }

  public void shutdown() throws VirtualDatabaseException
  {
    shutdown(Constants.CONTROLLER_SHUTDOWN_FAST);
  }

  public void setBlobFilter(AbstractBlobFilter filter)
  {
    this.blobFilter = filter;
  }

  public AbstractBlobFilter getBlobFilter()
  {
    return blobFilter;
  }

  public void setBackendLastKnownCheckpoint(String backendName,
      String checkpoint) throws VirtualDatabaseException
  {
    AbstractRecoveryLog log = requestManager.getRecoveryLog();
    DatabaseBackend backend = getAndCheckBackend(backendName, NO_CHECK_BACKEND);
    if (log == null)
      throw new VirtualDatabaseException(ExceptionTypes.NO_RECOVERY_LOG);
    else
    {
      if (!backend.isDisabled())
        throw new VirtualDatabaseException(
            "Cannot setLastKnownCheckpoint on a non-disabled backend");
      else
      {
        try
        {
          log.storeBackendInfo(name, backendName, checkpoint, backend
              .getStateValue());
          backend.setLastKnownCheckpoint(checkpoint);
        }
        catch (SQLException e)
        {
          throw new VirtualDatabaseException(
              "Failed to store recovery info for backend:" + backendName);
        }
      }
    }

  }

  public String getBackendState(String backendName)
      throws VirtualDatabaseException
  {
    DatabaseBackend backend = getAndCheckBackend(backendName, NO_CHECK_BACKEND);
    return backend.getState();
  }

  public String viewOwningController()
  {
    return controller.getJmxName();
  }

  public void restoreBackendFromBackupCheckpoint(String databaseBackendName,
      String checkpointName) throws VirtualDatabaseException, BackupException,
      OctopusException
  {
    DatabaseBackend backend = getAndCheckBackend(databaseBackendName,
        NO_CHECK_BACKEND);
    // Backend cannot be null, otherwise the above throws an
    // VirtualDatabaseException
    requestManager.restoreBackendFromBackupCheckpoint(backend, checkpointName,
        true, null);
  }

  public void storeBackendsInfo()
  {
    requestManager.storeBackendsInfo(this.name, getBackends());
  }

  public boolean hasRecoveryLog()
  {
    AbstractRecoveryLog log = requestManager.getRecoveryLog();
    if (log == null)
      return false;
    else
      return true;
  }

  public void replicateBackend(String backendName, String newBackendName,
      Map parameters) throws VirtualDatabaseException
  {
    // Access the backend we want to replicate
    DatabaseBackend backend = getAndCheckBackend(backendName, NO_CHECK_BACKEND);
    DatabaseBackend newBackend = null;

    // Create a clone of the backend with additionnal parameters
    try
    {
      newBackend = backend.copy(newBackendName, parameters);
    }
    catch (Exception e)
    {
      String msg = Translate.get("virtualdatabase.fail.backend.copy");
      logger.warn(msg, e);
      throw new VirtualDatabaseException(msg);
    }

    // Add the backend to the virtual database.
    addBackend(newBackend);
  }

  public String[][] retrieveBackendsData() throws VirtualDatabaseException
  {
    try
    {
      acquireReadLockBackendLists();
    }
    catch (InterruptedException e)
    {
      String msg = Translate.get("virtualdatabase.fail.read.lock", e);
      throw new VirtualDatabaseException(msg);
    }
    ArrayList backends = this.getBackends();
    int backendListSize = backends.size();
    String[][] data = new String[backendListSize][];
    for (int i = 0; i < backendListSize; i++)
    {
      data[i] = ((DatabaseBackend) backends.get(i)).getBackendData();
    }
    releaseReadLockBackendLists();
    return data;
  }

  public String[] viewControllerList()
  {
    return new String[]{viewOwningController()};
  }

  public Hashtable viewGroupBackends() throws VirtualDatabaseException
  {
    Hashtable map = new Hashtable();
    map.put(controller.getJmxName(), viewAllBackendNames());
    return map;
  }

  public void transferBackend(String backend, String controllerDestination)
      throws VirtualDatabaseException
  {
    throw new VirtualDatabaseException("Cannot transfer backend to controller:"
        + controllerDestination + " because database is not distributed");
  }
}

---