private Object _getKey(RegionEntry re) { if (this.key instanceof RegionEntry) { this.key = re.getKeyCopy(); } return this.key; }
private static String getGraphName(String ownerName, Object key) { if (key instanceof RegionEntry) { key = ((RegionEntry)key).getKeyCopy(); } return ownerName + ":" + key; }
private void enqueueOldEntry(RegionEntry oldRe, Map<Object, BlockingQueue<RegionEntry>> snapshot) { BlockingQueue<RegionEntry> oldEntryqueue = snapshot.get(oldRe.getKeyCopy()); if (oldEntryqueue == null) { oldEntryqueue = new LinkedBlockingDeque<RegionEntry>(); oldEntryqueue.add(oldRe); snapshot.put(oldRe.getKeyCopy(), oldEntryqueue); } else { oldEntryqueue.add(oldRe); } }
@Override public String toString() { String v = super.toString(); StringBuilder sb = new StringBuilder(); sb.append("(").append(entry.getKeyCopy()).append("; ") .append(region.getName()).append("; ").append(v) .append(")"); return sb.toString(); } }
public final boolean execute(final Object obj) { if (obj instanceof RegionEntry) { keys.add(((RegionEntry)obj).getKeyCopy()); } else { keys.add(obj); } return true; } });
private void checkEntryDestroyed() { this.region.getCancelCriterion().checkCancelInProgress(null); if (this.regionEntry.isRemoved()) { throw new EntryDestroyedException(this.regionEntry.getKeyCopy() .toString()); } } }
@Override public SelectResults getKeys() { if(keys == null){ keys = new ResultsSet(); keys.setElementType(keyType); } keys.clear(); keys.add(entry.getKeyCopy()); return keys; }
public void rescheduleTombstone(RegionEntry entry, VersionTag version) { LogWriterI18n log = getLogWriterI18n(); if (log.fineEnabled() || TombstoneService.VERBOSE || TombstoneService.DEBUG_TOMBSTONE_COUNT) { log.info(LocalizedStrings.DEBUG, "rescheduling tombstone in " + getName() + " for " + entry.getKeyCopy()); } Object sync = TombstoneService.DEBUG_TOMBSTONE_COUNT? TombstoneService.debugSync : new Object(); synchronized(sync) { unscheduleTombstone(entry, false); // count is off by one, so don't allow validation to take place scheduleTombstone(entry, version); } }
/** * To get the value from region in serialized form * @return {@link VMCachedDeserializable} */ public Object getRawValue() { if (this.regionVal != null) { return this.regionVal; } Object value = this.basicGetEntry().getValue((LocalRegion) getRegion()); if (value == null) { throw new EntryDestroyedException(this.getRegionEntry().getKeyCopy() .toString()); } else if(Token.isInvalid(value)) { return null; } return value; }
public boolean isTombstoneNotNeeded(RegionEntry re, int destroyedVersion) { // no need for synchronization - stale values are okay here // GFXD can return RegionEntry itself in getKey() call that fails when sent // to HDFS due to serialization attempt (#49887) RegionEntry actualRe = getEntry( getEntryNeedKeyCopy() ? re.getKeyCopy() : re.getKey()); // TODO this looks like a problem for regionEntry pooling if (actualRe != re) { // null actualRe is okay here return true; // tombstone was evicted at some point } int entryVersion = re.getVersionStamp().getEntryVersion(); boolean isSameTombstone = (entryVersion == destroyedVersion && re.isTombstone()); return !isSameTombstone; }
@Override public Compensation generateUndo(Transaction xact, LimitObjectInput in) throws StandardException, IOException { // need to refresh the value since the underlying RegionEntry in the region // may have changed (causes #43889) final RegionEntry entry; if (this.row != null && (entry = this.row.getRegionEntry()).isDestroyedOrRemoved()) { this.row = Hash1IndexScanController.fetchRowLocation( entry.getKeyCopy(), this.memcontainer.getBaseContainer().getRegion()); } SortedMap2IndexInsertOperation undoOp = new SortedMap2IndexInsertOperation( this.memcontainer, this.key, this.row, this.isUnique); return undoOp; }
@Override public Compensation generateUndo(Transaction xact, LimitObjectInput in) throws StandardException, IOException { // need to refresh the value since the underlying RegionEntry in the region // may have changed (causes #43889) final RegionEntry entry; if (this.row != null && (entry = this.row.getRegionEntry()).isDestroyedOrRemoved()) { this.row = Hash1IndexScanController.fetchRowLocation( entry.getKeyCopy(), this.memcontainer.getBaseContainer().getRegion()); } SortedMap2IndexInsertOperation undoOp = new SortedMap2IndexInsertOperation( this.memcontainer, this.key, this.row, this.isUnique); return undoOp; }
@Override public Compensation generateUndo(Transaction xact, LimitObjectInput in) throws StandardException, IOException { // need to refresh the value since the underlying RegionEntry in the region // may have changed (causes #43889) final RegionEntry entry; if (this.row != null && (entry = this.row.getRegionEntry()).isDestroyedOrRemoved()) { this.row = Hash1IndexScanController.fetchRowLocation( entry.getKeyCopy(), this.memcontainer.getBaseContainer().getRegion()); } SortedMap2IndexInsertOperation undoOp = new SortedMap2IndexInsertOperation( this.memcontainer, this.key, this.row, this.isUnique); return undoOp; }
/** * Create one of these in the local case so that we have a snapshot of the * state and can allow the bucket to move out from under us. */ protected NonLocalRegionEntry(RegionEntry re, LocalRegion br, boolean allowTombstones) { this.key = re.getKeyCopy(); // client get() operations need to see tombstone values if (allowTombstones && re.isTombstone()) { this.value = Token.TOMBSTONE; } else { this.value = re.getValue(br); // OFFHEAP: copy into heap cd } Assert.assertTrue(this.value != Token.NOT_AVAILABLE, "getEntry did not fault value in from disk"); this.lastModified = re.getLastModified(); this.isRemoved = re.isRemoved(); VersionStamp<?> stamp = re.getVersionStamp(); if (stamp != null) { this.versionTag = stamp.asVersionTag(); } }
static boolean delete(GemFireTransaction tran, TXStateInterface tx, GemFireContainer container, RegionEntry entry, int bucketId) throws StandardException { boolean deleted = true; try { if (entry == null || entry.isDestroyedOrRemoved()) { return false; } final Object regionKey = entry.getKeyCopy(); Object routingObject = GemFireXDUtils.getRoutingObject(bucketId); if (routingObject == null && container.isPartitioned()) { routingObject = GemFireXDUtils.getRoutingObjectFromGlobalIndex(regionKey, entry, container.getRegion()); } container.delete(regionKey, routingObject, false, tran, tx, GemFireTransaction.getLanguageConnectionContext(tran), false); } catch (EntryNotFoundException enfe) { // Can occur. Eat it. deleted = false; } catch (EntryDestroyedException ede) { // Can occur in getRoutingObjectFromGlobalIndex. Eat it. deleted = false; } return deleted; }
@Override protected boolean localInvalidate() throws EntryNotFoundException { RegionEntry re = getCheckedRegionEntry(); Object key = re.getKeyCopy(); LocalRegion lr = getLocalRegion(); EntryEventImpl event = EntryEventImpl.create(lr, Operation.EXPIRE_LOCAL_INVALIDATE, key, null, createExpireEntryCallback(lr, key), false, lr.getMyId()); try { if (lr.generateEventID()) { event.setNewEventId(lr.getCache().getDistributedSystem()); } lr.expireInvalidate(event); } finally { event.release(); } return true; }
@Override protected boolean invalidate() throws TimeoutException, EntryNotFoundException { RegionEntry re = getCheckedRegionEntry(); Object key = re.getKeyCopy(); LocalRegion lr = getLocalRegion(); EntryEventImpl event = EntryEventImpl.create(lr, Operation.EXPIRE_INVALIDATE, key, null, createExpireEntryCallback(lr, key), false, lr.getMyId()); try { if (lr.generateEventID()) { event.setNewEventId(lr.getCache().getDistributedSystem()); } lr.expireInvalidate(event); } finally { event.release(); } return true; }
@Override protected boolean localDestroy() throws CacheException { RegionEntry re = getCheckedRegionEntry(); Object key = re.getKeyCopy(); LocalRegion lr = getLocalRegion(); EntryEventImpl event = EntryEventImpl.create(lr, Operation.EXPIRE_LOCAL_DESTROY, key, null, createExpireEntryCallback(lr, key), false, lr.getMyId()); try { if (lr.generateEventID()) { event.setNewEventId(lr.getCache().getDistributedSystem()); } lr.expireDestroy(event, false); // expectedOldValue } finally { event.release(); } return true; }
@Override protected boolean destroy(boolean isPending) throws CacheException { RegionEntry re = getCheckedRegionEntry(); Object key = re.getKeyCopy(); LocalRegion lr = getLocalRegion(); EntryEventImpl event = EntryEventImpl.create( lr, Operation.EXPIRE_DESTROY, key, null, createExpireEntryCallback(lr, key), false, lr.getMyId()); event.setPendingSecondaryExpireDestroy(isPending); try { if (lr.generateEventID()) { event.setNewEventId(lr.getCache().getDistributedSystem()); } lr.expireDestroy(event, true); // expectedOldValue return true; } finally { event.release(); } }
@Override protected final void lruEntryCreate(RegionEntry re) { LRUEntry e = (LRUEntry)re; // Assert.assertFalse(e._getValue() instanceof DiskEntry.RecoveredEntry) if ( debug ) { debugLogging( "lruEntryCreate for key=" + re.getKeyCopy() + "; list size is: " + getTotalEntrySize() + "; actual size is: " + this._getLruList().getExpensiveListCount() + "; map size is: " + sizeInVM() + "; entry size: " + e.getEntrySize() + "; in lru clock: " + !e.testEvicted()); } // this.lruCreatedKey = re.getKey(); // [ bruce ] for DEBUGGING only e.unsetEvicted(); NewLRUClockHand lruList = _getLruList(); DiskRegion disk = _getOwner().getDiskRegion(); boolean possibleClear = disk != null && disk.didClearCountChange(); if(!possibleClear || this._getOwner().basicGetEntry(re.getKey()) == re ) { lruList.appendEntry(e); lruEntryUpdate(e); } }