/**
* @param sesId Session ID.
* @param taskNodeId Task node ID.
* @param taskName Task name.
* @param dep Deployment.
* @param taskClsName Task class name.
* @param top Topology.
* @param startTime Execution start time.
* @param endTime Execution end time.
* @param siblings Collection of siblings.
* @param attrs Map of attributes.
* @param fullSup {@code True} to enable distributed session attributes and checkpoints.
* @return New session if one did not exist, or existing one.
*/
public GridTaskSessionImpl createTaskSession(
GridUuid sesId,
UUID taskNodeId,
String taskName,
@Nullable GridDeployment dep,
String taskClsName,
@Nullable Collection<UUID> top,
long startTime,
long endTime,
Collection<GridComputeJobSibling> siblings,
Map<Object, Object> attrs,
boolean fullSup) {
if (!fullSup) {
return new GridTaskSessionImpl(
taskNodeId,
taskName,
dep,
taskClsName,
sesId,
top,
startTime,
endTime,
siblings,
attrs,
ctx,
fullSup);
}
while (true) {
GridTaskSessionImpl ses = sesMap.get(sesId);
if (ses == null) {
GridTaskSessionImpl old =
sesMap.putIfAbsent(
sesId,
ses =
new GridTaskSessionImpl(
taskNodeId,
taskName,
dep,
taskClsName,
sesId,
top,
startTime,
endTime,
siblings,
attrs,
ctx,
fullSup));
if (old != null) ses = old;
else
// Return without acquire.
return ses;
}
if (ses.acquire()) return ses;
else sesMap.remove(sesId, ses);
}
}
/** {@inheritDoc} */
@Nullable
@Override
public Map<String, Collection<?>> run(GridStreamerContext ctx, Collection<Bar> bars)
throws GridException {
ConcurrentMap<String, Bar> loc = ctx.localSpace();
GridStreamerWindow win = ctx.window("stage2");
// Add numbers to window.
win.enqueueAll(bars);
Collection<Bar> polled = win.pollEvictedBatch();
if (!polled.isEmpty()) {
Map<String, Bar> map = new HashMap<>();
for (Bar polledBar : polled) {
String symbol = polledBar.symbol();
Bar bar = map.get(symbol);
if (bar == null) map.put(symbol, bar = new Bar(symbol));
bar.update(polledBar);
}
loc.putAll(map);
}
return null;
}
/**
* Removes session for a given session ID.
*
* @param sesId ID of session to remove.
* @return {@code True} if session was removed.
*/
public boolean removeSession(GridUuid sesId) {
GridTaskSessionImpl ses = sesMap.get(sesId);
assert ses == null || ses.isFullSupport();
if (ses != null && ses.release()) {
sesMap.remove(sesId, ses);
return true;
}
return false;
}
/**
* @param cancel {@code True} to close with cancellation.
* @throws GridException If failed.
*/
@Override
public void close(boolean cancel) throws GridException {
if (!closed.compareAndSet(false, true)) return;
busyLock.block();
if (log.isDebugEnabled())
log.debug("Closing data loader [ldr=" + this + ", cancel=" + cancel + ']');
GridException e = null;
try {
// Assuming that no methods are called on this loader after this method is called.
if (cancel) {
cancelled = true;
for (Buffer buf : bufMappings.values()) buf.cancelAll();
} else doFlush();
ctx.event().removeLocalEventListener(discoLsnr);
ctx.io().removeMessageListener(topic);
} catch (GridException e0) {
e = e0;
}
fut.onDone(null, e);
if (e != null) throw e;
}
/**
* Flushes every internal buffer if buffer was flushed before passed in threshold.
*
* <p>Does not wait for result and does not fail on errors assuming that this method should be
* called periodically.
*/
@Override
public void tryFlush() throws GridInterruptedException {
if (!busyLock.enterBusy()) return;
try {
for (Buffer buf : bufMappings.values()) buf.flush();
lastFlushTime = U.currentTimeMillis();
} finally {
leaveBusy();
}
}
/**
* Performs flush.
*
* @throws GridException If failed.
*/
private void doFlush() throws GridException {
lastFlushTime = U.currentTimeMillis();
List<GridFuture> activeFuts0 = null;
int doneCnt = 0;
for (GridFuture<?> f : activeFuts) {
if (!f.isDone()) {
if (activeFuts0 == null) activeFuts0 = new ArrayList<>((int) (activeFuts.size() * 1.2));
activeFuts0.add(f);
} else {
f.get();
doneCnt++;
}
}
if (activeFuts0 == null || activeFuts0.isEmpty()) return;
while (true) {
Queue<GridFuture<?>> q = null;
for (Buffer buf : bufMappings.values()) {
GridFuture<?> flushFut = buf.flush();
if (flushFut != null) {
if (q == null) q = new ArrayDeque<>(bufMappings.size() * 2);
q.add(flushFut);
}
}
if (q != null) {
assert !q.isEmpty();
boolean err = false;
for (GridFuture fut = q.poll(); fut != null; fut = q.poll()) {
try {
fut.get();
} catch (GridException e) {
if (log.isDebugEnabled()) log.debug("Failed to flush buffer: " + e);
err = true;
}
}
if (err)
// Remaps needed - flush buffers.
continue;
}
doneCnt = 0;
for (int i = 0; i < activeFuts0.size(); i++) {
GridFuture f = activeFuts0.get(i);
if (f == null) doneCnt++;
else if (f.isDone()) {
f.get();
doneCnt++;
activeFuts0.set(i, null);
} else break;
}
if (doneCnt == activeFuts0.size()) return;
}
}
/**
* @param entries Entries.
* @param resFut Result future.
* @param activeKeys Active keys.
* @param remaps Remaps count.
*/
private void load0(
Collection<? extends Map.Entry<K, V>> entries,
final GridFutureAdapter<Object> resFut,
final Collection<K> activeKeys,
final int remaps) {
assert entries != null;
if (remaps >= MAX_REMAP_CNT) {
resFut.onDone(new GridException("Failed to finish operation (too many remaps): " + remaps));
return;
}
Map<GridNode, Collection<Map.Entry<K, V>>> mappings = new HashMap<>();
boolean initPda = ctx.deploy().enabled() && jobPda == null;
for (Map.Entry<K, V> entry : entries) {
GridNode node;
try {
K key = entry.getKey();
assert key != null;
if (initPda) {
jobPda = new DataLoaderPda(key, entry.getValue(), updater);
initPda = false;
}
node = ctx.affinity().mapKeyToNode(cacheName, key);
} catch (GridException e) {
resFut.onDone(e);
return;
}
if (node == null) {
resFut.onDone(
new GridTopologyException(
"Failed to map key to node "
+ "(no nodes with cache found in topology) [infos="
+ entries.size()
+ ", cacheName="
+ cacheName
+ ']'));
return;
}
Collection<Map.Entry<K, V>> col = mappings.get(node);
if (col == null) mappings.put(node, col = new ArrayList<>());
col.add(entry);
}
for (final Map.Entry<GridNode, Collection<Map.Entry<K, V>>> e : mappings.entrySet()) {
final UUID nodeId = e.getKey().id();
Buffer buf = bufMappings.get(nodeId);
if (buf == null) {
Buffer old = bufMappings.putIfAbsent(nodeId, buf = new Buffer(e.getKey()));
if (old != null) buf = old;
}
final Collection<Map.Entry<K, V>> entriesForNode = e.getValue();
GridInClosure<GridFuture<?>> lsnr =
new GridInClosure<GridFuture<?>>() {
@Override
public void apply(GridFuture<?> t) {
try {
t.get();
for (Map.Entry<K, V> e : entriesForNode) activeKeys.remove(e.getKey());
if (activeKeys.isEmpty()) resFut.onDone();
} catch (GridException e1) {
if (log.isDebugEnabled())
log.debug("Future finished with error [nodeId=" + nodeId + ", err=" + e1 + ']');
if (cancelled) {
resFut.onDone(
new GridException(
"Data loader has been cancelled: " + GridDataLoaderImpl.this, e1));
} else load0(entriesForNode, resFut, activeKeys, remaps + 1);
}
}
};
GridFutureAdapter<?> f;
try {
f = buf.update(entriesForNode, lsnr);
} catch (GridInterruptedException e1) {
resFut.onDone(e1);
return;
}
if (ctx.discovery().node(nodeId) == null) {
if (bufMappings.remove(nodeId, buf)) buf.onNodeLeft();
if (f != null)
f.onDone(
new GridTopologyException(
"Failed to wait for request completion " + "(node has left): " + nodeId));
}
}
}
/** {@inheritDoc} */
@Override
public void printMemoryStats() {
X.println(">>>");
X.println(">>> Task session processor memory stats [grid=" + ctx.gridName() + ']');
X.println(">>> sesMapSize: " + sesMap.size());
}
/**
* @param sesId Session ID.
* @return Session for a given session ID.
*/
@Nullable
public GridTaskSessionImpl getSession(GridUuid sesId) {
return sesMap.get(sesId);
}