internal void ProcessQueues()
{
if (Me == null) //out of network, we just need queues to go SOMEWHERE
{
Node currentNode;
for (int i = 0; i < Nodes.Count; i++)
{
currentNode = Nodes[i];
if (currentNode.DangerZone)
{
Node node = GetChosenNode();
if (node != null && !node.DangerZone)
{
SerializedMessageList errorsList = currentNode.DequeueErrors();
if (errorsList != null)
{
if (_log.IsInfoEnabled)
{
_log.InfoFormat("Using Node {0} to process {1} error queued messages from {2}",
node,
errorsList.InMessageCount,
currentNode.ToString());
}
// the message being processed is coming from a queue.
// In this case, we do not need to use setting to know
// if the queue should be used. Thus, no exception will be
// thrown, so we can send in "false" for "skipErrorQueueForSync
// without having to check the settings.
node.DoHandleInMessages(errorsList.InMessages, false);
}
}
}
else
{
currentNode.ProcessQueue();
}
}
}
else //in network, queues need to stay with the nodes that generated them
{
for (int i = 0; i < Nodes.Count; i++)
{
Nodes[i].ProcessQueue();
}
}
}
internal SerializedMessageList Dequeue()
{
SerializedMessageList list = null;
if (_enabled && InMessageQueueCount > 0)
{
int dequeueCount = 0;
list = new SerializedMessageList();
lock (_inMessageQueueLock)
{
for (; _inMessageQueue.Count > 0 && dequeueCount < _itemsPerDequeue; dequeueCount++)
{
list.Add(_inMessageQueue.Dequeue());
}
}
NodeManager.Instance.Counters.DecrementErrorQueueBy(list.InMessages.Count);
}
return(list);
}
/// <summary>
/// Dequeues a list of messages from the error queue. At most the number of messages
/// specified by the ItemsPerDequeue parameter of the QueueConfig will be returned.
/// </summary>
/// <returns>A <see cref="SerializedMessageList"/> containing the dequeued messages.</returns>
internal SerializedMessageList Dequeue()
{
SerializedMessageList list = null;
if (_enabled && InMessageQueueCount > 0)
{
list = new SerializedMessageList();
if (_persistence != null)
{
_persistence.Dequeue(list);
}
else
{
lock (_inMessageQueueLock)
{
for (int dequeueCount=0; _inMessageQueue.Count > 0 && dequeueCount < _itemsPerDequeue; dequeueCount++)
{
list.Add(_inMessageQueue.Dequeue());
}
}
}
// There is a slight possibility that _persistence.Dequeue can return no messages.
if (list.InMessages.Count == 0)
{
list = null;
}
else
{
NodeManager.Instance.Counters.DecrementErrorQueueBy(list.InMessages.Count);
}
}
return list;
}
internal SerializedMessageList Dequeue()
{
SerializedMessageList list = null;
if (_enabled && InMessageQueueCount > 0)
{
int dequeueCount = 0;
list = new SerializedMessageList();
lock (_inMessageQueueLock)
{
for (; _inMessageQueue.Count > 0 && dequeueCount < _itemsPerDequeue; dequeueCount++)
{
list.Add(_inMessageQueue.Dequeue());
}
}
NodeManager.Instance.Counters.DecrementErrorQueueBy(list.InMessages.Count);
}
return list;
}
/// <summary>
/// Dequeues persisted messages into the supplied <see cref="SerializedMessageList"/>.
/// </summary>
/// <remarks>
/// Each message file holds, at most, the number of messages specfied by the ItemsPerDequeue
/// QueueConfig" parameter. One file is deserialized per <see cref="Dequeue"/> call, so the
/// number of messages returned will not exceed ItemsPerDequeue.
/// </remarks>
/// <param name="messages">A <see cref="SerializedMessageList"/> into which the messages are stored.</param>
public void Dequeue(SerializedMessageList messages)
{
string path;
lock (_spillFiles)
{
// This should never happen.
if (_spillFiles.Count == 0)
{
return;
}
path = _spillFiles.Peek();
if (path == _currentSpillFilePath)
{
lock (_spillLock)
{
// We'll deadlock if we try to wait for the spill to complete, so bail-out.
if (_spillInProgress)
{
return;
}
_currentSpillFilePath = null;
}
}
_spillFiles.Dequeue();
}
try
{
using (var file = File.Open(path, FileMode.Open, FileAccess.Read))
{
var header = GetFileHeader(file);
IncrementGlobalFileSize(_nodeName, -file.Length);
for (int i = 0; i < header.MessageCount; ++i)
{
var message = Serializer.Deserialize <SerializedRelayMessage>(file);
messages.Add(message);
}
Interlocked.Add(ref _messageCount, -header.MessageCount);
}
File.Delete(path);
}
catch (Exception e)
{
_log.Error("Exception deserializing " + path, e);
if (File.Exists(path))
{
try
{
string newName = path.Replace(_spillFileExtension, ".error");
File.Delete(newName);
File.Move(path, newName);
}
catch (IOException ioex)
{
_log.Error("Exception renaming " + path, ioex);
}
}
throw;
}
}
