@Override public void cleanup() { _agg.cleanup(); }
private void execAggregatorAndStoreResult(int currentTriggerId, List<T> tupleEvents) { List<TridentTuple> resultTuples = getTridentTuples(tupleEvents); // run aggregator to compute the result AccumulatedTuplesCollector collector = new AccumulatedTuplesCollector(delegateCollector); Object state = aggregator.init(currentTriggerId, collector); for (TridentTuple resultTuple : resultTuples) { aggregator.aggregate(state, resultTuple, collector); } aggregator.complete(state, collector); List<List<Object>> resultantAggregatedValue = collector.values; ArrayList<WindowsStore.Entry> entries = Lists.newArrayList(new WindowsStore.Entry(windowTriggerCountId, currentTriggerId + 1), new WindowsStore.Entry(WindowTridentProcessor.generateWindowTriggerKey(windowTaskId, currentTriggerId), resultantAggregatedValue)); windowStore.putAll(entries); pendingTriggers.add(new TriggerResult(currentTriggerId, resultantAggregatedValue)); }
@Override public void complete(SingleEmitState val, TridentCollector collector) { if (!val.received) { if (this.myPartitionIndex == _batchToPartition.partitionIndex(val.batchId, this.totalPartitions)) { val.state = _agg.init(val.batchId, collector); _agg.complete(val.state, collector); } } else { _agg.complete(val.state, collector); } }
public void prepare(Map conf, TridentOperationContext context) { _inputFactories = new ProjectionFactory[_inputFields.length]; for (int i = 0; i < _inputFields.length; i++) { _inputFactories[i] = context.makeProjectionFactory(_inputFields[i]); _aggs[i].prepare(conf, new TridentOperationContext(context, _inputFactories[i])); } }
@Override public void complete(Object[] arr, TridentCollector collector) { Map<List, Object> val = (Map) arr[1]; GroupCollector groupColl = (GroupCollector) arr[0]; for (Entry<List, Object> e : val.entrySet()) { groupColl.currGroup = e.getKey(); _agg.complete(e.getValue(), groupColl); } }
public void aggregate(ChainedResult val, TridentTuple tuple, TridentCollector collector) { val.setFollowThroughCollector(collector); for (int i = 0; i < _aggs.length; i++) { TridentTuple projected = _inputFactories[i].create((TridentTupleView) tuple); _aggs[i].aggregate(val.objs[i], projected, val.collectors[i]); } }
public ChainedResult init(Object batchId, TridentCollector collector) { ChainedResult initted = new ChainedResult(collector, _aggs.length); for (int i = 0; i < _aggs.length; i++) { initted.objs[i] = _aggs[i].init(batchId, initted.collectors[i]); } return initted; }
@Override public void prepare(Map conf, TridentOperationContext context) { _agg.prepare(conf, context); this.myPartitionIndex = context.getPartitionIndex(); this.totalPartitions = context.numPartitions(); }
@Override public void complete(SingleEmitState val, TridentCollector collector) { if(!val.received) { if(this.myPartitionIndex == _batchToPartition.partitionIndex(val.batchId, this.totalPartitions)) { val.state = _agg.init(val.batchId, collector); _agg.complete(val.state, collector); } } else { _agg.complete(val.state, collector); } }
@Override public void finishBatch(ProcessorContext processorContext) { _collector.setContext(processorContext); _agg.complete(processorContext.state[_context.getStateIndex()], _collector); }
@Override public void execute(ProcessorContext processorContext, String streamId, TridentTuple tuple) { _collector.setContext(processorContext); _agg.aggregate(processorContext.state[_context.getStateIndex()], _projection.create(tuple), _collector); }
@Override public void startBatch(ProcessorContext processorContext) { _collector.setContext(processorContext); processorContext.state[_context.getStateIndex()] = _agg.init(processorContext.batchId, _collector); }
@Override public void aggregate(Object[] arr, TridentTuple tuple, TridentCollector collector) { GroupCollector groupColl = (GroupCollector) arr[0]; Map<List, Object> val = (Map) arr[1]; TridentTuple group = _groupFactory.create((TridentTupleView) tuple); TridentTuple input = _inputFactory.create((TridentTupleView) tuple); Object curr; if (!val.containsKey(group)) { curr = _agg.init(arr[2], groupColl); val.put((List) group, curr); } else { curr = val.get(group); } groupColl.currGroup = group; _agg.aggregate(curr, input, groupColl); }
private void execAggregatorAndStoreResult(int currentTriggerId, List<T> tupleEvents) { List<TridentTuple> resultTuples = getTridentTuples(tupleEvents); // run aggregator to compute the result AccumulatedTuplesCollector collector = new AccumulatedTuplesCollector(delegateCollector); Object state = aggregator.init(currentTriggerId, collector); for (TridentTuple resultTuple : resultTuples) { aggregator.aggregate(state, resultTuple, collector); } aggregator.complete(state, collector); List<List<Object>> resultantAggregatedValue = collector.values; ArrayList<WindowsStore.Entry> entries = Lists.newArrayList(new WindowsStore.Entry(windowTriggerCountId, currentTriggerId + 1), new WindowsStore.Entry(WindowTridentProcessor.generateWindowTriggerKey(windowTaskId, currentTriggerId), resultantAggregatedValue)); windowStore.putAll(entries); pendingTriggers.add(new TriggerResult(currentTriggerId, resultantAggregatedValue)); }
@Override public void prepare(Map conf, TopologyContext context, TridentContext tridentContext) { List<Factory> parents = tridentContext.getParentTupleFactories(); if (parents.size() != 1) { throw new RuntimeException("Aggregate operation can only have one parent"); } _context = tridentContext; _collector = new FreshCollector(tridentContext); _projection = new ProjectionFactory(parents.get(0), _inputFields); _agg.prepare(conf, new TridentOperationContext(context, _projection)); }
@Override public void cleanup() { _agg.cleanup(); }
@Override public void complete(SingleEmitState val, TridentCollector collector) { if (!val.received) { if (this.myPartitionIndex == _batchToPartition.partitionIndex(val.batchId, this.totalPartitions)) { val.state = _agg.init(val.batchId, collector); _agg.complete(val.state, collector); } } else { _agg.complete(val.state, collector); } }
public void complete(ChainedResult val, TridentCollector collector) { val.setFollowThroughCollector(collector); for (int i = 0; i < _aggs.length; i++) { _aggs[i].complete(val.objs[i], val.collectors[i]); } if (_aggs.length > 1) { // otherwise, tuples were emitted directly int[] indices = new int[val.collectors.length]; for (int i = 0; i < indices.length; i++) { indices[i] = 0; } boolean keepGoing = true; // emit cross-join of all emitted tuples while (keepGoing) { List[] combined = new List[_aggs.length]; for (int i = 0; i < _aggs.length; i++) { CaptureCollector capturer = (CaptureCollector) val.collectors[i]; combined[i] = capturer.captured.get(indices[i]); } collector.emit(_fact.create(combined)); keepGoing = increment(val.collectors, indices, indices.length - 1); } } }
@Override public void aggregate(Object val, TridentTuple tuple, TridentCollector collector) { try { getDelegate().aggregate(val, tuple, collector); } catch (FrameworkException ex) { LOG.error("aggregate() not delegated due to a Framework exception: ", ex); } catch (Exception ex) { LOG.error("aggregate() threw an uncaught exception: ", ex); } }