void UpdateExistingMessage(IDocumentSession session, string id, TransportMessage message)
{
var failedMessage = session.Load<Message>(id);
var timeOfFailure = DateTimeExtensions.ToUtcDateTime(message.Headers["NServiceBus.TimeOfFailure"]);
if (failedMessage.FailureDetails.TimeOfFailure == timeOfFailure)
{
return;
}
if (failedMessage.Status == MessageStatus.Successful && timeOfFailure > failedMessage.ProcessedAt)
{
throw new InvalidOperationException("A message can't first be processed successfully and then fail, Id: " + failedMessage.Id);
}
if (failedMessage.Status == MessageStatus.Successful)
{
failedMessage.FailureDetails = new FailureDetails(message);
}
else
{
failedMessage.Status = MessageStatus.RepeatedFailure;
failedMessage.FailureDetails.RegisterException(message);
}
session.SaveChanges();
}
public void MutateIncoming(TransportMessage transportMessage)
{
string bodyAsString = Encoding.UTF8
.GetString(transportMessage.Body);
Console.WriteLine("Serialized Message Body:");
Console.WriteLine(bodyAsString);
}
public bool Handle(TransportMessage message)
{
using (var session = Store.OpenSession())
{
session.Advanced.UseOptimisticConcurrency = true;
var failedMessage = new Message(message)
{
FailureDetails = new FailureDetails(message),
Status = MessageStatus.Failed,
ReplyToAddress = message.ReplyToAddress.ToString()
};
try
{
session.Store(failedMessage);
session.SaveChanges();
}
catch (ConcurrencyException) //there is already a message in the store with the same id
{
session.Advanced.Clear();
UpdateExistingMessage(session, failedMessage.Id, message);
}
}
Forwarder.Send(message, Settings.ErrorLogQueue);
return true;
}
public bool Handle(TransportMessage message)
{
using (var session = Store.OpenSession())
{
session.Advanced.UseOptimisticConcurrency = true;
var auditMessage = new Message(message);
auditMessage.MarkAsSuccessful(message);
try
{
session.Store(auditMessage);
session.SaveChanges();
}
catch (ConcurrencyException)
{
session.Advanced.Clear();
UpdateExistingMessage(session,auditMessage.Id, message);
}
}
return true;
}
public void MutateOutgoing(LogicalMessage logicalMessage, TransportMessage transportMessage)
{
var headers = transportMessage.Headers;
if (headers.ContainsKey(Constants.Headers.Keys.Originator)) return;
headers.Add(Constants.Headers.Keys.Originator, Source);
}
public void MutateIncoming(TransportMessage transportMessage)
{
string bodyAsString = Encoding.UTF8
.GetString(transportMessage.Body);
log.Info("Serialized Message Body:");
log.Info(bodyAsString);
}
public void With_ProcessingEndpoint_header_should_return_processing_endpoint()
{
var message = new TransportMessage(Guid.Empty.ToString(), new Dictionary<string, string>
{
{ Headers.ProcessingEndpoint ,"TheEndpoint"}
});
Assert.AreEqual("TheEndpoint",message.ProcessingEndpointName());
}
public void With_ReplyToAddress_should_return_ReplyToAddress()
{
var message = new TransportMessage
{
ReplyToAddress = new Address("TheEndpoint", "")
};
Assert.AreEqual("TheEndpoint",message.ProcessingEndpointName());
}
public void With_FailedQ_header_should_return_FailedQ()
{
var message = new TransportMessage(Guid.Empty.ToString(), new Dictionary<string, string>
{
{ "NServiceBus.FailedQ" ,"TheEndpoint"}
});
Assert.AreEqual("TheEndpoint",message.ProcessingEndpointName());
}
public void MutateOutgoing(object[] messages, TransportMessage transportMessage)
{
var incomingContext = bus.CurrentMessageContext;
var incomingMessageId = incomingContext?.Headers["NServiceBus.MessageId"];
transportMessage.Headers
.Add("MutateTransportMessages_Outgoing", "ValueMutateTransportMessages_Outgoing");
}
public void No_headers_with_message_type_should_throw_with_message_id_and_types()
{
var message = new TransportMessage(Guid.Empty.ToString(), new Dictionary<string, string>
{
{ Headers.EnclosedMessageTypes ,"TheMessageType"}
});
var exception = Assert.Throws<Exception>(() => { message.ProcessingEndpointName(); });
Assert.AreEqual("No processing endpoint could be determined for message (00000000-0000-0000-0000-000000000000) with EnclosedMessageTypes (TheMessageType)", exception.Message);
}
public void MutateOutgoing(LogicalMessage message, TransportMessage transportMessage)
{
log.Info("transportMessage.Body size before compression: " + transportMessage.Body.Length);
transportMessage.Body = Compress(transportMessage.Body);
transportMessage.Headers.Add(Constants.Headers.Keys.Compressed, Constants.Headers.Values.Compressed);
log.Info("transportMessage.Body size after compression: " + transportMessage.Body.Length);
}
public void MutateOutgoing(object[] messages, TransportMessage transportMessage)
{
if (Bus.CurrentMessageContext == null)
return;
if (!Bus.CurrentMessageContext.Headers.ContainsKey("tenant"))
return;
transportMessage.Headers["tenant"] = Bus.CurrentMessageContext.Headers["tenant"];
}
public void MutateOutgoing(LogicalMessage logicalMessage, TransportMessage transportMessage)
{
var command = logicalMessage.Instance as IOrderCommand;
if (command != null)
{
transportMessage.Headers[Headers.ConversationId] = command.OrderId;
}
}
protected override void HandleMessage(TransportMessage message)
{
var destinationAddress = Address.Parse(message.Headers["ServiceControl.TargetEndpointAddress"]);
message.Headers.Remove("ServiceControl.TargetEndpointAddress");
message.Headers.Remove("ServiceControl.Retry.StagingId");
sender.Send(message, destinationAddress);
}
public void MutateIncoming(TransportMessage transportMessage)
{
var headerUserId = transportMessage.Headers[Headers.WindowsIdentityName];
Guid userId;
if (Guid.TryParse(headerUserId, out userId))
{
this._authenticationService.UserId = userId;
}
}
public void MutateIncoming(TransportMessage transportMessage)
{
if (transportMessage.Headers.ContainsKey("$.diagnostics.hostid"))
{
return;
}
transportMessage.Headers["$.diagnostics.hostid"] = HostInformation.HostId.ToString("N");
transportMessage.Headers["$.diagnostics.hostdisplayname"] = HostInformation.DisplayName;
}
public PhysicalMessage(TransportMessage message)
{
MessageId = message.Id;
Headers = message.Headers;
Body = message.Body;
ReplyToAddress = message.ReplyToAddress.ToString();
CorrelationId = message.CorrelationId;
Recoverable = message.Recoverable;
MessageIntent = message.MessageIntent;
}
public void MutateOutgoing(object[] messages, TransportMessage transportMessage)
{
IMessageContext incomingContext = bus.CurrentMessageContext;
if (incomingContext != null)
{
string incomingMessageId = incomingContext.Headers["NServiceBus.MessageId"];
}
transportMessage.Headers
.Add("MutateOutgoingTransportMessages", "ValueMutateOutgoingTransportMessages");
}
public void MutateIncoming(TransportMessage transportMessage)
{
if (!transportMessage.Headers.ContainsKey("IWasCompressed"))
return;
using (var bigStream = new GZipStream(new MemoryStream(transportMessage.Body), CompressionMode.Decompress))
{
var bigStreamOut = new MemoryStream();
bigStream.CopyTo(bigStreamOut);
transportMessage.Body = bigStreamOut.ToArray();
}
}
public void Send(TransportMessage message, Address address)
{
Inner.Send(message,address);
if (BlowUpAfterDispatch && PipelineExecutor.CurrentContext.Get<bool>("Outbox_StartDispatching"))
{
BlowUpAfterDispatch = false;
Console.Out.WriteLine("Monkey: Message {0} dispatched, blowing up now like you asked me to!",message.Id);
throw new Exception("BlowUpAfterDispatch");
}
}
void UpdateExistingMessage(IDocumentSession session, string messageId, TransportMessage message)
{
var auditMessage = session.Load<Message>(messageId);
if (auditMessage == null)
throw new InvalidOperationException("There should be a message in the store");
auditMessage.Update(message);
session.SaveChanges();
}
public void MutateOutgoing(LogicalMessage logicalMessage, TransportMessage transportMessage)
{
const string accessTokenLiteral = "access_token";
if (_bus.CurrentMessageContext == null || !_bus.CurrentMessageContext.Headers.ContainsKey(accessTokenLiteral))
{
return;
}
transportMessage.Headers[accessTokenLiteral] = _bus.CurrentMessageContext.Headers[accessTokenLiteral];
}
private TimeSpan CustomRetryPolicy(TransportMessage message)
{
// Stop second level retries in case of a business exception
if (BusinessLogicExceptionTypes.Contains(message.ExceptionType()))
{
Console.WriteLine("Dropping Slr for message '{0}'", message.Id);
return TimeSpan.MinValue;
}
return TimeSpan.FromSeconds(10);
}
public void MutateIncoming(TransportMessage transportMessage)
{
if (transportMessage.Headers.ContainsKey(Constants.Headers.Keys.Compressed) == false) return;
using (GZipStream bigStream = new GZipStream(new MemoryStream(transportMessage.Body), CompressionMode.Decompress))
using (var bigStreamOut = new MemoryStream())
{
bigStream.CopyTo(bigStreamOut);
transportMessage.Body = bigStreamOut.ToArray();
}
}
TimeSpan MyCustomRetryPolicy(TransportMessage message)
{
// retry max 3 times
if (GetNumberOfRetries(message) >= 3)
{
// sending back a TimeSpan.MinValue tells the
// SecondLevelRetry not to retry this message
return TimeSpan.MinValue;
}
return TimeSpan.FromSeconds(5);
}
public void MutateIncoming(TransportMessage transportMessage)
{
var debugFlag = transportMessage.Headers.ContainsKey("Debug") ? transportMessage.Headers["Debug"] : "false";
if (debugFlag != null && debugFlag.Equals("true", StringComparison.OrdinalIgnoreCase))
{
debug.Value = true;
}
else
{
debug.Value = false;
}
}
public void Should_block_until_a_message_is_available()
{
var address = Address.Parse(MYRECEIVEQUEUE);
var message = new TransportMessage();
sender.Send(message, address);
var received = WaitForMessage();
Assert.AreEqual(message.Id, received.Id);
}
static int GetNumberOfRetries(TransportMessage message)
{
string value;
if (message.Headers.TryGetValue(Headers.Retries, out value))
{
int i;
if (int.TryParse(value, out i))
{
return i;
}
}
return 0;
}
public void MutateOutgoing(LogicalMessage logicalMessage, TransportMessage transportMessage)
{
if (Bus.CurrentMessageContext == null)
{
return;
}
if (!Bus.CurrentMessageContext.Headers.ContainsKey("tenant"))
{
return;
}
transportMessage.Headers["tenant"] = Bus.CurrentMessageContext.Headers["tenant"];
}