src/org/objectweb/cjdbc/controller/backend/DatabaseBackend.java

説明を見る。

package org.objectweb.cjdbc.controller.backend;

import java.io.Serializable;
import java.io.StringReader;
import java.net.ConnectException;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Vector;

import javax.management.NotCompliantMBeanException;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.objectweb.cjdbc.common.i18n.Translate;
import org.objectweb.cjdbc.common.jmx.mbeans.DatabaseBackendMBean;
import org.objectweb.cjdbc.common.jmx.notifications.CjdbcNotificationList;
import org.objectweb.cjdbc.common.log.Trace;
import org.objectweb.cjdbc.common.shared.BackendInfo;
import org.objectweb.cjdbc.common.shared.BackendState;
import org.objectweb.cjdbc.common.sql.schema.DatabaseSchema;
import org.objectweb.cjdbc.common.xml.DatabasesXmlTags;
import org.objectweb.cjdbc.common.xml.XmlComponent;
import org.objectweb.cjdbc.controller.backend.rewriting.AbstractRewritingRule;
import org.objectweb.cjdbc.controller.connection.AbstractConnectionManager;
import org.objectweb.cjdbc.controller.connection.FailFastPoolConnectionManager;
import org.objectweb.cjdbc.controller.connection.RandomWaitPoolConnectionManager;
import org.objectweb.cjdbc.controller.connection.SimpleConnectionManager;
import org.objectweb.cjdbc.controller.connection.VariablePoolConnectionManager;
import org.objectweb.cjdbc.controller.jmx.AbstractStandardMBean;
import org.objectweb.cjdbc.controller.jmx.MBeanServerManager;
import org.objectweb.cjdbc.controller.jmx.RmiConnector;

public class DatabaseBackend extends AbstractStandardMBean
    implements
      Serializable,
      XmlComponent,
      DatabaseBackendMBean
{
  //
  // How the code is organized?
  // 1. Member variables
  // 2. Constructor(s)
  // 3. Lookup functions
  // 4. Connections management
  // 5. State management
  // 6. Getter/Setter (possibly in alphabetical order)
  // 7. Debug/Monitoring
  //

  private String                         name;

  private String                         driverPath;

  private String                         driverClassName;

  private transient DriverCompliance     driverCompliance;

  private String                         url;

  private boolean                        writeCanBeEnabled;

  private String                         connectionTestStatement;

  private DatabaseSchema                 schema;

  private boolean                        schemaIsStatic     = false;

  private transient HashMap              connectionManagers;

  protected transient Trace              logger;

  private transient ArrayList            activeTransactions = new ArrayList();

  private transient Vector               pendingRequests    = new Vector();

  private int                            totalRequest;
  private int                            totalWriteRequest;
  private int                            totalReadRequest;
  private int                            totalTransactions;

  private ArrayList                      rewritingRules;

  private int                            dynamicPrecision;
  private boolean                        gatherSystemTables = false;

  private int                            sqlShortFormLength = 40;

  private String                         lastKnownCheckpoint;

  private int                            state              = BackendState.DISABLED;

  private transient BackendStateListener stateListener;

  public DatabaseBackend(String name, String driverPath,
      String driverClassName, String url, boolean writeCanBeEnabled,
      String connectionTestStatement) throws NotCompliantMBeanException
  {
    super(DatabaseBackendMBean.class);
    if (name == null)
      throw new IllegalArgumentException(Translate
          .get("backend.null.backend.name"));

    if (driverClassName == null)
      throw new IllegalArgumentException(Translate.get("backend.null.driver"));

    if (url == null)
      throw new IllegalArgumentException(Translate.get("backend.null.url"));

    if (connectionTestStatement == null)
      throw new IllegalArgumentException(Translate
          .get("backend.null.connection.test"));

    this.name = name;
    this.writeCanBeEnabled = writeCanBeEnabled;
    this.driverPath = driverPath;
    this.driverClassName = driverClassName;
    this.url = url;
    this.connectionTestStatement = connectionTestStatement;
    this.connectionManagers = new HashMap();
    logger = Trace
        .getLogger("org.objectweb.cjdbc.controller.backend.DatabaseBackend."
            + name);
    this.driverCompliance = new DriverCompliance(logger);
    totalRequest = 0;
    dynamicPrecision = DatabaseBackendSchemaConstants.DynamicPrecisionAll;
  }

  public DatabaseBackend(BackendInfo info) throws NotCompliantMBeanException
  {
    this(info.getName(), info.getDriverPath(), info.getDriverClassName(), info
        .getUrl(), true, info.getConnectionTestStatement());
    try
    {
      String xml = info.getXml();
      StringReader sreader = new StringReader(xml);
      SAXReader reader = new SAXReader();
      Document document = reader.read(sreader);
      Element root = document.getRootElement();
      Iterator iter1 = root.elementIterator();
      while (iter1.hasNext())
      {
        Element elem = (Element) iter1.next();
        if (elem.getName().equals(DatabasesXmlTags.ELT_ConnectionManager))
        {
          String vuser = elem.valueOf("@" + DatabasesXmlTags.ATT_vLogin);
          String rlogin = elem.valueOf("@" + DatabasesXmlTags.ATT_rLogin);
          String rpassword = elem.valueOf("@" + DatabasesXmlTags.ATT_rPassword);
          Iterator iter2 = elem.elementIterator();
          while (iter2.hasNext())
          {
            Element connectionManager = (Element) iter2.next();
            String cname = connectionManager.getName();
            if (cname
                .equals(DatabasesXmlTags.ELT_VariablePoolConnectionManager))
            {
              int minPoolSize = Integer.parseInt(connectionManager.valueOf("@"
                  + DatabasesXmlTags.ATT_minPoolSize));
              int maxPoolSize = Integer.parseInt(connectionManager.valueOf("@"
                  + DatabasesXmlTags.ATT_maxPoolSize));
              int idleTimeout = Integer.parseInt(connectionManager.valueOf("@"
                  + DatabasesXmlTags.ATT_idleTimeout));
              int waitTimeout = Integer.parseInt(connectionManager.valueOf("@"
                  + DatabasesXmlTags.ATT_waitTimeout));
              this.addConnectionManager(vuser,
                  new VariablePoolConnectionManager(url, name, rlogin,
                      rpassword, driverPath, driverClassName, minPoolSize,
                      maxPoolSize, idleTimeout, waitTimeout));
            }
            else if (cname.equals(DatabasesXmlTags.ELT_SimpleConnectionManager))
            {
              this.addConnectionManager(vuser, new SimpleConnectionManager(url,
                  name, rlogin, rpassword, driverPath, driverClassName));
            }
            else if (cname
                .equals(DatabasesXmlTags.ELT_RandomWaitPoolConnectionManager))
            {
              int poolSize = Integer.parseInt(connectionManager.valueOf("@"
                  + DatabasesXmlTags.ATT_poolSize));
              int timeout = Integer.parseInt(connectionManager.valueOf("@"
                  + DatabasesXmlTags.ATT_timeout));
              this
                  .addConnectionManager(vuser,
                      new RandomWaitPoolConnectionManager(url, name, rlogin,
                          rpassword, driverPath, driverClassName, poolSize,
                          timeout));
            }
            else if (cname
                .equals(DatabasesXmlTags.ELT_FailFastPoolConnectionManager))
            {
              int poolSize = Integer.parseInt(connectionManager.valueOf("@"
                  + DatabasesXmlTags.ATT_poolSize));
              this.addConnectionManager(vuser,
                  new FailFastPoolConnectionManager(url, name, rlogin,
                      rpassword, driverPath, driverClassName, poolSize));
            }
          }
        }
      }

    }
    catch (Exception e)
    {
      logger
          .error(Translate.get("backend.add.connection.manager.failed", e), e);
    }
  }

  public DatabaseBackend(String name, String driverPath,
      String driverClassName, String url, String connectionTestStatement,
      String dynamicSchemaLevel) throws NotCompliantMBeanException
  {
    this(name, driverPath, driverClassName, url, true, connectionTestStatement);
    this.dynamicPrecision = DatabaseBackendSchemaConstants
        .getDynamicSchemaLevel(dynamicSchemaLevel);
  }

  public void setSqlShortFormLength(int sqlShortFormLength)
  {
    this.sqlShortFormLength = sqlShortFormLength;
  }

  public int getSQLShortFormLength()
  {
    return sqlShortFormLength;
  }

  /* Lookup functions */

  public boolean equals(Object other)
  {
    if ((other == null) || (!(other instanceof DatabaseBackend)))
      return false;
    else
    {
      DatabaseBackend b = (DatabaseBackend) other;
      return name.equals(b.getName())
          && driverClassName.equals(b.getDriverClassName())
          && url.equals(b.getURL());
    }
  }

  public boolean hasTables(ArrayList tables)
  {
    if (schema == null)
      throw new NullPointerException(Translate.get("backend.schema.not.set"));

    if (tables == null)
      throw new IllegalArgumentException(Translate.get("backend.null.tables"));

    int size = tables.size();
    for (int i = 0; i < size; i++)
    {
      if (!schema.hasTable((String) tables.get(i)))
        return false;
    }
    return true;
  }

  public boolean hasTable(String table)
  {
    if (schema == null)
      throw new NullPointerException(Translate.get("backend.schema.not.set"));

    return schema.hasTable(table);
  }

  public ArrayList getTables()
  {
    if (schema == null)
      throw new NullPointerException(Translate.get("backend.schema.not.set"));
    return schema.getTables();
  }

  public boolean hasStoredProcedure(String procedureName)
  {
    if (schema == null)
      throw new NullPointerException(Translate.get("backend.schema.not.set"));

    return schema.hasProcedure(procedureName);
  }

  /* Connection management */

  public synchronized void initializeConnections() throws SQLException
  {
    if (connectionManagers.isEmpty())
      throw new SQLException(Translate.get("backend.not.defined", new String[]{
          name, url}));

    AbstractConnectionManager connectionManager;
    Iterator iter = connectionManagers.values().iterator();
    while (iter.hasNext())
    {
      connectionManager = (AbstractConnectionManager) iter.next();
      if (!connectionManager.isInitialized())
        connectionManager.initializeConnections();
    }
  }

  public synchronized void finalizeConnections() throws SQLException
  {
    if (connectionManagers.isEmpty())
      throw new SQLException(Translate.get("backend.not.defined", new String[]{
          name, url}));

    AbstractConnectionManager connectionManager;
    Iterator iter = connectionManagers.values().iterator();
    while (iter.hasNext())
    {
      connectionManager = (AbstractConnectionManager) iter.next();
      if (connectionManager.isInitialized())
        connectionManager.finalizeConnections();
    }
  }

  public final boolean isValidConnection(Connection connection)
  {
    try
    {
      Statement s = connection.createStatement();
      s.executeQuery(connectionTestStatement);
    }
    catch (SQLException e)
    {
      if ("25P02".equals(e.getSQLState())
          || (e.getMessage() != null && e
              .getMessage()
              .indexOf(
                  "current transaction is aborted, queries ignored until end of transaction block") > 0))
      {
        // see bug item #300873 on the forge for details
        // postgres throws an exception if a query is issued after a request has
        // failed within a transaction, we now have to check for this exception
        // as it is means the connection is valid
        //
        // postgres versions after 7.4 will return the SQLState, whereas
        // postgres versions prior to 7.4 will have to be checked for the
        // message text
        return true;
      }
      return false;
    }
    return true;
  }

  public void addConnectionManager(String vLogin,
      AbstractConnectionManager connectionManager)
  {
    if (connectionManager == null)
      throw new IllegalArgumentException(Translate.get(
          "backend.null.connection.manager", new String[]{name, url}));
    if (logger.isInfoEnabled())
      logger.info(Translate.get("backend.add.connection.manager.for.user",
          vLogin));
    connectionManager.setVLogin(vLogin);
    connectionManagers.put(vLogin, connectionManager);
  }

  /* State management */

  public void startTransaction(Long tid)
  {
    synchronized (activeTransactions)
    {
      totalTransactions++;
      activeTransactions.add(tid);
    }
  }

  public void stopTransaction(Long tid)
  {
    synchronized (activeTransactions)
    {
      if (!activeTransactions.remove(tid))
        throw new IllegalArgumentException(Translate.get(
            "backend.transaction.not.started", new String[]{"" + tid, name}));
      // If this was the last open transaction, we notify people possibly
      // waiting on waitForAllTransactionsToComplete()
      if (activeTransactions.isEmpty())
      {
        activeTransactions.notifyAll();
      }
    }
  }

  public void waitForAllTransactionsToComplete()
  {
    synchronized (activeTransactions)
    {
      if (activeTransactions.isEmpty())
        return;
      else
        try
        {
          activeTransactions.wait();
        }
        catch (InterruptedException ignore)
        {
        }
    }
  }

  public boolean isStartedTransaction(Long tid)
  {
    return activeTransactions.contains(tid);
  }

  public final synchronized boolean isInitialized() throws SQLException
  {
    if (connectionManagers.isEmpty())
      throw new SQLException(Translate.get("backend.null.connection.manager",
          new String[]{name, url}));
    Iterator iter = connectionManagers.values().iterator();
    while (iter.hasNext())
    {
      if (!((AbstractConnectionManager) iter.next()).isInitialized())
        return false;
    }
    return true;
  }

  public final synchronized boolean isReadEnabled()
  {
    return state == BackendState.READ_ENABLED_WRITE_DISABLED
        || state == BackendState.READ_ENABLED_WRITE_ENABLED;
  }

  public final synchronized boolean isWriteEnabled()
  {
    return state == BackendState.READ_ENABLED_WRITE_ENABLED
        || state == BackendState.READ_DISABLED_WRITE_ENABLED
        || state == BackendState.DISABLING;
  }

  public final boolean isRecovering()
  {
    return state == BackendState.RECOVERING;
  }

  public final boolean isDisabling()
  {
    return state == BackendState.DISABLING;
  }

  public final boolean isDisabled()
  {
    return state == BackendState.DISABLED;
  }

  public final boolean isKilled()
  {
    return state == BackendState.UNKNOWN;
  }

  public String getState()
  {
    switch (state)
    {
      case BackendState.READ_ENABLED_WRITE_DISABLED :
        return CjdbcNotificationList.VIRTUALDATABASE_BACKEND_ENABLED;
      case BackendState.READ_ENABLED_WRITE_ENABLED :
        return CjdbcNotificationList.VIRTUALDATABASE_BACKEND_ENABLED_WRITE;
      case BackendState.READ_DISABLED_WRITE_ENABLED :
        return CjdbcNotificationList.VIRTUALDATABASE_BACKEND_ENABLED_WRITE;
      case BackendState.DISABLING :
        return CjdbcNotificationList.VIRTUALDATABASE_BACKEND_DISABLING;
      case BackendState.BACKUPING :
        return CjdbcNotificationList.VIRTUALDATABASE_BACKEND_BACKINGUP;
      case BackendState.RECOVERING :
        return CjdbcNotificationList.VIRTUALDATABASE_BACKEND_RECOVERING;
      case BackendState.DISABLED :
        return CjdbcNotificationList.VIRTUALDATABASE_BACKEND_DISABLED;
      case BackendState.UNKNOWN :
        return CjdbcNotificationList.VIRTUALDATABASE_BACKEND_UNKNOWN;
      default :
        throw new IllegalArgumentException("Unknown backend state:" + state);
    }
  }

  public int getStateValue()
  {
    return state;
  }

  public synchronized void enableRead()
  {
    if (isWriteEnabled())
      setState(BackendState.READ_ENABLED_WRITE_ENABLED);
    else
      setState(BackendState.READ_ENABLED_WRITE_DISABLED);
  }

  public synchronized void disableRead()
  {
    if (isWriteEnabled())
      setState(BackendState.READ_DISABLED_WRITE_ENABLED);
    else
      setState(BackendState.DISABLED);
  }

  public synchronized void disableWrite()
  {
    if (isReadEnabled())
      setState(BackendState.READ_ENABLED_WRITE_DISABLED);
    else
      setState(BackendState.DISABLED);
  }

  public synchronized void enableWrite()
  {
    if (isReadEnabled())
      setState(BackendState.READ_ENABLED_WRITE_ENABLED);
    else
      setState(BackendState.READ_DISABLED_WRITE_ENABLED);
  }

  public void setDisabling()
  {
    setState(BackendState.DISABLING);
  }

  public synchronized void disable()
  {
    setState(BackendState.DISABLED);
  }

  /* Getter/setter methods */

  public AbstractConnectionManager getConnectionManager(String vLogin)
  {
    return (AbstractConnectionManager) connectionManagers.get(vLogin);
  }

  public HashMap getConnectionManagers()
  {
    return this.connectionManagers;
  }

  public String getConnectionTestStatement()
  {
    return connectionTestStatement;
  }

  public String getDriverPath()
  {
    return driverPath;
  }

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

  public String getDriverClassName()
  {
    return driverClassName;
  }

  public String getName()
  {
    return name;
  }

  public Vector getPendingRequests()
  {
    return pendingRequests;
  }

  public void addPendingReadRequest(Object request)
  {
    synchronized (this)
    {
      totalRequest++;
      totalReadRequest++;
    }
    pendingRequests.add(request);
  }

  public void addPendingWriteRequest(Object request)
  {
    synchronized (this)
    {
      totalRequest++;
      totalWriteRequest++;
    }
    pendingRequests.add(request);
  }

  public boolean removePendingRequest(Object request)
  {
    return pendingRequests.remove(request);
  }

  public DatabaseSchema getDatabaseSchema()
  {
    return schema;
  }

  public void setDatabaseSchema(DatabaseSchema databaseSchema, boolean isStatic)
  {
    if (schema == null)
    {
      schemaIsStatic = isStatic;
      schema = databaseSchema;
    }
    else
    {
      if (!isStatic)
        schema = databaseSchema;
    }
  }

  public boolean checkDatabaseSchema()
  {
    if (logger.isDebugEnabled())
      logger.debug(Translate.get("backend.dynamic.schema",
          DatabaseBackendSchemaConstants
              .getDynamicSchemaLevel(dynamicPrecision)));
    boolean checked = true;
    AbstractConnectionManager connectionMananger;
    Iterator iter = connectionManagers.values().iterator();
    while (iter.hasNext())
    {
      connectionMananger = (AbstractConnectionManager) iter.next();

      // Gather the database schema from this connection manager
      DatabaseBackendMetaData meta = new DatabaseBackendMetaData(
          connectionMananger, logger, dynamicPrecision, gatherSystemTables);

      DatabaseSchema metaSchema;
      try
      {
        if (logger.isInfoEnabled())
          logger.info(Translate.get("backend.gathering.database.schema"));
        metaSchema = meta.getDatabaseSchema();
      }
      catch (SQLException e)
      {
        if (logger.isWarnEnabled())
          logger.warn(Translate.get("backend.gather.schema.failed", e));
        return false;
      }
      if (schema == null)
      {
        if (logger.isDebugEnabled())
          logger.debug(Translate.get("backend.use.gathered.schema.as.new"));
        schema = metaSchema;
      }
      else
      {
        if (logger.isInfoEnabled())
          logger.info(Translate.get("backend.check.schema.compatibility"));
        if (schema.isCompatibleSubset(metaSchema))
          logger.info(Translate.get("backend.schema.compatible.for.login",
              connectionMananger.getLogin()));
        else
        {
          checked = false;
          logger.warn(Translate.get("backend.schema.not.compatible.for.login",
              connectionMananger.getLogin()));
        }
      }
    }
    return checked;
  }

  public DriverCompliance getDriverCompliance()
  {
    return driverCompliance;
  }

  public void checkDriverCompliance() throws SQLException
  {
    if (connectionManagers.isEmpty())
      throw new SQLException(Translate.get("backend.null.connection.manager",
          new String[]{name, url}));

    AbstractConnectionManager connectionManager;
    Iterator iter = connectionManagers.values().iterator();
    connectionManager = (AbstractConnectionManager) iter.next();

    try
    {
      if (!driverCompliance.complianceTest(url, connectionManager.getLogin(),
          connectionManager.getPassword(), connectionManager.getDriverPath(),
          connectionManager.getDriverClassName(), connectionTestStatement))
        throw new SQLException(Translate.get("backend.driver.not.compliant",
            driverClassName));
    }
    catch (ConnectException e)
    {
      throw new SQLException(Translate.get("backend.cannot.connect.to", e));
    }
  }

  public String getURL()
  {
    return url;
  }

  /*
   * Rewriting Rule management
   */

  public void addRewritingRule(AbstractRewritingRule rule)
  {
    if (rewritingRules == null)
      rewritingRules = new ArrayList();
    if (logger.isDebugEnabled())
      logger.debug(Translate.get("backend.rewriting.rule.add", new String[]{
          rule.getQueryPattern(), rule.getRewrite()}));
    rewritingRules.add(rule);
  }

  public final String rewriteQuery(String sqlQuery)
  {
    if (rewritingRules == null)
      return sqlQuery;
    int size = rewritingRules.size();
    for (int i = 0; i < size; i++)
    {
      AbstractRewritingRule rule = (AbstractRewritingRule) rewritingRules
          .get(i);
      sqlQuery = rule.rewrite(sqlQuery);
      if (rule.hasMatched())
      { //Rule matched, query rewriten
        if (logger.isDebugEnabled())
          logger.debug(Translate.get("backend.rewriting.query", sqlQuery));
        if (rule.isStopOnMatch())
          break; //Ok, stop here.
      }
    }
    return sqlQuery;
  }

  /*
   * Debug/Monitoring
   */

  public String getXml()
  {
    StringBuffer info = new StringBuffer();
    info.append("<" + DatabasesXmlTags.ELT_DatabaseBackend + " "
        + DatabasesXmlTags.ATT_name + "=\"" + name + "\" "
        + DatabasesXmlTags.ATT_driver + "=\"" + driverClassName + "\" "
        + DatabasesXmlTags.ATT_url + "=\"" + url + "\" "
        + DatabasesXmlTags.ATT_connectionTestStatement + "=\""
        + connectionTestStatement + "\">");

    info.append("<"
        + DatabasesXmlTags.ELT_DatabaseSchema
        + " "
        + DatabasesXmlTags.ATT_dynamicPrecision
        + "=\""
        + DatabaseBackendSchemaConstants
            .getDynamicSchemaLevel(dynamicPrecision) + "\" "
        + DatabasesXmlTags.ATT_gatherSystemTables + "=\""
        + (gatherSystemTables ? "true" : "false") + "\">");
    if (this.schema != null && dynamicPrecision ==0)
    {
      info.append(schema.getXml());
    }
    info.append("</" + DatabasesXmlTags.ELT_DatabaseSchema + ">");
    if (rewritingRules != null)
    {
      int size = rewritingRules.size();
      for (int i = 0; i < size; i++)
        info.append(((AbstractRewritingRule) rewritingRules.get(i)).getXml());
    }
    if (connectionManagers != null)
    {
      if (connectionManagers.isEmpty() == false)
      {
        AbstractConnectionManager connectionManager;
        Iterator iter = connectionManagers.values().iterator();
        while (iter.hasNext())
        {
          connectionManager = (AbstractConnectionManager) iter.next();
          info.append(connectionManager.getXml());
        }
      }
    }
    info.append("</" + DatabasesXmlTags.ELT_DatabaseBackend + ">");
    return info.toString();
  }

  public ArrayList getActiveTransactions()
  {
    return activeTransactions;
  }

  public boolean isSchemaStatic()
  {
    return schemaIsStatic;
  }

  public String[] getBackendData()
  {
    String[] data = new String[14];
    data[0] = this.name;
    data[1] = this.driverClassName;
    data[2] = this.url;
    data[3] = String.valueOf(this.activeTransactions.size());
    data[4] = String.valueOf(this.pendingRequests.size());
    data[5] = String.valueOf(this.isReadEnabled());
    data[6] = String.valueOf(this.isWriteEnabled());
    try
    {
      data[7] = String.valueOf(this.isInitialized());
    }
    catch (Exception e)
    {
      data[7] = "unknown";
    }
    data[8] = String.valueOf(this.schemaIsStatic);

    data[9] = String.valueOf(this.connectionManagers.size());
    data[10] = String.valueOf(getTotalActiveConnections());
    data[11] = String.valueOf(totalRequest);
    data[12] = String.valueOf(totalTransactions);
    if (lastKnownCheckpoint == null || lastKnownCheckpoint.equalsIgnoreCase(""))
      data[13] = "<unknown>";
    else
      data[13] = lastKnownCheckpoint;
    return data;
  }

  public long getTotalActiveConnections()
  {
    int activeConnections = 0;
    Iterator iter = connectionManagers.keySet().iterator();
    while (iter.hasNext())
      activeConnections += ((AbstractConnectionManager) connectionManagers
          .get(iter.next())).getCurrentNumberOfConnections();
    return activeConnections;
  }

  public int getDynamicPrecision()
  {
    return dynamicPrecision;
  }

  public void setDynamicPrecision(int dynamicPrecision,
      boolean gatherSystemTables)
  {
    this.dynamicPrecision = dynamicPrecision;
    this.gatherSystemTables = gatherSystemTables;
  }

  public int getTotalTransactions()
  {
    return totalTransactions;
  }

  public int getTotalReadRequest()
  {
    return totalReadRequest;
  }

  public int getTotalWriteRequest()
  {
    return totalWriteRequest;
  }

  public int getTotalRequest()
  {
    return totalRequest;
  }

  public void setLastKnownCheckpoint(String checkpoint)
  {
    this.lastKnownCheckpoint = checkpoint;
  }

  public String getLastKnownCheckpoint()
  {
    return lastKnownCheckpoint;
  }

  public String getDatabaseProductName()
  {
    return driverCompliance.getDatabaseProductName();
  }

  public ArrayList getRewritingRules()
  {
    return rewritingRules;
  }

  public void setRewritingRules(ArrayList rewritingRules)
  {
    this.rewritingRules = rewritingRules;
  }

  public DatabaseBackend copy(String newName, Map parameters) throws Exception
  {
    //  Get the parameters from the backend if they are not specified, or take
    // them from the map of parameters otherwise.
    String driverPath = parameters.containsKey(DatabasesXmlTags.ATT_driverPath)
        ? (String) parameters.get(DatabasesXmlTags.ATT_driverPath)
        : this.getDriverPath();

    String driverClassName = parameters
        .containsKey(DatabasesXmlTags.ATT_driver) ? (String) parameters
        .get(DatabasesXmlTags.ATT_driver) : this.getDriverClassName();

    String url = parameters.containsKey(DatabasesXmlTags.ATT_url)
        ? (String) parameters.get(DatabasesXmlTags.ATT_url)
        : this.getURL();

    String connectionTestStatement = parameters
        .containsKey(DatabasesXmlTags.ATT_connectionTestStatement)
        ? (String) parameters.get(DatabasesXmlTags.ATT_connectionTestStatement)
        : this.getConnectionTestStatement();

    // Create the new backend object
    DatabaseBackend newBackend = new DatabaseBackend(newName, driverPath,
        driverClassName, url, writeCanBeEnabled, connectionTestStatement);

    // Set the rewriting rules and the connection managers as the backend we
    // are copying
    newBackend.setRewritingRules(this.getRewritingRules());

    // Set Connection managers
    HashMap connectionManagers = this.getConnectionManagers();
    Iterator iter = connectionManagers.keySet().iterator();

    String vlogin = null;
    AbstractConnectionManager connectionManager;
    while (iter.hasNext())
    {
      vlogin = (String) iter.next();
      connectionManager = (AbstractConnectionManager) connectionManagers
          .get(vlogin);
      newBackend.addConnectionManager(vlogin, connectionManager.copy(url,
          newName));
    }

    return newBackend;

  }

  public boolean isBackuping()
  {
    return state == BackendState.BACKUPING;
  }

  public synchronized void setState(int state)
  {
    switch (state)
    {
      case BackendState.READ_ENABLED_WRITE_DISABLED :
      case BackendState.READ_ENABLED_WRITE_ENABLED :
      case BackendState.READ_DISABLED_WRITE_ENABLED :
      case BackendState.DISABLING :
      case BackendState.BACKUPING :
      case BackendState.RECOVERING :
      case BackendState.DISABLED :
      case BackendState.UNKNOWN :
        this.state = state;
        if (logger.isDebugEnabled())
          logger.debug(Translate.get("backend.state.changed", new String[]{
              name, getState()}));
        notifyStateChange();
        break;
      default :
        throw new IllegalArgumentException("Unknown backend state:" + state);
    }
  }

  public void notifyStateChange()
  {
    if (stateListener != null)
      stateListener.changeState(this);

    notifyJmx(getState());
  }

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

  public boolean isWriteCanBeEnabled()
  {
    return writeCanBeEnabled;
  }

  public void setStateListener(BackendStateListener stateListener)
  {
    this.stateListener = stateListener;
  }
}

---