/** {@inheritDoc} */
@Nullable
@Override
public Map<? extends GridComputeJob, GridNode> map(
List<GridNode> subgrid, @Nullable GridBiTuple<Set<UUID>, A> arg) throws GridException {
assert arg != null;
assert arg.get1() != null;
start = U.currentTimeMillis();
boolean debug = debugState(g);
if (debug) logStart(g.log(), getClass(), start);
Set<UUID> nodeIds = arg.get1();
Map<GridComputeJob, GridNode> map = U.newHashMap(nodeIds.size());
try {
taskArg = arg.get2();
for (GridNode node : subgrid) if (nodeIds.contains(node.id())) map.put(job(taskArg), node);
return map;
} finally {
if (debug) logMapped(g.log(), getClass(), map.values());
}
}
/**
* Maps list by node ID.
*
* @param subgrid Subgrid.
* @return Map.
*/
private Map<UUID, GridNode> mapSubgrid(Collection<GridNode> subgrid) {
Map<UUID, GridNode> res = U.newHashMap(subgrid.size());
for (GridNode node : subgrid) res.put(node.id(), node);
return res;
}
/** @throws Exception If failed. */
public void testAffinityPut() throws Exception {
Thread.sleep(2 * TOP_REFRESH_FREQ);
assertEquals(NODES_CNT, client.compute().refreshTopology(false, false).size());
Map<UUID, Grid> gridsByLocNode = new HashMap<>(NODES_CNT);
GridClientData partitioned = client.data(PARTITIONED_CACHE_NAME);
GridClientCompute compute = client.compute();
for (int i = 0; i < NODES_CNT; i++) gridsByLocNode.put(grid(i).localNode().id(), grid(i));
for (int i = 0; i < 100; i++) {
String key = "key" + i;
UUID primaryNodeId = grid(0).mapKeyToNode(PARTITIONED_CACHE_NAME, key).id();
assertEquals("Affinity mismatch for key: " + key, primaryNodeId, partitioned.affinity(key));
assertEquals(primaryNodeId, partitioned.affinity(key));
// Must go to primary node only. Since backup count is 0, value must present on
// primary node only.
partitioned.put(key, "val" + key);
for (Map.Entry<UUID, Grid> entry : gridsByLocNode.entrySet()) {
Object val = entry.getValue().cache(PARTITIONED_CACHE_NAME).peek(key);
if (primaryNodeId.equals(entry.getKey())) assertEquals("val" + key, val);
else assertNull(val);
}
}
// Now check that we will see value in near cache in pinned mode.
for (int i = 100; i < 200; i++) {
String pinnedKey = "key" + i;
UUID primaryNodeId = grid(0).mapKeyToNode(PARTITIONED_CACHE_NAME, pinnedKey).id();
UUID pinnedNodeId = F.first(F.view(gridsByLocNode.keySet(), F.notEqualTo(primaryNodeId)));
GridClientNode node = compute.node(pinnedNodeId);
partitioned.pinNodes(node).put(pinnedKey, "val" + pinnedKey);
for (Map.Entry<UUID, Grid> entry : gridsByLocNode.entrySet()) {
Object val = entry.getValue().cache(PARTITIONED_CACHE_NAME).peek(pinnedKey);
if (primaryNodeId.equals(entry.getKey()) || pinnedNodeId.equals(entry.getKey()))
assertEquals("val" + pinnedKey, val);
else assertNull(val);
}
}
}
/** {@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} */
@SuppressWarnings("BusyWait")
@Override
public Boolean reduce(List<GridComputeJobResult> results) throws GridException {
assert taskSes != null;
assert results != null;
assert params != null;
assert !params.isEmpty();
assert results.size() == params.size();
Map<String, Integer> receivedParams = new HashMap<>();
boolean allAttrReceived = false;
int cnt = 0;
while (!allAttrReceived && cnt++ < 3) {
allAttrReceived = true;
for (Map.Entry<String, Integer> entry : params.entrySet()) {
assert taskSes.getAttribute(entry.getKey()) != null;
Integer newVal = (Integer) taskSes.getAttribute(entry.getKey());
assert newVal != null;
receivedParams.put(entry.getKey(), newVal);
if (newVal != entry.getValue() + 1) allAttrReceived = false;
}
if (!allAttrReceived) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new GridException("Thread interrupted.", e);
}
}
}
if (log.isDebugEnabled()) {
for (Map.Entry<String, Integer> entry : receivedParams.entrySet()) {
log.debug(
"Received session attr value [name="
+ entry.getKey()
+ ", val="
+ entry.getValue()
+ ", expected="
+ (params.get(entry.getKey()) + 1)
+ ']');
}
}
return allAttrReceived;
}
/** {@inheritDoc} */
@Nullable
@Override
public final Map<? extends GridComputeJob, GridNode> map(
List<GridNode> subgrid, @Nullable GridGgfsTaskArgs<T> args) throws GridException {
assert grid != null;
assert args != null;
GridGgfs ggfs = grid.ggfs(args.ggfsName());
GridGgfsProcessorAdapter ggfsProc = ((GridKernal) grid).context().ggfs();
Map<GridComputeJob, GridNode> splitMap = new HashMap<>();
Map<UUID, GridNode> nodes = mapSubgrid(subgrid);
for (GridGgfsPath path : args.paths()) {
GridGgfsFile file = ggfs.info(path);
if (file == null) {
if (args.skipNonExistentFiles()) continue;
else
throw new GridException("Failed to process GGFS file because it doesn't exist: " + path);
}
Collection<GridGgfsBlockLocation> aff =
ggfs.affinity(path, 0, file.length(), args.maxRangeLength());
long totalLen = 0;
for (GridGgfsBlockLocation loc : aff) {
GridNode node = null;
for (UUID nodeId : loc.nodeIds()) {
node = nodes.get(nodeId);
if (node != null) break;
}
if (node == null)
throw new GridException(
"Failed to find any of block affinity nodes in subgrid [loc="
+ loc
+ ", subgrid="
+ subgrid
+ ']');
GridGgfsJob job =
createJob(path, new GridGgfsFileRange(file.path(), loc.start(), loc.length()), args);
if (job != null) {
GridComputeJob jobImpl =
ggfsProc.createJob(
job, ggfs.name(), file.path(), loc.start(), loc.length(), args.recordResolver());
splitMap.put(jobImpl, node);
}
totalLen += loc.length();
}
assert totalLen == file.length();
}
return splitMap;
}
