public void IsLimitExceeded_return_false_untill_specified_limit_reached()
{
const int retryLimit = 5;
var tracker = new MessageRetryTracker(retryLimit);
const string id = "qelofjsw";
for (int i = 0; i < retryLimit; i++)
{
Assert.IsFalse(tracker.IsRetryLimitExceeded(id));
tracker.IncrementRetryCount(id);
}
Assert.IsTrue(tracker.IsRetryLimitExceeded(id));
}
public void Should_return_false_until_the_limit_is_exceeded()
{
const int retryLimit = 5;
var tracker = new MessageRetryTracker(retryLimit);
const string id = "qelofjsw";
Exception ex;
for (int i = 0; i < retryLimit; i++)
{
Assert.IsFalse(tracker.IsRetryLimitExceeded(id, out ex));
tracker.IncrementRetryCount(id, ex);
}
Assert.IsTrue(tracker.IsRetryLimitExceeded(id, out ex));
}
public void Should_reset_once_the_message_was_received()
{
const int retryLimit = 5;
var tracker = new MessageRetryTracker(retryLimit);
const string id = "qelofjsw";
Assert.IsFalse(tracker.IsRetryLimitExceeded(id));
tracker.IncrementRetryCount(id);
tracker.MessageWasReceivedSuccessfully(id);
for (int i = 0; i < retryLimit; i++)
{
Assert.IsFalse(tracker.IsRetryLimitExceeded(id));
tracker.IncrementRetryCount(id);
}
Assert.IsTrue(tracker.IsRetryLimitExceeded(id));
}
public void Receive(Func <IReceiveContext, Action <IReceiveContext> > receiver, TimeSpan timeout)
{
if (_disposed)
{
throw new ObjectDisposedException(_disposedMessage);
}
string successfulMessageId = null;
try
{
Exception failedMessageException = null;
_transport.Receive(acceptContext =>
{
failedMessageException = null;
if (successfulMessageId != null)
{
_log.DebugFormat("Received Successfully: {0}", successfulMessageId);
_tracker.MessageWasReceivedSuccessfully(successfulMessageId);
successfulMessageId = null;
}
Exception retryException;
if (_tracker.IsRetryLimitExceeded(acceptContext.MessageId, out retryException))
{
if (_log.IsErrorEnabled)
{
_log.ErrorFormat("Message retry limit exceeded {0}:{1}", Address,
acceptContext.MessageId);
}
failedMessageException = retryException;
return(MoveMessageToErrorTransport);
}
Action <IReceiveContext> receive;
try
{
acceptContext.SetEndpoint(this);
_serializer.Deserialize(acceptContext);
receive = receiver(acceptContext);
if (receive == null)
{
Address.LogSkipped(acceptContext.MessageId);
_tracker.IncrementRetryCount(acceptContext.MessageId, null);
return(null);
}
}
catch (SerializationException sex)
{
if (_log.IsErrorEnabled)
{
_log.Error("Unrecognized message " + Address + ":" + acceptContext.MessageId, sex);
}
_tracker.IncrementRetryCount(acceptContext.MessageId, sex);
return(MoveMessageToErrorTransport);
}
catch (Exception ex)
{
if (_log.IsErrorEnabled)
{
_log.Error("An exception was thrown preparing the message consumers", ex);
}
_tracker.IncrementRetryCount(acceptContext.MessageId, ex);
return(null);
}
return(receiveContext =>
{
bool receivedSuccessfully;
try
{
receive(receiveContext);
// _tracker.MessageWasReceivedSuccessfully(receiveContext.MessageId);
receivedSuccessfully = true;
}
catch (MessageNotConsumedException ex)
{
receivedSuccessfully = false;
_tracker.MessageWasReceivedSuccessfully(receiveContext.MessageId);
MoveMessageToErrorTransport(receiveContext);
}
catch (Exception ex)
{
receivedSuccessfully = false;
if (_log.IsErrorEnabled)
{
_log.Error("An exception was thrown by a message consumer", ex);
}
_tracker.IncrementRetryCount(receiveContext.MessageId, ex);
MoveMessageToErrorTransport(receiveContext);
}
if (receivedSuccessfully)
{
successfulMessageId = receiveContext.MessageId;
}
});
}, timeout);
if (failedMessageException != null)
{
_log.DebugFormat("Throwing Original Exception: {0}", failedMessageException.GetType());
throw failedMessageException;
}
}
catch (Exception ex)
{
if (successfulMessageId != null)
{
_log.DebugFormat("Increment Retry Count: {0}", successfulMessageId);
_tracker.IncrementRetryCount(successfulMessageId, ex);
successfulMessageId = null;
}
throw;
}
finally
{
if (successfulMessageId != null)
{
_log.DebugFormat("Received Successfully: {0}", successfulMessageId);
_tracker.MessageWasReceivedSuccessfully(successfulMessageId);
successfulMessageId = null;
}
}
}
public void Receive(Func <IReceiveContext, Action <IReceiveContext> > receiver, TimeSpan timeout)
{
if (_disposed)
{
throw new ObjectDisposedException(_disposedMessage);
}
_transport.Receive(acceptContext =>
{
if (_tracker.IsRetryLimitExceeded(acceptContext.MessageId))
{
if (_log.IsErrorEnabled)
{
_log.ErrorFormat("Message retry limit exceeded {0}:{1}", Address, acceptContext.MessageId);
}
return(MoveMessageToErrorTransport);
}
Action <IReceiveContext> receive;
try
{
_serializer.Deserialize(acceptContext);
acceptContext.SetEndpoint(this);
receive = receiver(acceptContext);
if (receive == null)
{
return(null);
}
}
catch (SerializationException sex)
{
if (_log.IsErrorEnabled)
{
_log.Error("Unrecognized message " + Address + ":" + acceptContext.MessageId, sex);
}
_tracker.IncrementRetryCount(acceptContext.MessageId);
return(MoveMessageToErrorTransport);
}
catch (Exception ex)
{
if (_log.IsErrorEnabled)
{
_log.Error("An exception was thrown preparing the message consumers", ex);
}
_tracker.IncrementRetryCount(acceptContext.MessageId);
return(null);
}
return(receiveContext =>
{
try
{
receive(receiveContext);
_tracker.MessageWasReceivedSuccessfully(receiveContext.MessageId);
}
catch (Exception ex)
{
if (_log.IsErrorEnabled)
{
_log.Error("An exception was thrown by a message consumer", ex);
}
_tracker.IncrementRetryCount(receiveContext.MessageId);
MoveMessageToErrorTransport(receiveContext);
}
});
}, timeout);
}