/*
* Copyright (c) 2002-2014, Mairie de Paris
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright notice
* and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice
* and the following disclaimer in the documentation and/or other materials
* provided with the distribution.
*
* 3. Neither the name of 'Mairie de Paris' nor 'Lutece' nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* License 1.0
*/
package fr.paris.lutece.util.sql;
import fr.paris.lutece.portal.service.plugin.Plugin;
import fr.paris.lutece.portal.service.util.AppLogService;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
/**
* Class to manage transactions
*/
public final class TransactionManager
{
private static final String DEFAULT_POOL_NAME = "portal";
private static ThreadLocal<Map<String, MultiPluginTransaction>> _tlTransactions = new ThreadLocal<Map<String, MultiPluginTransaction>>( );
/**
* Default constructor
*/
private TransactionManager( )
{
// Do nothing
}
/**
* Begin a transaction for the current thread using the pool of a specific plugin with the default transaction isolation. The default transaction isolation
* is {@link Connection#TRANSACTION_READ_COMMITTED }.<br />
* Note that only one transaction may be active at a time by pool for each thread.
*
* @param plugin
* The plugin to use the pool of, or null to use the default pool.
*/
public static void beginTransaction( Plugin plugin )
{
beginTransaction( plugin, Connection.TRANSACTION_READ_COMMITTED );
}
/**
* Begin a transaction for the current thread using the pool of a specific plugin
*
* @param plugin
* The plugin to use the pool of, or null to use the default pool.
* @param nTransactionIsolation
* The transaction isolation. View {@link Connection#setTransactionIsolation(int) } to view the different available transaction isolations.
*/
public static void beginTransaction( Plugin plugin, int nTransactionIsolation )
{
Map<String, MultiPluginTransaction> mapTransactions = _tlTransactions.get( );
MultiPluginTransaction transaction = null;
if ( mapTransactions == null )
{
mapTransactions = new HashMap<String, MultiPluginTransaction>( );
_tlTransactions.set( mapTransactions );
}
else
{
transaction = mapTransactions.get( getPluginPool( plugin ) );
}
if ( ( transaction == null ) || ( transaction.getNbTransactionsOpened( ) <= 0 ) )
{
transaction = new MultiPluginTransaction( plugin );
try
{
transaction.getConnection( ).setTransactionIsolation( nTransactionIsolation );
}
catch( SQLException e )
{
AppLogService.error( e.getMessage( ), e );
}
mapTransactions.put( getPluginPool( plugin ), transaction );
}
else
{
// A transaction has already been opened for this pool,
// so we save that information to prevent the next call to the commit method to close the transaction.
transaction.incrementNbTransactionsOpened( );
}
}
/**
* Get the current transaction for the pool of a given plugin.
*
* @param plugin
* The plugin to use the pool of, or null to use the default pool.
* @return The transaction, or null if no transaction is currently running.
*/
public static MultiPluginTransaction getCurrentTransaction( Plugin plugin )
{
Map<String, MultiPluginTransaction> mapTransactions = _tlTransactions.get( );
if ( mapTransactions != null )
{
return mapTransactions.get( getPluginPool( plugin ) );
}
return null;
}
/**
* Commit the transaction associated to the pool of a given plugin.
*
* @param plugin
* The plugin associated to the pool to commit the transaction of, or null to use the default pool.
*/
public static void commitTransaction( Plugin plugin )
{
Map<String, MultiPluginTransaction> mapTransactions = _tlTransactions.get( );
if ( mapTransactions != null )
{
String strPoolName = getPluginPool( plugin );
MultiPluginTransaction transaction = mapTransactions.get( strPoolName );
if ( transaction != null )
{
// If the number of transactions opened is 1 or less, then we commit the transaction
if ( transaction.getNbTransactionsOpened( ) <= 1 )
{
transaction.commit( );
mapTransactions.remove( strPoolName );
}
else
{
// Otherwise, we decrement the number
transaction.decrementNbTransactionsOpened( );
}
}
}
}
/**
* Roll back a transaction associated to the pool of a given plugin. Note that any plugin can roll a transaction back.
*
* @param plugin
* The plugin associated to the pool to roll back the transaction of, or null to use the default pool.
*/
public static void rollBack( Plugin plugin )
{
rollBack( plugin, null );
}
/**
* Roll back a transaction associated to the pool of a given plugin with an exception.
*
* @param plugin
* The plugin associated to the pool to roll back the transaction of, or null to use the default pool.
* @param e
* The exception to associates with the roll back.
*/
public static void rollBack( Plugin plugin, Exception e )
{
Map<String, MultiPluginTransaction> mapTransactions = _tlTransactions.get( );
if ( mapTransactions != null )
{
String strPoolName = getPluginPool( plugin );
MultiPluginTransaction transaction = mapTransactions.get( strPoolName );
// We roll back the transaction, no matter how much transactions has been opened.
if ( transaction != null )
{
transaction.rollback( e );
mapTransactions.remove( strPoolName );
}
}
}
/**
* Roll back every transactions opened by the current thread. This method attempt to prevent connection leak.
*/
public static void rollBackEveryTransaction( )
{
rollBackEveryTransaction( null );
}
/**
* Roll back every transactions opened by the current thread. This method attempt to prevent connection leak.
*
* @param e
* The exception that occurs and that may have prevent transaction from being properly closed (committed or roll backed)
*/
public static void rollBackEveryTransaction( Throwable e )
{
Map<String, MultiPluginTransaction> mapTransactions = _tlTransactions.get( );
if ( ( mapTransactions != null ) && ( mapTransactions.size( ) > 0 ) )
{
for ( MultiPluginTransaction transaction : mapTransactions.values( ) )
{
transaction.rollback( null );
}
mapTransactions.clear( );
}
}
/**
* Get the name of the pool of a given plugin
*
* @param plugin
* The plugin to get the name of the pool, or null to get the name of the default pool.
* @return The name of the pool
*/
private static String getPluginPool( Plugin plugin )
{
return ( plugin != null ) ? plugin.getDbPoolName( ) : DEFAULT_POOL_NAME;
}
}