Rebus Saga: Message is not arrived in correct sequence when subscriber(s) sent to publisher - rebus

Question

Recently, we have upgraded rebus version from 1 to 5 and then after we are having problem with Saga handler. Now we are not getting response(s) in correct sequence from different subscriber(s).
We are having different sources to authenticate a request and for that we have coordinator to handle all responses from different authentication sources, but now problem is: All "SearchStarted" messages are not arrived first in coordinator from all authentication sources, due to that we can not check how many authentication sources started authenticating.
Tried to send message in different ways, like
1. Used SEND method instead of REPLY.
2. Tried with our without await keyword before sending response.
3. Tried .Wait() method with Send/Reply method(s).
AuthenticationCoordinator:
public class AuthenticationSaga : Saga<AuthenticationSagaData>, IAmInitiatedBy<AuthenticationRequest>, IHandleMessages<SearchStarted>, IHandleMessages<SearchCompleted>, IHandleMessages<AuthenticationResponse>
{
private readonly IBus _bus;
public IBus Bus
{
get { return _bus; }
}
public AuthenticationSaga(IBus bus)
{
_bus = bus;
}
public async Task Handle(AuthenticationRequest message)
{
if (!IsNew) return;
Data.Id = new Guid(MessageContext.Current.Headers[Rebus.Messages.Headers.CorrelationId]);
Data.ReturnAddress = MessageContext.Current.Headers[Rebus.Messages.Headers.ReturnAddress];
message.UniqueId = Data.Id.ToString();
Data.RequestMessage = message;
Bus.Publish(message);
}
public async Task Handle(SearchStarted message)
{
}
public async Task Handle(SearchCompleted message)
{
}
public async Task Handle(AuthenticationResponse message)
{
}
protected override void CorrelateMessages(ICorrelationConfig<AuthenticationSagaData> config)
{
config.Correlate<AuthenticationRequest>(m => m.UniqueId, d => d.Id);
config.Correlate<SearchStarted>(m => m.UniqueId, d => d.Id);
config.Correlate<AuthenticationResponse>(m => m.UniqueId, d => d.Id);
config.Correlate<SearchCompleted>(m => m.UniqueId, d => d.Id);
}
}
AuthenticationLdap:
public class AuthenticationLdapHandler : IHandleMessages
{
private readonly IBus _bus;
public IBus bus
{
get { return _bus; }
}
public AuthenticationLdapHandler(IBus bus)
{
_bus = bus;
}
public async Task Handle(AuthenticationRequest message)
{
await bus.Reply(new SearchStarted { MessageId = MessageContext.Current.Headers[Rebus.Messages.Headers.CorrelationId], UniqueId = message.UniqueId });
var response = AuthenticateLdap(message); await bus.Reply(response);
await bus.Reply(new SearchCompleted { MessageId = MessageContext.Current.Headers[Rebus.Messages.Headers.CorrelationId], UniqueId = message.UniqueId });
}
}
AuthenticationNative:
public class AuthenticationNativeHandler : IHandleMessages
{
private readonly IBus _bus;
public IBus bus
{
get { return _bus; }
}
public AuthenticationNativeHandler(IBus bus)
{
_bus = bus;
}
public async Task Handle(AuthenticationRequest message)
{
await bus.Reply(new SearchStarted { MessageId = MessageContext.Current.Headers[Rebus.Messages.Headers.CorrelationId], UniqueId = message.UniqueId });
var response = AuthenticateNative(message); await bus.Reply(response);
await bus.Reply(new SearchCompleted { MessageId = MessageContext.Current.Headers[Rebus.Messages.Headers.CorrelationId], UniqueId = message.UniqueId });
}
}
We are expecting response(s) in AuthenticationCoordinator as below sequence:
SearchStarted message from Ldap
SearchStarted message from Native
AuthenticationResponse message from Ldap
SearchCompleted message from Ldap
AuthenticationResponse message from Native
SearchCompleted message from Native
But now we are getting response(s) in below sequence:
SearchStarted message from Ldap
AuthenticationResponse message from Ldap
SearchCompleted message from Ldap
SearchStarted message from Native
AuthenticationResponse message from Native
SearchCompleted message from Native
Can we set priority to message? how we can achieve above expected responses in rebus 5.

Answer 1

What you're seeing is most likely a consequence of the fact that Rebus ensures that all outgoing messages are sent AFTER your handler has finished executing.
It does this by enlisting all bus operations in its transaction context, which gets committed only after your handler code is done.
This means that code like
public async Task Handle(string message)
{
await bus.Reply("this is message 1");
await Task.Delay(TimeSpan.FromSeconds(1));
await bus.Reply("this is message 2");
await Task.Delay(TimeSpan.FromSeconds(1));
await bus.Reply("this is message 3");
}
will result in messages 1, 2, and 3 being sent at the same time, when the Rebus transaction context is committed, which means that the recipient will receive them in random order.
If you messages to be sent immediately from your handler, you can "dismantle" the transaction context like this:
var transactionContext = AmbientTransactionContext.Current;
AmbientTransactionContext.SetCurrent(null);
try
{
// current transaction will never know....
await bus.Send(whee);
}
finally
{
AmbientTransactionContext.SetCurrent(transactionContext);
}
which I suggest you wrap in an implementation of IDisposable which enables usage like this:
using(new RebusTransactionContextDismantler())
{
// current transaction will never know....
await bus.Publish(whee);
}