Пример #1
0
        public async Task PlainSource_should_resume_on_deserialization_errors()
        {
            Directive Decider(Exception cause) => cause is SerializationException
                ? Directive.Resume
                : Directive.Stop;

            int elementsCount = 10;
            var topic1        = CreateTopic(1);
            var group1        = CreateGroup(1);

            await Produce(topic1, Enumerable.Range(1, elementsCount), ProducerSettings);

            var settings = ConsumerSettings <Null, int> .Create(Sys, null, new IntDeserializer())
                           .WithBootstrapServers(KafkaUrl)
                           .WithProperty("auto.offset.reset", "earliest")
                           .WithGroupId(group1);

            var probe = KafkaConsumer
                        .PlainSource(settings, Subscriptions.Assignment(new TopicPartition(topic1, 0)))
                        .WithAttributes(ActorAttributes.CreateSupervisionStrategy(Decider))
                        .Select(c => c.Value)
                        .RunWith(this.SinkProbe <int>(), _materializer);

            probe.Request(elementsCount);
            probe.ExpectNoMsg(TimeSpan.FromSeconds(10));
            probe.Cancel();
        }
Пример #2
0
        public void WhenMessageFails_OnMessageFault_IsCalled()
        {
            // arrange
            var onMessageFaultMock = new Mock <Action <ConsumerSettings, object, Exception> >();
            var consumerSettings   = new ConsumerSettings
            {
                Instances      = 1,
                Topic          = "topic1",
                ConsumerMode   = ConsumerMode.Subscriber,
                ConsumerType   = typeof(IConsumer <SomeMessage>),
                MessageType    = typeof(SomeMessage),
                OnMessageFault = onMessageFaultMock.Object
            };

            var p = new ConsumerInstancePool <SomeMessage>(consumerSettings, _busMock.Object, x => new byte[0]);

            var message = new SomeMessage();

            _serializerMock.Setup(x => x.Deserialize(typeof(SomeMessage), It.IsAny <byte[]>())).Returns(message);

            var ex = new Exception("Something went bad");

            _consumerMock.Setup(x => x.OnHandle(message, consumerSettings.Topic)).Returns(Task.FromException <SomeResponse>(ex));

            // act
            p.Submit(message);
            var commitedMsg = p.Commit(message);

            // assert
            commitedMsg.Should().BeSameAs(message);                                             // it should commit the failed message
            _consumerMock.Verify(x => x.OnHandle(message, consumerSettings.Topic), Times.Once); // handler called once

            onMessageFaultMock.Verify(x => x(consumerSettings, message, ex), Times.Once);       // callback called once
        }
Пример #3
0
        public static void Main(string[] args)
        {
            Config fallbackConfig = ConfigurationFactory.ParseString(@"
                    akka.suppress-json-serializer-warning=true
                    akka.loglevel = DEBUG
                ").WithFallback(ConfigurationFactory.FromResource <ConsumerSettings <object, object> >("Akka.Streams.Kafka.reference.conf"));

            var system       = ActorSystem.Create("TestKafka", fallbackConfig);
            var materializer = system.Materializer();

            var consumerSettings = ConsumerSettings <Null, string> .Create(system, null, null)
                                   .WithBootstrapServers("localhost:29092")
                                   .WithGroupId("group1");

            var subscription = Subscriptions.Topics("akka100");

            KafkaConsumer.PlainSource(consumerSettings, subscription)
            .RunForeach(result =>
            {
                Console.WriteLine($"Consumer: {result.Topic}/{result.Partition} {result.Offset}: {result.Value}");
            }, materializer);


            Console.ReadLine();
        }
Пример #4
0
        protected async Task ProcessMessagesAsync(Message message, CancellationToken token)
        {
            // Process the message.
            var mf = ConsumerSettings.FormatIf(message, _log.IsDebugEnabled);

            _log.DebugFormat(CultureInfo.InvariantCulture, "Received message - {0}", mf);

            await MessageProcessor.ProcessMessage(message).ConfigureAwait(false);

            if (token.IsCancellationRequested)
            {
                // Note: Use the cancellationToken passed as necessary to determine if the subscriptionClient has already been closed.
                // If subscriptionClient has already been closed, you can choose to not call CompleteAsync() or AbandonAsync() etc.
                // to avoid unnecessary exceptions.
                _log.DebugFormat(CultureInfo.InvariantCulture, "Abandon message - {0}", mf);
                await Client.AbandonAsync(message.SystemProperties.LockToken).ConfigureAwait(false);
            }
            else
            {
                // Complete the message so that it is not received again.
                // This can be done only if the subscriptionClient is created in ReceiveMode.PeekLock mode (which is the default).
                _log.DebugFormat(CultureInfo.InvariantCulture, "Complete message - {0}", mf);
                await Client.CompleteAsync(message.SystemProperties.LockToken).ConfigureAwait(false);
            }
        }
Пример #5
0
        public async Task PlainSource_should_resume_stage_if_broker_unavailable()
        {
            var topic1          = CreateTopic(1);
            var group1          = CreateGroup(1);
            var topicPartition1 = new TopicPartition(topic1, 0);

            await GivenInitializedTopic(topicPartition1);

            var config = ConsumerSettings <Null, string> .Create(Sys, null, null)
                         .WithBootstrapServers("localhost:10092")
                         .WithGroupId(group1);

            var regex    = new Regex("\\[localhost:10092\\/bootstrap: Connect to [a-zA-Z0-9#:.*]* failed:");
            var logProbe = CreateTestProbe();

            Sys.EventStream.Subscribe <Info>(logProbe.Ref);

            var(control, probe) = CreateProbe(config, Subscriptions.Assignment(topicPartition1));
            probe.Request(1);

            AwaitAssert(() =>
            {
                var info = logProbe.ExpectMsg <Info>();
                regex.IsMatch(info.Message.ToString() ?? "").Should().BeTrue();
                info.Message.ToString().Should().Contain("[Resume]");
            });
            //AwaitCondition(() => control.IsShutdown.IsCompleted, TimeSpan.FromSeconds(10));
        }
        public KafkaConsumerProcessorTest()
        {
            _topicPartition = new TopicPartition("topic-a", 0);

            var consumerSettings = new ConsumerSettings
            {
                MessageType  = typeof(SomeMessage),
                Topic        = _topicPartition.Topic,
                ConsumerType = typeof(SomeMessageConsumer),
                ConsumerMode = ConsumerMode.Consumer
            };

            consumerSettings.SetGroup("group-a");

            var massageBusMock = new MessageBusMock();

            massageBusMock.BusSettings.Consumers.Add(consumerSettings);
            massageBusMock.DependencyResolverMock.Setup(x => x.Resolve(typeof(SomeMessageConsumer))).Returns(_consumer);

            byte[] MessageValueProvider(Message m) => m.Value;

            var consumerInstancePoolMock = new Mock <ConsumerInstancePoolMessageProcessor <Message> >(consumerSettings, massageBusMock.Bus, (Func <Message, byte[]>)MessageValueProvider, null);

            _messageQueueWorkerMock = new Mock <MessageQueueWorker <Message> >(consumerInstancePoolMock.Object, _checkpointTrigger.Object);
            _subject = new KafkaConsumerProcessor(consumerSettings, _topicPartition, _commitControllerMock.Object, massageBusMock.Bus, _messageQueueWorkerMock.Object);
        }
Пример #7
0
        private void ApplySettings(ConsumerSettings <K, V> updatedSettings)
        {
            _settings         = updatedSettings;
            _pollTimeout      = _settings.PollTimeout;
            _positionTimeout  = _settings.PositionTimeout;
            _commitRefreshing = CommitRefreshing.Create <K, V>(_settings.CommitRefreshInterval);
            try
            {
                if (_log.IsDebugEnabled)
                {
                    _log.Debug($"Creating Kafka consumer with settings: {JsonConvert.SerializeObject(_settings)}");
                }

                var localSelf = Self;
                _consumer = _settings.CreateKafkaConsumer(
                    consumeErrorHandler: (c, e) => localSelf.Tell(new Status.Failure(new KafkaException(e))),
                    partitionAssignedHandler: (c, tp) => localSelf.Tell(new PartitionAssigned(tp.ToImmutableHashSet())),
                    partitionRevokedHandler: (c, tp) => localSelf.Tell(new PartitionRevoked(tp.ToImmutableHashSet())),
                    statisticHandler: (c, json) => _statisticsHandler.OnStatistics(c, json));

                if (_settings.ConnectionCheckerSettings.Enabled)
                {
                    _connectionCheckerActor = Context.ActorOf(ConnectionChecker.Props(_settings.ConnectionCheckerSettings));
                }
            }
            catch (Exception e)
            {
                ProcessError(e);
                throw;
            }
        }
Пример #8
0
        static void Consumer()
        {
            string topic            = "insidetech-5";
            int    countMessage     = 0;
            var    consumerSettings = new ConsumerSettings(
                "127.0.0.1:9092");

            var consumer = new Consumer(consumerSettings);

            Task.Run(() =>
            {
                consumer.Subscriber <Model.User>(topic,
                                                 (receive) =>
                {
                    if (receive != null)
                    {
                        Console.WriteLine($"Message: {++countMessage}, Date: {receive.CreatedAt}, Email: {receive.Email}, Name: {receive.Name}, Key: {receive.Key}");
                    }

                    return(true);
                },
                                                 (error) =>
                {
                    Console.WriteLine(((Exception)error).Message);
                });
            });
        }
Пример #9
0
 private ConsumerSettings <Null, string> CreateConsumerSettings(string group)
 {
     return(ConsumerSettings <Null, string> .Create(Sys, null, new StringDeserializer(Encoding.UTF8))
            .WithBootstrapServers(KafkaUrl)
            .WithProperty("auto.offset.reset", "earliest")
            .WithGroupId(group));
 }
Пример #10
0
        public ConsumerRuntimeInfo(ConsumerSettings consumerSettings)
        {
            ConsumerSettings = consumerSettings;

            if (consumerSettings.ConsumerType == null)
            {
                throw new ConfigurationMessageBusException($"{nameof(consumerSettings.ConsumerType)} is not set on the {consumerSettings}");
            }
            if (consumerSettings.MessageType == null)
            {
                throw new ConfigurationMessageBusException($"{nameof(consumerSettings.MessageType)} is not set on the {consumerSettings}");
            }
            ConsumerOnHandleMethod = consumerSettings.ConsumerType.GetMethod(nameof(IConsumer <object> .OnHandle), new[] { consumerSettings.MessageType, typeof(string) });

            if (consumerSettings.ConsumerMode == ConsumerMode.RequestResponse)
            {
                if (consumerSettings.ResponseType == null)
                {
                    throw new ConfigurationMessageBusException($"{nameof(consumerSettings.ResponseType)} is not set on the {consumerSettings}");
                }

                var taskType = typeof(Task <>).MakeGenericType(consumerSettings.ResponseType);
                TaskResultProperty = taskType.GetProperty(nameof(Task <object> .Result));
            }
        }
 public PartitionConsumerForConsumers(EventHubMessageBus messageBus, ConsumerSettings consumerSettings)
     : base(messageBus)
 {
     _logger       = messageBus.LoggerFactory.CreateLogger <PartitionConsumerForConsumers>();
     _instancePool = new ConsumerInstancePoolMessageProcessor <EventData>(consumerSettings, messageBus, e => e.Body.Array);
     _queueWorker  = new MessageQueueWorker <EventData>(_instancePool, new CheckpointTrigger(consumerSettings), messageBus.LoggerFactory);
 }
Пример #12
0
        public static void InitializeKafkaConsumer(IHandler handler)
        {
            CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
            ConsumerSettings        settings = null;

            settings = new ConsumerSettings()
            {
                GroupName    = "CustomerServiceAutomation",
                TopicName    = CustomerServiceConfig.CustomerServiceTopic,
                KafkaUri     = KafkaUri,
                AutoCommit   = true,
                BatchRead    = false,
                ReadAsync    = true,
                ReadFromEnd  = false,
                MaxQueueSize = 50000,
                MaxBatchSize = 2000
            };

            if (KafkaDriver.Equals(RPL))
            {
                CommonConsumer = new RPLConsumer();
            }
            else if (KafkaDriver.Equals(MISAKAI))
            {
                CommonConsumer = new MisakaiConsumer();
            }
            else
            {
                CommonConsumer = new JavaConsumer();
            }

            LogResult.Report(Log, "log_ForInfo", "Kafka Consumer Initialized For " + "Topic: " + CustomerServiceConfig.CustomerServiceTopic);
            KafkaConsumer = Task.Factory.StartNew(() => CommonConsumer.StartConsuming(handler, settings, cancellationTokenSource.Token));
        }
Пример #13
0
        public KafkaSourceStageLogic(KafkaSourceStage <K, V> stage, Attributes attributes, TaskCompletionSource <NotUsed> completion) : base(stage.Shape)
        {
            _settings     = stage.Settings;
            _subscription = stage.Subscription;
            _out          = stage.Out;
            _completion   = completion;
            _buffer       = new Queue <ConsumerRecord <K, V> >(stage.Settings.BufferSize);

            var supervisionStrategy = attributes.GetAttribute <ActorAttributes.SupervisionStrategy>(null);

            _decider = supervisionStrategy != null ? supervisionStrategy.Decider : Deciders.ResumingDecider;

            SetHandler(_out, onPull: () =>
            {
                if (_buffer.Count > 0)
                {
                    Push(_out, _buffer.Dequeue());
                }
                else
                {
                    if (_isPaused)
                    {
                        _consumer.Resume(_assignedPartitions);
                        _isPaused = false;
                        Log.Debug("Polling resumed, buffer is empty");
                    }
                    PullQueue();
                }
            });
        }
Пример #14
0
        public void WhenRequestExpired_OnMessageExpired_IsCalled()
        {
            // arrange

            var onMessageExpiredMock = new Mock <Action <ConsumerSettings, object> >();
            var consumerSettings     = new ConsumerSettings
            {
                Instances        = 1,
                Topic            = "topic1",
                ConsumerMode     = ConsumerMode.RequestResponse,
                ConsumerType     = typeof(IRequestHandler <SomeRequest, SomeResponse>),
                MessageType      = typeof(SomeRequest),
                OnMessageExpired = onMessageExpiredMock.Object
            };

            var p = new ConsumerInstancePool <SomeRequest>(consumerSettings, _busMock.Object, x => new byte[0]);

            var            request = new SomeRequest();
            string         requestId;
            string         replyTo;
            DateTimeOffset?expires = _currentTime.AddSeconds(-10);

            _busMock.Setup(x => x.DeserializeRequest(typeof(SomeRequest), It.IsAny <byte[]>(), out requestId, out replyTo, out expires)).Returns(request);

            // act
            p.Submit(request);
            var commitedMsg = p.Commit(request);

            // assert
            commitedMsg.Should().BeSameAs(request);                                                           // it should commit the request message
            _handlerMock.Verify(x => x.OnHandle(It.IsAny <SomeRequest>(), It.IsAny <string>()), Times.Never); // the handler should not be called

            onMessageExpiredMock.Verify(x => x(consumerSettings, request), Times.Once);                       // callback called once
        }
Пример #15
0
        protected virtual void AssertConsumerSettings(ConsumerSettings consumerSettings)
        {
            if (consumerSettings == null)
            {
                throw new ArgumentNullException(nameof(consumerSettings));
            }

            Assert.IsNotNull(consumerSettings.Topic,
                             () => new ConfigurationMessageBusException($"The {nameof(ConsumerSettings)}.{nameof(consumerSettings.Topic)} is not set"));
            Assert.IsNotNull(consumerSettings.MessageType,
                             () => new ConfigurationMessageBusException($"The {nameof(ConsumerSettings)}.{nameof(consumerSettings.MessageType)} is not set"));
            Assert.IsNotNull(consumerSettings.ConsumerType,
                             () => new ConfigurationMessageBusException($"The {nameof(ConsumerSettings)}.{nameof(consumerSettings.ConsumerType)} is not set"));
            Assert.IsNotNull(consumerSettings.ConsumerMethod,
                             () => new ConfigurationMessageBusException($"The {nameof(ConsumerSettings)}.{nameof(consumerSettings.ConsumerMethod)} is not set"));

            if (consumerSettings.ConsumerMode == ConsumerMode.RequestResponse)
            {
                Assert.IsNotNull(consumerSettings.ResponseType,
                                 () => new ConfigurationMessageBusException($"The {nameof(ConsumerSettings)}.{nameof(consumerSettings.ResponseType)} is not set"));

                Assert.IsNotNull(consumerSettings.ConsumerMethodResult,
                                 () => new ConfigurationMessageBusException($"The {nameof(ConsumerSettings)}.{nameof(consumerSettings.ConsumerMethodResult)} is not set"));
            }
        }
Пример #16
0
        protected void Setup()
        {
            testTopic = "akka100";

            subscription = Subscriptions.Topics(testTopic);

            probe = this.CreateTestProbe();

            string configText = File.ReadAllText("akka.test.conf");

            var config = ConfigurationFactory.ParseString(configText);

            var system_producer = ActorSystem.Create("TestKafka", config);

            materializer_producer = system_producer.Materializer();

            var system_consumer = ActorSystem.Create("TestKafka", config);

            materializer_consumer = system_producer.Materializer();

            this.Sys.Settings.Config.WithFallback(config);

            producerSettings = ProducerSettings <Null, string> .Create(system_producer, null, null)
                               .WithBootstrapServers("kafka:9092");

            consumerSettings = ConsumerSettings <Null, string> .Create(system_consumer, null, null)
                               .WithBootstrapServers("kafka:9092")
                               .WithGroupId("group1");
        }
Пример #17
0
        public void WhenMessageFailsThenOnMessageFaultIsCalled()
        {
            // arrange
            var onMessageFaultMock = new Mock <Action <AbstractConsumerSettings, object, Exception> >();
            var consumerSettings   = new ConsumerSettings
            {
                Instances      = 1,
                Topic          = "topic1",
                ConsumerMode   = ConsumerMode.Consumer,
                ConsumerType   = typeof(IConsumer <SomeMessage>),
                MessageType    = typeof(SomeMessage),
                OnMessageFault = onMessageFaultMock.Object
            };

            var p = new ConsumerInstancePool <SomeMessage>(consumerSettings, _busMock.Bus, x => Array.Empty <byte>());

            var message = new SomeMessage();

            _busMock.SerializerMock.Setup(x => x.Deserialize(typeof(SomeMessage), It.IsAny <byte[]>())).Returns(message);

            var ex = new Exception("Something went bad");

            _busMock.ConsumerMock.Setup(x => x.OnHandle(message, consumerSettings.Topic))
            .Returns(Task.FromException <SomeResponse>(ex));

            // act
            p.ProcessMessage(message).Wait();

            // assert
            _busMock.ConsumerMock.Verify(x => x.OnHandle(message, consumerSettings.Topic),
                                         Times.Once);                                     // handler called once

            onMessageFaultMock.Verify(x => x(consumerSettings, message, ex), Times.Once); // callback called once
        }
Пример #18
0
        public void WhenRequestExpiredThenOnMessageExpiredIsCalled()
        {
            // arrange

            var onMessageExpiredMock = new Mock <Action <AbstractConsumerSettings, object> >();
            var consumerSettings     = new ConsumerSettings
            {
                Instances        = 1,
                Topic            = "topic1",
                ConsumerMode     = ConsumerMode.RequestResponse,
                ConsumerType     = typeof(IRequestHandler <SomeRequest, SomeResponse>),
                MessageType      = typeof(SomeRequest),
                OnMessageExpired = onMessageExpiredMock.Object
            };

            var p = new ConsumerInstancePool <SomeRequest>(consumerSettings, _busMock.Bus, x => Array.Empty <byte>());

            var request        = new SomeRequest();
            var requestMessage = new MessageWithHeaders();

            requestMessage.SetHeader(ReqRespMessageHeaders.Expires, _busMock.CurrentTime.AddSeconds(-10));

            _busMock.BusMock.Setup(x => x.DeserializeRequest(typeof(SomeRequest), It.IsAny <byte[]>(), out requestMessage))
            .Returns(request);

            // act
            p.ProcessMessage(request).Wait();

            // assert
            _busMock.HandlerMock.Verify(x => x.OnHandle(It.IsAny <SomeRequest>(), It.IsAny <string>()), Times.Never); // the handler should not be called

            onMessageExpiredMock.Verify(x => x(consumerSettings, request), Times.Once);                               // callback called once
        }
Пример #19
0
        protected async Task ProcessMessagesAsync(Message message, CancellationToken token)
        {
            if (message is null)
            {
                throw new ArgumentNullException(nameof(message));
            }

            // Process the message.
            var mf = ConsumerSettings.FormatIf(message, _logger.IsEnabled(LogLevel.Debug));

            _logger.LogDebug("Received message - {0}", mf);

            if (token.IsCancellationRequested)
            {
                // Note: Use the cancellationToken passed as necessary to determine if the subscriptionClient has already been closed.
                // If subscriptionClient has already been closed, you can choose to not call CompleteAsync() or AbandonAsync() etc.
                // to avoid unnecessary exceptions.
                _logger.LogDebug("Abandon message - {0}", mf);
                await Client.AbandonAsync(message.SystemProperties.LockToken).ConfigureAwait(false);

                return;
            }

            var exception = await MessageProcessor.ProcessMessage(message).ConfigureAwait(false);

            if (exception != null)
            {
                if (mf == null)
                {
                    mf = ConsumerSettings.FormatIf(message, true);
                }
                _logger.LogError(exception, "Abandon message (exception occured while processing) - {0}", mf);

                try
                {
                    // Execute the event hook
                    ConsumerSettings.OnMessageFault?.Invoke(MessageBus, ConsumerSettings, null, exception, message);
                    MessageBus.Settings.OnMessageFault?.Invoke(MessageBus, ConsumerSettings, null, exception, message);
                }
                catch (Exception eh)
                {
                    MessageBusBase.HookFailed(_logger, eh, nameof(IConsumerEvents.OnMessageFault));
                }

                var messageProperties = new Dictionary <string, object>
                {
                    // Set the exception message
                    ["SMB.Exception"] = exception.Message
                };
                await Client.AbandonAsync(message.SystemProperties.LockToken, messageProperties).ConfigureAwait(false);

                return;
            }

            // Complete the message so that it is not received again.
            // This can be done only if the subscriptionClient is created in ReceiveMode.PeekLock mode (which is the default).
            _logger.LogDebug("Complete message - {0}", mf);
            await Client.CompleteAsync(message.SystemProperties.LockToken).ConfigureAwait(false);
        }
Пример #20
0
 private (IControl, TestSubscriber.Probe <string>) CreateProbe(ConsumerSettings <Null, string> consumerSettings, ISubscription sub)
 {
     return(KafkaConsumer
            .PlainSource(consumerSettings, sub)
            .Select(c => c.Value)
            .ToMaterialized(this.SinkProbe <string>(), Keep.Both)
            .Run(Materializer));
 }
Пример #21
0
 public KafkaSourceStage(ConsumerSettings <K, V> settings, ISubscription subscription)
 {
     Settings     = settings;
     Subscription = subscription;
     Shape        = new SourceShape <ConsumerRecord <K, V> >(Out);
     Settings     = settings;
     Subscription = subscription;
 }
Пример #22
0
 /// <summary>
 /// CommittableSourceStage
 /// </summary>
 /// <param name="settings">Consumer settings</param>
 /// <param name="subscription">Subscription to be used</param>
 /// <param name="metadataFromMessage">Function to extract string metadata from consumed message</param>
 public CommittableSourceStage(ConsumerSettings <K, V> settings, ISubscription subscription,
                               Func <ConsumeResult <K, V>, string> metadataFromMessage = null)
     : base("CommittableSource")
 {
     _metadataFromMessage = metadataFromMessage ?? (msg => string.Empty);
     Settings             = settings;
     Subscription         = subscription;
 }
Пример #23
0
 private TestSubscriber.Probe <string> CreateProbe(ConsumerSettings <Null, string> consumerSettings, string topic, ISubscription sub)
 {
     return(KafkaConsumer
            .PlainSource(consumerSettings, sub)
            .Where(c => !c.Value.Equals(InitialMsg))
            .Select(c => c.Value)
            .RunWith(this.SinkProbe <string>(), _materializer));
 }
Пример #24
0
        public KafkaConsumerProcessor(ConsumerSettings consumerSettings, TopicPartition topicPartition, IKafkaCommitController commitController, MessageBusBase messageBus, MessageQueueWorker <Message> messageQueueWorker)
        {
            Log.InfoFormat("Creating for Group: {0}, Topic: {1}, Partition: {2}, MessageType: {3}", consumerSettings.Group, consumerSettings.Topic, topicPartition, consumerSettings.MessageType);

            _consumerSettings   = consumerSettings;
            TopicPartition      = topicPartition;
            _commitController   = commitController;
            _messageQueueWorker = messageQueueWorker;
        }
 public AnaliseVendasRelatorioWorker(
     ILogger <AnaliseVendasRelatorioWorker> logger,
     IProcessaArquivoService gerarRelatorioService,
     IOptions <ConsumerSettings> config)
 {
     this.logger = logger;
     this.processaArquivoService = gerarRelatorioService;
     this.config = config.Value;
 }
 public SingleSourceStageLogic(SourceShape <TMessage> shape, ConsumerSettings <K, V> settings,
                               ISubscription subscription, Attributes attributes,
                               Func <BaseSingleSourceLogic <K, V, TMessage>, IMessageBuilder <K, V, TMessage> > messageBuilderFactory)
     : base(shape, attributes, messageBuilderFactory)
 {
     _shape        = shape;
     _settings     = settings;
     _subscription = subscription;
 }
Пример #27
0
        public static string FormatIf(this ConsumerSettings consumerSettings, bool logLevel)
        {
            if (!logLevel)
            {
                return(string.Empty);
            }

            return($"Topic: {consumerSettings.Topic}, MessageType: {consumerSettings.MessageType}");
        }
        public void Initialize(ConsumerSettings consumerSettings, string topic, int queueCount, bool continueWhenHandleFail, int retryIntervalSeconds, IInterceptor[] interceptors, params Assembly[] assemblies)
        {
            _consumer = new Consumer(consumerSettings);
            _consumer.Subscribe(topic, queueCount);

            _commandHandlerProvider = new CommandHandlerProvider();
            _commandHandlerProvider.Initialize(interceptors, assemblies);
            _commandProcessor = new DefaultMessageProcessor(string.Empty, _commandHandlerProvider, _mailboxProvider, continueWhenHandleFail, retryIntervalSeconds);
        }
Пример #29
0
 public KafkaConsumerProcessor(ConsumerSettings consumerSettings, TopicPartition topicPartition, IKafkaCommitController commitController, MessageBusBase messageBus)
     : this(consumerSettings,
            topicPartition,
            commitController,
            messageBus,
            new MessageQueueWorker <Message>(
                new ConsumerInstancePoolMessageProcessor <Message>(consumerSettings, messageBus, m => m.Value, (m, ctx) => ctx.SetTransportMessage(m)),
                new CheckpointTrigger(consumerSettings)))
 {
 }
Пример #30
0
        public void AfterCreation_DefaultInstances_ShouldBe1()
        {
            // arrange

            // act
            var cs = new ConsumerSettings();

            // assert
            cs.Instances.ShouldBeEquivalentTo(1);
        }
Пример #31
0
        public void Setup()
        {
            queue.Clear();

            consumerSettings = ConsumerSettings.CreateDefault();
        }