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"); }