/**
* @param nodeId Primary node ID.
* @param req Request.
* @return Remote transaction.
* @throws GridException If failed.
* @throws GridDistributedLockCancelledException If lock has been cancelled.
*/
@SuppressWarnings({"RedundantTypeArguments"})
@Nullable
public GridNearTxRemote<K, V> startRemoteTxForFinish(
UUID nodeId, GridDhtTxFinishRequest<K, V> req)
throws GridException, GridDistributedLockCancelledException {
GridNearTxRemote<K, V> tx = null;
ClassLoader ldr = ctx.deploy().globalLoader();
if (ldr != null) {
for (GridCacheTxEntry<K, V> txEntry : req.nearWrites()) {
GridDistributedCacheEntry<K, V> entry = null;
while (true) {
try {
entry = peekExx(txEntry.key());
if (entry != null) {
entry.keyBytes(txEntry.keyBytes());
// Handle implicit locks for pessimistic transactions.
tx = ctx.tm().tx(req.version());
if (tx != null) {
if (tx.local()) return null;
if (tx.markFinalizing()) tx.addWrite(txEntry.key(), txEntry.keyBytes());
else return null;
} else {
tx =
new GridNearTxRemote<K, V>(
nodeId,
req.nearNodeId(),
req.threadId(),
req.version(),
null,
PESSIMISTIC,
req.isolation(),
req.isInvalidate(),
0,
txEntry.key(),
txEntry.keyBytes(),
txEntry.value(),
txEntry.valueBytes(),
ctx);
if (tx.empty()) return tx;
tx = ctx.tm().onCreated(tx);
if (tx == null || !ctx.tm().onStarted(tx))
throw new GridCacheTxRollbackException(
"Failed to acquire lock "
+ "(transaction has been completed): "
+ req.version());
if (!tx.markFinalizing()) return null;
}
// Add remote candidate before reordering.
if (txEntry.explicitVersion() == null)
entry.addRemote(
req.nearNodeId(),
nodeId,
req.threadId(),
req.version(),
0,
tx.ec(),
/*tx*/ true,
tx.implicitSingle());
// Remote candidates for ordered lock queuing.
entry.addRemoteCandidates(
Collections.<GridCacheMvccCandidate<K>>emptyList(),
req.version(),
req.committedVersions(),
req.rolledbackVersions());
}
// Double-check in case if sender node left the grid.
if (ctx.discovery().node(req.nearNodeId()) == null) {
if (log.isDebugEnabled())
log.debug("Node requesting lock left grid (lock request will be ignored): " + req);
if (tx != null) tx.rollback();
return null;
}
// Entry is legit.
break;
} catch (GridCacheEntryRemovedException ignored) {
assert entry.obsoleteVersion() != null
: "Obsolete flag not set on removed entry: " + entry;
if (log.isDebugEnabled())
log.debug("Received entry removed exception (will retry on renewed entry): " + entry);
if (tx != null) {
tx.clearEntry(entry.key());
if (log.isDebugEnabled())
log.debug(
"Cleared removed entry from remote transaction (will retry) [entry="
+ entry
+ ", tx="
+ tx
+ ']');
}
}
}
}
} else {
String err = "Failed to acquire deployment class loader for message: " + req;
U.warn(log, err);
throw new GridException(err);
}
return tx;
}
/**
* @param nodeId Sender node ID.
* @param req Finish transaction message.
*/
@SuppressWarnings({"CatchGenericClass"})
private void processFinishRequest(UUID nodeId, GridDistributedTxFinishRequest<K, V> req) {
assert nodeId != null;
assert req != null;
GridReplicatedTxRemote<K, V> tx = ctx.tm().tx(req.version());
try {
ClassLoader ldr = ctx.deploy().globalLoader();
if (req.commit()) {
// If lock was acquired explicitly.
if (tx == null) {
// Create transaction and add entries.
tx =
ctx.tm()
.onCreated(
new GridReplicatedTxRemote<K, V>(
ldr,
nodeId,
req.threadId(),
req.version(),
req.commitVersion(),
PESSIMISTIC,
READ_COMMITTED,
req.isInvalidate(),
/*timeout */ 0,
/*read entries*/ null,
req.writes(),
ctx));
if (tx == null || !ctx.tm().onStarted(tx))
throw new GridCacheTxRollbackException(
"Attempt to start a completed " + "transaction: " + req);
} else {
boolean set = tx.commitVersion(req.commitVersion());
assert set;
}
Collection<GridCacheTxEntry<K, V>> writeEntries = req.writes();
if (!F.isEmpty(writeEntries)) {
// In OPTIMISTIC mode, we get the values at PREPARE stage.
assert tx.concurrency() == PESSIMISTIC;
for (GridCacheTxEntry<K, V> entry : writeEntries) {
// Unmarshal write entries.
entry.unmarshal(ctx, ldr);
if (log.isDebugEnabled())
log.debug(
"Unmarshalled transaction entry from pessimistic transaction [key="
+ entry.key()
+ ", value="
+ entry.value()
+ ", tx="
+ tx
+ ']');
if (!tx.setWriteValue(entry))
U.warn(
log,
"Received entry to commit that was not present in transaction [entry="
+ entry
+ ", tx="
+ tx
+ ']');
}
}
// Add completed versions.
tx.doneRemote(req.baseVersion(), req.committedVersions(), req.rolledbackVersions());
if (tx.pessimistic()) tx.prepare();
tx.commit();
} else if (tx != null) {
tx.doneRemote(req.baseVersion(), req.committedVersions(), req.rolledbackVersions());
tx.rollback();
}
if (req.replyRequired()) {
GridCacheMessage<K, V> res =
new GridDistributedTxFinishResponse<K, V>(req.version(), req.futureId());
try {
ctx.io().send(nodeId, res);
} catch (Throwable e) {
// Double-check.
if (ctx.discovery().node(nodeId) == null) {
if (log.isDebugEnabled())
log.debug(
"Node left while sending finish response [nodeId="
+ nodeId
+ ", res="
+ res
+ ']');
} else
U.error(
log,
"Failed to send finish response to node [nodeId=" + nodeId + ", res=" + res + ']',
e);
}
}
} catch (GridCacheTxRollbackException e) {
if (log.isDebugEnabled())
log.debug("Attempted to start a completed transaction (will ignore): " + e);
} catch (Throwable e) {
U.error(
log,
"Failed completing transaction [commit=" + req.commit() + ", tx=" + CU.txString(tx) + ']',
e);
if (tx != null) tx.rollback();
}
}