@Override public long getRegionVersion() { if (this.versionTag != null) { return this.versionTag.getRegionVersion(); } return 0; }
@Override public int compare(VersionTag o1, VersionTag o2) { long result = o1.getRegionVersion() - o2.getRegionVersion(); if (result == 0) { result = o1.getVersionTimeStamp() - o2.getVersionTimeStamp(); } return Long.signum(result); }
@Override public String toString() { StringBuilder sb = new StringBuilder(50); sb.append("(").append(getKey()).append(",").append(getOldValue()); if (this.bucketId > 0) { sb.append(", b").append(this.bucketId); } if (versionTag != null) { sb.append(",v").append(versionTag.getEntryVersion()) .append(",rv=" + versionTag.getRegionVersion()); } if (filterRouting != null) { sb.append(", ").append(filterRouting); } sb.append(")"); return sb.toString(); }
private void compareVersions(Map<String, VersionTag<VersionSource<?>>> versions, InternalDistributedMember defaultID, List<InternalDistributedMember> vmIds, List<RegionVersionVector<VersionSource<?>>> versionVectors) { for (Map.Entry<String, VersionTag<VersionSource<?>>> entry : versions.entrySet()) { VersionTag<VersionSource<?>> tag = entry.getValue(); tag.replaceNullIDs(defaultID); for (int i = 0; i < vmIds.size(); i++) { assertThat(versionVectors.get(i).contains(tag.getMemberID(), tag.getRegionVersion())) .describedAs( vmIds.get(i) + " should contain " + tag) .isTrue(); } } }
public void recordRecoveredVersionTag(VersionTag tag) { this.versionVector.recordVersion(tag.getMemberID(), tag.getRegionVersion()); }
protected void compareVersionTags(HashMap<String, VersionTag> map1, HashMap<String, VersionTag> map2) { assertEquals(map1.size(), map2.size()); for (String key : map1.keySet()) { VersionTag tag1 = map1.get(key); VersionTag tag2 = map2.get(key); assertEquals(tag1.getEntryVersion(), tag2.getEntryVersion()); assertEquals(tag1.getRegionVersion(), tag2.getRegionVersion()); assertEquals(tag1.getMemberID(), tag2.getMemberID()); } }
@Override public String toString() { StringBuilder s = new StringBuilder(); if (isGatewayTag()) { s.append("{ds=").append(this.distributedSystemId).append("; time=") .append(getVersionTimeStamp()).append("}"); } else { s.append("{v").append(this.entryVersion); s.append("; rv").append(getRegionVersion()); if (this.memberID != null) { s.append("; mbr=").append(this.memberID); } if (hasPreviousMemberID()) { s.append("; prev=").append(this.previousMemberID); } if (this.distributedSystemId >= 0) { s.append("; ds=").append(this.distributedSystemId); } s.append("; time=").append(getVersionTimeStamp()); if (isFromOtherMember()) { s.append("; remote"); } if (this.isAllowedByResolver()) { s.append("; allowed"); } s.append("}"); } return s.toString(); }
@Override public void addVersionTag(Object key, VersionTag<?> tag) { this.versionTags.add(new VersionTagEntryImpl(key, tag.getMemberID(), tag.getRegionVersion())); }
/** * Records a received region-version. These are transmitted in VersionTags in messages between * peers and from servers to clients. * * @param tag the version information */ public void recordVersion(T mbr, VersionTag<T> tag) { tag.setRecorded(); assert tag.isRecorded(); T member = tag.getMemberID(); if (member == null) { member = mbr; } if (this.myId.equals(member)) { // We can be asked to record a version for the local member if a persistent // member is restarted and an event is replayed after the persistent member // recovers. So we can only assert that the local member has already seen // the replayed event. synchronized (localExceptions) { if (this.localVersion.get() < tag.getRegionVersion() && region != null && region.isInitialized() && region.getDataPolicy().withPersistence()) { Assert.fail( "recordVersion invoked for a local version tag that is higher than our local version. rvv=" + this + ", tag=" + tag + " " + region.getName()); } } } recordVersion(member, tag.getRegionVersion()); }
byte[] serializeVersionTag(VersionTag tag) throws IOException { int entryVersion = tag.getEntryVersion(); long regionVersion = tag.getRegionVersion(); VersionSource versionMember = tag.getMemberID(); long timestamp = tag.getVersionTimeStamp(); int dsId = tag.getDistributedSystemId(); return serializeVersionTag(entryVersion, regionVersion, versionMember, timestamp, dsId); }
@Override public void recordRecoveredVersionTag(VersionTag tag) { if (this.getConcurrencyChecksEnabled()) { this.versionVector.recordVersion(tag.getMemberID(), tag.getRegionVersion()); DiskRegion region = this.getDiskRegion(); // We also need to update the RVV that represents what we have persisted on disk if (region != null) { region.recordRecoveredVersionTag(tag); } } }
logger.trace(LogMarker.PERSIST_RECOVERY_VERBOSE, "clearRVV={} tag={}", clearRVV, tag); if (clearRVV.contains(tag.getMemberID(), tag.getRegionVersion())) { if (logger.isTraceEnabled(LogMarker.PERSIST_RECOVERY_VERBOSE)) { logger.trace(LogMarker.PERSIST_RECOVERY_VERBOSE,
private boolean shouldClear(LocalRegion r, RegionVersionVector rvv, AsyncDiskEntry ade) { if (ade.region != r) { return false; } // If no RVV, remove all of the async items for this region. if (rvv == null) { return true; } // If we are clearing based on an RVV, only remove // entries contained in the RVV if (ade.versionOnly) { return rvv.contains(ade.tag.getMemberID(), ade.tag.getRegionVersion()); } else { VersionStamp stamp = ade.de.getVersionStamp(); VersionSource member = stamp.getMemberID(); if (member == null) { // For overflow only regions, the version member may be null // because that represents the local internal distributed member member = r.getVersionMember(); } return rvv.contains(member, stamp.getRegionVersion()); } }
@Override public boolean requiresOneHopForMissingEntry(EntryEventImpl event) { // received from another member - don't use one-hop if (event.isOriginRemote()) { return false; } // local ops aren't distributed if (event.getOperation().isLocal()) { return false; } // if it already has a valid version tag it can go out with a DistributedCacheOperation if (event.getVersionTag() != null && event.getVersionTag().getRegionVersion() > 0) { return false; } // if we're not allowed to generate a version tag we need to send it to someone who can if (!this.generateVersionTag) { return true; } return this.getConcurrencyChecksEnabled() && (this.serverRegionProxy == null) && !isTX() && this.scope.isDistributed() && !this.getDataPolicy().withReplication(); }
public void putVersionTagOnly(InternalRegion region, VersionTag tag, boolean async) { DiskRegion dr = region.getDiskRegion(); // this method will only be called by backup oplog assert dr.isBackup(); if (!async) { acquireReadLock(dr); } try { if (dr.isRegionClosed()) { region.getCancelCriterion().checkCancelInProgress(null); throw new RegionDestroyedException( "The DiskRegion has been closed or destroyed", dr.getName()); } if (dr.getRegionVersionVector().contains(tag.getMemberID(), tag.getRegionVersion())) { // No need to write the conflicting tag to disk if the disk RVV already // contains this tag. return; } PersistentOplogSet oplogSet = getPersistentOplogSet(dr); oplogSet.getChild().saveConflictVersionTag(region, tag, async); } finally { if (!async) { releaseReadLock(dr); } } }
rvv.recordVersion(tag.getMemberID(), tag.getRegionVersion());
@Override public void makeTombstone(InternalRegion region, VersionTag version) throws RegionClearedException { assert region.getVersionVector() != null; assert version != null; if (region.getServerProxy() == null && region.getVersionVector() .isTombstoneTooOld(version.getMemberID(), version.getRegionVersion())) { // distributed gc with higher vector version preempts this operation if (!isTombstone()) { basicMakeTombstone(region); region.getCachePerfStats().incTombstoneCount(1); } ((DiskRecoveryStore) region).getRegionMap().removeTombstone(this, version, false, true); } else { if (isTombstone()) { // unschedule the old tombstone region.unscheduleTombstone(this); } setRecentlyUsed(region); boolean newEntry = getValueAsToken() == Token.REMOVED_PHASE1; basicMakeTombstone(region); region.scheduleTombstone(this, version); if (newEntry) { // bug #46631 - entry count is decremented by scheduleTombstone but this is a new entry region.getCachePerfStats().incEntryCount(1); } } }
|| stamp.getRegionVersion() != tag.getRegionVersion())) { DiskEntry.Helper.doAsyncFlush(tag, region);
entryVersion.getMemberID(), entryVersion.getRegionVersion())) {