public void execute(Tuple tuple, BasicOutputCollector collector) {
String args = tuple.getString(0);
String returnInfo = tuple.getString(1);
long requestId = rand.nextLong();
collector.emit(ARGS_STREAM, new Values(requestId, args));
collector.emit(RETURN_STREAM, new Values(requestId, returnInfo));
collector.emit(ID_STREAM, new Values(requestId));
}
public void execute(Tuple input, BasicOutputCollector collector) {
String line = input.getString(0);
String[] triple = StringUtils.split(line, delim);
if (triple.length != 3) throw new RuntimeException("Line is not a triple: " + input);
// make sure that parts of the filter that are not variables match the respective parts in the
// input triple
// also make sure repeated variables receive the same value (ie ?a_foo_?a shouldn't accept
// A_foo_B)
Map<String, String> bindings = new TreeMap<String, String>();
for (int i = 0; i < 3; i++)
if (filter[i].startsWith(varIndicator)) {
if (bindings.containsKey(filter[i])) {
if (!bindings.get(filter[i]).equals(triple[i])) {
return;
}
} else {
bindings.put(filter[i], triple[i]);
}
} else {
if (!triple[i].equals(filter[i])) {
return;
}
}
collector.emit(new Values(bindings));
}
@Override
public void hanleData(
String msisdnId,
String sessionId,
Long currentTime,
double realInfoFee,
String channelId,
String productId,
String rules,
String provinceId,
int orderType,
String bookId) {
collector.emit(
StreamId.ABNORMALDATASTREAM.name(),
new Values(
msisdnId,
sessionId,
currentTime,
realInfoFee,
channelId,
productId,
provinceId,
orderType,
bookId,
rules));
}
@Override
public void execute(Tuple input, BasicOutputCollector collector) {
//
String track = input.getString(0);
if (track != null) {
String arr[] = track.split("\n");
List<TrackerVo> list = new ArrayList<TrackerVo>();
for (String s : arr) {
String cols[] = s.split("\\t");
// System.out.println("cols:"+cols.length);
// 过滤一：列小于30的丢弃
if (cols.length < 30) {
continue;
}
// 过滤二：过滤来自百度的爬虫数据
if (s.contains("http://www.baidu.com/search/spider.html")) {
continue;
}
TrackerVo tracker = new TrackerVo(s);
// 过滤三：过滤button_position 不为空的
if (tracker.getButton_position() != null
&& !"null".equals(tracker.getButton_position())
&& tracker.getButton_position().length() > 1) {
// System.out.println("button:"+tracker.getButton_position());
continue;
}
list.add(tracker);
// System.out.println(arr.length+"------:"+cols.length+"--"+tracker.getId());
}
if (list.size() > 0) {
collector.emit(new Values(list));
}
}
}
@Override
public void execute(Tuple input, BasicOutputCollector collector) {
String text = input.getString(0);
System.out.println("text: " + text);
for (String word : text.split(" ")) {
collector.emit(new Values(word));
}
}
@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));
}
public void execute(Tuple tuple, BasicOutputCollector collector) {
tpsCounter.count();
Long tupleId = tuple.getLong(0);
Pair pair = (Pair) tuple.getValue(1);
sum.addAndGet(pair.getValue());
collector.emit(new Values(tupleId, pair));
}
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));
System.err.println(word + "----------------------" + count);
}
@Override
public void execute(Tuple tuple, BasicOutputCollector collector) {
Object id = tuple.getValue(0);
String tweeter = tuple.getString(1);
List<String> followers = FOLLOWERS_DB.get(tweeter);
if (followers != null) {
for (String follower : followers) {
collector.emit(new Values(id, follower));
}
}
}
@Override
public void execute(Tuple tuple, BasicOutputCollector collector) {
Object id = tuple.getValue(0);
String url = tuple.getString(1);
List<String> tweeters = TWEETERS_DB.get(url);
if (tweeters != null) {
for (String tweeter : tweeters) {
collector.emit(new Values(id, tweeter));
}
}
}
@Override
public void execute(Tuple tuple, BasicOutputCollector collector) {
String word = tuple.getString(0);
if (log.isDebugEnabled()) {
log.debug("Received event: " + tuple.toString());
}
eventsReceived = true;
Integer count = counts.get(word);
if (count == null) count = 0;
count++;
eventCount++;
collector.emit(new Values(word, count));
}
public void execute(Tuple input, BasicOutputCollector collector) {
try {
String msg = input.getString(0);
System.out.println(msg + "-------------------");
if (msg != null) {
String[] s = msg.split(" ");
for (String string : s) {
collector.emit(new Values(string));
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void execute(Tuple tuple, BasicOutputCollector collector) {
TransactionAttempt attempt = (TransactionAttempt) tuple.getValue(0);
if (tuple.getSourceStreamId().equals(MasterBatchCoordinator.SUCCESS_STREAM_ID)) {
_state.cleanupBefore(attempt.getTransactionId());
_coord.success(attempt.getTransactionId());
} else {
long txid = attempt.getTransactionId();
Object prevMeta = _state.getPreviousState(txid);
Object meta = _coord.initializeTransaction(txid, prevMeta, _state.getState(txid));
_state.overrideState(txid, meta);
collector.emit(MasterBatchCoordinator.BATCH_STREAM_ID, new Values(attempt, meta));
}
}
@Override
public void execute(Tuple input, BasicOutputCollector collector) {
String address = input.getStringByField("address");
Long time = input.getLongByField("time");
GeocoderRequest request =
new GeocoderRequestBuilder().setAddress(address).setLanguage("en").getGeocoderRequest();
GeocodeResponse response = geocoder.geocode(request);
GeocoderStatus status = response.getStatus();
if (GeocoderStatus.OK.equals(status)) {
GeocoderResult firstResult = response.getResults().get(0);
LatLng latLng = firstResult.getGeometry().getLocation();
Long timeInterval = time / (15 * 1000);
String city = extractCity(firstResult);
collector.emit(new Values(timeInterval, latLng, city));
}
}
@Override
public void execute(Tuple arg0, BasicOutputCollector collector) {
/*
*
* Msg Receiving format from kafka
*
* [{ "timestamp":1407394935908, "publisher":"publisher_0",
* "advertiser":"advertiser_2" ,"website":"website_7689.com",
* "geo":"MI", "bid":0.14403514698631104, "cookie":"cookie_7447"}]
*/
String inputValue = arg0.getString(0).toString();
ObjectNode obj2 = null;
try {
obj2 = mapper.readValue(inputValue, ObjectNode.class);
} catch (IOException e) {
}
// System.out.println(" obj2-------> "+obj2);
Values val = new Values();
String geo = obj2.get("geo").asText();
val.add(geo);
String pub = obj2.get("publisher").asText();
val.add(pub);
val.add(obj2.get("advertiser").asText());
val.add(obj2.get("website").asText());
double bid = obj2.get("bid").asDouble();
val.add(new Double(bid).toString());
val.add(obj2.get("cookie").asText());
String timeStampStr = obj2.get("timestamp").asText();
// System.out.println(" timeStamp---str------> "+timeStampStr);
long timeStamp = Long.parseLong(timeStampStr);
// System.out.println(" timeStamp---------> "+timeStamp);
SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss aa");
String fullTime = DATE_FORMAT.format(timeStamp);
val.add(fullTime);
val.add(geo + pub + getDateUptoMinute(fullTime));
// System.out.println(" val ---------> "+val);
collector.emit(val);
}
@Override
public void processSlide(BasicOutputCollector collector) {
try {
T reduceValue = null;
// TODO: implement window data structure with tree, no need to for loop
for (T t : reduceList) {
if (null == reduceValue) {
reduceValue = t;
} else {
reduceValue = fun.reduce(reduceValue, t);
}
}
collector.emit(new Values(slideIndexInBuffer, reduceValue));
// clear data
reduceList.set((slideInWindow + 1) % WINDOW_SIZE, null);
} catch (Exception e) {
logger.error(e.toString());
}
}
@Override
public void execute(Tuple input, BasicOutputCollector collector) {
String author = input.getString(0);
double[] features = (double[]) input.getValue(1);
double[] posteriorProbability = (double[]) input.getValue(2);
double[] Nk = new double[features.length];
for (int i = 0; i < Nk.length; i++) {
Nk[i] += posteriorProbability[i];
}
if (!this.features.containsKey(author)
&& !this.posteriorProbability.containsKey(author)
&& !this.Nk.containsKey(author)) {
collector.emit(new Values(author, features, posteriorProbability, Nk));
this.features.put(author, features);
this.posteriorProbability.put(author, posteriorProbability);
this.Nk.put(author, Nk);
}
}
/**
* Function will examine the origin of the message in order to determine whether or not the
* message needs to be formatted and published to the Item Master Bolt, which would send item
* updates to the Item Master first, else push information to the next Bolt which will then
* process the information and push to multiple bolts which require the item update for their
* local copy of item.
*/
public void execute(Tuple input, BasicOutputCollector collector) {
String eventOrigin = input.getString(0);
String eventObject = input.getString(1);
String correlationId = input.getString(2);
logger.info("Item Event Notification Orgin is: " + eventOrigin);
if (!eventOrigin.equals(MASTER_ORIGIN)) {
logger.info(
"["
+ correlationId
+ "] - "
+ "Process is needing to send a notification to Item Master for master update ....");
logger.info("[" + correlationId + "] - " + "Event Object: " + eventObject);
/*
* Another Bolt will end up perform the transformation and then
* another Bolt will perform any additional calls to the Master Item
* Micro Service.
*/
collector.emit(new Values(correlationId, eventObject));
}
}
@Override
public void execute(Tuple input, BasicOutputCollector collector) {
for (String split : input.getString(0).split(" ")) {
collector.emit(Lists.<Object>newArrayList(split));
}
}
@Override
public void execute(Tuple tuple, BasicOutputCollector outputCollector) {
String commit = tuple.getStringByField("commit");
String[] parts = commit.split(" ");
outputCollector.emit(new Values(parts[1]));
}
private void emitRankings(BasicOutputCollector collector) {
collector.emit(new Values(rankings.copy()));
getLogger().debug("Rankings: " + rankings);
}
@Override
public void execute(Tuple tuple, BasicOutputCollector collector) {
collector.emit(new Values(tuple.getValue(0)));
}
