/** * 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(); }
private void givenExistingEntryWithTokenAndVersionTag(Token token) { if (token == Token.REMOVED_PHASE2) { when(regionMap.getEntry(event)).thenReturn(existingRegionEntry).thenReturn(null); when(regionMap.putEntryIfAbsent(KEY, newRegionEntry)).thenReturn(null); when(existingRegionEntry.isRemovedPhase2()).thenReturn(true); when(existingRegionEntry.isRemoved()).thenReturn(true); when(existingRegionEntry.isDestroyedOrRemoved()).thenReturn(true); when(existingRegionEntry.isInvalidOrRemoved()).thenReturn(true); when(existingRegionEntry.isDestroyedOrRemovedButNotTombstone()).thenReturn(true); } else { throw new IllegalArgumentException("unexpected token: " + token); } givenEventWithVersionTag(); }
@Override public boolean containsKey(Object key) { RegionEntry re = getEntry(key); if (re == null) { return false; } if (re.isRemoved()) { return false; } return true; }
/** return null if not found */ @Override public RegionEntry basicGetEntry(Object key) { // ok to ignore tx state; all callers are non-transactional RegionEntry regionEntry = this.entries.getEntry(key); if (regionEntry != null && regionEntry.isRemoved()) { regionEntry = null; } return regionEntry; }
@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 checkEntryDestroyed() { this.region.getCancelCriterion().checkCancelInProgress(null); if (this.regionEntry.isRemoved()) { throw new EntryDestroyedException(this.regionEntry.getKey().toString()); } } }
private void givenNotDestroyedOrRemoved() { when(existingRegionEntry.isRemoved()).thenReturn(false); when(existingRegionEntry.isDestroyedOrRemoved()).thenReturn(false); }
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 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 txApplyDestroyHasNoPendingCallback_givenExistingRegionEntryThatIsRemoved() { givenLocalRegion(); givenExistingRegionEntry(); when(existingRegionEntry.isRemoved()).thenReturn(true); doTxApplyDestroy(); assertThat(pendingCallbacks).isEmpty(); }
@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); }
@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 txApplyDestroyInvokesRescheduleTombstone_givenExistingRegionEntryThatIsTombstone() { givenLocalRegion(); givenExistingRegionEntry(); when(existingRegionEntry.isRemoved()).thenReturn(true); when(existingRegionEntry.isTombstone()).thenReturn(true); doTxApplyDestroy(); verify(owner, times(1)).rescheduleTombstone(same(existingRegionEntry), any()); }
@Override public void writeSyncIfPresent(Object key, Runnable runner) { RegionEntry re = getEntry(key); if (re != null) { final boolean disabled = disableLruUpdateCallback(); try { synchronized (re) { if (!re.isRemoved()) { runner.run(); } } } finally { if (disabled) { enableLruUpdateCallback(); } try { lruUpdateCallback(); } catch (DiskAccessException dae) { this._getOwner().handleDiskAccessException(dae); throw dae; } } } }
@Test public void putReturnsNull_ifOnlyExistingAndEntryIsRemoved() { ifOld = true; givenExistingRegionEntry(); when(existingRegionEntry.isRemoved()).thenReturn(true); givenReplaceOnPeer(); RegionEntry result = doPut(); assertThat(result).isNull(); }
@Test public void putReturnsExistingEntry_ifOnlyExistingEntryIsRemovedAndReplaceOnClient() { ifOld = true; givenExistingRegionEntry(); when(existingRegionEntry.isRemoved()).thenReturn(true); givenReplaceOnClient(); RegionEntry result = doPut(); assertThat(result).isSameAs(existingRegionEntry); }
private boolean isUpdate() { if (isCacheWrite() && getEvent().getOperation().isUpdate()) { // if there is a cacheWriter, type of event has already been set return true; } if (isReplaceOnClient()) { return true; } if (!getRegionEntry().isRemoved()) { return true; } return false; }
/** * 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. */ public NonLocalRegionEntry(RegionEntry re, InternalRegion br, boolean allowTombstones) { this.key = re.getKey(); if (allowTombstones && re.isTombstone()) { // client get() operations need to see tombstone values 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(); } }
@Override protected RegionEntry basicGetTXEntry(KeyInfo keyInfo) { int bucketId = keyInfo.getBucketId(); if (bucketId == KeyInfo.UNKNOWN_BUCKET) { bucketId = PartitionedRegionHelper.getHashKey(this, null, keyInfo.getKey(), keyInfo.getValue(), keyInfo.getCallbackArg()); keyInfo.setBucketId(bucketId); } if (keyInfo.isCheckPrimary()) { DistributedMember primary = getRegionAdvisor().getPrimaryMemberForBucket(bucketId); if (!primary.equals(getMyId())) { throw new PrimaryBucketException( "Bucket " + bucketId + " is not primary. Current primary holder is " + primary); } } BucketRegion br = this.dataStore.getLocalBucketById(bucketId); RegionEntry re = br.basicGetEntry(keyInfo.getKey()); if (re != null && re.isRemoved()) { re = null; } return re; }