public async Task Events_with_invalid_type_format_are_ignored_and_nacked([Frozen] IRabbitMqConfiguration configuration, RabbitMqBusEngine sut, string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, string messageId, Guid correlationId, FirstTestEvent @event)
{
sut.SubscribeToEvent <FirstTestEvent>();
var sequence = await sut.StartAsync();
var encoding = Encoding.UTF8;
IBasicProperties properties = new BasicProperties
{
MessageId = messageId,
ContentEncoding = encoding.WebName,
Headers = new Dictionary <string, object>
{
["Nybus:MessageId"] = encoding.GetBytes(messageId),
["Nybus:MessageType"] = encoding.GetBytes(@event.GetType().FullName),
["Nybus:CorrelationId"] = correlationId.ToByteArray()
}
};
var body = configuration.Serializer.SerializeObject(@event, encoding);
var incomingMessages = sequence.DumpInList();
sut.Consumers.First().Value.HandleBasicDeliver(consumerTag, deliveryTag, redelivered, exchange, routingKey, properties, body);
Assert.That(incomingMessages, Is.Empty);
Mock.Get(configuration.ConnectionFactory.CreateConnection().CreateModel()).Verify(p => p.BasicNack(deliveryTag, It.IsAny <bool>(), It.IsAny <bool>()));
}
public async Task NotifyFail_can_handle_closed_connections([Frozen] IRabbitMqConfiguration configuration, RabbitMqBusEngine sut, string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, string messageId, Guid correlationId, FirstTestCommand command, ShutdownEventArgs shutdownEventArgs)
{
sut.SubscribeToCommand <FirstTestCommand>();
var sequence = await sut.StartAsync().ConfigureAwait(false);
var encoding = Encoding.UTF8;
IBasicProperties properties = new BasicProperties
{
MessageId = messageId,
ContentEncoding = encoding.WebName,
Headers = new Dictionary <string, object>
{
["Nybus:MessageId"] = encoding.GetBytes(messageId),
["Nybus:MessageType"] = encoding.GetBytes(DescriptorName(command.GetType())),
["Nybus:CorrelationId"] = correlationId.ToByteArray()
}
};
var body = configuration.Serializer.SerializeObject(command, encoding);
var incomingMessages = sequence.DumpInList();
sut.Consumers.First().Value.HandleBasicDeliver(consumerTag, deliveryTag, redelivered, exchange, routingKey, properties, body);
Mock.Get(configuration.ConnectionFactory.CreateConnection().CreateModel()).Setup(p => p.BasicNack(It.IsAny <ulong>(), It.IsAny <bool>(), It.IsAny <bool>())).Throws(new AlreadyClosedException(shutdownEventArgs));
await sut.NotifyFailAsync(incomingMessages.First());
Mock.Get(configuration.ConnectionFactory.CreateConnection().CreateModel()).Verify(p => p.BasicNack(deliveryTag, It.IsAny <bool>(), It.IsAny <bool>()));
}
public async Task NotifySuccess_acks_event_messages([Frozen] IRabbitMqConfiguration configuration, RabbitMqBusEngine sut, string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, string messageId, Guid correlationId, FirstTestEvent @event)
{
sut.SubscribeToEvent <FirstTestEvent>();
var sequence = await sut.StartAsync().ConfigureAwait(false);
var encoding = Encoding.UTF8;
IBasicProperties properties = new BasicProperties
{
MessageId = messageId,
ContentEncoding = encoding.WebName,
Headers = new Dictionary <string, object>
{
["Nybus:MessageId"] = encoding.GetBytes(messageId),
["Nybus:MessageType"] = encoding.GetBytes(DescriptorName(@event.GetType())),
["Nybus:CorrelationId"] = correlationId.ToByteArray()
}
};
var body = configuration.Serializer.SerializeObject(@event, encoding);
var incomingMessages = sequence.DumpInList();
sut.Consumers.First().Value.HandleBasicDeliver(consumerTag, deliveryTag, redelivered, exchange, routingKey, properties, body);
await sut.NotifySuccessAsync(incomingMessages.First());
Mock.Get(configuration.ConnectionFactory.CreateConnection().CreateModel()).Verify(p => p.BasicAck(deliveryTag, It.IsAny <bool>()));
}
private static ConnectionFactory BuildConnectionFactory(IRabbitMqConfiguration configuration)
{
var factory = new ConnectionFactory();
if (configuration.Uri != null)
{
factory.Uri = configuration.Uri;
}
else
{
factory.HostName = configuration.Hostname;
factory.Port = configuration.Port ?? 5672;
}
if (configuration.ContinuationTimeout.HasValue)
{
factory.ContinuationTimeout = configuration.ContinuationTimeout.Value;
}
if (configuration.RequestedHeartbeat.HasValue)
{
factory.RequestedHeartbeat = configuration.RequestedHeartbeat.Value;
}
return(factory);
}
public RabbitMqConnectionFactory(
ILog log,
IRabbitMqConfiguration configuration)
{
_log = log;
_configuration = configuration;
}
public RabbitMqManager(IRabbitMqConfiguration configuration, IConnectionInfoProvider provider, RabbitConnector connector)
{
this._connectionInfoProvider = provider;
this._configuration = configuration;
this._rabbitConnector = connector;
}
public RabbitMqConnectionFactory(
ILog log,
IRabbitMqConfiguration configuration)
{
_log = log;
_configuration = configuration;
}
public ClientCommandDispatcherFactory(
IRabbitMqConfiguration configuration,
IPersistentChannelFactory persistentChannelFactory)
{
this.configuration = configuration;
this.persistentChannelFactory = persistentChannelFactory;
}
public async Task Invalid_commands_are_discarded([Frozen] IRabbitMqConfiguration configuration, RabbitMqBusEngine sut, string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, string messageId, Guid correlationId, FirstTestCommand command)
{
// At least one subscription is needed to inject invalid messages
sut.SubscribeToCommand <SecondTestCommand>();
var sequence = await sut.StartAsync();
var encoding = Encoding.UTF8;
IBasicProperties properties = new BasicProperties
{
MessageId = messageId,
ContentEncoding = encoding.WebName,
Headers = new Dictionary <string, object>
{
["Nybus:MessageId"] = encoding.GetBytes(messageId),
["Nybus:MessageType"] = encoding.GetBytes(DescriptorName(command.GetType())),
["Nybus:CorrelationId"] = correlationId.ToByteArray()
}
};
var body = configuration.Serializer.SerializeObject(command, encoding);
var incomingMessages = sequence.DumpInList();
sut.Consumers.First().Value.HandleBasicDeliver(consumerTag, deliveryTag, redelivered, exchange, routingKey, properties, body);
Assert.That(incomingMessages, Is.Empty);
Mock.Get(configuration.ConnectionFactory.CreateConnection().CreateModel()).Verify(p => p.BasicNack(deliveryTag, It.IsAny <bool>(), It.IsAny <bool>()));
}
public async Task Queue_is_bound_to_exchange_when_a_command_is_registered([Frozen] IRabbitMqConfiguration configuration, RabbitMqBusEngine sut)
{
sut.SubscribeToCommand <FirstTestCommand>();
var sequence = await sut.StartAsync();
Mock.Get(configuration.ConnectionFactory.CreateConnection().CreateModel()).Verify(p => p.QueueBind(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <IDictionary <string, object> >()));
}
public async Task Exchange_is_declared_when_a_command_is_registered([Frozen] IRabbitMqConfiguration configuration, RabbitMqBusEngine sut)
{
sut.SubscribeToCommand <FirstTestCommand>();
var sequence = await sut.StartAsync();
Mock.Get(configuration.CommandExchangeManager).Verify(p => p.EnsureExchangeExists(It.IsAny <IModel>(), It.IsAny <string>(), It.IsAny <string>()));
}
public async Task QueueFactory_is_invoked_when_a_command_is_registered([Frozen] IRabbitMqConfiguration configuration, RabbitMqBusEngine sut)
{
sut.SubscribeToCommand <FirstTestCommand>();
var sequence = await sut.StartAsync();
Mock.Get(configuration.CommandQueueFactory).Verify(p => p.CreateQueue(It.IsAny <IModel>()));
}
public async Task Events_can_be_sent([Frozen] IRabbitMqConfiguration configuration, RabbitMqBusEngine sut, EventMessage <FirstTestEvent> message)
{
await sut.StartAsync().ConfigureAwait(false);
await sut.SendMessageAsync(message);
Mock.Get(configuration.ConnectionFactory.CreateConnection().CreateModel()).Verify(p => p.BasicPublish(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <IBasicProperties>(), It.IsAny <byte[]>()));
}
public ClientCommandDispatcherSingleton(
IRabbitMqConfiguration configuration,
IPersistentConnection connection,
IPersistentChannelFactory persistentChannelFactory)
{
persistentChannel = persistentChannelFactory.CreatePersistentChannel(connection);
StartDispatcherThread(configuration);
}
public RabbitConsumePersistenceService(IDispatchToEventSubscribers dispatchToEventSubscribers, EnvironmentConfiguration environmentConfiguration, IEventJsonSerializer eventJsonSerializer, IRabbitMqConfiguration rabbitMqConfiguration, IRabbitMqConnectionFactory rabbitMqConnectionFactory)
{
_dispatchToEventSubscribers = dispatchToEventSubscribers;
_environmentConfiguration = environmentConfiguration;
_eventJsonSerializer = eventJsonSerializer;
_rabbitMqConfiguration = rabbitMqConfiguration;
_rabbitMqConnectionFactory = rabbitMqConnectionFactory;
}
public RevenueForecastService(IDatabaseAccessService databaseAccessService,
IModelMessagingService modelMessagingService, IMapper mapper, IForecastCachingService cachingService, IRabbitMqConfiguration rabbitMqConfiguration)
{
_databaseAccessService = databaseAccessService;
_modelMessagingService = modelMessagingService;
_mapper = mapper;
_cachingService = cachingService;
_rabbitMqConfiguration = rabbitMqConfiguration;
}
public RabbitMqMessageFactory(
ILog log,
IEventJsonSerializer eventJsonSerializer,
IRabbitMqConfiguration rabbitMqConfiguration)
{
_log = log;
_eventJsonSerializer = eventJsonSerializer;
_rabbitMqConfiguration = rabbitMqConfiguration;
}
public async Task Engine_can_be_stopped([Frozen] IRabbitMqConfiguration configuration, RabbitMqBusEngine sut)
{
await sut.StartAsync();
await sut.StopAsync();
Mock.Get(configuration.ConnectionFactory.CreateConnection()).Verify(p => p.Dispose());
Mock.Get(configuration.ConnectionFactory.CreateConnection().CreateModel()).Verify(p => p.Dispose());
}
public async Task No_QoS_is_sent_if_no_value_is_set([Frozen] IRabbitMqConfiguration configuration, RabbitMqBusEngine sut)
{
Mock.Get(configuration).SetupGet(p => p.UnackedMessageCountLimit).Returns(null as ushort?);
await sut.StartAsync();
await sut.StopAsync();
Mock.Get(configuration.ConnectionFactory.CreateConnection().CreateModel()).Verify(p => p.BasicQos(It.IsAny <uint>(), It.IsAny <ushort>(), It.IsAny <bool>()), Times.Never);
}
public async Task Global_QoS_is_sent_if_value_is_set([Frozen] IRabbitMqConfiguration configuration, RabbitMqBusEngine sut, ushort limit)
{
Mock.Get(configuration).SetupGet(p => p.UnackedMessageCountLimit).Returns(limit);
await sut.StartAsync();
await sut.StopAsync();
Mock.Get(configuration.ConnectionFactory.CreateConnection().CreateModel()).Verify(p => p.BasicQos(0, limit, true));
}
public async Task Arbitrary_headers_are_forwarded_when_sending_events([Frozen] IRabbitMqConfiguration configuration, RabbitMqBusEngine sut, EventMessage <FirstTestEvent> message, string headerKey, string headerValue)
{
message.Headers.Add(headerKey, headerValue);
await sut.StartAsync().ConfigureAwait(false);
await sut.SendMessageAsync(message);
Mock.Get(configuration.ConnectionFactory.CreateConnection().CreateModel()).Verify(p => p.BasicPublish(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>(), It.Is <IBasicProperties>(o => o.Headers.ContainsKey($"Custom:{headerKey}")), It.IsAny <byte[]>()));
}
public async Task Events_can_be_sent([Frozen] IRabbitMqConfiguration configuration, RabbitMqBusEngine sut, EventMessage <FirstTestEvent> message, string headerKey, string headerValue)
{
message.Headers[headerKey] = headerValue;
await sut.StartAsync();
await sut.SendMessageAsync(message);
Mock.Get(configuration.ConnectionFactory.CreateConnection().CreateModel()).Verify(p => p.BasicPublish(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>(), It.Is <IBasicProperties>(bp => bp.Headers.ContainsKey($"Custom:{headerKey}") && (string)bp.Headers[$"Custom:{headerKey}"] == headerValue), It.IsAny <byte[]>()));
}
public RabbitMqPublisher(
ILog log,
IRabbitMqConnectionFactory connectionFactory,
IRabbitMqConfiguration configuration,
ITransientFaultHandler<IRabbitMqRetryStrategy> transientFaultHandler)
{
_log = log;
_connectionFactory = connectionFactory;
_configuration = configuration;
_transientFaultHandler = transientFaultHandler;
}
public RabbitMqPublisher(
ILog log,
IRabbitMqConnectionFactory connectionFactory,
IRabbitMqConfiguration configuration,
ITransientFaultHandler <IRabbitMqRetryStrategy> transientFaultHandler)
{
_log = log;
_connectionFactory = connectionFactory;
_configuration = configuration;
_transientFaultHandler = transientFaultHandler;
}
public RabbitMqEndpointProvider(IRabbitMqConfiguration rabbitMqConfiguration)
{
_rabbitMqConfiguration = rabbitMqConfiguration;
_busControl = Bus.Factory.CreateUsingRabbitMq(rmqf =>
{
rmqf.Host(new Uri(rabbitMqConfiguration.Uri), h =>
{
h.Username(rabbitMqConfiguration.Username);
h.Password(rabbitMqConfiguration.Password);
});
});
}
public RabbitMqSubscriber(
ILog log,
IRabbitMqConnectionFactory connectionFactory,
IRabbitMqConfiguration configuration,
ITransientFaultHandler <IRabbitMqRetryStrategy> transientFaultHandler,
IRabbitMqMessageFactory rabbitMqMessageFactory
)
{
_log = log;
_connectionFactory = connectionFactory;
_configuration = configuration;
_transientFaultHandler = transientFaultHandler;
_rabbitMqMessageFactory = rabbitMqMessageFactory;
}
public static IEventFlowOptions PublishToRabbitMq(
this IEventFlowOptions eventFlowOptions,
IRabbitMqConfiguration configuration)
{
return(eventFlowOptions.RegisterServices(sr => {
sr.Register <IRabbitMqConnectionFactory, RabbitMqConnectionFactory>(Lifetime.Singleton);
sr.Register <IRabbitMqMessageFactory, RabbitMqMessageFactory>(Lifetime.Singleton);
sr.Register <IRabbitMqPublisher, RabbitMqPublisher>(Lifetime.Singleton);
sr.Register <IRabbitMqRetryStrategy, RabbitMqRetryStrategy>(Lifetime.Singleton);
sr.Register(rc => configuration, Lifetime.Singleton);
sr.Register <ISubscribeSynchronousToAll, RabbitMqDomainEventPublisher>();
}));
}
public static IEventFlowOptions SubscribeToRabbitMq(
this IEventFlowOptions eventFlowOptions,
IRabbitMqConfiguration configuration)
{
var registrations = eventFlowOptions.RegisterServices(sr =>
{
sr.Register <IRabbitMqConnectionFactory, RabbitMqConnectionFactory>(Lifetime.Singleton);
sr.Register <IRabbitMqMessageFactory, RabbitMqMessageFactory>(Lifetime.Singleton);
sr.Register <IRabbitMqSubscriber, RabbitMqSubscriber>(Lifetime.Singleton);
sr.Register <IRabbitMqRetryStrategy, RabbitMqRetryStrategy>(Lifetime.Singleton);
sr.Register(rc => configuration, Lifetime.Singleton);
});
return(registrations);
}
public static IEventFlowOptions PublishToRabbitMq(
this IEventFlowOptions eventFlowOptions,
IRabbitMqConfiguration configuration)
{
return eventFlowOptions.RegisterServices(sr =>
{
sr.Register<IRabbitMqConnectionFactory, RabbitMqConnectionFactory>(Lifetime.Singleton);
sr.Register<IRabbitMqMessageFactory, RabbitMqMessageFactory>(Lifetime.Singleton);
sr.Register<IRabbitMqPublisher, RabbitMqPublisher>(Lifetime.Singleton);
sr.Register<IRabbitMqRetryStrategy, RabbitMqRetryStrategy>(Lifetime.Singleton);
sr.Register(rc => configuration, Lifetime.Singleton);
sr.Register<ISubscribeSynchronousToAll, RabbitMqDomainEventPublisher>();
});
}
public RabbitMqSubscriber(
ILog log,
IRabbitMqConnectionFactory connectionFactory,
IRabbitMqConfiguration configuration,
IRabbitMqMessageFactory rabbitMqMessageFactory,
IEventJsonSerializer eventJsonSerializer,
IDispatchToEventSubscribers dispatchToEventSubscribers
)
{
_log = log;
_connectionFactory = connectionFactory;
_configuration = configuration;
_rabbitMqMessageFactory = rabbitMqMessageFactory;
_eventJsonSerializer = eventJsonSerializer;
_dispatchToEventSubscribers = dispatchToEventSubscribers;
}
public RabbitMqQueueFactory(IRabbitMqConfiguration configuration)
{
Configuration = (RabbitMqConfiguration)configuration;
Configuration.OnRemoveQueueConfiguration += delegate(Uri uri)
{
lock (_padlock)
{
if (_connectors.ContainsKey(uri))
{
var connector = _connectors[uri];
connector.Close();
_connectors.Remove(uri);
}
}
};
}
public ConnectionFactoryWrapper(
IRabbitMqConfiguration connectionConfiguration,
IClusterHostSelectionStrategy <ConnectionFactoryInfo> clusterHostSelectionStrategy)
{
this.clusterHostSelectionStrategy = clusterHostSelectionStrategy;
Configuration = connectionConfiguration;
foreach (RabbitMqHost hostConfiguration in Configuration.RabbitMqHosts)
{
var connectionFactory = new ConnectionFactory
{
UseBackgroundThreadsForIO = connectionConfiguration.UseBackgroundThreads,
AutomaticRecoveryEnabled = false,
TopologyRecoveryEnabled = false
};
connectionFactory.HostName = hostConfiguration.Ip;
if (connectionFactory.VirtualHost == "/")
{
connectionFactory.VirtualHost = Configuration.VirtualHost;
}
if (connectionFactory.UserName == "guest")
{
connectionFactory.UserName = Configuration.UserName;
}
if (connectionFactory.Password == "guest")
{
connectionFactory.Password = Configuration.Password;
}
if (connectionFactory.Port == -1)
{
connectionFactory.Port = hostConfiguration.Port;
}
connectionFactory.RequestedHeartbeat = Configuration.RequestedHeartbeat;
connectionFactory.ClientProperties = Configuration.ClientProperties;
clusterHostSelectionStrategy.Add(new ConnectionFactoryInfo(connectionFactory, hostConfiguration));
}
}
public async Task RabbitMq_headers_are_read_from_incoming_message([Frozen] IRabbitMqConfiguration configuration, RabbitMqBusEngine sut, string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, string messageId, Guid correlationId, FirstTestCommand Command, string headerKey, string headerValue)
{
sut.SubscribeToCommand <FirstTestCommand>();
var sequence = await sut.StartAsync();
var encoding = Encoding.UTF8;
IBasicProperties properties = new BasicProperties
{
MessageId = messageId,
ContentEncoding = encoding.WebName,
Headers = new Dictionary <string, object>
{
["Nybus:MessageId"] = encoding.GetBytes(messageId),
["Nybus:MessageType"] = encoding.GetBytes(DescriptorName(Command.GetType())),
["Nybus:CorrelationId"] = correlationId.ToByteArray(),
[$"RabbitMq:{headerKey}"] = headerValue
}
};
var body = configuration.Serializer.SerializeObject(Command, encoding);
var incomingMessages = sequence.DumpInList();
sut.Consumers.First().Value.HandleBasicDeliver(consumerTag, deliveryTag, redelivered, exchange, routingKey, properties, body);
Assert.That(incomingMessages, Has.Exactly(1).InstanceOf <CommandMessage <FirstTestCommand> >());
var message = incomingMessages[0] as CommandMessage <FirstTestCommand>;
Assert.That(message, Is.Not.Null);
Assert.That(message.MessageId, Is.EqualTo(messageId));
Assert.That(message.MessageType, Is.EqualTo(MessageType.Command));
Assert.That(message.Type, Is.EqualTo(Command.GetType()));
Assert.That(message.Command, Is.Not.Null);
Assert.That(message.Headers, Contains.Key($"RabbitMq:{headerKey}"));
Assert.That(message.Headers[$"RabbitMq:{headerKey}"], Is.EqualTo(headerValue));
}
private void StartDispatcherThread(IRabbitMqConfiguration configuration)
{
var thread = new Thread(() =>
{
while (!cancellation.IsCancellationRequested)
{
try
{
var channelAction = queue.Take(cancellation.Token);
channelAction();
}
catch (OperationCanceledException)
{
break;
}
}
})
{
Name = "Client Command Dispatcher Thread", IsBackground = configuration.UseBackgroundThreads
};
thread.Start();
}
public RabbitConnector(IRabbitMqConfiguration rabbitMqConfiguration)
{
_rabbitMqConfiguration=rabbitMqConfiguration;
}
