| public static PublishAsync ( object message ) : Task, | ||
| message | object | |
| return | Task, | |
public void TestSingleBusMultipleTypesExtensions()
{
var bus = new Bus <BaseMessageType>();
var type1Received = new List <MessageType1>();
var type2Received = new List <MessageType2>();
var subscription1 = bus.Subscribe(b => b.OfType <BaseMessageType, MessageType1>().Handler(
msg =>
{
type1Received.Add(msg);
return(Task.CompletedTask);
}));
var subscription2 = bus.Subscribe(b => b.OfType <BaseMessageType, MessageType2>().Handler(
msg =>
{
type2Received.Add(msg);
return(Task.CompletedTask);
}));
bus.PublishAsync(new MessageType1("Haj"));
bus.PublishAsync(
new MessageType2()
{
Name = "Boj"
});
Assert.Single(type1Received);
Assert.Single(type2Received);
subscription2.Dispose();
subscription1.Dispose();
}
public async Task TestConcurrentMessageBusPatternMatching()
{
// If you would rather have a single message bus for your entire application, that can be done in this way
var bus = new Bus <MessageBase>();
var type1Received = new List <MessageType1>();
var type2Received = new List <MessageType2>();
bus.SubscribeSimple(
message =>
{
switch (message)
{
case MessageType1 msg:
type1Received.Add(msg);
break;
case MessageType2 msg:
type2Received.Add(msg);
break;
}
return(Task.CompletedTask);
});
await bus.PublishAsync(new MessageType1("John Yolo"));
Assert.True(type1Received.Count == 1);
Assert.True(type2Received.Count == 0);
await bus.PublishAsync(new MessageType2("John Yolo"));
Assert.True(type1Received.Count == 1);
Assert.True(type2Received.Count == 1);
}
public async Task WeakReferenceDecoratorTest()
{
// new int[] { 1 }.SelectMany()
var bus = new Bus <int>();
Assert.Equal(0, bus.SubscriberCount);
// Strong references
bus.Subscribe(b => b.Concurrent(5).Retry(2, TimeSpan.FromSeconds(10)).Handler(new WeakReferenceHandler()));
Assert.Equal(1, bus.SubscriberCount);
GC.Collect(2, GCCollectionMode.Forced);
await bus.PublishAsync();
Assert.Equal(1, bus.SubscriberCount);
// Now weak reference
bus.Subscribe(b => b.WeakReference(new WeakReferenceHandler()));
Assert.Equal(2, bus.SubscriberCount);
GC.Collect(2, GCCollectionMode.Forced);
await bus.PublishAsync();
Assert.Equal(1, bus.SubscriberCount);
}
public void Publish_Connection_Closed_By_Application_Never_Recovers()
{
var _busConfigurationBuilder = new BusConfigurationBuilder(Accessories.Configuration.ConnectionSettingsString);
_busConfigurationBuilder
.RegisterPublication <Accessories.MyEvent>(Accessories.Configuration.ExchangeName1, typeof(Accessories.MyEvent).Name, MessageDeliveryMode.Persistent, message => Accessories.Configuration.QueueName1);
var _SUT = new Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
Console.WriteLine("Verify connection exists. Press enter to close connection ...");
Console.ReadKey();
// Close the connection explicitly
_SUT.Close();
// Attempt to publish after closing the connection from the application, this should never happen in reality ...
var _message = new Accessories.MyEvent(Guid.NewGuid(), "", "R1", 1, "09:00", "DDD....");
var _result = _SUT.PublishAsync(_message);
Console.WriteLine("Should keep retrying to publish every second indefinitely");
Console.WriteLine("This is due to the fact that the application initiated the close");
Console.WriteLine("Normally, close is only called when application is closing down");
Console.Read();
}
public void Publish_1000_Messages_To_A_Queue_Using_Custom_Exchange()
{
var _busConfigurationBuilder = new BusConfigurationBuilder(Accessories.Configuration.ConnectionSettingsString);
_busConfigurationBuilder
.RegisterPublication <Accessories.MyEvent>(Accessories.Configuration.ExchangeName1, typeof(Accessories.MyEvent).Name, MessageDeliveryMode.Persistent, message => Accessories.Configuration.QueueName1);
var _SUT = new Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
var _tasks = new ConcurrentBag <Task <PMCG.Messaging.PublicationResult> >();
for (int count = 0; count < 1000; count++)
{
var _message = new Accessories.MyEvent(Guid.NewGuid(), "", "R1", 1, "09:00", "DDD....");
_tasks.Add(_SUT.PublishAsync(_message));
}
Task.WhenAll(_tasks).ContinueWith(a =>
{
var _taskStatusCount = _tasks.Count(result => result.Status == TaskStatus.RanToCompletion);
var _messagePublishedCount = _tasks.Count(result => result.Result.Status == Messaging.PublicationResultStatus.Published);
Console.WriteLine(string.Format("RanToCompletionTaskCount expected: (1000), actual: ({0})", _taskStatusCount));
Console.WriteLine(string.Format("MessagePublishedCount expected: (1000), actual: ({0})", _messagePublishedCount));
Console.WriteLine("Verify that 1000 messages on queue on management ui");
});
Console.Read();
}
public void Publish_A_Message_And_Consume_For_The_Same_Message_With_Nack_And_Dead_Letter_Queue()
{
var _capturedMessageId = string.Empty;
var _busConfigurationBuilder = new BusConfigurationBuilder(Accessories.Configuration.ConnectionSettingsString);
_busConfigurationBuilder.NumberOfConsumers = 2;
_busConfigurationBuilder
.RegisterPublication <Accessories.MyEvent>(Accessories.Configuration.ExchangeName2, typeof(Accessories.MyEvent).Name, MessageDeliveryMode.Persistent, message => "test.queue.2")
.RegisterConsumer <Accessories.MyEvent>(
Accessories.Configuration.QueueName2,
typeof(Accessories.MyEvent).Name,
message => { _capturedMessageId = message.Id.ToString(); return(ConsumerHandlerResult.Errored); });
var _SUT = new Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
var _messageId = Guid.NewGuid();
var _message = new Accessories.MyEvent(_messageId, null, "R1", 1, "09:00", "DDD....");
_SUT.PublishAsync(_message);
Thread.Sleep(2000);
Console.WriteLine(string.Format("Captured message id expected: ({0}), actual: ({1})", _messageId, _capturedMessageId));
Console.WriteLine(string.Format("Ensure message with id: ({0}) no longer exists in the queue", _messageId));
Console.WriteLine(string.Format("Ensure message with id: ({0}) exists in the dead letter queue - rejected", _messageId));
Console.Read();
}
public void Publish_NullMessageReturnedFromGetMessageButNoSubscribers_DoesNotThrow()
{
var container = ContainerFactory.Bootstrap <EmptyServicesBootstrapper>();
var bus = new Bus(container);
Assert.DoesNotThrow(() => bus.PublishAsync(() => (string)null));
}
public void Publish_10000_Messages_And_Consume_For_The_Same_Messages_With_Ack_Connection_Closed_By_Server_Recovers_Automatically()
{
var _busConfigurationBuilder = new BusConfigurationBuilder(Accessories.Configuration.ConnectionSettingsString);
_busConfigurationBuilder.NumberOfConsumers = 2;
_busConfigurationBuilder
.RegisterPublication <Accessories.MyEvent>(Accessories.Configuration.ExchangeName2, typeof(Accessories.MyEvent).Name, MessageDeliveryMode.Persistent, message => "test.queue.2")
.RegisterConsumer <Accessories.MyEvent>(
Accessories.Configuration.QueueName2,
typeof(Accessories.MyEvent).Name,
message => { return(ConsumerHandlerResult.Completed); });
var _SUT = new Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
Console.WriteLine("Close connection via rabbitmq management ui while loop is executing");
for (int count = 0; count < 10000; count++)
{
var _messageId = Guid.NewGuid();
var _message = new Accessories.MyEvent(_messageId, null, "R1", 1, "09:00", "DDD....");
_SUT.PublishAsync(_message);
}
Console.WriteLine("Ensure there are no messages in the queue");
Console.WriteLine("Ensure there are some messages in the dead letter queue(reason expired)");
Console.ReadKey();
}
public void Publish_1000_Messages_And_Consume_For_The_Same_Messsage_On_A_Transient_Queue()
{
var _busConfigurationBuilder = new BusConfigurationBuilder(Accessories.Configuration.ConnectionSettingsString);
_busConfigurationBuilder
.RegisterPublication <Accessories.MyEvent>(Accessories.Configuration.ExchangeName1, typeof(Accessories.MyEvent).Name)
.RegisterConsumer <Accessories.MyEvent>(
typeof(Accessories.MyEvent).Name,
message => { return(ConsumerHandlerResult.Completed); },
Accessories.Configuration.ExchangeName1);
var _SUT = new Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
Console.WriteLine("Wait for transient queue to appear on management ui");
Console.ReadKey();
var _message = new Accessories.MyEvent(Guid.NewGuid(), "Correlation Id", "R1", 1, "09:00", "....");
for (int count = 0; count < 1000; count++)
{
_SUT.PublishAsync(_message);
}
Console.WriteLine("Ensure there are no messages in the queue");
Console.WriteLine("Ensure transient queue appears and disappears");
Console.ReadKey();
}
public void Publish_1000_Messages_And_Consume_For_The_Same_Messages_With_Half_Acked_Half_Nacked()
{
var _busConfigurationBuilder = new BusConfigurationBuilder(Accessories.Configuration.ConnectionSettingsString);
_busConfigurationBuilder.NumberOfConsumers = 2;
_busConfigurationBuilder
.RegisterPublication <Accessories.MyEvent>(Accessories.Configuration.ExchangeName2, typeof(Accessories.MyEvent).Name, MessageDeliveryMode.Persistent, message => "test.queue.2")
.RegisterConsumer <Accessories.MyEvent>(
Accessories.Configuration.QueueName2,
typeof(Accessories.MyEvent).Name,
message => { return(bool.Parse(message.RunIdentifier) ? ConsumerHandlerResult.Completed : ConsumerHandlerResult.Errored); });
var _SUT = new Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
for (int count = 0; count < 1000; count++)
{
var _messageId = Guid.NewGuid();
var _runIdentifier = (count % 2 == 0);
var _message = new Accessories.MyEvent(_messageId, null, _runIdentifier.ToString(), 1, "09:00", "DDD....");
_SUT.PublishAsync(_message);
}
Console.WriteLine("Ensure there are no messages in the queue");
Console.WriteLine("Ensure 500 messages exists in the dead letter queue - rejected");
Console.Read();
}
public void Consume_Continues_When_Node_We_Are_Not_Connected_To_Is_Blocked()
{
var _publisherBusConfigurationBuilder = new BusConfigurationBuilder(Accessories.Configuration.ConnectionSettingsString.Replace("myTestConnection", "publisher"));
_publisherBusConfigurationBuilder
.RegisterPublication <Accessories.MyEvent>(Accessories.Configuration.ExchangeName1, typeof(Accessories.MyEvent).Name, MessageDeliveryMode.Persistent, message => "test.queue.1");
var _publisherBus = new Bus(_publisherBusConfigurationBuilder.Build());
_publisherBus.Connect();
// Let node that we are connected to = NodeA
// Let other node = NodeB
// Before blocking rabbitmq service on NodeB, verify cluster is in working order
// We publish 50,000 messages and verify that these are on the queue
// We continuously consume the 50,000 messages
// During consumption, block NodeB for a period of time, then unblock
// rabbitmqctl set_vm_memory_high_watermark 0.0000001
// rabbitmqctl set_vm_memory_high_watermark 0.4
// Verify 0 messages exist on queue
// Verify consumed message count is at least 50,000
for (int count = 0; count < 50000; count++)
{
var _messageId = Guid.NewGuid();
var _message = new Accessories.MyEvent(_messageId, null, "R1", 1, "09:00", "DDD....");
_publisherBus.PublishAsync(_message);
}
Console.WriteLine("Verify exactly 50000 messages in the queue");
// Note that we see that a number of messages seem to get delivered more than once. This however is expected behaviour as we are using acknowledgements
// See link: https://groups.google.com/forum/#!topic/rabbitmq-users/PODU8wIYmQs
Console.ReadKey();
var _consumedMessageCount = 0;
var _consumerBusConfigurationBuilder = new BusConfigurationBuilder(Accessories.Configuration.ConnectionSettingsString.Replace("myTestConnection", "consumer"));
_consumerBusConfigurationBuilder.NumberOfConsumers = 5;
_consumerBusConfigurationBuilder
.RegisterConsumer <Accessories.MyEvent>(
Accessories.Configuration.QueueName1,
typeof(Accessories.MyEvent).Name,
message => {
Interlocked.Increment(ref _consumedMessageCount);
return(ConsumerHandlerResult.Completed);
});
var _consumerBus = new Bus(_consumerBusConfigurationBuilder.Build());
_consumerBus.Connect();
for (int _counter = 0; _counter < 60; _counter++)
{
Thread.Sleep(1000);
Console.WriteLine(string.Format("{0} seconds completed", _counter));
}
Console.WriteLine("Ensure there are no messages in the queue");
Console.WriteLine(string.Format("Consumed message count expected(at least): (50000), actual: ({0})", _consumedMessageCount));
Console.ReadKey();
}
public void Publish_NullGetMessage_ThrowsArgumentNullException()
{
var container = ContainerFactory.Bootstrap <EmptyServicesBootstrapper>();
var bus = new Bus(container);
Assert.Throws <ArgumentNullException>(() => bus.PublishAsync((Func <string>)null));
}
public void Publish_ActualMessageButNoSubscribers_DoesntThrownException()
{
var container = ContainerFactory.Bootstrap <EmptyServicesBootstrapper>();
var bus = new Bus(container);
Assert.DoesNotThrow(() => bus.PublishAsync("test"));
}
public async Task HandleAsync(FakeCommand message)
{
Logger.LogInformation("Handle FakeCommand {ObjectId}", message.ObjectId);
var tasksToRun = new List <Task>();
await LockProvider.TryUsingAsync(message.ObjectId, async token =>
{
var ex = await Repository.CheckAggregateExists <FakeAggregate>(message.ObjectId);
FakeAggregate agg;
if (!ex)
{
agg = FakeAggregate.Factory.Create(message.ObjectId);
}
else
{
agg = await Repository.GetByIdAsync <FakeAggregate>(message.ObjectId);
}
agg.DoFakeEvent(message.Text);
var evnts = await Repository.SaveAsyncWithOutPush(agg, CancellationToken);
foreach (var evnt in evnts)
{
tasksToRun.Add(Bus.PublishAsync(evnt));
}
//await Repository.SaveAsync(agg, CancellationToken);
},
cancellationToken : CancellationToken);
await Task.WhenAll(tasksToRun);
}
public async Task UseCustomPublisherTests()
{
var mypublisher = new MyPublisher();
var bus = new Bus <int>(options => options.UseCustomPublisher(mypublisher));
await bus.PublishAsync(55);
await bus.PublishAsync(1);
await bus.PublishAsync(5);
Assert.Equal(3, mypublisher.Messages.Count);
Assert.Equal(55, mypublisher.Messages[0]);
Assert.Equal(1, mypublisher.Messages[1]);
Assert.Equal(5, mypublisher.Messages[2]);
}
private async Task PublishInternalAsync(T message, MessageProperties properties)
{
var serializer = Serializer.Get(properties.ContentType);
var serializedMessage = serializer.Serialize(message);
var exchange = new Exchange(ExchangeConfiguration.Name);
await Bus.PublishAsync(exchange, QueueConfiguration.RoutingKey, true, properties, serializedMessage);
}
public void Consume_Continues_When_Node_We_Are_Connected_To_Is_Rebooted()
{
var _publisherBusConfigurationBuilder = new BusConfigurationBuilder(Accessories.Configuration.ConnectionSettingsString.Replace("myTestConnection", "publisher"));
_publisherBusConfigurationBuilder
.RegisterPublication <Accessories.MyEvent>(Accessories.Configuration.ExchangeName1, typeof(Accessories.MyEvent).Name, MessageDeliveryMode.Persistent, message => "test.queue.1");
var _publisherBus = new Bus(_publisherBusConfigurationBuilder.Build());
_publisherBus.Connect();
// Let node that we are connected to = NodeA
// Let other node = NodeB
// Before rebooting NodeA, verify cluster is in working order
// We publish 50,000 messages and verify that these are on the queue
// We continuously consume the 50,000 messages
// During consumption, reboot NodeA
// Verify 0 messages exist on queue
// Verify consumed message count is nearly 50,000
for (int count = 0; count < 50000; count++)
{
var _messageId = Guid.NewGuid();
var _message = new Accessories.MyEvent(_messageId, null, "R1", 1, "09:00", "DDD....");
_publisherBus.PublishAsync(_message);
}
Console.WriteLine("Verify at least 50000 messages in the queue");
Console.ReadKey();
var _consumedMessageCount = 0;
var _consumerBusConfigurationBuilder = new BusConfigurationBuilder(Accessories.Configuration.ConnectionSettingsString.Replace("myTestConnection", "consumer"));
_consumerBusConfigurationBuilder.NumberOfConsumers = 5;
_consumerBusConfigurationBuilder
.RegisterConsumer <Accessories.MyEvent>(
Accessories.Configuration.QueueName1,
typeof(Accessories.MyEvent).Name,
message => {
Interlocked.Increment(ref _consumedMessageCount);
return(ConsumerHandlerResult.Completed);
});
var _consumerBus = new Bus(_consumerBusConfigurationBuilder.Build());
_consumerBus.Connect();
for (int _counter = 0; _counter < 60; _counter++)
{
Thread.Sleep(1000);
Console.WriteLine(string.Format("{0} seconds completed", _counter));
}
Console.WriteLine("Ensure there are no messages in the queue");
Console.WriteLine(string.Format("Consumed message count expected(nearly): (50000), actual: ({0})", _consumedMessageCount));
Console.ReadKey();
}
internal void PingRequestHandler([NotNull] PingRequestMessage message)
{
var reply = new PingResponseMessage
{
ServiceName = m_Name,
Request = message.Request
};
Bus.PublishAsync(reply);
}
public async Task Publish_GetMessageWhenNoSubscribers_IsNotCalled()
{
var container = ContainerFactory.Bootstrap <EmptyServicesBootstrapper>();
var bus = new Bus(container);
var getMessage = Substitute.For <Func <string> >();
await bus.PublishAsync(getMessage);
getMessage.DidNotReceive().Invoke();
}
public void Publish_NullMessageReturnedFromGetMessage_ThrowsInvalidOperationException()
{
var container = ContainerFactory.Bootstrap <EmptyServicesBootstrapper>();
var bus = new Bus(container);
var subscriber = Substitute.For <ISubscriber <string> >();
bus.Subscribe(subscriber);
Assert.Throws <InvalidOperationException>(() => bus.PublishAsync(() => (string)null));
}
public void When_publishing_an_event_should_invoke_all_registered_event_handlers()
{
var serviceContainer = new ServiceContainer();
serviceContainer.RegisterAssembly(typeof (BusTests).Assembly, (serviceType, implementingType) => serviceType.IsGenericType && serviceType.GetGenericTypeDefinition() == typeof (IHandleMessages<>));
var bus = new Bus(serviceContainer.GetAllInstances);
var message = new Event();
bus.PublishAsync(message);
message.NumberOfTimesHandled.ShouldEqual(2);
}
public void PublishAsync_Null_Message_Results_In_An_Exception()
{
var _busConfigurationBuilder = new BusConfigurationBuilder();
_busConfigurationBuilder.ConnectionUris.Add(TestingConfiguration.LocalConnectionUri);
var _busConfirguration = _busConfigurationBuilder.Build();
var _SUT = new Bus(_busConfirguration);
_SUT.Connect();
_SUT.PublishAsync<MyEvent>(null);
}
public async Task Publish_OneSubscriber_CallsThatSubscriber()
{
var container = ContainerFactory.Bootstrap <EmptyServicesBootstrapper>();
var bus = new Bus(container);
string message = null;
bus.Subscribe <string>(m => message = m);
await bus.PublishAsync("Test");
Assert.That(message, Is.EqualTo("Test"));
}
public async Task Publish_OneSubscriberThatHasBeenUnsubscribed_DoesNotCallThatSubscriber()
{
var container = ContainerFactory.Bootstrap <EmptyServicesBootstrapper>();
var bus = new Bus(container);
string message = null;
bus.Subscribe <string>(m => message = m).Dispose();
await bus.PublishAsync("Test");
Assert.That(message, Is.Null);
}
private void OnConsoleOnCancelKeyPress(object s, ConsoleCancelEventArgs e)
{
Logger.Log(LogLevel.Debug, "User cancelled application with Ctrl+C");
WasCancelledByUser = true;
if (e != null)
{
e.Cancel = true;
}
_CtrlCCancellationTokenSource.Cancel();
_ApplicationLifetimeManager.SignalGracefulTermination();
Bus.PublishAsync(new UserCancellationKeypressMessage());
}
public override async Task Send <T>(T o, int timeout = 0)
{
if (timeout.Equals(0))
{
await Bus.PublishAsync(o);
}
else
{
await Bus.PublishAsync(o, i =>
{
i.WithExpires(timeout);
});
}
}
public void Bus_PublishAsync_EventHub_Nominal()
{
var id = Guid.NewGuid();
bool testOk = false;
var message = new TestMessage()
{
SomeData = id.ToString()
};
var serializer = new JSONSerializer();
var publisher = new AzureEventHubPublishTransport(serializer);
IBus bus = new Bus(serializer, new AzureStorageQueueSendTransport(serializer), publisher);
bus.Context = new AFBusMessageContext();
bus.PublishAsync(message, TOPICNAME).Wait();
var eventProcessorHost = new EventProcessorHost(TOPICNAME, PartitionReceiver.DefaultConsumerGroupName, SettingsUtil.GetSettings <string>(SETTINGS.AZURE_EVENTHUB), SettingsUtil.GetSettings <string>(SETTINGS.AZURE_STORAGE), "eventhubcontainer");
// Registers the Event Processor Host and starts receiving messages
var readingTask = eventProcessorHost.RegisterEventProcessorFactoryAsync(new AzureStreamProcessorFactory(stringMessage =>
{
var finalMessageEnvelope = JsonConvert.DeserializeObject <AFBusMessageEnvelope>(stringMessage, new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.Objects,
TypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Simple
});
var finalMessage = JsonConvert.DeserializeObject <TestMessage>(finalMessageEnvelope.Body, new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.Objects,
TypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Simple
});
testOk = testOk || (id.ToString() == finalMessage.SomeData);
}));
Task.Delay(5000).Wait();
// Disposes of the Event Processor Host
eventProcessorHost.UnregisterEventProcessorAsync().Wait();
Assert.IsTrue(testOk);
}
public void When_publishing_an_event_should_polymorphic_dispatch_to_all_handlers()
{
var serviceContainer = new ServiceContainer();
serviceContainer.Register<IHandleMessages<Event>, EventHandler>();
serviceContainer.Register<IHandleMessages<Event>, AnotherEventHandler>("Another");
var messageHandler = new MessageHandler();
serviceContainer.RegisterInstance<IHandleMessages<IMessage>>(messageHandler);
var bus = new Bus(serviceContainer.GetAllInstances);
var message = new Event();
bus.PublishAsync(message);
message.NumberOfTimesHandled.ShouldEqual(2);
messageHandler.IsHandled.ShouldBeTrue();
}
public async Task Publish_GetMessageWhenSubscribers_IsCalled()
{
var container = ContainerFactory.Bootstrap <EmptyServicesBootstrapper>();
var bus = new Bus(container);
var getMessage = Substitute.For <Func <string> >();
var subscriber = Substitute.For <ISubscriber <string> >();
getMessage.Invoke().Returns("Message");
bus.Subscribe(subscriber);
await bus.PublishAsync(getMessage);
getMessage.Received().Invoke();
subscriber.Received().Notify("Message");
}
public async Task Publish_SubscriberThatHasBeenCollected_DoesNotCallThatSubscriber()
{
var container = ContainerFactory.Bootstrap <EmptyServicesBootstrapper>();
var bus = new Bus(container);
Subscriber.LastMessage = null;
Subscribe(bus);
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
await bus.PublishAsync("Test");
Assert.That(Subscriber.LastMessage, Is.Null);
}
public static async Task MainExampleAsync()
{
ColorConsole.WriteLine();
ColorConsole.WriteLine(ConsoleColor.White, "** MainExample **");
// Create a message bus
var bus = new Bus <ExampleMessage>();
// "Use<ExampleMessage>.Bus" is a shortcut to a singleton bus instance for ExampleMessage
// var bus = Use<ExampleMessage>.Bus;
// Add a synchronous subscriber
var subscription = bus
.SubscribeSimple(message => Console.WriteLine(message.Id));
// Add an asynchronous subscriber
var asynchronousSubscription = bus
.SubscribeSimple(async message =>
{
await SomeMethodAsync();
Console.WriteLine(message.Id);
});
// Publish a message to the bus awaiting the message to pass through
await bus.PublishAsync(
new ExampleMessage
{
Id = "Message 1"
});
// Publish a message but do not wait for any asynchronous operations
bus.Publish(
new ExampleMessage
{
Id = "Message 2"
});
// Unsubscribe - the subscription implements IDisposable. Calling Dispose() unsubscribes
subscription.Dispose();
asynchronousSubscription.Dispose();
await Task.Delay(TimeSpan.FromMilliseconds(200));
ColorConsole.WriteLine();
ColorConsole.WriteLine(ConsoleColor.White, "** End of MainExample **");
}
public async Task Publish_SubscriberThatHasNotBeenCollectedThroughSubscription_CallsThatSubscriber()
{
var container = ContainerFactory.Bootstrap <EmptyServicesBootstrapper>();
var bus = new Bus(container);
Subscriber.LastMessage = null;
var subscription = SubscribeAndReturnSubscription(bus);
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
await bus.PublishAsync("Test");
Assert.That(Subscriber.LastMessage, Is.EqualTo("Test"));
GC.KeepAlive(subscription);
}
public void Publish_Continues_When_Node_We_Are_Connected_To_Is_Blocked()
{
var _busConfigurationBuilder = new BusConfigurationBuilder(Accessories.Configuration.ConnectionSettingsString);
_busConfigurationBuilder
.RegisterPublication <Accessories.MyEvent>(Accessories.Configuration.ExchangeName1, typeof(Accessories.MyEvent).Name, MessageDeliveryMode.Persistent, message => Accessories.Configuration.QueueName1);
var _SUT = new Bus(_busConfigurationBuilder.Build());
_SUT.Connect();
// Let node that we are connected to = NodeA
// Let other node = NodeB
// Before blocking NodeA, verify cluster is in working order
// We publish continuously for 10,000 messages
// During publication, block NodeA for a period of time, then unblock
// rabbitmqctl set_vm_memory_high_watermark 0.0000001
// rabbitmqctl set_vm_memory_high_watermark 0.4
// Verify 10,000 messages exist on queue
// Verify cluster is in working order
// NOTE: When we run high volume very fast we see messages go missing, we do not think this is worth chasing up on
// We also know that for some edge cases, channel.BasicPublish can execute where the messages simply go missing, this is simply another one of these use cases
var _tasks = new ConcurrentBag <Task <PMCG.Messaging.PublicationResult> >();
for (int count = 0; count < 10000; count++)
{
var _message = new Accessories.MyEvent(Guid.NewGuid(), "", "R1", 1, "09:00", "DDD....");
_tasks.Add(_SUT.PublishAsync(_message));
Console.WriteLine(count);
Thread.Sleep(1);
}
Task.WhenAll(_tasks).ContinueWith(a =>
{
var _taskStatusCount = _tasks.Count(result => result.Status == TaskStatus.RanToCompletion);
var _messagePublishedCount = _tasks.Count(result => result.Result.Status == Messaging.PublicationResultStatus.Published);
Console.WriteLine(string.Format("RanToCompletionTaskCount expected(nearly): (10000), actual: ({0})", _taskStatusCount));
Console.WriteLine(string.Format("MessagePublishedCount expected(nearly): (10000), actual: ({0})", _messagePublishedCount));
});
Console.Read();
}
public void When_sending_the_same_event_multiple_times_should_get_handlers_from_cahce()
{
var serviceContainer = new ServiceContainer();
serviceContainer.RegisterAssembly(typeof (BusTests).Assembly, (serviceType, implementingType) => serviceType.IsGenericType && serviceType.GetGenericTypeDefinition() == typeof (IHandleMessages<>));
IBus bus = new Bus(serviceContainer.GetAllInstances);
var message = new Event();
Assert.DoesNotThrow(() =>
{
bus.PublishAsync(message);
bus.PublishAsync(message);
bus.PublishAsync(message);
});
}
public void When_event_handler_throws_exception_should_propagate_exception()
{
var serviceContainer = new ServiceContainer();
serviceContainer.Register<IHandleMessages<EventWithException>, EventWithExceptionHandler>();
var bus = new Bus(serviceContainer.GetAllInstances);
Assert.Throws<InvalidOperationException>(() => bus.PublishAsync(new EventWithException()).Wait());
}