Examples with TraceSurroundings org.apache.ignite.internal.processors.tracing.MTC.TraceSurroundings used on opensource projects

Example 6 with TraceSurroundings

use of org.apache.ignite.internal.processors.tracing.MTC.TraceSurroundings in project ignite by apache.

the class GridDhtLockFuture method map.

/**
 */
public void map() {
    try (TraceSurroundings ignored = MTC.supportContinual(span = cctx.kernalContext().tracing().create(TX_DHT_LOCK_MAP, MTC.span()))) {
        if (F.isEmpty(entries)) {
            onComplete(true, false, true);
            return;
        }
        readyLocks();
        if (timeout > 0 && !isDone()) {
            // Prevent memory leak if future is completed by call to readyLocks.
            timeoutObj = new LockTimeoutObject();
            cctx.time().addTimeoutObject(timeoutObj);
        }
    }
}

Example 7 with TraceSurroundings

use of org.apache.ignite.internal.processors.tracing.MTC.TraceSurroundings in project ignite by apache.

the class GridDhtTxPrepareFuture method onDone.

/**
 * {@inheritDoc}
 */
@Override
public boolean onDone(GridNearTxPrepareResponse res0, Throwable err) {
    try (TraceSurroundings ignored2 = MTC.support(span)) {
        assert err != null || (initialized() && !hasPending()) : "On done called for prepare future that has " + "pending mini futures: " + this;
        ERR_UPD.compareAndSet(this, null, err);
        // Must clear prepare future before response is sent or listeners are notified.
        if (tx.optimistic())
            tx.clearPrepareFuture(this);
        // Do not commit one-phase commit transaction if originating node has near cache enabled.
        if (tx.commitOnPrepare()) {
            assert last;
            Throwable prepErr = this.err;
            // Must create prepare response before transaction is committed to grab correct return value.
            final GridNearTxPrepareResponse res = createPrepareResponse(prepErr);
            onComplete(res);
            if (tx.markFinalizing(IgniteInternalTx.FinalizationStatus.USER_FINISH)) {
                CIX1<IgniteInternalFuture<IgniteInternalTx>> resClo = new CIX1<IgniteInternalFuture<IgniteInternalTx>>() {

                    @Override
                    public void applyx(IgniteInternalFuture<IgniteInternalTx> fut) {
                        if (res.error() == null && fut.error() != null)
                            res.error(fut.error());
                        if (REPLIED_UPD.compareAndSet(GridDhtTxPrepareFuture.this, 0, 1))
                            sendPrepareResponse(res);
                    }
                };
                try {
                    if (prepErr == null) {
                        try {
                            tx.commitAsync().listen(resClo);
                        } catch (Throwable e) {
                            res.error(e);
                            tx.systemInvalidate(true);
                            try {
                                tx.rollbackAsync().listen(resClo);
                            } catch (Throwable e1) {
                                e.addSuppressed(e1);
                            }
                            throw e;
                        }
                    } else if (!cctx.kernalContext().isStopping()) {
                        try {
                            tx.rollbackAsync().listen(resClo);
                        } catch (Throwable e) {
                            if (err != null)
                                err.addSuppressed(e);
                            throw err;
                        }
                    }
                } catch (Throwable e) {
                    tx.logTxFinishErrorSafe(log, true, e);
                    cctx.kernalContext().failure().process(new FailureContext(FailureType.CRITICAL_ERROR, e));
                }
            }
            return true;
        } else {
            if (REPLIED_UPD.compareAndSet(this, 0, 1)) {
                GridNearTxPrepareResponse res = createPrepareResponse(this.err);
                // Will call super.onDone().
                onComplete(res);
                sendPrepareResponse(res);
                return true;
            } else {
                // Other thread is completing future. Wait for it to complete.
                try {
                    if (err != null)
                        get();
                } catch (IgniteInterruptedException e) {
                    onError(new IgniteCheckedException("Got interrupted while waiting for replies to be sent.", e));
                } catch (IgniteCheckedException ignored) {
                // No-op, get() was just synchronization.
                }
                return false;
            }
        }
    }
}

Example 8 with TraceSurroundings

use of org.apache.ignite.internal.processors.tracing.MTC.TraceSurroundings in project ignite by apache.

the class GridIoManager method send.

/**
 * @param node Destination node.
 * @param topic Topic to send the message to.
 * @param topicOrd GridTopic enumeration ordinal.
 * @param msg Message to send.
 * @param plc Type of processing.
 * @param ordered Ordered flag.
 * @param timeout Timeout.
 * @param skipOnTimeout Whether message can be skipped on timeout.
 * @param ackC Ack closure.
 * @param async If {@code true} message for local node will be processed in pool, otherwise in current thread.
 * @throws IgniteCheckedException Thrown in case of any errors.
 */
private void send(ClusterNode node, Object topic, int topicOrd, Message msg, byte plc, boolean ordered, long timeout, boolean skipOnTimeout, IgniteInClosure<IgniteException> ackC, boolean async) throws IgniteCheckedException {
    assert node != null;
    assert topic != null;
    assert msg != null;
    // Async execution was added only for IgniteMessaging.
    assert !async || msg instanceof GridIoUserMessage : msg;
    assert topicOrd >= 0 || !(topic instanceof GridTopic) : msg;
    try (TraceSurroundings ignored = support(null)) {
        MTC.span().addLog(() -> "Create communication msg - " + traceName(msg));
        GridIoMessage ioMsg = createGridIoMessage(topic, topicOrd, msg, plc, ordered, timeout, skipOnTimeout);
        if (locNodeId.equals(node.id())) {
            assert plc != P2P_POOL;
            CommunicationListener commLsnr = this.commLsnr;
            if (commLsnr == null)
                throw new IgniteCheckedException("Trying to send message when grid is not fully started.");
            if (ordered)
                processOrderedMessage(locNodeId, ioMsg, plc, null);
            else if (async)
                processRegularMessage(locNodeId, ioMsg, plc, NOOP);
            else
                processRegularMessage0(ioMsg, locNodeId);
            if (ackC != null)
                ackC.apply(null);
        } else {
            if (topicOrd < 0)
                ioMsg.topicBytes(U.marshal(marsh, topic));
            try {
                if ((CommunicationSpi<?>) getSpi() instanceof TcpCommunicationSpi)
                    getTcpCommunicationSpi().sendMessage(node, ioMsg, ackC);
                else
                    getSpi().sendMessage(node, ioMsg);
            } catch (IgniteSpiException e) {
                if (e.getCause() instanceof ClusterTopologyCheckedException)
                    throw (ClusterTopologyCheckedException) e.getCause();
                if (!ctx.discovery().alive(node))
                    throw new ClusterTopologyCheckedException("Failed to send message, node left: " + node.id(), e);
                throw new IgniteCheckedException("Failed to send message (node may have left the grid or " + "TCP connection cannot be established due to firewall issues) " + "[node=" + node + ", topic=" + topic + ", msg=" + msg + ", policy=" + plc + ']', e);
            }
        }
    }
}

Example 9 with TraceSurroundings

use of org.apache.ignite.internal.processors.tracing.MTC.TraceSurroundings in project ignite by apache.

the class GridNearTxLocal method enlistRead.

/**
 * @param cacheCtx Cache context.
 * @param keys Key to enlist.
 * @param expiryPlc Explicitly specified expiry policy for entry.
 * @param map Return map.
 * @param missed Map of missed keys.
 * @param keysCnt Keys count (to avoid call to {@code Collection.size()}).
 * @param deserializeBinary Deserialize binary flag.
 * @param skipVals Skip values flag.
 * @param keepCacheObjects Keep cache objects flag.
 * @param skipStore Skip store flag.
 * @param recovery Recovery flag..
 * @return Enlisted keys.
 * @throws IgniteCheckedException If failed.
 */
@SuppressWarnings({ "RedundantTypeArguments" })
private <K, V> Collection<KeyCacheObject> enlistRead(final GridCacheContext cacheCtx, @Nullable AffinityTopologyVersion entryTopVer, Collection<KeyCacheObject> keys, @Nullable ExpiryPolicy expiryPlc, Map<K, V> map, Map<KeyCacheObject, GridCacheVersion> missed, int keysCnt, boolean deserializeBinary, boolean skipVals, boolean keepCacheObjects, boolean skipStore, boolean recovery, ReadRepairStrategy readRepairStrategy, final boolean needVer) throws IgniteCheckedException {
    assert !F.isEmpty(keys);
    assert keysCnt == keys.size();
    try (TraceSurroundings ignored2 = MTC.support(context().kernalContext().tracing().create(TX_NEAR_ENLIST_READ, MTC.span()))) {
        cacheCtx.checkSecurity(SecurityPermission.CACHE_READ);
        boolean single = keysCnt == 1;
        Collection<KeyCacheObject> lockKeys = null;
        AffinityTopologyVersion topVer = entryTopVer != null ? entryTopVer : topologyVersion();
        boolean needReadVer = (serializable() && optimistic()) || needVer;
        // outside of this loop.
        for (KeyCacheObject key : keys) {
            if (isRollbackOnly())
                throw timedOut() ? timeoutException() : rollbackException();
            if ((pessimistic() || needReadVer) && !readCommitted() && !skipVals)
                addActiveCache(cacheCtx, recovery);
            IgniteTxKey txKey = cacheCtx.txKey(key);
            // Check write map (always check writes first).
            IgniteTxEntry txEntry = entry(txKey);
            // Either non-read-committed or there was a previous write.
            if (txEntry != null) {
                CacheObject val = txEntry.value();
                if (txEntry.hasValue()) {
                    if (!F.isEmpty(txEntry.entryProcessors()))
                        val = txEntry.applyEntryProcessors(val);
                    if (val != null) {
                        GridCacheVersion ver = null;
                        if (needVer) {
                            if (txEntry.op() != READ)
                                ver = IgniteTxEntry.GET_ENTRY_INVALID_VER_UPDATED;
                            else {
                                ver = txEntry.entryReadVersion();
                                if (ver == null && pessimistic()) {
                                    while (true) {
                                        try {
                                            GridCacheEntryEx cached = txEntry.cached();
                                            ver = cached.isNear() ? ((GridNearCacheEntry) cached).dhtVersion() : cached.version();
                                            break;
                                        } catch (GridCacheEntryRemovedException ignored) {
                                            txEntry.cached(entryEx(cacheCtx, txEntry.txKey(), topVer));
                                        }
                                    }
                                }
                                if (ver == null) {
                                    assert optimistic() && repeatableRead() : this;
                                    ver = IgniteTxEntry.GET_ENTRY_INVALID_VER_AFTER_GET;
                                }
                            }
                            assert ver != null;
                        }
                        cacheCtx.addResult(map, key, val, skipVals, keepCacheObjects, deserializeBinary, false, ver, 0, 0, U.deploymentClassLoader(cctx.kernalContext(), deploymentLdrId));
                    }
                } else {
                    assert txEntry.op() == TRANSFORM;
                    while (true) {
                        try {
                            GridCacheVersion readVer = null;
                            EntryGetResult getRes = null;
                            Object transformClo = (txEntry.op() == TRANSFORM && cctx.gridEvents().isRecordable(EVT_CACHE_OBJECT_READ)) ? F.first(txEntry.entryProcessors()) : null;
                            if (needVer) {
                                getRes = txEntry.cached().innerGetVersioned(null, this, /*update-metrics*/
                                true, /*event*/
                                !skipVals, transformClo, resolveTaskName(), null, txEntry.keepBinary(), null);
                                if (getRes != null) {
                                    val = getRes.value();
                                    readVer = getRes.version();
                                }
                            } else {
                                val = txEntry.cached().innerGet(null, this, /*read-through*/
                                false, /*metrics*/
                                true, /*event*/
                                !skipVals, transformClo, resolveTaskName(), null, txEntry.keepBinary());
                            }
                            if (val != null) {
                                if (!readCommitted() && !skipVals)
                                    txEntry.readValue(val);
                                if (!F.isEmpty(txEntry.entryProcessors()))
                                    val = txEntry.applyEntryProcessors(val);
                                cacheCtx.addResult(map, key, val, skipVals, keepCacheObjects, deserializeBinary, false, getRes, readVer, 0, 0, needVer, U.deploymentClassLoader(cctx.kernalContext(), deploymentLdrId));
                            } else
                                missed.put(key, txEntry.cached().version());
                            break;
                        } catch (GridCacheEntryRemovedException ignored) {
                            txEntry.cached(entryEx(cacheCtx, txEntry.txKey(), topVer));
                        }
                    }
                }
            } else // First time access within transaction.
            {
                if (lockKeys == null && !skipVals)
                    lockKeys = single ? Collections.singleton(key) : new ArrayList<KeyCacheObject>(keysCnt);
                if (!single && !skipVals)
                    lockKeys.add(key);
                while (true) {
                    GridCacheEntryEx entry = entryEx(cacheCtx, txKey, topVer);
                    try {
                        GridCacheVersion ver = entry.version();
                        CacheObject val = null;
                        GridCacheVersion readVer = null;
                        EntryGetResult getRes = null;
                        if ((!pessimistic() || (readCommitted() && !skipVals)) && readRepairStrategy == null) {
                            IgniteCacheExpiryPolicy accessPlc = optimistic() ? accessPolicy(cacheCtx, txKey, expiryPlc) : null;
                            if (needReadVer) {
                                getRes = primaryLocal(entry) ? entry.innerGetVersioned(null, this, /*metrics*/
                                true, /*event*/
                                true, null, resolveTaskName(), accessPlc, !deserializeBinary, null) : null;
                                if (getRes != null) {
                                    val = getRes.value();
                                    readVer = getRes.version();
                                }
                            } else {
                                val = entry.innerGet(null, this, /*read-through*/
                                false, /*metrics*/
                                true, /*event*/
                                !skipVals, null, resolveTaskName(), accessPlc, !deserializeBinary);
                            }
                            if (val != null) {
                                cacheCtx.addResult(map, key, val, skipVals, keepCacheObjects, deserializeBinary, false, getRes, readVer, 0, 0, needVer, U.deploymentClassLoader(cctx.kernalContext(), deploymentLdrId));
                            } else
                                missed.put(key, ver);
                        } else
                            // We must wait for the lock in pessimistic mode.
                            missed.put(key, ver);
                        if (!readCommitted() && !skipVals) {
                            txEntry = addEntry(READ, val, null, null, entry, expiryPlc, null, true, -1L, -1L, null, skipStore, !deserializeBinary, CU.isNearEnabled(cacheCtx));
                            // for non-pessimistic if value is not null.
                            if (val != null && !pessimistic()) {
                                txEntry.markValid();
                                if (needReadVer) {
                                    assert readVer != null;
                                    txEntry.entryReadVersion(readVer);
                                }
                            }
                        }
                        // While.
                        break;
                    } catch (GridCacheEntryRemovedException ignored) {
                        if (log.isDebugEnabled())
                            log.debug("Got removed entry in transaction getAllAsync(..) (will retry): " + key);
                    } finally {
                        if (entry != null && readCommitted()) {
                            if (cacheCtx.isNear()) {
                                if (cacheCtx.affinity().partitionBelongs(cacheCtx.localNode(), entry.partition(), topVer)) {
                                    if (entry.markObsolete(xidVer))
                                        cacheCtx.cache().removeEntry(entry);
                                }
                            } else
                                entry.touch();
                        }
                    }
                }
            }
        }
        return lockKeys != null ? lockKeys : Collections.<KeyCacheObject>emptyList();
    }
}

Example 10 with TraceSurroundings

use of org.apache.ignite.internal.processors.tracing.MTC.TraceSurroundings in project ignite by apache.

the class GridNearTxLocal method enlistWrite.

/**
 * Internal routine for <tt>putAll(..)</tt>
 *
 * @param cacheCtx Cache context.
 * @param keys Keys to enlist.
 * @param expiryPlc Explicitly specified expiry policy for entry.
 * @param lookup Value lookup map ({@code null} for remove).
 * @param invokeMap Map with entry processors for invoke operation.
 * @param invokeArgs Optional arguments for EntryProcessor.
 * @param retval Flag indicating whether a value should be returned.
 * @param lockOnly If {@code true}, then entry will be enlisted as noop.
 * @param filter User filters.
 * @param ret Return value.
 * @param enlisted Collection of keys enlisted into this transaction.
 * @param drPutMap DR put map (optional).
 * @param drRmvMap DR remove map (optional).
 * @param skipStore Skip store flag.
 * @param singleRmv {@code True} for single key remove operation ({@link Cache#remove(Object)}.
 * @param keepBinary Keep binary flag.
 * @param recovery Recovery flag.
 * @param dataCenterId Optional data center ID.
 * @return Future for enlisting writes.
 */
private <K, V> IgniteInternalFuture<Void> enlistWrite(final GridCacheContext cacheCtx, @Nullable AffinityTopologyVersion entryTopVer, Collection<?> keys, @Nullable ExpiryPolicy expiryPlc, @Nullable Map<?, ?> lookup, @Nullable Map<?, EntryProcessor<K, V, Object>> invokeMap, @Nullable Object[] invokeArgs, final boolean retval, boolean lockOnly, final CacheEntryPredicate[] filter, final GridCacheReturn ret, Collection<KeyCacheObject> enlisted, @Nullable Map<KeyCacheObject, GridCacheDrInfo> drPutMap, @Nullable Map<KeyCacheObject, GridCacheVersion> drRmvMap, boolean skipStore, final boolean singleRmv, final boolean keepBinary, final boolean recovery, Byte dataCenterId) {
    assert retval || invokeMap == null;
    try (TraceSurroundings ignored2 = MTC.support(context().kernalContext().tracing().create(TX_NEAR_ENLIST_WRITE, MTC.span()))) {
        GridFutureAdapter<Void> enlistFut = new GridFutureAdapter<>();
        if (!updateLockFuture(null, enlistFut))
            return finishFuture(enlistFut, timedOut() ? timeoutException() : rollbackException(), false);
        try {
            addActiveCache(cacheCtx, recovery);
        } catch (IgniteCheckedException e) {
            return finishFuture(enlistFut, e, false);
        }
        boolean rmv = lookup == null && invokeMap == null;
        final boolean hasFilters = !F.isEmptyOrNulls(filter) && !F.isAlwaysTrue(filter);
        final boolean needVal = singleRmv || retval || hasFilters;
        final boolean needReadVer = needVal && (serializable() && optimistic());
        try {
            // Set transform flag for transaction.
            if (invokeMap != null)
                transform = true;
            Set<KeyCacheObject> missedForLoad = null;
            for (Object key : keys) {
                if (isRollbackOnly())
                    return finishFuture(enlistFut, timedOut() ? timeoutException() : rollbackException(), false);
                if (key == null) {
                    rollback();
                    throw new NullPointerException("Null key.");
                }
                Object val = rmv || lookup == null ? null : lookup.get(key);
                EntryProcessor entryProcessor = invokeMap == null ? null : invokeMap.get(key);
                GridCacheVersion drVer;
                long drTtl;
                long drExpireTime;
                if (drPutMap != null) {
                    GridCacheDrInfo info = drPutMap.get(key);
                    assert info != null;
                    drVer = info.version();
                    drTtl = info.ttl();
                    drExpireTime = info.expireTime();
                } else if (drRmvMap != null) {
                    assert drRmvMap.get(key) != null;
                    drVer = drRmvMap.get(key);
                    drTtl = -1L;
                    drExpireTime = -1L;
                } else if (dataCenterId != null) {
                    drVer = cacheCtx.cache().nextVersion(dataCenterId);
                    drTtl = -1L;
                    drExpireTime = -1L;
                } else {
                    drVer = null;
                    drTtl = -1L;
                    drExpireTime = -1L;
                }
                if (!rmv && val == null && entryProcessor == null) {
                    setRollbackOnly();
                    throw new NullPointerException("Null value.");
                }
                KeyCacheObject cacheKey = cacheCtx.toCacheKeyObject(key);
                boolean loadMissed = enlistWriteEntry(cacheCtx, entryTopVer, cacheKey, val, entryProcessor, invokeArgs, expiryPlc, retval, lockOnly, filter, drVer, drTtl, drExpireTime, ret, enlisted, skipStore, singleRmv, hasFilters, needVal, needReadVer, keepBinary, recovery);
                if (loadMissed) {
                    if (missedForLoad == null)
                        missedForLoad = new HashSet<>();
                    missedForLoad.add(cacheKey);
                }
            }
            if (missedForLoad != null) {
                AffinityTopologyVersion topVer = topologyVersionSnapshot();
                if (topVer == null)
                    topVer = entryTopVer;
                IgniteInternalFuture<Void> loadFut = loadMissing(cacheCtx, topVer != null ? topVer : topologyVersion(), missedForLoad, filter, ret, needReadVer, singleRmv, hasFilters, /*read through*/
                (invokeMap != null || cacheCtx.config().isLoadPreviousValue()) && !skipStore, retval, keepBinary, recovery, expiryPlc);
                loadFut.listen(new IgniteInClosure<IgniteInternalFuture<Void>>() {

                    @Override
                    public void apply(IgniteInternalFuture<Void> fut) {
                        try {
                            fut.get();
                            finishFuture(enlistFut, null, true);
                        } catch (IgniteCheckedException e) {
                            finishFuture(enlistFut, e, true);
                        }
                    }
                });
                return enlistFut;
            }
            return finishFuture(enlistFut, null, true);
        } catch (IgniteCheckedException e) {
            return finishFuture(enlistFut, e, true);
        }
    }
}