}; //ascii 58--64 + misc.
//Process a tuple from the stream
public void Execute(SCPTuple tuple)
{
Context.Logger.Info("Execute enter");
try
{
var words = tuple.GetString(0).ToLower().Split(_punctuationChars);
int sentimentScore = CalcSentimentScore(words);
var word_pairs = words.Take(words.Length - 1)
.Select((word, idx) => string.Format("{0} {1}", word, words[idx + 1]));
var all_words = words.Concat(word_pairs).ToList();
// Emit all index entries for counting and writing downstream
foreach (var word in all_words)
{
this.ctx.Emit(new Values(word,
tuple.GetLong(1),
tuple.GetString(2),
tuple.GetString(3),
tuple.GetString(4),
sentimentScore));
}
}
catch (Exception ex)
{
Context.Logger.Error("SentimentIndexerBolt Exception: " + ex.Message + "\nStackTrace: \n" + ex.StackTrace);
}
Context.Logger.Info("Execute exit");
}
':', ';', '<', '=', '>', '?', '@', '[', ']', '^', '_', '`', '{', '|', '}', '~' }; //ascii 58--64 + misc.
//Process a tuple from the stream
public void Execute(SCPTuple tuple)
{
Context.Logger.Info("Execute enter");
try
{
var words = tuple.GetString(0).ToLower().Split(_punctuationChars);
int sentimentScore = CalcSentimentScore(words);
var word_pairs = words.Take(words.Length - 1)
.Select((word, idx) => string.Format("{0} {1}", word, words[idx + 1]));
var all_words = words.Concat(word_pairs).ToList();
// Emit all index entries for counting and writing downstream
foreach (var word in all_words)
{
this.ctx.Emit(new Values(word,
tuple.GetLong(1),
tuple.GetString(2),
tuple.GetString(3),
tuple.GetString(4),
sentimentScore));
}
}
catch (Exception ex)
{
Context.Logger.Error("SentimentIndexerBolt Exception: " + ex.Message + "\nStackTrace: \n" + ex.StackTrace);
}
Context.Logger.Info("Execute exit");
}
/// <summary>
/// The Execute() function will be called, when a new tuple is available.
/// </summary>
/// <param name="tuple"></param>
public void Execute(SCPTuple tuple)
{
Context.Logger.Info("Execute enter");
string streamId = tuple.GetSourceStreamId();
switch (streamId)
{
case SentenceGenerator.STREAM_ID:
{
string sentence = tuple.GetString(0);
Context.Logger.Info("sentence: {0}", sentence);
}
break;
case PersonGenerator.STREAM_ID:
{
Person person = (Person)tuple.GetValue(0);
Context.Logger.Info("person: {0}", person.ToString());
}
break;
default:
Context.Logger.Info("Get unknown tuple from unknown stream.");
break;
}
Context.Logger.Info("Execute exit");
}
public void Execute(SCPTuple tuple)
{
string json = tuple.GetString(0);
var node = JObject.Parse(json);
var temp = node.GetValue("temp");
JToken tempVal;
if (node.TryGetValue("temp", out tempVal)) //assume must be a temperature reading
{
Context.Logger.Info("temp:" + temp.Value <double>());
JToken createDate = node.GetValue("createDate");
JToken deviceId = node.GetValue("deviceId");
_context.Emit(Constants.DEFAULT_STREAM_ID,
new List <SCPTuple>()
{
tuple
},
new List <object> {
tempVal.Value <double>(), createDate.Value <string>(), deviceId.Value <string>()
});
}
_context.Ack(tuple);
}
/// <summary>
/// The Execute() function will be called, when a new tuple is available.
/// </summary>
/// <param name="tuple"></param>
public void Execute(SCPTuple tuple)
{
ctx.Ack(tuple);
//Log tuple content
Context.Logger.Warn(tuple.GetString(0));
}
/// <summary>
/// The Execute() function will be called, when a new tuple is available.
/// </summary>
/// <param name="tuple"></param>
public void Execute(SCPTuple tuple)
{
Context.Logger.Info("Execute enter");
string word = tuple.GetString(0);
int count = counts.ContainsKey(word) ? counts[word] : 0;
count++;
counts[word] = count;
Context.Logger.Info("Emit: {0}, count: {1}", word, count);
this.ctx.Emit(Constants.DEFAULT_STREAM_ID, new List <SCPTuple> {
tuple
}, new Values(word, count));
if (enableAck)
{
Context.Logger.Info("Ack tuple: tupleId: {0}", tuple.GetTupleId());
this.ctx.Ack(tuple);
}
// log some info to out file for bvt test validataion
if (taskIndex == 0) // For component with multiple parallism, only one of them need to log info
{
string fileName = @"..\..\..\..\..\HelloWorldOutput" + Process.GetCurrentProcess().Id + ".txt";
FileStream fs = new FileStream(fileName, FileMode.Append);
using (StreamWriter writer = new StreamWriter(fs))
{
writer.WriteLine("word: {0}, count: {1}", word, count);
}
}
Context.Logger.Info("Execute exit");
}
/// <summary>
/// The Execute() function will be called, when a new tuple is available.
/// </summary>
/// <param name="tuple"></param>
public void Execute(SCPTuple tuple)
{
Context.Logger.Info("Execute enter");
string sentence = tuple.GetString(0);
foreach (string word in sentence.Split(' '))
{
Context.Logger.Info("Emit: {0}", word);
this.ctx.Emit(Constants.DEFAULT_STREAM_ID, new List <SCPTuple> {
tuple
}, new Values(word, word[0]));
}
if (enableAck)
{
if (Sample(50)) // this is to demo how to fail tuple. We do it randomly
{
Context.Logger.Info("fail tuple: tupleId: {0}", tuple.GetTupleId());
this.ctx.Fail(tuple);
}
else
{
if (Sample(50)) // this is to simulate timeout
{
Context.Logger.Info("sleep {0} seconds", msgTimeoutSecs + 1);
Thread.Sleep((msgTimeoutSecs + 1) * 1000);
}
Context.Logger.Info("Ack tuple: tupleId: {0}", tuple.GetTupleId());
this.ctx.Ack(tuple);
}
}
Context.Logger.Info("Execute exit");
}
/// <summary>
/// The Execute() function will be called, when a new tuple is available.
/// </summary>
/// <param name="tuple"></param>
public void Execute(SCPTuple tuple)
{
Context.Logger.Info("Execute enter");
string word = tuple.GetString(0);
int count = counts.ContainsKey(word) ? counts[word] : 0;
count++;
counts[word] = count;
Context.Logger.Info("Emit: {0}, count: {1}", word, count);
this.ctx.Emit(Constants.DEFAULT_STREAM_ID, new List<SCPTuple> { tuple }, new Values(word, count));
if (enableAck)
{
Context.Logger.Info("Ack tuple: tupleId: {0}", tuple.GetTupleId());
this.ctx.Ack(tuple);
}
// log some info to out file for bvt test validataion
if (taskIndex == 0) // For component with multiple parallism, only one of them need to log info
{
string fileName = @"..\..\..\..\..\HelloWorldOutput" + Process.GetCurrentProcess().Id + ".txt";
FileStream fs = new FileStream(fileName, FileMode.Append);
using (StreamWriter writer = new StreamWriter(fs))
{
writer.WriteLine("word: {0}, count: {1}", word, count);
}
}
Context.Logger.Info("Execute exit");
}
/// <summary>
/// The Execute() function will be called, when a new tuple is available.
/// </summary>
/// <param name="tuple"></param>
public void Execute(SCPTuple tuple)
{
Context.Logger.Info("Execute enter");
string streamId = tuple.GetSourceStreamId();
switch (streamId)
{
case SentenceGenerator.STREAM_ID:
{
string sentence = tuple.GetString(0);
Context.Logger.Info("sentence: {0}", sentence);
}
break;
case PersonGenerator.STREAM_ID:
{
Person person = (Person)tuple.GetValue(0);
Context.Logger.Info("person: {0}", person.ToString());
}
break;
default:
Context.Logger.Info("Get unknown tuple from unknown stream.");
break;
}
Context.Logger.Info("Execute exit");
}
/// <summary>
/// The Execute() function will be called, when a new tuple is available.
/// </summary>
/// <param name="tuple"></param>
public void Execute(SCPTuple tuple)
{
Context.Logger.Info("Execute enter");
string sentence = tuple.GetString(0);
foreach (string word in sentence.Split(' '))
{
Context.Logger.Info("Emit: {0}", word);
this.ctx.Emit(Constants.DEFAULT_STREAM_ID, new List<SCPTuple> { tuple }, new Values(word, word[0]));
}
if (enableAck)
{
if (Sample(50)) // this is to demo how to fail tuple. We do it randomly
{
Context.Logger.Info("fail tuple: tupleId: {0}", tuple.GetTupleId());
this.ctx.Fail(tuple);
}
else
{
if (Sample(50)) // this is to simulate timeout
{
Context.Logger.Info("sleep {0} seconds", msgTimeoutSecs+1);
Thread.Sleep((msgTimeoutSecs + 1) * 1000);
}
Context.Logger.Info("Ack tuple: tupleId: {0}", tuple.GetTupleId());
this.ctx.Ack(tuple);
}
}
Context.Logger.Info("Execute exit");
}
/// <summary>
/// The Execute() function will be called, when a new tuple is available.
/// </summary>
/// <param name="tuple"></param>
public void Execute(SCPTuple tuple)
{
if (tuple.GetSourceStreamId().Equals(Constants.SYSTEM_TICK_STREAM_ID))
{
Context.Logger.Info("Aggregates tuple values..");
foreach (var key in _data.Keys)
{
var avg = _data[key].Average();
this.ctx.Emit(Constants.DEFAULT_STREAM_ID, tuplesToAck, new Values(key, avg));
}
Context.Logger.Info("acking the batch: " + tuplesToAck.Count);
foreach (var t in tuplesToAck)
{
this.ctx.Ack(t);
}
_data.Clear();
tuplesToAck.Clear();
}
else
{
var sensorName = tuple.GetString(0);
var value = tuple.GetDouble(1);
if (!_data.ContainsKey(tuple.GetString(0)))
{
_data.Add(sensorName, new List <double>()
{
value
});
}
else
{
_data[sensorName].Add(value);
}
tuplesToAck.Enqueue(tuple);
}
}
public void Execute(SCPTuple tuple)
{
PowerBIClient.Do(api =>
{
var isObjectInsert = api.Insert(datasetId, new Data.WordCount
{
Word = tuple.GetString(0),
Count = tuple.GetInteger(1)
});
});
}
// Called when a new tuple is available
public void Execute(SCPTuple tuple)
{
// Get the sentance from the tuple
string sentence = tuple.GetString(0);
// Split at space characters
foreach (string word in sentence.Split(' '))
{
//Emit each word
this.ctx.Emit(new Values(word));
}
}
/// <summary>
/// The Execute() function is called, when a new tuple is available.
/// </summary>
/// <param name="tuple"></param>
public void Execute(SCPTuple tuple)
{
//Get the string data from the tuple
string eventValue = tuple.GetString(0);
if (eventValue != null)
{
//Log the data
Context.Logger.Info("Received data: " + eventValue);
//ACK the tuple so the spout knows it was processed
//If we don't ACK, the EventHubSpout can stop receiving; it expects ACKs
this.ctx.Ack(tuple);
}
}
public void Execute(SCPTuple tuple)
{
try
{
double tempReading = tuple.GetDouble(0);
String createDate = tuple.GetString(1);
String deviceId = tuple.GetString(2);
if (tempReading > _maxAlertTemp)
{
_context.Emit(new Values(
"reading above bounds",
tempReading,
createDate,
deviceId
));
Context.Logger.Info("Emitting above bounds: " + tempReading);
}
else if (tempReading < _minAlertTemp)
{
_context.Emit(new Values(
"reading below bounds",
tempReading,
createDate,
deviceId
));
Context.Logger.Info("Emitting below bounds: " + tempReading);
}
_context.Ack(tuple);
}
catch (Exception ex)
{
Context.Logger.Error(ex.ToString());
}
}
public void Execute(SCPTuple tuple)
{
Context.Logger.Info("Execute enter");
string sentence = tuple.GetString(0); // grab the first (and only field) from the tuple
// tokenize it into words
foreach (string word in sentence.Split(' '))
{
// log each word and emit it into the output stream
Context.Logger.Info("Emit: {0}", word);
ctx.Emit(new Values(word));
}
Context.Logger.Info("Execute exit");
}
// Called when a new tuple is available
public void Execute(SCPTuple tuple)
{
Context.Logger.Info("Execute enter");
// Get the sentence from the tuple
string sentence = tuple.GetString(0);
// Split at space characters
foreach (string word in sentence.Split(' '))
{
Context.Logger.Info("Emit: {0}", word);
//Emit each word
this.ctx.Emit(new Values(word));
}
Context.Logger.Info("Execute exit");
}
// Called when a new tuple is available
public void Execute(SCPTuple tuple)
{
// Get the word from the tuple
string word = tuple.GetString(0);
// Do we already have an entry for the word in the dictionary?
// If no, create one with a count of 0
int count = counts.ContainsKey(word) ? counts[word] : 0;
// Increment the count
count++;
// Update the count in the dictionary
counts[word] = count;
// Emit the word and count information
this.ctx.Emit(Constants.DEFAULT_STREAM_ID, new List <SCPTuple> {
tuple
}, new Values(word, count));
}
public void Execute(SCPTuple tuple)
{
Context.Logger.Info("Execute enter");
string word = tuple.GetString(0); // grab the first (and only field) from the tuple
// figure out if the word has already been encountered or not
int count = counts.ContainsKey(word) ? counts[word] : 0;
count++; // update counter
counts[word] = count; // update the map
// log the running count for the word and emit those two fields into the output stream
Context.Logger.Info("Emit: {0}, count: {1}", word, count);
this.ctx.Emit(Constants.DEFAULT_STREAM_ID, new List <SCPTuple> {
tuple
}, new Values(word, count));
Context.Logger.Info("Execute exit");
}
// Called when a new tuple is available
public void Execute(SCPTuple tuple)
{
Context.Logger.Info("Execute enter");
// Get the word from the tuple
string word = tuple.GetString(0);
// Do we already have an entry for the word in the dictionary?
// If no, create one with a count of 0
int count = counts.ContainsKey(word) ? counts[word] : 0;
// Increment the count
count++;
// Update the count in the dictionary
counts[word] = count;
Context.Logger.Info("Emit: {0}, count: {1}", word, count);
// Emit the word and count information
this.ctx.Emit(Constants.DEFAULT_STREAM_ID, new List<SCPTuple> { tuple }, new Values(word, count));
Context.Logger.Info("Execute exit");
}
/// <summary>
/// The Execute() function will be called, when a new tuple is available.
/// </summary>
/// <param name="tuple"></param>
public void Execute(SCPTuple tuple)
{
var sensor = tuple.GetString(0);
var value = tuple.GetDouble(1);
//really add logic here!!
if (sensor.Equals("Sensor-A", StringComparison.InvariantCultureIgnoreCase)
&&
value > 10)
{
Context.Logger.Warn("The sensor {0} throw alarms by {1} value", sensor, value);
ctx.Emit(Constants.DEFAULT_STREAM_ID, new List <object>()
{
sensor
});
}
this.ctx.Ack(tuple);
}
// Called when a new tuple is available
public void Execute(SCPTuple tuple)
{
Context.Logger.Info("Execute enter");
// Get the sentance from the tuple
string sentence = tuple.GetString(0);
// Split at space characters
foreach (string word in sentence.Split(' '))
{
Context.Logger.Info("Emit: {0}", word);
if(word=="cow")
{
//Emit a true to the cowbell stream
this.ctx.Emit("cowbells", new Values("ding"));
}
//Emit each word to the default stream
this.ctx.Emit(new Values(word));
}
Context.Logger.Info("Execute exit");
}
/// <summary>
/// The Execute() function will be called, when a new tuple is available.
/// </summary>
/// <param name="tuple"></param>
public void Execute(SCPTuple tuple)
{
int wordCnt = 0;
string fileName = tuple.GetString(0);
Context.Logger.Info("PartialCount, Execute(), tuple content: {0}", fileName);
using (StreamReader reader = new StreamReader(fileName))
{
while (!reader.EndOfStream)
{
string line = reader.ReadLine();
Context.Logger.Info("read line: {0}", line);
foreach (string word in line.Split(' '))
{
wordCnt++;
}
}
}
Context.Logger.Info("Execute(), wordCnt: {0}", wordCnt);
this.ctx.Emit(new Values(wordCnt));
}
/// <summary>
/// The Execute() function will be called, when a new tuple is available.
/// </summary>
/// <param name="tuple"></param>
public void Execute(SCPTuple tuple)
{
int wordCnt = 0;
string fileName = tuple.GetString(0);
Context.Logger.Info("PartialCount, Execute(), tuple content: {0}", fileName);
using (StreamReader reader = new StreamReader(fileName))
{
while (!reader.EndOfStream)
{
string line = reader.ReadLine();
Context.Logger.Info("read line: {0}", line);
foreach (string word in line.Split(' '))
{
wordCnt++;
}
}
}
Context.Logger.Info("Execute(), wordCnt: {0}", wordCnt);
this.ctx.Emit(new Values(wordCnt));
}
public static Sensor GetSensor(this SCPTuple tuple)
{
try
{
Sensor sensor = null;
if (tuple.Size() == 1)
{
var content = tuple.GetString(0)
.Replace("\"", "'")
.Replace("\\", "");
sensor = JsonConvert.DeserializeObject <Sensor>(@content);
}
return(sensor);
}
catch (Exception ex)
{
Context.Logger.Error("JSON Serialization error:{0}", ex.ToString());
return(null);
}
}
/// <summary>
/// Executes incoming tuples
/// </summary>
/// <param name="tuple">The first field is treated as rowkey and rest as column names</param>
public void Execute(SCPTuple tuple)
{
//get the tuple info
string sessionId = tuple.GetString(0);
string sessionEvent = tuple.GetString(1);
long sessionEventTime = tuple.GetLong(2);
//If it's a start event, assume there's nothing to find so just re-emit
//NOTE: If messages may arrive out of order, you would need to add logic to
//query HBase to see if the end event has previously arrived,
//calculate the duration, etc.
if (sessionEvent == "START")
{
//Just re-emit the incoming data, plus 0 for duration, since we declare we send a 0 duration
//since we don't know the END event yet.
Values emitValues = new Values(tuple.GetValue(0), tuple.GetValue(1), tuple.GetValue(2), 0L);
//Is ack enabled?
if (enableAck)
{
//Emit the values, anchored to the incoming tuple
this.context.Emit(Constants.DEFAULT_STREAM_ID, new List <SCPTuple>()
{
tuple
}, emitValues);
//Ack the incoming tuple
this.context.Ack(tuple);
}
else
{
//No ack enabled? Fire and forget.
this.context.Emit(Constants.DEFAULT_STREAM_ID, emitValues);
}
}
if (sessionEvent == "END")
{
//Use filters
FilterList filters = new FilterList(FilterList.Operator.MustPassAll);
//Filter on the row by sessionID
RowFilter rowFilter = new RowFilter(CompareFilter.CompareOp.Equal, new BinaryComparator(TypeHelper.ToBytes(sessionId)));
filters.AddFilter(rowFilter);
//Filter on the event column for the START event
SingleColumnValueFilter valueFilter = new SingleColumnValueFilter(
Encoding.UTF8.GetBytes("cf"),
Encoding.UTF8.GetBytes("event"),
CompareFilter.CompareOp.Equal,
Encoding.UTF8.GetBytes("START"));
filters.AddFilter(valueFilter);
//Create scanner settings using the filters
var scannerSettings = new Scanner()
{
filter = filters.ToEncodedString()
};
//Get the scanner
var scanner = HBaseClusterClient.CreateScanner(HBaseTableName, scannerSettings);
CellSet readSet = null;
while ((readSet = HBaseClusterClient.ScannerGetNext(scanner)) != null)
{
//In theory we should only find one row
foreach (var row in readSet.rows)
{
//Pull back just the event column
var rowState = row.values.Where(v => Encoding.UTF8.GetString(v.column) == "cf:event")
.Select(v => Encoding.UTF8.GetString(v.data)).ToArray()[0];
//Is it a START event as expected?
if (rowState == "START")
{
//Get the start time
var startTime = TypeHelper.FromUnixTime(
row.values.Where(v => Encoding.UTF8.GetString(v.column) == "cf:time")
.Select(v => BitConverter.ToInt64(v.data, 0)).ToArray()[0]);
//Get the difference between start and end
DateTime endTime = TypeHelper.FromUnixTime(sessionEventTime);
TimeSpan duration = endTime.Subtract(startTime);
//Emit the tuple, with the duration between start/end.
Values emitValues = new Values(sessionId, sessionEvent, sessionEventTime, duration.Ticks);
//If ack is enabled
if (enableAck)
{
//Emit the values, anchored to the incoming tuple
this.context.Emit(Constants.DEFAULT_STREAM_ID, new List <SCPTuple>()
{
tuple
}, emitValues);
//Ack the incoming tuple
this.context.Ack(tuple);
}
else
{
//No ack enabled? Fire and forget.
this.context.Emit(Constants.DEFAULT_STREAM_ID, emitValues);
}
}
else
{
//Since this is a simple example, do nothing.
//In a real solution, you'd have to figure out what to do
//when receiving an END before a START.
}
}
}
}
}
public void Execute(SCPTuple tuple)
{
string cowBell = tuple.GetString(0);
this.ctx.Emit(new Values(cowBell));
}
/// <summary>
/// Executes incoming tuples
/// </summary>
/// <param name="tuple">The first field is treated as rowkey and rest as column names</param>
public void Execute(SCPTuple tuple)
{
//get the tuple info
string sessionId = tuple.GetString(0);
string sessionEvent = tuple.GetString(1);
long sessionEventTime = tuple.GetLong(2);
//If it's a start event, assume there's nothing to find so just re-emit
//NOTE: If messages may arrive out of order, you would need to add logic to
//query HBase to see if the end event has previously arrived,
//calculate the duration, etc.
if (sessionEvent == "START")
{
//Just re-emit the incoming data, plus 0 for duration, since we declare we send a 0 duration
//since we don't know the END event yet.
Values emitValues = new Values(tuple.GetValue(0), tuple.GetValue(1), tuple.GetValue(2), 0L);
//Is ack enabled?
if (enableAck)
{
//Emit the values, anchored to the incoming tuple
this.context.Emit(Constants.DEFAULT_STREAM_ID, new List<SCPTuple>() { tuple }, emitValues);
//Ack the incoming tuple
this.context.Ack(tuple);
}
else
{
//No ack enabled? Fire and forget.
this.context.Emit(Constants.DEFAULT_STREAM_ID, emitValues);
}
}
if (sessionEvent == "END")
{
//Use filters
FilterList filters = new FilterList(FilterList.Operator.MustPassAll);
//Filter on the row by sessionID
RowFilter rowFilter = new RowFilter(CompareFilter.CompareOp.Equal, new BinaryComparator(TypeHelper.ToBytes(sessionId)));
filters.AddFilter(rowFilter);
//Filter on the event column for the START event
SingleColumnValueFilter valueFilter = new SingleColumnValueFilter(
Encoding.UTF8.GetBytes("cf"),
Encoding.UTF8.GetBytes("event"),
CompareFilter.CompareOp.Equal,
Encoding.UTF8.GetBytes("START"));
filters.AddFilter(valueFilter);
//Create scanner settings using the filters
var scannerSettings = new Scanner()
{
filter = filters.ToEncodedString()
};
//Get the scanner
var scanner = HBaseClusterClient.CreateScanner(HBaseTableName, scannerSettings);
CellSet readSet = null;
while ((readSet = HBaseClusterClient.ScannerGetNext(scanner)) != null)
{
//In theory we should only find one row
foreach (var row in readSet.rows)
{
//Pull back just the event column
var rowState = row.values.Where(v => Encoding.UTF8.GetString(v.column) == "cf:event")
.Select(v => Encoding.UTF8.GetString(v.data)).ToArray()[0];
//Is it a START event as expected?
if (rowState == "START")
{
//Get the start time
var startTime = TypeHelper.FromUnixTime(
row.values.Where(v => Encoding.UTF8.GetString(v.column) == "cf:time")
.Select(v => BitConverter.ToInt64(v.data,0)).ToArray()[0]);
//Get the difference between start and end
DateTime endTime = TypeHelper.FromUnixTime(sessionEventTime);
TimeSpan duration = endTime.Subtract(startTime);
//Emit the tuple, with the duration between start/end.
Values emitValues = new Values(sessionId, sessionEvent, sessionEventTime, duration.Ticks);
//If ack is enabled
if (enableAck)
{
//Emit the values, anchored to the incoming tuple
this.context.Emit(Constants.DEFAULT_STREAM_ID, new List<SCPTuple>() { tuple }, emitValues);
//Ack the incoming tuple
this.context.Ack(tuple);
}
else
{
//No ack enabled? Fire and forget.
this.context.Emit(Constants.DEFAULT_STREAM_ID, emitValues);
}
}
else
{
//Since this is a simple example, do nothing.
//In a real solution, you'd have to figure out what to do
//when receiving an END before a START.
}
}
}
}
}
public static Sensor GetSensor(this SCPTuple tuple)
{
return(JsonConvert.DeserializeObject <Sensor>(
tuple.GetString(0)));
}
/// <summary>
/// The execute method for tuple received
/// </summary>
/// <param name="tuple"></param>
public void Execute(SCPTuple tuple)
{
try
{
var task = eventHubSender.SendAsync(new EventData(Encoding.UTF8.GetBytes(tuple.GetString(0))));
if (ackEnabled)
{
tasks.Add(task);
this.context.Ack(tuple);
if (tasks.Count >= 100)
{
Context.Logger.Info("Total tasks in waiting = {0}", tasks.Count);
Task.WaitAll(tasks.ToArray());
tasks.Clear();
Context.Logger.Info("All waiting tasks completed successfully!", tasks.Count);
}
}
global_emit_count++;
if (global_emit_count % 5000 == 0)
{
Context.Logger.Info("Total events sent to EventHub = {0} ({1} events/sec)", global_emit_count, global_emit_count / globalStopwatch.Elapsed.TotalSeconds);
}
}
catch (Exception ex)
{
Context.Logger.Error("Failed to send tuples. Last Id = {0}, Value = {1}. Tasks = {2}", tuple.GetTupleId(), tuple.GetString(0), tasks.Count);
Context.Logger.Error("Error Details: {0}", ex.ToString());
if (ackEnabled)
{
this.context.Fail(tuple);
}
global_error_count++;
if (global_error_count > 10)
{
Context.Logger.Error("High error count: {0}", global_error_count);
throw;
}
if (eventHubSender.IsClosed)
{
Context.Logger.Warn("EventHubSender is closed, re-intializing...");
InitializeEventHub();
}
}
}
/// <summary>
/// The execute method for tuple received
/// </summary>
/// <param name="tuple"></param>
public void Execute(SCPTuple tuple)
{
try
{
var task = eventHubSender.SendAsync(new EventData(Encoding.UTF8.GetBytes(tuple.GetString(0))));
if (ackEnabled)
{
tasks.Add(task);
this.context.Ack(tuple);
if (tasks.Count >= 100)
{
Context.Logger.Info("Total tasks in waiting = {0}", tasks.Count);
Task.WaitAll(tasks.ToArray());
tasks.Clear();
Context.Logger.Info("All waiting tasks completed successfully!", tasks.Count);
}
}
global_emit_count++;
if (global_emit_count % 5000 == 0)
{
Context.Logger.Info("Total events sent to EventHub = {0} ({1} events/sec)", global_emit_count, global_emit_count / globalStopwatch.Elapsed.TotalSeconds);
}
}
catch (Exception ex)
{
Context.Logger.Error("Failed to send tuples. Last Id = {0}, Value = {1}. Tasks = {2}", tuple.GetTupleId(), tuple.GetString(0), tasks.Count);
Context.Logger.Error("Error Details: {0}", ex.ToString());
if (ackEnabled)
{
this.context.Fail(tuple);
}
global_error_count++;
if (global_error_count > 10)
{
Context.Logger.Error("High error count: {0}", global_error_count);
throw;
}
}
}
