public async Task Stop()
        {
            LogContext.SetCurrentIfNull(_context.LogContext);
            try
            {
                _cancellationTokenSource.Cancel();

                await _consumerTask.ConfigureAwait(false);

                await _executor.DisposeAsync().ConfigureAwait(false);

                _consumer.Close();
                _consumer.Dispose();

                _cancellationTokenSource.Dispose();
            }
            catch (Exception e)
            {
                LogContext.Error?.Log(e, "Error occured while stopping kafka topic: '{topicName}' listener", _topic);
            }
            finally
            {
                var metrics        = _transport.GetMetrics();
                var completedEvent = new ReceiveTransportCompletedEvent(_context.InputAddress, metrics);

                await _context.TransportObservers.Completed(completedEvent).ConfigureAwait(false);

                await _context.EndpointObservers.Completed(new ReceiveEndpointCompletedEvent(completedEvent, this)).ConfigureAwait(false);

                LogContext.Debug?.Log("Kafka consumer completed {InputAddress}: {DeliveryCount} received, {ConcurrentDeliveryCount} concurrent",
                                      _context.InputAddress, metrics.DeliveryCount, metrics.ConcurrentDeliveryCount);
            }
        }
Exemplo n.º 2
0
        public async Task Disconnect(CancellationToken cancellationToken)
        {
            LogContext.SetCurrentIfNull(_context.LogContext);

            try
            {
                _cancellationTokenSource.Cancel();

                await _executor.DisposeAsync().ConfigureAwait(false);

                await _processor.StopProcessingAsync(cancellationToken).ConfigureAwait(false);

                _cancellationTokenSource.Dispose();
            }
            catch (Exception e)
            {
                LogContext.Error?.Log(e, "Error occured while stopping EventHub processor: '{EventHubName}' listener", _processor.EventHubName);
            }
            finally
            {
                var metrics        = _transport.GetMetrics();
                var completedEvent = new ReceiveTransportCompletedEvent(_context.InputAddress, metrics);

                await _context.TransportObservers.Completed(completedEvent).ConfigureAwait(false);

                await _context.EndpointObservers.Completed(new ReceiveEndpointCompletedEvent(completedEvent, this)).ConfigureAwait(false);

                LogContext.Debug?.Log("EventHub processor completed {InputAddress}: {DeliveryCount} received, {ConcurrentDeliveryCount} concurrent",
                                      _context.InputAddress, metrics.DeliveryCount, metrics.ConcurrentDeliveryCount);
            }
        }
Exemplo n.º 3
0
            async Task ReceiveTransportHandle.Stop(CancellationToken cancellationToken)
            {
                await _transport.Stop("Stop", cancellationToken).ConfigureAwait(false);

                var completed = new ReceiveTransportCompletedEvent(_transport._inputAddress, _transport._tracker.GetDeliveryMetrics());

                await _transport._receiveEndpointContext.TransportObservers.Completed(completed).ConfigureAwait(false);
            }
            async Task ReceiveTransportHandle.Stop(CancellationToken cancellationToken)
            {
                LogContext.SetCurrentIfNull(_transport._context.LogContext);

                await _transport.Stop("Stop", cancellationToken).ConfigureAwait(false);

                _consumerHandle.Disconnect();

                var completed = new ReceiveTransportCompletedEvent(_transport._inputAddress, _transport._dispatcher.GetDeliveryMetrics());

                await _transport._context.TransportObservers.Completed(completed).ConfigureAwait(false);
            }
            protected override async Task StopAgent(StopContext context)
            {
                LogContext.SetCurrentIfNull(_context.LogContext);

                var metrics   = _dispatcher.GetMetrics();
                var completed = new ReceiveTransportCompletedEvent(_context.InputAddress, metrics);

                await _context.TransportObservers.Completed(completed).ConfigureAwait(false);

                LogContext.Debug?.Log("Consumer completed {InputAddress}: {DeliveryCount} received, {ConcurrentDeliveryCount} concurrent",
                                      _context.InputAddress, metrics.DeliveryCount, metrics.ConcurrentDeliveryCount);

                _consumerHandle.Disconnect();

                await base.StopAgent(context).ConfigureAwait(false);
            }
Exemplo n.º 6
0
            async Task ReceiveTransportHandle.Stop(CancellationToken cancellationToken)
            {
                LogContext.SetCurrentIfNull(_transport._context.LogContext);

                await _transport.Stop("Stop", cancellationToken).ConfigureAwait(false);

                _consumerHandle.Disconnect();

                var metrics   = _transport._dispatcher.GetMetrics();
                var completed = new ReceiveTransportCompletedEvent(_transport._inputAddress, metrics);

                await _transport._context.TransportObservers.Completed(completed).ConfigureAwait(false);

                LogContext.Debug?.Log("Consumer completed {InputAddress}: {DeliveryCount} received, {ConcurrentDeliveryCount} concurrent",
                                      _transport._inputAddress, metrics.DeliveryCount, metrics.ConcurrentDeliveryCount);
            }