/// <summary>
/// ACKs the message by deleting it from the queue.
/// </summary>
/// <param name="message">The message context to ACK.</param>
public void AckMessage(MessageTransportContext message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
this._queue.DeleteMessage(( CloudQueueMessage )message.TransportMessage);
}
public void AckMessage(MessageTransportContext message)
{
foreach (var queue in _readers)
{
if (queue.Name == message.QueueName)
{
queue.AckMessage(message);
}
}
}
public void when_reader_ack_messages()
{
_queueWriter.PutMessage(Encoding.UTF8.GetBytes("message"));
var msg = _statelessReader.TryGetMessage();
var transportContext = new MessageTransportContext(
msg.Message.TransportMessage
, msg.Message.Unpacked
, msg.Message.QueueName);
_queueReader.AckMessage(transportContext);
var msg2 = _statelessReader.TryGetMessage();
Assert.AreEqual(GetEnvelopeResultState.Empty, msg2.State);
}
void ProcessMessage(MessageTransportContext context)
{
var dispatched = false;
try
{
_dispatcher(context.Unpacked);
dispatched = true;
}
catch (ThreadAbortException)
{
// we are shutting down. Stop immediately
return;
}
catch (Exception dispatchEx)
{
// if the code below fails, it will just cause everything to be reprocessed later,
// which is OK (duplication manager will handle this)
SystemObserver.Notify(new MessageDispatchFailed(context, context.QueueName, dispatchEx));
// quarantine is atomic with the processing
_inbox.TryNotifyNack(context);
}
if (!dispatched)
{
return;
}
try
{
_inbox.AckMessage(context);
// 3rd - notify.
SystemObserver.Notify(new MessageAcked(context));
}
catch (ThreadAbortException)
{
// nothing. We are going to sleep
}
catch (Exception ex)
{
// not a big deal. Message will be processed again.
SystemObserver.Notify(new MessageAckFailed(ex, context));
}
}
public bool TakeMessage(CancellationToken token, out MessageTransportContext context)
{
while (!token.IsCancellationRequested)
{
for (var i = 0; i < _readers.Length; i++)
{
var queue = _readers[i];
var message = queue.TryGetMessage();
switch (message.State)
{
case GetEnvelopeResultState.Success:
_emptyCycles = 0;
context = message.Message;
return(true);
case GetEnvelopeResultState.Empty:
_emptyCycles += 1;
break;
case GetEnvelopeResultState.Exception:
// access problem, fall back a bit
break;
case GetEnvelopeResultState.Retry:
// this could be the poison
break;
default:
throw new ArgumentOutOfRangeException();
}
var waiting = _waiter(_emptyCycles);
token.WaitHandle.WaitOne(waiting);
}
}
context = null;
return(false);
}
public void TryNotifyNack(MessageTransportContext context)
{
}
public MessageAcked(MessageTransportContext attributes)
{
Context = attributes;
}
public DispatchRecoveryFailed(Exception exception, MessageTransportContext message, string queueName)
{
DispatchException = exception;
Message = message;
QueueName = queueName;
}
public bool TakeMessage(CancellationToken token, out MessageTransportContext context)
{
context = new MessageTransportContext(null, new byte[0], "Name");
return(false);
}
public void AckMessage(MessageTransportContext message)
{
}
public MessageDispatchFailed(MessageTransportContext message, string queueName, Exception exception)
{
Exception = exception;
Message = message;
QueueName = queueName;
}
public MessageAckFailed(Exception exception, MessageTransportContext context)
{
Exception = exception;
Context = context;
}
