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

Example 41 with GridCacheVersion

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

the class WalStat method registerTxRecord.

/**
 * @param txRecord TX record to handle.
 */
private void registerTxRecord(TxRecord txRecord) {
    final TransactionState state = txRecord.state();
    incrementStat(state.toString(), txRecord, txRecordAct);
    int totalNodes = 0;
    final Map<Short, Collection<Short>> map = txRecord.participatingNodes();
    if (map != null) {
        incrementStat(map.size(), txRecord, txRecordPrimNodesCnt);
        final HashSet<Object> set = new HashSet<>(150);
        for (Map.Entry<Short, Collection<Short>> next : map.entrySet()) {
            set.add(next.getKey());
            set.addAll(next.getValue());
        }
        totalNodes = set.size();
        incrementStat(totalNodes, txRecord, txRecordNodesCnt);
    }
    final GridCacheVersion ver = txRecord.nearXidVersion();
    if (ver != null) {
        switch(state) {
            case PREPARING:
            case PREPARED:
                txStat.onTxPrepareStart(ver, map != null ? map.size() : 0, totalNodes);
                break;
            case COMMITTED:
                txStat.onTxEnd(ver, true);
                break;
            default:
                txStat.onTxEnd(ver, false);
        }
    }
}

Example 42 with GridCacheVersion

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

the class GridNearAtomicCache method processNearAtomicUpdateResponse.

/**
 * @param req Update request.
 * @param res Update response.
 */
public void processNearAtomicUpdateResponse(GridNearAtomicAbstractUpdateRequest req, GridNearAtomicUpdateResponse res) {
    if (F.size(res.failedKeys()) == req.size())
        return;
    /*
         * Choose value to be stored in near cache: first check key is not in failed and not in skipped list,
         * then check if value was generated on primary node, if not then use value sent in request.
         */
    Collection<KeyCacheObject> failed = res.failedKeys();
    List<Integer> nearValsIdxs = res.nearValuesIndexes();
    List<Integer> skipped = res.skippedIndexes();
    GridCacheVersion ver = res.nearVersion();
    assert ver != null : "Failed to find version [req=" + req + ", res=" + res + ']';
    int nearValIdx = 0;
    String taskName = ctx.kernalContext().task().resolveTaskName(req.taskNameHash());
    for (int i = 0; i < req.size(); i++) {
        if (F.contains(skipped, i))
            continue;
        KeyCacheObject key = req.key(i);
        if (F.contains(failed, key))
            continue;
        if (ctx.affinity().partitionBelongs(ctx.localNode(), ctx.affinity().partition(key), req.topologyVersion())) {
            // Reader became backup.
            GridCacheEntryEx entry = peekEx(key);
            if (entry != null && entry.markObsolete(ver))
                removeEntry(entry);
            continue;
        }
        CacheObject val = null;
        if (F.contains(nearValsIdxs, i)) {
            val = res.nearValue(nearValIdx);
            nearValIdx++;
        } else {
            assert req.operation() != TRANSFORM;
            if (req.operation() != DELETE)
                val = req.value(i);
        }
        long ttl = res.nearTtl(i);
        long expireTime = res.nearExpireTime(i);
        if (ttl != CU.TTL_NOT_CHANGED && expireTime == CU.EXPIRE_TIME_CALCULATE)
            expireTime = CU.toExpireTime(ttl);
        try {
            processNearAtomicUpdateResponse(ver, key, val, ttl, expireTime, req.keepBinary(), req.nodeId(), req.subjectId(), taskName);
        } catch (IgniteCheckedException e) {
            res.addFailedKey(key, new IgniteCheckedException("Failed to update key in near cache: " + key, e));
        }
    }
}

Example 43 with GridCacheVersion

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

the class GridNearGetFuture method map.

/**
 * @param mappings Mappings.
 * @param key Key to map.
 * @param topVer Topology version
 * @param mapped Previously mapped.
 * @param saved Reserved near cache entries.
 * @return Map.
 */
@SuppressWarnings("unchecked")
private Map<KeyCacheObject, GridNearCacheEntry> map(KeyCacheObject key, Map<ClusterNode, LinkedHashMap<KeyCacheObject, Boolean>> mappings, AffinityTopologyVersion topVer, Map<ClusterNode, LinkedHashMap<KeyCacheObject, Boolean>> mapped, Map<KeyCacheObject, GridNearCacheEntry> saved) {
    int part = cctx.affinity().partition(key);
    List<ClusterNode> affNodes = cctx.affinity().nodesByPartition(part, topVer);
    if (affNodes.isEmpty()) {
        onDone(serverNotFoundError(topVer));
        return null;
    }
    final GridNearCacheAdapter near = cache();
    // Allow to get cached value from the local node.
    boolean allowLocRead = !forcePrimary || cctx.localNode().equals(affNodes.get(0));
    while (true) {
        GridNearCacheEntry entry = allowLocRead ? (GridNearCacheEntry) near.peekEx(key) : null;
        try {
            CacheObject v = null;
            GridCacheVersion ver = null;
            boolean isNear = entry != null;
            // First we peek into near cache.
            if (isNear) {
                if (needVer) {
                    EntryGetResult res = entry.innerGetVersioned(null, null, /*update-metrics*/
                    true, /*event*/
                    !skipVals, subjId, null, taskName, expiryPlc, !deserializeBinary, null);
                    if (res != null) {
                        v = res.value();
                        ver = res.version();
                    }
                } else {
                    v = entry.innerGet(null, tx, /*read-through*/
                    false, /*metrics*/
                    true, /*events*/
                    !skipVals, subjId, null, taskName, expiryPlc, !deserializeBinary);
                }
            }
            if (v == null) {
                boolean fastLocGet = allowLocRead && cctx.reserveForFastLocalGet(part, topVer);
                if (fastLocGet) {
                    try {
                        if (localDhtGet(key, part, topVer, isNear))
                            break;
                    } finally {
                        cctx.releaseForFastLocalGet(part, topVer);
                    }
                }
                ClusterNode affNode = cctx.selectAffinityNodeBalanced(affNodes, canRemap);
                if (affNode == null) {
                    onDone(serverNotFoundError(topVer));
                    return saved;
                }
                if (cctx.statisticsEnabled() && !skipVals && !affNode.isLocal())
                    cache().metrics0().onRead(false);
                LinkedHashMap<KeyCacheObject, Boolean> keys = mapped.get(affNode);
                if (keys != null && keys.containsKey(key)) {
                    if (REMAP_CNT_UPD.incrementAndGet(this) > MAX_REMAP_CNT) {
                        onDone(new ClusterTopologyCheckedException("Failed to remap key to a new node after " + MAX_REMAP_CNT + " attempts (key got remapped to the same node) " + "[key=" + key + ", node=" + U.toShortString(affNode) + ", mappings=" + mapped + ']'));
                        return saved;
                    }
                }
                if (!affNodes.contains(cctx.localNode())) {
                    GridNearCacheEntry nearEntry = entry != null ? entry : near.entryExx(key, topVer);
                    nearEntry.reserveEviction();
                    entry = null;
                    if (saved == null)
                        saved = U.newHashMap(3);
                    saved.put(key, nearEntry);
                }
                // Don't add reader if transaction acquires lock anyway to avoid deadlock.
                boolean addRdr = tx == null || tx.optimistic();
                if (!addRdr && tx.readCommitted() && !tx.writeSet().contains(cctx.txKey(key)))
                    addRdr = true;
                LinkedHashMap<KeyCacheObject, Boolean> old = mappings.get(affNode);
                if (old == null)
                    mappings.put(affNode, old = new LinkedHashMap<>(3, 1f));
                old.put(key, addRdr);
            } else
                addResult(key, v, ver);
            break;
        } catch (IgniteCheckedException e) {
            onDone(e);
            break;
        } catch (GridCacheEntryRemovedException ignored) {
        // Retry.
        } finally {
            if (entry != null && tx == null)
                cctx.evicts().touch(entry, topVer);
        }
    }
    return saved;
}

Example 44 with GridCacheVersion

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

the class GridNearGetFuture method loadEntries.

/**
 * @param nodeId Node id.
 * @param keys Keys.
 * @param infos Entry infos.
 * @param savedEntries Saved entries.
 * @param topVer Topology version
 * @return Result map.
 */
private Map<K, V> loadEntries(UUID nodeId, Collection<KeyCacheObject> keys, Collection<GridCacheEntryInfo> infos, Map<KeyCacheObject, GridNearCacheEntry> savedEntries, AffinityTopologyVersion topVer) {
    boolean empty = F.isEmpty(keys);
    Map<K, V> map = empty ? Collections.<K, V>emptyMap() : new GridLeanMap<K, V>(keys.size());
    if (!empty) {
        boolean atomic = cctx.atomic();
        GridCacheVersion ver = atomic ? null : F.isEmpty(infos) ? null : cctx.versions().next();
        for (GridCacheEntryInfo info : infos) {
            try {
                info.unmarshalValue(cctx, cctx.deploy().globalLoader());
                // Entries available locally in DHT should not be loaded into near cache for reading.
                if (!cctx.affinity().keyLocalNode(info.key(), cctx.affinity().affinityTopologyVersion())) {
                    GridNearCacheEntry entry = savedEntries.get(info.key());
                    if (entry == null)
                        entry = cache().entryExx(info.key(), topVer);
                    // Load entry into cache.
                    entry.loadedValue(tx, nodeId, info.value(), atomic ? info.version() : ver, info.version(), info.ttl(), info.expireTime(), true, !deserializeBinary, topVer, subjId);
                }
                CacheObject val = info.value();
                KeyCacheObject key = info.key();
                assert skipVals == (info.value() == null);
                cctx.addResult(map, key, val, skipVals, keepCacheObjects, deserializeBinary, false, needVer ? info.version() : null, 0, 0);
            } catch (GridCacheEntryRemovedException ignore) {
                if (log.isDebugEnabled())
                    log.debug("Got removed entry while processing get response (will not retry).");
            } catch (Exception e) {
                // Fail.
                onDone(e);
                return Collections.emptyMap();
            }
        }
    }
    return map;
}

Example 45 with GridCacheVersion

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

the class GridDhtCacheEntry method localCandidateByNearVersion.

/**
 * @param nearVer Near version.
 * @param rmv If {@code true}, then add to removed list if not found.
 * @return Local candidate by near version.
 * @throws GridCacheEntryRemovedException If removed.
 */
@Nullable
GridCacheMvccCandidate localCandidateByNearVersion(GridCacheVersion nearVer, boolean rmv) throws GridCacheEntryRemovedException {
    lockEntry();
    try {
        checkObsolete();
        GridCacheMvcc mvcc = mvccExtras();
        if (mvcc != null) {
            for (GridCacheMvccCandidate c : mvcc.localCandidatesNoCopy(false)) {
                GridCacheVersion ver = c.otherVersion();
                if (ver != null && ver.equals(nearVer))
                    return c;
            }
        }
        if (rmv)
            addRemoved(nearVer);
        return null;
    } finally {
        unlockEntry();
    }
}