Examples with GridCacheReturn org.apache.ignite.internal.processors.cache.GridCacheReturn used on opensource projects

Example 31 with GridCacheReturn

use of org.apache.ignite.internal.processors.cache.GridCacheReturn in project ignite by apache.

the class GridDistributedTxRemoteAdapter method commitIfLocked.

/**
 * @throws IgniteCheckedException If commit failed.
 */
private void commitIfLocked() throws IgniteCheckedException {
    if (state() == COMMITTING) {
        for (IgniteTxEntry txEntry : writeEntries()) {
            assert txEntry != null : "Missing transaction entry for tx: " + this;
            while (true) {
                GridCacheEntryEx entry = txEntry.cached();
                assert entry != null : "Missing cached entry for transaction entry: " + txEntry;
                try {
                    GridCacheVersion ver = txEntry.explicitVersion() != null ? txEntry.explicitVersion() : xidVer;
                    // If locks haven't been acquired yet, keep waiting.
                    if (!entry.lockedBy(ver)) {
                        if (log.isDebugEnabled())
                            log.debug("Transaction does not own lock for entry (will wait) [entry=" + entry + ", tx=" + this + ']');
                        return;
                    }
                    // While.
                    break;
                } catch (GridCacheEntryRemovedException ignore) {
                    if (log.isDebugEnabled())
                        log.debug("Got removed entry while committing (will retry): " + txEntry);
                    try {
                        txEntry.cached(txEntry.context().cache().entryEx(txEntry.key(), topologyVersion()));
                    } catch (GridDhtInvalidPartitionException e) {
                        break;
                    }
                }
            }
        }
        // Only one thread gets to commit.
        if (COMMIT_ALLOWED_UPD.compareAndSet(this, 0, 1)) {
            IgniteCheckedException err = null;
            Map<IgniteTxKey, IgniteTxEntry> writeMap = txState.writeMap();
            GridCacheReturnCompletableWrapper wrapper = null;
            if (!F.isEmpty(writeMap) || mvccSnapshot != null) {
                GridCacheReturn ret = null;
                if (!near() && !local() && onePhaseCommit()) {
                    if (needReturnValue()) {
                        ret = new GridCacheReturn(null, cctx.localNodeId().equals(otherNodeId()), true, null, null, true);
                        // Originating node.
                        UUID origNodeId = otherNodeId();
                        cctx.tm().addCommittedTxReturn(this, wrapper = new GridCacheReturnCompletableWrapper(!cctx.localNodeId().equals(origNodeId) ? origNodeId : null));
                    } else
                        cctx.tm().addCommittedTx(this, this.nearXidVersion(), null);
                }
                // Register this transaction as completed prior to write-phase to
                // ensure proper lock ordering for removed entries.
                cctx.tm().addCommittedTx(this);
                AffinityTopologyVersion topVer = topologyVersion();
                WALPointer ptr = null;
                cctx.database().checkpointReadLock();
                // Reserved partitions (necessary to prevent race due to updates in RENTING state).
                Set<GridDhtLocalPartition> reservedParts = new HashSet<>();
                try {
                    assert !txState.mvccEnabled() || mvccSnapshot != null : "Mvcc is not initialized: " + this;
                    Collection<IgniteTxEntry> entries = near() || cctx.snapshot().needTxReadLogging() ? allEntries() : writeEntries();
                    // Data entry to write to WAL and associated with it TxEntry.
                    List<T2<DataEntry, IgniteTxEntry>> dataEntries = null;
                    batchStoreCommit(writeMap().values());
                    // Node that for near transactions we grab all entries.
                    for (IgniteTxEntry txEntry : entries) {
                        GridCacheContext cacheCtx = txEntry.context();
                        // Prevent stale updates.
                        GridDhtLocalPartition locPart = cacheCtx.group().topology().localPartition(txEntry.cached().partition());
                        if (!near()) {
                            if (locPart == null)
                                continue;
                            if (!reservedParts.contains(locPart) && locPart.reserve()) {
                                assert locPart.state() != EVICTED && locPart.reservations() > 0 : locPart;
                                reservedParts.add(locPart);
                            }
                            if (locPart.state() == RENTING || locPart.state() == EVICTED) {
                                LT.warn(log(), "Skipping update to partition that is concurrently evicting " + "[grp=" + cacheCtx.group().cacheOrGroupName() + ", part=" + locPart + "]");
                                continue;
                            }
                        }
                        boolean replicate = cacheCtx.isDrEnabled();
                        while (true) {
                            try {
                                GridCacheEntryEx cached = txEntry.cached();
                                if (cached == null)
                                    txEntry.cached(cached = cacheCtx.cache().entryEx(txEntry.key(), topologyVersion()));
                                if (near() && cacheCtx.dr().receiveEnabled()) {
                                    cached.markObsolete(xidVer);
                                    break;
                                }
                                GridNearCacheEntry nearCached = null;
                                if (updateNearCache(cacheCtx, txEntry.key(), topVer))
                                    nearCached = cacheCtx.dht().near().peekExx(txEntry.key());
                                if (!F.isEmpty(txEntry.entryProcessors()))
                                    txEntry.cached().unswap(false);
                                IgniteBiTuple<GridCacheOperation, CacheObject> res = applyTransformClosures(txEntry, false, ret);
                                GridCacheOperation op = res.get1();
                                CacheObject val = res.get2();
                                GridCacheVersion explicitVer = txEntry.conflictVersion();
                                if (explicitVer == null)
                                    explicitVer = writeVersion();
                                if (txEntry.ttl() == CU.TTL_ZERO)
                                    op = DELETE;
                                boolean conflictNeedResolve = cacheCtx.conflictNeedResolve();
                                GridCacheVersionConflictContext conflictCtx = null;
                                if (conflictNeedResolve) {
                                    IgniteBiTuple<GridCacheOperation, GridCacheVersionConflictContext> drRes = conflictResolve(op, txEntry, val, explicitVer, cached);
                                    assert drRes != null;
                                    conflictCtx = drRes.get2();
                                    if (conflictCtx.isUseOld())
                                        op = NOOP;
                                    else if (conflictCtx.isUseNew()) {
                                        txEntry.ttl(conflictCtx.ttl());
                                        txEntry.conflictExpireTime(conflictCtx.expireTime());
                                    } else if (conflictCtx.isMerge()) {
                                        op = drRes.get1();
                                        val = txEntry.context().toCacheObject(conflictCtx.mergeValue());
                                        explicitVer = writeVersion();
                                        txEntry.ttl(conflictCtx.ttl());
                                        txEntry.conflictExpireTime(conflictCtx.expireTime());
                                    }
                                } else
                                    // Nullify explicit version so that innerSet/innerRemove will work as usual.
                                    explicitVer = null;
                                GridCacheVersion dhtVer = cached.isNear() ? writeVersion() : null;
                                if (!near() && cacheCtx.group().persistenceEnabled() && cacheCtx.group().walEnabled() && op != NOOP && op != RELOAD && (op != READ || cctx.snapshot().needTxReadLogging())) {
                                    if (dataEntries == null)
                                        dataEntries = new ArrayList<>(entries.size());
                                    dataEntries.add(new T2<>(new DataEntry(cacheCtx.cacheId(), txEntry.key(), val, op, nearXidVersion(), addConflictVersion(writeVersion(), txEntry.conflictVersion()), 0, txEntry.key().partition(), txEntry.updateCounter(), DataEntry.flags(CU.txOnPrimary(this))), txEntry));
                                }
                                if (op == CREATE || op == UPDATE) {
                                    // Invalidate only for near nodes (backups cannot be invalidated).
                                    if (isSystemInvalidate() || (isInvalidate() && cacheCtx.isNear()))
                                        cached.innerRemove(this, eventNodeId(), nodeId, false, true, true, txEntry.keepBinary(), txEntry.hasOldValue(), txEntry.oldValue(), topVer, null, replicate ? DR_BACKUP : DR_NONE, near() ? null : explicitVer, resolveTaskName(), dhtVer, txEntry.updateCounter());
                                    else {
                                        assert val != null : txEntry;
                                        GridCacheUpdateTxResult updRes = cached.innerSet(this, eventNodeId(), nodeId, val, false, false, txEntry.ttl(), true, true, txEntry.keepBinary(), txEntry.hasOldValue(), txEntry.oldValue(), topVer, null, replicate ? DR_BACKUP : DR_NONE, txEntry.conflictExpireTime(), near() ? null : explicitVer, resolveTaskName(), dhtVer, txEntry.updateCounter());
                                        txEntry.updateCounter(updRes.updateCounter());
                                        if (updRes.loggedPointer() != null)
                                            ptr = updRes.loggedPointer();
                                        // Keep near entry up to date.
                                        if (nearCached != null) {
                                            CacheObject val0 = cached.valueBytes();
                                            nearCached.updateOrEvict(xidVer, val0, cached.expireTime(), cached.ttl(), nodeId, topVer);
                                        }
                                    }
                                } else if (op == DELETE) {
                                    GridCacheUpdateTxResult updRes = cached.innerRemove(this, eventNodeId(), nodeId, false, true, true, txEntry.keepBinary(), txEntry.hasOldValue(), txEntry.oldValue(), topVer, null, replicate ? DR_BACKUP : DR_NONE, near() ? null : explicitVer, resolveTaskName(), dhtVer, txEntry.updateCounter());
                                    txEntry.updateCounter(updRes.updateCounter());
                                    if (updRes.loggedPointer() != null)
                                        ptr = updRes.loggedPointer();
                                    // Keep near entry up to date.
                                    if (nearCached != null)
                                        nearCached.updateOrEvict(xidVer, null, 0, 0, nodeId, topVer);
                                } else if (op == RELOAD) {
                                    CacheObject reloaded = cached.innerReload();
                                    if (nearCached != null) {
                                        nearCached.innerReload();
                                        nearCached.updateOrEvict(cached.version(), reloaded, cached.expireTime(), cached.ttl(), nodeId, topVer);
                                    }
                                } else if (op == READ) {
                                    assert near();
                                    if (log.isDebugEnabled())
                                        log.debug("Ignoring READ entry when committing: " + txEntry);
                                } else // No-op.
                                {
                                    if (conflictCtx == null || !conflictCtx.isUseOld()) {
                                        if (txEntry.ttl() != CU.TTL_NOT_CHANGED)
                                            cached.updateTtl(null, txEntry.ttl());
                                        if (nearCached != null) {
                                            CacheObject val0 = cached.valueBytes();
                                            nearCached.updateOrEvict(xidVer, val0, cached.expireTime(), cached.ttl(), nodeId, topVer);
                                        }
                                    }
                                }
                                // that if we replaced removed entries.
                                assert txEntry.op() == READ || onePhaseCommit() || // and we simply allow the commit to proceed.
                                !cached.hasLockCandidateUnsafe(xidVer) || cached.lockedByUnsafe(xidVer) : "Transaction does not own lock for commit [entry=" + cached + ", tx=" + this + ']';
                                // Break out of while loop.
                                break;
                            } catch (GridCacheEntryRemovedException ignored) {
                                if (log.isDebugEnabled())
                                    log.debug("Attempting to commit a removed entry (will retry): " + txEntry);
                                // Renew cached entry.
                                txEntry.cached(cacheCtx.cache().entryEx(txEntry.key(), topologyVersion()));
                            }
                        }
                    }
                    // Apply cache size deltas.
                    applyTxSizes();
                    TxCounters txCntrs = txCounters(false);
                    // Apply update counters.
                    if (txCntrs != null)
                        cctx.tm().txHandler().applyPartitionsUpdatesCounters(txCntrs.updateCounters());
                    cctx.mvccCaching().onTxFinished(this, true);
                    if (!near() && !F.isEmpty(dataEntries) && cctx.wal() != null) {
                        // Set new update counters for data entries received from persisted tx entries.
                        List<DataEntry> entriesWithCounters = dataEntries.stream().map(tuple -> tuple.get1().partitionCounter(tuple.get2().updateCounter())).collect(Collectors.toList());
                        ptr = cctx.wal().log(new DataRecord(entriesWithCounters));
                    }
                    if (ptr != null)
                        cctx.wal().flush(ptr, false);
                } catch (Throwable ex) {
                    state(UNKNOWN);
                    if (X.hasCause(ex, NodeStoppingException.class)) {
                        U.warn(log, "Failed to commit transaction, node is stopping [tx=" + CU.txString(this) + ", err=" + ex + ']');
                        return;
                    }
                    err = heuristicException(ex);
                    try {
                        uncommit();
                    } catch (Throwable e) {
                        err.addSuppressed(e);
                    }
                    throw err;
                } finally {
                    for (GridDhtLocalPartition locPart : reservedParts) locPart.release();
                    cctx.database().checkpointReadUnlock();
                    if (wrapper != null)
                        wrapper.initialize(ret);
                }
            }
            cctx.tm().commitTx(this);
            state(COMMITTED);
        }
    }
}

Example 32 with GridCacheReturn

use of org.apache.ignite.internal.processors.cache.GridCacheReturn in project ignite by apache.

the class GridNearAtomicUpdateFuture method checkDhtNodes.

/**
 */
private void checkDhtNodes(long futId) {
    GridCacheReturn opRes0 = null;
    CachePartialUpdateCheckedException err0 = null;
    AffinityTopologyVersion remapTopVer0 = null;
    List<GridNearAtomicCheckUpdateRequest> checkReqs = null;
    boolean rcvAll = false;
    synchronized (this) {
        if (!checkFutureId(futId))
            return;
        if (singleReq != null) {
            if (!singleReq.req.initMappingLocally())
                return;
            DhtLeftResult res = singleReq.checkDhtNodes(cctx);
            if (res == DhtLeftResult.DONE) {
                opRes0 = opRes;
                err0 = err;
                remapTopVer0 = onAllReceived();
            } else if (res == DhtLeftResult.ALL_RCVD_CHECK_PRIMARY)
                checkReqs = Collections.singletonList(new GridNearAtomicCheckUpdateRequest(singleReq.req));
            else
                return;
        } else {
            if (mappings != null) {
                for (PrimaryRequestState reqState : mappings.values()) {
                    if (!reqState.req.initMappingLocally())
                        continue;
                    DhtLeftResult res = reqState.checkDhtNodes(cctx);
                    if (res == DhtLeftResult.DONE) {
                        assert mappings.size() > resCnt : "[mappings=" + mappings.size() + ", cnt=" + resCnt + ']';
                        resCnt++;
                        if (mappings.size() == resCnt) {
                            rcvAll = true;
                            opRes0 = opRes;
                            err0 = err;
                            remapTopVer0 = onAllReceived();
                            break;
                        }
                    } else if (res == DhtLeftResult.ALL_RCVD_CHECK_PRIMARY) {
                        if (checkReqs == null)
                            checkReqs = new ArrayList<>(mappings.size());
                        checkReqs.add(new GridNearAtomicCheckUpdateRequest(reqState.req));
                    }
                }
            } else
                return;
        }
    }
    if (checkReqs != null) {
        assert !rcvAll;
        for (int i = 0; i < checkReqs.size(); i++) sendCheckUpdateRequest(checkReqs.get(i));
    } else if (rcvAll)
        finishUpdateFuture(opRes0, err0, remapTopVer0, futId);
}

Example 33 with GridCacheReturn

use of org.apache.ignite.internal.processors.cache.GridCacheReturn in project ignite by apache.

the class GridNearAtomicUpdateFuture method onNodeLeft.

/**
 * {@inheritDoc}
 */
@Override
public boolean onNodeLeft(UUID nodeId) {
    GridCacheReturn opRes0 = null;
    CachePartialUpdateCheckedException err0 = null;
    AffinityTopologyVersion remapTopVer0 = null;
    boolean rcvAll = false;
    List<GridNearAtomicCheckUpdateRequest> checkReqs = null;
    long futId;
    synchronized (this) {
        if (!futureMapped())
            return false;
        futId = this.futId;
        if (singleReq != null) {
            if (singleReq.req.nodeId.equals(nodeId)) {
                GridNearAtomicAbstractUpdateRequest req = singleReq.onPrimaryFail();
                if (req != null) {
                    rcvAll = true;
                    GridNearAtomicUpdateResponse res = primaryFailedResponse(req);
                    singleReq.onPrimaryResponse(res, cctx);
                    onPrimaryError(req, res);
                }
            } else {
                DhtLeftResult res = singleReq.onDhtNodeLeft(nodeId);
                if (res == DhtLeftResult.DONE)
                    rcvAll = true;
                else if (res == DhtLeftResult.ALL_RCVD_CHECK_PRIMARY)
                    checkReqs = Collections.singletonList(new GridNearAtomicCheckUpdateRequest(singleReq.req));
            }
            if (rcvAll) {
                opRes0 = opRes;
                err0 = err;
                remapTopVer0 = onAllReceived();
            }
        } else {
            if (mappings == null)
                return false;
            for (Map.Entry<UUID, PrimaryRequestState> e : mappings.entrySet()) {
                assert e.getKey().equals(e.getValue().req.nodeId());
                PrimaryRequestState reqState = e.getValue();
                boolean reqDone = false;
                if (e.getKey().equals(nodeId)) {
                    GridNearAtomicAbstractUpdateRequest req = reqState.onPrimaryFail();
                    if (req != null) {
                        reqDone = true;
                        GridNearAtomicUpdateResponse res = primaryFailedResponse(req);
                        reqState.onPrimaryResponse(res, cctx);
                        onPrimaryError(req, res);
                    }
                } else {
                    DhtLeftResult res = reqState.onDhtNodeLeft(nodeId);
                    if (res == DhtLeftResult.DONE)
                        reqDone = true;
                    else if (res == DhtLeftResult.ALL_RCVD_CHECK_PRIMARY) {
                        if (checkReqs == null)
                            checkReqs = new ArrayList<>();
                        checkReqs.add(new GridNearAtomicCheckUpdateRequest(reqState.req));
                    }
                }
                if (reqDone) {
                    assert mappings.size() > resCnt : "[mappings=" + mappings.size() + ", cnt=" + resCnt + ']';
                    resCnt++;
                    if (mappings.size() == resCnt) {
                        rcvAll = true;
                        opRes0 = opRes;
                        err0 = err;
                        remapTopVer0 = onAllReceived();
                        break;
                    }
                }
            }
        }
    }
    if (checkReqs != null) {
        assert !rcvAll;
        for (int i = 0; i < checkReqs.size(); i++) sendCheckUpdateRequest(checkReqs.get(i));
    } else if (rcvAll)
        finishUpdateFuture(opRes0, err0, remapTopVer0, futId);
    return false;
}

Example 34 with GridCacheReturn

use of org.apache.ignite.internal.processors.cache.GridCacheReturn in project ignite by apache.

the class GridNearAtomicUpdateFuture method onDhtResponse.

/**
 * {@inheritDoc}
 */
@Override
public void onDhtResponse(UUID nodeId, GridDhtAtomicNearResponse res) {
    GridCacheReturn opRes0;
    CachePartialUpdateCheckedException err0;
    AffinityTopologyVersion remapTopVer0;
    synchronized (this) {
        if (!checkFutureId(res.futureId()))
            return;
        PrimaryRequestState reqState;
        if (singleReq != null) {
            assert singleReq.req.nodeId().equals(res.primaryId());
            if (opRes == null && res.hasResult())
                opRes = res.result();
            if (singleReq.onDhtResponse(nodeId, res)) {
                opRes0 = opRes;
                err0 = err;
                remapTopVer0 = onAllReceived();
            } else
                return;
        } else {
            reqState = mappings != null ? mappings.get(res.primaryId()) : null;
            if (reqState != null) {
                if (opRes == null && res.hasResult())
                    opRes = res.result();
                if (reqState.onDhtResponse(nodeId, res)) {
                    assert mappings.size() > resCnt : "[mappings=" + mappings.size() + ", cnt=" + resCnt + ']';
                    resCnt++;
                    if (mappings.size() == resCnt) {
                        opRes0 = opRes;
                        err0 = err;
                        remapTopVer0 = onAllReceived();
                    } else
                        return;
                } else
                    return;
            } else
                return;
        }
    }
    UpdateErrors errors = res.errors();
    if (errors != null) {
        assert errors.error() != null;
        completeFuture(null, errors.error(), res.futureId());
        return;
    }
    finishUpdateFuture(opRes0, err0, remapTopVer0, res.futureId());
}

Example 35 with GridCacheReturn

use of org.apache.ignite.internal.processors.cache.GridCacheReturn in project ignite by apache.

the class GridNearAtomicUpdateFuture method sendUpdateRequests.

/**
 * Sends messages to remote nodes and updates local cache.
 *
 * @param mappings Mappings to send.
 */
private void sendUpdateRequests(Map<UUID, PrimaryRequestState> mappings) {
    UUID locNodeId = cctx.localNodeId();
    GridNearAtomicAbstractUpdateRequest locUpdate = null;
    // Send messages to remote nodes first, then run local update.
    for (PrimaryRequestState reqState : mappings.values()) {
        GridNearAtomicAbstractUpdateRequest req = reqState.req;
        if (locNodeId.equals(req.nodeId())) {
            assert locUpdate == null : "Cannot have more than one local mapping [locUpdate=" + locUpdate + ", req=" + req + ']';
            locUpdate = req;
        } else {
            try {
                if (req.initMappingLocally() && reqState.mappedNodes.isEmpty())
                    reqState.resetLocalMapping();
                cctx.io().send(req.nodeId(), req, cctx.ioPolicy());
                if (msgLog.isDebugEnabled()) {
                    msgLog.debug("Near update fut, sent request [futId=" + req.futureId() + ", node=" + req.nodeId() + ']');
                }
            } catch (IgniteCheckedException e) {
                if (msgLog.isDebugEnabled()) {
                    msgLog.debug("Near update fut, failed to send request [futId=" + req.futureId() + ", node=" + req.nodeId() + ", err=" + e + ']');
                }
                onSendError(req, e);
            }
        }
    }
    if (locUpdate != null) {
        cache.updateAllAsyncInternal(cctx.localNode(), locUpdate, new GridDhtAtomicCache.UpdateReplyClosure() {

            @Override
            public void apply(GridNearAtomicAbstractUpdateRequest req, GridNearAtomicUpdateResponse res) {
                if (syncMode != FULL_ASYNC)
                    onPrimaryResponse(res.nodeId(), res, false);
                else if (res.remapTopologyVersion() != null)
                    ((GridDhtAtomicCache) cctx.cache()).remapToNewPrimary(req);
            }
        });
    }
    if (syncMode == FULL_ASYNC)
        completeFuture(new GridCacheReturn(cctx, true, true, null, null, true), null, null);
}