@Override @SuppressWarnings({"rawtypes", "unchecked"}) public Set<VersionSource> clear(RegionVersionVector rvv, BucketRegion bucketRegion) { // nothing needs to be done RegionVersionVector v = this.owner.getVersionVector(); if (v != null) { return v.getDepartedMembersSet(); } else { return Collections.emptySet(); } }
/** * Since version vectors aren't java.io.Serializable we use DataSerializer to return a serialized * form of the vector */ private static byte[] getCCRegionVersionVector() throws Exception { Object id = getMemberId(); int vm = VM.getCurrentVMNum(); logger.info( "vm" + vm + " with id " + id + " copying " + CCRegion.getVersionVector().fullToString()); RegionVersionVector vector = CCRegion.getVersionVector().getCloneForTransmission(); logger.info("clone is " + vector); HeapDataOutputStream dos = new HeapDataOutputStream(3000, Version.CURRENT); DataSerializer.writeObject(vector, dos); byte[] bytes = dos.toByteArray(); logger.info("serialized size is " + bytes.length); return bytes; }
private static boolean checkIfToUpdateAfterCreateFailed(LocalRegion rgn, EntryEventImpl ev) { // Try to create is failed due to found the entry exist, double check if should update boolean doUpdate = true; if (ev.oldValueIsDestroyedToken()) { if (rgn.getVersionVector() != null && ev.getVersionTag() != null) { rgn.getVersionVector().recordVersion( (InternalDistributedMember) ev.getDistributedMember(), ev.getVersionTag()); } doUpdate = false; } if (ev.isConcurrencyConflict()) { if (logger.isDebugEnabled()) { logger.debug("basicUpdate failed with CME, not to retry:" + ev); } doUpdate = false; } return doUpdate; }
/** * Ensure that a version tag has been recorded in the region's version vector. This makes note * that the event has been received and processed but probably didn't affect the cache's state * or it would have been recorded earlier. * * @param tag the version information * @param r the affected region */ public void checkVersionIsRecorded(VersionTag tag, LocalRegion r) { if (tag != null && !tag.isRecorded()) { // oops - someone forgot to record the event if (r != null) { RegionVersionVector v = r.getVersionVector(); if (v != null) { VersionSource mbr = tag.getMemberID(); if (mbr == null) { mbr = getSender(); } if (logger.isTraceEnabled()) { logger.trace( "recording version tag in RVV in basicProcess since it wasn't done earlier"); } v.recordVersion(mbr, tag); } } } }
@Test public void whenMakeTombstoneHasSetValueThatThrowsExceptionDoesNotChangeValueToTombstone() throws RegionClearedException { LocalRegion lr = mock(LocalRegion.class); RegionVersionVector<?> rvv = mock(RegionVersionVector.class); when(lr.getVersionVector()).thenReturn(rvv); VersionTag<?> vt = mock(VersionTag.class); Object value = "value"; AbstractRegionEntry re = new TestableRegionEntry(lr, value); assertEquals(value, re.getValueField()); Assertions.assertThatThrownBy(() -> re.makeTombstone(lr, vt)) .isInstanceOf(RuntimeException.class).hasMessage("throw exception on setValue(TOMBSTONE)"); Assert.assertEquals(Token.REMOVED_PHASE2, re.getValueField()); }
RegionVersionVector rvv = this.getVersionVector();
RegionVersionVector versionVector = ((LocalRegion) event.getRegion()).getVersionVector(); canonicalizeIDs(tag, versionVector);
@Test public void destroyOfExistingTombstoneWithConcurrencyChecksAndRemoveRecoveredEntryDoesRemove() { 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 = false; final boolean duringRI = false; final boolean removeRecoveredEntry = true; assertThat(arm.destroy(event, inTokenMode, duringRI, false, false, expectedOldValue, removeRecoveredEntry)).isTrue(); assertThat(arm.getEntryMap().containsKey(event.getKey())).isFalse(); 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 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 destroyOfExistingTombstoneWithConcurrencyChecksThrowsEntryNotFound() { 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 = false; final boolean duringRI = false; assertThatThrownBy( () -> arm.destroy(event, inTokenMode, duringRI, false, false, expectedOldValue, false)) .isInstanceOf(EntryNotFoundException.class); }
@Test public void destroyOfExistingRemovePhase2WithConcurrencyChecksAndRemoveRecoveredEntryDoesRetryAndThrowsEntryNotFound() { 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.REMOVED_PHASE2); final Object expectedOldValue = null; final boolean inTokenMode = false; final boolean duringRI = false; final boolean removeRecoveredEntry = true; assertThatThrownBy(() -> arm.destroy(event, inTokenMode, duringRI, false, false, expectedOldValue, removeRecoveredEntry)).isInstanceOf(EntryNotFoundException.class); }
void basicUpdateEntryVersion(EntryEventImpl event) throws EntryNotFoundException { if (hasSeenEvent(event)) { if (logger.isTraceEnabled(LogMarker.DM_VERBOSE)) { logger.trace(LogMarker.DM_VERBOSE, "LR.basicDestroy: this cache has already seen this event {}", event); } if (this.getConcurrencyChecksEnabled() && event.getVersionTag() != null && !event.getVersionTag().isRecorded()) { getVersionVector().recordVersion((InternalDistributedMember) event.getDistributedMember(), event.getVersionTag()); } return; } getDataView().updateEntryVersion(event); }
public void writeRVV(DiskRegion dr, LocalRegion region, Boolean isRVVTrusted) { acquireReadLock(dr); try { if (dr.isRegionClosed()) { dr.getCancelCriterion().checkCancelInProgress(null); throw new RegionDestroyedException( "The DiskRegion has been closed or destroyed", dr.getName()); } RegionVersionVector inMemoryRVV = (region == null) ? null : region.getVersionVector(); // persist the new GC RVV information for this region to the CRF PersistentOplogSet oplogSet = getPersistentOplogSet(dr); // use current dr.rvvTrust oplogSet.getChild().writeRVV(dr, inMemoryRVV, isRVVTrusted); } finally { releaseReadLock(dr); } }
/** * basicInvalidate is overridden in HARegion to abort expiry of Events which have key as Long , if * it is not able to destroy from availableIDs * * @param forceNewEntry true if we are a mirror and still in the initialization phase. Called from * InvalidateOperation.InvalidateMessage */ void basicInvalidate(final EntryEventImpl event, boolean invokeCallbacks, final boolean forceNewEntry) throws EntryNotFoundException { if (!event.isOriginRemote() && !event.isDistributed() && getScope().isDistributed() && getDataPolicy().withReplication() && invokeCallbacks) { // catches case where being called by (distributed) invalidateRegion throw new IllegalStateException( "Cannot do a local invalidate on a replicated region"); } if (hasSeenEvent(event)) { if (logger.isTraceEnabled(LogMarker.DM_VERBOSE)) { logger.trace(LogMarker.DM_VERBOSE, "LR.basicInvalidate: this cache has already seen this event {}", event); } if (this.getConcurrencyChecksEnabled() && event.getVersionTag() != null && !event.getVersionTag().isRecorded()) { getVersionVector().recordVersion((InternalDistributedMember) event.getDistributedMember(), event.getVersionTag()); } return; } discoverJTA(); getDataView().invalidateExistingEntry(event, invokeCallbacks, forceNewEntry); }
getVersionVector().recordVersion((InternalDistributedMember) event.getDistributedMember(), event.getVersionTag());
RegionVersionVector inMemoryRVV = region.getVersionVector(); RegionVersionVector diskRVV = dr.getRegionVersionVector();
@Override public void recordEvent(InternalCacheEvent event) { EventID eventID = event.getEventId(); if (ignoreEvent(event, eventID)) { return; // not tracked } LocalRegion lr = (LocalRegion) event.getRegion(); ThreadIdentifier membershipID = createThreadIDFromEvent(eventID); VersionTag tag = null; if (lr.getServerProxy() == null) { tag = event.getVersionTag(); RegionVersionVector v = ((LocalRegion) event.getRegion()).getVersionVector(); canonicalizeIDs(tag, v); } EventSequenceNumberHolder newEvh = new EventSequenceNumberHolder(eventID.getSequenceID(), tag); if (logger.isTraceEnabled()) { logger.trace("region event tracker recording {}", event); } recordSequenceNumber(membershipID, newEvh); // If this is a bulkOp, and concurrency checks are enabled, we need to // save the version tag in case we retry. // Make recordBulkOp version tag after recordSequenceNumber, so that recordBulkOpStart // in a retry bulk op would not incorrectly remove the saved version tag in // recordedBulkOpVersionTags if (lr.getConcurrencyChecksEnabled() && (event.getOperation().isPutAll() || event.getOperation().isRemoveAll()) && lr.getServerProxy() == null) { recordBulkOpEvent(event, membershipID); } }