static List <int> SendMessages(int messageCount)
{
var transport = new MsmqTransport(QueueName, new ConsoleLoggerFactory(true));
MsmqUtil.EnsureQueueExists(MsmqUtil.GetPath(QueueName));
var sendIds = new List <int>();
Enumerable.Range(0, messageCount)
.Select(id => new SomeMessage {
Id = id
})
.ToList()
.ForEach(msg =>
{
using (var context = new DefaultTransactionContext())
{
transport.Send(QueueName, TransportMessageHelpers.FromString(JsonConvert.SerializeObject(msg)),
context).Wait();
context.Complete().Wait();
sendIds.Add(msg.Id);
}
});
return(sendIds);
}
void SendToErrorQueue(TransportMessage message)
{
Logger.InfoFormat("Send message to error queue, {0}", FaultManager.ErrorQueue);
message.ReplyToAddress = TransportMessageHelpers.GetOriginalReplyToAddressAndRemoveItFromHeaders(message);
MessageSender.Send(message, FaultManager.ErrorQueue);
}
public void The_default_time_out_should_be_1_day()
{
TransportMessageHelpers.SetHeader(_message, SecondLevelRetriesHeaders.RetriesTimestamp, DateTimeExtensions.ToWireFormattedString(DateTime.UtcNow.AddDays(-1).AddSeconds(-1)));
var hasTimedOut = DefaultRetryPolicy.RetryPolicy(_message) == TimeSpan.MinValue;
Assert.IsTrue(hasTimedOut);
}
public void Init()
{
// The default policy will defer the message 10*N (where N is number of retries) seconds 3 times. (60 sec total)
// For this sample we changed that to retry faster and only 3 times
SecondLevelRetries.RetryPolicy = (tm) =>
{
if (TransportMessageHelpers.GetNumberOfRetries(tm) >= 3)
{
// To send back a value less than zero tells the
// SecondLevelRetry satellite not to retry this message
// anymore.
return(TimeSpan.MinValue);
}
// If an exception is thrown within SLR, we should send the message
// direct to the error queue since we can't do anything with it.
// if (TransportMessageHelpers.GetNumberOfRetries(tm) == 1)
// {
// throw new Exception("This exception it thrown from SLR, message should go to error queue");
// }
// We will defer this message for 5 seconds, then send it back to the input queue (retry it)
return(TimeSpan.FromSeconds(5));
};
SecondLevelRetries.TimeoutPolicy = (tm) =>
{
// This is used as a last chance to abort the retry logic.
// Retry according to the RetryPolicy Func, but not longer than this.
// In this case, we're just returning false, the retry timeout for this message never times out.
return(false);
};
}
static bool HasReachedMaxTime(TransportMessage message)
{
var timestampHeader = TransportMessageHelpers.GetHeader(message, SecondLevelRetriesHeaders.RetriesTimestamp);
if (String.IsNullOrEmpty(timestampHeader))
{
return(false);
}
try
{
var handledAt = DateTimeExtensions.ToUtcDateTime(timestampHeader);
if (DateTime.UtcNow > handledAt.AddDays(1))
{
return(true);
}
}
// ReSharper disable once EmptyGeneralCatchClause
// this code won't usually throw but in case a user has decided to hack a message/headers and for some bizarre reason
// they changed the date and that parse fails, we want to make sure that doesn't prevent the message from being
// forwarded to the error queue.
catch (Exception)
{
}
return(false);
}
public void A_message_should_only_be_able_to_retry_during_N_minutes()
{
TransportMessageHelpers.SetHeader(message, Faults.FaultsHeaderKeys.FailedQ, "reply@address");
TransportMessageHelpers.SetHeader(message, SecondLevelRetriesHeaders.RetriesTimestamp, DateTimeExtensions.ToWireFormattedString(DateTime.Now.AddDays(-2)));
satellite.Handle(message);
Assert.AreEqual(ERROR_QUEUE, messageSender.MessageSentTo);
}
public void Message_should_be_sent_to_retryQ_if_defer_timespan_is_greater_than_zero()
{
TransportMessageHelpers.SetHeader(_message, Faults.FaultsHeaderKeys.FailedQ, "reply@address");
SecondLevelRetries.RetryPolicy = _ => { return(TimeSpan.FromSeconds(1)); };
_satellite.Handle(_message);
Assert.AreEqual(TIMEOUT_MANAGER_QUEUE, _messageSender.MessageSentTo);
}
public void The_original_senders_address_should_be_used_as_ReplyToAddress()
{
TransportMessageHelpers.SetHeader(_message, Faults.FaultsHeaderKeys.FailedQ, ORIGINAL_QUEUE.ToString());
SecondLevelRetries.RetryPolicy = _ => { return(TimeSpan.FromSeconds(1)); };
_satellite.Handle(_message);
Assert.AreEqual(ORIGINAL_QUEUE, _message.ReplyToAddress);
}
public void A_message_should_only_be_able_to_retry_during_N_minutes()
{
TransportMessageHelpers.SetHeader(_message, Faults.FaultsHeaderKeys.FailedQ, "reply@address");
SecondLevelRetries.TimeoutPolicy = _ => { return(true); };
_satellite.Handle(_message);
Assert.AreEqual(ERROR_QUEUE, _messageSender.MessageSentTo);
}
public void Message_should_be_routed_to_the_failing_endpoint_when_the_time_is_up()
{
TransportMessageHelpers.SetHeader(message, Faults.FaultsHeaderKeys.FailedQ, ORIGINAL_QUEUE.ToString());
satellite.RetryPolicy = _ => TimeSpan.FromSeconds(1);
satellite.Handle(message);
Assert.AreEqual(ORIGINAL_QUEUE, deferrer.MessageRoutedTo);
}
public void Message_should_be_routed_to_the_failing_endpoint_when_the_time_is_up()
{
TransportMessageHelpers.SetHeader(_message, Faults.FaultsHeaderKeys.FailedQ, ORIGINAL_QUEUE.ToString());
SecondLevelRetries.RetryPolicy = _ => { return(TimeSpan.FromSeconds(1)); };
_satellite.Handle(_message);
Assert.AreEqual(ORIGINAL_QUEUE.ToString(), _message.Headers[Headers.RouteExpiredTimeoutTo]);
}
public void Message_should_be_sent_to_real_errorQ_if_defer_timeSpan_is_less_than_zero()
{
TransportMessageHelpers.SetHeader(message, Faults.FaultsHeaderKeys.FailedQ, "reply@address");
satellite.RetryPolicy = _ => TimeSpan.MinValue;
satellite.Handle(message);
Assert.AreEqual(ERROR_QUEUE, messageSender.MessageSentTo);
}
public void Message_should_be_sent_to_retryQ_if_defer_timeSpan_is_greater_than_zero()
{
TransportMessageHelpers.SetHeader(message, Faults.FaultsHeaderKeys.FailedQ, "reply@address");
satellite.RetryPolicy = _ => TimeSpan.FromSeconds(1);
satellite.Handle(message);
Assert.AreEqual(message, deferrer.DeferredMessage);
}
public static TimeSpan Validate(TransportMessage message)
{
var numberOfRetries = TransportMessageHelpers.GetNumberOfRetries(message);
var timeToIncreaseInTicks = TimeIncrease.Ticks * (numberOfRetries + 1);
var timeIncrease = TimeSpan.FromTicks(timeToIncreaseInTicks);
return(numberOfRetries >= NumberOfRetries ? TimeSpan.MinValue : timeIncrease);
}
public void Message_should_only_be_retried_X_times_when_using_the_defaultPolicy()
{
TransportMessageHelpers.SetHeader(message, Faults.FaultsHeaderKeys.FailedQ, "reply@address");
for (var i = 0; i < DefaultRetryPolicy.NumberOfRetries + 1; i++)
{
satellite.Handle(message);
}
Assert.AreEqual(ERROR_QUEUE, messageSender.MessageSentTo);
}
public void For_each_retry_the_NServiceBus_Retries_header_should_be_increased()
{
TransportMessageHelpers.SetHeader(message, Faults.FaultsHeaderKeys.FailedQ, "reply@address");
satellite.RetryPolicy = _ => TimeSpan.FromSeconds(1);
for (var i = 0; i < 10; i++)
{
satellite.Handle(message);
}
Assert.AreEqual(10, TransportMessageHelpers.GetNumberOfRetries(message));
}
public void Message_should_only_be_retried_X_times_when_using_the_defaultPolicy()
{
TransportMessageHelpers.SetHeader(_message, Faults.FaultsHeaderKeys.FailedQ, "reply@address");
// default policy is to retry once every minute for 30 minutes
for (int i = 0; i < 31; i++)
{
_satellite.Handle(_message);
}
Assert.AreEqual(ERROR_QUEUE, _messageSender.MessageSentTo);
}
public void Message_retries_header_should_be_removed_before_being_sent_to_real_errorQ()
{
TransportMessageHelpers.SetHeader(message, Faults.FaultsHeaderKeys.FailedQ, "reply@address");
satellite.Handle(message);
TransportMessageHelpers.SetHeader(message, SecondLevelRetriesHeaders.RetriesTimestamp, DateTimeExtensions.ToWireFormattedString(DateTime.Now.AddDays(-2)));
satellite.Handle(message);
Assert.False(message.Headers.ContainsKey(Headers.Retries));
}
public void Message_should_have_ReplyToAddress_set_to_original_sender_when_sent_to_real_error_queue_after_retries()
{
TransportMessageHelpers.SetHeader(message, Faults.FaultsHeaderKeys.FailedQ, "reply@address");
var expected = new Address("clientQ", "myMachine");
message.ReplyToAddress = expected;
for (var i = 0; i < DefaultRetryPolicy.NumberOfRetries + 1; i++)
{
satellite.Handle(message);
}
Assert.AreEqual(expected, message.ReplyToAddress);
}
void Defer(TimeSpan defer, TransportMessage message)
{
message.ReplyToAddress = TransportMessageHelpers.GetReplyToAddress(message);
TransportMessageHelpers.SetHeader(message, Headers.Expire, (DateTime.UtcNow + defer).ToWireFormattedString());
TransportMessageHelpers.SetHeader(message, SecondLevelRetriesHeaders.Retries, (TransportMessageHelpers.GetNumberOfRetries(message) + 1).ToString());
if (!TransportMessageHelpers.HeaderExists(message, SecondLevelRetriesHeaders.RetriesTimestamp))
{
TransportMessageHelpers.SetHeader(message, SecondLevelRetriesHeaders.RetriesTimestamp, DateTime.UtcNow.ToWireFormattedString());
}
Logger.InfoFormat("Defer message and send it to {0} using the timeout manager at {1}", message.ReplyToAddress, TimeoutManagerAddress);
MessageSender.Send(message, TimeoutManagerAddress);
}
protected override void Send(Unicast.Transport.TransportMessage message, Address errorQueue)
{
var failedQ = TransportMessageHelpers.GetReplyToAddress(message);
var sat = Configure.Instance.Builder.Build <SecondLevelRetries>();
if (failedQ == sat.InputAddress)
{
Logger.InfoFormat("The message was sent from the SecondLevelRetries satellite. Sending the message direct to the error queue!");
base.Send(message, sat.ErrorQueue);
return;
}
base.Send(message, errorQueue);
}
void Defer(TimeSpan defer, TransportMessage message)
{
TransportMessageHelpers.SetHeader(message, Headers.Expire, (DateTime.UtcNow + defer).ToWireFormattedString());
TransportMessageHelpers.SetHeader(message, Headers.Retries, (TransportMessageHelpers.GetNumberOfRetries(message) + 1).ToString());
var faultingEndpointAddress = TransportMessageHelpers.GetAddressOfFaultingEndpoint(message);
//tell the TM to route this message to the endpoint where this message failed
TransportMessageHelpers.SetHeader(message, Headers.RouteExpiredTimeoutTo, faultingEndpointAddress.ToString());
if (!TransportMessageHelpers.HeaderExists(message, SecondLevelRetriesHeaders.RetriesTimestamp))
{
TransportMessageHelpers.SetHeader(message, SecondLevelRetriesHeaders.RetriesTimestamp, DateTime.UtcNow.ToWireFormattedString());
}
Logger.DebugFormat("Defer message and send it to {0} using the timeout manager at {1}", faultingEndpointAddress, TimeoutManagerAddress);
MessageSender.Send(message, TimeoutManagerAddress);
}
void Defer(TimeSpan defer, TransportMessage message)
{
var retryMessageAt = DateTime.UtcNow + defer;
TransportMessageHelpers.SetHeader(message, Headers.Retries,
(TransportMessageHelpers.GetNumberOfRetries(message) + 1).ToString(CultureInfo.InvariantCulture));
var addressOfFaultingEndpoint = TransportMessageHelpers.GetAddressOfFaultingEndpoint(message);
if (!TransportMessageHelpers.HeaderExists(message, SecondLevelRetriesHeaders.RetriesTimestamp))
{
TransportMessageHelpers.SetHeader(message, SecondLevelRetriesHeaders.RetriesTimestamp,
DateTimeExtensions.ToWireFormattedString(DateTime.UtcNow));
}
logger.DebugFormat("Defer message and send it to {0}", addressOfFaultingEndpoint);
MessageDeferrer.Defer(message, retryMessageAt, addressOfFaultingEndpoint);
}
public static bool HasTimedOut(TransportMessage message)
{
var timestampHeader = TransportMessageHelpers.GetHeader(message, SecondLevelRetriesHeaders.RetriesTimestamp);
try
{
var handledAt = timestampHeader.ToUtcDateTime();
if (DateTime.UtcNow > handledAt.AddDays(1))
{
return(true);
}
}
catch (Exception)
{
return(false);
}
return(false);
}
static bool HasReachedMaxTime(TransportMessage message)
{
var timestampHeader = TransportMessageHelpers.GetHeader(message, SecondLevelRetriesHeaders.RetriesTimestamp);
if (String.IsNullOrEmpty(timestampHeader))
{
return(false);
}
try
{
var handledAt = DateTimeExtensions.ToUtcDateTime(timestampHeader);
if (DateTime.UtcNow > handledAt.AddDays(1))
{
return(true);
}
}
catch (Exception)
{
}
return(false);
}
private void Defer()
{
TransportMessageHelpers.SetHeader(_message, Headers.Retries, (TransportMessageHelpers.GetNumberOfRetries(_message) + 1).ToString());
}
