/// <summary>
/// Esse método apenas redireciona uma mensagem para outro tópico.
/// </summary>
public static TopicConsumer <TKey, TValue> GetTopicConsumerWithRedirectMessage <TKey, TValue>(
IConsumerClient <TKey, TValue> client,
ConsumerConnectionBuilder <TKey, TValue> cb,
IServiceBusLogger logger
)
{
var producerSender = GetResendProducerSender(cb, logger);
// Cria o consumidor
var consumer = cb.Build();
var consumerConfig = cb.GetConsumerConfig();
var redirect = new RedirectConsumerClient <TKey, TValue>(
cb.RetryTopic,
cb.Delay,
client,
producerSender,
logger
);
return(new TopicConsumer <TKey, TValue>(
cb.Topic,
consumerConfig,
consumer,
redirect,
logger
));
}
public AzureConsumerTransport(AzureClientFactory clientFactory, IAzureTopologyBuilder topologyBuilder, IServiceBus serviceBus, IServiceBusLogger logger)
{
_client = clientFactory;
_topology = topologyBuilder;
_bus = serviceBus;
_logger = logger;
}
public static TopicConsumer <TKey, TValue> GetTopicConsumerWithRetry <TKey, TValue>(
IConsumerClient <TKey, TValue> client,
ConsumerConnectionBuilder <TKey, TValue> cb,
IServiceBusLogger logger
)
{
var producerSender = GetResendProducerSender(cb, logger);
// Cria o consumidor
var consumer = cb.Build();
var consumerConfig = cb.GetConsumerConfig();
var retryConsumerClient = new RetryConsumerClient <TKey, TValue>(
cb.RetryTopic,
consumerConfig.GroupId, // Deve ser, obrigatoriamente, o mesmo groupId do tópico original
cb.Delay,
client,
producerSender,
logger
);
return(new TopicConsumer <TKey, TValue>(
cb.Topic,
consumerConfig,
consumer,
retryConsumerClient,
logger
));
}
public IActionResult Subscribe(
string appName,
bool simulateError,
[FromBody] ConsumerOptions settings,
[FromServices] IServiceBusLogger loggerServiceBus,
[FromServices] ILogger <SignalRConsumerClient> loggerSignalR
)
{
if (!subscribersCancels.ContainsKey(appName))
{
TopicConsumer <Guid, EventMessage> topicConsumer;
var cancelSource = new CancellationTokenSource();
var builder = new ConsumerConnectionBuilder <Guid, EventMessage>(settings.IgnoreSsl ? null : this._appConfiguration.Kafka.CertificatePath);
builder.WithBrokers(settings.BootstrapServers);
builder.WithTopic(settings.Topic);
builder.WithGroupId(settings.GroupId);
builder.WithRetry(settings.RetryTopic, settings.Delay);
builder.AutoOffSetReset(settings.AutoOffSetReset);
builder.EnableAutoCommit(settings.EnableAutoCommit);
builder.EnablePartitionEof(settings.EnablePartitionEof);
//builder.MaxPollIntervalMs(settings.MaxPollIntervalMs);
builder.WithJsonSerializer();
var appInfo = new AppInfo
{
AppName = appName,
CancellationToken = cancelSource,
SimulateError = simulateError,
Settings = settings
};
var client = new SignalRConsumerClient(appInfo, _kafkaHubContext, loggerSignalR);
switch (settings.RetryStrategy)
{
case "retry":
topicConsumer = TopicFactory.GetTopicConsumerWithRetry(client, builder, loggerServiceBus);
break;
case "redirect":
topicConsumer = TopicFactory.GetTopicConsumerWithRedirectMessage(client, builder, loggerServiceBus);
break;
default: // Only consume
topicConsumer = TopicFactory.GetTopicConsumer(client, builder, loggerServiceBus);
break;
}
var task = topicConsumer.Run(cancelSource.Token);
appInfo.TaskId = task.Id;
subscribersCancels.TryAdd(appName, appInfo);
return(Ok(appInfo));
}
return(Ok(subscribersCancels[appName]));
}
public ProducerAsyncSender(
IProducer <TKey, TValue> producer,
IProducerClient <TKey, TValue> producerClient,
IServiceBusLogger logger)
{
this.producer = producer;
this.producerClient = producerClient;
this.logger = logger;
}
// 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;
}
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);
}
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;
}
public async void Send(
[FromBody] PublisherRequest request,
[FromServices] IServiceBusLogger logger
)
{
// Set message properties
request.Message.Id = Guid.NewGuid();
request.Message.SendDate = DateTime.Now;
// Create producer
var builder = new ProducerConnectionBuilder <Guid, EventMessage>(request.Settings.IgnoreSsl ? null :this._appConfiguration.Kafka.CertificatePath);
var producer = builder
.WithBootstrapServers(request.Settings.BootstrapServers)
.WithAsyncProducer()
.WithJsonSerializer()
.Build();
var producerSender = new ProducerAsyncSender <Guid, EventMessage>(
producer,
null,
logger
);
await producerSender.SendAsync(request.Message.Id, request.Message, request.Settings.Topic);
}
public PublisherDefaultLoggingPipeline(IServiceBusLogger logger, IPublisherPipeline pipeline)
{
_logger = logger;
_pipeline = pipeline;
}
public PublisherLoggingPipelineFactory(IServiceBusLogger logger)
{
_logger = logger;
}
public ConsumerDefaultLoggingPipeline(IServiceBusLogger logger, IConsumerPipeline pipeline)
{
_logger = logger;
_pipeline = pipeline;
}
public ConsumerLoggingPipelineFactory(IServiceBusLogger logger)
{
_logger = logger;
}
private static ProducerSyncSender <TKey, TValue> GetResendProducerSender <TKey, TValue>(ConsumerConnectionBuilder <TKey, TValue> cb, IServiceBusLogger logger)
{
// Cria o produtor com o mesmo endereço do consumidor (isso pode melhorar)
var produtorBuilder = new ProducerConnectionBuilder <TKey, TValue>(cb.CaPath);
var producer = produtorBuilder
.WithBootstrapServers(cb.GetConsumerConfig().BootstrapServers)
.WithAsyncProducer()
.WithJsonSerializer()
.Build();
var producerSender = new ProducerSyncSender <TKey, TValue>(producer, new NullProducerClient <TKey, TValue>(logger), logger);
return(producerSender);
}
public NullProducerClient(IServiceBusLogger logger)
{
this.logger = logger;
}
