From d97df97a936e63b5089ce9b0c79cab0ddd2f723e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonas=20Bon=C3=A9r?= <jonasremove@jonasboner.com>
Date: Thu, 8 Apr 2010 17:02:01 +0200
Subject: [PATCH 01/41] Added JTA module, monadic and higher-order functional
 API

---
 .../scala/AtomikosTransactionService.scala    |  36 +++
 .../src/main/scala/TransactionContext.scala   | 181 ++++++++++++
 .../src/main/scala/TransactionProtocol.scala  | 258 ++++++++++++++++++
 project/build/AkkaProject.scala               |  17 +-
 4 files changed, 489 insertions(+), 3 deletions(-)
 create mode 100644 akka-jta/src/main/scala/AtomikosTransactionService.scala
 create mode 100644 akka-jta/src/main/scala/TransactionContext.scala
 create mode 100644 akka-jta/src/main/scala/TransactionProtocol.scala

diff --git a/akka-jta/src/main/scala/AtomikosTransactionService.scala b/akka-jta/src/main/scala/AtomikosTransactionService.scala
new file mode 100644
index 0000000000..d688564686
--- /dev/null
+++ b/akka-jta/src/main/scala/AtomikosTransactionService.scala
@@ -0,0 +1,36 @@
+/**
+ * Copyright (C) 2009-2010 Scalable Solutions AB <http://scalablesolutions.se>
+ */
+
+package se.scalablesolutions.akka.jta
+
+import javax.transaction.{TransactionManager, SystemException}
+
+import com.atomikos.icatch.jta.{J2eeTransactionManager, J2eeUserTransaction}
+import com.atomikos.icatch.config.{TSInitInfo, UserTransactionService, UserTransactionServiceImp}
+
+/**
+ * Atomikos implementation of the transaction service trait.
+ *
+ * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
+ */
+object AtomikosTransactionService extends TransactionService with TransactionProtocol {
+
+  // FIXME: make configurable
+  val JTA_TRANSACTION_TIMEOUT = 60
+  private val txService: UserTransactionService = new UserTransactionServiceImp
+  private val info: TSInitInfo = txService.createTSInitInfo
+
+  val transactionManager =
+    try {
+      txService.init(info)
+      val tm: TransactionManager = new J2eeTransactionManager
+      tm.setTransactionTimeout(JTA_TRANSACTION_TIMEOUT)
+      tm
+    } catch {
+      case e => throw new SystemException("Could not create a new Atomikos J2EE Transaction Manager, due to: " + e.toString)
+    }
+
+  // TODO: gracefully shutdown of the TM
+  //txService.shutdown(false)
+}
diff --git a/akka-jta/src/main/scala/TransactionContext.scala b/akka-jta/src/main/scala/TransactionContext.scala
new file mode 100644
index 0000000000..3ed562eeb5
--- /dev/null
+++ b/akka-jta/src/main/scala/TransactionContext.scala
@@ -0,0 +1,181 @@
+/**
+ * Copyright (C) 2009-2010 Scalable Solutions AB <http://scalablesolutions.se>
+ */
+
+package se.scalablesolutions.akka.jta
+
+import javax.transaction.{Transaction, Status, TransactionManager}
+
+import se.scalablesolutions.akka.util.Logging
+
+/**
+ * JTA Transaction service.
+ *
+ * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
+ */
+trait TransactionService {
+  def transactionManager: TransactionManager  
+}
+
+/**
+ * Base monad for the transaction monad implementations.
+ *
+ * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
+ */
+trait TransactionMonad {
+
+  // -----------------------------
+  // Monadic definitions
+  // -----------------------------
+
+  def map[T](f: TransactionMonad => T): T
+  def flatMap[T](f: TransactionMonad => T): T
+  def foreach(f: TransactionMonad => Unit): Unit
+  def filter(f: TransactionMonad => Boolean): TransactionMonad =
+    if (f(this)) this else TransactionContext.NoOpTransactionMonad
+
+  // -----------------------------
+  // JTA Transaction definitions
+  // -----------------------------
+
+  /**
+   * Returns the current Transaction.
+   */
+  def getTransaction: Transaction = TransactionContext.getTransactionManager.getTransaction
+
+  /**
+   * Marks the current transaction as doomed.
+   */
+  def setRollbackOnly = TransactionContext.setRollbackOnly
+
+  /**
+   * Marks the current transaction as doomed.
+   */
+  def doom = TransactionContext.setRollbackOnly
+
+  /**
+   * Checks if the current transaction is doomed.
+   */
+  def isRollbackOnly = TransactionContext.isRollbackOnly
+
+  /**
+   * Checks that the current transaction is NOT doomed.
+   */
+  def isNotDoomed = !TransactionContext.isRollbackOnly
+}
+
+/**
+ * Manages a thread-local stack of TransactionContexts.
+ * <p/>
+ * Choose TransactionService implementation by implicit definition of the implementation of choice,
+ * e.g. <code>implicit val txService = TransactionServices.AtomikosTransactionService</code>.
+ * <p/>
+ * Example usage 1:
+ * <pre>
+ * for {
+ *   ctx <- TransactionContext.Required
+ *   entity <- updatedEntities
+ *   if !ctx.isRollbackOnly
+ * } {
+ *   // transactional stuff
+ *   ...
+ * }
+ * </pre>
+ * Example usage 2:
+ * <pre>
+ * val users = for {
+ *   ctx <- TransactionContext.Required
+ *   name <- userNames
+ * } yield {
+ *   // transactional stuff
+ *   ...
+ * }
+ * </pre>
+ *
+ * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
+ */
+object TransactionContext extends TransactionProtocol with Logging {
+  // FIXME: make configurable
+  private implicit val defaultTransactionService = AtomikosTransactionService
+
+  private[TransactionContext] val stack = new scala.util.DynamicVariable(new TransactionContext)
+
+  object Required extends TransactionMonad {
+    def map[T](f: TransactionMonad => T): T =        withTxRequired { f(this) }
+    def flatMap[T](f: TransactionMonad => T): T =    withTxRequired { f(this) }
+    def foreach(f: TransactionMonad => Unit): Unit = withTxRequired { f(this) }
+  }
+
+  object RequiresNew extends TransactionMonad {
+    def map[T](f: TransactionMonad => T): T =        withTxRequiresNew { f(this) }
+    def flatMap[T](f: TransactionMonad => T): T =    withTxRequiresNew { f(this) }
+    def foreach(f: TransactionMonad => Unit): Unit = withTxRequiresNew { f(this) }
+  }
+
+  object Supports extends TransactionMonad {
+    def map[T](f: TransactionMonad => T): T =        withTxSupports { f(this) }
+    def flatMap[T](f: TransactionMonad => T): T =    withTxSupports { f(this) }
+    def foreach(f: TransactionMonad => Unit): Unit = withTxSupports { f(this) }
+  }
+
+  object Mandatory extends TransactionMonad {
+    def map[T](f: TransactionMonad => T): T =        withTxMandatory { f(this) }
+    def flatMap[T](f: TransactionMonad => T): T =    withTxMandatory { f(this) }
+    def foreach(f: TransactionMonad => Unit): Unit = withTxMandatory { f(this) }
+  }
+
+  object Never extends TransactionMonad {
+    def map[T](f: TransactionMonad => T): T =        withTxNever { f(this) }
+    def flatMap[T](f: TransactionMonad => T): T =    withTxNever { f(this) }
+    def foreach(f: TransactionMonad => Unit): Unit = withTxNever { f(this) }
+  }
+
+  object NoOpTransactionMonad extends TransactionMonad {
+    def map[T](f: TransactionMonad => T): T =        f(this)
+    def flatMap[T](f: TransactionMonad => T): T =    f(this)
+    def foreach(f: TransactionMonad => Unit): Unit = f(this)
+    override def filter(f: TransactionMonad => Boolean): TransactionMonad = this
+  }
+
+  private[jta] def setRollbackOnly = current.setRollbackOnly
+
+  private[jta] def isRollbackOnly = current.isRollbackOnly
+
+  private[jta] def getTransactionManager: TransactionManager = current.getTransactionManager
+
+  private[jta] def getTransaction: Transaction = current.getTransactionManager.getTransaction
+
+  private[this] def current = stack.value
+
+  /**
+   * Continues with the invocation defined in 'body' with the brand new context define in 'newCtx', the old
+   * one is put on the stack and will automatically come back in scope when the method exits.
+   * <p/>
+   * Suspends and resumes the current JTA transaction.
+   */
+  private[jta] def withNewContext[T](body: => T): T = {
+    val suspendedTx: Option[Transaction] =
+      if (isInExistingTransaction(getTransactionManager)) {
+        log.debug("Suspending TX")
+        Some(getTransactionManager.suspend)
+      } else None
+    val result = stack.withValue(new TransactionContext) { body }
+    if (suspendedTx.isDefined) {
+      log.debug("Resuming TX")
+      getTransactionManager.resume(suspendedTx.get)
+    }
+    result
+  }
+}
+
+/**
+ * Transaction context, holds the EntityManager and the TransactionManager.
+ *
+ * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
+ */
+class TransactionContext(private implicit val transactionService: TransactionService) {
+  val tm: TransactionManager = transactionService.transactionManager
+  private def setRollbackOnly = tm.setRollbackOnly
+  private def isRollbackOnly: Boolean = tm.getStatus == Status.STATUS_MARKED_ROLLBACK
+  private def getTransactionManager: TransactionManager = tm
+}
diff --git a/akka-jta/src/main/scala/TransactionProtocol.scala b/akka-jta/src/main/scala/TransactionProtocol.scala
new file mode 100644
index 0000000000..4a4c263eb1
--- /dev/null
+++ b/akka-jta/src/main/scala/TransactionProtocol.scala
@@ -0,0 +1,258 @@
+/**
+ * Copyright (C) 2009-2010 Scalable Solutions AB <http://scalablesolutions.se>
+ */
+
+package se.scalablesolutions.akka.jta
+
+import se.scalablesolutions.akka.util.Logging
+
+import javax.naming.{NamingException, Context, InitialContext}
+import javax.transaction.{
+  Transaction,
+  UserTransaction,
+  TransactionManager,
+  Status,
+  RollbackException,
+  SystemException,
+  TransactionRequiredException
+}
+
+/**
+ * <p>
+ * Trait that implements a JTA transaction service that obeys the transaction semantics defined
+ * in the transaction attribute types for the transacted methods according to the EJB 3 draft specification.
+ * The aspect handles UserTransaction, TransactionManager instance variable injection thru @javax.ejb.Inject
+ * (name subject to change as per EJB 3 spec) and method transaction levels thru @javax.ejb.TransactionAttribute.
+ * </p>
+ *
+ * <p>
+ * This trait should be inherited to implement the getTransactionManager() method that should return a concrete
+ * javax.transaction.TransactionManager implementation (from JNDI lookup etc).
+ * </p>
+ * <p>
+ * <h3>Transaction attribute semantics</h3>
+ * (From http://www.kevinboone.com/ejb-transactions.html)
+ * </p>
+ * <p>
+ * <h4>Required</h4>
+ * 'Required' is probably the best choice (at least initially) for an EJB method that will need to be transactional. In this case, if the  method's caller is already part of a transaction, then the EJB method does not create a new transaction, but continues in the same transaction as its caller. If the caller is not in a transaction, then a new transaction is created for the EJB method. If something happens in the EJB that means that a rollback is required, then the extent of the rollback will include everything done in the EJB method, whatever the condition of the caller. If the caller was in a transaction, then everything done by the caller will be rolled back as well. Thus the 'required' attribute ensures that any work done by the EJB will be rolled back if necessary, and if the caller requires a rollback that too will be rolled back.
+ * </p>
+ * <p>
+ * <h4>RequiresNew</h4>
+ * 'RequiresNew' will be appropriate if you want to ensure that the EJB method is rolled back if necessary, but you don't want the rollback to propogate back to the caller. This attribute results in the creation of a new transaction for the method, regardless of the transactional state of the caller. If the caller was operating in a transaction, then its transaction is suspended until the EJB method completes. Because a new transaction is always created, there may be a slight performance penalty if this attribute is over-used.
+ * </p>
+ * <p>
+ * <h4>Mandatory</h4>
+ * With the 'mandatory' attribute, the EJB method will not even start unless its caller is in a transaction. It will throw a <code>TransactionRequiredException</code> instead. If the method does start, then it will become part of the transaction of the caller. So if the EJB method signals a failure, the caller will be rolled back as well as the EJB.
+ * </p>
+ * <p>
+ * <h4>Supports</h4>
+ * With this attribute, the EJB method does not care about the transactional context of its caller. If the caller is part of a transaction, then the EJB method will be part of the same transaction. If the EJB method fails, the transaction will roll back. If the caller is not part of a transaction, then the EJB method will still operate, but a failure will not cause anything to roll back. 'Supports' is probably the attribute that leads to the fastest method call (as there is no transactional overhead), but it can lead to unpredicatable results. If you want a method to be isolated from transactions, that is, to have no effect on the transaction of its caller, then use 'NotSupported' instead.
+ * </p>
+ * <p>
+ * <h4>NotSupported</h4>
+ * With the 'NotSupported' attribute, the EJB method will never take part in a transaction. If the caller is part of a transaction, then the caller's transaction is suspended. If the EJB method fails, there will be no effect on the caller's transaction, and no rollback will occur. Use this method if you want to ensure that the EJB method will not cause a rollback in its caller. This is appropriate if, for example, the method does something non-essential, such as logging a message. It would not be helpful if the failure of this operation caused a transaction rollback.
+ * </p>
+ * <p>
+ * <h4>Never</h4>
+ * The 'NotSupported'' attribute will ensure that the EJB method is never called by a transactional caller. Any attempt to do so will result in a <code>RemoteException</code> being thrown. This attribute is probably less useful than `NotSupported', in that NotSupported will assure that the caller's transaction is never affected by the EJB method (just as `Never' does), but will allow a call from a transactional caller if necessary.
+ * </p>
+ *
+ * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
+ */
+trait TransactionProtocol extends Logging {
+
+  /**
+   * Join JTA transaction. Can be overriden by concrete transaction service implementation
+   * to hook into other transaction services.
+   * <p/>
+   * Here is an example on how to integrate with JPA EntityManager.
+   * 
+   * <pre>
+   * override def joinTransaction = {
+   *   val em = TransactionContext.getEntityManager
+   *   val tm = TransactionContext.getTransactionManager
+   *   val closeAtTxCompletion: Boolean) 
+   *   tm.getTransaction.registerSynchronization(new javax.transaction.Synchronization() {
+   *     def beforeCompletion = {
+   *       try {
+   *         val status = tm.getStatus
+   *         if (status != Status.STATUS_ROLLEDBACK &&
+   *             status != Status.STATUS_ROLLING_BACK &&
+   *             status != Status.STATUS_MARKED_ROLLBACK) {
+   *           log.debug("Flushing EntityManager...") 
+   *           em.flush // flush EntityManager on success
+   *         }
+   *       } catch {
+   *         case e: javax.transaction.SystemException => throw new RuntimeException(e)
+   *       }
+   *     }
+   *
+   *     def afterCompletion(status: Int) = {
+   *       val status = tm.getStatus
+   *       if (closeAtTxCompletion) em.close
+   *       if (status == Status.STATUS_ROLLEDBACK ||
+   *           status == Status.STATUS_ROLLING_BACK ||
+   *           status == Status.STATUS_MARKED_ROLLBACK) {
+   *         em.close
+   *       }
+   *     }
+   *   })
+   *   em.joinTransaction // join JTA transaction
+   * }
+   */
+  def joinTransaction: Unit = {}
+
+  /**
+   * Handle exception. Can be overriden by concrete transaction service implementation.
+   * <p/>
+   * Here is an example on how to handle JPA exceptions.
+   * 
+   * <pre>
+   * def handleException(tm: TransactionManager, e: Exception) = {
+   *   if (isInExistingTransaction(tm)) {
+   *     // Do not roll back in case of NoResultException or NonUniqueResultException
+   *     if (!e.isInstanceOf[NoResultException] &&
+   *         !e.isInstanceOf[NonUniqueResultException]) {
+   *       log.debug("Setting TX to ROLLBACK_ONLY, due to: " + e)
+   *       tm.setRollbackOnly
+   *     }
+   *   }
+   *   throw e
+   * }
+   * </pre>
+   */
+  def handleException(tm: TransactionManager, e: Exception) = {
+    tm.setRollbackOnly
+    throw e
+  }
+
+  /**
+   * Wraps body in a transaction with REQUIRED semantics.
+   * <p/>
+   * Creates a new transaction if no transaction is active in scope, else joins the outer transaction. 
+   */
+  def withTxRequired[T](body: => T): T = {
+    val tm = TransactionContext.getTransactionManager
+    if (!isInExistingTransaction(tm)) {
+      tm.begin
+      try {
+        joinTransaction
+        body
+      } catch {
+        case e: Exception => handleException(tm, e)
+      } finally {
+        commitOrRollBack(tm)
+      }
+    } else body
+  }
+
+  /**
+   * Wraps body in a transaction with REQUIRES_NEW semantics.
+   * <p/>
+   * Suspends existing transaction, starts a new transaction, invokes body,
+   * commits or rollbacks new transaction, finally resumes previous transaction.
+   */
+  def withTxRequiresNew[T](body: => T): T = TransactionContext.withNewContext {
+    val tm = TransactionContext.getTransactionManager
+    tm.begin
+    try {
+      joinTransaction
+      body
+    } catch {
+      case e: Exception => handleException(tm, e)
+    } finally {
+      commitOrRollBack(tm)
+    }
+  }
+
+  /**
+   * Wraps body in a transaction with NOT_SUPPORTED semantics.
+   * <p/>
+   * Suspends existing transaction, invokes body, resumes transaction.
+   */
+  def withTxNotSupported[T](body: => T): T = TransactionContext.withNewContext {
+    body
+  }
+
+  /**
+   * Wraps body in a transaction with SUPPORTS semantics.
+   * <p/>
+   * Basicalla a No-op.
+   */
+  def withTxSupports[T](body: => T): T = {
+    // attach to current if exists else skip -> do nothing
+    body
+  }
+
+  /**
+   * Wraps body in a transaction with MANDATORY semantics.
+   * <p/>
+   * Throws a TransactionRequiredException if there is no transaction active in scope.
+   */
+  def withTxMandatory[T](body: => T): T = {
+    if (!isInExistingTransaction(TransactionContext.getTransactionManager)) 
+      throw new TransactionRequiredException("No active TX at method with TX type set to MANDATORY")
+    body
+  }
+
+  /**
+   * Wraps body in a transaction with NEVER semantics.
+   * <p/>
+   * Throws a SystemException in case of an existing transaction in scope.
+   */
+  def withTxNever[T](body: => T): T = {
+    if (isInExistingTransaction(TransactionContext.getTransactionManager)) 
+      throw new SystemException("Detected active TX at method with TX type set to NEVER")
+    body
+  }
+
+  protected def commitOrRollBack(tm: TransactionManager) = {
+    if (isInExistingTransaction(tm)) {
+      if (isRollbackOnly(tm)) {
+        log.debug("Rolling back TX marked as ROLLBACK_ONLY")
+        tm.rollback
+      } else {
+        log.debug("Committing TX")
+        tm.commit
+      }
+    }
+  }
+
+  // ---------------------------
+  // Helper methods
+  // ---------------------------
+
+  /**
+   * Checks if a transaction is an existing transaction.
+   *
+   * @param tm the transaction manager
+   * @return boolean
+   */
+  protected def isInExistingTransaction(tm: TransactionManager): Boolean = 
+    tm.getStatus != Status.STATUS_NO_TRANSACTION
+
+  /**
+   * Checks if current transaction is set to rollback only.
+   *
+   * @param tm the transaction manager
+   * @return boolean
+   */
+  protected def isRollbackOnly(tm: TransactionManager): Boolean = 
+    tm.getStatus == Status.STATUS_MARKED_ROLLBACK
+
+  /**
+   * A ThreadLocal variable where to store suspended TX and enable pay as you go
+   * before advice - after advice data sharing in a specific case of requiresNew TX
+   */
+  private val suspendedTx = new ThreadLocal[Transaction] {
+    override def initialValue = null
+  }
+
+  private def storeInThreadLocal(tx: Transaction) = suspendedTx.set(tx)
+
+  private def fetchFromThreadLocal: Option[Transaction] = {
+    if (suspendedTx != null && suspendedTx.get() != null) Some(suspendedTx.get.asInstanceOf[Transaction])
+    else None
+  }
+}
diff --git a/project/build/AkkaProject.scala b/project/build/AkkaProject.scala
index b7c02135fc..1104535609 100644
--- a/project/build/AkkaProject.scala
+++ b/project/build/AkkaProject.scala
@@ -80,9 +80,10 @@ class AkkaParent(info: ProjectInfo) extends DefaultProject(info) {
   val codehaus_snapshots = "Codehaus Snapshots" at "http://snapshots.repository.codehaus.org"
   val jboss = "jBoss" at "http://repository.jboss.org/maven2"
   val guiceyfruit = "GuiceyFruit" at "http://guiceyfruit.googlecode.com/svn/repo/releases/"
-  val google = "google" at "http://google-maven-repository.googlecode.com/svn/repository"
-  val m2 = "m2" at "http://download.java.net/maven/2"
+  val google = "Google" at "http://google-maven-repository.googlecode.com/svn/repository"
+  val java_net = "java.net" at "http://download.java.net/maven/2"
   val scala_tools_snapshots = "scala-tools snapshots" at "http://scala-tools.org/repo-snapshots"
+  val scala_tools_releases = "scala-tools releases" at "http://scala-tools.org/repo-releases"
 
   // ------------------------------------------------------------
   // project defintions
@@ -98,6 +99,7 @@ class AkkaParent(info: ProjectInfo) extends DefaultProject(info) {
   lazy val akka_persistence = project("akka-persistence", "akka-persistence", new AkkaPersistenceParentProject(_))
   lazy val akka_cluster = project("akka-cluster", "akka-cluster", new AkkaClusterParentProject(_))
   lazy val akka_spring = project("akka-spring", "akka-spring", new AkkaSpringProject(_), akka_core)
+  lazy val akka_jta = project("akka-jta", "akka-jta", new AkkaJTAProject(_), akka_core)
   lazy val akka_servlet = project("akka-servlet", "akka-servlet", new AkkaServletProject(_),
     akka_core, akka_rest, akka_camel)
   lazy val akka_kernel = project("akka-kernel", "akka-kernel", new AkkaKernelProject(_),
@@ -146,7 +148,8 @@ class AkkaParent(info: ProjectInfo) extends DefaultProject(info) {
     " dist/akka-persistence-cassandra_%s-%s.jar".format(buildScalaVersion, version) +
     " dist/akka-servlet_%s-%s.jar".format(buildScalaVersion, version) +
     " dist/akka-kernel_%s-%s.jar".format(buildScalaVersion, version) +
-    " dist/akka-spring_%s-%s.jar".format(buildScalaVersion, version)
+    " dist/akka-spring_%s-%s.jar".format(buildScalaVersion, version) +
+    " dist/akka-jta_%s-%s.jar".format(buildScalaVersion, version)
     )
 
   // ------------------------------------------------------------
@@ -324,6 +327,14 @@ class AkkaParent(info: ProjectInfo) extends DefaultProject(info) {
     val junit = "junit" % "junit" % "4.5" % "test"
   }
 
+  class AkkaJTAProject(info: ProjectInfo) extends AkkaDefaultProject(info, distPath) {
+    val atomikos_transactions = "com.atomikos" % "transactions" % "3.2.3" % "compile"
+    val atomikos_transactions_jta = "com.atomikos" % "transactions-jta" % "3.2.3" % "compile"
+    val atomikos_transactions_api = "com.atomikos" % "transactions-api" % "3.2.3" % "compile"
+    //val atomikos_transactions_util = "com.atomikos" % "transactions-util" % "3.2.3" % "compile"
+    val jta_spec = "org.apache.geronimo.specs" % "geronimo-jta_1.1_spec" % "1.1.1" % "compile"
+  }
+
   // examples
   class AkkaFunTestProject(info: ProjectInfo) extends DefaultProject(info) {
     val jackson_core_asl = "org.codehaus.jackson" % "jackson-core-asl" % "1.2.1" % "compile"

From 7883b73052fd6ee94f2699163111518f9ff4c66d Mon Sep 17 00:00:00 2001
From: Viktor Klang <viktor.klang@gmail.com>
Date: Sat, 10 Apr 2010 23:59:40 +0200
Subject: [PATCH 02/41] Refactored _isEventBased into the MessageDispatcher

---
 akka-core/src/main/scala/actor/Actor.scala    | 28 ++++++++-----------
 .../ExecutorBasedEventDrivenDispatcher.scala  |  2 ++
 ...sedEventDrivenWorkStealingDispatcher.scala |  2 ++
 .../src/main/scala/dispatch/Reactor.scala     |  1 +
 ...sedSingleThreadEventDrivenDispatcher.scala |  2 ++
 ...BasedThreadPoolEventDrivenDispatcher.scala |  2 ++
 .../dispatch/ThreadBasedDispatcher.scala      |  2 ++
 7 files changed, 22 insertions(+), 17 deletions(-)

diff --git a/akka-core/src/main/scala/actor/Actor.scala b/akka-core/src/main/scala/actor/Actor.scala
index 4bc3a9dc31..b80ce3afb1 100644
--- a/akka-core/src/main/scala/actor/Actor.scala
+++ b/akka-core/src/main/scala/actor/Actor.scala
@@ -232,7 +232,6 @@ trait Actor extends TransactionManagement with Logging {
   @volatile private[this] var _isRunning = false
   @volatile private[this] var _isSuspended = true
   @volatile private[this] var _isShutDown = false
-  @volatile private[this] var _isEventBased: Boolean = false
   @volatile private[akka] var _isKilled = false
   private var _hotswap: Option[PartialFunction[Any, Unit]] = None
   private[akka] var _remoteAddress: Option[InetSocketAddress] = None
@@ -294,11 +293,7 @@ trait Actor extends TransactionManagement with Logging {
    * The default is also that all actors that are created and spawned from within this actor
    * is sharing the same dispatcher as its creator.
    */
-  protected[akka] var messageDispatcher: MessageDispatcher = {
-    val dispatcher = Dispatchers.globalExecutorBasedEventDrivenDispatcher
-    _isEventBased = dispatcher.isInstanceOf[ExecutorBasedEventDrivenDispatcher]
-    dispatcher
-  }
+  protected[akka] var messageDispatcher: MessageDispatcher = Dispatchers.globalExecutorBasedEventDrivenDispatcher
 
   /**
    * User overridable callback/setting.
@@ -513,8 +508,11 @@ trait Actor extends TransactionManagement with Logging {
           if (isActiveObject) throw e
           else None
       }
-      getResultOrThrowException(future)
-    } else throw new IllegalStateException(
+      
+      if (future.exception.isDefined) throw future.exception.get._2
+      else future.result.asInstanceOf[Option[T]]
+    }
+    else throw new IllegalStateException(
       "Actor has not been started, you need to invoke 'actor.start' before using it")
   }
 
@@ -593,7 +591,6 @@ trait Actor extends TransactionManagement with Logging {
       messageDispatcher.unregister(this)
       messageDispatcher = md
       messageDispatcher.register(this)
-      _isEventBased = messageDispatcher.isInstanceOf[ExecutorBasedEventDrivenDispatcher]
     } else throw new IllegalArgumentException(
       "Can not swap dispatcher for " + toString + " after it has been started")
   }
@@ -816,7 +813,7 @@ trait Actor extends TransactionManagement with Logging {
       RemoteClient.clientFor(_remoteAddress.get).send(requestBuilder.build, None)
     } else {
       val invocation = new MessageInvocation(this, message, sender.map(Left(_)), transactionSet.get)
-      if (_isEventBased) {
+      if (messageDispatcher.usesActorMailbox) {
         _mailbox.add(invocation)
         if (_isSuspended) invocation.send
       }
@@ -849,10 +846,11 @@ trait Actor extends TransactionManagement with Logging {
       val future = if (senderFuture.isDefined) senderFuture.get
                    else new DefaultCompletableFuture(timeout)
       val invocation = new MessageInvocation(this, message, Some(Right(future)), transactionSet.get)
-      if (_isEventBased) {
+      
+      if (messageDispatcher.usesActorMailbox)
         _mailbox.add(invocation)
-        invocation.send
-      } else invocation.send
+
+      invocation.send
       future
     }
   }
@@ -958,10 +956,6 @@ trait Actor extends TransactionManagement with Logging {
     }
   }
 
-  private def getResultOrThrowException[T](future: Future): Option[T] =
-    if (future.exception.isDefined) throw future.exception.get._2
-    else future.result.asInstanceOf[Option[T]]
-
   private def base: PartialFunction[Any, Unit] = lifeCycles orElse (_hotswap getOrElse receive)
 
   private val lifeCycles: PartialFunction[Any, Unit] = {
diff --git a/akka-core/src/main/scala/dispatch/ExecutorBasedEventDrivenDispatcher.scala b/akka-core/src/main/scala/dispatch/ExecutorBasedEventDrivenDispatcher.scala
index 705c3ee142..0c624c2e3a 100644
--- a/akka-core/src/main/scala/dispatch/ExecutorBasedEventDrivenDispatcher.scala
+++ b/akka-core/src/main/scala/dispatch/ExecutorBasedEventDrivenDispatcher.scala
@@ -94,6 +94,8 @@ class ExecutorBasedEventDrivenDispatcher(_name: String) extends MessageDispatche
     active = false
     references.clear
   }
+  
+  def usesActorMailbox = true
 
   def ensureNotActive: Unit = if (active) throw new IllegalStateException(
     "Can't build a new thread pool for a dispatcher that is already up and running")
diff --git a/akka-core/src/main/scala/dispatch/ExecutorBasedEventDrivenWorkStealingDispatcher.scala b/akka-core/src/main/scala/dispatch/ExecutorBasedEventDrivenWorkStealingDispatcher.scala
index a96f5c5e76..28fe624b86 100644
--- a/akka-core/src/main/scala/dispatch/ExecutorBasedEventDrivenWorkStealingDispatcher.scala
+++ b/akka-core/src/main/scala/dispatch/ExecutorBasedEventDrivenWorkStealingDispatcher.scala
@@ -199,6 +199,8 @@ class ExecutorBasedEventDrivenWorkStealingDispatcher(_name: String) extends Mess
     pooledActors.remove(actor)
     super.unregister(actor)
   }
+  
+  def usesActorMailbox = true
 
   private def verifyActorsAreOfSameType(newActor: Actor) = {
     actorType match {
diff --git a/akka-core/src/main/scala/dispatch/Reactor.scala b/akka-core/src/main/scala/dispatch/Reactor.scala
index f9db74190f..3f300b1c52 100644
--- a/akka-core/src/main/scala/dispatch/Reactor.scala
+++ b/akka-core/src/main/scala/dispatch/Reactor.scala
@@ -68,6 +68,7 @@ trait MessageDispatcher extends Logging {
   }
   def canBeShutDown: Boolean = references.isEmpty
   def isShutdown: Boolean
+  def usesActorMailbox : Boolean
 }
 
 trait MessageDemultiplexer {
diff --git a/akka-core/src/main/scala/dispatch/ReactorBasedSingleThreadEventDrivenDispatcher.scala b/akka-core/src/main/scala/dispatch/ReactorBasedSingleThreadEventDrivenDispatcher.scala
index 15af513d62..fc99cf88d2 100644
--- a/akka-core/src/main/scala/dispatch/ReactorBasedSingleThreadEventDrivenDispatcher.scala
+++ b/akka-core/src/main/scala/dispatch/ReactorBasedSingleThreadEventDrivenDispatcher.scala
@@ -37,6 +37,8 @@ class ReactorBasedSingleThreadEventDrivenDispatcher(name: String) extends Abstra
   }
 
   def isShutdown = !active
+  
+  def usesActorMailbox = false
 
   class Demultiplexer(private val messageQueue: ReactiveMessageQueue) extends MessageDemultiplexer {
 
diff --git a/akka-core/src/main/scala/dispatch/ReactorBasedThreadPoolEventDrivenDispatcher.scala b/akka-core/src/main/scala/dispatch/ReactorBasedThreadPoolEventDrivenDispatcher.scala
index 941e701410..3f33d4ffc0 100644
--- a/akka-core/src/main/scala/dispatch/ReactorBasedThreadPoolEventDrivenDispatcher.scala
+++ b/akka-core/src/main/scala/dispatch/ReactorBasedThreadPoolEventDrivenDispatcher.scala
@@ -134,6 +134,8 @@ class ReactorBasedThreadPoolEventDrivenDispatcher(_name: String)
     if (fair) true
     else nrOfBusyMessages < 100
   }
+  
+  def usesActorMailbox = false
 
   def ensureNotActive: Unit = if (active) throw new IllegalStateException(
     "Can't build a new thread pool for a dispatcher that is already up and running")
diff --git a/akka-core/src/main/scala/dispatch/ThreadBasedDispatcher.scala b/akka-core/src/main/scala/dispatch/ThreadBasedDispatcher.scala
index 8b1463f655..fbfffc999e 100644
--- a/akka-core/src/main/scala/dispatch/ThreadBasedDispatcher.scala
+++ b/akka-core/src/main/scala/dispatch/ThreadBasedDispatcher.scala
@@ -41,6 +41,8 @@ class ThreadBasedDispatcher private[akka] (val name: String, val messageHandler:
                        
   def isShutdown = !active
 
+  def usesActorMailbox = false
+
   def shutdown = if (active) {
     log.debug("Shutting down ThreadBasedDispatcher [%s]", name)
     active = false

From e34819007edbc1b93a92d2db16b1cc2ccf10975f Mon Sep 17 00:00:00 2001
From: Viktor Klang <viktor.klang@gmail.com>
Date: Sun, 11 Apr 2010 00:00:06 +0200
Subject: [PATCH 03/41] Moved a runtime error to compile time

---
 akka-core/src/main/scala/actor/Actor.scala | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/akka-core/src/main/scala/actor/Actor.scala b/akka-core/src/main/scala/actor/Actor.scala
index b80ce3afb1..627913407b 100644
--- a/akka-core/src/main/scala/actor/Actor.scala
+++ b/akka-core/src/main/scala/actor/Actor.scala
@@ -221,7 +221,7 @@ object Actor extends Logging {
  * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
  */
 trait Actor extends TransactionManagement with Logging {
-  implicit protected val self: Option[Actor] = Some(this)
+  implicit protected val self: Some[Actor] = Some(this)
   // Only mutable for RemoteServer in order to maintain identity across nodes
   private[akka] var _uuid = UUID.newUuid.toString
 
@@ -548,11 +548,10 @@ trait Actor extends TransactionManagement with Logging {
    * <p/>
    * Works with both '!' and '!!'.
    */
-  def forward(message: Any)(implicit sender: Option[Actor] = None) = {
+  def forward(message: Any)(implicit sender: Some[Actor]) = {
     if (_isKilled) throw new ActorKilledException("Actor [" + toString + "] has been killed, can't respond to messages")
     if (_isRunning) {
-      val forwarder = sender.getOrElse(throw new IllegalStateException("Can't forward message when the forwarder/mediator is not an actor"))
-      forwarder.replyTo match {
+      sender.get.replyTo match {
         case Some(Left(actor))   => postMessageToMailbox(message, Some(actor))
         case Some(Right(future)) => postMessageToMailboxAndCreateFutureResultWithTimeout(message, timeout, Some(future))
         case _                   => throw new IllegalStateException("Can't forward message when initial sender is not an actor")

From 90b28210f931b91dbf85b57da458a86dbd295d9d Mon Sep 17 00:00:00 2001
From: Viktor Klang <viktor.klang@gmail.com>
Date: Sun, 11 Apr 2010 00:00:18 +0200
Subject: [PATCH 04/41] Documented replyTo

---
 akka-core/src/main/scala/actor/Actor.scala | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/akka-core/src/main/scala/actor/Actor.scala b/akka-core/src/main/scala/actor/Actor.scala
index 627913407b..0b5aecf3f0 100644
--- a/akka-core/src/main/scala/actor/Actor.scala
+++ b/akka-core/src/main/scala/actor/Actor.scala
@@ -251,7 +251,10 @@ trait Actor extends TransactionManagement with Logging {
   // ====================================
 
   /**
-   * TODO: Document replyTo
+   * Holds the reference to the sender of the currently processed message.
+   * Is None if no sender was specified
+   * Is Some(Left(Actor)) if sender is an actor
+   * Is Some(Right(CompletableFuture)) if sender is holding on to a Future for the result
    */
   protected var replyTo: Option[Either[Actor,CompletableFuture]] = None
 

From 4728c3c1f07c26cd00f8366ffc0763cd28c9672b Mon Sep 17 00:00:00 2001
From: Michael Kober <michael.kober@jayway.com>
Date: Wed, 14 Apr 2010 09:56:01 +0200
Subject: [PATCH 05/41] implemented link/unlink for active objects

---
 .../src/main/scala/actor/ActiveObject.scala   | 84 +++++++++++++++----
 akka-core/src/main/scala/actor/Actor.scala    | 18 ++--
 .../akka/spring/foo/Bar.java                  |  6 ++
 3 files changed, 85 insertions(+), 23 deletions(-)

diff --git a/akka-core/src/main/scala/actor/ActiveObject.scala b/akka-core/src/main/scala/actor/ActiveObject.scala
index e3bd9ef943..cb67ae0244 100644
--- a/akka-core/src/main/scala/actor/ActiveObject.scala
+++ b/akka-core/src/main/scala/actor/ActiveObject.scala
@@ -4,6 +4,7 @@
 
 package se.scalablesolutions.akka.actor
 
+import _root_.se.scalablesolutions.akka.config.FaultHandlingStrategy
 import se.scalablesolutions.akka.remote.protobuf.RemoteProtocol.RemoteRequest
 import se.scalablesolutions.akka.remote.{RemoteProtocolBuilder, RemoteClient, RemoteRequestIdFactory}
 import se.scalablesolutions.akka.dispatch.{MessageDispatcher, Future}
@@ -199,18 +200,71 @@ object ActiveObject {
     proxy.asInstanceOf[T]
   }
 
-// Jan Kronquist: started work on issue 121
-//  def actorFor(obj: AnyRef): Option[Actor] = {
-//    ActorRegistry.actorsFor(classOf[Dispatcher]).find(a=>a.target == Some(obj))
-//  }
-//
-//  def link(supervisor: AnyRef, activeObject: AnyRef) = {
-//    actorFor(supervisor).get !! Link(actorFor(activeObject).get)
-//  }
-//
-//  def unlink(supervisor: AnyRef, activeObject: AnyRef) = {
-//    actorFor(supervisor).get !! Unlink(actorFor(activeObject).get)
-//  }
+  /**
+   * Get the underlying dispatcher actor for the given active object.
+   */
+  def actorFor(obj: AnyRef): Option[Actor] = {
+    ActorRegistry.actorsFor(classOf[Dispatcher]).find(a=>a.target == Some(obj))
+  }
+
+  /**
+   * Links an other active object to this active object.
+   * @param supervisor the supervisor active object
+   * @param supervised the active object to link
+   */
+  def link(supervisor: AnyRef, supervised: AnyRef) = {
+    val supervisorActor = actorFor(supervisor).getOrElse(throw new IllegalStateException("Can't link when the supervisor is not an active object"))
+    val supervisedActor = actorFor(supervised).getOrElse(throw new IllegalStateException("Can't link when the supervised is not an active object"))
+    supervisorActor !! Link(supervisedActor)
+  }
+
+  /**
+   * Links an other active object to this active object and sets the fault handling for the supervisor.
+   * @param supervisor the supervisor active object
+   * @param supervised the active object to link
+   * @param handler fault handling strategy
+   * @param trapExceptions array of exceptions that should be handled by the supervisor
+   */
+  def link(supervisor: AnyRef, supervised: AnyRef, handler: FaultHandlingStrategy, trapExceptions: Array[Class[_ <: Throwable]]) = {
+    val supervisorActor = actorFor(supervisor).getOrElse(throw new IllegalStateException("Can't link when the supervisor is not an active object"))
+    val supervisedActor = actorFor(supervised).getOrElse(throw new IllegalStateException("Can't link when the supervised is not an active object"))
+    supervisorActor.trapExit = trapExceptions.toList
+    supervisorActor.faultHandler = Some(handler)
+    supervisorActor !! Link(supervisedActor)
+  }
+
+  /**
+   * Unlink the supervised active object from the supervisor.
+   * @param supervisor the supervisor active object
+   * @param supervised the active object to unlink
+   */
+  def unlink(supervisor: AnyRef, supervised: AnyRef) = {
+    val supervisorActor = actorFor(supervisor).getOrElse(throw new IllegalStateException("Can't unlink when the supervisor is not an active object"))
+    val supervisedActor = actorFor(supervised).getOrElse(throw new IllegalStateException("Can't unlink when the supervised is not an active object"))
+    supervisorActor !! Unlink(supervisedActor)
+  }
+
+  /**
+   * Sets the trap exit for the given supervisor active object.
+   * @param supervisor the supervisor active object
+   * @param trapExceptions array of exceptions that should be handled by the supervisor
+   */
+  def trapExit(supervisor: AnyRef, trapExceptions: Array[Class[_ <: Throwable]]) = {
+    val supervisorActor = actorFor(supervisor).getOrElse(throw new IllegalStateException("Can't set trap exceptions when the supervisor is not an active object"))
+    supervisorActor.trapExit = trapExceptions.toList
+    this
+  }
+
+  /**
+   * Sets the fault handling strategy for the given supervisor active object.
+   * @param supervisor the supervisor active object
+   * @param handler fault handling strategy
+   */
+  def faultHandler(supervisor: AnyRef, handler: FaultHandlingStrategy) = {
+    val supervisorActor = actorFor(supervisor).getOrElse(throw new IllegalStateException("Can't set fault handler when the supervisor is not an active object"))
+    supervisorActor.faultHandler = Some(handler)
+    this
+  }
 
   private[akka] def supervise(restartStrategy: RestartStrategy, components: List[Supervise]): Supervisor = {
     val factory = SupervisorFactory(SupervisorConfig(restartStrategy, components))
@@ -366,7 +420,7 @@ private[akka] sealed class ActiveObjectAspect {
 }
 
 // Jan Kronquist: started work on issue 121
-// private[akka] case class Link(val actor: Actor)
+private[akka] case class Link(val actor: Actor)
 
 object Dispatcher {
   val ZERO_ITEM_CLASS_ARRAY = Array[Class[_]]()
@@ -434,8 +488,8 @@ private[akka] class Dispatcher(transactionalRequired: Boolean, val callbacks: Op
       if (isOneWay) joinPoint.proceed
       else reply(joinPoint.proceed)
 // Jan Kronquist: started work on issue 121
-//    case Link(target) =>
-//      link(target)
+    case Link(target) => link(target)
+    case Unlink(target) => unlink(target)
     case unexpected =>
       throw new IllegalStateException("Unexpected message [" + unexpected + "] sent to [" + this + "]")
   }
diff --git a/akka-core/src/main/scala/actor/Actor.scala b/akka-core/src/main/scala/actor/Actor.scala
index 4bc3a9dc31..8c38769579 100644
--- a/akka-core/src/main/scala/actor/Actor.scala
+++ b/akka-core/src/main/scala/actor/Actor.scala
@@ -52,6 +52,7 @@ case class HotSwap(code: Option[PartialFunction[Any, Unit]]) extends LifeCycleMe
 case class Restart(reason: Throwable) extends LifeCycleMessage
 case class Exit(dead: Actor, killer: Throwable) extends LifeCycleMessage
 case class Unlink(child: Actor) extends LifeCycleMessage
+case class UnlinkAndStop(child: Actor) extends LifeCycleMessage
 case object Kill extends LifeCycleMessage
 
 class ActorKilledException private[akka](message: String) extends RuntimeException(message)
@@ -318,7 +319,7 @@ trait Actor extends TransactionManagement with Logging {
    * trapExit = List(classOf[MyApplicationException], classOf[MyApplicationError])
    * </pre>
    */
-  protected var trapExit: List[Class[_ <: Throwable]] = Nil
+  protected[akka] var trapExit: List[Class[_ <: Throwable]] = Nil
 
   /**
    * User overridable callback/setting.
@@ -331,7 +332,7 @@ trait Actor extends TransactionManagement with Logging {
    *  faultHandler = Some(OneForOneStrategy(maxNrOfRetries, withinTimeRange))
    * </pre>
    */
-  protected var faultHandler: Option[FaultHandlingStrategy] = None
+  protected[akka] var faultHandler: Option[FaultHandlingStrategy] = None
 
   /**
    * User overridable callback/setting.
@@ -965,11 +966,12 @@ trait Actor extends TransactionManagement with Logging {
   private def base: PartialFunction[Any, Unit] = lifeCycles orElse (_hotswap getOrElse receive)
 
   private val lifeCycles: PartialFunction[Any, Unit] = {
-    case HotSwap(code) =>      _hotswap = code
-    case Restart(reason) =>    restart(reason)
-    case Exit(dead, reason) => handleTrapExit(dead, reason)
-    case Unlink(child) =>      unlink(child); child.stop
-    case Kill =>               throw new ActorKilledException("Actor [" + toString + "] was killed by a Kill message")
+    case HotSwap(code) =>        _hotswap = code
+    case Restart(reason) =>      restart(reason)
+    case Exit(dead, reason) =>   handleTrapExit(dead, reason)
+    case Unlink(child) =>        unlink(child)
+    case UnlinkAndStop(child) => unlink(child); child.stop
+    case Kill =>                 throw new ActorKilledException("Actor [" + toString + "] was killed by a Kill message")
   }
 
   private[this] def handleTrapExit(dead: Actor, reason: Throwable): Unit = {
@@ -1002,7 +1004,7 @@ trait Actor extends TransactionManagement with Logging {
                 // if last temporary actor is gone, then unlink me from supervisor
                 if (getLinkedActors.isEmpty) {
                   Actor.log.info("All linked actors have died permanently (they were all configured as TEMPORARY)\n\tshutting down and unlinking supervisor actor as well [%s].", actor.id)
-                  _supervisor.foreach(_ ! Unlink(this))
+                  _supervisor.foreach(_ ! UnlinkAndStop(this))
                 }
             }
           }
diff --git a/akka-spring/akka-spring-test-java/src/main/java/se/scalablesolutions/akka/spring/foo/Bar.java b/akka-spring/akka-spring-test-java/src/main/java/se/scalablesolutions/akka/spring/foo/Bar.java
index 7e21aaea8f..24e02a3fd6 100644
--- a/akka-spring/akka-spring-test-java/src/main/java/se/scalablesolutions/akka/spring/foo/Bar.java
+++ b/akka-spring/akka-spring-test-java/src/main/java/se/scalablesolutions/akka/spring/foo/Bar.java
@@ -1,10 +1,16 @@
 package se.scalablesolutions.akka.spring.foo;
 
+import java.io.IOException;
+
 public class Bar implements IBar {
 
         @Override
         public String getBar() {
                 return "bar";
         }
+        
+        public void throwsIOException() throws IOException {
+      	  throw new IOException("some IO went wrong");
+        }
 
 }

From 4117d943af18c4d62517bfc5fbcf9e56ba52fa12 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonas=20Bon=C3=A9r?= <jonasremove@jonasboner.com>
Date: Wed, 14 Apr 2010 15:37:29 +0200
Subject: [PATCH 06/41] fixed bug with ignoring timeout in Java API

---
 .../src/main/scala/actor/ActiveObject.scala   | 22 +++++++++----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/akka-core/src/main/scala/actor/ActiveObject.scala b/akka-core/src/main/scala/actor/ActiveObject.scala
index e3bd9ef943..17cd482582 100644
--- a/akka-core/src/main/scala/actor/ActiveObject.scala
+++ b/akka-core/src/main/scala/actor/ActiveObject.scala
@@ -35,7 +35,7 @@ object Annotations {
  */
 object ActiveObject {
   val AKKA_CAMEL_ROUTING_SCHEME = "akka"
-  private[actor] val AW_PROXY_PREFIX = "$$ProxiedByAW".intern  
+  private[actor] val AW_PROXY_PREFIX = "$$ProxiedByAW".intern
 
   def newInstance[T](target: Class[T], timeout: Long): T =
     newInstance(target, new Dispatcher(false, None), None, timeout)
@@ -227,19 +227,19 @@ private[akka] object AspectInitRegistry {
     val init = initializations.get(target)
     initializations.remove(target)
     init
-  }  
+  }
 
   def register(target: AnyRef, init: AspectInit) = initializations.put(target, init)
 }
 
 private[akka] sealed case class AspectInit(
   val target: Class[_],
-  val actor: Dispatcher,          
+  val actor: Dispatcher,
   val remoteAddress: Option[InetSocketAddress],
   val timeout: Long) {
   def this(target: Class[_],actor: Dispatcher, timeout: Long) = this(target, actor, None, timeout)
 }
-      
+
 /**
  * AspectWerkz Aspect that is turning POJOs into Active Object.
  * Is deployed on a 'per-instance' basis.
@@ -260,7 +260,7 @@ private[akka] sealed class ActiveObjectAspect {
     if (!isInitialized) {
       val init = AspectInitRegistry.initFor(joinPoint.getThis)
       target = init.target
-      actor = init.actor            
+      actor = init.actor
       remoteAddress = init.remoteAddress
       timeout = init.timeout
       isInitialized = true
@@ -279,7 +279,7 @@ private[akka] sealed class ActiveObjectAspect {
       (actor ! Invocation(joinPoint, true, true) ).asInstanceOf[AnyRef]
     }
     else {
-      val result = actor !! Invocation(joinPoint, false, isVoid(rtti))
+      val result = actor !! (Invocation(joinPoint, false, isVoid(rtti)), timeout)
       if (result.isDefined) result.get
       else throw new IllegalStateException("No result defined for invocation [" + joinPoint + "]")
     }
@@ -319,7 +319,7 @@ private[akka] sealed class ActiveObjectAspect {
       val (_, cause) = future.exception.get
       throw cause
     } else future.result.asInstanceOf[Option[T]]
-  
+
   private def isOneWay(rtti: MethodRtti) = rtti.getMethod.isAnnotationPresent(Annotations.oneway)
 
   private def isVoid(rtti: MethodRtti) = rtti.getMethod.getReturnType == java.lang.Void.TYPE
@@ -370,7 +370,7 @@ private[akka] sealed class ActiveObjectAspect {
 
 object Dispatcher {
   val ZERO_ITEM_CLASS_ARRAY = Array[Class[_]]()
-  val ZERO_ITEM_OBJECT_ARRAY = Array[Object]()  
+  val ZERO_ITEM_OBJECT_ARRAY = Array[Object]()
 }
 
 /**
@@ -408,7 +408,7 @@ private[akka] class Dispatcher(transactionalRequired: Boolean, val callbacks: Op
           "Could not find post restart method [" + post + "] \nin [" + targetClass.getName + "]. \nIt must have a zero argument definition.") })
     }
 
-    // See if we have any annotation defined restart callbacks 
+    // See if we have any annotation defined restart callbacks
     if (!preRestart.isDefined) preRestart = methods.find(m => m.isAnnotationPresent(Annotations.prerestart))
     if (!postRestart.isDefined) postRestart = methods.find(m => m.isAnnotationPresent(Annotations.postrestart))
 
@@ -421,7 +421,7 @@ private[akka] class Dispatcher(transactionalRequired: Boolean, val callbacks: Op
 
     if (preRestart.isDefined) preRestart.get.setAccessible(true)
     if (postRestart.isDefined) postRestart.get.setAccessible(true)
-    
+
     // see if we have a method annotated with @inittransactionalstate, if so invoke it
     initTxState = methods.find(m => m.isAnnotationPresent(Annotations.inittransactionalstate))
     if (initTxState.isDefined && initTxState.get.getParameterTypes.length != 0) throw new IllegalStateException("Method annotated with @inittransactionalstate must have a zero argument definition")
@@ -486,6 +486,6 @@ private[akka] class Dispatcher(transactionalRequired: Boolean, val callbacks: Op
     if (!unserializable && hasMutableArgument) {
       val copyOfArgs = Serializer.Java.deepClone(args)
       joinPoint.getRtti.asInstanceOf[MethodRtti].setParameterValues(copyOfArgs.asInstanceOf[Array[AnyRef]])
-    }    
+    }
   }
 }

From 2abad7d4be4922bc43e682bf4d1cddcceab7d09f Mon Sep 17 00:00:00 2001
From: Debasish Ghosh <debasish@debasishg.(none)>
Date: Wed, 14 Apr 2010 23:50:26 +0530
Subject: [PATCH 07/41] Redis client now implements pubsub. Also included a
 sample app for RedisPubSub in akka-samples

---
 .../src/main/scala/RedisPubSubServer.scala    |  42 +++++++
 .../src/main/scala/RedisPubSub.scala          | 103 ++++++++++++++++++
 .../redisclient-2.8.0.Beta1-1.3-SNAPSHOT.jar  | Bin 118217 -> 161101 bytes
 project/build/AkkaProject.scala               |   3 +
 4 files changed, 148 insertions(+)
 create mode 100644 akka-persistence/akka-persistence-redis/src/main/scala/RedisPubSubServer.scala
 create mode 100644 akka-samples/akka-sample-pubsub/src/main/scala/RedisPubSub.scala

diff --git a/akka-persistence/akka-persistence-redis/src/main/scala/RedisPubSubServer.scala b/akka-persistence/akka-persistence-redis/src/main/scala/RedisPubSubServer.scala
new file mode 100644
index 0000000000..c5621361fb
--- /dev/null
+++ b/akka-persistence/akka-persistence-redis/src/main/scala/RedisPubSubServer.scala
@@ -0,0 +1,42 @@
+package se.scalablesolutions.akka.persistence.redis
+
+import se.scalablesolutions.akka.actor.Actor
+import com.redis._
+
+sealed trait Msg
+case class Subscribe(channels: Array[String]) extends Msg
+case class Register(callback: PubSubMessage => Any) extends Msg
+case class Unsubscribe(channels: Array[String]) extends Msg
+case object UnsubscribeAll extends Msg
+case class Publish(channel: String, msg: String) extends Msg
+
+class Subscriber(client: RedisClient) extends Actor {
+  var callback: PubSubMessage => Any = { m => }
+
+  def receive = {
+    case Subscribe(channels) =>
+      client.subscribe(channels.head, channels.tail: _*)(callback)
+      reply(true)
+
+    case Register(cb) =>
+      callback = cb
+      reply(true)
+
+    case Unsubscribe(channels) =>
+      client.unsubscribe(channels.head, channels.tail: _*)
+      reply(true)
+
+    case UnsubscribeAll =>
+      client.unsubscribe
+      reply(true)
+  }
+}
+
+class Publisher(client: RedisClient) extends Actor {
+  def receive = {
+    case Publish(channel, message) =>
+      client.publish(channel, message)
+      reply(true)
+  }
+}
+
diff --git a/akka-samples/akka-sample-pubsub/src/main/scala/RedisPubSub.scala b/akka-samples/akka-sample-pubsub/src/main/scala/RedisPubSub.scala
new file mode 100644
index 0000000000..ee14c2880d
--- /dev/null
+++ b/akka-samples/akka-sample-pubsub/src/main/scala/RedisPubSub.scala
@@ -0,0 +1,103 @@
+/**
+ * Copyright (C) 2009-2010 Scalable Solutions AB <http://scalablesolutions.se>.
+ */
+
+package sample.pubsub
+
+import com.redis.{RedisClient, PubSubMessage, S, U, M}
+import se.scalablesolutions.akka.persistence.redis._
+
+/**
+ * Sample Akka application for Redis PubSub
+ * 
+ * Prerequisite: Need Redis Server running (the version that supports pubsub)
+ *
+ * 1. Download redis from http://github.com/antirez/redis
+ * 2. build using "make"
+ * 3. Run server as ./redis-server
+ *
+ * For running this sample application :-
+ *
+ * 1. Open a shell and set AKKA_HOME to the distribution root
+ * 2. cd $AKKA_HOME
+ * 3. sbt console
+ * 4. import sample.pubsub._
+ * 5. Sub.sub("a", "b") // starts Subscription server & subscribes to channels "a" and "b"
+ *
+ * 6. Open up another shell similarly as the above and set AKKA_HOME
+ * 7. cd $AKKA_HOME
+ * 8. sbt console
+ * 9. import sample.pubsub._
+ * 10. Pub.publish("a", "hello") // the first shell should get the message
+ * 11. Pub.publish("c", "hi") // the first shell should NOT get this message
+ *
+ * 12. Open up a redis-client from where you installed redis and issue a publish command
+ *     ./redis-cli publish a "hi there" ## the first shell should get the message
+ *
+ * 13. Go back to the first shell
+ * 14. Sub.unsub("a") // should unsubscribe the first shell from channel "a"
+ *
+ * 15. Study the callback function defined below. It supports many other message formats.
+ *     In the second shell window do the following:
+ *     scala> Pub.publish("b", "+c")  // will subscribe the first window to channel "c"
+ *     scala> Pub.publish("b", "+d")  // will subscribe the first window to channel "d"
+ *     scala> Pub.publish("b", "-c")  // will unsubscribe the first window from channel "c"
+ *     scala> Pub.publish("b", "exit")  // will unsubscribe the first window from all channels
+ */
+
+object Pub {
+  println("starting publishing service ..")
+  val r = new RedisClient("localhost", 6379)
+  val p = new Publisher(r)
+  p.start
+
+  def publish(channel: String, message: String) = {
+    p ! Publish(channel, message)
+  }
+}
+
+object Sub {
+  println("starting subscription service ..")
+  val r = new RedisClient("localhost", 6379)
+  val s = new Subscriber(r)
+  s.start
+  s ! Register(callback) 
+
+  def sub(channels: String*) = {
+    s ! Subscribe(channels.toArray)
+  }
+
+  def unsub(channels: String*) = {
+    s ! Unsubscribe(channels.toArray)
+  }
+
+  def callback(pubsub: PubSubMessage) = pubsub match {
+    case S(channel, no) => println("subscribed to " + channel + " and count = " + no)
+    case U(channel, no) => println("unsubscribed from " + channel + " and count = " + no)
+    case M(channel, msg) => 
+      msg match {
+        // exit will unsubscribe from all channels and stop subscription service
+        case "exit" => 
+          println("unsubscribe all ..")
+          r.unsubscribe
+
+        // message "+x" will subscribe to channel x
+        case x if x startsWith "+" => 
+          val s: Seq[Char] = x
+          s match {
+            case Seq('+', rest @ _*) => r.subscribe(rest.toString){ m => }
+          }
+
+        // message "-x" will unsubscribe from channel x
+        case x if x startsWith "-" => 
+          val s: Seq[Char] = x
+          s match {
+            case Seq('-', rest @ _*) => r.unsubscribe(rest.toString)
+          }
+
+        // other message receive
+        case x => 
+          println("received message on channel " + channel + " as : " + x)
+      }
+  }
+}
diff --git a/embedded-repo/com/redis/redisclient/2.8.0.Beta1-1.3-SNAPSHOT/redisclient-2.8.0.Beta1-1.3-SNAPSHOT.jar b/embedded-repo/com/redis/redisclient/2.8.0.Beta1-1.3-SNAPSHOT/redisclient-2.8.0.Beta1-1.3-SNAPSHOT.jar
index 0daede37f0471d224388f4634d63c854642064ce..52125e6d5270851b9c045c6dc83764bd94cac1d2 100644
GIT binary patch
delta 74689
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
M7#IvanHU%t07*aqY5)KL

delta 32124
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

diff --git a/project/build/AkkaProject.scala b/project/build/AkkaProject.scala
index 41a51b8c8c..b0466d5ec8 100644
--- a/project/build/AkkaProject.scala
+++ b/project/build/AkkaProject.scala
@@ -301,6 +301,7 @@ class AkkaParent(info: ProjectInfo) extends DefaultProject(info) {
   }
 
   class AkkaSampleChatProject(info: ProjectInfo) extends AkkaDefaultProject(info, deployPath)
+  class AkkaSamplePubSubProject(info: ProjectInfo) extends AkkaDefaultProject(info, deployPath)
 
   class AkkaSampleLiftProject(info: ProjectInfo) extends AkkaDefaultProject(info, deployPath) {
     val commons_logging = "commons-logging" % "commons-logging" % "1.1.1" % "compile"
@@ -335,6 +336,8 @@ class AkkaParent(info: ProjectInfo) extends DefaultProject(info) {
   class AkkaSamplesParentProject(info: ProjectInfo) extends ParentProject(info) {
     lazy val akka_sample_chat = project("akka-sample-chat", "akka-sample-chat",
       new AkkaSampleChatProject(_), akka_kernel)
+    lazy val akka_sample_pubsub = project("akka-sample-pubsub", "akka-sample-pubsub",
+      new AkkaSamplePubSubProject(_), akka_kernel)
     lazy val akka_sample_lift = project("akka-sample-lift", "akka-sample-lift",
       new AkkaSampleLiftProject(_), akka_kernel)
     lazy val akka_sample_rest_java = project("akka-sample-rest-java", "akka-sample-rest-java",

From 475649077208f38476ae2740a489f29e0717c9a7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonas=20Bon=C3=A9r?= <jonasremove@jonasboner.com>
Date: Wed, 14 Apr 2010 20:47:19 +0200
Subject: [PATCH 08/41] Added AtomicTemplate to allow atomic blocks from Java
 code

---
 .../src/main/scala/stm/Transaction.scala      | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/akka-core/src/main/scala/stm/Transaction.scala b/akka-core/src/main/scala/stm/Transaction.scala
index 16a3cd0e5f..209c131781 100644
--- a/akka-core/src/main/scala/stm/Transaction.scala
+++ b/akka-core/src/main/scala/stm/Transaction.scala
@@ -22,6 +22,25 @@ import org.multiverse.stms.alpha.AlphaStm
 class NoTransactionInScopeException extends RuntimeException
 class TransactionRetryException(message: String) extends RuntimeException(message)
 
+/**
+ * FIXDOC: document AtomicTemplate
+ * AtomicTemplate can be used to create atomic blocks from Java code.
+ * <pre>
+ * User newUser = new AtomicTemplate[User]() {
+ *   User atomic() {
+ *     ... // create user atomically
+ *     return user;
+ *   }
+ * }.execute();
+ * </pre>
+ */
+trait AtomicTemplate[T] {
+  def atomic: T
+  def execute: T = Transaction.Local.atomic {
+    atomic
+  }
+}
+
 object Transaction {
   val idFactory = new AtomicLong(-1L)
 

From fac08d26d146cb12d4e0d305922013d342abb71b Mon Sep 17 00:00:00 2001
From: rossputin <ross.mcdonald@thatcham.org>
Date: Wed, 14 Apr 2010 20:33:46 +0100
Subject: [PATCH 09/41] update instructions for chat running chat sample

---
 akka-samples/akka-sample-chat/README                        | 6 +++---
 .../akka-sample-chat/src/main/scala/ChatServer.scala        | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/akka-samples/akka-sample-chat/README b/akka-samples/akka-sample-chat/README
index 88720d8c55..66e54e3d44 100644
--- a/akka-samples/akka-sample-chat/README
+++ b/akka-samples/akka-sample-chat/README
@@ -17,10 +17,10 @@ Then to run the sample:
   - Set 'export AKKA_HOME=<root of distribution>.
   - Run 'sbt console' to start up a REPL (interpreter).
 4. In the first REPL you get execute: 
-  - scala> import se.scalablesolutions.akka.sample.chat._
+  - scala> import sample.chat._
   - scala> ChatService.start
-5. In the first REPL you get execute: 
-    - scala> import se.scalablesolutions.akka.sample.chat._
+5. In the second REPL you get execute: 
+    - scala> import sample.chat._
     - scala> Runner.run
 6. See the chat simulation run.
 7. Run it again to see full speed after first initialization.
diff --git a/akka-samples/akka-sample-chat/src/main/scala/ChatServer.scala b/akka-samples/akka-sample-chat/src/main/scala/ChatServer.scala
index 6d4bf9679e..51c4c9f91c 100644
--- a/akka-samples/akka-sample-chat/src/main/scala/ChatServer.scala
+++ b/akka-samples/akka-sample-chat/src/main/scala/ChatServer.scala
@@ -33,10 +33,10 @@ Then to run the sample:
   - Set 'export AKKA_HOME=<root of distribution>.
   - Run 'sbt console' to start up a REPL (interpreter).
 2. In the first REPL you get execute: 
-  - scala> import se.scalablesolutions.akka.sample.chat._
+  - scala> import sample.chat._
   - scala> ChatService.start
-3. In the first REPL you get execute: 
-    - scala> import se.scalablesolutions.akka.sample.chat._
+3. In the second REPL you get execute: 
+    - scala> import sample.chat._
     - scala> Runner.run
 4. See the chat simulation run.
 5. Run it again to see full speed after first initialization.

From 51619a0838a0cd8bed7d7e1b696fed0cb519dc71 Mon Sep 17 00:00:00 2001
From: Viktor Klang <viktor.klang@gmail.com>
Date: Thu, 15 Apr 2010 16:05:16 +0200
Subject: [PATCH 10/41] Removed Scala 2.8 deprecation warnings

---
 .../src/test/scala/MongoStorageSpec.scala                       | 2 +-
 .../src/test/scala/SupervisionBeanDefinitionParserTest.scala    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/akka-persistence/akka-persistence-mongo/src/test/scala/MongoStorageSpec.scala b/akka-persistence/akka-persistence-mongo/src/test/scala/MongoStorageSpec.scala
index 186157b576..97307dde17 100644
--- a/akka-persistence/akka-persistence-mongo/src/test/scala/MongoStorageSpec.scala
+++ b/akka-persistence/akka-persistence-mongo/src/test/scala/MongoStorageSpec.scala
@@ -192,7 +192,7 @@ class MongoStorageSpec extends TestCase {
     assertTrue(l.map(_._1).contains("3"))
     assertTrue(l.map(_._1).contains("4"))
 
-    val JsString(str) = l.filter(_._1 == "2").first._2
+    val JsString(str) = l.filter(_._1 == "2").head._2
     assertEquals(str, "peter")
 
     // trying to fetch for a non-existent transaction will throw
diff --git a/akka-spring/src/test/scala/SupervisionBeanDefinitionParserTest.scala b/akka-spring/src/test/scala/SupervisionBeanDefinitionParserTest.scala
index af79ecf5df..e0344ae4fb 100644
--- a/akka-spring/src/test/scala/SupervisionBeanDefinitionParserTest.scala
+++ b/akka-spring/src/test/scala/SupervisionBeanDefinitionParserTest.scala
@@ -50,7 +50,7 @@ class SupervisionBeanDefinitionParserTest extends Spec with ShouldMatchers {
       val supervised = builder.getBeanDefinition.getPropertyValues.getPropertyValue("supervised").getValue.asInstanceOf[List[ActiveObjectProperties]]
       assert(supervised != null)
       expect(3) { supervised.length }
-      val iterator = supervised.elements
+      val iterator = supervised.iterator
       expect("foo.bar.Foo") { iterator.next.target }
       expect("foo.bar.Bar") { iterator.next.target }
       expect("foo.bar.MyPojo") { iterator.next.target }

From 379b6e2c8517c8cf4eb950670b5b8b073e3eb2c1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonas=20Bon=C3=A9r?= <jonasremove@jonasboner.com>
Date: Fri, 16 Apr 2010 00:02:38 +0200
Subject: [PATCH 11/41] Updated old scaladoc

---
 akka-core/src/main/scala/dispatch/Dispatchers.scala | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/akka-core/src/main/scala/dispatch/Dispatchers.scala b/akka-core/src/main/scala/dispatch/Dispatchers.scala
index 49d9c624b6..2030d2026e 100644
--- a/akka-core/src/main/scala/dispatch/Dispatchers.scala
+++ b/akka-core/src/main/scala/dispatch/Dispatchers.scala
@@ -11,7 +11,7 @@ import se.scalablesolutions.akka.actor.Actor
  * <p/>
  * Example usage:
  * <pre/>
- *   val dispatcher = Dispatchers.newEventBasedThreadPoolDispatcher("name")
+ *   val dispatcher = Dispatchers.newExecutorBasedEventDrivenDispatcher("name")
  *   dispatcher
  *     .withNewThreadPoolWithBoundedBlockingQueue(100)
  *     .setCorePoolSize(16)
@@ -25,7 +25,7 @@ import se.scalablesolutions.akka.actor.Actor
  * <p/>
  * Example usage:
  * <pre/>
- *   MessageDispatcher dispatcher = Dispatchers.newEventBasedThreadPoolDispatcher("name");
+ *   MessageDispatcher dispatcher = Dispatchers.newExecutorBasedEventDrivenDispatcher("name");
  *   dispatcher
  *     .withNewThreadPoolWithBoundedBlockingQueue(100)
  *     .setCorePoolSize(16)
@@ -40,9 +40,8 @@ import se.scalablesolutions.akka.actor.Actor
  */
 object Dispatchers {
   object globalExecutorBasedEventDrivenDispatcher extends ExecutorBasedEventDrivenDispatcher("global") {
-    override def register(actor : Actor) = {
-      if (isShutdown)
-        init
+    override def register(actor: Actor) = {
+      if (isShutdown) init
       super.register(actor)
     }
   }

From 5b0f267c403138824895a72b8749398e11b1df69 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonas=20Bon=C3=A9r?= <jonasremove@jonasboner.com>
Date: Fri, 16 Apr 2010 01:48:53 +0200
Subject: [PATCH 12/41] converted tabs to spaces

---
 akka-core/src/main/scala/actor/Actor.scala    |   4 +-
 .../src/test/scala/PerformanceSpec.scala      |  12 +-
 .../akka/spring/foo/Bar.java                  |   2 +-
 .../akka/spring/foo/StatefulPojo.java         |   2 +-
 .../spring/SupervisorConfigurationTest.java   | 174 +++++++++---------
 5 files changed, 97 insertions(+), 97 deletions(-)

diff --git a/akka-core/src/main/scala/actor/Actor.scala b/akka-core/src/main/scala/actor/Actor.scala
index a78b3d09c8..37a297d5ca 100644
--- a/akka-core/src/main/scala/actor/Actor.scala
+++ b/akka-core/src/main/scala/actor/Actor.scala
@@ -712,7 +712,7 @@ trait Actor extends TransactionManagement with Logging {
    * <p/>
    * To be invoked from within the actor itself.
    */
-  protected[this] def spawnRemote[T <: Actor : Manifest](hostname: String, port: Int): T = {
+  protected[this] def spawnRemote[T <: Actor: Manifest](hostname: String, port: Int): T = {
     val actor = spawnButDoNotStart[T]
     actor.makeRemote(hostname, port)
     actor.start
@@ -724,7 +724,7 @@ trait Actor extends TransactionManagement with Logging {
    * <p/>
    * To be invoked from within the actor itself.
    */
-  protected[this] def spawnLink[T <: Actor : Manifest] : T = {
+  protected[this] def spawnLink[T <: Actor: Manifest]: T = {
     val actor = spawnButDoNotStart[T]
     try {
       actor.start
diff --git a/akka-core/src/test/scala/PerformanceSpec.scala b/akka-core/src/test/scala/PerformanceSpec.scala
index 742a560f06..dd00d5ac3e 100644
--- a/akka-core/src/test/scala/PerformanceSpec.scala
+++ b/akka-core/src/test/scala/PerformanceSpec.scala
@@ -57,9 +57,9 @@ class PerformanceSpec extends JUnitSuite {
         }
         
         protected def sender : Option[Actor] = replyTo match {
-    		case Some(Left(actor)) => Some(actor)
-    		case _ => None
-  		}
+                case Some(Left(actor)) => Some(actor)
+                case _ => None
+                }
 
         def receive = {
           case MeetingCount(i) => {
@@ -104,9 +104,9 @@ class PerformanceSpec extends JUnitSuite {
         }
         
         protected def sender : Option[Actor] = replyTo match {
-    		case Some(Left(actor)) => Some(actor)
-    		case _ => None
-  		}
+                case Some(Left(actor)) => Some(actor)
+                case _ => None
+                }
 
         override def receive: PartialFunction[Any, Unit] = {
           case Meet(from, otherColour) =>
diff --git a/akka-spring/akka-spring-test-java/src/main/java/se/scalablesolutions/akka/spring/foo/Bar.java b/akka-spring/akka-spring-test-java/src/main/java/se/scalablesolutions/akka/spring/foo/Bar.java
index 24e02a3fd6..1b9e67e09c 100644
--- a/akka-spring/akka-spring-test-java/src/main/java/se/scalablesolutions/akka/spring/foo/Bar.java
+++ b/akka-spring/akka-spring-test-java/src/main/java/se/scalablesolutions/akka/spring/foo/Bar.java
@@ -10,7 +10,7 @@ public class Bar implements IBar {
         }
         
         public void throwsIOException() throws IOException {
-      	  throw new IOException("some IO went wrong");
+          throw new IOException("some IO went wrong");
         }
 
 }
diff --git a/akka-spring/akka-spring-test-java/src/main/java/se/scalablesolutions/akka/spring/foo/StatefulPojo.java b/akka-spring/akka-spring-test-java/src/main/java/se/scalablesolutions/akka/spring/foo/StatefulPojo.java
index 7ee334548c..f2308e194f 100644
--- a/akka-spring/akka-spring-test-java/src/main/java/se/scalablesolutions/akka/spring/foo/StatefulPojo.java
+++ b/akka-spring/akka-spring-test-java/src/main/java/se/scalablesolutions/akka/spring/foo/StatefulPojo.java
@@ -15,7 +15,7 @@ public class StatefulPojo {
   @inittransactionalstate
   public void init() {
       if (!isInitialized) {
-    	mapState = TransactionalState.newMap();
+        mapState = TransactionalState.newMap();
         vectorState = TransactionalState.newVector();
         refState = TransactionalState.newRef();
         isInitialized = true;
diff --git a/akka-spring/akka-spring-test-java/src/test/java/se/scalablesolutions/akka/spring/SupervisorConfigurationTest.java b/akka-spring/akka-spring-test-java/src/test/java/se/scalablesolutions/akka/spring/SupervisorConfigurationTest.java
index fbbe23d18c..659433cb9f 100644
--- a/akka-spring/akka-spring-test-java/src/test/java/se/scalablesolutions/akka/spring/SupervisorConfigurationTest.java
+++ b/akka-spring/akka-spring-test-java/src/test/java/se/scalablesolutions/akka/spring/SupervisorConfigurationTest.java
@@ -35,101 +35,101 @@ import se.scalablesolutions.akka.spring.foo.StatefulPojo;
  */
 public class SupervisorConfigurationTest {
 
-	private ApplicationContext context = null;
+        private ApplicationContext context = null;
 
-	@Before
-	public void setUp() {
-		context = new ClassPathXmlApplicationContext(
-				"se/scalablesolutions/akka/spring/foo/supervisor-config.xml");
-	}
+        @Before
+        public void setUp() {
+                context = new ClassPathXmlApplicationContext(
+                                "se/scalablesolutions/akka/spring/foo/supervisor-config.xml");
+        }
 
-	@Test
-	public void testSupervision() {
-		// get ActiveObjectConfigurator bean from spring context
-		ActiveObjectConfigurator myConfigurator = (ActiveObjectConfigurator) context
-				.getBean("supervision1");
-		// get ActiveObjects
-		Foo foo = myConfigurator.getInstance(Foo.class);
-		assertNotNull(foo);
-		IBar bar = myConfigurator.getInstance(IBar.class);
-		assertNotNull(bar);
-		MyPojo pojo = myConfigurator.getInstance(MyPojo.class);
-		assertNotNull(pojo);
-	}
+        @Test
+        public void testSupervision() {
+                // get ActiveObjectConfigurator bean from spring context
+                ActiveObjectConfigurator myConfigurator = (ActiveObjectConfigurator) context
+                                .getBean("supervision1");
+                // get ActiveObjects
+                Foo foo = myConfigurator.getInstance(Foo.class);
+                assertNotNull(foo);
+                IBar bar = myConfigurator.getInstance(IBar.class);
+                assertNotNull(bar);
+                MyPojo pojo = myConfigurator.getInstance(MyPojo.class);
+                assertNotNull(pojo);
+        }
 
-	@Test
-	public void testTransactionalState() {
-		ActiveObjectConfigurator conf = (ActiveObjectConfigurator) context
-				.getBean("supervision2");
-		StatefulPojo stateful = conf.getInstance(StatefulPojo.class);
-		stateful.setMapState("testTransactionalState", "some map state");
-		stateful.setVectorState("some vector state");
-		stateful.setRefState("some ref state");
-		assertEquals("some map state", stateful
-				.getMapState("testTransactionalState"));
-		assertEquals("some vector state", stateful.getVectorState());
-		assertEquals("some ref state", stateful.getRefState());
-	}
+        @Test
+        public void testTransactionalState() {
+                ActiveObjectConfigurator conf = (ActiveObjectConfigurator) context
+                                .getBean("supervision2");
+                StatefulPojo stateful = conf.getInstance(StatefulPojo.class);
+                stateful.setMapState("testTransactionalState", "some map state");
+                stateful.setVectorState("some vector state");
+                stateful.setRefState("some ref state");
+                assertEquals("some map state", stateful
+                                .getMapState("testTransactionalState"));
+                assertEquals("some vector state", stateful.getVectorState());
+                assertEquals("some ref state", stateful.getRefState());
+        }
 
-	@Test
-	public void testInitTransactionalState() {
-		StatefulPojo stateful = ActiveObject.newInstance(StatefulPojo.class,
-				1000, true);
-		assertTrue("should be inititalized", stateful.isInitialized());
-	}
+        @Test
+        public void testInitTransactionalState() {
+                StatefulPojo stateful = ActiveObject.newInstance(StatefulPojo.class,
+                                1000, true);
+                assertTrue("should be inititalized", stateful.isInitialized());
+        }
 
-	@Test
-	public void testSupervisionWithDispatcher() {
-		ActiveObjectConfigurator myConfigurator = (ActiveObjectConfigurator) context
-				.getBean("supervision-with-dispatcher");
-		// get ActiveObjects
-		Foo foo = myConfigurator.getInstance(Foo.class);
-		assertNotNull(foo);
-		// TODO how to check dispatcher?
-	}
-	
-	@Test
-	public void testRemoteActiveObject() {
-		new Thread(new Runnable() {
-			public void run() {
-				RemoteNode.start();
-			}
-		}).start();
-		try {
-			Thread.currentThread().sleep(1000);
-		} catch (Exception e) {
-		}
-		Foo instance = ActiveObject.newRemoteInstance(Foo.class, 2000, "localhost", 9999);
-		System.out.println(instance.foo());
-	}
+        @Test
+        public void testSupervisionWithDispatcher() {
+                ActiveObjectConfigurator myConfigurator = (ActiveObjectConfigurator) context
+                                .getBean("supervision-with-dispatcher");
+                // get ActiveObjects
+                Foo foo = myConfigurator.getInstance(Foo.class);
+                assertNotNull(foo);
+                // TODO how to check dispatcher?
+        }
+        
+        @Test
+        public void testRemoteActiveObject() {
+                new Thread(new Runnable() {
+                        public void run() {
+                                RemoteNode.start();
+                        }
+                }).start();
+                try {
+                        Thread.currentThread().sleep(1000);
+                } catch (Exception e) {
+                }
+                Foo instance = ActiveObject.newRemoteInstance(Foo.class, 2000, "localhost", 9999);
+                System.out.println(instance.foo());
+        }
 
 
-	@Test
-	public void testSupervisedRemoteActiveObject() {
-		new Thread(new Runnable() {
-			public void run() {
-				RemoteNode.start();
-			}
-		}).start();
-		try {
-			Thread.currentThread().sleep(1000);
-		} catch (Exception e) {
-		}
+        @Test
+        public void testSupervisedRemoteActiveObject() {
+                new Thread(new Runnable() {
+                        public void run() {
+                                RemoteNode.start();
+                        }
+                }).start();
+                try {
+                        Thread.currentThread().sleep(1000);
+                } catch (Exception e) {
+                }
 
-		ActiveObjectConfigurator conf = new ActiveObjectConfigurator();
-		conf.configure(
-				new RestartStrategy(new AllForOne(), 3, 10000, new Class[] { Exception.class }),
-				new Component[] { 
-					new Component(
-							Foo.class,
-							new LifeCycle(new Permanent()),
-							10000,
-							new RemoteAddress("localhost", 9999))
-					}).supervise();
+                ActiveObjectConfigurator conf = new ActiveObjectConfigurator();
+                conf.configure(
+                                new RestartStrategy(new AllForOne(), 3, 10000, new Class[] { Exception.class }),
+                                new Component[] { 
+                                        new Component(
+                                                        Foo.class,
+                                                        new LifeCycle(new Permanent()),
+                                                        10000,
+                                                        new RemoteAddress("localhost", 9999))
+                                        }).supervise();
 
-		Foo instance = conf.getInstance(Foo.class);
-		assertEquals("foo", instance.foo());
-	}
+                Foo instance = conf.getInstance(Foo.class);
+                assertEquals("foo", instance.foo());
+        }
 
-	
+        
 }

From 3ac7acccd7bc6f1411113e6acb58056eb5c68411 Mon Sep 17 00:00:00 2001
From: Peter Vlugter <peter@keya>
Date: Wed, 14 Apr 2010 09:07:20 +0800
Subject: [PATCH 13/41] tests for TransactionalRef

---
 .../src/test/scala/TransactionalRefSpec.scala | 68 +++++++++++++++++++
 1 file changed, 68 insertions(+)
 create mode 100644 akka-core/src/test/scala/TransactionalRefSpec.scala

diff --git a/akka-core/src/test/scala/TransactionalRefSpec.scala b/akka-core/src/test/scala/TransactionalRefSpec.scala
new file mode 100644
index 0000000000..b4e9c0e67a
--- /dev/null
+++ b/akka-core/src/test/scala/TransactionalRefSpec.scala
@@ -0,0 +1,68 @@
+package se.scalablesolutions.akka.stm
+
+import org.scalatest.Spec
+import org.scalatest.matchers.ShouldMatchers
+import org.scalatest.junit.JUnitRunner
+import org.junit.runner.RunWith
+
+@RunWith(classOf[JUnitRunner])
+class TransactionalRefSpec extends Spec with ShouldMatchers {
+
+  describe("A TransactionalRef") {
+    import Transaction.Local._
+
+    it("should optionally accept an initial value") {
+      val emptyRef = Ref[Int]
+      val empty = atomic { emptyRef.get }
+
+      empty should be(None)
+
+      val ref = Ref(3)
+      val value = atomic { ref.get.get }
+
+      value should be(3)
+    }
+
+    it("should be settable using swap") {
+      val ref = Ref[Int]
+
+      atomic { ref.swap(3) }
+
+      val value = atomic { ref.get.get }
+
+      value should be(3)
+    }
+
+    it("should be changeable using alter") {
+      val ref = Ref(0)
+
+      def increment = atomic {
+	ref alter (_ + 1)
+      }
+
+      increment
+      increment
+      increment
+
+      val value = atomic { ref.get.get }
+
+      value should be(3)
+    }
+
+    it("should not be changeable using alter if no value has been set") {
+      val ref = Ref[Int]
+
+      def increment = atomic {
+	ref alter (_ + 1)
+      }
+
+      evaluating { increment } should produce [RuntimeException]
+    }
+
+    it("should be able to be mapped") (pending)
+    it("should be able to be used in a 'foreach' for comprehension") (pending)
+    it("should be able to be used in a 'map' for comprehension") (pending)
+    it("should be able to be used in a 'flatMap' for comprehension") (pending)
+    it("should be able to be used in a 'filter' for comprehension") (pending)
+  }
+}

From 86ee7d8b0b079ac950676e94126827d51f813734 Mon Sep 17 00:00:00 2001
From: Peter Vlugter <peter@keya>
Date: Wed, 14 Apr 2010 09:27:45 +0800
Subject: [PATCH 14/41] tests for TransactionalRef in for comprehensions

---
 .../src/test/scala/TransactionalRefSpec.scala | 79 +++++++++++++++++--
 1 file changed, 74 insertions(+), 5 deletions(-)

diff --git a/akka-core/src/test/scala/TransactionalRefSpec.scala b/akka-core/src/test/scala/TransactionalRefSpec.scala
index b4e9c0e67a..07c36ebdcf 100644
--- a/akka-core/src/test/scala/TransactionalRefSpec.scala
+++ b/akka-core/src/test/scala/TransactionalRefSpec.scala
@@ -59,10 +59,79 @@ class TransactionalRefSpec extends Spec with ShouldMatchers {
       evaluating { increment } should produce [RuntimeException]
     }
 
-    it("should be able to be mapped") (pending)
-    it("should be able to be used in a 'foreach' for comprehension") (pending)
-    it("should be able to be used in a 'map' for comprehension") (pending)
-    it("should be able to be used in a 'flatMap' for comprehension") (pending)
-    it("should be able to be used in a 'filter' for comprehension") (pending)
+    it("should be able to be mapped") {
+      val ref1 = Ref(1)
+
+      val ref2 = atomic {
+	ref1 map (_ + 1)
+      }
+
+      val value1 = atomic { ref1.get.get }
+      val value2 = atomic { ref2.get.get }
+      
+      value1 should be(1)
+      value2 should be(2)
+    }
+
+    it("should be able to be used in a 'foreach' for comprehension") {
+      val ref = Ref(3)
+      
+      var result = 0      
+
+      atomic {
+	for (value <- ref) {
+	  result += value
+	}
+      }
+
+      result should be(3)
+    }
+
+    it("should be able to be used in a 'map' for comprehension") {
+      val ref1 = Ref(1)
+
+      val ref2 = atomic {
+	for (value <- ref1) yield value + 2
+      }
+
+      val value2 = atomic { ref2.get.get }
+
+      value2 should be(3)
+    }
+
+    it("should be able to be used in a 'flatMap' for comprehension") {
+      val ref1 = Ref(1)
+      val ref2 = Ref(2)
+
+      val ref3 = atomic {
+	for {
+	  value1 <- ref1
+	  value2 <- ref2
+	} yield value1 + value2
+      }
+
+      val value3 = atomic { ref3.get.get }
+
+      value3 should be(3)
+    }
+    
+    it("should be able to be used in a 'filter' for comprehension") {
+      val ref1 = Ref(1)
+
+      val refLess2 = atomic {
+	for (value <- ref1 if value < 2) yield value
+      }
+
+      val optLess2 = atomic { refLess2.get }
+      
+      val refGreater2 = atomic {
+	for (value <- ref1 if value > 2) yield value
+      }
+
+      val optGreater2 = atomic { refGreater2.get }
+
+      optLess2 should be(Some(1))
+      optGreater2 should be(None)
+    }
   }
 }

From 5ab81358361cc656dcd987c716041a16752e9643 Mon Sep 17 00:00:00 2001
From: Peter Vlugter <peter@keya>
Date: Wed, 14 Apr 2010 09:08:50 +0800
Subject: [PATCH 15/41] updating TransactionalRef to be properly monadic

---
 .../main/scala/stm/TransactionalState.scala   | 42 +++++++++++--------
 1 file changed, 25 insertions(+), 17 deletions(-)

diff --git a/akka-core/src/main/scala/stm/TransactionalState.scala b/akka-core/src/main/scala/stm/TransactionalState.scala
index e84beaa4f0..9bf4859ee5 100644
--- a/akka-core/src/main/scala/stm/TransactionalState.scala
+++ b/akka-core/src/main/scala/stm/TransactionalState.scala
@@ -62,6 +62,8 @@ trait Committable {
  * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
  */
 object Ref {
+  type Ref[T] = TransactionalRef[T]
+
   def apply[T]() = new Ref[T]
 
   def apply[T](initialValue: T) = new Ref[T](Some(initialValue))
@@ -75,7 +77,7 @@ object Ref {
 object TransactionalRef {
 
   /**
-   * An implicit conversion that converts an Option to an Iterable value.
+   * An implicit conversion that converts a TransactionalRef to an Iterable value.
    */
   implicit def ref2Iterable[T](ref: TransactionalRef[T]): Iterable[T] = ref.toList
 
@@ -84,14 +86,6 @@ object TransactionalRef {
   def apply[T](initialValue: T) = new TransactionalRef[T](Some(initialValue))
 }
 
-/**
- * Implements a transactional managed reference. 
- * Alias to TransactionalRef.
- *
- * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
- */
-class Ref[T](initialOpt: Option[T] = None) extends TransactionalRef[T](initialOpt)
-
 /**
  * Implements a transactional managed reference.
  * Alias to Ref.
@@ -99,6 +93,8 @@ class Ref[T](initialOpt: Option[T] = None) extends TransactionalRef[T](initialOp
  * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
  */
 class TransactionalRef[T](initialOpt: Option[T] = None) extends Transactional {
+  self =>
+
   import org.multiverse.api.ThreadLocalTransaction._
 
   implicit val txInitName = "TransactionalRef:Init"
@@ -149,24 +145,36 @@ class TransactionalRef[T](initialOpt: Option[T] = None) extends Transactional {
     ref.isNull
   }
 
-  def map[B](f: T => B): Option[B] = {
+  def map[B](f: T => B): TransactionalRef[B] = {
     ensureIsInTransaction
-    if (isEmpty) None else Some(f(ref.get))
+    if (isEmpty) TransactionalRef[B] else TransactionalRef(f(ref.get))
   }
 
-  def flatMap[B](f: T => Option[B]): Option[B] = {
+  def flatMap[B](f: T => TransactionalRef[B]): TransactionalRef[B] = {
     ensureIsInTransaction
-    if (isEmpty) None else f(ref.get)
+    if (isEmpty) TransactionalRef[B] else f(ref.get)
   }
 
-  def filter(p: T => Boolean): Option[T] = {
+  def filter(p: T => Boolean): TransactionalRef[T] = {
     ensureIsInTransaction
-    if (isEmpty || p(ref.get)) Some(ref.get) else None
+    if (isDefined && p(ref.get)) TransactionalRef(ref.get) else TransactionalRef[T]
   }
 
-  def foreach(f: T => Unit) {
+  /**
+   * Necessary to keep from being implicitly converted to Iterable in for comprehensions.
+   */
+  def withFilter(p: T => Boolean): WithFilter = new WithFilter(p)
+	
+  class WithFilter(p: T => Boolean) {
+    def map[B](f: T => B): TransactionalRef[B] = self filter p map f
+    def flatMap[B](f: T => TransactionalRef[B]): TransactionalRef[B] = self filter p flatMap f
+    def foreach[U](f: T => U): Unit = self filter p foreach f
+    def withFilter(q: T => Boolean): WithFilter = new WithFilter(x => p(x) && q(x))
+  }
+
+  def foreach[U](f: T => U): Unit = {
     ensureIsInTransaction
-    if (!isEmpty) f(ref.get)
+    if (isDefined) f(ref.get)
   }
 
   def elements: Iterator[T] = {

From a596fbbd61a3db1606d335cb4a48421a79ebf607 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonas=20Bon=C3=A9r?= <jonasremove@jonasboner.com>
Date: Fri, 16 Apr 2010 09:23:24 +0200
Subject: [PATCH 16/41] Added Cassandra logging dependencies to the compile
 jars

---
 project/build/AkkaProject.scala | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/project/build/AkkaProject.scala b/project/build/AkkaProject.scala
index b0466d5ec8..960d380a05 100644
--- a/project/build/AkkaProject.scala
+++ b/project/build/AkkaProject.scala
@@ -23,7 +23,7 @@ class AkkaParent(info: ProjectInfo) extends DefaultProject(info) {
   lazy val deployPath = info.projectPath / "deploy"
   lazy val distPath = info.projectPath / "dist"
 
-  override def compileOptions = super.compileOptions ++ 
+  override def compileOptions = super.compileOptions ++
     Seq("-deprecation", "-Xmigration", "-Xcheckinit", "-Xstrict-warnings", "-Xwarninit", "-encoding", "utf8").map(x => CompileOption(x))
 
   override def javaCompileOptions = JavaCompileOption("-Xlint:unchecked") :: super.javaCompileOptions.toList
@@ -236,13 +236,14 @@ class AkkaParent(info: ProjectInfo) extends DefaultProject(info) {
 
   class AkkaCassandraProject(info: ProjectInfo) extends AkkaDefaultProject(info, distPath) {
     val cassandra = "org.apache.cassandra" % "cassandra" % CASSANDRA_VERSION % "compile"
+    val slf4j = "org.slf4j" % "slf4j-api" % "1.5.8" % "compile"
+    val slf4j_log4j = "org.slf4j" % "slf4j-log4j12" % "1.5.8" % "compile"
+    val log4j = "log4j" % "log4j" % "1.2.15" % "compile"
+    // testing
     val high_scale = "org.apache.cassandra" % "high-scale-lib" % CASSANDRA_VERSION % "test"
     val cassandra_clhm = "org.apache.cassandra" % "clhm-production" % CASSANDRA_VERSION % "test"
     val commons_coll = "commons-collections" % "commons-collections" % "3.2.1" % "test"
     val google_coll = "com.google.collections" % "google-collections" % "1.0" % "test"
-    val slf4j = "org.slf4j" % "slf4j-api" % "1.5.8" % "test"
-    val slf4j_log4j = "org.slf4j" % "slf4j-log4j12" % "1.5.8" % "test"
-    val log4j = "log4j" % "log4j" % "1.2.15" % "test"
     override def testOptions = TestFilter((name: String) => name.endsWith("Test")) :: Nil
   }
 

From 584de097ec95bb2eadad815e764071c64deaf55f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonas=20Bon=C3=A9r?= <jonasremove@jonasboner.com>
Date: Fri, 16 Apr 2010 14:36:51 +0200
Subject: [PATCH 17/41] added sbt plugin file

---
 project/plugins/Plugins.scala | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 project/plugins/Plugins.scala

diff --git a/project/plugins/Plugins.scala b/project/plugins/Plugins.scala
new file mode 100644
index 0000000000..a929827cc6
--- /dev/null
+++ b/project/plugins/Plugins.scala
@@ -0,0 +1,5 @@
+import sbt._
+
+class Plugins(info: ProjectInfo) extends PluginDefinition(info) {
+//  val surefire = "bryanjswift" % "sbt-surefire-reporting" % "0.0.3-SNAPSHOT"
+}
\ No newline at end of file

From dcaa743f8085d914c6445727b219852343cbd17a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonas=20Bon=C3=A9r?= <jonasremove@jonasboner.com>
Date: Sat, 17 Apr 2010 18:24:41 +0200
Subject: [PATCH 18/41] added TransactionManagerDetector

---
 akka-core/src/main/scala/config/Config.scala  |  2 +-
 .../scala/AtomikosTransactionService.scala    |  5 ++-
 .../src/main/scala/TransactionContext.scala   | 28 +++++++++---
 .../scala/TransactionManagerDetector.scala    | 44 +++++++++++++++++++
 config/akka-reference.conf                    |  8 +++-
 5 files changed, 76 insertions(+), 11 deletions(-)
 create mode 100644 akka-jta/src/main/scala/TransactionManagerDetector.scala

diff --git a/akka-core/src/main/scala/config/Config.scala b/akka-core/src/main/scala/config/Config.scala
index 68cd75d825..f9a1035a7c 100644
--- a/akka-core/src/main/scala/config/Config.scala
+++ b/akka-core/src/main/scala/config/Config.scala
@@ -12,7 +12,7 @@ import net.lag.configgy.{Configgy, ParseException}
  * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
  */
 object Config extends Logging {
-  val VERSION = "0.8.1"
+  val VERSION = "0.9"
 
   // Set Multiverse options for max speed
   System.setProperty("org.multiverse.MuliverseConstants.sanityChecks", "false")
diff --git a/akka-jta/src/main/scala/AtomikosTransactionService.scala b/akka-jta/src/main/scala/AtomikosTransactionService.scala
index d688564686..1daa08a204 100644
--- a/akka-jta/src/main/scala/AtomikosTransactionService.scala
+++ b/akka-jta/src/main/scala/AtomikosTransactionService.scala
@@ -9,6 +9,8 @@ import javax.transaction.{TransactionManager, SystemException}
 import com.atomikos.icatch.jta.{J2eeTransactionManager, J2eeUserTransaction}
 import com.atomikos.icatch.config.{TSInitInfo, UserTransactionService, UserTransactionServiceImp}
 
+import se.scalablesolutions.akka.config.Config._
+
 /**
  * Atomikos implementation of the transaction service trait.
  *
@@ -16,8 +18,7 @@ import com.atomikos.icatch.config.{TSInitInfo, UserTransactionService, UserTrans
  */
 object AtomikosTransactionService extends TransactionService with TransactionProtocol {
 
-  // FIXME: make configurable
-  val JTA_TRANSACTION_TIMEOUT = 60
+  val JTA_TRANSACTION_TIMEOUT = config.getInt("akka.jta.timeout", 60)
   private val txService: UserTransactionService = new UserTransactionServiceImp
   private val info: TSInitInfo = txService.createTSInitInfo
 
diff --git a/akka-jta/src/main/scala/TransactionContext.scala b/akka-jta/src/main/scala/TransactionContext.scala
index 3ed562eeb5..218bd93828 100644
--- a/akka-jta/src/main/scala/TransactionContext.scala
+++ b/akka-jta/src/main/scala/TransactionContext.scala
@@ -7,6 +7,7 @@ package se.scalablesolutions.akka.jta
 import javax.transaction.{Transaction, Status, TransactionManager}
 
 import se.scalablesolutions.akka.util.Logging
+import se.scalablesolutions.akka.config.Config._
 
 /**
  * JTA Transaction service.
@@ -65,13 +66,25 @@ trait TransactionMonad {
 }
 
 /**
+ * The TransactionContext object manages the transactions. 
+ * Can be used as higher-order functional 'atomic blocks' or monadic.
+ *
  * Manages a thread-local stack of TransactionContexts.
  * <p/>
- * Choose TransactionService implementation by implicit definition of the implementation of choice,
- * e.g. <code>implicit val txService = TransactionServices.AtomikosTransactionService</code>.
- * <p/>
  * Example usage 1:
  * <pre>
+ * import TransactionContext._
+ * 
+ * withTxRequired {
+ *   ... // transactional stuff
+ * }
+ * // or
+ * withTxRequiresNew {
+ *   ... // transactional stuff
+ * }
+ * </pre>
+ * Example usage 2:
+ * <pre>
  * for {
  *   ctx <- TransactionContext.Required
  *   entity <- updatedEntities
@@ -81,7 +94,7 @@ trait TransactionMonad {
  *   ...
  * }
  * </pre>
- * Example usage 2:
+ * Example usage 3:
  * <pre>
  * val users = for {
  *   ctx <- TransactionContext.Required
@@ -95,9 +108,12 @@ trait TransactionMonad {
  * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
  */
 object TransactionContext extends TransactionProtocol with Logging {
-  // FIXME: make configurable
-  private implicit val defaultTransactionService = AtomikosTransactionService
+  val TRANSACTION_PROVIDER = config.getString("akka.jta.transaction-provider", "atomikos")
 
+  private implicit val defaultTransactionService = TRANSACTION_PROVIDER match {
+    case "atomikos" => AtomikosTransactionService
+    case _ => throw new IllegalArgumentException("Transaction provider [" + TRANSACTION_PROVIDER + "] is not supported")
+  }
   private[TransactionContext] val stack = new scala.util.DynamicVariable(new TransactionContext)
 
   object Required extends TransactionMonad {
diff --git a/akka-jta/src/main/scala/TransactionManagerDetector.scala b/akka-jta/src/main/scala/TransactionManagerDetector.scala
new file mode 100644
index 0000000000..f86d513ab3
--- /dev/null
+++ b/akka-jta/src/main/scala/TransactionManagerDetector.scala
@@ -0,0 +1,44 @@
+/**
+ * Copyright (C) 2009-2010 Scalable Solutions AB <http://scalablesolutions.se>
+ */
+
+package se.scalablesolutions.akka.jta
+
+import javax.transaction.{TransactionManager, UserTransaction, SystemException}
+import javax.naming.{InitialContext, Context, NamingException}
+
+import se.scalablesolutions.akka.config.Config._
+
+/**
+ * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
+ */
+object TransactionManagerDetector {
+  val DEFAULT_USER_TRANSACTION_NAME = "java:comp/UserTransaction"
+  val FALLBACK_TRANSACTION_MANAGER_NAMES = List("java:comp/TransactionManager", 
+                                                "java:appserver/TransactionManager",
+                                                "java:pm/TransactionManager", 
+                                                "java:/TransactionManager")
+  val DEFAULT_TRANSACTION_SYNCHRONIZATION_REGISTRY_NAME = "java:comp/TransactionSynchronizationRegistry"
+  val TRANSACTION_SYNCHRONIZATION_REGISTRY_CLASS_NAME = "javax.transaction.TransactionSynchronizationRegistry"
+
+  def findUserTransaction: Option[UserTransaction] = {
+    val located = createInitialContext.lookup(DEFAULT_USER_TRANSACTION_NAME)
+    if (located eq null) None
+    else Some(located.asInstanceOf[UserTransaction])
+  }
+
+  def findTransactionManager: Option[TransactionManager] = {
+    val context = createInitialContext
+    val tms = for {
+      name <- FALLBACK_TRANSACTION_MANAGER_NAMES
+      tm = context.lookup(name)
+      if tm ne null
+    } yield tm
+    tms match {
+      case Nil => None
+      case tm :: _ => Some(tm.asInstanceOf[TransactionManager])
+    }
+  }
+
+  private def createInitialContext = new InitialContext(new java.util.Hashtable)
+}
diff --git a/config/akka-reference.conf b/config/akka-reference.conf
index 34cc9eaec8..9d9fc30cbb 100644
--- a/config/akka-reference.conf
+++ b/config/akka-reference.conf
@@ -15,7 +15,7 @@
 </log>
  
 <akka>
-  version = "0.8.1"
+  version = "0.9"
  
   # FQN to the class doing initial active object/actor
   # supervisor bootstrap, should be defined in default constructor
@@ -34,8 +34,12 @@
     fair = on                     # should transactions be fair or non-fair (non fair yield better performance)
     max-nr-of-retries = 1000      # max nr of retries of a failing transaction before giving up
     timeout = 10000               # transaction timeout; if transaction has not committed within the timeout then it is aborted
-    distributed = off             # not implemented yet
   </stm>
+  
+  <jta>
+    service = off  # 'on' means that if there is a running JTA transaction then the STM will participate in it. Default is 'off'
+    timeout = 60   # timeout in seconds
+  </jta>
  
   <rest>
     service = on

From 3ce5ef8abcd22e14f23b082ce9745f1988636fe2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonas=20Bon=C3=A9r?= <jonasremove@jonasboner.com>
Date: Sat, 17 Apr 2010 18:35:34 +0200
Subject: [PATCH 19/41] upgraded to 0.9

---
 .gitignore               | 1 +
 project/build.properties | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index 69dd6d55c9..b3b2c2ebc7 100755
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,6 @@
 *~
 *#
+project/plugins/project/
 project/boot/*
 */project/build/target
 */project/boot
diff --git a/project/build.properties b/project/build.properties
index 95d001115b..b52f2291c7 100644
--- a/project/build.properties
+++ b/project/build.properties
@@ -1,6 +1,6 @@
 project.organization=se.scalablesolutions.akka
 project.name=akka
-project.version=0.8.1
+project.version=0.9
 scala.version=2.8.0.Beta1
 sbt.version=0.7.3
 def.scala.version=2.7.7

From d5da87986a1617c1d6490826a64f09359a7e8f91 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonas=20Bon=C3=A9r?= <jonasremove@jonasboner.com>
Date: Sat, 17 Apr 2010 19:28:14 +0200
Subject: [PATCH 20/41] jta-enabled stm

---
 .../stm/JtaTransactionManagerDetector.scala   |  4 +--
 .../src/main/scala/stm/Transaction.scala      | 36 +++++++++++++++++--
 config/akka-reference.conf                    |  1 +
 project/build/AkkaProject.scala               |  5 +--
 4 files changed, 40 insertions(+), 6 deletions(-)
 rename akka-jta/src/main/scala/TransactionManagerDetector.scala => akka-core/src/main/scala/stm/JtaTransactionManagerDetector.scala (95%)

diff --git a/akka-jta/src/main/scala/TransactionManagerDetector.scala b/akka-core/src/main/scala/stm/JtaTransactionManagerDetector.scala
similarity index 95%
rename from akka-jta/src/main/scala/TransactionManagerDetector.scala
rename to akka-core/src/main/scala/stm/JtaTransactionManagerDetector.scala
index f86d513ab3..30e9d3a33c 100644
--- a/akka-jta/src/main/scala/TransactionManagerDetector.scala
+++ b/akka-core/src/main/scala/stm/JtaTransactionManagerDetector.scala
@@ -2,7 +2,7 @@
  * Copyright (C) 2009-2010 Scalable Solutions AB <http://scalablesolutions.se>
  */
 
-package se.scalablesolutions.akka.jta
+package se.scalablesolutions.akka.stm
 
 import javax.transaction.{TransactionManager, UserTransaction, SystemException}
 import javax.naming.{InitialContext, Context, NamingException}
@@ -12,7 +12,7 @@ import se.scalablesolutions.akka.config.Config._
 /**
  * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
  */
-object TransactionManagerDetector {
+object JtaTransactionManagerDetector {
   val DEFAULT_USER_TRANSACTION_NAME = "java:comp/UserTransaction"
   val FALLBACK_TRANSACTION_MANAGER_NAMES = List("java:comp/TransactionManager", 
                                                 "java:appserver/TransactionManager",
diff --git a/akka-core/src/main/scala/stm/Transaction.scala b/akka-core/src/main/scala/stm/Transaction.scala
index 209c131781..44bb545a69 100644
--- a/akka-core/src/main/scala/stm/Transaction.scala
+++ b/akka-core/src/main/scala/stm/Transaction.scala
@@ -8,9 +8,12 @@ import java.util.concurrent.atomic.AtomicLong
 import java.util.concurrent.atomic.AtomicInteger
 import java.util.concurrent.TimeUnit
 
+import javax.transaction.{TransactionManager, UserTransaction, Status}
+
 import scala.collection.mutable.HashMap
 
 import se.scalablesolutions.akka.util.Logging
+import se.scalablesolutions.akka.config.Config._
 
 import org.multiverse.api.{Transaction => MultiverseTransaction, TransactionLifecycleListener, TransactionLifecycleEvent}
 import org.multiverse.api.GlobalStmInstance.getGlobalStmInstance
@@ -272,9 +275,9 @@ object Transaction {
               createNewTransactionSet
             } else getTransactionSetInScope
           val tx = new Transaction
+          tx.begin
           tx.transaction = Some(mtx)
           setTransaction(Some(tx))
-
           txSet.registerOnCommitTask(new Runnable() {
             def run = tx.commit
           })
@@ -288,11 +291,20 @@ object Transaction {
 }
 
 /**
- * The Akka specific Transaction class, keeping track of persistent data structures (as in on-disc).
+ * The Akka specific Transaction class, keeping track of persistent data structures (as in on-disc)
+ * and JTA support.
  *
  * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
  */
 @serializable class Transaction extends Logging {
+  val JTA_AWARE = config.getBool("akka.stm.jta-aware", false)
+  val jta: Either[Option[UserTransaction], Option[TransactionManager]] = if (JTA_AWARE) {
+    JtaTransactionManagerDetector.findUserTransaction match {
+      case None => Right(JtaTransactionManagerDetector.findTransactionManager)
+      case tm =>   Left(tm)
+    }
+  } else Left(None)
+  
   val id = Transaction.idFactory.incrementAndGet
   @volatile private[this] var status: TransactionStatus = TransactionStatus.New
   private[akka] var transaction: Option[MultiverseTransaction] = None
@@ -303,16 +315,34 @@ object Transaction {
 
   // --- public methods ---------
 
+  def begin = synchronized {
+    jta match {
+      case Left(Some(userTx)) => if (!isJtaTxActive(userTx.getStatus)) userTx.begin
+      case Right(Some(txMan)) => if (!isJtaTxActive(txMan.getStatus)) txMan.begin
+      case _ => {} // do nothing
+    }
+  }
+  
   def commit = synchronized {
     log.trace("Committing transaction %s", toString)
     Transaction.atomic0 {
       persistentStateMap.valuesIterator.foreach(_.commit)
     }
     status = TransactionStatus.Completed
+    jta match {
+      case Left(Some(userTx)) => if (isJtaTxActive(userTx.getStatus)) userTx.commit
+      case Right(Some(txMan)) => if (isJtaTxActive(txMan.getStatus)) txMan.commit
+      case _ => {} // do nothing
+    }
   }
 
   def abort = synchronized {
     log.trace("Aborting transaction %s", toString)
+    jta match {
+      case Left(Some(userTx)) => if (isJtaTxActive(userTx.getStatus)) userTx.rollback
+      case Right(Some(txMan)) => if (isJtaTxActive(txMan.getStatus)) txMan.rollback
+      case _ => {} // do nothing
+    }
   }
 
   def isNew = synchronized { status == TransactionStatus.New }
@@ -325,6 +355,8 @@ object Transaction {
 
   // --- internal methods ---------
 
+  private def isJtaTxActive(status: Int) = status == Status.STATUS_ACTIVE
+  
   private[akka] def status_? = status
 
   private[akka] def increment = depth.incrementAndGet
diff --git a/config/akka-reference.conf b/config/akka-reference.conf
index a8184d2662..8e4be0bab4 100644
--- a/config/akka-reference.conf
+++ b/config/akka-reference.conf
@@ -34,6 +34,7 @@
     fair = on                     # should transactions be fair or non-fair (non fair yield better performance)
     max-nr-of-retries = 1000      # max nr of retries of a failing transaction before giving up
     timeout = 10000               # transaction timeout; if transaction has not committed within the timeout then it is aborted
+    jta-aware = off               # 'on' means that if there JTA Transaction Manager available then the STM will begin (or join), commit or rollback the JTA transaction. Default is 'off'
   </stm>
   
   <jta>
diff --git a/project/build/AkkaProject.scala b/project/build/AkkaProject.scala
index a998d07b90..cf1e9c3e68 100644
--- a/project/build/AkkaProject.scala
+++ b/project/build/AkkaProject.scala
@@ -151,13 +151,14 @@ class AkkaParent(info: ProjectInfo) extends DefaultProject(info) {
     val netty = "org.jboss.netty" % "netty" % "3.2.0.BETA1" % "compile"
     val commons_io = "commons-io" % "commons-io" % "1.4" % "compile"
     val dispatch_json = "net.databinder" % "dispatch-json_2.8.0.Beta1" % "0.6.6" % "compile"
-    val dispatch_htdisttp = "net.databinder" % "dispatch-http_2.8.0.Beta1" % "0.6.6" % "compile"
+    val dispatch_http = "net.databinder" % "dispatch-http_2.8.0.Beta1" % "0.6.6" % "compile"
     val sjson = "sjson.json" % "sjson" % "0.5-SNAPSHOT-2.8.Beta1" % "compile"
     val sbinary = "sbinary" % "sbinary" % "2.8.0.Beta1-2.8.0.Beta1-0.3.1-SNAPSHOT" % "compile"
     val jackson = "org.codehaus.jackson" % "jackson-mapper-asl" % "1.2.1" % "compile"
     val jackson_core = "org.codehaus.jackson" % "jackson-core-asl" % "1.2.1" % "compile"
-    val voldemort = "voldemort.store.compress" % "h2-lzf" % "1.0" % "compile"
+    val h2_lzf = "voldemort.store.compress" % "h2-lzf" % "1.0" % "compile"
     val jsr166x = "jsr166x" % "jsr166x" % "1.0" % "compile"
+    val jta_1_1 = "org.apache.geronimo.specs" % "geronimo-jta_1.1_spec" % "1.1.1" % "compile"
     // testing
     val scalatest = "org.scalatest" % "scalatest" % SCALATEST_VERSION % "test"
     val junit = "junit" % "junit" % "4.5" % "test"

From eb95fd8e45106d87b494430303bb332c265a144e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonas=20Bon=C3=A9r?= <jonasremove@jonasboner.com>
Date: Sat, 17 Apr 2010 19:48:52 +0200
Subject: [PATCH 21/41] added logging to jta detection

---
 .../scala/stm/JtaTransactionManagerDetector.scala    | 12 +++++++++---
 akka-core/src/main/scala/stm/Transaction.scala       |  5 +++--
 2 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/akka-core/src/main/scala/stm/JtaTransactionManagerDetector.scala b/akka-core/src/main/scala/stm/JtaTransactionManagerDetector.scala
index 30e9d3a33c..fb78bf922a 100644
--- a/akka-core/src/main/scala/stm/JtaTransactionManagerDetector.scala
+++ b/akka-core/src/main/scala/stm/JtaTransactionManagerDetector.scala
@@ -8,11 +8,12 @@ import javax.transaction.{TransactionManager, UserTransaction, SystemException}
 import javax.naming.{InitialContext, Context, NamingException}
 
 import se.scalablesolutions.akka.config.Config._
+import se.scalablesolutions.akka.util.Logging
 
 /**
  * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
  */
-object JtaTransactionManagerDetector {
+object JtaTransactionManagerDetector extends Logging {
   val DEFAULT_USER_TRANSACTION_NAME = "java:comp/UserTransaction"
   val FALLBACK_TRANSACTION_MANAGER_NAMES = List("java:comp/TransactionManager", 
                                                 "java:appserver/TransactionManager",
@@ -24,7 +25,10 @@ object JtaTransactionManagerDetector {
   def findUserTransaction: Option[UserTransaction] = {
     val located = createInitialContext.lookup(DEFAULT_USER_TRANSACTION_NAME)
     if (located eq null) None
-    else Some(located.asInstanceOf[UserTransaction])
+    else {
+      log.info("JTA UserTransaction detected [%s]", located)
+      Some(located.asInstanceOf[UserTransaction])
+    }
   }
 
   def findTransactionManager: Option[TransactionManager] = {
@@ -36,7 +40,9 @@ object JtaTransactionManagerDetector {
     } yield tm
     tms match {
       case Nil => None
-      case tm :: _ => Some(tm.asInstanceOf[TransactionManager])
+      case tm :: _ =>
+        log.info("JTA TransactionManager detected [%s]", tm)
+        Some(tm.asInstanceOf[TransactionManager])
     }
   }
 
diff --git a/akka-core/src/main/scala/stm/Transaction.scala b/akka-core/src/main/scala/stm/Transaction.scala
index 44bb545a69..d670060a45 100644
--- a/akka-core/src/main/scala/stm/Transaction.scala
+++ b/akka-core/src/main/scala/stm/Transaction.scala
@@ -297,10 +297,11 @@ object Transaction {
  * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
  */
 @serializable class Transaction extends Logging {
+  import JtaTransactionManagerDetector._
   val JTA_AWARE = config.getBool("akka.stm.jta-aware", false)
   val jta: Either[Option[UserTransaction], Option[TransactionManager]] = if (JTA_AWARE) {
-    JtaTransactionManagerDetector.findUserTransaction match {
-      case None => Right(JtaTransactionManagerDetector.findTransactionManager)
+    findUserTransaction match {
+      case None => Right(findTransactionManager)
       case tm =>   Left(tm)
     }
   } else Left(None)

From 75c1cf50fc1bdc2155ea931ce83208a63d21ae34 Mon Sep 17 00:00:00 2001
From: Viktor Klang <viktor.klang@gmail.com>
Date: Mon, 19 Apr 2010 23:49:39 +0200
Subject: [PATCH 22/41] Removed jndi.properties

---
 akka-kernel/src/main/resources/jndi.properties | 1 -
 1 file changed, 1 deletion(-)
 delete mode 100644 akka-kernel/src/main/resources/jndi.properties

diff --git a/akka-kernel/src/main/resources/jndi.properties b/akka-kernel/src/main/resources/jndi.properties
deleted file mode 100644
index 3485823a1e..0000000000
--- a/akka-kernel/src/main/resources/jndi.properties
+++ /dev/null
@@ -1 +0,0 @@
-java.naming.factory.initial=com.sun.enterprise.naming.SerialInitContextFactory
\ No newline at end of file

From 4a01336153926d9268b88dc9aa68f887fba11477 Mon Sep 17 00:00:00 2001
From: Peter Vlugter <peter@keya>
Date: Tue, 20 Apr 2010 11:07:16 +1200
Subject: [PATCH 23/41] added Dean's test for Vector bug (blowing up after 32
 items)

---
 .../src/test/scala/VectorBugTestSuite.scala     | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 akka-core/src/test/scala/VectorBugTestSuite.scala

diff --git a/akka-core/src/test/scala/VectorBugTestSuite.scala b/akka-core/src/test/scala/VectorBugTestSuite.scala
new file mode 100644
index 0000000000..658ace3681
--- /dev/null
+++ b/akka-core/src/test/scala/VectorBugTestSuite.scala
@@ -0,0 +1,17 @@
+package se.scalablesolutions.akka.stm
+
+import org.scalatest.FunSuite
+import Transaction.Global._
+
+class TransactionalVectorBugTestSuite extends FunSuite {
+
+  test("adding more than 32 items to a Vector shouldn't blow it up") {
+    atomic {
+      var v1 = new Vector[Int]()
+      for (i <- 0 to 31) {
+        v1 = v1 + i
+      }
+      v1 = v1 + 32
+    }
+  }
+}

From ee21af32cea14ca51f83632cea7b938a514dbead Mon Sep 17 00:00:00 2001
From: Peter Vlugter <peter@keya>
Date: Tue, 20 Apr 2010 11:07:59 +1200
Subject: [PATCH 24/41] fix for Vector from Dean (ticket #155)

---
 akka-core/src/main/scala/stm/Vector.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/akka-core/src/main/scala/stm/Vector.scala b/akka-core/src/main/scala/stm/Vector.scala
index b76281b909..a526906115 100644
--- a/akka-core/src/main/scala/stm/Vector.scala
+++ b/akka-core/src/main/scala/stm/Vector.scala
@@ -326,7 +326,7 @@ object Vector {
   @inline
   private[stm] def array(elems: AnyRef*) = {
     val back = new Array[AnyRef](elems.length)
-    Array.copy(elems, 0, back, 0, back.length)
+    Array.copy(elems.toArray, 0, back, 0, back.length)
 
     back
   }

From fc23d02d5ed649f36f38ada5642f7e9f6e3aa8a7 Mon Sep 17 00:00:00 2001
From: Michael Kober <michael.kober@jayway.com>
Date: Tue, 20 Apr 2010 10:54:10 +0200
Subject: [PATCH 25/41] fixed #154 added ActiveObjectConfiguration with fluent
 API

---
 .../src/main/scala/actor/ActiveObject.scala   | 74 ++++++++++++++++---
 .../actor/ActiveObjectConfiguration.scala     | 39 ++++++++++
 2 files changed, 104 insertions(+), 9 deletions(-)
 create mode 100644 akka-core/src/main/scala/actor/ActiveObjectConfiguration.scala

diff --git a/akka-core/src/main/scala/actor/ActiveObject.scala b/akka-core/src/main/scala/actor/ActiveObject.scala
index 8cace19031..2446472e0e 100644
--- a/akka-core/src/main/scala/actor/ActiveObject.scala
+++ b/akka-core/src/main/scala/actor/ActiveObject.scala
@@ -41,141 +41,191 @@ object ActiveObject {
   def newInstance[T](target: Class[T], timeout: Long): T =
     newInstance(target, new Dispatcher(false, None), None, timeout)
 
+  def newInstance[T](target: Class[T]): T =
+    newInstance(target, new Dispatcher(false, None), None, Actor.TIMEOUT)
+
+  def newInstance[T](intf: Class[T], target: AnyRef, timeout: Long): T =
+      newInstance(intf, target, new Dispatcher(false, None), None, timeout)
+
+  def newInstance[T](intf: Class[T], target: AnyRef): T =
+      newInstance(intf, target, new Dispatcher(false, None), None, Actor.TIMEOUT)
+
+  def newRemoteInstance[T](target: Class[T], timeout: Long, hostname: String, port: Int): T =
+      newInstance(target, new Dispatcher(false, None), Some(new InetSocketAddress(hostname, port)), timeout)
+
+  def newRemoteInstance[T](target: Class[T], hostname: String, port: Int): T =
+        newInstance(target, new Dispatcher(false, None), Some(new InetSocketAddress(hostname, port)), Actor.TIMEOUT)
+
+  def newInstance[T](target: Class[T], config: ActiveObjectConfiguration): T = {
+    val actor = new Dispatcher(config._transactionRequired, config._restartCallbacks)
+     if (config._messageDispatcher.isDefined) {
+       actor.messageDispatcher = config._messageDispatcher.get
+     }
+     newInstance(target, actor, config._host, config._timeout)
+  }
+
+  def newInstance[T](intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration): T = {
+    val actor = new Dispatcher(config._transactionRequired, config._restartCallbacks)
+     if (config._messageDispatcher.isDefined) {
+       actor.messageDispatcher = config._messageDispatcher.get
+     }
+     newInstance(intf, target, actor, config._host, config._timeout)
+  }
+
+  @deprecated("use newInstance(target: Class[T], config: ActiveObjectConfiguration) instead")
   def newInstance[T](target: Class[T], timeout: Long, restartCallbacks: Option[RestartCallbacks]): T =
     newInstance(target, new Dispatcher(false, restartCallbacks), None, timeout)
 
-  def newInstance[T](intf: Class[T], target: AnyRef, timeout: Long): T =
-    newInstance(intf, target, new Dispatcher(false, None), None, timeout)
-
+  @deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
   def newInstance[T](intf: Class[T], target: AnyRef, timeout: Long, restartCallbacks: Option[RestartCallbacks]): T =
     newInstance(intf, target, new Dispatcher(false, restartCallbacks), None, timeout)
 
+  @deprecated("use newInstance(target: Class[T], config: ActiveObjectConfiguration) instead")
   def newInstance[T](target: Class[T], timeout: Long, transactionRequired: Boolean): T =
     newInstance(target, new Dispatcher(transactionRequired, None), None, timeout)
 
+  @deprecated("use newInstance(target: Class[T], config: ActiveObjectConfiguration) instead")
   def newInstance[T](target: Class[T], timeout: Long, transactionRequired: Boolean, restartCallbacks: Option[RestartCallbacks]): T =
     newInstance(target, new Dispatcher(transactionRequired, restartCallbacks), None, timeout)
 
+  @deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
   def newInstance[T](intf: Class[T], target: AnyRef, timeout: Long, transactionRequired: Boolean): T =
     newInstance(intf, target, new Dispatcher(transactionRequired, None), None, timeout)
 
+  @deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
   def newInstance[T](intf: Class[T], target: AnyRef, timeout: Long, transactionRequired: Boolean, restartCallbacks: Option[RestartCallbacks]): T =
     newInstance(intf, target, new Dispatcher(transactionRequired, restartCallbacks), None, timeout)
 
-  def newRemoteInstance[T](target: Class[T], timeout: Long, hostname: String, port: Int): T =
-    newInstance(target, new Dispatcher(false, None), Some(new InetSocketAddress(hostname, port)), timeout)
-
-  def newRemoteInstance[T](target: Class[T], timeout: Long, hostname: String, port: Int, restartCallbacks: Option[RestartCallbacks]): T =
-    newInstance(target, new Dispatcher(false, restartCallbacks), Some(new InetSocketAddress(hostname, port)), timeout)
-
+  @deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
   def newRemoteInstance[T](intf: Class[T], target: AnyRef, timeout: Long, hostname: String, port: Int): T =
     newInstance(intf, target, new Dispatcher(false, None), Some(new InetSocketAddress(hostname, port)), timeout)
 
+  @deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
   def newRemoteInstance[T](intf: Class[T], target: AnyRef, timeout: Long, hostname: String, port: Int, restartCallbacks: Option[RestartCallbacks]): T =
     newInstance(intf, target, new Dispatcher(false, restartCallbacks), Some(new InetSocketAddress(hostname, port)), timeout)
 
+  @deprecated("use newInstance(target: Class[T], config: ActiveObjectConfiguration) instead")
   def newRemoteInstance[T](target: Class[T], timeout: Long, transactionRequired: Boolean, hostname: String, port: Int): T =
     newInstance(target, new Dispatcher(transactionRequired, None), Some(new InetSocketAddress(hostname, port)), timeout)
 
+  @deprecated("use newInstance(target: Class[T], config: ActiveObjectConfiguration) instead")
   def newRemoteInstance[T](target: Class[T], timeout: Long, transactionRequired: Boolean, hostname: String, port: Int, restartCallbacks: Option[RestartCallbacks]): T =
     newInstance(target, new Dispatcher(transactionRequired, restartCallbacks), Some(new InetSocketAddress(hostname, port)), timeout)
 
+  @deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
   def newRemoteInstance[T](intf: Class[T], target: AnyRef, timeout: Long, transactionRequired: Boolean, hostname: String, port: Int): T =
     newInstance(intf, target, new Dispatcher(transactionRequired, None), Some(new InetSocketAddress(hostname, port)), timeout)
 
+  @deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
   def newRemoteInstance[T](intf: Class[T], target: AnyRef, timeout: Long, transactionRequired: Boolean, hostname: String, port: Int, restartCallbacks: Option[RestartCallbacks]): T =
     newInstance(intf, target, new Dispatcher(transactionRequired, restartCallbacks), Some(new InetSocketAddress(hostname, port)), timeout)
 
+  @deprecated("use newInstance(target: Class[T], config: ActiveObjectConfiguration) instead")
   def newInstance[T](target: Class[T], timeout: Long, dispatcher: MessageDispatcher): T = {
     val actor = new Dispatcher(false, None)
     actor.messageDispatcher = dispatcher
     newInstance(target, actor, None, timeout)
   }
 
+  @deprecated("use newInstance(target: Class[T], config: ActiveObjectConfiguration) instead")
   def newInstance[T](target: Class[T], timeout: Long, dispatcher: MessageDispatcher, restartCallbacks: Option[RestartCallbacks]): T = {
     val actor = new Dispatcher(false, restartCallbacks)
     actor.messageDispatcher = dispatcher
     newInstance(target, actor, None, timeout)
   }
 
+  @deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
   def newInstance[T](intf: Class[T], target: AnyRef, timeout: Long, dispatcher: MessageDispatcher): T = {
     val actor = new Dispatcher(false, None)
     actor.messageDispatcher = dispatcher
     newInstance(intf, target, actor, None, timeout)
   }
 
+  @deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
   def newInstance[T](intf: Class[T], target: AnyRef, timeout: Long, dispatcher: MessageDispatcher, restartCallbacks: Option[RestartCallbacks]): T = {
     val actor = new Dispatcher(false, restartCallbacks)
     actor.messageDispatcher = dispatcher
     newInstance(intf, target, actor, None, timeout)
   }
 
+  @deprecated("use newInstance(target: Class[T], config: ActiveObjectConfiguration) instead")
   def newInstance[T](target: Class[T], timeout: Long, transactionRequired: Boolean, dispatcher: MessageDispatcher): T = {
     val actor = new Dispatcher(transactionRequired, None)
     actor.messageDispatcher = dispatcher
     newInstance(target, actor, None, timeout)
   }
 
+  @deprecated("use newInstance(target: Class[T], config: ActiveObjectConfiguration) instead")
   def newInstance[T](target: Class[T], timeout: Long, transactionRequired: Boolean, dispatcher: MessageDispatcher, restartCallbacks: Option[RestartCallbacks]): T = {
     val actor = new Dispatcher(transactionRequired, restartCallbacks)
     actor.messageDispatcher = dispatcher
     newInstance(target, actor, None, timeout)
   }
 
+  @deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
   def newInstance[T](intf: Class[T], target: AnyRef, timeout: Long, transactionRequired: Boolean, dispatcher: MessageDispatcher): T = {
     val actor = new Dispatcher(transactionRequired, None)
     actor.messageDispatcher = dispatcher
     newInstance(intf, target, actor, None, timeout)
   }
 
+  @deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
   def newInstance[T](intf: Class[T], target: AnyRef, timeout: Long, transactionRequired: Boolean, dispatcher: MessageDispatcher, restartCallbacks: Option[RestartCallbacks]): T = {
     val actor = new Dispatcher(transactionRequired, restartCallbacks)
     actor.messageDispatcher = dispatcher
     newInstance(intf, target, actor, None, timeout)
   }
 
+  @deprecated("use newInstance(target: Class[T], config: ActiveObjectConfiguration) instead")
   def newRemoteInstance[T](target: Class[T], timeout: Long, dispatcher: MessageDispatcher, hostname: String, port: Int): T = {
     val actor = new Dispatcher(false, None)
     actor.messageDispatcher = dispatcher
     newInstance(target, actor, Some(new InetSocketAddress(hostname, port)), timeout)
   }
 
+  @deprecated("use newInstance(target: Class[T], config: ActiveObjectConfiguration) instead")
   def newRemoteInstance[T](target: Class[T], timeout: Long, dispatcher: MessageDispatcher, hostname: String, port: Int, restartCallbacks: Option[RestartCallbacks]): T = {
     val actor = new Dispatcher(false, restartCallbacks)
     actor.messageDispatcher = dispatcher
     newInstance(target, actor, Some(new InetSocketAddress(hostname, port)), timeout)
   }
 
+  @deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
   def newRemoteInstance[T](intf: Class[T], target: AnyRef, timeout: Long, dispatcher: MessageDispatcher, hostname: String, port: Int): T = {
     val actor = new Dispatcher(false, None)
     actor.messageDispatcher = dispatcher
     newInstance(intf, target, actor, Some(new InetSocketAddress(hostname, port)), timeout)
   }
 
+  @deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
   def newRemoteInstance[T](intf: Class[T], target: AnyRef, timeout: Long, dispatcher: MessageDispatcher, hostname: String, port: Int, restartCallbacks: Option[RestartCallbacks]): T = {
     val actor = new Dispatcher(false, restartCallbacks)
     actor.messageDispatcher = dispatcher
     newInstance(intf, target, actor, Some(new InetSocketAddress(hostname, port)), timeout)
   }
 
+  @deprecated("use newInstance(target: Class[T], config: ActiveObjectConfiguration) instead")
   def newRemoteInstance[T](target: Class[T], timeout: Long, transactionRequired: Boolean, dispatcher: MessageDispatcher, hostname: String, port: Int): T = {
     val actor = new Dispatcher(transactionRequired, None)
     actor.messageDispatcher = dispatcher
     newInstance(target, actor, Some(new InetSocketAddress(hostname, port)), timeout)
   }
 
+  @deprecated("use newInstance(target: Class[T], config: ActiveObjectConfiguration) instead")
   def newRemoteInstance[T](target: Class[T], timeout: Long, transactionRequired: Boolean, dispatcher: MessageDispatcher, hostname: String, port: Int, restartCallbacks: Option[RestartCallbacks]): T = {
     val actor = new Dispatcher(transactionRequired, restartCallbacks)
     actor.messageDispatcher = dispatcher
     newInstance(target, actor, Some(new InetSocketAddress(hostname, port)), timeout)
   }
 
+  @deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
   def newRemoteInstance[T](intf: Class[T], target: AnyRef, timeout: Long, transactionRequired: Boolean, dispatcher: MessageDispatcher, hostname: String, port: Int): T = {
     val actor = new Dispatcher(transactionRequired, None)
     actor.messageDispatcher = dispatcher
     newInstance(intf, target, actor, Some(new InetSocketAddress(hostname, port)), timeout)
   }
 
+  @deprecated("use newInstance(intf: Class[T], target: AnyRef, config: ActiveObjectConfiguration) instead")
   def newRemoteInstance[T](intf: Class[T], target: AnyRef, timeout: Long, transactionRequired: Boolean, dispatcher: MessageDispatcher, hostname: String, port: Int, restartCallbacks: Option[RestartCallbacks]): T = {
     val actor = new Dispatcher(transactionRequired, restartCallbacks)
     actor.messageDispatcher = dispatcher
@@ -186,6 +236,9 @@ object ActiveObject {
     val proxy = Proxy.newInstance(target, false, true)
     actor.initialize(target, proxy)
     actor.timeout = timeout
+    if (remoteAddress.isDefined) {
+      actor.makeRemote(remoteAddress.get)
+    }
     AspectInitRegistry.register(proxy, AspectInit(target, actor, remoteAddress, timeout))
     actor.start
     proxy.asInstanceOf[T]
@@ -195,6 +248,9 @@ object ActiveObject {
     val proxy = Proxy.newInstance(Array(intf), Array(target), false, true)
     actor.initialize(target.getClass, target)
     actor.timeout = timeout
+    if (remoteAddress.isDefined) {
+      actor.makeRemote(remoteAddress.get)
+    }
     AspectInitRegistry.register(proxy, AspectInit(intf, actor, remoteAddress, timeout))
     actor.start
     proxy.asInstanceOf[T]
diff --git a/akka-core/src/main/scala/actor/ActiveObjectConfiguration.scala b/akka-core/src/main/scala/actor/ActiveObjectConfiguration.scala
new file mode 100644
index 0000000000..8390d2bdbb
--- /dev/null
+++ b/akka-core/src/main/scala/actor/ActiveObjectConfiguration.scala
@@ -0,0 +1,39 @@
+package se.scalablesolutions.akka.actor
+
+import _root_.java.net.InetSocketAddress
+import _root_.se.scalablesolutions.akka.config.ScalaConfig.RestartCallbacks
+import _root_.se.scalablesolutions.akka.dispatch.MessageDispatcher
+
+
+final class ActiveObjectConfiguration {
+  private[akka] var _timeout: Long = Actor.TIMEOUT
+  private[akka] var _restartCallbacks: Option[RestartCallbacks] = None
+  private[akka] var _transactionRequired = false
+  private[akka] var _host: Option[InetSocketAddress] = None
+  private[akka] var _messageDispatcher: Option[MessageDispatcher] = None
+
+  def timeout(timeout: Long) : ActiveObjectConfiguration = {
+    _timeout = timeout
+    this
+  }
+
+  def restartCallbacks(pre: String, post: String) : ActiveObjectConfiguration = {
+    _restartCallbacks = Some(new RestartCallbacks(pre, post))
+    this
+  }
+
+  def makeTransactionRequired() : ActiveObjectConfiguration = {
+    _transactionRequired = true;
+    this
+  }
+
+  def makeRemote(hostname: String, port: Int) : ActiveObjectConfiguration = {
+    _host = Some(new InetSocketAddress(hostname, port))
+    this
+  }
+
+  def dispatcher(messageDispatcher: MessageDispatcher) : ActiveObjectConfiguration = {
+    _messageDispatcher = Some(messageDispatcher)
+    this
+  }
+}
\ No newline at end of file

From 98d5c4adb186291caa936ff5bcd89e22cf01a203 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonas=20Bon=C3=A9r?= <jonasremove@jonasboner.com>
Date: Tue, 20 Apr 2010 11:44:26 +0200
Subject: [PATCH 26/41] Finalized the JTA support

---
 .../stm/JtaTransactionManagerDetector.scala   |  50 ------
 .../src/main/scala/stm/Transaction.scala      |  33 +---
 .../main/scala/stm/TransactionContainer.scala | 160 ++++++++++++++++++
 .../scala/AtomikosTransactionService.scala    |  11 +-
 .../src/main/scala/TransactionContext.scala   |  45 ++---
 .../src/main/scala/TransactionProtocol.scala  |  21 +--
 config/akka-reference.conf                    |  17 +-
 7 files changed, 208 insertions(+), 129 deletions(-)
 delete mode 100644 akka-core/src/main/scala/stm/JtaTransactionManagerDetector.scala
 create mode 100644 akka-core/src/main/scala/stm/TransactionContainer.scala

diff --git a/akka-core/src/main/scala/stm/JtaTransactionManagerDetector.scala b/akka-core/src/main/scala/stm/JtaTransactionManagerDetector.scala
deleted file mode 100644
index fb78bf922a..0000000000
--- a/akka-core/src/main/scala/stm/JtaTransactionManagerDetector.scala
+++ /dev/null
@@ -1,50 +0,0 @@
-/**
- * Copyright (C) 2009-2010 Scalable Solutions AB <http://scalablesolutions.se>
- */
-
-package se.scalablesolutions.akka.stm
-
-import javax.transaction.{TransactionManager, UserTransaction, SystemException}
-import javax.naming.{InitialContext, Context, NamingException}
-
-import se.scalablesolutions.akka.config.Config._
-import se.scalablesolutions.akka.util.Logging
-
-/**
- * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
- */
-object JtaTransactionManagerDetector extends Logging {
-  val DEFAULT_USER_TRANSACTION_NAME = "java:comp/UserTransaction"
-  val FALLBACK_TRANSACTION_MANAGER_NAMES = List("java:comp/TransactionManager", 
-                                                "java:appserver/TransactionManager",
-                                                "java:pm/TransactionManager", 
-                                                "java:/TransactionManager")
-  val DEFAULT_TRANSACTION_SYNCHRONIZATION_REGISTRY_NAME = "java:comp/TransactionSynchronizationRegistry"
-  val TRANSACTION_SYNCHRONIZATION_REGISTRY_CLASS_NAME = "javax.transaction.TransactionSynchronizationRegistry"
-
-  def findUserTransaction: Option[UserTransaction] = {
-    val located = createInitialContext.lookup(DEFAULT_USER_TRANSACTION_NAME)
-    if (located eq null) None
-    else {
-      log.info("JTA UserTransaction detected [%s]", located)
-      Some(located.asInstanceOf[UserTransaction])
-    }
-  }
-
-  def findTransactionManager: Option[TransactionManager] = {
-    val context = createInitialContext
-    val tms = for {
-      name <- FALLBACK_TRANSACTION_MANAGER_NAMES
-      tm = context.lookup(name)
-      if tm ne null
-    } yield tm
-    tms match {
-      case Nil => None
-      case tm :: _ =>
-        log.info("JTA TransactionManager detected [%s]", tm)
-        Some(tm.asInstanceOf[TransactionManager])
-    }
-  }
-
-  private def createInitialContext = new InitialContext(new java.util.Hashtable)
-}
diff --git a/akka-core/src/main/scala/stm/Transaction.scala b/akka-core/src/main/scala/stm/Transaction.scala
index d670060a45..7fbe9898e6 100644
--- a/akka-core/src/main/scala/stm/Transaction.scala
+++ b/akka-core/src/main/scala/stm/Transaction.scala
@@ -297,31 +297,24 @@ object Transaction {
  * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
  */
 @serializable class Transaction extends Logging {
-  import JtaTransactionManagerDetector._
   val JTA_AWARE = config.getBool("akka.stm.jta-aware", false)
-  val jta: Either[Option[UserTransaction], Option[TransactionManager]] = if (JTA_AWARE) {
-    findUserTransaction match {
-      case None => Right(findTransactionManager)
-      case tm =>   Left(tm)
-    }
-  } else Left(None)
-  
+
   val id = Transaction.idFactory.incrementAndGet
   @volatile private[this] var status: TransactionStatus = TransactionStatus.New
   private[akka] var transaction: Option[MultiverseTransaction] = None
   private[this] val persistentStateMap = new HashMap[String, Committable]
   private[akka] val depth = new AtomicInteger(0)
-
+  
+  val tc: Option[TransactionContainer] =
+    if (JTA_AWARE) Some(TransactionContainer())
+    else None
+  
   log.trace("Creating %s", toString)
 
   // --- public methods ---------
 
   def begin = synchronized {
-    jta match {
-      case Left(Some(userTx)) => if (!isJtaTxActive(userTx.getStatus)) userTx.begin
-      case Right(Some(txMan)) => if (!isJtaTxActive(txMan.getStatus)) txMan.begin
-      case _ => {} // do nothing
-    }
+    tc.foreach(_.begin)
   }
   
   def commit = synchronized {
@@ -330,20 +323,12 @@ object Transaction {
       persistentStateMap.valuesIterator.foreach(_.commit)
     }
     status = TransactionStatus.Completed
-    jta match {
-      case Left(Some(userTx)) => if (isJtaTxActive(userTx.getStatus)) userTx.commit
-      case Right(Some(txMan)) => if (isJtaTxActive(txMan.getStatus)) txMan.commit
-      case _ => {} // do nothing
-    }
+    tc.foreach(_.commit)
   }
 
   def abort = synchronized {
     log.trace("Aborting transaction %s", toString)
-    jta match {
-      case Left(Some(userTx)) => if (isJtaTxActive(userTx.getStatus)) userTx.rollback
-      case Right(Some(txMan)) => if (isJtaTxActive(txMan.getStatus)) txMan.rollback
-      case _ => {} // do nothing
-    }
+    tc.foreach(_.rollback)
   }
 
   def isNew = synchronized { status == TransactionStatus.New }
diff --git a/akka-core/src/main/scala/stm/TransactionContainer.scala b/akka-core/src/main/scala/stm/TransactionContainer.scala
new file mode 100644
index 0000000000..19c7c54255
--- /dev/null
+++ b/akka-core/src/main/scala/stm/TransactionContainer.scala
@@ -0,0 +1,160 @@
+/**
+ * Copyright (C) 2009-2010 Scalable Solutions AB <http://scalablesolutions.se>
+ */
+
+package se.scalablesolutions.akka.stm
+
+import javax.transaction.{TransactionManager, UserTransaction, Transaction => JtaTransaction, SystemException, Status}
+import javax.naming.{InitialContext, Context, NamingException}
+
+import se.scalablesolutions.akka.config.Config._
+import se.scalablesolutions.akka.util.Logging
+
+/**
+ * JTA transaction container holding either a UserTransaction or a TransactionManager.
+ * <p/>
+ * The TransactionContainer is created using the factory <tt>val container = TransactionContainer()</tt>
+ * 
+ * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
+ */
+class TransactionContainer private (val tm: Either[Option[UserTransaction], Option[TransactionManager]]) {
+ 
+  def begin = tm match {
+    case Left(Some(userTx)) => userTx.begin
+    case Right(Some(txMan)) => txMan.begin
+    case _ => throw new IllegalStateException("Does not have a UserTransaction or TransactionManager in scope")
+  }
+  
+  def commit = tm match {
+    case Left(Some(userTx)) => userTx.commit
+    case Right(Some(txMan)) => txMan.commit
+    case _ => throw new IllegalStateException("Does not have a UserTransaction or TransactionManager in scope")
+  }
+  
+  def rollback =  tm match {
+    case Left(Some(userTx)) => userTx.rollback
+    case Right(Some(txMan)) => txMan.rollback
+    case _ => throw new IllegalStateException("Does not have a UserTransaction or TransactionManager in scope")
+  }
+  
+  def getStatus = tm match {
+    case Left(Some(userTx)) => userTx.getStatus
+    case Right(Some(txMan)) => txMan.getStatus
+    case _ => throw new IllegalStateException("Does not have a UserTransaction or TransactionManager in scope")
+  }
+  
+  def isInExistingTransaction = tm match {
+    case Left(Some(userTx)) => userTx.getStatus == Status.STATUS_ACTIVE
+    case Right(Some(txMan)) => txMan.getStatus == Status.STATUS_ACTIVE
+    case _ => throw new IllegalStateException("Does not have a UserTransaction or TransactionManager in scope")
+  }
+
+  def isRollbackOnly = tm match {
+    case Left(Some(userTx)) => userTx.getStatus == Status.STATUS_MARKED_ROLLBACK
+    case Right(Some(txMan)) => txMan.getStatus == Status.STATUS_MARKED_ROLLBACK
+    case _ => throw new IllegalStateException("Does not have a UserTransaction or TransactionManager in scope")
+  }
+  
+  def setRollbackOnly = tm match {
+    case Left(Some(userTx)) => userTx.setRollbackOnly
+    case Right(Some(txMan)) => txMan.setRollbackOnly
+    case _ => throw new IllegalStateException("Does not have a UserTransaction or TransactionManager in scope")
+  }
+  /*
+  def getTransaction: JtaTransaction = tm match {
+    case Left(Some(userTx)) => userTx
+    case Right(Some(txMan)) => txMan.getTransaction
+    case _ => throw new IllegalStateException("Does not have a UserTransaction or TransactionManager in scope")
+  }
+ */
+  def suspend = tm match {
+    case Right(Some(txMan)) => txMan.suspend
+    case _ => throw new IllegalStateException("Does not have a TransactionManager in scope")
+  }
+  
+  def resume(tx: JtaTransaction) = tm match {
+    case Right(Some(txMan)) => txMan.resume(tx)
+    case _ => throw new IllegalStateException("Does not have a TransactionManager in scope")
+  }
+}
+
+/**
+ * Detects if there is a UserTransaction or TransactionManager available in the JNDI.
+ * 
+ * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
+ */
+object TransactionContainer extends Logging {
+  val AKKA_JTA_TRANSACTION_SERVICE_CLASS = "se.scalablesolutions.akka.jta.AtomikosTransactionService"
+  val DEFAULT_USER_TRANSACTION_NAME =                     "java:comp/UserTransaction"
+  val FALLBACK_TRANSACTION_MANAGER_NAMES =                "java:comp/TransactionManager" :: 
+                                                          "java:appserver/TransactionManager" ::
+                                                          "java:pm/TransactionManager" ::
+                                                          "java:/TransactionManager" :: Nil
+  val DEFAULT_TRANSACTION_SYNCHRONIZATION_REGISTRY_NAME = "java:comp/TransactionSynchronizationRegistry"
+  val TRANSACTION_SYNCHRONIZATION_REGISTRY_CLASS_NAME =   "javax.transaction.TransactionSynchronizationRegistry"
+  val JTA_PROVIDER = config.getString("akka.stm.jta.provider", "from-jndi")
+
+  def apply(tm: Either[Option[UserTransaction], Option[TransactionManager]]) = new TransactionContainer(tm)
+  
+  def apply(): TransactionContainer =
+    JTA_PROVIDER match {
+      case "from-jndi" => 
+        new TransactionContainer(findUserTransaction match {
+          case None => Right(findTransactionManager)
+          case tm =>   Left(tm)
+        })
+      case "atomikos" =>
+        try {
+          Class.forName(AKKA_JTA_TRANSACTION_SERVICE_CLASS)
+               .newInstance.asInstanceOf[TransactionService]
+               .transactionContainer
+        } catch {
+          case e: ClassNotFoundException => 
+            throw new IllegalStateException(
+              "JTA provider defined as 'atomikos', but the AtomikosTransactionService classes can not be found." + 
+              "\n\tPlease make sure you have 'akka-jta' JAR and its dependencies on your classpath.")
+        }
+      case _ => 
+        throw new IllegalStateException(
+        "No UserTransaction on TransactionManager could be found in scope." +
+        "\n\tEither add 'akka-jta' to the classpath or make sure there is a" + 
+        "\n\tTransactionManager or UserTransaction defined in the JNDI.")
+      
+    }
+  
+  def findUserTransaction: Option[UserTransaction] = {
+    val located = createInitialContext.lookup(DEFAULT_USER_TRANSACTION_NAME)
+    if (located eq null) None
+    else {
+      log.info("JTA UserTransaction detected [%s]", located)
+      Some(located.asInstanceOf[UserTransaction])
+    }
+  }
+
+  def findTransactionManager: Option[TransactionManager] = {
+    val context = createInitialContext
+    val tms = for {
+      name <- FALLBACK_TRANSACTION_MANAGER_NAMES
+      tm = context.lookup(name)
+      if tm ne null
+    } yield tm
+    tms match {
+      case Nil => None
+      case tm :: _ =>
+        log.info("JTA TransactionManager detected [%s]", tm)
+        Some(tm.asInstanceOf[TransactionManager])
+    }
+  }
+
+  private def createInitialContext = new InitialContext(new java.util.Hashtable)
+}
+
+/**
+ * JTA Transaction service.
+ *
+ * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
+ */
+trait TransactionService {
+  def transactionContainer: TransactionContainer  
+}
+
diff --git a/akka-jta/src/main/scala/AtomikosTransactionService.scala b/akka-jta/src/main/scala/AtomikosTransactionService.scala
index 1daa08a204..d59c60961b 100644
--- a/akka-jta/src/main/scala/AtomikosTransactionService.scala
+++ b/akka-jta/src/main/scala/AtomikosTransactionService.scala
@@ -10,19 +10,22 @@ import com.atomikos.icatch.jta.{J2eeTransactionManager, J2eeUserTransaction}
 import com.atomikos.icatch.config.{TSInitInfo, UserTransactionService, UserTransactionServiceImp}
 
 import se.scalablesolutions.akka.config.Config._
+import se.scalablesolutions.akka.stm.{TransactionService, TransactionContainer}
+
+object AtomikosTransactionService extends AtomikosTransactionService
 
 /**
  * Atomikos implementation of the transaction service trait.
  *
  * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
  */
-object AtomikosTransactionService extends TransactionService with TransactionProtocol {
+class AtomikosTransactionService extends TransactionService with TransactionProtocol {
 
-  val JTA_TRANSACTION_TIMEOUT = config.getInt("akka.jta.timeout", 60)
+  val JTA_TRANSACTION_TIMEOUT: Int = config.getInt("akka.stm.jta.timeout", 60000) / 1000
   private val txService: UserTransactionService = new UserTransactionServiceImp
   private val info: TSInitInfo = txService.createTSInitInfo
 
-  val transactionManager =
+  val transactionContainer: TransactionContainer = TransactionContainer(Right(Some(
     try {
       txService.init(info)
       val tm: TransactionManager = new J2eeTransactionManager
@@ -31,7 +34,7 @@ object AtomikosTransactionService extends TransactionService with TransactionPro
     } catch {
       case e => throw new SystemException("Could not create a new Atomikos J2EE Transaction Manager, due to: " + e.toString)
     }
-
+  )))
   // TODO: gracefully shutdown of the TM
   //txService.shutdown(false)
 }
diff --git a/akka-jta/src/main/scala/TransactionContext.scala b/akka-jta/src/main/scala/TransactionContext.scala
index 218bd93828..0f6ae29454 100644
--- a/akka-jta/src/main/scala/TransactionContext.scala
+++ b/akka-jta/src/main/scala/TransactionContext.scala
@@ -6,18 +6,10 @@ package se.scalablesolutions.akka.jta
 
 import javax.transaction.{Transaction, Status, TransactionManager}
 
+import se.scalablesolutions.akka.stm.{TransactionService, TransactionContainer}
 import se.scalablesolutions.akka.util.Logging
 import se.scalablesolutions.akka.config.Config._
 
-/**
- * JTA Transaction service.
- *
- * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
- */
-trait TransactionService {
-  def transactionManager: TransactionManager  
-}
-
 /**
  * Base monad for the transaction monad implementations.
  *
@@ -39,11 +31,6 @@ trait TransactionMonad {
   // JTA Transaction definitions
   // -----------------------------
 
-  /**
-   * Returns the current Transaction.
-   */
-  def getTransaction: Transaction = TransactionContext.getTransactionManager.getTransaction
-
   /**
    * Marks the current transaction as doomed.
    */
@@ -108,13 +95,8 @@ trait TransactionMonad {
  * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
  */
 object TransactionContext extends TransactionProtocol with Logging {
-  val TRANSACTION_PROVIDER = config.getString("akka.jta.transaction-provider", "atomikos")
-
-  private implicit val defaultTransactionService = TRANSACTION_PROVIDER match {
-    case "atomikos" => AtomikosTransactionService
-    case _ => throw new IllegalArgumentException("Transaction provider [" + TRANSACTION_PROVIDER + "] is not supported")
-  }
-  private[TransactionContext] val stack = new scala.util.DynamicVariable(new TransactionContext)
+  implicit val tc = TransactionContainer()                    
+  private[TransactionContext] val stack = new scala.util.DynamicVariable(new TransactionContext(tc))
 
   object Required extends TransactionMonad {
     def map[T](f: TransactionMonad => T): T =        withTxRequired { f(this) }
@@ -157,9 +139,7 @@ object TransactionContext extends TransactionProtocol with Logging {
 
   private[jta] def isRollbackOnly = current.isRollbackOnly
 
-  private[jta] def getTransactionManager: TransactionManager = current.getTransactionManager
-
-  private[jta] def getTransaction: Transaction = current.getTransactionManager.getTransaction
+  private[jta] def getTransactionContainer: TransactionContainer = current.getTransactionContainer
 
   private[this] def current = stack.value
 
@@ -171,14 +151,14 @@ object TransactionContext extends TransactionProtocol with Logging {
    */
   private[jta] def withNewContext[T](body: => T): T = {
     val suspendedTx: Option[Transaction] =
-      if (isInExistingTransaction(getTransactionManager)) {
+      if (getTransactionContainer.isInExistingTransaction) {
         log.debug("Suspending TX")
-        Some(getTransactionManager.suspend)
+        Some(getTransactionContainer.suspend)
       } else None
-    val result = stack.withValue(new TransactionContext) { body }
+    val result = stack.withValue(new TransactionContext(tc)) { body }
     if (suspendedTx.isDefined) {
       log.debug("Resuming TX")
-      getTransactionManager.resume(suspendedTx.get)
+      getTransactionContainer.resume(suspendedTx.get)
     }
     result
   }
@@ -189,9 +169,8 @@ object TransactionContext extends TransactionProtocol with Logging {
  *
  * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
  */
-class TransactionContext(private implicit val transactionService: TransactionService) {
-  val tm: TransactionManager = transactionService.transactionManager
-  private def setRollbackOnly = tm.setRollbackOnly
-  private def isRollbackOnly: Boolean = tm.getStatus == Status.STATUS_MARKED_ROLLBACK
-  private def getTransactionManager: TransactionManager = tm
+class TransactionContext(val tc: TransactionContainer) {
+  private def setRollbackOnly = tc.setRollbackOnly
+  private def isRollbackOnly: Boolean = tc.getStatus == Status.STATUS_MARKED_ROLLBACK
+  private def getTransactionContainer: TransactionContainer = tc
 }
diff --git a/akka-jta/src/main/scala/TransactionProtocol.scala b/akka-jta/src/main/scala/TransactionProtocol.scala
index 4a4c263eb1..837955425e 100644
--- a/akka-jta/src/main/scala/TransactionProtocol.scala
+++ b/akka-jta/src/main/scala/TransactionProtocol.scala
@@ -5,6 +5,7 @@
 package se.scalablesolutions.akka.jta
 
 import se.scalablesolutions.akka.util.Logging
+import se.scalablesolutions.akka.stm.TransactionContainer
 
 import javax.naming.{NamingException, Context, InitialContext}
 import javax.transaction.{
@@ -71,7 +72,7 @@ trait TransactionProtocol extends Logging {
    * <pre>
    * override def joinTransaction = {
    *   val em = TransactionContext.getEntityManager
-   *   val tm = TransactionContext.getTransactionManager
+   *   val tm = TransactionContext.getTransactionContainer
    *   val closeAtTxCompletion: Boolean) 
    *   tm.getTransaction.registerSynchronization(new javax.transaction.Synchronization() {
    *     def beforeCompletion = {
@@ -109,7 +110,7 @@ trait TransactionProtocol extends Logging {
    * Here is an example on how to handle JPA exceptions.
    * 
    * <pre>
-   * def handleException(tm: TransactionManager, e: Exception) = {
+   * def handleException(tm: TransactionContainer, e: Exception) = {
    *   if (isInExistingTransaction(tm)) {
    *     // Do not roll back in case of NoResultException or NonUniqueResultException
    *     if (!e.isInstanceOf[NoResultException] &&
@@ -122,7 +123,7 @@ trait TransactionProtocol extends Logging {
    * }
    * </pre>
    */
-  def handleException(tm: TransactionManager, e: Exception) = {
+  def handleException(tm: TransactionContainer, e: Exception) = {
     tm.setRollbackOnly
     throw e
   }
@@ -133,7 +134,7 @@ trait TransactionProtocol extends Logging {
    * Creates a new transaction if no transaction is active in scope, else joins the outer transaction. 
    */
   def withTxRequired[T](body: => T): T = {
-    val tm = TransactionContext.getTransactionManager
+    val tm = TransactionContext.getTransactionContainer
     if (!isInExistingTransaction(tm)) {
       tm.begin
       try {
@@ -154,7 +155,7 @@ trait TransactionProtocol extends Logging {
    * commits or rollbacks new transaction, finally resumes previous transaction.
    */
   def withTxRequiresNew[T](body: => T): T = TransactionContext.withNewContext {
-    val tm = TransactionContext.getTransactionManager
+    val tm = TransactionContext.getTransactionContainer
     tm.begin
     try {
       joinTransaction
@@ -191,7 +192,7 @@ trait TransactionProtocol extends Logging {
    * Throws a TransactionRequiredException if there is no transaction active in scope.
    */
   def withTxMandatory[T](body: => T): T = {
-    if (!isInExistingTransaction(TransactionContext.getTransactionManager)) 
+    if (!isInExistingTransaction(TransactionContext.getTransactionContainer)) 
       throw new TransactionRequiredException("No active TX at method with TX type set to MANDATORY")
     body
   }
@@ -202,12 +203,12 @@ trait TransactionProtocol extends Logging {
    * Throws a SystemException in case of an existing transaction in scope.
    */
   def withTxNever[T](body: => T): T = {
-    if (isInExistingTransaction(TransactionContext.getTransactionManager)) 
+    if (isInExistingTransaction(TransactionContext.getTransactionContainer)) 
       throw new SystemException("Detected active TX at method with TX type set to NEVER")
     body
   }
 
-  protected def commitOrRollBack(tm: TransactionManager) = {
+  protected def commitOrRollBack(tm: TransactionContainer) = {
     if (isInExistingTransaction(tm)) {
       if (isRollbackOnly(tm)) {
         log.debug("Rolling back TX marked as ROLLBACK_ONLY")
@@ -229,7 +230,7 @@ trait TransactionProtocol extends Logging {
    * @param tm the transaction manager
    * @return boolean
    */
-  protected def isInExistingTransaction(tm: TransactionManager): Boolean = 
+  protected def isInExistingTransaction(tm: TransactionContainer): Boolean = 
     tm.getStatus != Status.STATUS_NO_TRANSACTION
 
   /**
@@ -238,7 +239,7 @@ trait TransactionProtocol extends Logging {
    * @param tm the transaction manager
    * @return boolean
    */
-  protected def isRollbackOnly(tm: TransactionManager): Boolean = 
+  protected def isRollbackOnly(tm: TransactionContainer): Boolean = 
     tm.getStatus == Status.STATUS_MARKED_ROLLBACK
 
   /**
diff --git a/config/akka-reference.conf b/config/akka-reference.conf
index 8e4be0bab4..d2c5ed3c73 100644
--- a/config/akka-reference.conf
+++ b/config/akka-reference.conf
@@ -17,7 +17,7 @@
 <akka>
   version = "0.9"
  
-  # FQN to the class doing initial active object/actor
+  # FQN (Fully Qualified Name) to the class doing initial active object/actor
   # supervisor bootstrap, should be defined in default constructor
   boot = ["sample.camel.Boot",
           "sample.rest.java.Boot", 
@@ -31,17 +31,18 @@
  
   <stm>
     service = on
-    fair = on                     # should transactions be fair or non-fair (non fair yield better performance)
-    max-nr-of-retries = 1000      # max nr of retries of a failing transaction before giving up
-    timeout = 10000               # transaction timeout; if transaction has not committed within the timeout then it is aborted
-    jta-aware = off               # 'on' means that if there JTA Transaction Manager available then the STM will begin (or join), commit or rollback the JTA transaction. Default is 'off'
+    fair = on                # should transactions be fair or non-fair (non fair yield better performance)
+    max-nr-of-retries = 1000 # max nr of retries of a failing transaction before giving up
+    timeout = 10000          # transaction timeout; if transaction has not committed within the timeout then it is aborted
+    jta-aware = off          # 'on' means that if there JTA Transaction Manager available then the STM will
+                             # begin (or join), commit or rollback the JTA transaction. Default is 'off'.
   </stm>
   
   <jta>
-    service = off  # 'on' means that if there is a running JTA transaction then the STM will participate in it. Default is 'off'
-    timeout = 60   # timeout in seconds
+    provider = "from-jndi"   # Options: "from-jndi", "atomikos"
+    timeout = 60000
   </jta>
- 
+
   <rest>
     service = on
     hostname = "localhost"

From b4c7158b6172700b1210ab07282ae08348d49768 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonas=20Bon=C3=A9r?= <jonasremove@jonasboner.com>
Date: Tue, 20 Apr 2010 13:32:34 +0200
Subject: [PATCH 27/41] Cleaned up JTA stuff

---
 .../main/scala/stm/TransactionContainer.scala | 10 +--
 .../scala/AtomikosTransactionService.scala    |  2 +-
 .../src/main/scala/TransactionContext.scala   | 84 +++++++++----------
 .../src/main/scala/TransactionProtocol.scala  |  2 +-
 config/akka-reference.conf                    |  4 +-
 5 files changed, 49 insertions(+), 53 deletions(-)

diff --git a/akka-core/src/main/scala/stm/TransactionContainer.scala b/akka-core/src/main/scala/stm/TransactionContainer.scala
index 19c7c54255..09da21a494 100644
--- a/akka-core/src/main/scala/stm/TransactionContainer.scala
+++ b/akka-core/src/main/scala/stm/TransactionContainer.scala
@@ -60,13 +60,7 @@ class TransactionContainer private (val tm: Either[Option[UserTransaction], Opti
     case Right(Some(txMan)) => txMan.setRollbackOnly
     case _ => throw new IllegalStateException("Does not have a UserTransaction or TransactionManager in scope")
   }
-  /*
-  def getTransaction: JtaTransaction = tm match {
-    case Left(Some(userTx)) => userTx
-    case Right(Some(txMan)) => txMan.getTransaction
-    case _ => throw new IllegalStateException("Does not have a UserTransaction or TransactionManager in scope")
-  }
- */
+
   def suspend = tm match {
     case Right(Some(txMan)) => txMan.suspend
     case _ => throw new IllegalStateException("Does not have a TransactionManager in scope")
@@ -92,7 +86,7 @@ object TransactionContainer extends Logging {
                                                           "java:/TransactionManager" :: Nil
   val DEFAULT_TRANSACTION_SYNCHRONIZATION_REGISTRY_NAME = "java:comp/TransactionSynchronizationRegistry"
   val TRANSACTION_SYNCHRONIZATION_REGISTRY_CLASS_NAME =   "javax.transaction.TransactionSynchronizationRegistry"
-  val JTA_PROVIDER = config.getString("akka.stm.jta.provider", "from-jndi")
+  val JTA_PROVIDER = config.getString("akka.jta.provider", "from-jndi")
 
   def apply(tm: Either[Option[UserTransaction], Option[TransactionManager]]) = new TransactionContainer(tm)
   
diff --git a/akka-jta/src/main/scala/AtomikosTransactionService.scala b/akka-jta/src/main/scala/AtomikosTransactionService.scala
index d59c60961b..937f31a54e 100644
--- a/akka-jta/src/main/scala/AtomikosTransactionService.scala
+++ b/akka-jta/src/main/scala/AtomikosTransactionService.scala
@@ -21,7 +21,7 @@ object AtomikosTransactionService extends AtomikosTransactionService
  */
 class AtomikosTransactionService extends TransactionService with TransactionProtocol {
 
-  val JTA_TRANSACTION_TIMEOUT: Int = config.getInt("akka.stm.jta.timeout", 60000) / 1000
+  val JTA_TRANSACTION_TIMEOUT: Int = config.getInt("akka.jta.timeout", 60000) / 1000
   private val txService: UserTransactionService = new UserTransactionServiceImp
   private val info: TSInitInfo = txService.createTSInitInfo
 
diff --git a/akka-jta/src/main/scala/TransactionContext.scala b/akka-jta/src/main/scala/TransactionContext.scala
index 0f6ae29454..43d2c082d8 100644
--- a/akka-jta/src/main/scala/TransactionContext.scala
+++ b/akka-jta/src/main/scala/TransactionContext.scala
@@ -10,48 +10,6 @@ import se.scalablesolutions.akka.stm.{TransactionService, TransactionContainer}
 import se.scalablesolutions.akka.util.Logging
 import se.scalablesolutions.akka.config.Config._
 
-/**
- * Base monad for the transaction monad implementations.
- *
- * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
- */
-trait TransactionMonad {
-
-  // -----------------------------
-  // Monadic definitions
-  // -----------------------------
-
-  def map[T](f: TransactionMonad => T): T
-  def flatMap[T](f: TransactionMonad => T): T
-  def foreach(f: TransactionMonad => Unit): Unit
-  def filter(f: TransactionMonad => Boolean): TransactionMonad =
-    if (f(this)) this else TransactionContext.NoOpTransactionMonad
-
-  // -----------------------------
-  // JTA Transaction definitions
-  // -----------------------------
-
-  /**
-   * Marks the current transaction as doomed.
-   */
-  def setRollbackOnly = TransactionContext.setRollbackOnly
-
-  /**
-   * Marks the current transaction as doomed.
-   */
-  def doom = TransactionContext.setRollbackOnly
-
-  /**
-   * Checks if the current transaction is doomed.
-   */
-  def isRollbackOnly = TransactionContext.isRollbackOnly
-
-  /**
-   * Checks that the current transaction is NOT doomed.
-   */
-  def isNotDoomed = !TransactionContext.isRollbackOnly
-}
-
 /**
  * The TransactionContext object manages the transactions. 
  * Can be used as higher-order functional 'atomic blocks' or monadic.
@@ -164,6 +122,48 @@ object TransactionContext extends TransactionProtocol with Logging {
   }
 }
 
+/**
+ * Base monad for the transaction monad implementations.
+ *
+ * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
+ */
+trait TransactionMonad {
+
+  // -----------------------------
+  // Monadic definitions
+  // -----------------------------
+
+  def map[T](f: TransactionMonad => T): T
+  def flatMap[T](f: TransactionMonad => T): T
+  def foreach(f: TransactionMonad => Unit): Unit
+  def filter(f: TransactionMonad => Boolean): TransactionMonad =
+    if (f(this)) this else TransactionContext.NoOpTransactionMonad
+
+  // -----------------------------
+  // JTA Transaction definitions
+  // -----------------------------
+
+  /**
+   * Marks the current transaction as doomed.
+   */
+  def setRollbackOnly = TransactionContext.setRollbackOnly
+
+  /**
+   * Marks the current transaction as doomed.
+   */
+  def doom = TransactionContext.setRollbackOnly
+
+  /**
+   * Checks if the current transaction is doomed.
+   */
+  def isRollbackOnly = TransactionContext.isRollbackOnly
+
+  /**
+   * Checks that the current transaction is NOT doomed.
+   */
+  def isNotDoomed = !TransactionContext.isRollbackOnly
+}
+
 /**
  * Transaction context, holds the EntityManager and the TransactionManager.
  *
diff --git a/akka-jta/src/main/scala/TransactionProtocol.scala b/akka-jta/src/main/scala/TransactionProtocol.scala
index 837955425e..2036f0d013 100644
--- a/akka-jta/src/main/scala/TransactionProtocol.scala
+++ b/akka-jta/src/main/scala/TransactionProtocol.scala
@@ -115,7 +115,7 @@ trait TransactionProtocol extends Logging {
    *     // Do not roll back in case of NoResultException or NonUniqueResultException
    *     if (!e.isInstanceOf[NoResultException] &&
    *         !e.isInstanceOf[NonUniqueResultException]) {
-   *       log.debug("Setting TX to ROLLBACK_ONLY, due to: " + e)
+   *       log.debug("Setting TX to ROLLBACK_ONLY, due to: %s", e)
    *       tm.setRollbackOnly
    *     }
    *   }
diff --git a/config/akka-reference.conf b/config/akka-reference.conf
index d2c5ed3c73..ab365ea6eb 100644
--- a/config/akka-reference.conf
+++ b/config/akka-reference.conf
@@ -39,7 +39,9 @@
   </stm>
   
   <jta>
-    provider = "from-jndi"   # Options: "from-jndi", "atomikos"
+    provider = "from-jndi"   # Options: "from-jndi" (means that Akka will try to detect a TransactionManager in the JNDI) 
+                             #          "atomikos" (means that Akka will use the Atomikos based JTA impl in 'akka-jta', 
+                             #          e.g. you need the akka-jta JARs on classpath).
     timeout = 60000
   </jta>
 

From fec67a8fc1447545d09effd2937eebe2ea45d156 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonas=20Bon=C3=A9r?= <jonasremove@jonasboner.com>
Date: Tue, 20 Apr 2010 14:53:45 +0200
Subject: [PATCH 28/41] Added STM Synchronization registration to JNDI
 TransactionSynchronizationRegistry

---
 .../src/main/scala/stm/Transaction.scala      |  19 ++-
 .../main/scala/stm/TransactionContainer.scala | 154 ------------------
 2 files changed, 14 insertions(+), 159 deletions(-)
 delete mode 100644 akka-core/src/main/scala/stm/TransactionContainer.scala

diff --git a/akka-core/src/main/scala/stm/Transaction.scala b/akka-core/src/main/scala/stm/Transaction.scala
index 7fbe9898e6..97d588f400 100644
--- a/akka-core/src/main/scala/stm/Transaction.scala
+++ b/akka-core/src/main/scala/stm/Transaction.scala
@@ -8,7 +8,7 @@ import java.util.concurrent.atomic.AtomicLong
 import java.util.concurrent.atomic.AtomicInteger
 import java.util.concurrent.TimeUnit
 
-import javax.transaction.{TransactionManager, UserTransaction, Status}
+import javax.transaction.{TransactionManager, UserTransaction, Status, TransactionSynchronizationRegistry}
 
 import scala.collection.mutable.HashMap
 
@@ -305,7 +305,7 @@ object Transaction {
   private[this] val persistentStateMap = new HashMap[String, Committable]
   private[akka] val depth = new AtomicInteger(0)
   
-  val tc: Option[TransactionContainer] =
+  val jta: Option[TransactionContainer] =
     if (JTA_AWARE) Some(TransactionContainer())
     else None
   
@@ -314,7 +314,16 @@ object Transaction {
   // --- public methods ---------
 
   def begin = synchronized {
-    tc.foreach(_.begin)
+    jta.foreach { txContainer => 
+      txContainer.begin
+      TransactionContainer.findSynchronizationRegistry match {
+        case Some(registry) => 
+          registry.asInstanceOf[TransactionSynchronizationRegistry].registerInterposedSynchronization(
+            new StmSynchronization(txContainer, this))
+        case None =>           
+          log.warning("Cannot find TransactionSynchronizationRegistry in JNDI, can't register STM synchronization")
+      }
+    }
   }
   
   def commit = synchronized {
@@ -323,12 +332,12 @@ object Transaction {
       persistentStateMap.valuesIterator.foreach(_.commit)
     }
     status = TransactionStatus.Completed
-    tc.foreach(_.commit)
+    jta.foreach(_.commit)
   }
 
   def abort = synchronized {
     log.trace("Aborting transaction %s", toString)
-    tc.foreach(_.rollback)
+    jta.foreach(_.rollback)
   }
 
   def isNew = synchronized { status == TransactionStatus.New }
diff --git a/akka-core/src/main/scala/stm/TransactionContainer.scala b/akka-core/src/main/scala/stm/TransactionContainer.scala
deleted file mode 100644
index 09da21a494..0000000000
--- a/akka-core/src/main/scala/stm/TransactionContainer.scala
+++ /dev/null
@@ -1,154 +0,0 @@
-/**
- * Copyright (C) 2009-2010 Scalable Solutions AB <http://scalablesolutions.se>
- */
-
-package se.scalablesolutions.akka.stm
-
-import javax.transaction.{TransactionManager, UserTransaction, Transaction => JtaTransaction, SystemException, Status}
-import javax.naming.{InitialContext, Context, NamingException}
-
-import se.scalablesolutions.akka.config.Config._
-import se.scalablesolutions.akka.util.Logging
-
-/**
- * JTA transaction container holding either a UserTransaction or a TransactionManager.
- * <p/>
- * The TransactionContainer is created using the factory <tt>val container = TransactionContainer()</tt>
- * 
- * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
- */
-class TransactionContainer private (val tm: Either[Option[UserTransaction], Option[TransactionManager]]) {
- 
-  def begin = tm match {
-    case Left(Some(userTx)) => userTx.begin
-    case Right(Some(txMan)) => txMan.begin
-    case _ => throw new IllegalStateException("Does not have a UserTransaction or TransactionManager in scope")
-  }
-  
-  def commit = tm match {
-    case Left(Some(userTx)) => userTx.commit
-    case Right(Some(txMan)) => txMan.commit
-    case _ => throw new IllegalStateException("Does not have a UserTransaction or TransactionManager in scope")
-  }
-  
-  def rollback =  tm match {
-    case Left(Some(userTx)) => userTx.rollback
-    case Right(Some(txMan)) => txMan.rollback
-    case _ => throw new IllegalStateException("Does not have a UserTransaction or TransactionManager in scope")
-  }
-  
-  def getStatus = tm match {
-    case Left(Some(userTx)) => userTx.getStatus
-    case Right(Some(txMan)) => txMan.getStatus
-    case _ => throw new IllegalStateException("Does not have a UserTransaction or TransactionManager in scope")
-  }
-  
-  def isInExistingTransaction = tm match {
-    case Left(Some(userTx)) => userTx.getStatus == Status.STATUS_ACTIVE
-    case Right(Some(txMan)) => txMan.getStatus == Status.STATUS_ACTIVE
-    case _ => throw new IllegalStateException("Does not have a UserTransaction or TransactionManager in scope")
-  }
-
-  def isRollbackOnly = tm match {
-    case Left(Some(userTx)) => userTx.getStatus == Status.STATUS_MARKED_ROLLBACK
-    case Right(Some(txMan)) => txMan.getStatus == Status.STATUS_MARKED_ROLLBACK
-    case _ => throw new IllegalStateException("Does not have a UserTransaction or TransactionManager in scope")
-  }
-  
-  def setRollbackOnly = tm match {
-    case Left(Some(userTx)) => userTx.setRollbackOnly
-    case Right(Some(txMan)) => txMan.setRollbackOnly
-    case _ => throw new IllegalStateException("Does not have a UserTransaction or TransactionManager in scope")
-  }
-
-  def suspend = tm match {
-    case Right(Some(txMan)) => txMan.suspend
-    case _ => throw new IllegalStateException("Does not have a TransactionManager in scope")
-  }
-  
-  def resume(tx: JtaTransaction) = tm match {
-    case Right(Some(txMan)) => txMan.resume(tx)
-    case _ => throw new IllegalStateException("Does not have a TransactionManager in scope")
-  }
-}
-
-/**
- * Detects if there is a UserTransaction or TransactionManager available in the JNDI.
- * 
- * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
- */
-object TransactionContainer extends Logging {
-  val AKKA_JTA_TRANSACTION_SERVICE_CLASS = "se.scalablesolutions.akka.jta.AtomikosTransactionService"
-  val DEFAULT_USER_TRANSACTION_NAME =                     "java:comp/UserTransaction"
-  val FALLBACK_TRANSACTION_MANAGER_NAMES =                "java:comp/TransactionManager" :: 
-                                                          "java:appserver/TransactionManager" ::
-                                                          "java:pm/TransactionManager" ::
-                                                          "java:/TransactionManager" :: Nil
-  val DEFAULT_TRANSACTION_SYNCHRONIZATION_REGISTRY_NAME = "java:comp/TransactionSynchronizationRegistry"
-  val TRANSACTION_SYNCHRONIZATION_REGISTRY_CLASS_NAME =   "javax.transaction.TransactionSynchronizationRegistry"
-  val JTA_PROVIDER = config.getString("akka.jta.provider", "from-jndi")
-
-  def apply(tm: Either[Option[UserTransaction], Option[TransactionManager]]) = new TransactionContainer(tm)
-  
-  def apply(): TransactionContainer =
-    JTA_PROVIDER match {
-      case "from-jndi" => 
-        new TransactionContainer(findUserTransaction match {
-          case None => Right(findTransactionManager)
-          case tm =>   Left(tm)
-        })
-      case "atomikos" =>
-        try {
-          Class.forName(AKKA_JTA_TRANSACTION_SERVICE_CLASS)
-               .newInstance.asInstanceOf[TransactionService]
-               .transactionContainer
-        } catch {
-          case e: ClassNotFoundException => 
-            throw new IllegalStateException(
-              "JTA provider defined as 'atomikos', but the AtomikosTransactionService classes can not be found." + 
-              "\n\tPlease make sure you have 'akka-jta' JAR and its dependencies on your classpath.")
-        }
-      case _ => 
-        throw new IllegalStateException(
-        "No UserTransaction on TransactionManager could be found in scope." +
-        "\n\tEither add 'akka-jta' to the classpath or make sure there is a" + 
-        "\n\tTransactionManager or UserTransaction defined in the JNDI.")
-      
-    }
-  
-  def findUserTransaction: Option[UserTransaction] = {
-    val located = createInitialContext.lookup(DEFAULT_USER_TRANSACTION_NAME)
-    if (located eq null) None
-    else {
-      log.info("JTA UserTransaction detected [%s]", located)
-      Some(located.asInstanceOf[UserTransaction])
-    }
-  }
-
-  def findTransactionManager: Option[TransactionManager] = {
-    val context = createInitialContext
-    val tms = for {
-      name <- FALLBACK_TRANSACTION_MANAGER_NAMES
-      tm = context.lookup(name)
-      if tm ne null
-    } yield tm
-    tms match {
-      case Nil => None
-      case tm :: _ =>
-        log.info("JTA TransactionManager detected [%s]", tm)
-        Some(tm.asInstanceOf[TransactionManager])
-    }
-  }
-
-  private def createInitialContext = new InitialContext(new java.util.Hashtable)
-}
-
-/**
- * JTA Transaction service.
- *
- * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
- */
-trait TransactionService {
-  def transactionContainer: TransactionContainer  
-}
-

From 1d329247183ae957f9f6f483ccf5ff36a4ed68dd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonas=20Bon=C3=A9r?= <jonasremove@jonasboner.com>
Date: Tue, 20 Apr 2010 14:53:45 +0200
Subject: [PATCH 29/41] Added STM Synchronization registration to JNDI
 TransactionSynchronizationRegistry

---
 .../{TransactionContainer.scala => JTA.scala} | 163 +++++++++++-------
 .../src/main/scala/stm/Transaction.scala      |  19 +-
 2 files changed, 112 insertions(+), 70 deletions(-)
 rename akka-core/src/main/scala/stm/{TransactionContainer.scala => JTA.scala} (81%)

diff --git a/akka-core/src/main/scala/stm/TransactionContainer.scala b/akka-core/src/main/scala/stm/JTA.scala
similarity index 81%
rename from akka-core/src/main/scala/stm/TransactionContainer.scala
rename to akka-core/src/main/scala/stm/JTA.scala
index 09da21a494..5be0460681 100644
--- a/akka-core/src/main/scala/stm/TransactionContainer.scala
+++ b/akka-core/src/main/scala/stm/JTA.scala
@@ -4,12 +4,98 @@
 
 package se.scalablesolutions.akka.stm
 
-import javax.transaction.{TransactionManager, UserTransaction, Transaction => JtaTransaction, SystemException, Status}
+import javax.transaction.{TransactionManager, UserTransaction, Transaction => JtaTransaction, SystemException, Status, Synchronization, TransactionSynchronizationRegistry}
 import javax.naming.{InitialContext, Context, NamingException}
 
 import se.scalablesolutions.akka.config.Config._
 import se.scalablesolutions.akka.util.Logging
 
+/**
+ * Detects if there is a UserTransaction or TransactionManager available in the JNDI.
+ * 
+ * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
+ */
+object TransactionContainer extends Logging {
+  val AKKA_JTA_TRANSACTION_SERVICE_CLASS = "se.scalablesolutions.akka.jta.AtomikosTransactionService"
+  val DEFAULT_USER_TRANSACTION_NAME =                     "java:comp/UserTransaction"
+  val FALLBACK_TRANSACTION_MANAGER_NAMES =                "java:comp/TransactionManager" :: 
+                                                          "java:appserver/TransactionManager" ::
+                                                          "java:pm/TransactionManager" ::
+                                                          "java:/TransactionManager" :: Nil
+  val DEFAULT_TRANSACTION_SYNCHRONIZATION_REGISTRY_NAME = "java:comp/TransactionSynchronizationRegistry"
+
+  val JTA_PROVIDER = config.getString("akka.jta.provider", "from-jndi")
+
+  private var synchronizationRegistry: Option[TransactionSynchronizationRegistry] = None
+  
+  def apply(tm: Either[Option[UserTransaction], Option[TransactionManager]]) = new TransactionContainer(tm)
+  
+  def apply(): TransactionContainer =
+    JTA_PROVIDER match {
+      case "from-jndi" => 
+        new TransactionContainer(findUserTransaction match {
+          case None => Right(findTransactionManager)
+          case tm =>   Left(tm)
+        })
+      case "atomikos" =>
+        try {
+          Class.forName(AKKA_JTA_TRANSACTION_SERVICE_CLASS)
+               .newInstance.asInstanceOf[TransactionService]
+               .transactionContainer
+        } catch {
+          case e: ClassNotFoundException => 
+            throw new IllegalStateException(
+              "JTA provider defined as 'atomikos', but the AtomikosTransactionService classes can not be found." + 
+              "\n\tPlease make sure you have 'akka-jta' JAR and its dependencies on your classpath.")
+        }
+      case _ => 
+        throw new IllegalStateException(
+        "No UserTransaction on TransactionManager could be found in scope." +
+        "\n\tEither add 'akka-jta' to the classpath or make sure there is a" + 
+        "\n\tTransactionManager or UserTransaction defined in the JNDI.")
+      
+    }
+  
+  def findUserTransaction: Option[UserTransaction] = {
+    val located = createInitialContext.lookup(DEFAULT_USER_TRANSACTION_NAME)
+    if (located eq null) None
+    else {
+      log.info("JTA UserTransaction detected [%s]", located)
+      Some(located.asInstanceOf[UserTransaction])
+    }
+  }
+
+  def findSynchronizationRegistry: Option[TransactionSynchronizationRegistry] = synchronized {
+    if (synchronizationRegistry.isDefined) synchronizationRegistry
+    else {
+      val located = createInitialContext.lookup(DEFAULT_TRANSACTION_SYNCHRONIZATION_REGISTRY_NAME)
+      if (located eq null) None
+      else {
+        log.info("JTA TransactionSynchronizationRegistry detected [%s]", located)
+        synchronizationRegistry = Some(located.asInstanceOf[TransactionSynchronizationRegistry])
+        synchronizationRegistry
+      }      
+    }
+  }
+
+  def findTransactionManager: Option[TransactionManager] = {
+    val context = createInitialContext
+    val tms = for {
+      name <- FALLBACK_TRANSACTION_MANAGER_NAMES
+      tm = context.lookup(name)
+      if tm ne null
+    } yield tm
+    tms match {
+      case Nil => None
+      case tm :: _ =>
+        log.info("JTA TransactionManager detected [%s]", tm)
+        Some(tm.asInstanceOf[TransactionManager])
+    }
+  }
+
+  private def createInitialContext = new InitialContext(new java.util.Hashtable)
+}
+
 /**
  * JTA transaction container holding either a UserTransaction or a TransactionManager.
  * <p/>
@@ -18,7 +104,6 @@ import se.scalablesolutions.akka.util.Logging
  * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
  */
 class TransactionContainer private (val tm: Either[Option[UserTransaction], Option[TransactionManager]]) {
- 
   def begin = tm match {
     case Left(Some(userTx)) => userTx.begin
     case Right(Some(txMan)) => txMan.begin
@@ -73,74 +158,22 @@ class TransactionContainer private (val tm: Either[Option[UserTransaction], Opti
 }
 
 /**
- * Detects if there is a UserTransaction or TransactionManager available in the JNDI.
- * 
+ * STM Synchronization class for synchronizing with the JTA TransactionManager.
+ *
  * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
  */
-object TransactionContainer extends Logging {
-  val AKKA_JTA_TRANSACTION_SERVICE_CLASS = "se.scalablesolutions.akka.jta.AtomikosTransactionService"
-  val DEFAULT_USER_TRANSACTION_NAME =                     "java:comp/UserTransaction"
-  val FALLBACK_TRANSACTION_MANAGER_NAMES =                "java:comp/TransactionManager" :: 
-                                                          "java:appserver/TransactionManager" ::
-                                                          "java:pm/TransactionManager" ::
-                                                          "java:/TransactionManager" :: Nil
-  val DEFAULT_TRANSACTION_SYNCHRONIZATION_REGISTRY_NAME = "java:comp/TransactionSynchronizationRegistry"
-  val TRANSACTION_SYNCHRONIZATION_REGISTRY_CLASS_NAME =   "javax.transaction.TransactionSynchronizationRegistry"
-  val JTA_PROVIDER = config.getString("akka.jta.provider", "from-jndi")
-
-  def apply(tm: Either[Option[UserTransaction], Option[TransactionManager]]) = new TransactionContainer(tm)
-  
-  def apply(): TransactionContainer =
-    JTA_PROVIDER match {
-      case "from-jndi" => 
-        new TransactionContainer(findUserTransaction match {
-          case None => Right(findTransactionManager)
-          case tm =>   Left(tm)
-        })
-      case "atomikos" =>
-        try {
-          Class.forName(AKKA_JTA_TRANSACTION_SERVICE_CLASS)
-               .newInstance.asInstanceOf[TransactionService]
-               .transactionContainer
-        } catch {
-          case e: ClassNotFoundException => 
-            throw new IllegalStateException(
-              "JTA provider defined as 'atomikos', but the AtomikosTransactionService classes can not be found." + 
-              "\n\tPlease make sure you have 'akka-jta' JAR and its dependencies on your classpath.")
-        }
-      case _ => 
-        throw new IllegalStateException(
-        "No UserTransaction on TransactionManager could be found in scope." +
-        "\n\tEither add 'akka-jta' to the classpath or make sure there is a" + 
-        "\n\tTransactionManager or UserTransaction defined in the JNDI.")
-      
-    }
-  
-  def findUserTransaction: Option[UserTransaction] = {
-    val located = createInitialContext.lookup(DEFAULT_USER_TRANSACTION_NAME)
-    if (located eq null) None
-    else {
-      log.info("JTA UserTransaction detected [%s]", located)
-      Some(located.asInstanceOf[UserTransaction])
+class StmSynchronization(tc: TransactionContainer, tx: Transaction) extends Synchronization with Logging {
+  def beforeCompletion = {
+    val status = tc.getStatus
+    if (status != Status.STATUS_ROLLEDBACK &&
+        status != Status.STATUS_ROLLING_BACK &&
+        status != Status.STATUS_MARKED_ROLLBACK) {
+      log.debug("JTA transaction has failed, abort STM transaction")
+      tx.transaction.foreach(_.abort) // abort multiverse tx
     }
   }
 
-  def findTransactionManager: Option[TransactionManager] = {
-    val context = createInitialContext
-    val tms = for {
-      name <- FALLBACK_TRANSACTION_MANAGER_NAMES
-      tm = context.lookup(name)
-      if tm ne null
-    } yield tm
-    tms match {
-      case Nil => None
-      case tm :: _ =>
-        log.info("JTA TransactionManager detected [%s]", tm)
-        Some(tm.asInstanceOf[TransactionManager])
-    }
-  }
-
-  private def createInitialContext = new InitialContext(new java.util.Hashtable)
+  def afterCompletion(status: Int) = {}
 }
 
 /**
diff --git a/akka-core/src/main/scala/stm/Transaction.scala b/akka-core/src/main/scala/stm/Transaction.scala
index 7fbe9898e6..97d588f400 100644
--- a/akka-core/src/main/scala/stm/Transaction.scala
+++ b/akka-core/src/main/scala/stm/Transaction.scala
@@ -8,7 +8,7 @@ import java.util.concurrent.atomic.AtomicLong
 import java.util.concurrent.atomic.AtomicInteger
 import java.util.concurrent.TimeUnit
 
-import javax.transaction.{TransactionManager, UserTransaction, Status}
+import javax.transaction.{TransactionManager, UserTransaction, Status, TransactionSynchronizationRegistry}
 
 import scala.collection.mutable.HashMap
 
@@ -305,7 +305,7 @@ object Transaction {
   private[this] val persistentStateMap = new HashMap[String, Committable]
   private[akka] val depth = new AtomicInteger(0)
   
-  val tc: Option[TransactionContainer] =
+  val jta: Option[TransactionContainer] =
     if (JTA_AWARE) Some(TransactionContainer())
     else None
   
@@ -314,7 +314,16 @@ object Transaction {
   // --- public methods ---------
 
   def begin = synchronized {
-    tc.foreach(_.begin)
+    jta.foreach { txContainer => 
+      txContainer.begin
+      TransactionContainer.findSynchronizationRegistry match {
+        case Some(registry) => 
+          registry.asInstanceOf[TransactionSynchronizationRegistry].registerInterposedSynchronization(
+            new StmSynchronization(txContainer, this))
+        case None =>           
+          log.warning("Cannot find TransactionSynchronizationRegistry in JNDI, can't register STM synchronization")
+      }
+    }
   }
   
   def commit = synchronized {
@@ -323,12 +332,12 @@ object Transaction {
       persistentStateMap.valuesIterator.foreach(_.commit)
     }
     status = TransactionStatus.Completed
-    tc.foreach(_.commit)
+    jta.foreach(_.commit)
   }
 
   def abort = synchronized {
     log.trace("Aborting transaction %s", toString)
-    tc.foreach(_.rollback)
+    jta.foreach(_.rollback)
   }
 
   def isNew = synchronized { status == TransactionStatus.New }

From 011898b96d070b44d5a6f89716d576572344d1a1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonas=20Bon=C3=A9r?= <jonasremove@jonasboner.com>
Date: Wed, 21 Apr 2010 11:18:07 +0200
Subject: [PATCH 30/41] Made JTA Synchronization management generic and
 allowing more than one + refactoring

---
 akka-core/src/main/scala/stm/JTA.scala        | 15 +++++++
 .../src/main/scala/stm/Transaction.scala      |  8 +---
 .../src/main/scala/TransactionContext.scala   | 44 +++++++++++++++++--
 .../src/main/scala/TransactionProtocol.scala  | 42 ++++++------------
 4 files changed, 70 insertions(+), 39 deletions(-)

diff --git a/akka-core/src/main/scala/stm/JTA.scala b/akka-core/src/main/scala/stm/JTA.scala
index 5be0460681..510e9cf78c 100644
--- a/akka-core/src/main/scala/stm/JTA.scala
+++ b/akka-core/src/main/scala/stm/JTA.scala
@@ -104,6 +104,21 @@ object TransactionContainer extends Logging {
  * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
  */
 class TransactionContainer private (val tm: Either[Option[UserTransaction], Option[TransactionManager]]) {
+
+  def registerSynchronization(sync: Synchronization) = {
+    TransactionContainer.findSynchronizationRegistry match { // try to use SynchronizationRegistry in JNDI
+      case Some(registry) => 
+        registry.asInstanceOf[TransactionSynchronizationRegistry].registerInterposedSynchronization(sync)
+      case None =>
+        tm match {
+          case Right(Some(txMan)) => // try to use TransactionManager
+            txMan.getTransaction.registerSynchronization(sync)
+          case _ =>
+            log.warning("Cannot find TransactionSynchronizationRegistry in JNDI, can't register STM synchronization")          
+        }
+    }
+  }
+  
   def begin = tm match {
     case Left(Some(userTx)) => userTx.begin
     case Right(Some(txMan)) => txMan.begin
diff --git a/akka-core/src/main/scala/stm/Transaction.scala b/akka-core/src/main/scala/stm/Transaction.scala
index 97d588f400..37b38b670b 100644
--- a/akka-core/src/main/scala/stm/Transaction.scala
+++ b/akka-core/src/main/scala/stm/Transaction.scala
@@ -316,13 +316,7 @@ object Transaction {
   def begin = synchronized {
     jta.foreach { txContainer => 
       txContainer.begin
-      TransactionContainer.findSynchronizationRegistry match {
-        case Some(registry) => 
-          registry.asInstanceOf[TransactionSynchronizationRegistry].registerInterposedSynchronization(
-            new StmSynchronization(txContainer, this))
-        case None =>           
-          log.warning("Cannot find TransactionSynchronizationRegistry in JNDI, can't register STM synchronization")
-      }
+      txContainer.registerSynchronization(new StmSynchronization(txContainer, this))
     }
   }
   
diff --git a/akka-jta/src/main/scala/TransactionContext.scala b/akka-jta/src/main/scala/TransactionContext.scala
index 43d2c082d8..b2574dd478 100644
--- a/akka-jta/src/main/scala/TransactionContext.scala
+++ b/akka-jta/src/main/scala/TransactionContext.scala
@@ -4,7 +4,7 @@
 
 package se.scalablesolutions.akka.jta
 
-import javax.transaction.{Transaction, Status, TransactionManager}
+import javax.transaction.{Transaction, Status, TransactionManager, Synchronization}
 
 import se.scalablesolutions.akka.stm.{TransactionService, TransactionContainer}
 import se.scalablesolutions.akka.util.Logging
@@ -56,6 +56,41 @@ object TransactionContext extends TransactionProtocol with Logging {
   implicit val tc = TransactionContainer()                    
   private[TransactionContext] val stack = new scala.util.DynamicVariable(new TransactionContext(tc))
 
+  /**
+   * This method can be used to register a Synchronization instance for participating with the JTA transaction.
+   * Here is an example of how to add a JPA EntityManager integration.
+   * <pre>
+   *   TransactionContext.registerSynchronization(new javax.transaction.Synchronization() {
+   *     def beforeCompletion = {
+   *       try {
+   *         val status = tm.getStatus
+   *         if (status != Status.STATUS_ROLLEDBACK &&
+   *             status != Status.STATUS_ROLLING_BACK &&
+   *             status != Status.STATUS_MARKED_ROLLBACK) {
+   *           log.debug("Flushing EntityManager...") 
+   *           em.flush // flush EntityManager on success
+   *         }
+   *       } catch {
+   *         case e: javax.transaction.SystemException => throw new RuntimeException(e)
+   *       }
+   *     }
+   *
+   *     def afterCompletion(status: Int) = {
+   *       val status = tm.getStatus
+   *       if (closeAtTxCompletion) em.close
+   *       if (status == Status.STATUS_ROLLEDBACK ||
+   *           status == Status.STATUS_ROLLING_BACK ||
+   *           status == Status.STATUS_MARKED_ROLLBACK) {
+   *         em.close
+   *       }
+   *     }
+   *   })
+   * </pre>
+   * You should also override the 'joinTransaction' and 'handleException' methods. 
+   * See ScalaDoc for these methods in the 'TransactionProtocol' for details. 
+   */
+  def registerSynchronization(sync: Synchronization) = synchronization.add(sync)
+  
   object Required extends TransactionMonad {
     def map[T](f: TransactionMonad => T): T =        withTxRequired { f(this) }
     def flatMap[T](f: TransactionMonad => T): T =    withTxRequired { f(this) }
@@ -170,7 +205,8 @@ trait TransactionMonad {
  * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
  */
 class TransactionContext(val tc: TransactionContainer) {
-  private def setRollbackOnly = tc.setRollbackOnly
-  private def isRollbackOnly: Boolean = tc.getStatus == Status.STATUS_MARKED_ROLLBACK
-  private def getTransactionContainer: TransactionContainer = tc
+  def registerSynchronization(sync: Synchronization) = TransactionContext.registerSynchronization(sync)
+  def setRollbackOnly = tc.setRollbackOnly
+  def isRollbackOnly: Boolean = tc.getStatus == Status.STATUS_MARKED_ROLLBACK
+  def getTransactionContainer: TransactionContainer = tc
 }
diff --git a/akka-jta/src/main/scala/TransactionProtocol.scala b/akka-jta/src/main/scala/TransactionProtocol.scala
index 2036f0d013..004cf99657 100644
--- a/akka-jta/src/main/scala/TransactionProtocol.scala
+++ b/akka-jta/src/main/scala/TransactionProtocol.scala
@@ -7,6 +7,9 @@ package se.scalablesolutions.akka.jta
 import se.scalablesolutions.akka.util.Logging
 import se.scalablesolutions.akka.stm.TransactionContainer
 
+import java.util.{List => JList}
+import java.util.concurrent.CopyOnWriteArrayList
+
 import javax.naming.{NamingException, Context, InitialContext}
 import javax.transaction.{
   Transaction,
@@ -15,6 +18,7 @@ import javax.transaction.{
   Status,
   RollbackException,
   SystemException,
+  Synchronization,
   TransactionRequiredException
 }
 
@@ -62,6 +66,8 @@ import javax.transaction.{
  * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
  */
 trait TransactionProtocol extends Logging {
+  
+  protected val synchronization: JList[Synchronization] = new CopyOnWriteArrayList[Synchronization]
 
   /**
    * Join JTA transaction. Can be overriden by concrete transaction service implementation
@@ -71,36 +77,10 @@ trait TransactionProtocol extends Logging {
    * 
    * <pre>
    * override def joinTransaction = {
-   *   val em = TransactionContext.getEntityManager
-   *   val tm = TransactionContext.getTransactionContainer
-   *   val closeAtTxCompletion: Boolean) 
-   *   tm.getTransaction.registerSynchronization(new javax.transaction.Synchronization() {
-   *     def beforeCompletion = {
-   *       try {
-   *         val status = tm.getStatus
-   *         if (status != Status.STATUS_ROLLEDBACK &&
-   *             status != Status.STATUS_ROLLING_BACK &&
-   *             status != Status.STATUS_MARKED_ROLLBACK) {
-   *           log.debug("Flushing EntityManager...") 
-   *           em.flush // flush EntityManager on success
-   *         }
-   *       } catch {
-   *         case e: javax.transaction.SystemException => throw new RuntimeException(e)
-   *       }
-   *     }
-   *
-   *     def afterCompletion(status: Int) = {
-   *       val status = tm.getStatus
-   *       if (closeAtTxCompletion) em.close
-   *       if (status == Status.STATUS_ROLLEDBACK ||
-   *           status == Status.STATUS_ROLLING_BACK ||
-   *           status == Status.STATUS_MARKED_ROLLBACK) {
-   *         em.close
-   *       }
-   *     }
-   *   })
+   *   val em: EntityManager = ... // get the EntityManager
    *   em.joinTransaction // join JTA transaction
    * }
+   * </pre>
    */
   def joinTransaction: Unit = {}
 
@@ -137,6 +117,7 @@ trait TransactionProtocol extends Logging {
     val tm = TransactionContext.getTransactionContainer
     if (!isInExistingTransaction(tm)) {
       tm.begin
+      registerSynchronization
       try {
         joinTransaction
         body
@@ -157,6 +138,7 @@ trait TransactionProtocol extends Logging {
   def withTxRequiresNew[T](body: => T): T = TransactionContext.withNewContext {
     val tm = TransactionContext.getTransactionContainer
     tm.begin
+    registerSynchronization
     try {
       joinTransaction
       body
@@ -224,6 +206,10 @@ trait TransactionProtocol extends Logging {
   // Helper methods
   // ---------------------------
 
+  protected def registerSynchronization = {
+    val it = synchronization.iterator
+    while (it.hasNext) TransactionContext.getTransactionContainer.registerSynchronization(it.next)
+  }
   /**
    * Checks if a transaction is an existing transaction.
    *

From 68bb4af726d2c6eab2ff86a13320e522a0471b82 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonas=20Bon=C3=A9r?= <jonasremove@jonasboner.com>
Date: Wed, 21 Apr 2010 11:23:30 +0200
Subject: [PATCH 31/41] Moved ActiveObjectConfiguration to ActiveObject.scala
 file

---
 .../src/main/scala/actor/ActiveObject.scala   | 39 ++++++++++++++++++-
 .../actor/ActiveObjectConfiguration.scala     | 39 -------------------
 2 files changed, 38 insertions(+), 40 deletions(-)
 delete mode 100644 akka-core/src/main/scala/actor/ActiveObjectConfiguration.scala

diff --git a/akka-core/src/main/scala/actor/ActiveObject.scala b/akka-core/src/main/scala/actor/ActiveObject.scala
index 2446472e0e..9dbe1c939d 100644
--- a/akka-core/src/main/scala/actor/ActiveObject.scala
+++ b/akka-core/src/main/scala/actor/ActiveObject.scala
@@ -4,7 +4,7 @@
 
 package se.scalablesolutions.akka.actor
 
-import _root_.se.scalablesolutions.akka.config.FaultHandlingStrategy
+import se.scalablesolutions.akka.config.FaultHandlingStrategy
 import se.scalablesolutions.akka.remote.protobuf.RemoteProtocol.RemoteRequest
 import se.scalablesolutions.akka.remote.{RemoteProtocolBuilder, RemoteClient, RemoteRequestIdFactory}
 import se.scalablesolutions.akka.dispatch.{MessageDispatcher, Future}
@@ -29,6 +29,43 @@ object Annotations {
   val inittransactionalstate = classOf[inittransactionalstate]
 }
 
+/**
+ * TODO: document
+ * FIXDOC: document ActiveObjectConfiguration
+ */
+final class ActiveObjectConfiguration {
+  private[akka] var _timeout: Long = Actor.TIMEOUT
+  private[akka] var _restartCallbacks: Option[RestartCallbacks] = None
+  private[akka] var _transactionRequired = false
+  private[akka] var _host: Option[InetSocketAddress] = None
+  private[akka] var _messageDispatcher: Option[MessageDispatcher] = None
+
+  def timeout(timeout: Long) : ActiveObjectConfiguration = {
+    _timeout = timeout
+    this
+  }
+
+  def restartCallbacks(pre: String, post: String) : ActiveObjectConfiguration = {
+    _restartCallbacks = Some(new RestartCallbacks(pre, post))
+    this
+  }
+
+  def makeTransactionRequired() : ActiveObjectConfiguration = {
+    _transactionRequired = true;
+    this
+  }
+
+  def makeRemote(hostname: String, port: Int) : ActiveObjectConfiguration = {
+    _host = Some(new InetSocketAddress(hostname, port))
+    this
+  }
+
+  def dispatcher(messageDispatcher: MessageDispatcher) : ActiveObjectConfiguration = {
+    _messageDispatcher = Some(messageDispatcher)
+    this
+  }
+}
+
 /**
  * Factory class for creating Active Objects out of plain POJOs and/or POJOs with interfaces.
  *
diff --git a/akka-core/src/main/scala/actor/ActiveObjectConfiguration.scala b/akka-core/src/main/scala/actor/ActiveObjectConfiguration.scala
deleted file mode 100644
index 8390d2bdbb..0000000000
--- a/akka-core/src/main/scala/actor/ActiveObjectConfiguration.scala
+++ /dev/null
@@ -1,39 +0,0 @@
-package se.scalablesolutions.akka.actor
-
-import _root_.java.net.InetSocketAddress
-import _root_.se.scalablesolutions.akka.config.ScalaConfig.RestartCallbacks
-import _root_.se.scalablesolutions.akka.dispatch.MessageDispatcher
-
-
-final class ActiveObjectConfiguration {
-  private[akka] var _timeout: Long = Actor.TIMEOUT
-  private[akka] var _restartCallbacks: Option[RestartCallbacks] = None
-  private[akka] var _transactionRequired = false
-  private[akka] var _host: Option[InetSocketAddress] = None
-  private[akka] var _messageDispatcher: Option[MessageDispatcher] = None
-
-  def timeout(timeout: Long) : ActiveObjectConfiguration = {
-    _timeout = timeout
-    this
-  }
-
-  def restartCallbacks(pre: String, post: String) : ActiveObjectConfiguration = {
-    _restartCallbacks = Some(new RestartCallbacks(pre, post))
-    this
-  }
-
-  def makeTransactionRequired() : ActiveObjectConfiguration = {
-    _transactionRequired = true;
-    this
-  }
-
-  def makeRemote(hostname: String, port: Int) : ActiveObjectConfiguration = {
-    _host = Some(new InetSocketAddress(hostname, port))
-    this
-  }
-
-  def dispatcher(messageDispatcher: MessageDispatcher) : ActiveObjectConfiguration = {
-    _messageDispatcher = Some(messageDispatcher)
-    this
-  }
-}
\ No newline at end of file

From 70087d5d9a3bbcd3c27c672066af66fda0c00170 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonas=20Bon=C3=A9r?= <jonasremove@jonasboner.com>
Date: Wed, 21 Apr 2010 15:37:51 +0200
Subject: [PATCH 32/41] added scaladoc

---
 akka-core/src/main/scala/actor/ActiveObject.scala | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/akka-core/src/main/scala/actor/ActiveObject.scala b/akka-core/src/main/scala/actor/ActiveObject.scala
index 9dbe1c939d..f3c536fdf8 100644
--- a/akka-core/src/main/scala/actor/ActiveObject.scala
+++ b/akka-core/src/main/scala/actor/ActiveObject.scala
@@ -30,7 +30,8 @@ object Annotations {
 }
 
 /**
- * TODO: document
+ * Configuration factory for Active Objects. 
+ * 
  * FIXDOC: document ActiveObjectConfiguration
  */
 final class ActiveObjectConfiguration {

From 08f835e5fbcf366ad810428aa21499f2d0412bad Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonas=20Bon=C3=A9r?= <jonasremove@jonasboner.com>
Date: Thu, 22 Apr 2010 09:53:45 +0200
Subject: [PATCH 33/41] Added StmConfigurationException

---
 .gitignore                                    |  2 +-
 akka-core/src/main/scala/stm/JTA.scala        | 22 +++++++++----------
 .../src/main/scala/stm/Transaction.scala      |  7 +++---
 .../scala/stm/TransactionManagement.scala     |  4 ++--
 4 files changed, 18 insertions(+), 17 deletions(-)

diff --git a/.gitignore b/.gitignore
index b3b2c2ebc7..45fe24daba 100755
--- a/.gitignore
+++ b/.gitignore
@@ -33,4 +33,4 @@ tm.out
 .classpath
 .idea
 .scala_dependencies
-
+multiverse.log
\ No newline at end of file
diff --git a/akka-core/src/main/scala/stm/JTA.scala b/akka-core/src/main/scala/stm/JTA.scala
index 510e9cf78c..fd2db0fc74 100644
--- a/akka-core/src/main/scala/stm/JTA.scala
+++ b/akka-core/src/main/scala/stm/JTA.scala
@@ -44,12 +44,12 @@ object TransactionContainer extends Logging {
                .transactionContainer
         } catch {
           case e: ClassNotFoundException => 
-            throw new IllegalStateException(
+            throw new StmConfigurationException(
               "JTA provider defined as 'atomikos', but the AtomikosTransactionService classes can not be found." + 
               "\n\tPlease make sure you have 'akka-jta' JAR and its dependencies on your classpath.")
         }
       case _ => 
-        throw new IllegalStateException(
+        throw new StmConfigurationException(
         "No UserTransaction on TransactionManager could be found in scope." +
         "\n\tEither add 'akka-jta' to the classpath or make sure there is a" + 
         "\n\tTransactionManager or UserTransaction defined in the JNDI.")
@@ -122,53 +122,53 @@ class TransactionContainer private (val tm: Either[Option[UserTransaction], Opti
   def begin = tm match {
     case Left(Some(userTx)) => userTx.begin
     case Right(Some(txMan)) => txMan.begin
-    case _ => throw new IllegalStateException("Does not have a UserTransaction or TransactionManager in scope")
+    case _ => throw new StmConfigurationException("Does not have a UserTransaction or TransactionManager in scope")
   }
   
   def commit = tm match {
     case Left(Some(userTx)) => userTx.commit
     case Right(Some(txMan)) => txMan.commit
-    case _ => throw new IllegalStateException("Does not have a UserTransaction or TransactionManager in scope")
+    case _ => throw new StmConfigurationException("Does not have a UserTransaction or TransactionManager in scope")
   }
   
   def rollback =  tm match {
     case Left(Some(userTx)) => userTx.rollback
     case Right(Some(txMan)) => txMan.rollback
-    case _ => throw new IllegalStateException("Does not have a UserTransaction or TransactionManager in scope")
+    case _ => throw new StmConfigurationException("Does not have a UserTransaction or TransactionManager in scope")
   }
   
   def getStatus = tm match {
     case Left(Some(userTx)) => userTx.getStatus
     case Right(Some(txMan)) => txMan.getStatus
-    case _ => throw new IllegalStateException("Does not have a UserTransaction or TransactionManager in scope")
+    case _ => throw new StmConfigurationException("Does not have a UserTransaction or TransactionManager in scope")
   }
   
   def isInExistingTransaction = tm match {
     case Left(Some(userTx)) => userTx.getStatus == Status.STATUS_ACTIVE
     case Right(Some(txMan)) => txMan.getStatus == Status.STATUS_ACTIVE
-    case _ => throw new IllegalStateException("Does not have a UserTransaction or TransactionManager in scope")
+    case _ => throw new StmConfigurationException("Does not have a UserTransaction or TransactionManager in scope")
   }
 
   def isRollbackOnly = tm match {
     case Left(Some(userTx)) => userTx.getStatus == Status.STATUS_MARKED_ROLLBACK
     case Right(Some(txMan)) => txMan.getStatus == Status.STATUS_MARKED_ROLLBACK
-    case _ => throw new IllegalStateException("Does not have a UserTransaction or TransactionManager in scope")
+    case _ => throw new StmConfigurationException("Does not have a UserTransaction or TransactionManager in scope")
   }
   
   def setRollbackOnly = tm match {
     case Left(Some(userTx)) => userTx.setRollbackOnly
     case Right(Some(txMan)) => txMan.setRollbackOnly
-    case _ => throw new IllegalStateException("Does not have a UserTransaction or TransactionManager in scope")
+    case _ => throw new StmConfigurationException("Does not have a UserTransaction or TransactionManager in scope")
   }
 
   def suspend = tm match {
     case Right(Some(txMan)) => txMan.suspend
-    case _ => throw new IllegalStateException("Does not have a TransactionManager in scope")
+    case _ => throw new StmConfigurationException("Does not have a TransactionManager in scope")
   }
   
   def resume(tx: JtaTransaction) = tm match {
     case Right(Some(txMan)) => txMan.resume(tx)
-    case _ => throw new IllegalStateException("Does not have a TransactionManager in scope")
+    case _ => throw new StmConfigurationException("Does not have a TransactionManager in scope")
   }
 }
 
diff --git a/akka-core/src/main/scala/stm/Transaction.scala b/akka-core/src/main/scala/stm/Transaction.scala
index 37b38b670b..fb9f14b62e 100644
--- a/akka-core/src/main/scala/stm/Transaction.scala
+++ b/akka-core/src/main/scala/stm/Transaction.scala
@@ -24,6 +24,7 @@ import org.multiverse.stms.alpha.AlphaStm
 
 class NoTransactionInScopeException extends RuntimeException
 class TransactionRetryException(message: String) extends RuntimeException(message)
+class StmConfigurationException(message: String) extends RuntimeException(message)
 
 /**
  * FIXDOC: document AtomicTemplate
@@ -357,17 +358,17 @@ object Transaction {
   private[akka] def register(uuid: String, storage: Committable) = persistentStateMap.put(uuid, storage)
 
   private def ensureIsActive = if (status != TransactionStatus.Active)
-    throw new IllegalStateException(
+    throw new StmConfigurationException(
       "Expected ACTIVE transaction - current status [" + status + "]: " + toString)
 
   private def ensureIsActiveOrAborted =
     if (!(status == TransactionStatus.Active || status == TransactionStatus.Aborted))
-      throw new IllegalStateException(
+      throw new StmConfigurationException(
         "Expected ACTIVE or ABORTED transaction - current status [" + status + "]: " + toString)
 
   private def ensureIsActiveOrNew =
     if (!(status == TransactionStatus.Active || status == TransactionStatus.New))
-      throw new IllegalStateException(
+      throw new StmConfigurationException(
         "Expected ACTIVE or NEW transaction - current status [" + status + "]: " + toString)
 
   // For reinitialize transaction after sending it over the wire
diff --git a/akka-core/src/main/scala/stm/TransactionManagement.scala b/akka-core/src/main/scala/stm/TransactionManagement.scala
index 371d57ad88..d551f7fd76 100644
--- a/akka-core/src/main/scala/stm/TransactionManagement.scala
+++ b/akka-core/src/main/scala/stm/TransactionManagement.scala
@@ -40,13 +40,13 @@ object TransactionManagement extends TransactionManagement {
 
   private[akka] def getTransactionSet: CountDownCommitBarrier = {
     val option = transactionSet.get
-    if ((option eq null) || option.isEmpty) throw new IllegalStateException("No Transaction set in scope")
+    if ((option eq null) || option.isEmpty) throw new StmConfigurationException("No Transaction set in scope")
     else option.get
   }
 
   private[akka] def getTransaction: Transaction = {
     val option = transaction.get
-    if ((option eq null) || option.isEmpty) throw new IllegalStateException("No Transaction in scope")
+    if ((option eq null) || option.isEmpty) throw new StmConfigurationException("No Transaction in scope")
     option.get
   }
 }

From 70256e4bb1b0ea89fc5f1f40394945ad6f25de93 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonas=20Bon=C3=A9r?= <jonasremove@jonasboner.com>
Date: Thu, 22 Apr 2010 12:18:18 +0200
Subject: [PATCH 34/41] JTA: Added option to register "joinTransaction"
 function and which classes to NOT roll back on

---
 .../src/main/scala/TransactionContext.scala   | 27 ++++++++++
 .../src/main/scala/TransactionProtocol.scala  | 51 +++++++------------
 2 files changed, 44 insertions(+), 34 deletions(-)

diff --git a/akka-jta/src/main/scala/TransactionContext.scala b/akka-jta/src/main/scala/TransactionContext.scala
index b2574dd478..e6ac00de8b 100644
--- a/akka-jta/src/main/scala/TransactionContext.scala
+++ b/akka-jta/src/main/scala/TransactionContext.scala
@@ -54,6 +54,7 @@ import se.scalablesolutions.akka.config.Config._
  */
 object TransactionContext extends TransactionProtocol with Logging {
   implicit val tc = TransactionContainer()                    
+
   private[TransactionContext] val stack = new scala.util.DynamicVariable(new TransactionContext(tc))
 
   /**
@@ -91,6 +92,32 @@ object TransactionContext extends TransactionProtocol with Logging {
    */
   def registerSynchronization(sync: Synchronization) = synchronization.add(sync)
   
+  /**
+   * Registeres a join transaction function.
+   * <p/>
+   * Here is an example on how to integrate with JPA EntityManager.
+   * 
+   * <pre>
+   * TransactionContext.registerJoinTransactionFun(() => {
+   *   val em: EntityManager = ... // get the EntityManager
+   *   em.joinTransaction // join JTA transaction
+   * })
+   * </pre>
+   */
+  def registerJoinTransactionFun(fn: () => Unit) = joinTransactionFuns.add(fn)
+  
+  /**
+   * Handle exception. Can be overriden by concrete transaction service implementation.
+   * <p/>
+   * Here is an example on how to handle JPA exceptions.
+   * 
+   * <pre>
+   * TransactionContext.registerExceptionNotToRollbackOn(classOf[NoResultException])
+   * TransactionContext.registerExceptionNotToRollbackOn(classOf[NonUniqueResultException])
+   * </pre>
+   */
+  def registerExceptionNotToRollbackOn(e: Class[_ <: Exception]) = exceptionsNotToRollbackOn.add(e)
+
   object Required extends TransactionMonad {
     def map[T](f: TransactionMonad => T): T =        withTxRequired { f(this) }
     def flatMap[T](f: TransactionMonad => T): T =    withTxRequired { f(this) }
diff --git a/akka-jta/src/main/scala/TransactionProtocol.scala b/akka-jta/src/main/scala/TransactionProtocol.scala
index 004cf99657..c23ec26fd7 100644
--- a/akka-jta/src/main/scala/TransactionProtocol.scala
+++ b/akka-jta/src/main/scala/TransactionProtocol.scala
@@ -68,43 +68,26 @@ import javax.transaction.{
 trait TransactionProtocol extends Logging {
   
   protected val synchronization: JList[Synchronization] = new CopyOnWriteArrayList[Synchronization]
+  protected val joinTransactionFuns: JList[() => Unit] = new CopyOnWriteArrayList[() => Unit]
+  protected val exceptionsNotToRollbackOn: JList[Class[_ <: Exception]] = new CopyOnWriteArrayList[Class[_ <: Exception]]
 
-  /**
-   * Join JTA transaction. Can be overriden by concrete transaction service implementation
-   * to hook into other transaction services.
-   * <p/>
-   * Here is an example on how to integrate with JPA EntityManager.
-   * 
-   * <pre>
-   * override def joinTransaction = {
-   *   val em: EntityManager = ... // get the EntityManager
-   *   em.joinTransaction // join JTA transaction
-   * }
-   * </pre>
-   */
-  def joinTransaction: Unit = {}
+  def joinTransaction: Unit = { 
+    val it = joinTransactionFuns.iterator
+    while (it.hasNext) {
+      val fn = it.next
+      fn()
+    }
+  }
 
-  /**
-   * Handle exception. Can be overriden by concrete transaction service implementation.
-   * <p/>
-   * Here is an example on how to handle JPA exceptions.
-   * 
-   * <pre>
-   * def handleException(tm: TransactionContainer, e: Exception) = {
-   *   if (isInExistingTransaction(tm)) {
-   *     // Do not roll back in case of NoResultException or NonUniqueResultException
-   *     if (!e.isInstanceOf[NoResultException] &&
-   *         !e.isInstanceOf[NonUniqueResultException]) {
-   *       log.debug("Setting TX to ROLLBACK_ONLY, due to: %s", e)
-   *       tm.setRollbackOnly
-   *     }
-   *   }
-   *   throw e
-   * }
-   * </pre>
-   */
   def handleException(tm: TransactionContainer, e: Exception) = {
-    tm.setRollbackOnly
+    var rollback = true
+    val it = joinTransactionFuns.iterator
+    while (it.hasNext) {
+      val exception = it.next
+      if (e.getClass.isAssignableFrom(exception.getClass))
+      rollback = false
+    }
+    if (rollback) tm.setRollbackOnly
     throw e
   }
 

From d7e327d2b520b08d19bfd0023aafff0237fbbd4c Mon Sep 17 00:00:00 2001
From: Michael Kober <michael.kober@jayway.com>
Date: Thu, 22 Apr 2010 12:48:16 +0200
Subject: [PATCH 35/41] updated dependencies in pom

---
 akka-spring/akka-spring-test-java/pom.xml | 22 ++++++++++++++++------
 1 file changed, 16 insertions(+), 6 deletions(-)

diff --git a/akka-spring/akka-spring-test-java/pom.xml b/akka-spring/akka-spring-test-java/pom.xml
index 0d35a47739..11a29262ac 100644
--- a/akka-spring/akka-spring-test-java/pom.xml
+++ b/akka-spring/akka-spring-test-java/pom.xml
@@ -6,7 +6,7 @@
   <name>Akka Spring Tests in Java</name>
   <artifactId>akka-spring-test-java</artifactId>
   <groupId>se.scalablesolutions.akka</groupId>
-  <version>0.8</version>
+  <version>0.9</version>
   <packaging>jar</packaging>
 
   <properties>
@@ -147,22 +147,22 @@
     <dependency>
       <groupId>se.scalablesolutions.akka</groupId>
       <artifactId>akka-core_2.8.0.Beta1</artifactId>
-      <version>0.8.1</version>
+      <version>0.9</version>
     </dependency>
     <dependency>
       <groupId>se.scalablesolutions.akka</groupId>
       <artifactId>akka-util_2.8.0.Beta1</artifactId>
-      <version>0.8.1</version>
+      <version>0.9</version>
     </dependency>
     <dependency>
       <groupId>se.scalablesolutions.akka</groupId>
       <artifactId>akka-util-java_2.8.0.Beta1</artifactId>
-      <version>0.8.1</version>
+      <version>0.9</version>
     </dependency>
     <dependency>
       <groupId>se.scalablesolutions.akka</groupId>
       <artifactId>akka-spring_2.8.0.Beta1</artifactId>
-      <version>0.8.1</version>
+      <version>0.9</version>
       <exclusions>
         <exclusion>
           <groupId>org.springframework</groupId>
@@ -263,7 +263,17 @@
       <artifactId>h2-lzf</artifactId>
       <version>1.0</version>
     </dependency>
-    
+
+    <dependency>
+      <groupId>jsr166x</groupId>
+      <artifactId>jsr166x</artifactId>
+      <version>1.0</version>
+    </dependency>
+    <dependency>
+          <groupId>org.apache.geronimo.specs</groupId>
+          <artifactId>geronimo-jta_1.1_spec</artifactId>
+          <version>1.1.1</version>
+    </dependency>
 
    <!-- test -->
     <dependency>

From e598c28251bf46e06d30c29ce04fc34c6be01e38 Mon Sep 17 00:00:00 2001
From: Viktor Klang <viktor.klang@gmail.com>
Date: Fri, 23 Apr 2010 20:46:58 +0200
Subject: [PATCH 36/41] Initial parametrization

---
 akka-camel/src/main/scala/Producer.scala      |  2 +-
 .../src/main/scala/actor/ActiveObject.scala   |  4 +--
 akka-core/src/main/scala/actor/Actor.scala    | 24 +++++++-------
 .../src/main/scala/dispatch/Future.scala      | 32 +++++++++----------
 .../src/main/scala/dispatch/Reactor.scala     |  2 +-
 .../src/main/scala/remote/RemoteClient.scala  | 18 +++++------
 .../src/main/scala/stm/DataFlowVariable.scala |  6 ++--
 7 files changed, 44 insertions(+), 44 deletions(-)

diff --git a/akka-camel/src/main/scala/Producer.scala b/akka-camel/src/main/scala/Producer.scala
index 2b7d053457..e793794804 100644
--- a/akka-camel/src/main/scala/Producer.scala
+++ b/akka-camel/src/main/scala/Producer.scala
@@ -162,7 +162,7 @@ trait Producer { self: Actor =>
  */
 class ProducerResponseSender(
     headers: Map[String, Any],
-    replyTo : Option[Either[Actor,CompletableFuture]],
+    replyTo : Option[Either[Actor,CompletableFuture[Any]]],
     producer: Actor) extends Synchronization with Logging {
 
   implicit val producerActor = Some(producer) // the response sender
diff --git a/akka-core/src/main/scala/actor/ActiveObject.scala b/akka-core/src/main/scala/actor/ActiveObject.scala
index f3c536fdf8..839ebb1c3e 100644
--- a/akka-core/src/main/scala/actor/ActiveObject.scala
+++ b/akka-core/src/main/scala/actor/ActiveObject.scala
@@ -462,11 +462,11 @@ private[akka] sealed class ActiveObjectAspect {
     }
   }
 
-  private def getResultOrThrowException[T](future: Future): Option[T] =
+  private def getResultOrThrowException[T](future: Future[T]): Option[T] =
     if (future.exception.isDefined) {
       val (_, cause) = future.exception.get
       throw cause
-    } else future.result.asInstanceOf[Option[T]]
+    } else future.result
 
   private def isOneWay(rtti: MethodRtti) = rtti.getMethod.isAnnotationPresent(Annotations.oneway)
 
diff --git a/akka-core/src/main/scala/actor/Actor.scala b/akka-core/src/main/scala/actor/Actor.scala
index 37a297d5ca..8d46ff605d 100644
--- a/akka-core/src/main/scala/actor/Actor.scala
+++ b/akka-core/src/main/scala/actor/Actor.scala
@@ -257,7 +257,7 @@ trait Actor extends TransactionManagement with Logging {
    * Is Some(Left(Actor)) if sender is an actor
    * Is Some(Right(CompletableFuture)) if sender is holding on to a Future for the result
    */
-  protected var replyTo: Option[Either[Actor,CompletableFuture]] = None
+  protected var replyTo: Option[Either[Actor,CompletableFuture[Any]]] = None
 
   // ====================================
   // ==== USER CALLBACKS TO OVERRIDE ====
@@ -502,9 +502,9 @@ trait Actor extends TransactionManagement with Logging {
   def !![T](message: Any, timeout: Long): Option[T] = {
     if (_isKilled) throw new ActorKilledException("Actor [" + toString + "] has been killed, can't respond to messages")
     if (_isRunning) {
-      val future = postMessageToMailboxAndCreateFutureResultWithTimeout(message, timeout, None)
+      val future = postMessageToMailboxAndCreateFutureResultWithTimeout[T](message, timeout, None)
       val isActiveObject = message.isInstanceOf[Invocation]
-      if (isActiveObject && message.asInstanceOf[Invocation].isVoid) future.completeWithResult(None)
+      if (isActiveObject && message.asInstanceOf[Invocation].isVoid) future.asInstanceOf[CompletableFuture[Option[_]]].completeWithResult(None)
       try {
         future.await
       } catch {
@@ -514,7 +514,7 @@ trait Actor extends TransactionManagement with Logging {
       }
       
       if (future.exception.isDefined) throw future.exception.get._2
-      else future.result.asInstanceOf[Option[T]]
+      else future.result
     }
     else throw new IllegalStateException(
       "Actor has not been started, you need to invoke 'actor.start' before using it")
@@ -539,10 +539,10 @@ trait Actor extends TransactionManagement with Logging {
   /**
    * FIXME document !!!
    */
-  def !!!(message: Any): Future = {
+  def !!![T](message: Any): Future[T] = {
     if (_isKilled) throw new ActorKilledException("Actor [" + toString + "] has been killed, can't respond to messages")
     if (_isRunning) {
-      postMessageToMailboxAndCreateFutureResultWithTimeout(message, timeout, None)
+      postMessageToMailboxAndCreateFutureResultWithTimeout[T](message, timeout, None)
     } else throw new IllegalStateException(
       "Actor has not been started, you need to invoke 'actor.start' before using it")
   }
@@ -569,7 +569,7 @@ trait Actor extends TransactionManagement with Logging {
    */
   protected[this] def reply(message: Any) = replyTo match {
     case Some(Left(actor))   => actor ! message
-    case Some(Right(future)) => future.completeWithResult(message)
+    case Some(Right(future : Future[Any])) => future.completeWithResult(message)
     case _ => throw new IllegalStateException(
               "\n\tNo sender in scope, can't reply. " +
               "\n\tYou have probably used the '!' method to either; " +
@@ -813,7 +813,7 @@ trait Actor extends TransactionManagement with Logging {
         RemoteServer.actorsFor(RemoteServer.Address(host, port)).actors.put(sender.get.getId, sender.get)
       }
       RemoteProtocolBuilder.setMessage(message, requestBuilder)
-      RemoteClient.clientFor(_remoteAddress.get).send(requestBuilder.build, None)
+      RemoteClient.clientFor(_remoteAddress.get).send[Any](requestBuilder.build, None)
     } else {
       val invocation = new MessageInvocation(this, message, sender.map(Left(_)), transactionSet.get)
       if (messageDispatcher.usesActorMailbox) {
@@ -824,10 +824,10 @@ trait Actor extends TransactionManagement with Logging {
     }
   }
 
-  protected[akka] def postMessageToMailboxAndCreateFutureResultWithTimeout(
+  protected[akka] def postMessageToMailboxAndCreateFutureResultWithTimeout[T](
       message: Any,
       timeout: Long,
-      senderFuture: Option[CompletableFuture]): CompletableFuture = {
+      senderFuture: Option[CompletableFuture[T]]): CompletableFuture[T] = {
     joinTransaction(message)
 
     if (_remoteAddress.isDefined) {
@@ -847,8 +847,8 @@ trait Actor extends TransactionManagement with Logging {
       else throw new IllegalStateException("Expected a future from remote call to actor " + toString)
     } else {
       val future = if (senderFuture.isDefined) senderFuture.get
-                   else new DefaultCompletableFuture(timeout)
-      val invocation = new MessageInvocation(this, message, Some(Right(future)), transactionSet.get)
+                   else new DefaultCompletableFuture[T](timeout)
+      val invocation = new MessageInvocation(this, message, Some(Right(future.asInstanceOf[CompletableFuture[Any]])), transactionSet.get)
       
       if (messageDispatcher.usesActorMailbox)
         _mailbox.add(invocation)
diff --git a/akka-core/src/main/scala/dispatch/Future.scala b/akka-core/src/main/scala/dispatch/Future.scala
index 0bf9723e31..7e8fd5b087 100644
--- a/akka-core/src/main/scala/dispatch/Future.scala
+++ b/akka-core/src/main/scala/dispatch/Future.scala
@@ -20,8 +20,8 @@ object Futures {
    * }
    * </pre>
    */
-  def future(timeout: Long)(body: => Any): Future = {
-    val promise = new DefaultCompletableFuture(timeout)
+  def future[T](timeout: Long)(body: => T): Future[T] = {
+    val promise = new DefaultCompletableFuture[T](timeout)
     try {
       promise completeWithResult body
     } catch {
@@ -30,10 +30,10 @@ object Futures {
     promise
   }
 
-  def awaitAll(futures: List[Future]): Unit = futures.foreach(_.await)
+  def awaitAll(futures: List[Future[_]]): Unit = futures.foreach(_.await)
 
-  def awaitOne(futures: List[Future]): Future = {
-    var future: Option[Future] = None
+  def awaitOne(futures: List[Future[_]]): Future[_] = {
+    var future: Option[Future[_]] = None
     do {
       future = futures.find(_.isCompleted)
     } while (future.isEmpty)
@@ -41,12 +41,12 @@ object Futures {
   }
 
   /*
-  def awaitEither(f1: Future, f2: Future): Option[Any] = {
+  def awaitEither[T](f1: Future[T], f2: Future[T]): Option[T] = {
     import Actor.Sender.Self
     import Actor.{spawn, actor}
       
-    case class Result(res: Option[Any])
-    val handOff = new SynchronousQueue[Option[Any]]
+    case class Result(res: Option[T])
+    val handOff = new SynchronousQueue[Option[T]]
     spawn {
       try {
         println("f1 await")
@@ -70,23 +70,23 @@ object Futures {
 */
 }
 
-sealed trait Future {
+sealed trait Future[T] {
   def await
   def awaitBlocking
   def isCompleted: Boolean
   def isExpired: Boolean
   def timeoutInNanos: Long
-  def result: Option[Any]
+  def result: Option[T]
   def exception: Option[Tuple2[AnyRef, Throwable]]
 }
 
-trait CompletableFuture extends Future {
-  def completeWithResult(result: Any)
+trait CompletableFuture[T] extends Future[T] {
+  def completeWithResult(result: T)
   def completeWithException(toBlame: AnyRef, exception: Throwable)
 }
 
 // Based on code from the actorom actor framework by Sergio Bossa [http://code.google.com/p/actorom/].
-class DefaultCompletableFuture(timeout: Long) extends CompletableFuture {
+class DefaultCompletableFuture[T](timeout: Long) extends CompletableFuture[T] {
   private val TIME_UNIT = TimeUnit.MILLISECONDS
   def this() = this(0)
 
@@ -95,7 +95,7 @@ class DefaultCompletableFuture(timeout: Long) extends CompletableFuture {
   private val _lock = new ReentrantLock
   private val _signal = _lock.newCondition
   private var _completed: Boolean = _
-  private var _result: Option[Any] = None
+  private var _result: Option[T] = None
   private var _exception: Option[Tuple2[AnyRef, Throwable]] = None
 
   def await = try {
@@ -138,7 +138,7 @@ class DefaultCompletableFuture(timeout: Long) extends CompletableFuture {
     _lock.unlock
   }
 
-  def result: Option[Any] = try {
+  def result: Option[T] = try {
     _lock.lock
     _result
   } finally {
@@ -152,7 +152,7 @@ class DefaultCompletableFuture(timeout: Long) extends CompletableFuture {
     _lock.unlock
   }
 
-  def completeWithResult(result: Any) = try {
+  def completeWithResult(result: T) = try {
     _lock.lock
     if (!_completed) {
       _completed = true
diff --git a/akka-core/src/main/scala/dispatch/Reactor.scala b/akka-core/src/main/scala/dispatch/Reactor.scala
index 3f300b1c52..3eecbef0f3 100644
--- a/akka-core/src/main/scala/dispatch/Reactor.scala
+++ b/akka-core/src/main/scala/dispatch/Reactor.scala
@@ -15,7 +15,7 @@ import org.multiverse.commitbarriers.CountDownCommitBarrier
 
 final class MessageInvocation(val receiver: Actor,
                               val message: Any,
-                              val replyTo : Option[Either[Actor,CompletableFuture]],
+                              val replyTo : Option[Either[Actor,CompletableFuture[Any]]],
                               val transactionSet: Option[CountDownCommitBarrier]) {
   if (receiver eq null) throw new IllegalArgumentException("receiver is null")
 
diff --git a/akka-core/src/main/scala/remote/RemoteClient.scala b/akka-core/src/main/scala/remote/RemoteClient.scala
index 81d5591fbb..4676acc904 100644
--- a/akka-core/src/main/scala/remote/RemoteClient.scala
+++ b/akka-core/src/main/scala/remote/RemoteClient.scala
@@ -85,13 +85,13 @@ object RemoteClient extends Logging {
           requestBuilder.setSourcePort(port)
         }
         RemoteProtocolBuilder.setMessage(message, requestBuilder)
-        remoteClient.send(requestBuilder.build, None)
+        remoteClient.send[Any](requestBuilder.build, None)
       }
 
-      override def postMessageToMailboxAndCreateFutureResultWithTimeout(
+      override def postMessageToMailboxAndCreateFutureResultWithTimeout[T](
           message: Any,
           timeout: Long,
-          senderFuture: Option[CompletableFuture]): CompletableFuture = {
+          senderFuture: Option[CompletableFuture[T]]): CompletableFuture[T] = {
         val requestBuilder = RemoteRequest.newBuilder
             .setId(RemoteRequestIdFactory.nextId)
             .setTarget(className)
@@ -173,7 +173,7 @@ class RemoteClient(val hostname: String, val port: Int) extends Logging {
   val name = "RemoteClient@" + hostname + "::" + port
 
   @volatile private[remote] var isRunning = false
-  private val futures = new ConcurrentHashMap[Long, CompletableFuture]
+  private val futures = new ConcurrentHashMap[Long, CompletableFuture[_]]
   private val supervisors = new ConcurrentHashMap[String, Actor]
   private[remote] val listeners = new ConcurrentSkipListSet[Actor]
 
@@ -217,14 +217,14 @@ class RemoteClient(val hostname: String, val port: Int) extends Logging {
     }
   }
 
-  def send(request: RemoteRequest, senderFuture: Option[CompletableFuture]): Option[CompletableFuture] = if (isRunning) {
+  def send[T](request: RemoteRequest, senderFuture: Option[CompletableFuture[T]]): Option[CompletableFuture[T]] = if (isRunning) {
     if (request.getIsOneWay) {
       connection.getChannel.write(request)
       None
     } else {
       futures.synchronized {
         val futureResult = if (senderFuture.isDefined) senderFuture.get
-        else new DefaultCompletableFuture(request.getTimeout)
+        else new DefaultCompletableFuture[T](request.getTimeout)
         futures.put(request.getId, futureResult)
         connection.getChannel.write(request)
         Some(futureResult)
@@ -253,7 +253,7 @@ class RemoteClient(val hostname: String, val port: Int) extends Logging {
  * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
  */
 class RemoteClientPipelineFactory(name: String,
-                                  futures: ConcurrentMap[Long, CompletableFuture],
+                                  futures: ConcurrentMap[Long, CompletableFuture[_]],
                                   supervisors: ConcurrentMap[String, Actor],
                                   bootstrap: ClientBootstrap,
                                   remoteAddress: SocketAddress,
@@ -284,7 +284,7 @@ class RemoteClientPipelineFactory(name: String,
  */
 @ChannelHandler.Sharable
 class RemoteClientHandler(val name: String,
-                          val futures: ConcurrentMap[Long, CompletableFuture],
+                          val futures: ConcurrentMap[Long, CompletableFuture[_]],
                           val supervisors: ConcurrentMap[String, Actor],
                           val bootstrap: ClientBootstrap,
                           val remoteAddress: SocketAddress,
@@ -306,7 +306,7 @@ class RemoteClientHandler(val name: String,
       if (result.isInstanceOf[RemoteReply]) {
         val reply = result.asInstanceOf[RemoteReply]
         log.debug("Remote client received RemoteReply[\n%s]", reply.toString)
-        val future = futures.get(reply.getId)
+        val future : CompletableFuture[Any] = futures.get(reply.getId).asInstanceOf[CompletableFuture[Any]]
         if (reply.getIsSuccessful) {
           val message = RemoteProtocolBuilder.getMessage(reply)
           future.completeWithResult(message)
diff --git a/akka-core/src/main/scala/stm/DataFlowVariable.scala b/akka-core/src/main/scala/stm/DataFlowVariable.scala
index 7b2084aec6..332ae5c14e 100644
--- a/akka-core/src/main/scala/stm/DataFlowVariable.scala
+++ b/akka-core/src/main/scala/stm/DataFlowVariable.scala
@@ -80,7 +80,7 @@ import se.scalablesolutions.akka.dispatch.CompletableFuture
     private class Out[T <: Any](dataFlow: DataFlowVariable[T]) extends Actor {
       timeout = TIME_OUT
       start
-      private var readerFuture: Option[CompletableFuture] = None
+      private var readerFuture: Option[CompletableFuture[T]] = None
       def receive = {
         case Get =>
           val ref = dataFlow.value.get
@@ -88,11 +88,11 @@ import se.scalablesolutions.akka.dispatch.CompletableFuture
             reply(ref.get)
           else {
             readerFuture = replyTo match { 
-              case Some(Right(future)) => Some(future)
+              case Some(Right(future)) => Some(future.asInstanceOf[CompletableFuture[T]])
               case _ => None
             }
           }
-        case Set(v) => if (readerFuture.isDefined) readerFuture.get.completeWithResult(v)
+        case Set(v:T) => if (readerFuture.isDefined) readerFuture.get.completeWithResult(v)
         case Exit =>  exit
       }
     }

From 71f766faa80d4563bfc0ba51d7489c5f42aa97ba Mon Sep 17 00:00:00 2001
From: Viktor Klang <viktor.klang@gmail.com>
Date: Fri, 23 Apr 2010 21:28:45 +0200
Subject: [PATCH 37/41] Minor cleanup

---
 akka-core/src/main/scala/remote/RemoteClient.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/akka-core/src/main/scala/remote/RemoteClient.scala b/akka-core/src/main/scala/remote/RemoteClient.scala
index 4676acc904..2557c33d02 100644
--- a/akka-core/src/main/scala/remote/RemoteClient.scala
+++ b/akka-core/src/main/scala/remote/RemoteClient.scala
@@ -306,7 +306,7 @@ class RemoteClientHandler(val name: String,
       if (result.isInstanceOf[RemoteReply]) {
         val reply = result.asInstanceOf[RemoteReply]
         log.debug("Remote client received RemoteReply[\n%s]", reply.toString)
-        val future : CompletableFuture[Any] = futures.get(reply.getId).asInstanceOf[CompletableFuture[Any]]
+        val future = futures.get(reply.getId).asInstanceOf[CompletableFuture[Any]]
         if (reply.getIsSuccessful) {
           val message = RemoteProtocolBuilder.getMessage(reply)
           future.completeWithResult(message)

From 4ffa75937beb3a5130cc537a3ac5223494b80123 Mon Sep 17 00:00:00 2001
From: Viktor Klang <viktor.klang@gmail.com>
Date: Sat, 24 Apr 2010 14:56:50 +0200
Subject: [PATCH 38/41] Added Listeners to akka-patterns

---
 akka-patterns/src/main/scala/Patterns.scala   | 18 +++++++++
 .../src/test/scala/ActorPatternsTest.scala    | 38 +++++++++++++++++++
 2 files changed, 56 insertions(+)

diff --git a/akka-patterns/src/main/scala/Patterns.scala b/akka-patterns/src/main/scala/Patterns.scala
index fc50292676..d8a49c74e3 100644
--- a/akka-patterns/src/main/scala/Patterns.scala
+++ b/akka-patterns/src/main/scala/Patterns.scala
@@ -85,3 +85,21 @@ class SmallestMailboxFirstIterator(items : List[Actor]) extends InfiniteIterator
     items.reduceLeft((actor1, actor2) => actorWithSmallestMailbox(actor1,actor2))
   }
 } 
+
+sealed trait ListenerMessage
+case class Listen(listener : Actor) extends ListenerMessage
+case class Deafen(listener : Actor) extends ListenerMessage 
+case class WithListeners(f : Set[Actor] => Unit) extends ListenerMessage
+
+trait Listeners { self : Actor =>
+  import se.scalablesolutions.akka.actor.Agent
+  private lazy val listeners = Agent(Set[Actor]())
+
+  protected def listenerManagement : PartialFunction[Any,Unit] = {
+    case Listen(l) => listeners( _ + l)
+    case Deafen(l) => listeners( _ - l )
+    case WithListeners(f) => listeners foreach f
+  }
+  
+  protected def gossip(msg : Any) = listeners foreach ( _ foreach ( _ ! msg ) )
+}
\ No newline at end of file
diff --git a/akka-patterns/src/test/scala/ActorPatternsTest.scala b/akka-patterns/src/test/scala/ActorPatternsTest.scala
index 0ce999add0..2235b1a1a7 100644
--- a/akka-patterns/src/test/scala/ActorPatternsTest.scala
+++ b/akka-patterns/src/test/scala/ActorPatternsTest.scala
@@ -90,6 +90,44 @@ class ActorPatternsTest extends junit.framework.TestCase with Suite with MustMat
       }
     }
   })
+  
+  @Test def testListener = verify(new TestActor {
+    import java.util.concurrent.{ CountDownLatch, TimeUnit }
+  
+    def test = {
+      val latch = new CountDownLatch(2)
+      val num = new AtomicInteger(0)
+      val i = new Actor with Listeners {
+        def receive = listenerManagement orElse {
+          case "foo" =>  gossip("bar")
+        }
+      }
+      i.start
+      
+      def newListener = actor { 
+        case "bar" => 
+        num.incrementAndGet
+        latch.countDown
+      }
+      
+      val a1 = newListener
+      val a2 = newListener
+      val a3 = newListener
+      
+      handle(i,a1,a2,a3) {
+      i ! Listen(a1)
+      i ! Listen(a2)
+      i ! Listen(a3)
+      i ! Deafen(a3)
+
+	  i ! "foo"
+	  
+	  val done = latch.await(5,TimeUnit.SECONDS)
+	  done must be (true)
+	  num.get must be (2)
+	  }
+    }
+  });
 
 }
 

From 12d3ce354586546abe0c592445d3e32dbdb91d5d Mon Sep 17 00:00:00 2001
From: Viktor Klang <viktor.klang@gmail.com>
Date: Sat, 24 Apr 2010 14:57:32 +0200
Subject: [PATCH 39/41] Added reply_? that discards messages if it cannot find
 reply target

---
 akka-core/src/main/scala/actor/Actor.scala | 23 ++++++++++++++++++----
 1 file changed, 19 insertions(+), 4 deletions(-)

diff --git a/akka-core/src/main/scala/actor/Actor.scala b/akka-core/src/main/scala/actor/Actor.scala
index 37a297d5ca..7947848634 100644
--- a/akka-core/src/main/scala/actor/Actor.scala
+++ b/akka-core/src/main/scala/actor/Actor.scala
@@ -566,11 +566,9 @@ trait Actor extends TransactionManagement with Logging {
   /**
    * Use <code>reply(..)</code> to reply with a message to the original sender of the message currently
    * being processed.
+   * Throws an IllegalStateException if unable to determine what to reply to
    */
-  protected[this] def reply(message: Any) = replyTo match {
-    case Some(Left(actor))   => actor ! message
-    case Some(Right(future)) => future.completeWithResult(message)
-    case _ => throw new IllegalStateException(
+  protected[this] def reply(message: Any) = if(!reply_?(message)) throw new IllegalStateException(
               "\n\tNo sender in scope, can't reply. " +
               "\n\tYou have probably used the '!' method to either; " +
               "\n\t\t1. Send a message to a remote actor which does not have a contact address." +
@@ -579,6 +577,23 @@ trait Actor extends TransactionManagement with Logging {
               "\n\tIf so, switch to '!!' (or remove '@oneway') which passes on an implicit future" +
               "\n\tthat will be bound by the argument passed to 'reply'." +
               "\n\tAlternatively, you can use setReplyToAddress to make sure the actor can be contacted over the network.")
+  
+  /**
+   * Use <code>reply_?(..)</code> to reply with a message to the original sender of the message currently
+   * being processed.
+   * Returns true if reply was sent, and false if unable to determine what to reply to.
+   */
+  protected[this] def reply_?(message: Any) : Boolean = replyTo match {
+    case Some(Left(actor))   => 
+      actor ! message
+      true
+      
+    case Some(Right(future)) => 
+      future.completeWithResult(message)
+      true
+      
+    case _ => 
+      false
   }
   
   /**

From 716229c8b85b34ce8b7bbd28e50d30fe2545f472 Mon Sep 17 00:00:00 2001
From: Viktor Klang <viktor.klang@gmail.com>
Date: Sun, 25 Apr 2010 18:07:27 +0200
Subject: [PATCH 40/41] Added Future[T] as return type for await and
 awaitBlocking

---
 akka-core/src/main/scala/dispatch/Future.scala | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/akka-core/src/main/scala/dispatch/Future.scala b/akka-core/src/main/scala/dispatch/Future.scala
index 7e8fd5b087..7fe0c4ab6a 100644
--- a/akka-core/src/main/scala/dispatch/Future.scala
+++ b/akka-core/src/main/scala/dispatch/Future.scala
@@ -71,8 +71,8 @@ object Futures {
 }
 
 sealed trait Future[T] {
-  def await
-  def awaitBlocking
+  def await : Future[T]
+  def awaitBlocking : Future[T]
   def isCompleted: Boolean
   def isExpired: Boolean
   def timeoutInNanos: Long
@@ -111,6 +111,7 @@ class DefaultCompletableFuture[T](timeout: Long) extends CompletableFuture[T] {
           wait = wait - (currentTimeInNanos - start)
       }
     }
+    this
   } finally {
     _lock.unlock
   }
@@ -120,6 +121,7 @@ class DefaultCompletableFuture[T](timeout: Long) extends CompletableFuture[T] {
     while (!_completed) {
       _signal.await
     }
+    this
   } finally {
     _lock.unlock
   }

From 2fb619bffeba4213bc114be4ad695ae239100b58 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonas=20Bon=C3=A9r?= <jonasremove@jonasboner.com>
Date: Mon, 26 Apr 2010 08:25:52 +0200
Subject: [PATCH 41/41] Made ActiveObject non-advisable in AW terms

---
 akka-core/src/main/scala/actor/ActiveObject.scala | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/akka-core/src/main/scala/actor/ActiveObject.scala b/akka-core/src/main/scala/actor/ActiveObject.scala
index 839ebb1c3e..f80dd2db42 100644
--- a/akka-core/src/main/scala/actor/ActiveObject.scala
+++ b/akka-core/src/main/scala/actor/ActiveObject.scala
@@ -271,7 +271,7 @@ object ActiveObject {
   }
 
   private[akka] def newInstance[T](target: Class[T], actor: Dispatcher, remoteAddress: Option[InetSocketAddress], timeout: Long): T = {
-    val proxy = Proxy.newInstance(target, false, true)
+    val proxy = Proxy.newInstance(target, false, false)
     actor.initialize(target, proxy)
     actor.timeout = timeout
     if (remoteAddress.isDefined) {
@@ -283,7 +283,7 @@ object ActiveObject {
   }
 
   private[akka] def newInstance[T](intf: Class[T], target: AnyRef, actor: Dispatcher, remoteAddress: Option[InetSocketAddress], timeout: Long): T = {
-    val proxy = Proxy.newInstance(Array(intf), Array(target), false, true)
+    val proxy = Proxy.newInstance(Array(intf), Array(target), false, false)
     actor.initialize(target.getClass, target)
     actor.timeout = timeout
     if (remoteAddress.isDefined) {