protected override void Before_all_tests()
{
base.Before_all_tests();
logMessageHandler = LogMessageHandlerFactory.GetHandlerFor(LogMessage);
}
/// <summary>Adds the given ILogMessageHandler to the indicated group</summary>
public static void AddLogMessageHandlerToDistributionGroup(string groupName, ILogMessageHandler logMessageHandler)
{
GetLogMessageDistributionImpl().AddLogMessageHandlerToDistributionGroup(logMessageHandler, groupName);
}
// methods used by global methods
public void AddLogMessageHandlerToDistributionGroup(ILogMessageHandler logMessageHandler, string groupName)
{
lock (distMutex)
{
int dgid = InnerGetDistGroupID(groupName, true);
if (!InnerIsDistGroupIDValid(dgid))
{
Utils.Asserts.TakeBreakpointAfterFault("AddLogMessageHandler...::Given GroupName could not be created.");
return;
}
PerDistGroupIDInfo dgInfo = distGroupIDInfoList [dgid];
if (logMessageHandler != null)
{
int dhInfoIdx = dgInfo.distHandlerInfoList.Count;
dgInfo.Add(new DistHandlerInfo(logMessageHandler));
DistHandlerInfo distHandlerInfo = dgInfo.distHandlerInfoList [dhInfoIdx];
logMessageHandler.NotifyOnCompletedDelivery.AddItem(mesgDeliveryOccurredNotification);
if (dgInfo.UpdateActiveLoggerConfig())
InnerUpdateLoggerDistGroupConfigForGroup(dgid);
}
}
}
public DistHandlerInfo(ILogMessageHandler lmh)
{
LMH = lmh;
}
//-------------------------------------------------------------------
/// <summary>Adds the given ILogMessaeHandler to the default distribution group.</summary>
public static void AddLogMessageHandlerToDefaultDistributionGroup(ILogMessageHandler logMessageHandler)
{
AddLogMessageHandlerToDistributionGroup(DefaultDistributionGroupName, logMessageHandler);
}
/// <summary>
/// Single targetLMH constructor. Derives name and LoggingConfig values from the given targetLMH.
/// </summary>
/// <param name="targetLMH">Gives the target LMH instance to which the queued messages will be delivered.</param>
/// <param name="maxQueueSize">Defines te maximum number of messages that can be held internally before messages are lost.</param>
public QueueLogMessageHandler(ILogMessageHandler targetLMH, int maxQueueSize)
: this(targetLMH.Name, new[] { targetLMH }, maxQueueSize)
{
}
/// <summary>
/// Multiple targetLMH constructor. Derives LoggingConfig values from the given targetLMH
/// </summary>
/// <param name="name">Gives the name of this LMH - different than the names of the target LMH instances</param>
/// <param name="targetLMHArray">Gives the set of LMH instance that are to be given the dequeued LogMessages.</param>
/// <param name="maxQueueSize">Defines te maximum number of messages that can be held internally before messages are lost.</param>
public QueueLogMessageHandler(string name, ILogMessageHandler[] targetLMHArray, int maxQueueSize)
: base(name, LogGate.None, false, false)
{
targetLMHArray = targetLMHArray ?? emptyLMHArray;
LogGate logGate = LogGate.None;
bool recordSourceStackFrame = false;
bool supportsReferenceCountedRelease = true;
foreach (ILogMessageHandler targetLMH in targetLMHArray)
{
logGate.MesgTypeMask |= targetLMH.LoggerConfig.LogGate.MesgTypeMask;
recordSourceStackFrame |= targetLMH.LoggerConfig.RecordSourceStackFrame;
supportsReferenceCountedRelease &= targetLMH.LoggerConfig.SupportsReferenceCountedRelease;
}
loggerConfig.LogGate = logGate;
loggerConfig.RecordSourceStackFrame = recordSourceStackFrame;
loggerConfig.SupportsReferenceCountedRelease = supportsReferenceCountedRelease;
this.targetLMHArray = targetLMHArray;
dist = Logging.GetLogMessageDistribution();
mesgDeliveryList = new List<LogMessage>(10); // define its initial capacity
mesgQueue = new MessageQueue(maxQueueSize);
mesgQueue.SetEffectiveSourceInfo(logger.LoggerSourceInfo);
mesgQueue.EnableQueue();
mesgQueueMutex = mesgQueue.Mutex;
// create and start the thread
StartIfNeeded();
}
protected override void Before_all_tests()
{
base.Before_all_tests();
logMessageHandler = LogMessageHandlerFactory.GetHandlerFor(LogMessage);
}
/// <summary>
/// Single targetLMH constructor. Derives name and LoggingConfig values from the given targetLMH.
/// </summary>
/// <param name="targetLMH">Gives the target LMH instance to which the queued messages will be delivered.</param>
/// <param name="maxQueueSize">Defines te maximum number of messages that can be held internally before messages are lost.</param>
public QueueLogMessageHandler(ILogMessageHandler targetLMH, int maxQueueSize = DefaultMesgQueueSize)
: this(targetLMH.Name + ".q", new[] { targetLMH }, maxQueueSize)
{
}
public LogController(ILogMessageHandler handler)
{
this.handler = handler;
}
public ILogMessageHandler <T> SetNext(ILogMessageHandler <T> nextHandler)
{
Next = nextHandler;
return(Next);
}
/// <summary>Constructor</summary>
/// <param name="logMesgHandler">Gives the LMH to which emitted messages will be passed.</param>
public LogMesgHandlerLogger(ILogMessageHandler logMesgHandler)
: base(logMesgHandler.Name, string.Empty, logMesgHandler.LoggerConfig.LogGate, false)
{
lmh = logMesgHandler;
if (lmh == null)
Utils.Asserts.TakeBreakpointAfterFault("LogMesgHandlerLogger: LMH == null");
sourceInfo = new LoggerSourceInfo(LoggerID_InternalLogger, Name);
}
/// <summary>Creates a wrapper LMH that serves to Queue delivery of messages to the given targetLMH. Uses given maxQueueSize</summary>
public static ILogMessageHandler CreateQueueLogMessageHandler(ILogMessageHandler targetLMH, int maxQueueSize)
{
return new Handlers.QueueLogMessageHandler(targetLMH, maxQueueSize);
}
/// <summary>Creates a wrapper LMH that serves to Queue delivery of messages to the given targetLMH. Uses DefaultMesgQueueSize</summary>
public static ILogMessageHandler CreateQueueLogMessageHandler(ILogMessageHandler targetLMH)
{
return CreateQueueLogMessageHandler(targetLMH, DefaultMesgQueueSize);
}
