Examples with Tuple org.apache.storm.tuple.Tuple used on opensource projects

Example 61 with Tuple

use of org.apache.storm.tuple.Tuple in project storm by apache.

the class ProcessorBoltTest method testEmitTs.

@Test
public void testEmitTs() throws Exception {
    Tuple tupleWithTs = Mockito.mock(Tuple.class);
    setUpMockTuples(tupleWithTs);
    Mockito.when(tupleWithTs.getLongByField("ts")).thenReturn(12345L);
    setUpProcessorBolt(new FilterProcessor(x -> true), "ts");
    bolt.execute(tupleWithTs);
    ArgumentCaptor<Collection> anchor = ArgumentCaptor.forClass(Collection.class);
    ArgumentCaptor<Values> values = ArgumentCaptor.forClass(Values.class);
    ArgumentCaptor<String> os = ArgumentCaptor.forClass(String.class);
    Mockito.verify(mockOutputCollector).emit(os.capture(), anchor.capture(), values.capture());
    assertEquals("outputstream", os.getValue());
    assertArrayEquals(new Object[] { tupleWithTs }, anchor.getValue().toArray());
    assertEquals(new Values(100, 12345L), values.getValue());
    Mockito.verify(mockOutputCollector, Mockito.times(1)).ack(tupleWithTs);
}

Example 62 with Tuple

use of org.apache.storm.tuple.Tuple in project storm by apache.

the class StatefulProcessorBoltTest method setUpMockTuples.

private void setUpMockTuples(Tuple... tuples) {
    for (Tuple tuple : tuples) {
        Mockito.when(tuple.size()).thenReturn(1);
        Mockito.when(tuple.getValue(0)).thenReturn(Pair.of("k", "v"));
        Mockito.when(tuple.getSourceComponent()).thenReturn("bolt0");
        Mockito.when(tuple.getSourceStreamId()).thenReturn("inputstream");
    }
}

Example 63 with Tuple

use of org.apache.storm.tuple.Tuple in project storm by apache.

the class StreamBuilderTest method testSpoutToBolt.

@Test
public void testSpoutToBolt() throws Exception {
    Stream<Tuple> stream = streamBuilder.newStream(newSpout(Utils.DEFAULT_STREAM_ID));
    stream.to(newBolt());
    StormTopology topology = streamBuilder.build();
    assertEquals(1, topology.get_spouts_size());
    assertEquals(1, topology.get_bolts_size());
    String spoutId = topology.get_spouts().keySet().iterator().next();
    Map<GlobalStreamId, Grouping> expected = new HashMap<>();
    expected.put(new GlobalStreamId(spoutId, "default"), Grouping.shuffle(new NullStruct()));
    assertEquals(expected, topology.get_bolts().values().iterator().next().get_common().get_inputs());
}

Example 64 with Tuple

use of org.apache.storm.tuple.Tuple in project storm by apache.

the class JoinBolt method doInnerJoin.

// inner join - core implementation
protected JoinAccumulator doInnerJoin(JoinAccumulator probe, Map<Object, ArrayList<Tuple>> buildInput, JoinInfo joinInfo, boolean finalJoin) {
    String[] probeKeyName = joinInfo.getOtherField();
    JoinAccumulator result = new JoinAccumulator();
    FieldSelector fieldSelector = new FieldSelector(joinInfo.other.getStreamName(), probeKeyName);
    for (ResultRecord rec : probe.getRecords()) {
        Object probeKey = rec.getField(fieldSelector);
        if (probeKey != null) {
            ArrayList<Tuple> matchingBuildRecs = buildInput.get(probeKey);
            if (matchingBuildRecs != null) {
                for (Tuple matchingRec : matchingBuildRecs) {
                    ResultRecord mergedRecord = new ResultRecord(rec, matchingRec, finalJoin);
                    result.insert(mergedRecord);
                }
            }
        }
    }
    return result;
}

Example 65 with Tuple

use of org.apache.storm.tuple.Tuple in project storm by apache.

the class JoinBolt method hashJoin.

protected JoinAccumulator hashJoin(List<Tuple> tuples) {
    clearHashedInputs();
    JoinAccumulator probe = new JoinAccumulator();
    // 1) Build phase - Segregate tuples in the Window into streams.
    //    First stream's tuples go into probe, rest into HashMaps in hashedInputs
    String firstStream = joinCriteria.keySet().iterator().next();
    for (Tuple tuple : tuples) {
        String streamId = getStreamSelector(tuple);
        if (!streamId.equals(firstStream)) {
            Object field = getJoinField(streamId, tuple);
            ArrayList<Tuple> recs = hashedInputs.get(streamId).get(field);
            if (recs == null) {
                recs = new ArrayList<Tuple>();
                hashedInputs.get(streamId).put(field, recs);
            }
            recs.add(tuple);
        } else {
            ResultRecord probeRecord = new ResultRecord(tuple, joinCriteria.size() == 1);
            // first stream's data goes into the probe
            probe.insert(probeRecord);
        }
    }
    // 2) Join the streams in order of streamJoinOrder
    int i = 0;
    for (String streamName : joinCriteria.keySet()) {
        boolean finalJoin = (i == joinCriteria.size() - 1);
        if (i > 0) {
            probe = doJoin(probe, hashedInputs.get(streamName), joinCriteria.get(streamName), finalJoin);
        }
        ++i;
    }
    return probe;
}