/**
* Basically, future mapping consists from two parts. First, we must determine the topology
* version this future will map on. Locking is performed within a user transaction, we must
* continue to map keys on the same topology version as it started. If topology version is
* undefined, we get current topology future and wait until it completes so the topology is ready
* to use.
*
* <p>During the second part we map keys to primary nodes using topology snapshot we obtained
* during the first part. Note that if primary node leaves grid, the future will fail and
* transaction will be rolled back.
*/
void map() {
// Obtain the topology version to use.
GridDiscoveryTopologySnapshot snapshot =
tx != null
? tx.topologySnapshot()
: cctx.mvcc().lastExplicitLockTopologySnapshot(Thread.currentThread().getId());
if (snapshot != null) {
// Continue mapping on the same topology version as it was before.
topSnapshot.compareAndSet(null, snapshot);
map(keys);
markInitialized();
return;
}
// Must get topology snapshot and map on that version.
mapOnTopology();
}
/**
* Acquires topology future and checks it completeness under the read lock. If it is not complete,
* will asynchronously wait for it's completeness and then try again.
*/
void mapOnTopology() {
// We must acquire topology snapshot from the topology version future.
try {
cctx.topology().readLock();
try {
GridDhtTopologyFuture fut = cctx.topologyVersionFuture();
if (fut.isDone()) {
GridDiscoveryTopologySnapshot snapshot = fut.topologySnapshot();
if (tx != null) {
tx.topologyVersion(snapshot.topologyVersion());
tx.topologySnapshot(snapshot);
}
topSnapshot.compareAndSet(null, snapshot);
map(keys);
markInitialized();
} else {
fut.listenAsync(
new CI1<GridFuture<Long>>() {
@Override
public void apply(GridFuture<Long> t) {
mapOnTopology();
}
});
}
} finally {
cctx.topology().readUnlock();
}
} catch (GridException e) {
onDone(e);
}
}
/** @param t Error. */
private void onError(Throwable t) {
err.compareAndSet(null, t instanceof GridCacheLockTimeoutException ? null : t);
}
