public void HandlersWorksAsUsual()
{
// Arrange
var handled = false;
var resetEvent = new ManualResetEvent(false);
DeclareQueue(QueueName);
adapter.Handle <DummyMessage>(req =>
{
handled = true;
resetEvent.Set();
});
// Act
adapter.Bus.Send(new DummyMessage {
Message = "hello there!"
});
if (!resetEvent.WaitOne(3.Seconds()))
{
Assert.Fail("Did not receive message within 3 seconds of waiting!");
}
// Assert
Assert.IsTrue(handled);
}
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 ItHasBeenFixed()
{
using (var adapter = new BuiltinContainerAdapter())
{
adapter.Handle<string>(s =>
{
throw new ApplicationException("Will trigger that the message gets moved to the error queue");
});
Configure.With(adapter)
.Transport(t => t.UseRabbitMq(ConnectionString, "test.input", "test.error")
.UseExchange("AlternativeExchange"))
.CreateBus()
.Start();
adapter.Bus.SendLocal("hello there!!!");
// wait until we're sure
Thread.Sleep(2.Seconds());
using (var errorQueue = new RabbitMqMessageQueue(ConnectionString, "test.error"))
{
var serializer = new JsonMessageSerializer();
var receivedTransportMessage = errorQueue.ReceiveMessage(new NoTransaction());
receivedTransportMessage.ShouldNotBe(null);
var errorMessage = serializer.Deserialize(receivedTransportMessage);
errorMessage.Messages.Length.ShouldBe(1);
errorMessage.Messages[0].ShouldBeTypeOf<string>();
((string)errorMessage.Messages[0]).ShouldBe("hello there!!!");
}
}
}
public void DoesNotLeakChannels()
{
// let MSMQ bus "bridge" between MSMQ and Rabbit by publishing all received strings
var receivedMessages = 0;
var resetEvent = new ManualResetEvent(false);
msmqBus.Handle <string>(str =>
{
rabbitBus.Bus.Publish(str);
receivedMessages++;
if (receivedMessages == 100)
{
resetEvent.Set();
}
});
var counter = 1;
100.Times(() => msmqBus.Bus.SendLocal(string.Format("This is message {0}", counter++)));
var timeout = 20.Seconds();
Assert.That(resetEvent.WaitOne(timeout), Is.Not.False, "Did not receive all the messages withing {0} timeout");
Thread.Sleep(30.Seconds());
}
static void Main()
{
using (var adapter = new BuiltinContainerAdapter())
{
adapter.Handle<string>(reply => Console.WriteLine("Got reply: {0}" + Environment.NewLine, reply));
Configure.With(adapter)
.Logging(l => l.ColoredConsole(minLevel: LogLevel.Warn))
.Transport(t => t.UseMsmqAndGetInputQueueNameFromAppConfig())
.MessageOwnership(o => o.FromRebusConfigurationSection())
.CreateBus()
.Start();
var bus = adapter.Bus;
Console.WriteLine("Type a greeting + ENTER to send to server" + Environment.NewLine);
while (true)
{
var text = Console.ReadLine();
if (string.IsNullOrWhiteSpace(text)) break;
var greeting = new SensitiveMessage(text);
bus.Send(greeting);
}
}
}
public void RunTest(bool useLowLatencyBackoffStrategy, int iterations)
{
var adapter = new BuiltinContainerAdapter();
var messageHasBeenReceived = new ManualResetEvent(false);
adapter.Handle<string>(s => messageHasBeenReceived.Set());
ConfigureBus(adapter, useLowLatencyBackoffStrategy);
var bus = adapter.Bus;
var recordedLatencies = new List<TimeSpan>();
iterations.Times(() =>
{
// let things calm down
Console.Write("Calming down.... ");
Thread.Sleep(30.Seconds());
Console.Write("Sending! ");
var sendTime = DateTime.UtcNow;
bus.SendLocal("w0000tamafooook!!1");
Console.Write("waiting... ");
messageHasBeenReceived.WaitUntilSetOrDie(20.Seconds());
var elapsedUntilNow = sendTime.ElapsedUntilNow();
Console.WriteLine("got the message - recorded latency of {0}", elapsedUntilNow);
recordedLatencies.Add(elapsedUntilNow);
messageHasBeenReceived.Reset();
});
Console.WriteLine("AVERAGE RECORDED LATENCY: {0:0.00} s", recordedLatencies.Average(t => t.TotalSeconds));
}
public void RunTest(bool useLowLatencyBackoffStrategy, int iterations)
{
var adapter = new BuiltinContainerAdapter();
var messageHasBeenReceived = new ManualResetEvent(false);
adapter.Handle <string>(s => messageHasBeenReceived.Set());
ConfigureBus(adapter, useLowLatencyBackoffStrategy);
var bus = adapter.Bus;
var recordedLatencies = new List <TimeSpan>();
iterations.Times(() =>
{
// let things calm down
Console.Write("Calming down.... ");
Thread.Sleep(30.Seconds());
Console.Write("Sending! ");
var sendTime = DateTime.UtcNow;
bus.SendLocal("w0000tamafooook!!1");
Console.Write("waiting... ");
messageHasBeenReceived.WaitUntilSetOrDie(20.Seconds());
var elapsedUntilNow = sendTime.ElapsedUntilNow();
Console.WriteLine("got the message - recorded latency of {0}", elapsedUntilNow);
recordedLatencies.Add(elapsedUntilNow);
messageHasBeenReceived.Reset();
});
Console.WriteLine("AVERAGE RECORDED LATENCY: {0:0.00} s", recordedLatencies.Average(t => t.TotalSeconds));
}
public void CanBeConfiguredToHandleMessagesInsideTransactionScope()
{
using (var adapter = new BuiltinContainerAdapter())
{
var resetEvent = new ManualResetEvent(false);
var transactionScopeDetected = false;
adapter.Handle <string>(str =>
{
transactionScopeDetected = Transaction.Current != null;
resetEvent.Set();
});
Configure.With(adapter)
.Transport(t => t.UseMsmq(InputQueueName, ErrorQueueName))
.Behavior(b => b.HandleMessagesInsideTransactionScope())
.CreateBus()
.Start();
adapter.Bus.SendLocal("bla bla whatever");
if (!resetEvent.WaitOne(2.Seconds()))
{
Assert.Fail("Did not receive the message withing 2 second timeout!!");
}
transactionScopeDetected.ShouldBe(true);
}
}
public void CanSendAndReceiveMessageWithThisManyKiloBytesOfOPayload(int sizeInKiloBytes)
{
// arrange
var resetEvent = new ManualResetEvent(false);
adapter.Handle <byte[]>(b => resetEvent.Set());
var sizeInBytes = sizeInKiloBytes * 1024;
var byteArray = Enumerable.Repeat((byte)'*', sizeInBytes).ToArray();
Console.WriteLine("Publishing byte[] with Length={0}", byteArray.Length);
// act
var stopwatch = Stopwatch.StartNew();
bus.Publish(byteArray);
Console.WriteLine("Publishing took {0:0.0} s", stopwatch.Elapsed.TotalSeconds);
var timeout = 2.Seconds() + TimeSpan.FromMilliseconds(byteArray.Length / 10);
if (!resetEvent.WaitOne(timeout))
{
Assert.Fail("Did not receive {0} bytes of messaging goodness within {1} timeout",
sizeInBytes, timeout);
}
// assert
}
public void ItWorks()
{
using (AppConfig.Change(AppConfigPath))
using (var adapter = new BuiltinContainerAdapter())
{
var messageHandled = new ManualResetEvent(false);
adapter.Handle<string>(s => messageHandled.Set());
var bus = Configure.With(adapter)
.Transport(t => t.UseMsmqAndGetInputQueueNameFromAppConfig())
.CreateBus()
.Start();
bus.SendLocal("hello there!");
messageHandled.WaitUntilSetOrDie(5.Seconds());
}
var auditedMessages = MsmqTestHelper
.GetMessagesFrom(AuditQueue)
.ToList();
Assert.That(auditedMessages.Count, Is.EqualTo(1), "Expected to find exactly one copy of the sent message in the audit queue");
Assert.That(auditedMessages.Single().Messages[0], Is.EqualTo("hello there!"));
}
IBus PullOneOutOfTheHat(string inputQueueName, Action <int> handler = null, bool oneExchangePerType = false, string inputExchange = null)
{
var adapter = new BuiltinContainerAdapter();
if (handler != null)
{
adapter.Handle <SomeEvent>(e => handler(e.Number));
}
Configure.With(adapter)
.Transport(t => {
var obj = t.UseRabbitMq(ConnectionString, inputQueueName, "error").ManageSubscriptions();
if (oneExchangePerType)
{
obj.UseOneExchangePerMessageTypeRouting();
}
if (inputExchange != null)
{
obj.UseExchangeAsInputAddress(inputExchange);
}
})
.CreateBus().Start();
TrackDisposable(adapter);
return(adapter.Bus);
}
public void CanCopySuccessfullyHandledMessageToAuditQueue()
{
// arrange
var fakeTime = DateTime.UtcNow;
TimeMachine.FixTo(fakeTime);
var resetEvent = new ManualResetEvent(false);
adapter.Handle<string>(str => resetEvent.Set());
// act
adapter.Bus.SendLocal("yo!");
// assert
var message = GetMessageFromAuditQueue();
message.ShouldNotBe(null);
var logicalMessages = message.Messages;
var headers = message.Headers;
logicalMessages.Length.ShouldBe(1);
logicalMessages[0].ShouldBe("yo!");
headers.ShouldContainKeyAndValue(Headers.AuditReason, Headers.AuditReasons.Handled);
headers.ShouldContainKeyAndValue(Headers.AuditMessageCopyTime, fakeTime.ToString("u"));
headers.ShouldContainKeyAndValue(Headers.AuditSourceQueue, InputQueueAddress);
}
public void DoesNotUseTransactionScopeByDefault()
{
using (var adapter = new BuiltinContainerAdapter())
{
var resetEvent = new ManualResetEvent(false);
var transactionScopeDetected = false;
adapter.Handle<string>(str =>
{
transactionScopeDetected = Transaction.Current != null;
resetEvent.Set();
});
Configure.With(adapter)
.Transport(t => t.UseMsmq(InputQueueName, ErrorQueueName))
.CreateBus()
.Start();
adapter.Bus.SendLocal("bla bla whatever");
if (!resetEvent.WaitOne(2.Seconds()))
{
Assert.Fail("Did not receive the message withing 2 second timeout!!");
}
transactionScopeDetected.ShouldBe(false);
}
}
static void Main()
{
using (var adapter = new BuiltinContainerAdapter())
{
adapter.Handle<Reply>(reply => Console.WriteLine("Got reply '{0}' (from OS process {1})", reply.KeyChar, reply.OsProcessId));
Configure.With(adapter)
.Logging(l => l.ColoredConsole(minLevel: LogLevel.Warn))
.Transport(t => t.UseSqlServer("server=.; database=rebus; trusted_connection=true", "producer.input", "error").EnsureTableIsCreated())
.MessageOwnership(o => o.FromRebusConfigurationSection())
.CreateBus()
.Start();
Console.WriteLine("Press Q to quit or any other key to produce a job");
while (true)
{
var keyChar = char.ToLower(Console.ReadKey(true).KeyChar);
switch (keyChar)
{
case 'q':
goto quit;
default:
adapter.Bus.Send(new Job(keyChar));
break;
}
}
quit:
Console.WriteLine("Quitting...");
}
}
public void YeahItDoes()
{
var deliveryAttempts = 0;
adapter.Handle <string>(str =>
{
Interlocked.Increment(ref deliveryAttempts);
throw new ApplicationException(RecognizableErrorMessage);
});
adapter.Bus.SendLocal("HELLO MY FRIEND!!!!!2222");
var timeout = 5.Seconds();
Assert.That(resetEvent.WaitOne(timeout), Is.True, "Did not receive PoisonMessage event within {0} timeout", timeout);
Assert.That(deliveryAttempts, Is.EqualTo(5), "Expected 5 failed delivery attempts to have been made");
// be sure that message has moved and everything
Thread.Sleep(1.Seconds());
using (var errorQueueClient = new AzureServiceBusMessageQueue(ConnectionString, ErrorQueueName))
{
var receivedTransportMessage = errorQueueClient.ReceiveMessage(new NoTransaction());
Assert.That(receivedTransportMessage, Is.Not.Null);
}
}
public void ItHasBeenFixed()
{
using (var adapter = new BuiltinContainerAdapter())
{
adapter.Handle <string>(s =>
{
throw new ApplicationException("Will trigger that the message gets moved to the error queue");
});
Configure.With(adapter)
.Transport(t => t.UseRabbitMq(ConnectionString, "test.input", "test.error")
.UseExchange("AlternativeExchange"))
.CreateBus()
.Start();
adapter.Bus.SendLocal("hello there!!!");
// wait until we're sure
Thread.Sleep(2.Seconds());
using (var errorQueue = new RabbitMqMessageQueue(ConnectionString, "test.error"))
{
var serializer = new JsonMessageSerializer();
var receivedTransportMessage = errorQueue.ReceiveMessage(new NoTransaction());
receivedTransportMessage.ShouldNotBe(null);
var errorMessage = serializer.Deserialize(receivedTransportMessage);
errorMessage.Messages.Length.ShouldBe(1);
errorMessage.Messages[0].ShouldBeOfType <string>();
((string)errorMessage.Messages[0]).ShouldBe("hello there!!!");
}
}
}
public void ItWorks()
{
using (AppConfig.Change(AppConfigPath))
using (var adapter = new BuiltinContainerAdapter())
{
var messageHandled = new ManualResetEvent(false);
adapter.Handle <string>(s => messageHandled.Set());
var bus = Configure.With(adapter)
.Transport(t => t.UseMsmqAndGetInputQueueNameFromAppConfig())
.CreateBus()
.Start();
bus.SendLocal("hello there!");
messageHandled.WaitUntilSetOrDie(5.Seconds());
}
var auditedMessages = MsmqTestHelper
.GetMessagesFrom(AuditQueue)
.ToList();
Assert.That(auditedMessages.Count, Is.EqualTo(1), "Expected to find exactly one copy of the sent message in the audit queue");
Assert.That(auditedMessages.Single().Messages[0], Is.EqualTo("hello there!"));
}
static void Main()
{
using (var adapter = new BuiltinContainerAdapter())
{
adapter.Handle <string>(reply => Console.WriteLine("Got reply: {0}" + Environment.NewLine, reply));
Configure.With(adapter)
.Logging(l => l.ColoredConsole(minLevel: LogLevel.Warn))
.Transport(t => t.UseMsmqAndGetInputQueueNameFromAppConfig())
.MessageOwnership(o => o.FromRebusConfigurationSection())
.CreateBus()
.Start();
var bus = adapter.Bus;
Console.WriteLine("Type a greeting + ENTER to send to server" + Environment.NewLine);
while (true)
{
var text = Console.ReadLine();
if (string.IsNullOrWhiteSpace(text))
{
break;
}
var greeting = new GreetingMessage(text);
bus.Send(greeting);
}
}
}
public void CanConfigureNumberOfRetriesForExceptionTypes()
{
using (var adapter = new BuiltinContainerAdapter())
using (var errorQueue = GetMessageQueue(ErrorQueueName))
{
errorQueue.Purge();
using (var inputQueue = GetMessageQueue(TestCustomRetryCountInput))
{
inputQueue.Purge();
}
var bimCount = 0;
var bomCount = 0;
var bommelomCount = 0;
adapter.Handle <string>(str =>
{
if (str == "bim")
{
bimCount++;
throw new InvalidOperationException("bim!");
}
if (str == "bom")
{
bomCount++;
throw new ArgumentException("bom!");
}
bommelomCount++;
throw new ExpectationViolationException("bommelom!");
});
var bus = (RebusBus)
Configure.With(adapter)
.Logging(l => l.None())
.Transport(t => t.UseMsmq(TestCustomRetryCountInput, ErrorQueueName))
.Behavior(b => b.SetMaxRetriesFor <InvalidOperationException>(9)
.SetMaxRetriesFor <ArgumentException>(7))
.CreateBus();
bus.Start(1);
adapter.Bus.SendLocal("bim");
adapter.Bus.SendLocal("bom");
adapter.Bus.SendLocal("bommelom");
// dequeue three messages
var first = errorQueue.Receive(TimeSpan.FromSeconds(10));
var second = errorQueue.Receive(TimeSpan.FromSeconds(1));
var third = errorQueue.Receive(TimeSpan.FromSeconds(1));
bimCount.ShouldBe(9);
bomCount.ShouldBe(7);
bommelomCount.ShouldBe(5); //< default
}
}
public void CanConfigureNumberOfRetriesForExceptionTypes()
{
using (var adapter = new BuiltinContainerAdapter())
using (var errorQueue = GetMessageQueue(ErrorQueueName))
{
errorQueue.Purge();
using (var inputQueue = GetMessageQueue(TestCustomRetryCountInput))
{
inputQueue.Purge();
}
var bimCount = 0;
var bomCount = 0;
var bommelomCount = 0;
adapter.Handle<string>(str =>
{
if (str == "bim")
{
bimCount++;
throw new InvalidOperationException("bim!");
}
if (str == "bom")
{
bomCount++;
throw new ArgumentException("bom!");
}
bommelomCount++;
throw new ExpectationViolationException("bommelom!");
});
var bus = (RebusBus)
Configure.With(adapter)
.Logging(l => l.None())
.Transport(t => t.UseMsmq(TestCustomRetryCountInput, ErrorQueueName))
.Behavior(b => b.SetMaxRetriesFor<InvalidOperationException>(9)
.SetMaxRetriesFor<ArgumentException>(7))
.CreateBus();
bus.Start(1);
adapter.Bus.SendLocal("bim");
adapter.Bus.SendLocal("bom");
adapter.Bus.SendLocal("bommelom");
// dequeue three messages
var first = errorQueue.Receive(TimeSpan.FromSeconds(10));
var second = errorQueue.Receive(TimeSpan.FromSeconds(1));
var third = errorQueue.Receive(TimeSpan.FromSeconds(1));
bimCount.ShouldBe(9);
bomCount.ShouldBe(7);
bommelomCount.ShouldBe(5); //< default
}
}
public void DoesNotReceiveTheSameMessageTwice()
{
var counts = new ConcurrentDictionary <string, int>();
bus1.Handle <string>(str =>
{
counts.AddOrUpdate(str, key => 1, (key, value) => value + 1);
Thread.Sleep(100);
});
const string message = "bam!!";
bus1.Bus.SendLocal(message);
Thread.Sleep(2.Seconds());
counts.ShouldContainKeyAndValue(message, 1);
}
public void AzureServiceBusIsJustEmulatingItsThingByActuallyUsingMsmqUnderneath()
{
var resetEvent = new ManualResetEvent(false);
azureAdapter.Handle <string>(message => msmqAdapter.Bus.Reply(string.Format("I got your message: {0}", message)));
msmqAdapter.Handle <string>(reply =>
{
if (reply == "I got your message: H3LL0!!")
{
resetEvent.Set();
}
});
msmqAdapter.Bus.Advanced.Routing.Send(AzureReceiverInputQueueName, "H3LL0!!");
var timeout = 2.Seconds();
Assert.That(resetEvent.WaitOne(timeout), Is.True, "Did not receive reply within {0} timeout", timeout);
}
public void BasicThingWorks()
{
adapter.Handle <SomeRequest>(req => bus.Reply(new SomeReply {
Message = "Thank you sir!"
}));
var resetEvent = new ManualResetEvent(false);
adapter.Bus.Send(new SomeRequest {
Message = "hello there!"
},
(SomeReply reply) =>
{
Console.WriteLine("Got reply in callback: {0} - YAY!", reply.Message);
resetEvent.Set();
});
if (!resetEvent.WaitOne(2.Seconds()))
{
Assert.Fail("Did not receive reply within 2 seconds of waiting!");
}
}
void StartWorkerBus(string queueName, ConcurrentQueue <WorkDone> workDone)
{
var adapter = new BuiltinContainerAdapter();
adapter.Handle <Work>(w => workDone.Enqueue(new WorkDone
{
MessageId = w.MessageId,
WorkerQueueName = queueName
}));
Configure.With(TrackDisposable(adapter))
.Logging(l => l.ColoredConsole(minLevel: LogLevel.Warn))
.Transport(t => t.UseMsmq(queueName, "error"))
.CreateBus()
.Start();
}
static void Main(string[] args)
{
// we have the container in a variable, but you would probably stash it in a static field somewhere
using (var adapter = new BuiltinContainerAdapter())
{
Configure.With(adapter)
.Logging(t => t.None())
.Transport(t => t.UseMsmqAndGetInputQueueNameFromAppConfig())
.MessageOwnership(d => d.FromRebusConfigurationSection())
.CreateBus().Start();
adapter.Handle <DateTime>(currentDateTime => Console.WriteLine("The time is {0}", currentDateTime));
Console.WriteLine("Press enter to quit");
Console.ReadLine();
} //< always dispose bus when your app quits - here done via the container adapter
}
IBus PullOneOutOfTheHat(string inputQueueName, Action <int> handler = null)
{
var adapter = new BuiltinContainerAdapter();
if (handler != null)
{
adapter.Handle <SomeEvent>(e => handler(e.Number));
}
Configure.With(adapter)
.Transport(t => t.UseRabbitMq(ConnectionString, inputQueueName, "error").ManageSubscriptions())
.CreateBus().Start();
TrackDisposable(adapter);
return(adapter.Bus);
}
public void YesItWorks()
{
var resetEvent = new ManualResetEvent(false);
recipientAdapter.Handle <string>(str =>
{
if (str == "hullo!")
{
resetEvent.Set();
}
});
senderAdapter.Bus.Advanced.Routing.Send(RecipientInputQueueName, "hullo!");
var timeout = 5.Seconds();
Assert.That(resetEvent.WaitOne(timeout), Is.True,
"Does not look like we received the message withing {0} timeout", timeout);
}
public void SeeIfItWorks(int workers, int iterations)
{
var receivedStrings = new List <string>();
using (var adapter1 = new BuiltinContainerAdapter())
using (var adapter2 = new BuiltinContainerAdapter())
{
adapter1.Handle <ThisIsJustSomeRandomTestMessage>(msg => receivedStrings.Add(msg.WithSomethingInside));
var bus1 =
(RebusBus)Configure.With(adapter1)
.Transport(x => x.UseRabbitMq(ConnectionString, InputQueueName1, ErrorQueueName)
.ManageSubscriptions())
.CreateBus();
bus1.Start(workers);
bus1.Subscribe <ThisIsJustSomeRandomTestMessage>();
var bus2 =
(RebusBus)Configure.With(adapter2)
.Transport(x => x.UseRabbitMq(ConnectionString, InputQueueName2, ErrorQueueName)
.ManageSubscriptions())
.CreateBus();
bus2.Start(1);
var messageCounter = 1;
iterations.Times(() =>
{
Thread.Sleep(TimeSpan.FromSeconds(2));
bus2.Publish(new ThisIsJustSomeRandomTestMessage {
WithSomethingInside = string.Format("Message number {0}", messageCounter++)
});
});
Thread.Sleep(TimeSpan.FromSeconds(5));
}
receivedStrings.ShouldBe(Enumerable.Range(1, iterations)
.Select(i => string.Format("Message number {0}", i))
.ToList());
}
static void Main()
{
using (var adapter = new BuiltinContainerAdapter())
{
adapter.Handle<Job>(job =>
{
adapter.Bus.Reply(new Reply(job.KeyChar, Process.GetCurrentProcess().Id));
});
Configure.With(adapter)
.Logging(l => l.ColoredConsole(minLevel: LogLevel.Warn))
.Transport(t => t.UseSqlServer("server=.; database=rebus; trusted_connection=true", "consumer.input", "error").EnsureTableIsCreated())
.CreateBus()
.Start();
Console.WriteLine("Press ENTER to quit");
Console.ReadLine();
}
}
static void Main()
{
using (var adapter = new BuiltinContainerAdapter())
{
adapter.Handle <Job>(job =>
{
Console.WriteLine("Processing job {0}", job.JobNumber);
Thread.Sleep(200);
});
Configure.With(adapter)
.Logging(l => l.ColoredConsole(LogLevel.Warn))
.Transport(t => t.UseMsmqAndGetInputQueueNameFromAppConfig())
.CreateBus()
.Start();
Console.WriteLine("Consumer 1 listening - press ENTER to quit");
Console.ReadLine();
}
}
static void Main()
{
using (var adapter = new BuiltinContainerAdapter())
{
adapter.Handle<Job>(job =>
{
Console.WriteLine("Processing job {0}", job.JobNumber);
Thread.Sleep(200);
});
Configure.With(adapter)
.Logging(l => l.ColoredConsole(LogLevel.Warn))
.Transport(t => t.UseMsmqAndGetInputQueueNameFromAppConfig())
.CreateBus()
.Start();
Console.WriteLine("Consumer 1 listening - press ENTER to quit");
Console.ReadLine();
}
}
public void SeeIfItWorks(int workers, int iterations)
{
var receivedStrings = new List<string>();
using (var adapter1 = new BuiltinContainerAdapter())
using (var adapter2 = new BuiltinContainerAdapter())
{
adapter1.Handle<ThisIsJustSomeRandomTestMessage>(msg => receivedStrings.Add(msg.WithSomethingInside));
var bus1 =
(RebusBus) Configure.With(adapter1)
.Transport(x => x.UseRabbitMq(ConnectionString, InputQueueName1, ErrorQueueName)
.ManageSubscriptions())
.CreateBus();
bus1.Start(workers);
bus1.Subscribe<ThisIsJustSomeRandomTestMessage>();
var bus2 =
(RebusBus) Configure.With(adapter2)
.Transport(x => x.UseRabbitMq(ConnectionString, InputQueueName2, ErrorQueueName)
.ManageSubscriptions())
.CreateBus();
bus2.Start(1);
var messageCounter = 1;
iterations.Times(() =>
{
Thread.Sleep(TimeSpan.FromSeconds(2));
bus2.Publish(new ThisIsJustSomeRandomTestMessage{WithSomethingInside=string.Format("Message number {0}", messageCounter++)});
});
Thread.Sleep(TimeSpan.FromSeconds(5));
}
receivedStrings.ShouldBe(Enumerable.Range(1, iterations)
.Select(i => string.Format("Message number {0}", i))
.ToList());
}
static void Main()
{
using (var adapter = new BuiltinContainerAdapter())
{
adapter.Handle<Job>(job =>
{
Console.WriteLine("Processing job {0}", job.JobNumber);
Thread.Sleep(200);
});
Configure.With(adapter)
.Logging(l => l.ColoredConsole(LogLevel.Warn))
.Transport(t => t.UseSqlServer("server=.;initial catalog=rebus_test;integrated security=true", "consumer", "error")
.EnsureTableIsCreated())
.CreateBus()
.Start(20);
Console.WriteLine("Consumer listening - press ENTER to quit");
Console.ReadLine();
}
}
IBus Create(string inputQueueName, Action <SomeEvent> eventHandler = null)
{
RabbitMqFixtureBase.DeleteQueue(inputQueueName);
var adapter = new BuiltinContainerAdapter();
if (eventHandler != null)
{
adapter.Handle(eventHandler);
}
Configure.With(adapter)
.Transport(t => t.UseRabbitMq(RabbitMqFixtureBase.ConnectionString,
inputQueueName,
"test.resilience.error")
.ManageSubscriptions())
.CreateBus()
.Start();
TrackDisposable(adapter);
return(adapter.Bus);
}
static void Main()
{
using (var adapter = new BuiltinContainerAdapter())
{
adapter.Handle<Job>(job =>
{
Console.WriteLine("Processing job {0}", job.JobNumber);
Thread.Sleep(200);
});
Configure.With(adapter)
.Logging(l => l.ColoredConsole(LogLevel.Warn))
.Transport(t => t.UseRabbitMq("amqp://localhost", "consumer", "error")
.ManageSubscriptions()
.SetPrefetchCount(65535))
.CreateBus()
.Start(20);
adapter.Bus.Subscribe<Job>();
Console.WriteLine("Consumer listening - press ENTER to quit");
Console.ReadLine();
}
}
public void StatementOfSomethingThatMustHold(int numberOfWorkers)
{
var resetEvent = new ManualResetEvent(false);
adapter.Handle <string>(str =>
{
if (str == "w00t!")
{
resetEvent.Set();
}
});
var bus = startableBus.Start(numberOfWorkers);
Thread.Sleep(0.5.Seconds());
bus.Subscribe <string>();
bus.Publish("w00t!");
var timeout = 3.Seconds();
Assert.That(resetEvent.WaitOne(timeout), Is.True, "Did not receive expected event within {0} timeout", timeout);
}
IBus PullOneOutOfTheHat(string inputQueueName, Action<int> handler = null, bool oneExchangePerType = false, string inputExchange = null)
{
var adapter = new BuiltinContainerAdapter();
if (handler != null) adapter.Handle<SomeEvent>(e => handler(e.Number));
Configure.With(adapter)
.Transport(t => {
var obj = t.UseRabbitMq(ConnectionString, inputQueueName, "error").ManageSubscriptions();
if (oneExchangePerType) obj.UseOneExchangePerMessageTypeRouting();
if (inputExchange != null) obj.UseExchangeAsInputAddress(inputExchange);
})
.CreateBus().Start();
TrackDisposable(adapter);
return adapter.Bus;
}
IBus Create(string inputQueueName, Action<SomeEvent> eventHandler = null)
{
RabbitMqFixtureBase.DeleteQueue(inputQueueName);
var adapter = new BuiltinContainerAdapter();
if (eventHandler != null) adapter.Handle(eventHandler);
Configure.With(adapter)
.Transport(t => t.UseRabbitMq(RabbitMqFixtureBase.ConnectionString,
inputQueueName,
"test.resilience.error")
.ManageSubscriptions())
.CreateBus()
.Start();
disposables.Add(adapter);
return adapter.Bus;
}
public void CanSendAndReceiveManyMessagesReliably(int numberOfMessages)
{
using (var statusTimer = new Timer())
{
var messages = Enumerable.Range(1, numberOfMessages)
.Select(n => new SomeNumberedMessage
{
Id = Guid.NewGuid(),
Text = string.Format("Message # {0}", n)
})
.ToList();
var receivedMessages = new ConcurrentList <SomeNumberedMessage>();
var resetEvent = new ManualResetEvent(false);
var sentMessageIds = new ConcurrentList <Guid>();
statusTimer.Elapsed += (sender, args) => Console.WriteLine("Sent {0} messages, received {1} messages",
sentMessageIds.Count, receivedMessages.Count);
statusTimer.Interval = 2000;
statusTimer.Start();
adapter2.Handle <SomeNumberedMessage>(msg =>
{
receivedMessages.Add(msg);
if (receivedMessages.Count >= numberOfMessages)
{
Console.WriteLine("Setting the reset event!");
resetEvent.Set();
}
});
var rebusRouting = adapter1.Bus.Advanced.Routing;
var stopwatch = Stopwatch.StartNew();
// send first half as batch
var batchSize = messages.Count / 2;
var firstBatch = messages.Take(batchSize)
.ToList();
var theRest = messages.Skip(batchSize)
.ToList();
Console.WriteLine("Sending the first {0} messages in batches", firstBatch.Count);
foreach (var msgBatch in firstBatch.Partition(100))
{
Console.WriteLine("Sending batch of {0} messages", msgBatch.Count);
var complete = false;
var attempts = 0;
do
{
try
{
using (var scope = new TransactionScope())
{
foreach (var msg in msgBatch)
{
rebusRouting.Send(QueueName2, msg);
sentMessageIds.Add(msg.Id);
}
scope.Complete();
}
complete = true;
}
catch (Exception e)
{
Console.WriteLine("An error occurred while sending batch of {0} msgs: {1}",
msgBatch.Count, e);
attempts++;
if (attempts >= 5)
{
throw;
}
Thread.Sleep(1.Seconds());
}
} while (!complete);
}
Console.WriteLine("Sending the next {0} messages one at a time", theRest.Count);
foreach (var msg in theRest)
{
var attempts = 0;
var complete = false;
do
{
try
{
rebusRouting.Send(QueueName2, msg);
sentMessageIds.Add(msg.Id);
complete = true;
}
catch (Exception e)
{
Console.WriteLine("An error occurred while attempting to send single message: {0}", e);
attempts++;
if (attempts >= 5)
{
throw;
}
Thread.Sleep(1.Seconds());
}
} while (!complete);
}
var totalSeconds = stopwatch.Elapsed.TotalSeconds;
Console.WriteLine("Sending {0} messages took {1:0.0} s - that's {2:0} msg/s",
numberOfMessages, totalSeconds, numberOfMessages / totalSeconds);
var timeout = TimeSpan.FromSeconds(15 + numberOfMessages / 10.0);
Console.WriteLine("Waiting with {0} timeout", timeout);
if (!resetEvent.WaitOne(timeout))
{
Assert.Fail(@"Did not receive all {0} messages within {1} timeout
{2}",
numberOfMessages, timeout, FormatReport(sentMessageIds, receivedMessages));
}
Console.WriteLine("Waiting some extra time for possible duplicates to arrive");
// wait and see if we have duplicates
Thread.Sleep(2.Seconds());
Console.WriteLine("Checking stuff");
receivedMessages.Count.ShouldBe(numberOfMessages);
Console.WriteLine("Checking {0} messages", sentMessageIds.Count);
var formattedReport = FormatReport(sentMessageIds, receivedMessages);
foreach (var id in sentMessageIds)
{
var messagesWithThatId = receivedMessages.Count(m => m.Id == id);
Assert.That(messagesWithThatId, Is.EqualTo(1),
@"Expected exactly 1 message with ID {0}, but there was {1}!!
{2}",
id, messagesWithThatId, formattedReport);
}
Console.WriteLine("All done!");
}
Console.WriteLine("Disposed!!");
}
public void Run()
{
var endpointName = Assembly.GetEntryAssembly().GetName().Name;
var directory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "RebusSamples", "MessageBus");
var subscriptionsFilePath = Path.Combine(directory, "subscriptions.xml");
using (var adapter = new BuiltinContainerAdapter())
{
adapter.Handle<string>(str => Console.WriteLine("Got message: {0}", str));
Console.WriteLine("Starting {0} bus - using subscription storage in {1}...", endpointName, subscriptionsFilePath);
Configure.With(adapter)
.Logging(l => l.ColoredConsole(minLevel: LogLevel.Warn))
.Transport(t => t.UseMsmqAndGetInputQueueNameFromAppConfig())
.MessageOwnership(o => o.FromRebusConfigurationSection())
.Subscriptions(s => s.StoreInXmlFile(subscriptionsFilePath))
.CreateBus()
.Start();
Console.WriteLine(@"-------------------------------
A) Subscribe to System.String
B) Unsubscribe to System.String
C) Publish System.String
Q) Quit
-------------------------------
");
var keepRunning = true;
while (keepRunning)
{
var key = Console.ReadKey(true);
switch (char.ToLower(key.KeyChar))
{
case 'a':
Console.WriteLine("Subscribing!");
adapter.Bus.Subscribe<string>();
break;
case 'b':
Console.WriteLine("Unsubscribing!");
adapter.Bus.Unsubscribe<string>();
break;
case 'c':
Console.WriteLine("Publishing!");
adapter.Bus.Publish(string.Format("Greetings to subscribers from {0}", endpointName));
break;
case 'q':
Console.WriteLine("Quitting!");
keepRunning = false;
break;
}
}
Console.WriteLine("Stopping the bus....");
}
}
IBus PullOneOutOfTheHat(string inputQueueName, Action<int> handler = null)
{
var adapter = new BuiltinContainerAdapter();
if (handler != null) adapter.Handle<SomeEvent>(e => handler(e.Number));
Configure.With(adapter)
.Transport(t => t.UseRabbitMq(ConnectionString, inputQueueName, "error").ManageSubscriptions())
.CreateBus().Start();
disposables.Add(adapter);
return adapter.Bus;
}
void StartWorkerBus(string queueName, ConcurrentQueue<WorkDone> workDone)
{
var adapter = new BuiltinContainerAdapter();
adapter.Handle<Work>(w => workDone.Enqueue(new WorkDone
{
MessageId = w.MessageId,
WorkerQueueName = queueName
}));
Configure.With(TrackDisposable(adapter))
.Logging(l => l.ColoredConsole(minLevel:LogLevel.Warn))
.Transport(t => t.UseMsmq(queueName, "error"))
.CreateBus()
.Start();
}
