public void CanSendAndReceiveMessageWithHeaders()
{
// arrange
var encoding = Encoding.UTF7;
var transportMessageToSend = new TransportMessageToSend
{
Body = encoding.GetBytes("this is some data"),
Headers = new Dictionary <string, object>
{
{ "key1", "value1" },
{ "key2", "value2" },
}
};
// act
sender.Send(receiver.InputQueue, transportMessageToSend, new NoTransaction());
Thread.Sleep(MaximumExpectedQueueLatency);
var receivedTransportMessage = receiver.ReceiveMessage(new NoTransaction());
// assert
encoding.GetString(receivedTransportMessage.Body).ShouldBe("this is some data");
var headers = receivedTransportMessage.Headers;
headers.ShouldNotBe(null);
headers.Count.ShouldBe(2);
headers.ShouldContainKeyAndValue("key1", "value1");
headers.ShouldContainKeyAndValue("key2", "value2");
5.Times(() => receiver.ReceiveMessage(new NoTransaction()).ShouldBe(null));
}
/// <summary>
/// Sends a new message to an existing queue
/// </summary>
/// <param name="messageToSend">The message to send.</param>
/// <param name="data">The additional data.</param>
/// <returns></returns>
public IQueueOutputMessage Send(IMessage messageToSend, IAdditionalMessageData data)
{
using (var scope = _tracer.StartActivity("SendMessage"))
{
scope?.AddCommonTags(data, _connectionInformation);
scope?.Add(data);
scope?.SetTag("IsBatch", false);
if (scope != null)
{
messageToSend.Inject(_tracer, scope.Context, _headers.StandardHeaders);
}
try
{
var outputMessage = _handler.Send(messageToSend, data);
if (outputMessage.HasError)
{
scope?.SetStatus(Status.Error);
if (outputMessage.SendingException != null)
{
scope?.RecordException(outputMessage.SendingException);
}
}
scope?.AddMessageIdTag(outputMessage.SentMessage.MessageId);
return(outputMessage);
}
catch (Exception e)
{
scope?.SetStatus(Status.Error);
scope?.RecordException(e);
throw;
}
}
}
public List <ScenarioResult> Run(int maxSample, CancellationToken cancellationToken)
{
var scenarios = _scenarios;
if (_selectedScenarios != null)
{
scenarios = _scenarios.Where(s => _selectedScenarios.SelectedScenarios.Any(sel => sel.Name == s.Name));
}
List <ScenarioResult> results = new List <ScenarioResult>();
for (int i = 1; i <= maxSample; i = _sampleSizeStep.Increment(i))
{
_sender.Send(new SampleSizeChanged {
SampleSize = i
});
foreach (var scenario in scenarios)
{
_sender.Send(new ScenarioChanged {
Scenario = scenario.Name
});
results.AddRange(scenario.Run(i, cancellationToken));
}
}
return(results);
}
public ActionResult Create(Person person)
{
CreatePerson command = new CreatePerson(Guid.NewGuid(), person.Name, person.Street, person.StreetNumber);
bus.Send(command);
return(this.RedirectToAction("Index"));
}
/// <summary>
/// Sends a new message to an existing queue
/// </summary>
/// <param name="messageToSend">The message to send.</param>
/// <param name="data">The additional data.</param>
/// <returns></returns>
public IQueueOutputMessage Send(IMessage messageToSend, IAdditionalMessageData data)
{
using (IScope scope = _tracer.BuildSpan("SendMessage").StartActive(finishSpanOnDispose: true))
{
scope.Span.AddCommonTags(data, _connectionInformation);
scope.Span.Add(data);
scope.Span.SetTag("IsBatch", false);
messageToSend.Inject(_tracer, scope.Span.Context, _headers.StandardHeaders);
try
{
var outputMessage = _handler.Send(messageToSend, data);
if (outputMessage.HasError)
{
Tags.Error.Set(scope.Span, true);
if (outputMessage.SendingException != null)
{
scope.Span.Log(outputMessage.SendingException.ToString());
}
}
scope.Span.AddMessageIdTag(outputMessage.SentMessage.MessageId);
return(outputMessage);
}
catch (Exception e)
{
Tags.Error.Set(scope.Span, true);
scope.Span.Log(e.ToString());
throw;
}
}
}
public void RunTests()
{
_cancelationToken = new CancellationTokenSource();
Task.Factory.StartNew(() =>
{
_allRunResults = new List <ScenarioInRunResult>();
_sender.Send(new TestStarted());
for (int i = 0; i < _config.NumberOfRuns; i++)
{
_sender.Send(new IterationChanged());
_allRunResults.AddRange(_runner.Run(_config.MaximumSampleSize, _cancelationToken.Token)
.Select(r =>
new ScenarioInRunResult
{
ApplicationTime = r.ApplicationTime,
CommitTime = r.CommitTime,
ConfigurationName = r.ConfigurationName,
MemoryUsage = r.MemoryUsage,
SampleSize = r.SampleSize,
ScenarioName = r.ScenarioName,
SetupTime = r.SetupTime,
Status = r.Status,
Technology = r.Technology,
RunNumber = i + 1
}));
}
foreach (var formatter in _formatters)
{
formatter.FormatResults(_allRunResults);
}
_sender.Send(new TestStopped());
}, _cancelationToken.Token);
}
public void the_main_application_is_sent_to_the_messaging_service()
{
A.CallTo(() => _fakeMessageSender.Send(A <SubmitLrap1Command> .That.Matches(
c => c.Username == _username &&
c.Password == _password &&
c.Payload == _package.Payload)))
.MustHaveHappened();
}
public void Process(SubmitLrap1Command message)
{
var response = _commsService.Send(message);
if (response == ResponseType.None)
{
_messageSender.Send(message);
}
}
public void CanReceiveAndDoOneSingleSendAtomically(bool commitTransactionAndExpectMessagesToBeThere)
{
sender.Send(receiver.InputQueueAddress, MessageWith("hello"), new NoTransaction());
var destination1 = factory.CreateReceiver("destination1");
Thread.Sleep(300.Milliseconds());
// pretend that this is a message handler tx scope...
using (var tx = new TransactionScope())
{
var ctx = new AmbientTransactionContext();
// arrange
var receivedTransportMessage = receiver.ReceiveMessage(ctx);
Assert.That(receivedTransportMessage, Is.Not.Null);
// act
sender.Send(destination1.InputQueueAddress, MessageWith("hello mr. 1"), ctx);
if (commitTransactionAndExpectMessagesToBeThere)
{
tx.Complete();
}
}
Thread.Sleep(300.Milliseconds());
// assert
var msg1 = destination1.ReceiveMessage(new NoTransaction());
if (commitTransactionAndExpectMessagesToBeThere)
{
Assert.That(msg1, Is.Not.Null);
Assert.That(Encoding.GetString(msg1.Body), Is.EqualTo("hello mr. 1"));
using (new TransactionScope())
{
var ctx = new AmbientTransactionContext();
var receivedTransportMessage = receiver.ReceiveMessage(ctx);
Assert.That(receivedTransportMessage, Is.Null);
}
}
else
{
Assert.That(msg1, Is.Null);
using (new TransactionScope())
{
var ctx = new AmbientTransactionContext();
var receivedTransportMessage = receiver.ReceiveMessage(ctx);
Assert.That(receivedTransportMessage, Is.Not.Null);
Assert.That(Encoding.GetString(receivedTransportMessage.Body), Is.EqualTo("hello"));
}
}
}
public void Start()
{
var msg = CreateTransportMessage(2);
sendMessages.Send(msg, new SendOptions(Address.Parse("error")));
msg = CreateTransportMessage(1);
sendMessages.Send(msg, new SendOptions(Address.Parse("error")));
msg = CreateTransportMessage(3);
sendMessages.Send(msg, new SendOptions(Address.Parse("error")));
}
public void CanReceiveAndDoMultipleSendsAtomically(bool commitTransactionAndExpectMessagesToBeThere)
{
sender.Send(receiver.InputQueueAddress, MessageWith("hello"));
var destination1 = factory.CreateReceiver("destination1");
var destination2 = factory.CreateReceiver("destination2");
Thread.Sleep(300);
// pretend that this is a message handler tx scope...
using (var tx = new TransactionScope())
{
// arrange
var receivedTransportMessage = receiver.ReceiveMessage();
// act
sender.Send(destination1.InputQueueAddress, receivedTransportMessage.ToForwardableMessage());
sender.Send(destination2.InputQueueAddress, receivedTransportMessage.ToForwardableMessage());
if (commitTransactionAndExpectMessagesToBeThere)
{
tx.Complete();
}
}
Thread.Sleep(300);
// assert
var msg1 = destination1.ReceiveMessage();
var msg2 = destination2.ReceiveMessage();
if (commitTransactionAndExpectMessagesToBeThere)
{
msg1.ShouldNotBe(null);
Encoding.GetString(msg1.Body).ShouldBe("hello");
msg2.ShouldNotBe(null);
Encoding.GetString(msg2.Body).ShouldBe("hello");
receiver.ReceiveMessage().ShouldBe(null);
}
else
{
msg1.ShouldBe(null);
msg2.ShouldBe(null);
receiver.ReceiveMessage().ShouldNotBe(null);
}
}
/// <summary>
/// Sends a new message to an existing queue
/// </summary>
/// <param name="messageToSend">The message to send.</param>
/// <param name="data">The additional data.</param>
/// <returns></returns>
public IQueueOutputMessage Send(IMessage messageToSend, IAdditionalMessageData data)
{
using (_sendTimer.NewContext())
{
var result = _handler.Send(messageToSend, data);
if (!result.HasError)
{
_sendMeter.Mark("SendMessage", 1);
}
else
{
_sendErrorMeter.Mark("SendMessage", 1);
}
return(result);
}
}
public void Start()
{
context.EndpointNameOfReceivingEndpoint = settings.EndpointName();
context.MessageId = Guid.NewGuid().ToString();
context.UniqueMessageId = DeterministicGuid.MakeId(context.MessageId, context.EndpointNameOfReceivingEndpoint).ToString();
var transportMessage = new TransportMessage();
transportMessage.Headers[Headers.ProcessingEndpoint] = context.EndpointNameOfReceivingEndpoint;
transportMessage.Headers[Headers.MessageId] = context.MessageId;
transportMessage.Headers[Headers.ConversationId] = "a59395ee-ec80-41a2-a728-a3df012fc707";
transportMessage.Headers["$.diagnostics.hostid"] = "bdd4b0510bff5a6d07e91baa7e16a804";
transportMessage.Headers["$.diagnostics.hostdisplayname"] = "SELENE";
transportMessage.Headers["NServiceBus.ExceptionInfo.ExceptionType"] = "2014-11-11 02:26:57:767462 Z";
transportMessage.Headers["NServiceBus.ExceptionInfo.Message"] = "An error occurred while attempting to extract logical messages from transport message NServiceBus.TransportMessage";
transportMessage.Headers["NServiceBus.ExceptionInfo.InnerExceptionType"] = "System.Exception";
transportMessage.Headers["NServiceBus.ExceptionInfo.HelpLink"] = String.Empty;
transportMessage.Headers["NServiceBus.ExceptionInfo.Source"] = "NServiceBus.Core";
transportMessage.Headers["NServiceBus.ExceptionInfo.StackTrace"] = String.Empty;
transportMessage.Headers["NServiceBus.FailedQ"] = settings.LocalAddress().ToString();
transportMessage.Headers["NServiceBus.TimeOfFailure"] = "2014-11-11 02:26:58:000462 Z";
transportMessage.Headers["NServiceBus.TimeSent"] = "2014-11-11 02:26:01:174786 Z";
transportMessage.Headers[Headers.ControlMessageHeader] = Boolean.TrueString;
transportMessage.Headers[Headers.ReplyToAddress] = settings.LocalAddress().ToString();
sendMessages.Send(transportMessage, new SendOptions(Address.Parse("error")));
}
/// <summary>
/// Sends a copy of the specified <see cref="TransportMessageToSend"/> using the underlying implementation of <see cref="ISendMessages"/>
/// with an encrypted message body and additional headers
/// </summary>
public void Send(string destinationQueueName, TransportMessageToSend message, ITransactionContext context)
{
var clone = new TransportMessageToSend
{
Headers = message.Headers.Clone(),
Label = message.Label,
Body = message.Body,
};
if (compressionHelper != null)
{
var compresssionResult = compressionHelper.Compress(clone.Body);
if (compresssionResult.Item1)
{
clone.Headers[Headers.Compression] = Headers.CompressionTypes.GZip;
}
clone.Body = compresssionResult.Item2;
}
if (encryptionHelper != null)
{
var iv = encryptionHelper.GenerateNewIv();
clone.Body = encryptionHelper.Encrypt(clone.Body, iv);
clone.Headers[Headers.Encrypted] = null;
clone.Headers[Headers.EncryptionSalt] = iv;
}
innerSendMessages.Send(destinationQueueName, clone, context);
}
protected void SendMessages(ISendMessages sender, int count)
{
for (var i = 0; i < count; i++)
{
sender.Send(GenerateTransportMessage(i, "MessageType"), ReceiverAddress);
}
}
private void InnerHandle(TransportMessage message)
{
var entity = auditImporter.ConvertToSaveMessage(message);
using (var session = store.OpenSession())
{
session.Store(entity);
session.SaveChanges();
}
if (settings.ForwardAuditMessages)
{
TransportMessageCleaner.CleanForForwarding(message);
forwarder.Send(message, new SendOptions(settings.AuditLogQueue));
}
}
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;
}
message.SetExceptionHeaders(e, localAddress ?? config.LocalAddress, reason);
try
{
messageSender.Send(message, new SendOptions(errorQueue));
}
catch (Exception exception)
{
var queueNotFoundException = exception as QueueNotFoundException;
string errorMessage;
if (queueNotFoundException != null)
{
errorMessage = string.Format("Could not forward failed message to error queue '{0}' as it could not be found.", queueNotFoundException.Queue);
Logger.Fatal(errorMessage);
}
else
{
errorMessage = "Could not forward failed message to error queue.";
Logger.Fatal(errorMessage, exception);
}
throw new InvalidOperationException(errorMessage, exception);
}
}
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 void WillQueueMessageForProcessing()
{
var message = new Message <String>(Guid.NewGuid(), HeaderCollection.Empty, "Test Message");
messageSender.Send(message);
Assert.Equal(message.Id, ReceiveMessage().Id);
}
/// <summary>
/// Publishes the specified <paramref name="payload"/> on the underlying message bus.
/// </summary>
/// <param name="headers">The set of message headers associated with the command.</param>
/// <param name="payload">The command payload to be published.</param>
public void Publish(IEnumerable <Header> headers, CommandEnvelope payload)
{
Verify.NotNull(payload, nameof(payload));
Log.Trace("Publishing {0} to {1}", payload.Command, payload.AggregateId);
messageSender.Send(messageFactory.Create(headers, payload));
}
public bool Publish(TransportMessage message, IEnumerable <Type> eventTypes)
{
var eventTypeTopics = String.Join("/", eventTypes);
messageSender.Send(message, Address.Parse(String.Format("topic://{0}/EVENTS/{1}", WebSphereMqAddress.GetQueueName(Address.Local), eventTypeTopics)));
return(true);
}
public void Start()
{
var transportMessage = new TransportMessage(context.MessageId, new Dictionary <string, string> {
{ Headers.ProcessingEndpoint, settings.EndpointName() }
});
sendMessages.Send(transportMessage, new SendOptions("audit"));
}
public void Send(TransportMessage message, SendOptions sendOptions)
{
if (sendOptions.Destination.Queue == context.DecommissionedEndpointName)
{
throw new QueueNotFoundException();
}
original.Send(message, sendOptions);
}
/// <summary>
/// Sends the specified message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="data">The data.</param>
/// <returns></returns>
private IQueueOutputMessage InternalSend(T message, IAdditionalMessageData data)
{
Guard.NotNull(() => message, message);
Guard.NotNull(() => data, data);
if (!Configuration.IsReadOnly)
{
Configuration.SetReadOnly();
}
var additionalHeaders = _generateMessageHeaders.HeaderSetup(data);
var messageToSend = _messageFactory.Create(message, additionalHeaders);
_addStandardMessageHeaders.AddHeaders(messageToSend, data);
//send the message to the transport
return(_sendMessages.Send(messageToSend, data));
}
private void InnerHandle(TransportMessage message)
{
var metadata = new Dictionary <string, object>
{
["MessageId"] = message.Id,
["MessageIntent"] = message.MessageIntent,
["HeadersForSearching"] = string.Join(" ", message.Headers.Values)
};
foreach (var enricher in enrichers)
{
enricher.Enrich(message.Headers, metadata);
}
bodyStorageEnricher.StoreErrorMessageBody(
message.Body,
message.Headers,
metadata);
var failureDetails = failedMessageFactory.ParseFailureDetails(message.Headers);
var replyToAddress = message.ReplyToAddress == null ? null : message.ReplyToAddress.ToString();
var processingAttempt = failedMessageFactory.CreateProcessingAttempt(
message.Headers,
metadata,
failureDetails,
message.MessageIntent,
message.Recoverable,
message.CorrelationId,
replyToAddress);
var groups = failedMessageFactory.GetGroups((string)metadata["MessageType"], failureDetails, processingAttempt);
Store(message.Headers.UniqueId(), processingAttempt, groups);
AnnounceFailedMessage(message.Headers, failureDetails);
if (settings.ForwardErrorMessages)
{
TransportMessageCleaner.CleanForForwarding(message);
forwarder.Send(message, new SendOptions(settings.ErrorLogQueue));
}
}
/// <summary>
/// Sends a new message to an existing queue
/// </summary>
/// <param name="messageToSend">The message to send.</param>
/// <param name="data">The additional data.</param>
/// <returns></returns>
public IQueueOutputMessage Send(IMessage messageToSend, IAdditionalMessageData data)
{
IQueueOutputMessage result = null;
if (_policy == null)
{
_policies.Registry.TryGet(_policies.Definition.SendMessage, out _policy);
}
if (_policy != null)
{
_policy.Execute(() => result = _handler.Send(messageToSend, data));
}
else //no policy found
{
result = _handler.Send(messageToSend, data);
}
return(result);
}
public void the_message_is_resent_if_no_response_is_returned()
{
//Arrange
A.CallTo(() => _fakeCommsService.Send(_command)).Returns(ResponseType.None);
//Act
_sut.Process(_command);
//Assert
A.CallTo(() => _fakeMessageSender.Send(A <SubmitLrap1AttachmentCommand> .Ignored)).MustHaveHappened(Repeated.Exactly.Once);
}
public SubmitLrap1Result Submit(string username, string password, Lrap1Package lrap1Package)
{
var applicationId = Guid.NewGuid().ToString();
var saveResult = _commandInvoker.Execute <CreateLrap1SubmissionCommand, CreateLrap1SubmissionQueryResult>(new CreateLrap1SubmissionCommand()
{
ApplicationId = applicationId,
Username = username,
Payload = lrap1Package.Payload
});
var saveAttachmentResult = _commandInvoker.Execute <CreateLrap1AttachmentCommand, CreateLrap1AttachmentQueryResult>(new CreateLrap1AttachmentCommand()
{
AttachmentId = Guid.NewGuid().ToString(),
ApplicationId = saveResult.Command.ApplicationId,
Username = username,
Payload = lrap1Package.Attachments[0].Payload
});
var sendResult = _messageSender.Send(new SubmitLrap1Command()
{
ApplicationId = saveResult.Command.ApplicationId,
Username = username,
Password = password,
Payload = lrap1Package.Payload
});
foreach (var attachment in lrap1Package.Attachments)
{
_messageSender.Send(new SubmitLrap1AttachmentCommand()
{
AttachmentId = saveAttachmentResult.Command.AttachmentId,
ApplicationId = saveResult.Command.ApplicationId,
Username = username,
Password = password,
Payload = attachment.Payload
});
}
return(sendResult);
}
public void Send(TransportMessage message, SendOptions sendOptions)
{
string relatedTimeoutId;
if (message.Headers.TryGetValue("NServiceBus.RelatedToTimeoutId", out relatedTimeoutId) && !context.SendingMessageFailedOnce)
{
context.SendingMessageFailedOnce = true;
throw new Exception("simulated exception");
}
wrappedSender.Send(message, sendOptions);
}
/// <summary>
/// Sends the specified message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="responseId">The response identifier.</param>
/// <param name="inputData"></param>
/// <returns></returns>
public IQueueOutputMessage Send(T message, IResponseId responseId, IAdditionalMessageData inputData = null)
{
ThrowIfDisposed();
Guard.NotNull(() => message, message);
Guard.NotNull(() => responseId, responseId);
var data = SetupForSend(message, responseId, inputData);
//send the message to the transport
return(_sendMessages.Send(data.Item1, data.Item2));
}
public void Init()
{
NServiceBus.Configure.With().Log4Net().DefaultBuilder().UnicastBus();
string errorQueue = ConfigurationManager.AppSettings["ErrorQueue"];
string audit = ConfigurationManager.AppSettings["ForwardReceivedMessageTo"];
string listenUrl = ConfigurationManager.AppSettings["ListenUrl"];
string n = ConfigurationManager.AppSettings["NumberOfWorkerThreads"];
string remoteUrl = ConfigurationManager.AppSettings["RemoteUrl"];
connectionString = ConfigurationManager.AppSettings["ConnectionString"];
inputQueue = ConfigurationManager.AppSettings["InputQueue"];
outputQueue = ConfigurationManager.AppSettings["OutputQueue"];
int numberOfWorkerThreads = 10;
int.TryParse(n, out numberOfWorkerThreads);
ThreadPool.SetMaxThreads(numberOfWorkerThreads, numberOfWorkerThreads);
messageSender = new MsmqMessageSender {UseDeadLetterQueue = true, UseJournalQueue = true};
transport = new TransactionalTransport
{
MessageReceiver = new MsmqMessageReceiver(),
IsTransactional = true,
NumberOfWorkerThreads = numberOfWorkerThreads
};
notifier = new MessageNotifier();
NServiceBus.Configure.Instance.Configurer.RegisterSingleton<ISendMessages>(messageSender);
NServiceBus.Configure.Instance.Configurer.RegisterSingleton<ITransport>(transport);
NServiceBus.Configure.Instance.Configurer.RegisterSingleton<INotifyAboutMessages>(notifier);
transport.TransportMessageReceived += (s, e) =>
{
new MsmqHandler(notifier, listenUrl).Handle(e.Message, remoteUrl);
if (!string.IsNullOrEmpty(audit))
messageSender.Send(e.Message, audit);
};
listener = new HttpListener();
listener.Prefixes.Add(listenUrl);
}
public void Init()
{
NServiceBus.Configure.With().DefaultBuilder();
string errorQueue = ConfigurationManager.AppSettings["ErrorQueue"];
string audit = ConfigurationManager.AppSettings["ForwardReceivedMessageTo"];
string listenUrl = ConfigurationManager.AppSettings["ListenUrl"];
string n = ConfigurationManager.AppSettings["NumberOfWorkerThreads"];
string req = ConfigurationManager.AppSettings["RequireMD5FromClient"];
string remoteUrl = ConfigurationManager.AppSettings["RemoteUrl"];
inputQueue = ConfigurationManager.AppSettings["InputQueue"];
outputQueue = ConfigurationManager.AppSettings["OutputQueue"];
int numberOfWorkerThreads = 10;
int.TryParse(n, out numberOfWorkerThreads);
bool.TryParse(req, out requireMD5FromClient);
ThreadPool.SetMaxThreads(numberOfWorkerThreads, numberOfWorkerThreads);
messageSender = new MsmqMessageSender();
transport = new TransactionalTransport
{
MessageReceiver = new MsmqMessageReceiver(),
IsTransactional = true,
NumberOfWorkerThreads = numberOfWorkerThreads
};
transport.TransportMessageReceived += (s, e) =>
{
new MsmqHandler(listenUrl).Handle(e.Message, remoteUrl);
if (!string.IsNullOrEmpty(audit))
messageSender.Send(e.Message, audit);
};
listener = new HttpListener();
listener.Prefixes.Add(listenUrl);
}
protected void SendMessages(ISendMessages sender, int count)
{
for (var i = 0; i < count; i++)
{
sender.Send(GenerateTransportMessage(i, "MessageType"), ReceiverAddress);
}
}
public When_the_submissions_service_is_asked_to_send_an_LRAP1_package()
{
_applicationId = "01234567890";
_username = "******";
_password = "******";
_fakeCommandInvoker = A.Fake<ICommandInvoker>();
var attachments = new List<Lrap1Attachment>
{
new Lrap1Attachment() {Payload = "Attachment 1 payload data"},
new Lrap1Attachment() {Payload = "Attachment 2 payload data"}
};
_package = new Lrap1Package()
{
Payload = "Lrap1 Payload Data",
Attachments = attachments
};
A.CallTo(
() =>
_fakeCommandInvoker.Execute<CreateLrap1SubmissionCommand, CreateLrap1SubmissionQueryResult>(
A<CreateLrap1SubmissionCommand>.Ignored)).Returns(new CreateLrap1SubmissionQueryResult()
{
Command = new CreateLrap1SubmissionCommand()
{
ApplicationId = _applicationId,
Username = _username,
Payload = _package.Payload
}
});
A.CallTo(
() =>
_fakeCommandInvoker.Execute<CreateLrap1AttachmentCommand, CreateLrap1AttachmentQueryResult>(
A<CreateLrap1AttachmentCommand>.Ignored)).Returns(new CreateLrap1AttachmentQueryResult()
{
Command = new CreateLrap1AttachmentCommand()
{
AttachmentId = "98765",
ApplicationId = _applicationId,
Username = _username,
Payload = _package.Payload
}
});
_fakeMessageSender = A.Fake<ISendMessages>();
A.CallTo(() => _fakeMessageSender.Send(A<SubmitLrap1Command>.That.Matches(
c => c.Username == _username &&
c.Password == _password &&
c.Payload == _package.Payload)))
.Returns(new SubmitLrap1Result()
{
Command = new SubmitLrap1Command()
{
ApplicationId = _applicationId,
Username = _username,
Password = _password,
Payload = _package.Payload
}
});
var sut = new Lrap1SubmissionService(_fakeMessageSender, _fakeCommandInvoker);
_response = sut.Submit(_username, _password, _package);
}
public void Handle(HttpListenerContext ctx, ISendMessages sender, string queue)
{
try
{
if (ctx.Request.ContentLength64 > 4 * 1024 * 1024)
{
Logger.Warn("Received an Http request larger than 4MB, returning an error to the client " +
ctx.Request.RemoteEndPoint);
ctx.Response.StatusCode = 413; // Request Entity Too Large
ctx.Response.StatusDescription = "Cannot accept messages larger than 4MB.";
ctx.Response.Close(Encoding.ASCII.GetBytes("<html><body>" + ctx.Response.StatusDescription + "</body></html>"), false);
return;
}
string hash = ctx.Request.Headers[Headers.ContentMd5Key];
if (hash == null && requireMD5FromClient)
{
Logger.Warn("Received an Http request that didn't contain the " + Headers.ContentMd5Key +
" header from " + ctx.Request.RemoteEndPoint +
". Rejecting the request. If you wish to allow these kinds of requests, please set the configuration field 'RequireMD5FromClient' to 'false'.");
ctx.Response.StatusCode = 400; //Bad Request
ctx.Response.StatusDescription = "Required header '" + Headers.ContentMd5Key +
"' missing. Cannot accept request.";
ctx.Response.Close(Encoding.ASCII.GetBytes("<html><body>" + ctx.Response.StatusDescription + "</body></html>"), false);
return;
}
var length = (int)ctx.Request.ContentLength64;
var buffer = new byte[length];
int numBytesToRead = length;
int numBytesRead = 0;
while (numBytesToRead > 0)
{
int n = ctx.Request.InputStream.Read(
buffer,
numBytesRead,
numBytesToRead < maximumBytesToRead ? numBytesToRead : maximumBytesToRead);
if (n == 0)
break;
numBytesRead += n;
numBytesToRead -= n;
}
string myHash = Hasher.Hash(buffer);
TransportMessage msg;
if (myHash == hash)
{
msg = new TransportMessage
{
Body = buffer,
ReturnAddress = inputQueue
};
//check to see if this is a gateway from another site
if (ctx.Request.Headers["NServiceBus.Gateway"] != null)
HeaderMapper.Map(ctx.Request.Headers, msg);
else
{
msg.MessageIntent = MessageIntentEnum.Send;
msg.Recoverable = true;
msg.Headers = new Dictionary<string, string>();
}
if (ctx.Request.Headers[Headers.FromKey] != null)
msg.Headers.Add(NServiceBus.Headers.HttpFrom, ctx.Request.Headers[Headers.FromKey]);
if (msg.Headers.ContainsKey(HeaderMapper.RouteTo))
sender.Send(msg, msg.Headers[HeaderMapper.RouteTo]);
else
sender.Send(msg, queue);
}
if (hash != null)
{
Logger.Debug("Sending HTTP response.");
ctx.Response.AddHeader(Headers.ContentMd5Key, myHash);
ctx.Response.StatusCode = 200;
ctx.Response.StatusDescription = "OK";
ctx.Response.Close(Encoding.ASCII.GetBytes("<html><body>" + ctx.Response.StatusDescription + "</body></html>"), false);
}
}
catch (Exception ex)
{
Logger.Error("Unexpected error", ex);
try
{
ctx.Response.StatusCode = 502;
ctx.Response.StatusDescription = "Unexpected server error";
ctx.Response.Close(
Encoding.ASCII.GetBytes("<html><body>" + ctx.Response.StatusDescription + "</body></html>"),
false);
}
catch (Exception)
{
Logger.Info("Could not notify client about exception.");
}
}
Logger.Info("Http request processing complete.");
}