[Mulgara-svn] r1063 - branches/mgr-121-lockrecovery/src/jar/resolver/java/org/mulgara/resolver

[ronald at mulgara.org]

Author: ronald
Date: 2008-07-07 05:54:35 -0700 (Mon, 07 Jul 2008)
New Revision: 1063

Modified:
   branches/mgr-121-lockrecovery/src/jar/resolver/java/org/mulgara/resolver/MulgaraInternalTransaction.java
Log:
Cleaning up a bit:
 * cleaned out FIXME's
 * removed unnecessary mutex acquisition/release on internal methods
 * remove obsolete synchronized blocks around currentThread (mutex now protects)


Modified: branches/mgr-121-lockrecovery/src/jar/resolver/java/org/mulgara/resolver/MulgaraInternalTransaction.java
===================================================================
--- branches/mgr-121-lockrecovery/src/jar/resolver/java/org/mulgara/resolver/MulgaraInternalTransaction.java	2008-07-07 12:54:31 UTC (rev 1062)
+++ branches/mgr-121-lockrecovery/src/jar/resolver/java/org/mulgara/resolver/MulgaraInternalTransaction.java	2008-07-07 12:54:35 UTC (rev 1063)
@@ -278,10 +278,8 @@
     acquireMutex(0, false, MulgaraTransactionException.class);
     try {
       try {
-        synchronized (this) {
-          if (currentThread != null && !currentThread.equals(Thread.currentThread())) {
-            throw new MulgaraTransactionException("Concurrent access attempted to transaction: Transaction has NOT been rolledback.");
-          }
+        if (currentThread != null && !currentThread.equals(Thread.currentThread())) {
+          throw new MulgaraTransactionException("Concurrent access attempted to transaction: Transaction has NOT been rolledback.");
         }
 
         switch (state) {
@@ -323,59 +321,38 @@
 
   private void startTransaction() throws MulgaraTransactionException {
     report("Initiating transaction");
-    acquireMutex(0, false, MulgaraTransactionException.class);
     try {
-      try {
-        transaction = factory.transactionStart(this);
-        synchronized (this) {
-          currentThread = Thread.currentThread();
-        }
-      } catch (Throwable th) {
-        throw abortTransaction("Failed to start transaction", th);
-      }
-    } finally {
-      releaseMutex();
+      transaction = factory.transactionStart(this);
+      currentThread = Thread.currentThread();
+    } catch (Throwable th) {
+      throw abortTransaction("Failed to start transaction", th);
     }
   }
 
   private void resumeTransaction() throws MulgaraTransactionException {
 //    report("Resuming transaction");
-    acquireMutex(0, false, MulgaraTransactionException.class);
     try {
-      try {
-        factory.transactionResumed(this, transaction);
-        synchronized (this) {
-          currentThread = Thread.currentThread();
-        }
-      } catch (Throwable th) {
-        throw abortTransaction("Failed to resume transaction", th);
-      }
-    } finally {
-      releaseMutex();
+      factory.transactionResumed(this, transaction);
+      currentThread = Thread.currentThread();
+    } catch (Throwable th) {
+      throw abortTransaction("Failed to resume transaction", th);
     }
   }
 
   private void suspendTransaction() throws MulgaraTransactionException {
 //    report("Suspending Transaction");
-    acquireMutex(0, false, MulgaraTransactionException.class);
     try {
-      try {
-        if (using < 1) {
-          throw implicitRollback(
-              new MulgaraTransactionException("Attempt to suspend unreferenced transaction"));
-        }
-        transaction = factory.transactionSuspended(this);
-        synchronized (this) {
-          currentThread = null;
-        }
-        state = State.DEACTREF;
-      } catch (Throwable th) {
-        throw implicitRollback(th);
-      } finally {
-//      report("Finished suspending transaction");
+      if (using < 1) {
+        throw implicitRollback(
+            new MulgaraTransactionException("Attempt to suspend unreferenced transaction"));
       }
+      transaction = factory.transactionSuspended(this);
+      currentThread = null;
+      state = State.DEACTREF;
+    } catch (Throwable th) {
+      throw implicitRollback(th);
     } finally {
-      releaseMutex();
+//      report("Finished suspending transaction");
     }
   }
 
@@ -399,11 +376,9 @@
           enlisted.clear();
         } finally { try {
           factory.transactionComplete(this);
-        } finally { try {
-          //FIXME: factory = null;
         } finally {
           report("Committed transaction");
-        } } } } } }
+        } } } } }
       } catch (Throwable th) {
         errorReport("Error cleaning up transaction post-commit", th);
         throw new MulgaraTransactionException("Error cleaning up transaction post-commit", th);
@@ -454,7 +429,6 @@
             enlisted.clear();
             factory.transactionComplete(this);
             transaction = null;
-            //FIXME: factory = null;
             state = State.FINISHED;
             break;
           case DEACTREF:
@@ -518,7 +492,6 @@
             enlisted.clear();
             state = State.FAILED;
             factory.transactionAborted(this);
-            //FIXME: factory = null;
             return new MulgaraTransactionException("Transaction rollback triggered", cause);
         case DEACTREF:
           throw new IllegalStateException("Attempt to rollback deactivated transaction");
@@ -577,11 +550,9 @@
           enlisted.clear();
         } finally { try {
           transaction = null;
-        } finally { try {
-          //FIXME: factory = null;
         } finally {
           state = State.FAILED;
-        } } } } } } } }
+        } } } } } } }
         return new MulgaraTransactionException(errorMessage + " - Aborting", cause);
       } catch (Throwable th) {
         throw new MulgaraTransactionException(errorMessage + " - Failed to abort cleanly", th);
@@ -780,7 +751,6 @@
       errorReport("Reference counting error in transaction", null);
     }
 
-    //FIXME: if (factory != null || transaction != null) {
     if (transaction != null) {
       errorReport("Transaction not terminated properly", null);
     }