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

[andrae at mulgara.org]

Author: andrae
Date: 2007-11-21 05:09:28 -0600 (Wed, 21 Nov 2007)
New Revision: 566

Modified:
   branches/mgr-73/src/jar/resolver/java/org/mulgara/resolver/MulgaraInternalTransactionFactory.java
Log:
Fixed up compliance with interfaces, as well as several compile-errors.



Modified: branches/mgr-73/src/jar/resolver/java/org/mulgara/resolver/MulgaraInternalTransactionFactory.java
===================================================================
--- branches/mgr-73/src/jar/resolver/java/org/mulgara/resolver/MulgaraInternalTransactionFactory.java	2007-11-16 06:20:02 UTC (rev 565)
+++ branches/mgr-73/src/jar/resolver/java/org/mulgara/resolver/MulgaraInternalTransactionFactory.java	2007-11-21 11:09:28 UTC (rev 566)
@@ -38,8 +38,8 @@
 
 // Local packages
 import org.mulgara.query.MulgaraTransactionException;
-import org.mulgara.server.Session;
 import org.mulgara.transaction.TransactionManagerFactory;
+import org.mulgara.util.Assoc1toNMap;
 
 /**
  * Implements the internal transaction controls offered by Session.
@@ -63,19 +63,25 @@
   private boolean autoCommit;
 
   /** Set of sessions whose transactions have been rolledback.*/
-  private Set<Session> failedSessions;
+  private Set<DatabaseSession> failedSessions;
 
   /** Map of threads to active transactions. */
   private Map<Thread, MulgaraTransaction> activeTransactions;
 
+  private Assoc1toNMap<DatabaseSession, MulgaraTransaction> sessionXAMap;
+
   private final TransactionManager transactionManager;
 
+  private MulgaraInternalTransaction internalWriteTransaction;
+
   public MulgaraInternalTransactionFactory(MulgaraTransactionManager manager, TransactionManagerFactory transactionManagerFactory) {
     super(manager);
     this.autoCommit = true;
 
-    this.failedSessions = new HashSet<Session>();
+    this.failedSessions = new HashSet<DatabaseSession>();
     this.activeTransactions = new HashMap<Thread, MulgaraTransaction>();
+    this.sessionXAMap = new Assoc1toNMap<DatabaseSession, MulgaraTransaction>();
+    this.internalWriteTransaction = null;
 
     this.transactionManager = transactionManagerFactory.newTransactionManager();
   }
@@ -98,16 +104,14 @@
           });
           try {
             assert writeTransaction == null;
-            writeTransaction = transaction = newMulgaraTransaction(session.newOperationContext(true));
-          } catch (MulgaraTransactionException em) {
-            manager.releaseWriteLock(session);
-            throw em;
+            writeTransaction = internalWriteTransaction = transaction = 
+                new MulgaraInternalTransaction(this, session.newOperationContext(true));
           } catch (Throwable th) {
             manager.releaseWriteLock(session);
             throw new MulgaraTransactionException("Error creating write transaction", th);
           }
         } else {
-          transaction = newMulgaraTransaction(session.newOperationContext(false));
+          transaction = new MulgaraInternalTransaction(this, session.newOperationContext(false));
         }
 
         sessionXAMap.put(session, transaction);
@@ -123,6 +127,10 @@
     }
   }
 
+  public Set<MulgaraTransaction> getTransactionsForSession(DatabaseSession session) {
+    Set <MulgaraTransaction> xas = sessionXAMap.getN(session);
+    return xas == null ? new HashSet<MulgaraTransaction>() : xas;
+  }
 
   public MulgaraTransaction newMulgaraTransaction(DatabaseOperationContext context)
       throws MulgaraTransactionException {
@@ -133,11 +141,11 @@
   public void commit(DatabaseSession session) throws MulgaraTransactionException {
     acquireMutex();
     try {
-      manager.reserveWriteLock();
+      manager.reserveWriteLock(session);
       try {
         if (failedSessions.contains(session)) {
           throw new MulgaraTransactionException("Attempting to commit failed exception");
-        } else if (session != currentWritingSession) {
+        } else if (!manager.isHoldingWriteLock(session)) {
           throw new MulgaraTransactionException(
               "Attempting to commit while not the current writing transaction");
         }
@@ -145,7 +153,7 @@
         setAutoCommit(session, true);
         setAutoCommit(session, false);
       } finally {
-        manager.releaseReserve();
+        manager.releaseReserve(session);
       }
     } finally {
       releaseMutex();
@@ -161,11 +169,11 @@
   public void rollback(DatabaseSession session) throws MulgaraTransactionException {
     acquireMutex();
     try {
-      manager.reserveWriteLock();
+      manager.reserveWriteLock(session);
       try {
         if (manager.isHoldingWriteLock(session)) {
           try {
-            writeTransaction.rollback("Explicit Rollback");
+            writeTransaction.heuristicRollback("Explicit Rollback");
             // FIXME: Should be checking status here, not writelock.
             if (manager.isHoldingWriteLock(session)) {
               // transaction referenced by something - need to explicitly end it.
@@ -184,7 +192,7 @@
               "Attempt to rollback while not in the current writing transaction");
         }
       } finally {
-        manager.releaseReserve();
+        manager.releaseReserve(session);
       }
     } finally {
       releaseMutex();
@@ -210,14 +218,14 @@
                 public void execute() throws MulgaraTransactionException {
                   writeTransaction.execute(new TransactionOperation() {
                     public void execute() throws MulgaraTransactionException {
-                      writeTransaction.dereference();
-                      writeTransaction.commitTransaction();
+                      internalWriteTransaction.dereference();
+                      internalWriteTransaction.commitTransaction();
                     }
                   });
                 }
               });
             } finally {
-              releaseWriteLock();
+              manager.releaseWriteLock(session);
               this.autoCommit = true;
             }
           } else if (failedSessions.contains(session)) {
@@ -234,7 +242,7 @@
           logger.info("Attempting to set autocommit true without setting it false");
         } else {
           // AutoCommit on -> off == Start new transaction.
-          writeTransaction = getTransaction(session, true);
+          getTransaction(session, true); // Set's writeTransaction.
           writeTransaction.reference();
           this.autoCommit = false;
         }
@@ -330,12 +338,17 @@
     }
   }
 
-  public void transactionComplete(MulgaraTransaction transaction) {
+  public void transactionComplete(MulgaraTransaction transaction) throws MulgaraTransactionException {
     acquireMutex();
     try {
-      if (transaction == writeTransaction) {
+      DatabaseSession session = sessionXAMap.get1(transaction);
+      if (session == null) {
+        throw new MulgaraTransactionException("No associated session found for transaction");
+      }
+      if (manager.isHoldingWriteLock(session)) {
         manager.releaseWriteLock(session);
         writeTransaction = null;
+        internalWriteTransaction = null;
       }
 
       sessionXAMap.removeN(transaction);
@@ -351,7 +364,7 @@
       try {
         // Make sure this cleans up the transaction metadata - this transaction is DEAD!
         if (transaction == writeTransaction) {
-          failedSessions.add(currentWritingSession);
+          failedSessions.add(sessionXAMap.get1(transaction));
         }
         transactionComplete(transaction);
       } catch (Throwable th) {