org.infinispan.hotrod.transaction.lookup.GenericTransactionManagerLookup Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of infinispan-hotrod-jakarta Show documentation

Infinispan Hot Rod Client Jakarta EE

There is a newer version: 14.0.33.Final

Show newest version

package org.infinispan.hotrod.transaction.lookup;

import java.util.Optional;

import javax.naming.InitialContext;
import javax.naming.NamingException;
import jakarta.transaction.TransactionManager;

import org.infinispan.hotrod.transaction.manager.RemoteTransactionManager;
import org.infinispan.commons.util.Util;
import org.infinispan.commons.tx.lookup.LookupNames;
import org.infinispan.commons.tx.lookup.TransactionManagerLookup;

import net.jcip.annotations.GuardedBy;

/**
 * A {@link TransactionManagerLookup} implementation that attempts to locate a {@link TransactionManager}.
 * 
 * A variety of different classes and JNDI locations are tried, for servers such as: 
  JBoss 
 JRun4 

 * Resin 
 Orion 
 JOnAS 
 BEA Weblogic 
 Websphere 4.0, 5.0, 5.1, 6.0 
 Sun, Glassfish .
 * 
 * If a transaction manager is not found, returns an {@link RemoteTransactionManager}.
 *
 * @since 14.0
 */
public class GenericTransactionManagerLookup implements TransactionManagerLookup {

   private static final GenericTransactionManagerLookup INSTANCE = new GenericTransactionManagerLookup();
   @GuardedBy("this")
   private TransactionManager transactionManager = null;

   private GenericTransactionManagerLookup() {
   }

   public static GenericTransactionManagerLookup getInstance() {
      return INSTANCE;
   }

   @Override
   public synchronized TransactionManager getTransactionManager() {
      if (transactionManager != null) {
         return transactionManager;
      }

      transactionManager = tryTmFactoryLookup().orElseGet(RemoteTransactionManager::getInstance);
      transactionManager = tryJndiLookup().orElseGet(
            () -> tryTmFactoryLookup().orElseGet(RemoteTransactionManager::getInstance));
      return transactionManager;
   }

   private Optional tryJndiLookup() {
      InitialContext ctx;
      try {
         ctx = new InitialContext();
      } catch (NamingException e) {
         return Optional.empty();
      }

      try {
         //probe jndi lookups first
         for (LookupNames.JndiTransactionManager knownJNDIManager : LookupNames.JndiTransactionManager.values()) {
            Object jndiObject;
            try {
               jndiObject = ctx.lookup(knownJNDIManager.getJndiLookup());
            } catch (NamingException e) {
               continue;
            }
            if (jndiObject instanceof TransactionManager) {
               return Optional.of((TransactionManager) jndiObject);
            }
         }
      } finally {
         Util.close(ctx);
      }
      return Optional.empty();
   }

   private Optional tryTmFactoryLookup() {
      for (LookupNames.TransactionManagerFactory transactionManagerFactory : LookupNames.TransactionManagerFactory
            .values()) {
         TransactionManager transactionManager = transactionManagerFactory
               .tryLookup(GenericTransactionManagerLookup.class.getClassLoader());
         if (transactionManager != null) {
            return Optional.of(transactionManager);
         }
      }
      return Optional.empty();
   }
}