/**
* Log task mapped.
*
* @param log Logger.
* @param clazz Task class.
* @param nodes Mapped nodes.
*/
public static void logMapped(
@Nullable IgniteLogger log, Class<?> clazz, Collection<ClusterNode> nodes) {
log0(
log,
U.currentTimeMillis(),
String.format("[%s]: MAPPED: %s", clazz.getSimpleName(), U.toShortString(nodes)));
}
/** {@inheritDoc} */
@SuppressWarnings({"unchecked", "ThrowableInstanceNeverThrown"})
@Override
protected GridFuture<Boolean> lockAllAsync(
Collection<? extends K> keys,
long timeout,
GridCacheTxLocalEx<K, V> tx,
boolean isInvalidate,
boolean isRead,
boolean retval,
GridCacheTxIsolation isolation,
GridPredicate<? super GridCacheEntry<K, V>>[] filter) {
if (keys.isEmpty()) return new GridFinishedFuture<Boolean>(ctx.kernalContext(), true);
Collection<GridRichNode> nodes = ctx.remoteNodes(keys);
final GridReplicatedLockFuture<K, V> fut =
new GridReplicatedLockFuture<K, V>(ctx, keys, tx, this, nodes, timeout, filter);
GridDistributedLockRequest<K, V> req =
new GridDistributedLockRequest<K, V>(
locNodeId,
Thread.currentThread().getId(),
fut.futureId(),
fut.version(),
tx != null,
isRead,
isolation,
isInvalidate,
timeout,
keys.size());
try {
// Must add future before redying locks.
if (!ctx.mvcc().addFuture(fut))
throw new IllegalStateException("Duplicate future ID: " + fut);
boolean distribute = false;
for (K key : keys) {
while (true) {
GridDistributedCacheEntry<K, V> entry = null;
try {
entry = entryexx(key);
if (!ctx.isAll(entry.wrap(false), filter)) {
if (log.isDebugEnabled())
log.debug("Entry being locked did not pass filter (will not lock): " + entry);
fut.onDone(false);
return fut;
}
// Removed exception may be thrown here.
GridCacheMvccCandidate<K> cand = fut.addEntry(entry);
if (cand != null) {
req.addKeyBytes(
key,
cand.reentry() ? null : entry.getOrMarshalKeyBytes(),
retval,
entry.localCandidates(fut.version()),
ctx);
req.completedVersions(
ctx.tm().committedVersions(fut.version()),
ctx.tm().rolledbackVersions(fut.version()));
distribute = !cand.reentry();
} else if (fut.isDone()) return fut;
break;
} catch (GridCacheEntryRemovedException ignored) {
if (log.isDebugEnabled())
log.debug("Got removed entry in lockAsync(..) method (will retry): " + entry);
}
}
}
// If nothing to distribute at this point,
// then all locks are reentries.
if (!distribute) fut.complete(true);
if (nodes.isEmpty()) fut.readyLocks();
// No reason to send request if all locks are locally re-entered,
// or if timeout is negative and local locks could not be acquired.
if (fut.isDone()) return fut;
try {
ctx.io()
.safeSend(
fut.nodes(),
req,
new P1<GridNode>() {
@Override
public boolean apply(GridNode node) {
fut.onNodeLeft(node.id());
return !fut.isDone();
}
});
} catch (GridException e) {
U.error(
log,
"Failed to send lock request to node [nodes="
+ U.toShortString(nodes)
+ ", req="
+ req
+ ']',
e);
fut.onError(e);
}
return fut;
} catch (GridException e) {
Throwable err = new GridException("Failed to acquire asynchronous lock for keys: " + keys, e);
// Clean-up.
fut.onError(err);
ctx.mvcc().removeFuture(fut);
return fut;
}
}