public async Task HandleApplicationMessageReceivedAsync(MqttApplicationMessageReceivedEventArgs eventArgs)
{
var consumeResult = new ConsumeMessageResult(_topics);
consumeResult.SetMessageAsync(eventArgs.ApplicationMessage);
consumeResult.PublishToDomainAsync(_serviceProvider, _logger, CancellationToken.None);
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
using var consumer = MakeConsumer();
consumer.Subscribe(_topics.Keys);
using var scope = _services.CreateScope();
var mediator = scope.ServiceProvider.GetRequiredService <IMicroMediator>();
while (!stoppingToken.IsCancellationRequested)
{
try
{
var consumeResult = new ConsumeMessageResult(_topics);
if (!consumer.TryConsumeMessage(_connection.MillisecondsTimeout, consumeResult, stoppingToken))
{
// _logger.LogTrace($"{consumer.Name}:{consumer.MemberId} is empty. Sleep for {_connection.MillisecondsTimeout}MS");
await Task.Delay(1, stoppingToken);
// TimeTrackerCollection.Append(consumeResult.GetTimes());
// TimeTrackerCollection.Print();
continue;
}
// var sw = Stopwatch.StartNew();
_logger.LogTrace($"{consumer.Name} - Pull Message.TP:{consumeResult.Result.TopicPartition.Topic}:{consumeResult.Result.TopicPartition.Partition}, Offset:{consumeResult.Result.Offset.Value}");
var processTask = consumeResult.PublishToDomainAsync(mediator, _logger, stoppingToken);
consumer.StoreOffset(consumeResult.Result);
// sw.Stop();
// consumeResult.SetProcessTime(sw.Elapsed.TotalMilliseconds);
}
catch (OperationCanceledException ex) when(stoppingToken.IsCancellationRequested)
{
_logger.LogError(ex,
"Error occurred executing {WorkItem}.", nameof(_connection));
if (stoppingToken.IsCancellationRequested)
{
throw;
}
}
catch (Exception ex)
{
_logger.LogError(ex,
"Error occurred executing {WorkItem}.", nameof(_connection));
}
}
consumer.Close();
_logger.LogWarning(
$"Stopping conusmer request has been raised => IsCancellationRequested={stoppingToken.IsCancellationRequested}");
}
private void HandleApplicationMessageReceivedAsync(RedisChannel channel, RedisValue value)
{
var consumeResult = new ConsumeMessageResult(_topics);
var message = new RedisMessage()
{
Payload = value,
Topic = channel
};
consumeResult.SetMessageAsync(message);
consumeResult.PublishToDomainAsync(_serviceProvider, _logger, CancellationToken.None);
}
public static bool TryConsumeMessage(this IConsumer <Ignore, string> consumer, int timeOut,
ConsumeMessageResult result, CancellationToken cancellationToken)
{
if (!TryConsume(consumer, timeOut, out var consumeResult, cancellationToken))
{
return(false);
}
result.SetMessageAsync(consumeResult);
return(true);
}
public static bool TryConsumeMessage(this IConsumer <Ignore, string> consumer, ConsumeMessageResult result,
ILogger logger, CancellationToken cancellationToken)
{
try
{
if (!TryConsume(consumer, cancellationToken, out var consumeResult))
{
return(false);
}
result.SetMessage(consumeResult, cancellationToken);
return(true);
}
catch (Exception e)
{
logger.LogCritical(e, $"Nike exception: {consumer.Name} has exception in TryConsumeMessage {e.Message}");
return(false);
}
}
