public void ShouldFilterHeadersOfBlackList()
            {
                var excludedList = new List <string> {
                    "b", "c"
                };

                var excludedListAddition = new List <string> {
                    "e", "f"
                };

                var sut = new MessageHeaderStorage(excludedList);

                sut.RegisterExcludedHeaders(excludedListAddition);

                sut.Store(new Dictionary <string, object> {
                    { "a", 1 }, { "b", 2 }, { "c", 3 }, { "d", 4 }, { "e", 5 }, { "f", 6 }, { "g", 7 }
                });

                var storedResult = sut.Load();

                CollectionAssert.DoesNotContain(storedResult.Keys, "b", "Заголовок должен быть исключен при сохранении.");
                CollectionAssert.DoesNotContain(storedResult.Keys, "c", "Заголовок должен быть исключен при сохранении.");
                CollectionAssert.DoesNotContain(storedResult.Keys, "e", "Заголовок должен быть исключен при сохранении.");
                CollectionAssert.DoesNotContain(storedResult.Keys, "f", "Заголовок должен быть исключен при сохранении.");
            }
            public void ShouldFilterHeadersOfBlackList()
            {
                var blackList = new List<string> { "b", "c" };

                var sut = new MessageHeaderStorage(blackList);

                sut.Store(new Dictionary<string, object> { { "a", 1 }, { "b", 2 }, { "c", 3 }, { "d", 4 } });

                CollectionAssert.DoesNotContain(sut.Load().Keys, "b", "Заголовок должен быть исключен при сохранении.");
                CollectionAssert.DoesNotContain(sut.Load().Keys, "c", "Заголовок должен быть исключен при сохранении.");
            }
            public void ShouldFilterHeadersOfBlackList()
            {
                var blackList = new List <string> {
                    "b", "c"
                };

                var sut = new MessageHeaderStorage(blackList);

                sut.Store(new Dictionary <string, object> {
                    { "a", 1 }, { "b", 2 }, { "c", 3 }, { "d", 4 }
                });

                CollectionAssert.DoesNotContain(sut.Load().Keys, "b", "Заголовок должен быть исключен при сохранении.");
                CollectionAssert.DoesNotContain(sut.Load().Keys, "c", "Заголовок должен быть исключен при сохранении.");
            }
Пример #4
0
            public void should_set_message_header_storage_for_incoming_and_outgoing_messages_by_default()
            {
                var configuration = new BusConfiguration();
                var storage       = new MessageHeaderStorage(Enumerable.Empty <string>());

                configuration.UseIncomingMessageHeaderStorage(storage);

                var senderStorage = configuration.SenderDefaults.GetIncomingMessageHeaderStorage();

                senderStorage.HasValue.Should().BeTrue();
                senderStorage.Value.Should().Be(storage);

                var receiverStorage = configuration.ReceiverDefaults.GetIncomingMessageHeaderStorage();

                receiverStorage.HasValue.Should().BeTrue();
                receiverStorage.Value.Should().Be(storage);
            }
Пример #5
0
        /// <summary>
        /// Включает использование брокера <c>RabbitMQ</c>.
        /// </summary>
        /// <param name="busConfigurator">Конфигуратор шины сообщений.</param>
        /// <returns>Конфигуратор шины сообщений с включенной поддержкой брокера.</returns>
        public static IBusConfigurator UseRabbitMq(this IBusConfigurator busConfigurator)
        {
            var c = (BusConfiguration)busConfigurator;

            if (c.BusFactoryFunc != null)
            {
                return(busConfigurator);
            }

            c.BuildBusUsing(bc => new RabbitBus(c));

            var blockedHeaders = new List <string>
            {
                Headers.Expires,
                Headers.MessageLabel,
                Headers.Persist,
                Headers.QueueMessageTtl,
                Headers.ReplyRoute,
                Headers.Timeout,
                Headers.Ttl,
                Headers.Delay
            };

            var messageHeaderStorage = new MessageHeaderStorage(blockedHeaders);

            c.UseIncomingMessageHeaderStorage(messageHeaderStorage);

            c.SenderDefaults = new RabbitSenderOptions(c.EndpointOptions)
            {
                ConfirmationIsRequired = false,
                Persistently           = false,
                RequestTimeout         = TimeSpan.FromSeconds(30),
                Ttl = default(TimeSpan?),
                RouteResolverBuilder    = RabbitBusDefaults.RouteResolverBuilder,
                ReuseConnection         = true,
                ProducerSelectorBuilder = RabbitBusDefaults.ProducerSelectorBuilder,
                FailoverAttempts        = 7,
                MaxRetryDelay           = 30,
                InactivityResetDelay    = 120
            };

            c.ReceiverDefaults = new RabbitReceiverOptions(c.EndpointOptions)
            {
                AcceptIsRequired = false,
                ParallelismLevel = 1,
                EndpointBuilder  = RabbitBusDefaults.SubscriptionEndpointBuilder,
                QoS             = new QoSParams(50, 0),
                ReuseConnection = true
            };

            c.UseMessageLabelHandler(new DefaultRabbitMessageLabelHandler());

            // TODO: extract, combine routing and handler definition
            Func <IRouteResolverBuilder, IRouteResolver> faultRouteResolverBuilder = b =>
            {
                TimeSpan messageTtl = c.ReceiverDefaults.GetFaultQueueTtl().HasValue
                                              ? c.ReceiverDefaults.GetFaultQueueTtl().Value
                                              : TimeSpan.FromDays(FaultMessageTtlDays);

                string       name    = b.Endpoint.Address + ".Fault";
                Exchange     e       = b.Topology.Declare(Exchange.Named(name).Durable.Topic);
                QueueBuilder builder = Queue.Named(name).Durable.WithTtl(messageTtl);

                if (c.ReceiverDefaults.GetFaultQueueLimit().HasValue)
                {
                    builder = builder.WithLimit(c.ReceiverDefaults.GetFaultQueueLimit().Value);
                }
                Queue q = b.Topology.Declare(builder);
                b.Topology.Bind(e, q);
                return(e);
            };

            c.Route("document.Contour.unhandled").Persistently().ConfiguredWith(faultRouteResolverBuilder).ReuseConnection();
            c.Route("document.Contour.failed").Persistently().ConfiguredWith(faultRouteResolverBuilder).ReuseConnection();

            c.OnUnhandled(
                d =>
            {
                d.Forward("document.Contour.unhandled", d.BuildFaultMessage());
                d.Accept();
            });
            c.OnFailed(
                d =>
            {
                d.Forward("document.Contour.failed", d.BuildFaultMessage());
                d.Accept();
            });

            return(busConfigurator);
        }