public void PushMessage(IntelEventArgs message)
{
if (messages.Count > maxMessages) {
messages.Dequeue();
}
messages.Enqueue(new MessageData {
Message = message
});
this.Invalidate();
}
/// <summary>
/// Sent by <see cref="IntelReporter"/> every time it parses a
/// new log entry.
/// </summary>
private void intelReporter_IntelReported(object sender, IntelEventArgs e)
{
messageView.PushMessage(e);
if (e.Message.IndexOf("Dabigredboat", StringComparison.OrdinalIgnoreCase) != -1) {
++this.noveltyCount;
this.UpdateStatus();
}
}
/// <summary>
/// Event handler for <see cref="IntelChannelContainer.IntelReported"/>.
/// </summary>
private void channels_IntelReported(object sender, IntelEventArgs e)
{
Contract.Requires(e != null);
this.OnIntelReported(e);
}
/// <summary>
/// Raises the <see cref="IntelReported"/> event.
/// </summary>
protected internal virtual void OnIntelReported(IntelEventArgs e)
{
Contract.Requires<ArgumentNullException>(e != null, "e");
// Raise the event (as appropriate)
this.lastIntel = DateTime.UtcNow;
var handler = this.IntelReported;
if (handler != null) {
var sync = this.synchronizingObject;
WaitCallback callback = (state) => handler(this, e);
if ((sync != null) && sync.InvokeRequired) {
sync.BeginInvoke(callback, new object[] { null });
} else {
ThreadPool.QueueUserWorkItem(callback);
}
}
// Report the intel
try {
lock (this.syncRoot) {
// Race condition avoidance
if (!this.IsRunning) {
return;
}
// Report as necessary
var session = this.GetSession(true);
if (session.Report(e)) {
this.Status = IntelStatus.Active;
++this.IntelSent;
this.OnPropertyChanged("IntelSent");
} else {
++this.IntelDropped;
this.OnPropertyChanged("IntelDropped");
}
}
} catch (WebException) {
this.Status = IntelStatus.NetworkError;
++this.IntelDropped;
this.OnPropertyChanged("IntelDropped");
} catch (AuthenticationException) {
this.Status = IntelStatus.AuthenticationError;
++this.IntelDropped;
this.OnPropertyChanged("IntelDropped");
}
}
/// <summary>Sends a log entry to the intel reporting server.</summary>
/// <param name="e">An instance of <see cref="IntelEventArgs" />
/// containing the information to report.</param>
/// <returns>
/// <see langword="true" /> if our session is still valid;
/// otherwise, <see langword="false" />.
/// </returns>
public bool Report(IntelEventArgs e)
{
Contract.Requires<ArgumentNullException>(e != null, "e");
return this.Report(e.Channel, e.Timestamp, e.Message);
}
/// <summary>Raises the <see cref="IntelReported" /> event.</summary>
/// <param name="e">Arguments of the event being raised.</param>
/// <remarks>
/// <see cref="OnIntelReported" /> makes no changes to the internal
/// object state and can be safely called at any time. If the
/// logic within <see cref="CreateChannel" /> is replaced, the
/// <see cref="IntelChannel.IntelReported" /> event needs to be
/// forwarded to <see cref="OnIntelReported" />.
/// </remarks>
protected virtual void OnIntelReported(IntelEventArgs e)
{
Contract.Requires<ArgumentNullException>(e != null, "e");
Interlocked.Increment(ref this.uploadCount);
this.OnPropertyChanged("IntelCount");
var handler = this.IntelReported;
if (handler != null) {
handler(this, e);
}
}
/// <summary>
/// Called every couple of seconds to sweep the log file for
/// new entries.
/// </summary>
/// <remarks>
/// <see cref="OnTick" /> will be called from within a synchronized
/// context so derived classes should not attempt to perform any
/// additional synchronization themselves.
/// </remarks>
protected virtual void OnTick()
{
if (this.watcher == null) {
// Try (again) to create the watcher object
try {
this.watcher = this.CreateFileSystemWatcher();
this.Status = IntelStatus.Waiting;
this.ScanFiles();
} catch (ArgumentException) {
// Still doesn't seem to exist
}
}
if (this.reader != null) {
// Read new log entries from the current log
try {
string line;
while ((line = reader.ReadLine()) != null) {
Trace.WriteLine("R " + line, IntelExtensions.WebTraceCategory);
var match = Parser.Match(line);
if (match.Success && !match.Groups[7].Value.StartsWith(MotdPrefix)) {
var e = new IntelEventArgs(
this.Name,
new DateTime(
match.Groups[1].ToInt32(),
match.Groups[2].ToInt32(),
match.Groups[3].ToInt32(),
match.Groups[4].ToInt32(),
match.Groups[5].ToInt32(),
match.Groups[6].ToInt32(),
DateTimeKind.Utc),
match.Groups[7].Value);
this.OnIntelReported(e);
}
}
} catch (IOException) {
this.CloseFile();
}
// Close the log if it has been idle for too long
if (this.lastEntry + this.expireLog < DateTime.UtcNow) {
this.CloseFile();
}
}
}
/// <summary>
/// Raises the <see cref="IntelReported" /> event.
/// </summary>
/// <param name="e">Arguments for the event being raised.</param>
/// <remarks>
/// <see cref="OnIntelReported" /> will be called from within
/// a synchronized context so derived classes should not attempt to
/// perform any additional synchronization themselves.
/// </remarks>
protected internal void OnIntelReported(IntelEventArgs e)
{
Contract.Requires<ArgumentNullException>(e != null, "e");
ThreadPool.QueueUserWorkItem(delegate(object state) {
Contract.Requires(state is IntelEventArgs);
var handler = this.IntelReported;
if (handler != null) {
handler(this, (IntelEventArgs)state);
}
}, e);
this.lastEntry = DateTime.UtcNow;
++this.IntelCount;
this.OnPropertyChanged("IntelCount");
}
