public void afterCommitOrRollback(EhcacheXAResource xaResource) { transactionManagerLookup.unregister(xaResource, false); } }
/** * Lookup available txnManagers * * @return TransactionManager */ public TransactionManager getTransactionManager() { if (selector == null) { lock.lock(); try { if (selector == null) { lookupTransactionManager(); } } finally { lock.unlock(); } } return selector.getTransactionManager(); }
private Transaction getCurrentTransaction() throws SystemException { Transaction transaction = transactionManagerLookup.getTransactionManager().getTransaction(); if (transaction == null) { throw new TransactionException("JTA transaction not started"); } return transaction; }
/** * {@inheritDoc} */ public void init() { if (!initialized) { lock.lock(); try { Iterator<EhcacheXAResource> iterator = uninitializedEhcacheXAResources.iterator(); while (iterator.hasNext()) { if (getTransactionManager() == null) { throw new CacheException("No Transaction Manager could be located, cannot initialize DefaultTransactionManagerLookup." + " Caches which registered an XAResource: " + getUninitializedXAResourceCacheNames()); } EhcacheXAResource resource = iterator.next(); selector.registerResource(resource, true); iterator.remove(); } } finally { lock.unlock(); } initialized = true; } }
/** * Constructor * @param transactionManagerLookup the transaction manager lookup implementation * @param softLockManager the soft lock manager * @param transactionIdFactory the transaction ID factory * @param cache the cache * @param store the underlying store */ public XATransactionStore(TransactionManagerLookup transactionManagerLookup, SoftLockManager softLockManager, TransactionIDFactory transactionIdFactory, Ehcache cache, Store store, ElementValueComparator comparator) { super(store); this.transactionManagerLookup = transactionManagerLookup; this.transactionIdFactory = transactionIdFactory; this.comparator = comparator; if (transactionManagerLookup.getTransactionManager() == null) { throw new TransactionException("no JTA transaction manager could be located, cannot bind twopc cache with JTA"); } this.softLockManager = softLockManager; this.cache = cache; // this xaresource is for initial registration and recovery this.recoveryResource = new EhcacheXAResourceImpl(cache, underlyingStore, transactionManagerLookup, softLockManager, transactionIdFactory, comparator, commitObserver, rollbackObserver, recoveryObserver); transactionManagerLookup.register(recoveryResource, true); }
private XATransactionContext getOrCreateTransactionContext() { try { EhcacheXAResourceImpl xaResource = getOrCreateXAResource(); XATransactionContext transactionContext = xaResource.getCurrentTransactionContext(); if (transactionContext == null) { transactionManagerLookup.register(xaResource, false); LOG.debug("creating new XA context"); transactionContext = xaResource.createTransactionContext(); xaResource.addTwoPcExecutionListener(new UnregisterXAResource()); } else { transactionContext = xaResource.getCurrentTransactionContext(); } LOG.debug("using XA context {}", transactionContext); return transactionContext; } catch (SystemException e) { throw new TransactionException("cannot get the current transaction", e); } catch (RollbackException e) { throw new TransactionException("transaction rolled back", e); } }
.loadClass(lookupConfiguration.getFullyQualifiedClassPath()); this.transactionManagerLookup = transactionManagerLookupClass.newInstance(); this.transactionManagerLookup.setProperties(properties); } catch (Exception e) { LOG.error("could not instantiate transaction manager lookup class: {}", lookupConfiguration.getFullyQualifiedClassPath(), e);
/** * Create a new JtaLocalTransactionStore instance * @param underlyingStore the underlying LocalTransactionStore * @param transactionManagerLookup the TransactionManagerLookup * @param transactionController the TransactionController */ public JtaLocalTransactionStore(LocalTransactionStore underlyingStore, TransactionManagerLookup transactionManagerLookup, TransactionController transactionController) { super(underlyingStore); this.transactionManagerLookup = transactionManagerLookup; this.transactionController = transactionController; this.transactionManager = transactionManagerLookup.getTransactionManager(); if (this.transactionManager == null) { throw new TransactionException("no JTA transaction manager could be located"); } this.cache = underlyingStore.getCache(); if (transactionManager.getClass().getName().contains("atomikos")) { System.setProperty(ALTERNATIVE_TERMINATION_MODE_SYS_PROPERTY_NAME, "true"); if (ATOMIKOS_WARNING_ISSUED.compareAndSet(false, true)) { LOG.warn("Atomikos transaction manager detected, make sure you configured com.atomikos.icatch.threaded_2pc=false"); } } }
@Override public void dispose() { super.dispose(); transactionManagerLookup.unregister(recoveryResource, true); }
private XATransactionContext getTransactionContext() { try { Transaction transaction = getCurrentTransaction(); EhcacheXAResourceImpl xaResource = (EhcacheXAResourceImpl) transactionToXAResourceMap.get(transaction); if (xaResource == null) { return null; } XATransactionContext transactionContext = xaResource.getCurrentTransactionContext(); if (transactionContext == null) { transactionManagerLookup.register(xaResource, false); LOG.debug("creating new XA context"); transactionContext = xaResource.createTransactionContext(); xaResource.addTwoPcExecutionListener(new UnregisterXAResource()); } else { transactionContext = xaResource.getCurrentTransactionContext(); } LOG.debug("using XA context {}", transactionContext); return transactionContext; } catch (SystemException e) { throw new TransactionException("cannot get the current transaction", e); } catch (RollbackException e) { throw new TransactionException("transaction rolled back", e); } }
/** * Constructor * @param cache the cache * @param underlyingStore the underlying store * @param txnManagerLookup the transaction manager lookup * @param softLockManager the soft lock manager * @param transactionIDFactory the transaction ID factory * @param comparator the element value comparator */ public EhcacheXAResourceImpl(Ehcache cache, Store underlyingStore, TransactionManagerLookup txnManagerLookup, SoftLockManager softLockManager, TransactionIDFactory transactionIDFactory, ElementValueComparator comparator, OperationObserver<XaCommitOutcome> commitObserver, OperationObserver<XaRollbackOutcome> rollbackObserver, OperationObserver<XaRecoveryOutcome> recoveryObserver) { this.cache = cache; this.underlyingStore = underlyingStore; this.transactionIDFactory = transactionIDFactory; this.txnManager = txnManagerLookup.getTransactionManager(); this.softLockManager = softLockManager; this.processor = new XARequestProcessor(this); this.transactionTimeout = cache.getCacheManager().getTransactionController().getDefaultTransactionTimeout(); this.comparator = comparator; this.commitObserver = commitObserver; this.rollbackObserver = rollbackObserver; this.recoveryObserver = recoveryObserver; }
public void commit(Xid xid, boolean onePhase) throws XAException { transactionController.commit(true); JtaLocalTransactionStore.BOUND_JTA_TRANSACTIONS.remove(); transactionManagerLookup.unregister(this, false); }
transactionManagerLookup.register(xaRes, false); tx.enlistResource(xaRes); } else {
/** * {@inheritDoc} */ public int getTerracottaClusteredSize() { try { Transaction transaction = transactionManagerLookup.getTransactionManager().getTransaction(); if (transaction == null) { return underlyingStore.getTerracottaClusteredSize(); } } catch (SystemException se) { throw new TransactionException("cannot get the current transaction", se); } LOG.debug("cache {} getTerracottaClusteredSize", cache.getName()); XATransactionContext context = getOrCreateTransactionContext(); int size = underlyingStore.getTerracottaClusteredSize(); return size + context.getSizeModifier(); }
public void rollback(Xid xid) throws XAException { transactionController.rollback(); JtaLocalTransactionStore.BOUND_JTA_TRANSACTIONS.remove(); transactionManagerLookup.unregister(this, false); }
/** * Check if a transaction has begun on the current thread if the cache is configured as * transactional, otherwise always return false. * @param cache the cache to check if a transaction started for * @return true if the cache is transactional and a transaction started, false otherwise * @throws CacheException if anything wrong happens */ public static boolean isTransactionStarted(Ehcache cache) throws CacheException { try { switch (cache.getCacheConfiguration().getTransactionalMode()) { case LOCAL: TransactionController ctrl = cache.getCacheManager().getTransactionController(); return ctrl.getCurrentTransactionContext() != null; case XA: case XA_STRICT: Object tm = ((net.sf.ehcache.Cache) cache).getTransactionManagerLookup().getTransactionManager(); return ((Integer) tm.getClass().getMethod("getStatus").invoke(tm)) != XA_STATUS_NO_TRANSACTION; case OFF: default: return false; } } catch (Exception e) { e.printStackTrace(); throw new CacheException("error checking if transaction started: " + e); } }
/** * Begin a transaction on the current thread if the cache is configured as transactional, * otherwise this method does nothing. * * @param cache the cache to begin a transaction for * @throws CacheException if anything wrong happens */ public static void beginTransactionIfNeeded(Ehcache cache) throws CacheException { try { switch (cache.getCacheConfiguration().getTransactionalMode()) { case LOCAL: TransactionController ctrl = cache.getCacheManager().getTransactionController(); ctrl.begin(); break; case XA: case XA_STRICT: Object tm = ((net.sf.ehcache.Cache) cache).getTransactionManagerLookup().getTransactionManager(); tm.getClass().getMethod("begin").invoke(tm); break; case OFF: default: break; } } catch (Exception e) { e.printStackTrace(); throw new CacheException("error beginning transaction:" + e); } }
Object tm = ((net.sf.ehcache.Cache) cache).getTransactionManagerLookup().getTransactionManager(); tm.getClass().getMethod("commit").invoke(tm); break;
private AbstractTransactionStore makeTransactional(final Store store) { AbstractTransactionStore wrappedStore; if (configuration.isXaStrictTransactional()) { if (transactionManagerLookup.getTransactionManager() == null) { throw new CacheException("You've configured cache " + cacheManager.getName() + "." + configuration.getName() + " to be transactional, but no TransactionManager could be found!"); } // set xa enabled if (configuration.isTerracottaClustered()) { configuration.getTerracottaConfiguration().setCacheXA(true); } SoftLockManager softLockManager = cacheManager.createSoftLockManager(this); TransactionIDFactory transactionIDFactory = cacheManager.getOrCreateTransactionIDFactory(); wrappedStore = new XATransactionStore(transactionManagerLookup, softLockManager, transactionIDFactory, this, store, elementValueComparator); } else if (configuration.isXaTransactional()) { SoftLockManager softLockManager = cacheManager.createSoftLockManager(this); LocalTransactionStore localTransactionStore = new LocalTransactionStore(getCacheManager().getTransactionController(), getCacheManager().getOrCreateTransactionIDFactory(), softLockManager, this, store, elementValueComparator); wrappedStore = new JtaLocalTransactionStore(localTransactionStore, transactionManagerLookup, cacheManager.getTransactionController()); } else if (configuration.isLocalTransactional()) { SoftLockManager softLockManager = cacheManager.createSoftLockManager(this); wrappedStore = new LocalTransactionStore(getCacheManager().getTransactionController(), getCacheManager() .getOrCreateTransactionIDFactory(), softLockManager, this, store, elementValueComparator); } else { throw new IllegalStateException("Method should called only with a transactional configuration"); } return wrappedStore; }
if (transactionManagerLookup.getTransactionManager() == null) { throw new CacheException("You've configured cache " + cacheManager.getName() + "." + configuration.getName() + " to be transactional, but no TransactionManager could be found!");