/** {@inheritDoc} */
@Override
public V unswap(K key) throws GridException {
ctx.denyOnFlags(F.asList(READ, SKIP_SWAP));
// Unswap only from DHT. Near cache does not have swap storage.
return dht.unswap(key);
}
/** {@inheritDoc} */
@Override
public void stopListenAsync(@Nullable GridInClosure<? super GridFuture<R>>... lsnr) {
if (F.isEmpty(lsnr))
synchronized (mux) {
lsnrs.clear();
}
else
synchronized (mux) {
lsnrs.removeAll(F.asList(lsnr));
}
}
/**
* Checks entry for empty value.
*
* @param entry Entry to check.
* @return {@code True} if entry is empty.
*/
private boolean empty(GridCacheEntry<K, V> entry) {
try {
return entry.peek(F.asList(GLOBAL)) == null;
} catch (GridException e) {
U.error(null, e.getMessage(), e);
assert false : "Should never happen: " + e;
return false;
}
}
/** @throws GridException If failed. */
public void testAffinity() throws GridException {
Grid g1 = grid(1);
Grid g2 = grid(2);
assert caches(g1).size() == 0;
assert F.first(caches(g2)).getCacheMode() == PARTITIONED;
Map<GridNode, Collection<String>> map = g1.mapKeysToNodes(null, F.asList("1"));
assertNotNull(map);
assertEquals("Invalid map size: " + map.size(), 1, map.size());
assertEquals(F.first(map.keySet()), g2.localNode());
UUID id1 = g1.mapKeyToNode(null, "2").id();
assertNotNull(id1);
assertEquals(g2.localNode().id(), id1);
UUID id2 = g1.mapKeyToNode(null, "3").id();
assertNotNull(id2);
assertEquals(g2.localNode().id(), id2);
}
/**
* Removes locks regardless of whether they are owned or not for given version and keys.
*
* @param ver Lock version.
* @param keys Keys.
*/
@SuppressWarnings({"unchecked"})
public void removeLocks(GridCacheVersion ver, Collection<? extends K> keys) {
if (keys.isEmpty()) return;
try {
Collection<GridRichNode> affNodes = null;
int keyCnt = -1;
Map<GridNode, GridNearUnlockRequest<K, V>> map = null;
for (K key : keys) {
// Send request to remove from remote nodes.
GridNearUnlockRequest<K, V> req = null;
while (true) {
GridDistributedCacheEntry<K, V> entry = peekExx(key);
try {
if (entry != null) {
GridCacheMvccCandidate<K> cand = entry.candidate(ver);
if (cand != null) {
if (affNodes == null) {
affNodes = CU.allNodes(ctx, cand.topologyVersion());
keyCnt = (int) Math.ceil((double) keys.size() / affNodes.size());
map = new HashMap<GridNode, GridNearUnlockRequest<K, V>>(affNodes.size());
}
GridRichNode primary = CU.primary0(ctx.affinity(key, affNodes));
if (!primary.isLocal()) {
req = map.get(primary);
if (req == null) {
map.put(primary, req = new GridNearUnlockRequest<K, V>(keyCnt));
req.version(ver);
}
}
// Remove candidate from local node first.
if (entry.removeLock(cand.version())) {
if (primary.isLocal()) {
dht.removeLocks(primary.id(), ver, F.asList(key), true);
assert req == null;
continue;
}
req.addKey(entry.key(), entry.getOrMarshalKeyBytes(), ctx);
}
}
}
break;
} catch (GridCacheEntryRemovedException ignored) {
if (log.isDebugEnabled())
log.debug(
"Attempted to remove lock from removed entry (will retry) [rmvVer="
+ ver
+ ", entry="
+ entry
+ ']');
}
}
}
if (map == null || map.isEmpty()) return;
Collection<GridCacheVersion> committed = ctx.tm().committedVersions(ver);
Collection<GridCacheVersion> rolledback = ctx.tm().rolledbackVersions(ver);
for (Map.Entry<GridNode, GridNearUnlockRequest<K, V>> mapping : map.entrySet()) {
GridNode n = mapping.getKey();
GridDistributedUnlockRequest<K, V> req = mapping.getValue();
if (!req.keyBytes().isEmpty()) {
req.completedVersions(committed, rolledback);
// We don't wait for reply to this message.
ctx.io().send(n, req);
}
}
} catch (GridException ex) {
U.error(log, "Failed to unlock the lock for keys: " + keys, ex);
}
}
/** {@inheritDoc} */
@Override
public Collection<GridRichNode> affinityNodes(K key) {
return F.asList(ctx.localNode());
}
/** {@inheritDoc} */
@Override
public GridFuture<?> addData(Map.Entry<K, V> entry) throws GridException, IllegalStateException {
A.notNull(entry, "entry");
return addData(F.asList(entry));
}
/**
* @param nodeId Node ID to send message to.
* @param msg Message to send.
* @throws GridException If send failed.
*/
private void send0(UUID nodeId, Object msg) throws GridException {
GridNode node = ctx.kernalContext().discovery().node(nodeId);
ctx.kernalContext().io().sendUserMessage(F.asList(node), msg, GridTopic.TOPIC_HADOOP, false, 0);
}