/** * Emits a tuple to the specified task on the default output stream. This * output stream must have been declared as a direct stream, and the * specified task must use a direct grouping on this stream to receive the * message. The emitted values must be immutable. */ public void emitDirect(int taskId, List<Object> tuple, Object messageId) { emitDirect(taskId, Utils.DEFAULT_STREAM_ID, tuple, messageId); }
public void emitDirect(int taskId, String streamId, List<Object> tuple, Object messageId) { out.emitDirect(taskId, streamId, tuple, messageId); }
/** * Emits a tuple to the specified task on the default output stream. This * output stream must have been declared as a direct stream, and the * specified task must use a direct grouping on this stream to receive the * message. The emitted values must be immutable. * * <p> * Because no message id is specified, Storm will not track this message so * ack and fail will never be called for this tuple. * </p> */ public void emitDirect(int taskId, List<Object> tuple) { emitDirect(taskId, tuple, null); }
public void emitDirect(int taskId, List<Object> tuple, Object messageId, ICollectorCallback callback) { emitDirect(taskId, Utils.DEFAULT_STREAM_ID, tuple, messageId, callback); }
/** * Emits a tuple to the specified task on the specified output stream. This * output stream must have been declared as a direct stream, and the * specified task must use a direct grouping on this stream to receive the * message. The emitted values must be immutable. * * <p> * Because no message id is specified, Storm will not track this message so * ack and fail will never be called for this tuple. * </p> */ public void emitDirect(int taskId, String streamId, List<Object> tuple) { emitDirect(taskId, streamId, tuple, null); }
public void emitDirect(int taskId, String streamId, List<Object> tuple, ICollectorCallback callback) { emitDirect(taskId, streamId, tuple, null, callback); }
public void emitDirect(int taskId, List<Object> tuple, ICollectorCallback callback) { emitDirect(taskId, tuple, null, callback); }
/** * Emits a tuple to the specified task on the default output stream. This output * stream must have been declared as a direct stream, and the specified task must * use a direct grouping on this stream to receive the message. */ public void emitDirect(int taskId, List<Object> tuple, Object messageId) { emitDirect(taskId, Utils.DEFAULT_STREAM_ID, tuple, messageId); }
/** * Emits a tuple to the specified task on the specified output stream. This output * stream must have been declared as a direct stream, and the specified task must * use a direct grouping on this stream to receive the message. * * <p> Because no message id is specified, Storm will not track this message * so ack and fail will never be called for this tuple.</p> */ public void emitDirect(int taskId, String streamId, List<Object> tuple) { emitDirect(taskId, streamId, tuple, null); }
/** * Emits a tuple to the specified task on the default output stream. This output * stream must have been declared as a direct stream, and the specified task must * use a direct grouping on this stream to receive the message. * * <p> Because no message id is specified, Storm will not track this message * so ack and fail will never be called for this tuple.</p> */ public void emitDirect(int taskId, List<Object> tuple) { emitDirect(taskId, tuple, null); } }
public void emitDirect(int taskId, String streamId, List<Object> tuple, Object messageId) { _collector.emitDirect(taskId, streamId, tuple, messageId); recordSpoutEmit(); }
public void emitDirect(int taskId, String streamId, List<Object> tuple, Object messageId) { _collector.emitDirect(taskId, streamId, tuple, messageId); recordSpoutEmit(); } }
@Override public List<Integer> emit(String ignore, List<Object> values, Object msgId) { long batchIdVal = _rand.nextLong(); Object batchId = new RichSpoutBatchId(batchIdVal); FinishCondition finish = new FinishCondition(); finish.msgId = msgId; List<Integer> tasks = new ArrayList<>(); _collector.emit(_stream, new ConsList(batchId, values), new CollectorCb(tasks)); _collector.flush(); Set<Integer> outTasksSet = new HashSet<>(tasks); for(Integer t: _outputTasks) { int count = 0; if(outTasksSet.contains(t)) { count = 1; } long r = _rand.nextLong(); _collector.emitDirect(t, _coordStream, new Values(batchId, count), r); finish.vals.add(r); _msgIdToBatchId.put(r, batchIdVal); } _finishConditions.put(batchIdVal, finish); return tasks; }
@Override public void close() { if (JStormUtils.isKilledStatus(context)){ JStormUtils.sleepMs(10); int sendNum = 0; for (List<Integer> tasks : _targetTasks.values()) { for (Integer task : tasks) { sendNum++; _collector.emitDirect(task, new Values()); } } _collector.flush(); LOG.info("this component already sent {} finish messages", sendNum); JStormUtils.sleepMs(100); } }
_collector.emit(stream, tuple, messageId, new ShellEmitCb(shellMsg)); } else { _collector.emitDirect((int) task.longValue(), stream, tuple, messageId);
/** * Emits a tuple to the specified task on the default output stream. This output * stream must have been declared as a direct stream, and the specified task must * use a direct grouping on this stream to receive the message. The emitted values must be * immutable. */ public void emitDirect(int taskId, List<Object> tuple, Object messageId) { emitDirect(taskId, Utils.DEFAULT_STREAM_ID, tuple, messageId); }
/** * Emits a tuple to the specified task on the specified output stream. This output * stream must have been declared as a direct stream, and the specified task must * use a direct grouping on this stream to receive the message. The emitted values must be * immutable. * <p> * <p> Because no message id is specified, Storm will not track this message * so ack and fail will never be called for this tuple.</p> */ public void emitDirect(int taskId, String streamId, List<Object> tuple) { emitDirect(taskId, streamId, tuple, null); }
/** * Emits a tuple to the specified task on the specified output stream. This output * stream must have been declared as a direct stream, and the specified task must * use a direct grouping on this stream to receive the message. The emitted values must be * immutable. * * <p> Because no message id is specified, Storm will not track this message * so ack and fail will never be called for this tuple.</p> */ public void emitDirect(int taskId, String streamId, List<Object> tuple) { emitDirect(taskId, streamId, tuple, null); }
/** * Emits a tuple to the specified task on the default output stream. This output * stream must have been declared as a direct stream, and the specified task must * use a direct grouping on this stream to receive the message. The emitted values must be * immutable. * <p> * <p> Because no message id is specified, Storm will not track this message * so ack and fail will never be called for this tuple.</p> */ public void emitDirect(int taskId, List<Object> tuple) { emitDirect(taskId, tuple, null); }
public void emitDirect(int taskId, String streamId, List<Object> tuple, Object messageId) { out.emitDirect(taskId, streamId, tuple, messageId); }