public async Task ItWorks() { var sub1GotEvent = new ManualResetEvent(false); var sub2GotEvent = new ManualResetEvent(false); var sub1 = GetBus(_subscriber1QueueName, async str => { if (str == "weehoo!!") { sub1GotEvent.Set(); } }); var sub2 = GetBus(_subscriber2QueueName, async str => { if (str == "weehoo!!") { sub2GotEvent.Set(); } }); await sub1.Bus.Subscribe<string>(); await sub2.Bus.Subscribe<string>(); await _publisher.Bus.Publish("weehoo!!"); sub1GotEvent.WaitOrDie(TimeSpan.FromSeconds(2)); sub2GotEvent.WaitOrDie(TimeSpan.FromSeconds(2)); }
public void ItWorks() { var gotTheMessage = new ManualResetEvent(false); _handlerActivator.Handle<HugeMessage>(async msg => { gotTheMessage.Set(); }); var hugePayload = string.Concat(Enumerable.Range(0, 128) .Select(i => string.Concat(Enumerable.Repeat(i.ToString(), 128)))); _bus.SendLocal(new HugeMessage {Payload = hugePayload}); gotTheMessage.WaitOrDie(TimeSpan.FromSeconds(2)); var hugePayloadLength = hugePayload.Length; var sentMessageBodyLength = _sentMessages.Single().Body.Length; var receivedMessageBodyLength = _receivedMessages.Single().Body.Length; Console.WriteLine(@" Huge payload: {0} Sent message: {1} Received message: {2}", hugePayloadLength, sentMessageBodyLength, receivedMessageBodyLength); Assert.That(sentMessageBodyLength, Is.LessThan(hugePayloadLength)); Assert.That(receivedMessageBodyLength, Is.LessThan(hugePayloadLength)); }
public void CheckEncryptedMessages() { var transportMessages = new ConcurrentQueue<TransportMessage>(); _transportTap.MessageReceived += transportMessages.Enqueue; _transportTap.MessageSent += transportMessages.Enqueue; var gotMessage = new ManualResetEvent(false); _activator.Handle<string>(async message => { if (message != "hej") throw new ArgumentException("not the right message!!"); gotMessage.Set(); }); _activator.Bus.SendLocal("hej").Wait(); gotMessage.WaitOrDie(TimeSpan.FromSeconds(3)); var messages = transportMessages.ToList(); Assert.That(messages.Count, Is.EqualTo(2)); var headers = messages.First().Headers; Assert.That(headers[EncryptionHeaders.ContentEncryption], Is.EqualTo("silly")); }
public async Task UsesNativeDeferralMechanism() { var done = new ManualResetEvent(false); var receiveTime = DateTimeOffset.MinValue; var hadDeferredUntilHeader = false; _activator.Handle<TimedMessage>(async (bus, context, message) => { receiveTime = DateTimeOffset.Now; hadDeferredUntilHeader = context.TransportMessage.Headers.ContainsKey(Headers.DeferredUntil); done.Set(); }); var sendTime = DateTimeOffset.Now; await _bus.Defer(TimeSpan.FromSeconds(5), new TimedMessage { Time = sendTime }); done.WaitOrDie(TimeSpan.FromSeconds(8), "Did not receive 5s-deferred message within 8 seconds of waiting...."); var delay = receiveTime - sendTime; Console.WriteLine("Message was delayed {0}", delay); Assert.That(delay, Is.GreaterThan(TimeSpan.FromSeconds(4)), "The message not delayed ~5 seconds as expected!"); Assert.That(delay, Is.LessThan(TimeSpan.FromSeconds(8)), "The message not delayed ~5 seconds as expected!"); Assert.That(hadDeferredUntilHeader, Is.False, "Received message still had the '{0}' header - we must remove that", Headers.DeferredUntil); }
public async Task NizzleName() { var gotMessage = new ManualResetEvent(false); using (var activator = new BuiltinHandlerActivator()) { activator.Handle<string>(async s => { Console.WriteLine("Got message: {0}", s); gotMessage.Set(); }); Configure.With(activator) .Transport(t => t.UseInMemoryTransport(new InMemNetwork(), "bimse")) .Options(o => { o.Register<IWorkerFactory>(c => { var transport = c.Get<ITransport>(); var pipeline = c.Get<IPipeline>(); var pipelineInvoker = c.Get<IPipelineInvoker>(); var rebusLoggerFactory = c.Get<IRebusLoggerFactory>(); return new AsyncTaskWorkerFactory(transport, pipeline, pipelineInvoker, rebusLoggerFactory); }); }) .Start(); await activator.Bus.SendLocal("hej med dig min ven"); gotMessage.WaitOrDie(TimeSpan.FromSeconds(3)); } }
public void DoesNotBarfInTheBackground() { var doneHandlingMessage = new ManualResetEvent(false); _activator.Handle<string>(async str => { for (var count = 0; count < 5; count++) { Console.WriteLine("waiting..."); await Task.Delay(TimeSpan.FromSeconds(20)); } Console.WriteLine("done waiting!"); doneHandlingMessage.Set(); }); _activator.Bus.SendLocal("hej med dig min ven!").Wait(); doneHandlingMessage.WaitOrDie(TimeSpan.FromMinutes(2)); var logLinesAboveInformation = _loggerFactory .Where(l => l.Level >= LogLevel.Warn) .ToList(); Assert.That(!logLinesAboveInformation.Any(), "Expected no warnings - got this: {0}", string.Join(Environment.NewLine, logLinesAboveInformation)); }
public void CanHandleMessagesInsideTranasctionScope(bool useTransactionScope) { var done = new ManualResetEvent(false); var detectedAmbientTransaction = false; var activator = Using(new BuiltinHandlerActivator()); activator.Handle<string>(async str => { detectedAmbientTransaction = Transaction.Current != null; done.Set(); }); Configure.With(activator) .Transport(t => t.UseInMemoryTransport(new InMemNetwork(), "txtest")) .Options(o => { if (useTransactionScope) { o.HandleMessagesInsideTransactionScope(); } o.LogPipeline(); }) .Start(); activator.Bus.SendLocal("hej").Wait(); done.WaitOrDie(TimeSpan.FromSeconds(2)); Assert.That(detectedAmbientTransaction, Is.EqualTo(useTransactionScope), "Detected: {0}, expected: {1}", detectedAmbientTransaction, useTransactionScope); }
public async Task CopiesProperlyHandledMessageToAuditQueue() { var gotTheMessage = new ManualResetEvent(false); _adapter.Handle<string>(async _ => { gotTheMessage.Set(); }); await _bus.SendLocal("woohooo!!!!"); gotTheMessage.WaitOrDie(TimeSpan.FromSeconds(5)); InMemTransportMessage message; var timer = Stopwatch.StartNew(); while ((message = _network.GetNextOrNull("audit")) == null) { await Task.Delay(200); if (timer.Elapsed > TimeSpan.FromSeconds(2)) { Assert.Fail("Did not receive message copy within 2 seconds of waiting...."); } } PrintHeaders(message); Assert.That(message.Headers.ContainsKey(AuditHeaders.AuditTime)); Assert.That(message.Headers.ContainsKey(AuditHeaders.HandleTime)); Assert.That(message.Headers.ContainsKey(Headers.Intent)); Assert.That(message.Headers[Headers.Intent], Is.EqualTo(Headers.IntentOptions.PointToPoint)); }
public async Task CanSendAndReceive() { var gotMessage = new ManualResetEvent(false); _handlerActivator .Handle<string>(async (bus, str) => { if (str == "hej med dig min ven!") { Console.WriteLine("w00t!"); await bus.Reply("t00t!"); } if (str == "t00t!") { Console.WriteLine("got t++t!!!"); gotMessage.Set(); } }); await _bus.Send("hej med dig min ven!"); gotMessage.WaitOrDie(TimeSpan.FromSeconds(30)); }
public async Task DoIt() { var builtinHandlerActivator = new BuiltinHandlerActivator(); var allDone = false; var gotMessage = new ManualResetEvent(false); builtinHandlerActivator.Handle<string>(async _ => { gotMessage.Set(); await Task.Delay(2000); allDone = true; }); var bus = Configure.With(builtinHandlerActivator) .Transport(t => t.UseInMemoryTransport(new InMemNetwork(), "shutdown with pending tasks")) .Start(); using (bus) { await bus.SendLocal("hej"); gotMessage.WaitOrDie(TimeSpan.FromSeconds(2)); // make bus shut down here } Assert.That(allDone, Is.True, "The message was apparently not handled all the way to the end!!!"); }
public async Task PubSubSeemsToWorkAlsoWithUnsubscribe() { var gotString1 = new ManualResetEvent(false); var subscriber2GotTheMessage = false; _bus1.Handle<string>(async str => gotString1.Set()); _bus2.Handle<string>(async str => { subscriber2GotTheMessage = true; }); await _bus1.Bus.Subscribe<string>(); await _bus2.Bus.Subscribe<string>(); await Task.Delay(500); await _bus2.Bus.Unsubscribe<string>(); await Task.Delay(500); await _bus3.Bus.Publish("hello there!!!!"); gotString1.WaitOrDie(TimeSpan.FromSeconds(2)); Assert.That(subscriber2GotTheMessage, Is.False, "Didn't expect subscriber 2 to get the string since it was unsubscribed"); }
public async Task YeahItWorks() { var events = new List<string>(); var finishedHandled = new ManualResetEvent(false); _handlerActivator.Handle<string>(async str => { await AppendEvent(events, "1"); await AppendEvent(events, "2"); await AppendEvent(events, "3"); await AppendEvent(events, "4"); finishedHandled.Set(); }); Console.WriteLine(string.Join(Environment.NewLine, events)); await _bus.Send("hej med dig!"); finishedHandled.WaitOrDie(TimeSpan.FromSeconds(10)); Assert.That(events.Count, Is.EqualTo(4)); Assert.That(events[0], Is.StringStarting("event=1")); Assert.That(events[1], Is.StringStarting("event=2")); Assert.That(events[2], Is.StringStarting("event=3")); Assert.That(events[3], Is.StringStarting("event=4")); }
public void ItWorksWithComplexMessage(bool withCompressionEnabled) { var activator = new BuiltinHandlerActivator(); var gotIt = new ManualResetEvent(false); activator.Handle<TextMessage>(async str => { if (string.Equals(str.Text, LongText)) { gotIt.Set(); } else { throw new Exception(string.Format("Received text with {0} chars did not match expected text with {1} chars!", str.Text.Length, LongText.Length)); } }); Using(activator); var bus = CreateBus(withCompressionEnabled, activator); bus.SendLocal(new TextMessage {Text = LongText}).Wait(); gotIt.WaitOrDie(TimeSpan.FromSeconds(10)); }
public void DispatchesDynamicMessageWhenDotNetTypeCannotBeFound() { var gotTheMessage = new ManualResetEvent(false); string messageText = null; _builtinHandlerActivator.Handle<dynamic>(async message => { Console.WriteLine("Received dynamic message: {0}", message); messageText = message.something.text; gotTheMessage.Set(); }); var headers = new Dictionary<string, string> { {Headers.MessageId, Guid.NewGuid().ToString()}, {Headers.ContentType, "application/json;charset=utf-8"}, }; var transportMessage = new TransportMessage(headers, Encoding.UTF8.GetBytes(@"{ ""something"": { ""text"": ""OMG dynamic JSON BABY!!"" } }")); _network.Deliver(InputQueueName, new InMemTransportMessage(transportMessage)); gotTheMessage.WaitOrDie(TimeSpan.FromSeconds(2)); Assert.That(messageText, Is.EqualTo("OMG dynamic JSON BABY!!")); }
public async Task CanSubscribeEvenThoughWeHaveNotConfiguredAnyEndpointMappings() { var gotTheString = new ManualResetEvent(false); _activator.Handle<string>(async str => gotTheString.Set()); await _activator.Bus.Subscribe<string>(); await Task.Delay(500); await _activator.Bus.Publish("whooo hooo this is a string!!"); gotTheString.WaitOrDie(TimeSpan.FromSeconds(2)); }
public async Task OneWayClientWorks() { var gotIt = new ManualResetEvent(false); _server.Handle<string>(async str => { Console.WriteLine("Got string: {0}", str); gotIt.Set(); }); await _client.Send("w000000h000000!!!!1111"); gotIt.WaitOrDie(TimeSpan.FromSeconds(3)); }
public async Task CanDeferMessage() { var stopwatch = Stopwatch.StartNew(); var gotTheMessage = new ManualResetEvent(false); _activator.Handle<string>(async str => { stopwatch.Stop(); gotTheMessage.Set(); }); await _activator.Bus.Defer(TimeSpan.FromSeconds(4), "hej med dig!"); gotTheMessage.WaitOrDie(TimeSpan.FromSeconds(8)); Assert.That(stopwatch.Elapsed, Is.GreaterThan(TimeSpan.FromSeconds(4))); }
public async Task ItWorksWhenTheHeaderHasBeenSet() { var gotTheMessage = new ManualResetEvent(false); _destination.Handle<string>(async str => { gotTheMessage.Set(); }); var headers = new Dictionary<string, string> { { Headers.DeferredRecipient, DestinationQueueName } }; await _oneWayClient.Defer(TimeSpan.FromSeconds(1), "hej med dig min ven!!", headers); gotTheMessage.WaitOrDie(TimeSpan.FromSeconds(4)); }
public async Task SubcriberReceivesMessagesWhenItHasSubscribed() { var subscriberReceivedMessage = new ManualResetEvent(false); const string topicName = "someTopic"; await _subscriberBus.Advanced.Topics.Subscribe(topicName); _subscriberHandlers.Handle<string>(async str => { subscriberReceivedMessage.Set(); }); await Task.Delay(1000); await _publisherBus.Advanced.Topics.Publish(topicName, "hej med dig min ven!!!!!"); subscriberReceivedMessage.WaitOrDie(TimeSpan.FromSeconds(30), "Expected to have received a message"); }
public async Task PubSubSeemsToWork() { var gotString1 = new ManualResetEvent(false); var gotString2 = new ManualResetEvent(false); _bus1.Handle<string>(async str => gotString1.Set()); _bus2.Handle<string>(async str => gotString2.Set()); await _bus1.Bus.Subscribe<string>(); await _bus2.Bus.Subscribe<string>(); await Task.Delay(500); await _bus3.Bus.Publish("hello there!!!!"); gotString1.WaitOrDie(TimeSpan.FromSeconds(2)); gotString2.WaitOrDie(TimeSpan.FromSeconds(2)); }
public void CanDoItSyncWithoutBlocking() { var messageWasProperlyHandled = new ManualResetEvent(false); var bus = _activator.Bus.Advanced.SyncBus; _activator.Handle<string>(async str => messageWasProperlyHandled.Set()); var thread = new Thread(() => { bus.SendLocal("ey det virker"); }); thread.SetApartmentState(ApartmentState.STA); thread.Start(); Assert.That(thread.Join(TimeSpan.FromSeconds(1)), Is.True, "thread did not finish within timeout"); messageWasProperlyHandled.WaitOrDie(timeout: TimeSpan.FromSeconds(2)); }
public async Task WorksOutOfTheBoxWithInternalTimeoutManager() { var gotTheMessage = new ManualResetEvent(false); var activator = new BuiltinHandlerActivator(); activator.Handle<string>(async str => gotTheMessage.Set()); Configure.With(activator) .Transport(t => t.UseMsmq(_queueName)) .Start(); var stopwatch = Stopwatch.StartNew(); await activator.Bus.Defer(TimeSpan.FromSeconds(5), "hej med dig min ven!"); gotTheMessage.WaitOrDie(TimeSpan.FromSeconds(6), "Message was not received within 6,5 seconds (which it should have been since it was only deferred 5 seconds)"); Assert.That(stopwatch.Elapsed, Is.GreaterThan(TimeSpan.FromSeconds(5)), "It must take more than 5 second to get the message back"); }
public async Task AutomaticallyCreatesDestinationQueue() { var queueName = TestConfig.QueueName("does_not_exist_yet"); RabbitMqTransportFactory.DeleteQueue(queueName); // first we send a message to a queue that does not exist at this time Console.WriteLine($"Sending 'hej med dig min ven!' message to '{queueName}'"); await _bus.Advanced.Routing.Send(queueName, "hej med dig min ven!"); // then we start a server listening on the queue var gotTheMessage = new ManualResetEvent(false); StartServer(queueName).Handle<string>(async str => { gotTheMessage.Set(); }); Console.WriteLine("Waiting for message to arrive"); gotTheMessage.WaitOrDie(TimeSpan.FromSeconds(5)); Console.WriteLine("Got it :)"); }
public async Task SendAndReceiveOneSingleMessage() { var gotTheMessage = new ManualResetEvent(false); var receivedMessageCount = 0; _handlerActivator.Handle<string>(async message => { Interlocked.Increment(ref receivedMessageCount); Console.WriteLine("w00000t! Got message: {0}", message); gotTheMessage.Set(); }); await _bus.SendLocal("hej med dig min ven!"); gotTheMessage.WaitOrDie(TimeSpan.FromSeconds(10)); await Task.Delay(500); Assert.That(receivedMessageCount, Is.EqualTo(1)); }
public async Task ReceivesManuallyRoutedMessage() { var queueName = TestConfig.QueueName("manual_routing"); var gotTheMessage = new ManualResetEvent(false); StartServer(queueName).Handle<string>(async str => { gotTheMessage.Set(); }); Console.WriteLine($"Sending 'hej med dig min ven!' message to '{queueName}'"); await _bus.Advanced.Routing.Send(queueName, "hej med dig min ven!"); Console.WriteLine("Waiting for message to arrive"); gotTheMessage.WaitOrDie(TimeSpan.FromSeconds(5)); Console.WriteLine("Got it :)"); }
public async Task CopiesProperlyHandledMessageToAuditQueue() { var gotTheMessage = new ManualResetEvent(false); _adapter.Handle<string>(async _ => { gotTheMessage.Set(); }); await _bus.SendLocal("woohooo!!!!"); gotTheMessage.WaitOrDie(TimeSpan.FromSeconds(5)); var message = await _network.WaitForNextMessageFrom("audit"); PrintHeaders(message); Assert.That(message.Headers.ContainsKey(AuditHeaders.AuditTime)); Assert.That(message.Headers.ContainsKey(AuditHeaders.HandleTime)); Assert.That(message.Headers.ContainsKey(Headers.Intent)); Assert.That(message.Headers[Headers.Intent], Is.EqualTo(Headers.IntentOptions.PointToPoint)); }
public async Task CanDeferMessage() { var messageReceived = new ManualResetEvent(false); var deliveryTime = DateTime.MaxValue; _handlerActivator.Handle<string>(async s => { deliveryTime = DateTime.UtcNow; messageReceived.Set(); }); var sendTime = DateTime.UtcNow; var delay = TimeSpan.FromSeconds(5); await _bus.Defer(delay, "hej med dig!"); messageReceived.WaitOrDie(TimeSpan.FromSeconds(8)); var timeToBeDelivered = deliveryTime - sendTime; Assert.That(timeToBeDelivered, Is.GreaterThanOrEqualTo(delay)); }
public void CannotSendFailedMessageWrapper() { var couldNotSendMessage = new ManualResetEvent(false); Exception caughtException = null; _activator.Handle<string>(async str => { throw new ArithmeticException(); }); _activator.Handle<IFailed<string>>(async (bus, context, failed) => { // "failed" is an IFailed<string> in here - let's pretend that // we accidentally Defer that one instead of "failed.Message" // as we should try { await bus.Defer(TimeSpan.FromSeconds(1), failed); } catch(Exception exception) { // just what we wanted! :) caughtException = exception; couldNotSendMessage.Set(); } }); _activator.Bus.SendLocal("HOOLOOBOOLOO").Wait(); couldNotSendMessage.WaitOrDie(TimeSpan.FromSeconds(5)); Console.WriteLine($@"This is the exception that we caught: {caughtException} You're welcome."); }
public async Task SentMessageIsBasicallyUnreadable() { const string plainTextMessage = "hej med dig min ven!!!"; var gotTheMessage = new ManualResetEvent(false); _builtinHandlerActivator.Handle<string>(async str => { gotTheMessage.Set(); }); await _bus.Route("bimse", plainTextMessage); gotTheMessage.WaitOrDie(TimeSpan.FromSeconds(2)); var sentMessage = _tap.SentMessages.Single(); var receivedMessage = _tap.ReceivedMessages.Single(); var sentMessageBodyAsString = Encoding.UTF8.GetString(sentMessage.Body); var receivedMessageBodyAsString = Encoding.UTF8.GetString(receivedMessage.Body); Assert.That(sentMessageBodyAsString, Is.Not.StringContaining(plainTextMessage)); Assert.That(receivedMessageBodyAsString, Is.Not.StringContaining(plainTextMessage)); }
public void ItWorksWithString(bool withCompressionEnabled) { var gotIt = new ManualResetEvent(false); _activator.Handle<string>(async str => { if (string.Equals(str, LongText)) { gotIt.Set(); } else { throw new Exception( $"Received text with {str.Length} chars did not match expected text with {LongText.Length} chars!"); } }); var bus = CreateBus(withCompressionEnabled, _activator); bus.SendLocal(LongText).Wait(); gotIt.WaitOrDie(TimeSpan.FromSeconds(10)); }