/**
* @param rmtReducer Optional reducer.
* @param rmtTransform Optional transformer.
* @param args Arguments.
* @return Future.
*/
@SuppressWarnings("IfMayBeConditional")
private <R> CacheQueryFuture<R> execute(
@Nullable IgniteReducer<T, R> rmtReducer,
@Nullable IgniteClosure<T, R> rmtTransform,
@Nullable Object... args) {
Collection<ClusterNode> nodes = nodes();
cctx.checkSecurity(SecurityPermission.CACHE_READ);
if (nodes.isEmpty())
return new GridCacheQueryErrorFuture<>(
cctx.kernalContext(), new ClusterGroupEmptyCheckedException());
if (log.isDebugEnabled())
log.debug("Executing query [query=" + this + ", nodes=" + nodes + ']');
if (cctx.deploymentEnabled()) {
try {
cctx.deploy().registerClasses(filter, rmtReducer, rmtTransform);
cctx.deploy().registerClasses(args);
} catch (IgniteCheckedException e) {
return new GridCacheQueryErrorFuture<>(cctx.kernalContext(), e);
}
}
if (subjId == null) subjId = cctx.localNodeId();
taskHash = cctx.kernalContext().job().currentTaskNameHash();
final GridCacheQueryBean bean =
new GridCacheQueryBean(
this,
(IgniteReducer<Object, Object>) rmtReducer,
(IgniteClosure<Object, Object>) rmtTransform,
args);
final GridCacheQueryManager qryMgr = cctx.queries();
boolean loc = nodes.size() == 1 && F.first(nodes).id().equals(cctx.localNodeId());
if (type == SQL_FIELDS || type == SPI)
return (CacheQueryFuture<R>)
(loc ? qryMgr.queryFieldsLocal(bean) : qryMgr.queryFieldsDistributed(bean, nodes));
else if (type == SCAN && part != null && nodes.size() > 1)
return new CacheQueryFallbackFuture<>(nodes, bean, qryMgr);
else
return (CacheQueryFuture<R>)
(loc ? qryMgr.queryLocal(bean) : qryMgr.queryDistributed(bean, nodes));
}
/** {@inheritDoc} */
@Override
public void onEvicted(GridDhtLocalPartition part, boolean updateSeq) {
assert updateSeq || lock.isWriteLockedByCurrentThread();
lock.writeLock().lock();
try {
if (stopping) return;
assert part.state() == EVICTED;
long seq = updateSeq ? this.updateSeq.incrementAndGet() : this.updateSeq.get();
updateLocal(part.id(), cctx.localNodeId(), part.state(), seq);
consistencyCheck();
} finally {
lock.writeLock().unlock();
}
}
/** Clears values for this partition. */
private void clearAll() {
GridCacheVersion clearVer = cctx.versions().next();
boolean swap = cctx.isSwapOrOffheapEnabled();
boolean rec = cctx.events().isRecordable(EVT_CACHE_REBALANCE_OBJECT_UNLOADED);
Iterator<GridDhtCacheEntry> it = map.values().iterator();
GridCloseableIterator<Map.Entry<byte[], GridCacheSwapEntry>> swapIt = null;
if (swap
&& GridQueryProcessor.isEnabled(cctx.config())) { // Indexing needs to unswap cache values.
Iterator<GridDhtCacheEntry> unswapIt = null;
try {
swapIt = cctx.swap().iterator(id);
unswapIt = unswapIterator(swapIt);
} catch (Exception e) {
U.error(log, "Failed to clear swap for evicted partition: " + this, e);
}
if (unswapIt != null) it = F.concat(it, unswapIt);
}
try {
while (it.hasNext()) {
GridDhtCacheEntry cached = it.next();
try {
if (cached.clearInternal(clearVer, swap)) {
map.remove(cached.key(), cached);
if (!cached.isInternal()) {
mapPubSize.decrement();
if (rec)
cctx.events()
.addEvent(
cached.partition(),
cached.key(),
cctx.localNodeId(),
(IgniteUuid) null,
null,
EVT_CACHE_REBALANCE_OBJECT_UNLOADED,
null,
false,
cached.rawGet(),
cached.hasValue(),
null,
null,
null);
}
}
} catch (IgniteCheckedException e) {
U.error(log, "Failed to clear cache entry for evicted partition: " + cached, e);
}
}
} finally {
U.close(swapIt, log);
}
}
/**
* @param entry Entry to map.
* @param val Value to write.
* @param entryProcessor Entry processor.
* @param ttl TTL (optional).
* @param conflictExpireTime Conflict expire time (optional).
* @param conflictVer Conflict version (optional).
* @param updateCntr Partition update counter.
*/
public void addWriteEntry(
GridDhtCacheEntry entry,
@Nullable CacheObject val,
EntryProcessor<Object, Object, Object> entryProcessor,
long ttl,
long conflictExpireTime,
@Nullable GridCacheVersion conflictVer,
boolean addPrevVal,
@Nullable CacheObject prevVal,
long updateCntr) {
AffinityTopologyVersion topVer = updateReq.topologyVersion();
Collection<ClusterNode> dhtNodes = cctx.dht().topology().nodes(entry.partition(), topVer);
if (log.isDebugEnabled())
log.debug(
"Mapping entry to DHT nodes [nodes=" + U.nodeIds(dhtNodes) + ", entry=" + entry + ']');
CacheWriteSynchronizationMode syncMode = updateReq.writeSynchronizationMode();
keys.add(entry.key());
for (ClusterNode node : dhtNodes) {
UUID nodeId = node.id();
if (!nodeId.equals(cctx.localNodeId())) {
GridDhtAtomicUpdateRequest updateReq = mappings.get(nodeId);
if (updateReq == null) {
updateReq =
new GridDhtAtomicUpdateRequest(
cctx.cacheId(),
nodeId,
futVer,
writeVer,
syncMode,
topVer,
forceTransformBackups,
this.updateReq.subjectId(),
this.updateReq.taskNameHash(),
forceTransformBackups ? this.updateReq.invokeArguments() : null,
cctx.deploymentEnabled(),
this.updateReq.keepBinary());
mappings.put(nodeId, updateReq);
}
updateReq.addWriteValue(
entry.key(),
val,
entryProcessor,
ttl,
conflictExpireTime,
conflictVer,
addPrevVal,
entry.partition(),
prevVal,
updateCntr);
} else if (dhtNodes.size() == 1) {
try {
cctx.continuousQueries()
.onEntryUpdated(
entry.key(),
val,
prevVal,
entry.key().internal() || !cctx.userCache(),
entry.partition(),
true,
false,
updateCntr,
updateReq.topologyVersion());
} catch (IgniteCheckedException e) {
U.warn(
log,
"Failed to send continuous query message. [key="
+ entry.key()
+ ", newVal="
+ val
+ ", err="
+ e
+ "]");
}
}
}
}