DatabaseTransactionFactoryImpl


1   /*
2    * Copyright (c) 2003 - 2007 OpenSubsystems s.r.o. Slovak Republic. All rights reserved.
3    * 
4    * Project: OpenSubsystems
5    * 
6    * $Id: DatabaseTransactionFactoryImpl.java,v 1.25 2007/01/07 06:14:18 bastafidli Exp $
7    * 
8    * This program is free software; you can redistribute it and/or modify
9    * it under the terms of the GNU General Public License as published by
10   * the Free Software Foundation; version 2 of the License. 
11   * 
12   * This program is distributed in the hope that it will be useful,
13   * but WITHOUT ANY WARRANTY; without even the implied warranty of
14   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   * GNU General Public License for more details.
16   * 
17   * You should have received a copy of the GNU General Public License
18   * along with this program; if not, write to the Free Software
19   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
20   */
21  
22  package org.opensubsystems.core.persist.db;
23  
24  import java.sql.Connection  ;
25  import java.sql.SQLException  ;
26  import java.util.Properties  ;
27  import java.util.logging.Level  ;
28  import java.util.logging.Logger  ;
29  
30  import javax.transaction.Status  ;
31  import javax.transaction.SystemException  ;
32  import javax.transaction.UserTransaction  ;
33  
34  import org.opensubsystems.core.error.OSSDatabaseAccessException;
35  import org.opensubsystems.core.error.OSSDynamicClassException;
36  import org.opensubsystems.core.error.OSSException;
37  import org.opensubsystems.core.persist.db.transaction.J2EETransactionFactoryImpl;
38  import org.opensubsystems.core.persist.db.transaction.SimpleLocalTransactionFactoryImpl;
39  import org.opensubsystems.core.util.ClassFactory;
40  import org.opensubsystems.core.util.Config;
41  import org.opensubsystems.core.util.GlobalConstants;
42  import org.opensubsystems.core.util.J2EEUtils;
43  import org.opensubsystems.core.util.Log;
44  import org.opensubsystems.core.util.TransactionFactory;
45  
46  /**
47   * Base class for implementation of database transaction factories.
48   * 
49   * @version $Id: DatabaseTransactionFactoryImpl.java,v 1.25 2007/01/07 06:14:18 bastafidli Exp $
50   * @author Miro Halas
51   * @code.reviewer Miro Halas
52   * @code.reviewed 1.18 2006/05/24 15:18:33 bastafidli
53   */
54  public abstract class DatabaseTransactionFactoryImpl implements DatabaseTransactionFactory
55  {
56     // Configuration settings ///////////////////////////////////////////////////
57     
58     /**
59      * Transaction timeout in seconds, which should be set for a transaction when 
60      * it is started. If this is set to 0, according to documentation the transaction 
61      * manager restores the default value.
62      */
63     public static final String   TRANSACTION_TIMEOUT = "oss.transaction.timeout";
64     
65     /**
66      * Boolean flag, which specifies if the system should monitor transactions 
67      * that is use a delegating class which intercepts and monitors calls to 
68      * UserTransaction class. This is useful for troubleshooting and during 
69      * development but can affect the system performance.
70      */
71     public static final String   TRANSACTION_MONITOR = "oss.transaction.monitor";
72  
73     // Constants ////////////////////////////////////////////////////////////////
74  
75     /**
76      * Lock used in synchronized sections.
77      */
78     private static final String   IMPL_LOCK = "IMPL_LOCK";
79  
80     /**
81      * Default transaction timeout. Keep it longer so that if during debugging
82      * we need to step through the code, we have enough time to complete 
83      * transaction.
84      */
85     public static final int TRANSACTION_TIMEOUT_DEFAULT = 600;
86  
87     /**
88      * Default transaction monitor setting. Keep it false so that it doesn't affect
89      * performance.
90      */
91     public static final boolean TRANSACTION_MONITOR_DEFAULT = false;
92     
93     // Cached values ////////////////////////////////////////////////////////////
94  
95     /**
96      * Logger for this class
97      */
98     private static Logger   s_logger = Log.getInstance(DatabaseTransactionFactoryImpl.class);
99    
100    /**
101     * Reference to default instance.
102     */
103    private static DatabaseTransactionFactory s_defaultInstance = null;
104 
105    /**
106     * Transaction timeout, which should be set for a transaction when it is 
107     * started. If this is set to 0, according to documentation transaction 
108     * manager restores the default value.
109     */
110    protected static int s_iTransactionTimeout;
111    
112    /**
113     * Flag, which is telling us if we should monitor transactions that is use
114     * a delegating class which intercepts and monitors calls to UserTransaction 
115     * class. 
116     */
117    protected static boolean s_bTransactionMonitor;
118    
119    // Constructors /////////////////////////////////////////////////////////////
120    
121    /**
122     * Static initializer.
123     */
124    static
125    {
126       // Read configuration parameters
127       Properties   prpSettings;
128 
129       prpSettings = Config.getInstance().getPropertiesSafely();
130       s_iTransactionTimeout = Config.getIntPropertyInRange(
131                                         prpSettings, 
132                                         TRANSACTION_TIMEOUT, 
133                                         TRANSACTION_TIMEOUT_DEFAULT, 
134                                         "Default transaction timout", 
135                                         0, // 0 is allowed 
136                                         Integer.MAX_VALUE);
137 
138       s_bTransactionMonitor = Config.getBooleanProperty(
139                                         prpSettings, 
140                                         TRANSACTION_MONITOR,
141                                         TRANSACTION_MONITOR_DEFAULT,
142                                         "Default transaction monitoring");
143    }
144    
145    /**
146     * Default constructor. 
147     */
148    public DatabaseTransactionFactoryImpl(
149    )
150    {
151       super();      
152    }
153 
154    // Factory methods //////////////////////////////////////////////////////////
155 
156    /**
157     * Get the default factory. This method is here to make the transaction factory 
158     * is configurable. Once can specify in configuration file derived class to 
159     * used instead of this one [DatabaseTransactionFactory.class]=new class to 
160     * use or [TransactionFactory.class]=new class to use
161     *
162     * @return DatabaseTransactionFactory
163     * @throws OSSException - an error has occured 
164     */
165    public static DatabaseTransactionFactory getInstance(
166    ) throws OSSException
167    {
168       if (s_defaultInstance == null)
169       {
170          // Only if the default factory wasn't set by other means create a new one
171          // Synchronize just for the creation
172          synchronized (IMPL_LOCK)
173          {
174             if (s_defaultInstance == null)
175             {
176                DatabaseTransactionFactory transactionFactory = null;
177                
178                try
179                {                
180                   transactionFactory = (DatabaseTransactionFactory)ClassFactory.getInstance()
181                                .createInstance(DatabaseTransactionFactory.class);
182                }
183                catch (OSSDynamicClassException dneExc)
184                {
185                   // Cannot instantiate database transaction factory 
186                   // so try just the generic transaction factory
187                   Class   defaultTransactionFactoryImpl = SimpleLocalTransactionFactoryImpl.class;
188 
189                   // Find out if we are running under a j2ee server. If yes, redefine
190                   // default variable defaultTransactionFactoryImpl for using 
191                   // j2ee transaction factory implementation.
192                   if (J2EEUtils.getJ2EEServerType() != J2EEUtils.J2EE_SERVER_NO)
193                   {
194                      defaultTransactionFactoryImpl = J2EETransactionFactoryImpl.class;
195                   }
196                   
197                   transactionFactory = (DatabaseTransactionFactory)ClassFactory.getInstance()
198                                           .createInstance(TransactionFactory.class,
199                                                           defaultTransactionFactoryImpl);
200                }
201                
202                setInstance(transactionFactory);                  
203             }
204          }   
205       }
206       
207       return s_defaultInstance;
208    }
209    
210    /**
211     * Set default factory instance. This instance will be returned by 
212     * getInstance method until it is changed.
213     *
214     * @param defaultFactory - new default factory instance
215     * @see #getInstance
216     */
217    public static void setInstance(
218       DatabaseTransactionFactory defaultFactory
219    )
220    {
221       if (GlobalConstants.ERROR_CHECKING)
222       {
223          
224          assert defaultFactory != null 
225                 : "Default transaction factory instance cannot be null";
226       }   
227       
228       synchronized (IMPL_LOCK)
229       {
230          s_defaultInstance = defaultFactory;
231          s_logger.fine("Default database transaction factory is " 
232                        + s_defaultInstance.getClass().getName());
233       }   
234    }
235    
236    /**
237     * {@inheritDoc}
238     */
239    public void commitTransaction(
240       Connection   cntConnection
241    ) throws SQLException  
242    {
243       try
244       {
245          boolean bAutoCommit = cntConnection.getAutoCommit();
246          
247          if ((!isTransactionInProgress()) && (!bAutoCommit))
248          {
249             // If there is no global transaction in progress and then can be some
250             // sql pending since the autocommit is false then just commit
251             // this connection since the transaction has to be connection based
252             if (s_bTransactionMonitor)
253             {
254                s_logger.finest("commitTransaction on connection " 
255                                + cntConnection.toString());
256             }
257             cntConnection.commit();
258             if (s_bTransactionMonitor)
259             {
260                s_logger.finest("commitTransaction sucessfull on connection " 
261                                + cntConnection.toString());
262             }
263          }
264          else
265          {
266             if (s_bTransactionMonitor)
267             {
268                s_logger.finest("commitTransaction on connection " 
269                                + cntConnection.toString()
270                                + " ignored since either transaction in progress"
271                                + " or autoCommit is set. Autocommit value is " 
272                                + bAutoCommit);
273             }
274          }
275       }
276       catch (SystemException   seExc)
277       {
278          SQLException   sqlExc = new SQLException  ("Cannot check state of the transaction");
279          sqlExc.initCause(seExc);
280          throw sqlExc;
281       }
282       catch (OSSException osseExc)
283       {
284          SQLException   sqlExc = new SQLException  ("Cannot check state of the transaction");
285          sqlExc.initCause(osseExc);
286          throw sqlExc;
287       }
288    }
289 
290    /**
291     * {@inheritDoc}
292     */
293    public void rollbackTransaction(
294       Connection   cntConnection
295    ) throws SQLException  
296    {
297       try
298       {
299          boolean bAutoCommit = cntConnection.getAutoCommit();
300          
301          // Connection can be null in case an exception is thrown when
302          // getting connection
303          if (cntConnection != null) 
304          {
305             if ((!isTransactionInProgress()) && (!bAutoCommit))
306             {
307                // If there is no global transaction in progress and then can be some
308                // sql pending since the autocommit is false then just rollback
309                // this connection since the transaction has to be connection based
310                if (s_bTransactionMonitor)
311                {
312                   s_logger.finest("rollbackTransaction on connection " 
313                                   + cntConnection.toString());
314                }
315                cntConnection.rollback();
316                if (s_bTransactionMonitor)
317                {
318                   s_logger.finest("rollbackTransaction sucessfull on connection " 
319                                   + cntConnection.toString());
320                }
321             }
322             else
323             {
324                if (s_bTransactionMonitor)
325                {
326                   s_logger.finest("rollbackTransaction on connection " 
327                                   + cntConnection.toString()
328                                   + " ignored since either transaction in progress"
329                                   + " or autoCommit is set. Autocommit value is " 
330                                   + bAutoCommit);
331                }
332             }
333          }
334       }
335       catch (SystemException   seExc)
336       {
337          s_logger.log(Level.WARNING, "Cannot check state of the transaction",  
338                       seExc);
339          // Rollback anyway, since that should be better than just
340          cntConnection.rollback();
341       }
342       catch (OSSException osseExc)
343       {
344          SQLException   sqlExc = new SQLException  ("Cannot check state of the transaction");
345          sqlExc.initCause(osseExc);
346          throw sqlExc;
347       }
348    }
349 
350    /**
351     * Test if transaction is in progress.
352     * 
353     * @return boolean - if true then transaction is in progress for curren thread.
354     * @throws SystemException - error occured while getting the transaction status
355     * @throws OSSException - error occured while getting the transaction status
356     */
357    public boolean isTransactionInProgress(
358    ) throws SystemException  , 
359             OSSException 
360    {
361       UserTransaction   transaction = requestTransaction(); 
362       int iStatus = Status.STATUS_NO_TRANSACTION;
363       
364       if (transaction != null)
365       {
366          // Transaction might be null if there is an error to initialize 
367          // the persistence layer
368          iStatus = transaction.getStatus();
369       }
370 
371       return ((iStatus != Status.STATUS_NO_TRANSACTION)
372               && (iStatus != Status.STATUS_COMMITTED)
373               && (iStatus != Status.STATUS_ROLLEDBACK));
374    }
375    
376    /**
377     * Test if transaction should be monitored
378     * 
379     * @return boolean - if true then transactions should be monitored and log
380     *                   should capture additional diagnostic information about
381     *                   each transaction
382     */
383    public boolean isTransactionMonitored()
384    {
385       return s_bTransactionMonitor;
386    }
387 
388    // Helper methods ///////////////////////////////////////////////////////////
389    
390    /**
391     * This method should be exclusively used by DatabaseConnectionFactoryImpl
392     * to get a transaction aware version of a connection. If there one already 
393     * exists (such as there is one associated with the current pending transaction
394     * managed by the database transaction factory) then this method will return
395     * that one and there is no need to allocate a new one. If there is not one,
396     * then this method will call back the database connection factory which
397     * allocated the connection and then create a transaction aware version of it.
398     * 
399     * This method is protected so that only classes in this package can access it.
400     * 
401     * @param bAutoCommit - The desired autocommit state of the connection. If 
402     *                      this connection is invoked in global (JTA) transaction
403     *                      then the autocommit is false regardless of what
404     *                      value is specified here. Use true here if the client
405     *                      only reads the data and false if the client also 
406     *                      modifies the data. 
407     * @param strDataSourceName - datasource for which the connection was requested,
408     *                            if null then it is requested for default data source
409     * @param strUser - user for which the connection was requested, if null
410     *                  then it is requested for default user
411     * @param strPassword - password for which the connection was requested, if
412     *                      null then it is requested for default passwoed
413     * @param connectionFactory - connection factory which is requesting the connection
414     * @return Connection - transaction aware version of connection
415     * @throws OSSDatabaseAccessException - an error has occured
416     */
417    protected Connection   requestTransactionalConnection(
418       boolean                       bAutoCommit,
419       String                          strDataSourceName,
420       String                          strUser,
421       String                          strPassword,
422       DatabaseConnectionFactoryImpl connectionFactory
423    ) throws OSSDatabaseAccessException
424    {
425       // Many external connection pools already integrate with transaction
426       // managers so we don't have to do anything, just call the real 
427       // connection acquiring method.
428       Connection   realConnection;
429       
430       if (strDataSourceName == null)
431       {
432          if ((strUser == null) && (strPassword == null))
433          {
434             // Get just connection for default user
435             realConnection = connectionFactory.requestNonTransactionalConnection(
436                                 bAutoCommit);
437          }
438          else
439          {
440             realConnection = connectionFactory.requestNonTransactionalConnection(
441                                 bAutoCommit, strUser, strPassword);            
442          }
443       }
444       else
445       {
446          if ((strUser == null) && (strPassword == null))
447          {
448             // Get just connection for default user
449             realConnection = connectionFactory.requestNonTransactionalConnection(
450                                 bAutoCommit, strDataSourceName);
451          }
452          else
453          {
454             realConnection = connectionFactory.requestNonTransactionalConnection(
455                                 bAutoCommit, strDataSourceName, strUser, strPassword);            
456          }
457       }
458       
459       return realConnection;
460    }
461 
462    /**
463     * This method should be exclusively used by DatabaseConnectionFactoryImpl
464     * to get a transaction aware version of a connection. If the connection
465     * is transaction aware then it will be realy returned if it is not involved
466     * in a pending transaction.
467     *
468     * This method is protected so that only classes from this package can access it.
469     * 
470     * @param cntDBConnection - connection to return, can be null
471     * @param connectionFactory - connection factory to which the connection should  
472     *                            be returned
473     */
474    protected void returnTransactionalConnection(
475       Connection                      cntDBConnection,
476       DatabaseConnectionFactoryImpl connectionFactory
477    )
478    {
479       // Many external connection pools already integrate with transaction
480       // managers so we don't have to do anything, just call the real 
481       // connection returning method.
482       connectionFactory.returnNonTransactionalConnection(cntDBConnection);
483    }
484 }
485
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags