public void Trace(string category, string message)
{
var logMessage = new Ice.LogMessage(Ice.LogMessageType.TraceMessage, Now(), category, message);
_localLogger.Trace(category, message);
Log(logMessage);
}
public void Print(string message)
{
var logMessage = new Ice.LogMessage(Ice.LogMessageType.PrintMessage, Now(), "", message);
_localLogger.Print(message);
Log(logMessage);
}
public void Warning(string message)
{
var logMessage = new Ice.LogMessage(Ice.LogMessageType.WarningMessage, Now(), "", message);
_localLogger.Warning(message);
Log(logMessage);
}
public void Error(string message)
{
var logMessage = new Ice.LogMessage(Ice.LogMessageType.ErrorMessage, Now(), "", message);
_localLogger.Error(message);
Log(logMessage);
}
internal void checkNextLog(Ice.LogMessageType messageType, string message, string category)
{
lock (this)
{
Ice.LogMessage logMessage = new Ice.LogMessage(messageType, 0, category, message);
_expectedLogMessages.Enqueue(logMessage);
}
}
override public void log(Ice.LogMessage message, Ice.Current current)
{
lock (this)
{
_logMessages.Enqueue(message);
_receivedCalls++;
Monitor.PulseAll(this);
}
}
private static void filterLogMessages(LinkedList <Ice.LogMessage> logMessages,
HashSet <Ice.LogMessageType> messageTypes,
HashSet <string> traceCategories, int messageMax)
{
Debug.Assert(logMessages.Count > 0 && messageMax != 0);
//
// Filter only if one of the 3 filters is set; messageMax < 0 means "give me all"
// that match the other filters, if any.
//
if (messageTypes.Count > 0 || traceCategories.Count > 0 || messageMax > 0)
{
int count = 0;
var p = logMessages.Last;
while (p != null)
{
bool keepIt = false;
Ice.LogMessage msg = p.Value;
if (messageTypes.Count == 0 || messageTypes.Contains(msg.type))
{
if (msg.type != Ice.LogMessageType.TraceMessage || traceCategories.Count == 0 ||
traceCategories.Contains(msg.traceCategory))
{
keepIt = true;
}
}
if (keepIt)
{
++count;
if (messageMax > 0 && count >= messageMax)
{
// Remove all older messages
p = p.Previous;
while (p != null)
{
var previous = p.Previous;
logMessages.Remove(p);
p = previous;
}
break; // while
}
else
{
p = p.Previous;
}
}
else
{
var previous = p.Previous;
logMessages.Remove(p);
p = previous;
}
}
}
// else, don't need any filtering
}
override public void log(Ice.LogMessage logMessage, Ice.Current current)
{
lock (this)
{
Ice.LogMessage front = _expectedLogMessages.Dequeue();
test(front.type == logMessage.type && front.message.Equals(logMessage.message) &&
front.traceCategory.Equals(logMessage.traceCategory));
_receivedCalls++;
Monitor.PulseAll(this);
}
}
internal void Log(Ice.LogMessage logMessage)
{
List <Ice.IRemoteLoggerPrx>?remoteLoggers = _loggerAdmin.Log(logMessage);
if (remoteLoggers != null)
{
Debug.Assert(remoteLoggers.Count > 0);
lock (this)
{
if (_sendLogThread == null)
{
_sendLogThread = new Thread(new ThreadStart(Run));
_sendLogThread.Name = "Ice.SendLogThread";
_sendLogThread.IsBackground = true;
_sendLogThread.Start();
}
_jobQueue.Enqueue(new Job(remoteLoggers, logMessage));
Monitor.PulseAll(this);
}
}
}
public void trace(string category, string message)
{
Ice.LogMessage logMessage = new Ice.LogMessage(Ice.LogMessageType.TraceMessage, now(), category, message);
_localLogger.trace(category, message);
log(logMessage);
}
public void print(string message)
{
Ice.LogMessage logMessage = new Ice.LogMessage(Ice.LogMessageType.PrintMessage, now(), "", message);
_localLogger.print(message);
log(logMessage);
}
public void error(string message)
{
Ice.LogMessage logMessage = new Ice.LogMessage(Ice.LogMessageType.ErrorMessage, now(), "", message);
_localLogger.error(message);
log(logMessage);
}
public void warning(string message)
{
Ice.LogMessage logMessage = new Ice.LogMessage(Ice.LogMessageType.WarningMessage, now(), "", message);
_localLogger.warning(message);
log(logMessage);
}
internal List <Ice.RemoteLoggerPrx> log(Ice.LogMessage logMessage)
{
lock (this)
{
List <Ice.RemoteLoggerPrx> remoteLoggers = null;
//
// Put message in _queue
//
if ((logMessage.type != Ice.LogMessageType.TraceMessage && _maxLogCount > 0) ||
(logMessage.type == Ice.LogMessageType.TraceMessage && _maxTraceCount > 0))
{
_queue.AddLast(logMessage);
if (logMessage.type != Ice.LogMessageType.TraceMessage)
{
Debug.Assert(_maxLogCount > 0);
if (_logCount == _maxLogCount)
{
//
// Need to remove the oldest log from the queue
//
Debug.Assert(_oldestLog != null);
var next = _oldestLog.Next;
_queue.Remove(_oldestLog);
_oldestLog = next;
while (_oldestLog != null && _oldestLog.Value.type == Ice.LogMessageType.TraceMessage)
{
_oldestLog = _oldestLog.Next;
}
Debug.Assert(_oldestLog != null); // remember: we just added a Log at the end
}
else
{
Debug.Assert(_logCount < _maxLogCount);
_logCount++;
if (_oldestLog == null)
{
_oldestLog = _queue.Last;
}
}
}
else
{
Debug.Assert(_maxTraceCount > 0);
if (_traceCount == _maxTraceCount)
{
//
// Need to remove the oldest trace from the queue
//
Debug.Assert(_oldestTrace != null);
var next = _oldestTrace.Next;
_queue.Remove(_oldestTrace);
_oldestTrace = next;
while (_oldestTrace != null && _oldestTrace.Value.type != Ice.LogMessageType.TraceMessage)
{
_oldestTrace = _oldestTrace.Next;
}
Debug.Assert(_oldestTrace != null); // remember: we just added a Log at the end
}
else
{
Debug.Assert(_traceCount < _maxTraceCount);
_traceCount++;
if (_oldestTrace == null)
{
_oldestTrace = _queue.Last;
}
}
}
}
//
// Queue updated, now find which remote loggers want this message
//
foreach (RemoteLoggerData p in _remoteLoggerMap.Values)
{
Filters filters = p.filters;
if (filters.messageTypes.Count == 0 || filters.messageTypes.Contains(logMessage.type))
{
if (logMessage.type != Ice.LogMessageType.TraceMessage || filters.traceCategories.Count == 0 ||
filters.traceCategories.Contains(logMessage.traceCategory))
{
if (remoteLoggers == null)
{
remoteLoggers = new List <Ice.RemoteLoggerPrx>();
}
remoteLoggers.Add(p.remoteLogger);
}
}
}
return(remoteLoggers);
}
}
internal Job(List <Ice.IRemoteLoggerPrx> r, Ice.LogMessage l)
{
RemoteLoggers = r;
LogMessage = l;
}
public void print(string message)
{
Ice.LogMessage logMessage = new Ice.LogMessage(Ice.LogMessageType.PrintMessage, now(), "", message);
_localLogger.print(message);
log(logMessage);
}
internal Job(List<Ice.RemoteLoggerPrx> r, Ice.LogMessage l)
{
remoteLoggers = r;
logMessage = l;
}
public void trace(string category, string message)
{
Ice.LogMessage logMessage = new Ice.LogMessage(Ice.LogMessageType.TraceMessage, now(), category, message);
_localLogger.trace(category, message);
log(logMessage);
}
public void warning(string message)
{
Ice.LogMessage logMessage = new Ice.LogMessage(Ice.LogMessageType.WarningMessage, now(), "", message);
_localLogger.warning(message);
log(logMessage);
}
internal void checkNextLog(Ice.LogMessageType messageType,string message, string category)
{
lock(this)
{
Ice.LogMessage logMessage = new Ice.LogMessage(messageType, 0, category, message);
_expectedLogMessages.Enqueue(logMessage);
}
}
public void error(string message)
{
Ice.LogMessage logMessage = new Ice.LogMessage(Ice.LogMessageType.ErrorMessage, now(), "", message);
_localLogger.error(message);
log(logMessage);
}
internal Job(List <Ice.RemoteLoggerPrx> r, Ice.LogMessage l)
{
remoteLoggers = r;
logMessage = l;
}
