Examples with TransactionTimeoutException org.apache.ignite.transactions.TransactionTimeoutException used on opensource projects

Example 6 with TransactionTimeoutException

use of org.apache.ignite.transactions.TransactionTimeoutException in project ignite by apache.

the class TxRollbackOnTimeoutTest method testRandomMixedTxConfigurations.

/**
 * Test timeouts with random values and different tx configurations.
 */
@Test
public void testRandomMixedTxConfigurations() throws Exception {
    final Ignite client = startClient();
    final AtomicBoolean stop = new AtomicBoolean();
    final long seed = System.currentTimeMillis();
    final Random r = new Random(seed);
    log.info("Using seed: " + seed);
    final int threadsCnt = Runtime.getRuntime().availableProcessors() * 2;
    for (int k = 0; k < threadsCnt; k++) grid(0).cache(CACHE_NAME).put(k, (long) 0);
    final TransactionConcurrency[] TC_VALS = TransactionConcurrency.values();
    final TransactionIsolation[] TI_VALS = TransactionIsolation.values();
    final LongAdder cntr0 = new LongAdder();
    final LongAdder cntr1 = new LongAdder();
    final LongAdder cntr2 = new LongAdder();
    final LongAdder cntr3 = new LongAdder();
    final IgniteInternalFuture<?> fut = multithreadedAsync(new Runnable() {

        @Override
        public void run() {
            while (!stop.get()) {
                int nodeId = r.nextInt(GRID_CNT + 1);
                Ignite node = nodeId == GRID_CNT || nearCacheEnabled() ? client : grid(nodeId);
                TransactionConcurrency conc = TC_VALS[r.nextInt(TC_VALS.length)];
                TransactionIsolation isolation = TI_VALS[r.nextInt(TI_VALS.length)];
                int k = r.nextInt(threadsCnt);
                long timeout = r.nextInt(200) + 50;
                // Roughly 50% of transactions should time out.
                try (Transaction tx = node.transactions().txStart(conc, isolation, timeout, 1)) {
                    cntr0.add(1);
                    final Long v = (Long) node.cache(CACHE_NAME).get(k);
                    assertNotNull("Expecting not null value: " + tx, v);
                    final int delay = r.nextInt(400);
                    if (delay > 0)
                        sleep(delay);
                    node.cache(CACHE_NAME).put(k, v + 1);
                    tx.commit();
                    cntr1.add(1);
                } catch (TransactionTimeoutException e) {
                    cntr2.add(1);
                } catch (CacheException e) {
                    assertEquals(TransactionTimeoutException.class, X.getCause(e).getClass());
                    cntr2.add(1);
                } catch (Exception e) {
                    cntr3.add(1);
                }
            }
        }
    }, threadsCnt, "tx-async-thread");
    sleep(DURATION);
    stop.set(true);
    try {
        fut.get(30_000);
    } catch (IgniteFutureTimeoutCheckedException e) {
        error("Transactions hang", e);
        for (Ignite node : G.allGrids()) ((IgniteKernal) node).dumpDebugInfo();
        // Try to interrupt hanging threads.
        fut.cancel();
        throw e;
    }
    log.info("Tx test stats: started=" + cntr0.sum() + ", completed=" + cntr1.sum() + ", failed=" + cntr3.sum() + ", timedOut=" + cntr2.sum());
    assertEquals("Expected finished count same as started count", cntr0.sum(), cntr1.sum() + cntr2.sum() + cntr3.sum());
}

Example 7 with TransactionTimeoutException

use of org.apache.ignite.transactions.TransactionTimeoutException in project ignite by apache.

the class PerformingTransactions method deadlockDetectionExample.

public static void deadlockDetectionExample() {
    try (Ignite ignite = Ignition.start()) {
        // tag::deadlock[]
        CacheConfiguration<Integer, String> cfg = new CacheConfiguration<>();
        cfg.setAtomicityMode(CacheAtomicityMode.TRANSACTIONAL);
        cfg.setName("myCache");
        IgniteCache<Integer, String> cache = ignite.getOrCreateCache(cfg);
        try (Transaction tx = ignite.transactions().txStart(TransactionConcurrency.PESSIMISTIC, TransactionIsolation.READ_COMMITTED, 300, 0)) {
            cache.put(1, "1");
            cache.put(2, "1");
            tx.commit();
        } catch (CacheException e) {
            if (e.getCause() instanceof TransactionTimeoutException && e.getCause().getCause() instanceof TransactionDeadlockException)
                System.out.println(e.getCause().getCause().getMessage());
        }
    // end::deadlock[]
    }
}

Example 8 with TransactionTimeoutException

use of org.apache.ignite.transactions.TransactionTimeoutException in project ignite by apache.

the class IgniteUtils method exceptionConverters.

/**
 * Gets map with converters to convert internal checked exceptions to public API unchecked exceptions.
 *
 * @return Exception converters.
 */
private static Map<Class<? extends IgniteCheckedException>, C1<IgniteCheckedException, IgniteException>> exceptionConverters() {
    Map<Class<? extends IgniteCheckedException>, C1<IgniteCheckedException, IgniteException>> m = new HashMap<>();
    m.put(IgniteInterruptedCheckedException.class, new C1<IgniteCheckedException, IgniteException>() {

        @Override
        public IgniteException apply(IgniteCheckedException e) {
            return new IgniteInterruptedException(e.getMessage(), (InterruptedException) e.getCause());
        }
    });
    m.put(IgniteFutureCancelledCheckedException.class, new C1<IgniteCheckedException, IgniteException>() {

        @Override
        public IgniteException apply(IgniteCheckedException e) {
            return new IgniteFutureCancelledException(e.getMessage(), e);
        }
    });
    m.put(IgniteFutureTimeoutCheckedException.class, new C1<IgniteCheckedException, IgniteException>() {

        @Override
        public IgniteException apply(IgniteCheckedException e) {
            return new IgniteFutureTimeoutException(e.getMessage(), e);
        }
    });
    m.put(ClusterGroupEmptyCheckedException.class, new C1<IgniteCheckedException, IgniteException>() {

        @Override
        public IgniteException apply(IgniteCheckedException e) {
            return new ClusterGroupEmptyException(e.getMessage(), e);
        }
    });
    m.put(ClusterTopologyCheckedException.class, new C1<IgniteCheckedException, IgniteException>() {

        @Override
        public IgniteException apply(IgniteCheckedException e) {
            ClusterTopologyException topEx = new ClusterTopologyException(e.getMessage(), e);
            ClusterTopologyCheckedException checked = (ClusterTopologyCheckedException) e;
            if (checked.retryReadyFuture() != null)
                topEx.retryReadyFuture(new IgniteFutureImpl<>(checked.retryReadyFuture()));
            return topEx;
        }
    });
    m.put(IgniteDeploymentCheckedException.class, new C1<IgniteCheckedException, IgniteException>() {

        @Override
        public IgniteException apply(IgniteCheckedException e) {
            return new IgniteDeploymentException(e.getMessage(), e);
        }
    });
    m.put(ComputeTaskTimeoutCheckedException.class, new C1<IgniteCheckedException, IgniteException>() {

        @Override
        public IgniteException apply(IgniteCheckedException e) {
            return new ComputeTaskTimeoutException(e.getMessage(), e);
        }
    });
    m.put(ComputeTaskCancelledCheckedException.class, new C1<IgniteCheckedException, IgniteException>() {

        @Override
        public IgniteException apply(IgniteCheckedException e) {
            return new ComputeTaskCancelledException(e.getMessage(), e);
        }
    });
    m.put(IgniteTxRollbackCheckedException.class, new C1<IgniteCheckedException, IgniteException>() {

        @Override
        public IgniteException apply(IgniteCheckedException e) {
            return new TransactionRollbackException(e.getMessage(), e);
        }
    });
    m.put(IgniteTxHeuristicCheckedException.class, new C1<IgniteCheckedException, IgniteException>() {

        @Override
        public IgniteException apply(IgniteCheckedException e) {
            return new TransactionHeuristicException(e.getMessage(), e);
        }
    });
    m.put(IgniteTxTimeoutCheckedException.class, new C1<IgniteCheckedException, IgniteException>() {

        @Override
        public IgniteException apply(IgniteCheckedException e) {
            if (e.getCause() instanceof TransactionDeadlockException)
                return new TransactionTimeoutException(e.getMessage(), e.getCause());
            return new TransactionTimeoutException(e.getMessage(), e);
        }
    });
    m.put(IgniteTxOptimisticCheckedException.class, new C1<IgniteCheckedException, IgniteException>() {

        @Override
        public IgniteException apply(IgniteCheckedException e) {
            return new TransactionOptimisticException(e.getMessage(), e);
        }
    });
    m.put(IgniteClientDisconnectedCheckedException.class, new C1<IgniteCheckedException, IgniteException>() {

        @Override
        public IgniteException apply(IgniteCheckedException e) {
            return new IgniteClientDisconnectedException(((IgniteClientDisconnectedCheckedException) e).reconnectFuture(), e.getMessage(), e);
        }
    });
    m.put(IgniteTxSerializationCheckedException.class, new C1<IgniteCheckedException, IgniteException>() {

        @Override
        public IgniteException apply(IgniteCheckedException e) {
            return new TransactionSerializationException(e.getMessage(), e);
        }
    });
    m.put(IgniteTxDuplicateKeyCheckedException.class, new C1<IgniteCheckedException, IgniteException>() {

        @Override
        public IgniteException apply(IgniteCheckedException e) {
            return new TransactionDuplicateKeyException(e.getMessage(), e);
        }
    });
    m.put(IgniteTxAlreadyCompletedCheckedException.class, new C1<IgniteCheckedException, IgniteException>() {

        @Override
        public IgniteException apply(IgniteCheckedException e) {
            return new TransactionAlreadyCompletedException(e.getMessage(), e);
        }
    });
    return m;
}