/** * Checks if the entry is a valid entry * * @return true if entry not null or entry is not removed */ protected boolean checkEntryNotValid(RegionEntry mapEntry) { return mapEntry == null || mapEntry.isRemoved() && !mapEntry.isTombstone(); }
@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 DiskEntry getDiskEntry(Object key) { RegionEntry re = getRecoveredEntryMap().getEntry(key); if (re != null && re.isRemoved() && !re.isTombstone()) { re = null; } return (DiskEntry) re; }
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); }
@Test public void putThatUpdatesTombstoneCallsUnscheduleTombstone() { when(internalRegion.isInitialized()).thenReturn(true); when(internalRegion.getConcurrencyChecksEnabled()).thenReturn(true); RegionEntry existingEntry = mock(RegionEntry.class); when(existingEntry.isTombstone()).thenReturn(true); when(focusedRegionMap.getEntry(eq(event))).thenReturn(existingEntry); createInstance(Operation.UPDATE, false, txRmtEvent, null); RegionEntry result = instance.put(); assertThat(result).isNotNull(); verify(internalRegion, times(1)).unscheduleTombstone(eq(existingEntry)); }
@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()); }
@Test public void txApplyDestroy_givenExistingNonTombstone_callsUpdateSizeOnRemove() { RegionEntry regionEntry = mock(RegionEntry.class); when(regionEntry.isTombstone()).thenReturn(false); when(regionEntry.getVersionStamp()).thenReturn(mock(VersionStamp.class)); TXId txId = mock(TXId.class); when(txId.getMemberId()).thenReturn(mock(InternalDistributedMember.class)); TestableAbstractRegionMap arm = new TestableAbstractRegionMap(false, null, null, regionEntry); arm.txApplyDestroy(KEY, txId, null, false, false, null, null, null, new ArrayList<>(), null, null, false, null, null, 0); verify(arm._getOwner(), times(1)).updateSizeOnRemove(eq(KEY), anyInt()); }
@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 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 updateRecoveredEntry_givenExistingRemovedNonTombstone_neverCallsUpdateSizeOnRemove() { RecoveredEntry recoveredEntry = mock(RecoveredEntry.class); RegionEntry regionEntry = mock(RegionEntry.class); when(regionEntry.isRemoved()).thenReturn(true); when(regionEntry.isTombstone()).thenReturn(false); TestableAbstractRegionMap arm = new TestableAbstractRegionMap(false, null, null, regionEntry); arm.updateRecoveredEntry(KEY, recoveredEntry); verify(arm._getOwner(), never()).updateSizeOnRemove(any(), anyInt()); }
@Test public void txApplyDestroyCallUpdateSizeOnRemoveWithOldSize_givenOldRegionEntryThatIsNotTombstone() { givenLocalRegion(); givenConcurrencyChecks(); givenOldRegionEntry(); int oldSize = 79; when(owner.calculateRegionEntryValueSize(oldRegionEntry)).thenReturn(oldSize); when(oldRegionEntry.isTombstone()).thenReturn(false); doTxApplyDestroy(); verify(owner, times(1)).updateSizeOnRemove(eq(key), eq(oldSize)); }
@Test public void putReturnsNull_ifOnlyExistingAndEntryIsTombstone() { ifOld = true; givenExistingRegionEntry(); when(existingRegionEntry.isTombstone()).thenReturn(true); RegionEntry result = doPut(); assertThat(result).isNull(); }
@Test public void putReturnsExistingEntry_ifOnlyExistingAndEntryIsNotTombstone() { ifOld = true; givenExistingRegionEntry(); when(existingRegionEntry.isTombstone()).thenReturn(false); RegionEntry result = doPut(); assertThat(result).isSameAs(existingRegionEntry); }
@Test public void txApplyDestroyInvokesRescheduleTombstone_givenExistingRegionEntryThatIsTombstone() { givenLocalRegion(); givenExistingRegionEntry(); when(existingRegionEntry.isRemoved()).thenReturn(true); when(existingRegionEntry.isTombstone()).thenReturn(true); doTxApplyDestroy(); verify(owner, times(1)).rescheduleTombstone(same(existingRegionEntry), any()); }
@Test public void txApplyDestroyCallUpdateSizeOnRemoveWithZero_givenOldRegionEntryThatIsTombstone() { givenLocalRegion(); givenConcurrencyChecks(); givenOldRegionEntry(); when(oldRegionEntry.isTombstone()).thenReturn(true); doTxApplyDestroy(); verify(owner, times(1)).updateSizeOnRemove(eq(key), eq(0)); }
@Test public void putReturnsExistingEntry_ifReplaceOnClientAndTombstoneButNoVersionTag() { ifOld = true; givenReplaceOnClient(); givenExistingRegionEntry(); when(existingRegionEntry.isTombstone()).thenReturn(true); when(event.getVersionTag()).thenReturn(null); RegionEntry result = doPut(); assertThat(result).isSameAs(existingRegionEntry); }
@Test public void txApplyDestroyCallsUnscheduleTombstone_givenOldRegionEntryThatIsTombstone() { givenLocalRegion(); givenConcurrencyChecks(); givenOldRegionEntry(); when(oldRegionEntry.isTombstone()).thenReturn(true); doTxApplyDestroy(); verify(owner, times(1)).unscheduleTombstone(same(oldRegionEntry)); }
private void setNewValueOnRegionEntry(final Object newValue) throws RegionClearedException { final RegionEntry regionEntry = getRegionEntry(); final InternalRegion owner = getOwner(); final boolean wasTombstone = regionEntry.isTombstone(); final Object preparedValue = regionEntry.prepareValueForCache(owner, newValue, getEvent(), !isPutOpCreate()); regionEntry.setValue(owner, preparedValue); if (wasTombstone) { owner.unscheduleTombstone(regionEntry); } }
private void updateEntry() throws RegionClearedException { final EntryEventImpl event = getEvent(); final RegionEntry re = getRegionEntry(); final boolean wasTombstone = re.isTombstone(); final int oldSize = event.getRegion().calculateRegionEntryValueSize(re); getRegionMap().processVersionTag(re, event); event.putExistingEntry(event.getRegion(), re, isRequireOldValue(), getOldValueForDelta()); EntryLogger.logPut(event); updateSize(oldSize, true/* isUpdate */, wasTombstone); }
private void createEntry() throws RegionClearedException { final EntryEventImpl event = getEvent(); final RegionEntry re = getRegionEntry(); final boolean wasTombstone = re.isTombstone(); getRegionMap().processVersionTag(re, event); event.putNewEntry(getOwner(), re); updateSize(0, false, wasTombstone); if (!event.getRegion().isInitialized()) { getOwner().getImageState().removeDestroyedEntry(event.getKey()); } }