@Override public TransactionConfiguration get() { TransactionConfigurationBuilder builder = new ConfigurationBuilder().transaction() .lockingMode(this.locking) .cacheStopTimeout(this.timeout) .transactionMode((this.mode == TransactionMode.NONE) ? org.infinispan.transaction.TransactionMode.NON_TRANSACTIONAL : org.infinispan.transaction.TransactionMode.TRANSACTIONAL) .useSynchronization(this.mode == TransactionMode.NON_XA) .recovery().enabled(this.mode == TransactionMode.FULL_XA).transaction() ; switch (this.mode) { case NONE: { break; } case BATCH: { builder.transactionManagerLookup(new TransactionManagerProvider(EmbeddedTransactionManager.getInstance())); break; } case NON_XA: { builder.transactionSynchronizationRegistryLookup(new TransactionSynchronizationRegistryProvider(this.tsrDependency.get())); // fall through } default: { builder.transactionManagerLookup(new TransactionManagerProvider(ContextTransactionManager.getInstance())); } } return builder.create(); } }
/** * Marks the transaction as rollback-only. */ public void setRollbackOnly() { try { tx.setRollbackOnly(); } catch (SystemException e) { //our tx implementation doesn't throw SystemException throw new IllegalStateException(e); } }
private EmbeddedTransaction newTx(Xid xid) { EmbeddedTransaction tx = new EmbeddedTransaction(EmbeddedTransactionManager.getInstance()); tx.setXid(xid); return tx; }
public void testNumberOfLocksHeld() throws Exception { EmbeddedTransactionManager tm = (EmbeddedTransactionManager) tm(); tm.begin(); cache.put("key", "value"); tm.getTransaction().runPrepare(); assertAttributeValue("NumberOfLocksHeld", 1); tm.getTransaction().runCommit(false); assertAttributeValue("NumberOfLocksHeld", 0); }
@Override public void registerSynchronization(Synchronization synchronization) { try { BatchModeTransactionManager.getInstance().getTransaction().registerSynchronization(synchronization); } catch (RollbackException e) { throw new RuntimeException(e); } catch (SystemException e) { throw new RuntimeException(e); } } };
@Override public boolean isActive() { try { return BatchModeTransactionManager.getInstance().getStatus() == Status.STATUS_ACTIVE; } catch (SystemException e) { return false; } }
protected void rollback() { EmbeddedTransactionManager dtm = (EmbeddedTransactionManager) tm(); try { dtm.getTransaction().rollback(); } catch (SystemException e) { throw new RuntimeException(e); } }
protected void prepare() { EmbeddedTransactionManager dtm = (EmbeddedTransactionManager) tm(0); dtm.getTransaction().runPrepare(); }
protected void commit() { EmbeddedTransactionManager dtm = (EmbeddedTransactionManager) tm(0); try { dtm.getTransaction().runCommit(false); } catch (HeuristicMixedException | HeuristicRollbackException | RollbackException e) { throw new RuntimeException(e); } }
@Override public TransactionStatus getStatus() { try { EmbeddedTransaction transaction = tm.getTransaction(); return transaction == null ? TransactionStatus.NOT_ACTIVE : StatusTranslator.translate(transaction.getStatus()); } catch (SystemException e) { throw new RuntimeException(e); } }
@Override public TransactionManager retrieveTransactionManager() { try { return BatchModeTransactionManager.getInstance(); } catch (Exception e) { throw new HibernateException("Failed getting BatchModeTransactionManager", e); } }
@Override public synchronized TransactionManager getTransactionManager() throws Exception { DummyTransactionManager dtm = new DummyTransactionManager(); dtm.setUseXaXid(true); return dtm; } }
@Override public void begin() { try { tm.begin(); } catch (Exception e) { throw new RuntimeException(e); } }
@Override public void commit() { try { tm.commit(); } catch (Exception e) { throw new RuntimeException(e); } }
@Override public void rollback() { try { tm.rollback(); } catch (Exception e) { throw new RuntimeException(e); } }
private Xid getXid() throws SystemException { Xid xid; EmbeddedTransaction dummyTransaction = (EmbeddedTransaction) tm().getTransaction(); xid = dummyTransaction.getXid(); return xid; }
public void testCommitOnNonexistentXid() { EmbeddedXid xid = new EmbeddedXid(uuid); try { xaAdapter.commit(xid, false); assert false; } catch (XAException e) { assertEquals(XAException.XAER_NOTA, e.errorCode); } }
public void testLocksOnRemoveNonexistent() throws Exception { LockTestData tl = lockTestData; Cache<String, String> cache = tl.cache; EmbeddedTransactionManager tm = tl.tm; assert !cache.containsKey("k") : "Should not exist"; tm.begin(); cache.remove("k"); tm.getTransaction().runPrepare(); assertLocked("k"); tm.getTransaction().runCommit(false); assert !cache.containsKey("k") : "Should not exist"; assertNoLocks(); }
protected void rollback() { EmbeddedTransactionManager dtm = (EmbeddedTransactionManager) tm(0); try { dtm.getTransaction().rollback(); } catch (SystemException e) { throw new RuntimeException(e); } }
public void testNumberOfLocksAvailable() throws Exception { EmbeddedTransactionManager tm = (EmbeddedTransactionManager) tm(); int initialAvailable = getAttrValue("NumberOfLocksAvailable"); tm.begin(); cache.put("key", "value"); tm.getTransaction().runPrepare(); assertAttributeValue("NumberOfLocksHeld", 1); assertAttributeValue("NumberOfLocksAvailable", initialAvailable - 1); tm.getTransaction().runCommit(true); assertAttributeValue("NumberOfLocksAvailable", initialAvailable); assertAttributeValue("NumberOfLocksHeld", 0); }