private void GivenSubscriptionsToAQueueInTwoRegions()
        {
            var primaryHandler = Substitute.For <IHandlerAsync <GenericMessage> >();

            primaryHandler.Handle(Arg.Any <GenericMessage>()).Returns(true);
            primaryHandler
            .When(x => x.Handle(Arg.Any <GenericMessage>()))
            .Do(async x => await _primaryHandler.Complete((GenericMessage)x.Args()[0]));

            _primaryBus = CreateMeABus
                          .InRegion(PrimaryRegion)
                          .WithSqsPointToPointSubscriber()
                          .IntoQueue(string.Empty)
                          .WithMessageHandler(primaryHandler);
            _primaryBus.StartListening();

            var secondaryHandler = Substitute.For <IHandlerAsync <GenericMessage> >();

            secondaryHandler.Handle(Arg.Any <GenericMessage>()).Returns(true);
            secondaryHandler
            .When(x => x.Handle(Arg.Any <GenericMessage>()))
            .Do(async x => await _secondaryHandler.Complete((GenericMessage)x.Args()[0]));

            _secondaryBus = CreateMeABus
                            .InRegion(SecondaryRegion)
                            .WithSqsPointToPointSubscriber()
                            .IntoQueue(string.Empty)
                            .WithMessageHandler(secondaryHandler);
            _secondaryBus.StartListening();
        }
        private void GivenSubscriptionsToAQueueInTwoRegions()
        {
            var primaryHandler = Substitute.For <IHandlerAsync <SimpleMessage> >();

            primaryHandler.Handle(Arg.Any <SimpleMessage>()).Returns(true);
            primaryHandler
            .When(x => x.Handle(Arg.Any <SimpleMessage>()))
            .Do(async x => await _primaryHandler.Complete((SimpleMessage)x.Args()[0]));

            _primaryBus = CreateMeABus
                          .WithLogging(LoggerFactory)
                          .InRegion(PrimaryRegion)
                          .WithSqsTopicSubscriber()
                          .IntoQueue(QueueName)
                          .WithMessageHandler(primaryHandler);

            _primaryBus.StartListening();

            var secondaryHandler = Substitute.For <IHandlerAsync <SimpleMessage> >();

            secondaryHandler.Handle(Arg.Any <SimpleMessage>()).Returns(true);
            secondaryHandler
            .When(x => x.Handle(Arg.Any <SimpleMessage>()))
            .Do(async x => await _secondaryHandler.Complete((SimpleMessage)x.Args()[0]));

            _secondaryBus = CreateMeABus
                            .WithLogging(LoggerFactory)
                            .InRegion(SecondaryRegion)
                            .WithSqsTopicSubscriber()
                            .IntoQueue(QueueName)
                            .WithMessageHandler(secondaryHandler);

            _secondaryBus.StartListening();
        }
        private void GivenSubscriptionsToAQueueInTwoRegions()
        {
            var primaryHandler = Substitute.For <IHandler <GenericMessage> >();

            primaryHandler.Handle(Arg.Any <GenericMessage>()).Returns(true);
            primaryHandler
            .When(x => x.Handle(Arg.Any <GenericMessage>()))
            .Do(x => _primaryHandler.Complete((GenericMessage)x.Args()[0]));

            _primaryBus = CreateMeABus
                          .InRegion(PrimaryRegion)
                          .WithSqsTopicSubscriber()
                          .IntoQueue("queuename")
                          .WithMessageHandler(primaryHandler);
            _primaryBus.StartListening();

            var secondaryHandler = Substitute.For <IHandler <GenericMessage> >();

            secondaryHandler.Handle(Arg.Any <GenericMessage>()).Returns(true);
            secondaryHandler
            .When(x => x.Handle(Arg.Any <GenericMessage>()))
            .Do(x => _secondaryHandler.Complete((GenericMessage)x.Args()[0]));

            _secondaryBus = CreateMeABus
                            .InRegion(SecondaryRegion)
                            .WithSqsTopicSubscriber()
                            .IntoQueue("queuename")
                            .WithMessageHandler(secondaryHandler);
            _secondaryBus.StartListening();
        }
        private void GivenSubscriptionsToAQueueInTwoRegions()
        {
            var primaryHandler = Substitute.For<IHandler<GenericMessage>>();
            primaryHandler.Handle(Arg.Any<GenericMessage>()).Returns(true);
            primaryHandler
                .When(x => x.Handle(Arg.Any<GenericMessage>()))
                .Do(x => _primaryHandler.Complete((GenericMessage)x.Args()[0]));

            _primaryBus = CreateMeABus
                .InRegion(PrimaryRegion)
                .WithSqsTopicSubscriber()
                .IntoQueue("queuename")
                .WithMessageHandler(primaryHandler);
            _primaryBus.StartListening();

            var secondaryHandler = Substitute.For<IHandler<GenericMessage>>();
            secondaryHandler.Handle(Arg.Any<GenericMessage>()).Returns(true);
            secondaryHandler
                .When(x => x.Handle(Arg.Any<GenericMessage>()))
                .Do(x => _secondaryHandler.Complete((GenericMessage)x.Args()[0]));

            _secondaryBus = CreateMeABus
                .InRegion(SecondaryRegion)
                .WithSqsTopicSubscriber()
                .IntoQueue("queuename")
                .WithMessageHandler(secondaryHandler);
            _secondaryBus.StartListening();
        }
        private void GivenSubscriptionsToAQueueInTwoRegions()
        {
            var primaryHandler = Substitute.For<IHandlerAsync<GenericMessage>>();
            primaryHandler.Handle(Arg.Any<GenericMessage>()).Returns(true);
            primaryHandler
                .When(x => x.Handle(Arg.Any<GenericMessage>()))
                .Do(async x => await _primaryHandler.Complete((GenericMessage)x.Args()[0]));

            _primaryBus = CreateMeABus
                .InRegion(PrimaryRegion)
                .WithSqsPointToPointSubscriber()
                .IntoQueue(string.Empty)
                .WithMessageHandler(primaryHandler);
            _primaryBus.StartListening();

            var secondaryHandler = Substitute.For<IHandlerAsync<GenericMessage>>();
            secondaryHandler.Handle(Arg.Any<GenericMessage>()).Returns(true);
            secondaryHandler
                .When(x => x.Handle(Arg.Any<GenericMessage>()))
                .Do(async x => await _secondaryHandler.Complete((GenericMessage)x.Args()[0]));

            _secondaryBus = CreateMeABus
                .InRegion(SecondaryRegion)
                .WithSqsPointToPointSubscriber()
                .IntoQueue(string.Empty)
                .WithMessageHandler(secondaryHandler);
            _secondaryBus.StartListening();
        }
        public GenericMessageService()
        {
            _logger = LogManager.GetCurrentClassLogger();

            CreateMeABus.DefaultClientFactory = () =>
                                                new DefaultAwsClientFactory(new BasicAWSCredentials("accessKey", "secretKey"));

            _bus = CreateMeABus
                   .InRegion("eu-west-1")
                   .WithSnsMessagePublisher <GenericMessage>()
                   .WithSqsTopicSubscriber("generic-message-topic")
                   .IntoQueue("generic-message-queue")
                   .WithMessageHandler(new GenericMessageHandler());

            _logger.Info("Bus created");
        }
        private void GivenASubscriptionToAQueueInTwoRegions(string primaryRegion, string secondaryRegion)
        {
            var handler = Substitute.For<IHandler<GenericMessage>>();
            handler.Handle(Arg.Any<GenericMessage>()).Returns(true);
            handler
                .When(x => x.Handle(Arg.Any<GenericMessage>()))
                .Do(x => _handler.Complete((GenericMessage) x.Args()[0]));

            _subscriber = CreateMeABus
                .InRegion(primaryRegion)
                .WithFailoverRegion(secondaryRegion)
                .WithActiveRegion(() => primaryRegion)
                .WithSqsPointToPointSubscriber()
                .IntoQueue(string.Empty)
                .WithMessageHandler(handler);
            _subscriber.StartListening();
        }
        private void GivenASubscriptionToAQueueInTwoRegions(string primaryRegion, string secondaryRegion)
        {
            var handler = Substitute.For <IHandler <GenericMessage> >();

            handler.Handle(Arg.Any <GenericMessage>()).Returns(true);
            handler
            .When(x => x.Handle(Arg.Any <GenericMessage>()))
            .Do(x => _handler.Complete((GenericMessage)x.Args()[0]));

            _subscriber = CreateMeABus
                          .InRegion(primaryRegion)
                          .WithFailoverRegion(secondaryRegion)
                          .WithActiveRegion(() => primaryRegion)
                          .WithSqsPointToPointSubscriber()
                          .IntoQueue(string.Empty)
                          .WithMessageHandler(handler);
            _subscriber.StartListening();
        }
        private void GivenASubscriptionToAQueueInTwoRegions(string primaryRegion, string secondaryRegion)
        {
            _handler.ExpectedMessageCount = 2;

            var handler = Substitute.For<IHandlerAsync<GenericMessage>>();
            handler.Handle(Arg.Any<GenericMessage>()).Returns(true);
            handler
                .When(x => x.Handle(Arg.Any<GenericMessage>()))
                .Do(async x => await _handler.Complete((GenericMessage) x.Args()[0]));

            _subscriber = CreateMeABus
                .InRegion(primaryRegion)
                .WithFailoverRegion(secondaryRegion)
                .WithActiveRegion(() => primaryRegion)
                .WithSqsTopicSubscriber()
                .IntoQueue("queuename")
                .WithMessageHandler(handler);
            _subscriber.StartListening();
        }
        private void GivenASubscriptionToAQueueInTwoRegions(string primaryRegion, string secondaryRegion)
        {
            _handler.ExpectedMessageCount = 2;

            var handler = Substitute.For <IHandlerAsync <GenericMessage> >();

            handler.Handle(Arg.Any <GenericMessage>()).Returns(true);
            handler
            .When(x => x.Handle(Arg.Any <GenericMessage>()))
            .Do(async x => await _handler.Complete((GenericMessage)x.Args()[0]));

            _subscriber = CreateMeABus
                          .InRegion(primaryRegion)
                          .WithFailoverRegion(secondaryRegion)
                          .WithActiveRegion(() => primaryRegion)
                          .WithSqsTopicSubscriber()
                          .IntoQueue("queuename")
                          .WithMessageHandler(handler);
            _subscriber.StartListening();
        }
Ejemplo n.º 11
0
        private void GivenASubscriptionToAQueueInTwoRegions(string primaryRegion, string secondaryRegion)
        {
            _handler.ExpectedMessageCount = 2;

            var handler = Substitute.For <IHandlerAsync <SimpleMessage> >();

            handler.Handle(Arg.Any <SimpleMessage>()).Returns(true);
            handler
            .When(x => x.Handle(Arg.Any <SimpleMessage>()))
            .Do(async x => await _handler.Complete((SimpleMessage)x.Args()[0]));

            _subscriber = CreateMeABus
                          .WithLogging(LoggerFactory)
                          .InRegion(primaryRegion)
                          .WithFailoverRegion(secondaryRegion)
                          .WithActiveRegion(() => primaryRegion)
                          .WithSqsTopicSubscriber()
                          .IntoQueue(QueueName)
                          .WithMessageHandler(handler);

            _subscriberCts = new CancellationTokenSource();
            _subscriber.StartListening(_subscriberCts.Token);
        }