public async static Task Main()
{
var user = "******";
var pwd = "raspberry";
var vhost = "/";
var hostname = "192.168.88.19";
var consumer = new RabbitMqConsumer(user, pwd, vhost, hostname);
consumer.RegisterCommandConsumer("wpay_command_consumer", new ConsumeExecuter("command"));
var exchanges = new string[]
{
"wpay_exchange_1",
"wpay_exchange_2"
};
consumer.RegisterEventConsumer("wpay_command_consumer", exchanges, new ConsumeExecuter("event"));
/*
* await consumer
* .GetExchangePublisher()
* .Command("wpay_command_consumer", Encoding.UTF8.GetBytes("test"));
*
* await consumer
* .GetExchangePublisher()
* .Command("wpay_command_consumer", Encoding.UTF8.GetBytes("message 2"));
*/
await Task.Delay(300000);
}
public void PublisherPerformance()
{
var exchange = new Exchange("eventflow");
var routingKey = new RoutingKey("performance");
var exceptions = new ConcurrentBag <Exception>();
const int threadCount = 100;
const int messagesPrThread = 200;
using (var consumer = new RabbitMqConsumer(_uri, "eventflow", new[] { "#" }))
using (var resolver = BuildResolver(o => o.RegisterServices(sr => sr.Register <ILog, NullLog>())))
{
var rabbitMqPublisher = resolver.Resolve <IRabbitMqPublisher>();
var threads = Enumerable.Range(0, threadCount)
.Select(_ =>
{
var thread = new Thread(o => SendMessages(rabbitMqPublisher, messagesPrThread, exchange, routingKey, exceptions));
thread.Start();
return(thread);
})
.ToList();
foreach (var thread in threads)
{
thread.Join();
}
var rabbitMqMessages = consumer.GetMessages(threadCount * messagesPrThread);
rabbitMqMessages.Should().HaveCount(threadCount * messagesPrThread);
exceptions.Should().BeEmpty();
}
}
public Worker1(ILogger <Worker1> logger, RabbitMqConsumer consumer)
{
_logger = logger;
_consumer = consumer;
_queueName = Environment.GetCommandLineArgs()[1];
_methodName = Environment.GetCommandLineArgs()[2];
}
public Worker(ILogger <Worker> logger, RabbitMqConsumer rabbitMqConsumer, IMediator mediator, IOptions <BankAPIConfig> signalRConfig, ProcessPaymentAppService processPaymentAppService)
{
_logger = logger;
_rabbitMqConsumer = rabbitMqConsumer;
_mediator = mediator;
_signalRConfig = signalRConfig.Value;
_processPaymentAppService = processPaymentAppService;
}
protected SubscriberBase(DipsConfiguration configuration, ILogger logger, RabbitMqConsumer consumer, RabbitMqExchange invalidExchange, string invalidRoutingKey, string recoverableRoutingKey)
{
Log = logger;
Configuration = configuration;
Consumer = consumer;
InvalidExchange = invalidExchange;
InvalidRoutingKey = invalidRoutingKey;
RecoverableRoutingKey = recoverableRoutingKey;
}
protected override Task ExecuteAsync(CancellationToken stoppingToken)
{
var consumer = new RabbitMqConsumer(_config, OnMessage);
// Dispose the consumer when service is stopped
stoppingToken.Register(() => consumer.Dispose());
return(Task.CompletedTask);
}
public ConsumerCompoment()
{
RabbitMqFactory.Start();
var consumer = new RabbitMqConsumer(
ConfigHelper.SubQueueNames,
new PubSubDispatcher <RabbitMqEventStream>(AutoFacConfig.Container),
ConfigHelper.QueueId);
consumer.Register();
}
public MainWindow()
{
InitializeComponent();
_consumer = new RabbitMqConsumer();
_consumer.OnEvent += (sender, args) =>
Dispatcher.Invoke(() =>
{
AppendText(((ConsumerArgs)args).Message);
});
_consumer.Subscribe();
}
public CorrectCodelineRequestSubscriber(DipsConfiguration configuration, ILogger logger,
RabbitMqConsumer consumer, RabbitMqExchange invalidExchange, string invalidRoutingKey,
string recoverableRoutingKey)
: base(configuration, logger, consumer, invalidExchange, invalidRoutingKey, recoverableRoutingKey)
{
var helper = new BatchCodelineRequestMapHelper(new DateTimeProvider(), Configuration);
QueueMapper = new CorrectBatchCodelineRequestToDipsQueueMapper(helper);
VoucherMapper = new CorrectBatchCodelineRequestToDipsNabChqScanPodMapper(helper);
DbIndexMapper = new CorrectBatchCodelineRequestToDipsDbIndexMapper(helper);
}
public async Task Execute()
{
var consumer = new RabbitMqConsumer(_rabbitUsername, _rabbitPassword, "/pay_queue", _rabbitHost);
var factory =
new ImplFactoryDelegate <RequestServiceDefinition, RequestServiceImpl>(() => new RequestServiceImpl());
var serv = new ServiceWrapper <RequestServiceDefinition, RequestServiceImpl>(consumer, factory);
serv.Execute();
await serv.CallAsync(async (reqServ, publisher) =>
await reqServ.Create(publisher)
);
await consumer.WaitPoolFinished();
}
public async Task Execute()
{
var consumer = new RabbitMqConsumer(_rabbitUsername, _rabbitPassword, "/pay_queue", _rabbitHost);
var factory =
new ImplFactoryDelegate <ResponseServiceDefinition, ResponseServiceImpl>(() => new ResponseServiceImpl());
var serv = new ServiceWrapper <ResponseServiceDefinition, ResponseServiceImpl>(consumer, factory,
(conf) =>
{
conf.UseErrorEventHandling(() => new ErrorHandler());
conf.UseErrorCommandHandling(() => new ErrorHandler());
});
serv.Execute();
await consumer.WaitPoolFinished();
}
private void InitializeQueueConnection()
{
var invalidExchange = Configuration.InvalidExchangeName;
var hostNames = Configuration.HostName;
var userName = Configuration.UserName;
var password = Configuration.Password;
var timeout = Configuration.Timeout;
var heartbeat = Configuration.HeartbeatSeconds;
InvalidRoutingKey = Configuration.InvalidRoutingKey;
RecoverableRoutingKey = Configuration.RecoverableRoutingKey;
PollingIntervalSecs = Configuration.PollingIntervalSecs;
Consumer = new RabbitMqConsumer(ConsumerName, hostNames, userName, password, timeout, heartbeat);
Exchange = new RabbitMqExchange(ExchangeName, hostNames, userName, password, timeout, heartbeat);
InvalidExchange = new RabbitMqExchange(invalidExchange, hostNames, userName, password, timeout, heartbeat);
}
public RabbitMqConsumerTest()
{
const MockBehavior mockBehavior = MockBehavior.Strict;
SetupChannelMock(mockBehavior);
SetupMessageMock(mockBehavior);
SetupBuilderMock(mockBehavior);
SetupManagerMock(mockBehavior);
SetupProcessorMock(mockBehavior);
SetupPublisherMock(mockBehavior);
SetupMessageProcessorMock(mockBehavior);
_consumer = new RabbitMqConsumer(_channelMock.Object, _publisherMock.Object, _builderMock.Object, _managerMock.Object, _messageProcessorMock.Object);
SetupBasicPropertiesMock(mockBehavior);
var userData = Encoding.UTF8.GetBytes(UserJson);
_basicDeliverEventArgs = new BasicDeliverEventArgs(ConsumerTag, 1, false, string.Empty, QueueName, _basicPropertiesMock.Object, userData);
}
private void InitializeQueueConnection()
{
log.Debug("CarService: InitializeQueueConnection");
var hostName = ConfigurationManager.AppSettings["queue:HostName"];
var userName = ConfigurationManager.AppSettings["queue:UserName"];
var password = ConfigurationManager.AppSettings["queue:Password"];
var queueTimeout = int.Parse(ConfigurationManager.AppSettings["queue:Timeout"]);
var heartbeatSeconds = int.Parse(ConfigurationManager.AppSettings["queue:HeartbeatSeconds"]);
var inboundQueueName = ConfigurationManager.AppSettings["adapter:InboundQueueName"];
var outboundExchangeName = ConfigurationManager.AppSettings["adapter:OutboundExchangeName"];
var invalidQueueName = ConfigurationManager.AppSettings["adapter:InvalidQueueName"];
var automaticRecoveryEnabled = bool.Parse(ConfigurationManager.AppSettings["queue:AutomaticRecoveryEnabled"]);
consumer = new RabbitMqConsumer(inboundQueueName, hostName, userName, password, queueTimeout, heartbeatSeconds, automaticRecoveryEnabled);
exchange = new RabbitMqExchange(outboundExchangeName, hostName, userName, password, queueTimeout, heartbeatSeconds, automaticRecoveryEnabled);
invalidExchange = new RabbitMqExchange(invalidQueueName, hostName, userName, password, queueTimeout, heartbeatSeconds, automaticRecoveryEnabled);
consumer.ConnectionLost += Connection_ConnectionShutdown;
consumer.ConsumerFailed += Consumer_ConsumerFailed;
ProcessingService.Consumer = consumer;
ProcessingService.Exchange = exchange;
ProcessingService.InvalidExchange = invalidExchange;
}
public void Scenario()
{
using (var consumer = new RabbitMqConsumer(_uri, "eventflow", new[] { "#" }))
using (var resolver = BuildResolver())
{
var commandBus = resolver.Resolve<ICommandBus>();
var eventJsonSerializer = resolver.Resolve<IEventJsonSerializer>();
var pingId = PingId.New;
commandBus.Publish(new PingCommand(TestId.New, pingId), CancellationToken.None);
var rabbitMqMessage = consumer.GetMessages().Single();
rabbitMqMessage.Exchange.Value.Should().Be("eventflow");
rabbitMqMessage.RoutingKey.Value.Should().Be("eventflow.domainevent.test.ping-event.1");
var pingEvent = (IDomainEvent<TestAggregate, TestId, PingEvent>)eventJsonSerializer.Deserialize(
rabbitMqMessage.Message,
new Metadata(rabbitMqMessage.Headers));
pingEvent.AggregateEvent.PingId.Should().Be(pingId);
}
}
public void Scenario()
{
using (var consumer = new RabbitMqConsumer(_uri, "eventflow", new[] { "#" }))
using (var resolver = BuildResolver())
{
var commandBus = resolver.Resolve <ICommandBus>();
var eventJsonSerializer = resolver.Resolve <IEventJsonSerializer>();
var pingId = PingId.New;
commandBus.Publish(new ThingyPingCommand(ThingyId.New, pingId), CancellationToken.None);
var rabbitMqMessage = consumer.GetMessages().Single();
rabbitMqMessage.Exchange.Value.Should().Be("eventflow");
rabbitMqMessage.RoutingKey.Value.Should().Be("eventflow.domainevent.thingy.thingy-ping.1");
var pingEvent = (IDomainEvent <ThingyAggregate, ThingyId, ThingyPingEvent>)eventJsonSerializer.Deserialize(
rabbitMqMessage.Message,
new Metadata(rabbitMqMessage.Headers));
pingEvent.AggregateEvent.PingId.Should().Be(pingId);
}
}
public async Task PublisherPerformance()
{
var exchange = new Exchange($"eventflow-{Guid.NewGuid():N}");
var routingKey = new RoutingKey("performance");
var exceptions = new ConcurrentBag <Exception>();
const int taskCount = 10;
const int messagesPrThread = 200;
const int totalMessageCount = taskCount * messagesPrThread;
using (var consumer = new RabbitMqConsumer(_uri, exchange, new[] { "#" }))
using (var resolver = BuildResolver(exchange, o => o.RegisterServices(sr => sr.Register <ILog, NullLog>())))
{
var rabbitMqPublisher = resolver.Resolve <IRabbitMqPublisher>();
var tasks = Enumerable.Range(0, taskCount)
.Select(i => Task.Run(() => SendMessagesAsync(rabbitMqPublisher, messagesPrThread, exchange, routingKey, exceptions)));
await Task.WhenAll(tasks).ConfigureAwait(false);
var rabbitMqMessages = consumer.GetMessages(TimeSpan.FromMinutes(1), totalMessageCount);
rabbitMqMessages.Should().HaveCount(totalMessageCount);
exceptions.Should().BeEmpty();
}
}
public async Task Scenario()
{
var exchange = new Exchange($"eventflow-{Guid.NewGuid():N}");
using (var consumer = new RabbitMqConsumer(_uri, exchange, new[] { "#" }))
using (var resolver = BuildResolver(exchange))
{
var commandBus = resolver.Resolve <ICommandBus>();
var eventJsonSerializer = resolver.Resolve <IEventJsonSerializer>();
var pingId = PingId.New;
await commandBus.PublishAsync(new ThingyPingCommand(ThingyId.New, pingId), CancellationToken.None).ConfigureAwait(false);
var rabbitMqMessage = consumer.GetMessages(TimeSpan.FromMinutes(1)).Single();
rabbitMqMessage.Exchange.Value.Should().Be(exchange.Value);
rabbitMqMessage.RoutingKey.Value.Should().Be("eventflow.domainevent.thingy.thingy-ping.1");
var pingEvent = (IDomainEvent <ThingyAggregate, ThingyId, ThingyPingEvent>)eventJsonSerializer.Deserialize(
rabbitMqMessage.Message,
new Metadata(rabbitMqMessage.Headers));
pingEvent.AggregateEvent.PingId.Should().Be(pingId);
}
}
public GetVouchersInformationResponseSubscriber(DipsConfiguration configuration, ILogger logger, RabbitMqConsumer consumer, RabbitMqExchange invalidExchange, string invalidRoutingKey, string recoverableRoutingKey)
: base(configuration, logger, consumer, invalidExchange, invalidRoutingKey, recoverableRoutingKey)
{
}
public void When_Create_Consumer_Should_Set_Empty_ConsumerTag()
{
var consumer = new RabbitMqConsumer(_channelMock.Object, _publisherMock.Object, _builderMock.Object, _managerMock.Object, _messageProcessorMock.Object);
consumer.ConsumerTag.Should().BeEmpty();
}
public void PublisherPerformance()
{
var exchange = new Exchange("eventflow");
var routingKey = new RoutingKey("performance");
var exceptions = new ConcurrentBag<Exception>();
const int threadCount = 100;
const int messagesPrThread = 200;
using (var consumer = new RabbitMqConsumer(_uri, "eventflow", new[] {"#"}))
using (var resolver = BuildResolver(o => o.RegisterServices(sr => sr.Register<ILog, NullLog>())))
{
var rabbitMqPublisher = resolver.Resolve<IRabbitMqPublisher>();
var threads = Enumerable.Range(0, threadCount)
.Select(_ =>
{
var thread = new Thread(o => SendMessages(rabbitMqPublisher, messagesPrThread, exchange, routingKey, exceptions));
thread.Start();
return thread;
})
.ToList();
foreach (var thread in threads)
{
thread.Join();
}
var rabbitMqMessages = consumer.GetMessages(threadCount * messagesPrThread);
rabbitMqMessages.Should().HaveCount(threadCount*messagesPrThread);
exceptions.Should().BeEmpty();
}
}
public PaymentBackgroundService(RabbitMqConsumer rabbitMqConsumer, IHubContext <PaymentResponseHub> hubContext)
{
_rabbitMqConsumer = rabbitMqConsumer;
_hubContext = hubContext;
}
void AddConsumerBinding()
{
if (_consumer != null)
return;
_consumer = new RabbitMqConsumer(_address, _purgeExistingMessages);
_connectionHandler.AddBinding(_consumer);
}
private static void Consume(Func <BasicDeliverEventArgs, Task> onMessage)
{
var consumer = new RabbitMqConsumer(_consumerConfig, onMessage);
}
