static void AddProducers(this IRiderRegistrationConfigurator rider)
 {
     rider.AddProducer <OrderFinishedIntegrationEvent>("order-finished"); // talvez deletar
     rider.AddProducer <OrderToManagerIntegrationEvent>(_kafkaConfiguration.OrdersToManager);
     rider.AddProducer <OrderCreatedIntegrationEvent>(_kafkaConfiguration.OrdersToProductsStockConfirmation);
     rider.AddProducer <OrderRollbackIntegrationEvent>(_kafkaConfiguration.OrderRollbackProducts);
     rider.AddProducer <StockUpdateIntegrationEvent>(_kafkaConfiguration.ManagerStockUpdate);
 }
Exemplo n.º 2
0
        public static void UsingKafka(this IRiderRegistrationConfigurator configurator, Action <IRiderRegistrationContext, IKafkaFactoryConfigurator> configure)
        {
            if (configurator == null)
            {
                throw new ArgumentNullException(nameof(configurator));
            }

            var factory = new KafkaRegistrationRiderFactory(configure);

            configurator.SetRiderFactory(factory);
        }
        public static void UsingEventHub(this IRiderRegistrationConfigurator configurator,
                                         Action <IRiderRegistrationContext, IEventHubFactoryConfigurator> configure)
        {
            if (configurator == null)
            {
                throw new ArgumentNullException(nameof(configurator));
            }

            var factory = new EventHubRegistrationRiderFactory(configure);

            configurator.SetRiderFactory(factory);

            configurator.Registrar.Register(GetCurrentProducerProvider);
        }
Exemplo n.º 4
0
        public static void KafkaRegistrationConfigurator(this IRiderRegistrationConfigurator x)
        {
            x.AddConsumer <KafkaMessageConsumer>();
            x.UsingKafka((context, kafkaConfigurator) => {
                var kafkaOptions = context.GetRequiredService <IOptions <KafkaOptions> >().Value;
                kafkaConfigurator.SecurityProtocol = SecurityProtocol.SaslPlaintext;
                kafkaConfigurator.Host(kafkaOptions.Host, hostConfigurator =>
                                       hostConfigurator.UseSasl(saslConfigurator => {
                    saslConfigurator.Mechanism = SaslMechanism.ScramSha512;
                    saslConfigurator.Username  = kafkaOptions.UserName;
                    saslConfigurator.Password  = kafkaOptions.Password;
                }));

                var groupId = ComposeGroupId(context);

                kafkaConfigurator.TopicEndpoint <string, KafkaMessage>(kafkaOptions.Topic, groupId,
                                                                       e => {
                    e.AutoOffsetReset = AutoOffsetReset.Earliest;
                    e.SetValueDeserializer(new KafkaMessageDeserializer());
                    e.ConfigureConsumer <KafkaMessageConsumer>(context);
                });
            });
        }
        /// <summary>
        /// Add a provider to the container for the specified message type, using a key type of Null
        /// The producer must be configured in the UsingKafka configuration method.
        /// </summary>
        /// <param name="configurator"></param>
        /// <param name="topicName">The topic name</param>
        /// <param name="producerConfig"></param>
        /// <typeparam name="T">The message type</typeparam>
        /// <typeparam name="TKey">The key type</typeparam>
        public static IKafkaProducerRegistrationConfigurator <TKey, T> AddProducer <TKey, T>(this IRiderRegistrationConfigurator configurator, string topicName,
                                                                                             ProducerConfig producerConfig)
            where T : class
        {
            if (string.IsNullOrWhiteSpace(topicName))
            {
                throw new ArgumentException(nameof(topicName));
            }
            if (producerConfig == null)
            {
                throw new ArgumentNullException(nameof(producerConfig));
            }

            var registration = new KafkaProducerRegistrationConfigurator <TKey, T>(topicName, producerConfig);

            configurator.Registrar.Register(provider => GetProducer <TKey, T>(topicName, provider));
            configurator.AddRegistration(registration);
            return(registration);
        }
 /// <summary>
 /// Add a provider to the container for the specified message type, using a key type of Null
 /// The producer must be configured in the UsingKafka configuration method.
 /// </summary>
 /// <param name="configurator"></param>
 /// <param name="topicName">The topic name</param>
 /// <param name="producerConfig"></param>
 /// <typeparam name="T">The message type</typeparam>
 public static IKafkaProducerRegistrationConfigurator <Ignore, T> AddProducer <T>(this IRiderRegistrationConfigurator configurator, string topicName,
                                                                                  ProducerConfig producerConfig)
     where T : class
 {
     return(configurator.AddProducer <Ignore, T>(topicName, producerConfig, _ => default));
 }
        /// <summary>
        /// Add a provider to the container for the specified message type, using a key type of Null
        /// The producer must be configured in the UsingKafka configuration method.
        /// </summary>
        /// <param name="configurator"></param>
        /// <param name="topicName">The topic name</param>
        /// <param name="producerConfig"></param>
        /// <param name="keyResolver">Key resolver</param>
        /// <typeparam name="T">The message type</typeparam>
        /// <typeparam name="TKey">The key type</typeparam>
        public static IKafkaProducerRegistrationConfigurator <TKey, T> AddProducer <TKey, T>(this IRiderRegistrationConfigurator configurator, string topicName,
                                                                                             ProducerConfig producerConfig, KafkaKeyResolver <TKey, T> keyResolver)
            where T : class
        {
            IKafkaProducerRegistrationConfigurator <TKey, T> registration = configurator.AddProducer <TKey, T>(topicName, producerConfig);

            configurator.Registrar.Register <ITopicProducer <T> >(provider =>
                                                                  new KeyedTopicProducer <TKey, T>(provider.GetRequiredService <ITopicProducer <TKey, T> >(), keyResolver));

            return(registration);
        }
 /// <summary>
 /// Add a provider to the container for the specified message type, using a key type of Null
 /// The producer must be configured in the UsingKafka configuration method.
 /// </summary>
 /// <param name="configurator"></param>
 /// <param name="topicName">The topic name</param>
 /// <param name="configure"></param>
 /// <typeparam name="T">The message type</typeparam>
 public static void AddProducer <T>(this IRiderRegistrationConfigurator configurator, string topicName,
                                    Action <IRiderRegistrationContext, IKafkaProducerConfigurator <Null, T> > configure = null)
     where T : class
 {
     configurator.AddProducer(topicName, _ => default, configure);
Exemplo n.º 9
0
 static void AddProducers(this IRiderRegistrationConfigurator rider)
 {
     rider.AddProducer <ProductCreatedIntegrationEvent>(_kafkaConfiguration.ManagerToProductsCreate);
     rider.AddProducer <ProductUpdatedIntegrationEvent>(_kafkaConfiguration.ManagerToProductsUpdate);
     rider.AddProducer <ProductDeletedIntegrationEvent>(_kafkaConfiguration.ManagerToProductsDelete);
 }
 private static void AddProducers(this IRiderRegistrationConfigurator rider)
 {
     rider.AddProducer <StockConfirmationIntegrationEvent>(_kafkaConfiguration.ProductsStockResponseSuccess);
     rider.AddProducer <StockConfirmationFailIntegrationEvent>(_kafkaConfiguration.ProductsStockResponseFail);
     rider.AddProducer <ProductRollbackIntegrationEvent>(_kafkaConfiguration.ManagerRollbackProducts);
 }