@Override public Object call() throws Exception { try (Transaction tx = ignite(0).transactions().txStart()) { jcache(0).lockAll(Arrays.asList("key1", "key2")).lock(); } return null; } },
/** * @return Currently open transaction. */ private Transaction tx() { return node().transactions().tx(); }
@Override public Void call() throws Exception { spi.waitForBlocked(); client.transactions().localActiveTransactions().iterator().next().rollback(); return null; } }, "tx-rollback-thread");
/** * Run command in transaction. * * @param startNode Ignite node to start transaction and run passed command. * @param cmdInTx Command which should be done in transaction. */ private void runTransactionally(Ignite startNode, Consumer<Ignite> cmdInTx) { try (Transaction tx = startNode.transactions().withLabel(TX_LABEL).txStart(concurrency, isolation)) { cmdInTx.accept(startNode); tx.commit(); } }
@Override public void applyx(Ignite ignite, final IgniteCache<Integer, Integer> cache) throws Exception { for (TransactionIsolation isolation : TransactionIsolation.values()) { final Transaction tx = ignite.transactions().txStart(OPTIMISTIC, isolation); assertNull("Thread already have tx", ignite.transactions().tx());
TransactionMetrics metrics = txs.metrics(); Collection<Transaction> activeTxs = txs.localActiveTransactions();
/** {@inheritDoc} */ @Override public long processInLongOutLong(int type, long val) throws IgniteCheckedException { switch (type) { case OP_PREPARE: ((TransactionProxyImpl)tx(val)).tx().prepare(true); return TRUE; case OP_COMMIT: tx(val).commit(); return txClose(val); case OP_ROLLBACK: tx(val).rollback(); return txClose(val); case OP_CLOSE: return txClose(val); case OP_SET_ROLLBACK_ONLY: return tx(val).setRollbackOnly() ? TRUE : FALSE; case OP_STATE: return tx(val).state().ordinal(); case OP_RESET_METRICS: txs.resetMetrics(); return TRUE; } return super.processInLongOutLong(type, val); }
/** * Constructor. * * @param platformCtx Context. * @param lbl Label. */ public PlatformTransactions(PlatformContext platformCtx, String lbl) { super(platformCtx); txs = platformCtx.kernalContext().grid().transactions().withLabel(lbl); }
@Override public void applyx(Ignite ignite, final IgniteCache<Integer, Integer> cache) throws Exception { for (TransactionIsolation isolation : TransactionIsolation.values()) { final Transaction tx = ignite.transactions().txStart(OPTIMISTIC, isolation); cache.put(1, 1); cache.put(2, 2); tx.suspend(); assertNull("There is no transaction for current thread", ignite.transactions().tx()); assertEquals(SUSPENDED, tx.state()); GridTestUtils.runAsync(new Runnable() { @Override public void run() { tx.resume(); assertEquals(ACTIVE, tx.state()); cache.put(3, 3); tx.rollback(); } }).get(FUT_TIMEOUT); assertTrue(GridTestUtils.waitForCondition(new PA() { @Override public boolean apply() { return tx.state() == ROLLED_BACK; } }, getTestTimeout())); assertEquals(ROLLED_BACK, tx.state()); assertFalse(cache.containsKey(1)); assertFalse(cache.containsKey(2)); assertFalse(cache.containsKey(3)); cache.removeAll(); } } });
/** * @param txs Transaction manager. * @param cache Ignite cache. */ private void checkRollback(IgniteTransactions txs, IgniteCache<Integer, Integer> cache) { // create & rollback (pessimistic) try (Transaction tx = txs.withLabel(lb).txStart( TransactionConcurrency.PESSIMISTIC, TransactionIsolation.REPEATABLE_READ, timeout, 3)) { cache.put(4, 5); } assertTrue( creation.get() && !commit.get() && rollback.get() && !suspend.get() && !resume.get()); }
TransactionMetrics metrics = txs.metrics(); Collection<Transaction> activeTxs = txs.localActiveTransactions();
/** {@inheritDoc} */ @Override protected void afterTest() throws Exception { super.afterTest(); for (int i = 0; i < gridCount(); i++) { Ignite g = grid(i); g.cache(DEFAULT_CACHE_NAME).removeAll(); assert g.cache(DEFAULT_CACHE_NAME).localSize() == 0; } for (int i = 0; i < gridCount(); i++) { Ignite g = grid(i); g.cache(DEFAULT_CACHE_NAME).localMxBean().clear(); g.transactions().resetMetrics(); } }
/** * Constructor. * * @param platformCtx Context. * @param lbl Label. */ public PlatformTransactions(PlatformContext platformCtx, String lbl) { super(platformCtx); txs = platformCtx.kernalContext().grid().transactions().withLabel(lbl); }
/** * @param txMode Transaction concurrency mode. * @return Transaction. */ @Nullable private Transaction startTx(@Nullable TransactionConcurrency txMode) { return txMode == null ? null : ignite(0).transactions().txStart(txMode, REPEATABLE_READ); }
/** */ private void deactivateWithPendingTransaction(TransactionConcurrency concurrency, TransactionIsolation isolation) { final Ignite ignite0 = grid(0); final IgniteCache<Object, Object> cache0 = ignite0.cache(CACHE_NAME); try (Transaction ignore = ignite0.transactions().txStart(concurrency, isolation)) { cache0.put(1, "1"); //noinspection ThrowableNotThrown GridTestUtils.assertThrowsAnyCause(log, new Callable<Object>() { @Override public Object call() { grid(0).cluster().active(false); return null; } }, IgniteException.class, "Failed to deactivate cluster (must invoke the method outside of an active transaction)."); } assertNull(cache0.get(1)); assertNull(ignite0.transactions().tx()); }
/** * @param txs Transaction manager. * @param cache Ignite cache. */ private void checkCommit(IgniteTransactions txs, IgniteCache<Integer, Integer> cache) { // create & commit try (Transaction tx = txs.withLabel(lb).txStart( TransactionConcurrency.PESSIMISTIC, TransactionIsolation.REPEATABLE_READ, timeout, 3)) { cache.put(1, 1); tx.commit(); } assertTrue( creation.get() && commit.get() && !rollback.get() && !suspend.get() && !resume.get()); clear(); }
/** * @return Currently open transaction. */ private Transaction tx() { return node().transactions().tx(); }