public void MutateOutgoing(LogicalMessage logicalMessage, TransportMessage transportMessage) { if (returnInfo == null) { return; } if (string.IsNullOrEmpty(transportMessage.CorrelationId)) { return; } if (transportMessage.Headers.ContainsKey(Headers.HttpTo) || transportMessage.Headers.ContainsKey(Headers.DestinationSites)) { return; } transportMessage.Headers[Headers.HttpTo] = returnInfo.HttpFrom; transportMessage.Headers[Headers.OriginatingSite] = returnInfo.OriginatingSite; if (!transportMessage.Headers.ContainsKey(Headers.RouteTo)) { transportMessage.Headers[Headers.RouteTo] = returnInfo.ReplyToAddress.ToString(); } // send to be backwards compatible with Gateway 3.X transportMessage.Headers[GatewayHeaders.LegacyMode] = returnInfo.LegacyMode.ToString(); }
void SendFailureMessage(TransportMessage message, Exception e, string reason) { if (errorQueue == null) { Logger.Error("Message processing always fails for message with ID " + message.Id + ".", e); return; } SetExceptionHeaders(message, e, reason); try { var sender = Configure.Instance.Builder.Build<ISendMessages>(); sender.Send(message, errorQueue); } catch (Exception exception) { var qnfEx = exception as QueueNotFoundException; string errorMessage; if (qnfEx != null) { errorMessage = string.Format("Could not forward failed message to error queue '{0}' as it could not be found.", qnfEx.Queue); Logger.Fatal(errorMessage); } else { errorMessage = "Could not forward failed message to error queue."; Logger.Fatal(errorMessage, exception); } throw new InvalidOperationException(errorMessage, exception); } }
public void Handle(TransportMessage message) { var sagaId = Guid.Empty; if (message.Headers.ContainsKey(Headers.SagaId)) sagaId = Guid.Parse(message.Headers[Headers.SagaId]); if (message.Headers.ContainsKey(Headers.ClearTimeouts)) { if(sagaId == Guid.Empty) throw new InvalidOperationException("Invalid saga id specified, clear timeouts is only supported for saga instances"); Persister.ClearTimeoutsFor(sagaId); Manager.ClearTimeout(sagaId); } else { if (!message.Headers.ContainsKey(Headers.Expire)) throw new InvalidOperationException("Non timeout message arrived at the timeout manager, id:" + message.Id); var data = new TimeoutData { Destination = message.ReplyToAddress, SagaId = sagaId, State = message.Body, Time = message.Headers[Headers.Expire].ToUtcDateTime(), CorrelationId = message.CorrelationId, Headers = message.Headers }; Persister.Add(data); Manager.PushTimeout(data); } }
TransportMessage MapToTransportMessage(TimeoutData timeoutData) { var transportMessage = new TransportMessage { ReplyToAddress = Address.Local, Headers = new Dictionary<string, string>(), Recoverable = true, MessageIntent = MessageIntentEnum.Send, CorrelationId = timeoutData.CorrelationId, Body = timeoutData.State }; if (timeoutData.Headers != null) { transportMessage.Headers = timeoutData.Headers; } else { //we do this to be backwards compatible, this can be removed when going to 3.1.X transportMessage.Headers[Headers.Expire] = timeoutData.Time.ToWireFormattedString(); if (timeoutData.SagaId != Guid.Empty) transportMessage.Headers[Headers.SagaId] = timeoutData.SagaId.ToString(); } return transportMessage; }
string GetRemoteAddress(TransportMessage msg) { if (msg.Headers.ContainsKey(Headers.HttpTo)) return msg.Headers[Headers.HttpTo]; return remoteUrl; }
public static TransportMessage ToTransportMessage(BasicDeliverEventArgs message) { var properties = message.BasicProperties; if (!properties.IsMessageIdPresent() || string.IsNullOrWhiteSpace(properties.MessageId)) { throw new InvalidOperationException("A non empty message_id property is required when running NServiceBus on top of RabbitMq. If this is a interop message please make sure to set the message_id property before publishing the message"); } var headers = DeserializeHeaders(message); var result = new TransportMessage(properties.MessageId, headers) { Body = message.Body, }; if (properties.IsReplyToPresent()) { result.ReplyToAddress = Address.Parse(properties.ReplyTo); } if (properties.IsCorrelationIdPresent()) { result.CorrelationId = properties.CorrelationId; } //When doing native interop we only require the type to be set the "fullName" of the message if (!result.Headers.ContainsKey(Headers.EnclosedMessageTypes) && properties.IsTypePresent()) { result.Headers[Headers.EnclosedMessageTypes] = properties.Type; } return result; }
protected void SendMessageToGatewayQueue(IMessage messageToSend) { transportMessage = null; messageReceived = new ManualResetEvent(false); bus.Send("gateway", messageToSend); }
public static TransportMessage ToTransportMessage(this SqsTransportMessage sqsTransportMessage, IAmazonS3 amazonS3, SqsConnectionConfiguration connectionConfiguration) { var messageId = sqsTransportMessage.Headers[Headers.MessageId]; var result = new TransportMessage(messageId, sqsTransportMessage.Headers); if (!string.IsNullOrEmpty(sqsTransportMessage.S3BodyKey)) { var s3GetResponse = amazonS3.GetObject(connectionConfiguration.S3BucketForLargeMessages, sqsTransportMessage.S3BodyKey); result.Body = new byte[s3GetResponse.ResponseStream.Length]; using (BufferedStream bufferedStream = new BufferedStream(s3GetResponse.ResponseStream)) { int count; int transferred = 0; while ((count = bufferedStream.Read(result.Body, transferred, 8192)) > 0) { transferred += count; } } } else { result.Body = Convert.FromBase64String(sqsTransportMessage.Body); } result.TimeToBeReceived = sqsTransportMessage.TimeToBeReceived; if (sqsTransportMessage.ReplyToAddress != null) { result.Headers[Headers.ReplyToAddress] = sqsTransportMessage.ReplyToAddress.ToString(); } return result; }
/// <summary> /// Converts a TransportMessage to an Msmq message. /// Doesn't set the ResponseQueue of the result. /// </summary> public static Message Convert(TransportMessage message) { var result = new Message(); if (message.Body != null) { result.BodyStream = new MemoryStream(message.Body); } AssignMsmqNativeCorrelationId(message, result); result.Recoverable = message.Recoverable; if (message.TimeToBeReceived < MessageQueue.InfiniteTimeout) { result.TimeToBeReceived = message.TimeToBeReceived; } using (var stream = new MemoryStream()) { headerSerializer.Serialize(stream, message.Headers.Select(pair => new HeaderInfo { Key = pair.Key, Value = pair.Value }).ToList()); result.Extension = stream.ToArray(); } result.AppSpecific = (int) message.MessageIntent; return result; }
public bool Handle(TransportMessage message) { var destinationSites = GetDestinationSitesFor(message); //if there is more than 1 destination we break it up into multiple messages if (destinationSites.Count() > 1) { foreach (var destinationSite in destinationSites) { CloneAndSendLocal(message, destinationSite); } return true; } var destination = destinationSites.FirstOrDefault(); if (destination == null) { throw new InvalidOperationException("No destination found for message"); } SendToSite(message, destination); return true; }
void IMutateOutgoingTransportMessages.MutateOutgoing(IMessage[] messages, TransportMessage transportMessage) { 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 bool Handle(TransportMessage errorMessage) { transport.PipelineFactory .GetPipeline(errorPipelineName) .Push(errorMessage.AsEndpointMessage(serializer, endpointWhereErrorOccured)); return true; }
public void When_a_message_is_received_the_Handle_method_should_called_on_the_satellite() { var tm = new TransportMessage(); FakeReceiver.FakeMessageReceived(tm); Assert.That(_sat.IsMessageHandled, Is.True); }
Dictionary<string,string> MapToHeaders(TransportMessage from) { var to = new Dictionary<string, string>(StringComparer.CurrentCultureIgnoreCase); to[NServiceBus + Id] = from.Id; to[NServiceBus + CorrelationId] = GetCorrelationForBackwardsCompatibility(from); to[NServiceBus + Recoverable] = from.Recoverable.ToString(); to[NServiceBus + TimeToBeReceived] = from.TimeToBeReceived.ToString(); if (from.ReplyToAddress != null) //Handles SendOnly endpoints, where ReplyToAddress is not set { to[NServiceBus + ReplyToAddress] = from.ReplyToAddress.ToString(); } SetBackwardsCompatibilityHeaders(to); string replyToAddress; if (from.Headers.TryGetValue(ReplyToAddress, out replyToAddress)) { to[Headers.RouteTo] = replyToAddress; } from.Headers.ToList() .ForEach(header => to[NServiceBus + Headers.HeaderName + "." + header.Key] = header.Value); return to; }
public static TransportMessage Map(IDictionary<string, string> from) { if (!from.ContainsKey(GatewayHeaders.IsGatewayMessage)) { return new TransportMessage(); } var headers = ExtractHeaders(from); var to = new TransportMessage(from[NServiceBus + Id], headers); to.CorrelationId = StripSlashZeroFromCorrelationId(from[NServiceBus + CorrelationId]) ?? to.Id; bool recoverable; if (bool.TryParse(from[NServiceBus + Recoverable], out recoverable)) { to.Recoverable = recoverable; } TimeSpan timeToBeReceived; TimeSpan.TryParse(from[NServiceBus + TimeToBeReceived], out timeToBeReceived); to.TimeToBeReceived = timeToBeReceived; if (to.TimeToBeReceived < MinimumTimeToBeReceived) { to.TimeToBeReceived = MinimumTimeToBeReceived; } return to; }
public void ReceiveMessageLater(TransportMessage m, string address) { if (!string.IsNullOrEmpty(address)) { Send(m, address); } }
public TransportMessage ToTransportMessage(BrokeredMessage message) { TransportMessage t; var rawMessage = message.GetBody<byte[]>(); if (message.Properties.Count == 0) { t = DeserializeMessage(rawMessage); } else { t = new TransportMessage(message.MessageId, message.Properties.ToDictionary(kvp=>kvp.Key,kvp=>kvp.Value.ToString())) { CorrelationId = message.CorrelationId, TimeToBeReceived = message.TimeToLive }; t.MessageIntent = (MessageIntentEnum) Enum.Parse(typeof(MessageIntentEnum), message.Properties[Headers.MessageIntent].ToString()); if ( !String.IsNullOrWhiteSpace( message.ReplyTo ) ) { t.ReplyToAddress = Address.Parse( message.ReplyTo ); // Will this work? } t.Body = rawMessage; } return t; }
public void Send(TransportMessage message) { var received = MessageReceived; if (received != null) received(message, this); }
private static string SerializeToXml(TransportMessage transportMessage) { var overrides = new XmlAttributeOverrides(); var attrs = new XmlAttributes {XmlIgnore = true}; // Exclude non-serializable members overrides.Add(typeof (TransportMessage), "Body", attrs); overrides.Add(typeof (TransportMessage), "ReplyToAddress", attrs); overrides.Add(typeof (TransportMessage), "Headers", attrs); var sb = new StringBuilder(); var xws = new XmlWriterSettings { Encoding = Encoding.Unicode }; var xw = XmlWriter.Create(sb, xws); var xs = new XmlSerializer(typeof (TransportMessage), overrides); xs.Serialize(xw, transportMessage); var xdoc = XDocument.Parse(sb.ToString()); var body = new XElement("Body"); var cdata = new XCData(Encoding.UTF8.GetString(transportMessage.Body)); body.Add(cdata); xdoc.SafeElement("TransportMessage").Add(body); sb.Clear(); var sw = new StringWriter(sb); xdoc.Save(sw); return sb.ToString(); }
public void Send(TransportMessage message, Address address) { using(var redisClient = new RedisClient()) { redisClient.Add(string.Format("{0}:{1}", address.Machine, address.Queue), message); } }
/// <summary> /// Ensure that the content type which is introduced in V4.0.0 and later versions is present in the header. /// </summary> /// <param name="transportMessage">Transport Message to mutate.</param> public void MutateIncoming(TransportMessage transportMessage) { if (!transportMessage.IsControlMessage() && !transportMessage.Headers.ContainsKey(Headers.ContentType)) { transportMessage.Headers[Headers.ContentType] = Serializer.ContentType; } }
void HandleProcessingAlwaysFailsForMessage(TransportMessage message, Exception e, int numberOfRetries) { message.SetExceptionHeaders(e, localAddress ?? config.LocalAddress); if (MessageWasSentFromSLR(message)) { SendToErrorQueue(message, e); return; } var flrPart = numberOfRetries > 0 ? $"Message with '{message.Id}' id has failed FLR and" : $"FLR is disabled and the message '{message.Id}'"; //HACK: We need this hack here till we refactor the SLR to be a first class concept in the TransportReceiver if (RetriesQueue == null) { Logger.ErrorFormat("{0} will be moved to the configured error queue.", flrPart); SendToErrorQueue(message, e); return; } var defer = SecondLevelRetriesConfiguration.RetryPolicy.Invoke(message); if (defer < TimeSpan.Zero) { Logger.ErrorFormat( "SLR has failed to resolve the issue with message {0} and will be forwarded to the error queue at {1}", message.Id, ErrorQueue); SendToErrorQueue(message, e); return; } SendToRetriesQueue(message, e, flrPart); }
public static IBasicProperties FillRabbitMqProperties(TransportMessage message, IBasicProperties properties) { properties.MessageId = message.Id; properties.CorrelationId = message.CorrelationId; if (message.TimeToBeReceived < TimeSpan.MaxValue) properties.Expiration = message.TimeToBeReceived.TotalMilliseconds.ToString(); properties.SetPersistent(message.Recoverable); properties.Headers = message.Headers; if (message.Headers.ContainsKey(Headers.EnclosedMessageTypes)) { properties.Type = message.Headers[Headers.EnclosedMessageTypes].Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).FirstOrDefault(); } if (message.Headers.ContainsKey(Headers.ContentType)) properties.ContentType = message.Headers[Headers.ContentType]; else { properties.ContentType = "application/octet-stream"; } if (message.ReplyToAddress != null && message.ReplyToAddress != Address.Undefined) properties.ReplyTo = message.ReplyToAddress.Queue; return properties; }
static bool HasReachedMaxTime(TransportMessage message) { var timestampHeader = TransportMessageHeaderHelper.GetHeader(message, SecondLevelRetriesHeaders.RetriesTimestamp); if (String.IsNullOrEmpty(timestampHeader)) { return false; } try { var handledAt = DateTimeExtensions.ToUtcDateTime(timestampHeader); if (DateTime.UtcNow > handledAt.AddDays(1)) { return true; } } // ReSharper disable once EmptyGeneralCatchClause // this code won't usually throw but in case a user has decided to hack a message/headers and for some bizarre reason // they changed the date and that parse fails, we want to make sure that doesn't prevent the message from being // forwarded to the error queue. catch (Exception) { } return false; }
public void Defer(TransportMessage message, SendOptions sendOptions) { message.Headers[TimeoutManagerHeaders.RouteExpiredTimeoutTo] = sendOptions.Destination.ToString(); DateTime deliverAt; if (sendOptions.DelayDeliveryWith.HasValue) { deliverAt = DateTime.UtcNow + sendOptions.DelayDeliveryWith.Value; } else { if (sendOptions.DeliverAt.HasValue) { deliverAt = sendOptions.DeliverAt.Value; } else { throw new ArgumentException("A delivery time needs to be specified for Deferred messages"); } } message.Headers[TimeoutManagerHeaders.Expire] = DateTimeExtensions.ToWireFormattedString(deliverAt); try { MessageSender.Send(message, new SendOptions(TimeoutManagerAddress)); } catch (Exception ex) { Log.Error("There was a problem deferring the message. Make sure that DisableTimeoutManager was not called for your endpoint.", ex); throw; } }
public void Send(object messageToSend, TimeSpan timeToBeReceived) { var message = new TransportMessage { TimeToBeReceived = timeToBeReceived }; using (var stream = new MemoryStream()) { serializer.Serialize(new[] { messageToSend }, stream); message.Body = stream.ToArray(); } //hack to remove the type info from the json var bodyString = Encoding.UTF8.GetString(message.Body); var toReplace = ", " + messageToSend.GetType().Assembly.GetName().Name; bodyString = bodyString.Replace(toReplace, ", ServiceControl"); message.Body = Encoding.UTF8.GetBytes(bodyString); // end hack message.Headers[Headers.EnclosedMessageTypes] = messageToSend.GetType().FullName; message.Headers[Headers.ContentType] = ContentTypes.Json; //Needed for ActiveMQ transport try { messageSender.Send(message, new SendOptions(serviceControlBackendAddress) { ReplyToAddress = configure.LocalAddress }); circuitBreaker.Success(); } catch (Exception ex) { circuitBreaker.Failure(ex); } }
private SqlCommand BuildSendCommand(SqlConnection connection, TransportMessage transportMessage, Address address) { var command = connection.CreateCommand(); command.CommandText = String.Format(SqlCommands.Send, address); command.CommandType = CommandType.Text; command.Parameters.AddWithValue("@Id", transportMessage.MessageId); command.Parameters.AddWithValue("@ReplyTo", transportMessage.ReplyToAddress.ToString()); command.Parameters.AddWithValue("@Headers", objectSerializer.SerializeObject(transportMessage.Headers)); command.Parameters.AddWithValue("@Body", transportMessage.Body); if (transportMessage.CorrelationId != Guid.Empty) { command.Parameters.AddWithValue("@CorrelationId", transportMessage.CorrelationId); } else { command.Parameters.AddWithValue("@CorrelationId", DBNull.Value); } if (transportMessage.HasExpiryTime) { command.Parameters.AddWithValue("@Expires", transportMessage.ExpiryTime); } else { command.Parameters.AddWithValue("@Expires", DBNull.Value); } return command; }
void Defer(TimeSpan defer, TransportMessage message) { var retryMessageAt = DateTime.UtcNow + defer; TransportMessageHeaderHelper.SetHeader(message, Headers.Retries, (TransportMessageHeaderHelper.GetNumberOfRetries(message) + 1).ToString(CultureInfo.InvariantCulture)); var addressOfFaultingEndpoint = TransportMessageHeaderHelper.GetAddressOfFaultingEndpoint(message); if (!TransportMessageHeaderHelper.HeaderExists(message, SecondLevelRetriesHeaders.RetriesTimestamp)) { TransportMessageHeaderHelper.SetHeader(message, SecondLevelRetriesHeaders.RetriesTimestamp, DateTimeExtensions.ToWireFormattedString(DateTime.UtcNow)); } logger.DebugFormat("Defer message and send it to {0}", addressOfFaultingEndpoint); var sendOptions = new SendOptions(addressOfFaultingEndpoint) { DeliverAt = retryMessageAt }; MessageDeferrer.Defer(message, sendOptions); }
/// <summary> /// Stores the original saga id and type of the incoming message /// </summary> /// <param name="transportMessage"></param> public void MutateIncoming(TransportMessage transportMessage) { originatingSagaId = null; originatingSagaType = null; // We need this for backwards compatibility because in v4.0.0 we still have this headers being sent as part of the message even if MessageIntent == MessageIntentEnum.Publish if (transportMessage.MessageIntent == MessageIntentEnum.Publish) { if (transportMessage.Headers.ContainsKey(Headers.SagaId)) { transportMessage.Headers.Remove(Headers.SagaId); } if (transportMessage.Headers.ContainsKey(Headers.SagaType)) { transportMessage.Headers.Remove(Headers.SagaType); } } if (transportMessage.Headers.ContainsKey(Headers.OriginatingSagaId)) { originatingSagaId = transportMessage.Headers[Headers.OriginatingSagaId]; } if (transportMessage.Headers.ContainsKey(Headers.OriginatingSagaType)) { originatingSagaType = transportMessage.Headers[Headers.OriginatingSagaType]; } }
public static TransportMessage ToTransportMessage(this BrokeredMessage message) { TransportMessage t; var rawMessage = BrokeredMessageBodyConversion.ExtractBody(message); if (message.Properties.Count > 0) { var headers = message.Properties.ToDictionary(kvp => kvp.Key, kvp => kvp.Value as string); if (!String.IsNullOrWhiteSpace(message.ReplyTo)) { headers[Headers.ReplyToAddress] = message.ReplyTo; } t = new TransportMessage(message.MessageId, headers) { CorrelationId = message.CorrelationId, TimeToBeReceived = message.TimeToLive, MessageIntent = (MessageIntentEnum)Enum.Parse(typeof(MessageIntentEnum), message.Properties[Headers.MessageIntent].ToString()), Body = rawMessage }; } else { t = new TransportMessage { Body = rawMessage }; } return t; }
public Task OnReceived(IMessageSender sender, TransportMessage message) { return(Task.CompletedTask); }
public static bool IsDnsResultMessage(this TransportMessage message) { return(message.ContentType == typeof(DnsTransportMessage).FullName); }
void AssertReceived <T>(TransportMessage receivedEvent) { Assert.AreEqual(typeof(T).FullName, receivedEvent.CorrelationId); }
public IncomingContext(TransportMessage message) { Set(message); }
public byte[] Encode(TransportMessage message) { var transportMessage = new ProtoBufTransportMessage(message); return(SerializerUtilitys.Serialize(transportMessage)); }
public void Send(TransportMessage message, string destination) { Send(message, Address.Parse(destination)); }
public void MutateIncoming(TransportMessage transportMessage) { var headers = transportMessage.Headers; var nsbVersion = headers[Headers.NServiceBusVersion]; var customHeader = headers["MyCustomHeader"]; }
public MessageDispatch CreateMessageDispatch(TransportMessage transportMessage) { return(new MessageDispatch(MessageContext.CreateNew(transportMessage), null, null)); }
async Task ProcessMessage(Message receivedMessage, CancellationToken token) { try { await maxConcurrencySempahore.WaitAsync(token).ConfigureAwait(false); } catch (OperationCanceledException) { // shutting down, semaphore doesn't need to be released because it was never acquired return; } try { IncomingMessage incomingMessage = null; TransportMessage transportMessage = null; var isPoisonMessage = false; try { transportMessage = JsonConvert.DeserializeObject <TransportMessage>(receivedMessage.Body); incomingMessage = await transportMessage.ToIncomingMessage(s3Client, configuration, token).ConfigureAwait(false); } catch (OperationCanceledException) { // shutting down return; } catch (Exception ex) { // Can't deserialize. This is a poison message Logger.Warn($"Treating message with SQS Message Id {receivedMessage.MessageId} as a poison message due to exception {ex}. Moving to error queue."); isPoisonMessage = true; } if (incomingMessage == null || transportMessage == null) { Logger.Warn($"Treating message with SQS Message Id {receivedMessage.MessageId} as a poison message because it could not be converted to an IncomingMessage. Moving to error queue."); isPoisonMessage = true; } if (isPoisonMessage) { await MovePoisonMessageToErrorQueue(receivedMessage).ConfigureAwait(false); return; } if (!IsMessageExpired(receivedMessage, incomingMessage)) { await ProcessMessageWithInMemoryRetries(incomingMessage, token).ConfigureAwait(false); } // Always delete the message from the queue. // If processing failed, the onError handler will have moved the message // to a retry queue. await DeleteMessage(receivedMessage, transportMessage, incomingMessage, token).ConfigureAwait(false); } finally { maxConcurrencySempahore.Release(); } }
public void Send(TransportMessage message) { _messages.Enqueue(message); }
private void SendToPersistenceService(TransportMessage transportMessage, IEnumerable <Peer> persistencePeers) { _innerTransport.Send(transportMessage, persistencePeers, new SendContext()); }
public static TransportMessage ForEndpoint(this TransportMessage message, string endpoint) { message.Headers[MessageHeaders.Endpoint] = endpoint; return(message); }
public void Send(TransportMessage message, IEnumerable <Peer> peers) { Send(message, peers, new SendContext()); }
/// <summary> /// Constructs the in-mem transport message from the given <see cref="TransportMessage"/> /// </summary> public InMemTransportMessage(TransportMessage transportMessage) { Headers = transportMessage.Headers; Body = transportMessage.Body; }
IList <Site> GetDestinationSitesFor(TransportMessage messageToDispatch) { return(Builder.BuildAll <IRouteMessagesToSites>() .SelectMany(r => r.GetDestinationSitesFor(messageToDispatch)).ToList()); }
private void TriggerMessageReceived(TransportMessage transportMessage) { MessageReceived?.Invoke(transportMessage); }
public Task Invoke(TransportMessage message) { return(InvokeInternal(message, 0)); }
/// <summary> /// Adds the <see cref="TransportMessage"/> as an outgoing message destined for the addresses specified by <paramref name="destinationAddresses"/> /// under the given <paramref name="messageId"/> /// </summary> public void AddOutgoingMessage(string messageId, IEnumerable <string> destinationAddresses, TransportMessage transportMessage) { var outgoingMessage = new OutgoingMessage(destinationAddresses, transportMessage); GetOrCreate(messageId).Add(outgoingMessage); }
protected void AddTestMessage(TransportMessage messageToAdd) { queue.Send(messageToAdd, QueueName); }
static void PrintHeaders(TransportMessage message) { Console.WriteLine(@"Headers: {0}", string.Join(Environment.NewLine, message.Headers.Select(kvp => $" {kvp.Key}: {kvp.Value}"))); }
public void MutateOutgoing(LogicalMessage logicalMessage, TransportMessage transportMessage) { var headers = transportMessage.Headers; headers["MyCustomHeader"] = "My custom value"; }
async Task StoreMessageUntilDue(string deferredUntil, Dictionary <string, string> headers, TransportMessage transportMessage) { var approximateDueTime = GetTimeToBeDelivered(deferredUntil); _log.Debug("Deferring message {0} until {1}", headers[Headers.MessageId], approximateDueTime); headers.Remove(Headers.DeferredUntil); await _timeoutManager.Defer(approximateDueTime, headers, transportMessage.Body); }
IEnumerable <Site> GetDestinationSitesFor(TransportMessage messageToDispatch) { return(builder.BuildAll <IRouteMessagesToSites>() .SelectMany(r => r.GetDestinationSitesFor(messageToDispatch))); }
public void outgoing_no_headers() { var transportMessage = new TransportMessage(); Assert.DoesNotThrow(() => _uow.MutateOutgoing(Moq.It.IsAny <LogicalMessage>(), transportMessage)); }
public Task Send(string destinationAddress, TransportMessage message, ITransactionContext context) { _sendCallback(destinationAddress); return(_transport.Send(destinationAddress, message, context)); }
public void Handle(TransportMessage msg, string remoteUrl) { var address = remoteUrl; var headers = new WebHeaderCollection(); if (msg.Headers.ContainsKey(NServiceBus.Headers.HttpTo)) { address = msg.Headers[NServiceBus.Headers.HttpTo]; } var request = WebRequest.Create(address); request.Method = "POST"; var buffer = msg.Body; request.ContentType = "application/x-www-form-urlencoded"; if (!String.IsNullOrEmpty(msg.IdForCorrelation)) { msg.IdForCorrelation = msg.Id; } HeaderMapper.Map(msg, headers); string hash = Hasher.Hash(buffer); headers[HttpHeaders.ContentMd5Key] = hash; headers["NServiceBus.Gateway"] = "true"; headers[HttpHeaders.FromKey] = from; headers[HeaderMapper.NServiceBus + HeaderMapper.CallType] = Enum.GetName(typeof(CallType), CallType.Submit); request.Headers = headers; request.ContentLength = buffer.Length; var stream = request.GetRequestStream(); stream.Write(buffer, 0, buffer.Length); Logger.Debug("Sending message to: " + address); var response = request.GetResponse() as HttpWebResponse; var statusCode = (int)response.StatusCode; response.Close(); Logger.Debug("Got HTTP response with status code " + statusCode); if (statusCode == 200) { Logger.Debug("Message transferred successfully. Going to acknowledge."); var ack = WebRequest.Create(address); ack.Method = "POST"; ack.ContentType = "application/x-www-form-urlencoded"; ack.Headers = headers; ack.Headers[HeaderMapper.NServiceBus + HeaderMapper.CallType] = Enum.GetName(typeof(CallType), CallType.Ack); ack.ContentLength = 0; Logger.Debug("Sending ack to: " + address); var ackResponse = ack.GetResponse() as HttpWebResponse; var ackCode = (int)ackResponse.StatusCode; response.Close(); Logger.Debug("Got HTTP response with status code " + ackCode); if (ackCode != 200) { Logger.Info("Ack not transferred successfully. Trying again..."); throw new Exception("Retrying"); } notifier.RaiseMessageProcessed(TransportTypeEnum.FromMsmqToHttp, msg); } else { Logger.Info("Message not transferred successfully. Trying again..."); throw new Exception("Retrying"); } }
public void FakeMessageBeeingProcessed(TransportMessage transportMessage) { StartedMessageProcessing(this, new EventArgs()); TransportMessageReceived(this, new TransportMessageReceivedEventArgs(transportMessage)); FinishedMessageProcessing(this, new EventArgs()); }
public void MutateOutgoing(object[] messages, TransportMessage transportMessage) { logger.Info("Adding Thread.CurrentPrincipal user to headers"); transportMessage.Headers["UserName"] = Thread.CurrentPrincipal.Identity.Name; }
/// <summary> /// Sets the <see cref="Headers.DeferredUntil"/> header to the specified time /// </summary> public static void SetDeferHeaders(this TransportMessage message, DateTimeOffset approximateDeliveryTime, string destinationAddress) { InnerSetDeferHeaders(approximateDeliveryTime, message.Headers, destinationAddress); }
public void FakeMessageBeeingPassedToTheFaultManager(TransportMessage transportMessage) { StartedMessageProcessing(this, new EventArgs()); FinishedMessageProcessing(this, new EventArgs()); }