@Override public IgniteInternalFuture<V> apply() { return getAsync0(ctx.toCacheKeyObject(key), forcePrimary, subjId0, taskName, deserializeBinary, recovery, expiryPlc, skipVals, skipStore, needVer); } });
@Override public KeyCacheObject apply(Object key) { if (key == null) throw new NullPointerException("Null key."); return toCacheKeyObject(key); } });
/** * @param key Entry key. * @return Entry (never {@code null}). */ public final GridCacheEntryEx entryEx(Object key) { return entryEx(ctx.toCacheKeyObject(key)); }
/** {@inheritDoc} */ @Override public boolean isLockedByThread(K key) { KeyCacheObject cacheKey = ctx.toCacheKeyObject(key); return ctx.mvcc().isLockedByThread(ctx.txKey(cacheKey), Thread.currentThread().getId()); }
@Override public void apply(Object k, Object val) { if (convert) { Object v = convert(val); vis.apply(cctx.toCacheKeyObject(k), v); } else { IgniteBiTuple<Object, GridCacheVersion> v = (IgniteBiTuple<Object, GridCacheVersion>)val; if (v != null) verVis.apply(cctx.toCacheKeyObject(k), v.get1(), v.get2()); } } };
/** * * @param key Entry key. * @return Entry or <tt>null</tt>. */ @Nullable public final GridCacheEntryEx peekEx(Object key) { return entry0(ctx.toCacheKeyObject(key), ctx.affinity().affinityTopologyVersion(), false, false); }
/** {@inheritDoc} */ @Override public boolean isLocked(K key) { KeyCacheObject cacheKey = ctx.toCacheKeyObject(key); return ctx.mvcc().isLockedByThread(ctx.txKey(cacheKey), -1); }
/** * @param ctx Context. * @param key Key. */ GridCacheTestEntryEx(GridCacheContext ctx, Object key) { mvcc = new GridCacheMvcc(ctx); this.key = ctx.toCacheKeyObject(key); }
@Override public void apply(Object k, Object o) { Object v; GridCacheVersion ver = null; if (locStore) { IgniteBiTuple<Object, GridCacheVersion> t = (IgniteBiTuple<Object, GridCacheVersion>)o; v = t.get1(); ver = t.get2(); } else v = o; KeyCacheObject cacheKey = cctx.toCacheKeyObject(k); vis.apply(cacheKey, v, ver); } }, args);
/** {@inheritDoc} */ @Override public boolean isLocked(K key) { A.notNull(key, "key"); if (keyCheck) validateCacheKey(key); KeyCacheObject cacheKey = ctx.toCacheKeyObject(key); while (true) { try { GridCacheEntryEx entry = peekEx(cacheKey); return entry != null && entry.lockedByAny(); } catch (GridCacheEntryRemovedException ignore) { // No-op. } } }
/** */ private KeyCacheObject toKey(EnlistOperation op, Object cur) { KeyCacheObject key = cctx.toCacheKeyObject(op.isDeleteOrLock() ? cur : ((IgniteBiTuple)cur).getKey()); if (key.partition() == -1) key.partition(cctx.affinity().partition(key)); return key; }
/** {@inheritDoc} */ @Nullable @Override public V get(K key) throws IgniteCheckedException { A.notNull(key, "key"); boolean statsEnabled = ctx.statisticsEnabled(); long start = statsEnabled ? System.nanoTime() : 0L; boolean keepBinary = ctx.keepBinary(); if (keepBinary) key = (K)ctx.toCacheKeyObject(key); V val = get(key, !keepBinary, false); if (ctx.config().getInterceptor() != null) { key = keepBinary ? (K)ctx.unwrapBinaryIfNeeded(key, true, false) : key; val = (V)ctx.config().getInterceptor().onGet(key, val); } if (statsEnabled) metrics0().addGetTimeNanos(System.nanoTime() - start); return val; }
/** {@inheritDoc} */ @Override public void unlockAll( Collection<? extends K> keys ) throws IgniteCheckedException { AffinityTopologyVersion topVer = ctx.affinity().affinityTopologyVersion(); for (K key : keys) { GridLocalCacheEntry entry = peekExx(ctx.toCacheKeyObject(key)); if (entry != null && ctx.isAll(entry, CU.empty0())) { entry.releaseLocal(); entry.touch(); } } }
/** * @param cache Cache. * @param key Key. * @return Collection of versioned rows. * @throws IgniteCheckedException if failed. */ private List<CacheDataRow> allKeyVersions(IgniteCache cache, Object key) throws IgniteCheckedException { IgniteCacheProxy cache0 = (IgniteCacheProxy)cache; GridCacheContext cctx = cache0.context(); KeyCacheObject key0 = cctx.toCacheKeyObject(key); GridCursor<CacheDataRow> cur = cctx.offheap().mvccAllVersionsCursor(cctx, key0, null); List<CacheDataRow> rows = new ArrayList<>(); while (cur.next()) { CacheDataRow row = cur.get(); rows.add(row); } return rows; }
/** {@inheritDoc} */ @Override public IgniteInternalFuture<V> getAsync(final K key) { A.notNull(key, "key"); final boolean statsEnabled = ctx.statisticsEnabled(); final long start = statsEnabled ? System.nanoTime() : 0L; final boolean keepBinary = ctx.keepBinary(); final K key0 = keepBinary ? (K)ctx.toCacheKeyObject(key) : key; IgniteInternalFuture<V> fut = getAsync(key, !keepBinary, false); if (ctx.config().getInterceptor() != null) fut = fut.chain(new CX1<IgniteInternalFuture<V>, V>() { @Override public V applyx(IgniteInternalFuture<V> f) throws IgniteCheckedException { K key = keepBinary ? (K)ctx.unwrapBinaryIfNeeded(key0, true, false) : key0; return (V)ctx.config().getInterceptor().onGet(key, f.get()); } }); if (statsEnabled) fut.listen(new UpdateGetTimeStatClosure<V>(metrics0(), start)); return fut; }
@Override public boolean apply() { try { GridCacheContext cctx = node.context().cache().context().cacheContext(CU.cacheId(DEFAULT_CACHE_NAME)); KeyCacheObject key = cctx.toCacheKeyObject(1); return cctx.offheap().read(cctx, key) == null; } catch (Exception e) { fail(); return false; } } }, 5000));
/** {@inheritDoc} */ @Override public void batchEvict(Collection<?> keys, @Nullable GridCacheVersion obsoleteVer) throws IgniteCheckedException { boolean recordable = cctx.events().isRecordable(EVT_CACHE_ENTRY_EVICTED); GridCacheAdapter cache = cctx.cache(); // Get all participating entries to avoid deadlock. for (Object k : keys) { KeyCacheObject cacheKey = cctx.toCacheKeyObject(k); GridCacheEntryEx entry = cache.peekEx(cacheKey); if (entry != null && entry.evictInternal(GridCacheVersionManager.EVICT_VER, null, false)) { if (plcEnabled) notifyPolicy(entry); if (recordable) cctx.events().addEvent(entry.partition(), entry.key(), cctx.nodeId(), null, null, null, EVT_CACHE_ENTRY_EVICTED, null, false, entry.rawGet(), entry.hasValue(), null, null, null, false); } } }
/** * Checks if transaction has given key enlisted. * * @param tx Transaction to check. * @param key Key to check. * @return {@code True} if key was enlisted. */ private boolean txContainsKey(Transaction tx, String key) { TransactionProxyImpl<String, Integer> proxy = (TransactionProxyImpl<String, Integer>)tx; IgniteInternalTx txEx = proxy.tx(); IgniteTxEntry entry = txEx.entry(context(0).txKey(context(0).toCacheKeyObject(key))); return entry != null; } }
@Override public void applyx() { // Check that no more entries left in the map. assertNull(g.cache(DEFAULT_CACHE_NAME).get(key)); if (!g.internalCache(DEFAULT_CACHE_NAME).context().deferredDelete()) assertNull(g.internalCache(DEFAULT_CACHE_NAME).map().getEntry(g.internalCache(DEFAULT_CACHE_NAME).context(), g.internalCache(DEFAULT_CACHE_NAME).context().toCacheKeyObject(key))); } });
/** */ private void checkAllVersionsHints(IgniteCache cache) throws IgniteCheckedException { IgniteCacheProxy cache0 = (IgniteCacheProxy)cache; GridCacheContext cctx = cache0.context(); assert cctx.mvccEnabled(); for (Object e : cache) { IgniteBiTuple entry = (IgniteBiTuple)e; KeyCacheObject key = cctx.toCacheKeyObject(entry.getKey()); GridCursor<CacheDataRow> cur = cctx.offheap().mvccAllVersionsCursor(cctx, key, CacheDataRowAdapter.RowData.LINK_WITH_HEADER); while (cur.next()) { CacheDataRow row = cur.get(); assertTrue(row.mvccTxState() != 0); } } }