/** {@inheritDoc} */
@Override
public GridFuture<Map<K, V>> getAllAsync(
@Nullable Collection<? extends K> keys,
@Nullable GridPredicate<? super GridCacheEntry<K, V>>[] filter) {
ctx.denyOnFlag(LOCAL);
if (F.isEmpty(keys))
return new GridFinishedFuture<Map<K, V>>(ctx.kernalContext(), Collections.<K, V>emptyMap());
GridCacheTxLocalAdapter<K, V> tx = ctx.tm().threadLocalTx();
if (tx != null && !tx.implicit()) return ctx.wrapCloneMap(tx.getAllAsync(keys, filter));
return loadAsync(keys, false, filter);
}
/**
* @param keys Keys to load.
* @param reload Reload flag.
* @param filter Filter.
* @return Loaded values.
*/
public GridFuture<Map<K, V>> loadAsync(
@Nullable Collection<? extends K> keys,
boolean reload,
@Nullable GridPredicate<? super GridCacheEntry<K, V>>[] filter) {
if (F.isEmpty(keys))
return new GridFinishedFuture<Map<K, V>>(ctx.kernalContext(), Collections.<K, V>emptyMap());
GridNearGetFuture<K, V> fut = new GridNearGetFuture<K, V>(ctx, keys, reload, null, filter);
// Register future for responses.
ctx.mvcc().addFuture(fut);
fut.init();
return ctx.wrapCloneMap(fut);
}
/** {@inheritDoc} */
@Override
public Map<K, Collection<GridCacheMvccCandidate<K>>> localCandidates() {
return Collections.emptyMap();
}
/**
* @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;
}
/** {@inheritDoc} */
@SuppressWarnings({"unchecked"})
@Override
public Map<GridRichNode, Collection<K>> mapKeysToNodes(Collection<? extends K> keys) {
return Collections.singletonMap(ctx.localNode(), (Collection<K>) keys);
}
/** Initializes future. */
public void prepare() {
if (log.isDebugEnabled())
log.debug("Checking if transaction was committed on remote nodes: " + tx);
// Check local node first (local node can be a backup node for some part of this transaction).
long originatingThreadId = tx.threadId();
if (tx instanceof GridCacheTxRemoteEx)
originatingThreadId = ((GridCacheTxRemoteEx) tx).remoteThreadId();
GridCacheCommittedTxInfo<K, V> txInfo =
cctx.tm().txCommitted(tx.nearXidVersion(), tx.eventNodeId(), originatingThreadId);
if (txInfo != null) {
onDone(txInfo);
markInitialized();
return;
}
Collection<GridNode> checkNodes = CU.remoteNodes(cctx, tx.topologyVersion());
if (tx instanceof GridDhtTxRemote) {
// If we got primary node failure and near node has not failed.
if (tx.nodeId().equals(failedNodeId) && !tx.eventNodeId().equals(failedNodeId)) {
nearCheck = true;
GridNode nearNode = cctx.discovery().node(tx.eventNodeId());
if (nearNode == null) {
// Near node failed, separate check prepared future will take care of it.
onDone(
new GridTopologyException(
"Failed to check near transaction state (near node left grid): "
+ tx.eventNodeId()));
return;
}
checkNodes = Collections.singletonList(nearNode);
}
}
for (GridNode rmtNode : checkNodes) {
// Skip left nodes and local node.
if (rmtNode.id().equals(failedNodeId)) continue;
/*
* Send message to all cache nodes in the topology.
*/
MiniFuture fut = new MiniFuture(rmtNode.id());
GridCachePessimisticCheckCommittedTxRequest<K, V> req =
new GridCachePessimisticCheckCommittedTxRequest<>(
tx, originatingThreadId, futureId(), fut.futureId());
add(fut);
try {
cctx.io().send(rmtNode.id(), req);
} catch (GridTopologyException ignored) {
fut.onNodeLeft();
} catch (GridException e) {
fut.onError(e);
break;
}
}
markInitialized();
}