@Override public boolean apply() { return internalCache.peekEx(key) == null; } }, 5000);
/** {@inheritDoc} */ @Override public void apply(StringBuilder sb, GridKernalContext ctx) { sb.append(U.nl()); GridCacheContext cctx = ctx.cache().context().cacheContext(cacheId); if (cctx == null) { sb.append("Failed to find cache with id: ").append(cacheId); return; } try { for (KeyCacheObject key : keys) key.finishUnmarshal(cctx.cacheObjectContext(), null); } catch (IgniteCheckedException e) { ctx.cluster().diagnosticLog().error("Failed to unmarshal key: " + e, e); sb.append("Failed to unmarshal key: ").append(e).append(U.nl()); } sb.append("Cache entries [cacheId=").append(cacheId) .append(", cacheName=").append(cctx.name()).append("]: "); for (KeyCacheObject key : keys) { GridCacheMapEntry e = (GridCacheMapEntry)cctx.cache().peekEx(key); sb.append(U.nl()).append(" Key [key=").append(key).append(", entry=").append(e).append("]"); } }
@Override public IgniteInternalFuture<Map<K, V>> apply(Map<K, V> map, Exception e) { if (e != null) { clearReservationsIfNeeded(topVer, loadKeys, loaded, tx0); return new GridFinishedFuture<>(e); } if (tx0 == null || (!tx0.implicit() && tx0.isolation() == READ_COMMITTED)) { Collection<KeyCacheObject> notFound = new HashSet<>(loadKeys.keySet()); notFound.removeAll(loaded); // Touch entries that were not found in store. for (KeyCacheObject key : notFound) { GridCacheEntryEx entry = peekEx(key); if (entry != null) entry.touch(); } } // There were no misses. return new GridFinishedFuture<>(Collections.<K, V>emptyMap()); } },
/** * Evicts an entry from cache. * * @param key Key. * @param ver Version. * @param filter Filter. * @return {@code True} if entry was evicted. */ private boolean evictx(K key, GridCacheVersion ver, @Nullable CacheEntryPredicate[] filter) { KeyCacheObject cacheKey = ctx.toCacheKeyObject(key); GridCacheEntryEx entry = peekEx(cacheKey); if (entry == null) return true; try { return ctx.evicts().evict(entry, ver, true, filter); } catch (IgniteCheckedException ex) { U.error(log, "Failed to evict entry from cache: " + entry, ex); return false; } }
/** * */ void recheck() { for (Iterator<IgniteTxKey> it = pendingLocks.keySet().iterator(); it.hasNext(); ) { IgniteTxKey key = it.next(); GridCacheContext cacheCtx = cctx.cacheContext(key.cacheId()); GridCacheEntryEx entry = cacheCtx.cache().peekEx(key.key()); if (entry == null) it.remove(); else recheck(entry); } if (log.isDebugEnabled()) log.debug("After rechecking finished future: " + this); if (pendingLocks.isEmpty()) { if (exchLog.isDebugEnabled()) exchLog.debug("Finish lock future is done: " + this); onDone(); } }
/** {@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. } } }
/** * @param keys Keys. * @param readers Readers flag. */ public void clearLocally(Collection<KeyCacheObject> keys, boolean readers) { if (F.isEmpty(keys)) return; //TODO IGNITE-7952 MvccUtils.verifyMvccOperationSupport(ctx, "Clear"); GridCacheVersion obsoleteVer = ctx.versions().next(); for (KeyCacheObject key : keys) { GridCacheEntryEx e = peekEx(key); try { if (e != null) e.clear(obsoleteVer, readers); } catch (IgniteCheckedException ex) { U.error(log, "Failed to clearLocally entry (will continue to clearLocally other entries): " + e, ex); } } }
@Override public void run(int idx) throws Exception { for (int i = 0; i < cnt; i++) { String key = String.valueOf(i); GridCacheContext<String, Integer> ctx = ((IgniteKernal)ignite).<String, Integer>internalCache(cacheName).context(); GridCacheEntryEx entry = ctx.isNear() ? ctx.near().dht().peekEx(key) : ctx.cache().peekEx(key); if (ignite.affinity(cacheName).mapKeyToPrimaryAndBackups(key).contains(((IgniteKernal)ignite).localNode())) { assertNotNull(entry); assertTrue(entry.deleted()); } else assertNull(entry); } } }
/** {@inheritDoc} */ @Override public void run(int idx) throws Exception { for (int i = 0; i < cnt; i++) { String key = String.valueOf(i); GridCacheContext<String, Integer> ctx = ((IgniteKernal)ignite).<String, Integer>internalCache(DEFAULT_CACHE_NAME).context(); GridCacheEntryEx entry = ctx.isNear() ? ctx.near().dht().peekEx(key) : ctx.cache().peekEx(key); if (ignite.affinity(DEFAULT_CACHE_NAME).mapKeyToPrimaryAndBackups(key).contains(((IgniteKernal)ignite).localNode())) { assertNotNull(entry); assertTrue(entry.deleted()); } else assertNull(entry); } } }
@Override public boolean applyx() { try { Integer val = c.get(key); if (val != null) { info("Value is in cache [key=" + key + ", val=" + val + ']'); return false; } // Get "cache" field from GridCacheProxyImpl. GridCacheAdapter c0 = cacheFromCtx(c); if (!c0.context().deferredDelete()) { GridCacheEntryEx e0 = c0.peekEx(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())));
@Override public boolean applyx() { try { Integer val = c.get(key); if (val != null) { info("Value is in cache [key=" + key + ", val=" + val + ']'); return false; } // Get "cache" field from GridCacheProxyImpl. GridCacheAdapter c0 = cacheFromCtx(c); if (!c0.context().deferredDelete()) { GridCacheEntryEx e0 = c0.peekEx(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())));
private void checkEmpty(final GridCacheAdapter internalCache, final Object key) throws Exception { if (internalCache.isNear()) { checkEmpty(((GridNearCacheAdapter)internalCache).dht(), key); return; } GridTestUtils.waitForCondition(new PA() { @Override public boolean apply() { return internalCache.peekEx(key) == null; } }, 5000); assertNull(internalCache.peekEx(key)); } }
/** {@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); } } }
/** * @param nodeId Node ID. * @param res Response. */ final void onDhtResponse(UUID nodeId, GridDhtAtomicUpdateResponse res) { if (!F.isEmpty(res.nearEvicted())) { for (KeyCacheObject key : res.nearEvicted()) { try { GridDhtCacheEntry entry = (GridDhtCacheEntry)cctx.cache().peekEx(key); if (entry != null) entry.removeReader(nodeId, res.messageId()); } catch (GridCacheEntryRemovedException e) { if (log.isDebugEnabled()) log.debug("Entry with evicted reader was removed [key=" + key + ", err=" + e + ']'); } } } registerResponse(nodeId); }
@Override public boolean applyx() throws IgniteCheckedException { try { Integer val = c.get(key); if (val != null) { info("Value is in cache [key=" + key + ", val=" + val + ']'); return false; } if (!internalCache(c).context().deferredDelete()) { GridCacheEntryEx e0 = internalCache(c).peekEx(key); return e0 == null || (e0.rawGet() == null && e0.valueBytes() == null); } else return true; } catch (GridCacheEntryRemovedException ignored) { // If e0.valueBytes() thrown this exception then entry has been removed. return true; } } }, Math.min(ttl * 10, getTestTimeout())));
/** {@inheritDoc} */ @Override protected void checkThreadChain(GridCacheMvccCandidate owner) { assert !lockedByCurrentThread(); assert owner != null; assert owner.owner() || owner.used() : "Neither owner or used flags are set on ready local candidate: " + owner; if (owner.next() != null) { for (GridCacheMvccCandidate cand = owner.next(); cand != null; cand = cand.next()) { assert cand.local(); // Allow next lock in the thread to proceed. if (!cand.used()) { GridCacheContext cctx0 = cand.parent().context(); GridLocalCacheEntry e = (GridLocalCacheEntry)cctx0.cache().peekEx(cand.parent().key()); // At this point candidate may have been removed and entry destroyed, // so we check for null. if (e != null) e.recheck(); break; } } } }
/** {@inheritDoc} */ @Override protected final void checkThreadChain(GridCacheMvccCandidate owner) { assert !lockedByCurrentThread(); assert owner != null; assert owner.owner() || owner.used() : "Neither owner or used flags are set on ready local candidate: " + owner; if (owner.local() && owner.next() != null) { for (GridCacheMvccCandidate cand = owner.next(); cand != null; cand = cand.next()) { assert cand.local() : "Remote candidate cannot be part of thread chain: " + cand; // Allow next lock in the thread to proceed. if (!cand.used()) { GridCacheContext cctx0 = cand.parent().context(); GridDistributedCacheEntry e = (GridDistributedCacheEntry)cctx0.cache().peekEx(cand.parent().key()); if (e != null) e.recheck(); break; } } } }
/** * @throws Exception If failed. */ @Test public void testUnlockPrimaryLeft() throws Exception { GridCacheAdapter<Integer, Integer> cache = ((IgniteKernal)grid(0)).internalCache(DEFAULT_CACHE_NAME); Integer key = backupKey(grid(0).cache(DEFAULT_CACHE_NAME)); cache.lock(key, 0); stopGrid(1); cache.unlock(key); GridCacheEntryEx entry = cache.peekEx(key); assertTrue("Remote MVCC is not empty: " + entry, entry == null || entry.remoteMvccSnapshot().isEmpty()); startGrid(1); } }
/** * @param cacheName Cache to check. * @param vals Key-value pairs. * @throws Exception If failed. */ private void checkEntries(String cacheName, Object... vals) throws Exception { for (int g = 0; g < NODES_CNT; g++) { IgniteKernal kernal = (IgniteKernal)grid(g); GridCacheAdapter<Object, Object> cache = kernal.context().cache().internalCache(cacheName); for (int i = 0; i < vals.length; i += 2) { Object key = vals[i]; Object val = vals[i + 1]; GridCacheEntryEx entry = cache.peekEx(key); if (entry != null) { assertFalse("Entry is locked [g=" + g + ", cacheName=" + cacheName + ", entry=" + entry + ']', entry.lockedByAny()); assertEquals("Invalid entry value [g=" + g + ", cacheName=" + cacheName + ", entry=" + entry + ']', val, entry.rawGet().value(cache.context().cacheObjectContext(), false)); } } } } }
/** * @param tx Transaction. */ private void removeObsolete(IgniteInternalTx tx) { Collection<IgniteTxEntry> entries = tx.local() ? tx.allEntries() : tx.writeEntries(); for (IgniteTxEntry entry : entries) { GridCacheEntryEx cached = entry.cached(); GridCacheContext cacheCtx = entry.context(); if (cached == null) cached = cacheCtx.cache().peekEx(entry.key()); if (cached.detached()) continue; try { if (cached.obsolete() || cached.markObsoleteIfEmpty(tx.xidVersion())) cacheCtx.cache().removeEntry(cached); if (!tx.near() && isNearEnabled(cacheCtx)) { GridNearCacheAdapter near = cacheCtx.isNear() ? cacheCtx.near() : cacheCtx.dht().near(); GridNearCacheEntry e = near.peekExx(entry.key()); if (e != null && e.markObsoleteIfEmpty(null)) near.removeEntry(e); } } catch (IgniteCheckedException e) { U.error(log, "Failed to remove obsolete entry from cache: " + cached, e); } } }