/**
* @param in Object input.
* @return Read collection.
* @throws IOException If failed.
* @throws ClassNotFoundException If failed.
*/
private Collection<Object> readFieldsCollection(ObjectInput in)
throws IOException, ClassNotFoundException {
assert fields;
int size = in.readInt();
if (size == -1) return null;
Collection<Object> res = new ArrayList<>(size);
for (int i = 0; i < size; i++) {
int size0 = in.readInt();
Collection<Object> col = new ArrayList<>(size0);
for (int j = 0; j < size0; j++) col.add(in.readObject());
assert col.size() == size0;
res.add(col);
}
assert res.size() == size;
return res;
}
/** @throws Exception If failed. */
public void testClientAffinity() throws Exception {
GridClientData partitioned = client.data(PARTITIONED_CACHE_NAME);
Collection<Object> keys = new ArrayList<>();
keys.addAll(Arrays.asList(Boolean.TRUE, Boolean.FALSE, 1, Integer.MAX_VALUE));
Random rnd = new Random();
StringBuilder sb = new StringBuilder();
// Generate some random strings.
for (int i = 0; i < 100; i++) {
sb.setLength(0);
for (int j = 0; j < 255; j++)
// Only printable ASCII symbols for test.
sb.append((char) (rnd.nextInt(0x7f - 0x20) + 0x20));
keys.add(sb.toString());
}
// Generate some more keys to achieve better coverage.
for (int i = 0; i < 100; i++) keys.add(UUID.randomUUID());
for (Object key : keys) {
UUID nodeId = grid(0).mapKeyToNode(PARTITIONED_CACHE_NAME, key).id();
UUID clientNodeId = partitioned.affinity(key);
assertEquals(
"Invalid affinity mapping for REST response for key: " + key, nodeId, clientNodeId);
}
}
/** {@inheritDoc} */
@Override
protected Collection<GridComputeJobAdapter> split(int gridSize, Object arg)
throws GridException {
assert rsrc1 != null;
assert rsrc2 != null;
assert rsrc3 != null;
assert rsrc4 != null;
assert log != null;
log.info("Injected shared resource1 into task: " + rsrc1);
log.info("Injected shared resource2 into task: " + rsrc2);
log.info("Injected shared resource3 into task: " + rsrc3);
log.info("Injected shared resource4 into task: " + rsrc4);
log.info("Injected log resource into task: " + log);
task1Rsrc1 = rsrc1;
task1Rsrc2 = rsrc2;
task1Rsrc3 = rsrc3;
task1Rsrc4 = rsrc4;
Collection<GridComputeJobAdapter> jobs = new ArrayList<>(gridSize);
for (int i = 0; i < gridSize; i++) {
jobs.add(new GridSharedJob1());
}
return jobs;
}
/** {@inheritDoc} */
@Override
protected Collection<E> dequeue0(int cnt) {
WindowHolder tup = ref.get();
AtomicInteger size = tup.size();
Collection<T> evts = tup.collection();
Collection<E> resCol = new ArrayList<>(cnt);
while (true) {
int curSize = size.get();
if (curSize > 0) {
if (size.compareAndSet(curSize, curSize - 1)) {
E res = pollInternal(evts, tup.set());
if (res != null) {
resCol.add(res);
if (resCol.size() >= cnt) return resCol;
} else {
size.incrementAndGet();
return resCol;
}
}
} else return resCol;
}
}
/** {@inheritDoc} */
@Override
public void explicitUndeploy(UUID nodeId, String rsrcName) {
Collection<SharedDeployment> undeployed = new LinkedList<SharedDeployment>();
synchronized (mux) {
for (Iterator<List<SharedDeployment>> i1 = cache.values().iterator(); i1.hasNext(); ) {
List<SharedDeployment> deps = i1.next();
for (Iterator<SharedDeployment> i2 = deps.iterator(); i2.hasNext(); ) {
SharedDeployment dep = i2.next();
if (dep.hasName(rsrcName)) {
if (!dep.isUndeployed()) {
dep.undeploy();
dep.onRemoved();
// Undeploy.
i2.remove();
undeployed.add(dep);
if (log.isInfoEnabled()) log.info("Undeployed per-version class loader: " + dep);
}
break;
}
}
if (deps.isEmpty()) i1.remove();
}
}
recordUndeployed(null, undeployed);
}
/**
* Check whether provided path must be excluded from evictions.
*
* @param path Path.
* @return {@code True} in case non block of related file must be excluded.
* @throws GridException In case of faulty patterns.
*/
public boolean exclude(GridGgfsPath path) throws GridException {
assert path != null;
Collection<Pattern> excludePatterns0;
if (excludeRecompile.compareAndSet(true, false)) {
// Recompile.
Collection<String> excludePaths0 = excludePaths;
if (excludePaths0 != null) {
excludePatterns0 = new HashSet<>(excludePaths0.size(), 1.0f);
for (String excludePath : excludePaths0) {
try {
excludePatterns0.add(Pattern.compile(excludePath));
} catch (PatternSyntaxException ignore) {
throw new GridException("Invalid regex pattern: " + excludePath);
}
}
excludePatterns = excludePatterns0;
} else excludePatterns0 = excludePatterns = null;
} else excludePatterns0 = excludePatterns;
if (excludePatterns0 != null) {
String pathStr = path.toString();
for (Pattern pattern : excludePatterns0) {
if (pattern.matcher(pathStr).matches()) return true;
}
}
return false;
}
/** {@inheritDoc} */
@SuppressWarnings("TypeMayBeWeakened")
@Nullable
private Collection<Object> unmarshalFieldsCollection(
@Nullable Collection<byte[]> byteCol, GridCacheContext<K, V> ctx, ClassLoader ldr)
throws GridException {
assert ctx != null;
assert ldr != null;
Collection<Object> col = unmarshalCollection(byteCol, ctx, ldr);
Collection<Object> col0 = null;
if (col != null) {
col0 = new ArrayList<>(col.size());
for (Object o : col) {
List<Object> list = (List<Object>) o;
List<Object> list0 = new ArrayList<>(list.size());
for (Object obj : list)
list0.add(obj != null ? ctx.marshaller().unmarshal((byte[]) obj, ldr) : null);
col0.add(list0);
}
}
return col0;
}
/** {@inheritDoc} */
@Override
protected Collection<? extends GridComputeJob> split(int gridSize, Object arg)
throws GridException {
Collection<GridComputeJobAdapter> jobs = new ArrayList<>(gridSize);
this.gridSize = gridSize;
final String locNodeId = grid.localNode().id().toString();
for (int i = 0; i < gridSize; i++) {
jobs.add(
new GridComputeJobAdapter() {
@SuppressWarnings("OverlyStrongTypeCast")
@Override
public Object execute() {
try {
Thread.sleep(1000);
} catch (InterruptedException ignored) {
Thread.currentThread().interrupt();
}
return new GridBiTuple<>(locNodeId, 1);
}
});
}
return jobs;
}
/**
* Schedules runnable task for execution.
*
* @param w Runnable task.
* @throws GridException Thrown if any exception occurred.
*/
@SuppressWarnings({"CatchGenericClass", "ProhibitedExceptionThrown"})
public void execute(final GridWorker w) throws GridException {
workers.add(w);
try {
exec.execute(
new Runnable() {
@Override
public void run() {
try {
w.run();
} finally {
workers.remove(w);
}
}
});
} catch (RejectedExecutionException e) {
workers.remove(w);
throw new GridComputeExecutionRejectedException(
"Failed to execute worker due to execution rejection.", e);
} catch (RuntimeException e) {
workers.remove(w);
throw new GridException("Failed to execute worker due to runtime exception.", e);
} catch (Error e) {
workers.remove(w);
throw e;
}
}
/** {@inheritDoc} */
@Override
public final Map<UUID, GridNodeMetrics> metrics(Collection<UUID> nodeIds)
throws GridSpiException {
assert !F.isEmpty(nodeIds);
long now = U.currentTimeMillis();
Collection<UUID> expired = new LinkedList<>();
for (UUID id : nodeIds) {
GridNodeMetrics nodeMetrics = metricsMap.get(id);
Long ts = tsMap.get(id);
if (nodeMetrics == null || ts == null || ts < now - metricsExpireTime) expired.add(id);
}
if (!expired.isEmpty()) {
Map<UUID, GridNodeMetrics> refreshed = metrics0(expired);
for (UUID id : refreshed.keySet()) tsMap.put(id, now);
metricsMap.putAll(refreshed);
}
return F.view(metricsMap, F.contains(nodeIds));
}
/**
* The added suite will be always executed locally, but in parallel with other locally or remotely
* running tests. This comes handy for tests that cannot be distributed for some environmental
* reasons, but still would benefit from parallel execution.
*
* <p>Note, that local suites will be executed on local node even if grid topology only allows
* remote nodes.
*
* @param localSuite Test to execute locally in parallel with other local or distributed tests.
*/
@SuppressWarnings({"TypeMayBeWeakened"})
public void addTest(GridJunit3LocalTestSuite localSuite) {
if (!locTests.contains(localSuite.getName())) {
locTests.add(localSuite.getName());
}
addTest((Test) localSuite);
}
/** {@inheritDoc} */
@Override
protected Collection<? extends GridComputeJob> split(int gridSize, String arg)
throws GridException {
Collection<GridComputeJobAdapter> jobs = new ArrayList<>(jobCnt);
for (int i = 0; i < jobCnt; i++) jobs.add(new TestJob());
return jobs;
}
/**
* Add information about key and version to request.
*
* <p>Other version has to be provided if suspect lock is DHT local.
*
* @param key Key.
* @param cand Candidate.
*/
@SuppressWarnings({"MismatchedQueryAndUpdateOfCollection"})
void addCandidate(K key, GridCacheDgcLockCandidate cand) {
Collection<GridCacheDgcLockCandidate> col =
F.addIfAbsent(map, key, new ArrayList<GridCacheDgcLockCandidate>());
assert col != null;
col.add(cand);
}
/** {@inheritDoc} */
@Override
public Collection<UUID> nodeIds() {
Collection<UUID> ids = new GridLeanSet<UUID>();
ids.add(cctx.nodeId());
ids.addAll(mappings.keySet());
return ids;
}
/** {@inheritDoc} */
@Override
public Collection<GridDeployment> getDeployments() {
Collection<GridDeployment> deps = new LinkedList<GridDeployment>();
synchronized (mux) {
for (List<SharedDeployment> list : cache.values())
for (SharedDeployment d : list) deps.add(d);
}
return deps;
}
/** {@inheritDoc} */
@Override
protected Collection<? extends GridComputeJob> split(int gridSize, Object arg)
throws GridException {
if (log.isInfoEnabled())
log.info("Splitting job [job=" + this + ", gridSize=" + gridSize + ", arg=" + arg + ']');
Collection<GridComputeJob> jobs = new ArrayList<>(SPLIT_COUNT);
for (int i = 1; i <= SPLIT_COUNT; i++) jobs.add(new GridCancelTestJob(i));
return jobs;
}
/** {@inheritDoc} */
@SuppressWarnings("all")
@Override
public boolean readFrom(ByteBuffer buf) {
commState.setBuffer(buf);
if (!super.readFrom(buf)) return false;
switch (commState.idx) {
case 2:
if (buf.remaining() < 1) return false;
err = commState.getBoolean();
commState.idx++;
case 3:
if (buf.remaining() < 8) return false;
futId = commState.getLong();
commState.idx++;
case 4:
if (commState.readSize == -1) {
if (buf.remaining() < 4) return false;
commState.readSize = commState.getInt();
}
if (commState.readSize >= 0) {
if (rejectedKeyBytes == null) rejectedKeyBytes = new ArrayList<>(commState.readSize);
for (int i = commState.readItems; i < commState.readSize; i++) {
byte[] _val = commState.getByteArray();
if (_val == BYTE_ARR_NOT_READ) return false;
rejectedKeyBytes.add((byte[]) _val);
commState.readItems++;
}
}
commState.readSize = -1;
commState.readItems = 0;
commState.idx++;
}
return true;
}
/** {@inheritDoc} */
@Override
protected Collection<E> pollEvicted0(int cnt) {
Collection<E> res = new ArrayList<>(cnt);
for (int i = 0; i < cnt; i++) {
E evicted = pollEvictedInternal();
if (evicted == null) return res;
res.add(evicted);
}
return res;
}
/** {@inheritDoc} */
@Override
public void loadCache(GridBiInClosure<K, V> c, @Nullable Object... args) throws GridException {
ExecutorService exec =
new ThreadPoolExecutor(
threadsCnt,
threadsCnt,
0L,
MILLISECONDS,
new ArrayBlockingQueue<Runnable>(batchQueueSize),
new BlockingRejectedExecutionHandler());
Iterator<I> iter = inputIterator(args);
Collection<I> buf = new ArrayList<>(batchSize);
try {
while (iter.hasNext()) {
if (Thread.currentThread().isInterrupted()) {
U.warn(log, "Working thread was interrupted while loading data.");
break;
}
buf.add(iter.next());
if (buf.size() == batchSize) {
exec.submit(new Worker(c, buf, args));
buf = new ArrayList<>(batchSize);
}
}
if (!buf.isEmpty()) exec.submit(new Worker(c, buf, args));
} catch (RejectedExecutionException ignored) {
// Because of custom RejectedExecutionHandler.
assert false : "RejectedExecutionException was thrown while it shouldn't.";
} finally {
exec.shutdown();
try {
exec.awaitTermination(Long.MAX_VALUE, MILLISECONDS);
} catch (InterruptedException ignored) {
U.warn(log, "Working thread was interrupted while waiting for put operations to complete.");
Thread.currentThread().interrupt();
}
}
}
/** {@inheritDoc} */
@Override
public Collection<GridDeployment> getDeployments() {
Collection<GridDeployment> deps = new ArrayList<GridDeployment>();
synchronized (mux) {
for (List<GridDeployment> depList : cache.values()) {
for (GridDeployment d : depList) {
if (!deps.contains(d)) {
deps.add(d);
}
}
}
return deps;
}
}
/** {@inheritDoc} */
@Override
public void start0() throws GridException {
aff =
new GridAffinityAssignmentCache(
cctx,
cctx.namex(),
cctx.config().getAffinity(),
cctx.config().getAffinityMapper(),
cctx.config().getBackups());
// Generate internal keys for partitions.
int partCnt = partitions();
partAffKeys = new GridPartitionLockKey[partCnt];
Collection<Integer> found = new HashSet<>();
long affKey = 0;
while (true) {
GridPartitionLockKey key = new GridPartitionLockKey(affKey);
int part = aff.partition(key);
if (found.add(part)) {
// This is a key for not yet calculated partition.
key.partitionId(part);
partAffKeys[part] = key;
if (found.size() == partCnt) break;
}
affKey++;
if (affKey > partCnt * MAX_PARTITION_KEY_ATTEMPT_RATIO)
throw new IllegalStateException(
"Failed to calculate partition affinity keys for given affinity "
+ "function [attemptCnt="
+ affKey
+ ", found="
+ found
+ ", cacheName="
+ cctx.name()
+ ']');
}
}
/** {@inheritDoc} */
@Override
public Map<GridRichNode, Collection<K>> mapKeysToNodes(Collection<? extends K> keys) {
Map<GridRichNode, Collection<K>> map = new HashMap<GridRichNode, Collection<K>>();
for (K key : keys) {
Collection<GridRichNode> nodes = ctx.allNodes(key);
for (GridRichNode node : nodes) {
Collection<K> keyCol = map.get(node);
if (keyCol == null) map.put(node, keyCol = new LinkedList<K>());
keyCol.add(key);
}
}
return map;
}
/** {@inheritDoc} */
@Override
public Map<? extends GridComputeJob, GridNode> map(List<GridNode> subgrid, Integer arg)
throws GridException {
assert taskSes != null;
assert arg != null;
assert arg > 0;
Map<GridSessionLoadTestJob, GridNode> map = new HashMap<>(subgrid.size());
Iterator<GridNode> iter = subgrid.iterator();
Random rnd = new Random();
params = new HashMap<>(arg);
Collection<UUID> assigned = new ArrayList<>(subgrid.size());
for (int i = 0; i < arg; i++) {
// Recycle iterator.
if (!iter.hasNext()) iter = subgrid.iterator();
String paramName = UUID.randomUUID().toString();
int paramVal = rnd.nextInt();
taskSes.setAttribute(paramName, paramVal);
GridNode node = iter.next();
assigned.add(node.id());
map.put(new GridSessionLoadTestJob(paramName), node);
params.put(paramName, paramVal);
if (log.isDebugEnabled())
log.debug("Set session attribute [name=" + paramName + ", value=" + paramVal + ']');
}
taskSes.setAttribute("nodes", assigned);
return map;
}
/** {@inheritDoc} */
@Override
public void stop() {
Collection<SharedDeployment> copy = new HashSet<SharedDeployment>();
synchronized (mux) {
for (List<SharedDeployment> deps : cache.values())
for (SharedDeployment dep : deps) {
// Mark undeployed.
dep.undeploy();
copy.add(dep);
}
cache.clear();
}
for (SharedDeployment dep : copy) dep.recordUndeployed(null);
if (log.isDebugEnabled()) log.debug(stopInfo());
}
/**
* @param ldr Class loader to undeploy.
* @param recEvt Whether or not to record the event.
*/
private void undeploy(ClassLoader ldr, boolean recEvt) {
Collection<GridDeployment> doomed = new HashSet<GridDeployment>();
synchronized (mux) {
for (Iterator<LinkedList<GridDeployment>> i1 = cache.values().iterator(); i1.hasNext(); ) {
LinkedList<GridDeployment> deps = i1.next();
for (Iterator<GridDeployment> i2 = deps.iterator(); i2.hasNext(); ) {
GridDeployment dep = i2.next();
if (dep.classLoader() == ldr) {
dep.undeploy();
i2.remove();
doomed.add(dep);
if (log.isInfoEnabled()) {
log.info("Removed undeployed class: " + dep);
}
}
}
if (deps.isEmpty()) {
i1.remove();
}
}
}
for (GridDeployment dep : doomed) {
if (dep.isObsolete()) {
// Resource cleanup.
ctx.resource().onUndeployed(dep);
}
if (recEvt) {
recordUndeploy(dep, true);
}
}
}
/**
* Adds a test to be executed on the grid. In case of test suite, all tests inside of test suite
* will be executed sequentially on some remote node.
*
* @param test Test to add.
*/
@Override
public void addTest(Test test) {
if (copy == null) {
copy = new TestSuite(getName());
}
// Add test to the list of local ones.
if (test instanceof GridJunit3LocalTestSuite) {
String testName = ((TestSuite) test).getName();
if (!locTests.contains(testName)) {
locTests.add(testName);
}
}
if (test instanceof GridJunit3TestSuite) {
copy.addTest(((GridJunit3TestSuite) test).copy);
super.addTest(new GridJunit3TestSuiteProxy(((GridJunit3TestSuite) test).copy, factory));
} else if (test instanceof GridJunit3TestSuiteProxy) {
copy.addTest(((GridJunit3TestSuiteProxy) test).getOriginal());
super.addTest(test);
} else if (test instanceof GridJunit3TestCaseProxy) {
copy.addTest(((GridJunit3TestCaseProxy) test).getGridGainJunit3OriginalTestCase());
super.addTest(test);
} else if (test instanceof TestSuite) {
copy.addTest(test);
super.addTest(new GridJunit3TestSuiteProxy((TestSuite) test, factory));
} else {
assert test instanceof TestCase
: "Test must be either instance of TestSuite or TestCase: " + test;
copy.addTest(test);
super.addTest(factory.createProxy((TestCase) test));
}
}
/** {@inheritDoc} */
@Override
public GridFuture<?> addData(Collection<? extends Map.Entry<K, V>> entries) {
A.notEmpty(entries, "entries");
enterBusy();
try {
GridFutureAdapter<Object> resFut = new GridFutureAdapter<>(ctx);
activeFuts.add(resFut);
resFut.listenAsync(rmvActiveFut);
Collection<K> keys = new GridConcurrentHashSet<>(entries.size(), 1.0f, 16);
for (Map.Entry<K, V> entry : entries) keys.add(entry.getKey());
load0(entries, resFut, keys, 0);
return resFut;
} finally {
leaveBusy();
}
}
/** {@inheritDoc} */
@Override
protected Collection<GridComputeJobAdapter> split(int gridSize, Object arg)
throws GridException {
assert rsrc1 != null;
assert rsrc2 != null;
assert rsrc3 != null;
assert rsrc4 != null;
assert log != null;
log.info("Injected shared resource1 into task: " + rsrc1);
log.info("Injected shared resource2 into task: " + rsrc2);
log.info("Injected shared resource3 into task: " + rsrc3);
log.info("Injected shared resource4 into task: " + rsrc4);
log.info("Injected log resource into task: " + log);
task2Rsrc1 = rsrc1;
task2Rsrc2 = rsrc2;
task2Rsrc3 = rsrc3;
task2Rsrc4 = rsrc4;
Collection<GridComputeJobAdapter> jobs = new ArrayList<>(gridSize);
for (int i = 0; i < gridSize; i++) {
jobs.add(
new GridComputeJobAdapter() {
/** User resource. */
@GridUserResource(resourceClass = UserResource1.class)
private transient GridAbstractUserResource rsrc5;
/** User resource */
@GridUserResource private transient UserResource2 rsrc6;
/** User resource. */
@GridUserResource(resourceClass = UserResource1.class, resourceName = "rsrc3")
private transient GridAbstractUserResource rsrc7;
/** User resource */
@GridUserResource(resourceName = "rsrc4")
private transient UserResource2 rsrc8;
/** {@inheritDoc} */
@SuppressWarnings({"ObjectEquality"})
@Override
public Serializable execute() {
assert rsrc1 != null;
assert rsrc2 != null;
assert rsrc3 != null;
assert rsrc4 != null;
assert log != null;
assert rsrc5 != null;
assert rsrc6 != null;
assert rsrc7 != null;
assert rsrc8 != null;
// Make sure that neither task nor global scope got
// created more than once.
assert rsrc1 == rsrc5;
assert rsrc2 == rsrc6;
assert rsrc3 == rsrc7;
assert rsrc4 == rsrc8;
log.info("Injected shared resource1 into job: " + rsrc1);
log.info("Injected shared resource2 into job: " + rsrc2);
log.info("Injected shared resource3 into job: " + rsrc3);
log.info("Injected shared resource4 into job: " + rsrc4);
log.info("Injected shared resource5 into job: " + rsrc5);
log.info("Injected shared resource6 into job: " + rsrc6);
log.info("Injected shared resource7 into job: " + rsrc7);
log.info("Injected shared resource8 into job: " + rsrc8);
log.info("Injected log resource into job: " + log);
return null;
}
});
}
return jobs;
}
/** {@inheritDoc} */
@SuppressWarnings("all")
@Override
public boolean readFrom(ByteBuffer buf) {
commState.setBuffer(buf);
if (!super.readFrom(buf)) return false;
switch (commState.idx) {
case 2:
if (commState.readSize == -1) {
if (buf.remaining() < 4) return false;
commState.readSize = commState.getInt();
}
if (commState.readSize >= 0) {
if (dataBytes == null) dataBytes = new ArrayList<>(commState.readSize);
for (int i = commState.readItems; i < commState.readSize; i++) {
byte[] _val = commState.getByteArray();
if (_val == BYTE_ARR_NOT_READ) return false;
dataBytes.add((byte[]) _val);
commState.readItems++;
}
}
commState.readSize = -1;
commState.readItems = 0;
commState.idx++;
case 3:
byte[] errBytes0 = commState.getByteArray();
if (errBytes0 == BYTE_ARR_NOT_READ) return false;
errBytes = errBytes0;
commState.idx++;
case 4:
if (buf.remaining() < 1) return false;
fields = commState.getBoolean();
commState.idx++;
case 5:
if (buf.remaining() < 1) return false;
finished = commState.getBoolean();
commState.idx++;
case 6:
if (commState.readSize == -1) {
if (buf.remaining() < 4) return false;
commState.readSize = commState.getInt();
}
if (commState.readSize >= 0) {
if (metaDataBytes == null) metaDataBytes = new ArrayList<>(commState.readSize);
for (int i = commState.readItems; i < commState.readSize; i++) {
byte[] _val = commState.getByteArray();
if (_val == BYTE_ARR_NOT_READ) return false;
metaDataBytes.add((byte[]) _val);
commState.readItems++;
}
}
commState.readSize = -1;
commState.readItems = 0;
commState.idx++;
case 7:
commState.idx++;
case 8:
if (buf.remaining() < 8) return false;
reqId = commState.getLong();
commState.idx++;
}
return true;
}
/** {@inheritDoc} */
@Override
public void unlockAll(
Collection<? extends K> keys, GridPredicate<? super GridCacheEntry<K, V>>[] filter) {
if (keys.isEmpty()) return;
try {
GridCacheVersion ver = null;
Collection<GridRichNode> affNodes = null;
int keyCnt = -1;
Map<GridRichNode, GridNearUnlockRequest<K, V>> map = null;
Collection<K> locKeys = new LinkedList<K>();
GridCacheVersion obsoleteVer = ctx.versions().next();
for (K key : keys) {
while (true) {
GridDistributedCacheEntry<K, V> entry = peekExx(key);
if (entry == null || !ctx.isAll(entry.wrap(false), filter)) break; // While.
try {
GridCacheMvccCandidate<K> cand =
entry.candidate(ctx.nodeId(), Thread.currentThread().getId());
if (cand != null) {
ver = cand.version();
if (affNodes == null) {
affNodes = CU.allNodes(ctx, cand.topologyVersion());
keyCnt = (int) Math.ceil((double) keys.size() / affNodes.size());
map = new HashMap<GridRichNode, GridNearUnlockRequest<K, V>>(affNodes.size());
}
// Send request to remove from remote nodes.
GridRichNode primary = CU.primary0(ctx.affinity(key, affNodes));
GridNearUnlockRequest<K, V> 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.
GridCacheMvccCandidate<K> rmv = entry.removeLock();
if (rmv != null) {
if (!rmv.reentry()) {
if (ver != null && !ver.equals(rmv.version()))
throw new GridException(
"Failed to unlock (if keys were locked separately, "
+ "then they need to be unlocked separately): "
+ keys);
if (!primary.isLocal()) {
assert req != null;
req.addKey(entry.key(), entry.getOrMarshalKeyBytes(), ctx);
} else locKeys.add(key);
if (log.isDebugEnabled()) log.debug("Removed lock (will distribute): " + rmv);
} else if (log.isDebugEnabled())
log.debug(
"Current thread still owns lock (or there are no other nodes)"
+ " [lock="
+ rmv
+ ", curThreadId="
+ Thread.currentThread().getId()
+ ']');
}
// Try to evict near entry if it's dht-mapped locally.
evictNearEntry(entry, obsoleteVer);
}
break;
} catch (GridCacheEntryRemovedException ignore) {
if (log.isDebugEnabled())
log.debug("Attempted to unlock removed entry (will retry): " + entry);
}
}
}
if (ver == null) return;
for (Map.Entry<GridRichNode, GridNearUnlockRequest<K, V>> mapping : map.entrySet()) {
GridRichNode n = mapping.getKey();
GridDistributedUnlockRequest<K, V> req = mapping.getValue();
if (n.isLocal()) dht.removeLocks(ctx.nodeId(), req.version(), locKeys, true);
else if (!req.keyBytes().isEmpty())
// 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);
}
}
