public MessagingSubscriberOptionsBuilder(MessagingSubscriberOptions options = null)
{
Options = new MessagingSubscriberOptions();
if (options != null)
{
Options.ConsumerType = options.ConsumerType;
}
var serDesBuilder = new MessageSerDesOptionsBuilder(options?.SerDes);
Options.SerDes = serDesBuilder.Options;
}
public MessageBusSubscriberService(
IMessageBusSubscriber <TMessage> messageBusSubscriber,
IServiceProvider serviceProvider,
MessagingContextAccessor messagingContextAccessor,
ILogger <MessageBusSubscriberService <TMessage> > logger,
MessagingSubscriberOptions subscriberOptions = null
)
{
_subscriberOptions = subscriberOptions;
_messageBusSubscriber = messageBusSubscriber;
_serviceProvider = serviceProvider;
_messagingContextAccessor = messagingContextAccessor;
_logger = logger;
}
public async Task <HostedSubscription> SubscribeAsync(PipelineDelegate <MessagingContext> pipeline,
MessagingSubscriberOptions options = null,
CancellationToken cancellationToken = default)
{
var topicName = _topicRegistry.GetTopicForName(options?.TopicName, false) ??
_topicRegistry.GetTopicForMessageType(typeof(TMessage), false);
Task HandleMsg(MessagingEnvelope <TMessage> msg) => _executionMonitor.Handle(() => Handle(msg, topicName, pipeline, cancellationToken));
_logger.LogInformation("Messaging subscriber for topic {TopicName} is starting", topicName);
var subscription = await _messageBus.SubscribeAsync <TMessage>(HandleMsg, options, cancellationToken);
return(new HostedSubscription(subscription, topicName, _logger));
}
public MessagingTopicSubscriberService(
string topic,
IMessageSerDes messageSerDes,
IMessagingTopicSubscriber messagingTopicSubscriber,
IServiceProvider serviceProvider,
MessagingContextAccessor messagingContextAccessor,
ITopicRegistry topicRegistry,
ILogger <MessagingTopicSubscriberService> logger,
MessagingSubscriberOptions subscriberOptions = null)
{
_messagingTopicSubscriber = messagingTopicSubscriber;
_serviceProvider = serviceProvider;
_messagingContextAccessor = messagingContextAccessor;
_messageSerDes = messageSerDes;
_logger = logger;
_subscriberOptions = subscriberOptions;
_topic = topicRegistry.GetTopicForName(topic);
}
public Task SubscribeAsync(string topicName, Func <string, Task> handler, CancellationToken cancellationToken = default, MessagingSubscriberOptions options = null)
{
if (!_subscribedToTopic)
{
lock (lockObj)
{
if (!_subscribedToTopic)
{
_subscribedToTopic = true;
_subscriberOptions = options ?? new MessagingSubscriberOptions();
_consumer = GetConsumer();
return(SubscribeToTopicAsync(topicName, handler, cancellationToken));
}
}
}
throw new Exception("Already subscribed to this topic: " + topicName);
}
public MessagingEventStoreSubscriber(IMessageBusSubscriber <IEvent> messageBusSubscriber, MessagingTopicResolver messagingTopicResolver, MessagingSubscriberOptions subscriberOptions)
{
_messageBusSubscriber = messageBusSubscriber;
_messagingTopicResolver = messagingTopicResolver;
_subscriberOptions = subscriberOptions;
}
private Task SubscribeToTopicAsync(string subject, Func <string, Task> handler, CancellationToken cancellationToken = default, MessagingSubscriberOptions options = null)
{
var opts = StanSubscriptionOptions.GetDefaultOptions();
opts.DurableName = _configuration.GetSection("Messaging").GetSection("Nats")["durableName"];
var qGroup = _configuration.GetSection("Messaging").GetSection("Nats")["qGroup"];
var subscriberOptions = options ?? new MessagingSubscriberOptions();
opts.ManualAcks = subscriberOptions.AcknowledgeStrategy != MessagingAcknowledgeStrategy.Auto;
//https://github.com/nats-io/go-nats-streaming#subscriber-rate-limiting
opts.MaxInflight = subscriberOptions.MaxInFlight;
opts.AckWait = _configuration.GetSection("Messaging").GetSection("Nats").GetValue <int?>("ackWait") ?? 50000;
void StanMsgHandler(object obj, StanMsgHandlerArgs args)
{
_logger.LogDebug("Nats subscriber {QGroup} received message from subject {Subject}", qGroup,
subject);
var json = System.Text.Encoding.UTF8.GetString(args.Message.Data);
async Task Handler()
{
try {
await handler(json);
if (subscriberOptions.AcknowledgeStrategy == MessagingAcknowledgeStrategy.Manual)
{
args.Message.Ack();
}
}
catch (Exception ex)
{
_logger.LogError(
"Nats consumer {QGroup} encountered an error when handling a message from subject {Subject}.\n {Error}",
qGroup, subject, ex);
}
}
if (subscriberOptions.HandlerStrategy == MessagingHandlerStrategy.Serial)
{
Handler().Wait(cancellationToken);
}
else
{
Task.Run(Handler, cancellationToken);
}
}
_stanConnectionManager.Execute(stanConnection =>
{
var _ = subscriberOptions.ConsumerType == MessagingConsumerType.CollaborativeConsumer
? stanConnection.Subscribe(subject, opts, StanMsgHandler)
: stanConnection.Subscribe(subject, qGroup, opts, StanMsgHandler);
});
return(Task.CompletedTask);
}
public Task SubscribeAsync(string topic, Func <string, Task> handler, CancellationToken cancellationToken = default, MessagingSubscriberOptions options = null)
{
if (!_subscribedToTopic)
{
lock (lockObj)
{
if (!_subscribedToTopic)
{
_subscribedToTopic = true;
return(SubscribeToTopicAsync(topic, handler, cancellationToken, options));
}
}
}
return(Task.CompletedTask);
}
