@Override public List<Values> toTuple(ITuple input, Object value) { List<Values> values = new ArrayList<Values>(); values.add(new Values(getKeyFromTuple(input), value)); return values; }
private static void generateGenderData(FeederSpout genderSpout) { for (int i = 0; i < 10; i++) { String gender; if (i % 2 == 0) { gender = "male"; } else { gender = "female"; } genderSpout.feed(new Values(i, gender)); } } }
@Override public Values execute(TridentTuple input) { return new Values(input.getStringByField("word").toUpperCase()); } };
@Override public List<Values> toTuple(ITuple input, Object value) { String member = getKeyFromTuple(input); List<Values> values = Lists.newArrayList(); values.add(new Values(member, value)); return values; }
@Override public Values toValues(T value) { byte[] serialized = serializer.serialize(value); return new Values(ByteBuffer.wrap(serialized)); }
@Override public void execute(TridentTuple tuple, Object result, TridentCollector collector) { collector.emit(new Values(result)); } }
@Override public void execute(Tuple tuple, BasicOutputCollector collector) { String word = tuple.getString(0); Integer count = counts.get(word); if (count == null) { count = 0; } count++; counts.put(word, count); collector.emit(new Values(word, count)); }
@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; }
public EmittingProcessorContext(ProcessorNode processorNode, OutputCollector collector, String outputStreamId) { this.processorNode = processorNode; this.outputStreamId = outputStreamId; this.collector = collector; outputFields = processorNode.getOutputFields(); punctuation = new Values(PUNCTUATION); punctuationStreamId = StreamUtil.getPunctuationStream(outputStreamId); }
@Override public void updateState(Snapshottable state, List<TridentTuple> tuples, TridentCollector collector) { if (tuples.size() != 1) { throw new IllegalArgumentException("Combiner state updater should receive a single tuple. Received: " + tuples.toString()); } Object newVal = state.update(new CombinerValueUpdater(_agg, tuples.get(0).getValue(0))); collector.emit(new Values(newVal)); }
@Override public void execute(TridentTuple tuple, TridentCollector collector) { List l = (List) tuple.getValue(0); if (l != null) { for (Object o : l) { collector.emit(new Values(o)); } } }
/** * Forwards the checkpoint tuple downstream. * * @param checkpointTuple the checkpoint tuple * @param action the action (prepare, commit, rollback or initstate) * @param txid the transaction id. */ protected void handleCheckpoint(Tuple checkpointTuple, Action action, long txid) { collector.emit(CHECKPOINT_STREAM_ID, checkpointTuple, new Values(txid, action)); collector.ack(checkpointTuple); }
public void execute(Tuple input) { Integer sourceId = input.getInteger(0); Long eventId = input.getLong(1); Long recentEvent = recentEventId.get(sourceId); if (null != recentEvent && eventId <= recentEvent) { String error = "Error: event id is not in strict order! event source Id: " + sourceId + ", last event Id: " + recentEvent + ", current event Id: " + eventId; _collector.emit(input, new Values(error)); } recentEventId.put(sourceId, eventId); _collector.ack(input); }
@Override public Values apply(Values input) { Context calciteContext = new StormContext(dataContext); calciteContext.values = input.toArray(); projectionInstance.execute(calciteContext, outputValues); return new Values(outputValues); } }
@Override public IRichSpout getProducer() { List<Values> records = new ArrayList<>(); for (int i = 0; i < 5; ++i) { records.add(new Values(i, 0, "x", "y", 5 - i, i * 10)); } Fields outputFields = new Fields("ID", "GRPID", "NAME", "ADDR", "AGE", "SCORE"); return new MockSpout(records, outputFields); }
private Tuple generateTestTuple(Long key, String value) { TopologyBuilder builder = new TopologyBuilder(); GeneralTopologyContext topologyContext = new GeneralTopologyContext(builder.createTopology(), new Config(), new HashMap<>(), new HashMap<>(), new HashMap<>(), "") { @Override public Fields getComponentOutputFields(String componentId, String streamId) { return new Fields("key", "value"); } }; return new TupleImpl(topologyContext, new Values(key, value), topologyContext.getComponentId(1), 1, ""); }
private Tuple generateTestTuple(Object id, Object msg, Object city, Object state) { TopologyBuilder builder = new TopologyBuilder(); GeneralTopologyContext topologyContext = new GeneralTopologyContext(builder.createTopology(), new Config(), new HashMap<>(), new HashMap<>(), new HashMap<>(), "") { @Override public Fields getComponentOutputFields(String componentId, String streamId) { return new Fields("id", "msg", "city", "state"); } }; return new TupleImpl(topologyContext, new Values(id, msg, city, state), topologyContext.getComponentId(1), 1, ""); }
@Override public void execute(Tuple tuple) { String orig = tuple.getString(0); String ret = getFromCache(orig); if (ret == null) { ret = orig + "!!!"; addToCache(orig, ret); } _collector.emit(tuple, new Values(ret)); _collector.ack(tuple); }
@Test public void testTestTupleWithMkTupleParam() throws Exception { MkTupleParam mkTupleParam = new MkTupleParam(); mkTupleParam.setStream("test-stream"); mkTupleParam.setComponent("test-component"); mkTupleParam.setFields("fname", "lname"); Tuple tuple = Testing.testTuple(new Values("james", "bond"), mkTupleParam); assertThat(tuple.getValues(), is(new Values("james", "bond"))); assertThat(tuple.getSourceStreamId(), is("test-stream")); assertThat(tuple.getFields().toList(), is(Arrays.asList("fname", "lname"))); assertThat(tuple.getSourceComponent(), is("test-component")); }