/** * @param key Entry key. * @return Entry (never {@code null}). */ public final GridCacheEntryEx entryEx(Object key) { return entryEx(ctx.toCacheKeyObject(key)); }
/** * Gets cache entry for given key and topology version. * * @param cacheCtx Cache context. * @param key Key. * @param topVer Topology version. * @return Cache entry. */ protected GridCacheEntryEx entryEx(GridCacheContext cacheCtx, IgniteTxKey key, AffinityTopologyVersion topVer) { return cacheCtx.cache().entryEx(key.key(), topVer); }
/** * @param key Entry key. * @return Entry (never {@code null}). */ public final GridCacheEntryEx entryEx(KeyCacheObject key) { return entryEx(key, ctx.affinity().affinityTopologyVersion()); }
/** * Gets cache entry for given key. * * @param cacheCtx Cache context. * @param key Key. * @return Cache entry. */ protected GridCacheEntryEx entryEx(GridCacheContext cacheCtx, IgniteTxKey key) { return cacheCtx.cache().entryEx(key.key()); }
/** * Process single key. * * @param key Key. * @param clo Closure. * @throws IgniteCheckedException If failed. */ private void processKey(KeyCacheObject key, SchemaIndexCacheVisitorClosure clo) throws IgniteCheckedException { while (true) { try { checkCancelled(); GridCacheEntryEx entry = cctx.cache().entryEx(key); try { entry.updateIndex(rowFilter, clo); } finally { entry.touch(); } break; } catch (GridDhtInvalidPartitionException ignore) { break; } catch (GridCacheEntryRemovedException ignored) { // No-op. } } }
/** * Return CacheEntry instance for lock purpose. * * @param grp Cache group * @param row Pending row. * @return CacheEntry if found or null otherwise. */ private GridCacheEntryEx getEntry(CacheGroupContext grp, PendingRow row) { try { CacheDataRowAdapter rowData = new CacheDataRowAdapter(row.link); rowData.initFromLink(grp, CacheDataRowAdapter.RowData.KEY_ONLY); GridCacheContext cctx = grp.shared().cacheContext(row.cacheId); assert cctx != null; return cctx.cache().entryEx(rowData.key()); } catch (Throwable ex) { if (Thread.currentThread().isInterrupted() || X.hasCause(ex, InterruptedException.class)) throw new IgniteException(new InterruptedException()); log.warning("Failed to move old-version pending entry " + "to per-partition PendingTree: key not found (skipping): " + "[grpId=" + grp.groupId() + ", grpName=" + grp.name() + ", pendingRow=" + row + "]"); return null; } }
/** @throws Exception If failed. */ @Test public void testReplicated() throws Exception { IgniteCache<Integer, Value> cache = createCache(false, REPLICATED); try { cache.put(1, new Value(new byte[1024])); cache.put(2, new Value(new byte[2048])); GridCacheAdapter<Integer, Value> internalCache = dht(cache); // All values are stored in PageMemory, cache entry size shouldn't depend on value size assertEquals(KEY_SIZE + NULL_REF_SIZE + ENTRY_OVERHEAD + REPLICATED_ENTRY_OVERHEAD + extrasSize(internalCache.entryEx(0)), internalCache.entryEx(0).memorySize()); assertEquals(KEY_SIZE + NULL_REF_SIZE + ENTRY_OVERHEAD + REPLICATED_ENTRY_OVERHEAD + extrasSize(internalCache.entryEx(1)), internalCache.entryEx(1).memorySize()); assertEquals(KEY_SIZE + NULL_REF_SIZE + ENTRY_OVERHEAD + REPLICATED_ENTRY_OVERHEAD + extrasSize(internalCache.entryEx(2)), internalCache.entryEx(2).memorySize()); } finally { ignite(0).destroyCache(cache.getName()); } }
@Override public void applyx(GridCacheEntryEx entry, GridCacheVersion obsoleteVer) { boolean touch = !entry.isNear(); while (true) { try { if (log.isTraceEnabled()) log.trace("Trying to remove expired entry from cache: " + entry); if (entry.onTtlExpired(obsoleteVer)) touch = false; break; } catch (GridCacheEntryRemovedException ignore) { entry = entry.context().cache().entryEx(entry.key()); touch = true; } } if (touch) entry.touch(); } };
/** @throws Exception If failed. */ @Test public void testLocal() throws Exception { MvccFeatureChecker.failIfNotSupported(MvccFeatureChecker.Feature.LOCAL_CACHE); IgniteCache<Integer, Value> cache = createCache(false, LOCAL); try { cache.put(1, new Value(new byte[1024])); cache.put(2, new Value(new byte[2048])); GridCacheAdapter<Integer, Value> internalCache = internalCache(cache); // All values are stored in PageMemory, cache entry size shouldn't depend on value size assertEquals(KEY_SIZE + NULL_REF_SIZE + ENTRY_OVERHEAD + extrasSize(internalCache.entryEx(0)), internalCache.entryEx(0).memorySize()); assertEquals(KEY_SIZE + NULL_REF_SIZE + ENTRY_OVERHEAD + extrasSize(internalCache.entryEx(1)), internalCache.entryEx(1).memorySize()); assertEquals(KEY_SIZE + NULL_REF_SIZE + ENTRY_OVERHEAD + extrasSize(internalCache.entryEx(2)), internalCache.entryEx(2).memorySize()); } finally { ignite(0).destroyCache(cache.getName()); } }
@Override public boolean applyx() { try { if (c.get(key) != null) return false; // Get "cache" field from GridCacheProxyImpl. GridCacheAdapter c0 = cacheFromCtx(c); if (!c0.context().deferredDelete()) { GridCacheEntryEx e0 = c0.entryEx(key); return e0 == null || (e0.rawGet() == null && e0.valueBytes() == null); } else return true; } catch (GridCacheEntryRemovedException e) { throw new RuntimeException(e); } } }, Math.min(ttl * 10, getTestTimeout())));
/** * @param tx Transaction. * @param txEntry Entry to unlock. */ private void txUnlock(IgniteInternalTx tx, IgniteTxEntry txEntry) { while (true) { try { GridCacheEntryEx entry = txEntry.cached(); assert entry != null; if (entry.detached()) break; entry.txUnlock(tx); break; } catch (GridCacheEntryRemovedException ignored) { if (log.isDebugEnabled()) log.debug("Got removed entry in TM txUnlock(..) method (will retry): " + txEntry); txEntry.cached(txEntry.context().cache().entryEx(txEntry.key(), tx.topologyVersion())); } } }
/** {@inheritDoc} */ @Override protected GridCacheEntryEx entryEx( GridCacheContext cacheCtx, IgniteTxKey key, AffinityTopologyVersion topVer ) { if (cacheCtx.isColocated()) { IgniteTxEntry txEntry = entry(key); if (txEntry == null) return cacheCtx.colocated().entryExx(key.key(), topVer, true); GridCacheEntryEx cached = txEntry.cached(); assert cached != null; if (cached.detached()) return cached; if (cached.obsoleteVersion() != null) { cached = cacheCtx.colocated().entryExx(key.key(), topVer, true); txEntry.cached(cached); } return cached; } else return cacheCtx.cache().entryEx(key.key(), topVer); }
/** {@inheritDoc} */ @Override protected GridCacheEntryEx entryEx(GridCacheContext cacheCtx, IgniteTxKey key) { if (cacheCtx.isColocated()) { IgniteTxEntry txEntry = entry(key); if (txEntry == null) return cacheCtx.colocated().entryExx(key.key(), topologyVersion(), true); GridCacheEntryEx cached = txEntry.cached(); assert cached != null; if (cached.detached()) return cached; if (cached.obsoleteVersion() != null) { cached = cacheCtx.colocated().entryExx(key.key(), topologyVersion(), true); txEntry.cached(cached); } return cached; } else return cacheCtx.cache().entryEx(key.key()); }
/** * JUnit. * * @throws Exception If failed. */ @Test public void testEnabled() throws Exception { storeValBytes = true; Ignite g0 = startGrid(0); Ignite g1 = startGrid(1); IgniteCache<Integer, String> c = g0.cache(DEFAULT_CACHE_NAME); c.put(1, "Cached value"); GridCacheEntryEx entry = ((IgniteKernal)g1).internalCache(DEFAULT_CACHE_NAME).entryEx(1); assert entry != null; entry.unswap(); assert entry.valueBytes() != null; } }
/** {@inheritDoc} */ @Override public IgnitePair<Long> call(Ignite ignite, IgniteCache<String, Integer> cache) throws Exception { GridCacheAdapter<?, ?> internalCache = internalCache0(cache); if (internalCache.context().isNear()) internalCache = internalCache.context().near().dht(); GridCacheEntryEx entry = internalCache.entryEx(key); entry.unswap(); if (!entry.hasValue()) { assertEquals(0, entry.ttl()); assertEquals(0, entry.expireTime()); return null; } IgnitePair<Long> pair = new IgnitePair<>(entry.ttl(), entry.expireTime()); if (!entry.isNear()) entry.context().cache().removeEntry(entry); return pair; } }
/** * @param key Key. * @param readers Whether to clear readers. */ private boolean clearLocally0(K key, boolean readers) { //TODO IGNITE-7952 MvccUtils.verifyMvccOperationSupport(ctx, "Clear"); ctx.checkSecurity(SecurityPermission.CACHE_REMOVE); if (keyCheck) validateCacheKey(key); GridCacheVersion obsoleteVer = ctx.versions().next(); ctx.shared().database().checkpointReadLock(); try { KeyCacheObject cacheKey = ctx.toCacheKeyObject(key); GridCacheEntryEx entry = ctx.isNear() ? peekEx(cacheKey) : entryEx(cacheKey); if (entry != null) return entry.clear(obsoleteVer, readers); } catch (GridDhtInvalidPartitionException ignored) { // No-op. } catch (IgniteCheckedException ex) { U.error(log, "Failed to clearLocally entry for key: " + key, ex); } finally { ctx.shared().database().checkpointReadUnlock(); } return false; }
/** {@inheritDoc} */ @Override public void run(int idx) throws Exception { GridCacheContext<String, Integer> ctx = ((IgniteKernal)ignite).<String, Integer>internalCache(cacheName).context(); int size = 0; if (ctx.isNear()) ctx = ctx.near().dht().context(); for (String key : keys) { if (ctx.affinity().keyLocalNode(key, ctx.discovery().topologyVersionEx())) { GridCacheEntryEx e = ctx.cache().entryEx(key); assert e != null : "Entry is null [idx=" + idx + ", key=" + key + ", ctx=" + ctx + ']'; assert !e.deleted() : "Entry is deleted: " + e; size++; e.touch(); } } assertEquals("Incorrect size on cache #" + idx, size, ignite.cache(ctx.name()).localSize(ALL)); } }
/** {@inheritDoc} */ @Override public void run(int idx) throws Exception { GridCacheContext<String, Integer> ctx = ((IgniteKernal)ignite).<String, Integer>internalCache(DEFAULT_CACHE_NAME).context(); int size = 0; if (ctx.isNear()) ctx = ctx.near().dht().context(); for (String key : keys) { if (ctx.affinity().keyLocalNode(key, ctx.discovery().topologyVersionEx())) { GridCacheEntryEx e = ctx.cache().entryEx(key); assert e != null : "Entry is null [idx=" + idx + ", key=" + key + ", ctx=" + ctx + ']'; assert !e.deleted() : "Entry is deleted: " + e; size++; e.touch(); } } assertEquals("Incorrect size on cache #" + idx, size, ignite.cache(ctx.name()).localSize(ALL)); } }
/** {@inheritDoc} */ @Override public IgnitePair<Long> call(Ignite ignite, IgniteCache<String, Integer> cache) throws Exception { GridCacheAdapter<?, ?> internalCache = internalCache0(cache); if (useDhtForNearCache && internalCache.context().isNear()) internalCache = internalCache.context().near().dht(); GridCacheEntryEx entry = internalCache.entryEx(key); entry.unswap(); IgnitePair<Long> pair = new IgnitePair<>(entry.ttl(), entry.expireTime()); if (!entry.isNear()) entry.context().cache().removeEntry(entry); return pair; } }
/** * @param e Entry. * @param cache Cache. * @throws Exception If failed. */ private void compareVersionWithPrimaryNode(CacheEntry<Integer, ?> e, IgniteCache<Integer, TestValue> cache) throws Exception { CacheConfiguration cfg = cache.getConfiguration(CacheConfiguration.class); if (cfg.getCacheMode() != LOCAL) { Ignite prim = primaryNode(e.getKey(), cache.getName()); GridCacheAdapter<Object, Object> cacheAdapter = ((IgniteKernal)prim).internalCache(cache.getName()); if (cfg.getNearConfiguration() != null) cacheAdapter = ((GridNearCacheAdapter)cacheAdapter).dht(); IgniteCacheObjectProcessor cacheObjects = cacheAdapter.context().cacheObjects(); CacheObjectContext cacheObjCtx = cacheAdapter.context().cacheObjectContext(); GridCacheEntryEx mapEntry = cacheAdapter.entryEx(cacheObjects.toCacheKeyObject( cacheObjCtx, cacheAdapter.context(), e.getKey(), true)); mapEntry.unswap(); assertNotNull("No entry for key: " + e.getKey(), mapEntry); assertEquals(mapEntry.version(), e.version()); } }