static void Main(string[] args) { RabbitMQService.Start(ConfigHelper.RabbitMQURI); var consumer = new RabbitMQConsumer( ConfigHelper.SubQueueNames, new PubSubDispatcher <RabbitMQEventStream>(AutofacConfig.Container), ConfigHelper.QueueId); consumer.Start(); Parallel.ForEach(Enumerable.Range(0, ConfigHelper.ProducerBatchCount), (index) => { RabbitMQProducer.Publish( ConfigHelper.QueueId, new PressureTestContentEvent() { Content = $"{DateTime.Now.ToString("yyyyMMdd HH:mm:ss.fff")}-{index}", CreateDateTime = DateTime.Now }); }); Console.Read(); RabbitMQService.Stop(); }
static void Main(string[] args) { RabbitMQConsumer client = new RabbitMQConsumer(); client.CreateConnection(); client.ProcessMessages(); }
//测试RabbitMQ的消费者 static void RabbitMQTest() { LogLocation.Log = new LogInfo(); RabbitMQClientContext context = new RabbitMQClientContext() { ListenQueueName = "HELLOQUEUES", MqConfigDom = new MqConfigDom() { MqHost = "127.0.0.1", MqUserName = "******", MqPassword = "******", MqVirtualHost = "/" } }; RabbitMQConsumer <MessageEntity> consumer = new RabbitMQConsumer <MessageEntity>(context, new EventMessage <MessageEntity>()) { ActionMessage = b => { Console.WriteLine(JsonConvert.SerializeObject(b.MessageEntity)); b.IsOperationOk = true; } }; consumer.OnListening(); //多个消费者,共用一个连接,使用不同的Channel //consumer.OnListening(); }
private static async Task StartConsumer() { var loggerFactory = LoggerFactory.Create(builder => { builder.AddConsole(); builder.SetMinimumLevel(LogLevel.Debug); }); var builder = new RabbitMQConnectionFactoryBuilder(new DnsEndPoint(Host, 5672)); var factory = builder.AddLogger(loggerFactory.CreateLogger(string.Empty)).Build(); var connection = factory.CreateConnection(); await connection.StartAsync(); var channel = await connection.OpenChannel(); await channel.ExchangeDeclareAsync(ExchangeDeclare.Create("TestExchange", ExchangeType.Direct)); await channel.QueueDeclareAsync(QueueDeclare.Create("TestQueue")); await channel.QueueBindAsync(QueueBind.Create("TestQueue", "TestExchange")); var consumer = new RabbitMQConsumer(channel, ConsumeConf.CreateNoWait("TestQueue", "TestConsumer", true), PipeScheduler.ThreadPool); consumer.Received += /*async*/ (sender, result) => { if (result.Body[0] != 42) { throw new Exception("SHIT"); } //await channel.Ack(AckInfo.Create(result.DeliveryTag)); }; await channel.ConsumerStartAsync(consumer); await Task.Delay(TimeSpan.FromHours(1)); }
public async Task SubscribeAsync <T>(Func <T, Task <bool> > handler, SubscribeOptions subscribeOptions = null, CancellationToken cancellationToken = default(CancellationToken)) where T : class { InitDelayQueue(); var topic = GetTopic(typeof(T)); var groupId = subscribeOptions?.GroupId; var threadCount = subscribeOptions?.ConsumerThreadCount ?? 0; threadCount = threadCount > 0 ? threadCount : _options.DefaultConsumerThreadCount; AssertUtils.IsTrue(threadCount > 0, "消费者线程数必须大于0"); var key = !string.IsNullOrEmpty(groupId) ? $"{topic}_{groupId}" : topic; lock (Subscribers) { AssertUtils.IsTrue(!Subscribers.Contains(key), "该类型重复订阅,如果需要订阅请区分不同的GroupId"); Subscribers.Add(key); } _logger.LogInformation($"订阅[{topic}],threadcount={threadCount}"); for (int i = 0; i < threadCount; i++) { var consumer = new RabbitMQConsumer(this._serviceProvider, this._producer); _consumers.Add(consumer); consumer.OnMessage += async(result) => { var obj = _options.Serializer.Deserialize <T>(result.Data); return(await handler(obj)); }; await consumer.Subscribe(topic, groupId, cancellationToken); } }
private static async Task Main(string[] args) { var builder = new RabbitMQConnectionFactoryBuilder(new DnsEndPoint(Host, 5672)); var factory = builder.Build(); var connection = factory.CreateConnection(); await connection.StartAsync(); var channel = await connection.OpenChannel(); await channel.ExchangeDeclareAsync(ExchangeDeclare.Create("TestExchange", ExchangeType.Direct)); await channel.QueueDeclareAsync(QueueDeclare.Create("TestQueue")); await channel.QueueBindAsync(QueueBind.Create("TestQueue", "TestExchange")); var consumer = new RabbitMQConsumer(channel, ConsumeConf.Create("TestQueue", "TestConsumer", true)); consumer.Received += /*async*/ (sender, result) => { //await channel.Ack(AckInfo.Create(result.DeliveryTag)); }; await channel.ConsumerStartAsync(consumer); await Task.Delay(TimeSpan.FromHours(1)); }
public async ValueTask <RabbitMQConsumer> CreateConsumer(string queueName, string consumerTag, bool noLocal = false, bool noAck = false, bool exclusive = false, Dictionary <string, object> arguments = null) { await _semaphore.WaitAsync().ConfigureAwait(false); _consumerCreateSrc = new TaskCompletionSource <string>(); await SendBasicConsume(queueName, consumerTag, noLocal, noAck, exclusive, arguments).ConfigureAwait(false); var result = await _consumerCreateSrc.Task.ConfigureAwait(false); if (result.Equals(consumerTag)) { var consumer = new RabbitMQConsumer(consumerTag, _protocol, _channelId); if (!_consumers.TryAdd(consumerTag, consumer)) { if (!_consumers.TryGetValue(consumerTag, out ConsumerBase existedConsumer)) { throw new ArgumentException($"{nameof(BasicReaderWriter)}.{nameof(CreateChunkedConsumer)} cant create consumer:{consumerTag}"); } if (existedConsumer is RabbitMQConsumer) { return((RabbitMQConsumer)existedConsumer); } else { throw new ArgumentException($"{nameof(BasicReaderWriter)}.{nameof(CreateChunkedConsumer)} consumer {consumerTag} already exists but with a different type"); } } return(consumer); } else { throw new ArgumentException($"{nameof(BasicReaderWriter)}.{nameof(CreateChunkedConsumer)} : {consumerTag}"); } }
static void Main(string[] args) { if (push) { var publisher = new RabbitMQPublisher(server, port, username, password); publisher.BindAddress(routingKey, exchangeName); for (int i = 0; i < 100; i++) { publisher.pushToQueue(routingKey, new PersonModel() { Id = i, Name = $"Name_{i}", CreatedDate = DateTime.Now.AddMinutes(i) }); } } if (consume) { var consumer = new RabbitMQConsumer(server, port, username, password, exchangeName, queueName, routingKey); consumer.Init((PersonModel item) => { Console.WriteLine($" Id: {item.Id}\t|\tName: {item.Id}\t|\tDate: {item.CreatedDate.ToString()}"); return(true); }); consumer.Consume(); } Console.WriteLine("__________________________________________________________"); Console.ReadKey(); }
private void Execute() { if (ExecuteProperty.Instance.GetStartCommunication) { return; } try { using (RabbitMQConsumer c = new RabbitMQConsumer(this._rabbitmqConfig.Server, this._rabbitmqConfig.User, this._rabbitmqConfig.Pass, this._rabbitmqConfig.Queue, this._rabbitmqConfig.Port)) { try { GetValuesModel wc = GetMessage(c); if (wc == null) { return; } if (!ExecuteProperty.Instance.GetStartCommunication) { ExecuteProperty.Instance.SetStartCommunication(); } else { return; } switch (wc.GetValuesEnum) { case GetValuesEnum.GetReceitas: new ReceitaCommunicationService(); break; default: throw new Exception("O Tipo não está configurado"); } c.AcknowledgeMsg(true); Thread.Sleep(100); } catch (Exception ex) { Singleton.ExecuteProperty.Instance.EventLog.WriteEntry(ex.Message, System.Diagnostics.EventLogEntryType.Error); c.AcknowledgeMsg(false); } } } catch (Exception ex) { Singleton.ExecuteProperty.Instance.EventLog.WriteEntry(ex.Message, System.Diagnostics.EventLogEntryType.Error); } finally { ExecuteProperty.Instance.SetCloseCommunication(); } Thread.Sleep(100); }
public void TestIfWeReceiveTheMessageSent() { RabbitMQProducer rmp = new RabbitMQProducer("165.22.199.153", "admin", "2MmV2KjEhX36DaZeyAqhbifbp86YDxHG7yJq2R7JPJwJiXvN7jXpqhxjUr4ZCkGL"); rmp.Send("test_queue", "testing"); RabbitMQConsumer rmc = new RabbitMQConsumer("165.22.199.153", "admin", "2MmV2KjEhX36DaZeyAqhbifbp86YDxHG7yJq2R7JPJwJiXvN7jXpqhxjUr4ZCkGL"); Assert.AreEqual("testing", rmc.Receive("test_queue")); }
public static IApplicationBuilder UseRabbitMQListener(this IApplicationBuilder app) { Listener = app.ApplicationServices.GetService <RabbitMQConsumer>(); var life = app.ApplicationServices.GetService <IHostApplicationLifetime>(); life.ApplicationStarted.Register(OnStarted); life.ApplicationStopping.Register(OnStopping); return(app); }
public static string rmqconsume(List <string> args) { try { consumer = new RabbitMQConsumer <IncidentData>("localhost", 5672, "test"); consumer.Connect(); consumer.MessageReceived += onReceive; return("Consumer Connected"); } catch (Exception ex) { return(ex.Message); } }
private GetValuesModel GetMessage(RabbitMQConsumer c) { byte[] bodyBytes = c.Pop(); if (bodyBytes == null) { return(null); } using (MemoryStream ms = new MemoryStream(bodyBytes)) { DataContractJsonSerializer deserializer = new DataContractJsonSerializer(typeof(GetValuesModel)); return((GetValuesModel)deserializer.ReadObject(ms)); } }
static void Main(string[] args) { var config = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true) .Build() .GetSection("MQCreateSettings") .Get <MQCreateSettings>(); using (var client = new RabbitMQConsumer(config)) { client.ProcessMessages(); } }
static void Main(string[] args) { RabbitMQService.Start(ConfigHelper.RabbitMQURI); var consumer = new RabbitMQConsumer( ConfigHelper.SubQueueNames, new PubSubDispatcher <RabbitMQEventStream>(AutofacConfig.Container), ConfigHelper.QueueId); consumer.Start(); Console.Read(); RabbitMQService.Stop(); }
private static void LoadMsg() { int doSeconds = 2; ushort prefetchCount = 1; RabbitmqConfigOptions rabbitmqOption = new RabbitmqConfigOptions(); var queueName = "queue_test_workqueues"; RabbitMQConsumer consumer = new RabbitMQConsumer(rabbitmqOption); consumer.Open(); consumer.SetWorkQueuesReceivedAction(delegate(string msg) { Console.WriteLine(DateTime.Now.ToString("HH:mm:ss") + " 1接收到消息:" + msg); //Thread.Sleep(doSeconds * 100 * Program.GetRandomNum(1, 50)); }, queueName, prefetchCount, false, 20); }
public ConsumerSample() { var conn = new ConnectionModel() { AutomaticRecoveryEnabled = true, HostName = "127.0.0.1", NetworkRecoveryInterval = TimeSpan.FromSeconds(15), Password = "******", Port = 5672, UserName = "******", VirtualHost = "/" }; rabbitMQConsumer = new RabbitMQConsumer(conn); }
public async Task <T> Consume(string exchangeName, string queue) { T response; try { RabbitMQConsumer <T> consumer = new RabbitMQConsumer <T>(rabbitmqSettings.Value.HostName, rabbitmqSettings.Value.UserName, rabbitmqSettings.Value.Password); response = consumer.Consume(exchangeName, queue); } catch (Exception) { response = null; } return(response); }
public static async Task RunDefault() { var builder = new RabbitMQConnectionFactoryBuilder(new DnsEndPoint(Host, 5672)); var factory = builder.Build(); var connection = factory.CreateConnection(); await connection.StartAsync(); var channel = await connection.OpenChannel(); await channel.ExchangeDeclareAsync(ExchangeDeclare.Create("TestExchange", ExchangeType.Direct)); await channel.ExchangeDeclareAsync(ExchangeDeclare.CreateNoWait("TestExchange2", ExchangeType.Direct)); var declareOk = await channel.QueueDeclareAsync(QueueDeclare.Create("TestQueue")); await channel.QueueDeclareNoWaitAsync(QueueDeclare.Create("TestQueue2")); var purgeOk = await channel.QueuePurgeAsync(QueuePurge.Create("TestQueue")); await channel.QueuePurgeNoWaitAsync(QueuePurge.Create("TestQueue2")); await channel.QueueBindAsync(QueueBind.Create("TestQueue", "TestExchange")); await channel.QueueBindAsync(QueueBind.CreateNoWait("TestQueue2", "TestExchange2")); var consumer = new RabbitMQConsumer(channel, ConsumeConf.Create("TestQueue", "TestConsumer", true)); consumer.Received += (sender, result) => { //await channel.Ack(deliver.DeliveryTag, false); //Console.WriteLine(Encoding.UTF8.GetString(result.Body)); }; await channel.ConsumerStartAsync(consumer); await channel.Publish("TestExchange", string.Empty, false, false, new ContentHeaderProperties(), new byte[16 * 1024 * 1024 + 1]); //await channel.QueueUnbindAsync(QueueUnbind.Create("TestQueue", "TestExchange")); //await channel.QueueUnbindAsync(QueueUnbind.Create("TestQueue2", "TestExchange2")); //var deleteOk = await channel.QueueDeleteAsync(QueueDelete.Create("TestQueue")); //await channel.QueueDeleteNoWaitAsync(QueueDelete.Create("TestQueue2")); //await channel.ExchangeDeleteAsync(ExchangeDelete.Create("TestExchange")); //await channel.ExchangeDeleteAsync(ExchangeDelete.CreateNoWait("TestExchange2")); await connection.CloseAsync(); await Task.Delay(TimeSpan.FromHours(2)); }
static void Main(string[] args) { Console.WriteLine("Please write your message:"); var message = Console.ReadLine(); _publisher = new RabbitMQPublisher(_queueName); _publisher.Publish(message); _consumer = new RabbitMQConsumer(_queueName); _consumer.Consume((model, ea) => { var body = ea.Body.ToArray(); var message = Encoding.UTF8.GetString(body); Console.WriteLine("{0} - Incoming message from {1}: \"{2}\"", DateTime.Now.ToString("dd.MM.yyyy HH:mm:ss"), _queueName, message); }); Console.ReadLine(); }
public override bool OnStart() { // Set the maximum number of concurrent connections ServicePointManager.DefaultConnectionLimit = 12; // For information on handling configuration changes // see the MSDN topic at https://go.microsoft.com/fwlink/?LinkId=166357. bool result = base.OnStart(); client = new RabbitMQConsumer(CloudConfigurationManager.GetSetting("monitoringBrokerExchangeName"), CloudConfigurationManager.GetSetting("monitoringBrokerQueueName"), new string[] { CloudConfigurationManager.GetSetting("monitoringKeysRouting") }); client.CreateConnection(); Trace.TraceInformation("ExternalConsultingWorker has been started"); return(result); }
private void prepareRabbitMQConnections() { RabbitMqMessages = new Dictionary <Type, List <IRabbitMQOperation> >(); CashInOutSubscription = new RabbitMQConsumer <CashOperation>( new RabbitMQSettings(_configBuilder, "cashinout", Constants.TestQueueName), handleOperationMessages); CashTransferSubscription = new RabbitMQConsumer <CashTransferOperation>( new RabbitMQSettings(_configBuilder, "transfers", Constants.TestQueueName), handleOperationMessages); CashSwapSubscription = new RabbitMQConsumer <CashSwapOperation>( new RabbitMQSettings(_configBuilder, "cashswap", Constants.TestQueueName), handleOperationMessages); BalanceUpdateSubscription = new RabbitMQConsumer <BalanceUpdate>( new RabbitMQSettings(_configBuilder, "balanceupdate", Constants.TestQueueName), handleOperationMessages); LimitOrderSubscription = new RabbitMQConsumer <LimitOrdersResponse>( new RabbitMQSettings(_configBuilder, "limitorders.clients", Constants.TestQueueName), handleOperationMessages); TradesOrderSubscription = new RabbitMQConsumer <MarketOrderWithTrades>( new RabbitMQSettings(_configBuilder, "trades", Constants.TestQueueName), handleOperationMessages); }
internal static async Task ConsumerStartAsync(this RabbitMQSession session, RabbitMQConsumer consumer) { var data = session.GetChannelData(consumer.Channel.ChannelId); if (!consumer.Conf.NoWait) { data.ConsumeTcs = new TaskCompletionSource <string>(TaskCreationOptions.RunContinuationsAsynchronously); } await session.Writer.SendBasicConsumeAsync(consumer.Channel.ChannelId, consumer.Conf).ConfigureAwait(false); if (!consumer.Conf.NoWait) { var tag = await data.ConsumeTcs.Task.ConfigureAwait(false); if (!tag.Equals(consumer.Conf.ConsumerTag)) { RabbitMQExceptionHelper.ThrowIfConsumeOkTagMissmatch(consumer.Conf.ConsumerTag, tag); } consumer.IsClosed = false; } data.Consumers.Add(consumer.Conf.ConsumerTag, consumer); }
public async Task TestMultithreadFloodPublishingNoAck() { var receivedCount = 0; byte[] sendBody = Encoding.UTF8.GetBytes(message); //var builder = new RabbitMQConnectionFactoryBuilder(new IPEndPoint(IPAddress.Loopback, 5672)); var loggerFactory = LoggerFactory.Create(builder => { builder.AddConsole(); }); var builder = new RabbitMQConnectionFactoryBuilder(new DnsEndPoint(Host, 5672)); var factory = builder.AddLogger(loggerFactory.CreateLogger(string.Empty)).Build(); var connection = factory.CreateConnection(); await connection.StartAsync(); var channel = await connection.OpenChannel(); await channel.ExchangeDeclareAsync(_exchangeDeclare); var queueOk = await channel.QueueDeclareAsync(_queueDeclare); await channel.QueueBindAsync(_queueBind); var consumer = new RabbitMQConsumer(channel, _consumerConfNoAck, PipeScheduler.ThreadPool); await channel.ConsumerStartAsync(consumer); var tcs = new TaskCompletionSource <bool>(); consumer.Received += async(sender, result) => { Assert.Equal(message, Encoding.UTF8.GetString(result.Body)); var inc = Interlocked.Increment(ref receivedCount); if (inc == threadCount * publishCount) { tcs.SetResult(true); } }; var cts = new CancellationTokenSource(TimeSpan.FromSeconds(seconds)); using (var timeoutRegistration = cts.Token.Register(() => tcs.SetCanceled())) { var tasks = new List <Task>(); for (int i = 0; i < threadCount; i++) { var task = StartFloodAsync(channel, "TestQueue", sendBody, publishCount); tasks.Add(task); } await Task.WhenAll(tasks); await tcs.Task; } //await consumer1.CancelAsync(); //TODOL fix this Assert.Equal(threadCount * publishCount, receivedCount); await channel.QueueUnbindAsync(_queueUnbind); var deleted = await channel.QueueDeleteAsync(_queueDelete); await channel.ExchangeDeleteAsync(_exchangeDelete); await connection.CloseAsync("Finish TestMultithreadFloodPublishingNoAck"); }
public void Comsumer_WithExpectedParameters() { RabbitMQConsumer consumer = new RabbitMQConsumer(); consumer.Receive(queue.Example01, durable: true); }
public Task ConsumerStartAsync(RabbitMQConsumer consumer) { return(Session.ConsumerStartAsync(consumer)); }
public void Test_Read_With_Incorrect_HostName() { RabbitMQConsumer rmq = new RabbitMQConsumer("165.22.199.15", "admin", "2MmV2KjEhX36DaZeyAqhbifbp86YDxHG7yJq2R7JPJwJiXvN7jXpqhxjUr4ZCkGL"); Assert.ThrowsException <RabbitMQ.Client.Exceptions.BrokerUnreachableException>(() => rmq.Receive("Test_Queue")); }
public static async Task ChannelTest() { var loggerFactory = LoggerFactory.Create(builder => { //builder.AddConsole(); builder.SetMinimumLevel(LogLevel.Information); }); var builder = new RabbitMQConnectionFactoryBuilder(new DnsEndPoint(Host, 5672)); var factory = builder.AddLogger(loggerFactory.CreateLogger(string.Empty)) .ConnectionTimeout(TimeSpan.FromSeconds(30)) .ConnectionAttempts(100000) .Build(); var connection = factory.CreateConnection(); await connection.StartAsync(); var channel1 = await connection.OpenChannel(); var channel2 = await connection.OpenChannel(); await channel1.ExchangeDeclareAsync(ExchangeDeclare.Create("TestExchange", ExchangeType.Direct)); await channel1.ExchangeDeclareAsync(ExchangeDeclare.CreateNoWait("TestExchange2", ExchangeType.Direct)); var declareOk = await channel1.QueueDeclareAsync(QueueDeclare.Create("TestQueue")); await channel1.QueueDeclareNoWaitAsync(QueueDeclare.Create("TestQueue2")); var purgeOk = await channel1.QueuePurgeAsync(QueuePurge.Create("TestQueue")); await channel1.QueuePurgeNoWaitAsync(QueuePurge.Create("TestQueue2")); await channel1.QueueBindAsync(QueueBind.Create("TestQueue", "TestExchange")); await channel1.QueueBindAsync(QueueBind.CreateNoWait("TestQueue2", "TestExchange2")); var body1 = new byte[Size]; var consumer1 = new RabbitMQConsumer(channel1, ConsumeConf.Create("TestQueue", "TestConsumer", true)); consumer1.Received += async(sender, result) => { //await channel1.Ack(deliver.DeliveryTag, true); var propertiesConsume = new ContentHeaderProperties(); propertiesConsume.AppId = "testapp2"; var published = await channel2.Publish("TestExchange2", string.Empty, false, false, propertiesConsume, body1); }; var consumer2 = new RabbitMQConsumer(channel2, ConsumeConf.Create("TestQueue2", "TestConsumer2", true)); consumer2.Received += async(sender, result) => { //await channel2.Ack(deliver.DeliveryTag, true); var propertiesConsume = new ContentHeaderProperties(); propertiesConsume.AppId = "testapp1"; var published = await channel1.Publish("TestExchange", string.Empty, false, false, propertiesConsume, body1); }; await channel1.ConsumerStartAsync(consumer1); await channel2.ConsumerStartAsync(consumer2); var firtsTask = Task.Run(async() => { var properties = new ContentHeaderProperties(); properties.AppId = "testapp1"; while (true /*!channel1.IsClosed*/) { var published = await channel1.Publish("TestExchange", string.Empty, false, false, properties, body1); } }); var secondTask = Task.Run(async() => { var properties = new ContentHeaderProperties(); properties.AppId = "testapp2"; while (true /*!channel2.IsClosed*/) { var published = await channel2.Publish("TestExchange2", string.Empty, false, false, properties, body1); } }); await Task.Delay(TimeSpan.FromHours(1)); }
public Worker(ILogger <Worker> logger, RabbitMQConsumer rabbitMQConsumer) { _logger = logger; _rabbitMQConsumer = rabbitMQConsumer; }