CJDBCversion1.0rc6: org.objectweb.cjdbc.controller.loadbalancer.tasks.WriteRequestTask class Reference

00073   {
00074     DatabaseBackend backend = backendThread.getBackend();
00075 
00076     AbstractConnectionManager cm = backend.getConnectionManager(request
00077         .getLogin());
00078 
00079     if (request.isAutoCommit())
00080     { // Use a connection just for this request
00081       Connection c = null;
00082       try
00083       {
00084         c = cm.getConnection();
00085       }
00086       catch (UnreachableBackendException e1)
00087       {
00088         backendThread.getLogger().error(
00089             "Disabling backend " + backend.getName()
00090                 + " because it is no more reachable.");
00091         backend.disable();
00092         throw new SQLException("Backend " + backend.getName()
00093             + " is no more reachable.");
00094       }
00095 
00096       // Sanity check
00097       if (c == null)
00098       {
00099         SQLException se = new SQLException("No more connections");
00100         try
00101         { // All backends failed, just ignore
00102           if (!notifyFailure(backendThread, (long) request.getTimeout() * 1000,
00103               se))
00104             return;
00105         }
00106         catch (SQLException ignore)
00107         {
00108         }
00109         // Disable this backend (it is no more in sync) by killing the backend
00110         // thread
00111         backendThread.kill();
00112         String msg = "Request '"
00113             + request.getSQLShortForm(backend.getSQLShortFormLength())
00114             + "' failed on backend " + backend.getName() + " but "
00115             + getSuccess() + " succeeded (" + se + ")";
00116         backendThread.getLogger().error(msg);
00117         throw new SQLException(msg);
00118       }
00119 
00120       // Execute Query
00121       try
00122       {
00123         Statement s = c.createStatement();
00124         if (backend.getDriverCompliance().supportSetQueryTimeout())
00125           s.setQueryTimeout(request.getTimeout());
00126 
00127         String sql = request.getSQL();
00128         // Rewrite the query if needed
00129         sql = backend.rewriteQuery(sql);
00130         result = s.executeUpdate(sql);
00131 
00132         // Update schema
00133         if (request.isCreate())
00134         { // Add the table to the schema
00135           DatabaseSchema dbs = backend.getDatabaseSchema();
00136           if (dbs != null)
00137           {
00138             DatabaseTable t = ((CreateRequest) request).getDatabaseTable();
00139             if (t != null)
00140             {
00141               dbs.addTable(t);
00142               if (backendThread.getLogger().isDebugEnabled())
00143                 backendThread.getLogger().debug(
00144                     "Added table '" + request.getTableName()
00145                         + "' to backend database schema");
00146             }
00147           }
00148         }
00149         else if (request.isDrop())
00150         { // Delete the table from the schema
00151           DatabaseSchema dbs = backend.getDatabaseSchema();
00152           if (dbs != null)
00153           {
00154             DatabaseTable t = dbs.getTable(request.getTableName());
00155             if (t != null)
00156             {
00157               dbs.removeTable(t);
00158               if (backendThread.getLogger().isDebugEnabled())
00159                 backendThread.getLogger().debug(
00160                     "Removed table '" + request.getTableName()
00161                         + "' from backend database schema");
00162             }
00163           }
00164         }
00165       }
00166       catch (SQLException e)
00167       {
00168         try
00169         { // All backends failed, just ignore
00170           if (!notifyFailure(backendThread, (long) request.getTimeout() * 1000,
00171               e))
00172             return;
00173         }
00174         catch (SQLException ignore)
00175         {
00176         }
00177         // Disable this backend (it is no more in sync) by killing the backend
00178         // thread
00179         backendThread.kill();
00180         String msg = "Request '"
00181             + request.getSQLShortForm(backend.getSQLShortFormLength())
00182             + "' failed on backend " + backend.getName() + " but "
00183             + getSuccess() + " succeeded (" + e + ")";
00184         backendThread.getLogger().error(msg);
00185         throw new SQLException(msg);
00186       }
00187       finally
00188       {
00189         cm.releaseConnection(c);
00190       }
00191     }
00192     else
00193     { // Re-use the connection used by this transaction
00194       Connection c;
00195       long tid = request.getTransactionId();
00196       Long lTid = new Long(tid);
00197 
00198       if (!backend.isStartedTransaction(lTid))
00199       { // Transaction has not been started yet, this is a lazy begin
00200         try
00201         {
00202           c = cm.getConnection(tid);
00203         }
00204         catch (UnreachableBackendException e1)
00205         {
00206           backendThread.getLogger().error(
00207               "Disabling backend " + backend.getName()
00208                   + " because it is no more reachable.");
00209           backend.disable();
00210           throw new SQLException("Backend " + backend.getName()
00211               + " is no more reachable.");
00212         }
00213 
00214         // Sanity check
00215         if (c == null)
00216         { // Bad connection
00217           SQLException se = new SQLException(
00218               "Unable to get connection for transaction " + tid);
00219           try
00220           { // All backends failed, just ignore
00221             if (!notifyFailure(backendThread,
00222                 (long) request.getTimeout() * 1000, se))
00223               return;
00224           }
00225           catch (SQLException ignore)
00226           {
00227           }
00228           // Disable this backend (it is no more in sync) by killing the
00229           // backend thread
00230           backendThread.kill();
00231           String msg = "Request '"
00232               + request.getSQLShortForm(backend.getSQLShortFormLength())
00233               + "' failed on backend " + backend.getName() + " but "
00234               + getSuccess() + " succeeded (" + se + ")";
00235           backendThread.getLogger().error(msg);
00236           throw new SQLException(msg);
00237         }
00238 
00239         // begin transaction
00240         backend.startTransaction(lTid);
00241         c.setAutoCommit(false);
00242       }
00243       else
00244       { // Transaction has already been started, retrieve connection
00245         c = cm.retrieveConnection(tid);
00246 
00247         // Sanity check
00248         if (c == null)
00249         { // Bad connection
00250           SQLException se = new SQLException(
00251               "Unable to retrieve connection for transaction " + tid);
00252           try
00253           { // All backends failed, just ignore
00254             if (!notifyFailure(backendThread,
00255                 (long) request.getTimeout() * 1000, se))
00256               return;
00257           }
00258           catch (SQLException ignore)
00259           {
00260           }
00261           // Disable this backend (it is no more in sync) by killing the
00262           // backend thread
00263           backendThread.kill();
00264           String msg = "Request '"
00265               + request.getSQLShortForm(backend.getSQLShortFormLength())
00266               + "' failed on backend " + backend.getName() + " but "
00267               + getSuccess() + " succeeded (" + se + ")";
00268           backendThread.getLogger().error(msg);
00269           throw new SQLException(msg);
00270         }
00271       }
00272 
00273       // Execute Query
00274       try
00275       {
00276         Statement s = c.createStatement();
00277         if (backend.getDriverCompliance().supportSetQueryTimeout())
00278           s.setQueryTimeout(request.getTimeout());
00279 
00280         String sql = request.getSQL();
00281         // Rewrite the query if needed
00282         sql = backend.rewriteQuery(sql);
00283         result = s.executeUpdate(sql);
00284 
00285         // Update schema
00286         if (request.isCreate())
00287         { // Add the table to the schema
00288           DatabaseSchema dbs = backend.getDatabaseSchema();
00289           if (dbs != null)
00290           {
00291             DatabaseTable t = ((CreateRequest) request).getDatabaseTable();
00292             if (t != null)
00293             {
00294               dbs.addTable(t);
00295               if (backendThread.getLogger().isDebugEnabled())
00296                 backendThread.getLogger().debug(
00297                     "Added table '" + request.getTableName()
00298                         + "' to backend database schema");
00299             }
00300           }
00301         }
00302         else if (request.isDrop())
00303         { // Delete the table from the schema
00304           DatabaseSchema dbs = backend.getDatabaseSchema();
00305           if (dbs != null)
00306           {
00307             DatabaseTable t = dbs.getTable(request.getTableName());
00308             if (t != null)
00309             {
00310               dbs.removeTable(t);
00311               if (backendThread.getLogger().isDebugEnabled())
00312                 backendThread.getLogger().debug(
00313                     "Removed table '" + request.getTableName()
00314                         + "' from backend database schema");
00315             }
00316           }
00317         }
00318       }
00319       catch (SQLException e)
00320       {
00321         try
00322         { // All backends failed, just ignore
00323           if (!notifyFailure(backendThread, (long) request.getTimeout() * 1000,
00324               e))
00325             return;
00326         }
00327         catch (SQLException ignore)
00328         {
00329         }
00330         // Disable this backend (it is no more in sync) by killing the backend
00331         // thread
00332         backendThread.kill();
00333         String msg = "Request '"
00334             + request.getSQLShortForm(backend.getSQLShortFormLength())
00335             + "' failed on backend " + backend.getName() + " but "
00336             + getSuccess() + " succeeded (" + e + ")";
00337         backendThread.getLogger().error(msg);
00338         throw new SQLException(msg);
00339       }
00340     }
00341     notifySuccess();
00342   }

Public メソッド
	WriteRequestTask (int nbToComplete, int totalNb, AbstractWriteRequest request)
void	execute (BackendWorkerThread backendThread) throws SQLException
int	getResult ()
String	toString ()
boolean	hasTid ()
synchronized void	notifySuccess ()
synchronized boolean	notifyFailure (BackendWorkerThread backendThread, long timeout, SQLException e) throws SQLException
ArrayList	getExceptions ()
int	getFailed ()
int	getNbToComplete ()
int	getSuccess ()
int	getTotalNb ()
void	setTotalNb (int totalNb)
void	setHasTid (boolean hasTid)
Private 変数
AbstractWriteRequest	request
int	result
クラス org.objectweb.cjdbc.controller.loadbalancer.tasks.WriteRequestTask

説明

Public メソッド

Private 変数

コンストラクタとデストラクタ

メソッド

変数
