public PublishConfiguration GetConfiguration(Type messageType, Action <IPublishConfigurationBuilder> configuration)
{
configuration = configuration ?? (builder => { });
// 根据注解属性获取Exchange和Routing Key值
configuration = (builder =>
{
builder.WithExchange(ExchangeAction(messageType));
var routingAttr = GetAttribute <RoutingAttribute>(messageType);
if (routingAttr?.RoutingKey != null)
{
builder.WithRoutingKey(routingAttr.RoutingKey);
}
}) + configuration;
var exchangeConfig = new ExchangeConfiguration(_clientConfig.Exchange)
{
ExchangeName = _conventions.ExchangeNamingConvention(messageType)
};
var routingKey = _conventions.QueueNamingConvention(messageType);
var cfgBuilder = new PublishConfigurationBuilder(exchangeConfig, routingKey);
configuration?.Invoke(cfgBuilder);
return(cfgBuilder.Configuration);
}
public void TestSource_WhenDifferentConfigsForBaseAndDerived_ThenReceiveFromBoth()
{
const string exchangeName = "exchange";
const string exchangeType = "type";
const string routingKey = "route";
const string derivedExchangeName = "derived-exchange";
const string derivedExchangeType = "derived-type";
const string derivedRoutingKey = "derived-route";
var derivedTestEvent = new DerivedTestEvent();
var derivedTestEvent2 = new DerivedTestEvent();
var sourceMock = new Mock <IEventSource>(MockBehavior.Strict);
sourceMock.Setup(m => m.ReceiveEvents <DerivedTestEvent>()).Returns(Observable.Return(derivedTestEvent));
var derivedSourceMock = new Mock <IEventSource>(MockBehavior.Strict);
derivedSourceMock.Setup(m => m.ReceiveEvents <DerivedTestEvent>()).Returns(Observable.Return(derivedTestEvent2));
var factoryMock = new Mock <IEventProcessorFactory>(MockBehavior.Strict);
factoryMock.Setup(m => m.CreateSource(exchangeName, exchangeType, routingKey)).Returns(sourceMock.Object);
factoryMock.Setup(m => m.CreateSource(derivedExchangeName, derivedExchangeType, derivedRoutingKey)).Returns(derivedSourceMock.Object);
var exchangeConfiguration = new ExchangeConfiguration();
exchangeConfiguration.ConfigureEventSource(typeof(TestEvent), exchangeName, exchangeType, routingKey);
exchangeConfiguration.ConfigureEventSource(typeof(DerivedTestEvent), derivedExchangeName, derivedExchangeType, derivedRoutingKey);
var bus = new Bus(factoryMock.Object, exchangeConfiguration) as IEventSource;
var receivedEvents = bus.ReceiveEvents <DerivedTestEvent>().ToArray().Wait();
Assert.Equal(2, receivedEvents.Length);
Assert.True(receivedEvents.Contains(derivedTestEvent));
Assert.True(receivedEvents.Contains(derivedTestEvent2));
sourceMock.Verify(m => m.ReceiveEvents <DerivedTestEvent>(), Times.Once);
derivedSourceMock.Verify(m => m.ReceiveEvents <DerivedTestEvent>(), Times.Once);
}
public void TestSender_WhenConfiguredMultipleEvents_ThenChooseWisely()
{
const string exchangeName = "exchange";
const string anotherExchangeName = "another-exchange";
var @event = new TestEvent();
var anotherEvent = new AnotherTestEvent();
var senderMock = new Mock <IEventSender>(MockBehavior.Strict);
senderMock.Setup(m => m.SendEvent(@event));
var anotherSenderMock = new Mock <IEventSender>(MockBehavior.Strict);
anotherSenderMock.Setup(m => m.SendEvent(anotherEvent));
var factoryMock = new Mock <IEventProcessorFactory>(MockBehavior.Strict);
factoryMock.Setup(m => m.CreateSender(exchangeName)).Returns(senderMock.Object);
factoryMock.Setup(m => m.CreateSender(anotherExchangeName)).Returns(anotherSenderMock.Object);
var exchangeConfiguration = new ExchangeConfiguration();
exchangeConfiguration.ConfigureEventSender(typeof(TestEvent), exchangeName);
exchangeConfiguration.ConfigureEventSender(typeof(AnotherTestEvent), anotherExchangeName);
var bus = new Bus(factoryMock.Object, exchangeConfiguration) as IEventSender;
bus.SendEvent(@event);
bus.SendEvent(anotherEvent);
senderMock.Verify(m => m.SendEvent(@event), Times.Once);
anotherSenderMock.Verify(m => m.SendEvent(@event), Times.Never);
senderMock.Verify(m => m.SendEvent(anotherEvent), Times.Never);
anotherSenderMock.Verify(m => m.SendEvent(anotherEvent), Times.Once);
}
public void TestSender_WhenDifferentConfigsForBaseAndDerived_ThenSendToBoth()
{
const string exchangeName = "exchange";
const string derivedExchangeName = "derived-exchange";
var derivedTestEvent = new DerivedTestEvent();
var senderMock = new Mock <IEventSender>(MockBehavior.Strict);
senderMock.Setup(m => m.SendEvent(derivedTestEvent));
var derivedSenderMock = new Mock <IEventSender>(MockBehavior.Strict);
derivedSenderMock.Setup(m => m.SendEvent(derivedTestEvent));
var factoryMock = new Mock <IEventProcessorFactory>(MockBehavior.Strict);
factoryMock.Setup(m => m.CreateSender(exchangeName)).Returns(senderMock.Object);
factoryMock.Setup(m => m.CreateSender(derivedExchangeName)).Returns(derivedSenderMock.Object);
var exchangeConfiguration = new ExchangeConfiguration();
exchangeConfiguration.ConfigureEventSender(typeof(TestEvent), exchangeName);
exchangeConfiguration.ConfigureEventSender(typeof(DerivedTestEvent), derivedExchangeName);
var bus = new Bus(factoryMock.Object, exchangeConfiguration) as IEventSender;
bus.SendEvent(derivedTestEvent);
senderMock.Verify(m => m.SendEvent(derivedTestEvent), Times.Once);
derivedSenderMock.Verify(m => m.SendEvent(derivedTestEvent), Times.Once);
}
public void When_rejecting_a_message_it_is_removed_from_the_queue()
{
// Arrange
const string uri = @"amqp://*****:*****@sea-2600-53:5672/Dev_JoshR";
var message = new TestMessage {
Identifier = Guid.NewGuid().ToString(), Description = "something", SentAt = DateTime.Now
};
var receivedMessages = new List <TestMessage>();
var queueConfiguration = new QueueConfiguration {
IsQueueDurable = true, IsQueueExclusive = false, SupportsAutoDelete = false
};
var exchangeConfiguration = new ExchangeConfiguration {
ExchangeType = ExchangeType.Direct, IsExchangeDurable = true
};
var receiver = new RabbitMqMessageSubscriber <TestMessage>(uri, new ClassTypeNameExchangeNameFactory(), new ClassTypeQueueNameFactory(), new EmptyRoutingKeyFactory(), new JsonMessageFormatter(), queueConfiguration);
receiver.Subscribe(s =>
{
receivedMessages.Add(s.Message);
s.Reject();
});
var sender = new RabbitMqMessenger(uri, new ClassTypeNameExchangeNameFactory(), new EmptyRoutingKeyFactory(), new JsonMessageFormatter(), exchangeConfiguration);
// Act
sender.Send(message);
Thread.Sleep(5000);
// Assert
Assert.That(receivedMessages, Is.Not.Empty);
}
public void TestSource_WhenConfiguredMultipleEventsWithEqualParameters_ThenCreateOnlyOneSource()
{
const string exchangeName = "exchange";
const string exchangeType = "type";
const string routingKey = "route";
var sourceMock = new Mock <IEventSource>(MockBehavior.Strict);
sourceMock.Setup(m => m.ReceiveEvents <TestEvent>()).Returns(Observable.Empty <TestEvent>());
sourceMock.Setup(m => m.ReceiveEvents <AnotherTestEvent>()).Returns(Observable.Empty <AnotherTestEvent>());
var factoryMock = new Mock <IEventProcessorFactory>(MockBehavior.Strict);
factoryMock.Setup(m => m.CreateSource(exchangeName, exchangeType, routingKey)).Returns(sourceMock.Object);
var exchangeConfiguration = new ExchangeConfiguration();
exchangeConfiguration.ConfigureEventSource(typeof(TestEvent), exchangeName, exchangeType, routingKey);
exchangeConfiguration.ConfigureEventSource(typeof(AnotherTestEvent), exchangeName, exchangeType, routingKey);
var bus = new Bus(factoryMock.Object, exchangeConfiguration) as IEventSource;
bus.ReceiveEvents <TestEvent>();
bus.ReceiveEvents <AnotherTestEvent>();
factoryMock.Verify(m => m.CreateSource(exchangeName, exchangeType, routingKey), Times.Once);
}
public RequestConfiguration GetConfiguration(Type requestType, Type responseType, Action <IRequestConfigurationBuilder> configuration)
{
// leverage direct reply to: https://www.rabbitmq.com/direct-reply-to.html
var replyQueueConfig = new QueueConfiguration
{
QueueName = _directReplyTo,
AutoDelete = true,
Durable = false,
Exclusive = true
};
var exchangeConfig = new ExchangeConfiguration(_clientConfig.Exchange)
{
ExchangeName = _conventions.ExchangeNamingConvention(requestType)
};
var defaultConfig = new RequestConfiguration
{
ReplyQueue = replyQueueConfig,
Exchange = exchangeConfig,
RoutingKey = _conventions.QueueNamingConvention(requestType),
ReplyQueueRoutingKey = replyQueueConfig.QueueName
};
var builder = new RequestConfigurationBuilder(defaultConfig);
configuration?.Invoke(builder);
return(builder.Configuration);
}
protected QueueWriterService(
ConnectionFactory connectionFactory,
ExchangeConfiguration exchange,
IMessageHandler messageHandler
) : base(connectionFactory, messageHandler)
{
Exchange = exchange;
}
public void TestSource_WhenEventNotConfigured_ThenError()
{
var factoryMock = new Mock <IEventProcessorFactory>(MockBehavior.Strict);
var exchangeConfiguration = new ExchangeConfiguration();
var bus = new Bus(factoryMock.Object, exchangeConfiguration) as IEventSource;
Assert.Throws <InvalidOperationException>(() => bus.ReceiveEvents <TestEvent>());
}
public DefaultStrategy(IMessageSerializer serializer, INamingConventions conventions, IBasicPropertiesProvider propertiesProvider, ITopologyProvider topologyProvider, IChannelFactory channelFactory)
{
_serializer = serializer;
_propertiesProvider = propertiesProvider;
_topologyProvider = topologyProvider;
_channelFactory = channelFactory;
_errorExchangeCfg = ExchangeConfiguration.Default;
_errorExchangeCfg.ExchangeName = conventions.ErrorExchangeNamingConvention();
}
public ResponderConfigurationBuilder(QueueConfiguration defaultQueue = null, ExchangeConfiguration defaultExchange = null)
{
_exchangeBuilder = new ExchangeConfigurationBuilder(defaultExchange);
_queueBuilder = new QueueConfigurationBuilder(defaultQueue);
Configuration = new ResponderConfiguration
{
Queue = _queueBuilder.Configuration,
Exchange = _exchangeBuilder.Configuration,
RoutingKey = _queueBuilder.Configuration.QueueName
};
}
public Export GetExport(string exportId)
{
if (_tableMapping == null || string.IsNullOrEmpty(exportId) || exportId == "0")
{
return(ExchangeConfiguration.BuildDefaultExport <T>());
}
else
{
return(_tableMapping.Exports[exportId]);
}
}
public PublishConfiguration GetConfiguration(Type messageType, Action <IPublishConfigurationBuilder> configuration)
{
var exchangeConfig = new ExchangeConfiguration(_clientConfig.Exchange)
{
ExchangeName = _conventions.ExchangeNamingConvention(messageType)
};
var routingKey = _conventions.QueueNamingConvention(messageType);
var builder = new PublishConfigurationBuilder(exchangeConfig, routingKey);
configuration?.Invoke(builder);
return(builder.Configuration);
}
public Task DeclareExchangeAsync(ExchangeConfiguration exchange)
{
if (IsInitialized(exchange))
{
return(_completed);
}
var scheduled = new ScheduledExchangeTask(exchange);
_topologyTasks.Enqueue(scheduled);
EnsureWorker();
return(scheduled.TaskCompletionSource.Task);
}
public Task UnbindQueueAsync(QueueConfiguration queue, ExchangeConfiguration exchange, string routingKey)
{
var scheduled = new ScheduledUnbindQueueTask
{
Queue = queue,
Exchange = exchange,
RoutingKey = routingKey
};
_topologyTasks.Enqueue(scheduled);
EnsureWorker();
return(scheduled.TaskCompletionSource.Task);
}
/// <summary>
/// Creates a configuration for a persistent exchange
/// </summary>
/// <param name="name">name of the exchange</param>
/// <param name="type">type of the exchange</param>
/// <returns>exchange configuration</returns>
public static ExchangeConfiguration PersistentExchange(string name, ExchangeType type)
{
Arguments.NotNullOrWhitespace(name, nameof(name));
var temp = new ExchangeConfiguration
{
ExchangeType = type,
Name = name,
IsAutoDelete = false,
IsDurable = true,
};
return(temp);
}
public void Create(ExchangeConfiguration exchangeConfiguration)
{
exchangeConfiguration = Arguments.EnsureNotNull(exchangeConfiguration, nameof(exchangeConfiguration));
this.InitializeIfRequired();
lock (this.Mutex)
{
this.ThrowIfDisposed();
this.Logger.Debug($"EXCHANGE DECLARE:{exchangeConfiguration?.Name} type:{exchangeConfiguration?.ExchangeType} durable:{exchangeConfiguration?.IsDurable} auto delete:{exchangeConfiguration?.IsAutoDelete} arguments:[{exchangeConfiguration?.Arguments?.StringFormat()}]");
this.RabbitMQChannel.ExchangeDeclare(exchangeConfiguration !.Name, exchangeConfiguration.ExchangeType.ToString().ToLower(CultureInfo.InvariantCulture), exchangeConfiguration.IsDurable, exchangeConfiguration.IsAutoDelete, exchangeConfiguration.Arguments);
}
}
public ModelBuilder CreateExchange(ExchangeConfiguration exchangeConfig)
{
try
{
Console.Write($"Creating exchange '{exchangeConfig.ExchangeName}'... ");
_model.ExchangeDeclare(exchangeConfig.ExchangeName, exchangeConfig.ExchangeType.ToLower(), exchangeConfig.Durable, exchangeConfig.AutoDelete, exchangeConfig.Arguments);
Console.WriteLine("Done!");
return(this);
}
catch (Exception ex)
{
Console.WriteLine($"Failed!\n{ex.Message}");
throw;
}
}
public ResponderConfiguration GetConfiguration(Type requestType, Type responseType, Action <IResponderConfigurationBuilder> configuration)
{
var queueConfig = new QueueConfiguration(_clientConfig.Queue)
{
QueueName = _conventions.QueueNamingConvention(requestType)
};
var exchangeConfig = new ExchangeConfiguration(_clientConfig.Exchange)
{
ExchangeName = _conventions.ExchangeNamingConvention(requestType)
};
var builder = new ResponderConfigurationBuilder(queueConfig, exchangeConfig);
configuration?.Invoke(builder);
return(builder.Configuration);
}
public void TestSender_WhenConfiguredsDerivedEvent_ThenErrorWhileSendingBase()
{
const string derivedExchangeName = "derived-exchange";
var @event = new TestEvent();
var derivedSenderMock = new Mock <IEventSender>(MockBehavior.Strict);
var factoryMock = new Mock <IEventProcessorFactory>(MockBehavior.Strict);
factoryMock.Setup(m => m.CreateSender(derivedExchangeName)).Returns(derivedSenderMock.Object);
var exchangeConfiguration = new ExchangeConfiguration();
exchangeConfiguration.ConfigureEventSender(typeof(DerivedTestEvent), derivedExchangeName);
var bus = new Bus(factoryMock.Object, exchangeConfiguration) as IEventSender;
Assert.Throws <InvalidOperationException>(() => bus.SendEvent(@event));
}
public SubscriptionConfiguration GetConfiguration(Type messageType, Action <ISubscriptionConfigurationBuilder> configuration = null)
{
configuration = configuration ?? (builder => { });
// 根据注解属性获取Exchange、Queue和Routing Key值
configuration = (builder =>
{
builder
.WithExchange(ExchangeAction(messageType))
.WithQueue(QueueAction(messageType));
var routingAttr = GetAttribute <RoutingAttribute>(messageType);
if (routingAttr != null)
{
if (routingAttr.NullableNoAck.HasValue)
{
builder.WithNoAck(routingAttr.NullableNoAck.Value);
}
if (routingAttr.PrefetchCount > 0)
{
builder.WithPrefetchCount(routingAttr.PrefetchCount);
}
if (routingAttr.RoutingKey != null)
{
builder.WithRoutingKey(routingAttr.RoutingKey);
}
}
}) + configuration;
var routingKey = _conventions.QueueNamingConvention(messageType);
var queueConfig = new QueueConfiguration(_clientConfig.Queue)
{
QueueName = routingKey,
NameSuffix = _conventions.SubscriberQueueSuffix(messageType)
};
var exchangeConfig = new ExchangeConfiguration(_clientConfig.Exchange)
{
ExchangeName = _conventions.ExchangeNamingConvention(messageType)
};
var cfgBuilder = new SubscriptionConfigurationBuilder(queueConfig, exchangeConfig, routingKey);
configuration?.Invoke(cfgBuilder);
return(cfgBuilder.Configuration);
}
public void TestSource_WhenConfiguredsDerivedEvent_ThenErrorWhileReceivingBase()
{
const string exchangeName = "exchange";
const string exchangeType = "type";
const string routingKey = "route";
var sourceMock = new Mock <IEventSource>(MockBehavior.Strict);
var factoryMock = new Mock <IEventProcessorFactory>(MockBehavior.Strict);
factoryMock.Setup(m => m.CreateSource(exchangeName, exchangeType, routingKey)).Returns(sourceMock.Object);
var exchangeConfiguration = new ExchangeConfiguration();
exchangeConfiguration.ConfigureEventSource(typeof(DerivedTestEvent), exchangeName, exchangeType, routingKey);
var bus = new Bus(factoryMock.Object, exchangeConfiguration) as IEventSource;
Assert.Throws <InvalidOperationException>(() => bus.ReceiveEvents <TestEvent>().Wait());
}
private void DeclareExchange(ExchangeConfiguration exchange)
{
if (IsInitialized(exchange))
{
return;
}
_logger.LogInformation($"Declaring exchange '{exchange.ExchangeName}'.");
var channel = GetOrCreateChannel();
channel.ExchangeDeclare(
exchange.ExchangeName,
exchange.ExchangeType,
exchange.Durable,
exchange.AutoDelete,
exchange.Arguments);
_initExchanges.Add(exchange.ExchangeName);
}
public SubscriptionConfiguration GetConfiguration(Type messageType, Action <ISubscriptionConfigurationBuilder> configuration = null)
{
var routingKey = _conventions.QueueNamingConvention(messageType);
var queueConfig = new QueueConfiguration(_clientConfig.Queue)
{
QueueName = routingKey,
NameSuffix = _conventions.SubscriberQueueSuffix(messageType)
};
var exchangeConfig = new ExchangeConfiguration(_clientConfig.Exchange)
{
ExchangeName = _conventions.ExchangeNamingConvention(messageType)
};
var builder = new SubscriptionConfigurationBuilder(queueConfig, exchangeConfig, routingKey);
configuration?.Invoke(builder);
return(builder.Configuration);
}
public void ValidatorResolution()
{
var container = CreateContainer();
var meConfig = new SimpleMappingEngineConfiguration(container);
meConfig.Configure();
var repository = new Mock <IRepository>();
container.RegisterInstance(repository.Object);
var config = new ExchangeConfiguration(container);
config.Configure();
var validator = container.Resolve <IValidator <Exchange> >("exchange");
// Assert
Assert.IsNotNull(validator, "Validator resolution failed");
}
public void TestSender_WhenConfiguredMultipleEventsWithEqualParameters_ThenCreateOnlyOneSender()
{
const string exchangeName = "exchange";
var senderMock = new Mock <IEventSender>(MockBehavior.Loose);
var factoryMock = new Mock <IEventProcessorFactory>(MockBehavior.Strict);
factoryMock.Setup(m => m.CreateSender(exchangeName)).Returns(senderMock.Object);
var exchangeConfiguration = new ExchangeConfiguration();
exchangeConfiguration.ConfigureEventSender(typeof(TestEvent), exchangeName);
exchangeConfiguration.ConfigureEventSender(typeof(AnotherTestEvent), exchangeName);
var bus = new Bus(factoryMock.Object, exchangeConfiguration) as IEventSender;
bus.SendEvent(new TestEvent());
bus.SendEvent(new AnotherTestEvent());
factoryMock.Verify(m => m.CreateSender(exchangeName), Times.Once);
}
public void TestSender_WhenEventConfigured_ThenSend()
{
const string exchangeName = "exchange";
var @event = new TestEvent();
var senderMock = new Mock <IEventSender>(MockBehavior.Strict);
senderMock.Setup(m => m.SendEvent(@event));
var factoryMock = new Mock <IEventProcessorFactory>(MockBehavior.Strict);
factoryMock.Setup(m => m.CreateSender(exchangeName)).Returns(senderMock.Object);
var exchangeConfiguration = new ExchangeConfiguration();
exchangeConfiguration.ConfigureEventSender(typeof(TestEvent), exchangeName);
var bus = new Bus(factoryMock.Object, exchangeConfiguration) as IEventSender;
bus.SendEvent(@event);
senderMock.Verify(m => m.SendEvent(@event), Times.Once);
}
public virtual IEndPointConfigurator EndPoint()
{
var exchange = new ExchangeConfiguration(_messagingOption.Exchange)
{
Type = _messagingOption.ExchangeType ?? ExchangeType.Direct,
Durable = true,
AutoDelete = false,
Arguments = new Dictionary <string, object>()
};
var queue = new QueueConfiguration(_messagingOption.Queue)
{
Durable = true,
Exclusive = false,
AutoDelete = false,
Arguments = new Dictionary <string, object>()
};
return(new EndPointConfigurator(exchange,
queue,
routingKey: _messagingOption.RoutingKey));
}
public void TestSource_WhenEventConfigured_ThenReceive()
{
const string exchangeName = "exchange";
const string exchangeType = "type";
const string routingKey = "route";
var @event = new TestEvent();
var sourceMock = new Mock <IEventSource>(MockBehavior.Strict);
sourceMock.Setup(m => m.ReceiveEvents <TestEvent>()).Returns(Observable.Return(@event));
var factoryMock = new Mock <IEventProcessorFactory>(MockBehavior.Strict);
factoryMock.Setup(m => m.CreateSource(exchangeName, exchangeType, routingKey)).Returns(sourceMock.Object);
var exchangeConfiguration = new ExchangeConfiguration();
exchangeConfiguration.ConfigureEventSource(typeof(TestEvent), exchangeName, exchangeType, routingKey);
var bus = new Bus(factoryMock.Object, exchangeConfiguration) as IEventSource;
var receivedEvent = bus.ReceiveEvents <TestEvent>().Wait();
sourceMock.Verify(m => m.ReceiveEvents <TestEvent>(), Times.Once);
Assert.Equal(@event, receivedEvent);
}
public Task BindQueueAsync(QueueConfiguration queue, ExchangeConfiguration exchange, string routingKey)
{
if (exchange.IsDefaultExchange())
{
return(_completed);
}
var bindKey = $"{queue.FullQueueName}_{exchange.ExchangeName}_{routingKey}";
if (_queueBinds.Contains(bindKey))
{
return(_completed);
}
var scheduled = new ScheduledBindQueueTask
{
Queue = queue,
Exchange = exchange,
RoutingKey = routingKey
};
_topologyTasks.Enqueue(scheduled);
EnsureWorker();
return(scheduled.TaskCompletionSource.Task);
}
public ExchangeConfigurationBuilder(ExchangeConfiguration initialExchange = null)
{
Configuration = initialExchange ?? ExchangeConfiguration.Default;
}
public void ValidatorResolution()
{
var container = CreateContainer();
var meConfig = new SimpleMappingEngineConfiguration(container);
meConfig.Configure();
var repository = new Mock<IRepository>();
container.RegisterInstance(repository.Object);
var config = new ExchangeConfiguration(container);
config.Configure();
var validator = container.Resolve<IValidator<Exchange>>("exchange");
// Assert
Assert.IsNotNull(validator, "Validator resolution failed");
}
