/**
* @param cctx Registry.
* @param keys Keys to lock.
* @param tx Transaction.
* @param read Read flag.
* @param retval Flag to return value or not.
* @param timeout Lock acquisition timeout.
* @param filter Filter.
*/
public GridNearLockFuture(
GridCacheContext<K, V> cctx,
Collection<? extends K> keys,
@Nullable GridNearTxLocal<K, V> tx,
boolean read,
boolean retval,
long timeout,
GridPredicate<GridCacheEntry<K, V>>[] filter) {
super(cctx.kernalContext(), CU.boolReducer());
assert cctx != null;
assert keys != null;
this.cctx = cctx;
this.keys = keys;
this.tx = tx;
this.read = read;
this.retval = retval;
this.timeout = timeout;
this.filter = filter;
threadId = tx == null ? Thread.currentThread().getId() : tx.threadId();
lockVer = tx != null ? tx.xidVersion() : cctx.versions().next();
futId = GridUuid.randomUuid();
entries = new ArrayList<>(keys.size());
log = U.logger(ctx, logRef, GridNearLockFuture.class);
if (timeout > 0) {
timeoutObj = new LockTimeoutObject();
cctx.time().addTimeoutObject(timeoutObj);
}
valMap = new ConcurrentHashMap8<>(keys.size(), 1f);
}
public GridTestJobContext() {
jobId = GridUuid.randomUuid();
}
/**
* Gets next near lock mapping and either acquires dht locks locally or sends near lock request to
* remote primary node.
*
* @param mappings Queue of mappings.
* @throws GridException If mapping can not be completed.
*/
private void proceedMapping(final ConcurrentLinkedDeque8<GridNearLockMapping<K, V>> mappings)
throws GridException {
GridNearLockMapping<K, V> map = mappings.poll();
// If there are no more mappings to process, complete the future.
if (map == null) return;
final GridNearLockRequest<K, V> req = map.request();
final Collection<K> mappedKeys = map.distributedKeys();
final GridNode node = map.node();
if (filter != null && filter.length != 0) req.filter(filter, cctx);
if (node.isLocal()) {
req.miniId(GridUuid.randomUuid());
if (log.isDebugEnabled()) log.debug("Before locally locking near request: " + req);
GridFuture<GridNearLockResponse<K, V>> fut;
if (CU.DHT_ENABLED) fut = dht().lockAllAsync(cctx.localNode(), req, filter);
else {
// Create dummy values for testing.
GridNearLockResponse<K, V> res =
new GridNearLockResponse<>(lockVer, futId, null, false, 1, null);
res.addValueBytes(null, null, true, lockVer, lockVer, cctx);
fut = new GridFinishedFuture<>(ctx, res);
}
// Add new future.
add(
new GridEmbeddedFuture<>(
cctx.kernalContext(),
fut,
new C2<GridNearLockResponse<K, V>, Exception, Boolean>() {
@Override
public Boolean apply(GridNearLockResponse<K, V> res, Exception e) {
if (CU.isLockTimeoutOrCancelled(e)
|| (res != null && CU.isLockTimeoutOrCancelled(res.error()))) return false;
if (e != null) {
onError(e);
return false;
}
if (res == null) {
onError(new GridException("Lock response is null for future: " + this));
return false;
}
if (res.error() != null) {
onError(res.error());
return false;
}
if (log.isDebugEnabled())
log.debug(
"Acquired lock for local DHT mapping [locId="
+ cctx.nodeId()
+ ", mappedKeys="
+ mappedKeys
+ ", fut="
+ GridNearLockFuture.this
+ ']');
try {
int i = 0;
for (K k : mappedKeys) {
while (true) {
GridNearCacheEntry<K, V> entry =
cctx.near().entryExx(k, req.topologyVersion());
try {
GridTuple3<GridCacheVersion, V, byte[]> oldValTup =
valMap.get(entry.key());
boolean hasBytes = entry.hasValue();
V oldVal = entry.rawGet();
V newVal = res.value(i);
byte[] newBytes = res.valueBytes(i);
GridCacheVersion dhtVer = res.dhtVersion(i);
GridCacheVersion mappedVer = res.mappedVersion(i);
// On local node don't record twice if DHT cache already recorded.
boolean record =
retval && oldValTup != null && oldValTup.get1().equals(dhtVer);
if (newVal == null) {
if (oldValTup != null) {
if (oldValTup.get1().equals(dhtVer)) {
newVal = oldValTup.get2();
newBytes = oldValTup.get3();
}
oldVal = oldValTup.get2();
}
}
// Lock is held at this point, so we can set the
// returned value if any.
entry.resetFromPrimary(newVal, newBytes, lockVer, dhtVer, node.id());
entry.readyNearLock(
lockVer,
mappedVer,
res.committedVersions(),
res.rolledbackVersions(),
res.pending());
if (inTx() && implicitTx() && tx.onePhaseCommit()) {
boolean pass = res.filterResult(i);
tx.entry(k).filters(pass ? CU.<K, V>empty() : CU.<K, V>alwaysFalse());
}
if (record) {
if (cctx.events().isRecordable(EVT_CACHE_OBJECT_READ))
cctx.events()
.addEvent(
entry.partition(),
entry.key(),
tx,
null,
EVT_CACHE_OBJECT_READ,
newVal,
newVal != null,
oldVal,
hasBytes,
CU.subjectId(tx, cctx));
cctx.cache().metrics0().onRead(oldVal != null);
}
if (log.isDebugEnabled())
log.debug(
"Processed response for entry [res="
+ res
+ ", entry="
+ entry
+ ']');
break; // Inner while loop.
} catch (GridCacheEntryRemovedException ignored) {
if (log.isDebugEnabled())
log.debug(
"Failed to add candidates because entry was "
+ "removed (will renew).");
// Replace old entry with new one.
entries.set(
i,
(GridDistributedCacheEntry<K, V>) cctx.cache().entryEx(entry.key()));
}
}
i++; // Increment outside of while loop.
}
// Proceed and add new future (if any) before completing embedded future.
proceedMapping(mappings);
} catch (GridException ex) {
onError(ex);
return false;
}
return true;
}
}));
} else {
final MiniFuture fut = new MiniFuture(node, mappedKeys, mappings);
req.miniId(fut.futureId());
add(fut); // Append new future.
GridFuture<?> txSync = null;
if (inTx()) txSync = cctx.tm().awaitFinishAckAsync(node.id(), tx.threadId());
if (txSync == null || txSync.isDone()) {
try {
if (log.isDebugEnabled())
log.debug("Sending near lock request [node=" + node.id() + ", req=" + req + ']');
cctx.io().send(node, req);
} catch (GridTopologyException ex) {
assert fut != null;
fut.onResult(ex);
}
} else {
txSync.listenAsync(
new CI1<GridFuture<?>>() {
@Override
public void apply(GridFuture<?> t) {
try {
if (log.isDebugEnabled())
log.debug(
"Sending near lock request [node=" + node.id() + ", req=" + req + ']');
cctx.io().send(node, req);
} catch (GridTopologyException ex) {
assert fut != null;
fut.onResult(ex);
} catch (GridException e) {
onError(e);
}
}
});
}
}
}
/**
* Mini-future for get operations. Mini-futures are only waiting on a single node as opposed to
* multiple nodes.
*/
private class MiniFuture extends GridFutureAdapter<Boolean> {
/** */
private static final long serialVersionUID = 0L;
/** */
private final GridUuid futId = GridUuid.randomUuid();
/** Node ID. */
@GridToStringExclude private GridNode node;
/** Keys. */
@GridToStringInclude private Collection<K> keys;
/** Mappings to proceed. */
@GridToStringExclude private ConcurrentLinkedDeque8<GridNearLockMapping<K, V>> mappings;
/** */
private AtomicBoolean rcvRes = new AtomicBoolean(false);
/** Empty constructor required for {@link Externalizable}. */
public MiniFuture() {
// No-op.
}
/**
* @param node Node.
* @param keys Keys.
* @param mappings Mappings to proceed.
*/
MiniFuture(
GridNode node,
Collection<K> keys,
ConcurrentLinkedDeque8<GridNearLockMapping<K, V>> mappings) {
super(cctx.kernalContext());
this.node = node;
this.keys = keys;
this.mappings = mappings;
}
/** @return Future ID. */
GridUuid futureId() {
return futId;
}
/** @return Node ID. */
public GridNode node() {
return node;
}
/** @return Keys. */
public Collection<K> keys() {
return keys;
}
/** @param e Error. */
void onResult(Throwable e) {
if (rcvRes.compareAndSet(false, true)) {
if (log.isDebugEnabled())
log.debug("Failed to get future result [fut=" + this + ", err=" + e + ']');
// Fail.
onDone(e);
} else
U.warn(
log,
"Received error after another result has been processed [fut="
+ GridNearLockFuture.this
+ ", mini="
+ this
+ ']',
e);
}
/** @param e Node left exception. */
void onResult(GridTopologyException e) {
if (isDone()) return;
if (rcvRes.compareAndSet(false, true)) {
if (log.isDebugEnabled())
log.debug(
"Remote node left grid while sending or waiting for reply (will fail): " + this);
if (tx != null) tx.removeMapping(node.id());
// Primary node left the grid, so fail the future.
GridNearLockFuture.this.onDone(newTopologyException(e, node.id()));
onDone(true);
}
}
/** @param res Result callback. */
void onResult(GridNearLockResponse<K, V> res) {
if (rcvRes.compareAndSet(false, true)) {
if (res.error() != null) {
if (log.isDebugEnabled())
log.debug(
"Finishing mini future with an error due to error in response [miniFut="
+ this
+ ", res="
+ res
+ ']');
// Fail.
if (res.error() instanceof GridCacheLockTimeoutException) onDone(false);
else onDone(res.error());
return;
}
int i = 0;
long topVer = topSnapshot.get().topologyVersion();
for (K k : keys) {
while (true) {
GridNearCacheEntry<K, V> entry = cctx.near().entryExx(k, topVer);
try {
if (res.dhtVersion(i) == null) {
onDone(
new GridException(
"Failed to receive DHT version from remote node "
+ "(will fail the lock): "
+ res));
return;
}
GridTuple3<GridCacheVersion, V, byte[]> oldValTup = valMap.get(entry.key());
V oldVal = entry.rawGet();
boolean hasOldVal = false;
V newVal = res.value(i);
byte[] newBytes = res.valueBytes(i);
boolean readRecordable = false;
if (retval) {
readRecordable = cctx.events().isRecordable(EVT_CACHE_OBJECT_READ);
if (readRecordable) hasOldVal = entry.hasValue();
}
GridCacheVersion dhtVer = res.dhtVersion(i);
GridCacheVersion mappedVer = res.mappedVersion(i);
if (newVal == null) {
if (oldValTup != null) {
if (oldValTup.get1().equals(dhtVer)) {
newVal = oldValTup.get2();
newBytes = oldValTup.get3();
}
oldVal = oldValTup.get2();
}
}
// Lock is held at this point, so we can set the
// returned value if any.
entry.resetFromPrimary(newVal, newBytes, lockVer, dhtVer, node.id());
if (inTx() && implicitTx() && tx.onePhaseCommit()) {
boolean pass = res.filterResult(i);
tx.entry(k).filters(pass ? CU.<K, V>empty() : CU.<K, V>alwaysFalse());
}
entry.readyNearLock(
lockVer,
mappedVer,
res.committedVersions(),
res.rolledbackVersions(),
res.pending());
if (retval) {
if (readRecordable)
cctx.events()
.addEvent(
entry.partition(),
entry.key(),
tx,
null,
EVT_CACHE_OBJECT_READ,
newVal,
newVal != null || newBytes != null,
oldVal,
hasOldVal,
CU.subjectId(tx, cctx));
cctx.cache().metrics0().onRead(false);
}
if (log.isDebugEnabled())
log.debug("Processed response for entry [res=" + res + ", entry=" + entry + ']');
break; // Inner while loop.
} catch (GridCacheEntryRemovedException ignored) {
if (log.isDebugEnabled())
log.debug("Failed to add candidates because entry was removed (will renew).");
// Replace old entry with new one.
entries.set(i, (GridDistributedCacheEntry<K, V>) cctx.cache().entryEx(entry.key()));
} catch (GridException e) {
onDone(e);
return;
}
}
i++;
}
try {
proceedMapping(mappings);
} catch (GridException e) {
onDone(e);
}
onDone(true);
}
}
/** {@inheritDoc} */
@Override
public String toString() {
return S.toString(MiniFuture.class, this, "node", node.id(), "super", super.toString());
}
}