[WFLY-10229] Remove dependency on Narayana internal classes to ensure…

… correct synch order and execution

transactions/src/main/java/org/jboss/as/txn/service/ArjunaTransactionManagerService.java

@@ -40,7 +40,6 @@
 import org.jboss.tm.TransactionManagerLocator;
 import org.jboss.tm.usertx.UserTransactionRegistry;
 import org.omg.CORBA.ORB;
-import org.wildfly.transaction.client.ContextTransactionSynchronizationRegistry;
 import org.wildfly.transaction.client.LocalUserTransaction;
 
 import java.lang.reflect.Field;
@@ -103,7 +102,7 @@ public synchronized void start(final StartContext context) throws StartException
             final LocalUserTransaction userTransaction = LocalUserTransaction.getInstance();
             jtaEnvironmentBean.getValue().setUserTransaction(userTransaction);
             service.setJbossXATerminator(xaTerminatorInjector.getValue());
-            service.setTransactionSynchronizationRegistry(new TransactionSynchronizationRegistryWrapper(ContextTransactionSynchronizationRegistry.getInstance()));
+            service.setTransactionSynchronizationRegistry(new TransactionSynchronizationRegistryWrapper());
 
             try {
                 service.create();
@@ -121,7 +120,7 @@ public synchronized void start(final StartContext context) throws StartException
             final LocalUserTransaction userTransaction = LocalUserTransaction.getInstance();
             jtaEnvironmentBean.getValue().setUserTransaction(userTransaction);
             service.setJbossXATerminator(xaTerminatorInjector.getValue());
-            service.setTransactionSynchronizationRegistry(new TransactionSynchronizationRegistryWrapper(ContextTransactionSynchronizationRegistry.getInstance()));
+            service.setTransactionSynchronizationRegistry(new TransactionSynchronizationRegistryWrapper());
             service.setPropagateFullContext(true);
 
             // this is not great, but it's the only way presently to influence the behavior of com.arjuna.ats.internal.jbossatx.jts.InboundTransactionCurrentImple

transactions/src/main/java/org/jboss/as/txn/service/internal/tsr/JCAOrderedLastSynchronizationList.java

@@ -22,16 +22,14 @@
 package org.jboss.as.txn.service.internal.tsr;
 
 import java.util.ArrayList;
-import java.util.Iterator;
 import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
 
 import javax.transaction.Synchronization;
 import javax.transaction.SystemException;
-import javax.transaction.Transaction;
 
 import org.jboss.as.txn.logging.TransactionLogger;
+import org.wildfly.transaction.client.ContextTransactionManager;
+import org.wildfly.transaction.client.ContextTransactionSynchronizationRegistry;
 
 /**
  * This class was added to:
@@ -48,15 +46,10 @@
  * "Resources can be closed but no transactional work can be performed with them"
  */
 public class JCAOrderedLastSynchronizationList implements Synchronization {
-    private final com.arjuna.ats.jta.transaction.Transaction tx;
-    private final Map<Transaction, JCAOrderedLastSynchronizationList> jcaOrderedLastSynchronizations;
     private final List<Synchronization> preJcaSyncs = new ArrayList<Synchronization>();
     private final List<Synchronization> jcaSyncs = new ArrayList<Synchronization>();
 
-    public JCAOrderedLastSynchronizationList(com.arjuna.ats.jta.transaction.Transaction tx,
-        Map<Transaction, JCAOrderedLastSynchronizationList> jcaOrderedLastSynchronizations) {
-        this.tx = tx;
-        this.jcaOrderedLastSynchronizations = jcaOrderedLastSynchronizations;
+    public JCAOrderedLastSynchronizationList() {
     }
 
     /**
@@ -67,7 +60,7 @@ public JCAOrderedLastSynchronizationList(com.arjuna.ats.jta.transaction.Transact
      * @throws SystemException In case the transaction status was not known
      */
     public void registerInterposedSynchronization(Synchronization synchronization) throws IllegalStateException, SystemException {
-        int status = tx.getStatus();
+        int status = ContextTransactionSynchronizationRegistry.getInstance().getTransactionStatus();
         switch (status) {
             case javax.transaction.Status.STATUS_ACTIVE:
             case javax.transaction.Status.STATUS_PREPARING:
@@ -148,7 +141,7 @@ public void afterCompletion(int status) {
             } catch (Exception e) {
                 // Trap these exceptions so the rest of the synchronizations get the chance to complete
                 // https://github.com/jbosstm/narayana/blob/5.0.4.Final/ArjunaJTA/jta/classes/com/arjuna/ats/internal/jta/resources/arjunacore/SynchronizationImple.java#L102
-                TransactionLogger.ROOT_LOGGER.preJcaSyncAfterCompletionFailed(preJcaSync, tx, e);
+                TransactionLogger.ROOT_LOGGER.preJcaSyncAfterCompletionFailed(preJcaSync, ContextTransactionManager.getInstance().getTransaction(), e);
             }
         }
         for (int i = jcaSyncs.size() - 1; i>= 0; --i) {
@@ -164,29 +157,7 @@ public void afterCompletion(int status) {
             } catch (Exception e) {
                 // Trap these exceptions so the rest of the synchronizations get the chance to complete
                 // https://github.com/jbosstm/narayana/blob/5.0.4.Final/ArjunaJTA/jta/classes/com/arjuna/ats/internal/jta/resources/arjunacore/SynchronizationImple.java#L102
-                TransactionLogger.ROOT_LOGGER.jcaSyncAfterCompletionFailed(jcaSync, tx, e);
-            }
-        }
-
-        if (jcaOrderedLastSynchronizations.remove(tx) == null) {
-            // The identifier wasn't stable - scan for it - this can happen in JTS propagation when the UID needs retrieving
-            // from the parent and the parent has been deactivated
-            Transaction altKey = null;
-            Iterator<Entry<Transaction, JCAOrderedLastSynchronizationList>> iterator = jcaOrderedLastSynchronizations.entrySet().iterator();
-            while (altKey == null && iterator.hasNext()) {
-                Map.Entry<Transaction, JCAOrderedLastSynchronizationList> next = iterator.next();
-                if (next.getValue().equals(this)) {
-                    altKey = next.getKey();
-                    iterator.remove();
-                    if (TransactionLogger.ROOT_LOGGER.isTraceEnabled()) {
-                        TransactionLogger.ROOT_LOGGER.tracef("Removed: %s [%s]", System.identityHashCode(tx), tx.toString());
-                    }
-                    break;
-                }
-            }
-
-            if (altKey == null) {
-                TransactionLogger.ROOT_LOGGER.transactionNotFound(tx);
+                TransactionLogger.ROOT_LOGGER.jcaSyncAfterCompletionFailed(jcaSync, ContextTransactionManager.getInstance().getTransaction(), e);
             }
         }
     }

transactions/src/main/java/org/jboss/as/txn/service/internal/tsr/TransactionSynchronizationRegistryWrapper.java

@@ -21,14 +21,14 @@
  */
 package org.jboss.as.txn.service.internal.tsr;
 
-import java.util.concurrent.ConcurrentHashMap;
-
 import javax.transaction.Synchronization;
 import javax.transaction.SystemException;
-import javax.transaction.Transaction;
-import javax.transaction.TransactionManager;
 import javax.transaction.TransactionSynchronizationRegistry;
 
+import org.wildfly.transaction.client.AbstractTransaction;
+import org.wildfly.transaction.client.ContextTransactionManager;
+import org.wildfly.transaction.client.ContextTransactionSynchronizationRegistry;
+
 /**
  * Most of this implementation delegates down to the underlying transactions implementation to provide the services of the
  * TransactionSynchronizationRegistry. The one area it modifies is the registration of the interposed Synchronizations. The
@@ -51,28 +51,26 @@
  */
 public class TransactionSynchronizationRegistryWrapper implements TransactionSynchronizationRegistry {
 
-    private TransactionSynchronizationRegistry delegate;
-    private TransactionManager transactionManager;
-    private ConcurrentHashMap<Transaction, JCAOrderedLastSynchronizationList> interposedSyncs = new ConcurrentHashMap<Transaction, JCAOrderedLastSynchronizationList>();
+    private final Object key = new Object();
 
-    public TransactionSynchronizationRegistryWrapper(TransactionSynchronizationRegistry delegate) {
-        this.delegate = delegate;
-        transactionManager = com.arjuna.ats.jta.TransactionManager
-            .transactionManager();
+    public TransactionSynchronizationRegistryWrapper() {
     }
 
     @Override
     public void registerInterposedSynchronization(Synchronization sync)
         throws IllegalStateException {
         try {
-            Transaction tx = transactionManager.getTransaction();
-            JCAOrderedLastSynchronizationList jcaOrderedLastSynchronization = interposedSyncs.get(tx);
+            AbstractTransaction tx = ContextTransactionManager.getInstance().getTransaction();
+            JCAOrderedLastSynchronizationList jcaOrderedLastSynchronization = (JCAOrderedLastSynchronizationList) tx.getResource(key);
             if (jcaOrderedLastSynchronization == null) {
-                JCAOrderedLastSynchronizationList toPut = new JCAOrderedLastSynchronizationList((com.arjuna.ats.jta.transaction.Transaction) tx, interposedSyncs);
-                jcaOrderedLastSynchronization = interposedSyncs.putIfAbsent(tx, toPut);
-                if (jcaOrderedLastSynchronization == null) {
-                    jcaOrderedLastSynchronization = toPut;
-                    delegate.registerInterposedSynchronization(jcaOrderedLastSynchronization);
+                final ContextTransactionSynchronizationRegistry tsr = ContextTransactionSynchronizationRegistry.getInstance();
+                synchronized (key) {
+                    jcaOrderedLastSynchronization = (JCAOrderedLastSynchronizationList) tx.getResource(key);
+                    if (jcaOrderedLastSynchronization == null) {
+                        jcaOrderedLastSynchronization = new JCAOrderedLastSynchronizationList();
+                        tx.putResource(key, jcaOrderedLastSynchronization);
+                        tsr.registerInterposedSynchronization(jcaOrderedLastSynchronization);
+                    }
                 }
             }
             jcaOrderedLastSynchronization.registerInterposedSynchronization(sync);
@@ -83,33 +81,33 @@ public void registerInterposedSynchronization(Synchronization sync)
 
     @Override
     public Object getTransactionKey() {
-        return delegate.getTransactionKey();
+        return ContextTransactionSynchronizationRegistry.getInstance().getTransactionKey();
     }
 
     @Override
     public int getTransactionStatus() {
-        return delegate.getTransactionStatus();
+        return ContextTransactionSynchronizationRegistry.getInstance().getTransactionStatus();
     }
 
     @Override
     public boolean getRollbackOnly() throws IllegalStateException {
-        return delegate.getRollbackOnly();
+        return ContextTransactionSynchronizationRegistry.getInstance().getRollbackOnly();
     }
 
     @Override
     public void setRollbackOnly() throws IllegalStateException {
-        delegate.setRollbackOnly();
+        ContextTransactionSynchronizationRegistry.getInstance().setRollbackOnly();
     }
 
     @Override
     public Object getResource(Object key) throws IllegalStateException {
-        return delegate.getResource(key);
+        return ContextTransactionSynchronizationRegistry.getInstance().getResource(key);
     }
 
     @Override
     public void putResource(Object key, Object value)
         throws IllegalStateException {
-        delegate.putResource(key, value);
+        ContextTransactionSynchronizationRegistry.getInstance().putResource(key, value);
     }
 
 }

transactions/src/test/java/org/jboss/as/txn/TestWildFlyTSR.java

@@ -11,10 +11,14 @@
 import javax.transaction.TransactionManager;
 import javax.transaction.TransactionSynchronizationRegistry;
 
+import com.arjuna.ats.internal.jta.transaction.arjunacore.jca.XATerminatorImple;
 import org.jboss.as.txn.service.internal.tsr.TransactionSynchronizationRegistryWrapper;
 import org.junit.Test;
 
 import com.arjuna.ats.jta.common.jtaPropertyManager;
+import org.wildfly.transaction.client.ContextTransactionManager;
+import org.wildfly.transaction.client.LocalTransactionContext;
+import org.wildfly.transaction.client.provider.jboss.JBossLocalTransactionProvider;
 
 public class TestWildFlyTSR {
     boolean innerSyncCalled = false;
@@ -23,8 +27,14 @@ public class TestWildFlyTSR {
     public void test() throws NotSupportedException, SystemException, SecurityException, IllegalStateException, RollbackException, HeuristicMixedException, HeuristicRollbackException {
         jtaPropertyManager.getJTAEnvironmentBean().setTransactionManagerClassName("com.arjuna.ats.internal.jta.transaction.arjunacore.TransactionManagerImple");
         final TransactionSynchronizationRegistry tsr =
-            new TransactionSynchronizationRegistryWrapper(new com.arjuna.ats.internal.jta.transaction.arjunacore.TransactionSynchronizationRegistryImple());
-        TransactionManager transactionManager = com.arjuna.ats.jta.TransactionManager.transactionManager();
+            new TransactionSynchronizationRegistryWrapper();
+        final JBossLocalTransactionProvider.Builder builder = JBossLocalTransactionProvider.builder();
+        builder.setTransactionManager(com.arjuna.ats.jta.TransactionManager.transactionManager());
+        builder.setExtendedJBossXATerminator(new XATerminatorImple());
+        LocalTransactionContext.getContextManager().setGlobalDefault(new LocalTransactionContext(
+            builder.build()
+        ));
+        TransactionManager transactionManager = ContextTransactionManager.getInstance();
         transactionManager.begin();
         tsr.registerInterposedSynchronization(new Synchronization() {
             @Override