[Mulgara-svn] r573 - branches/mgr-73/src/jar/resolver/java/org/mulgara/resolver

[andrae at mulgara.org]

Author: andrae
Date: 2007-11-21 05:18:53 -0600 (Wed, 21 Nov 2007)
New Revision: 573

Modified:
   branches/mgr-73/src/jar/resolver/java/org/mulgara/resolver/MulgaraXAResource.java
Log:
Added code to handle session/transaction association/disassociation.
Also includes various compile-error fixes.



Modified: branches/mgr-73/src/jar/resolver/java/org/mulgara/resolver/MulgaraXAResource.java
===================================================================
--- branches/mgr-73/src/jar/resolver/java/org/mulgara/resolver/MulgaraXAResource.java	2007-11-21 11:16:09 UTC (rev 572)
+++ branches/mgr-73/src/jar/resolver/java/org/mulgara/resolver/MulgaraXAResource.java	2007-11-21 11:18:53 UTC (rev 573)
@@ -19,12 +19,16 @@
 package org.mulgara.resolver;
 
 // Java2 packages
+import javax.transaction.xa.XAException;
 import javax.transaction.xa.XAResource;
+import javax.transaction.xa.Xid;
 
 // Third party packages
 import org.apache.log4j.Logger;
 
 // Local packages
+import org.mulgara.query.MulgaraTransactionException;
+import org.mulgara.util.Assoc1toNMap;
 
 /**
  * Provides an external JTA-compliant TransactionManager with the ability to
@@ -42,6 +46,8 @@
  */
 
 public class MulgaraXAResource implements XAResource {
+  private static final Logger logger =
+    Logger.getLogger(MulgaraXAResource.class.getName());
   private MulgaraExternalTransactionFactory factory;
 
   private DatabaseSession session;
@@ -91,10 +97,10 @@
       // We are not allowed to forget this transaction if we completed
       // heuristically.
       switch (ex.errorCode) { 
-        case XA_HEURHAZ:
-        case XA_HEURCOM:
-        case XA_HEURRB:
-        case XA_HEURMIX:
+        case XAException.XA_HEURHAZ:
+        case XAException.XA_HEURCOM:
+        case XAException.XA_HEURRB:
+        case XAException.XA_HEURMIX:
           throw ex;
         default:
           xa2xid.remove1(xa);
@@ -119,7 +125,7 @@
     }
     switch (flags) {
       case TMFAIL:
-        xa.setRollbackOnly();
+        xa.rollback(xid);
         break;
       case TMSUCCESS:
         break;
@@ -130,17 +136,27 @@
         throw new XAException(XAException.XAER_INVAL);
     }
 
-    factory.disassociate(session, xa);
+    try {
+      factory.disassociateTransaction(session, xa);
+    } catch (MulgaraTransactionException em) {
+      logger.error("Error disassociating transaction from session", em);
+      throw new XAException(XAException.XAER_PROTO);
+    }
   }
 
-  public void forget(Xid xid) {
+  public void forget(Xid xid) throws XAException {
     MulgaraExternalTransaction xa = xa2xid.get1(xid);
     if (xa == null) {
       throw new XAException(XAException.XAER_NOTA);
     }
     try {
-      if (!xa.isHeuristicRollbackOnly()) {
-        xa.abortTransaction("External XA Manager specified 'forget'", new Throwable());
+      if (!xa.isHeuristicallyRollbacked()) {
+        try {
+          xa.abortTransaction("External XA Manager specified 'forget'", new Throwable());
+        } catch (MulgaraTransactionException em) {
+          logger.error("Failed to abort transaction in forget", em);
+          throw new XAException(XAException.XAER_RMERR);
+        }
       }
     } finally {
       xa2xid.remove1(xa);
@@ -148,11 +164,12 @@
   }
 
   public int getTransactionTimeout() {
-    FIXME!
+    return 3600;
   }
 
   public boolean isSameRM(XAResource xares) {
-    FIXME!
+    return false; // FIXME: We need another interface here, as well as some way
+                  // of identifying a local Mulgara instance.
   }
 
 
@@ -165,6 +182,8 @@
     }
 
     xa.prepare(xid);
+
+    return XA_OK;
   }
 
   /**
@@ -188,6 +207,7 @@
 
 
   public boolean setTransactionTimeout(int seconds) {
+    return false;
   }
 
   public void start(Xid xid, int flags) throws XAException {
@@ -195,28 +215,35 @@
       case TMNOFLAGS:
         if (xa2xid.containsN(xid)) {
           throw new XAException(XAException.XAER_DUPID);
-        } else if (existing transaction(session)) {
+        } else if (factory.hasAssociatedTransaction(session)) {
           throw new XAException(XAException.XA_RBDEADLOCK);
         } else {
-          MulgaraTransaction xa = factory.createTransaction(session, isWrite);
-          xa2xid.put(xa, xid);
+          // FIXME: Need to consider read-only transactions here.
+          try {
+            MulgaraExternalTransaction xa = factory.createTransaction(session, true);
+            xa2xid.put(xa, xid);
+          } catch (MulgaraTransactionException em) {
+            logger.error("Failed to create transaction", em);
+            throw new XAException(XAException.XAER_RMFAIL);
+          }
         }
         break;
       case TMJOIN:
-        if (!existing transaction(session)) {
+        if (!factory.hasAssociatedTransaction(session)) {
           throw new XAException(XAException.XAER_NOTA);
         } else {
-          FIXME! // Do stuff.
+          // FIXME
+          throw new XAException("Need to finalise understanding of semantics of TMJOIN");
         }
-        break;
+        //break;
       case TMRESUME:
         MulgaraExternalTransaction xa = xa2xid.get1(xid);
         if (xa == null) {
           throw new XAException(XAException.XAER_NOTA);
-        } else if (xa.isRollbackOnly()) {
+        } else if (xa.isRollbacked()) {
           throw new XAException(XAException.XA_RBROLLBACK);
         } else {
-          if (!factory.associate(session, xa)) {
+          if (!factory.associateTransaction(session, xa)) {
             // session already associated with a transaction.
             throw new XAException(XAException.XAER_PROTO);
           }
@@ -229,6 +256,6 @@
    * Called on session close to clean-up any remaining transactions.
    */
   public void close() {
-    FIXME!
+    factory.closingSession(session);
   }
 }