public async Task IncludesFullErrorDetailsWhenSecondLevelRetriesFailToo()
{
var counter = new SharedCounter(1);
Using(counter);
_activator.Handle <string>(async str =>
{
throw new ApplicationException("1st level!!");
});
_activator.Handle <IFailed <string> >(async failed =>
{
throw new ApplicationException("2nd level!!");
});
await _bus.SendLocal("hej med dig!");
var transportMessage = await _network.WaitForNextMessageFrom("error");
var errorDetails = transportMessage.Headers[Headers.ErrorDetails];
Console.WriteLine(errorDetails);
Assert.That(errorDetails, Does.Contain("1st level!!"));
Assert.That(errorDetails, Does.Contain("2nd level!!"));
}
public async Task CanForwardToMultipleRecipients()
{
var network = new InMemNetwork();
var activator = new BuiltinHandlerActivator();
Using(activator);
var recipients = new[] { "recipient-A", "recipient-B" }.ToList();
recipients.ForEach(network.CreateQueue);
Configure.With(activator)
.Transport(t => t.UseInMemoryTransport(network, "forwarder"))
.Routing(t =>
{
t.AddTransportMessageForwarder(async transportMessage => ForwardAction.ForwardTo(recipients));
})
.Start();
await activator.Bus.SendLocal("HEJ MED DIG!!!");
var transportMessages = await Task.WhenAll(recipients.Select(async queue =>
{
var message = await network.WaitForNextMessageFrom(queue);
return(message);
}));
Assert.That(transportMessages.Length, Is.EqualTo(2));
}
public async Task CanRevealNumberOfRetries()
{
var retryCounts = new ConcurrentQueue <int>();
var activator = Using(new BuiltinHandlerActivator());
// create random header key every time to verify that it is actually used
var headerKey = $"retry-count/{Guid.NewGuid()}";
activator.Handle <Fail>(async(_, context, _) =>
{
Console.WriteLine($@"Got message {context.TransportMessage.GetMessageId()}:
{string.Join(Environment.NewLine, context.Headers.Select(kvp => $" {kvp.Key}: {kvp.Value}"))}");
retryCounts.Enqueue(int.Parse(context.Headers.GetValue(headerKey)));
throw new Exception("oh no!");
});
var network = new InMemNetwork();
var bus = Configure.With(activator)
.Transport(t => t.UseInMemoryTransport(network, "who-cares"))
.Options(o => o.AddRetryCountHeader(key: headerKey))
.Options(o => o.LogPipeline(verbose: true))
.Start();
// send message that will fail
await bus.SendLocal(new Fail());
// wait until the message is dead-lettered
_ = await network.WaitForNextMessageFrom("error");
Assert.That(retryCounts.Count, Is.EqualTo(5));
Assert.That(retryCounts.ToArray(), Is.EqualTo(new[] { 0, 1, 2, 3, 4 }));
}
public async Task CanMoveMessageToErrorQueueEvenThoughExceptionIsNotSerializable()
{
using (var activator = new BuiltinHandlerActivator())
{
activator.Handle <string>(async str =>
{
throw new ThisOneCannotBeSerialized("BAM!!!!!!!!!!!11111111111111111");
});
var network = new InMemNetwork();
var bus = Configure.With(activator)
.Transport(t => t.UseInMemoryTransport(network, "unserializable exceptions"))
.Options(o => o.SimpleRetryStrategy(maxDeliveryAttempts: 1))
.Start();
const string knownString = "JUST SOME LISP!!!!11((((((((((((((((((()))))))))))))))))))))))";
await bus.SendLocal(knownString);
var failedMessage = await network.WaitForNextMessageFrom("error");
Assert.That(Encoding.UTF8.GetString(failedMessage.Body), Is.EqualTo(JsonConvert.SerializeObject(knownString)));
}
}
public async Task ItWorks()
{
var network = new InMemNetwork();
var builder = new ContainerBuilder();
var stuff = new ConcurrentQueue <string>();
builder.RegisterInstance(stuff);
builder.RegisterRebus(configure =>
configure
.Logging(l => l.None())
.Transport(t => t.UseInMemoryTransport(network, "test"))
.Options(o => o.SimpleRetryStrategy(secondLevelRetriesEnabled: true, maxDeliveryAttempts: 1))
);
builder.RegisterHandler <MyTestHandler>();
await using var container = builder.Build();
var bus = container.Resolve <IBus>();
Console.WriteLine("Sending message");
await bus.SendLocal("hej søtte!");
Console.WriteLine("Waiting for message to arrive in queue 'done'...");
await network.WaitForNextMessageFrom("done");
Console.WriteLine("Got the message!");
Assert.That(stuff.Count, Is.EqualTo(1),
"Expected second level handler to have been called only once!!");
}
public async Task CopiesProperlyHandledMessageToAuditQueue()
{
var gotTheMessage = new ManualResetEvent(false);
_adapter.Handle <string>(async _ =>
{
gotTheMessage.Set();
});
await _bus.SendLocal("woohooo!!!!");
gotTheMessage.WaitOrDie(TimeSpan.FromSeconds(5));
var message = await _network.WaitForNextMessageFrom("audit");
PrintHeaders(message);
Assert.That(message.Headers.ContainsKey(AuditHeaders.AuditTime));
Assert.That(message.Headers.ContainsKey(AuditHeaders.HandleTime));
Assert.That(message.Headers.ContainsKey(Headers.Intent));
Assert.That(message.Headers[Headers.Intent], Is.EqualTo(Headers.IntentOptions.PointToPoint));
}
public async Task ItWorks()
{
const int numberOfRetries = 5;
InitializeBus(numberOfRetries);
var attemptedDeliveries = 0;
_handlerActivator.AddHandlerWithBusTemporarilyStopped <string>(async _ =>
{
Interlocked.Increment(ref attemptedDeliveries);
throw new RebusApplicationException("omgwtf!");
});
await _bus.Send("hej");
var failedMessage = await _network.WaitForNextMessageFrom(ErrorQueueName);
Assert.That(attemptedDeliveries, Is.EqualTo(numberOfRetries));
Assert.That(failedMessage.Headers.GetValue(Headers.ErrorDetails), Contains.Substring("5 unhandled exceptions"));
Assert.That(failedMessage.Headers.GetValue(Headers.SourceQueue), Is.EqualTo(InputQueueName));
}
public async Task DeferredMessageHasDeferCountOf1()
{
var bus = _starter.Start();
await bus.Defer(TimeSpan.FromSeconds(0.001), "HEJ MED DIG MIN VEN");
var message = await _network.WaitForNextMessageFrom(DestinationAddress);
var headers = message.Headers;
Assert.That(headers.Keys, Contains.Item("rbs2-defer-count"));
Assert.That(int.Parse(headers["rbs2-defer-count"]), Is.EqualTo(1));
}
public async Task CanRetryForever()
{
const string recipientQueueName = "recipient";
var network = new InMemNetwork();
var activator = new BuiltinHandlerActivator();
Using(activator);
network.CreateQueue(recipientQueueName);
var bus = GetFailingBus(activator, network, recipientQueueName, ErrorBehavior.RetryForever);
await bus.SendLocal("HEJ MED DIG!!!");
var message = await network.WaitForNextMessageFrom(recipientQueueName);
Assert.That(Encoding.UTF8.GetString(message.Body), Is.EqualTo(@"""HEJ MED DIG!!!"""));
}
public async Task ContinuationsCanStillUseTheBus()
{
const string queueName = "another-queue";
_network.CreateQueue(queueName);
_activator.Bus.Advanced.Workers.SetNumberOfWorkers(1);
var gotMessage = new ManualResetEvent(false);
var doneHandlingMessage = new ManualResetEvent(false);
_activator.Handle <string>(async(bus, message) =>
{
gotMessage.Set();
Printt("Got message - waiting 3 s...");
await Task.Delay(3000);
Printt("Done waiting :)");
await bus.Advanced.Routing.Send(queueName, "JAJA DET VIRKER!");
doneHandlingMessage.Set();
});
// send message
await _activator.Bus.SendLocal("hej med dig");
// wait for message to be received and then immediately shutdown the bus
gotMessage.WaitOrDie(TimeSpan.FromSeconds(3), "Did not receive message within timeout");
CleanUpDisposables();
// wait for message to have been handled to end
doneHandlingMessage.WaitOrDie(TimeSpan.FromSeconds(6), "Did not finish handling the message within expected timeframe");
// wait for message to pop up in the expected queue
var transportMessage = await _network.WaitForNextMessageFrom(queueName);
Assert.That(Encoding.UTF8.GetString(transportMessage.Body), Is.EqualTo(@"""JAJA DET VIRKER!"""));
}
public async Task CanFailFastAndForwardToErrorQueue()
{
const string recipientQueueName = "recipient";
var network = new InMemNetwork();
var activator = new BuiltinHandlerActivator();
Using(activator);
network.CreateQueue(recipientQueueName);
var bus = GetFailingBus(activator, network, recipientQueueName, ErrorBehavior.ForwardToErrorQueue);
await bus.SendLocal("HEJ MED DIG!!!");
var message = await network.WaitForNextMessageFrom("error");
Assert.That(Encoding.UTF8.GetString(message.Body), Is.EqualTo(@"""HEJ MED DIG!!!"""));
Assert.That(message.Headers.GetValueOrNull(Headers.SourceQueue), Is.EqualTo("forwarder"));
Assert.That(message.Headers.GetValueOrNull(Headers.ErrorDetails), Does.Contain("fake an error"));
}
public async Task ComeOn_InMemory()
{
using var activator = new BuiltinHandlerActivator();
activator.Register((bús, context) => new TestMessageHandler(context, bús.Advanced.TransportMessage));
var network = new InMemNetwork();
var bus = Configure.With(activator)
.Logging(l => l.None())
.Transport(t => t.UseInMemoryTransport(network, "whatever-man"))
.Options(o => o.SimpleRetryStrategy(secondLevelRetriesEnabled: true))
.Timeouts(t => t.StoreInMemory())
.Start();
await bus.SendLocal(new TestMessage("yo!"));
var message = await network.WaitForNextMessageFrom("error", timeoutSeconds : 25);
Assert.That(message.DeserializeTo <TestMessage>().Text, Is.EqualTo("yo!"));
}
public async Task ErrorInErrorQueue()
{
var network = new InMemNetwork();
var activator = Using(new BuiltinHandlerActivator());
// count send operations to error queue with this one
var sendToErrorQueueAttempts = 0;
// hook into send operations
void SendCallback(string queue)
{
if (queue != "error")
{
return; //< don't care about other queues
}
sendToErrorQueueAttempts++;
// fail on the very first attempt
if (sendToErrorQueueAttempts == 1)
{
throw new ApplicationException("FAILURE ON FIRST ATTEMPT!");
}
}
Configure.With(activator)
.Transport(t => t.UseInMemoryTransport(network, "whatever"))
.Routing(r => r.AddTransportMessageForwarder(async msg => throw new AbandonedMutexException("oh no it's been abandoned")))
.Options(o => o.Decorate <ITransport>(c => new FailureTransportDecorator(SendCallback, c.Get <ITransport>())))
.Start();
await activator.Bus.SendLocal("HEJ MED DIG MIN VEN");
var failedMessage = await network.WaitForNextMessageFrom("error", timeoutSeconds : 10);
var receivedString = Encoding.UTF8.GetString(failedMessage.Body);
Assert.That(receivedString, Is.EqualTo("\"HEJ MED DIG MIN VEN\""));
}