protected void commit() { EmbeddedTransactionManager dtm = (EmbeddedTransactionManager) tm(0); try { dtm.getTransaction().runCommit(false); } catch (HeuristicMixedException | HeuristicRollbackException | RollbackException e) { throw new RuntimeException(e); } }
protected void rollback() { EmbeddedTransactionManager dtm = (EmbeddedTransactionManager) tm(); try { dtm.getTransaction().rollback(); } catch (SystemException e) { throw new RuntimeException(e); } }
protected void rollback() { EmbeddedTransactionManager dtm = (EmbeddedTransactionManager) tm(0); try { dtm.getTransaction().rollback(); } catch (SystemException e) { throw new RuntimeException(e); } }
protected void prepare() { EmbeddedTransactionManager dtm = (EmbeddedTransactionManager) tm(0); dtm.getTransaction().runPrepare(); }
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); }
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(); }
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); }
public void testReadOnlyResource() throws Exception { //test for ISPN-2813 EmbeddedTransactionManager transactionManager = EmbeddedTransactionManager.getInstance(); transactionManager.begin(); cacheManager.<String, String>getCache(SYNC_CACHE_NAME).put(KEY, VALUE); cacheManager.<String, String>getCache(XA_CACHE_NAME).put(KEY, VALUE); transactionManager.getTransaction().enlistResource(new ReadOnlyXaResource()); transactionManager.commit(); assertData(); assertNoTxInAllCaches(); assertNull(transactionManager.getTransaction()); }
public void testLocksOnPutKeyVal() throws Exception { Cache<String, String> cache = lockTestData.cache; EmbeddedTransactionManager tm = lockTestData.tm; tm.begin(); cache.put("k", "v"); assertTrue(tm.getTransaction().runPrepare()); assertLocked("k"); tm.getTransaction().runCommit(false); assertNoLocks(); tm.begin(); assertEquals("v", cache.get("k")); assertNotLocked("k"); tm.commit(); assertNoLocks(); tm.begin(); cache.remove("k"); assertTrue(tm.getTransaction().runPrepare()); assertLocked("k"); tm.getTransaction().runCommit(false); assertNoLocks(); }
public void testConcurrentWriters() throws Exception { LockTestData tl = lockTestData; Cache<String, String> cache = tl.cache; EmbeddedTransactionManager tm = tl.tm; tm.begin(); cache.put("k", "v"); final EmbeddedTransaction transaction = tm.getTransaction(); assertTrue(transaction.runPrepare()); tm.suspend(); tm.begin(); cache.put("k", "v"); assert !tm.getTransaction().runPrepare(); tm.rollback(); tm.resume(transaction); transaction.runCommit(false); assertNoLocks(); }
private void doAfterCompletionFailTest(Collection<RegisterTransaction> registerTransactionCollection) throws Exception { EmbeddedTransactionManager transactionManager = EmbeddedTransactionManager.getInstance(); transactionManager.begin(); for (RegisterTransaction registerTransaction : registerTransactionCollection) { registerTransaction.register(transactionManager); } transactionManager.commit(); assertData(); assertNoTxInAllCaches(); assertNull(transactionManager.getTransaction()); }
public void testOneTx() throws Exception { embeddedTm().begin(); cache.put("k", "v"); TransactionXaAdapter xaRes = (TransactionXaAdapter) embeddedTm().firstEnlistedResource(); assertPrepared(0, embeddedTm().getTransaction()); xaRes.prepare(xaRes.getLocalTransaction().getXid()); assertPrepared(1, embeddedTm().getTransaction()); final EmbeddedTransaction suspend = (EmbeddedTransaction) embeddedTm().suspend(); xaRes.commit(xaRes.getLocalTransaction().getXid(), false); assertPrepared(0, suspend); assertEquals(0, TestingUtil.getTransactionTable(cache).getLocalTxCount()); }
private void doCommitWithRollbackExceptionTest(Collection<RegisterTransaction> registerTransactionCollection) throws Exception { EmbeddedTransactionManager transactionManager = EmbeddedTransactionManager.getInstance(); transactionManager.begin(); for (RegisterTransaction registerTransaction : registerTransactionCollection) { registerTransaction.register(transactionManager); } try { transactionManager.commit(); AssertJUnit.fail("RollbackException expected!"); } catch (RollbackException e) { //expected } assertEmpty(); assertNoTxInAllCaches(); assertNull(transactionManager.getTransaction()); }
private void doCommitWithHeuristicExceptionTest(Collection<RegisterTransaction> registerTransactionCollection) throws Exception { EmbeddedTransactionManager transactionManager = EmbeddedTransactionManager.getInstance(); transactionManager.begin(); for (RegisterTransaction registerTransaction : registerTransactionCollection) { registerTransaction.register(transactionManager); } try { transactionManager.commit(); AssertJUnit.fail("HeuristicMixedException expected!"); } catch (HeuristicMixedException e) { //expected } assertData(); assertNoTxInAllCaches(); assertNull(transactionManager.getTransaction()); }
private void doRollbackWithHeuristicExceptionTest(Collection<RegisterTransaction> registerTransactionCollection) throws Exception { EmbeddedTransactionManager transactionManager = EmbeddedTransactionManager.getInstance(); transactionManager.begin(); for (RegisterTransaction registerTransaction : registerTransactionCollection) { registerTransaction.register(transactionManager); } try { transactionManager.rollback(); AssertJUnit.fail("SystemException expected!"); } catch (SystemException e) { //expected } assertEmpty(); assertNoTxInAllCaches(); assertNull(transactionManager.getTransaction()); }
public void testLocksOnRemoveData() throws Exception { LockTestData tl = lockTestData; Cache<String, String> cache = tl.cache; EmbeddedTransactionManager tm = tl.tm; // init some data cache.put("k", "v"); cache.put("k2", "v2"); assertEquals("v", cache.get("k")); assertEquals("v2", cache.get("k2")); // remove tm.begin(); cache.remove("k"); cache.remove("k2"); assertTrue(tm.getTransaction().runPrepare()); assertLocked("k"); assertLocked("k2"); tm.getTransaction().runCommit(false); assert cache.isEmpty(); assertNoLocks(); }
@Test(groups = "functional", expectedExceptions = { CacheException.class }) public void testLockAcquisitionTimeout() throws Exception { AdvancedCache<Object, Object> cache1 = advancedCache(0, "syncReplCache"); AdvancedCache<Object, Object> cache2 = advancedCache(1, "syncReplCache"); cache1.getCacheConfiguration().locking().lockAcquisitionTimeout(10); cache2.getCacheConfiguration().locking().lockAcquisitionTimeout(10); TestingUtil.blockUntilViewsReceived(10000, cache1, cache2); // get a lock on cache 2 and hold on to it. EmbeddedTransactionManager tm = (EmbeddedTransactionManager) TestingUtil.getTransactionManager(cache2); tm.begin(); cache2.put("block", "block"); assertTrue(tm.getTransaction().runPrepare()); tm.suspend(); cache1.put("block", "v"); }
private void testLockMigrationAfterPrepare(Object key) throws Exception { final EmbeddedTransactionManager tm = embeddedTm(ORIGINATOR_INDEX); tm.begin(); originatorCache.put(key, "value"); EmbeddedTransaction tx = tm.getTransaction(); boolean prepareSuccess = tx.runPrepare(); assert prepareSuccess; tm.suspend(); log.trace("Lock transfer happens here"); killCache(); checkNewTransactionFails(key); log.trace("About to commit existing transaction."); tm.resume(tx); tx.runCommit(false); // read the data from the container, just to make sure all replicas are correctly set checkValue(key, "value"); }
public void testSplitBeforeRollback() throws Exception { //the transaction is successfully prepare and then the split happens before the commit phase starts. waitForClusterToForm(OPTIMISTIC_TX_CACHE_NAME); final KeyInfo keyInfo = createKeys(OPTIMISTIC_TX_CACHE_NAME); final Cache<Object, String> originator = cache(0, OPTIMISTIC_TX_CACHE_NAME); final EmbeddedTransactionManager transactionManager = (EmbeddedTransactionManager) originator.getAdvancedCache().getTransactionManager(); transactionManager.begin(); final EmbeddedTransaction transaction = transactionManager.getTransaction(); keyInfo.putFinalValue(originator); AssertJUnit.assertTrue(transaction.runPrepare()); transactionManager.suspend(); SplitMode.BOTH_DEGRADED.split(this); transactionManager.resume(transaction); transaction.runCommit(true); assertEventuallyNotLocked(cache(1, OPTIMISTIC_TX_CACHE_NAME), keyInfo.getKey1()); assertLocked(cache(2, OPTIMISTIC_TX_CACHE_NAME), keyInfo.getKey2()); mergeCluster(OPTIMISTIC_TX_CACHE_NAME); finalAsserts(OPTIMISTIC_TX_CACHE_NAME, keyInfo, INITIAL_VALUE); }
public void testSplitBeforeCommit() throws Exception { //the transaction is successfully prepare and then the split happens before the commit phase starts. waitForClusterToForm(OPTIMISTIC_TX_CACHE_NAME); final KeyInfo keyInfo = createKeys(OPTIMISTIC_TX_CACHE_NAME); final Cache<Object, String> originator = cache(0, OPTIMISTIC_TX_CACHE_NAME); final EmbeddedTransactionManager transactionManager = (EmbeddedTransactionManager) originator.getAdvancedCache().getTransactionManager(); transactionManager.begin(); final EmbeddedTransaction transaction = transactionManager.getTransaction(); keyInfo.putFinalValue(originator); AssertJUnit.assertTrue(transaction.runPrepare()); transactionManager.suspend(); SplitMode.BOTH_DEGRADED.split(this); transactionManager.resume(transaction); transaction.runCommit(false); assertLocked(cache(1, OPTIMISTIC_TX_CACHE_NAME), keyInfo.getKey1()); assertLocked(cache(2, OPTIMISTIC_TX_CACHE_NAME), keyInfo.getKey2()); mergeCluster(OPTIMISTIC_TX_CACHE_NAME); finalAsserts(OPTIMISTIC_TX_CACHE_NAME, keyInfo, FINAL_VALUE); }