/** {@inheritDoc} */
@Override
public void finishUnmarshal(GridCacheSharedContext ctx, ClassLoader ldr)
throws IgniteCheckedException {
super.finishUnmarshal(ctx, ldr);
if (writes != null) unmarshalTx(writes, false, ctx, ldr);
if (reads != null) unmarshalTx(reads, false, ctx, ldr);
if (grpLockKeyBytes != null && grpLockKey == null)
grpLockKey = ctx.marshaller().unmarshal(grpLockKeyBytes, ldr);
if (dhtVerKeys != null && dhtVers == null) {
assert dhtVerVals != null;
assert dhtVerKeys.size() == dhtVerVals.size();
Iterator<IgniteTxKey> keyIt = dhtVerKeys.iterator();
Iterator<GridCacheVersion> verIt = dhtVerVals.iterator();
dhtVers = U.newHashMap(dhtVerKeys.size());
while (keyIt.hasNext()) {
IgniteTxKey key = keyIt.next();
key.finishUnmarshal(ctx.cacheContext(key.cacheId()), ldr);
dhtVers.put(key, verIt.next());
}
}
if (txNodesBytes != null) txNodes = ctx.marshaller().unmarshal(txNodesBytes, ldr);
}
private void recheck() {
// If this is the oldest node.
if (oldestNode.get().id().equals(cctx.localNodeId())) {
Collection<UUID> remaining = remaining();
if (!remaining.isEmpty()) {
try {
cctx.io()
.safeSend(
cctx.discovery().nodes(remaining),
new GridDhtPartitionsSingleRequest(exchId),
SYSTEM_POOL,
null);
} catch (IgniteCheckedException e) {
U.error(
log,
"Failed to request partitions from nodes [exchangeId="
+ exchId
+ ", nodes="
+ remaining
+ ']',
e);
}
}
// Resend full partition map because last attempt failed.
else {
if (spreadPartitions()) onDone(exchId.topologyVersion());
}
} else sendPartitions();
// Schedule another send.
scheduleRecheck();
}
/**
* @param cacheCtx Cache context.
* @return {@code True} if local node can calculate affinity on it's own for this partition map
* exchange.
*/
private boolean canCalculateAffinity(GridCacheContext cacheCtx) {
AffinityFunction affFunc = cacheCtx.config().getAffinity();
// Do not request affinity from remote nodes if affinity function is not centralized.
if (!U.hasAnnotation(affFunc, AffinityCentralizedFunction.class)) return true;
// If local node did not initiate exchange or local node is the only cache node in grid.
Collection<ClusterNode> affNodes = CU.affinityNodes(cacheCtx, exchId.topologyVersion());
return !exchId.nodeId().equals(cctx.localNodeId())
|| (affNodes.size() == 1 && affNodes.contains(cctx.localNode()));
}
/** Cleans up resources to avoid excessive memory usage. */
public void cleanUp() {
topSnapshot.set(null);
singleMsgs.clear();
fullMsgs.clear();
rcvdIds.clear();
oldestNode.set(null);
partReleaseFut = null;
Collection<ClusterNode> rmtNodes = this.rmtNodes;
if (rmtNodes != null) rmtNodes.clear();
}
/**
* @param key Key to add to read set.
* @param val Value.
* @param drVer Data center replication version.
* @param skipStore Skip store flag.
* @throws IgniteCheckedException If failed.
* @return {@code True} if entry has been enlisted.
*/
public boolean addEntry(
GridCacheContext cacheCtx,
IgniteTxKey key,
GridCacheOperation op,
CacheObject val,
@Nullable GridCacheVersion drVer,
boolean skipStore)
throws IgniteCheckedException {
checkInternal(key);
GridNearCacheEntry cached = cacheCtx.near().peekExx(key.key());
try {
if (cached == null) {
evicted.add(key);
return false;
} else {
cached.unswap();
CacheObject peek = cached.peek(true, false, false, null);
if (peek == null && cached.evictInternal(false, xidVer, null)) {
cached.context().cache().removeIfObsolete(key.key());
evicted.add(key);
return false;
} else {
IgniteTxEntry txEntry =
new IgniteTxEntry(cacheCtx, this, op, val, -1L, -1L, cached, drVer, skipStore);
writeMap.put(key, txEntry);
return true;
}
}
} catch (GridCacheEntryRemovedException ignore) {
evicted.add(key);
if (log.isDebugEnabled())
log.debug(
"Got removed entry when adding reads to remote transaction (will ignore): " + cached);
return false;
}
}
/** {@inheritDoc} */
@Override
public void finishUnmarshal(GridCacheSharedContext ctx, ClassLoader ldr)
throws IgniteCheckedException {
super.finishUnmarshal(ctx, ldr);
if (ownedValKeys != null && ownedVals == null) {
ownedVals = U.newHashMap(ownedValKeys.size());
assert ownedValKeys.size() == ownedValVals.size();
Iterator<IgniteTxKey> keyIter = ownedValKeys.iterator();
Iterator<CacheVersionedValue> valIter = ownedValVals.iterator();
while (keyIter.hasNext()) {
IgniteTxKey key = keyIter.next();
GridCacheContext cctx = ctx.cacheContext(key.cacheId());
CacheVersionedValue val = valIter.next();
key.finishUnmarshal(cctx, ldr);
val.finishUnmarshal(cctx, ldr);
ownedVals.put(key, val);
}
}
if (retVal != null && retVal.cacheId() != 0) {
GridCacheContext cctx = ctx.cacheContext(retVal.cacheId());
assert cctx != null : retVal.cacheId();
retVal.finishUnmarshal(cctx, ldr);
}
if (filterFailedKeys != null) {
for (IgniteTxKey key : filterFailedKeys) {
GridCacheContext cctx = ctx.cacheContext(key.cacheId());
key.finishUnmarshal(cctx, ldr);
}
}
}
/** @return {@code True} if all replies are received. */
private boolean allReceived() {
Collection<UUID> rmtIds = this.rmtIds;
assert rmtIds != null : "Remote Ids can't be null: " + this;
synchronized (rcvdIds) {
return rcvdIds.containsAll(rmtIds);
}
}
/**
* @param entry Entry to enlist.
* @throws IgniteCheckedException If failed.
* @return {@code True} if entry was enlisted.
*/
private boolean addEntry(IgniteTxEntry entry) throws IgniteCheckedException {
checkInternal(entry.txKey());
GridCacheContext cacheCtx = entry.context();
if (!cacheCtx.isNear()) cacheCtx = cacheCtx.dht().near().context();
GridNearCacheEntry cached = cacheCtx.near().peekExx(entry.key());
if (cached == null) {
evicted.add(entry.txKey());
return false;
} else {
cached.unswap();
try {
CacheObject val = cached.peek(true, false, false, null);
if (val == null && cached.evictInternal(false, xidVer, null)) {
evicted.add(entry.txKey());
return false;
} else {
// Initialize cache entry.
entry.cached(cached);
writeMap.put(entry.txKey(), entry);
addExplicit(entry);
return true;
}
} catch (GridCacheEntryRemovedException ignore) {
evicted.add(entry.txKey());
if (log.isDebugEnabled())
log.debug("Got removed entry when adding to remote transaction (will ignore): " + cached);
return false;
}
}
}
/**
* This constructor is meant for optimistic transactions.
*
* @param ldr Class loader.
* @param nodeId Node ID.
* @param nearNodeId Near node ID.
* @param rmtThreadId Remote thread ID.
* @param xidVer XID version.
* @param commitVer Commit version.
* @param sys System flag.
* @param concurrency Concurrency level (should be pessimistic).
* @param isolation Transaction isolation.
* @param invalidate Invalidate flag.
* @param timeout Timeout.
* @param writeEntries Write entries.
* @param ctx Cache registry.
* @param txSize Expected transaction size.
* @throws IgniteCheckedException If unmarshalling failed.
*/
public GridNearTxRemote(
GridCacheSharedContext ctx,
ClassLoader ldr,
UUID nodeId,
UUID nearNodeId,
long rmtThreadId,
GridCacheVersion xidVer,
GridCacheVersion commitVer,
boolean sys,
byte plc,
TransactionConcurrency concurrency,
TransactionIsolation isolation,
boolean invalidate,
long timeout,
Collection<IgniteTxEntry> writeEntries,
int txSize,
@Nullable UUID subjId,
int taskNameHash)
throws IgniteCheckedException {
super(
ctx,
nodeId,
rmtThreadId,
xidVer,
commitVer,
sys,
plc,
concurrency,
isolation,
invalidate,
timeout,
txSize,
subjId,
taskNameHash);
assert nearNodeId != null;
this.nearNodeId = nearNodeId;
readMap = Collections.emptyMap();
writeMap =
new LinkedHashMap<>(
writeEntries != null ? Math.max(txSize, writeEntries.size()) : txSize, 1.0f);
if (writeEntries != null) {
for (IgniteTxEntry entry : writeEntries) {
entry.unmarshal(ctx, true, ldr);
addEntry(entry);
}
}
}
/**
* Adds evicted key bytes to evicted collection.
*
* @param key Evicted key.
*/
public void addEvicted(IgniteTxKey key) {
evicted.add(key);
}
