/*
* JBoss, Home of Professional Open Source.
* Copyright 2008, Red Hat Middleware LLC, and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.test.tm.resource;
import java.io.Serializable;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import javax.naming.InitialContext;
import javax.transaction.Synchronization;
import javax.transaction.Transaction;
import javax.transaction.TransactionManager;
import org.jboss.logging.Logger;
import org.jboss.tm.TxUtils;
/**
* MultiThreaded Operations that can be executed concurrently.
*
* Based on Operation class.
*
* @author <a href="dimitris@jboss.org">Dimitris Andreadis</a>
* @version $Revision: 100025 $
*/
public class MTOperation implements Serializable
{
// Static Data ---------------------------------------------------
/** The serialVersionUID */
private static final long serialVersionUID = 2924873545494045020L;
/** Available Operations */
public static final int TM_GET_STATUS = 0;
public static final int TM_BEGIN = 1;
public static final int TM_RESUME = 2;
public static final int TM_COMMIT = 3;
public static final int TX_COMMIT = 4;
public static final int TX_REGISTER_SYNC = 5;
public static final int XX_SLEEP_200 = 6;
public static final int XX_WAIT_FOR = 7;
/** The Logger */
protected static Logger log;
/** TM instance */
protected static TransactionManager tm = null;
/** Shared resources */
protected static Map resources = Collections.synchronizedMap(new HashMap());
/** Active Transactions */
protected static Map transactions = Collections.synchronizedMap(new HashMap());
// Protected Data ------------------------------------------------
/** An id for this transaction */
protected Integer id;
/** The operation to execute */
protected int op;
/** Set when an exception is expected */
protected Throwable throwable;
/** If a throwable is required, or only *may* occur */
private boolean require;
// Static Methods ------------------------------------------------
/**
* Setup static objects for the test
*/
public static void init(Logger log) throws Exception
{
MTOperation.log = log;
if (getTM().getTransaction() != null)
{
throw new IllegalStateException("Invalid thread association " + getTM().getTransaction());
}
resources.clear();
transactions.clear();
}
/**
* Lazy TransactionManager lookup
*/
public static TransactionManager getTM() throws Exception
{
if (tm == null)
{
tm = (TransactionManager) new InitialContext().lookup("java:/TransactionManager");
}
return tm;
}
/**
* Cleanup
*/
public static void destroy()
{
resources.clear();
transactions.clear();
}
// Constructors --------------------------------------------------
public MTOperation(int op)
{
this(op, 0);
}
public MTOperation(int op, int id)
{
this.id = new Integer(id);
this.op = op;
}
public MTOperation(int op, int id, Throwable throwable)
{
this(op, id, throwable, true);
}
public MTOperation(int op, int id, Throwable throwable, boolean require)
{
this.id = new Integer(id);
this.op = op;
this.throwable = throwable;
this.require = require;
}
// Public Methods ------------------------------------------------
public void perform() throws Exception
{
Throwable caught = null;
try
{
switch (op)
{
case TM_GET_STATUS:
tmGetStatus();
break;
case TM_BEGIN:
tmBegin();
break;
case TM_RESUME:
tmResume();
break;
case TM_COMMIT:
tmCommit();
break;
case TX_COMMIT:
txCommit();
break;
case TX_REGISTER_SYNC:
txRegisterSync();
break;
case XX_SLEEP_200:
xxSleep200();
break;
case XX_WAIT_FOR:
xxWaitForTx();
break;
default:
throw new IllegalArgumentException("Invalid operation " + op);
}
}
catch (Throwable t)
{
caught = t;
}
// required an exception but caught none
if (require && throwable != null && caught == null)
{
throw new Exception("Expected throwable " + throwable);
}
// got an exception, but it was the wrong one
if (throwable != null && caught != null && !throwable.getClass().isAssignableFrom(caught.getClass()))
{
log.warn("Caught wrong throwable", caught);
throw new Exception("Expected throwable " + throwable + " caught " + caught);
}
// did not expect an exception but caught one
if (throwable == null && caught != null)
{
log.warn("Caught unexpected throwable", caught);
throw new Exception("Unexpected throwable " + caught);
}
}
public void tmGetStatus() throws Exception
{
log.info(tid() + " " + TxUtils.getStatusAsString(getTM().getStatus()));
}
public void tmBegin() throws Exception
{
log.info(tid() + " TM_BEGIN (" + id + ")");
getTM().begin();
Transaction tx = getTM().getTransaction();
synchronized (transactions)
{
transactions.put(id, tx);
transactions.notifyAll();
}
}
public void tmResume() throws Exception
{
log.info(tid() + " TM_RESUME (" + id + ")");
Transaction tx = (Transaction)transactions.get(id);
if (tx == null)
{
throw new IllegalStateException("Tx not found:" + id);
}
else
{
getTM().resume(tx);
}
}
public void tmCommit() throws Exception
{
log.info(tid() + " TM_COMMIT");
getTM().commit();
}
public void txCommit() throws Exception
{
log.info(tid() + " TX_COMMIT (" + id + ")");
Transaction tx = (Transaction)transactions.get(id);
if (tx == null)
{
throw new IllegalStateException("Tx not found: " + id);
}
else
{
tx.commit();
}
}
public void txRegisterSync() throws Exception
{
log.info(tid() + " TX_REGISTER_SYNC (" + id + ")");
Transaction tx = (Transaction)transactions.get(id);
if (tx == null)
{
throw new IllegalStateException("Tx not found: " + id);
}
Synchronization sync = new Synchronization()
{
public void beforeCompletion()
{
log.info(tid() + " beforeCompletion() called");
}
public void afterCompletion(int status)
{
log.info (tid() + " afterCompletion(" + TxUtils.getStatusAsString(status) + ") called");
}
};
tx.registerSynchronization(sync);
}
public void xxWaitForTx() throws Exception
{
log.info(tid() + " XX_WAIT_FOR (" + id + ")");
Transaction tx = (Transaction)transactions.get(id);
while (tx == null)
{
log.info(tid() + " Sleeping for 100 msecs");
synchronized (transactions)
{
try
{
transactions.wait(100);
}
catch (InterruptedException ignore) {}
}
tx = (Transaction)transactions.get(id);
}
log.info(tid() + " Got it");
}
public void xxSleep200() throws Exception
{
log.info(tid() + " XX_SLEEP_200");
Thread.sleep(200);
}
private String tid()
{
return Thread.currentThread().getName();
}
}