public VersionTag getVersionTag() { VersionStamp stamp = regionEntry.getVersionStamp(); if (stamp != null) { return stamp.asVersionTag(); } return null; }
byte[] serializeVersionTag(VersionStamp stamp) throws IOException { int entryVersion = stamp.getEntryVersion(); long regionVersion = stamp.getRegionVersion(); VersionSource versionMember = stamp.getMemberID(); long timestamp = stamp.getVersionTimeStamp(); int dsId = stamp.getDistributedSystemId(); return serializeVersionTag(entryVersion, regionVersion, versionMember, timestamp, dsId); }
private void processVersionTagForGII(RegionEntry re, LocalRegion owner, VersionTag entryVersion, boolean isTombstone, InternalDistributedMember sender, boolean checkConflicts) { re.getVersionStamp().processVersionTag(_getOwner(), entryVersion, isTombstone, false, owner.getMyId(), sender, checkConflicts); }
public boolean hasValidVersion() { VersionStamp stamp = (VersionStamp) this; return stamp.getRegionVersion() != 0 || stamp.getEntryVersion() != 0; }
protected StringBuilder appendFieldsToString(final StringBuilder sb) { // OFFHEAP _getValue ok: the current toString on ObjectChunk is safe to use without incing // refcount. sb.append("key=").append(getKey()).append("; rawValue=").append(getValue()); VersionStamp stamp = getVersionStamp(); if (stamp != null) { sb.append("; version=").append(stamp.asVersionTag()).append(";member=") .append(stamp.getMemberID()); } return sb; }
synchronized (mapEntry) { // bug #46042 must sync to make sure the tag goes with VersionSource<?> id = stamp.getMemberID(); if (id == null) { id = myId; if (versionVector.contains(id, stamp.getRegionVersion())) { continue; entry.setVersionTag(stamp.asVersionTag()); fillRes = mapEntry.fillInValue(rgn, entry, in, rgn.getDistributionManager(), sender.getVersionObject());
private void copyRecoveredEntry(RegionEntry oldRe, RegionEntry newRe) { if (newRe.getVersionStamp() != null) { newRe.getVersionStamp().setMemberID(oldRe.getVersionStamp().getMemberID()); newRe.getVersionStamp().setVersions(oldRe.getVersionStamp().asVersionTag()); } if (newRe instanceof AbstractOplogDiskRegionEntry) { ((AbstractOplogDiskRegionEntry) newRe).setDiskId(oldRe); _getOwner().getDiskRegion().replaceIncompatibleEntry((DiskEntry) oldRe, (DiskEntry) newRe); } getEntryMap().put(newRe.getKey(), newRe); }
@Test public void initialImagePut_givenPutIfAbsentReturningRegionEntryAndProcessVersionTagThrowsConcurrentCacheModificationException_createdEntryRemovedFromMapAndNotInitialImageInit() throws RegionClearedException { ConcurrentMapWithReusableEntries map = mock(ConcurrentMapWithReusableEntries.class); RegionEntry entry = mock(RegionEntry.class); when(entry.isTombstone()).thenReturn(false); when(entry.isDestroyedOrRemoved()).thenReturn(false); when(entry.initialImagePut(any(), anyLong(), any(), anyBoolean(), anyBoolean())) .thenReturn(true); VersionStamp versionStamp = mock(VersionStamp.class); when(entry.getVersionStamp()).thenReturn(versionStamp); when(versionStamp.asVersionTag()).thenReturn(mock(VersionTag.class)); doThrow(new ConcurrentCacheModificationException()).when(versionStamp).processVersionTag(any(), any(), anyBoolean(), anyBoolean(), any(), any(), anyBoolean()); RegionEntry createdEntry = mock(RegionEntry.class); when(createdEntry.getVersionStamp()).thenReturn(versionStamp); RegionEntryFactory factory = mock(RegionEntryFactory.class); when(factory.createEntry(any(), any(), any())).thenReturn(createdEntry); TestableAbstractRegionMap arm = new TestableAbstractRegionMap(false, map, factory); when(map.putIfAbsent(eq(KEY), any())).thenReturn(entry); 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(map, times(1)).remove(eq(KEY), eq(createdEntry)); verify(entry, never()).initialImagePut(any(), anyLong(), any(), anyBoolean(), anyBoolean()); }
VersionTag stampTag = stamp.asVersionTag(); if (stampTag.hasValidVersion() && checkForConflict) { .append(stamp.asVersionTag()).append(", tag=").append(tag) .append(", checkForConflict=").append(checkForConflict); if (!tag.isGatewayTag() && stamp.getDistributedSystemId() == tag.getDistributedSystemId() && tag.getVersionTimeStamp() > stamp.getVersionTimeStamp()) { stamp.setVersionTimeStamp(tag.getVersionTimeStamp()); tag.setTimeStampApplied(true); if (verbose != null) {
synchronized (newRe) { if (value.getVersionTag() != null && newRe.getVersionStamp() != null) { newRe.getVersionStamp().setVersions(value.getVersionTag()); if (newRe.isTombstone()) { _getOwner().scheduleTombstone(newRe, newRe.getVersionStamp().asVersionTag()); } else { _getOwner().updateSizeOnCreate(key, _getOwner().calculateRegionEntryValueSize(newRe));
int stampDsId = stamp.getDistributedSystemId(); int tagDsId = tag.getDistributedSystemId(); verbose = new StringBuilder(); verbose.append("processing tag for key ").append(getKey()).append(", stamp=") .append(stamp.asVersionTag()).append(", tag=").append(tag); long stampTime = stamp.getVersionTimeStamp(); long tagTime = tag.getVersionTimeStamp(); if (stampTime > 0 && (tagTime > stampTime || (tagTime == stampTime && tag.getDistributedSystemId() >= stamp.getDistributedSystemId()))) { if (verbose != null) { verbose.append(" - allowing event");
if (stamp != null && region.getServerProxy() == null) { int v = stamp.getEntryVersion() + 1; if (v > 0xFFFFFF) { v -= 0x1000000; // roll-over VersionSource previous = stamp.getMemberID(); if (time <= stamp.getVersionTimeStamp() && dsid != tag.getDistributedSystemId()) { time = stamp.getVersionTimeStamp() + 1; stamp.setVersions(tag); stamp.setMemberID(member); event.setVersionTag(tag); if (logger.isDebugEnabled()) {
RegionEntry mapEntry = it.next(); VersionStamp<?> stamp = mapEntry.getVersionStamp(); VersionSource<?> id = stamp.getMemberID(); if (id == null) { id = myId; rvv.recordVersion(id, stamp.getRegionVersion());
isPresent = true; VersionStamp stamp = entry.getVersionStamp(); if (stamp != null && stamp.hasValidVersion()) { tag = stamp.asVersionTag();
InternalDistributedMember sender, StringBuilder verbose) { int stampVersion = stamp.getEntryVersion(); int tagVersion = tag.getEntryVersion(); if (stamp.getVersionTimeStamp() != 0) { // new entries have no timestamp } else if (stampVersion > tagVersion) { if (overwritingOldTombstone(region, stamp, tag, verbose) && tag.getVersionTimeStamp() > stamp.getVersionTimeStamp()) { apply = true; } else { && tag.getVersionTimeStamp() > stamp.getVersionTimeStamp()) { } else { VersionSource stampID = stamp.getMemberID(); if (stampID == null) { stampID = dmId;
@Override public void run() { assertThat(CCRegion.get(loadKey)).isEqualTo("loadedValue"); assertThat((CCRegion.getRegionEntry(loadKey)).getVersionStamp().getEntryVersion()) .isEqualTo( (long) 3); } });
private void applyVersionTag(InternalRegion region, VersionStamp stamp, VersionTag tag, InternalDistributedMember sender) { VersionSource mbr = tag.getMemberID(); if (mbr == null) { mbr = sender; } mbr = region.getVersionVector().getCanonicalId(mbr); tag.setMemberID(mbr); stamp.setVersions(tag); if (tag.hasPreviousMemberID()) { if (tag.getPreviousMemberID() == null) { tag.setPreviousMemberID(stamp.getMemberID()); } else { tag.setPreviousMemberID( region.getVersionVector().getCanonicalId(tag.getPreviousMemberID())); } } }
long stampTime = getVersionStamp().getVersionTimeStamp(); long tagTime = tag.getVersionTimeStamp(); int stampDsid = getVersionStamp().getDistributedSystemId(); int tagDsid = tag.getDistributedSystemId(); if (isDebugEnabled) {
VersionSource stampID = stamp.getMemberID(); if (stampID == null) { stampID = dmId;
private boolean overwritingOldTombstone(InternalRegion region, VersionStamp stamp, VersionTag tag, StringBuilder verbose) { // Tombstone GC does not use locking to stop operations when old tombstones // are being removed. Because of this we might get an operation that was applied // in another VM that has just reaped a tombstone and is now using a reset // entry version number. Because of this we check the timestamp on the current // local entry and see if it is old enough to have expired. If this is the case // we accept the change and allow the tag to be recorded long stampTime = stamp.getVersionTimeStamp(); if (isExpiredTombstone(region, stampTime, this.isTombstone())) { // no local change since the tombstone would have timed out - accept the change if (verbose != null) { verbose.append(" - accepting because local timestamp is old"); } return true; } else { return false; } }