src/org/objectweb/cjdbc/controller/loadbalancer/AbstractLoadBalancer.java

説明を見る。

package org.objectweb.cjdbc.controller.loadbalancer;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;

import org.objectweb.cjdbc.common.exceptions.BadConnectionException;
import org.objectweb.cjdbc.common.i18n.Translate;
import org.objectweb.cjdbc.common.log.Trace;
import org.objectweb.cjdbc.common.sql.AbstractRequest;
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.MacrosHandler;
import org.objectweb.cjdbc.common.xml.DatabasesXmlTags;
import org.objectweb.cjdbc.common.xml.XmlComponent;
import org.objectweb.cjdbc.controller.backend.DatabaseBackend;
import org.objectweb.cjdbc.controller.backend.DriverCompliance;
import org.objectweb.cjdbc.controller.cache.metadata.MetadataCache;
import org.objectweb.cjdbc.controller.requestmanager.TransactionMarkerMetaData;
import org.objectweb.cjdbc.controller.virtualdatabase.ControllerResultSet;
import org.objectweb.cjdbc.controller.virtualdatabase.VirtualDatabase;

public abstract class AbstractLoadBalancer implements XmlComponent
{

  //
  // How the code is organized ?
  //
  // 1. Member variables/Constructor
  // 2. Getter/Setter (possibly in alphabetical order)
  // 3. Request handling
  // 4. Transaction management
  // 5. Backend management
  // 6. Debug/Monitoring
  //

  // Virtual Database this load balancer is attached to.
  protected VirtualDatabase vdb;
  protected int             raidbLevel;
  protected int             parsingGranularity;

  protected static Trace    logger = Trace
                                       .getLogger("org.objectweb.cjdbc.controller.loadbalancer");

  protected MacrosHandler   macroHandler;

  protected AbstractLoadBalancer(VirtualDatabase vdb, int raidbLevel,
      int parsingGranularity) throws SQLException
  {
    this.raidbLevel = raidbLevel;
    this.parsingGranularity = parsingGranularity;
    this.vdb = vdb;
    try
    {
      vdb.acquireReadLockBackendLists();
    }
    catch (InterruptedException e)
    {
      String msg = Translate.get(
          "loadbalancer.backendlist.acquire.readlock.failed", e);
      logger.error(msg);
      throw new SQLException(msg);
    }
    int size = vdb.getBackends().size();
    ArrayList backends = vdb.getBackends();
    for (int i = 0; i < size; i++)
    {
      DatabaseBackend backend = (DatabaseBackend) backends.get(i);
      if (backend.isReadEnabled() || backend.isWriteEnabled())
      {
        if (logger.isWarnEnabled())
          logger.warn(Translate.get(
              "loadbalancer.constructor.backends.not.disabled", backend
                  .getName()));
        backend.disable();
      }
    }
    vdb.releaseReadLockBackendLists();
  }

  //
  // Getter/Setter methods
  //

  public int getRAIDbLevel()
  {
    return raidbLevel;
  }

  public void setRAIDbLevel(int raidbLevel)
  {
    this.raidbLevel = raidbLevel;
  }

  public int getParsingGranularity()
  {
    return parsingGranularity;
  }

  public void setParsingGranularity(int parsingGranularity)
  {
    this.parsingGranularity = parsingGranularity;
  }

  //
  // Request Handling
  //

  public abstract ControllerResultSet execReadRequest(SelectRequest request,
      MetadataCache metadataCache) throws SQLException;

  public abstract int execWriteRequest(AbstractWriteRequest request)
      throws AllBackendsFailedException, SQLException;

  public abstract ControllerResultSet execWriteRequestWithKeys(
      AbstractWriteRequest request, MetadataCache metadataCache)
      throws AllBackendsFailedException, SQLException;

  public abstract ControllerResultSet execReadOnlyReadStoredProcedure(
      StoredProcedure proc, MetadataCache metadataCache) throws SQLException;

  public abstract ControllerResultSet execReadStoredProcedure(
      StoredProcedure proc, MetadataCache metadataCache) throws SQLException;

  public abstract int execWriteStoredProcedure(StoredProcedure proc)
      throws SQLException;

  public static ControllerResultSet executeSelectRequestOnBackend(
      SelectRequest request, DatabaseBackend backend, Connection c,
      MetadataCache metadataCache) throws SQLException, BadConnectionException
  {
    ControllerResultSet rs = null;
    try
    {
      backend.addPendingReadRequest(request);
      String sql = request.getSQL();
      // Rewrite the query if needed
      sql = backend.rewriteQuery(sql);

      Statement s; // Can also be used as a PreparedStatement
      if (request.isDriverProcessed() || (request.getSqlSkeleton() == null))
        s = c.createStatement();
      else
      {
        s = c.prepareStatement(request.getSqlSkeleton());
        org.objectweb.cjdbc.driver.PreparedStatement.setPreparedStatement(sql,
            (PreparedStatement) s);
      }

      // Execute the query
      DriverCompliance driverCompliance = backend.getDriverCompliance();
      if (driverCompliance.supportSetQueryTimeout())
        s.setQueryTimeout(request.getTimeout());
      if ((request.getCursorName() != null)
          && (driverCompliance.supportSetCursorName()))
        s.setCursorName(request.getCursorName());
      if ((request.getFetchSize() != 0)
          && driverCompliance.supportSetFetchSize())
        s.setFetchSize(request.getFetchSize());
      if ((request.getMaxRows() > 0) && driverCompliance.supportSetMaxRows())
        s.setMaxRows(request.getMaxRows());
      if (request.isDriverProcessed() || (request.getSqlSkeleton() == null))
        rs = new ControllerResultSet(request, s.executeQuery(sql),
            metadataCache);
      else
        rs = new ControllerResultSet(request, ((PreparedStatement) s)
            .executeQuery(), metadataCache);
    }
    catch (SQLException e)
    { // Something bad happened
      if (backend.isValidConnection(c))
        throw e; // Connection is valid, throw the exception
      else
        throw new BadConnectionException(e);
    }
    finally
    {
      backend.removePendingRequest(request);
    }
    return rs;
  }

  public static int executeUpdateRequestOnBackend(AbstractWriteRequest request,
      DatabaseBackend backend, Connection c) throws SQLException,
      BadConnectionException
  {
    try
    {
      backend.addPendingWriteRequest(request);
      String sql = request.getSQL();
      // Rewrite the query if needed
      sql = backend.rewriteQuery(sql);

      Statement s; // Can also be used as a PreparedStatement
      if (request.isDriverProcessed() || (request.getSqlSkeleton() == null))
        s = c.createStatement();
      else
      {
        s = c.prepareStatement(request.getSqlSkeleton());
        org.objectweb.cjdbc.driver.PreparedStatement.setPreparedStatement(sql,
            (PreparedStatement) s);
      }

      // Execute the query
      DriverCompliance driverCompliance = backend.getDriverCompliance();
      if (driverCompliance.supportSetQueryTimeout())
        s.setQueryTimeout(request.getTimeout());

      if (request.isDriverProcessed() || (request.getSqlSkeleton() == null))
        return s.executeUpdate(sql);
      else
        return ((PreparedStatement) s).executeUpdate();
    }
    catch (SQLException e)
    { // Something bad happened
      if (backend.isValidConnection(c))
        throw e; // Connection is valid, throw the exception
      else
        throw new BadConnectionException(e);
    }
    finally
    {
      backend.removePendingRequest(request);
    }
  }

  public static ResultSet executeUpdateRequestOnBackendWithKeys(
      AbstractWriteRequest request, DatabaseBackend backend, Connection c)
      throws SQLException, BadConnectionException
  {
    try
    {
      backend.addPendingWriteRequest(request);
      String sql = request.getSQL();
      // Rewrite the query if needed
      sql = backend.rewriteQuery(sql);

      Statement s = c.createStatement();

      // Execute the query
      DriverCompliance driverCompliance = backend.getDriverCompliance();
      if (driverCompliance.supportSetQueryTimeout())
        s.setQueryTimeout(request.getTimeout());

      s.executeUpdate(sql, Statement.RETURN_GENERATED_KEYS);
      return s.getGeneratedKeys();
    }
    catch (SQLException e)
    { // Something bad happened
      if (backend.isValidConnection(c))
        throw e; // Connection is valid, throw the exception
      else
        throw new BadConnectionException(e);
    }
    finally
    {
      backend.removePendingRequest(request);
    }
  }

  public static ControllerResultSet executeReadStoredProcedureOnBackend(
      StoredProcedure proc, DatabaseBackend backend, Connection c,
      MetadataCache metadataCache) throws SQLException, BadConnectionException
  {
    try
    {
      backend.addPendingReadRequest(proc);

      // We suppose here that the request does not modify the schema since
      // it is a read-only query.
      CallableStatement cs;
      if (proc.isDriverProcessed())
        cs = c.prepareCall(proc.getSQL());
      else
      {
        cs = c.prepareCall(proc.getSqlSkeleton());
        org.objectweb.cjdbc.driver.PreparedStatement.setPreparedStatement(proc
            .getSQL(), cs);
      }
      if (backend.getDriverCompliance().supportSetQueryTimeout())
        cs.setQueryTimeout(proc.getTimeout());
      if ((proc.getMaxRows() > 0)
          && backend.getDriverCompliance().supportSetMaxRows())
        cs.setMaxRows(proc.getMaxRows());
      return new ControllerResultSet(proc, cs.executeQuery(), metadataCache);
    }
    catch (SQLException e)
    { // Something bad happened
      if (backend.isValidConnection(c))
        throw e; // Connection is valid, throw the exception
      else
        throw new BadConnectionException(e);
    }
    finally
    {
      backend.removePendingRequest(proc);
    }
  }

  public static int executeWriteStoredProcedureOnBackend(StoredProcedure proc,
      DatabaseBackend backend, Connection c) throws SQLException,
      BadConnectionException
  {
    try
    {
      backend.addPendingWriteRequest(proc);

      // We suppose here that the request does not modify the schema since
      // it is a read-only query.
      CallableStatement cs;
      if (proc.isDriverProcessed())
        cs = c.prepareCall(proc.getSQL());
      else
      {
        cs = c.prepareCall(proc.getSqlSkeleton());
        org.objectweb.cjdbc.driver.PreparedStatement.setPreparedStatement(proc
            .getSQL(), cs);
      }
      if (backend.getDriverCompliance().supportSetQueryTimeout())
        cs.setQueryTimeout(proc.getTimeout());
      if ((proc.getMaxRows() > 0)
          && backend.getDriverCompliance().supportSetMaxRows())
        cs.setMaxRows(proc.getMaxRows());
      return cs.executeUpdate();
    }
    catch (SQLException e)
    { // Something bad happened
      if (backend.isValidConnection(c))
        throw e; // Connection is valid, throw the exception
      else
        throw new BadConnectionException(e);
    }
    finally
    {
      backend.removePendingRequest(proc);
    }
  }

  //
  // Transaction management
  //

  public abstract void begin(TransactionMarkerMetaData tm) throws SQLException;

  public abstract void commit(TransactionMarkerMetaData tm)
      throws AllBackendsFailedException, SQLException;

  public abstract void rollback(TransactionMarkerMetaData tm)
      throws AllBackendsFailedException, SQLException;

  //
  // Backends management
  //

  public abstract void enableBackend(DatabaseBackend db, boolean writeEnabled)
      throws SQLException;

  public abstract void disableBackend(DatabaseBackend db) throws SQLException;

  public void setWeight(String name, int w) throws SQLException
  {
    throw new SQLException("Weight is not supported by this load balancer");
  }

  //
  // Debug/Monitoring
  //

  public abstract String getInformation();

  public abstract String getXmlImpl();

  public void setMacroHandler(MacrosHandler handler)
  {
    this.macroHandler = handler;
  }

  public void handleMacros(AbstractRequest request)
  {
    if (macroHandler == null)
      return;

    if (request.isDriverProcessed() || (request.getSqlSkeleton() == null))
      request.setSQL(macroHandler.processMacros(request.getSQL()));
    else
      request.setSqlSkeleton(macroHandler.processMacros(request
          .getSqlSkeleton()));
  }

  public String getXml()
  {
    StringBuffer info = new StringBuffer();
    info.append("<" + DatabasesXmlTags.ELT_LoadBalancer + ">");
    info.append(getXmlImpl());
    info.append("</" + DatabasesXmlTags.ELT_LoadBalancer + ">");
    return info.toString();
  }

}

---