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