@Override
public final CacheEntry wrapEntryForReading(InvocationContext ctx, Object key)
throws InterruptedException {
CacheEntry cacheEntry = getFromContext(ctx, key);
if (cacheEntry == null) {
cacheEntry = getFromContainer(key);
// do not bother wrapping though if this is not in a tx. repeatable read etc are all
// meaningless unless there is a tx.
if (useRepeatableRead) {
MVCCEntry mvccEntry =
cacheEntry == null
? createWrappedEntry(key, null, null, false, false, -1)
: createWrappedEntry(
key,
cacheEntry.getValue(),
cacheEntry.getVersion(),
false,
false,
cacheEntry.getLifespan());
if (mvccEntry != null) ctx.putLookedUpEntry(key, mvccEntry);
return mvccEntry;
} else if (cacheEntry
!= null) { // if not in transaction and repeatable read, or simply read committed
// (regardless of whether in TX or not), do not wrap
ctx.putLookedUpEntry(key, cacheEntry);
}
return cacheEntry;
}
return cacheEntry;
}
public static String printCache(Cache cache) {
DataContainer dataContainer = TestingUtil.extractComponent(cache, DataContainer.class);
Iterator it = dataContainer.iterator();
StringBuilder builder = new StringBuilder(cache.getName() + "[");
while (it.hasNext()) {
CacheEntry ce = (CacheEntry) it.next();
builder.append(ce.getKey() + "=" + ce.getValue() + ",l=" + ce.getLifespan() + "; ");
}
builder.append("]");
return builder.toString();
}
private MVCCEntry wrapMvccEntryForRemove(
InvocationContext ctx, Object key, CacheEntry cacheEntry) {
MVCCEntry mvccEntry =
createWrappedEntry(
key,
cacheEntry.getValue(),
cacheEntry.getVersion(),
false,
true,
cacheEntry.getLifespan());
ctx.putLookedUpEntry(key, mvccEntry);
return mvccEntry;
}
public void transformForL1(CacheEntry entry) {
if (entry.getLifespan() < 0 || entry.getLifespan() > configuration.getL1Lifespan())
entry.setLifespan(configuration.getL1Lifespan());
}
@Override
protected void commitSingleEntry(
CacheEntry entry,
Metadata metadata,
FlagAffectedCommand command,
InvocationContext ctx,
Flag trackFlag,
boolean l1Invalidation) {
// Don't allow the CH to change (and state transfer to invalidate entries)
// between the ownership check and the commit
stateTransferLock.acquireSharedTopologyLock();
try {
boolean doCommit = true;
// ignore locality for removals, even if skipOwnershipCheck is not true
boolean skipOwnershipCheck = command != null && command.hasFlag(Flag.SKIP_OWNERSHIP_CHECK);
boolean isForeignOwned = !skipOwnershipCheck && !localNodeIsOwner(entry.getKey());
if (isForeignOwned && !entry.isRemoved()) {
if (configuration.clustering().l1().enabled()) {
// transform for L1
long lifespan;
if (metadata != null) {
lifespan = metadata.lifespan();
} else {
lifespan = entry.getLifespan();
}
if (lifespan < 0 || lifespan > configuration.clustering().l1().lifespan()) {
Metadata.Builder builder;
if (metadata != null) {
builder = metadata.builder();
} else {
builder = entry.getMetadata().builder();
}
metadata = builder.lifespan(configuration.clustering().l1().lifespan()).build();
}
} else {
doCommit = false;
}
}
boolean created = false;
boolean removed = false;
boolean expired = false;
if (!isForeignOwned) {
created = entry.isCreated();
removed = entry.isRemoved();
if (removed && entry instanceof MVCCEntry) {
expired = ((MVCCEntry) entry).isExpired();
}
}
if (doCommit) {
InternalCacheEntry previousEntry = dataContainer.peek(entry.getKey());
Object previousValue = null;
Metadata previousMetadata = null;
if (previousEntry != null) {
previousValue = previousEntry.getValue();
previousMetadata = previousEntry.getMetadata();
}
commitManager.commit(entry, metadata, trackFlag, l1Invalidation);
if (!isForeignOwned) {
notifyCommitEntry(
created, removed, expired, entry, ctx, command, previousValue, previousMetadata);
}
} else entry.rollback();
} finally {
stateTransferLock.releaseSharedTopologyLock();
}
}