public MessageConsumer(
IConsumerClient consumerClient,
IConsumerWorkerPool workerPool,
ConsumerSetting configuration,
ILogHandler logHandler)
{
this.workerPool = workerPool;
this.configuration = configuration;
this.logHandler = logHandler;
this.consumerClient = consumerClient;
}
/// <summary>
/// Initializes a new instance of the <see cref="EventBusHostedService"/> class.
/// </summary>
/// <param name="consumerClientFactory">The consumer client factory.</param>
/// <param name="subscribers">The subscribers.</param>
/// <param name="transportOptions">The transport options.</param>
/// <exception cref="ArgumentNullException">subscribers</exception>
public EventBusHostedService(
IConsumerClientFactory consumerClientFactory,
IEnumerable <ISubscriber> subscribers,
IOptions <TransportOptions> transportOptions)
{
_subscribers = subscribers ?? throw new ArgumentNullException(nameof(subscribers));
_options = transportOptions.Value;
//TODO think groups id
_consumerClient = consumerClientFactory.Create("group_1");
}
/// <summary>
/// Initializes a new instance of the <see cref="EventBusHostedService"/> class.
/// </summary>
/// <param name="consumerClientFactory">The consumer client factory.</param>
/// <param name="subscribers">The subscribers.</param>
/// <param name="transportOptions">The transport options.</param>
/// <exception cref="ArgumentNullException">subscribers</exception>
public EventBusHostedService(
IConsumerClientFactory consumerClientFactory,
IServiceScopeFactory serviceScopeFactory,
IOptions <TransportOptions> transportOptions)
{
_serviceScopeFactory = serviceScopeFactory ?? throw new ArgumentNullException(nameof(serviceScopeFactory));
_options = transportOptions.Value;
//TODO think groups id
_consumerClient = consumerClientFactory.Create(_options.DefaultGroup);
}
private void RegisterMessageProcessor(IConsumerClient client)
{
client.MessageReceieved += (sender, message) =>
{
try
{
var receive = message.Content.ToModel <ReceivedMessage>();
try
{
if (receive.ExpiresAt > expiresTime && receive.ExpiresAt < DateTime.Now)
{
//超时未消费队列
Log.Warn(new LogFormat(message.ToJson(), "rabbitmq", "consumer", "overtime", 500, 0, "", "", ""));
}
else
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
try
{
StoreMessage(message, receive); //抛出异常 进入重试机制
stopwatch.Stop();
Log.Info(new LogFormat(message.ToJson(), "rabbitmq", "consumer", "queue", 200, stopwatch.ElapsedMilliseconds.ConvertToIntSafe(), "", "", ""));
}
catch (Exception ex)
{
stopwatch.Stop();
Log.Error(new LogFormat(message.ToJson(), "rabbitmq", "consumer", "error", 500, stopwatch.ElapsedMilliseconds.ConvertToIntSafe(), ex.ToString(), "", ""));
throw ex;
}
}
}
catch
{
if (receive.Retries > 0) //重试
{
receive.Retries -= 1;
PublishQueueFactory.factory.PublishAsync(message.Name, receive.ToJson());
}
else
{
//失败队列记录
Log.Warn(new LogFormat(message.ToJson(), "rabbitmq", "consumer", "overtime", 500, 0, "", "", ""));
}
}
client.Commit();
}
catch { }
};
}
private void RegisterMessageProcessor(IConsumerClient client)
{
client.MessageReceieved += (sender, message) =>
{
try
{
var receive = message.Content.ToModel <ReceivedMessage>();
try
{
if (receive.ExpiresAt > expiresTime && receive.ExpiresAt < DateTime.Now)
{
//超时未消费队列
Log.Info(LogFormat.Record("RabbitmqOvertime", 0, DateTime.Now, message));
}
else
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
try
{
StoreMessage(message, receive); //抛出异常 进入重试机制
stopwatch.Stop();
Log.Info(LogFormat.Record("RabbitmqQueue", stopwatch.ElapsedMilliseconds, DateTime.Now, message));
}
catch (Exception ex)
{
stopwatch.Stop();
Log.Info(LogFormat.Record("RabbitmqQueueException", stopwatch.ElapsedMilliseconds, DateTime.Now, new { message = message, ex = ex.ToString() }));
throw ex;
}
}
}
catch
{
if (receive.Retries > 0) //重试
{
receive.Retries -= 1;
PublishQueueFactory.factory.PublishAsync(message.Name, receive.ToJson());
}
else
{
//失败队列记录
Log.Warn(LogFormat.Record("RabbitmqQueueFail", 0, DateTime.Now, message));
}
}
client.Commit();
}
catch { }
};
}
// DUVIDA: é necessário obter o groupId
public TopicConsumer(
string topicName,
ConsumerConfig config,
IConsumer <TKey, TValue> consumer,
IConsumerClient <TKey, TValue> consumerClient,
IServiceBusLogger logger
)
{
this.topicName = topicName;
this.config = config;
this.consumer = consumer;
this.consumerClient = consumerClient;
this.logger = logger;
}
public RedirectConsumerClient(
string redirectTopic,
int delay,
IConsumerClient <TKey, TValue> consumerClient,
IProducerSender <TKey, TValue> retrySender,
IServiceBusLogger logger
)
{
this.redirectTopic = redirectTopic;
this.delay = delay;
this.consumerClient = consumerClient;
this.retrySender = retrySender;
this.logger = logger;
}
private void RegisterMessageProcessor(IConsumerClient client)
{
client.MessageReceieved += (sender, message) =>
{
_logger.EnqueuingReceivedMessage(message.Name, message.Content);
using (var scope = _serviceProvider.CreateScope())
{
var receviedMessage = StoreMessage(scope, message);
client.Commit();
}
Pulse();
};
}
public KafkaBus2(
IDependencyResolver dependencyResolver,
IConsumerManager consumerManager,
IProducerAccessor accessor,
IConfiguration config,
IConsumerClient ConsumerClient,
ILogHandler logHandler)
{
this.dependencyResolver = dependencyResolver;
this.consumerManager = consumerManager;
this.logHandler = logHandler;
this.Producers = accessor;
this.config = config;
this.ConsumerClient = ConsumerClient;
}
//private ConsumerSetting configuration;
public MessageContextConsumer(
IConsumerClient consumerClient,
IOffsetManager offsetManager,
IntermediateMessage kafkaResult,
CancellationToken workerStopped)
{
//this.configuration = configuration;
if (consumerClient != null)
{
this.Name = consumerClient.ConsumerName;
}
this.WorkerStopped = workerStopped;
this.consumerClient = consumerClient;
this.offsetManager = offsetManager;
this.kafkaResult = kafkaResult;
}
public ConsumerWorker(
IConsumerClient consumerClient,
int workerId,
ConsumerSetting configuration,
IOffsetManager offsetManager,
ILogHandler logHandler,
IMiddlewareExecutor middlewareExecutor)
{
this.Id = workerId;
this.consumerClient = consumerClient;
this.configuration = configuration;
this.offsetManager = offsetManager;
this.logHandler = logHandler;
this.middlewareExecutor = middlewareExecutor;
this.messagesBuffer = Channel.CreateBounded <IntermediateMessage>(configuration.BufferSize);
}
private void RegisterMessageProcessor(IConsumerClient client, IConsumerSubscriber subscriber)
{
client.OnMessageReceived += async(sender, transportMessage) =>
{
Message message = null;
try
{
try
{
message = await _serializer.DeserializeAsync(transportMessage, subscriber.GetMessageType());
var context = new ConsumerContext(client.HostAddress, subscriber.ClientOption, message, transportMessage);
await _consumerReceiveFilter.OnSubscriberInvokingAsync(context);
if (message.Body is null)
{
throw new MessageBodyNullException();
}
await subscriber.Invoke(message);
}
catch (Exception e)
{
throw new SubscriberInvokeException(e);
}
client.Commit(sender);
}
catch (Exception e)
{
var context = new ExceptionConsumerContext(client.HostAddress, subscriber.ClientOption, message, transportMessage, e);
await _consumerReceiveFilter.OnSubscriberExceptionAsync(context);
if (subscriber.CommitIfAnyException)
{
client.Commit(sender);
}
else
{
client.Reject(sender);
}
}
};
client.OnLog += WriteLog;
}
public static TopicConsumer <TKey, TValue> GetTopicConsumer <TKey, TValue>(
IConsumerClient <TKey, TValue> client,
ConsumerConnectionBuilder <TKey, TValue> cb,
IServiceBusLogger logger
)
{
var consumer = cb.Build();
var topicConsumer = new TopicConsumer <TKey, TValue>(
cb.Topic,
cb.GetConsumerConfig(),
consumer,
client,
logger
);
return(topicConsumer);
}
private void RegisterMessageProcessor(IConsumerClient client)
{
client.OnMessageReceived += (sender, messageContext) =>
{
_cts.Token.ThrowIfCancellationRequested();
var startTime = DateTimeOffset.UtcNow;
var stopwatch = Stopwatch.StartNew();
var tracingResult = TracingBefore(messageContext.Name, messageContext.Content);
var operationId = tracingResult.Item1;
var messageBody = tracingResult.Item2;
var receivedMessage = new CapReceivedMessage(messageContext)
{
Id = SnowflakeId.Default().NextId(),
StatusName = StatusName.Scheduled,
Content = messageBody
};
try
{
StoreMessage(receivedMessage);
client.Commit();
TracingAfter(operationId, receivedMessage.Name, receivedMessage.Content, startTime,
stopwatch.Elapsed);
_dispatcher.EnqueueToExecute(receivedMessage);
}
catch (Exception e)
{
_logger.LogError(e, "An exception occurred when store received message. Message:'{0}'.", messageContext);
client.Reject();
TracingError(operationId, receivedMessage.Name, receivedMessage.Content, e, startTime,
stopwatch.Elapsed);
}
};
client.OnLog += WriteLog;
}
public RetryConsumerClient(
string retryTopic,
string groupId,
int delay,
IConsumerClient <TKey, TValue> consumerClient,
IProducerSender <TKey, TValue> retrySender,
IServiceBusLogger logger
)
{
// DUVIDA: não entendi o uso dessa variavel
this.consumed = 0;
this.retryTopic = retryTopic;
this.groupId = groupId;
this.delay = delay;
this.consumerClient = consumerClient;
this.retrySender = retrySender;
this.logger = logger;
}
private void RegisterMessageProcessor(IConsumerClient client)
{
client.OnMessageReceived += (sender, message) =>
{
_logger.EnqueuingReceivedMessage(message.Name, message.Content);
using (var scope = _serviceProvider.CreateScope())
{
try
{
StoreMessage(scope, message);
client.Commit();
}
catch (Exception e)
{
_logger.LogError(e, "An exception occurred when storage received message. Message:'{0}'.", message);
client.Reject();
}
}
Pulse();
};
client.OnLog += WriteLog;
}
/// <summary>
/// Initializes a new instance of the <see cref="HandleContext"/> class.
/// </summary>
/// <param name="consumerClient">The consumer client.</param>
/// <param name="headers">The headers.</param>
/// <exception cref="ArgumentNullException">consumerClient</exception>
public HandleContext(IConsumerClient consumerClient, TransportMessage message)
{
_consumerClient = consumerClient ?? throw new ArgumentNullException(nameof(consumerClient));
MessageContext = new MessageContext(message);
}
private void RegisterMessageProcessor(IConsumerClient client)
{
// Cannot set subscription to asynchronous
client.OnMessageReceived += (sender, transportMessage) =>
{
_logger.MessageReceived(transportMessage.GetId(), transportMessage.GetName());
long?tracingTimestamp = null;
try
{
tracingTimestamp = TracingBefore(transportMessage, _serverAddress);
var name = transportMessage.GetName();
var group = transportMessage.GetGroup();
Message message;
var canFindSubscriber = _selector.TryGetTopicExecutor(name, group, out var executor);
try
{
if (!canFindSubscriber)
{
var error = $"Message can not be found subscriber. Name:{name}, Group:{group}. {Environment.NewLine} see: https://github.com/dotnetcore/CAP/issues/63";
var ex = new SubscriberNotFoundException(error);
TracingError(tracingTimestamp, transportMessage, client.BrokerAddress, ex);
throw ex;
}
var type = executor.Parameters.FirstOrDefault(x => x.IsFromCap == false)?.ParameterType;
message = _serializer.DeserializeAsync(transportMessage, type).GetAwaiter().GetResult();
message.RemoveException();
}
catch (Exception e)
{
transportMessage.Headers[Headers.Exception] = e.GetType().Name + "-->" + e.Message;
if (transportMessage.Headers.TryGetValue(Headers.Type, out var val))
{
var dataUri = $"data:{val};base64," + Convert.ToBase64String(transportMessage.Body);
message = new Message(transportMessage.Headers, dataUri);
}
else
{
var dataUri = "data:UnknownType;base64," + Convert.ToBase64String(transportMessage.Body);
message = new Message(transportMessage.Headers, dataUri);
}
}
if (message.HasException())
{
var content = _serializer.Serialize(message);
_storage.StoreReceivedExceptionMessage(name, group, content);
client.Commit(sender);
try
{
_options.FailedThresholdCallback?.Invoke(new FailedInfo
{
ServiceProvider = _serviceProvider,
MessageType = MessageType.Subscribe,
Message = message
});
_logger.ConsumerExecutedAfterThreshold(message.GetId(), _options.FailedRetryCount);
}
catch (Exception e)
{
_logger.ExecutedThresholdCallbackFailed(e);
}
TracingAfter(tracingTimestamp, transportMessage, _serverAddress);
}
else
{
var mediumMessage = _storage.StoreReceivedMessage(name, group, message);
mediumMessage.Origin = message;
client.Commit(sender);
TracingAfter(tracingTimestamp, transportMessage, _serverAddress);
_dispatcher.EnqueueToExecute(mediumMessage, executor);
}
}
catch (Exception e)
{
_logger.LogError(e, "An exception occurred when process received message. Message:'{0}'.", transportMessage);
client.Reject(sender);
TracingError(tracingTimestamp, transportMessage, client.BrokerAddress, e);
}
};
client.OnLog += WriteLog;
}
public ConsumerConnectionBuilder <TKey, TValue> WithAutoCommits(IConsumerClient <TKey, TValue> consumerClient)
{
consumerBuilder.SetOffsetsCommittedHandler((consumer, offset) => consumerClient.AutoCommited(offset));
return(this);
}
private void RegisterMessageProcessor(IConsumerClient client)
{
client.OnMessageReceived += async delegate(object sender, TransportMessage transportMessage)
{
long?tracingTimestamp = null;
try
{
tracingTimestamp = TracingBefore(transportMessage, _serverAddress);
string name = transportMessage.GetName();
string group = transportMessage.GetGroup();
ConsumerExecutorDescriptor executor;
bool canFindSubscriber = _selector.TryGetTopicExecutor(name, group, out executor);
Message message;
try
{
if (!canFindSubscriber)
{
SubscriberNotFoundException ex = new SubscriberNotFoundException("Message can not be found subscriber. Name:" + name + ", Group:" + group + ". " + " see: https://github.com/dotnetcore/CAP/issues/63");
TracingError(tracingTimestamp, transportMessage, client.BrokerAddress, ex);
throw ex;
}
Type type = Enumerable.FirstOrDefault <ParameterDescriptor>((IEnumerable <ParameterDescriptor>)executor.Parameters, (Func <ParameterDescriptor, bool>)((ParameterDescriptor x) => !x.IsFromCap))?.ParameterType;
message = await _serializer.DeserializeAsync(transportMessage, type);
message.RemoveException();
}
catch (Exception e3)
{
transportMessage.Headers.Add("cap-exception", "SerializationException-->" + e3.Message);
if (transportMessage.Headers.TryGetValue("cap-msg-type", out var val))
{
string dataUri2 = "data:" + val + ";base64," + Convert.ToBase64String(transportMessage.Body);
message = new Message(transportMessage.Headers, dataUri2);
}
else
{
string dataUri = "data:UnknownType;base64," + Convert.ToBase64String(transportMessage.Body);
message = new Message(transportMessage.Headers, dataUri);
}
}
if (message.HasException())
{
string content = _serializer.Serialize(message);
_storage.StoreReceivedExceptionMessage(name, group, content);
client.Commit(sender);
try
{
_options.FailedThresholdCallback?.Invoke(new FailedInfo
{
ServiceProvider = _serviceProvider,
MessageType = MessageType.Subscribe,
Message = message
});
}
catch (Exception e2)
{
}
TracingAfter(tracingTimestamp, transportMessage, _serverAddress);
}
else
{
MediumMessage mediumMessage = _storage.StoreReceivedMessage(name, group, message);
mediumMessage.Origin = message;
TracingAfter(tracingTimestamp, transportMessage, _serverAddress);
_dispatcher.EnqueueToExecute(mediumMessage, executor);
client.Commit(sender);
}
}
catch (Exception e)
{
_logger.LogError(e, "An exception occurred when process received message. Message:'{0}'.", transportMessage);
client.Reject(sender);
TracingError(tracingTimestamp, transportMessage, client.BrokerAddress, e);
}
};
client.OnLog += WriteLog;
}
/// <summary>
/// Initializes a new instance of the <see cref="HandleContext"/> class.
/// </summary>
/// <param name="consumerClient">The consumer client.</param>
/// <param name="headers">The headers.</param>
/// <exception cref="ArgumentNullException">consumerClient</exception>
public HandleContext(IConsumerClient consumerClient, IDictionary <string, string> headers)
{
_consumerClient = consumerClient ?? throw new ArgumentNullException(nameof(consumerClient));
MessageContext = new MessageContext(headers);
}
private void RegisterMessageProcessor(IConsumerClient client)
{
client.OnMessageReceived += async(sender, transportMessage) =>
{
_logger.MessageReceived(transportMessage.GetId(), transportMessage.GetName());
long?tracingTimestamp = null;
try
{
tracingTimestamp = TracingBefore(transportMessage, _serverAddress);
var name = transportMessage.GetName();
var group = transportMessage.GetGroup();
Message message;
var canFindSubscriber = _selector.TryGetTopicExecutor(name, group, out var executor);
try
{
if (!canFindSubscriber)
{
var error = $"Message can not be found subscriber. Name:{name}, Group:{group}. {Environment.NewLine} see: https://github.com/dotnetcore/CAP/issues/63";
var ex = new SubscriberNotFoundException(error);
TracingError(tracingTimestamp, transportMessage, client.BrokerAddress, ex);
throw ex;
}
var type = executor.Parameters.FirstOrDefault(x => x.IsFromCap == false)?.ParameterType;
message = await _serializer.DeserializeAsync(transportMessage, type);
}
catch (Exception e)
{
transportMessage.Headers.Add(Headers.Exception, nameof(SerializationException) + "-->" + e.Message);
var dataUri = $"data:{transportMessage.Headers[Headers.Type]};base64," + Convert.ToBase64String(transportMessage.Body);
message = new Message(transportMessage.Headers, dataUri);
}
if (message.HasException())
{
var content = StringSerializer.Serialize(message);
_storage.StoreReceivedExceptionMessage(name, group, content);
client.Commit(sender);
TracingAfter(tracingTimestamp, transportMessage, _serverAddress);
}
else
{
var mediumMessage = _storage.StoreReceivedMessage(name, group, message);
mediumMessage.Origin = message;
client.Commit(sender);
TracingAfter(tracingTimestamp, transportMessage, _serverAddress);
_dispatcher.EnqueueToExecute(mediumMessage, executor);
}
}
catch (Exception e)
{
_logger.LogError(e, "An exception occurred when process received message. Message:'{0}'.", transportMessage);
client.Reject(sender);
TracingError(tracingTimestamp, transportMessage, client.BrokerAddress, e);
}
};
client.OnLog += WriteLog;
}
public EventHubReaderService(BoundedMessageChannel <BusMessage> boundedMessageChannel,
IConsumerClient <BusMessage> consumer)
{
_consumer = consumer;
_boundedMessageChannel = boundedMessageChannel;
}
