Java Code Examples for org.apache.storm.tuple.Tuple#getValue()

@Override
public void execute(TupleWindow inputWindow) {
    int sum = 0;
    List<Tuple> tuplesInWindow = inputWindow.get();
    LOG.debug("Events in current window: " + tuplesInWindow.size());
    if (tuplesInWindow.size() > 0) {
        /*
         * Since this is a tumbling window calculation,
         * we use all the tuples in the window to compute the avg.
         */
        for (Tuple tuple : tuplesInWindow) {
            sum += (int) tuple.getValue(0);
        }
        collector.emit(new Values(sum / tuplesInWindow.size()));
    }
}
 

@Override
public void execute(Tuple tuple) {
  try {
    Object event = tuple.getValue(0);
    logger.trace("Received event for processing {}", event);
    if (event instanceof AlarmDefinitionCreatedEvent) {
      handle((AlarmDefinitionCreatedEvent) event);
    } else if (event instanceof AlarmDefinitionUpdatedEvent) {
        handle((AlarmDefinitionUpdatedEvent) event);
    } else if (event instanceof AlarmDefinitionDeletedEvent) {
      handle((AlarmDefinitionDeletedEvent) event);
    } else if (event instanceof AlarmDeletedEvent) {
      handle((AlarmDeletedEvent) event);
    } else if (event instanceof AlarmUpdatedEvent) {
      handle((AlarmUpdatedEvent) event);
    }
  } catch (Exception e) {
    logger.error("Error processing tuple {}", tuple, e);
  } finally {
    collector.ack(tuple);
  }
}
 

@Override
public void execute(TupleWindow inputWindow) {
  int sum = 0;
  List<Tuple> tuplesInWindow = inputWindow.get();
  LOG.fine("Events in current window: " + tuplesInWindow.size());
  if (tuplesInWindow.size() > 0) {
            /*
            * Since this is a tumbling window calculation,
            * we use all the tuples in the window to compute the avg.
            */
    for (Tuple tuple : tuplesInWindow) {
      sum += (int) tuple.getValue(0);
    }
    collector.emit(new Values(sum / tuplesInWindow.size()));
  }
}
 

@Override
public void execute(Tuple tuple) {
  Object obj = tuple.getValue(0);
  long count = tuple.getLong(1);
  int source = tuple.getSourceTask();
  Map<Integer, Long> subCounts = counts.get(obj);
  if (subCounts == null) {
    subCounts = new HashMap<Integer, Long>();
    counts.put(obj, subCounts);
  }
  //Update the current count for this object
  subCounts.put(source, count);
  //Output the sum of all the known counts so for this key
  long sum = 0;
  for (Long val: subCounts.values()) {
    sum += val;
  }
  collector.emit(new Values(obj, sum));
}
 

@Override
public void convert(Object from, BytesArray to) {
    Assert.isTrue(from == null || from instanceof Tuple,
            String.format("Unexpected object type, expecting [%s], given [%s]", Tuple.class, from.getClass()));

    // handle common cases
    Tuple tuple = (Tuple) from;

    if (tuple == null || tuple.size() == 0) {
        to.bytes("{}");
        return;
    }
    Assert.isTrue(tuple.size() == 1, "When using JSON input, only one field is expected");

    super.convert(tuple.getValue(0), to);
}
 

/**
 * Handles a metadata message for a query.
 *
 * @param tuple The metadata tuple.
 * @return The created {@link Metadata}.
 */
protected Metadata onMeta(Tuple tuple) {
    String id = tuple.getString(TopologyConstants.ID_POSITION);
    Metadata metadata = (Metadata) tuple.getValue(TopologyConstants.METADATA_POSITION);
    if (metadata == null) {
        return null;
    }
    Metadata.Signal signal = metadata.getSignal();
    if (signal == Metadata.Signal.KILL || signal == Metadata.Signal.COMPLETE) {
        removeQuery(id);
        log.info("Received {} signal and killed query: {}", signal, id);
    }
    return metadata;
}
 

private JSONObject getMessage(Tuple tuple) {
  Object ret = tuple.getValueByField("message");
  if(ret != null) {
    ret = tuple.getValue(0);
  }
  if(ret != null) {
    return (JSONObject)((JSONObject)ret).clone();
  }
  else {
    return null;
  }
}
 

@Override
public void execute(Tuple tuple) {
    String id = tuple.getString(TopologyConstants.ID_POSITION);
    String result = tuple.getString(TopologyConstants.RESULT_POSITION);
    Metadata metadata = (Metadata) tuple.getValue(TopologyConstants.RESULT_METADATA_POSITION);
    publish(new PubSubMessage(id, result, metadata), tuple);
}
 

private void updateLatency(Tuple tuple) {
    if (metricsEnabled && tuple.size() > 1) {
        // Could use named fields instead
        Long timestamp = (Long) tuple.getValue(TopologyConstants.RECORD_TIMESTAMP_POSITION);
        averageLatency.update(System.currentTimeMillis() - timestamp);
    }
}
 

@Override
public void execute(Tuple tuple) {
    String id = tuple.getString(TopologyConstants.ID_POSITION);
    Metadata metadata = (Metadata) tuple.getValue(TopologyConstants.METADATA_POSITION);
    log.info("Looping back metadata with signal {} for {}", metadata.getSignal(), id);
    publish(new PubSubMessage(id, (byte[]) null, metadata), tuple);
}
 

@Override
public void execute(Tuple input) {
    Object requestId = input.getValue(0);
    String name = input.getString(1);

    //业务逻辑
    String result = "add user:" + name;
    this.outputCollector.emit(new Values(requestId, result));
}
 

public void execute(Tuple input) {

        dataToTopic = (String) input.getValue(0);
        ProducerRecord data = new ProducerRecord<String, String>(topic, this.dataToTopic);
        Future<RecordMetadata> recordMetadata = producer.send(data);
        _collector.ack(input);

    }
 

public void execute(Tuple input) {
    String ipRecord = (String) input.getValue(0);
    String[] columns = ipRecord.split(",");
    Values value = new Values(columns[0], columns[3], columns[4], columns[5], columns[6]);
    _collector.emit(value);
    _collector.ack(input);


}
 

@Override
public void execute(Tuple input) {
    if(alarmEPLManager.isUpdate()) {
        try {
            alarmEPLManager.getCountDownLatch().await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    String streamName = input.getValue(0).toString();
    Map<String, Object> record = (Map<String, Object>) input.getValue(1);
    alarmEPLManager.getEPRuntime().sendEvent(record, streamName);
    collector.ack(input);
}
 

@Override
public void execute(Tuple tuple, BasicOutputCollector basicOutputCollector) {
    //The input is a tuple
    Key currentKey = (Key) tuple.getValue(0);
    if (!slicingWindowOperatorMap.containsKey(currentKey)) {
        slicingWindowOperatorMap.put(currentKey, initWindowOperator());
    }
    SlicingWindowOperator<Value> slicingWindowOperator = slicingWindowOperatorMap.get(currentKey);
    //We only process the Value of a tuple
    slicingWindowOperator.processElement((Value) tuple.getValue(1), tuple.getLong(2));
    processWatermark(currentKey, tuple.getLong(2), basicOutputCollector);
}
 

@Override
public void execute(Tuple input) {
    Object requestId = input.getValue(0);
    String name = input.getString(1);

    //业务逻辑
    String result = "add user:" + name;
    this.outputCollector.emit(new Values(requestId, result));
}
 

@Override
void updateRankingsWithTuple(Tuple tuple) {
  Rankings rankingsToBeMerged = (Rankings) tuple.getValue(0);
  super.getRankings().updateWith(rankingsToBeMerged);
  super.getRankings().pruneZeroCounts();
}
 

@Override
public void execute(Tuple tuple) {
    List<Object> objects = (List<Object>) tuple.getValue(TopologyConstants.RECORD_POSITION);
    objects.forEach(this::convertAndEmit);
    collector.ack(tuple);
}
 

private void onRecord(Tuple tuple) {
    BulletRecord record = (BulletRecord) tuple.getValue(TopologyConstants.RECORD_POSITION);
    handleCategorizedQueries(manager.categorize(record));
}
 

private void countObjAndAck(Tuple tuple) {
    Object obj = tuple.getValue(0);
    counter.incrementCount(obj);
    collector.ack(tuple);
}