Examples with IgniteTxRollbackCheckedException org.apache.ignite.internal.transactions.IgniteTxRollbackCheckedException used on opensource projects

Example 6 with IgniteTxRollbackCheckedException

use of org.apache.ignite.internal.transactions.IgniteTxRollbackCheckedException in project ignite by apache.

the class GridNearTransactionalCache method startRemoteTx.

/**
     * @param nodeId Primary node ID.
     * @param req Request.
     * @return Remote transaction.
     * @throws IgniteCheckedException If failed.
     * @throws GridDistributedLockCancelledException If lock has been cancelled.
     */
@SuppressWarnings({ "RedundantTypeArguments", "ForLoopReplaceableByForEach" })
@Nullable
public GridNearTxRemote startRemoteTx(UUID nodeId, GridDhtLockRequest req) throws IgniteCheckedException, GridDistributedLockCancelledException {
    List<KeyCacheObject> nearKeys = req.nearKeys();
    GridNearTxRemote tx = null;
    ClassLoader ldr = ctx.deploy().globalLoader();
    if (ldr != null) {
        Collection<IgniteTxKey> evicted = null;
        // Avoid iterator creation.
        for (int i = 0; i < nearKeys.size(); i++) {
            KeyCacheObject key = nearKeys.get(i);
            if (key == null)
                continue;
            IgniteTxKey txKey = ctx.txKey(key);
            if (log.isDebugEnabled())
                log.debug("Unmarshalled key: " + key);
            GridNearCacheEntry entry = null;
            while (true) {
                try {
                    entry = peekExx(key);
                    if (entry != null) {
                        // Handle implicit locks for pessimistic transactions.
                        if (req.inTx()) {
                            tx = ctx.tm().nearTx(req.version());
                            if (tx == null) {
                                tx = new GridNearTxRemote(ctx.shared(), req.topologyVersion(), nodeId, req.nearNodeId(), req.nearXidVersion(), req.version(), null, ctx.systemTx(), ctx.ioPolicy(), PESSIMISTIC, req.isolation(), req.isInvalidate(), req.timeout(), req.txSize(), req.subjectId(), req.taskNameHash());
                                tx = ctx.tm().onCreated(null, tx);
                                if (tx == null || !ctx.tm().onStarted(tx))
                                    throw new IgniteTxRollbackCheckedException("Failed to acquire lock " + "(transaction has been completed): " + req.version());
                            }
                            tx.addEntry(ctx, txKey, GridCacheOperation.NOOP, null, /*Value.*/
                            null, /*dr version*/
                            req.skipStore(), req.keepBinary());
                        }
                        // Add remote candidate before reordering.
                        // Owned candidates should be reordered inside entry lock.
                        entry.addRemote(req.nodeId(), nodeId, req.threadId(), req.version(), tx != null, tx != null && tx.implicitSingle(), req.owned(entry.key()));
                        if (!req.inTx())
                            ctx.evicts().touch(entry, req.topologyVersion());
                    } else {
                        if (evicted == null)
                            evicted = new LinkedList<>();
                        evicted.add(txKey);
                    }
                    // Double-check in case if sender node left the grid.
                    if (ctx.discovery().node(req.nodeId()) == null) {
                        if (log.isDebugEnabled())
                            log.debug("Node requesting lock left grid (lock request will be ignored): " + req);
                        if (tx != null)
                            tx.rollbackRemoteTx();
                        return null;
                    }
                    // Entry is legit.
                    break;
                } catch (GridCacheEntryRemovedException ignored) {
                    assert entry.obsoleteVersion() != null : "Obsolete flag not set on removed entry: " + entry;
                    if (log.isDebugEnabled())
                        log.debug("Received entry removed exception (will retry on renewed entry): " + entry);
                    if (tx != null) {
                        tx.clearEntry(txKey);
                        if (log.isDebugEnabled())
                            log.debug("Cleared removed entry from remote transaction (will retry) [entry=" + entry + ", tx=" + tx + ']');
                    }
                }
            }
        }
        if (tx != null && evicted != null) {
            assert !evicted.isEmpty();
            for (IgniteTxKey evict : evicted) tx.addEvicted(evict);
        }
    } else {
        String err = "Failed to acquire deployment class loader for message: " + req;
        U.warn(log, err);
        throw new IgniteCheckedException(err);
    }
    return tx;
}

Example 7 with IgniteTxRollbackCheckedException

use of org.apache.ignite.internal.transactions.IgniteTxRollbackCheckedException in project ignite by apache.

the class GridDhtTransactionalCacheAdapter method startRemoteTx.

/**
     * @param nodeId Primary node ID.
     * @param req Request.
     * @param res Response.
     * @return Remote transaction.
     * @throws IgniteCheckedException If failed.
     * @throws GridDistributedLockCancelledException If lock has been cancelled.
     */
@SuppressWarnings({ "RedundantTypeArguments" })
@Nullable
private GridDhtTxRemote startRemoteTx(UUID nodeId, GridDhtLockRequest req, GridDhtLockResponse res) throws IgniteCheckedException, GridDistributedLockCancelledException {
    List<KeyCacheObject> keys = req.keys();
    GridDhtTxRemote tx = null;
    int size = F.size(keys);
    for (int i = 0; i < size; i++) {
        KeyCacheObject key = keys.get(i);
        if (key == null)
            continue;
        IgniteTxKey txKey = ctx.txKey(key);
        if (log.isDebugEnabled())
            log.debug("Unmarshalled key: " + key);
        GridDistributedCacheEntry entry = null;
        while (true) {
            try {
                int part = ctx.affinity().partition(key);
                GridDhtLocalPartition locPart = ctx.topology().localPartition(part, req.topologyVersion(), false);
                if (locPart == null || !locPart.reserve()) {
                    if (log.isDebugEnabled())
                        log.debug("Local partition for given key is already evicted (will add to invalid " + "partition list) [key=" + key + ", part=" + part + ", locPart=" + locPart + ']');
                    res.addInvalidPartition(part);
                    // Invalidate key in near cache, if any.
                    if (isNearEnabled(cacheCfg))
                        obsoleteNearEntry(key);
                    break;
                }
                try {
                    // Handle implicit locks for pessimistic transactions.
                    if (req.inTx()) {
                        if (tx == null)
                            tx = ctx.tm().tx(req.version());
                        if (tx == null) {
                            tx = new GridDhtTxRemote(ctx.shared(), req.nodeId(), req.futureId(), nodeId, req.nearXidVersion(), req.topologyVersion(), req.version(), /*commitVer*/
                            null, ctx.systemTx(), ctx.ioPolicy(), PESSIMISTIC, req.isolation(), req.isInvalidate(), req.timeout(), req.txSize(), req.subjectId(), req.taskNameHash());
                            tx = ctx.tm().onCreated(null, tx);
                            if (tx == null || !ctx.tm().onStarted(tx))
                                throw new IgniteTxRollbackCheckedException("Failed to acquire lock (transaction " + "has been completed) [ver=" + req.version() + ", tx=" + tx + ']');
                        }
                        tx.addWrite(ctx, NOOP, txKey, null, null, req.accessTtl(), req.skipStore(), req.keepBinary());
                    }
                    entry = entryExx(key, req.topologyVersion());
                    // Add remote candidate before reordering.
                    entry.addRemote(req.nodeId(), nodeId, req.threadId(), req.version(), tx != null, tx != null && tx.implicitSingle(), null);
                    // Invalidate key in near cache, if any.
                    if (isNearEnabled(cacheCfg) && req.invalidateNearEntry(i))
                        invalidateNearEntry(key, req.version());
                    // Get entry info after candidate is added.
                    if (req.needPreloadKey(i)) {
                        entry.unswap();
                        GridCacheEntryInfo info = entry.info();
                        if (info != null && !info.isNew() && !info.isDeleted())
                            res.addPreloadEntry(info);
                    }
                    // Double-check in case if sender node left the grid.
                    if (ctx.discovery().node(req.nodeId()) == null) {
                        if (log.isDebugEnabled())
                            log.debug("Node requesting lock left grid (lock request will be ignored): " + req);
                        entry.removeLock(req.version());
                        if (tx != null) {
                            tx.clearEntry(txKey);
                            // COMMITTING state, but this lock is never acquired.
                            if (tx.state() == COMMITTING)
                                tx.forceCommit();
                            else
                                tx.rollbackRemoteTx();
                        }
                        return null;
                    }
                    // Entry is legit.
                    break;
                } finally {
                    locPart.release();
                }
            } catch (GridDhtInvalidPartitionException e) {
                if (log.isDebugEnabled())
                    log.debug("Received invalid partition exception [e=" + e + ", req=" + req + ']');
                res.addInvalidPartition(e.partition());
                // Invalidate key in near cache, if any.
                if (isNearEnabled(cacheCfg))
                    obsoleteNearEntry(key);
                if (tx != null) {
                    tx.clearEntry(txKey);
                    if (log.isDebugEnabled())
                        log.debug("Cleared invalid entry from remote transaction (will skip) [entry=" + entry + ", tx=" + tx + ']');
                }
                break;
            } catch (GridCacheEntryRemovedException ignored) {
                assert entry.obsoleteVersion() != null : "Obsolete flag not set on removed entry: " + entry;
                if (log.isDebugEnabled())
                    log.debug("Received entry removed exception (will retry on renewed entry): " + entry);
                if (tx != null) {
                    tx.clearEntry(txKey);
                    if (log.isDebugEnabled())
                        log.debug("Cleared removed entry from remote transaction (will retry) [entry=" + entry + ", tx=" + tx + ']');
                }
            }
        }
    }
    if (tx != null && tx.empty()) {
        if (log.isDebugEnabled())
            log.debug("Rolling back remote DHT transaction because it is empty [req=" + req + ", res=" + res + ']');
        tx.rollbackRemoteTx();
        tx = null;
    }
    return tx;
}

Example 8 with IgniteTxRollbackCheckedException

use of org.apache.ignite.internal.transactions.IgniteTxRollbackCheckedException in project ignite by apache.

the class GridDhtTransactionalCacheAdapter method processDhtLockRequest0.

/**
     * @param nodeId Node ID.
     * @param req Request.
     */
private void processDhtLockRequest0(UUID nodeId, GridDhtLockRequest req) {
    assert nodeId != null;
    assert req != null;
    assert !nodeId.equals(locNodeId);
    int cnt = F.size(req.keys());
    GridDhtLockResponse res;
    GridDhtTxRemote dhtTx = null;
    GridNearTxRemote nearTx = null;
    boolean fail = false;
    boolean cancelled = false;
    try {
        res = new GridDhtLockResponse(ctx.cacheId(), req.version(), req.futureId(), req.miniId(), cnt, ctx.deploymentEnabled());
        dhtTx = startRemoteTx(nodeId, req, res);
        nearTx = isNearEnabled(cacheCfg) ? near().startRemoteTx(nodeId, req) : null;
        if (nearTx != null && !nearTx.empty())
            res.nearEvicted(nearTx.evicted());
        else {
            if (!F.isEmpty(req.nearKeys())) {
                Collection<IgniteTxKey> nearEvicted = new ArrayList<>(req.nearKeys().size());
                nearEvicted.addAll(F.viewReadOnly(req.nearKeys(), new C1<KeyCacheObject, IgniteTxKey>() {

                    @Override
                    public IgniteTxKey apply(KeyCacheObject k) {
                        return ctx.txKey(k);
                    }
                }));
                res.nearEvicted(nearEvicted);
            }
        }
    } catch (IgniteTxRollbackCheckedException e) {
        String err = "Failed processing DHT lock request (transaction has been completed): " + req;
        U.error(log, err, e);
        res = new GridDhtLockResponse(ctx.cacheId(), req.version(), req.futureId(), req.miniId(), new IgniteTxRollbackCheckedException(err, e), ctx.deploymentEnabled());
        fail = true;
    } catch (IgniteCheckedException e) {
        String err = "Failed processing DHT lock request: " + req;
        U.error(log, err, e);
        res = new GridDhtLockResponse(ctx.cacheId(), req.version(), req.futureId(), req.miniId(), new IgniteCheckedException(err, e), ctx.deploymentEnabled());
        fail = true;
    } catch (GridDistributedLockCancelledException ignored) {
        // Received lock request for cancelled lock.
        if (log.isDebugEnabled())
            log.debug("Received lock request for canceled lock (will ignore): " + req);
        res = null;
        fail = true;
        cancelled = true;
    }
    boolean releaseAll = false;
    if (res != null) {
        try {
            // Reply back to sender.
            ctx.io().send(nodeId, res, ctx.ioPolicy());
            if (txLockMsgLog.isDebugEnabled()) {
                txLockMsgLog.debug("Sent dht lock response [txId=" + req.nearXidVersion() + ", dhtTxId=" + req.version() + ", inTx=" + req.inTx() + ", node=" + nodeId + ']');
            }
        } catch (ClusterTopologyCheckedException ignored) {
            U.warn(txLockMsgLog, "Failed to send dht lock response, node failed [" + "txId=" + req.nearXidVersion() + ", dhtTxId=" + req.version() + ", inTx=" + req.inTx() + ", node=" + nodeId + ']');
            fail = true;
            releaseAll = true;
        } catch (IgniteCheckedException e) {
            U.error(txLockMsgLog, "Failed to send dht lock response (lock will not be acquired) " + "txId=" + req.nearXidVersion() + ", dhtTxId=" + req.version() + ", inTx=" + req.inTx() + ", node=" + nodeId + ']', e);
            fail = true;
        }
    }
    if (fail) {
        if (dhtTx != null)
            dhtTx.rollbackRemoteTx();
        if (// Even though this should never happen, we leave this check for consistency.
        nearTx != null)
            nearTx.rollbackRemoteTx();
        List<KeyCacheObject> keys = req.keys();
        if (keys != null) {
            for (KeyCacheObject key : keys) {
                while (true) {
                    GridDistributedCacheEntry entry = peekExx(key);
                    try {
                        if (entry != null) {
                            // Release all locks because sender node left grid.
                            if (releaseAll)
                                entry.removeExplicitNodeLocks(req.nodeId());
                            else
                                entry.removeLock(req.version());
                        }
                        break;
                    } catch (GridCacheEntryRemovedException ignore) {
                        if (log.isDebugEnabled())
                            log.debug("Attempted to remove lock on removed entity during during failure " + "handling for dht lock request (will retry): " + entry);
                    }
                }
            }
        }
        if (releaseAll && !cancelled)
            U.warn(log, "Sender node left grid in the midst of lock acquisition (locks have been released).");
    }
}

Example 9 with IgniteTxRollbackCheckedException

use of org.apache.ignite.internal.transactions.IgniteTxRollbackCheckedException in project ignite by apache.

the class GridDhtTxLocal method prepareAsync.

/**
     * Prepares next batch of entries in dht transaction.
     *
     * @param reads Read entries.
     * @param writes Write entries.
     * @param verMap Version map.
     * @param msgId Message ID.
     * @param nearMiniId Near mini future ID.
     * @param txNodes Transaction nodes mapping.
     * @param last {@code True} if this is last prepare request.
     * @return Future that will be completed when locks are acquired.
     */
public final IgniteInternalFuture<GridNearTxPrepareResponse> prepareAsync(@Nullable Collection<IgniteTxEntry> reads, @Nullable Collection<IgniteTxEntry> writes, Map<IgniteTxKey, GridCacheVersion> verMap, long msgId, int nearMiniId, Map<UUID, Collection<UUID>> txNodes, boolean last) {
    // In optimistic mode prepare still can be called explicitly from salvageTx.
    GridDhtTxPrepareFuture fut = prepFut;
    long timeout = remainingTime();
    if (fut == null) {
        init();
        // Future must be created before any exception can be thrown.
        if (!PREP_FUT_UPD.compareAndSet(this, null, fut = new GridDhtTxPrepareFuture(cctx, this, timeout, nearMiniId, verMap, last, needReturnValue()))) {
            GridDhtTxPrepareFuture f = prepFut;
            assert f.nearMiniId() == nearMiniId : "Wrong near mini id on existing future " + "[futMiniId=" + f.nearMiniId() + ", miniId=" + nearMiniId + ", fut=" + f + ']';
            if (timeout == -1)
                f.onError(timeoutException());
            return chainOnePhasePrepare(f);
        }
    } else {
        assert fut.nearMiniId() == nearMiniId : "Wrong near mini id on existing future " + "[futMiniId=" + fut.nearMiniId() + ", miniId=" + nearMiniId + ", fut=" + fut + ']';
        // Prepare was called explicitly.
        return chainOnePhasePrepare(fut);
    }
    if (state() != PREPARING) {
        if (!state(PREPARING)) {
            if (state() == PREPARED && isSystemInvalidate())
                fut.complete();
            if (setRollbackOnly()) {
                if (timeout == -1)
                    fut.onError(new IgniteTxTimeoutCheckedException("Transaction timed out and was rolled back: " + this));
                else
                    fut.onError(new IgniteCheckedException("Invalid transaction state for prepare [state=" + state() + ", tx=" + this + ']'));
            } else
                fut.onError(new IgniteTxRollbackCheckedException("Invalid transaction state for prepare [state=" + state() + ", tx=" + this + ']'));
            return fut;
        }
    }
    try {
        if (reads != null) {
            for (IgniteTxEntry e : reads) addEntry(msgId, e);
        }
        if (writes != null) {
            for (IgniteTxEntry e : writes) addEntry(msgId, e);
        }
        userPrepare(null);
        // Make sure to add future before calling prepare on it.
        cctx.mvcc().addFuture(fut);
        if (isSystemInvalidate())
            fut.complete();
        else
            fut.prepare(reads, writes, txNodes);
    } catch (IgniteTxTimeoutCheckedException | IgniteTxOptimisticCheckedException e) {
        fut.onError(e);
    } catch (IgniteCheckedException e) {
        setRollbackOnly();
        fut.onError(new IgniteTxRollbackCheckedException("Failed to prepare transaction: " + this, e));
        try {
            rollbackDhtLocal();
        } catch (IgniteTxOptimisticCheckedException e1) {
            if (log.isDebugEnabled())
                log.debug("Failed optimistically to prepare transaction [tx=" + this + ", e=" + e1 + ']');
            fut.onError(e);
        } catch (IgniteCheckedException e1) {
            U.error(log, "Failed to rollback transaction: " + this, e1);
        }
    }
    return chainOnePhasePrepare(fut);
}

Example 10 with IgniteTxRollbackCheckedException

use of org.apache.ignite.internal.transactions.IgniteTxRollbackCheckedException in project ignite by apache.

the class GridCacheAdapter method asyncOp.

/**
     * @param tx Transaction.
     * @param op Cache operation.
     * @param opCtx Cache operation context.
     * @param <T> Return type.
     * @return Future.
     */
@SuppressWarnings("unchecked")
protected <T> IgniteInternalFuture<T> asyncOp(GridNearTxLocal tx, final AsyncOp<T> op, final CacheOperationContext opCtx, final boolean retry) {
    IgniteInternalFuture<T> fail = asyncOpAcquire(retry);
    if (fail != null)
        return fail;
    FutureHolder holder = lastFut.get();
    holder.lock();
    try {
        IgniteInternalFuture fut = holder.future();
        final GridNearTxLocal tx0 = tx;
        if (fut != null && !fut.isDone()) {
            IgniteInternalFuture<T> f = new GridEmbeddedFuture(fut, new IgniteOutClosure<IgniteInternalFuture>() {

                @Override
                public IgniteInternalFuture<T> apply() {
                    if (ctx.kernalContext().isStopping())
                        return new GridFinishedFuture<>(new IgniteCheckedException("Operation has been cancelled (node is stopping)."));
                    return op.op(tx0, opCtx).chain(new CX1<IgniteInternalFuture<T>, T>() {

                        @Override
                        public T applyx(IgniteInternalFuture<T> tFut) throws IgniteCheckedException {
                            try {
                                return tFut.get();
                            } catch (IgniteTxRollbackCheckedException e) {
                                throw e;
                            } catch (IgniteCheckedException e1) {
                                tx0.rollbackNearTxLocalAsync();
                                throw e1;
                            } finally {
                                ctx.shared().txContextReset();
                            }
                        }
                    });
                }
            });
            saveFuture(holder, f, retry);
            return f;
        }
        final IgniteInternalFuture<T> f = op.op(tx, opCtx).chain(new CX1<IgniteInternalFuture<T>, T>() {

            @Override
            public T applyx(IgniteInternalFuture<T> tFut) throws IgniteCheckedException {
                try {
                    return tFut.get();
                } catch (IgniteTxRollbackCheckedException e) {
                    throw e;
                } catch (IgniteCheckedException e1) {
                    tx0.rollbackNearTxLocalAsync();
                    throw e1;
                } finally {
                    ctx.shared().txContextReset();
                }
            }
        });
        saveFuture(holder, f, retry);
        if (tx.implicit())
            ctx.tm().resetContext();
        return f;
    } finally {
        holder.unlock();
    }
}