/** * Emits a tuple to the default output stream with a null message id. Storm will not track this message so ack and fail will never be * called for this tuple. The emitted values must be immutable. */ public List<Integer> emit(List<Object> tuple) { return emit(tuple, null); }
public void fail(Object msgId) { System.out.println("**** RESENDING FAILED TUPLE"); this.collector.emit(this.pending.get(msgId), msgId); } }
@Override public void nextTuple() { List<Object> tuple; if (curr < strCount) { tuple = Collections.singletonList((Object) records.get(curr)); ++curr; collector.emit(tuple, ++count); } }
@Override public void nextTuple() { final Random rand = new Random(); final Values values = listValues.get(rand.nextInt(listValues.size())); collector.emit(values); Thread.yield(); }
public void nextTuple() { final Random rand = new Random(); final Values row = rows.get(rand.nextInt(rows.size() - 1)); this.collector.emit(row); Thread.yield(); }
public void nextTuple() { if (_serveTuples.size() > 0) { FixedTuple ft = _serveTuples.remove(0); String id = UUID.randomUUID().toString(); _pending.put(id, ft); _collector.emit(ft.stream, ft.values, id); } else { Utils.sleep(100); } }
public void nextTuple() { List<Object> toEmit = (List<Object>) InprocMessaging.pollMessage(_id); if (toEmit != null) { List<Object> tuple = (List<Object>) toEmit.get(0); Object msgId = toEmit.get(1); _collector.emit(tuple, msgId); } }
@Override public void nextTuple() { String sentence = CHOICES[_rand.nextInt(CHOICES.length)]; _collector.emit(new Values(sentence), sentence); }
@Override public void nextTuple() { Utils.sleep(5000); for (Values v : values.get(index)) { collector.emit(v); } index = (index + 1) % values.size(); }
public void nextTuple() { final Random rand = new Random(); final String word = words[rand.nextInt(words.length)]; this.collector.emit(new Values(word), UUID.randomUUID()); Thread.yield(); }
@Override public void nextTuple() { try { String line = null; while ((line = br.readLine()) != null) { collector.emit(Arrays.asList(line.split(","))); } } catch (IOException e) { closeReader(); e.printStackTrace(); } }
@Override public void nextTuple() { ConsumerBatchMessage<List<Object>> batchMessage = queue.poll(); if (batchMessage != null) { List<List<Object>> list = batchMessage.getData(); for (List<Object> data : list) { String messageId = UUID.randomUUID().toString(); cache.put(messageId, batchMessage); collector.emit(data, messageId); } } }
public void nextTuple() { final Random rand = new Random(); final String word = words[rand.nextInt(words.length)]; this.collector.emit(new Values(word), UUID.randomUUID()); Thread.yield(); }
@Override public void nextTuple() { if (queue.peek() != null) { List<Object> values = queue.poll(); if (values != null) { String id = UUID.randomUUID().toString(); emitted.put(id, values); collector.emit(values, id); } } }
@Override public void nextTuple() { if (numEmitted >= TestableTopology.MAX_SPOUT_EMITS) { //Stop emitting at a certain point, because log rolling breaks the tests. return; } //Sleep a bit to avoid hogging the CPU. TimeUtil.sleepMilliSec(1); collector.emit(new Values(WORDS.get((currentIndex++) % WORDS.size()))); ++numEmitted; }
@Override public void nextTuple() { Utils.sleep(100); collector.emit(new Values(rand.nextInt(1000), System.currentTimeMillis() - (24 * 60 * 60 * 1000), ++msgId), msgId); }
@Override public void nextTuple() { Utils.sleep(990); collector.emit(new Values(i, function.apply(i))); i++; }
public void nextTuple() { Utils.sleep(100); final String[] words = new String[]{"nathan", "mike", "jackson", "golda", "bertels"}; final Random rand = new Random(); final String word = words[rand.nextInt(words.length)]; _collector.emit(new Values(word)); }
private KafkaSpoutMessageId emitOne() { ArgumentCaptor<KafkaSpoutMessageId> messageId = ArgumentCaptor.forClass(KafkaSpoutMessageId.class); spout.nextTuple(); verify(collector).emit(anyString(), anyList(), messageId.capture()); clearInvocations(collector); return messageId.getValue(); }