public async Task StartAsync(CancellationToken cancellationToken)
        {
            var connection =
                await _rabbitMqConnectionFactory.CreateConnectionAsync(_rabbitMqConfiguration.Uri, cancellationToken);

            await connection.WithModelAsync(model =>
            {
                model.ExchangeDeclare(_rabbitMqConfiguration.Exchange, ExchangeType.Fanout);
                model.QueueDeclare(_environmentConfiguration.RabbitQueueName, false, false, true, null);
                model.QueueBind(_environmentConfiguration.RabbitQueueName, _rabbitMqConfiguration.Exchange, "");

                var consume       = new EventingBasicConsumer(model);
                consume.Received += (obj, @event) =>
                {
                    var msg         = CreateRabbitMqMessage(@event);
                    var domainEvent = _eventJsonSerializer.Deserialize(msg.Message, new Metadata(msg.Headers));

                    _dispatchToEventSubscribers.DispatchToAsynchronousSubscribersAsync(domainEvent, cancellationToken);
                };


                model.BasicConsume(_environmentConfiguration.RabbitQueueName, false, consume);
                return(Task.CompletedTask);
            }, cancellationToken);
        }
예제 #2
0
        public async Task SubscribeAsync(string exchange, string queue,
                                         Action <IList <IDomainEvent>, IDomainEventPublisher> action,
                                         IDomainEventPublisher domainEventPublisher, CancellationToken cancellationToken)
        {
            Uri uri = _configuration.Uri;
            IRabbitConnection rabbitConnection = null;

            try
            {
                rabbitConnection = await GetRabbitMqConnectionAsync(uri, cancellationToken).ConfigureAwait(false);

                await rabbitConnection.WithModelAsync(model => {
                    model.ExchangeDeclare(exchange, ExchangeType.Fanout);
                    model.QueueDeclare(queue, false, false, true, null);
                    model.QueueBind(queue, exchange, "");

                    var consume       = new EventingBasicConsumer(model);
                    consume.Received += (obj, @event) => {
                        var msg         = CreateRabbitMqMessage(@event);
                        var domainEvent = _eventJsonSerializer.Deserialize(msg.Message, new Metadata(msg.Headers));

                        _dispatchToEventSubscribers.DispatchToAsynchronousSubscribersAsync(domainEvent, cancellationToken);
                    };
                    model.BasicConsume(queue, false, consume);
                    return(Task.CompletedTask);
                }, cancellationToken);
            }
            catch (OperationCanceledException)
            {
                throw;
            }
            catch (Exception e)
            {
                if (rabbitConnection != null)
                {
                    using (await _asyncLock.WaitAsync(CancellationToken.None).ConfigureAwait(false))
                    {
                        rabbitConnection.Dispose();
                        _connections.Remove(uri);
                    }
                }

                _log.Error(e, "Failed to subscribe to RabbitMQ");
                throw;
            }
        }