示例#1
0
        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");
            }
        }
        static 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)
            {
                acao.UltimaAtualizacao = DateTime.Now;
                var dbRedis = _conexaoRedis.GetDatabase();
                dbRedis.StringSet(
                    "ACAO-" + acao.Codigo,
                    JsonSerializer.Serialize(acao),
                    expiry: null);

                _logger.Information("Ação registrada com sucesso!");
            }
            else
            {
                _logger.Error("Dados inválidos para a Ação");
            }

            await _subscriptionClient.CompleteAsync(
                message.SystemProperties.LockToken);
        }
示例#4
0
        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(
            [RabbitMQTrigger("queue-acoes", ConnectionStringSetting = "RabbitMQConnection")] string inputMessage,
            ILogger log)
        {
            log.LogInformation($"ProcessarAcoes - Dados: {inputMessage}");

            DadosAcao dadosAcao = null;

            try
            {
                dadosAcao = JsonSerializer.Deserialize <DadosAcao>(inputMessage,
                                                                   new JsonSerializerOptions()
                {
                    PropertyNameCaseInsensitive = true
                });
            }
            catch
            {
                log.LogError("ProcessarAcoes - Erro durante a deserializacao!");
            }

            if (dadosAcao != null)
            {
                var validationResult = new AcaoValidator().Validate(dadosAcao);
                if (validationResult.IsValid)
                {
                    log.LogInformation($"ProcessarAcoes - Dados pos formatacao: {JsonSerializer.Serialize(dadosAcao)}");

                    _context.Acoes.Add(new Acao()
                    {
                        Codigo         = dadosAcao.Codigo,
                        DataReferencia = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
                        Valor          = dadosAcao.Valor.Value
                    });
                    _context.SaveChanges();

                    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}");
                    }
                }
            }
        }
示例#7
0
        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}");
                    }
                }
            }
        }
示例#8
0
        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 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}");
                    }
                }
            }
        }
示例#12
0
        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("|")
            }));
        }
示例#13
0
        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");

            var conexaoRedis =
                ConnectionMultiplexer.Connect(configuration["BaseCotacoes"]);

            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}-redis",
                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
                    {
                        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)
                            {
                                acao.UltimaAtualizacao = DateTime.Now;
                                var dbRedis = conexaoRedis.GetDatabase();
                                dbRedis.StringSet(
                                    "ACAO-" + acao.Codigo,
                                    JsonSerializer.Serialize(acao),
                                    expiry: null);

                                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}");
            }
        }