private void SetConfig(QueueConfig config)
{
if (config != null)
{
if (!config.Enabled)
_enabled = false;
_itemsPerDequeue = config.ItemsPerDequeue;
_maxCount = config.MaxCount;
_persistence = ErrorQueuePersistence.Initialize(config.PersistenceFolder, _nodeName, _itemsPerDequeue,
config.PersistenceFileSize, config.MaxPersistedMB,
DequeueAllMessages, ProbeMessages);
if (config.Enabled)
_enabled = true;
}
}
/// <summary>
/// Populates this error queue from the messages stored in a previous instance of the error queue.
/// </summary>
/// <remarks>
/// <para>
/// When an AppDomain restart occurs the error queues are serialized into the Forwarding component's
/// RunState. Upon restart they are deserialized and all messages from the memory queue from the old
/// AppDomain are copied into the error queues for the new AppDomain.
/// </para>
/// <para>
/// If persistent error queues are enabled then the memory queues will normally be empty as they are
/// flushed to perisistent storage before serializing the error queues.
/// </para>
/// </remarks>
/// <param name="errorQueue">The original error queue.</param>
/// <param name="incrementCounters">if set to <see langword="true"/> the performance counter for messages
/// in the error queue will be incremented by the number of messages in the source error queue.</param>
internal void Populate(ErrorQueue errorQueue, bool incrementCounters)
{
if (errorQueue.InMessageQueueCount == 0) return;
if (_persistence != null && !_persistence.CreateSpillFolder())
_persistence = null;
lock (_inMessageQueueLock)
{
SerializedRelayMessage[] curMessages = null;
if (InMessageQueue.Count > 0)
{
curMessages = InMessageQueue.ToArray();
InMessageQueue.Clear();
}
foreach (var message in errorQueue.InMessageQueue)
{
InMessageQueue.Enqueue(message);
}
if (curMessages != null)
{
foreach (var message in curMessages)
{
InMessageQueue.Enqueue(message);
}
}
}
if (incrementCounters)
{
NodeManager.Instance.Counters.IncrementErrorQueueBy(errorQueue.InMessageQueue.Count);
}
StartSpill();
}
/// <summary>
/// Initializes persistent error queues.
/// </summary>
/// <param name="rootFolder">The root folder for persistent error queue storage.</param>
/// <param name="nodeName">Name of the node. Used as a sub-folder name, for this node, under rootFolder.</param>
/// <param name="itemsPerFile">The number of messages per file.</param>
/// <param name="maxFileSize">The maximum file size in bytes.</param>
/// <param name="globalMaxMb">The maximum aggregate files sizes in MB. Zero is unlimited.</param>
/// <param name="getMessages">A delegate that will be called to retrieve messages from the <see cref="ErrorQueue"/>.</param>
/// <param name="probeMessages">A delegate that will be called to determine if the <see cref="ErrorQueue"/> has any
/// messages waiting to be persisted.</param>
/// <returns>An <see cref="ErrorQueuePersistence"/> object if persistence is enabled. Returns <see langword="null"/>
/// if persistence is disabled or the storage folder is inaccessable.</returns>
public static ErrorQueuePersistence Initialize(
string rootFolder,
string nodeName,
int itemsPerFile,
int maxFileSize,
int globalMaxMb,
Func <SerializedRelayMessage[]> getMessages,
Func <bool> probeMessages)
{
if (string.IsNullOrEmpty(rootFolder))
{
return(null);
}
if (nodeName == null)
{
throw new ArgumentNullException("nodeName");
}
if (nodeName == string.Empty)
{
throw new ArgumentException("Node name may not be empty.", "nodeName");
}
if (itemsPerFile <= 0)
{
throw new ArgumentException("Items per file must be greater than zero.", "itemsPerFile");
}
if (maxFileSize <= 0)
{
throw new ArgumentException("Max file size must be greater than zero.", "maxFileSize");
}
if (globalMaxMb < 0)
{
throw new ArgumentException("Global Max MB must be non-negative", "globalMaxMB");
}
if (getMessages == null)
{
throw new ArgumentNullException("getMessages");
}
if (probeMessages == null)
{
throw new ArgumentNullException("probeMessages");
}
try
{
var spillFolder = Path.Combine(rootFolder, nodeName);
var peristence = new ErrorQueuePersistence(spillFolder, nodeName, itemsPerFile, maxFileSize, getMessages, probeMessages);
GlobalMaxBytes = globalMaxMb > 0 ? globalMaxMb * 1024L * 1024L : long.MaxValue;
_log.DebugFormat("Persistent Error Queue Enabled for {0}: itemsPerFile={1}, maxFileSize={2}, maxTotalBytes={3}",
nodeName, itemsPerFile, maxFileSize, GlobalMaxBytes);
return(peristence);
}
catch (Exception e)
{
_log.Error("Exception initializing " + nodeName, e);
return(null);
}
}