public static void Run([KafkaTrigger(
"KafkaConnection", "topic-acoes",
ConsumerGroup = "topic-acoes-mongo")] KafkaEventData <string> kafkaEvent,
ILogger log)
{
string dados = kafkaEvent.Value.ToString();
log.LogInformation($"KafkaAcoesTopicTrigger - Dados: {dados}");
var acao = JsonSerializer.Deserialize <Acao>(dados,
new JsonSerializerOptions()
{
PropertyNameCaseInsensitive = true
});
var validationResult = new AcaoValidator().Validate(acao);
if (validationResult.IsValid)
{
log.LogInformation($"KafkaAcoesTopicTrigger - Dados pós formatação: {JsonSerializer.Serialize(acao)}");
AcoesRepository.Save(acao);
log.LogInformation("KafkaAcoesTopicTrigger - Ação registrada com sucesso!");
}
else
{
log.LogInformation("KafkaAcoesTopicTrigger - Dados inválidos para a Ação");
}
}
public static void Run([ServiceBusTrigger("topic-acoes",
"FunctionAppAcoesSqlServer",
Connection = "AzureServiceBusConnection")] string mySbMsg,
ILogger log)
{
log.LogInformation($"AcoesServiceBusTopicTrigger - Dados: {mySbMsg}");
var acao = JsonSerializer.Deserialize <DadosAcao>(mySbMsg,
new JsonSerializerOptions()
{
PropertyNameCaseInsensitive = true
});
var validationResult = new AcaoValidator().Validate(acao);
if (validationResult.IsValid)
{
log.LogInformation($"AcoesServiceBusTopicTrigger - Dados pós formatação: {mySbMsg}");
AcoesRepository.Save(acao);
log.LogInformation("AcoesServiceBusTopicTrigger - Ação registrada com sucesso!");
}
else
{
log.LogInformation("AcoesServiceBusTopicTrigger - Dados inválidos para a Ação");
}
}
private async Task ProcessMessagesAsync(Message message, CancellationToken token)
{
string dados = Encoding.UTF8.GetString(message.Body);
_logger.Information($"Mensagem recebida: {dados}");
var acao = JsonSerializer.Deserialize <Acao>(dados,
new JsonSerializerOptions()
{
PropertyNameCaseInsensitive = true
});
var validationResult = new AcaoValidator().Validate(acao);
if (validationResult.IsValid)
{
_repository.Save(acao);
_logger.Information("Ação registrada com sucesso!");
}
else
{
_logger.Error("Dados inválidos para a Ação");
}
await _subscriptionClient.CompleteAsync(
message.SystemProperties.LockToken);
}
public void Run([KafkaTrigger(
"BrokerKafka", "topic-acoes",
ConsumerGroup = "processar_acoes-sql",
Protocol = BrokerProtocol.SaslSsl,
AuthenticationMode = BrokerAuthenticationMode.Plain,
Username = "******",
Password = "******"
)] KafkaEventData <string> kafkaEvent,
ILogger log)
{
string dados = kafkaEvent.Value.ToString();
log.LogInformation($"ProcessarAcoesSql - Dados: {dados}");
Acao acao = null;
try
{
acao = JsonSerializer.Deserialize <Acao>(dados,
new JsonSerializerOptions()
{
PropertyNameCaseInsensitive = true
});
}
catch
{
log.LogError("ProcessarAcoesSql - Erro durante a deserializacao!");
}
if (acao != null)
{
var validationResult = new AcaoValidator().Validate(acao);
if (validationResult.IsValid)
{
log.LogInformation($"ProcessarAcoesSql - Dados pos formatacao: {JsonSerializer.Serialize(acao)}");
_repository.Save(acao);
log.LogInformation("ProcessarAcoesSql - Acao registrada com sucesso!");
}
else
{
log.LogError("ProcessarAcoesSql - Dados invalidos para a Acao");
foreach (var error in validationResult.Errors)
{
log.LogError($"ProcessarAcoesSql - {error.ErrorMessage}");
}
}
}
}
public void Run([KafkaTrigger(
"ApacheKafkaConnection", "topic-acoes",
ConsumerGroup = "processador-acoes-mongo")] KafkaEventData <string> kafkaEvent,
ILogger log)
{
string dados = kafkaEvent.Value.ToString();
log.LogInformation($"ProcessarAcoes - Dados: {dados}");
Acao acao = null;
try
{
acao = JsonSerializer.Deserialize <Acao>(dados,
new JsonSerializerOptions()
{
PropertyNameCaseInsensitive = true
});
}
catch
{
log.LogError("ProcessarAcoes - Erro durante a deserializacao!");
}
if (acao != null)
{
var validationResult = new AcaoValidator().Validate(acao);
if (validationResult.IsValid)
{
log.LogInformation($"ProcessarAcoes - Dados pos formatacao: {JsonSerializer.Serialize(acao)}");
_repository.Save(acao);
log.LogInformation("ProcessarAcoes - Acao registrada com sucesso!");
}
else
{
log.LogError("ProcessarAcoes - Dados invalidos para a Acao");
foreach (var error in validationResult.Errors)
{
log.LogError($"ProcessarAcoes - {error.ErrorMessage}");
}
}
}
}
private void ProcessarAcao(string dados)
{
Acao acao;
try
{
acao = JsonSerializer.Deserialize <Acao>(dados,
new JsonSerializerOptions()
{
PropertyNameCaseInsensitive = true
});
}
catch
{
acao = null;
}
var dadosValidos = acao is not null;
if (dadosValidos)
{
var validationResult = new AcaoValidator().Validate(acao);
dadosValidos = validationResult.IsValid;
if (!validationResult.IsValid)
{
validationResult.Errors.ToList().ForEach(f =>
_logger.LogError(f.ErrorMessage));
}
}
if (dadosValidos)
{
_repository.Save(acao);
_logger.LogInformation("Ação registrada com sucesso!");
}
else
{
_logger.LogError("Dados inválidos para a Ação");
}
}
public static void Run([KafkaTrigger(
"KafkaConnection", "topic-acoes",
ConsumerGroup = "topic-acoes-docdb")] KafkaEventData <string> kafkaEvent,
ILogger log)
{
string dados = kafkaEvent.Value.ToString();
log.LogInformation($"KafkaAcoesTopicTrigger 1 - Dados: {dados}");
var acao = JsonSerializer.Deserialize <Acao>(dados,
new JsonSerializerOptions()
{
PropertyNameCaseInsensitive = true
});
var validationResult = new AcaoValidator().Validate(acao);
if (validationResult.IsValid)
{
log.LogInformation($"KafkaAcoesTopicTrigger - Dados pós formatação: {JsonSerializer.Serialize(acao)}");
var eventTest = new KafkaEventData <string>(JsonSerializer.Serialize(acao));
try
{
AcoesRepository.Save(acao);
}
catch (System.Exception e)
{
throw e;
}
log.LogInformation("KafkaAcoesTopicTrigger - Ação registrada com sucesso!");
log.LogInformation("KafkaAcoesTopicTrigger - Executando próxima ação...");
KafkaAcoesTopicTrigger2.Run(eventTest, log);
}
else
{
log.LogInformation("KafkaAcoesTopicTrigger - Dados inválidos para a Ação");
}
}
public static void Run(
[RabbitMQTrigger("compra-acoes-queue", ConnectionStringSetting = "RabbitMQConnection")] string inputMessage,
ILogger log)
{
log.LogInformation($"CompraAcoesRabbitMQTrigger - Dados: {inputMessage}");
Transacao transacao = null;
try
{
transacao = JsonSerializer.Deserialize <Transacao>(inputMessage,
new JsonSerializerOptions()
{
PropertyNameCaseInsensitive = true
});
}
catch
{
log.LogInformation($"CompraAcoesRabbitMQTrigger - Erro durante a deserialização");
}
if (transacao == null)
{
return;
}
var validationResult = new TransacoesValidator().Validate(transacao);
if (validationResult.IsValid)
{
log.LogInformation($"CompraAcoesRabbitMQTrigger - Dados pós formatação: {JsonSerializer.Serialize(transacao)}");
AcoesRepository.Save <CompraAcaoDocument>(transacao);
log.LogInformation("CompraAcoesRabbitMQTrigger - Transação registrada com sucesso!");
}
else
{
log.LogInformation("CompraAcoesRabbitMQTrigger - Dados inválidos para a Transação");
}
}
public void Run([ServiceBusTrigger("topic-acoes", "mongo", Connection = "AzureServiceBus")] string mySbMsg, ILogger log)
{
log.LogInformation($"AcoesMongoServiceBusTopicTrigger - Dados: {mySbMsg}");
Acao acao = null;
try
{
acao = JsonSerializer.Deserialize <Acao>(mySbMsg,
new JsonSerializerOptions()
{
PropertyNameCaseInsensitive = true
});
}
catch
{
log.LogError("AcoesMongoServiceBusTopicTrigger - Erro durante a deserializacao!");
}
if (acao != null)
{
var validationResult = new AcaoValidator().Validate(acao);
if (validationResult.IsValid)
{
acao.UltimaAtualizacao = DateTime.Now;
log.LogInformation($"AcoesMongoServiceBusTopicTrigger - Dados pos formatacao: {JsonSerializer.Serialize(acao)}");
_repository.Save(acao);
log.LogInformation("AcoesMongoServiceBusTopicTrigger - Acao registrada com sucesso!");
}
else
{
log.LogError("AcoesMongoServiceBusTopicTrigger - Dados invalidos para a Acao");
foreach (var error in validationResult.Errors)
{
log.LogError($"AcoesMongoServiceBusTopicTrigger - {error.ErrorMessage}");
}
}
}
}
public void Run([QueueTrigger("queue-acoes", Connection = "AzureWebJobsStorage")] string myQueueItem, ILogger log)
{
log.LogInformation($"ProcessarAcoes - Dados: {myQueueItem}");
Acao acao = null;
try
{
acao = JsonSerializer.Deserialize <Acao>(myQueueItem,
new JsonSerializerOptions()
{
PropertyNameCaseInsensitive = true
});
}
catch
{
log.LogError("ProcessarAcoes - Erro durante a deserializacao!");
}
if (acao != null)
{
var validationResult = new AcaoValidator().Validate(acao);
if (validationResult.IsValid)
{
log.LogInformation($"ProcessarAcoes - Dados pos formatacao: {JsonSerializer.Serialize(acao)}");
_repository.Save(acao);
log.LogInformation("ProcessarAcoes - Acao registrada com sucesso!");
}
else
{
log.LogError("ProcessarAcoes - Dados invalidos para a Acao");
foreach (var error in validationResult.Errors)
{
log.LogError($"ProcessarAcoes - {error.ErrorMessage}");
}
}
}
}
private void ProcessarAcao(string dados)
{
Acao acao;
try
{
acao = JsonSerializer.Deserialize <Acao>(dados,
new JsonSerializerOptions()
{
PropertyNameCaseInsensitive = true
});
}
catch
{
acao = null;
}
if (acao is not null &&
new AcaoValidator().Validate(acao).IsValid)
{
_repository.Save(acao);
_logger.LogInformation("Ação registrada com sucesso!");
}
public override Task <AcaoReply> Registrar(AcaoRequest request, ServerCallContext context)
{
_logger.LogInformation(
$"Dados recebidos: {System.Text.Json.JsonSerializer.Serialize(request)}");
var validationResult = new AcaoValidator().Validate(request);
bool dadosValidos = validationResult.IsValid;
if (dadosValidos)
{
_repository.Save(request);
_logger.LogInformation("Dados de ação registrados com sucesso.");
}
else
{
_logger.LogInformation("Dados de ação inconsistentes!");
}
return(Task.FromResult(new AcaoReply
{
Sucesso = dadosValidos,
Descricao = dadosValidos ? "OK" : validationResult.ToString("|")
}));
}
public void Run()
{
_logger.Information("Testando o consumo de mensagens com Kafka");
string nomeTopic = _configuration["ApacheKafka:Topic"];
_logger.Information($"Topic = {nomeTopic}");
CancellationTokenSource cts = new ();
Console.CancelKeyPress += (_, e) =>
{
e.Cancel = true;
cts.Cancel();
};
try
{
using (var consumer = GetConsumerBuilder())
{
consumer.Subscribe(nomeTopic);
try
{
while (true)
{
var cr = consumer.Consume(cts.Token);
string dados = cr.Message.Value;
_logger.Information(
$"Mensagem lida: {dados}");
var acao = JsonSerializer.Deserialize <Acao>(dados,
new JsonSerializerOptions()
{
PropertyNameCaseInsensitive = true
});
var validationResult = new AcaoValidator().Validate(acao);
if (validationResult.IsValid)
{
_repository.Save(acao);
_logger.Information("Ação registrada com sucesso!");
}
else
{
_logger.Error("Dados inválidos para a Ação");
}
}
}
catch (OperationCanceledException)
{
consumer.Close();
_logger.Warning("Cancelada a execução do Consumer...");
}
}
}
catch (Exception ex)
{
_logger.Error($"Exceção: {ex.GetType().FullName} | " +
$"Mensagem: {ex.Message}");
}
}
static void Main(string[] args)
{
Console.WriteLine("Carregando configurações...");
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile($"appsettings.json");
var configuration = builder.Build();
var logger = new LoggerConfiguration()
.WriteTo.Console()
.CreateLogger();
logger.Information(
"Testando o consumo de mensagens com Kafka + MongoDB");
string bootstrapServers = configuration["Kafka_Broker"];
string nomeTopic = configuration["Kafka_Topic"];
logger.Information($"BootstrapServers = {bootstrapServers}");
logger.Information($"Topic = {nomeTopic}");
var config = new ConsumerConfig
{
BootstrapServers = bootstrapServers,
GroupId = $"{nomeTopic}-mongodb",
AutoOffsetReset = AutoOffsetReset.Earliest
};
CancellationTokenSource cts = new CancellationTokenSource();
Console.CancelKeyPress += (_, e) =>
{
e.Cancel = true;
cts.Cancel();
};
try
{
using (var consumer = new ConsumerBuilder <Ignore, string>(config).Build())
{
consumer.Subscribe(nomeTopic);
try
{
var repository = new AcoesRepository(configuration);
while (true)
{
var cr = consumer.Consume(cts.Token);
string dados = cr.Message.Value;
logger.Information(
$"Mensagem lida: {dados}");
var dadosAcao = JsonSerializer.Deserialize <DadosAcao>(dados,
new JsonSerializerOptions()
{
PropertyNameCaseInsensitive = true
});
var validationResult = new AcaoValidator().Validate(dadosAcao);
if (validationResult.IsValid)
{
repository.Save(dadosAcao);
logger.Information("Ação registrada com sucesso!");
}
else
{
logger.Error("Dados inválidos para a Ação");
}
}
}
catch (OperationCanceledException)
{
consumer.Close();
logger.Warning("Cancelada a execução do Consumer...");
}
}
}
catch (Exception ex)
{
logger.Error($"Exceção: {ex.GetType().FullName} | " +
$"Mensagem: {ex.Message}");
}
}