public DispatchManager(
object sender, // Agent reference for callbacks
Options options, WaterFlowManager incomingFlowManager,
IOWorker ioWorker,
LogCallback logCallback, LogEventArgs.LogLevel logLevel)
{
this.sender = sender;
this.incomingFlowManager = incomingFlowManager;
this.ioWorker = ioWorker;
this.logCallback = logCallback;
this.logLevel = logLevel;
messageQueue = new LinkedList<IncomingMessage>();
objectMap = new Dictionary<string, IncomingMessageHandler>();
anyObjectCallback = null;
int numOfThreads = options.dispatcherThreads;
dispatchers = new List<Thread>();
for (int i = 0; i != numOfThreads; ++i)
{
Thread th = new Thread((new Dispatcher(this)).run);
th.Name = "YAMI4 message dispatcher";
th.IsBackground = true;
th.Start();
dispatchers.Add(th);
}
}
public ChannelReader(
NetworkUtils.TransportChannel connection,
IncomingMessageDispatchCallback incomingMessageDispatchCallback,
string target, Options options,
LogCallback logCallback, LogEventArgs.LogLevel logLevel)
{
this.connection = connection;
this.incomingMessageDispatchCallback =
incomingMessageDispatchCallback;
this.target = target;
this.logCallback = logCallback;
this.logLevel = logLevel;
incomingFrames = new Dictionary<int, IncomingMessageFrames>();
if (connection != null)
{
if (connection.connectedChannel != null)
{
// stream-based connection
headerBuffer = new MemoryStream(Frame.FRAME_HEADER_SIZE);
setReadingFrameHeaderState();
}
else
{
// datagram-based connection
wholeFrameBuffer = new byte[options.udpFrameSize];
state = InputState.READING_WHOLE_FRAMES;
}
}
deliverAsRawBinary = options.deliverAsRawBinary;
}
/// <summary>
/// 实际的日志写入处理过程
/// </summary>
/// <param name="sender">调用者</param>
/// <param name="args"><see cref="LogEventArgs"/> 数组</param>
protected override void WriteLogInternal(object sender, LogEventArgs[] args)
{
var msg = this.LogFormat(sender, args, false);
if (Environment.UserInteractive) {
Console.Write(msg);
}
}
/// <summary>
/// Writes a log request to the diagnostic trace on the page.
/// </summary>
/// <param name="sender">Sender of the log request.</param>
/// <param name="e">Parameters of the log request.</param>
public void Log(object sender, LogEventArgs e)
{
if (e.Exception != null)
{
LogController.WriteLog(e.Exception);
}
}
/// <summary>
/// 实际的日志写入处理过程
/// </summary>
/// <param name="sender">调用者</param>
/// <param name="args"><see cref="LogEventArgs"/> 数组</param>
protected override void WriteLogInternal(object sender, LogEventArgs[] args)
{
if (this.MailService != null) {
var msg = this.LogFormat(sender, args, false);
this.MailService.Send(this.MailFrom, this.MailTo, this.MailSubject, msg);
}
}
/// <summary>
/// Sends a log request via email.
/// </summary>
/// <remarks>
/// Actual email 'Send' calls are commented out.
/// Uncomment if you have the proper email privileges.
/// </remarks>
/// <param name="sender">Sender of the log request.</param>
/// <param name="e">Parameters of the log request.</param>
public void Log(object sender, LogEventArgs e)
{
string message = "[" + e.Date.ToString() + "] " +
e.SeverityString + ": " + e.Message;
// Commented out for now. You need privileges to send email.
// _smtpClient.Send(_from, _to, _subject, body);
}
void End(object sender, LogEventArgs e)
{
log.LogMessage(@"***************
SUCCEEDED!!
{0}
***************", e.Message);
ReturnValue = true;
}
protected override string LogFormat(object sender, LogEventArgs[] args, bool withBatchFlag)
{
var message = new StringBuilder();
foreach(var arg in args) {
message.AppendLine(arg.Message);
}
return message.ToString();
}
void shard_LogOccurred(object sender, LogEventArgs args)
{
if (this.InvokeRequired)
{
this.BeginInvoke(new LogEventHandler(shard_LogOccurred), sender, args);
return;
}
textBox1.Text = textBox1.Text + args.Message + Environment.NewLine + Environment.NewLine;
}
/// <summary>
/// Writes a log request to the diagnostic trace on the page.
/// </summary>
/// <param name="sender">Sender of the log request.</param>
/// <param name="e">Parameters of the log request.</param>
public void Log(object sender, LogEventArgs e)
{
// Example code of entering a log event to output console
string message = "[" + e.Date.ToString() + "] " +
e.SeverityString + ": " + e.Message;
// Writes message to debug output window
System.Diagnostics.Debugger.Log(0, null, message + "\r\n\r\n");
}
internal Listener(
Socket channel, string resolvedTarget,
LogCallback logCallback, LogEventArgs.LogLevel logLevel)
{
this.channel = channel;
this.resolvedTarget = resolvedTarget;
this.logCallback = logCallback;
this.logLevel = logLevel;
}
// Parameter incomingMessageDispatchCallback not used here
internal UdpListener(
Socket channel, string resolvedTarget,
IncomingMessageDispatchCallback incomingMessageDispatchCallback,
Options options,
LogCallback logCallback, LogEventArgs.LogLevel logLevel)
: base(channel, resolvedTarget, logCallback, logLevel)
{
this.channel = channel;
this.options = options;
}
internal ChannelWriter(
NetworkUtils.TransportChannel connection, string target,
LogCallback logCallback, LogEventArgs.LogLevel logLevel)
{
this.connection = connection;
this.target = target;
this.logCallback = logCallback;
this.logLevel = logLevel;
outgoingFrames = new List<OutgoingFrame>();
}
/// <summary>
/// Logs a <see cref="string"/> into the VS debugger.
/// </summary>
/// <param name="sender">Sending object (usually a <see cref="Logger"/>)</param>
/// <param name="e"><see cref="LogEventArgs"/> containing message info</param>
public static void DebuggerLogPart(object sender, LogEventArgs e)
{
if (e.Level.IsAnyOf(LogLevel.Error, LogLevel.Fatal))
{
Debug.Fail(e.Message);
}
else
{
Debug.Write(e.Message);
}
}
/// <summary>
/// Writes a log request to the database.
/// </summary>
/// <remarks>
/// Actual database insert statements are commented out.
/// You can activate this if you have the proper database
/// configuration and access privileges.
/// </remarks>
/// <param name="sender">Sender of the log request.</param>
/// <param name="e">Parameters of the log request.</param>
public void Log(object sender, LogEventArgs e)
{
// Example code of entering a log event to database
string message = "[" + e.Date.ToString() + "] " +
e.SeverityString + ": " + e.Message;
// Something like
string sql = "INSERT INTO LOG (message) VALUES('" + message + "')";
// Commented out for now. You need database to store log values.
//Db.Update(sql);
}
public void OnEventLogged(object sender, LogEventArgs e)
{
if (IsDisposed || !IsHandleCreated)
return;
if (InvokeRequired)
{
Invoke((EventHandler<LogEventArgs>)OnEventLogged, sender, e);
return;
}
if (filterSessionCombobox.SelectedItem == null || !MeetsCriteria(e.LogEntry))
{
return;
}
EntryCache.Add(e.LogEntry);
++log.VirtualListSize;
EnableButtons();
}
internal Channel(string target, Options options,
IncomingMessageDispatchCallback incomingMessageDispatchCallback,
LogCallback logCallback, LogEventArgs.LogLevel logLevel)
{
this.target = target;
this.options = options;
this.logCallback = logCallback;
this.logLevel = logLevel;
connect(incomingMessageDispatchCallback);
if (logCallback != null)
{
logCallback.Log(LogEventArgs.LogLevel.LOW,
"Connected to " + target);
}
}
/// <summary>
/// Write a log request to a file.
/// </summary>
/// <param name="sender">Sender of the log request.</param>
/// <param name="e">Parameters of the log request.</param>
public void Log(object sender, LogEventArgs e)
{
string message = "[" + e.Date.ToString() + "] " +
e.SeverityString + ": " + e.Message;
FileStream fileStream;
// Create directory, if necessary
try
{
fileStream = new FileStream(_fileName, FileMode.Append);
}
catch (DirectoryNotFoundException)
{
Directory.CreateDirectory((new FileInfo(_fileName)).DirectoryName);
fileStream = new FileStream(_fileName, FileMode.Append);
}
// NOTE: Be sure you have write privileges to folder
var writer = new StreamWriter(fileStream);
try
{
writer.WriteLine(message);
}
catch
{
/* do nothing */
}
finally
{
try
{
writer.Close();
}
catch
{
/* do nothing */
}
}
}
public void Log(object sender, LogEventArgs e)
{
switch (e.Severity)
{
case LogSeverity.Debug:
getLog().Debug(e.Message, e.Exception);
break;
case LogSeverity.Error:
getLog().Error(e.Message, e.Exception);
break;
case LogSeverity.Fatal:
getLog().Fatal(e.Message, e.Exception);
break;
case LogSeverity.Info:
getLog().Info(e.Message, e.Exception);
break;
case LogSeverity.Warning:
getLog().Warn(e.Message, e.Exception);
break;
}
}
// used by listener when accepting new connections
internal Channel(Socket acceptedChannel, string sourceTarget,
IncomingMessageDispatchCallback incomingMessageDispatchCallback,
Options options, LogCallback logCallback,
LogEventArgs.LogLevel logLevel)
{
this.target = sourceTarget;
this.options = options;
this.connection =
new NetworkUtils.TransportChannel(acceptedChannel);
this.logCallback = logCallback;
this.logLevel = logLevel;
createReaderWriter(incomingMessageDispatchCallback);
if (logCallback != null)
{
logCallback.Log(LogEventArgs.LogLevel.LOW,
"Accepted connection from " + target);
}
}
private static void Log(object sender, LogEventArgs e)
{
switch (e.Level)
{
case 5:
case 4:
_logger.Debug(e.Data);
break;
case 3:
_logger.Info(e.Data);
break;
case 2:
_logger.Warn(e.Data);
break;
case 1:
_logger.Error(e.Data);
break;
case 0:
_logger.Fatal(e.Data);
break;
}
}
/// <summary>
/// Write a log request to the event log.
/// </summary>
/// <remarks>
/// Actual event log write entry statements are commented out.
/// Uncomment if you have the proper privileges.
/// </remarks>
/// <param name="sender">Sender of the log request.</param>
/// <param name="e">Parameters of the log request.</param>
public void Log(object sender, LogEventArgs e)
{
string message = "[" + e.Date.ToString() + "] " +
e.SeverityString + ": " + e.Message;
var eventLog = new EventLog();
eventLog.Source = "Patterns In Action";
// Map severity level to an Windows EventLog entry type
var type = EventLogEntryType.Error;
if (e.Severity < LogSeverity.Warning) type = EventLogEntryType.Information;
if (e.Severity < LogSeverity.Error) type = EventLogEntryType.Warning;
// In try catch. You will need proper privileges to write to eventlog.
try
{
eventLog.WriteEntry(message, type);
}
catch
{
/* do nothing */
}
}
void b2db_Status(LogEventArgs e)
{
if (!e.Text.StartsWith("\tSTATUS\t"))
TransferStatus();
this.status.Text = "[" + e.Module + "]: ";
string[] spl = e.Text.Split(new char[] { '\t' }, StringSplitOptions.RemoveEmptyEntries);
switch (spl[0].ToLower())
{
case "error":
this.status.Text += "Fehler: ";
this.status.BackColor = Color.Red;
this.status.ForeColor = Color.White;
break;
case "status":
this.status.BackColor = Color.Transparent;
this.status.ForeColor = SystemColors.ControlText;
break;
case "opening":
this.status.Text += "Öffne Datei: ";
this.status.BackColor = Color.Transparent;
this.status.ForeColor = SystemColors.GradientActiveCaption;
break;
case "closing":
this.status.Text += "Schließe Datei: ";
this.status.BackColor = Color.Transparent;
this.status.ForeColor = SystemColors.GradientActiveCaption;
break;
default:
this.status.Text += spl[0].ToUpper().Substring(0, 1) + spl[0].ToLower().Substring(1) + ": ";
this.status.BackColor = Color.Transparent;
this.status.ForeColor = SystemColors.GradientActiveCaption;
break;
}
this.status.Text += spl[1];
this.status.Refresh();
}
public IOWorker(
IDictionary<string, Channel> channels,
IDictionary<string, Listener> listeners,
WaterFlowManager incomingFlowManager,
Options options,
IncomingMessageDispatchCallback incomingMessageDispatchCallback,
ConnectionEventCallback connectionEventCallback,
LogCallback logCallback, LogEventArgs.LogLevel logLevel)
{
this.channels = channels;
this.listeners = listeners;
this.incomingFlowManager = incomingFlowManager;
this.options = options;
this.incomingMessageDispatchCallback =
incomingMessageDispatchCallback;
this.connectionEventCallback = connectionEventCallback;
this.logCallback = logCallback;
this.logLevel = logLevel;
listenersForSelection = new Dictionary<Socket, Listener>();
channelsForSelection = new Dictionary<Socket, Channel>();
stopRequest = false;
}
private static void LogToConsole(LogEventArgs e)
{
ConsoleColor c = Console.ForegroundColor;
var d = DateTime.Now;
var logString = String.Format("[{0:d} - {0:t}] [{1}] {2}", d, e.Level.ToString().ToUpper(), e.Message);
Debug.WriteLine(logString);
if ((int)e.Level >= _minLogLevel)
{
switch (e.Level)
{
case LogLevel.Error:
Console.ForegroundColor = ConsoleColor.Red;
break;
case LogLevel.Warning:
Console.ForegroundColor = ConsoleColor.Yellow;
break;
}
Console.WriteLine(logString);
}
Console.ForegroundColor = c;
}
public void OnLog(LogEventArgs args)
{
if (Log != null)
{
Log(args);
}
}
private void Test_Log1(object sender, LogEventArgs e)
{
message = e.Message;
}
private void task_Logged(object sender, LogEventArgs e)
{
if (InvokeRequired)
{
Invoke(new EventHandler<LogEventArgs>(task_Logged), sender, e);
return;
}
if (filterSessionCombobox.SelectedItem == null ||
(DateTime)filterSessionCombobox.SelectedItem != task.Log.LastSession ||
!MeetsCriteria(e.LogEntry))
{
return;
}
entryCache.Add(e.LogEntry);
++log.VirtualListSize;
EnableButtons();
}
public void OnLogged(object sender, LogEventArgs e)
{
if (!e.WriteToConsole)
{
return;
}
try
{
if (shutdownComplete)
{
return;
}
if (logBox.InvokeRequired)
{
BeginInvoke((EventHandler <LogEventArgs>)OnLogged, sender, e);
}
else
{
// store user's selection
int userSelectionStart = logBox.SelectionStart;
int userSelectionLength = logBox.SelectionLength;
bool userSelecting = (logBox.SelectionStart != logBox.Text.Length && logBox.Focused ||
logBox.SelectionLength > 0);
// insert and color a new message
int oldLength = logBox.Text.Length;
string msgToAppend = e.Message + Environment.NewLine;
/*if (e.MessageType == LogType.GlobalChat) //If Global Message, send to global and stop
* {
* logGlobal.SelectionColor = System.Drawing.Color.LightGray;
* logGlobal.AppendText(msgToAppend);
* return;
* }
* else*/
{
logBox.AppendText(msgToAppend);
}
logBox.Select(oldLength, msgToAppend.Length);
switch (e.MessageType)
{
case LogType.PrivateChat:
logBox.SelectionColor = System.Drawing.Color.Teal;
break;
case LogType.IRC:
if (ThemeBox.SelectedItem == null)
{
logBox.SelectionColor = System.Drawing.Color.FromName(Color.GetName(GemsCraft.Utils.Color.IRC));
}
else
{
switch (ThemeBox.SelectedItem.ToString())
{
default:
logBox.SelectionColor = System.Drawing.Color.LightSkyBlue;
break;
case "Default LC":
logBox.SelectionColor = System.Drawing.Color.Navy;
break;
}
}
break;
case LogType.ChangedWorld:
logBox.SelectionColor = System.Drawing.Color.Orange;
break;
case LogType.Warning:
if (ThemeBox.SelectedItem == null)
{
logBox.SelectionColor = System.Drawing.Color.Yellow;
}
else
{
switch (ThemeBox.SelectedItem.ToString())
{
default:
logBox.SelectionColor = System.Drawing.Color.MediumOrchid;
break;
case "Default LC":
logBox.SelectionColor = System.Drawing.Color.Yellow;
break;
}
}
break;
case LogType.Debug:
logBox.SelectionColor = System.Drawing.Color.DarkGray;
break;
case LogType.Error:
case LogType.SeriousError:
logBox.SelectionColor = System.Drawing.Color.Red;
break;
case LogType.ConsoleInput:
case LogType.ConsoleOutput:
if (ThemeBox.SelectedItem == null)
{
logBox.SelectionColor = System.Drawing.Color.White;
}
else
{
switch (ThemeBox.SelectedItem.ToString())
{
default:
logBox.SelectionColor = System.Drawing.Color.Black;
break;
case "Default LC":
logBox.SelectionColor = System.Drawing.Color.White;
break;
}
}
break;
default:
if (ThemeBox.SelectedItem == null)
{
logBox.SelectionColor = System.Drawing.Color.LightGray;
}
else
{
switch (ThemeBox.SelectedItem.ToString())
{
default:
logBox.SelectionColor = System.Drawing.Color.Black;
break;
case "Default LC":
logBox.SelectionColor = System.Drawing.Color.LightGray;
break;
}
}
break;
}
// cut off the log, if too long
if (logBox.Lines.Length > MaxLinesInLog)
{
logBox.SelectionStart = 0;
logBox.SelectionLength = logBox.GetFirstCharIndexFromLine(LinesToTrimWhenExceeded);
userSelectionStart -= logBox.SelectionLength;
if (userSelectionStart < 0)
{
userSelecting = false;
}
string textToAdd = "----- cut off, see " + Logger.CurrentLogFileName + " for complete log -----" + Environment.NewLine;
logBox.SelectedText = textToAdd;
userSelectionStart += textToAdd.Length;
logBox.SelectionColor = System.Drawing.Color.DarkGray;
}
// either restore user's selection, or scroll to end
if (userSelecting)
{
logBox.Select(userSelectionStart, userSelectionLength);
}
else
{
logBox.SelectionStart = logBox.Text.Length;
logBox.ScrollToCaret();
}
}
}
catch (ObjectDisposedException)
{
}
catch (InvalidOperationException) { }
}
private void LogReceived(object sender, LogEventArgs args)
{
backup.AddHubNotificationEvent(args.Code, args.Message, "");
}
private void OnMessageLogged(object sender, LogEventArgs e) => _logger.Log(e.Severity, e.Message, e.Exception);
//static void Main()
//{
// var di = new DebugInfo(Path.Combine(CosmosRoot, @"source2\Demos\Guess\bin\Debug\Guess.cdb"));
// di.LoadLookups();
// var addr = (uint)1;
// var q = new SQLinq<Label>()
// .Where(i => i.Address <= addr)
// .OrderByDescending(i => i.Address)
// ;
// Console.WriteLine(q.ToSQL().ToQuery());
// var xLabels = di.Connection.Query<Label>(q).Select(i => i.Name).ToArray();
// var g = Guid.Empty;
// di.GetMethod(1);
//}
private static void SQLiteLog_Log(object sender, LogEventArgs e)
{
Console.WriteLine("SQL: {0}", e.Message);
}
private static void Log_LogError(LogEventArgs e)
{
_log.Error(e.Message, e.Exception);
}
public static void LogEvent(object sender, LogEventArgs args)
{
Transaction tx = (Transaction)args.ScriptContainer;
tx.Script = new byte[] { 0x01, 0x02, 0x03 };
}
/// <summary>
/// Called when file parsing has begun.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="LogEventArgs" /> instance containing the event data.</param>
public void OnParseStarted(object sender, LogEventArgs e)
{
}
static void OnLogged(object sender, LogEventArgs e)
{
if (!e.WriteToConsole)
{
return;
}
switch (e.MessageType)
{
case LogType.Error:
if (useColor)
{
Console.ForegroundColor = ConsoleColor.Red;
}
Console.Error.WriteLine(e.Message);
if (useColor)
{
Console.ResetColor();
}
return;
case LogType.SeriousError:
if (useColor)
{
Console.ForegroundColor = ConsoleColor.White;
}
if (useColor)
{
Console.BackgroundColor = ConsoleColor.Red;
}
Console.Error.WriteLine(e.Message);
if (useColor)
{
Console.ResetColor();
}
return;
case LogType.Warning:
if (useColor)
{
Console.ForegroundColor = ConsoleColor.Yellow;
}
Console.WriteLine(e.Message);
if (useColor)
{
Console.ResetColor();
}
return;
case LogType.Debug:
case LogType.Trace:
if (useColor)
{
Console.ForegroundColor = ConsoleColor.DarkGray;
}
Console.WriteLine(e.Message);
if (useColor)
{
Console.ResetColor();
}
return;
default:
Console.WriteLine(e.Message);
return;
}
}
/// <summary>
/// Add a log to the logging queue
/// </summary>
public void AddLog(LogEventArgs log)
{
LogsQueue.Enqueue(log);
NotifyAddedLog.Release();
}
/// <summary>
/// Add a log to the logging queue
/// </summary>
public void AddLog(object sender, LogEventArgs log)
{
AddLog(log);
}
/// <summary>
/// Handler for component logging
/// </summary>
void OnLog(object sender, LogEventArgs e)
{
AddLog(e);
}
/// <inheritdoc/> public override void RaiseLogEntry(LogEventArgs e) => OnLogEntry?.Invoke(this, e);
private static void Log_LogDebug(LogEventArgs e)
{
_log.Debug(e.Message, e.Exception);
}
public void LogEvent(object sender, LogEventArgs eventArgs)
{
var log = $"[{eventArgs.Level,-7}:{((ILogSource) sender).SourceName,10}] {eventArgs.Data}\r\n";
ConsoleManager.StandardOutStream?.Write(log);
}
/// <summary>
/// Log handler
/// </summary>
private void OnLog(object sender, LogEventArgs e)
{
Logger.AddLog(sender, e);
}
/// <summary>
/// Listen for any logs made by the engine.
/// </summary>
/// <param name="sender">The logger.</param>
/// <param name="e">The log that was made.</param>
private void Log_OnLog(object sender, LogEventArgs e)
{
logList.AddItem(e.LogStatement.ToStringShort());
logList.ScrollToBottom();
}
/// <summary>
/// Event handler when adding a log message
/// Call PrintMessage to print the given message live to the log panel of the UI
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Add_Message(object sender, LogEventArgs e)
{
PrintMessage(String.Format("[{0}] {1}", RunningTask.Name, e.Message), e.LogType);
}
protected virtual void LogMessage(string message)
{
LogEventArgs e = new LogEventArgs(message);
OnLog(e);
}
private static void OnLogReady(object sender, LogEventArgs e)
{
Log.Write(e.Content);
}
public void LogEvent(object sender, LogEventArgs eventArgs)
{
OnEntryLogged(eventArgs);
}
static void OnLogString(object sender, LogEventArgs logEventArgs)
{
Console.WriteLine("LogOnOnLogString: {0}", logEventArgs.LogString);
}
private void Log(LogEventArgs args) =>
Log(args.LogMessage.Internal.Severity, args.LogMessage.Internal.Source,
args.LogMessage.Internal.Message, args.LogMessage.Internal.Exception);
private void Log_OnLogPart(object sender, LogEventArgs e)
{
testResult += e.Message;
}
public void OnLog(object sender, LogEventArgs e)
{
LogManager.Instance.Enqueue(e.Log);
}
private void Test_Log2(object sender, LogEventArgs e)
{
message = null;
}
protected abstract void OnLogCore(object sender, LogEventArgs e);
public void Log(object sender, LogEventArgs e)
{
}
void LogManager_LogEvent(object?sender, LogEventArgs e)
{
Debug.WriteLine(e.Message);
Console.WriteLine(e.Message);
}
void _Manager_OnLog(object sender, LogEventArgs e)
{
Log(e.Message);
}
public static void MagickNET_Log(object sender, LogEventArgs arguments)
{
// Write log message
WriteLogMessage(arguments.Message);
}
private static void _libVLC_Log(object sender, LogEventArgs e)
{
Debug.WriteLine("vlc: " + e.Message);
}
private void Log_LogDebug(LogEventArgs e)
{
this.logger.AppendFormat("Debug: {0}{1}", e.Message, Environment.NewLine);
}
