private static EventData ToEventData(TransportMessage transportMessage, EventStoreMessageMetadata metadata) { metadata.CorrelationId = transportMessage.CorrelationId; metadata.MessageId = transportMessage.Id; metadata.ReplyTo = transportMessage.ReplyToAddress.ToString(); metadata.Headers = transportMessage.Headers; var type = transportMessage.IsControlMessage() ? "ControlMessage" : transportMessage.Headers[Headers.EnclosedMessageTypes]; byte[] data; string contentType; if (transportMessage.Headers.TryGetValue(Headers.ContentType, out contentType)) { if (contentType != ContentTypes.Json) { throw new InvalidOperationException("Invalid content type: "+contentType); } data = transportMessage.Body; } else { data = new byte[0]; } return new EventData(Guid.NewGuid(), type, true, data, metadata.ToJsonBytes()); }
public void Send(TransportMessage message, Address address) { try { XmsAddress addr = address.ToXmsAddress(); using (var producer = provider.GetProducer(addr)) { var xmsMessage = producer.CreateBytesMessage(); XmsUtilities.Convert(message, xmsMessage); producer.Send(xmsMessage); message.Id = xmsMessage.JMSMessageID; } } // TODO: QueueNotFoundException catch (Exception ex) { if (address == null) throw new FailedToSendMessageException("Failed to send message.", ex); throw new FailedToSendMessageException( string.Format("Failed to send message to address: {0}@{1}", address.Queue, address.Machine), ex); } }
public void Defer(TransportMessage message, DateTime processAt, Address address) { message.Headers[ScheduledMessage.AMQ_SCHEDULED_DELAY] = ((int)processAt.Subtract(DateTime.UtcNow).TotalMilliseconds).ToString(CultureInfo.InvariantCulture); this.MessageSender.Send(message, address); }
public void SetUp() { destination = Target.Input; XmsUtilities.Purge(destination); received = null; sent = new TransportMessage().WithBody();; }
public void MutateIncoming(TransportMessage transportMessage) { string bodyAsString = Encoding.UTF8 .GetString(transportMessage.Body); Console.WriteLine("Serialized Message Body:"); Console.WriteLine(bodyAsString); }
public void MutateIncoming(TransportMessage transportMessage) { string bodyAsString = Encoding.UTF8 .GetString(transportMessage.Body); log.Info("Serialized Message Body:"); log.Info(bodyAsString); }
public void IncrementFailuresForMessage(TransportMessage message, Exception e) { var item = failuresPerMessage.AddOrUpdate(message.Id, s => new Tuple<int, Exception>(1, e), (s, i) => new Tuple<int, Exception>(i.Item1 + 1, e)); notifications.Errors.InvokeMessageHasFailedAFirstLevelRetryAttempt(item.Item1, message, e); }
void ISendMessages.Send(TransportMessage message, Address address) { var queuePath = MsmqUtilities.GetFullPath(address); using (var q = new MessageQueue(queuePath, QueueAccessMode.Send)) { var toSend = MsmqUtilities.Convert(message); toSend.UseDeadLetterQueue = UseDeadLetterQueue; toSend.UseJournalQueue = UseJournalQueue; if (message.ReplyToAddress != null) toSend.ResponseQueue = new MessageQueue(MsmqUtilities.GetReturnAddress(message.ReplyToAddress.ToString(), address.ToString())); try { q.Send(toSend, GetTransactionTypeForSend()); } catch (MessageQueueException ex) { if (ex.MessageQueueErrorCode == MessageQueueErrorCode.QueueNotFound) throw new QueueNotFoundException { Queue = address }; throw; } message.Id = toSend.Id; } }
void CloneAndSendLocal(TransportMessage messageToDispatch, Site destinationSite) { //todo - do we need to clone? check with Jonathan O messageToDispatch.Headers[Headers.DestinationSites] = destinationSite.Key; messageSender.Send(messageToDispatch, localAddress); }
void IManageMessageFailures.ProcessingAlwaysFailsForMessage(TransportMessage message, Exception e) { if (SanitizeProcessingExceptions) e = ExceptionSanitizer.Sanitize(e); this.SendFailureMessage(message, e, "ProcessingFailed"); }
private bool TryInvokeFaultManager(TransportMessage message, Exception exception) { try { Exception e = exception; if (e is AggregateException) { e = e.GetBaseException(); } if (e is TransportMessageHandlingFailedException) { e = e.InnerException; } message.RevertToOriginalBodyIfNeeded(); failureManager.ProcessingAlwaysFailsForMessage(message, e); return true; } catch (Exception ex) { Configure.Instance.RaiseCriticalError( String.Format("Fault manager failed to process the failed message with id {0}", message.Id), ex); } return false; }
void IMutateOutgoingTransportMessages.MutateOutgoing(IMessage[] messages, TransportMessage transportMessage) { if (transportMessage.Headers.ContainsKey(WindowsIdentityName)) transportMessage.Headers.Remove(WindowsIdentityName); transportMessage.Headers.Add(WindowsIdentityName, Thread.CurrentPrincipal.Identity.Name); }
public void Send(TransportMessage message, string destination) { var address = MsmqUtilities.GetFullPath(destination); using (var q = new MessageQueue(address, QueueAccessMode.Send)) { var toSend = new Message(); if (message.Body != null) toSend.BodyStream = new MemoryStream(message.Body); if (message.CorrelationId != null) toSend.CorrelationId = message.CorrelationId; toSend.Recoverable = message.Recoverable; toSend.UseDeadLetterQueue = UseDeadLetterQueue; toSend.UseJournalQueue = UseJournalQueue; if (!string.IsNullOrEmpty(message.ReturnAddress)) toSend.ResponseQueue = new MessageQueue(MsmqUtilities.GetReturnAddress(message.ReturnAddress, destination)); if (message.TimeToBeReceived < MessageQueue.InfiniteTimeout) toSend.TimeToBeReceived = message.TimeToBeReceived; if (message.Headers == null) message.Headers = new Dictionary<string, string>(); if (!message.Headers.ContainsKey(HeaderKeys.IDFORCORRELATION)) message.Headers.Add(HeaderKeys.IDFORCORRELATION, null); if (String.IsNullOrEmpty(message.Headers[HeaderKeys.IDFORCORRELATION])) message.Headers[HeaderKeys.IDFORCORRELATION] = message.IdForCorrelation; using (var stream = new MemoryStream()) { headerSerializer.Serialize(stream, message.Headers.Select(pair => new HeaderInfo { Key = pair.Key, Value = pair.Value }).ToList()); toSend.Extension = stream.GetBuffer(); } toSend.AppSpecific = (int)message.MessageIntent; try { if (MsmqUtilities.CurrentTransaction != null) q.Send(toSend, MsmqUtilities.CurrentTransaction); else q.Send(toSend, GetTransactionTypeForSend()); } catch (MessageQueueException ex) { if (ex.MessageQueueErrorCode == MessageQueueErrorCode.QueueNotFound) throw new QueueNotFoundException { Queue = destination }; throw; } message.Id = toSend.Id; } }
public void SerializationFailedForMessage(TransportMessage message, Exception e) { if (_logger.IsDebugEnabled) { _logger.Debug(string.Format("Serialization failed for message {0} -- persisting to failure store.", message.Id)); } Save(new FailureInfo(message, e, true)); }
public void ProcessingAlwaysFailsForMessage(TransportMessage message, Exception e) { if (_logger.IsDebugEnabled) { _logger.Debug(string.Format("All processing attempts failed for message {0} -- pesisting to failure store.", message.Id)); } Save(new FailureInfo(message, e, false)); }
public void SendPopulatesMessageId() { var message = new TransportMessage().WithBody(); Assert.That(message.Id, Is.Null); transport.Send(message, Target.Input.ToString()); Assert.That(message.Id, Is.Not.Null); Console.WriteLine(message.Id); }
void IMapOutgoingTransportMessages.MapOutgoing(IMessage[] messages, TransportMessage transportMessage) { if (messages[0] is ReadyMessage) return; //when not talking to the distributor, pretend that our address is that of the distributor transportMessage.ReturnAddress = DistributorDataAddress; }
private static void SetExceptionHeaders(TransportMessage message, Exception e, string reason) { message.Headers["ExceptionInfo.Reason"] = reason; message.Headers["ExceptionInfo.HelpLink"] = e.HelpLink; message.Headers["ExceptionInfo.Message"] = e.Message; message.Headers["ExceptionInfo.Source"] = e.Source; message.Headers["ExceptionInfo.StackTrace"] = e.StackTrace; }
public void SetUp() { destination = Target.Input; XmsUtilities.Purge(destination); transport = new XmsTransport(){Aliases = new Dictionary<string, string>()}; received = null; sent = new TransportMessage().WithBody(); ; }
public void The_message_id_should_be_updated_with_the_native_id() { GetDestinationQueue(); var message = new TransportMessage(); queue.Send(message, destinationQueueName); Assert.NotNull(message.Id); }
public void MutateOutgoing(IMessage[] messages, TransportMessage transportMessage) { if (messages[0] is ReadyMessage) return; //when not talking to the distributor, pretend that our address is that of the distributor if (DistributorDataQueue != null) transportMessage.ReturnAddress = DistributorDataQueue; }
//Intentionally service-locate the bus to avoid circular //resolution problem in the container void IManageMessageFailures.SerializationFailedForMessage(TransportMessage message, Exception e) { Configure.Instance.Builder.Build<IBus>() .Send(ErrorQueue, new SerializationFailedMessage { ExceptionInfo = e.GetInfo(), FailedMessage = message }); }
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 MutateIncoming(TransportMessage message) { string routingSlipJson; if (_bus.CurrentMessageContext.Headers.TryGetValue(Router.RoutingSlipHeaderKey, out routingSlipJson)) { _routingSlip = JsonConvert.DeserializeObject<RoutingSlip>(routingSlipJson); } }
void IMessageNotifier.RaiseMessageForwarded(ChannelType from, ChannelType to, TransportMessage message) { if (MessageForwarded != null) MessageForwarded(this, new MessageForwardingArgs { FromChannel = from, ToChannel = to, Message = message }); }
/// <summary> /// Make MessageIntent to be compatible between NServiceBus V3.0.0 and later versions. /// In publish/subscribe/unsubscribe in V3.0.0 there is no Version header. /// In send in V3.0.0 the header is set with 3.0.0 value. /// In both cases, do not mutate the MessageIntent. /// </summary> /// <param name="transportMessage">Transport Message to mutate.</param> public void MutateIncoming(TransportMessage transportMessage) { if (transportMessage.Headers.ContainsKey("NServiceBus.Version") && transportMessage.Headers["NServiceBus.Version"] != "3.0.0") { if ((int)transportMessage.MessageIntent == 0) transportMessage.MessageIntent = Enum.GetValues(typeof(MessageIntentEnum)).Cast<MessageIntentEnum>().Max(); else transportMessage.MessageIntent--; } }
/// <summary> /// Re-Adjust V3.0.0 subscribe and unsubscribe messages. /// Version 3.0.0 subscribe and unsubscribe message have no NServiceBus.Version set it the headers. /// Version 3.0.0 Send message have it with "3.0.0" set as value. /// Do nothing If it is a V2.6 message (contains EnclosedMessageTypes key). /// </summary> /// <param name="transportMessage"></param> public void MutateIncoming(TransportMessage transportMessage) { if ((!transportMessage.Headers.ContainsKey(Headers.NServiceBusVersion) || (transportMessage.Headers.ContainsKey(Headers.NServiceBusVersion)) && (transportMessage.Headers[Headers.NServiceBusVersion] == "3.0.0")) && (!transportMessage.Headers.ContainsKey("EnclosedMessageTypes"))) { transportMessage.MessageIntent++; Log.Debug("Just mutated V3.0.0 to message intent: " + transportMessage.MessageIntent); } }
void IMutateOutgoingTransportMessages.MutateOutgoing(IMessage[] messages, TransportMessage transportMessage) { foreach(var key in staticOutgoingHeaders.Keys) transportMessage.Headers.Add(key, staticOutgoingHeaders[key]); if (messageHeaders != null) if (messageHeaders.ContainsKey(messages[0])) foreach(var key in messageHeaders[messages[0]].Keys) transportMessage.Headers.Add(key, messageHeaders[messages[0]][key]); }
public void Handle(TransportMessage msg) { var header = msg.Headers.Find(h => h.Key == NServiceBus.Headers.HttpTo); if (header == null) { Logger.Warn("Message received without the " + NServiceBus.Headers.HttpTo + " header indicating to which HTTP address it should be sent."); // we don't throw so that if we try to reply to bad clients, we don't DOS our system return; } var request = WebRequest.Create(header.Value); request.Method = "POST"; var buffer = new byte[msg.BodyStream.Length]; msg.BodyStream.Read(buffer, 0, (int)msg.BodyStream.Length); request.ContentType = "application/x-www-form-urlencoded"; HeaderMapper.Map(msg, request.Headers); string hash = Hasher.Hash(buffer); request.Headers[Headers.ContentMd5Key] = hash; request.Headers["NServiceBus.Gateway"] = "true"; request.Headers[Headers.FromKey] = from; request.ContentLength = buffer.Length; var stream = request.GetRequestStream(); stream.Write(buffer, 0, buffer.Length); Logger.Debug("Sending message to: " + header.Value); var response = request.GetResponse(); Logger.Debug("Got HTTP Response, going to check MD5."); var md5 = response.Headers[Headers.ContentMd5Key]; response.Close(); if (md5 == null) { Logger.Error("Integration Error: Response did not contain necessary header " + Headers.ContentMd5Key + ". Can't be sure that data arrived intact at target " + header.Value); return; } if (md5 == hash) Logger.Debug("Message transferred successfully."); else { Logger.Info(Headers.ContentMd5Key + " header received from client not the same as that sent. Message not transferred successfully. Trying again..."); throw new Exception("Retrying"); } }
public static void SetHeader(TransportMessage message, string key, string value) { if (message.Headers.ContainsKey(key)) { message.Headers[key] = value; } else { message.Headers.Add(key, value); } }
public void IncrementFailuresForMessage(TransportMessage message, Exception e) { failuresPerMessage.AddOrUpdate(message.Id, new Tuple<int, Exception>(1, e), (s, i) => new Tuple<int, Exception>(i.Item1 + 1, e)); }
public void ClearFailuresForMessage(TransportMessage message) { var messageId = message.Id; Tuple<int, Exception> e; failuresPerMessage.TryRemove(messageId, out e); }
/// <summary> /// True if the transport message is a control message /// </summary> /// <param name="transportMessage"></param> /// <returns></returns> public static bool IsControlMessage(this TransportMessage transportMessage) { return(transportMessage.Headers != null && transportMessage.Headers.ContainsKey(Headers.ControlMessageHeader)); }