protected override void StartReceive(TimeSpan fromSeconds)
{
if (RunningChannelSpec.Instance.IsSatisfiedBy(this))
{
_messageQueue.BeginReceive(fromSeconds);
}
else
{
ReadingQueue = false;
}
}
void Process()
{
this.queue = QueueManager.GetQueue(this.QueueName);
if (null == this.queue)
{
throw new ArgumentOutOfRangeException("QueueName", string.Format("Not find the queue : {0}", this.QueueName));
}
this.queue.ReceiveCompleted += message => queue_ReceiveCompleted(message);
queue.BeginReceive();
}
private void ReceiveFromQueue(IMessageQueue queue)
{
using (CancellationTokenSource tokenSource = new CancellationTokenSource())
{
Task task = Task.Run(() =>
{
while (!tokenSource.Token.IsCancellationRequested)
{
queue.BeginReceive();
}
}, tokenSource.Token);
tokenSource.CancelAfter(TimeSpan.FromSeconds(1));
Task.WaitAll(task);
}
}
private void BeginReceive()
{
while (ListQueues != null && TokenSource != null && !TokenSource.Token.IsCancellationRequested)
{
List <string> keys = ListQueues.Keys.ToList();
foreach (string topic in keys)
{
IMessageQueue queue = ListQueues[topic];
if (queue != null)
{
queue.BeginReceive();
}
}
}
}
void queue_ReceiveCompleted(object message)
{
AppInstance.GetThreadPool().QueueWorkItem(() =>
{
if (false == (message is ILogEntry))
{
var filePath = string.Format("logs\\{0}-{1}.log", message.GetType().Name, DateTime.Now.ToString("yyyy-MM-dd-hh"));
var content = message.ToText();
Console.WriteLine(content);
FileHelper.WriteInfo(filePath, content);
}
else
{
SaveLogEntry(message as ILogEntry);
}
});
queue.BeginReceive();
}
public void Start()
{
_messageQueue.ReceiveCompleted += _IMessageQueue_ReceiveCompleted;
_messageQueue.BeginReceive(_defaultTimeout);
}
public IAsyncResult BeginReceive()
{
return(delegateQueue.BeginReceive());
}
/// <summary>
/// Begin listening for <see cref="IMessage"/>s on the <see cref="IMessageQueue"/>
/// </summary>
public void StartListening()
{
_queue.BeginReceive();
}
private void Run()
{
Logger.Info("Reading for queue {0} was started", this.m_Queue.QueueName);
if (m_Queue.Timeout.HasValue)
{
m_Queue.SetTimeout();
}
long tooManyErrorCount = 0;
var lastSentError = DateTime.MinValue;
bool fatalSent = false;
while (!m_Terminated &&
m_Queue != null)
{
IAsyncResult result = null;
try
{
result = m_Queue.BeginReceive();
}
catch (Exception ex)
{
Logger.Error(ex);
System.Threading.Thread.Sleep(500);
continue;
}
if (result == null)
{
continue;
}
var waitHandles = new WaitHandle[] { m_EventStop, result.AsyncWaitHandle };
int index = 0;
if (m_Queue.Timeout.HasValue)
{
index = WaitHandle.WaitAny(waitHandles, m_Queue.Timeout.Value);
}
else
{
index = WaitHandle.WaitAny(waitHandles);
}
if (index == 0)
{
m_Terminated = true;
break;
}
else if (index == 258) // Timeout
{
m_Queue.SetTimeout();
Elapsed();
continue;
}
T message = default(T);
try
{
message = m_Queue.EndReceive <T>(result);
}
catch (Exception ex)
{
if ((DateTime.Now - lastSentError).TotalMilliseconds > 1000)
{
Logger.Error(ex);
lastSentError = DateTime.Now;
}
else
{
tooManyErrorCount++;
}
if (!fatalSent &&
tooManyErrorCount > 100)
{
Logger.Fatal("Too many error {0}", ex.Message);
tooManyErrorCount = 0;
fatalSent = true;
}
}
finally
{
m_Queue.Reset();
}
if (message == null)
{
continue;
}
ProcessMessage(message);
}
}
