/** Initializes future. */
@SuppressWarnings({"unchecked"})
void finish() {
if (mappings != null) {
finish(mappings.values());
markInitialized();
if (!isSync()) {
boolean complete = true;
for (GridFuture<?> f : pending())
// Mini-future in non-sync mode gets done when message gets sent.
if (isMini(f) && !f.isDone()) complete = false;
if (complete) onComplete();
}
} else {
assert !commit;
try {
tx.rollback();
} catch (GridException e) {
U.error(log, "Failed to rollback empty transaction: " + tx, e);
}
markInitialized();
}
}
void cancelAll() {
GridException err =
new GridException("Data loader has been cancelled: " + GridDataLoaderImpl.this);
for (GridFuture<?> f : locFuts) {
try {
f.cancel();
} catch (GridException e) {
U.error(log, "Failed to cancel mini-future.", e);
}
}
for (GridFutureAdapter<?> f : reqs.values()) f.onDone(err);
}
/**
* @param entries Entries to submit.
* @param curFut Current future.
* @throws GridInterruptedException If interrupted.
*/
private void submit(final List<Map.Entry<K, V>> entries, final GridFutureAdapter<Object> curFut)
throws GridInterruptedException {
assert entries != null;
assert !entries.isEmpty();
assert curFut != null;
incrementActiveTasks();
GridFuture<Object> fut;
if (isLocNode) {
fut =
ctx.closure()
.callLocalSafe(
new GridDataLoadUpdateJob<>(ctx, log, cacheName, entries, false, updater),
false);
locFuts.add(fut);
fut.listenAsync(
new GridInClosure<GridFuture<Object>>() {
@Override
public void apply(GridFuture<Object> t) {
try {
boolean rmv = locFuts.remove(t);
assert rmv;
curFut.onDone(t.get());
} catch (GridException e) {
curFut.onDone(e);
}
}
});
} else {
byte[] entriesBytes;
try {
entriesBytes = ctx.config().getMarshaller().marshal(entries);
if (updaterBytes == null) {
assert updater != null;
updaterBytes = ctx.config().getMarshaller().marshal(updater);
}
if (topicBytes == null) topicBytes = ctx.config().getMarshaller().marshal(topic);
} catch (GridException e) {
U.error(log, "Failed to marshal (request will not be sent).", e);
return;
}
GridDeployment dep = null;
GridPeerDeployAware jobPda0 = null;
if (ctx.deploy().enabled()) {
try {
jobPda0 = jobPda;
assert jobPda0 != null;
dep = ctx.deploy().deploy(jobPda0.deployClass(), jobPda0.classLoader());
} catch (GridException e) {
U.error(
log,
"Failed to deploy class (request will not be sent): " + jobPda0.deployClass(),
e);
return;
}
if (dep == null)
U.warn(log, "Failed to deploy class (request will be sent): " + jobPda0.deployClass());
}
long reqId = idGen.incrementAndGet();
fut = curFut;
reqs.put(reqId, (GridFutureAdapter<Object>) fut);
GridDataLoadRequest<Object, Object> req =
new GridDataLoadRequest<>(
reqId,
topicBytes,
cacheName,
updaterBytes,
entriesBytes,
true,
dep != null ? dep.deployMode() : null,
dep != null ? jobPda0.deployClass().getName() : null,
dep != null ? dep.userVersion() : null,
dep != null ? dep.participants() : null,
dep != null ? dep.classLoaderId() : null,
dep == null);
try {
ctx.io().send(node, TOPIC_DATALOAD, req, PUBLIC_POOL);
if (log.isDebugEnabled())
log.debug("Sent request to node [nodeId=" + node.id() + ", req=" + req + ']');
} catch (GridException e) {
if (ctx.discovery().alive(node) && ctx.discovery().pingNode(node.id()))
((GridFutureAdapter<Object>) fut).onDone(e);
else
((GridFutureAdapter<Object>) fut)
.onDone(
new GridTopologyException(
"Failed to send " + "request (node has left): " + node.id()));
}
}
}
/**
* Performs flush.
*
* @throws GridException If failed.
*/
private void doFlush() throws GridException {
lastFlushTime = U.currentTimeMillis();
List<GridFuture> activeFuts0 = null;
int doneCnt = 0;
for (GridFuture<?> f : activeFuts) {
if (!f.isDone()) {
if (activeFuts0 == null) activeFuts0 = new ArrayList<>((int) (activeFuts.size() * 1.2));
activeFuts0.add(f);
} else {
f.get();
doneCnt++;
}
}
if (activeFuts0 == null || activeFuts0.isEmpty()) return;
while (true) {
Queue<GridFuture<?>> q = null;
for (Buffer buf : bufMappings.values()) {
GridFuture<?> flushFut = buf.flush();
if (flushFut != null) {
if (q == null) q = new ArrayDeque<>(bufMappings.size() * 2);
q.add(flushFut);
}
}
if (q != null) {
assert !q.isEmpty();
boolean err = false;
for (GridFuture fut = q.poll(); fut != null; fut = q.poll()) {
try {
fut.get();
} catch (GridException e) {
if (log.isDebugEnabled()) log.debug("Failed to flush buffer: " + e);
err = true;
}
}
if (err)
// Remaps needed - flush buffers.
continue;
}
doneCnt = 0;
for (int i = 0; i < activeFuts0.size(); i++) {
GridFuture f = activeFuts0.get(i);
if (f == null) doneCnt++;
else if (f.isDone()) {
f.get();
doneCnt++;
activeFuts0.set(i, null);
} else break;
}
if (doneCnt == activeFuts0.size()) return;
}
}
/**
* @param f Future.
* @return {@code True} if mini-future.
*/
private boolean isMini(GridFuture<?> f) {
return f.getClass().equals(MiniFuture.class);
}
/**
* 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);
}
}
});
}
}
}
/**
* JUnit.
*
* @throws Exception In case of error.
*/
@SuppressWarnings({"TooBroadScope"})
public void testH2Text() throws Exception {
int duration = 60 * 1000;
final int keyCnt = 5000;
final int logFreq = 50;
final String txt = "Value";
final GridCache<Integer, H2TextValue> c = grid(0).cache(null);
GridFuture<?> fut1 =
multithreadedAsync(
new Callable() {
@Override
public Object call() throws Exception {
for (int i = 0; i < keyCnt; i++) {
c.putx(i, new H2TextValue(txt));
if (i % logFreq == 0) X.println("Stored values: " + i);
}
return null;
}
},
1);
// Create query.
final GridCacheQuery<Map.Entry<Integer, H2TextValue>> qry =
c.queries().createFullTextQuery(H2TextValue.class, txt);
qry.enableDedup(false);
qry.includeBackups(false);
qry.timeout(TEST_TIMEOUT);
final AtomicBoolean stop = new AtomicBoolean();
GridFuture<?> fut2 =
multithreadedAsync(
new Callable() {
@Override
public Object call() throws Exception {
int cnt = 0;
while (!stop.get()) {
Collection<Map.Entry<Integer, H2TextValue>> res = qry.execute().get();
cnt++;
if (cnt % logFreq == 0) {
X.println("Result set: " + res.size());
X.println("Executed queries: " + cnt);
}
}
return null;
}
},
1);
Thread.sleep(duration);
fut1.get();
stop.set(true);
fut2.get();
}