public void StartListening(string queueName)
        {
            CanBeStartedCheck();

            IEnumerable <string> topicFilters = _dispatchers.Keys;

            _receiver = _busContext.CreateMessageReceiver(queueName, topicFilters);
            _receiver.StartReceivingMessages();
            _receiver.StartHandlingMessages(EventReveived);
        }
Ejemplo n.º 2
0
        private void CreateReceiver(EventMessageReceivedCallback handle, string queueName, List <string> expressions)
        {
            var messageReceiver = _context.CreateMessageReceiver(
                queueName: queueName,
                topicExpressions: expressions
                );

            messageReceiver.DeclareQueue();
            messageReceiver.StartReceivingMessages(handle);
        }
        public void SendAndReceiveTest()
        {
            var sentMessage = new EventMessage
            {
                CorrelationId = Guid.NewGuid(),
                EventType     = "string",
                Timestamp     = 100000,
                Topic         = "MVM.Klantbeheer.KlantGeregistreerd",
                Body          = Encoding.Unicode.GetBytes("Klant is geregistreerd"),
            };

            var          receivedFlag    = new AutoResetEvent(false);
            EventMessage receivedMessage = null;

            var builder = new RabbitMQBusContextBuilder()
                          .WithExchange("MVM.Eventbus")
                          .WithAddress("localhost", 5672)
                          .WithCredentials("guest", "guest");

            using (IBusContext busContext = builder.CreateContext())
                // Act - receiver
                using (IMessageReceiver receiver = busContext.CreateMessageReceiver(
                           queueName: "MVM.PolisService",
                           topicFilters: new string[] { "MVM.Klantbeheer.KlantGeregistreerd" }))
                {
                    receiver.StartReceivingMessages();
                    receiver.StartHandlingMessages((EventMessage message) =>
                    {
                        receivedMessage = message;
                        receivedFlag.Set();
                    });

                    // Act - sender
                    var sender = busContext.CreateMessageSender();
                    sender.SendMessageAsync(sentMessage).Wait();

                    // Assert
                    bool messageHasBeenReveived = receivedFlag.WaitOne(2000);
                    Assert.IsTrue(messageHasBeenReveived);
                    Assert.AreEqual(sentMessage.CorrelationId, receivedMessage.CorrelationId);
                    Assert.AreEqual(sentMessage.EventType, receivedMessage.EventType);
                    Assert.AreEqual(sentMessage.Timestamp, receivedMessage.Timestamp);
                    Assert.AreEqual(sentMessage.Topic, receivedMessage.Topic);
                    CollectionAssert.AreEqual(sentMessage.Body, receivedMessage.Body);
                }
        }
        public void CreateQueues()
        {
            foreach (var eventListener in _eventListeners)
            {
                var methodTopics = eventListener.Topics.Keys.Select(x => x.TopicPattern);

                eventListener.StartListening(this);
                eventListener.MessageReceiver =
                    Context.CreateMessageReceiver(eventListener.EventListenerAttribute.QueueName, methodTopics);
                eventListener.MessageReceiver.DeclareQueue();
            }

            foreach (var commandListener in _commandListeners)
            {
                commandListener.DeclareQueue(Context);
            }

            _queuesDeclared = true;
        }