|
|
Glassfish example source code file (JavaEETransactionManagerSimplified.java)
This example Glassfish source code file (JavaEETransactionManagerSimplified.java) is included in the DevDaily.com
"Java Source Code
Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.
The Glassfish JavaEETransactionManagerSimplified.java source code
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright (c) 1997-2011 Oracle and/or its affiliates. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can
* obtain a copy of the License at
* https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
* or packager/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at packager/legal/LICENSE.txt.
*
* GPL Classpath Exception:
* Oracle designates this particular file as subject to the "Classpath"
* exception as provided by Oracle in the GPL Version 2 section of the License
* file that accompanied this code.
*
* Modifications:
* If applicable, add the following below the License Header, with the fields
* enclosed by brackets [] replaced by your own identifying information:
* "Portions Copyright [year] [name of copyright owner]"
*
* Contributor(s):
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*/
package com.sun.enterprise.transaction;
import java.util.*;
import java.util.logging.*;
import java.rmi.RemoteException;
import javax.transaction.*;
import javax.transaction.xa.*;
import javax.resource.spi.XATerminator;
import javax.resource.spi.work.WorkException;
import com.sun.appserv.util.cache.Cache;
import com.sun.appserv.util.cache.BaseCache;
import com.sun.enterprise.transaction.api.JavaEETransaction;
import com.sun.enterprise.transaction.api.JavaEETransactionManager;
import com.sun.enterprise.transaction.api.TransactionAdminBean;
import com.sun.enterprise.transaction.api.XAResourceWrapper;
import com.sun.enterprise.transaction.spi.JavaEETransactionManagerDelegate;
import com.sun.enterprise.transaction.spi.TransactionalResource;
import com.sun.enterprise.transaction.spi.TransactionInternal;
import com.sun.enterprise.transaction.monitoring.TransactionServiceProbeProvider;
import com.sun.enterprise.transaction.monitoring.TransactionServiceStatsProvider;
import com.sun.logging.LogDomains;
import com.sun.enterprise.util.i18n.StringManager;
import org.jvnet.hk2.annotations.Inject;
import org.jvnet.hk2.annotations.Service;
import org.jvnet.hk2.annotations.ContractProvided;
import org.jvnet.hk2.component.Habitat;
import org.jvnet.hk2.component.PostConstruct;
import org.glassfish.api.invocation.ComponentInvocation;
import org.glassfish.api.invocation.InvocationManager;
import org.glassfish.api.invocation.InvocationException;
import org.glassfish.api.invocation.ResourceHandler;
import org.glassfish.external.probe.provider.PluginPoint;
import org.glassfish.external.probe.provider.StatsProviderManager;
import com.sun.enterprise.config.serverbeans.TransactionService;
import com.sun.enterprise.config.serverbeans.ModuleMonitoringLevels;
/**
* Implementation of javax.transaction.TransactionManager interface.
* This class provides non-XA local transaction support and delegates
* to implementation of the JavaEETransactionManagerDelegate for XA
* or LAO optimization, and complete JTS implementation.
*
* @author Tony Ng
* @author Marina Vatkina
*/
@Service
@ContractProvided(TransactionManager.class)
public class JavaEETransactionManagerSimplified
implements JavaEETransactionManager, PostConstruct {
protected Logger _logger = LogDomains.getLogger(JavaEETransactionManagerSimplified.class, LogDomains.JTA_LOGGER);
@Inject private Habitat habitat;
@Inject protected InvocationManager invMgr;
private JavaEETransactionManagerDelegate delegate;
// Sting Manager for Localization
private static StringManager sm
= StringManager.getManager(JavaEETransactionManagerSimplified.class);
// Note: this is not inheritable because we dont want transactions
// to be inherited by child threads.
private ThreadLocal<JavaEETransaction> transactions;
private ThreadLocal localCallCounter;
private ThreadLocal<JavaEETransactionManagerDelegate> delegates;
// If multipleEnlistDelists is set to true, with in the transaction, for the same
// - connection multiple enlistments and delistments might happen
// - By setting the System property ALLOW_MULTIPLE_ENLISTS_DELISTS to true
// - multipleEnlistDelists can be enabled
private boolean multipleEnlistDelists = false;
private int transactionTimeout;
private ThreadLocal<Integer> txnTmout = new ThreadLocal();
private int purgeCancelledTtransactions = 0;
// admin and monitoring related parameters
private static final Hashtable statusMap = new Hashtable();
private Vector activeTransactions = new Vector();
private boolean monitoringEnabled = false;
private TransactionServiceProbeProvider monitor;
private Hashtable txnTable = null;
private Cache resourceTable;
private Timer _timer = new Timer("transaction-manager", true);
static {
statusMap.put(Status.STATUS_ACTIVE, "Active");
statusMap.put(Status.STATUS_MARKED_ROLLBACK, "MarkedRollback");
statusMap.put(Status.STATUS_PREPARED, "Prepared");
statusMap.put(Status.STATUS_COMMITTED, "Committed");
statusMap.put(Status.STATUS_ROLLEDBACK, "RolledBack");
statusMap.put(Status.STATUS_UNKNOWN, "UnKnown");
statusMap.put(Status.STATUS_NO_TRANSACTION, "NoTransaction");
statusMap.put(Status.STATUS_PREPARING, "Preparing");
statusMap.put(Status.STATUS_COMMITTING, "Committing");
statusMap.put(Status.STATUS_ROLLING_BACK, "RollingBack");
}
public JavaEETransactionManagerSimplified() {
transactions = new ThreadLocal<JavaEETransaction>();
localCallCounter = new ThreadLocal();
delegates = new ThreadLocal<JavaEETransactionManagerDelegate>();
}
public void postConstruct() {
initDelegates();
initProperties();
}
private void initProperties() {
int maxEntries = 8192; // FIXME: this maxEntry should be a config
float loadFactor = 0.75f; // FIXME: this loadFactor should be a config
// for now, let's get it from system prop
try {
String mEnlistDelists
= System.getProperty("ALLOW_MULTIPLE_ENLISTS_DELISTS");
if ("true".equals(mEnlistDelists)) {
multipleEnlistDelists = true;
if (_logger.isLoggable(Level.FINE))
_logger.log(Level.FINE,"TM: multiple enlists, delists are enabled");
}
String maxEntriesValue
= System.getProperty("JTA_RESOURCE_TABLE_MAX_ENTRIES");
if (maxEntriesValue != null) {
int temp = Integer.parseInt(maxEntriesValue);
if (temp > 0) {
maxEntries = temp;
}
}
String loadFactorValue
= System.getProperty("JTA_RESOURCE_TABLE_DEFAULT_LOAD_FACTOR");
if (loadFactorValue != null) {
float f = Float.parseFloat(loadFactorValue);
if (f > 0) {
loadFactor = f;
}
}
} catch (Exception ex) {
// ignore
}
Properties cacheProps = null;
resourceTable = new BaseCache();
((BaseCache)resourceTable).init(maxEntries, loadFactor, cacheProps);
// END IASRI 4705808 TTT001
if (habitat != null) {
TransactionService txnService = habitat.getComponent(TransactionService.class);
// running on the server side ?
if (txnService != null) {
transactionTimeout = Integer.parseInt(txnService.getTimeoutInSeconds());
// the delegates will do the rest if they support it
String v = txnService.getPropertyValue("purge-cancelled-transactions-after");
if (v != null && v.length() > 0) {
purgeCancelledTtransactions = Integer.parseInt(v);
}
TransactionServiceConfigListener listener =
habitat.getComponent(TransactionServiceConfigListener.class);
listener.setTM(this);
}
ModuleMonitoringLevels levels = habitat.getComponent(ModuleMonitoringLevels.class);
// running on the server side ?
if (levels != null) {
String level = levels.getTransactionService();
if (!("OFF".equals(level))) {
monitoringEnabled = true;
}
}
}
// ENF OF BUG 4665539
if (_logger.isLoggable(Level.FINE))
_logger.log(Level.FINE,"TM: Tx Timeout = " + transactionTimeout);
// START IASRI 4705808 TTT004 -- monitor resource table stats
try {
// XXX TODO:
if (Boolean.getBoolean("MONITOR_JTA_RESOURCE_TABLE_STATISTICS")) {
registerStatisticMonitorTask();
}
StatsProviderManager.register(
"transaction-service", // element in domain.xml <monitoring-service>/
PluginPoint.SERVER, "transaction-service", // server.transaction-service node in asadmin get
new TransactionServiceStatsProvider(this, _logger));
} catch (Exception ex) {
// ignore
}
monitor = new TransactionServiceProbeProvider();
}
/**
* Clears the transaction associated with the caller thread
*/
public void clearThreadTx() {
setCurrentTransaction(null);
delegates.set(null);
}
/** {@inheritDoc}
*/
public String getTxLogLocation() {
return getDelegate().getTxLogLocation();
}
/** {@inheritDoc}
*/
public void registerRecoveryResourceHandler(XAResource xaResource) {
getDelegate().registerRecoveryResourceHandler(xaResource);
}
/****************************************************************************/
/** Implementations of JavaEETransactionManager APIs **************************/
/****************************************************************************/
/**
* Return true if a "null transaction context" was received
* from the client. See EJB2.0 spec section 19.6.2.1.
* A null tx context has no Coordinator objref. It indicates
* that the client had an active
* tx but the client container did not support tx interop.
*/
public boolean isNullTransaction() {
return getDelegate().isNullTransaction();
}
public void initRecovery(boolean force) {
getDelegate().initRecovery(force);
}
public void recover(XAResource[] resourceList) {
getDelegate().recover(resourceList);
}
public boolean enlistResource(Transaction tran, TransactionalResource h)
throws RollbackException, IllegalStateException, SystemException {
if ( !h.isTransactional() )
return true;
//If LazyEnlistment is suspended, do not enlist resource.
if(h.isEnlistmentSuspended()){
return false;
}
if (monitoringEnabled) {
JavaEETransaction tx = getDelegate().getJavaEETransaction(tran);
if ( tx != null ) {
((JavaEETransactionImpl)tx).addResourceName(h.getName());
}
}
if ( !(tran instanceof JavaEETransaction) ) {
return enlistXAResource(tran, h);
}
JavaEETransactionImpl tx = (JavaEETransactionImpl)tran;
if(_logger.isLoggable(Level.FINE)) {
_logger.log(Level.FINE,"\n\nIn JavaEETransactionManagerSimplified.enlistResource, h="
+h+" h.xares="+h.getXAResource()
/** +" h.alloc=" +h.getResourceAllocator() **/ +" tx="+tx);
}
JavaEETransactionManagerDelegate d = setDelegate();
boolean useLAO = d.useLAO();
if ( (tx.getNonXAResource()!=null) && (!useLAO || (useLAO && !h.supportsXA()))) {
boolean isSameRM=false;
try {
isSameRM = h.getXAResource().isSameRM(tx.getNonXAResource().getXAResource());
} catch ( XAException xex ) {
throw new SystemException(sm.getString("enterprise_distributedtx.samerm_excep",xex));
} catch ( Exception ex ) {
throw new SystemException(sm.getString("enterprise_distributedtx.samerm_excep",ex));
}
if ( !isSameRM ) {
throw new IllegalStateException(sm.getString("enterprise_distributedtx.already_has_nonxa"));
}
}
if ( h.supportsXA() ) {
if (!d.supportsXAResource()) {
throw new IllegalStateException(
sm.getString("enterprise_distributedtx.xaresource_not_supported"));
}
if ( tx.isLocalTx() ) {
d.enlistLAOResource(tx, tx.getNonXAResource());
/** XXX TO BE MOVED TO XA DELEGATE XXX **
startJTSTx(tx);
//If transaction conatains a NonXA and no LAO, convert the existing
//Non XA to LAO
if(useLAO) {
if(tx.getNonXAResource()!=null && (tx.getLAOResource()==null) ) {
tx.setLAOResource(tx.getNonXAResource());
// XXX super.enlistLAOResource(tx, tx.getNonXAResource());
}
}
** XXX TO BE MOVED TO XA DELEGATE XXX **/
}
return enlistXAResource(tx, h);
} else { // non-XA resource
if (tx.isImportedTransaction())
throw new IllegalStateException(
sm.getString("enterprise_distributedtx.nonxa_usein_jts"));
if (tx.getNonXAResource() == null) {
tx.setNonXAResource(h);
}
if ( tx.isLocalTx() ) {
// notify resource that it is being used for tx,
// e.g. this allows the correct physical connection to be
// swapped in for the logical connection.
// The flags parameter can be 0 because the flags are not
// used by the XAResource implementation for non-XA resources.
try {
h.getXAResource().start(tx.getLocalXid(), 0);
} catch ( XAException ex ) {
throw new RuntimeException(
sm.getString("enterprise_distributedtx.xaresource_start_excep"),ex);
}
h.enlistedInTransaction(tx);
return true;
} else {
return d.enlistDistributedNonXAResource(tx, h);
/** XXX TO BE MOVED TO XA DELEGATE? XXX
if(useLAO) {
return super.enlistResource(tx, h);
} else {
throw new IllegalStateException(
sm.getString("enterprise_distributedtx.nonxa_usein_jts"));
}
** XXX TO BE MOVED TO XA DELEGATE? XXX **/
}
}
}
public void unregisterComponentResource(TransactionalResource h) {
Object instance = h.getComponentInstance();
if (instance == null) return;
h.setComponentInstance(null);
ComponentInvocation inv = invMgr.getCurrentInvocation();
List l = getExistingResourceList(instance, inv);
if (l != null) {
l.remove(h);
}
}
public void startJTSTx(JavaEETransaction t)
throws RollbackException, IllegalStateException, SystemException {
JavaEETransactionImpl tx = (JavaEETransactionImpl)t;
TransactionInternal jtsTx = getDelegate().startJTSTx(tx, tx.isAssociatedTimeout());
// The local Transaction was promoted to global Transaction
if (tx!=null && monitoringEnabled){
if(activeTransactions.remove(tx)){
monitor.transactionDeactivatedEvent();
}
}
tx.setJTSTx(jtsTx);
jtsTx.registerSynchronization(new JTSSynchronization(jtsTx, this));
}
/**
try {
if (tx.isAssociatedTimeout()) {
// calculate the timeout for the transaction, this is required as the local tx
// is getting converted to a global transaction
int timeout = tx.cancelTimerTask();
int newtimeout = (int) ((System.currentTimeMillis() - tx.getStartTime()) / 1000);
newtimeout = (timeout - newtimeout);
getDelegate().beginJTS(newtimeout);
} else {
getDelegate().beginJTS(getEffectiveTimeout());
}
// The local Transaction was promoted to global Transaction
if (tx!=null && monitoringEnabled){
if(activeTransactions.remove(tx)){
monitor.transactionDeactivatedEvent();
}
}
} catch ( NotSupportedException ex ) {
throw new RuntimeException(sm.getString("enterprise_distributedtx.lazy_transaction_notstarted"),ex);
}
**/
/**
* get the resources being used in the calling component's invocation context
* @param instance Calling component instance
* @param inv Calling component's invocation information
* @return List of resources
*/
public List getResourceList(Object instance, ComponentInvocation inv) {
if (inv == null)
return new ArrayList(0);
List l = null;
/** XXX EJB CONTAINER ONLY XXX -- NEED TO CHECK THE NEW CODE BELOW **
if (inv.getInvocationType() ==
ComponentInvocation.ComponentInvocationType.EJB_INVOCATION) {
ComponentContext ctx = inv.context;
if (ctx != null)
l = ctx.getResourceList();
else {
l = new ArrayList(0);
}
}
** XXX EJB CONTAINER ONLY XXX **/
ResourceHandler rh = inv.getResourceHandler();
if (rh != null) {
l = rh.getResourceList();
if (l == null) {
l = new ArrayList(0);
}
}
else {
Object key = getResourceTableKey(instance, inv);
if (key == null)
return new ArrayList(0);
l = (List) resourceTable.get(key);
if (l == null) {
l = new ArrayList(); //FIXME: use an optimum size?
resourceTable.put(key, l);
}
}
return l;
}
public void enlistComponentResources() throws RemoteException {
if (_logger.isLoggable(Level.FINE))
_logger.log(Level.FINE,"TM: enlistComponentResources");
ComponentInvocation inv = invMgr.getCurrentInvocation();
if (inv == null)
return;
try {
Transaction tran = getTransaction();
inv.setTransaction((JavaEETransaction)tran);
enlistComponentResources(inv);
} catch (InvocationException ex) {
_logger.log(Level.SEVERE,"enterprise_distributedtx.excep_in_enlist" ,ex);
throw new RemoteException(ex.getMessage(), ex.getNestedException());
} catch (Exception ex) {
_logger.log(Level.SEVERE,"enterprise_distributedtx.excep_in_enlist" ,ex);
throw new RemoteException(ex.getMessage(), ex);
}
}
public boolean delistResource(Transaction tran, TransactionalResource h, int flag)
throws IllegalStateException, SystemException {
if (!h.isTransactional()) return true;
if ( !(tran instanceof JavaEETransaction) )
return delistJTSResource(tran, h, flag);
JavaEETransactionImpl tx = (JavaEETransactionImpl)tran;
if ( tx.isLocalTx() ) {
// dissociate resource from tx
try {
h.getXAResource().end(tx.getLocalXid(), flag);
} catch ( XAException ex ) {
throw new RuntimeException(sm.getString("enterprise_distributedtx.xaresource_end_excep", ex));
}
return true;
}
else
return delistJTSResource(tran, h, flag);
}
public void delistComponentResources(boolean suspend)
throws RemoteException {
if (_logger.isLoggable(Level.FINE))
_logger.log(Level.FINE,"TM: delistComponentResources");
ComponentInvocation inv = invMgr.getCurrentInvocation();
// BEGIN IASRI# 4646060
if (inv == null) {
return;
}
// END IASRI# 4646060
try {
delistComponentResources(inv, suspend);
} catch (InvocationException ex) {
_logger.log(Level.SEVERE,"enterprise_distributedtx.excep_in_delist",ex);
throw new RemoteException("", ex.getNestedException());
} catch (Exception ex) {
_logger.log(Level.SEVERE,"enterprise_distributedtx.excep_in_delist",ex);
throw new RemoteException("", ex);
}
}
public void registerComponentResource(TransactionalResource h) {
ComponentInvocation inv = invMgr.getCurrentInvocation();
if (inv != null) {
Object instance = inv.getInstance();
if (instance == null) return;
h.setComponentInstance(instance);
List l = getResourceList(instance, inv);
l.add(h);
}
}
private JavaEETransactionImpl initJavaEETransaction(int timeout) {
JavaEETransactionImpl tx = null;
if (timeout > 0)
tx = new JavaEETransactionImpl(timeout);
else
tx = new JavaEETransactionImpl();
// Do not need to use injection.
tx.javaEETM = this;
setCurrentTransaction(tx);
return tx;
}
private List getExistingResourceList(Object instance) {
throw new IllegalStateException("Should not be called");
/**
if (instance == null)
return null;
Object key = getResourceTableKey(instance);
if (key == null)
return null;
return (List) resourceTable.get(key);
**/
}
public List getExistingResourceList(Object instance, ComponentInvocation inv) {
if (inv == null)
return null;
List l = null;
/** XXX EJB CONTAINER ONLY XXX -- NEED TO CHECK THE NEW CODE BELOW **
if (inv.getInvocationType() ==
ComponentInvocation.ComponentInvocationType.EJB_INVOCATION) {
ComponentContext ctx = inv.context;
if (ctx != null)
l = ctx.getResourceList();
return l;
}
** XXX EJB CONTAINER ONLY XXX **/
ResourceHandler rh = inv.getResourceHandler();
if (rh != null) {
l = rh.getResourceList();
}
else {
Object key = getResourceTableKey(instance, inv);
if (key != null)
l = (List) resourceTable.get(key);
}
return l;
}
public void preInvoke(ComponentInvocation prev)
throws InvocationException {
if ( prev != null && prev.getTransaction() != null &&
prev.isTransactionCompleting() == false) {
// do not worry about delisting previous invocation resources
// if transaction is being completed
delistComponentResources(prev, true); // delist with TMSUSPEND
}
}
public void postInvoke(ComponentInvocation curr, ComponentInvocation prev)
throws InvocationException {
if ( curr != null && curr.getTransaction() != null )
delistComponentResources(curr, false); // delist with TMSUCCESS
if ( prev != null && prev.getTransaction() != null &&
prev.isTransactionCompleting() == false) {
// do not worry about re-enlisting previous invocation resources
// if transaction is being completed
enlistComponentResources(prev);
}
}
public void componentDestroyed(Object instance) {
componentDestroyed(instance, null);
}
public void componentDestroyed(Object instance, ComponentInvocation inv) {
if (_logger.isLoggable(Level.FINE)) {
_logger.log(Level.FINE,"TM: componentDestroyed" + instance);
_logger.log(Level.FINE,"TM: resourceTable before: " + resourceTable.getEntryCount());
}
// Access resourceTable directly to avoid adding an empty list then removing it
List l = (List)resourceTable.remove(getResourceTableKey(instance, inv));
processResourceList(l);
if (_logger.isLoggable(Level.FINE))
_logger.log(Level.FINE,"TM: resourceTable after: " + resourceTable.getEntryCount());
}
public void componentDestroyed(ResourceHandler rh) {
if (_logger.isLoggable(Level.FINE))
_logger.log(Level.FINE, " componentDestroyed: " + rh);
if (rh != null) {
processResourceList(rh.getResourceList());
}
}
public boolean isTimedOut() {
JavaEETransaction tx = transactions.get();
if ( tx != null)
return tx.isTimedout();
else
return false;
}
/**
* Called from the CORBA Interceptors on the server-side when
* the server is replying to the client (local + remote client).
* Check if there is an active transaction and remove it from TLS.
*/
public void checkTransactionImport() {
// First check if this is a local call
int[] count = (int[])localCallCounter.get();
if ( count != null && count[0] > 0 ) {
count[0]--;
return;
}
else {
// A remote call, clear TLS so that if this thread is reused
// later, the current tx doesnt hang around.
clearThreadTx();
}
}
/**
* Called from the CORBA Interceptors on the client-side when
* a client makes a call to a remote object (not in the same JVM).
* Check if there is an active, exportable transaction.
* @exception RuntimeException if the transaction is not exportable
*/
public void checkTransactionExport(boolean isLocal) {
if ( isLocal ) {
// Put a counter in TLS indicating this is a local call.
// Use int[1] as a mutable java.lang.Integer!
int[] count = (int[])localCallCounter.get();
if ( count == null ) {
count = new int[1];
localCallCounter.set(count);
}
count[0]++;
return;
}
JavaEETransaction tx = transactions.get();
if ( tx == null )
return;
if ( !tx.isLocalTx() ) // a JTS tx, can be exported
return;
// Check if a local tx with non-XA resource is being exported.
// XXX what if this is a call on a non-transactional remote object ?
if ( tx.getNonXAResource() != null )
throw new RuntimeException(sm.getString("enterprise_distributedtx.cannot_export_transaction_having_nonxa"));
// If we came here, it means we have a local tx with no registered
// resources, so start a JTS tx which can be exported.
try {
startJTSTx(tx);
} catch ( RollbackException rlex ) {
throw new RuntimeException(sm.getString("enterprise_distributedtx.unable_tostart_JTSTransaction"),rlex);
} catch ( IllegalStateException isex ) {
throw new RuntimeException(sm.getString("enterprise_distributedtx.unable_tostart_JTSTransaction"),isex);
} catch ( SystemException ex ) {
throw new RuntimeException(sm.getString("enterprise_distributedtx.unable_tostart_JTSTransaction"),ex);
} catch ( Exception excep ) {
throw new RuntimeException(sm.getString("enterprise_distributedtx.unable_tostart_JTSTransaction"),excep);
}
}
/**
* This is used by importing transactions via the Connector contract.
* Should not be called
*
* @return a <code>XATerminator instance.
* @throws UnsupportedOperationException
*/
public XATerminator getXATerminator() {
return getDelegate().getXATerminator();
}
/**
* Release a transaction. This call causes the calling thread to be
* dissociated from the specified transaction. <p>
* This is used by importing transactions via the Connector contract.
*
* @param xid the Xid object representing a transaction.
*/
public void release(Xid xid) throws WorkException {
getDelegate().release(xid);
}
/**
* Recreate a transaction based on the Xid. This call causes the calling
* thread to be associated with the specified transaction. <p>
* This is used by importing transactions via the Connector contract.
*
* @param xid the Xid object representing a transaction.
*/
public void recreate(Xid xid, long timeout) throws WorkException {
getDelegate().recreate(xid, timeout);
}
/****************************************************************************/
/** Implementations of JTA TransactionManager APIs **************************/
/****************************************************************************/
public void registerSynchronization(Synchronization sync)
throws IllegalStateException, SystemException {
if (_logger.isLoggable(Level.FINE))
_logger.log(Level.FINE,"TM: registerSynchronization");
try {
Transaction tran = getTransaction();
if (tran != null) {
tran.registerSynchronization(sync);
}
} catch (RollbackException ex) {
_logger.log(Level.SEVERE,"enterprise_distributedtx.rollbackexcep_in_regsynch",ex);
throw new IllegalStateException();
}
}
// Implementation of begin() is moved to begin(int timeout)
public void begin() throws NotSupportedException, SystemException {
begin(getEffectiveTimeout());
}
/**
* This method is introduced as part of implementing the local transaction timeout
* capability. Implementation of begin() moved here. Previpusly there is no timeout
* infrastructure for local txns, so when ever a timeout required for local txn, it
* uses the globaltxn timeout infrastructure by doing an XA simulation.
**/
public void begin(int timeout) throws NotSupportedException, SystemException {
// Check if tx already exists
if ( transactions.get() != null )
throw new NotSupportedException(sm.getString("enterprise_distributedtx.notsupported_nested_transaction"));
setDelegate();
// Check if JTS tx exists, without starting JTS tx.
// This is needed in case the JTS tx was imported from a client.
if ( getStatus() != Status.STATUS_NO_TRANSACTION )
throw new NotSupportedException(sm.getString("enterprise_distributedtx.notsupported_nested_transaction"));
// START IASRI 4662745
if(monitoringEnabled){
getDelegate().getReadLock().lock(); // XXX acquireReadLock();
try{
JavaEETransactionImpl tx = initJavaEETransaction(timeout);
activeTransactions.addElement(tx);
monitor.transactionActivatedEvent();
ComponentInvocation inv = invMgr.getCurrentInvocation();
if (inv != null && inv.getInstance() != null) {
tx.setComponentName(inv.getInstance().getClass().getName());
}
}finally{
getDelegate().getReadLock().unlock(); // XXX releaseReadLock();
}
} else {
initJavaEETransaction(timeout);
}
// START IASRI 4662745
}
public void commit() throws RollbackException,
HeuristicMixedException, HeuristicRollbackException, SecurityException,
IllegalStateException, SystemException {
try {
JavaEETransaction tx = transactions.get();
if ( tx != null && tx.isLocalTx()) {
if(monitoringEnabled){
Object obj = tx;
getDelegate().getReadLock().lock(); // XXX acquireReadLock();
boolean success = false;
try{
tx.commit(); // commit local tx
success = true;
}catch(HeuristicMixedException e){
success = true;
throw e;
} finally {
monitorTxCompleted(obj, success);
getDelegate().getReadLock().unlock(); // XXX releaseReadLock();
}
} else {
tx.commit(); // commit local tx
}
}
else {
try{
// an XA transaction
getDelegate().commitDistributedTransaction();
}finally{
if ( tx != null ) {
((JavaEETransactionImpl)tx).onTxCompletion(true);
}
}
}
} finally {
setCurrentTransaction(null); // clear current thread's tx
delegates.set(null);
}
// END IASRI 4662745
}
public void rollback() throws IllegalStateException, SecurityException,
SystemException {
boolean acquiredlock=false;
try {
JavaEETransaction tx = transactions.get();
if ( tx != null && tx.isLocalTx()) {
if(monitoringEnabled){
Object obj = tx;
getDelegate().getReadLock().lock(); // XXX acquireReadLock();
acquiredlock = true;
try {
tx.rollback(); // rollback local tx
} finally {
monitorTxCompleted(obj, false);
}
} else {
tx.rollback(); // rollback local tx
}
}
else {
try {
// an XA transaction
getDelegate().rollbackDistributedTransaction();
}finally{
if ( tx != null ) {
((JavaEETransactionImpl)tx).onTxCompletion(false);
}
}
}
} finally {
setCurrentTransaction(null); // clear current thread's tx
delegates.set(null);
if(acquiredlock){
getDelegate().getReadLock().unlock(); // XXX releaseReadLock();
}
}
}
public int getStatus() throws SystemException {
return getDelegate().getStatus();
}
public Transaction getTransaction() throws SystemException {
return getDelegate().getTransaction();
/** XXX CHECK WHAT'S NEEDED FOR XA DELEGATE XXX **
TransactionInternal jtsTx = super.getTransaction();
if ( jtsTx == null )
return null;
else {
// check if this JTS Transaction was previously active
// in this JVM (possible for distributed loopbacks).
tx = (JavaEETransaction)globalTransactions.get(jtsTx);
if ( tx == null ) {
tx = new JavaEETransaction(jtsTx);
tx.setImportedTransaction();
try {
jtsTx.registerSynchronization(
new JTSSynchronization(jtsTx, this));
} catch ( RollbackException rlex ) {
throw new SystemException(rlex.toString());
} catch ( IllegalStateException isex ) {
throw new SystemException(isex.toString());
} catch ( Exception ex ) {
throw new SystemException(ex.toString());
}
globalTransactions.put(jtsTx, tx);
}
setCurrentTransaction(tx); // associate tx with thread
return tx;
}
** XXX CHECK WHAT'S NEEDED FOR XA DELEGATE XXX **/
}
public void setRollbackOnly()
throws IllegalStateException, SystemException {
JavaEETransaction tx = transactions.get();
// START IASRI 4662745
if ( tx != null && tx.isLocalTx()){
if(monitoringEnabled){
getDelegate().getReadLock().lock(); // XXX acquireReadLock();
try{
tx.setRollbackOnly();
}finally{
getDelegate().getReadLock().unlock(); // XXX releaseReadLock();
}
} else {
tx.setRollbackOnly();
}
}
else
getDelegate().setRollbackOnlyDistributedTransaction(); // probably a JTS imported tx
}
public Transaction suspend() throws SystemException {
return getDelegate().suspend(transactions.get());
/** XXX TO BE MOVED TO DELEGATES XXX **
if ( tx != null ) {
if ( !tx.isLocalTx() )
super.suspend();
setCurrentTransaction(null);
return tx;
}
else {
return super.suspend(); // probably a JTS imported tx
}
** XXX TO BE MOVED TO DELEGATES XXX **/
}
public void resume(Transaction tobj)
throws InvalidTransactionException, IllegalStateException,
SystemException {
JavaEETransaction tx = transactions.get();
if ( tx != null )
throw new IllegalStateException(
sm.getString("enterprise_distributedtx.transaction_exist_on_currentThread"));
if ( tobj instanceof JavaEETransactionImpl ) {
JavaEETransactionImpl javaEETx = (JavaEETransactionImpl)tobj;
if ( !javaEETx.isLocalTx() )
getDelegate().resume(javaEETx.getJTSTx());
setCurrentTransaction(javaEETx);
}
else {
getDelegate().resume(tobj); // probably a JTS imported tx
}
}
/**
* Modify the value of the timeout value that is associated with the
* transactions started by the current thread with the begin method.
*
* <p> If an application has not called this method, the transaction
* service uses some default value for the transaction timeout.
*
* @exception SystemException Thrown if the transaction manager
* encounters an unexpected error condition
*
*/
public void setTransactionTimeout(int seconds) throws SystemException {
if (seconds < 0) {
throw new SystemException(sm.getString("enterprise_distributedtx.invalid_timeout"));
}
txnTmout.set(seconds);
// transactionTimeout = seconds;
}
/**
* Modify the value to be used to purge transaction tasks after the
* specified number of cancelled tasks.
*/
public void setPurgeCancelledTtransactionsAfter(int num) {
purgeCancelledTtransactions = num;
}
/**
* Returns the value to be used to purge transaction tasks after the
* specified number of cancelled tasks.
*/
public int getPurgeCancelledTtransactionsAfter() {
return purgeCancelledTtransactions;
}
public JavaEETransaction getCurrentTransaction() {
return transactions.get();
}
public void setCurrentTransaction(JavaEETransaction t) {
transactions.set(t);
}
public XAResourceWrapper getXAResourceWrapper(String clName) {
return getDelegate().getXAResourceWrapper(clName);
}
public void handlePropertyUpdate(String name, Object value) {
delegate.handlePropertyUpdate(name, value);
// XXX Check if the current delegate needs to be called as well.
}
public boolean recoverIncompleteTx(boolean delegated, String logPath,
XAResource[] xaresArray) throws Exception {
return delegate.recoverIncompleteTx(delegated, logPath, xaresArray);
}
/****************************************************************************/
/*********************** Called by Admin Framework **************************/
/****************************************************************************/
/*
* Called by Admin Framework to freeze the transactions.
*/
public synchronized void freeze(){
getDelegate().acquireWriteLock();
monitor.freezeEvent(true);
}
/*
* Called by Admin Framework to freeze the transactions.
* These undoes the work done by the freeze.
*/
public synchronized void unfreeze(){
getDelegate().releaseWriteLock();
monitor.freezeEvent(false);
}
/** XXX ???
*/
public boolean isFrozen() {
return getDelegate().isWriteLocked();
}
public void cleanTxnTimeout() {
txnTmout.set(null);
}
public int getEffectiveTimeout() {
Integer tmout = txnTmout.get();
if (tmout == null) {
return transactionTimeout;
}
else {
return tmout;
}
}
public void setDefaultTransactionTimeout(int seconds) {
if (seconds < 0) seconds = 0;
transactionTimeout = seconds;
}
/*
* This method returns the details of the Currently Active Transactions
* Called by Admin Framework when transaction monitoring is enabled
* @return ArrayList of TransactionAdminBean
* @see TransactionAdminBean
*/
public ArrayList getActiveTransactions() {
ArrayList tranBeans = new ArrayList();
txnTable = new Hashtable();
Vector active = (Vector)activeTransactions.clone(); // get the clone of the active transactions
for(int i=0;i<active.size();i++){
try{
Transaction tran = (Transaction)active.elementAt(i);
TransactionAdminBean tBean = getDelegate().getTransactionAdminBean(tran);
if (tBean == null) {
// Shouldn't happen
_logger.warning("enterprise_distributedtx.txbean_null" + tran);
} else {
if (_logger.isLoggable(Level.FINE))
_logger.log(Level.FINE,"TM: Adding txnId " + tBean.getId() + " to txnTable");
txnTable.put(tBean.getId(), tran);
tranBeans.add(tBean);
}
}catch(Exception ex){
_logger.log(Level.SEVERE,
"transaction.monitor.error_while_getting_monitor_attr", ex);
}
}
return tranBeans;
}
public TransactionAdminBean getTransactionAdminBean(Transaction tran)
throws javax.transaction.SystemException {
TransactionAdminBean tBean = null;
if(tran instanceof JavaEETransaction){
JavaEETransactionImpl tran1 = (JavaEETransactionImpl)tran;
String id = tran1.getTransactionId();
long startTime = tran1.getStartTime();
String componentName = tran1.getComponentName();
ArrayList<String> resourceNames = tran1.getResourceNames();
long elapsedTime = System.currentTimeMillis()-startTime;
String status = getStatusAsString(tran.getStatus());
tBean = new TransactionAdminBean(tran, id, status, elapsedTime,
componentName, resourceNames);
}
return tBean;
}
/*
* Called by Admin Framework when transaction monitoring is enabled
*/
public void forceRollback(String txnId) throws IllegalStateException, SystemException{
// XXX - WORK AROUND MONITORING BUG
if (txnTable == null || txnTable.size() == 0)
getActiveTransactions();
// XXX - WORK AROUND MONITORING BUG
if (txnTable == null || txnTable.get(txnId) == null) {
String result = sm.getString("transaction.monitor.rollback_invalid_id");
throw new IllegalStateException(result);
} else {
if (_logger.isLoggable(Level.FINE))
_logger.log(Level.FINE,"TM: Marking txnId " + txnId + " for rollback");
((Transaction) txnTable.get(txnId)).setRollbackOnly();
}
}
public void setMonitoringEnabled(boolean enabled){
monitoringEnabled = enabled;
//reset the variables
activeTransactions.removeAllElements();
}
protected void monitorTxCompleted(Object obj, boolean committed){
if(obj != null) {
if (obj instanceof JavaEETransactionImpl) {
JavaEETransactionImpl t = (JavaEETransactionImpl) obj;
if (!t.isLocalTx()) {
obj = t.getJTSTx();
}
}
if(activeTransactions.remove(obj)){
if(committed){
monitor.transactionCommittedEvent();
}else{
monitor.transactionRolledbackEvent();
}
} else {
// WARN ???
}
}
}
// Mods: Adding method for statistic dumps using TimerTask
private void registerStatisticMonitorTask() {
TimerTask task = new StatisticMonitorTask();
// for now, get monitoring interval from system prop
int statInterval = 2 * 60 * 1000;
try {
String interval
= System.getProperty("MONITOR_JTA_RESOURCE_TABLE_SECONDS");
int temp = Integer.parseInt(interval);
if (temp > 0) {
statInterval = temp;
}
} catch (Exception ex) {
// ignore
}
_timer.scheduleAtFixedRate(task, 0, statInterval);
}
// Mods: Adding TimerTask class for statistic dumps
class StatisticMonitorTask extends TimerTask {
public void run() {
if (resourceTable != null) {
Map stats = resourceTable.getStats();
Iterator it = stats.keySet().iterator();
String key;
_logger.log(Level.INFO,
"********** JavaEETransactionManager resourceTable stats *****");
while (it.hasNext()) {
key = (String)it.next();
_logger.log(Level.INFO, key + ": " + stats.get(key).toString());
}
}
}
}
/****************************************************************************/
/************************* Helper Methods ***********************************/
/****************************************************************************/
public static String getStatusAsString(int status) {
return (String)statusMap.get(status);
}
private void delistComponentResources(ComponentInvocation inv,
boolean suspend)
throws InvocationException {
try {
Transaction tran = (Transaction) inv.getTransaction();
if (isTransactionActive(tran)) {
List l = getExistingResourceList(inv.getInstance(), inv);
if (l == null || l.size() == 0)
return;
int flag = (suspend)? XAResource.TMSUSPEND : XAResource.TMSUCCESS;
Iterator it = l.iterator();
while(it.hasNext()){
TransactionalResource h = (TransactionalResource)it.next();
try{
if ( h.isEnlisted() ) {
delistResource(tran, h, flag);
}
} catch (IllegalStateException ex) {
if (_logger.isLoggable(Level.FINE))
_logger.log(Level.FINE,"TM: Exception in delistResource", ex);
// ignore error due to tx time out
}catch(Exception ex){
if (_logger.isLoggable(Level.FINE))
_logger.log(Level.FINE,"TM: Exception in delistResource", ex);
it.remove();
handleResourceError(h, ex, tran);
}
}
//END OF IASRI 4658504
}
} catch (Exception ex) {
_logger.log(Level.SEVERE,"enterprise_distributedtx.excep_in_delist",ex);
}
}
protected boolean enlistXAResource(Transaction tran, TransactionalResource h)
throws RollbackException, IllegalStateException, SystemException {
if (_logger.isLoggable(Level.FINE))
_logger.log(Level.FINE,"TM: enlistResource");
if (resourceEnlistable(h)) {
XAResource res = h.getXAResource();
boolean result = tran.enlistResource(res);
if (!h.isEnlisted())
h.enlistedInTransaction(tran);
return result;
} else {
return true;
}
}
private void enlistComponentResources(ComponentInvocation inv)
throws InvocationException {
try {
Transaction tran = (Transaction) inv.getTransaction();
if (isTransactionActive(tran)) {
List l = getExistingResourceList(inv.getInstance(), inv);
if (l == null || l.size() == 0) return;
Iterator it = l.iterator();
// END IASRI 4705808 TTT002
while(it.hasNext()) {
TransactionalResource h = (TransactionalResource) it.next();
try{
enlistResource(tran,h);
}catch(Exception ex){
it.remove();
handleResourceError(h,ex,tran);
}
}
//END OF IASRI 4658504
}
} catch (Exception ex) {
_logger.log(Level.SEVERE,"enterprise_distributedtx.excep_in_enlist",ex);
}
}
/**
* Called by #componentDestroyed()
*/
private void processResourceList(List l) {
if (l != null && l.size() > 0) {
Iterator it = l.iterator();
while (it.hasNext()) {
TransactionalResource h = (TransactionalResource) it.next();
try {
h.closeUserConnection();
} catch (Exception ex) {
if (_logger.isLoggable(Level.FINE))
_logger.log(Level.WARNING,"enterprise_distributedtx.pooling_excep", ex);
}
}
l.clear();
}
}
private void handleResourceError(TransactionalResource h,
Exception ex, Transaction tran) {
if (_logger.isLoggable(Level.FINE)) {
if (h.isTransactional()) {
_logger.log(Level.FINE,"TM: HandleResourceError " +
h.getXAResource() +
"," + ex);
}
}
try {
if (tran != null && h.isTransactional() && h.isEnlisted() ) {
tran.delistResource(h.getXAResource(), XAResource.TMSUCCESS);
}
} catch (Exception ex2) {
// ignore
}
if (ex instanceof RollbackException) {
// transaction marked as rollback
return;
} else if (ex instanceof IllegalStateException) {
// transaction aborted by time out
// close resource
try {
h.closeUserConnection();
} catch (Exception ex2) {
//Log.err.println(ex2);
}
} else {
// destroy resource. RM Error.
try {
h.destroyResource();
} catch (Exception ex2) {
//Log.err.println(ex2);
}
}
}
private Object getResourceTableKey(Object instance, ComponentInvocation inv) {
Object key = null;
if ( inv != null) {
key = inv.getResourceTableKey();
}
// If ComponentInvocation is null or doesn't hold the key,
// use instance as the key.
if (key == null) {
key = instance;
}
return key;
}
private boolean isTransactionActive(Transaction tran) {
return (tran != null);
}
/**
* JTS version of the #delistResource
* @param suspend true if the transaction association should
* be suspended rather than ended.
*/
private boolean delistJTSResource(Transaction tran, TransactionalResource h,
int flag)
throws IllegalStateException, SystemException {
// ** XXX Throw an exception instead ??? XXX **
if (_logger.isLoggable(Level.FINE))
_logger.log(Level.FINE,"TM: delistResource");
if (!h.isShareable() || multipleEnlistDelists) {
if (h.isTransactional() && h.isEnlisted()) {
return tran.delistResource(h.getXAResource(), flag);
} else {
return true;
}
}
return true;
}
private void remove(Transaction tx) {
getDelegate().removeTransaction(tx);
/** XXX TO BE MOVED TO XA DELEGATE XXX
javaEETM.globalTransactions.remove(jtsTx);
** XXX TO BE MOVED TO XA DELEGATE XXX **/
}
/**
* Called by JavaEETransactionImpl also
*/
JavaEETransactionManagerDelegate getDelegate() {
JavaEETransactionManagerDelegate d = delegates.get();
return (d == null)? delegate : d;
}
private JavaEETransactionManagerDelegate setDelegate() {
JavaEETransactionManagerDelegate d = delegates.get();
if (d == null) {
d = delegate;
delegates.set(d);
}
return d;
}
public boolean isDelegate(JavaEETransactionManagerDelegate d) {
if (delegate == null)
return false;
return (d.getClass().getName().equals(delegate.getClass().getName()));
}
private void initDelegates() {
if (habitat == null)
return; // the delegate will be set explicitly
for (JavaEETransactionManagerDelegate d :
habitat.getAllByContract(JavaEETransactionManagerDelegate.class)) {
setDelegate(d);
}
if (delegate != null && _logger.isLoggable(Level.FINE))
_logger.log(Level.INFO, "enterprise_used_delegate_name", delegate.getClass().getName());
}
public synchronized void setDelegate(JavaEETransactionManagerDelegate d) {
// XXX Check if it's valid to set or if we need to remember all that asked.
int curr = 0;
if (delegate != null) {
curr = delegate.getOrder();
}
if (d.getOrder() > curr) {
delegate = d;
// XXX Hk2 work around XXX
delegate.setTransactionManager(this);
if (_logger.isLoggable(Level.FINE))
_logger.log(Level.FINE,"Replaced delegate with "
+ d.getClass().getName());
}
}
public Logger getLogger() {
return _logger;
}
public void monitorTxCompleted0(Object obj, boolean b) {
if(monitoringEnabled){
monitorTxCompleted(obj, b);
}
}
public void monitorTxBegin(Transaction tx) {
if (monitoringEnabled) {
activeTransactions.addElement(tx);
monitor.transactionActivatedEvent();
}
}
public boolean resourceEnlistable(TransactionalResource h) {
return (h.isTransactional() &&
(!h.isEnlisted() || !h.isShareable() || multipleEnlistDelists));
}
public boolean isInvocationStackEmpty() {
return (invMgr == null || invMgr.isInvocationStackEmpty());
}
public void setTransactionCompeting(boolean b) {
ComponentInvocation curr = invMgr.getCurrentInvocation();
if (curr != null)
curr.setTransactionCompeting(b);
}
public JavaEETransaction createImportedTransaction(TransactionInternal jtsTx)
throws SystemException {
JavaEETransactionImpl tx = new JavaEETransactionImpl(jtsTx);
tx.setImportedTransaction();
try {
jtsTx.registerSynchronization(
new JTSSynchronization(jtsTx, this));
} catch ( RollbackException rlex ) {
throw new SystemException(rlex.toString());
} catch ( IllegalStateException isex ) {
throw new SystemException(isex.toString());
} catch ( Exception ex ) {
throw new SystemException(ex.toString());
}
return tx;
}
/****************************************************************************/
/** Implementation of javax.transaction.Synchronization *********************/
/****************************************************************************/
private class JTSSynchronization implements Synchronization {
private TransactionInternal jtsTx;
private JavaEETransactionManagerSimplified javaEETM;
JTSSynchronization(TransactionInternal jtsTx,
JavaEETransactionManagerSimplified javaEETM){
this.jtsTx = jtsTx;
this.javaEETM = javaEETM;
}
public void beforeCompletion() {}
public void afterCompletion(int status) {
javaEETM.remove(jtsTx);
}
}
}
Other Glassfish examples (source code examples)
Here is a short list of links related to this Glassfish JavaEETransactionManagerSimplified.java source code file:
|
The search page
Other Glassfish source code examples at this package level
Click here to learn more about this project
