/** {@inheritDoc} */
@Override
public boolean onDone(GridCacheTx tx, Throwable err) {
if ((initialized() || err != null) && super.onDone(tx, err)) {
if (error() instanceof GridCacheTxHeuristicException) {
long topVer = this.tx.topologyVersion();
for (GridCacheTxEntry<K, V> e : this.tx.writeMap().values()) {
try {
if (e.op() != NOOP && !cctx.affinity().localNode(e.key(), topVer)) {
GridCacheEntryEx<K, V> cacheEntry = cctx.cache().peekEx(e.key());
if (cacheEntry != null) cacheEntry.invalidate(null, this.tx.xidVersion());
}
} catch (Throwable t) {
U.error(log, "Failed to invalidate entry.", t);
if (t instanceof Error) throw (Error) t;
}
}
}
// Don't forget to clean up.
cctx.mvcc().removeFuture(this);
return true;
}
return false;
}
/** {@inheritDoc} */
@Override
public long getOverflowSize() {
try {
return cctx.cache().overflowSize();
} catch (GridException ignored) {
return -1;
}
}
/** @return {@code True} if locks have been acquired. */
private boolean checkLocks() {
if (!isDone() && initialized() && !hasPending()) {
for (int i = 0; i < entries.size(); i++) {
while (true) {
GridCacheEntryEx<K, V> cached = entries.get(i);
try {
if (!locked(cached)) {
if (log.isDebugEnabled())
log.debug(
"Lock is still not acquired for entry (will keep waiting) [entry="
+ cached
+ ", fut="
+ this
+ ']');
return false;
}
break;
}
// Possible in concurrent cases, when owner is changed after locks
// have been released or cancelled.
catch (GridCacheEntryRemovedException ignore) {
if (log.isDebugEnabled())
log.debug("Got removed entry in onOwnerChanged method (will retry): " + cached);
// Replace old entry with new one.
entries.set(i, (GridDistributedCacheEntry<K, V>) cctx.cache().entryEx(cached.key()));
}
}
}
if (log.isDebugEnabled())
log.debug("Local lock acquired for entries [fut=" + this + ", entries=" + entries + "]");
onComplete(true, true);
return true;
}
return false;
}
void recheck() {
for (Iterator<IgniteTxKey> it = pendingLocks.keySet().iterator(); it.hasNext(); ) {
IgniteTxKey key = it.next();
GridCacheContext cacheCtx = cctx.cacheContext(key.cacheId());
GridCacheEntryEx entry = cacheCtx.cache().peekEx(key.key());
if (entry == null) it.remove();
else recheck(entry);
}
if (log.isDebugEnabled()) log.debug("After rechecking finished future: " + this);
if (pendingLocks.isEmpty()) {
if (exchLog.isDebugEnabled()) exchLog.debug("Finish lock future is done: " + this);
onDone();
}
}
/**
* Undoes all locks.
*
* @param dist If {@code true}, then remove locks from remote nodes as well.
*/
private void undoLocks(boolean dist) {
// Transactions will undo during rollback.
if (dist && tx == null) cctx.nearTx().removeLocks(lockVer, keys);
else {
if (tx != null) {
if (tx.setRollbackOnly()) {
if (log.isDebugEnabled())
log.debug(
"Marked transaction as rollback only because locks could not be acquired: " + tx);
} else if (log.isDebugEnabled())
log.debug(
"Transaction was not marked rollback-only while locks were not acquired: " + tx);
}
for (GridCacheEntryEx<K, V> e : entriesCopy()) {
try {
e.removeLock(lockVer);
} catch (GridCacheEntryRemovedException ignored) {
while (true) {
try {
e = cctx.cache().peekEx(e.key());
if (e != null) e.removeLock(lockVer);
break;
} catch (GridCacheEntryRemovedException ignore) {
if (log.isDebugEnabled())
log.debug(
"Attempted to remove lock on removed entry (will retry) [ver="
+ lockVer
+ ", entry="
+ e
+ ']');
}
}
}
}
}
cctx.mvcc().recheckPendingLocks();
}
/** {@inheritDoc} */
@Override
public void execute(@Nullable GridProjection prj) throws GridException {
if (cb == null)
throw new IllegalStateException("Mandatory local callback is not set for the query: " + this);
if (prj == null) prj = ctx.grid();
prj = prj.forCache(ctx.name());
if (prj.nodes().isEmpty())
throw new GridTopologyException("Failed to execute query (projection is empty): " + this);
GridCacheMode mode = ctx.config().getCacheMode();
if (mode == LOCAL || mode == REPLICATED) {
Collection<GridNode> nodes = prj.nodes();
GridNode node = nodes.contains(ctx.localNode()) ? ctx.localNode() : F.rand(nodes);
assert node != null;
if (nodes.size() > 1 && !ctx.cache().isDrSystemCache()) {
if (node.id().equals(ctx.localNodeId()))
U.warn(
log,
"Continuous query for "
+ mode
+ " cache can be run only on local node. "
+ "Will execute query locally: "
+ this);
else
U.warn(
log,
"Continuous query for "
+ mode
+ " cache can be run only on single node. "
+ "Will execute query on remote node [qry="
+ this
+ ", node="
+ node
+ ']');
}
prj = prj.forNode(node);
}
closeLock.lock();
try {
if (routineId != null)
throw new IllegalStateException("Continuous query can't be executed twice.");
guard.block();
GridContinuousHandler hnd =
new GridCacheContinuousQueryHandler<>(ctx.name(), topic, cb, filter, prjPred);
routineId =
ctx.kernalContext()
.continuous()
.startRoutine(hnd, bufSize, timeInterval, autoUnsubscribe, prj.predicate())
.get();
} finally {
closeLock.unlock();
}
}
/** @throws IgniteCheckedException If query is invalid. */
public void validate() throws IgniteCheckedException {
if ((type != SCAN && type != SET) && !GridQueryProcessor.isEnabled(cctx.config()))
throw new IgniteCheckedException("Indexing is disabled for cache: " + cctx.cache().name());
}
/** @throws GridException If query is invalid. */
public void validate() throws GridException {
if (type != SCAN && !cctx.config().isQueryIndexEnabled())
throw new GridException("Indexing is disabled for cache: " + cctx.cache().name());
}
/** {@inheritDoc} */
@Override
public boolean isEmpty() {
return cctx.cache().isEmpty();
}
/** {@inheritDoc} */
@Override
public int getKeySize() {
return cctx.cache().keySize();
}
/** {@inheritDoc} */
@Override
public int getSize() {
return cctx.cache().size();
}
/** {@inheritDoc} */
@Override
public String metricsFormatted() {
return String.valueOf(cctx.cache().metrics());
}