private void givenExistingTombstone(boolean miss) { givenExistingEntry(); when(existingRegionEntry.isTombstone()).thenReturn(true); when(existingRegionEntry.isRemoved()).thenReturn(true); when(existingRegionEntry.isDestroyedOrRemoved()).thenReturn(true); when(existingRegionEntry.isInvalidOrRemoved()).thenReturn(true); when(existingRegionEntry.getValue()).thenReturn(Token.TOMBSTONE); }
protected HashMap<String, VersionTag> saveVersionTags(LocalRegion region) { HashMap<String, VersionTag> tagmap = new HashMap<String, VersionTag>(); Iterator entryItr = region.entrySet().iterator(); while (entryItr.hasNext()) { RegionEntry entry = ((NonTXEntry) entryItr.next()).getRegionEntry(); String key = (String) entry.getKey(); VersionTag tag = entry.getVersionStamp().asVersionTag(); tagmap.put(key, tag); } return tagmap; }
@Override protected boolean shouldCreatedEntryBeRemoved() { return getRegionEntry().getValueAsToken() == Token.REMOVED_PHASE1; }
@Override public DiskEntry getDiskEntry(Object key) { // should return tombstone as an valid entry RegionEntry regionEntry = this.entries.getEntry(key); if (regionEntry != null && regionEntry.isRemoved() && !regionEntry.isTombstone()) { regionEntry = null; } return (DiskEntry) regionEntry; }
@Override public Object getTargetObject(RegionEntry entry) { if (indexOnValues) { Object o = entry.getValue((LocalRegion) region); if (o instanceof CachedDeserializable) { return ((CachedDeserializable) o).getDeserializedValue(region, entry); } return o; } else if (indexOnRegionKeys) { return entry.getKey(); } return ((LocalRegion) region).new NonTXEntry(entry); }
@Override public Object getTargetObjectInVM(RegionEntry entry) { if (indexOnValues) { Object o = entry.getValueInVM((LocalRegion) region); if (o instanceof CachedDeserializable) { return ((CachedDeserializable) o).getDeserializedValue(region, entry); } return o; } else if (indexOnRegionKeys) { return entry.getKey(); } return ((LocalRegion) region).new NonTXEntry(entry); }
while (!done && oldRe != null) { synchronized (oldRe) { if (oldRe.isRemovedPhase2()) { owner.getCachePerfStats().incRetries(); getEntryMap().remove(key, oldRe); boolean isSameTombstone = oldRe.isTombstone() && isTombstone && oldRe.getVersionStamp().asVersionTag().equals(entryVersion); if (isSameTombstone) { return true; final boolean oldIsTombstone = oldRe.isTombstone(); final boolean oldIsDestroyedOrRemoved = oldRe.isDestroyedOrRemoved(); final int oldSize = owner.calculateRegionEntryValueSize(oldRe); if (owner.getIndexManager() != null) { if (!oldRe.isRemoved()) { owner.getIndexManager().updateIndexes(oldRe, IndexManager.REMOVE_ENTRY, IndexProtocol.BEFORE_UPDATE_OP); result = oldRe.initialImagePut(owner, lastModified, newValue, wasRecovered, acceptedVersionTag); if (result) { if (oldRe.isRemoved()) { owner.getIndexManager().updateIndexes(oldRe, IndexManager.REMOVE_ENTRY, IndexProtocol.REMOVE_DUE_TO_GII_TOMBSTONE_CLEANUP); result = newRe.initialImageInit(owner, lastModified, newValue, true, wasRecovered,
if (entry instanceof EntrySnapshot) { vt = ((EntrySnapshot) entry).getVersionTag(); key = ((EntrySnapshot) entry).getRegionEntry().getKey(); value = ((EntrySnapshot) entry).getRegionEntry().getValue(null); updateValues(values, key, value, vt); } else { VersionStamp vs = ((NonTXEntry) entry).getRegionEntry().getVersionStamp(); vt = vs == null ? null : vs.asVersionTag(); key = entry.getKey(); value = ((NonTXEntry) entry).getRegionEntry().getValueRetain(region, true); try { updateValues(values, key, value, vt);
@Test public void updateRecoveredEntry_givenExistingDestroyedOrRemovedAndSettingToTombstone_neverCallsUpdateSizeOnRemove() { RecoveredEntry recoveredEntry = mock(RecoveredEntry.class); RegionEntry regionEntry = mock(RegionEntry.class); when(regionEntry.isTombstone()).thenReturn(false).thenReturn(true); when(regionEntry.isDestroyedOrRemoved()).thenReturn(true); when(regionEntry.getVersionStamp()).thenReturn(mock(VersionStamp.class)); TestableAbstractRegionMap arm = new TestableAbstractRegionMap(false, null, null, regionEntry); arm.updateRecoveredEntry(KEY, recoveredEntry); verify(arm._getOwner(), never()).updateSizeOnRemove(any(), anyInt()); }
@Test public void initialImagePut_givenPutIfAbsentReturnsNullAndValueIsTombstone_callToScheduleTombstone() throws RegionClearedException { ConcurrentMapWithReusableEntries map = mock(ConcurrentMapWithReusableEntries.class); when(map.putIfAbsent(eq(KEY), any())).thenReturn(null); RegionEntryFactory factory = mock(RegionEntryFactory.class); VersionStamp mockVersionStamp = mock(VersionStamp.class); RegionEntry createdEntry = mock(RegionEntry.class); when(createdEntry.getVersionStamp()).thenReturn(mockVersionStamp); when(createdEntry.initialImageInit(any(), anyLong(), any(), anyBoolean(), anyBoolean(), anyBoolean())).thenReturn(true); when(factory.createEntry(any(), any(), any())).thenReturn(createdEntry); final TestableAbstractRegionMap arm = new TestableAbstractRegionMap(false, map, factory); when(arm._getOwner().getConcurrencyChecksEnabled()).thenReturn(true); when(arm._getOwner().getServerProxy()).thenReturn(mock(ServerRegionProxy.class)); VersionTag versionTag = mock(VersionTag.class); when(versionTag.getMemberID()).thenReturn(mock(VersionSource.class)); arm.initialImagePut(KEY, 0, Token.TOMBSTONE, false, false, versionTag, null, false); verify(arm._getOwner(), times(1)).scheduleTombstone(any(), any()); }
@Override public int calculateRegionEntryValueSize(RegionEntry regionEntry) { return calcMemSize(regionEntry.getValue()); // OFFHEAP _getValue ok }
private void givenExistingEntryWithValue(Object value) throws RegionClearedException { if (value == Token.TOMBSTONE) { givenExistingTombstone(); } else { when(existingRegionEntry.getValue()).thenReturn(value); } when(regionMap.getEntry(event)).thenReturn(value == null ? null : existingRegionEntry); when(regionMap.putEntryIfAbsent(eq(KEY), any())).thenReturn(existingRegionEntry); if (withConcurrencyChecks) { when(existingRegionEntry.getVersionStamp()).thenReturn(mock(VersionStamp.class)); } }
@Test public void remoteUpdateWithOnlyExistingSucceeds() throws Exception { when(internalRegion.isAllEvents()).thenReturn(true); when(internalRegion.isInitialized()).thenReturn(true); Object oldValue = new Object(); RegionEntry existingEntry = mock(RegionEntry.class); when(existingEntry.getValueInVM(any())).thenReturn(oldValue); when(focusedRegionMap.getEntry(eq(event))).thenReturn(existingEntry); when(existingEntry.prepareValueForCache(any(), eq(newValue), eq(event), eq(true))) .thenReturn(newValue); createInstance(Operation.UPDATE, false, txRmtEvent, null); RegionEntry result = instance.put(); assertThat(result).isSameAs(existingEntry); verify(existingEntry, times(1)).setValue(eq(internalRegion), eq(newValue)); }
@Test public void updateRecoveredEntry_givenExistingNonTombstoneAndSettingToTombstone_callsUpdateSizeOnRemove() { RecoveredEntry recoveredEntry = mock(RecoveredEntry.class); RegionEntry regionEntry = mock(RegionEntry.class); when(regionEntry.isTombstone()).thenReturn(false).thenReturn(true); when(regionEntry.getVersionStamp()).thenReturn(mock(VersionStamp.class)); TestableAbstractRegionMap arm = new TestableAbstractRegionMap(false, null, null, regionEntry); arm.updateRecoveredEntry(KEY, recoveredEntry); verify(arm._getOwner(), times(1)).updateSizeOnRemove(eq(KEY), anyInt()); }
@Test public void doesNotAddCallbackEvent_ifExistingRegionEntryIsTombstone() throws Exception { givenLocalRegion(); givenExistingRegionEntry(); when(existingRegionEntry.isRemoved()).thenReturn(true); when(existingRegionEntry.isTombstone()).thenReturn(true); doTxApplyDestroy(); assertThat(pendingCallbacks).isEmpty(); verify(existingRegionEntry, never()).makeTombstone(any(), any()); verify(txEntryState, never()).setVersionTag(any()); }
@Override public Object getKey() { return this.regionEntry.getKey(); } }
/** * returns a map of keys->versiontags for the test region */ private static Map<String, VersionTag<VersionSource<?>>> getCCRegionVersions() { Map<String, VersionTag<VersionSource<?>>> result = new HashMap<>(); @SuppressWarnings("unchecked") Map<String, Object> regionAsMap = (Map<String, Object>) CCRegion; for (String key : regionAsMap.keySet()) { result.put(key, CCRegion.getRegionEntry(key).getVersionStamp().asVersionTag()); } return result; }
@Before public void setup() { RegionEntryFactory regionEntryFactory = mock(RegionEntryFactory.class); when(regionEntryFactory.createEntry(any(), any(), any())).thenReturn(createdRegionEntry); when(internalRegion.getScope()).thenReturn(Scope.LOCAL); when(internalRegion.isInitialized()).thenReturn(true); when(internalRegion.getCachePerfStats()).thenReturn(mock(CachePerfStats.class)); when(internalRegion.getAttributes()).thenReturn(mock(RegionAttributes.class)); when(internalRegion.getImageState()).thenReturn(mock(ImageState.class)); when(focusedRegionMap.getEntryMap()).thenReturn(mock(Map.class)); when(focusedRegionMap.getEntryFactory()).thenReturn(regionEntryFactory); givenAnOperationThatDoesNotGuaranteeOldValue(); when(event.getKey()).thenReturn("key"); when(event.getRegion()).thenReturn(internalRegion); when(createdRegionEntry.getValueAsToken()).thenReturn(Token.REMOVED_PHASE1); when(createdRegionEntry.isRemoved()).thenReturn(true); when(createdRegionEntry.isDestroyedOrRemoved()).thenReturn(true); }
private Object getTargetObjectForUpdate(RegionEntry entry) { if (this.indexOnValues) { Object o = entry.getValueOffHeapOrDiskWithoutFaultIn((LocalRegion) getRegion()); try { if (o instanceof StoredObject) { StoredObject ohval = (StoredObject) o; try { o = ohval.getDeserializedForReading(); } finally { ohval.release(); } } else if (o instanceof CachedDeserializable) { o = ((CachedDeserializable) o).getDeserializedForReading(); } } catch (EntryDestroyedException ignored) { return Token.INVALID; } return o; } else if (this.indexOnRegionKeys) { return entry.getKey(); } return ((LocalRegion) getRegion()).new NonTXEntry(entry); }
ArrayList<PdxType> result = new ArrayList<PdxType>(); for (RegionEntry re : foundPdx.getRecoveredEntryMap().regionEntries()) { Object value = re.getValueRetain(foundPdx, true); if (Token.isRemoved(value)) { continue;