@Override protected boolean shouldCreatedEntryBeRemoved() { return getRegionEntry().getValueAsToken() == Token.REMOVED_PHASE1; }
public static boolean checkForValidStateAfterRegisterInterest(LocalRegion region, Object key, Object serverValue) { int cacheEntryState = -1; RegionEntry re = region.entries.getEntry(key); if (re == null) { // nonexistent cacheEntryState = 0; } else { Token token = re.getValueAsToken(); if (token == Token.DESTROYED) { // destroyed cacheEntryState = 3; } else if (token == Token.INVALID) { // invalid cacheEntryState = 2; } else { // valid cacheEntryState = 1; } } // A matrix During register interest response processing // 4 nonexistent, valid , invalid,destroyed // 2 invalid, valid boolean matrix[][] = {{true, true}, {false, false}, {true, true}, {true, true}}; int registerInterstResState = 0; // invalid if (serverValue != null) { registerInterstResState = 1; // valid } return matrix[cacheEntryState][registerInterstResState]; }
public int testHookGetValuesOnDisk() { int result = 0; for (RegionEntry re : getRegionMap().regionEntries()) { if (re.getValueAsToken() == null) { result++; } } return result; }
public int testHookGetValuesInVM() { int result = 0; for (RegionEntry re : getRegionMap().regionEntries()) { if (re.getValueAsToken() == Token.NOT_A_TOKEN) { result++; } } return result; }
@Test public void createWithoutOverwriteDestroyedReturnsNullAndCallsSetOldValueDestroyedToken_ifRegionUninitializedAndCurrentValueIsTombstone() { overwriteDestroyed = false; when(internalRegion.isInitialized()).thenReturn(false); when(createdRegionEntry.getValueAsToken()).thenReturn(Token.TOMBSTONE); RegionEntry result = doPut(); assertThat(result).isNull(); verify(event, times(1)).setOldValueDestroyedToken(); }
@Test public void createWithoutOverwriteDestroyedReturnsNullAndCallsSetOldValueDestroyedToken_ifRegionUninitializedAndCurrentValueIsDestroyed() { overwriteDestroyed = false; when(internalRegion.isInitialized()).thenReturn(false); when(createdRegionEntry.getValueAsToken()).thenReturn(Token.DESTROYED); RegionEntry result = doPut(); assertThat(result).isNull(); verify(event, times(1)).setOldValueDestroyedToken(); }
@Test public void createWithOverwriteDestroyedReturnsCreatedRegionEntry_ifRegionUninitializedAndCurrentValueIsDestroyed() { overwriteDestroyed = true; when(internalRegion.isInitialized()).thenReturn(false); when(createdRegionEntry.getValueAsToken()).thenReturn(Token.DESTROYED); RegionEntry result = doPut(); assertThat(result).isSameAs(createdRegionEntry); verify(event, never()).setOldValueDestroyedToken(); }
@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 void verifyTxApplyInvalidate(TxTestableAbstractRegionMap arm, Object key, RegionEntry re, Token token) throws RegionClearedException { re.setValue(arm._getOwner(), token); arm.txApplyInvalidate(key, Token.INVALID, false, new TXId(mock(InternalDistributedMember.class), 1), mock(TXRmtEvent.class), false, mock(EventID.class), null, new ArrayList<EntryEventImpl>(), null, null, null, null, 1); assertEquals(re.getValueAsToken(), token); }
@Test public void destroyWithEmptyRegionInTokenModeAddsAToken() { final TestableAbstractRegionMap arm = new TestableAbstractRegionMap(); final EntryEventImpl event = createEventForDestroy(arm._getOwner()); final Object expectedOldValue = null; final boolean inTokenMode = true; final boolean duringRI = false; assertThat(arm.destroy(event, inTokenMode, duringRI, false, false, expectedOldValue, false)) .isTrue(); assertThat(arm.getEntryMap().containsKey(event.getKey())).isTrue(); RegionEntry re = (RegionEntry) arm.getEntryMap().get(event.getKey()); assertThat(re.getValueAsToken()).isEqualTo(Token.DESTROYED); boolean invokeCallbacks = true; verify(arm._getOwner(), times(1)).basicDestroyPart2(any(), eq(event), eq(inTokenMode), eq(false), eq(duringRI), eq(invokeCallbacks)); verify(arm._getOwner(), times(1)).basicDestroyPart3(any(), eq(event), eq(inTokenMode), eq(duringRI), eq(invokeCallbacks), eq(expectedOldValue)); }
private boolean checkUninitializedRegionPreconditions() { if (!getOwner().isInitialized()) { if (!isOverwriteDestroyed()) { Token oldValueInVM = getRegionEntry().getValueAsToken(); if (oldValueInVM == Token.DESTROYED || oldValueInVM == Token.TOMBSTONE) { getEvent().setOldValueDestroyedToken(); return false; } } } return true; }
@Test public void destroyOfExistingEntryInTokenModeAddsAToken() { final TestableAbstractRegionMap arm = new TestableAbstractRegionMap(); addEntry(arm); final EntryEventImpl event = createEventForDestroy(arm._getOwner()); final Object expectedOldValue = null; final boolean inTokenMode = true; final boolean duringRI = false; assertThat(arm.destroy(event, inTokenMode, duringRI, false, false, expectedOldValue, false)) .isTrue(); assertThat(arm.getEntryMap().containsKey(event.getKey())).isTrue(); RegionEntry re = (RegionEntry) arm.getEntryMap().get(event.getKey()); assertThat(re.getValueAsToken()).isEqualTo(Token.DESTROYED); boolean invokeCallbacks = true; verify(arm._getOwner(), times(1)).basicDestroyPart2(any(), eq(event), eq(inTokenMode), eq(false), eq(duringRI), eq(invokeCallbacks)); verify(arm._getOwner(), times(1)).basicDestroyPart3(any(), eq(event), eq(inTokenMode), eq(duringRI), eq(invokeCallbacks), eq(expectedOldValue)); }
@Test public void evictDestroyWithExistingTombstoneInTokenModeChangesToDestroyToken() { final TestableVMLRURegionMap arm = new TestableVMLRURegionMap(true); addEntry(arm, Token.TOMBSTONE); final EntryEventImpl event = createEventForDestroy(arm._getOwner()); final Object expectedOldValue = null; final boolean inTokenMode = true; final boolean duringRI = false; final boolean evict = true; assertThat(arm.destroy(event, inTokenMode, duringRI, false, evict, expectedOldValue, false)) .isTrue(); assertThat(arm.getEntryMap().containsKey(event.getKey())).isTrue(); RegionEntry re = (RegionEntry) arm.getEntryMap().get(event.getKey()); assertThat(re.getValueAsToken()).isEqualTo(Token.DESTROYED); boolean invokeCallbacks = true; verify(arm._getOwner(), times(1)).basicDestroyPart2(any(), eq(event), eq(inTokenMode), eq(false), eq(duringRI), eq(invokeCallbacks)); verify(arm._getOwner(), times(1)).basicDestroyPart3(any(), eq(event), eq(inTokenMode), eq(duringRI), eq(invokeCallbacks), eq(expectedOldValue)); }
@Test public void destroyWithEmptyRegionWithConcurrencyChecksAndNullVersionTagAddsATombstone() { final TestableAbstractRegionMap arm = new TestableAbstractRegionMap(true); final EntryEventImpl event = createEventForDestroy(arm._getOwner()); event.setOriginRemote(true); final Object expectedOldValue = null; final boolean inTokenMode = false; final boolean duringRI = false; assertThat(arm.destroy(event, inTokenMode, duringRI, false, false, expectedOldValue, false)) .isTrue(); assertThat(arm.getEntryMap().containsKey(event.getKey())).isTrue(); boolean invokeCallbacks = true; verify(arm._getOwner(), times(1)).basicDestroyPart2(any(), eq(event), eq(inTokenMode), eq(false), eq(duringRI), eq(invokeCallbacks)); verify(arm._getOwner(), times(1)).basicDestroyPart3(any(), eq(event), eq(inTokenMode), eq(duringRI), eq(invokeCallbacks), eq(expectedOldValue)); // instead of a TOMBSTONE we leave an entry whose value is REMOVE_PHASE1 // this looks like a bug. It is caused by some code in: AbstractRegionEntry.destroy() // that calls removePhase1 when the versionTag is null. // It seems like this code path needs to tell the higher levels // to call removeEntry RegionEntry re = (RegionEntry) arm.getEntryMap().get(event.getKey()); assertThat(re.getValueAsToken()).isEqualTo(Token.REMOVED_PHASE1); }
@Test public void destroyWithEmptyRegionWithConcurrencyChecksAddsATombstone() { final TestableAbstractRegionMap arm = new TestableAbstractRegionMap(true); RegionVersionVector versionVector = mock(RegionVersionVector.class); when(arm._getOwner().getVersionVector()).thenReturn(versionVector); final EntryEventImpl event = createEventForDestroy(arm._getOwner()); VersionTag versionTag = mock(VersionTag.class); when(versionTag.hasValidVersion()).thenReturn(true); event.setVersionTag(versionTag); event.setOriginRemote(true); final Object expectedOldValue = null; final boolean inTokenMode = false; final boolean duringRI = false; assertThat(arm.destroy(event, inTokenMode, duringRI, false, false, expectedOldValue, false)) .isTrue(); assertThat(arm.getEntryMap().containsKey(event.getKey())).isTrue(); RegionEntry re = (RegionEntry) arm.getEntryMap().get(event.getKey()); assertThat(re.getValueAsToken()).isEqualTo(Token.TOMBSTONE); boolean invokeCallbacks = true; verify(arm._getOwner(), times(1)).basicDestroyPart2(any(), eq(event), eq(inTokenMode), eq(false), eq(duringRI), eq(invokeCallbacks)); verify(arm._getOwner(), times(1)).basicDestroyPart3(any(), eq(event), eq(inTokenMode), eq(duringRI), eq(invokeCallbacks), eq(expectedOldValue)); }
@Test public void destroyOfExistingEntryWithConcurrencyChecksAddsTombstone() { final TestableAbstractRegionMap arm = new TestableAbstractRegionMap(true); RegionVersionVector versionVector = mock(RegionVersionVector.class); when(arm._getOwner().getVersionVector()).thenReturn(versionVector); addEntry(arm); final EntryEventImpl event = createEventForDestroy(arm._getOwner()); VersionTag versionTag = mock(VersionTag.class); when(versionTag.hasValidVersion()).thenReturn(true); event.setVersionTag(versionTag); final Object expectedOldValue = null; final boolean inTokenMode = false; final boolean duringRI = false; assertThat(arm.destroy(event, inTokenMode, duringRI, false, false, expectedOldValue, false)) .isTrue(); assertThat(arm.getEntryMap().containsKey(event.getKey())).isTrue(); RegionEntry re = (RegionEntry) arm.getEntryMap().get(event.getKey()); assertThat(re.getValueAsToken()).isEqualTo(Token.TOMBSTONE); boolean invokeCallbacks = true; verify(arm._getOwner(), times(1)).basicDestroyPart2(any(), eq(event), eq(inTokenMode), eq(false), eq(duringRI), eq(invokeCallbacks)); verify(arm._getOwner(), times(1)).basicDestroyPart3(any(), eq(event), eq(inTokenMode), eq(duringRI), eq(invokeCallbacks), eq(expectedOldValue)); }
@Test public void evictDestroyOfExistingEntryWithConcurrencyChecksAddsTombstone() { final TestableVMLRURegionMap arm = new TestableVMLRURegionMap(true); RegionVersionVector<?> versionVector = mock(RegionVersionVector.class); when(arm._getOwner().getVersionVector()).thenReturn(versionVector); addEntry(arm); final EntryEventImpl event = createEventForDestroy(arm._getOwner()); VersionTag<?> versionTag = mock(VersionTag.class); when(versionTag.hasValidVersion()).thenReturn(true); event.setVersionTag(versionTag); final Object expectedOldValue = null; final boolean inTokenMode = false; final boolean duringRI = false; final boolean evict = true; assertThat(arm.destroy(event, inTokenMode, duringRI, false, evict, expectedOldValue, false)) .isTrue(); assertThat(arm.getEntryMap().containsKey(event.getKey())).isTrue(); RegionEntry re = (RegionEntry) arm.getEntryMap().get(event.getKey()); assertThat(re.getValueAsToken()).isEqualTo(Token.TOMBSTONE); boolean invokeCallbacks = true; verify(arm._getOwner(), times(1)).basicDestroyPart2(any(), eq(event), eq(inTokenMode), eq(false), eq(duringRI), eq(invokeCallbacks)); verify(arm._getOwner(), times(1)).basicDestroyPart3(any(), eq(event), eq(inTokenMode), eq(duringRI), eq(invokeCallbacks), eq(expectedOldValue)); }
@Test public void destroyOfExistingTombstoneInTokenModeWithConcurrencyChecksDoesNothing() { final TestableAbstractRegionMap arm = new TestableAbstractRegionMap(true); RegionVersionVector<?> versionVector = mock(RegionVersionVector.class); when(arm._getOwner().getVersionVector()).thenReturn(versionVector); final EntryEventImpl event = createEventForDestroy(arm._getOwner()); VersionTag<?> versionTag = mock(VersionTag.class); when(versionTag.hasValidVersion()).thenReturn(true); event.setVersionTag(versionTag); addEntry(arm, Token.TOMBSTONE); final Object expectedOldValue = null; final boolean inTokenMode = true; final boolean duringRI = false; assertThat(arm.destroy(event, inTokenMode, duringRI, false, false, expectedOldValue, false)) .isTrue(); assertThat(arm.getEntryMap().containsKey(event.getKey())).isTrue(); RegionEntry re = (RegionEntry) arm.getEntryMap().get(event.getKey()); // why not DESTROY token? assertThat(re.getValueAsToken()).isEqualTo(Token.TOMBSTONE); // since it was already destroyed why do we do the parts? boolean invokeCallbacks = true; verify(arm._getOwner(), times(1)).basicDestroyPart2(any(), eq(event), eq(inTokenMode), eq(false), eq(duringRI), eq(invokeCallbacks)); verify(arm._getOwner(), times(1)).basicDestroyPart3(any(), eq(event), eq(inTokenMode), eq(duringRI), eq(invokeCallbacks), eq(expectedOldValue)); }
@Test public void evictDestroyWithEmptyRegionWithConcurrencyChecksDoesNothing() { final TestableVMLRURegionMap arm = new TestableVMLRURegionMap(true); EntryEventImpl event = createEventForDestroy(arm._getOwner()); assertThat(arm.destroy(event, false, false, false, true, null, false)).isFalse(); verify(arm._getOwner(), never()).basicDestroyPart2(any(), any(), anyBoolean(), anyBoolean(), anyBoolean(), anyBoolean()); verify(arm._getOwner(), never()).basicDestroyPart3(any(), any(), anyBoolean(), anyBoolean(), anyBoolean(), any()); // This seems to be a bug. We should not leave an entry in the map // added by the destroy call if destroy returns false. assertThat(arm.getEntryMap().containsKey(event.getKey())).isTrue(); RegionEntry re = (RegionEntry) arm.getEntryMap().get(event.getKey()); assertThat(re.getValueAsToken()).isEqualTo(Token.REMOVED_PHASE1); }
@Override public void lruEntryDestroy(RegionEntry regionEntry) { final EvictableEntry e = (EvictableEntry) regionEntry; if (logger.isTraceEnabled(LogMarker.LRU_VERBOSE)) { logger.trace(LogMarker.LRU_VERBOSE, "lruEntryDestroy for key={}; list size is: {}; actual size is: {}; map size is: {}; entry size: {}; in lru clock: {}", regionEntry.getKey(), getTotalEntrySize(), this.getEvictionList().size(), size(), e.getEntrySize(), !e.isEvicted()); } getEvictionList().destroyEntry(e); changeTotalEntrySize(-1 * e.getEntrySize());// subtract the size. Token vTok = regionEntry.getValueAsToken(); if (vTok == Token.DESTROYED || vTok == Token.TOMBSTONE) { // OFFHEAP noop TODO: use re.isDestroyedOrTombstone // if in token mode we need to recalculate the size of the entry since it's // staying in the map and may be resurrected e.updateEntrySize(getEvictionController()); } }