public void CanPreserveCustomHeadersOnDeferredMessage()
{
// arrange
var deferredMessageReceived = new ManualResetEvent(false);
IDictionary <string, object> receivedHeaders = null;
handlerActivator.Handle <MessageWithText>(m =>
{
receivedHeaders = MessageContext.GetCurrent().Headers;
deferredMessageReceived.Set();
});
var message = new MessageWithText {
Text = "hello"
};
bus.AttachHeader(message, Headers.UserName, "joe");
bus.AttachHeader(message, "test-custom1", "bimmelim!");
bus.AttachHeader(message, "test-custom2", "w00t!");
// act
bus.Defer(1.Seconds(), message);
deferredMessageReceived.WaitUntilSetOrDie(3.Seconds());
// assert
receivedHeaders.ShouldNotBe(null);
receivedHeaders.ShouldContainKeyAndValue(Headers.UserName, "joe");
receivedHeaders.ShouldContainKeyAndValue("test-custom1", "bimmelim!");
receivedHeaders.ShouldContainKeyAndValue("test-custom2", "w00t!");
}
public void WorksWhenMovingToErrorQueue()
{
using (var messageQueue = new MsmqMessageQueue("error"))
{
// make sure error queue is empty
messageQueue.PurgeInputQueue();
adapter.Handle <Request>(req =>
{
throw new ApplicationException("oh crap");
});
var request = new Request();
bus.AttachHeader(request, Headers.CorrelationId, "super-unique!!!!111");
bus.SendLocal(request);
// let it fail
Thread.Sleep(2.Seconds());
var receivedTransportMessage = messageQueue.ReceiveMessage(new NoTransaction());
receivedTransportMessage.ShouldNotBe(null);
var serializer = new JsonMessageSerializer();
var message = serializer.Deserialize(receivedTransportMessage);
message.Headers.ShouldContainKeyAndValue(Headers.CorrelationId, "super-unique!!!!111");
}
}
public void DispatchLocal(object deferredMessage, Guid sagaId)
{
if (sagaId != Guid.Empty)
{
bus.AttachHeader(deferredMessage, Headers.AutoCorrelationSagaId, sagaId.ToString());
}
bus.SendLocal(deferredMessage);
}
public void DispatchLocal(object deferredMessage, Guid sagaId, IDictionary <string, object> headers)
{
if (sagaId != Guid.Empty)
{
bus.AttachHeader(deferredMessage, Headers.AutoCorrelationSagaId, sagaId.ToString());
}
foreach (var header in headers)
{
bus.AttachHeader(deferredMessage, header.Key, (header.Value ?? "").ToString());
}
bus.SendLocal(deferredMessage);
}
/// <summary>
/// Replies to origin saga correlating with sagaId parameter.
/// </summary>
public static void ReplyToSaga <TResponse>(this IBus bus, string originator, Guid sagaId, TResponse message)
{
Guard.IsNotNull(bus, nameof(bus));
Guard.IsNotNullNorEmpty(originator, nameof(originator));
Guard.IsNotDefault(sagaId, nameof(sagaId));
Guard.IsNotNull(message, nameof(message));
var messageContext = MessageContext.GetCurrent();
var sagaContextKey = SagaContext.SagaContextItemKey;
var sagaContextExists = messageContext.Items.ContainsKey(sagaContextKey);
// Current saga context
var currentSagaContext = sagaContextExists ? messageContext.Items[sagaContextKey] : null;
try
{
// XXX: The .Routing.Send() method is overwriting the AutoCorrelationSagaId header by current SagaConext.Id,
// so we need to (temporarilly) remove the existing sagaContext from messageContext.
messageContext.Items.Remove(sagaContextKey);
bus.AttachHeader(message, Headers.AutoCorrelationSagaId, sagaId.ToString());
bus.ReplyTo(originator, message);
}
finally
{
if (sagaContextExists)
{
// XXX: Restore the current SagaConext, no matter what.
messageContext.Items[sagaContextKey] = currentSagaContext;
}
}
}
protected override void PerformProceed(IInvocation invocation)
{
Guard.Against <InvalidOperationException>(
invocation.Method.Name != "Handle" || !invocation.Method.IsPublic || invocation.Arguments.Length != 1,
$"Invoked {GetType().Name} interceptor for a non-handle method ({invocation.Method.Name})?!"
);
if (IsLockedSaga(invocation.InvocationTarget as Saga) && !IsFlaggedAsDeferred())
{
var message = invocation.GetArgumentValue(0);
_Log.DebugFormat("Deferring handling of message of type {0}, due to target saga being currently locked.", message?.GetType());
if (MessageContext.HasCurrent)
{
// The Rebus transport message ID can not be overwritten
foreach (var header in MessageContext.GetCurrent().Headers.Where(x => x.Key != Headers.MessageId))
{
_bus.AttachHeader(message, header.Key, Convert.ToString(header.Value));
}
}
_bus.Defer(_settings.LockedSagasDeferInterval, message);
MessageContext.GetCurrent().Abort();
// Flag the MessageContext as deferred to avoid generating multiple timeouts
// when a message that is handled by multiple sagas has at least one of them locked
FlagAsDeferred();
return;
}
base.PerformProceed(invocation);
}
static void EncodeUserContextHeadersIfPossible(IBus bus, string destination, object message)
{
var current = AmbientUserContext.Current;
if (current == null) return;
var encodedUserContext = Encode(current);
bus.AttachHeader(message, UserContextHeaderKey, encodedUserContext);
}
static void EncodeUserContextHeadersIfPossible(IBus bus, string destination, object message)
{
var current = AmbientUserContext.Current;
if (current == null)
{
return;
}
var encodedUserContext = Encode(current);
bus.AttachHeader(message, UserContextHeaderKey, encodedUserContext);
}
protected virtual void PrepareCommand(ICommand command, string impersonatingUser)
{
var userId = command.GetContextData("user.id");
if (userId == null)
{
userId = ImpersonateUser(command, impersonatingUser);
command.SetContextData("user.id", userId);
}
if (!UserIsAllowedToSendCommand(command, userId))
{
throw new UserCannotSendCommandException();
}
foreach (var key in command.AllContextKeys)
{
_bus.AttachHeader(command, key, command.GetContextData(key));
}
_bus.AttachHeader(command, "command.id", command.MessageId.ToString());
_bus.AttachHeader(command, "command.description", command.Describe());
}
static void InnerSend <TReply>(IBus bus, object message, Action <TReply> replyHandler, TimeSpan timeout, Action timeoutAction = null)
{
if (bus == null)
{
throw new ArgumentNullException("bus", "You cannot call these methods without a bus instance");
}
if (message == null)
{
throw new ArgumentNullException("message", "You cannot call these methods without a message");
}
if (replyHandler == null)
{
throw new ArgumentNullException("replyHandler", "Please specify a reply handler");
}
var correlationId = Guid.NewGuid().ToString();
bus.AttachHeader(message, Headers.CorrelationId, correlationId);
var replyCallback = new ReplyCallback
{
Callback = replyHandler,
RegistrationTime = DateTime.UtcNow,
MaxCallbackAge = timeout,
TimeoutCallback = timeoutAction,
};
var key = GetKey(correlationId, typeof(TReply));
if (TransactionContext.Current != null)
{
TransactionContext.Current.DoCommit +=
() => registeredReplyHandlers.TryAdd(key, replyCallback);
}
else
{
registeredReplyHandlers.TryAdd(key, replyCallback);
}
bus.Send(message);
}
/// <summary>
/// http://mookid.dk/oncode/archives/2966
/// </summary>
/// <param name="bus"></param>
/// <param name="destination"></param>
/// <param name="message"></param>
private void OnMessageSent(IBus bus, string destination, object message)
{
if (MessagesTracker != null)
{
var msg = message as IMessage;
if (msg != null)
{
MessagesTracker.Started(msg);
}
}
var attribute = message.GetType()
.GetCustomAttributes(typeof(TimeToBeReceivedAttribute), false)
.Cast <TimeToBeReceivedAttribute>()
.SingleOrDefault();
if (attribute == null)
{
return;
}
bus.AttachHeader(message, Headers.TimeToBeReceived, attribute.HmsString);
}
private static void SetDateOnMessageSent(IBus bus, string destination, object message)
{
bus.AttachHeader(message, MessageDataHeader, DateTime.UtcNow.ToString("o"));
}
